fix(core): preserve admitted tool names

packages/core/src/codemode/tool.ts

@@ -155,7 +155,7 @@ function runtime(
 ) {
   const tools: Record<string, Tool.Tool<never>> = {}
   for (const [name, registration] of registrations) {
-    const child = definition(registration)
+    const child = definition(name, registration)
     const path = qualifiedName(registration)
     tools[path] = Tool.make({
       description: child.description,

packages/core/src/file-mutation.ts

@@ -48,13 +48,15 @@ export const readText = Effect.fn("FileMutation.readText")(function* (files: Fil
   return Bom.decodeBytes((yield* files.read(target)).bytes)
 })
 
-export const syncTextBom = Effect.fn("FileMutation.syncTextBom")((files: Files, target: string, bom: boolean) =>
-  Effect.gen(function* () {
-    const synced = Bom.syncBytes((yield* files.read(target)).bytes, bom)
-    if (synced.bytes) yield* files.write(target, synced.bytes)
-    return synced.text
-  }).pipe(Effect.uninterruptible),
-)
+export const syncTextBom = Effect.fn("FileMutation.syncTextBom")(function* (
+  files: Files,
+  target: string,
+  bom: boolean,
+) {
+  const synced = Bom.syncBytes((yield* files.read(target)).bytes, bom)
+  if (synced.bytes) yield* files.write(target, synced.bytes)
+  return synced.text
+})
 
 /** Share transaction locks across Location graphs that address the same file. */
 const transactionLocks = KeyedMutex.makeUnsafe<string>()
@@ -68,10 +70,15 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const environment = yield* Environment.Service
+    const locks = KeyedMutex.makeUnsafe<string>()
     const withLock: Interface["withLock"] = (targets) => (effect) =>
       [...new Set(targets.map(FSUtil.resolve))]
         .sort()
         .reduceRight((result, target) => transactionLocks.withLock(target)(result), effect)
+    const withTargetLock =
+      (target: Target) =>
+      <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        locks.withLock(target.absolute)(Effect.uninterruptible(effect))
 
     const writeResult = (target: Target, existed: boolean): WriteResult => ({
       operation: "write",
@@ -81,32 +88,36 @@ const layer = Layer.effect(
     })
 
     const write = Effect.fn("FileMutation.write")((input: WriteInput) =>
-      Effect.gen(function* () {
-        const existed = yield* environment.files.stat(input.target.absolute).pipe(
-          Effect.as(true),
-          Effect.catchTag("Environment.NotFound", () => Effect.succeed(false)),
-        )
-        yield* environment.files.write(
-          input.target.absolute,
-          typeof input.content === "string" ? new TextEncoder().encode(input.content) : input.content,
-        )
-        return writeResult(input.target, existed)
-      }).pipe(Effect.uninterruptible),
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const existed = yield* environment.files.stat(input.target.absolute).pipe(
+            Effect.as(true),
+            Effect.catchTag("Environment.NotFound", () => Effect.succeed(false)),
+          )
+          yield* environment.files.write(
+            input.target.absolute,
+            typeof input.content === "string" ? new TextEncoder().encode(input.content) : input.content,
+          )
+          return writeResult(input.target, existed)
+        }),
+      ),
     )
 
     const writeTextPreservingBom = Effect.fn("FileMutation.writeTextPreservingBom")((input: TextWriteInput) =>
-      Effect.gen(function* () {
-        const next = Bom.split(input.content)
-        const current = yield* environment.files.read(input.target.absolute, { offset: 0, length: 3 }).pipe(
-          Effect.map((result) => result.bytes),
-          Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)),
-        )
-        yield* environment.files.write(
-          input.target.absolute,
-          new TextEncoder().encode(Bom.join(next.text, Boolean(current && Bom.has(current)) || next.bom)),
-        )
-        return writeResult(input.target, current !== undefined)
-      }).pipe(Effect.uninterruptible),
+      withTargetLock(input.target)(
+        Effect.gen(function* () {
+          const next = Bom.split(input.content)
+          const current = yield* environment.files.read(input.target.absolute, { offset: 0, length: 3 }).pipe(
+            Effect.map((result) => result.bytes),
+            Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)),
+          )
+          yield* environment.files.write(
+            input.target.absolute,
+            new TextEncoder().encode(Bom.join(next.text, Boolean(current && Bom.has(current)) || next.bom)),
+          )
+          return writeResult(input.target, current !== undefined)
+        }),
+      ),
     )
 
     return Service.of({ withLock, write, writeTextPreservingBom })

packages/core/src/tool.ts

@@ -213,8 +213,8 @@ const layer = Layer.effect(
               definitions: [
                 ...Array.from(direct)
                   .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-                  .map(([, tool]) => definition(tool)),
-                ...(codemodeTool ? [definition(codemodeTool)] : []),
+                  .map(([name, tool]) => definition(name, tool)),
+                ...(codemodeTool ? [definition("execute", codemodeTool)] : []),
               ],
               execute: (input: {
                 readonly sessionID: SessionSchema.ID

packages/core/src/tool/plugin/write.ts

@@ -69,43 +69,34 @@ export const Plugin = {
                 id: context.id,
               }
               const target = yield* mutation.resolve({ path: input.path, kind: "file" })
-              return yield* fileMutation.withLock([target.absolute])(
-                Effect.gen(function* () {
-                  const external = target.externalDirectory
-                  if (external)
-                    yield* permission.assert({
-                      ...LocationMutation.externalDirectoryPermission(external),
-                      sessionID: context.sessionID,
-                      agent: context.agent,
-                      source,
-                    })
-                  const current = yield* FileMutation.readText(environment.files, target.absolute).pipe(
-                    Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)),
-                  )
-                  const next = Bom.split(input.content)
-                  const preview = fileDiff(
-                    target.resource,
-                    current?.text ?? "",
-                    next.text,
-                    current ? "modified" : "added",
-                  )
-                  yield* permission.assert({
-                    action: "edit",
-                    resources: [target.resource],
-                    save: ["*"],
-                    metadata: { files: [preview] },
-                    sessionID: context.sessionID,
-                    agent: context.agent,
-                    source,
-                  })
-                  const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content })
-                  const bom = (yield* FileMutation.readText(environment.files, target.absolute)).bom
-                  if (yield* formatter.file(target.absolute)) {
-                    yield* FileMutation.syncTextBom(environment.files, target.absolute, bom)
-                  }
-                  return result
-                }),
+              const external = target.externalDirectory
+              if (external)
+                yield* permission.assert({
+                  ...LocationMutation.externalDirectoryPermission(external),
+                  sessionID: context.sessionID,
+                  agent: context.agent,
+                  source,
+                })
+              const current = yield* FileMutation.readText(environment.files, target.absolute).pipe(
+                Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)),
               )
+              const next = Bom.split(input.content)
+              const preview = fileDiff(target.resource, current?.text ?? "", next.text, current ? "modified" : "added")
+              yield* permission.assert({
+                action: "edit",
+                resources: [target.resource],
+                save: ["*"],
+                metadata: { files: [preview] },
+                sessionID: context.sessionID,
+                agent: context.agent,
+                source,
+              })
+              const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content })
+              const bom = (yield* FileMutation.readText(environment.files, target.absolute)).bom
+              if (yield* formatter.file(target.absolute)) {
+                yield* FileMutation.syncTextBom(environment.files, target.absolute, bom)
+              }
+              return result
             }).pipe(
               Effect.map((output) => ({ output, content: toModelOutput(output) })),
               Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })),

packages/core/src/tool/runtime.ts

@@ -3,8 +3,8 @@ import { Tool } from "@opencode-ai/schema/tool"
 import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec"
 import { Effect, JsonSchema, Schema } from "effect"
 
-export const definition = (tool: Tool.Info<any, any>): ToolDefinition => ({
-  name: effectiveName(tool),
+export const definition = (name: string, tool: Tool.Info<any, any>): ToolDefinition => ({
+  name,
   description: tool.description,
   inputSchema: inputJsonSchema(tool.input),
   ...(tool.output === undefined ? {} : { outputSchema: outputJsonSchema(tool.output) }),
@@ -199,10 +199,3 @@ const stringify = (value: unknown) => {
     return String(value)
   }
 }
-
-const normalizedName = (tool: Tool.Info) => tool.name.replace(/[^a-zA-Z0-9_-]/g, "_")
-
-const effectiveName = (tool: Tool.Info) =>
-  tool.options?.namespace === undefined
-    ? normalizedName(tool)
-    : `${tool.options.namespace.replaceAll(".", "_")}_${normalizedName(tool)}`

packages/core/test/file-mutation.test.ts

@@ -109,6 +109,49 @@ describe("FileMutation", () => {
     ),
   )
 
+  it.live("serializes concurrent writes to the same absolute target", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const targetPath = path.join(directory, "shared.txt")
+        yield* Effect.promise(() => fs.writeFile(targetPath, "initial"))
+        const firstStarted = yield* Deferred.make<void>()
+        const releaseFirst = yield* Deferred.make<void>()
+        const secondStarted = yield* Deferred.make<void>()
+        let writes = 0
+        const filesystem = instrumentWrites((write) =>
+          Effect.gen(function* () {
+            writes++
+            if (writes === 1) {
+              yield* Deferred.succeed(firstStarted, undefined)
+              yield* Deferred.await(releaseFirst)
+            } else {
+              yield* Deferred.succeed(secondStarted, undefined)
+            }
+            yield* write
+          }),
+        )
+
+        yield* Effect.gen(function* () {
+          const mutation = yield* LocationMutation.Service
+          const files = yield* FileMutation.Service
+          const firstPlan = yield* mutation.resolve({ path: "shared.txt" })
+          const secondPlan = yield* mutation.resolve({ path: "shared.txt" })
+          const first = yield* files.write({ target: firstPlan, content: "first" }).pipe(Effect.forkChild)
+          yield* Deferred.await(firstStarted)
+          const second = yield* files.write({ target: secondPlan, content: "second" }).pipe(Effect.forkChild)
+          yield* Effect.yieldNow
+          expect(yield* Deferred.isDone(secondStarted)).toBe(false)
+
+          yield* Deferred.succeed(releaseFirst, undefined)
+          yield* Deferred.await(secondStarted)
+          yield* Fiber.join(first)
+          yield* Fiber.join(second)
+          expect(yield* Effect.promise(() => fs.readFile(targetPath, "utf8"))).toBe("second")
+        }).pipe(provide(directory, filesystem))
+      }),
+    ),
+  )
+
   it.live("shares transaction locks across Location service instances", () =>
     withTmp((directory) =>
       Effect.gen(function* () {
@@ -159,4 +202,56 @@ describe("FileMutation", () => {
       }).pipe(provide(directory)),
     ),
   )
+
+  it.live("allows distinct absolute targets to proceed independently", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const releaseFirst = yield* Deferred.make<void>()
+        const secondFinished = yield* Deferred.make<void>()
+        const secondPath = path.join(directory, "second.txt")
+        let writes = 0
+        const filesystem = instrumentWrites((write) =>
+          ++writes === 1
+            ? Deferred.succeed(firstStarted, undefined).pipe(
+                Effect.andThen(Deferred.await(releaseFirst)),
+                Effect.andThen(write),
+              )
+            : write.pipe(Effect.andThen(Deferred.succeed(secondFinished, undefined))),
+        )
+
+        yield* Effect.gen(function* () {
+          const mutation = yield* LocationMutation.Service
+          const files = yield* FileMutation.Service
+          const firstPlan = yield* mutation.resolve({ path: "first.txt" })
+          const secondPlan = yield* mutation.resolve({ path: "second.txt" })
+          const first = yield* files.write({ target: firstPlan, content: "first" }).pipe(Effect.forkChild)
+          yield* Deferred.await(firstStarted)
+          const second = yield* files.write({ target: secondPlan, content: "second" }).pipe(Effect.forkChild)
+          yield* Deferred.await(secondFinished)
+          expect(yield* Effect.promise(() => fs.readFile(secondPath, "utf8"))).toBe("second")
+
+          yield* Deferred.succeed(releaseFirst, undefined)
+          yield* Fiber.join(first)
+          yield* Fiber.join(second)
+        }).pipe(provide(directory, filesystem))
+      }),
+    ),
+  )
 })
+
+function instrumentWrites(run: <E>(write: Effect.Effect<void, E>, target: string) => Effect.Effect<void, E>) {
+  return Layer.effect(
+    Environment.Service,
+    Effect.gen(function* () {
+      const environment = yield* Environment.Service
+      return Environment.Service.of({
+        ...environment,
+        files: {
+          ...environment.files,
+          write: (target, content) => run(environment.files.write(target, content), target),
+        },
+      })
+    }),
+  ).pipe(Layer.provide(LayerNode.compile(Environment.node)))
+}

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

@@ -146,6 +146,25 @@ describe("Tool", () => {
     }),
   )
 
+  it.effect("advertises the admitted direct lookup identity", () =>
+    Effect.gen(function* () {
+      const service = yield* Tool.Service
+      const tool = {
+        ...make(),
+        name: "send.message",
+        options: { namespace: "slack.admin", codemode: false },
+      }
+      yield* service.transform((draft) => draft.add(tool))
+      tool.name = "renamed"
+
+      const snapshot = yield* service.snapshot()
+      expect(snapshot.definitions.map((definition) => definition.name)).toEqual(["slack_admin_send_message", "execute"])
+      expect((yield* snapshot.execute(call("slack_admin_send_message"))).content).toEqual([
+        { type: "text", text: "slack_admin_send_message" },
+      ])
+    }),
+  )
+
   it.effect("snapshots external tools with missing input schemas", () =>
     Effect.gen(function* () {
       const service = yield* Tool.Service

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

@@ -14,7 +14,7 @@ test("tools are structural values", async () => {
   }
   const tool: Info = config
 
-  expect(definition(tool)).toEqual({
+  expect(definition(tool.name, tool)).toEqual({
     name: "foreign",
     description: "Foreign tool",
     inputSchema: {
@@ -43,7 +43,7 @@ test("Effect tool schemas use exact optional keys and flatten compatible constra
     execute: () => Effect.succeed({ content: "unused" }),
   }
 
-  expect(definition(tool).inputSchema).toEqual({
+  expect(definition(tool.name, tool).inputSchema).toEqual({
     type: "object",
     properties: {
       offset: { type: "integer", minimum: 0 },
@@ -63,7 +63,7 @@ test("Effect tool schemas inline named child schemas", () => {
     execute: () => Effect.succeed({ content: "unused" }),
   }
 
-  expect(definition(tool).inputSchema).toEqual({
+  expect(definition(tool.name, tool).inputSchema).toEqual({
     type: "object",
     properties: {
       child: {
@@ -89,8 +89,8 @@ test("Effect tool schemas resolve escaped definition names", () => {
     execute: () => Effect.succeed({ content: "unused" }),
   }
 
-  expect(JSON.stringify(definition(tool).inputSchema)).not.toContain("$ref")
-  expect(JSON.stringify(definition(tool).inputSchema)).not.toContain("$defs")
+  expect(JSON.stringify(definition(tool.name, tool).inputSchema)).not.toContain("$ref")
+  expect(JSON.stringify(definition(tool.name, tool).inputSchema)).not.toContain("$defs")
 })
 
 test("portable schemas validate and describe typed tools", async () => {
@@ -129,7 +129,7 @@ test("portable schemas validate and describe typed tools", async () => {
     execute: ({ count }) => Effect.succeed({ output: count + 1 }),
   })
 
-  expect(definition(tool)).toEqual({
+  expect(definition(tool.name, tool)).toEqual({
     name: "portable",
     description: "Portable tool",
     inputSchema: { type: "object", properties: { count: { type: "string" } } },
@@ -194,7 +194,7 @@ test("raw JSON schemas are render-only and omitted output means model-only", asy
     execute: (input) => Effect.succeed({ content: JSON.stringify(input) }),
   })
 
-  expect(definition(tool)).toEqual({
+  expect(definition(tool.name, tool)).toEqual({
     name: "raw",
     description: "Raw tool",
     inputSchema: { type: "object", properties: { value: { type: "string" } } },
@@ -213,7 +213,7 @@ test("missing external input schemas fall back to an empty schema", () => {
     execute: () => Effect.succeed({ content: "unused" }),
   } as unknown as Info
 
-  expect(definition(tool)).toEqual({
+  expect(definition(tool.name, tool)).toEqual({
     name: "external",
     description: "External tool",
     inputSchema: {},

packages/core/test/tool-write.test.ts

@@ -1,7 +1,7 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Deferred, Effect, Fiber, Layer } from "effect"
+import { Effect, Layer } from "effect"
 import { FileMutation } from "@opencode-ai/core/file-mutation"
 import { Formatter } from "@opencode-ai/core/formatter"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -13,7 +13,6 @@ import { Permission } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { Tool } from "@opencode-ai/core/tool"
-import { EditTool } from "@opencode-ai/core/tool/plugin/edit"
 import { WriteTool } from "@opencode-ai/core/tool/plugin/write"
 import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
@@ -27,25 +26,10 @@ const writeToolNode = makeLocationNode({
   deps: [Tool.node, LocationMutation.node, FileMutation.node, Environment.node, Formatter.node, Permission.node],
 })
 
-const editToolNode = makeLocationNode({
-  name: "test/edit-tool-plugin",
-  layer: Layer.effectDiscard(registerToolPlugin(EditTool.Plugin)),
-  deps: [
-    Tool.node,
-    LocationMutation.node,
-    FileMutation.node,
-    Environment.node,
-    Formatter.node,
-    Location.node,
-    Permission.node,
-  ],
-})
-
 const sessionID = Session.ID.make("ses_write_tool_test")
 const assertions: Permission.AssertInput[] = []
 const writes: string[] = []
 let formatFile = (_target: string): Effect.Effect<boolean> => Effect.succeed(false)
-let afterPermission = (_input: Permission.AssertInput): Effect.Effect<void> => Effect.void
 let denyAction: string | undefined
 
 const permission = Layer.succeed(
@@ -53,7 +37,6 @@ const permission = Layer.succeed(
   Permission.Service.of({
     assert: (input) =>
       Effect.sync(() => assertions.push(input)).pipe(
-        Effect.andThen(Effect.suspend(() => afterPermission(input))),
         Effect.andThen(
           input.action === denyAction
             ? Effect.fail(
@@ -82,7 +65,6 @@ const reset = () => {
   assertions.length = 0
   writes.length = 0
   formatFile = () => Effect.succeed(false)
-  afterPermission = () => Effect.void
   denyAction = undefined
 }
 
@@ -101,11 +83,7 @@ const environment = Layer.effect(
   }),
 ).pipe(Layer.provide(LayerNode.compile(Environment.node)))
 
-const withTool = <A, E, R>(
-  directory: string,
-  body: (registry: Tool.Interface) => Effect.Effect<A, E, R>,
-  options?: { edit?: boolean },
-) => {
+const withTool = <A, E, R>(directory: string, body: (registry: Tool.Interface) => Effect.Effect<A, E, R>) => {
   const activeLocation = Layer.succeed(
     Location.Service,
     Location.Service.of(location({ directory: AbsolutePath.make(directory) })),
@@ -115,13 +93,7 @@ const withTool = <A, E, R>(
   }).pipe(
     Effect.provide(
       AppNodeBuilder.build(
-        LayerNode.group([
-          Tool.node,
-          LocationMutation.node,
-          FileMutation.node,
-          writeToolNode,
-          ...(options?.edit ? [editToolNode] : []),
-        ]),
+        LayerNode.group([Tool.node, Tool.node, LocationMutation.node, FileMutation.node, writeToolNode]),
         [
           [Environment.node, environment],
           [Location.node, activeLocation],
@@ -139,12 +111,6 @@ const call = (input: typeof WriteTool.Input.Type, id = "call-write") => ({
   call: { type: "tool-call" as const, id, name: "write", input },
 })
 
-const editCall = (input: typeof EditTool.Input.Type, id = "call-edit") => ({
-  sessionID,
-  ...toolIdentity,
-  call: { type: "tool-call" as const, id, name: "edit", input },
-})
-
 const it = testEffect(Layer.empty)
 
 describe("WriteTool", () => {
@@ -454,59 +420,4 @@ describe("WriteTool", () => {
         ),
     ),
   )
-
-  it.live("serializes write and edit transactions across Location service instances", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        const target = path.join(tmp.path, "shared.txt")
-        return Effect.gen(function* () {
-          yield* Effect.promise(() => fs.writeFile(target, "initial"))
-          const formatting = yield* Deferred.make<void>()
-          const releaseFormatting = yield* Deferred.make<void>()
-          const editApproved = yield* Deferred.make<void>()
-          let formats = 0
-          formatFile = () =>
-            ++formats === 1
-              ? Deferred.succeed(formatting, undefined).pipe(
-                  Effect.andThen(Deferred.await(releaseFormatting)),
-                  Effect.as(false),
-                )
-              : Effect.succeed(false)
-          afterPermission = (input) =>
-            input.source?.id === "call-serialized-edit" && input.action === "edit"
-              ? Deferred.succeed(editApproved, undefined).pipe(Effect.asVoid)
-              : Effect.void
-
-          const write = yield* withTool(
-            tmp.path,
-            (registry) =>
-              executeTool(registry, call({ path: "shared.txt", content: "before" }, "call-serialized-write")),
-            { edit: true },
-          ).pipe(Effect.forkChild)
-          yield* Deferred.await(formatting)
-          const edit = yield* withTool(
-            tmp.path,
-            (registry) =>
-              executeTool(
-                registry,
-                editCall({ path: "shared.txt", oldString: "before", newString: "after" }, "call-serialized-edit"),
-              ),
-            { edit: true },
-          ).pipe(Effect.forkChild)
-          yield* Effect.yieldNow
-          expect(yield* Deferred.isDone(editApproved)).toBe(false)
-
-          yield* Deferred.succeed(releaseFormatting, undefined)
-          expect((yield* Fiber.join(write)).status).toBe("completed")
-          expect((yield* Fiber.join(edit)).status).toBe("completed")
-          expect(yield* Deferred.isDone(editApproved)).toBe(true)
-          expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("after")
-        })
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
 })