fix(core): share one tool snapshot per request (#38596)

packages/core/test/codemode/instructions.test.ts

@@ -1,15 +1,12 @@
 import { describe, expect } from "bun:test"
-import { AgentV2 } from "@opencode-ai/core/agent"
 import { CodeMode } from "@opencode-ai/core/codemode"
 import { CodeModeInstructions } from "@opencode-ai/core/codemode/instructions"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Tool } from "@opencode-ai/core/tool/tool"
-import { Effect, Layer, Schema } from "effect"
+import { Effect, Schema } from "effect"
 import { it } from "../lib/effect"
 import { readInitial, readUpdate } from "../lib/instructions"
 
-const agent = AgentV2.Info.make(AgentV2.Info.empty(AgentV2.ID.make("build")))
-
 describe("CodeModeInstructions", () => {
   it.effect("treats equivalent registration orders as an instruction no-op", () => {
     const alpha = Tool.make({
@@ -24,70 +21,46 @@ describe("CodeModeInstructions", () => {
       output: Schema.String,
       execute: () => Effect.succeed({ output: "zeta" }),
     })
-
     const codeModeLayer = AppNodeBuilder.build(CodeMode.node)
-    const layer = Layer.merge(
-      codeModeLayer,
-      AppNodeBuilder.build(CodeModeInstructions.node, [[CodeMode.node, codeModeLayer]]),
-    )
 
     return Effect.gen(function* () {
       const codeMode = yield* CodeMode.Service
-      const instructions = yield* CodeModeInstructions.Service
       const initialized = yield* Effect.scoped(
         Effect.gen(function* () {
           yield* codeMode.register(Tool.registrationEntries({ zeta, alpha }, { namespace: "tools" }))
-          return yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))
+          const materialization = yield* codeMode.materialize()
+          return yield* readInitial(CodeModeInstructions.make(materialization.instructions))
         }),
       )
       const reordered = yield* Effect.scoped(
         Effect.gen(function* () {
           yield* codeMode.register(Tool.registrationEntries({ alpha, zeta }, { namespace: "tools" }))
-          return yield* instructions
-            .load({ id: agent.id, info: agent })
-            .pipe(Effect.flatMap((context) => readUpdate(context, initialized)))
+          const materialization = yield* codeMode.materialize()
+          return yield* readUpdate(CodeModeInstructions.make(materialization.instructions), initialized)
         }),
       )
 
       expect(reordered.changed).toBe(false)
       expect(reordered.text).toBe("")
-    }).pipe(Effect.provide(layer))
+    }).pipe(Effect.provide(codeModeLayer))
   })
 
   it.effect("renders catalog changes and removal", () => {
     let catalog: string | undefined = "Initial Code Mode catalog"
-    const layer = AppNodeBuilder.build(CodeModeInstructions.node, [
-      [
-        CodeMode.node,
-        Layer.mock(CodeMode.Service, {
-          materialize: () => Effect.succeed({ ...(catalog === undefined ? {} : { instructions: catalog }) }),
-          register: () => Effect.void,
-        }),
-      ],
-    ])
 
     return Effect.gen(function* () {
-      const instructions = yield* CodeModeInstructions.Service
-      const initialized = yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))
+      const initialized = yield* readInitial(CodeModeInstructions.make(catalog))
       expect(initialized.text).toBe("Initial Code Mode catalog")
 
       catalog = "Updated Code Mode catalog"
-      expect(
-        yield* instructions
-          .load({ id: agent.id, info: agent })
-          .pipe(Effect.flatMap((context) => readUpdate(context, initialized))),
-      ).toMatchObject({
+      expect(yield* readUpdate(CodeModeInstructions.make(catalog), initialized)).toMatchObject({
         text: "The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.\n\nUpdated Code Mode catalog",
       })
 
       catalog = undefined
-      expect(
-        yield* instructions
-          .load({ id: agent.id, info: agent })
-          .pipe(Effect.flatMap((context) => readUpdate(context, initialized))),
-      ).toMatchObject({
+      expect(yield* readUpdate(CodeModeInstructions.make(catalog), initialized)).toMatchObject({
         text: "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools.",
       })
-    }).pipe(Effect.provide(layer))
+    })
   })
 })

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

@@ -578,7 +578,8 @@ describe("LocationServiceMap", () => {
           const blockedState = yield* update(blocked.path, blockedID)
           expect(blockedState.providers.some((provider) => provider.id === blockedID)).toBe(true)
           expect(blockedState.providers.some((provider) => provider.id === allowedID)).toBe(false)
-          expect(blockedState.tools.map((tool) => tool.name).sort()).toEqual([
+          const blockedTools = blockedState.tools.map((tool) => tool.name)
+          expect(blockedTools.filter((name) => name !== "execute").sort()).toEqual([
             "edit",
             "glob",
             "grep",
@@ -595,7 +596,9 @@ describe("LocationServiceMap", () => {
           const allowedState = yield* update(allowed.path, allowedID)
           expect(allowedState.providers.some((provider) => provider.id === allowedID)).toBe(true)
           expect(allowedState.providers.some((provider) => provider.id === blockedID)).toBe(false)
-          expect(allowedState.tools.map((tool) => tool.name).sort()).toEqual([
+          const allowedTools = allowedState.tools.map((tool) => tool.name)
+          expect(blockedTools.includes("execute")).toBe(allowedTools.includes("execute"))
+          expect(allowedTools.filter((name) => name !== "execute").sort()).toEqual([
             "edit",
             "glob",
             "grep",

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

@@ -97,6 +97,7 @@ const plugins = Layer.mock(PluginSupervisor.Service, { flush: Effect.void })
 const tools = Layer.mock(ToolRegistry.Service, {
   snapshot: () =>
     Effect.succeed({
+      codeModeInstructions: "Captured Code Mode catalog",
       definitions: [ToolDefinition.make({ name: "lookup", description: "Lookup", inputSchema: { type: "object" } })],
       execute: () => Effect.die(new Error("unused")),
     }),
@@ -285,13 +286,14 @@ it.effect("generates from fresh settled Session context without durable mutation
     expect(requests[0]?.system.map((part) => part.text)).toContain("Initial context")
     expect(requests[0]?.http?.headers).toMatchObject({ "X-Session-Id": sessionID })
     expect(requests[0]?.providerOptions).toMatchObject({ openai: { promptCacheKey: sessionID } })
-    expect(
-      requests[0]?.messages.flatMap((message) =>
-        message.role === "system"
-          ? message.content.flatMap((content) => (content.type === "text" ? [content.text] : []))
-          : [],
-      ),
-    ).toEqual(["Changed context"])
+    const instructionUpdates = requests[0]?.messages.flatMap((message) =>
+      message.role === "system"
+        ? message.content.flatMap((content) => (content.type === "text" ? [content.text] : []))
+        : [],
+    )
+    expect(instructionUpdates).toHaveLength(1)
+    expect(instructionUpdates?.[0]).toContain("Changed context")
+    expect(instructionUpdates?.[0]).toContain("Captured Code Mode catalog")
     expect(userTexts(requests[0])).toEqual(["Existing durable context", "Summarize privately"])
     expect(
       requests[0]?.messages.flatMap((message) =>

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

@@ -533,6 +533,7 @@ describe("ToolRegistry", () => {
         .pipe(Scope.provide(scope))
       const toolSet = yield* service.snapshot()
       const execute = toolSet.definitions.find((tool) => tool.name === "execute")
+      expect(toolSet.codeModeInstructions).toContain("tools.echo")
       expect(execute?.description).toContain("confined Code Mode runtime")
       expect(execute?.description).not.toContain("Echo text")
       yield* Scope.close(scope, Exit.void)

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

@@ -43,6 +43,7 @@ import * as SessionRunnerLLM from "@opencode-ai/core/session/runner/llm"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { SessionUsage } from "@opencode-ai/core/session/usage"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
+import { CodeMode } from "@opencode-ai/core/codemode"
 import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { SystemPromptPlugin } from "@opencode-ai/core/plugin/system-prompt"
@@ -368,6 +369,12 @@ const pluginSupervisor = Layer.succeed(
     flush: Effect.suspend(() => pluginFlushHook),
   }),
 )
+let codeModeMaterializations: ReadonlyArray<CodeMode.Materialization> = []
+let codeModeMaterializationCount = 0
+const codeMode = Layer.mock(CodeMode.Service, {
+  register: () => Effect.void,
+  materialize: () => Effect.sync(() => codeModeMaterializations[codeModeMaterializationCount++] ?? {}),
+})
 const promptCatalog = Layer.mock(Catalog.Service, {
   provider: {
     get: () => Effect.succeed(undefined),
@@ -405,6 +412,7 @@ const runnerLayer = AppNodeBuilder.build(SessionRunnerLLM.node, [
   [McpInstructions.node, mcpInstructions],
   [ToolOutputStore.node, toolOutputStore],
   [PluginSupervisor.node, pluginSupervisor],
+  [CodeMode.node, codeMode],
 ])
 const execution = Layer.effect(
   SessionExecution.Service,
@@ -464,6 +472,7 @@ const it = testEffect(
       [Config.node, config],
       [ToolOutputStore.node, toolOutputStore],
       [PluginSupervisor.node, pluginSupervisor],
+      [CodeMode.node, codeMode],
     ],
   ),
 )
@@ -512,6 +521,8 @@ const setup = Effect.gen(function* () {
   systemLoadHook = Effect.void
   modelResolveHook = Effect.void
   pluginFlushHook = Effect.void
+  codeModeMaterializations = []
+  codeModeMaterializationCount = 0
   currentModel = model
   skillBaselines.clear()
   responses = undefined
@@ -823,6 +834,45 @@ const verifyPartialFlushOnInterruption = (kind: FragmentKind) =>
   })
 
 describe("SessionRunnerLLM", () => {
+  it.effect("uses one Code Mode materialization per request for instructions and execution", () =>
+    Effect.gen(function* () {
+      const executed: string[] = []
+      const execute = (name: string) =>
+        Tool.make({
+          description: `Execute ${name}`,
+          input: Schema.Struct({}),
+          output: Schema.String,
+          execute: () => Effect.sync(() => executed.push(name)).pipe(Effect.as({ output: name })),
+        })
+      const session = yield* setup
+      codeModeMaterializations = [
+        { instructions: "Code Mode catalog A", tool: execute("A") },
+        { instructions: "Code Mode catalog B", tool: execute("B") },
+        { instructions: "Code Mode catalog C", tool: execute("C") },
+        { instructions: "Code Mode catalog D", tool: execute("D") },
+      ]
+      yield* admit(session, "Use Code Mode")
+      responses = [reply.tool("call-execute", "execute", {}), reply.stop()]
+
+      yield* session.resume(sessionID)
+
+      expect(requests).toHaveLength(2)
+      expect(codeModeMaterializationCount).toBe(2)
+      expect(requests[0]?.system.some((part) => part.text.includes("Code Mode catalog A"))).toBe(true)
+      expect(requests[0]?.system.some((part) => part.text.includes("Code Mode catalog B"))).toBe(false)
+      expect(requests[0]?.tools.find((tool) => tool.name === "execute")?.description).toBe("Execute A")
+      expect(executed).toEqual(["A"])
+      expect(requests[1]?.tools.find((tool) => tool.name === "execute")?.description).toBe("Execute B")
+      expect(
+        requests[1]?.messages.some(
+          (message) =>
+            message.role === "system" &&
+            message.content.some((part) => part.type === "text" && part.text.includes("Code Mode catalog B")),
+        ),
+      ).toBe(true)
+    }),
+  )
+
   it.effect("applies session context hooks without exposing unavailable tools", () =>
     Effect.gen(function* () {
       const session = yield* setup