feat(codemode): support property deletion

packages/app/e2e/utils/mock-server.ts

@@ -55,7 +55,7 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
     const path = url.pathname
     if (path === "/global/event" || path === "/event") return sse(route, config.events?.(), config.eventRetry)
     if (path === "/global/health") return json(route, { healthy: true })
-    if (path === "/experimental/capabilities") return json(route, { backgroundSubagents: true })
+    if (path === "/experimental/capabilities") return json(route, { backgroundSubagents: false })
     if (path === "/permission")
       return json(route, typeof config.permissions === "function" ? config.permissions() : (config.permissions ?? []))
     if (path === "/question")

packages/cli/src/mini/footer.ts

@@ -84,6 +84,7 @@ type RunFooterOptions = {
   theme: RunTheme
   keymap: Keymap<Renderable, KeyEvent>
   tuiConfig: RunTuiConfig
+  backgroundSubagents: boolean
   diffStyle: RunDiffStyle
   onPermissionReply: (input: PermissionReply) => void | Promise<void>
   onQuestionReply: (input: QuestionReply) => void | Promise<void>
@@ -325,6 +326,7 @@ export class RunFooter implements FooterApi {
               theme: footer.theme,
               diffStyle: options.diffStyle,
               tuiConfig: options.tuiConfig,
+              backgroundSubagents: options.backgroundSubagents,
               history: footer.history,
               agent: options.agentLabel,
               onSubmit: footer.handlePrompt,

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

@@ -89,6 +89,7 @@ type RunFooterViewProps = {
   theme: () => RunTheme
   diffStyle?: RunDiffStyle
   tuiConfig: RunTuiConfig
+  backgroundSubagents: boolean
   history?: () => RunPrompt[]
   agent: string
   onSubmit: (input: RunPrompt) => boolean
@@ -168,7 +169,9 @@ export function RunFooterView(props: RunFooterViewProps) {
 
     return tabs().findIndex((item) => item.sessionID === sessionID) + 1
   })
-  const foregroundSubagents = createMemo(() => activeTabs().some((item) => !item.background))
+  const foregroundSubagents = createMemo(
+    () => props.backgroundSubagents && activeTabs().some((item) => !item.background),
+  )
   const model = createMemo(() => {
     const current = props.currentModel()
     return current ? modelInfo(props.providers(), current) : { model: props.state().model, provider: undefined }

packages/cli/src/mini/mini.ts

@@ -1,5 +1,6 @@
 import { NodeFileSystem } from "@effect/platform-node"
 import { OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
+import { truthy } from "@opencode-ai/core/flag/flag"
 import { Global } from "@opencode-ai/core/global"
 import { Effect } from "effect"
 import path from "node:path"
@@ -83,6 +84,9 @@ export async function runMini(input: MiniCommandInput) {
       files: [],
       initialInput,
       thinking: true,
+      backgroundSubagents:
+        truthy("OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS") ||
+        (process.env.OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS === undefined && truthy("OPENCODE_EXPERIMENTAL")),
       replay: input.replay ?? true,
       replayLimit: input.replayLimit,
       demo: input.demo,

packages/cli/src/mini/runtime.lifecycle.ts

@@ -64,6 +64,7 @@ export type LifecycleInput = {
   model: RunInput["model"]
   variant: string | undefined
   tuiConfig: RunTuiConfig | Promise<RunTuiConfig>
+  backgroundSubagents: boolean
   onPermissionReply: (input: PermissionReply) => void | Promise<void>
   onQuestionReply: (input: QuestionReply) => void | Promise<void>
   onQuestionReject: (input: QuestionReject) => void | Promise<void>
@@ -235,6 +236,7 @@ export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lif
       wrote,
       keymap,
       tuiConfig,
+      backgroundSubagents: input.backgroundSubagents,
       diffStyle: tuiConfig.diff_style ?? "auto",
       onPermissionReply: input.onPermissionReply,
       onQuestionReply: input.onQuestionReply,

packages/cli/src/mini/runtime.ts

@@ -56,6 +56,7 @@ type RunRuntimeInput = {
   files: RunInput["files"]
   initialInput?: string
   thinking: boolean
+  backgroundSubagents: boolean
   replay?: boolean
   replayLimit?: number
   demo?: RunInput["demo"]
@@ -74,6 +75,7 @@ type RunDeferredInput = {
   files: RunInput["files"]
   initialInput?: string
   thinking: boolean
+  backgroundSubagents: boolean
   replay?: boolean
   replayLimit?: number
   demo?: RunInput["demo"]
@@ -268,6 +270,7 @@ async function runInteractiveRuntime(input: RunRuntimeInput, deps: RunRuntimeDep
     model: state.model,
     variant: state.activeVariant,
     tuiConfig: tuiConfigTask,
+    backgroundSubagents: input.backgroundSubagents,
     onPermissionReply: async (next) => {
       if (state.demo?.permission(next)) {
         return
@@ -873,6 +876,7 @@ export async function runInteractiveDeferredMode(input: RunDeferredInput, deps?:
       files: input.files,
       initialInput: input.initialInput,
       thinking: input.thinking,
+      backgroundSubagents: input.backgroundSubagents,
       replay: input.replay,
       replayLimit: input.replayLimit,
       demo: input.demo,
@@ -924,6 +928,7 @@ export async function runInteractiveMode(
       files: input.files,
       initialInput: input.initialInput,
       thinking: input.thinking,
+      backgroundSubagents: input.backgroundSubagents,
       replay: input.replay,
       replayLimit: input.replayLimit,
       demo: input.demo,

packages/cli/src/mini/types.ts

@@ -135,6 +135,7 @@ export type RunInput = {
   files: RunFilePart[]
   initialInput?: string
   thinking: boolean
+  backgroundSubagents: boolean
   demo?: boolean
 }
 

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

@@ -111,167 +111,157 @@ export type Endpoint4_8Input = {
 export type Endpoint4_8Output = EffectValue<ReturnType<RawClient["server.session"]["session.rename"]>>
 export type SessionRenameOperation<E = never> = (input: Endpoint4_8Input) => Effect.Effect<Endpoint4_8Output, E>
 
-type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
+type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
 export type Endpoint4_9Input = {
   readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
-  readonly destination: Endpoint4_9Request["payload"]["destination"]
-  readonly moveChanges?: Endpoint4_9Request["payload"]["moveChanges"]
+  readonly id?: Endpoint4_9Request["payload"]["id"]
+  readonly prompt: Endpoint4_9Request["payload"]["prompt"]
+  readonly delivery?: Endpoint4_9Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_9Request["payload"]["resume"]
 }
-export type Endpoint4_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.move"]>>
-export type SessionMoveOperation<E = never> = (input: Endpoint4_9Input) => Effect.Effect<Endpoint4_9Output, E>
+export type Endpoint4_9Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"]
+export type SessionPromptOperation<E = never> = (input: Endpoint4_9Input) => Effect.Effect<Endpoint4_9Output, E>
 
-type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
+type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.command"]>[0]
 export type Endpoint4_10Input = {
   readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
   readonly id?: Endpoint4_10Request["payload"]["id"]
-  readonly prompt: Endpoint4_10Request["payload"]["prompt"]
+  readonly command: Endpoint4_10Request["payload"]["command"]
+  readonly arguments?: Endpoint4_10Request["payload"]["arguments"]
+  readonly agent?: Endpoint4_10Request["payload"]["agent"]
+  readonly model?: Endpoint4_10Request["payload"]["model"]
+  readonly files?: Endpoint4_10Request["payload"]["files"]
+  readonly agents?: Endpoint4_10Request["payload"]["agents"]
   readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
   readonly resume?: Endpoint4_10Request["payload"]["resume"]
 }
-export type Endpoint4_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.prompt"]>>["data"]
-export type SessionPromptOperation<E = never> = (input: Endpoint4_10Input) => Effect.Effect<Endpoint4_10Output, E>
+export type Endpoint4_10Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"]
+export type SessionCommandOperation<E = never> = (input: Endpoint4_10Input) => Effect.Effect<Endpoint4_10Output, E>
 
-type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
 export type Endpoint4_11Input = {
   readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
   readonly id?: Endpoint4_11Request["payload"]["id"]
-  readonly command: Endpoint4_11Request["payload"]["command"]
-  readonly arguments?: Endpoint4_11Request["payload"]["arguments"]
-  readonly agent?: Endpoint4_11Request["payload"]["agent"]
-  readonly model?: Endpoint4_11Request["payload"]["model"]
-  readonly files?: Endpoint4_11Request["payload"]["files"]
-  readonly agents?: Endpoint4_11Request["payload"]["agents"]
-  readonly delivery?: Endpoint4_11Request["payload"]["delivery"]
+  readonly skill: Endpoint4_11Request["payload"]["skill"]
   readonly resume?: Endpoint4_11Request["payload"]["resume"]
 }
-export type Endpoint4_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.command"]>>["data"]
-export type SessionCommandOperation<E = never> = (input: Endpoint4_11Input) => Effect.Effect<Endpoint4_11Output, E>
+export type Endpoint4_11Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>
+export type SessionSkillOperation<E = never> = (input: Endpoint4_11Input) => Effect.Effect<Endpoint4_11Output, E>
 
-type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
 export type Endpoint4_12Input = {
   readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
-  readonly id?: Endpoint4_12Request["payload"]["id"]
-  readonly skill: Endpoint4_12Request["payload"]["skill"]
-  readonly resume?: Endpoint4_12Request["payload"]["resume"]
+  readonly text: Endpoint4_12Request["payload"]["text"]
+  readonly description?: Endpoint4_12Request["payload"]["description"]
+  readonly metadata?: Endpoint4_12Request["payload"]["metadata"]
 }
-export type Endpoint4_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.skill"]>>
-export type SessionSkillOperation<E = never> = (input: Endpoint4_12Input) => Effect.Effect<Endpoint4_12Output, E>
+export type Endpoint4_12Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>
+export type SessionSyntheticOperation<E = never> = (input: Endpoint4_12Input) => Effect.Effect<Endpoint4_12Output, E>
 
-type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
 export type Endpoint4_13Input = {
   readonly sessionID: Endpoint4_13Request["params"]["sessionID"]
-  readonly text: Endpoint4_13Request["payload"]["text"]
-  readonly description?: Endpoint4_13Request["payload"]["description"]
-  readonly metadata?: Endpoint4_13Request["payload"]["metadata"]
-  readonly resume?: Endpoint4_13Request["payload"]["resume"]
+  readonly id?: Endpoint4_13Request["payload"]["id"]
+  readonly command: Endpoint4_13Request["payload"]["command"]
 }
-export type Endpoint4_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.synthetic"]>>
-export type SessionSyntheticOperation<E = never> = (input: Endpoint4_13Input) => Effect.Effect<Endpoint4_13Output, E>
+export type Endpoint4_13Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>
+export type SessionShellOperation<E = never> = (input: Endpoint4_13Input) => Effect.Effect<Endpoint4_13Output, E>
 
-type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
 export type Endpoint4_14Input = {
   readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
   readonly id?: Endpoint4_14Request["payload"]["id"]
-  readonly command: Endpoint4_14Request["payload"]["command"]
 }
-export type Endpoint4_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.shell"]>>
-export type SessionShellOperation<E = never> = (input: Endpoint4_14Input) => Effect.Effect<Endpoint4_14Output, E>
+export type Endpoint4_14Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"]
+export type SessionCompactOperation<E = never> = (input: Endpoint4_14Input) => Effect.Effect<Endpoint4_14Output, E>
 
-type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-export type Endpoint4_15Input = {
-  readonly sessionID: Endpoint4_15Request["params"]["sessionID"]
-  readonly id?: Endpoint4_15Request["payload"]["id"]
+type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+export type Endpoint4_15Input = { readonly sessionID: Endpoint4_15Request["params"]["sessionID"] }
+export type Endpoint4_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>
+export type SessionWaitOperation<E = never> = (input: Endpoint4_15Input) => Effect.Effect<Endpoint4_15Output, E>
+
+type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+export type Endpoint4_16Input = {
+  readonly sessionID: Endpoint4_16Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_16Request["payload"]["messageID"]
+  readonly files?: Endpoint4_16Request["payload"]["files"]
 }
-export type Endpoint4_15Output = EffectValue<ReturnType<RawClient["server.session"]["session.compact"]>>["data"]
-export type SessionCompactOperation<E = never> = (input: Endpoint4_15Input) => Effect.Effect<Endpoint4_15Output, E>
+export type Endpoint4_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"]
+export type SessionRevertStageOperation<E = never> = (input: Endpoint4_16Input) => Effect.Effect<Endpoint4_16Output, E>
 
-type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-export type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
-export type Endpoint4_16Output = EffectValue<ReturnType<RawClient["server.session"]["session.wait"]>>
-export type SessionWaitOperation<E = never> = (input: Endpoint4_16Input) => Effect.Effect<Endpoint4_16Output, E>
+type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+export type Endpoint4_17Input = { readonly sessionID: Endpoint4_17Request["params"]["sessionID"] }
+export type Endpoint4_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>
+export type SessionRevertClearOperation<E = never> = (input: Endpoint4_17Input) => Effect.Effect<Endpoint4_17Output, E>
 
-type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-export type Endpoint4_17Input = {
-  readonly sessionID: Endpoint4_17Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_17Request["payload"]["messageID"]
-  readonly files?: Endpoint4_17Request["payload"]["files"]
-}
-export type Endpoint4_17Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.stage"]>>["data"]
-export type SessionRevertStageOperation<E = never> = (input: Endpoint4_17Input) => Effect.Effect<Endpoint4_17Output, E>
-
-type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
 export type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
-export type Endpoint4_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.clear"]>>
-export type SessionRevertClearOperation<E = never> = (input: Endpoint4_18Input) => Effect.Effect<Endpoint4_18Output, E>
+export type Endpoint4_18Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>
+export type SessionRevertCommitOperation<E = never> = (input: Endpoint4_18Input) => Effect.Effect<Endpoint4_18Output, E>
 
-type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context"]>[0]
 export type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
-export type Endpoint4_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.revert.commit"]>>
-export type SessionRevertCommitOperation<E = never> = (input: Endpoint4_19Input) => Effect.Effect<Endpoint4_19Output, E>
+export type Endpoint4_19Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"]
+export type SessionContextOperation<E = never> = (input: Endpoint4_19Input) => Effect.Effect<Endpoint4_19Output, E>
 
-type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
 export type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
-export type Endpoint4_20Output = EffectValue<ReturnType<RawClient["server.session"]["session.context"]>>["data"]
-export type SessionContextOperation<E = never> = (input: Endpoint4_20Input) => Effect.Effect<Endpoint4_20Output, E>
-
-type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
-export type Endpoint4_21Input = { readonly sessionID: Endpoint4_21Request["params"]["sessionID"] }
-export type Endpoint4_21Output = EffectValue<
+export type Endpoint4_20Output = EffectValue<
   ReturnType<RawClient["server.session"]["session.instructions.entry.list"]>
 >["data"]
 export type SessionInstructionsEntryListOperation<E = never> = (
+  input: Endpoint4_20Input,
+) => Effect.Effect<Endpoint4_20Output, E>
+
+type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
+export type Endpoint4_21Input = {
+  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
+  readonly key: Endpoint4_21Request["params"]["key"]
+  readonly value: Endpoint4_21Request["payload"]["value"]
+}
+export type Endpoint4_21Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>
+export type SessionInstructionsEntryPutOperation<E = never> = (
   input: Endpoint4_21Input,
 ) => Effect.Effect<Endpoint4_21Output, E>
 
-type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
+type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
 export type Endpoint4_22Input = {
   readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
   readonly key: Endpoint4_22Request["params"]["key"]
-  readonly value: Endpoint4_22Request["payload"]["value"]
 }
-export type Endpoint4_22Output = EffectValue<ReturnType<RawClient["server.session"]["session.instructions.entry.put"]>>
-export type SessionInstructionsEntryPutOperation<E = never> = (
-  input: Endpoint4_22Input,
-) => Effect.Effect<Endpoint4_22Output, E>
-
-type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
-export type Endpoint4_23Input = {
-  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
-  readonly key: Endpoint4_23Request["params"]["key"]
-}
-export type Endpoint4_23Output = EffectValue<
+export type Endpoint4_22Output = EffectValue<
   ReturnType<RawClient["server.session"]["session.instructions.entry.remove"]>
 >
 export type SessionInstructionsEntryRemoveOperation<E = never> = (
-  input: Endpoint4_23Input,
-) => Effect.Effect<Endpoint4_23Output, E>
+  input: Endpoint4_22Input,
+) => Effect.Effect<Endpoint4_22Output, E>
 
-type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.log"]>[0]
-export type Endpoint4_24Input = {
-  readonly sessionID: Endpoint4_24Request["params"]["sessionID"]
-  readonly after?: Endpoint4_24Request["query"]["after"]
-  readonly follow?: Endpoint4_24Request["query"]["follow"]
+type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+export type Endpoint4_23Input = {
+  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
+  readonly after?: Endpoint4_23Request["query"]["after"]
+  readonly follow?: Endpoint4_23Request["query"]["follow"]
 }
-export type Endpoint4_24Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>
-export type SessionLogOperation<E = never> = (input: Endpoint4_24Input) => Stream.Stream<Endpoint4_24Output, E>
+export type Endpoint4_23Output = StreamValue<EffectValue<ReturnType<RawClient["server.session"]["session.log"]>>>
+export type SessionLogOperation<E = never> = (input: Endpoint4_23Input) => Stream.Stream<Endpoint4_23Output, E>
 
-type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+export type Endpoint4_24Input = { readonly sessionID: Endpoint4_24Request["params"]["sessionID"] }
+export type Endpoint4_24Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>
+export type SessionInterruptOperation<E = never> = (input: Endpoint4_24Input) => Effect.Effect<Endpoint4_24Output, E>
+
+type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.background"]>[0]
 export type Endpoint4_25Input = { readonly sessionID: Endpoint4_25Request["params"]["sessionID"] }
-export type Endpoint4_25Output = EffectValue<ReturnType<RawClient["server.session"]["session.interrupt"]>>
-export type SessionInterruptOperation<E = never> = (input: Endpoint4_25Input) => Effect.Effect<Endpoint4_25Output, E>
+export type Endpoint4_25Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>
+export type SessionBackgroundOperation<E = never> = (input: Endpoint4_25Input) => Effect.Effect<Endpoint4_25Output, E>
 
-type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.background"]>[0]
-export type Endpoint4_26Input = { readonly sessionID: Endpoint4_26Request["params"]["sessionID"] }
-export type Endpoint4_26Output = EffectValue<ReturnType<RawClient["server.session"]["session.background"]>>
-export type SessionBackgroundOperation<E = never> = (input: Endpoint4_26Input) => Effect.Effect<Endpoint4_26Output, E>
-
-type Endpoint4_27Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-export type Endpoint4_27Input = {
-  readonly sessionID: Endpoint4_27Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_27Request["params"]["messageID"]
+type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+export type Endpoint4_26Input = {
+  readonly sessionID: Endpoint4_26Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_26Request["params"]["messageID"]
 }
-export type Endpoint4_27Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"]
-export type SessionMessageOperation<E = never> = (input: Endpoint4_27Input) => Effect.Effect<Endpoint4_27Output, E>
+export type Endpoint4_26Output = EffectValue<ReturnType<RawClient["server.session"]["session.message"]>>["data"]
+export type SessionMessageOperation<E = never> = (input: Endpoint4_26Input) => Effect.Effect<Endpoint4_26Output, E>
 
 export interface SessionApi<E = never> {
   readonly list: SessionListOperation<E>
@@ -283,7 +273,6 @@ export interface SessionApi<E = never> {
   readonly switchAgent: SessionSwitchAgentOperation<E>
   readonly switchModel: SessionSwitchModelOperation<E>
   readonly rename: SessionRenameOperation<E>
-  readonly move: SessionMoveOperation<E>
   readonly prompt: SessionPromptOperation<E>
   readonly command: SessionCommandOperation<E>
   readonly skill: SessionSkillOperation<E>
@@ -450,14 +439,8 @@ export type Endpoint10_0Input = { readonly location?: Endpoint10_0Request["query
 export type Endpoint10_0Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.list"]>>
 export type ServerMcpListOperation<E = never> = (input?: Endpoint10_0Input) => Effect.Effect<Endpoint10_0Output, E>
 
-type Endpoint10_1Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0]
-export type Endpoint10_1Input = { readonly location?: Endpoint10_1Request["query"]["location"] }
-export type Endpoint10_1Output = EffectValue<ReturnType<RawClient["server.mcp"]["mcp.resource.catalog"]>>
-export type ServerMcpCatalogOperation<E = never> = (input?: Endpoint10_1Input) => Effect.Effect<Endpoint10_1Output, E>
-
 export interface ServerMcpApi<E = never> {
   readonly list: ServerMcpListOperation<E>
-  readonly catalog: ServerMcpCatalogOperation<E>
 }
 
 type Endpoint11_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]

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

@@ -141,27 +141,15 @@ const Endpoint4_8 = (raw: RawClient["server.session"]) => (input: Endpoint4_8Inp
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.move"]>[0]
+type Endpoint4_9Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
 type Endpoint4_9Input = {
   readonly sessionID: Endpoint4_9Request["params"]["sessionID"]
-  readonly destination: Endpoint4_9Request["payload"]["destination"]
-  readonly moveChanges?: Endpoint4_9Request["payload"]["moveChanges"]
+  readonly id?: Endpoint4_9Request["payload"]["id"]
+  readonly prompt: Endpoint4_9Request["payload"]["prompt"]
+  readonly delivery?: Endpoint4_9Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_9Request["payload"]["resume"]
 }
 const Endpoint4_9 = (raw: RawClient["server.session"]) => (input: Endpoint4_9Input) =>
-  raw["session.move"]({
-    params: { sessionID: input["sessionID"] },
-    payload: { destination: input["destination"], moveChanges: input["moveChanges"] },
-  }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.prompt"]>[0]
-type Endpoint4_10Input = {
-  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
-  readonly id?: Endpoint4_10Request["payload"]["id"]
-  readonly prompt: Endpoint4_10Request["payload"]["prompt"]
-  readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_10Request["payload"]["resume"]
-}
-const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10Input) =>
   raw["session.prompt"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], prompt: input["prompt"], delivery: input["delivery"], resume: input["resume"] },
@@ -170,20 +158,20 @@ const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10I
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.command"]>[0]
-type Endpoint4_11Input = {
-  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
-  readonly id?: Endpoint4_11Request["payload"]["id"]
-  readonly command: Endpoint4_11Request["payload"]["command"]
-  readonly arguments?: Endpoint4_11Request["payload"]["arguments"]
-  readonly agent?: Endpoint4_11Request["payload"]["agent"]
-  readonly model?: Endpoint4_11Request["payload"]["model"]
-  readonly files?: Endpoint4_11Request["payload"]["files"]
-  readonly agents?: Endpoint4_11Request["payload"]["agents"]
-  readonly delivery?: Endpoint4_11Request["payload"]["delivery"]
-  readonly resume?: Endpoint4_11Request["payload"]["resume"]
+type Endpoint4_10Request = Parameters<RawClient["server.session"]["session.command"]>[0]
+type Endpoint4_10Input = {
+  readonly sessionID: Endpoint4_10Request["params"]["sessionID"]
+  readonly id?: Endpoint4_10Request["payload"]["id"]
+  readonly command: Endpoint4_10Request["payload"]["command"]
+  readonly arguments?: Endpoint4_10Request["payload"]["arguments"]
+  readonly agent?: Endpoint4_10Request["payload"]["agent"]
+  readonly model?: Endpoint4_10Request["payload"]["model"]
+  readonly files?: Endpoint4_10Request["payload"]["files"]
+  readonly agents?: Endpoint4_10Request["payload"]["agents"]
+  readonly delivery?: Endpoint4_10Request["payload"]["delivery"]
+  readonly resume?: Endpoint4_10Request["payload"]["resume"]
 }
-const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11Input) =>
+const Endpoint4_10 = (raw: RawClient["server.session"]) => (input: Endpoint4_10Input) =>
   raw["session.command"]({
     params: { sessionID: input["sessionID"] },
     payload: {
@@ -202,73 +190,67 @@ const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11I
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
-type Endpoint4_12Input = {
-  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
-  readonly id?: Endpoint4_12Request["payload"]["id"]
-  readonly skill: Endpoint4_12Request["payload"]["skill"]
-  readonly resume?: Endpoint4_12Request["payload"]["resume"]
+type Endpoint4_11Request = Parameters<RawClient["server.session"]["session.skill"]>[0]
+type Endpoint4_11Input = {
+  readonly sessionID: Endpoint4_11Request["params"]["sessionID"]
+  readonly id?: Endpoint4_11Request["payload"]["id"]
+  readonly skill: Endpoint4_11Request["payload"]["skill"]
+  readonly resume?: Endpoint4_11Request["payload"]["resume"]
 }
-const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
+const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11Input) =>
   raw["session.skill"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
-type Endpoint4_13Input = {
-  readonly sessionID: Endpoint4_13Request["params"]["sessionID"]
-  readonly text: Endpoint4_13Request["payload"]["text"]
-  readonly description?: Endpoint4_13Request["payload"]["description"]
-  readonly metadata?: Endpoint4_13Request["payload"]["metadata"]
-  readonly resume?: Endpoint4_13Request["payload"]["resume"]
+type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.synthetic"]>[0]
+type Endpoint4_12Input = {
+  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
+  readonly text: Endpoint4_12Request["payload"]["text"]
+  readonly description?: Endpoint4_12Request["payload"]["description"]
+  readonly metadata?: Endpoint4_12Request["payload"]["metadata"]
 }
-const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
+const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
   raw["session.synthetic"]({
     params: { sessionID: input["sessionID"] },
-    payload: {
-      text: input["text"],
-      description: input["description"],
-      metadata: input["metadata"],
-      resume: input["resume"],
-    },
+    payload: { text: input["text"], description: input["description"], metadata: input["metadata"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
-type Endpoint4_14Input = {
-  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
-  readonly id?: Endpoint4_14Request["payload"]["id"]
-  readonly command: Endpoint4_14Request["payload"]["command"]
+type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
+type Endpoint4_13Input = {
+  readonly sessionID: Endpoint4_13Request["params"]["sessionID"]
+  readonly id?: Endpoint4_13Request["payload"]["id"]
+  readonly command: Endpoint4_13Request["payload"]["command"]
 }
-const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
+const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
   raw["session.shell"]({
     params: { sessionID: input["sessionID"] },
     payload: { id: input["id"], command: input["command"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint4_15Input = {
-  readonly sessionID: Endpoint4_15Request["params"]["sessionID"]
-  readonly id?: Endpoint4_15Request["payload"]["id"]
+type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint4_14Input = {
+  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
+  readonly id?: Endpoint4_14Request["payload"]["id"]
 }
-const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
+const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
   raw["session.compact"]({ params: { sessionID: input["sessionID"] }, payload: { id: input["id"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
-const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
+type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint4_15Input = { readonly sessionID: Endpoint4_15Request["params"]["sessionID"] }
+const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
   raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint4_17Input = {
-  readonly sessionID: Endpoint4_17Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_17Request["payload"]["messageID"]
-  readonly files?: Endpoint4_17Request["payload"]["files"]
+type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint4_16Input = {
+  readonly sessionID: Endpoint4_16Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_16Request["payload"]["messageID"]
+  readonly files?: Endpoint4_16Request["payload"]["files"]
 }
-const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
+const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
   raw["session.revert.stage"]({
     params: { sessionID: input["sessionID"] },
     payload: { messageID: input["messageID"], files: input["files"] },
@@ -277,61 +259,61 @@ const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17I
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
-const Endpoint4_18 = (raw: RawClient["server.session"]) => (input: Endpoint4_18Input) =>
+type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+type Endpoint4_17Input = { readonly sessionID: Endpoint4_17Request["params"]["sessionID"] }
+const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
   raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
-type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
-const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
+type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
+const Endpoint4_18 = (raw: RawClient["server.session"]) => (input: Endpoint4_18Input) =>
   raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context"]>[0]
-type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
-const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
+type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
+const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
   raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
-type Endpoint4_21Input = { readonly sessionID: Endpoint4_21Request["params"]["sessionID"] }
-const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
+type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.instructions.entry.list"]>[0]
+type Endpoint4_20Input = { readonly sessionID: Endpoint4_20Request["params"]["sessionID"] }
+const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
   raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
-type Endpoint4_22Input = {
-  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
-  readonly key: Endpoint4_22Request["params"]["key"]
-  readonly value: Endpoint4_22Request["payload"]["value"]
+type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.instructions.entry.put"]>[0]
+type Endpoint4_21Input = {
+  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
+  readonly key: Endpoint4_21Request["params"]["key"]
+  readonly value: Endpoint4_21Request["payload"]["value"]
 }
-const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
+const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
   raw["session.instructions.entry.put"]({
     params: { sessionID: input["sessionID"], key: input["key"] },
     payload: { value: input["value"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
-type Endpoint4_23Input = {
-  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
-  readonly key: Endpoint4_23Request["params"]["key"]
+type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.instructions.entry.remove"]>[0]
+type Endpoint4_22Input = {
+  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
+  readonly key: Endpoint4_22Request["params"]["key"]
 }
-const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
+const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
   raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.log"]>[0]
-type Endpoint4_24Input = {
-  readonly sessionID: Endpoint4_24Request["params"]["sessionID"]
-  readonly after?: Endpoint4_24Request["query"]["after"]
-  readonly follow?: Endpoint4_24Request["query"]["follow"]
+type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint4_23Input = {
+  readonly sessionID: Endpoint4_23Request["params"]["sessionID"]
+  readonly after?: Endpoint4_23Request["query"]["after"]
+  readonly follow?: Endpoint4_23Request["query"]["follow"]
 }
-const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
+const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
   Stream.unwrap(
     raw["session.log"]({
       params: { sessionID: input["sessionID"] },
@@ -342,22 +324,22 @@ const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24I
     ),
   )
 
-type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint4_25Input = { readonly sessionID: Endpoint4_25Request["params"]["sessionID"] }
-const Endpoint4_25 = (raw: RawClient["server.session"]) => (input: Endpoint4_25Input) =>
+type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint4_24Input = { readonly sessionID: Endpoint4_24Request["params"]["sessionID"] }
+const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
   raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.background"]>[0]
-type Endpoint4_26Input = { readonly sessionID: Endpoint4_26Request["params"]["sessionID"] }
-const Endpoint4_26 = (raw: RawClient["server.session"]) => (input: Endpoint4_26Input) =>
+type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint4_25Input = { readonly sessionID: Endpoint4_25Request["params"]["sessionID"] }
+const Endpoint4_25 = (raw: RawClient["server.session"]) => (input: Endpoint4_25Input) =>
   raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_27Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint4_27Input = {
-  readonly sessionID: Endpoint4_27Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_27Request["params"]["messageID"]
+type Endpoint4_26Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint4_26Input = {
+  readonly sessionID: Endpoint4_26Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_26Request["params"]["messageID"]
 }
-const Endpoint4_27 = (raw: RawClient["server.session"]) => (input: Endpoint4_27Input) =>
+const Endpoint4_26 = (raw: RawClient["server.session"]) => (input: Endpoint4_26Input) =>
   raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
@@ -373,23 +355,22 @@ const adaptGroup4 = (raw: RawClient["server.session"]) => ({
   switchAgent: Endpoint4_6(raw),
   switchModel: Endpoint4_7(raw),
   rename: Endpoint4_8(raw),
-  move: Endpoint4_9(raw),
-  prompt: Endpoint4_10(raw),
-  command: Endpoint4_11(raw),
-  skill: Endpoint4_12(raw),
-  synthetic: Endpoint4_13(raw),
-  shell: Endpoint4_14(raw),
-  compact: Endpoint4_15(raw),
-  wait: Endpoint4_16(raw),
-  revertStage: Endpoint4_17(raw),
-  revertClear: Endpoint4_18(raw),
-  revertCommit: Endpoint4_19(raw),
-  context: Endpoint4_20(raw),
-  instructions: { entry: { list: Endpoint4_21(raw), put: Endpoint4_22(raw), remove: Endpoint4_23(raw) } },
-  log: Endpoint4_24(raw),
-  interrupt: Endpoint4_25(raw),
-  background: Endpoint4_26(raw),
-  message: Endpoint4_27(raw),
+  prompt: Endpoint4_9(raw),
+  command: Endpoint4_10(raw),
+  skill: Endpoint4_11(raw),
+  synthetic: Endpoint4_12(raw),
+  shell: Endpoint4_13(raw),
+  compact: Endpoint4_14(raw),
+  wait: Endpoint4_15(raw),
+  revertStage: Endpoint4_16(raw),
+  revertClear: Endpoint4_17(raw),
+  revertCommit: Endpoint4_18(raw),
+  context: Endpoint4_19(raw),
+  instructions: { entry: { list: Endpoint4_20(raw), put: Endpoint4_21(raw), remove: Endpoint4_22(raw) } },
+  log: Endpoint4_23(raw),
+  interrupt: Endpoint4_24(raw),
+  background: Endpoint4_25(raw),
+  message: Endpoint4_26(raw),
 })
 
 type Endpoint5_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
@@ -548,12 +529,7 @@ type Endpoint10_0Input = { readonly location?: Endpoint10_0Request["query"]["loc
 const Endpoint10_0 = (raw: RawClient["server.mcp"]) => (input?: Endpoint10_0Input) =>
   raw["mcp.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint10_1Request = Parameters<RawClient["server.mcp"]["mcp.resource.catalog"]>[0]
-type Endpoint10_1Input = { readonly location?: Endpoint10_1Request["query"]["location"] }
-const Endpoint10_1 = (raw: RawClient["server.mcp"]) => (input?: Endpoint10_1Input) =>
-  raw["mcp.resource.catalog"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
-
-const adaptGroup10 = (raw: RawClient["server.mcp"]) => ({ list: Endpoint10_0(raw), catalog: Endpoint10_1(raw) })
+const adaptGroup10 = (raw: RawClient["server.mcp"]) => ({ list: Endpoint10_0(raw) })
 
 type Endpoint11_0Request = Parameters<RawClient["server.credential"]["credential.update"]>[0]
 type Endpoint11_0Input = {

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

@@ -23,8 +23,6 @@ import type {
   SessionSwitchModelOutput,
   SessionRenameInput,
   SessionRenameOutput,
-  SessionMoveInput,
-  SessionMoveOutput,
   SessionPromptInput,
   SessionPromptOutput,
   SessionCommandInput,
@@ -89,8 +87,6 @@ import type {
   IntegrationAttemptCancelOutput,
   ServerMcpListInput,
   ServerMcpListOutput,
-  ServerMcpCatalogInput,
-  ServerMcpCatalogOutput,
   CredentialUpdateInput,
   CredentialUpdateOutput,
   CredentialRemoveInput,
@@ -491,18 +487,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      move: (input: SessionMoveInput, requestOptions?: RequestOptions) =>
-        request<SessionMoveOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
-            body: { destination: input["destination"], moveChanges: input["moveChanges"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
       prompt: (input: SessionPromptInput, requestOptions?: RequestOptions) =>
         request<{ readonly data: SessionPromptOutput }>(
           {
@@ -554,12 +538,7 @@ export function make(options: ClientOptions) {
           {
             method: "POST",
             path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
-            body: {
-              text: input["text"],
-              description: input["description"],
-              metadata: input["metadata"],
-              resume: input["resume"],
-            },
+            body: { text: input["text"], description: input["description"], metadata: input["metadata"] },
             successStatus: 204,
             declaredStatuses: [404, 400, 401],
             empty: true,
@@ -913,18 +892,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      catalog: (input?: ServerMcpCatalogInput, requestOptions?: RequestOptions) =>
-        request<ServerMcpCatalogOutput>(
-          {
-            method: "GET",
-            path: `/api/mcp/resource`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
     },
     credential: {
       update: (input: CredentialUpdateInput, requestOptions?: RequestOptions) =>

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

@@ -526,20 +526,6 @@ export type SessionRenameInput = {
 
 export type SessionRenameOutput = void
 
-export type SessionMoveInput = {
-  readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly destination: {
-    readonly destination: { readonly directory: string }
-    readonly moveChanges?: boolean | undefined
-  }["destination"]
-  readonly moveChanges?: {
-    readonly destination: { readonly directory: string }
-    readonly moveChanges?: boolean | undefined
-  }["moveChanges"]
-}
-
-export type SessionMoveOutput = void
-
 export type SessionPromptInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
   readonly id?: {
@@ -870,26 +856,17 @@ export type SessionSyntheticInput = {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly resume?: boolean | null
   }["text"]
   readonly description?: {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly resume?: boolean | null
   }["description"]
   readonly metadata?: {
     readonly text: string
     readonly description?: string | null
     readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly resume?: boolean | null
   }["metadata"]
-  readonly resume?: {
-    readonly text: string
-    readonly description?: string | null
-    readonly metadata?: { readonly [x: string]: JsonValue }
-    readonly resume?: boolean | null
-  }["resume"]
 }
 
 export type SessionSyntheticOutput = void
@@ -2501,36 +2478,6 @@ export type ServerMcpListOutput = {
   }>
 }
 
-export type ServerMcpCatalogInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-}
-
-export type ServerMcpCatalogOutput = {
-  readonly location: {
-    readonly directory: string
-    readonly workspaceID?: string
-    readonly project: { readonly id: string; readonly directory: string }
-  }
-  readonly data: {
-    readonly resources: ReadonlyArray<{
-      readonly server: string
-      readonly name: string
-      readonly uri: string
-      readonly description?: string
-      readonly mimeType?: string
-    }>
-    readonly templates: ReadonlyArray<{
-      readonly server: string
-      readonly name: string
-      readonly uriTemplate: string
-      readonly description?: string
-      readonly mimeType?: string
-    }>
-  }
-}
-
 export type CredentialUpdateInput = {
   readonly credentialID: { readonly credentialID: string }["credentialID"]
   readonly location?: {
@@ -5561,14 +5508,6 @@ export type EventSubscribeOutput =
       readonly location?: { readonly directory: string; readonly workspaceID?: string }
       readonly data: { readonly server: string }
     }
-  | {
-      readonly id: string
-      readonly created: number
-      readonly metadata?: { readonly [x: string]: unknown }
-      readonly type: "mcp.resources.changed"
-      readonly location?: { readonly directory: string; readonly workspaceID?: string }
-      readonly data: { readonly server: string }
-    }
   | {
       readonly id: string
       readonly created: number

packages/client/test/promise.test.ts

@@ -50,29 +50,6 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
 })
 
-test("MCP resource catalog uses the public HTTP contract", async () => {
-  let request: Request | undefined
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input) => {
-      request = input instanceof Request ? input : new Request(input)
-      return Response.json({
-        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
-        data: {
-          resources: [{ server: "docs", name: "Readme", uri: "docs://readme" }],
-          templates: [{ server: "docs", name: "File", uriTemplate: "docs://{path}" }],
-        },
-      })
-    },
-  })
-
-  const result = await client["server.mcp"].catalog({ location: { directory: "/tmp/project" } })
-
-  expect(result.data.resources[0]?.uri).toBe("docs://readme")
-  expect(request?.method).toBe("GET")
-  expect(request?.url).toBe("http://localhost:3000/api/mcp/resource?location%5Bdirectory%5D=%2Ftmp%2Fproject")
-})
-
 test("file.read returns binary content from the public HTTP contract", async () => {
   let request: Request | undefined
   const client = OpenCode.make({

packages/codemode/README.md

@@ -237,11 +237,11 @@ A host cannot define its own `$codemode` top-level namespace.
 
 CodeMode executes a deliberately bounded JavaScript subset. It supports:
 
-- Plain data literals, property access, assignment, destructuring, and sequence expressions (the comma operator, evaluated left to right with the final value returned).
+- Plain data literals, property access, assignment, property deletion, destructuring, and sequence expressions (the comma operator, evaluated left to right with the final value returned).
 - `if`, conditional expressions, `switch`, `for`, `for...of` (arrays, strings, Maps, Sets, including assignment-form destructuring such as `for ([key, value] of entries)`), `for...in` (own keys of plain objects, index strings of arrays, and namespace/tool names of `tools` references - anything else is an error suggesting `for...of` or `Object.keys`, rather than real JS's surprising behavior of indices for strings and zero iterations for Maps/Sets), `while`, and `do...while`.
 - Arrow functions and function declarations with closures, defaults, rest parameters, and destructuring.
 - Optional chaining, nullish coalescing, templates, spread (arrays, strings, Maps, Sets), and `try`/`catch`.
-- Common array, string, number, `Object`, `Math`, and `JSON` operations, including primitive-number `valueOf`, the standard non-finite `Number` constants, and host-backed `Math.random`. Mutating array methods include `push`/`pop`/`shift`/`unshift`/`splice` (removes in place and returns the removed elements)/`fill`/`copyWithin`; array `keys`/`values`/`entries` return **arrays** (matching the Map/Set convention) and work with `for...of` and spread. String methods include `localeCompare` (locale/options arguments ignored), `normalize`, and the `trimLeft`/`trimRight` aliases. `Object.keys` also accepts arrays (index strings, as in JS) and tool references: `Object.keys(tools)` lists the top-level namespaces, including `$codemode`, and `Object.keys(tools.ns)` lists the names at that node (a callable tool enumerates as `[]`; an unknown path is an `UnknownTool` diagnostic). `Object.values`/`Object.entries` on a tool reference fail with a pointer at `Object.keys(tools)` and `tools.$codemode.search`.
+- Common array, string, number, `Object`, `Math`, and `JSON` operations. Mutating array methods include `push`/`pop`/`shift`/`unshift`/`splice` (removes in place and returns the removed elements)/`fill`/`copyWithin`; array `keys`/`values`/`entries` return **arrays** (matching the Map/Set convention) and work with `for...of` and spread. String methods include `localeCompare` (locale/options arguments ignored), `normalize`, and the `trimLeft`/`trimRight` aliases. `Object.keys` also accepts arrays (index strings, as in JS) and tool references: `Object.keys(tools)` lists the top-level namespaces, including `$codemode`, and `Object.keys(tools.ns)` lists the names at that node (a callable tool enumerates as `[]`; an unknown path is an `UnknownTool` diagnostic). `Object.values`/`Object.entries` on a tool reference fail with a pointer at `Object.keys(tools)` and `tools.$codemode.search`.
 - `Date` - `Date.now()`/`Date.parse()`/`Date.UTC()`, `new Date(...)`, the getter methods, and date arithmetic/comparison via the time value. Dates stringify as ISO (`toString` included, for determinism across host timezones).
 - Regular expressions - `/literals/` and `new RegExp(...)` with `test`/`exec` (stateful `lastIndex` for `g`), plus string `match`/`matchAll`/`replace`/`replaceAll`/`split`/`search` with patterns. Match results are arrays carrying `index` and named `groups` as own properties (`input` is omitted). `replace` and `replaceAll` accept function replacers with captures, offset, input, and named groups; callbacks run sequentially, may await tool calls, and have their results coerced to strings. Invalid patterns, invalid flags, and missing-`g` calls fail with catchable errors that say what was wrong and how to fix it (escaping hints, the exact `/pattern/g` to write). Patterns run on the host engine, so pathological backtracking is bounded only by the execution timeout.
 - `Map` and `Set` - construction from entries/arrays/strings, `get`/`set`/`add`/`has`/`delete`/`clear`/`size`/`forEach`, and `keys`/`values`/`entries` returning **arrays** (not iterators).

packages/codemode/codemode.md

@@ -158,7 +158,7 @@ current omissions to implement, not intentional product boundaries.
 - [ ] Add `Object.is` after runtime method and tool references have stable identity semantics.
 - [ ] Add deterministic modern collection conveniences where they improve orchestration: `Object.groupBy`, Set
       composition methods, and `Array.prototype.toSpliced`.
-- [ ] Decide whether iterable `Math.sumPrecise` belongs in the runtime.
+- [ ] Decide whether nondeterministic `Math.random` and iterable `Math.sumPrecise` belong in the runtime.
 - [ ] Refine diagnostics so user throws, expected tool failures, unexpected host/tool defects, and genuine interpreter
       defects are distinguishable without leaking private causes.
 

packages/codemode/src/interpreter/runtime.ts

@@ -530,29 +530,17 @@ const invokeArrayStatic = (name: string, args: Array<unknown>, node: AstNode): u
       if (args[0] instanceof SandboxURLSearchParams) {
         return Array.from(args[0].params.entries(), ([key, value]) => [key, value])
       }
-      const source = args[0]
-      if (source instanceof SandboxPromise) {
-        throw new InterpreterRuntimeError(
-          "Array.from received an un-awaited Promise; await it before creating the array.",
-          node,
-          "InvalidDataValue",
-        )
-      }
+      const source = boundedData(args[0], "Array.from input")
       if (typeof source === "string") return Array.from(source)
       if (Array.isArray(source)) return [...source]
       if (
         source !== null &&
         typeof source === "object" &&
-        (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) &&
         typeof (source as { length?: unknown }).length === "number"
       ) {
         return Array.from(source as ArrayLike<unknown>)
       }
-      throw new InterpreterRuntimeError(
-        "Array.from expects an array, string, Map, Set, or array-like value.",
-        node,
-        "InvalidDataValue",
-      )
+      throw new InterpreterRuntimeError("Array.from expects an array, string, Map, Set, or array-like value.", node)
     }
     default:
       throw new InterpreterRuntimeError(`Array.${name} is not available in CodeMode.`, node)
@@ -1835,6 +1823,13 @@ class Interpreter<R> {
   private evaluateUnaryExpression(node: AstNode): Effect.Effect<unknown, unknown, R> {
     const operator = getString(node, "operator")
     const argument = getNode(node, "argument")
+    if (operator === "delete") {
+      const target = argument.type === "ChainExpression" ? getNode(argument, "expression") : argument
+      if (target.type !== "MemberExpression") {
+        throw new InterpreterRuntimeError("Delete target must be a data property in CodeMode.", argument)
+      }
+      return this.deleteMember(target)
+    }
     // `typeof undeclaredIdentifier` is `"undefined"` in JS (never a ReferenceError), so
     // feature-detection guards like `typeof x !== "undefined"` don't crash. Short-circuit before
     // evaluating the argument; a declared-but-TDZ binding still falls through to the normal throw.
@@ -2017,9 +2012,6 @@ class Interpreter<R> {
         if (callable.namespace === "Object" && objectMethodsPreservingIdentity.has(callable.name)) {
           return invokeGlobalMethod(callable, args, node)
         }
-        if (callable.namespace === "Array" && (callable.name === "from" || callable.name === "of")) {
-          return invokeGlobalMethod(callable, args, node)
-        }
         return boundedData(invokeGlobalMethod(callable, args, node), `${callable.namespace}.${callable.name} result`)
       }
       if (callable instanceof CoercionFunction) {
@@ -3082,6 +3074,7 @@ class Interpreter<R> {
 
   private getMemberReference(
     node: AstNode,
+    options?: { readonly allowUnknownArrayProperty: boolean },
   ): Effect.Effect<
     | MemberReference
     | ToolReference
@@ -3248,6 +3241,7 @@ class Interpreter<R> {
           typeof key !== "number" &&
           !/^\d+$/.test(key)
         ) {
+          if (options?.allowUnknownArrayProperty === true) return { target: objectValue, key }
           // Own non-index properties read through (match results carry index/groups); like JS,
           // they are readable in place and dropped by JSON at data boundaries.
           if (typeof key === "string" && Object.hasOwn(objectValue, key)) {
@@ -3293,6 +3287,29 @@ class Interpreter<R> {
     return this.modifyMember(node, () => Effect.succeed({ write: true, next: value, result: value }))
   }
 
+  private deleteMember(node: AstNode): Effect.Effect<boolean, unknown, R> {
+    return Effect.map(this.getMemberReference(node, { allowUnknownArrayProperty: true }), (reference) => {
+      if (reference === OptionalShortCircuit) return true
+      if (
+        reference instanceof ComputedValue ||
+        reference === undefined ||
+        reference instanceof ToolReference ||
+        reference instanceof PromiseMethodReference ||
+        reference instanceof IntrinsicReference ||
+        reference instanceof GlobalMethodReference ||
+        reference.target instanceof SandboxURL
+      ) {
+        throw new InterpreterRuntimeError("Only data properties may be deleted in CodeMode.", node)
+      }
+      if (Array.isArray(reference.target)) {
+        if (reference.key === "length" || (typeof reference.key === "string" && arrayMethods.has(reference.key))) {
+          throw new InterpreterRuntimeError("Array length and methods cannot be deleted in CodeMode.", node)
+        }
+      }
+      return Reflect.deleteProperty(reference.target, reference.key)
+    })
+  }
+
   // Resolves the member reference EXACTLY ONCE (so a side-effecting object/key expression
   // runs once), then lets `compute` decide whether to write - enabling compound assignment,
   // updates, plain writes, and short-circuiting logical assignment to share one safe path.

packages/codemode/src/stdlib/math.ts

@@ -1,7 +1,6 @@
 export const mathConstants = new Set(["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"])
 
 export const mathMethods = new Set([
-  "random",
   "max",
   "min",
   "abs",
@@ -41,7 +40,6 @@ export const mathMethods = new Set([
 
 export const invokeMathMethod = (name: string, args: Array<unknown>, node: AstNode): number => {
   if (!mathMethods.has(name)) throw new InterpreterRuntimeError(`Math.${name} is not available in CodeMode.`, node)
-  if (name === "random") return Math.random()
   const nums = args.map((arg) => {
     if (typeof arg !== "number") throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node)
     return arg

packages/codemode/src/stdlib/number.ts

@@ -1,15 +1,6 @@
-export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"])
+export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString"])
 
-export const numberConstants = new Set([
-  "MAX_SAFE_INTEGER",
-  "MIN_SAFE_INTEGER",
-  "MAX_VALUE",
-  "MIN_VALUE",
-  "EPSILON",
-  "NaN",
-  "POSITIVE_INFINITY",
-  "NEGATIVE_INFINITY",
-])
+export const numberConstants = new Set(["MAX_SAFE_INTEGER", "MIN_SAFE_INTEGER", "MAX_VALUE", "MIN_VALUE", "EPSILON"])
 
 export const numberStatics = new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"])
 
@@ -41,9 +32,6 @@ export const invokeNumberMethod = (value: number, name: string, args: Array<unkn
       result = value.toString(radix)
       break
     }
-    case "valueOf":
-      result = value
-      break
     default:
       throw new InterpreterRuntimeError(`Number method '${name}' is not available in CodeMode.`, node)
   }

packages/codemode/src/stdlib/object.ts

@@ -1,6 +1,6 @@
 import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
 import { isBlockedMember } from "../tool-runtime.js"
-import { isSandboxValue, SandboxMap, SandboxPromise, SandboxSet, SandboxURLSearchParams } from "../values.js"
+import { isSandboxValue, SandboxMap, SandboxSet, SandboxURLSearchParams } from "../values.js"
 import { boundedData, coerceToString } from "./value.js"
 
 export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "assign", "fromEntries"])
@@ -10,23 +10,13 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
   if (!objectStatics.has(name)) throw new InterpreterRuntimeError(`Object.${name} is not available in CodeMode.`, node)
   const requireObject = (): Record<string, unknown> => {
     const input = args[0]
+    const value = boundedData(args[0], `Object.${name} input`)
     if (Array.isArray(input)) return input as unknown as Record<string, unknown>
-    if (isSandboxValue(input)) return {}
-    if (input instanceof SandboxPromise) {
-      throw new InterpreterRuntimeError(
-        `Object.${name} received an un-awaited Promise; await it before inspecting the result.`,
-        node,
-        "InvalidDataValue",
-      )
+    if (isSandboxValue(value)) return {}
+    if (value === null || typeof value !== "object") {
+      throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node)
     }
-    if (input === null || typeof input !== "object") {
-      throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue")
-    }
-    const prototype = Object.getPrototypeOf(input)
-    if (prototype !== null && prototype !== Object.prototype) {
-      throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue")
-    }
-    return input as Record<string, unknown>
+    return value as Record<string, unknown>
   }
   const guardedSet = (out: Record<string, unknown>, key: string, item: unknown): void => {
     if (isBlockedMember(key)) throw new InterpreterRuntimeError(`Property '${key}' is not available in CodeMode.`, node)
@@ -38,8 +28,15 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
     guardedSet(out, coerceToString(key), item)
   }
   switch (name) {
-    case "keys":
-      return Object.keys(requireObject())
+    case "keys": {
+      const value = boundedData(args[0], "Object.keys input")
+      if (isSandboxValue(value)) return []
+      if (Array.isArray(value)) return Object.keys(value)
+      if (value === null || typeof value !== "object") {
+        throw new InterpreterRuntimeError("Object.keys expects a data object or array.", node)
+      }
+      return Object.keys(value)
+    }
     case "values":
       return Object.values(requireObject())
     case "entries":

packages/codemode/src/tool-runtime.ts

@@ -617,7 +617,6 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
     "",
     "Use common JavaScript data operations, functions, control flow, selected standard-library methods, and awaited tool calls. Built-ins include Date, RegExp, Map, Set, URL, URLSearchParams, and URI encoding helpers.",
     "Modules/imports, classes, generators, timers, fetch, eval, prototype access, unlisted methods, and promise chaining are unavailable. Use Code Mode tools for external operations. Use await with try/catch.",
-    "Prefer explicit `return`; otherwise only the final top-level expression becomes the result.",
     "Dates and URLs serialize to strings at data boundaries; Map/Set/RegExp/URLSearchParams serialize to `{}`.",
   ]
 

packages/codemode/test/codemode.test.ts

@@ -658,9 +658,6 @@ describe("CodeMode public contract", () => {
     expect(instructions).toContain("URL, URLSearchParams, and URI encoding helpers")
     expect(instructions).not.toContain("host globals")
     expect(instructions).toContain("Use Code Mode tools for external operations")
-    expect(instructions).toContain(
-      "Prefer explicit `return`; otherwise only the final top-level expression becomes the result.",
-    )
     expect(instructions).toContain(
       "Dates and URLs serialize to strings at data boundaries; Map/Set/RegExp/URLSearchParams serialize to `{}`.",
     )

packages/codemode/test/parity.test.ts

@@ -89,6 +89,69 @@ describe("H6: object spread of null/undefined is a no-op", () => {
   })
 })
 
+describe("delete data properties", () => {
+  test("removes an object property and reports success", async () => {
+    expect(await value(`const item = { keep: 1, remove: 2 }; const removed = delete item.remove; return { item, removed }`)).toEqual({
+      item: { keep: 1 },
+      removed: true,
+    })
+  })
+
+  test("evaluates a computed deletion key once", async () => {
+    expect(
+      await value(`
+        const item = { a: 1, b: 2 }
+        let calls = 0
+        const key = () => { calls += 1; return "b" }
+        const removed = delete item[key()]
+        return { item, calls, removed }
+      `),
+    ).toEqual({ item: { a: 1 }, calls: 1, removed: true })
+  })
+
+  test("deleting an array element leaves a hole without changing length", async () => {
+    expect(
+      await value(`
+        const items = ["a", "b", "c"]
+        const removed = delete items[1]
+        return { removed, length: items.length, hasIndex: 1 in items, keys: Object.keys(items) }
+      `),
+    ).toEqual({ removed: true, length: 3, hasIndex: false, keys: ["0", "2"] })
+  })
+
+  test("deleting an absent property succeeds", async () => {
+    expect(await value(`const item = { keep: 1 }; return delete item.missing`)).toBe(true)
+  })
+
+  test("optional deletion of a nullish receiver succeeds", async () => {
+    expect(
+      await value(`let calls = 0; const item = null; const removed = delete item?.[calls++]; return { calls, removed }`),
+    ).toEqual({ calls: 0, removed: true })
+  })
+
+  test("deleting an absent or non-canonical array key does not remove an element", async () => {
+    expect(
+      await value(`
+        const items = ["a", "b"]
+        const absent = delete items.missing
+        const nonCanonical = delete items["01"]
+        return { absent, nonCanonical, items, hasIndex: 1 in items }
+      `),
+    ).toEqual({ absent: true, nonCanonical: true, items: ["a", "b"], hasIndex: true })
+  })
+
+  test("rejects deletion of runtime and protected members", async () => {
+    for (const code of [
+      `delete tools.missing`,
+      `delete new URL("https://example.test").pathname`,
+      `delete [1].length`,
+      `delete [1].map`,
+    ]) {
+      expect((await error(code)).message).toContain("deleted")
+    }
+  })
+})
+
 describe("H4: typeof on an undeclared identifier is 'undefined'", () => {
   test("feature-detection guard does not throw", async () => {
     expect(await value(`return typeof foo === "undefined" ? "safe" : "no"`)).toBe("safe")

packages/codemode/test/promise.test.ts

@@ -245,12 +245,6 @@ describe("promises at data boundaries", () => {
     expect(diagnostic.message).toContain("await tools.ns.tool(...)")
   })
 
-  test("collection helpers do not let un-awaited promises cross the result boundary", async () => {
-    const diagnostic = await error(`return Array.from([Promise.resolve(1)])`)
-    expect(diagnostic.kind).toBe("InvalidDataValue")
-    expect(diagnostic.message).toContain("un-awaited Promise")
-  })
-
   test("passing an un-awaited promise as a tool argument is a clear diagnostic", async () => {
     const diagnostic = await error(`return await tools.host.sleepy({ id: tools.host.sleepy({ id: 1 }) })`)
     expect(diagnostic.kind).toBe("InvalidDataValue")

packages/codemode/test/stdlib.test.ts

@@ -19,28 +19,6 @@ const error = async (code: string) => {
   return result.error
 }
 
-describe("Number and Math", () => {
-  test("Math.random returns a number in [0, 1)", async () => {
-    expect(await value(`const n = Math.random(); return typeof n === "number" && n >= 0 && n < 1`)).toBe(true)
-  })
-
-  test("Number exposes native non-finite constants", async () => {
-    expect(
-      await value(
-        `return [Number.isNaN(Number.NaN), Number.POSITIVE_INFINITY === Infinity, Number.NEGATIVE_INFINITY === -Infinity]`,
-      ),
-    ).toEqual([true, true, true])
-  })
-
-  test("Number valueOf returns its primitive receiver", async () => {
-    expect(await value(`return (42).valueOf()`)).toBe(42)
-  })
-
-  test("Number valueOf does not enable boxed numbers", async () => {
-    expect((await error(`return new Number(42)`)).kind).toBe("UnsupportedSyntax")
-  })
-})
-
 describe("Date", () => {
   test("Date.now() returns a number", async () => {
     expect(await value(`return typeof Date.now()`)).toBe("number")
@@ -773,43 +751,6 @@ describe("sandbox values at intra-sandbox checkpoints", () => {
     )
   })
 
-  test("Object.values/entries preserve nested object identity", async () => {
-    expect(
-      await value(`
-      const child = { selected: false }
-      const rows = { a: child }
-      Object.values(rows)[0].selected = true
-      return child.selected
-    `),
-    ).toBe(true)
-    expect(
-      await value(`
-      const child = { selected: false }
-      const rows = { a: child }
-      Object.entries(rows)[0][1].selected = true
-      return child.selected
-    `),
-    ).toBe(true)
-  })
-
-  test("Object enumeration preserves promises and callable references", async () => {
-    expect(
-      await value(`
-      const pending = Promise.resolve(1)
-      const source = { pending }
-      return [Object.keys(source), Object.hasOwn(source, "pending"), await Object.values(source)[0], await Object.entries(source)[0][1]]
-    `),
-    ).toEqual([["pending"], true, 1, 1])
-    expect(await value(`return Object.values({ max: Math.max })[0](1, 2)`)).toBe(2)
-  })
-
-  test("Object enumeration rejects invalid receivers and gives promises an await hint", async () => {
-    const diagnostic = await error(`return Object.keys(Promise.resolve({ a: 1 }))`)
-    expect(diagnostic.kind).toBe("InvalidDataValue")
-    expect(diagnostic.message).toContain("await")
-    expect((await error(`return Object.keys(Math)`)).kind).toBe("InvalidDataValue")
-  })
-
   test("Object.assign keeps Maps usable", async () => {
     expect(await value(`const merged = Object.assign({}, { m: new Map([["a", 1]]) }); return merged.m.get("a")`)).toBe(
       1,
@@ -832,53 +773,6 @@ describe("sandbox values at intra-sandbox checkpoints", () => {
     expect(await value(`return Array.from([new Date(5)])[0].getTime()`)).toBe(5)
   })
 
-  test("Array.from and Array.of preserve nested object identity", async () => {
-    expect(
-      await value(`
-      const child = { selected: false }
-      Array.from([child])[0].selected = true
-      return child.selected
-    `),
-    ).toBe(true)
-    expect(
-      await value(`
-      const child = { selected: false }
-      Array.of(child)[0].selected = true
-      return child.selected
-    `),
-    ).toBe(true)
-  })
-
-  test("Array.from and Array.of preserve promises and callable references", async () => {
-    expect(
-      await value(`
-      const pending = Promise.resolve(1)
-      return [await Array.from([pending])[0], await Array.of(pending)[0]]
-    `),
-    ).toEqual([1, 1])
-    expect(await value(`return [Array.from([Math.max])[0](1, 2), Array.of(Math.max)[0](3, 4)]`)).toEqual([2, 4])
-  })
-
-  test("Array.from preserves identity across supported collection shapes", async () => {
-    expect(
-      await value(`
-      const child = { selected: false }
-      const fromArrayLike = Array.from({ 0: child, length: 1 })
-      const fromMap = Array.from(new Map([["child", child]]))
-      const fromSet = Array.from(new Set([child]))
-      fromArrayLike[0].selected = true
-      return [fromMap[0][1] === child, fromSet[0] === child, child.selected]
-    `),
-    ).toEqual([true, true, true])
-  })
-
-  test("Array.from rejects invalid receivers and gives promises an await hint", async () => {
-    const diagnostic = await error(`return Array.from(Promise.resolve([1]))`)
-    expect(diagnostic.kind).toBe("InvalidDataValue")
-    expect(diagnostic.message).toContain("await")
-    expect((await error(`return Array.from(() => 1)`)).kind).toBe("InvalidDataValue")
-  })
-
   test("regexes stay callable through Object.values", async () => {
     expect(await value(`return Object.values({ r: /ab+/ })[0].test("abb")`)).toBe(true)
   })

packages/core/src/code-mode.ts

@@ -1,127 +0,0 @@
-export * as CodeModeV2 from "./code-mode"
-
-import type { CodeMode } from "@opencode-ai/plugin/v2/effect"
-import { Context, Effect, Layer, Scope } from "effect"
-import { makeLocationNode } from "./effect/app-node"
-import { Flag } from "./flag/flag"
-import { PermissionV2 } from "./permission"
-import { ExecuteTool } from "./code-mode/execute"
-import { permission, RegistrationError, type AnyTool } from "./tool/tool"
-import { Wildcard } from "./util/wildcard"
-
-type Registration = {
-  readonly identity: object
-  readonly tool: AnyTool
-  readonly name: string
-  readonly path: readonly [string, ...string[]]
-}
-
-export interface MaterializeInput {
-  readonly permissions?: PermissionV2.Ruleset
-}
-
-export interface Interface {
-  readonly enabled: boolean
-  readonly register: (
-    source: (draft: CodeMode.Draft) => void,
-  ) => Effect.Effect<void, RegistrationError, Scope.Scope>
-  readonly materialize: (input: MaterializeInput) => Effect.Effect<AnyTool | undefined>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/CodeMode") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const enabled = Flag.CODEMODE_ENABLED
-    const local = new Map<string, Array<{ readonly token: object; readonly registration: Registration }>>()
-
-    return Service.of({
-      enabled,
-      register: Effect.fn("CodeMode.register")(function* (source) {
-        const pending: Array<{ readonly path: readonly [string, ...string[]]; readonly tool: AnyTool }> = []
-        yield* Effect.sync(() =>
-          source({
-            add: (path, tool) => pending.push({ path, tool }),
-          }),
-        )
-        if (pending.length === 0) return
-
-        const entries = pending.map((entry) => ({
-          ...entry,
-          key: entry.path.join("\0"),
-          name: entry.path.join("_"),
-        }))
-        const invalid = entries.find((entry) => entry.path.some((segment) => segment.length === 0))
-        if (invalid)
-          return yield* new RegistrationError({
-            name: invalid.path.join("."),
-            message: "Code Mode paths cannot contain empty segments",
-          })
-        const keys = new Set<string>()
-        const duplicate = entries.find((entry) => {
-          if (keys.has(entry.key)) return true
-          keys.add(entry.key)
-          return false
-        })
-        if (duplicate)
-          return yield* new RegistrationError({
-            name: duplicate.path.join("."),
-            message: `Duplicate Code Mode path: ${duplicate.path.join(".")}`,
-          })
-
-        yield* Effect.uninterruptible(
-          Effect.gen(function* () {
-            const token = {}
-            for (const entry of entries)
-              local.set(entry.key, [
-                ...(local.get(entry.key) ?? []),
-                {
-                  token,
-                  registration: {
-                    identity: {},
-                    tool: entry.tool,
-                    name: entry.name,
-                    path: entry.path,
-                  },
-                },
-              ])
-            yield* Effect.addFinalizer(() =>
-              Effect.sync(() => {
-                for (const entry of entries) {
-                  const registrations = local.get(entry.key)?.filter((item) => item.token !== token) ?? []
-                  if (registrations.length > 0) local.set(entry.key, registrations)
-                  else local.delete(entry.key)
-                }
-              }),
-            )
-          }),
-        )
-      }),
-      materialize: Effect.fn("CodeMode.materialize")(function* (input) {
-        if (!enabled || whollyDisabled("execute", input.permissions ?? [])) return undefined
-        const registrations = new Map<string, Registration>()
-        for (const [key, entries] of local) {
-          const registration = entries.at(-1)?.registration
-          if (
-            registration &&
-            !whollyDisabled(permission(registration.tool, registration.name), input.permissions ?? [])
-          )
-            registrations.set(key, registration)
-        }
-        if (registrations.size === 0) return undefined
-        return ExecuteTool.create({
-          registrations,
-          current: (key) => local.get(key)?.at(-1)?.registration,
-        })
-      }),
-    })
-  }),
-)
-
-function whollyDisabled(action: string, rules: PermissionV2.Ruleset) {
-  const rule = rules.findLast((rule) => Wildcard.match(action, rule.action))
-  return rule?.resource === "*" && rule.effect === "deny"
-}
-
-export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/location-services.ts

@@ -2,7 +2,6 @@ import { Effect, Layer, LayerMap } from "effect"
 import { AgentV2 } from "./agent"
 import { AISDK } from "./aisdk"
 import { Catalog } from "./catalog"
-import { CodeModeV2 } from "./code-mode"
 import { CommandV2 } from "./command"
 import { Config } from "./config"
 import { LayerNode } from "./effect/layer-node"
@@ -120,7 +119,6 @@ const locationServiceNodes = [
   MCP.node,
   PermissionV2.node,
   ToolOutputStore.node,
-  CodeModeV2.node,
   ToolRegistry.node,
   ToolRegistry.toolsNode,
   Image.node,

packages/core/src/mcp/client.ts

@@ -3,7 +3,7 @@ export * as MCPClient from "./client"
 import path from "node:path"
 import { execFile } from "node:child_process"
 import { pathToFileURL } from "node:url"
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { Client, type ClientOptions } from "@modelcontextprotocol/sdk/client/index.js"
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
 import { UnauthorizedError, type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
@@ -21,7 +21,6 @@ import {
   ListToolsResultSchema,
   PromptListChangedNotificationSchema,
   PromptSchema,
-  ResourceListChangedNotificationSchema,
   type LoggingMessageNotification,
   LoggingMessageNotificationSchema,
   ToolListChangedNotificationSchema,
@@ -69,13 +68,11 @@ export interface ToolDefinition {
 export interface PromptDefinition {
   readonly name: string
   readonly description: string | undefined
-  readonly arguments:
-    | ReadonlyArray<{
-        readonly name: string
-        readonly description: string | undefined
-        readonly required: boolean | undefined
-      }>
-    | undefined
+  readonly arguments: ReadonlyArray<{
+    readonly name: string
+    readonly description: string | undefined
+    readonly required: boolean | undefined
+  }> | undefined
 }
 
 export interface PromptMessage {
@@ -87,28 +84,6 @@ export interface PromptResult {
   readonly messages: ReadonlyArray<PromptMessage>
 }
 
-export interface ResourceDefinition {
-  readonly name: string
-  readonly uri: string
-  readonly description: string | undefined
-  readonly mimeType: string | undefined
-}
-
-export interface ResourceTemplateDefinition {
-  readonly name: string
-  readonly uriTemplate: string
-  readonly description: string | undefined
-  readonly mimeType: string | undefined
-}
-
-export type ResourceContentPart =
-  | { readonly type: "text"; readonly uri: string; readonly text: string; readonly mimeType: string | undefined }
-  | { readonly type: "blob"; readonly uri: string; readonly blob: string; readonly mimeType: string | undefined }
-
-export interface ReadResourceResult {
-  readonly contents: ReadonlyArray<ResourceContentPart>
-}
-
 export type CallToolContent =
   | { readonly type: "text"; readonly text: string }
   | { readonly type: "media"; readonly data: string; readonly mimeType: string }
@@ -149,12 +124,6 @@ export interface Connection {
   readonly tools: () => Effect.Effect<ToolDefinition[], Error>
   /** Lists the server's prompts; returns [] when the server doesn't advertise prompt support, fails on a transport error. */
   readonly prompts: () => Effect.Effect<PromptDefinition[], Error>
-  /** Lists the server's resources; returns [] when the server doesn't advertise resource support. */
-  readonly resources: () => Effect.Effect<ResourceDefinition[], Error>
-  /** Lists the server's resource templates; returns [] when the server doesn't advertise resource support. */
-  readonly resourceTemplates: () => Effect.Effect<ResourceTemplateDefinition[], Error>
-  /** Reads one resource; returns undefined when the server doesn't advertise resource support. */
-  readonly readResource: (input: { readonly uri: string }) => Effect.Effect<ReadResourceResult | undefined, Error>
   /** Invokes a prompt on the server. Interruption aborts the in-flight request. */
   readonly prompt: (input: {
     readonly name: string
@@ -172,8 +141,6 @@ export interface Connection {
   readonly onToolsChanged: (callback: () => void) => void
   /** Registers a callback fired when the server announces its prompt list changed; no-op if unsupported. */
   readonly onPromptsChanged: (callback: () => void) => void
-  /** Registers a callback fired when the server announces its resource catalog changed. */
-  readonly onResourcesChanged: (callback: () => void) => void
 }
 
 /** Connects an MCP server; closing the calling scope tears down the transport and any spawned process. */
@@ -201,8 +168,7 @@ export const connect = Effect.fnUntraced(function* (
         },
       })
     }
-    if (!URL.canParse(config.url))
-      return yield* new ConnectError({ server, message: `Invalid MCP URL for "${server}"` })
+    if (!URL.canParse(config.url)) return yield* new ConnectError({ server, message: `Invalid MCP URL for "${server}"` })
     return new StreamableHTTPClientTransport(new URL(config.url), {
       requestInit: config.headers ? { headers: config.headers } : undefined,
       authProvider,
@@ -236,7 +202,10 @@ export const connect = Effect.fnUntraced(function* (
   }).pipe(Effect.exit)
   if (Exit.isSuccess(exit)) {
     yield* Effect.addFinalizer(() =>
-      cleanupStdioDescendants(transport).pipe(Effect.andThen(Effect.promise(() => client.close())), Effect.ignore),
+      cleanupStdioDescendants(transport).pipe(
+        Effect.andThen(Effect.promise(() => client.close())),
+        Effect.ignore,
+      ),
     )
     const catalogTimeout = config.timeout?.catalog ?? DEFAULT_CATALOG_TIMEOUT
     const executionTimeout = config.timeout?.execution ?? DEFAULT_EXECUTION_TIMEOUT
@@ -288,9 +257,7 @@ export const connect = Effect.fnUntraced(function* (
               ),
             catch: (error) => (error instanceof Error ? error : new Error(String(error))),
           }).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("failed to list MCP prompts", { server, error: error.message }),
-            ),
+            Effect.tapError((error) => Effect.logWarning("failed to list MCP prompts", { server, error: error.message })),
           )
           return prompts.map((prompt) => ({
             name: prompt.name,
@@ -302,74 +269,6 @@ export const connect = Effect.fnUntraced(function* (
             })),
           }))
         }),
-      resources: () =>
-        Effect.gen(function* () {
-          if (!client.getServerCapabilities()?.resources) return []
-          const resources = yield* Effect.tryPromise({
-            try: () =>
-              paginate(
-                (cursor) =>
-                  client.listResources(cursor === undefined ? undefined : { cursor }, { timeout: catalogTimeout }),
-                (result) => result.resources,
-              ),
-            catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-          }).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("failed to list MCP resources", { server, error: error.message }),
-            ),
-          )
-          return resources.map((resource) => ({
-            name: resource.name,
-            uri: resource.uri,
-            description: resource.description,
-            mimeType: resource.mimeType,
-          }))
-        }),
-      resourceTemplates: () =>
-        Effect.gen(function* () {
-          if (!client.getServerCapabilities()?.resources) return []
-          const templates = yield* Effect.tryPromise({
-            try: () =>
-              paginate(
-                (cursor) =>
-                  client.listResourceTemplates(cursor === undefined ? undefined : { cursor }, {
-                    timeout: catalogTimeout,
-                  }),
-                (result) => result.resourceTemplates,
-              ),
-            catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-          }).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("failed to list MCP resource templates", { server, error: error.message }),
-            ),
-          )
-          return templates.map((template) => ({
-            name: template.name,
-            uriTemplate: template.uriTemplate,
-            description: template.description,
-            mimeType: template.mimeType,
-          }))
-        }),
-      readResource: (input) =>
-        Effect.gen(function* () {
-          if (!client.getServerCapabilities()?.resources) return undefined
-          const result = yield* Effect.tryPromise({
-            try: (signal) => client.readResource({ uri: input.uri }, { signal, timeout: executionTimeout }),
-            catch: (error) => (error instanceof Error ? error : new Error(String(error))),
-          }).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning("failed to read MCP resource", { server, uri: input.uri, error: error.message }),
-            ),
-          )
-          return {
-            contents: result.contents.map(
-              (part): ResourceContentPart =>
-                "text" in part
-                  ? { type: "text", uri: part.uri, text: part.text, mimeType: part.mimeType }
-                  : { type: "blob", uri: part.uri, blob: part.blob, mimeType: part.mimeType },
-            ),
-          }
-        }),
       prompt: (input) =>
         Effect.tryPromise({
           try: (signal) =>
@@ -429,14 +328,13 @@ export const connect = Effect.fnUntraced(function* (
         if (!client.getServerCapabilities()?.prompts?.listChanged) return
         client.setNotificationHandler(PromptListChangedNotificationSchema, async () => callback())
       },
-      onResourcesChanged: (callback) => {
-        if (!client.getServerCapabilities()?.resources?.listChanged) return
-        client.setNotificationHandler(ResourceListChangedNotificationSchema, async () => callback())
-      },
     } satisfies Connection
   }
 
-  yield* cleanupStdioDescendants(transport).pipe(Effect.andThen(Effect.promise(() => transport.close())), Effect.ignore)
+  yield* cleanupStdioDescendants(transport).pipe(
+    Effect.andThen(Effect.promise(() => transport.close())),
+    Effect.ignore,
+  )
   const error = Cause.squash(exit.cause)
   if (error instanceof UnauthorizedError) return yield* new NeedsAuthError({ server })
   return yield* new ConnectError({ server, message: error instanceof Error ? error.message : String(error) })

packages/core/src/mcp/guidance.ts

@@ -1,7 +1,7 @@
 export * as McpGuidance from "./guidance"
 
 import { makeLocationNode } from "../effect/app-node"
-import { CodeModeV2 } from "../code-mode"
+import { Flag } from "../flag/flag"
 import { Context, Effect, Layer, Schema } from "effect"
 import { AgentV2 } from "../agent"
 import { PermissionV2 } from "../permission"
@@ -15,10 +15,10 @@ const Summary = Schema.Struct({
 })
 type Summary = typeof Summary.Type
 
-const entries = (servers: ReadonlyArray<Summary>, codeMode: boolean) =>
+const entries = (servers: ReadonlyArray<Summary>) =>
   servers.flatMap((server) => [
     `  <server name="${server.server}">`,
-    ...(codeMode
+    ...(Flag.CODEMODE_ENABLED
       ? [
           `    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(McpTool.group(server.server))}]\`.`,
         ]
@@ -27,10 +27,10 @@ const entries = (servers: ReadonlyArray<Summary>, codeMode: boolean) =>
     "  </server>",
   ])
 
-const render = (servers: ReadonlyArray<Summary>, codeMode: boolean) =>
-  ["<mcp_instructions>", ...entries(servers, codeMode), "</mcp_instructions>"].join("\n")
+const render = (servers: ReadonlyArray<Summary>) =>
+  ["<mcp_instructions>", ...entries(servers), "</mcp_instructions>"].join("\n")
 
-const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary>, codeMode: boolean) => {
+const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary>) => {
   const diff = Instructions.diffByKey(
     previous,
     current,
@@ -41,15 +41,12 @@ const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary
   if (diff.changed.length > 0 || (diff.added.length === 0 && diff.removed.length === 0))
     return [
       "The available MCP server instructions have changed. This list supersedes the previous one.",
-      render(current, codeMode),
+      render(current),
     ].join("\n")
   return [
     ...(diff.added.length === 0
       ? []
-      : [
-          "New MCP server instructions are available in addition to those previously listed:",
-          ...entries(diff.added, codeMode),
-        ]),
+      : ["New MCP server instructions are available in addition to those previously listed:", ...entries(diff.added)]),
     ...(diff.removed.length === 0
       ? []
       : [
@@ -67,14 +64,13 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const codeMode = yield* CodeModeV2.Service
     const mcp = yield* MCP.Service
 
     return Service.of({
       load: Effect.fn("McpGuidance.load")(function* (selection) {
         const agent = selection.info
         if (!agent) return Instructions.empty
-        if (codeMode.enabled && PermissionV2.evaluate("execute", "*", agent.permissions).effect === "deny")
+        if (Flag.CODEMODE_ENABLED && PermissionV2.evaluate("execute", "*", agent.permissions).effect === "deny")
           return Instructions.empty
         const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
           concurrency: "unbounded",
@@ -84,7 +80,7 @@ export const layer = Layer.effect(
           .filter((item) => {
             const owned = tools.filter((tool) => tool.server === item.server)
             return (
-              (!codeMode.enabled && owned.length === 0) ||
+              (!Flag.CODEMODE_ENABLED && owned.length === 0) ||
               owned.some(
                 (tool) =>
                   PermissionV2.evaluate(McpTool.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny",
@@ -97,8 +93,8 @@ export const layer = Layer.effect(
           key: Instructions.Key.make("core/mcp-guidance"),
           codec: Schema.toCodecJson(Schema.Array(Summary)),
           load: Effect.succeed(visible),
-          baseline: (servers) => render(servers, codeMode.enabled),
-          update: (previous, current) => update(previous, current, codeMode.enabled),
+          baseline: render,
+          update,
           removed: () => "MCP server instructions are no longer available.",
         })
       }),
@@ -106,4 +102,4 @@ export const layer = Layer.effect(
   }),
 )
 
-export const node = makeLocationNode({ service: Service, layer, deps: [CodeModeV2.node, MCP.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [MCP.node] })

packages/core/src/mcp/index.ts

@@ -83,16 +83,48 @@ export class PromptResult extends Schema.Class<PromptResult>("MCP.PromptResult")
   messages: Schema.Array(PromptMessage),
 }) {}
 
-export const Resource = Mcp.Resource
-export type Resource = Mcp.Resource
-export const ResourceTemplate = Mcp.ResourceTemplate
-export type ResourceTemplate = Mcp.ResourceTemplate
-export const ResourceCatalog = Mcp.ResourceCatalog
-export type ResourceCatalog = Mcp.ResourceCatalog
-export const ResourceContentPart = Mcp.ResourceContentPart
-export type ResourceContentPart = Mcp.ResourceContentPart
-export const ResourceContent = Mcp.ResourceContent
-export type ResourceContent = Mcp.ResourceContent
+export class Resource extends Schema.Class<Resource>("MCP.Resource")({
+  server: ServerName,
+  name: Schema.String,
+  uri: Schema.String,
+  description: Schema.String.pipe(Schema.optional),
+  mimeType: Schema.String.pipe(Schema.optional),
+}) {}
+
+export class ResourceTemplate extends Schema.Class<ResourceTemplate>("MCP.ResourceTemplate")({
+  server: ServerName,
+  name: Schema.String,
+  uriTemplate: Schema.String,
+  description: Schema.String.pipe(Schema.optional),
+  mimeType: Schema.String.pipe(Schema.optional),
+}) {}
+
+export class ResourceCatalog extends Schema.Class<ResourceCatalog>("MCP.ResourceCatalog")({
+  resources: Schema.Array(Resource),
+  templates: Schema.Array(ResourceTemplate),
+}) {}
+
+export const ResourceContentPart = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("text"),
+    uri: Schema.String,
+    text: Schema.String,
+    mimeType: Schema.String.pipe(Schema.optional),
+  }),
+  Schema.Struct({
+    type: Schema.Literal("blob"),
+    uri: Schema.String,
+    blob: Schema.String,
+    mimeType: Schema.String.pipe(Schema.optional),
+  }),
+]).pipe(Schema.toTaggedUnion("type"))
+export type ResourceContentPart = typeof ResourceContentPart.Type
+
+export class ResourceContent extends Schema.Class<ResourceContent>("MCP.ResourceContent")({
+  server: ServerName,
+  uri: Schema.String,
+  contents: Schema.Array(ResourceContentPart),
+}) {}
 
 export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("MCP.NotFoundError", {
   server: ServerName,
@@ -383,24 +415,6 @@ export const layer = Layer.effect(
         ),
       })
 
-    const toResource = (server: ServerName, def: MCPClient.ResourceDefinition) =>
-      Resource.make({
-        server,
-        name: def.name,
-        uri: def.uri,
-        description: def.description,
-        mimeType: def.mimeType,
-      })
-
-    const toResourceTemplate = (server: ServerName, def: MCPClient.ResourceTemplateDefinition) =>
-      ResourceTemplate.make({
-        server,
-        name: def.name,
-        uriTemplate: def.uriTemplate,
-        description: def.description,
-        mimeType: def.mimeType,
-      })
-
     const refreshTools = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
       connection.tools().pipe(
         Effect.map((defs) => {
@@ -429,7 +443,6 @@ export const layer = Layer.effect(
         entry.prompts = undefined
         entry.status = { status: "failed", error: "Connection closed" }
         fork(events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore))
-        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
         fork(events.publish(Command.Event.Updated, {}).pipe(Effect.ignore))
         fork(events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore))
       })
@@ -445,10 +458,6 @@ export const layer = Layer.effect(
       connection.onPromptsChanged(() => {
         fork(refreshPrompts(name, entry, connection).pipe(Effect.ignore))
       })
-      connection.onResourcesChanged(() => {
-        if (entry.client !== connection) return
-        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
-      })
     }
 
     const serverLog = (server: ServerName, message: MCPClient.LogMessage) => {
@@ -492,7 +501,6 @@ export const layer = Layer.effect(
           // after the initial registration sweep and emits no list-changed notification would otherwise
           // stay invisible to the model.
           yield* events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-          yield* events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
           yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
           fork(refreshPrompts(name, entry, result.value.connection).pipe(Effect.ignore))
           return
@@ -549,6 +557,11 @@ export const layer = Layer.effect(
       concurrency: "unbounded",
       discard: true,
     })
+    const gate = Effect.fnUntraced(function* (server: ServerName | string) {
+      const target = yield* requireServer(server)
+      yield* Deferred.await(target.entry.startup)
+    })
+
     return Service.of({
       servers: Effect.fn("MCP.servers")(function* () {
         const entries = Array.from(runtime).toSorted(([a], [b]) => a.localeCompare(b))
@@ -624,54 +637,11 @@ export const layer = Layer.effect(
       }),
       resourceCatalog: Effect.fn("MCP.resourceCatalog")(function* () {
         yield* whenAllReady
-        const catalogs = yield* Effect.forEach(
-          Array.from(runtime),
-          ([name, entry]) => {
-            if (!entry.client) return Effect.succeed({ resources: [], templates: [] })
-            return Effect.all(
-              {
-                resources: entry.client.resources().pipe(Effect.catch(() => Effect.succeed([]))),
-                templates: entry.client.resourceTemplates().pipe(Effect.catch(() => Effect.succeed([]))),
-              },
-              { concurrency: "unbounded" },
-            ).pipe(
-              Effect.map((catalog) => ({
-                resources: catalog.resources.map((def) => toResource(name, def)),
-                templates: catalog.templates.map((def) => toResourceTemplate(name, def)),
-              })),
-            )
-          },
-          { concurrency: "unbounded" },
-        )
-        return ResourceCatalog.make({
-          resources: catalogs
-            .flatMap((catalog) => catalog.resources)
-            .toSorted(
-              (a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name) || a.uri.localeCompare(b.uri),
-            ),
-          templates: catalogs
-            .flatMap((catalog) => catalog.templates)
-            .toSorted(
-              (a, b) =>
-                a.server.localeCompare(b.server) ||
-                a.name.localeCompare(b.name) ||
-                a.uriTemplate.localeCompare(b.uriTemplate),
-            ),
-        })
+        return new ResourceCatalog({ resources: [], templates: [] })
       }),
       readResource: Effect.fn("MCP.readResource")(function* (input) {
-        const target = yield* requireServer(input.server)
-        yield* Deferred.await(target.entry.startup)
-        if (!target.entry.client) return undefined
-        const result = yield* target.entry.client
-          .readResource({ uri: input.uri })
-          .pipe(Effect.catch(() => Effect.succeed(undefined)))
-        if (!result) return undefined
-        return ResourceContent.make({
-          server: target.name,
-          uri: input.uri,
-          contents: result.contents,
-        })
+        yield* gate(input.server)
+        return undefined
       }),
     })
   }),

packages/core/src/plugin.ts

@@ -7,7 +7,6 @@ import { Context, Effect, Exit, Layer, Scope, Semaphore } from "effect"
 import { AgentV2 } from "./agent"
 import { AISDK } from "./aisdk"
 import { Catalog } from "./catalog"
-import { CodeModeV2 } from "./code-mode"
 import { CommandV2 } from "./command"
 import { EventV2 } from "./event"
 import { Integration } from "./integration"
@@ -125,7 +124,6 @@ export const node = makeLocationNode({
     AgentV2.node,
     AISDK.node,
     Catalog.node,
-    CodeModeV2.node,
     CommandV2.node,
     Integration.node,
     Location.node,

packages/core/src/plugin/host.ts

@@ -6,7 +6,6 @@ import { Effect, Schema, Stream } from "effect"
 import { AgentV2 } from "../agent"
 import { AISDK } from "../aisdk"
 import { Catalog } from "../catalog"
-import { CodeModeV2 } from "../code-mode"
 import { CommandV2 } from "../command"
 import { Credential } from "../credential"
 import { EventV2 } from "../event"
@@ -29,7 +28,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
   const agents = yield* AgentV2.Service
   const aisdk = yield* AISDK.Service
   const catalog = yield* Catalog.Service
-  const codeMode = yield* CodeModeV2.Service
   const commands = yield* CommandV2.Service
   const events = yield* EventV2.Service
   const integration = yield* Integration.Service
@@ -160,9 +158,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
           callback(draft)
         }),
     },
-    codemode: {
-      register: codeMode.register,
-    },
     event: {
       subscribe: () => events.subscribe().pipe(Stream.filter(EventManifest.isServer)),
     },

packages/core/src/session.ts

@@ -243,7 +243,6 @@ export interface Interface {
     text: string
     description?: string
     metadata?: Record<string, unknown>
-    resume?: boolean
   }) => Effect.Effect<void, NotFoundError>
   readonly revert: {
     readonly stage: (input: {
@@ -683,7 +682,6 @@ const layer = Layer.effect(
           description: input.description,
           metadata: input.metadata,
         })
-        if (input.resume === false) return
         yield* execution
           .resume(input.sessionID)
           .pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid)

packages/core/src/tool/execute.ts

@@ -3,7 +3,7 @@ export * as ExecuteTool from "./execute"
 import { CodeMode, Tool, toolError } from "@opencode-ai/codemode"
 import { ToolOutput } from "@opencode-ai/llm"
 import { Effect, Ref, Schema } from "effect"
-import { definition, make, settle, type AnyTool } from "../tool/tool"
+import { definition, make, settle, type AnyTool } from "./tool"
 
 const ExecuteFile = Schema.Struct({
   data: Schema.String,
@@ -40,11 +40,7 @@ export interface Registration {
   readonly identity: object
   readonly tool: AnyTool
   readonly name: string
-  readonly path: readonly [string, ...string[]]
-}
-
-interface CodeModeTools {
-  [name: string]: Tool.Definition<never> | CodeModeTools
+  readonly group?: string
 }
 
 export const create = (options: {
@@ -55,16 +51,33 @@ export const create = (options: {
     invoke: (name: string, registration: Registration, input: unknown) => Effect.Effect<unknown, unknown>,
     hooks?: CodeMode.ToolCallHooks,
   ) => {
-    const tools: CodeModeTools = Object.create(null)
-    for (const [key, registration] of options.registrations) {
-      const child = definition(registration.name, registration.tool)
+    const tools: Record<string, Tool.Definition<never> | Record<string, Tool.Definition<never>>> = {}
+    for (const [name, registration] of options.registrations) {
+      const child = definition(name, registration.tool)
       const value = Tool.make({
         description: child.description,
         input: child.inputSchema,
         output: child.outputSchema,
-        run: (input) => invoke(key, registration, input),
+        run: (input) => invoke(name, registration, input),
       })
-      addTool(tools, registration.path, value)
+      if (registration.group === undefined) {
+        const path = registration.name
+        if (Object.hasOwn(tools, path)) throw new TypeError(`Deferred tool namespace conflict: ${path}`)
+        tools[path] = value
+        continue
+      }
+      const path = registration.name
+      const namespace = registration.group
+      const group = tools[namespace]
+      if (group && Tool.isDefinition(group)) throw new TypeError(`Deferred tool namespace conflict: ${namespace}`)
+      if (group) {
+        if (Object.hasOwn(group, path)) throw new TypeError(`Deferred tool namespace conflict: ${namespace}.${path}`)
+        group[path] = value
+        continue
+      }
+      const entries: Record<string, Tool.Definition<never>> = {}
+      entries[path] = value
+      tools[namespace] = entries
     }
     return CodeMode.make<typeof tools>({ tools, ...hooks })
   }
@@ -99,15 +112,15 @@ export const create = (options: {
           ),
         )
         const result = yield* runtime(
-          (key, registration, input) =>
+          (name, registration, input) =>
             Effect.gen(function* () {
               const index = yield* Ref.getAndUpdate(callIndex, (index) => index + 1)
-              const current = options.current(key)
+              const current = options.current(name)
               if (!current || current.identity !== registration.identity)
-                return yield* Effect.fail(toolError(`Stale tool call: ${registration.path.join(".")}`))
+                return yield* Effect.fail(toolError(`Stale tool call: ${name}`))
               const output = yield* settle(
                 current.tool,
-                { type: "tool-call", id: context.toolCallID, name: registration.name, input },
+                { type: "tool-call", id: context.toolCallID, name, input },
                 {
                   sessionID: context.sessionID,
                   agent: context.agent,
@@ -150,21 +163,6 @@ export const create = (options: {
   })
 }
 
-function addTool(tools: CodeModeTools, path: readonly string[], value: Tool.Definition<never>) {
-  const [name, ...rest] = path
-  if (name === undefined) return
-  if (rest.length === 0) {
-    if (Object.hasOwn(tools, name)) throw new TypeError(`Code Mode namespace conflict: ${path.join(".")}`)
-    tools[name] = value
-    return
-  }
-  const current = tools[name]
-  if (Tool.isDefinition(current)) throw new TypeError(`Code Mode namespace conflict: ${path.join(".")}`)
-  const child: CodeModeTools = current ?? Object.create(null)
-  tools[name] = child
-  addTool(child, rest, value)
-}
-
 function displayInput(input: unknown): Record<string, unknown> | undefined {
   if (input === null || input === undefined) return
   if (typeof input !== "object" || Array.isArray(input)) return { input }

packages/core/src/tool/mcp.ts

@@ -5,7 +5,7 @@ import { McpEvent } from "@opencode-ai/schema/mcp-event"
 import { Effect, Exit, type JsonSchema, Layer, Scope, Semaphore, Stream } from "effect"
 import { makeLocationNode } from "../effect/app-node"
 import { EventV2 } from "../event"
-import { CodeModeV2 } from "../code-mode"
+import { Flag } from "../flag/flag"
 import { MCP } from "../mcp"
 import { PermissionV2 } from "../permission"
 import { Tool } from "./tool"
@@ -21,7 +21,6 @@ export const name = (server: string, tool: string) => `${group(server)}_${tool.r
 export const layer = Layer.effectDiscard(
   Effect.gen(function* () {
     const mcp = yield* MCP.Service
-    const codeMode = yield* CodeModeV2.Service
     const tools = yield* Tools.Service
     const events = yield* EventV2.Service
     const permission = yield* PermissionV2.Service
@@ -106,14 +105,13 @@ export const layer = Layer.effectDiscard(
           groups.set(tool.server, group)
         }
         const next = yield* Scope.fork(scope)
-        const register = codeMode.enabled
-          ? codeMode.register((draft) => {
-              for (const [server, record] of groups)
-                for (const [tool, value] of Object.entries(record))
-                  draft.add([group(server), tool.replace(/[^a-zA-Z0-9_-]/g, "_")], value)
-            })
-          : Effect.forEach(groups, ([group, record]) => tools.register(record, { group }), { discard: true })
-        yield* register.pipe(Scope.provide(next), Effect.orDie)
+        yield* Effect.forEach(
+          groups,
+          ([group, record]) => tools.register(record, { group, deferred: Flag.CODEMODE_ENABLED }),
+          {
+            discard: true,
+          },
+        ).pipe(Scope.provide(next), Effect.orDie)
         if (current) yield* Scope.close(current, Exit.void)
         current = next
       }),
@@ -130,5 +128,5 @@ export const layer = Layer.effectDiscard(
 export const node = makeLocationNode({
   name: "mcp-tools",
   layer,
-  deps: [CodeModeV2.node, ToolRegistry.toolsNode, MCP.node, EventV2.node, PermissionV2.node],
+  deps: [ToolRegistry.toolsNode, MCP.node, EventV2.node, PermissionV2.node],
 })

packages/core/src/tool/registry.ts

@@ -3,12 +3,13 @@ export * as ToolRegistry from "./registry"
 import { ToolOutput, type ToolCall, type ToolDefinition, type ToolResultValue } from "@opencode-ai/llm"
 import { Context, Effect, Layer, Scope } from "effect"
 import type { AgentV2 } from "../agent"
-import { CodeModeV2 } from "../code-mode"
+import { Flag } from "../flag/flag"
 import { PermissionV2 } from "../permission"
 import { SessionMessage } from "../session/message"
 import { SessionSchema } from "../session/schema"
 import { ToolOutputStore } from "../tool-output-store"
 import { Wildcard } from "../util/wildcard"
+import { ExecuteTool } from "./execute"
 import { definition, permission, registrationEntries, RegistrationError, settle, type AnyTool } from "./tool"
 import { Tools } from "./tools"
 import { ToolHooks } from "./hooks"
@@ -54,12 +55,14 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 const registryLayer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const codeMode = yield* CodeModeV2.Service
     const resources = yield* ToolOutputStore.Service
     const toolHooks = yield* ToolHooks.Service
     type Registration = {
       readonly identity: object
       readonly tool: AnyTool
+      readonly name: string
+      readonly group?: string
+      readonly deferred: boolean
     }
     const local = new Map<string, Array<{ readonly token: object; readonly registration: Registration }>>()
 
@@ -147,7 +150,7 @@ const registryLayer = Layer.effect(
       register: Effect.fn("ToolRegistry.register")(function* (tools, options) {
         const entries = registrationEntries(tools, options?.group)
         if (entries.length === 0) return
-        const reserved = entries.find((entry) => entry.key === "execute")
+        const reserved = options?.deferred ? undefined : entries.find((entry) => entry.key === "execute")
         if (reserved)
           return yield* Effect.fail(
             new RegistrationError({ name: reserved.key, message: 'Tool name "execute" is reserved for CodeMode' }),
@@ -163,6 +166,9 @@ const registryLayer = Layer.effect(
                   registration: {
                     identity: {},
                     tool: entry.tool,
+                    name: entry.name,
+                    group: entry.group,
+                    deferred: options?.deferred ?? false,
                   },
                 },
               ])
@@ -189,18 +195,30 @@ const registryLayer = Layer.effect(
         const usePatch = input.model.provider.toLowerCase() === "openai" || input.model.id.toLowerCase().includes("gpt")
         for (const [name, registration] of registrations) {
           const wrongEditTool = name === "apply_patch" ? !usePatch : (name === "edit" || name === "write") && usePatch
-          if (wrongEditTool || whollyDisabled(permission(registration.tool, name), input.permissions ?? []))
+          if (
+            wrongEditTool ||
+            (registration.deferred && !Flag.CODEMODE_ENABLED) ||
+            whollyDisabled(permission(registration.tool, name), input.permissions ?? [])
+          )
             registrations.delete(name)
         }
-        const execute = yield* codeMode.materialize({ permissions: input.permissions })
+        const direct = new Map(Array.from(registrations).filter(([, registration]) => !registration.deferred))
+        const deferred = new Map(Array.from(registrations).filter(([, registration]) => registration.deferred))
+        const execute =
+          deferred.size > 0 && !whollyDisabled("execute", input.permissions ?? [])
+            ? ExecuteTool.create({
+                registrations: deferred,
+                current: (name) => local.get(name)?.at(-1)?.registration,
+              })
+            : undefined
         return {
           definitions: [
-            ...Array.from(registrations, ([name, registration]) => definition(name, registration.tool)),
+            ...Array.from(direct, ([name, registration]) => definition(name, registration.tool)),
             ...(execute ? [definition("execute", execute)] : []),
           ],
           settle: (input) => {
             if (input.call.name === "execute" && execute) return settleTool(input, execute)
-            const registration = registrations.get(input.call.name)
+            const registration = direct.get(input.call.name)
             if (registration) return settleWith(input, registration.identity)
             return Effect.succeed({
               result: { type: "error", value: `Unknown tool: ${input.call.name}` },
@@ -226,11 +244,11 @@ function whollyDisabled(action: string, rules: PermissionV2.Ruleset) {
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [CodeModeV2.node, ToolOutputStore.node, ToolHooks.node],
+  deps: [ToolOutputStore.node, ToolHooks.node],
 })
 
 export const toolsNode = makeLocationNode({
   service: Tools.Service,
   layer,
-  deps: [CodeModeV2.node, ToolOutputStore.node, ToolHooks.node],
+  deps: [ToolOutputStore.node, ToolHooks.node],
 })

packages/core/test/fixture/mcp-timeout.ts

@@ -4,27 +4,16 @@ import {
   CallToolRequestSchema,
   GetPromptRequestSchema,
   ListPromptsRequestSchema,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
   ListToolsRequestSchema,
-  ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js"
 
-const server = new Server(
-  { name: "timeout", version: "1.0.0" },
-  { capabilities: { prompts: {}, resources: {}, tools: {} } },
-)
+const server = new Server({ name: "timeout", version: "1.0.0" }, { capabilities: { prompts: {}, tools: {} } })
 
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   if (process.env.MCP_TIMEOUT_TARGET === "catalog") await Bun.sleep(100)
   return { tools: [{ name: "slow", inputSchema: { type: "object" } }] }
 })
 server.setRequestHandler(ListPromptsRequestSchema, () => Promise.resolve({ prompts: [{ name: "slow" }] }))
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  if (process.env.MCP_TIMEOUT_TARGET === "resource-catalog") await Bun.sleep(100)
-  return { resources: [{ name: "slow", uri: "test://slow" }] }
-})
-server.setRequestHandler(ListResourceTemplatesRequestSchema, () => Promise.resolve({ resourceTemplates: [] }))
 server.setRequestHandler(CallToolRequestSchema, async () => {
   await Bun.sleep(100)
   return { content: [] }
@@ -33,9 +22,5 @@ server.setRequestHandler(GetPromptRequestSchema, async () => {
   await Bun.sleep(100)
   return { messages: [] }
 })
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-  await Bun.sleep(100)
-  return { contents: [{ uri: request.params.uri, text: "slow" }] }
-})
 
 await server.connect(new StdioServerTransport())

packages/core/test/fixture/mcp.ts

@@ -14,12 +14,15 @@ export const emptyMcpLayer = Layer.succeed(
     instructions: () => Effect.succeed([]),
     prompts: () => Effect.succeed([]),
     prompt: () => Effect.succeed(undefined),
-    resourceCatalog: () => Effect.succeed(MCP.ResourceCatalog.make({ resources: [], templates: [] })),
+    resourceCatalog: () => Effect.succeed(new MCP.ResourceCatalog({ resources: [], templates: [] })),
     readResource: () => Effect.succeed(undefined),
   }),
 )
 
-export const emptyConfigLayer = Layer.succeed(Config.Service, Config.Service.of({ entries: () => Effect.succeed([]) }))
+export const emptyConfigLayer = Layer.succeed(
+  Config.Service,
+  Config.Service.of({ entries: () => Effect.succeed([]) }),
+)
 
 export const testLocationLayer = Layer.succeed(
   Location.Service,

packages/core/test/mcp.test.ts

@@ -3,165 +3,26 @@ import { describe, expect, test } from "bun:test"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js"
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js"
 import { Server } from "@modelcontextprotocol/sdk/server/index.js"
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js"
-import {
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ListResourceTemplatesRequestSchema,
-  ListToolsRequestSchema,
-  ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js"
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js"
 import { ConfigMCP } from "@opencode-ai/core/config/mcp"
-import { Config } from "@opencode-ai/core/config"
-import { Credential } from "@opencode-ai/core/credential"
 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 { Location } from "@opencode-ai/core/location"
 import { MCP } from "@opencode-ai/core/mcp/index"
 import { MCPClient } from "@opencode-ai/core/mcp/client"
 import { PermissionV2 } from "@opencode-ai/core/permission"
-import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { McpTool } from "@opencode-ai/core/tool/mcp"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
-import { Deferred, Effect, Exit, Fiber, Layer, Stream } from "effect"
+import { Deferred, Effect, Fiber, Layer, Stream } from "effect"
 import { testEffect } from "./lib/effect"
-import { location } from "./fixture/location"
 import { settleTool, toolDefinitions, toolIdentity, waitForTool } from "./lib/tool"
 
 let assertion: Deferred.Deferred<PermissionV2.AssertInput> | undefined
 let decision: Effect.Effect<void, PermissionV2.Error> = Effect.void
 let calls = 0
 
-type ResourcePage = {
-  items: Array<{ name: string; uri: string; description?: string; mimeType?: string }>
-  nextCursor?: string
-}
-
-type ResourceTemplatePage = {
-  items: Array<{ name: string; uriTemplate: string; description?: string; mimeType?: string }>
-  nextCursor?: string
-}
-
-function resourceServer(input: { resources?: boolean; listChanged?: boolean } = {}) {
-  return Effect.acquireRelease(
-    Effect.promise(async () => {
-      const state = {
-        resources: [] as ResourcePage["items"],
-        templates: [] as ResourceTemplatePage["items"],
-        resourcePages: undefined as Record<string, ResourcePage> | undefined,
-        templatePages: undefined as Record<string, ResourceTemplatePage> | undefined,
-        contents: [
-          { uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-          { uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-        ] as Array<{ uri: string; text: string; mimeType?: string } | { uri: string; blob: string; mimeType?: string }>,
-        resourceLists: 0,
-        templateLists: 0,
-      }
-      const protocol = new Server(
-        { name: "mcp-resources", version: "1.0.0" },
-        {
-          capabilities: {
-            tools: {},
-            ...(input.resources === false ? {} : { resources: { listChanged: input.listChanged } }),
-          },
-        },
-      )
-      protocol.setRequestHandler(ListToolsRequestSchema, () => Promise.resolve({ tools: [] }))
-      if (input.resources !== false) {
-        protocol.setRequestHandler(ListResourcesRequestSchema, (request) => {
-          state.resourceLists += 1
-          const page = state.resourcePages?.[request.params?.cursor ?? "initial"]
-          return Promise.resolve({ resources: page?.items ?? state.resources, nextCursor: page?.nextCursor })
-        })
-        protocol.setRequestHandler(ListResourceTemplatesRequestSchema, (request) => {
-          state.templateLists += 1
-          const page = state.templatePages?.[request.params?.cursor ?? "initial"]
-          return Promise.resolve({ resourceTemplates: page?.items ?? state.templates, nextCursor: page?.nextCursor })
-        })
-        protocol.setRequestHandler(ReadResourceRequestSchema, () => Promise.resolve({ contents: state.contents }))
-      }
-      const transport = new WebStandardStreamableHTTPServerTransport({
-        sessionIdGenerator: () => crypto.randomUUID(),
-        enableJsonResponse: true,
-      })
-      await protocol.connect(transport)
-      const http = Bun.serve({
-        port: 0,
-        fetch: (request) => transport.handleRequest(request),
-      })
-      return {
-        state,
-        url: http.url.toString(),
-        sendResourceListChanged: () => protocol.sendResourceListChanged(),
-        close: async () => {
-          await protocol.close().catch(() => {})
-          await http.stop(true)
-        },
-      }
-    }),
-    (server) => Effect.promise(server.close),
-  )
-}
-
-function resourceMcpLayer(url: string) {
-  const directory = AbsolutePath.make(import.meta.dir)
-  const unusedIntegration = () => Effect.die("unused integration service")
-  return MCP.layer.pipe(
-    Layer.provide(
-      Layer.mergeAll(
-        Layer.succeed(
-          Config.Service,
-          Config.Service.of({
-            entries: () =>
-              Effect.succeed([
-                new Config.Document({
-                  type: "document",
-                  info: new Config.Info({
-                    mcp: new ConfigMCP.Info({
-                      servers: { resources: new ConfigMCP.Remote({ type: "remote", url, oauth: false }) },
-                    }),
-                  }),
-                }),
-              ]),
-          }),
-        ),
-        Layer.succeed(Location.Service, Location.Service.of(location({ directory }))),
-        Layer.mock(EventV2.Service, {
-          subscribe: () => Stream.never,
-          publish: (definition, data) =>
-            Effect.succeed({
-              id: EventV2.ID.create(),
-              type: definition.type,
-              data,
-            } as EventV2.Payload<typeof definition>),
-        }),
-        Layer.mock(Form.Service, {}),
-        Layer.mock(Integration.Service, {
-          connection: {
-            active: unusedIntegration,
-            resolve: unusedIntegration,
-            key: unusedIntegration,
-            oauth: unusedIntegration,
-            update: unusedIntegration,
-            remove: unusedIntegration,
-          },
-          attempt: {
-            status: unusedIntegration,
-            complete: unusedIntegration,
-            cancel: unusedIntegration,
-          },
-        }),
-        Layer.mock(Credential.Service, {}),
-      ),
-    ),
-  )
-}
-
 const mcp = Layer.mock(MCP.Service, {
   tools: () =>
     Effect.succeed([
@@ -380,163 +241,6 @@ test("applies the configured MCP execution timeout to prompts", async () => {
   await expect(result).rejects.toThrow("Request timed out")
 })
 
-test("applies configured MCP timeouts to resource operations", async () => {
-  const catalog = Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
-          "resource-catalog-timeout",
-          new ConfigMCP.Local({
-            type: "local",
-            command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-timeout.ts")],
-            environment: { MCP_TIMEOUT_TARGET: "resource-catalog" },
-            timeout: new ConfigMCP.Timeout({ catalog: 10 }),
-          }),
-          import.meta.dir,
-        )
-        return yield* connection.resources()
-      }),
-    ),
-  )
-  await expect(catalog).rejects.toThrow("Request timed out")
-
-  const read = Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const connection = yield* MCPClient.connect(
-          "resource-read-timeout",
-          new ConfigMCP.Local({
-            type: "local",
-            command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-timeout.ts")],
-            timeout: new ConfigMCP.Timeout({ execution: 10 }),
-          }),
-          import.meta.dir,
-        )
-        return yield* connection.readResource({ uri: "test://slow" })
-      }),
-    ),
-  )
-  await expect(read).rejects.toThrow("Request timed out")
-})
-
-test("lists, reads, and reports MCP resource changes", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer({ listChanged: true })
-        server.state.resourcePages = {
-          initial: {
-            items: [{ name: "Readme", uri: "docs://readme", description: "Project docs" }],
-            nextCursor: "resources-2",
-          },
-          "resources-2": { items: [{ name: "Logo", uri: "docs://logo", mimeType: "image/png" }] },
-        }
-        server.state.templatePages = {
-          initial: {
-            items: [{ name: "File", uriTemplate: "docs://{path}" }],
-            nextCursor: "templates-2",
-          },
-          "templates-2": { items: [{ name: "Issue", uriTemplate: "issue://{id}", description: "Issue" }] },
-        }
-        const connection = yield* MCPClient.connect(
-          "resources",
-          new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
-          import.meta.dir,
-        )
-
-        expect(yield* connection.resources()).toEqual([
-          { name: "Readme", uri: "docs://readme", description: "Project docs", mimeType: undefined },
-          { name: "Logo", uri: "docs://logo", description: undefined, mimeType: "image/png" },
-        ])
-        expect(yield* connection.resourceTemplates()).toEqual([
-          { name: "File", uriTemplate: "docs://{path}", description: undefined, mimeType: undefined },
-          { name: "Issue", uriTemplate: "issue://{id}", description: "Issue", mimeType: undefined },
-        ])
-        expect(yield* connection.readResource({ uri: "docs://readme" })).toEqual({
-          contents: [
-            { type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-            { type: "blob", uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-          ],
-        })
-
-        const changed = yield* Deferred.make<void>()
-        connection.onResourcesChanged(() => Deferred.doneUnsafe(changed, Exit.void))
-        yield* Effect.promise(server.sendResourceListChanged)
-        yield* Deferred.await(changed)
-      }),
-    ),
-  )
-})
-
-test("skips MCP resource requests when the capability is absent", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer({ resources: false })
-        const connection = yield* MCPClient.connect(
-          "resources",
-          new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false }),
-          import.meta.dir,
-        )
-        expect(yield* connection.resources()).toEqual([])
-        expect(yield* connection.resourceTemplates()).toEqual([])
-        expect(yield* connection.readResource({ uri: "docs://readme" })).toBeUndefined()
-        expect({ resources: server.state.resourceLists, templates: server.state.templateLists }).toEqual({
-          resources: 0,
-          templates: 0,
-        })
-      }),
-    ),
-  )
-})
-
-test("loads and reads MCP resources", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const server = yield* resourceServer()
-        server.state.resources = [{ name: "Readme", uri: "docs://readme" }]
-        server.state.templates = [{ name: "File", uriTemplate: "docs://{path}" }]
-
-        yield* Effect.gen(function* () {
-          const service = yield* MCP.Service
-          expect(yield* service.resourceCatalog()).toEqual({
-            resources: [
-              {
-                server: "resources",
-                name: "Readme",
-                uri: "docs://readme",
-                description: undefined,
-                mimeType: undefined,
-              },
-            ],
-            templates: [
-              {
-                server: "resources",
-                name: "File",
-                uriTemplate: "docs://{path}",
-                description: undefined,
-                mimeType: undefined,
-              },
-            ],
-          })
-
-          server.state.resources = [{ name: "Guide", uri: "docs://guide" }]
-          expect((yield* service.resourceCatalog()).resources.map((resource) => resource.uri)).toEqual(["docs://guide"])
-          expect(yield* service.readResource({ server: "resources", uri: "docs://readme" })).toEqual({
-            server: "resources",
-            uri: "docs://readme",
-            contents: [
-              { type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-              { type: "blob", uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-            ],
-          })
-        }).pipe(Effect.provide(resourceMcpLayer(server.url)))
-      }),
-    ),
-  )
-})
-
 it.effect("advertises MCP output schemas to Code Mode", () =>
   Effect.gen(function* () {
     const registry = yield* ToolRegistry.Service

packages/core/test/plugin.test.ts

@@ -191,7 +191,7 @@ describe("PluginV2", () => {
     }),
   )
 
-  it.effect("registers direct and Code Mode tools through separate plugin domains", () =>
+  it.effect("groups tool names and defers registrations from direct exposure", () =>
     Effect.gen(function* () {
       const plugins = yield* PluginV2.Service
       const registry = yield* ToolRegistry.Service
@@ -205,17 +205,13 @@ describe("PluginV2", () => {
       const plugin = define({
         id: "grouped-tools",
         effect: (ctx) =>
-          Effect.gen(function* () {
-            yield* ctx.tool
-              .transform((draft) => {
-                draft.add("plain", tool("Plain"))
-                draft.add("look/up", tool("Lookup"), { group: "context 7" })
-              })
-              .pipe(Effect.orDie)
-            yield* ctx.codemode
-              .register((draft) => draft.add(["context_7", "search"], tool("Search")))
-              .pipe(Effect.orDie)
-          }),
+          ctx.tool
+            .transform((draft) => {
+              draft.add("plain", tool("Plain"))
+              draft.add("look/up", tool("Lookup"), { group: "context 7" })
+              draft.add("search", tool("Search"), { group: "context 7", deferred: true })
+            })
+            .pipe(Effect.orDie),
       })
 
       yield* plugins.activate([{ plugin }])
@@ -225,9 +221,6 @@ describe("PluginV2", () => {
         "context_7_look_up",
         "execute",
       ])
-
-      yield* plugins.activate([])
-      expect((yield* registry.materialize({ model: testModel })).definitions).toEqual([])
     }),
   )
 

packages/core/test/plugin/fixture.ts

@@ -1,7 +1,6 @@
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { Catalog } from "@opencode-ai/core/catalog"
-import { CodeModeV2 } from "@opencode-ai/core/code-mode"
 import { CommandV2 } from "@opencode-ai/core/command"
 import { Credential } from "@opencode-ai/core/credential"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -44,7 +43,6 @@ export const PluginTestLayer = AppNodeBuilder.build(
     AgentV2.node,
     AISDK.node,
     Catalog.node,
-    CodeModeV2.node,
     CommandV2.node,
     Integration.node,
     PluginRuntime.node,

packages/core/test/plugin/host.ts

@@ -39,9 +39,6 @@ export function host(overrides: Overrides = {}): PluginContext {
       transform: () => Effect.die("unused command.transform"),
       reload: () => Effect.die("unused command.reload"),
     },
-    codemode: overrides.codemode ?? {
-      register: () => Effect.die("unused codemode.register"),
-    },
     event: overrides.event ?? {
       subscribe: () => Stream.empty,
     },

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

@@ -1,10 +1,8 @@
 import { describe, expect } from "bun:test"
 import { Tool } from "@opencode-ai/core/tool/tool"
 import { AgentV2 } from "@opencode-ai/core/agent"
-import { CodeModeV2 } from "@opencode-ai/core/code-mode"
 import type { PermissionV2 } from "@opencode-ai/core/permission"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
@@ -30,9 +28,7 @@ const outputStore = Layer.mock(ToolOutputStore.Service, {
     )
   },
 })
-const registryLayer = AppNodeBuilder.build(LayerNode.group([ToolRegistry.node, CodeModeV2.node]), [
-  [ToolOutputStore.node, outputStore],
-])
+const registryLayer = AppNodeBuilder.build(ToolRegistry.node, [[ToolOutputStore.node, outputStore]])
 const it = testEffect(registryLayer)
 const identity = {
   agent: AgentV2.ID.make("build"),
@@ -57,30 +53,6 @@ const make = (permission?: string) => {
 }
 
 describe("ToolRegistry", () => {
-  it.effect("materializes nested Code Mode sources as execute", () =>
-    Effect.gen(function* () {
-      const codeMode = yield* CodeModeV2.Service
-      const service = yield* ToolRegistry.Service
-      yield* codeMode.register((draft) => draft.add(["opencode", "v2", "echo"], make()))
-
-      const definitions = yield* toolDefinitions(service)
-      expect(definitions.map((tool) => tool.name)).toEqual(["execute"])
-      expect(definitions[0]?.description).toContain("tools.opencode.v2.echo")
-      expect(
-        yield* executeTool(service, {
-          sessionID,
-          ...identity,
-          call: {
-            type: "tool-call",
-            id: "call-code-mode",
-            name: "execute",
-            input: { code: 'return await tools.opencode.v2.echo({ text: "hello" })' },
-          },
-        }),
-      ).toEqual({ type: "text", value: '{\n  "text": "hello"\n}' })
-    }),
-  )
-
   it.effect("filters disabled tools with edit aliases and ordered wildcard precedence", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service

packages/opencode/src/effect/runtime-flags.ts

@@ -40,6 +40,7 @@ export class Service extends ConfigService.Service<Service>()("@opencode/Runtime
   enableExperimentalModels: bool("OPENCODE_ENABLE_EXPERIMENTAL_MODELS"),
   enableQuestionTool: bool("OPENCODE_ENABLE_QUESTION_TOOL"),
   experimentalReferences: enabledByExperimental("OPENCODE_EXPERIMENTAL_REFERENCES"),
+  experimentalBackgroundSubagents: enabledByExperimental("OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS"),
   experimentalLspTy: bool("OPENCODE_EXPERIMENTAL_LSP_TY"),
   experimentalLspTool: enabledByExperimental("OPENCODE_EXPERIMENTAL_LSP_TOOL"),
   experimentalOxfmt: enabledByExperimental("OPENCODE_EXPERIMENTAL_OXFMT"),

packages/opencode/src/server/routes/instance/httpapi/handlers/experimental.ts

@@ -3,6 +3,7 @@ import { Agent } from "@/agent/agent"
 import { Job } from "@/job"
 import { Config } from "@/config/config"
 import { InstanceState } from "@/effect/instance-state"
+import { RuntimeFlags } from "@/effect/runtime-flags"
 import { MCP } from "@/mcp"
 import { Project } from "@/project/project"
 import { Session } from "@/session/session"
@@ -33,9 +34,10 @@ export const experimentalHandlers = HttpApiBuilder.group(InstanceHttpApi, "exper
     const worktreeSvc = yield* Worktree.Service
     const sessions = yield* Session.Service
     const jobs = yield* Job.Service
+    const flags = yield* RuntimeFlags.Service
 
     const capabilities = Effect.fn("ExperimentalHttpApi.capabilities")(function* () {
-      return { backgroundSubagents: true }
+      return { backgroundSubagents: flags.experimentalBackgroundSubagents }
     })
 
     const getConsole = Effect.fn("ExperimentalHttpApi.console")(function* () {
@@ -157,6 +159,7 @@ export const experimentalHandlers = HttpApiBuilder.group(InstanceHttpApi, "exper
     const sessionBackground = Effect.fn("ExperimentalHttpApi.sessionBackground")(function* (ctx: {
       params: { sessionID: SessionID }
     }) {
+      if (!flags.experimentalBackgroundSubagents) return false
       return (yield* jobs.backgroundAll({ sessionID: ctx.params.sessionID, type: "task" })).length > 0
     })
 

packages/opencode/src/tool/task.ts

@@ -1,5 +1,6 @@
 import * as Tool from "./tool"
 import DESCRIPTION from "./task.txt"
+import { ToolJsonSchema } from "./json-schema"
 import { SessionV1 } from "@opencode-ai/core/v1/session"
 import { Job } from "@/job"
 import { Session } from "@/session/session"
@@ -11,6 +12,7 @@ import type { SessionPrompt } from "../session/prompt"
 import { Config } from "@/config/config"
 import { Effect, Exit, Schema, Scope } from "effect"
 import { EffectBridge } from "@/effect/bridge"
+import { RuntimeFlags } from "@/effect/runtime-flags"
 import { Database } from "@opencode-ai/core/database/database"
 
 export interface TaskPromptOps {
@@ -49,6 +51,8 @@ const BaseParameterFields = {
   command: Schema.optional(Schema.String).annotate({ description: "The command that triggered this task" }),
 }
 
+const BaseParameters = Schema.Struct(BaseParameterFields)
+
 export const Parameters = Schema.Struct({
   ...BaseParameterFields,
   background: Schema.optional(Schema.Boolean).annotate({
@@ -82,6 +86,7 @@ export const TaskTool = Tool.define(
     const config = yield* Config.Service
     const sessions = yield* Session.Service
     const scope = yield* Scope.Scope
+    const flags = yield* RuntimeFlags.Service
     const database = yield* Database.Service
 
     const run = Effect.fn("TaskTool.execute")(function* (
@@ -90,6 +95,11 @@ export const TaskTool = Tool.define(
     ) {
       const cfg = yield* config.get()
       const runInBackground = params.background === true
+      if (runInBackground && !flags.experimentalBackgroundSubagents) {
+        return yield* Effect.fail(
+          new Error("Background subagents require OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true"),
+        )
+      }
 
       if (!ctx.extra?.bypassAgentCheck) {
         yield* ctx.ask({
@@ -323,8 +333,11 @@ export const TaskTool = Tool.define(
     })
 
     return {
-      description: [DESCRIPTION, BACKGROUND_DESCRIPTION].join("\n\n"),
+      description: flags.experimentalBackgroundSubagents
+        ? [DESCRIPTION, BACKGROUND_DESCRIPTION].join("\n\n")
+        : DESCRIPTION,
       parameters: Parameters,
+      jsonSchema: flags.experimentalBackgroundSubagents ? undefined : ToolJsonSchema.fromSchema(BaseParameters),
       execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
         run(params, ctx).pipe(Effect.orDie),
     }

packages/opencode/test/cli/run/footer.view.test.tsx

@@ -161,6 +161,7 @@ async function renderFooter(
     currentModel?: RunInput["model"]
     currentVariant?: string
     subagents?: FooterSubagentState
+    backgroundSubagents?: boolean
     width?: number
     height?: number
     state?: Partial<FooterState>
@@ -198,6 +199,7 @@ async function renderFooter(
           subagent={subagents}
           theme={input.theme ?? (() => RUN_THEME_FALLBACK)}
           tuiConfig={config}
+          backgroundSubagents={input.backgroundSubagents ?? true}
           agent="opencode"
           onSubmit={input.onSubmit ?? (() => true)}
           onPermissionReply={() => {}}
@@ -996,6 +998,7 @@ test("direct footer shows editable prompts and additional queued work while runn
           ]}
           theme={() => RUN_THEME_FALLBACK}
           tuiConfig={tuiConfig}
+          backgroundSubagents={true}
           agent="opencode"
           onSubmit={() => true}
           onPermissionReply={() => {}}
@@ -1068,7 +1071,7 @@ test("direct footer shows editable prompts and additional queued work while runn
   }
 })
 
-test("direct footer always offers backgrounding for a foreground subagent", async () => {
+test("direct footer separates a lone context hint from model and command hint", async () => {
   const app = await renderFooter({
     providers: [provider()],
     currentModel: { providerID: "opencode", modelID: "gpt-5" },
@@ -1079,6 +1082,7 @@ test("direct footer always offers backgrounding for a foreground subagent", asyn
       permissions: [],
       questions: [],
     },
+    backgroundSubagents: false,
     width: 160,
   })
 
@@ -1087,8 +1091,8 @@ test("direct footer always offers backgrounding for a foreground subagent", asyn
     const frame = app.captureCharFrame()
 
     expect(frame).toContain("GPT-5")
-    expect(frame).toContain("xhigh · ctrl+b background · ctrl+x down subagents · ctrl+p cmd")
-    expect(frame).toContain("ctrl+b background")
+    expect(frame).toContain("xhigh · ctrl+x down subagents · ctrl+p cmd")
+    expect(frame).not.toContain("ctrl+b background")
     expect(frame).not.toContain("queued")
   } finally {
     app.cleanup()
@@ -1106,6 +1110,7 @@ test("direct footer hides the subagent hint when only completed subagents remain
       permissions: [],
       questions: [],
     },
+    backgroundSubagents: false,
     width: 160,
   })
 

packages/opencode/test/cli/run/runtime.test.ts

@@ -134,6 +134,7 @@ describe("run interactive runtime", () => {
         variant: undefined,
         files: [],
         thinking: false,
+        backgroundSubagents: false,
       },
       {
         createRuntimeLifecycle: async () => {
@@ -232,6 +233,7 @@ describe("run interactive runtime", () => {
         variant: undefined,
         files: [],
         thinking: false,
+        backgroundSubagents: false,
       },
       {
         createRuntimeLifecycle: async () => {
@@ -404,6 +406,7 @@ describe("run interactive runtime", () => {
         variant: undefined,
         files: [],
         thinking: true,
+        backgroundSubagents: false,
       },
       {
         createRuntimeLifecycle: async (input) => {
@@ -493,6 +496,7 @@ describe("run interactive runtime", () => {
         variant: undefined,
         files: [],
         thinking: false,
+        backgroundSubagents: false,
       },
       {
         createRuntimeLifecycle: async (input) => {
@@ -553,6 +557,7 @@ describe("run interactive runtime", () => {
         variant: undefined,
         files: [],
         thinking: false,
+        backgroundSubagents: false,
       },
       {
         createRuntimeLifecycle: async () => {
@@ -598,6 +603,7 @@ describe("run interactive runtime", () => {
         variant: undefined,
         files: [],
         thinking: false,
+        backgroundSubagents: false,
       },
       {
         createRuntimeLifecycle: async (input) => {
@@ -710,6 +716,7 @@ describe("run interactive runtime", () => {
         variant: "low",
         files: [],
         thinking: false,
+        backgroundSubagents: false,
       },
       {
         createRuntimeLifecycle: async (input) => {

packages/opencode/test/effect/runtime-flags.test.ts

@@ -51,6 +51,7 @@ describe("RuntimeFlags", () => {
       expect(flags.enableExperimentalModels).toBe(true)
       expect(flags.enableQuestionTool).toBe(true)
       expect(flags.experimentalReferences).toBe(true)
+      expect(flags.experimentalBackgroundSubagents).toBe(true)
       expect(flags.experimentalLspTy).toBe(false)
       expect(flags.experimentalLspTool).toBe(true)
       expect(flags.experimentalOxfmt).toBe(true)

packages/opencode/test/server/httpapi-exercise/index.ts

@@ -579,10 +579,8 @@ const scenarios: Scenario[] = [
     .at((ctx) => ({ path: "/experimental/session?roots=false&archived=false", headers: ctx.headers() }))
     .json(200, array),
   http.protected.get("/experimental/capabilities", "experimental.capabilities.get").json(200, (body) => {
-    check(
-      typeof body === "object" && body !== null && "backgroundSubagents" in body && body.backgroundSubagents === true,
-      "capabilities should report background subagents as available",
-    )
+    check(typeof body === "object" && body !== null, "capabilities should be an object")
+    check("backgroundSubagents" in body, "capabilities should report background subagents")
   }),
   http.protected
     .post("/experimental/session/{sessionID}/background", "experimental.session.background")

packages/opencode/test/server/session-actions.test.ts

@@ -1,13 +1,12 @@
 import { afterEach, describe, expect, mock } from "bun:test"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { Effect, Fiber, Layer } from "effect"
+import { Effect, Layer } from "effect"
 import { Session as SessionNs } from "@/session/session"
-import { Job } from "@/job"
 import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { pollWithTimeout, testEffect } from "../lib/effect"
+import { testEffect } from "../lib/effect"
 import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
 
-const it = testEffect(Layer.mergeAll(LayerNode.compile(SessionNs.node), LayerNode.compile(Job.node), httpApiLayer))
+const it = testEffect(Layer.mergeAll(LayerNode.compile(SessionNs.node), httpApiLayer))
 
 afterEach(async () => {
   mock.restore()
@@ -15,19 +14,6 @@ afterEach(async () => {
 })
 
 describe("session action routes", () => {
-  it.instance(
-    "reports background subagents as available",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const res = yield* requestInDirectory("/experimental/capabilities", test.directory)
-
-        expect(res.status).toBe(200)
-        expect(yield* res.json).toEqual({ backgroundSubagents: true })
-      }),
-    { git: true },
-  )
-
   it.instance(
     "session routes expose metadata on create, update, get, and fork",
     () =>
@@ -121,33 +107,4 @@ describe("session action routes", () => {
       }),
     { git: true },
   )
-
-  it.instance(
-    "experimental background route backgrounds a synchronous subagent",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const session = yield* Effect.acquireRelease(SessionNs.use.create({}), (created) =>
-          SessionNs.use.remove(created.id).pipe(Effect.ignore),
-        )
-        const jobs = yield* Job.Service
-        const job = yield* jobs.start({ type: "task", run: Effect.never })
-        const waiting = yield* jobs.block({ id: job.id, sessionID: session.id }).pipe(Effect.forkChild)
-
-        const backgrounded = yield* pollWithTimeout(
-          requestInDirectory(`/experimental/session/${session.id}/background`, test.directory, {
-            method: "POST",
-          }).pipe(
-            Effect.flatMap((res) => res.json),
-            Effect.map((value) => (value === true ? true : undefined)),
-          ),
-          "background route never released the synchronous subagent",
-        )
-
-        expect(backgrounded).toBe(true)
-        expect(yield* Fiber.join(waiting)).toMatchObject({ type: "backgrounded", info: { id: job.id } })
-        yield* jobs.cancel(job.id)
-      }),
-    { git: true },
-  )
 })

packages/opencode/test/tool/registry.test.ts

@@ -150,7 +150,7 @@ describe("tool.registry", () => {
     }),
   )
 
-  it.instance("exposes the task background parameter by default", () =>
+  it.instance("hides task background parameter unless experimental background subagents are enabled", () =>
     Effect.gen(function* () {
       const registry = yield* ToolRegistry.Service
       const agent = yield* Agent.Service
@@ -162,9 +162,8 @@ describe("tool.registry", () => {
         agent: build,
       })).find((tool) => tool.id === "task")
 
-      if (!task) throw new Error("task tool not found")
-      const jsonSchema = ToolJsonSchema.fromTool(task)
-      expect((jsonSchema.properties as Record<string, unknown> | undefined)?.background).toBeDefined()
+      expect(task?.jsonSchema).toBeDefined()
+      expect((task?.jsonSchema?.properties as Record<string, unknown> | undefined)?.background).toBeUndefined()
     }),
   )
 

packages/opencode/test/tool/task.test.ts

@@ -34,7 +34,7 @@ const ref = {
   modelID: ModelV2.ID.make("test-model"),
 }
 
-const layer = () =>
+const layer = (flags: Partial<RuntimeFlags.Info> = {}) =>
   LayerNode.compile(
     LayerNode.group([
       Agent.node,
@@ -52,10 +52,11 @@ const layer = () =>
       RuntimeFlags.node,
       Ripgrep.node,
     ]),
-    [[RuntimeFlags.node, RuntimeFlags.layer()]],
+    [[RuntimeFlags.node, RuntimeFlags.layer(flags)]],
   )
 
 const it = testEffect(layer())
+const background = testEffect(layer({ experimentalBackgroundSubagents: true }))
 
 function defer<T>() {
   let resolve!: (value: T | PromiseLike<T>) => void
@@ -455,6 +456,37 @@ describe("tool.task", () => {
     },
   )
 
+  it.instance("rejects background execution when the experiment is disabled", () =>
+    Effect.gen(function* () {
+      const { chat, assistant } = yield* seed()
+      const tool = yield* TaskTool
+      const def = yield* tool.init()
+
+      const exit = yield* def
+        .execute(
+          {
+            description: "inspect bug",
+            prompt: "look into the cache key path",
+            subagent_type: "general",
+            background: true,
+          },
+          {
+            sessionID: chat.id,
+            messageID: assistant.id,
+            agent: "build",
+            abort: new AbortController().signal,
+            extra: { promptOps: stubOps() },
+            messages: [],
+            metadata: () => Effect.void,
+            ask: () => Effect.void,
+          },
+        )
+        .pipe(Effect.exit)
+
+      expect(Exit.isFailure(exit)).toBe(true)
+    }),
+  )
+
   it.instance("backgrounds a running foreground task without restarting it", () =>
     Effect.gen(function* () {
       const jobs = yield* Job.Service
@@ -526,7 +558,7 @@ describe("tool.task", () => {
     }),
   )
 
-  it.instance("execute launches background tasks without waiting for completion", () =>
+  background.instance("execute launches background tasks without waiting for completion", () =>
     Effect.gen(function* () {
       const jobs = yield* Job.Service
       const { chat, assistant } = yield* seed()
@@ -564,7 +596,7 @@ describe("tool.task", () => {
     }),
   )
 
-  it.instance("running task_id reports the existing background task", () =>
+  background.instance("running task_id reports the existing background task", () =>
     Effect.gen(function* () {
       const jobs = yield* Job.Service
       const { chat, assistant } = yield* seed()
@@ -629,7 +661,7 @@ describe("tool.task", () => {
     }),
   )
 
-  it.instance("background tasks complete through the job service", () =>
+  background.instance("background tasks complete through the job service", () =>
     Effect.gen(function* () {
       const jobs = yield* Job.Service
       const { chat, assistant } = yield* seed()
@@ -662,7 +694,7 @@ describe("tool.task", () => {
     }),
   )
 
-  it.instance("background task completion does not wait for the parent async prompt", () =>
+  background.instance("background task completion does not wait for the parent async prompt", () =>
     Effect.gen(function* () {
       const jobs = yield* Job.Service
       const { chat, assistant } = yield* seed()
@@ -700,7 +732,7 @@ describe("tool.task", () => {
     }),
   )
 
-  it.instance("removing the parent session cancels running background tasks", () =>
+  background.instance("removing the parent session cancels running background tasks", () =>
     Effect.gen(function* () {
       const jobs = yield* Job.Service
       const sessions = yield* Session.Service
@@ -739,7 +771,7 @@ describe("tool.task", () => {
     }),
   )
 
-  it.instance("removing the child task session cancels its running background task", () =>
+  background.instance("removing the child task session cancels its running background task", () =>
     Effect.gen(function* () {
       const jobs = yield* Job.Service
       const sessions = yield* Session.Service
@@ -778,7 +810,7 @@ describe("tool.task", () => {
     }),
   )
 
-  it.instance("cancelling the parent run cancels running background tasks", () =>
+  background.instance("cancelling the parent run cancels running background tasks", () =>
     Effect.gen(function* () {
       const jobs = yield* Job.Service
       const runState = yield* SessionRunState.Service

packages/plugin/src/tui.ts

@@ -475,7 +475,6 @@ export type TuiHostSlotMap = {
   }
   sidebar_footer: {
     session_id: string
-    directory: string
   }
 }
 

packages/plugin/src/v2/effect/code-mode.ts

@@ -1,12 +0,0 @@
-import type { Effect, Scope } from "effect"
-import type { AnyTool, RegistrationError } from "./tool.js"
-
-export type Path = readonly [string, ...string[]]
-
-export interface Draft {
-  add(path: Path, tool: AnyTool): void
-}
-
-export interface Domain {
-  readonly register: (source: (draft: Draft) => void) => Effect.Effect<void, RegistrationError, Scope.Scope>
-}

packages/plugin/src/v2/effect/context.ts

@@ -3,7 +3,6 @@ import type { AgentHooks } from "./agent.js"
 import type { AISDKHooks } from "./aisdk.js"
 import type { CatalogHooks } from "./catalog.js"
 import type { CommandHooks } from "./command.js"
-import type { Domain } from "./code-mode.js"
 import type { EventHooks } from "./event.js"
 import type { IntegrationHooks } from "./integration.js"
 import type { PluginDomain } from "./plugin.js"
@@ -18,7 +17,6 @@ export interface PluginContext {
   readonly aisdk: AISDKHooks
   readonly catalog: CatalogHooks
   readonly command: CommandHooks
-  readonly codemode: Domain
   readonly event: EventHooks
   readonly integration: IntegrationHooks
   readonly plugin: PluginDomain

packages/plugin/src/v2/effect/index.ts

@@ -5,7 +5,6 @@ export type { AgentDraft, AgentHooks } from "./agent.js"
 export type { AISDKHooks } from "./aisdk.js"
 export type { CatalogDraft, CatalogHooks, CatalogProviderRecord } from "./catalog.js"
 export type { CommandDraft, CommandHooks } from "./command.js"
-export * as CodeMode from "./code-mode.js"
 export type { EventHooks } from "./event.js"
 export type { IntegrationDraft, IntegrationHooks, IntegrationMethodRegistration } from "./integration.js"
 export type { ReferenceDraft, ReferenceHooks } from "./reference.js"

packages/plugin/src/v2/effect/tool.ts

@@ -246,6 +246,7 @@ export interface ToolExecuteAfterEvent {
 
 export interface RegisterOptions {
   readonly group?: string
+  readonly deferred?: boolean
 }
 
 export interface ToolDraft {

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

@@ -27,7 +27,6 @@ test.each([
   expect(entrypoint.Skill).toBe(Skill)
   expect(Object.keys(entrypoint).sort()).toEqual([
     "Agent",
-    ...(name === "effect" ? ["CodeMode"] : []),
     "Command",
     "Connection",
     "Credential",

packages/protocol/src/groups/mcp.ts

@@ -19,18 +19,4 @@ export const McpGroup = HttpApiGroup.make("server.mcp")
         }),
       ),
   )
-  .add(
-    HttpApiEndpoint.get("mcp.resource.catalog", "/api/mcp/resource", {
-      query: LocationQuery,
-      success: Location.response(Mcp.ResourceCatalog),
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.mcp.resource.catalog",
-          summary: "List MCP resources",
-          description: "Retrieve resources and resource templates from connected MCP servers.",
-        }),
-      ),
-  )
-  .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server and resource routes." }))
+  .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server status routes." }))

packages/protocol/src/groups/session.ts

@@ -269,25 +269,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
           }),
         ),
     )
-    .add(
-      HttpApiEndpoint.post("session.move", "/api/session/:sessionID/move", {
-        params: { sessionID: Session.ID },
-        payload: Schema.Struct({
-          destination: Schema.Struct({ directory: AbsolutePath }),
-          moveChanges: Schema.Boolean.pipe(Schema.optional),
-        }),
-        success: HttpApiSchema.NoContent,
-        error: [SessionNotFoundError, InvalidRequestError],
-      })
-        .middleware(sessionLocationMiddleware)
-        .annotateMerge(
-          OpenApi.annotations({
-            identifier: "v2.session.move",
-            summary: "Move session",
-            description: "Move a session to another project directory, optionally transferring local changes.",
-          }),
-        ),
-    )
     .add(
       HttpApiEndpoint.post("session.prompt", "/api/session/:sessionID/prompt", {
         params: { sessionID: Session.ID },
@@ -363,7 +344,6 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
           text: Schema.String,
           description: Schema.String.pipe(Schema.optional),
           metadata: SessionMessage.Synthetic.fields.metadata,
-          resume: Schema.Boolean.pipe(Schema.optional),
         }),
         success: HttpApiSchema.NoContent,
         error: SessionNotFoundError,

packages/protocol/test/event.test.ts

@@ -4,6 +4,5 @@ import { isOpenCodeEvent } from "../src/groups/event.js"
 test("classifies public events by type", () => {
   expect(isOpenCodeEvent({ type: "server.connected" })).toBe(true)
   expect(isOpenCodeEvent({ type: "mcp.status.changed" })).toBe(true)
-  expect(isOpenCodeEvent({ type: "mcp.resources.changed" })).toBe(true)
   expect(isOpenCodeEvent({ type: "mcp.tools.changed" })).toBe(false)
 })

packages/schema/src/event-manifest.ts

@@ -80,7 +80,6 @@ export const ServerDefinitions = Event.inventory(
   ...InstallationEvent.Definitions,
   ...VcsEvent.Definitions,
   McpEvent.StatusChanged,
-  McpEvent.ResourcesChanged,
   // Shared transitional: V1 contracts the current TUI still consumes during
   // the migration (permission.asked/replied, question.asked, session.error).
   // Remove when the TUI moves to the current permission/question surfaces.

packages/schema/src/index.ts

@@ -9,7 +9,6 @@ export { Form } from "./form.js"
 export { Integration } from "./integration.js"
 export { LLM } from "./llm.js"
 export { Location } from "./location.js"
-export { Mcp } from "./mcp.js"
 export { Model } from "./model.js"
 export { Permission } from "./permission.js"
 export { PermissionSaved } from "./permission-saved.js"

packages/schema/src/mcp-event.ts

@@ -10,13 +10,6 @@ export const ToolsChanged = Event.ephemeral({
   },
 })
 
-export const ResourcesChanged = Event.ephemeral({
-  type: "mcp.resources.changed",
-  schema: {
-    server: Schema.String,
-  },
-})
-
 export const BrowserOpenFailed = Event.ephemeral({
   type: "mcp.browser.open.failed",
   schema: {
@@ -34,4 +27,4 @@ export const StatusChanged = Event.ephemeral({
   },
 })
 
-export const Definitions = Event.inventory(ToolsChanged, ResourcesChanged, StatusChanged)
+export const Definitions = Event.inventory(ToolsChanged, StatusChanged)

packages/schema/src/mcp.ts

@@ -25,9 +25,14 @@ const NeedsClientRegistration = Schema.Struct({
 }).annotate({ identifier: "Mcp.Status.NeedsClientRegistration" })
 
 export type Status = typeof Status.Type
-export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth, NeedsClientRegistration]).pipe(
-  Schema.toTaggedUnion("status"),
-)
+export const Status = Schema.Union([
+  Connected,
+  Pending,
+  Disabled,
+  Failed,
+  NeedsAuth,
+  NeedsClientRegistration,
+]).pipe(Schema.toTaggedUnion("status"))
 
 export interface Server extends Schema.Schema.Type<typeof Server> {}
 export const Server = Schema.Struct({
@@ -37,50 +42,3 @@ export const Server = Schema.Struct({
   // without matching by name, which could collide with provider or plugin integrations.
   integrationID: optional(IntegrationID),
 }).annotate({ identifier: "Mcp.Server" })
-
-export interface Resource extends Schema.Schema.Type<typeof Resource> {}
-export const Resource = Schema.Struct({
-  server: Schema.String,
-  name: Schema.String,
-  uri: Schema.String,
-  description: optional(Schema.String),
-  mimeType: optional(Schema.String),
-}).annotate({ identifier: "Mcp.Resource" })
-
-export interface ResourceTemplate extends Schema.Schema.Type<typeof ResourceTemplate> {}
-export const ResourceTemplate = Schema.Struct({
-  server: Schema.String,
-  name: Schema.String,
-  uriTemplate: Schema.String,
-  description: optional(Schema.String),
-  mimeType: optional(Schema.String),
-}).annotate({ identifier: "Mcp.ResourceTemplate" })
-
-export interface ResourceCatalog extends Schema.Schema.Type<typeof ResourceCatalog> {}
-export const ResourceCatalog = Schema.Struct({
-  resources: Schema.Array(Resource),
-  templates: Schema.Array(ResourceTemplate),
-}).annotate({ identifier: "Mcp.ResourceCatalog" })
-
-export const ResourceContentPart = Schema.Union([
-  Schema.Struct({
-    type: Schema.Literal("text"),
-    uri: Schema.String,
-    text: Schema.String,
-    mimeType: optional(Schema.String),
-  }),
-  Schema.Struct({
-    type: Schema.Literal("blob"),
-    uri: Schema.String,
-    blob: Schema.String,
-    mimeType: optional(Schema.String),
-  }),
-]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "Mcp.ResourceContentPart" }))
-export type ResourceContentPart = typeof ResourceContentPart.Type
-
-export interface ResourceContent extends Schema.Schema.Type<typeof ResourceContent> {}
-export const ResourceContent = Schema.Struct({
-  server: Schema.String,
-  uri: Schema.String,
-  contents: Schema.Array(ResourceContentPart),
-}).annotate({ identifier: "Mcp.ResourceContent" })

packages/schema/test/contract-hygiene.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test"
 import { DateTime, Schema } from "effect"
 import { Agent } from "../src/agent.js"
 import { FileSystem } from "../src/filesystem.js"
-import { Mcp } from "../src/mcp.js"
 import { Model } from "../src/model.js"
 import { Project } from "../src/project.js"
 import { Provider } from "../src/provider.js"
@@ -52,11 +51,6 @@ describe("contract hygiene", () => {
     const identifiers = [
       Agent.Color,
       FileSystem.Submatch,
-      Mcp.Resource,
-      Mcp.ResourceTemplate,
-      Mcp.ResourceCatalog,
-      Mcp.ResourceContentPart,
-      Mcp.ResourceContent,
       Model.Ref,
       Model.Capabilities,
       Model.Cost,

packages/schema/test/event-manifest.test.ts

@@ -51,7 +51,6 @@ describe("public event manifest", () => {
     expect(EventManifest.Latest.get("agent.updated")).toBe(Agent.Event.Updated)
     expect(EventManifest.Latest.get("plugin.updated")).toBe(Plugin.Event.Updated)
     expect(EventManifest.Server.get("mcp.status.changed")).toBe(McpEvent.StatusChanged)
-    expect(EventManifest.Server.get("mcp.resources.changed")).toBe(McpEvent.ResourcesChanged)
     expect(EventManifest.Server.get("session.deleted")).toBe(SessionEvent.Deleted)
     expect(EventManifest.Server.has("mcp.tools.changed")).toBe(false)
     expect(Agent.Event.Updated.durable).toBeUndefined()
@@ -77,7 +76,7 @@ describe("public event manifest", () => {
     expect(Form.Event.Definitions).toEqual([Form.Event.Created, Form.Event.Replied, Form.Event.Cancelled])
     expect(Reference.Event.Definitions).toEqual([Reference.Event.Updated])
     expect(Plugin.Event.Definitions).toEqual([Plugin.Event.Added, Plugin.Event.Updated])
-    expect(McpEvent.Definitions).toEqual([McpEvent.ToolsChanged, McpEvent.ResourcesChanged, McpEvent.StatusChanged])
+    expect(McpEvent.Definitions).toEqual([McpEvent.ToolsChanged, McpEvent.StatusChanged])
     expect(EventManifest.Latest.has("mcp.browser.open.failed")).toBe(false)
     expect(EventManifest.Latest.has("ide.installed")).toBe(false)
     expect(IdeEvent.Definitions).toEqual([IdeEvent.Installed])

packages/schema/test/mcp.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { Mcp } from "../src/mcp.js"
-
-describe("Mcp resources", () => {
-  test("decodes resource catalogs and omits absent metadata", () => {
-    const value = Schema.decodeUnknownSync(Mcp.ResourceCatalog)({
-      resources: [{ server: "docs", name: "Readme", uri: "docs://readme" }],
-      templates: [{ server: "docs", name: "File", uriTemplate: "docs://{path}" }],
-    })
-
-    expect(Schema.encodeSync(Mcp.ResourceCatalog)(value)).toEqual({
-      resources: [{ server: "docs", name: "Readme", uri: "docs://readme" }],
-      templates: [{ server: "docs", name: "File", uriTemplate: "docs://{path}" }],
-    })
-  })
-
-  test("preserves text and base64 blob contents", () => {
-    expect(
-      Schema.decodeUnknownSync(Mcp.ResourceContent)({
-        server: "docs",
-        uri: "docs://readme",
-        contents: [
-          { type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-          { type: "blob", uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-        ],
-      }),
-    ).toEqual({
-      server: "docs",
-      uri: "docs://readme",
-      contents: [
-        { type: "text", uri: "docs://readme", text: "hello", mimeType: "text/plain" },
-        { type: "blob", uri: "docs://logo", blob: "aGVsbG8=", mimeType: "image/png" },
-      ],
-    })
-  })
-})

packages/server/src/handlers/mcp.ts

@@ -6,28 +6,20 @@ import { response } from "../location"
 
 export const McpHandler = HttpApiBuilder.group(Api, "server.mcp", (handlers) =>
   Effect.gen(function* () {
-    return handlers
-      .handle(
-        "mcp.list",
-        Effect.fn(function* () {
-          const service = yield* MCP.Service
-          return yield* response(
-            service
-              .servers()
-              .pipe(
-                Effect.map((servers) =>
-                  servers.map((info) => ({ name: info.name, status: info.status, integrationID: info.integrationID })),
-                ),
+    return handlers.handle(
+      "mcp.list",
+      Effect.fn(function* () {
+        const service = yield* MCP.Service
+        return yield* response(
+          service
+            .servers()
+            .pipe(
+              Effect.map((servers) =>
+                servers.map((info) => ({ name: info.name, status: info.status, integrationID: info.integrationID })),
               ),
-          )
-        }),
-      )
-      .handle(
-        "mcp.resource.catalog",
-        Effect.fn(function* () {
-          const service = yield* MCP.Service
-          return yield* response(service.resourceCatalog())
-        }),
-      )
+            ),
+        )
+      }),
+    )
   }),
 )

packages/server/src/handlers/session.ts

@@ -1,6 +1,5 @@
 import { SessionV2 } from "@opencode-ai/core/session"
 import { InstructionEntry } from "@opencode-ai/core/session/instruction-entry"
-import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
 import { DateTime, Effect, Stream } from "effect"
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
 import { Api } from "../api"
@@ -9,8 +8,8 @@ import {
   ConflictError,
   CommandEvaluationError,
   CommandNotFoundError,
-  InvalidRequestError,
   InvalidCursorError,
+  InvalidRequestError,
   MessageNotFoundError,
   ServiceUnavailableError,
   SessionBusyError,
@@ -25,7 +24,6 @@ const DefaultSessionsLimit = 50
 export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handlers) =>
   Effect.gen(function* () {
     const session = yield* SessionV2.Service
-    const moveSession = yield* MoveSession.Service
 
     return handlers
       .handle(
@@ -203,43 +201,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           return HttpApiSchema.NoContent.make()
         }),
       )
-      .handle(
-        "session.move",
-        Effect.fn(function* (ctx) {
-          yield* moveSession.moveSession({
-            sessionID: ctx.params.sessionID,
-            destination: ctx.payload.destination,
-            moveChanges: ctx.payload.moveChanges,
-          }).pipe(
-            Effect.catchTag("Session.NotFoundError", (error) =>
-              Effect.fail(
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-              ),
-            ),
-            Effect.catchTag("MoveSession.DestinationProjectMismatchError", () =>
-              Effect.fail(new InvalidRequestError({ message: "Destination directory belongs to another project" })),
-            ),
-            Effect.catchTag("MoveSession.ApplyChangesError", () =>
-              Effect.fail(
-                new InvalidRequestError({
-                  message:
-                    "Unable to apply your changes in the destination directory. The files may conflict with existing changes.",
-                }),
-              ),
-            ),
-            Effect.catchTag("MoveSession.CaptureChangesError", (error) =>
-              Effect.fail(new InvalidRequestError({ message: error.message })),
-            ),
-            Effect.catchTag("MoveSession.ResetSourceChangesError", (error) =>
-              Effect.fail(new InvalidRequestError({ message: error.message })),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
       .handle(
         "session.prompt",
         Effect.fn(function* (ctx) {
@@ -368,7 +329,6 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
               text: ctx.payload.text,
               description: ctx.payload.description,
               metadata: ctx.payload.metadata,
-              resume: ctx.payload.resume,
             })
             .pipe(
               Effect.catchTag("Session.NotFoundError", (error) =>

packages/server/src/routes.ts

@@ -8,7 +8,6 @@ import { Observability } from "@opencode-ai/core/observability"
 import { Credential } from "@opencode-ai/core/credential"
 import { PermissionSaved } from "@opencode-ai/core/permission/saved"
 import { PtyTicket } from "@opencode-ai/core/pty/ticket"
-import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
 import { Project } from "@opencode-ai/core/project"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { SessionExecution } from "@opencode-ai/core/session/execution"
@@ -38,7 +37,6 @@ const applicationServices = LayerNode.group([
   httpClient,
   ToolOutputStore.cleanupNode,
   Job.node,
-  MoveSession.node,
   Project.node,
   SessionV2.node,
   PluginRuntime.providerNode,

packages/tui/src/component/dialog-move-session.tsx

@@ -19,9 +19,8 @@ import { Spinner } from "./spinner"
 import { DialogWorkspaceFileChanges } from "./dialog-workspace-file-changes"
 import type { ProjectDirectoriesOutput } from "@opencode-ai/client/promise"
 import { useRoute } from "../context/route"
-import { DialogProjectCopyName } from "./dialog-project-copy-name"
 
-export type MoveSessionSelection = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new"; name: string }
+export type MoveSessionSelection = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new" }
 type ProjectDirectory = ProjectDirectoriesOutput[number]
 
 type DialogMoveSessionProps = {
@@ -292,12 +291,6 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
     if (await removedCurrent(deletingCurrent)) return
   }
 
-  async function create() {
-    const name = await DialogProjectCopyName.show(dialog)
-    if (name === null) return
-    props.onSelect({ type: "new", name })
-  }
-
   const fullHeight = createMemo(() =>
     Math.max(8, Math.min(16, dimensions().height - Math.floor(dimensions().height / 4) - 2)),
   )
@@ -341,7 +334,7 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
                 {
                   command: "dialog.move_session.new",
                   title: "new",
-                  onTrigger: () => void create(),
+                  onTrigger: () => props.onSelect({ type: "new" }),
                 },
                 {
                   command: "dialog.move_session.delete",

packages/tui/src/component/dialog-project-copy-name.tsx

@@ -1,95 +0,0 @@
-import { InputRenderable, TextAttributes } from "@opentui/core"
-import { Slug } from "@opencode-ai/core/util/slug"
-import { createSignal, onMount } from "solid-js"
-import { useTuiConfig } from "../config"
-import { useTheme } from "../context/theme"
-import { useBindings, useCommandShortcut } from "../keymap"
-import { useDialog, type DialogContext } from "../ui/dialog"
-
-export function DialogProjectCopyName(props: { onConfirm: (name: string) => void }) {
-  const dialog = useDialog()
-  const { theme } = useTheme()
-  const tuiConfig = useTuiConfig()
-  const generateShortcut = useCommandShortcut("dialog.project_copy.generate")
-  const [inputTarget, setInputTarget] = createSignal<InputRenderable>()
-  let input: InputRenderable
-
-  function generate() {
-    input.value = Slug.create()
-    input.gotoLineEnd()
-  }
-
-  function confirm() {
-    props.onConfirm(slugify(input.value) || Slug.create())
-  }
-
-  useBindings(() => ({
-    target: inputTarget,
-    enabled: inputTarget() !== undefined,
-    priority: 1,
-    commands: [
-      {
-        name: "dialog.project_copy.generate",
-        title: "Generate project copy name",
-        category: "Dialog",
-        run: generate,
-      },
-    ],
-    bindings: tuiConfig.keybinds.get("dialog.project_copy.generate"),
-  }))
-
-  onMount(() => {
-    dialog.setSize("medium")
-    setTimeout(() => {
-      if (!input || input.isDestroyed) return
-      input.focus()
-    }, 1)
-  })
-
-  return (
-    <box paddingLeft={2} paddingRight={2} gap={1}>
-      <box flexDirection="row" justifyContent="space-between">
-        <text attributes={TextAttributes.BOLD} fg={theme.text}>
-          Name project copy
-        </text>
-        <text fg={theme.textMuted} onMouseUp={() => dialog.clear()}>
-          esc
-        </text>
-      </box>
-      <input
-        ref={(value: InputRenderable) => {
-          input = value
-          setInputTarget(value)
-        }}
-        onSubmit={confirm}
-        placeholder="Project copy name"
-        placeholderColor={theme.textMuted}
-        textColor={theme.text}
-        focusedTextColor={theme.text}
-        cursorColor={theme.text}
-      />
-      <box paddingBottom={1} flexDirection="row" gap={2}>
-        <text fg={theme.text}>
-          enter <span style={{ fg: theme.textMuted }}>submit</span>
-        </text>
-        <text fg={theme.text}>
-          {generateShortcut()} <span style={{ fg: theme.textMuted }}>generate one</span>
-        </text>
-      </box>
-    </box>
-  )
-}
-
-DialogProjectCopyName.show = (dialog: DialogContext) =>
-  new Promise<string | null>((resolve) => {
-    dialog.replace(() => <DialogProjectCopyName onConfirm={resolve} />, () => resolve(null))
-  })
-
-function slugify(input: string) {
-  return input
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+/, "")
-    .replace(/-+$/, "")
-}

packages/tui/src/component/prompt/index.tsx

@@ -218,10 +218,7 @@ export function Prompt(props: PromptProps) {
   const editorContextLabelState = createMemo(() => editor.labelState())
   const [auto, setAuto] = createSignal<AutocompleteRef>()
   const workspace = usePromptWorkspace(props.sessionID)
-  const move = usePromptMove({
-    projectID: () => (props.sessionID ? data.session.get(props.sessionID)?.projectID : undefined) ?? project.project(),
-    sessionID: () => props.sessionID,
-  })
+  const move = usePromptMove({ projectID: project.project, sessionID: () => props.sessionID })
   const [cursorVersion, setCursorVersion] = createSignal(0)
   const currentProviderLabel = createMemo(() => local.model.parsed().provider)
   const connected = useConnected()
@@ -958,13 +955,13 @@ export function Prompt(props: PromptProps) {
     if (workspace.creating() || move.creating()) return false
     if (auto()?.visible) return false
     if (!store.prompt.text) return false
+    const agent = local.agent.current()
+    if (!agent) return false
     const trimmed = store.prompt.text.trim()
     if (trimmed === "exit" || trimmed === "quit" || trimmed === ":q") {
       void exit()
       return true
     }
-    const agent = local.agent.current()
-    if (!agent) return false
     const selectedModel = local.model.current()
     if (!selectedModel) {
       void promptModelWarning()
@@ -994,7 +991,7 @@ export function Prompt(props: PromptProps) {
       const selectedWorkspace = workspace.selection()
       const workspaceID = selectedWorkspace?.type === "existing" ? selectedWorkspace.workspaceID : undefined
 
-      const directory = await move.getDirectory()
+      const directory = await move.getDirectory(store.prompt.text)
       if (move.pending() && !directory) return false
       finishMoveProgress = Boolean(move.progress())
       const location = data.location.default()

packages/tui/src/component/prompt/move.tsx

@@ -4,12 +4,12 @@ import { useTuiPaths } from "../../context/runtime"
 import { errorMessage } from "../../util/error"
 import { useDialog } from "../../ui/dialog"
 import { useSDK } from "../../context/sdk"
+import { useSync } from "../../context/sync"
 import { useToast } from "../../ui/toast"
 import { DialogMoveSession, type MoveSessionSelection } from "../dialog-move-session"
 import { DialogWorkspaceFileChanges } from "../dialog-workspace-file-changes"
 import { useHomeSessionDestination } from "../../routes/home/session-destination"
 import { useProject } from "../../context/project"
-import { useData } from "../../context/data"
 
 function moveReminderText(directory: string) {
   return `<system-reminder>The user has changed the current working directory to "${directory}". This is still the same project but at a possibly new location; take this into account when working with any files from now on.</system-reminder>`
@@ -18,33 +18,38 @@ function moveReminderText(directory: string) {
 export function usePromptMove(input: { projectID: () => string | undefined; sessionID: () => string | undefined }) {
   const dialog = useDialog()
   const sdk = useSDK()
+  const sync = useSync()
   const toast = useToast()
   const homeDestination = useHomeSessionDestination()
   const project = useProject()
-  const data = useData()
   const paths = useTuiPaths()
   const [creating, setCreating] = createSignal(false)
   const [creatingDots, setCreatingDots] = createSignal(3)
   const [progress, setProgress] = createSignal<string>()
 
-  async function create(name: string) {
-    const projectID = await resolveProjectID()
+  async function create(context?: string) {
+    const projectID = input.projectID()
     if (!projectID) return
     setCreating(true)
     setProgress("Creating copy")
     try {
+      const generated = await sdk.client.experimental.projectCopy.generateName(
+        { projectID, context },
+        { throwOnError: true },
+      )
       const result = await sdk.api.projectCopy.create({
         projectID,
         location: { directory: project.instance.directory() || paths.cwd },
         strategy: "git_worktree",
         directory: path.join(paths.worktree, projectID.slice(0, 6)),
-        name,
+        name: generated.data.name,
       })
       const directory = result.directory
       if (!directory) throw new Error("No project copy directory returned")
 
-      // Call a location-based route to make sure it's bootstrapped before moving on.
-      await sdk.api.location.get({ location: { directory } })
+      // Call a location-based route to make sure it's bootstrapped
+      // before moving on
+      await sdk.client.path.get({ directory }, { throwOnError: true })
 
       setProgress("Creating session")
       return directory
@@ -57,14 +62,11 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
     }
   }
 
-  async function open() {
-    const projectID = await resolveProjectID()
-    if (!projectID) {
-      toast.show({ message: "Unable to determine current project", variant: "error" })
-      return
-    }
+  function open() {
+    const projectID = input.projectID()
+    if (!projectID) return
     const sessionID = input.sessionID()
-    const session = sessionID ? await resolveSession(sessionID) : undefined
+    const session = sessionID ? sync.session.get(sessionID) : undefined
     dialog.replace(() => (
       <DialogMoveSession
         projectID={projectID}
@@ -73,8 +75,8 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
           (session
             ? {
                 type: "directory",
-                directory: session.location.directory,
-                subdirectory: !!session.subpath,
+                directory: session.directory,
+                subdirectory: !!session.path,
               }
             : {
                 type: "directory",
@@ -96,13 +98,26 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
     ))
   }
 
+  function sessionContext(sessionID: string) {
+    const session = sync.session.get(sessionID)
+    const messages = (sync.data.message[sessionID] ?? [])
+      .slice(-6)
+      .map((message) =>
+        [
+          message.role + ":",
+          ...(sync.data.part[message.id] ?? []).flatMap((part) => (part.type === "text" ? [part.text] : [])),
+        ].join(" "),
+      )
+    return [session?.title, ...messages].filter(Boolean).join("\n") || undefined
+  }
+
   async function moveExistingSession(sessionID: string, selection: MoveSessionSelection) {
-    const session = await resolveSession(sessionID)
-    const status = await sdk.client.vcs.status({ directory: session?.location.directory }).catch(() => undefined)
+    const session = sync.session.get(sessionID)
+    const status = await sdk.client.vcs.status({ directory: session?.directory }).catch(() => undefined)
     const choice = status?.data?.length ? await DialogWorkspaceFileChanges.show(dialog, status.data) : "no"
     if (!choice) return
     dialog.clear()
-    const directory = selection.type === "new" ? await create(selection.name) : selection.directory
+    const directory = selection.type === "new" ? await create(sessionContext(sessionID)) : selection.directory
     if (!directory) {
       setProgress(undefined)
       dialog.clear()
@@ -110,9 +125,27 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
     }
     setProgress("Moving session")
     try {
-      await sdk.api.session.move({ sessionID, destination: { directory }, moveChanges: choice === "yes" })
-      await sdk.api.session
-        .synthetic({ sessionID, text: moveReminderText(directory), resume: false })
+      await sdk.client.experimental.controlPlane.moveSession(
+        {
+          sessionID,
+          destination: { directory },
+          moveChanges: choice === "yes",
+        },
+        { throwOnError: true },
+      )
+      await sdk.client.session
+        .promptAsync({
+          sessionID,
+          directory,
+          noReply: true,
+          parts: [
+            {
+              type: "text",
+              text: moveReminderText(directory),
+              synthetic: true,
+            },
+          ],
+        })
         .catch(() => undefined)
       dialog.clear()
     } catch (error) {
@@ -124,34 +157,16 @@ export function usePromptMove(input: { projectID: () => string | undefined; sess
     }
   }
 
-  async function resolveProjectID() {
-    const projectID = input.projectID()
-    if (projectID) return projectID
-    const sessionID = input.sessionID()
-    if (sessionID) return (await resolveSession(sessionID))?.projectID
-    return sdk.api.project
-      .current({ location: { directory: project.instance.directory() || paths.cwd } })
-      .then((project) => project.id)
-      .catch(() => undefined)
-  }
-
-  async function resolveSession(sessionID: string) {
-    const session = data.session.get(sessionID)
-    if (session) return session
-    await data.session.refresh(sessionID).catch(() => undefined)
-    return data.session.get(sessionID)
-  }
-
   const pending = createMemo(() => Boolean(homeDestination?.destination()))
   const pendingNew = createMemo(() => homeDestination?.destination()?.type === "new")
 
-  async function getDirectory() {
+  async function getDirectory(context?: string) {
     const value = homeDestination?.destination()
     if (!value) return
     if (value.type === "directory") {
       return value.directory
     }
-    return await create(value.name)
+    return await create(context)
   }
 
   function startSubmit() {

packages/tui/src/config/keybind.ts

@@ -207,7 +207,6 @@ export const Definitions = {
   "dialog.select.end": keybind("end", "Move to last dialog item"),
   "dialog.select.submit": keybind("return", "Submit selected dialog item"),
   "dialog.prompt.submit": keybind("return", "Submit dialog prompt"),
-  "dialog.project_copy.generate": keybind("tab", "Generate project copy name"),
   "dialog.mcp.toggle": keybind("space", "Toggle MCP in MCP dialog"),
   "dialog.move_session.new": keybind("ctrl+m", "New project copy"),
   "dialog.move_session.delete": keybind("ctrl+d", "Delete project copy"),

packages/tui/src/context/data.tsx

@@ -304,12 +304,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           if (store.session.info[event.data.sessionID])
             setStore("session", "info", event.data.sessionID, "title", event.data.title)
           break
-        case "session.moved":
-          if (store.session.info[event.data.sessionID]) {
-            setStore("session", "info", event.data.sessionID, "location", mutable(event.data.location))
-            setStore("session", "info", event.data.sessionID, "subpath", event.data.subpath)
-          }
-          break
         case "session.prompt.promoted": {
           message.update(event.data.sessionID, (draft, index) => {
             const position = index.get(event.data.inputID)

packages/tui/src/context/sync.tsx

@@ -42,6 +42,9 @@ export const {
       provider_default: Record<string, string>
       provider_next: ProviderListResponse
       console_state: ConsoleState
+      capabilities: {
+        experimentalBackgroundSubagents: boolean
+      }
       provider_auth: Record<string, ProviderAuthMethod[]>
       agent: Agent[]
       command: Command[]
@@ -68,6 +71,9 @@ export const {
         connected: [],
       },
       console_state: emptyConsoleState,
+      capabilities: {
+        experimentalBackgroundSubagents: false,
+      },
       provider_auth: {},
       agent: [],
       command: [],

packages/tui/src/feature-plugins/sidebar/footer.tsx

@@ -6,7 +6,7 @@ import { useTuiPaths } from "../../context/runtime"
 
 const id = "internal:sidebar-footer"
 
-function View(props: { api: TuiPluginApi; directory: string }) {
+function View(props: { api: TuiPluginApi; sessionID: string }) {
   const paths = useTuiPaths()
   const theme = () => props.api.theme.current
   const has = createMemo(() =>
@@ -17,8 +17,10 @@ function View(props: { api: TuiPluginApi; directory: string }) {
   const done = createMemo(() => props.api.kv.get("dismissed_getting_started", false))
   const show = createMemo(() => !has() && !done())
   const path = createMemo(() => {
-    const out = abbreviateHome(props.directory, paths.home)
-    const branch = props.directory === props.api.state.path.directory ? props.api.state.vcs?.branch : undefined
+    const session = props.api.state.session.get(props.sessionID)
+    const dir = session?.directory || props.api.state.path.directory || paths.cwd
+    const out = abbreviateHome(dir, paths.home)
+    const branch = session?.directory === props.api.state.path.directory ? props.api.state.vcs?.branch : undefined
     const text = branch ? out + ":" + branch : out
     const list = text.split("/")
     return {
@@ -82,7 +84,7 @@ const tui: TuiPlugin = async (api) => {
     order: 100,
     slots: {
       sidebar_footer(_ctx, props) {
-        return <View api={api} directory={props.directory} />
+        return <View api={api} sessionID={props.session_id} />
       },
     },
   })

packages/tui/src/routes/home/session-destination.tsx

@@ -10,7 +10,7 @@ import {
 import { useSync } from "../../context/sync"
 import { useTuiPaths } from "../../context/runtime"
 
-export type HomeSessionDestination = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new"; name: string }
+export type HomeSessionDestination = { type: "directory"; directory: string; subdirectory: boolean } | { type: "new" }
 
 type Context = {
   destination: Accessor<HomeSessionDestination | undefined>

packages/tui/src/routes/session/sidebar.tsx

@@ -85,12 +85,7 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
         </scrollbox>
 
         <box flexShrink={0} gap={1} paddingTop={1}>
-          <pluginRuntime.Slot
-            name="sidebar_footer"
-            mode="single_winner"
-            session_id={props.sessionID}
-            directory={session()?.location.directory ?? ""}
-          >
+          <pluginRuntime.Slot name="sidebar_footer" mode="single_winner" session_id={props.sessionID}>
             <text fg={theme.textMuted}>
               <span style={{ fg: theme.success }}>•</span> <b>Open</b>
               <span style={{ fg: theme.text }}>

packages/tui/test/cli/tui/data.test.tsx

@@ -108,68 +108,6 @@ test("refreshes resources into reactive getters", async () => {
   }
 })
 
-test("updates session location when moved", async () => {
-  const events = createEventStream()
-  const destination = "/tmp/opencode-moved"
-  const calls = createFetch((url) => {
-    if (url.pathname === "/api/session/ses_test")
-      return json({
-        data: {
-          id: "ses_test",
-          projectID: "proj_test",
-          cost: 0,
-          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-          time: { created: 0, updated: 0 },
-          title: "Test session",
-          location: { directory },
-        },
-      })
-  }, events)
-  let data!: ReturnType<typeof useData>
-  let ready!: () => void
-  const mounted = new Promise<void>((resolve) => {
-    ready = resolve
-  })
-
-  function Probe() {
-    data = useData()
-    onMount(ready)
-    return <box />
-  }
-
-  const app = await testRender(() => (
-    <TestTuiContexts>
-      <SDKProvider client={createClient(calls.fetch)} api={createApi(calls.fetch)}>
-        <ProjectProvider>
-          <DataProvider>
-            <Probe />
-          </DataProvider>
-        </ProjectProvider>
-      </SDKProvider>
-    </TestTuiContexts>
-  ))
-
-  try {
-    await mounted
-    await data.session.refresh("ses_test")
-    emitEvent(events, {
-      id: "evt_moved_1",
-      created: 1,
-      type: "session.moved",
-      durable: durable("ses_test"),
-      data: {
-        sessionID: "ses_test",
-        location: { directory: destination },
-        subpath: "packages/cli",
-      },
-    })
-    await wait(() => data.session.get("ses_test")?.location.directory === destination)
-    expect(data.session.get("ses_test")?.subpath).toBe("packages/cli")
-  } finally {
-    app.renderer.destroy()
-  }
-})
-
 test("restores running manual compaction before applying live deltas", async () => {
   const events = createEventStream()
   const calls = createFetch((url) => {

packages/tui/test/fixture/tui-sdk.ts

@@ -90,7 +90,7 @@ export function createFetch(override?: FetchHandler, events?: ReturnType<typeof
       return json({})
     if (url.pathname === "/config/providers") return json({ providers: {}, default: {} })
     if (url.pathname === "/experimental/console") return json({ consoleManagedProviders: [], switchableOrgCount: 0 })
-    if (url.pathname === "/experimental/capabilities") return json({ backgroundSubagents: true })
+    if (url.pathname === "/experimental/capabilities") return json({ backgroundSubagents: false })
     if (url.pathname === "/path") return json({ home: "", state: "", config: "", worktree, directory })
     if (url.pathname === "/api/location") return json({ directory, project: { id: "proj_test", directory: worktree } })
     if (url.pathname === "/api/project/current") return json({ id: "proj_test", directory: worktree })

packages/web/src/content/docs/ar/cli.mdx

@@ -608,6 +608,7 @@ opencode upgrade v0.1.48
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | تفعيل ميزات Exa التجريبية                    |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | تمكين TY LSP لملفات python                   |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | تفعيل وضع الخطة                              |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | تفعيل مهام subagent في الخلفية               |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | تفعيل نظام الأحداث التجريبي                  |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | تفعيل مسار طلبات LLM الأصلي                  |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | تفعيل تنفيذ بحث الويب بالتوازي               |

packages/web/src/content/docs/bs/cli.mdx

@@ -606,6 +606,7 @@ Ove varijable okruženja omogućavaju eksperimentalne karakteristike koje se mog
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | Omogući eksperimentalne Exa funkcije                    |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | Omogući TY LSP za python datoteke                       |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | Omogući Plan mod                                        |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | Omogući pozadinske zadatke subagenata                   |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | Omogući eksperimentalni sistem događaja                 |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | Omogući nativnu putanju LLM zahtjeva                    |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | Omogući paralelno izvršavanje web pretrage              |

packages/web/src/content/docs/cli.mdx

@@ -725,6 +725,7 @@ These environment variables enable experimental features that may change or be r
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | Enable experimental Exa features        |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | Enable TY LSP for python files          |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | Enable plan mode                        |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | Enable background subagent tasks        |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | Enable experimental event system        |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | Enable native LLM request path          |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | Enable parallel web search execution    |

packages/web/src/content/docs/da/cli.mdx

@@ -609,6 +609,7 @@ Disse miljøvariabler muliggør eksperimentelle funktioner, der kan ændres elle
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | Aktive eksperimenter Exa-funktioner                  |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | Aktiver TY LSP for python-filer                      |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | Aktiver plantilstand                                 |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | Aktiver baggrundsopgaver for subagenter              |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | Aktiver eksperimentelt hændelsessystem               |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | Aktiver native LLM-anmodningssti                     |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | Aktiver parallel udførelse af websøgning             |

packages/web/src/content/docs/de/cli.mdx

@@ -608,6 +608,7 @@ Diese Umgebungsvariablen ermöglichen experimentelle Funktionen, die sich änder
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolescher Wert | Experimentelle Exa-Funktionen aktivieren                  |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolescher Wert | TY LSP für Python-Dateien aktivieren                      |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolescher Wert | Planmodus aktivieren                                      |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolescher Wert | Hintergrundaufgaben für Subagenten aktivieren             |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolescher Wert | Experimentelles Ereignissystem aktivieren                 |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolescher Wert | Nativen LLM-Anfragepfad aktivieren                        |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolescher Wert | Parallele Websuche aktivieren                             |

packages/web/src/content/docs/es/cli.mdx

@@ -608,6 +608,7 @@ Estas variables de entorno habilitan funciones experimentales que pueden cambiar
 | `OPENCODE_EXPERIMENTAL_EXA`                     | booleano | Habilitar funciones experimentales de Exa                  |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | booleano | Habilitar Habilitar TY LSP para archivos python            |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | booleano | Habilitar modo de plan                                     |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | booleano | Habilitar tareas de subagentes en segundo plano            |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | booleano | Habilitar sistema de eventos experimental                  |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | booleano | Habilitar ruta nativa de solicitud LLM                     |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | booleano | Habilitar ejecución paralela de búsqueda web               |

packages/web/src/content/docs/fr/cli.mdx

@@ -609,6 +609,7 @@ Ces variables d'environnement activent des fonctionnalités expérimentales qui
 | `OPENCODE_EXPERIMENTAL_EXA`                     | booléen | Activer les fonctionnalités Exa expérimentales                  |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | booléen | Activer TY LSP pour les fichiers python                         |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | booléen | Activer le mode plan                                            |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | booléen | Activer les tâches de sous-agents en arrière-plan               |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | booléen | Activer le système d'événements expérimental                    |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | booléen | Activer le chemin de requête LLM natif                          |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | booléen | Activer l'exécution parallèle de la recherche web               |

packages/web/src/content/docs/it/cli.mdx

@@ -609,6 +609,7 @@ Queste variabili d'ambiente abilitano funzionalità sperimentali che potrebbero
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | Abilita funzionalità Exa sperimentali                   |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | Abilita TY LSP per i file python                        |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | Abilita plan mode                                       |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | Abilita task subagent in background                     |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | Abilita sistema eventi sperimentale                     |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | Abilita percorso nativo di richiesta LLM                |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | Abilita esecuzione parallela della ricerca web          |

packages/web/src/content/docs/ja/cli.mdx

@@ -608,6 +608,7 @@ OpenCode は環境変数を使用して構成できます。
 | `OPENCODE_EXPERIMENTAL_EXA`                     | ブール値 | 実験的な Exa 機能を有効にする                    |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | ブール値 | python ファイルの TY LSP を有効にする            |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | ブール値 | プランモードを有効にする                         |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | ブール値 | バックグラウンド subagent タスクを有効にする     |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | ブール値 | 実験的なイベントシステムを有効にする             |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | ブール値 | ネイティブ LLM リクエスト経路を有効にする        |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | ブール値 | 並列 Web 検索実行を有効にする                    |

packages/web/src/content/docs/ko/cli.mdx

@@ -608,6 +608,7 @@ OpenCode는 환경 변수로도 구성할 수 있습니다.
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | 실험적 Exa 기능 활성화                      |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | python 파일에 대해 TY LSP 활성화            |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | Plan mode 활성화                            |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | 백그라운드 subagent 작업 활성화             |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | 실험적 이벤트 시스템 활성화                 |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | 네이티브 LLM 요청 경로 활성화               |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | 병렬 웹 검색 실행 활성화                    |

packages/web/src/content/docs/nb/cli.mdx

@@ -609,6 +609,7 @@ Disse miljøvariablene muliggjør eksperimentelle funksjoner som kan endres elle
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolsk | Aktiver eksperimentelle Exa-funksjoner                |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolsk | Aktiver TY LSP for python-filer                       |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolsk | Aktiver planmodus                                     |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolsk | Aktiver bakgrunnsoppgaver for subagenter              |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolsk | Aktiver eksperimentelt hendelsessystem                |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolsk | Aktiver innebygd LLM-forespørselsvei                  |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolsk | Aktiver parallell kjøring av websøk                   |

packages/web/src/content/docs/pl/cli.mdx

@@ -609,6 +609,7 @@ Te zmienne włączają funkcje eksperymentalne, które mogą ulec zmianie lub zo
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | Włącz funkcje eksperymentalne Exa                   |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | Włącz TY LSP dla plików python                      |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | Włącz tryb planowania                               |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | Włącz zadania subagentów w tle                      |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | Włącz eksperymentalny system zdarzeń                |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | Włącz natywną ścieżkę żądań LLM                     |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | Włącz równoległe wykonywanie wyszukiwania web       |

packages/web/src/content/docs/pt-br/cli.mdx

@@ -608,6 +608,7 @@ Essas variáveis de ambiente habilitam recursos experimentais que podem mudar ou
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | Habilitar recursos experimentais do Exa                   |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | Habilitar TY LSP para arquivos python                     |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | Habilitar modo de plano                                   |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | Habilitar tarefas de subagentes em segundo plano          |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | Habilitar sistema de eventos experimental                 |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | Habilitar caminho nativo de requisição LLM                |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | Habilitar execução paralela de busca web                  |

packages/web/src/content/docs/ru/cli.mdx

@@ -609,6 +609,7 @@ opencode можно настроить с помощью переменных с
 | `OPENCODE_EXPERIMENTAL_EXA`                     | логическое значение | Включить экспериментальные функции Exa                 |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | логическое значение | Включить TY LSP для файлов python                      |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | логическое значение | Включить режим плана                                   |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | логическое значение | Включить фоновые задачи субагентов                     |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | логическое значение | Включить экспериментальную систему событий             |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | логическое значение | Включить нативный путь запросов LLM                    |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | логическое значение | Включить параллельное выполнение веб-поиска            |

packages/web/src/content/docs/th/cli.mdx

@@ -610,6 +610,7 @@ OpenCode สามารถกำหนดค่าโดยใช้ตัว
 | `OPENCODE_EXPERIMENTAL_EXA`                     | Boolean | ฟีเจอร์ Exa ทดลอง                              |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | Boolean | เปิดใช้งาน TY LSP สำหรับไฟล์ python            |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | Boolean | เปิดใช้งาน Plan mode                           |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | Boolean | เปิดใช้งานงาน subagent เบื้องหลัง              |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | Boolean | เปิดใช้งานระบบเหตุการณ์ทดลอง                   |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | Boolean | เปิดใช้งานเส้นทางคำขอ LLM แบบ native           |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | Boolean | เปิดใช้งานการค้นหาเว็บแบบขนาน                  |

packages/web/src/content/docs/tr/cli.mdx

@@ -609,6 +609,7 @@ Bu ortam değişkenleri değişebilecek veya kaldırılabilecek deneysel özelli
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | Deneysel Exa özelliklerini etkinleştirin                |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | python dosyaları için TY LSP'yi etkinleştir             |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | Plan modunu etkinleştir                                 |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | Arka plan alt ajan görevlerini etkinleştir              |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | Deneysel olay sistemini etkinleştir                     |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | Yerel LLM istek yolunu etkinleştir                      |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | Paralel web araması yürütmesini etkinleştir             |

packages/web/src/content/docs/zh-cn/cli.mdx

@@ -609,6 +609,7 @@ OpenCode 可以通过环境变量进行配置。
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | 启用实验性 Exa 功能             |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | 为 python 文件启用 TY LSP       |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | 启用计划模式                    |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | 启用后台子代理任务              |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | 启用实验性事件系统              |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | 启用原生 LLM 请求路径           |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | 启用并行 Web 搜索执行           |

packages/web/src/content/docs/zh-tw/cli.mdx

@@ -609,6 +609,7 @@ OpenCode 可以透過環境變數進行設定。
 | `OPENCODE_EXPERIMENTAL_EXA`                     | boolean | 啟用實驗性 Exa 功能             |
 | `OPENCODE_EXPERIMENTAL_LSP_TY`                  | boolean | 為 python 檔案啟用 TY LSP       |
 | `OPENCODE_EXPERIMENTAL_PLAN_MODE`               | boolean | 啟用計畫模式                    |
+| `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS`    | boolean | 啟用背景子代理任務              |
 | `OPENCODE_EXPERIMENTAL_EVENT_SYSTEM`            | boolean | 啟用實驗性事件系統              |
 | `OPENCODE_EXPERIMENTAL_NATIVE_LLM`              | boolean | 啟用原生 LLM 請求路徑           |
 | `OPENCODE_EXPERIMENTAL_PARALLEL`                | boolean | 啟用平行 Web 搜尋執行           |