fix(core): key mutation locks by file

.github/workflows/publish.yml

@@ -124,66 +124,12 @@ jobs:
 
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
-          name: opencode-preview-cli-unsigned
+          name: opencode-preview-cli
           path: packages/cli/dist/cli-*
 
     outputs:
       version: ${{ needs.version.outputs.version }}
 
-  sign-cli-macos:
-    needs: build-cli
-    runs-on: macos-26
-    if: github.repository == 'anomalyco/opencode'
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-
-      - uses: apple-actions/import-codesign-certs@8f3fb608891dd2244cdab3d69cd68c0d37a7fe93 # v2.0.0
-        with:
-          keychain: build
-          p12-file-base64: ${{ secrets.APPLE_CERTIFICATE }}
-          p12-password: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-
-      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
-        with:
-          name: opencode-preview-cli-unsigned
-          path: packages/cli/dist
-
-      - name: Sign macOS CLI binaries
-        run: |
-          identity=$(security find-identity -v -p codesigning build.keychain | sed -n 's/.*"\(Developer ID Application:.*\)"/\1/p' | head -n 1)
-          if [ -z "$identity" ]; then
-            echo "Developer ID Application identity not found"
-            exit 1
-          fi
-
-          found=0
-          for file in packages/cli/dist/cli-darwin-*/bin/opencode2; do
-            if [ ! -f "$file" ]; then
-              continue
-            fi
-            found=1
-            codesign \
-              --force \
-              --timestamp \
-              --options runtime \
-              --entitlements packages/cli/script/entitlements.plist \
-              --sign "$identity" \
-              "$file"
-            codesign --verify --deep --strict --verbose=4 "$file"
-            codesign --display --requirements - "$file"
-          done
-
-          if [ "$found" -eq 0 ]; then
-            echo "No macOS CLI binaries found"
-            exit 1
-          fi
-
-      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: opencode-preview-cli
-          path: packages/cli/dist/cli-*
-          if-no-files-found: error
-
   build-node-cli:
     needs: version
     if: github.repository == 'anomalyco/opencode'
@@ -525,7 +471,6 @@ jobs:
     needs:
       - version
       - build-cli
-      - sign-cli-macos
       - build-node-cli
       - sign-cli-windows
       - build-electron

packages/cli/script/entitlements.plist

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>com.apple.security.cs.allow-jit</key>
-    <true/>
-    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
-    <true/>
-    <key>com.apple.security.cs.disable-executable-page-protection</key>
-    <true/>
-    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
-    <true/>
-    <key>com.apple.security.cs.disable-library-validation</key>
-    <true/>
-</dict>
-</plist>

packages/cli/src/acp/event.ts

@@ -1,4 +1,4 @@
-import type { AgentSideConnection, PromptResponse, SessionUpdate } from "@agentclientprotocol/sdk"
+import type { AgentSideConnection, PromptResponse } from "@agentclientprotocol/sdk"
 import type {
   EventSubscribeOutput,
   OpenCodeClient,
@@ -37,34 +37,6 @@ export type TurnStart =
   | { readonly type: "skill"; readonly id: string }
   | { readonly type: "compaction"; readonly id: string }
 
-export const ChildSessionUpdatesCapability = "opencode/child-session-updates"
-export const ChildSessionUpdateMethod = "opencode/session/child_update"
-
-type ChildSessionUpdateBase = {
-  readonly rootSessionId: string
-  readonly childSessionId: string
-  readonly parentSessionId: string
-  readonly depth: number
-  readonly title?: string
-}
-
-type ChildSessionEvent =
-  | { readonly type: "update"; readonly update: SessionUpdate }
-  | {
-      readonly type: "status"
-      readonly status: "created" | "running" | "completed" | "failed" | "interrupted"
-      readonly error?: { readonly type: string; readonly message: string }
-    }
-
-export type ChildSessionUpdate = ChildSessionUpdateBase & ChildSessionEvent
-
-type ChildSession = {
-  readonly id: string
-  readonly parentID: string
-  readonly depth: number
-  readonly title?: string
-}
-
 function emptyToolState(): ToolState {
   return { name: "tool", input: {}, metadata: {}, content: [] }
 }
@@ -78,13 +50,8 @@ export async function streamTurn(input: {
   readonly writeTextFile: boolean
   readonly submit: (signal: AbortSignal) => Promise<unknown>
   readonly control: TurnControl
-  readonly childSessionUpdate?: (update: ChildSessionUpdate) => Promise<void>
-  readonly connectionSignal?: AbortSignal
-  readonly sessionSignal?: AbortSignal
 }): Promise<PromptResponse> {
   const streamController = new AbortController()
-  const connectionAbort = () => streamController.abort()
-  input.connectionSignal?.addEventListener("abort", connectionAbort, { once: true })
   const stream = input.client.event.subscribe({ signal: streamController.signal })[Symbol.asyncIterator]()
   const connected = await stream.next()
   if (connected.done) throw new Error("event stream disconnected before prompt admission")
@@ -95,101 +62,47 @@ export async function streamTurn(input: {
   let finish: SessionMessageAssistant["finish"]
   let executionError: { readonly type: string; readonly message: string } | undefined
   const tools = new Map<string, ToolState>()
-  const children = new Map<string, ChildSession>()
-  const openChildren = new Set<string>()
-  let handedOff = false
 
-  const notifyChild = async (child: ChildSession, value: ChildSessionEvent) => {
-    if (!input.childSessionUpdate) return
-    await input
-      .childSessionUpdate({
-        rootSessionId: input.sessionID,
-        childSessionId: child.id,
-        parentSessionId: child.parentID,
-        depth: child.depth,
-        ...(child.title ? { title: child.title } : {}),
-        ...value,
-      })
-      .catch(() => {})
-  }
+  const update = (value: Parameters<Connection["sessionUpdate"]>[0]["update"]) =>
+    input.connection.sessionUpdate({ sessionId: input.sessionID, update: value })
 
-  const updateSession = async (value: SessionUpdate, child: ChildSession | undefined, mode: "turn" | "background") => {
-    const projected = child ? projectChildUpdate(value, child) : value
-    if (mode === "turn" && (!child || !input.childSessionUpdate)) {
-      await input.connection.sessionUpdate({ sessionId: input.sessionID, update: projected })
-    }
-    if (child) await notifyChild(child, { type: "update", update: projected })
-  }
-
-  const consume = async (mode: "turn" | "background") => {
+  const consume = async () => {
     while (!streamController.signal.aborted) {
       const next = await stream.next()
       if (next.done) throw new Error("event stream disconnected during prompt execution")
       const event = next.value
-      if (event.type === "session.created") {
-        const parentID = event.data.info.parentID
-        if (!parentID) continue
-        const parent = parentID === input.sessionID ? undefined : children.get(parentID)
-        if ((mode === "turn" && parentID === input.sessionID) || parent) {
-          const child = {
-            id: event.data.sessionID,
-            parentID,
-            depth: parent ? parent.depth + 1 : 1,
-            title: event.data.info.title,
-          }
-          children.set(child.id, child)
-          openChildren.add(child.id)
-          await notifyChild(child, { type: "status", status: "created" })
-        }
-        continue
-      }
-
-      const eventSessionID = sessionIDFromEvent(event)
-      const child = eventSessionID ? children.get(eventSessionID) : undefined
-      const send = (update: SessionUpdate) => updateSession(update, child, mode)
-      if (mode === "background" && !child) continue
-
-      if (event.type === "permission.asked" && (event.data.sessionID === input.sessionID || child)) {
-        const tool = event.data.source?.id ? tools.get(toolKey(event.data.sessionID, event.data.source.id)) : undefined
+      if (event.type === "permission.asked" && event.data.sessionID === input.sessionID) {
+        const tool = event.data.source?.id ? tools.get(event.data.source.id) : undefined
         await replyPermission({
           client: input.client,
           connection: input.connection,
           event,
-          sessionID: event.data.sessionID,
-          clientSessionID: input.sessionID,
+          sessionID: input.sessionID,
           cwd: input.cwd,
           tool,
-          ...(child ? { toolCallPrefix: child.id, titlePrefix: child.title } : {}),
         })
         continue
       }
-      if (event.type === "form.created" && (event.data.form.sessionID === input.sessionID || child)) {
+      if (event.type === "form.created" && event.data.form.sessionID === input.sessionID) {
         await input.client.form
-          .cancel({ sessionID: event.data.form.sessionID, formID: event.data.form.id })
-          .catch(() => input.client.session.interrupt({ sessionID: event.data.form.sessionID }).catch(() => {}))
+          .cancel({ sessionID: input.sessionID, formID: event.data.form.id })
+          .catch(() => input.client.session.interrupt({ sessionID: input.sessionID }).catch(() => {}))
         continue
       }
-      if (!eventSessionID || (eventSessionID !== input.sessionID && !child)) continue
+      if (!("sessionID" in event.data) || event.data.sessionID !== input.sessionID) continue
       if (matchesStart(event, input.start)) {
         started = true
         continue
       }
       if (!started) continue
 
-      if (event.type === "session.execution.started") {
-        if (child) {
-          await notifyChild(child, { type: "status", status: "running" })
-        }
-        continue
-      }
-
       if (event.type === "session.step.started") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
+        assistantMessageID = event.data.assistantMessageID
         continue
       }
       if (event.type === "session.text.delta") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
-        await send({
+        assistantMessageID = event.data.assistantMessageID
+        await update({
           sessionUpdate: "agent_message_chunk",
           messageId: event.data.assistantMessageID,
           content: { type: "text", text: event.data.delta },
@@ -197,8 +110,8 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.reasoning.delta") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
-        await send({
+        assistantMessageID = event.data.assistantMessageID
+        await update({
           sessionUpdate: "agent_thought_chunk",
           messageId: event.data.assistantMessageID,
           content: { type: "text", text: event.data.delta },
@@ -206,14 +119,9 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.input.started") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
-        tools.set(toolKey(event.data.sessionID, event.data.id), {
-          name: event.data.name,
-          input: {},
-          metadata: {},
-          content: [],
-        })
-        await send({
+        assistantMessageID = event.data.assistantMessageID
+        tools.set(event.data.id, { name: event.data.name, input: {}, metadata: {}, content: [] })
+        await update({
           sessionUpdate: "tool_call",
           ...pendingToolCall({
             toolCallId: event.data.id,
@@ -225,12 +133,11 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.called") {
-        if (!child) assistantMessageID = event.data.assistantMessageID
-        const key = toolKey(event.data.sessionID, event.data.id)
-        const current = tools.get(key) ?? emptyToolState()
+        assistantMessageID = event.data.assistantMessageID
+        const current = tools.get(event.data.id) ?? emptyToolState()
         current.input = event.data.input
-        tools.set(key, current)
-        await send({
+        tools.set(event.data.id, current)
+        await update({
           sessionUpdate: "tool_call_update",
           ...runningToolUpdate({
             toolCallId: event.data.id,
@@ -242,10 +149,10 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.progress") {
-        const current = tools.get(toolKey(event.data.sessionID, event.data.id))
+        const current = tools.get(event.data.id)
         if (!current) continue
         current.metadata = event.data.metadata
-        await send({
+        await update({
           sessionUpdate: "tool_call_update",
           ...runningToolUpdate({
             toolCallId: event.data.id,
@@ -257,9 +164,8 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.success") {
-        const key = toolKey(event.data.sessionID, event.data.id)
-        const current = tools.get(key) ?? emptyToolState()
-        tools.delete(key)
+        const current = tools.get(event.data.id) ?? emptyToolState()
+        tools.delete(event.data.id)
         await syncEditedFiles({
           connection: input.connection,
           writeTextFile: input.writeTextFile,
@@ -269,7 +175,7 @@ export async function streamTurn(input: {
           toolInput: current.input,
           metadata: event.data.metadata ?? {},
         }).catch(() => {})
-        await send({
+        await update({
           sessionUpdate: "tool_call_update",
           ...completedToolUpdate({
             toolCallId: event.data.id,
@@ -282,10 +188,9 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.tool.failed") {
-        const key = toolKey(event.data.sessionID, event.data.id)
-        const current = tools.get(key) ?? emptyToolState()
-        tools.delete(key)
-        await send({
+        const current = tools.get(event.data.id) ?? emptyToolState()
+        tools.delete(event.data.id)
+        await update({
           sessionUpdate: "tool_call_update",
           ...errorToolUpdate({
             toolCallId: event.data.id,
@@ -300,33 +205,13 @@ export async function streamTurn(input: {
         continue
       }
       if (event.type === "session.step.ended") {
-        if (!child) {
-          assistantMessageID = event.data.assistantMessageID
-          finish = event.data.finish
-        }
-        continue
-      }
-      if (event.type === "session.execution.succeeded") {
-        if (!child) return "succeeded" as const
-        openChildren.delete(child.id)
-        await notifyChild(child, { type: "status", status: "completed" })
-        if (mode === "background" && openChildren.size === 0) return "succeeded" as const
-        continue
-      }
-      if (event.type === "session.execution.interrupted") {
-        if (!child) return "interrupted" as const
-        openChildren.delete(child.id)
-        await notifyChild(child, { type: "status", status: "interrupted" })
-        if (mode === "background" && openChildren.size === 0) return "interrupted" as const
+        assistantMessageID = event.data.assistantMessageID
+        finish = event.data.finish
         continue
       }
+      if (event.type === "session.execution.succeeded") return "succeeded" as const
+      if (event.type === "session.execution.interrupted") return "interrupted" as const
       if (event.type === "session.execution.failed") {
-        if (child) {
-          openChildren.delete(child.id)
-          await notifyChild(child, { type: "status", status: "failed", error: event.data.error })
-          if (mode === "background" && openChildren.size === 0) return "failed" as const
-          continue
-        }
         executionError = event.data.error
         return "failed" as const
       }
@@ -334,13 +219,7 @@ export async function streamTurn(input: {
     return "interrupted" as const
   }
 
-  const completed = consume("turn")
-  const closeStream = async () => {
-    streamController.abort()
-    input.connectionSignal?.removeEventListener("abort", connectionAbort)
-    input.sessionSignal?.removeEventListener("abort", connectionAbort)
-    await stream.return?.(undefined).catch(() => {})
-  }
+  const completed = consume()
   try {
     await input.submit(control.admission.signal).catch((error) => {
       if (!control.cancelled) throw error
@@ -354,13 +233,6 @@ export async function streamTurn(input: {
       }
     }
     const terminal = await completed
-    if (input.childSessionUpdate && openChildren.size > 0 && !input.sessionSignal?.aborted) {
-      handedOff = true
-      input.sessionSignal?.addEventListener("abort", connectionAbort, { once: true })
-      void consume("background")
-        .catch(() => {})
-        .finally(closeStream)
-    }
     const assistant = assistantMessageID
       ? await input.client.session
           .message({ sessionID: input.sessionID, messageID: assistantMessageID })
@@ -378,38 +250,11 @@ export async function streamTurn(input: {
     await completed.catch(() => {})
     throw error
   } finally {
-    if (!handedOff) await closeStream()
+    streamController.abort()
+    await stream.return?.(undefined).catch(() => {})
   }
 }
 
-function sessionIDFromEvent(event: EventSubscribeOutput) {
-  if ("sessionID" in event.data && typeof event.data.sessionID === "string") return event.data.sessionID
-  if (event.type === "form.created") return event.data.form.sessionID
-  return undefined
-}
-
-function toolKey(sessionID: string, id: string) {
-  return `${sessionID}:${id}`
-}
-
-function projectChildUpdate(update: SessionUpdate, child: ChildSession) {
-  const projected = { ...update }
-  projected._meta = {
-    ...projected._meta,
-    "opencode/child-session": {
-      id: child.id,
-      parentID: child.parentID,
-      depth: child.depth,
-      ...(child.title ? { title: child.title } : {}),
-    },
-  }
-  if (projected.sessionUpdate === "tool_call" || projected.sessionUpdate === "tool_call_update") {
-    projected.toolCallId = `${child.id}:${projected.toolCallId}`
-    if (projected.title && child.title) projected.title = `${child.title}: ${projected.title}`
-  }
-  return projected
-}
-
 export async function replayMessages(
   connection: Pick<AgentSideConnection, "sessionUpdate">,
   sessionID: string,

packages/cli/src/acp/permission.ts

@@ -20,28 +20,20 @@ export async function replyPermission(input: {
   readonly connection: Connection
   readonly event: PermissionEvent
   readonly sessionID: string
-  readonly clientSessionID?: string
   readonly cwd: string
   readonly tool?: Tool
-  readonly toolCallPrefix?: string
-  readonly titlePrefix?: string
 }) {
   const toolName = input.tool?.name ?? input.event.data.action
   const toolInput = { ...input.event.data.metadata, ...input.tool?.input }
   const previews = await permissionPreviews(toolName, toolInput, input.cwd)
-  const toolCallID = input.event.data.source?.id ?? input.event.data.id
-  const title = permissionTitle(toolName, toolInput, previews)
   const result = await input.connection
     .requestPermission({
-      sessionId: input.clientSessionID ?? input.sessionID,
+      sessionId: input.sessionID,
       toolCall: {
         ...pendingToolCall({
-          toolCallId: input.toolCallPrefix ? `${input.toolCallPrefix}:${toolCallID}` : toolCallID,
+          toolCallId: input.event.data.source?.id ?? input.event.data.id,
           toolName,
-          state: {
-            input: toolInput,
-            title: prefixedTitle(input.titlePrefix, title),
-          },
+          state: { input: toolInput, title: permissionTitle(toolName, toolInput, previews) },
           cwd: input.cwd,
         }),
         locations: permissionLocations(toolName, toolInput, input.event.data.resources, input.cwd, previews),
@@ -59,12 +51,6 @@ export async function replyPermission(input: {
   })
 }
 
-function prefixedTitle(prefix: string | undefined, title: string | undefined) {
-  if (!prefix) return title
-  if (!title) return prefix
-  return `${prefix}: ${title}`
-}
-
 export async function syncEditedFiles(input: {
   readonly connection: Partial<Pick<AgentSideConnection, "writeTextFile">>
   readonly writeTextFile: boolean

packages/cli/src/acp/service.ts

@@ -43,21 +43,13 @@ import { OPENCODE_VERSION } from "../version"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { buildConfigOptions, parseModelSelection, type ConfigOptionProvider } from "./config-option"
 import { promptContentToParts } from "./content"
-import {
-  ChildSessionUpdateMethod,
-  ChildSessionUpdatesCapability,
-  replayMessages,
-  streamTurn,
-  type ChildSessionUpdate,
-  type TurnControl,
-  type TurnStart,
-} from "./event"
+import { replayMessages, streamTurn, type TurnControl, type TurnStart } from "./event"
 import { ACPError } from "./error"
 
 export const AuthMethodID = "opencode-login"
 
 type Connection = Pick<AgentSideConnection, "sessionUpdate" | "requestPermission"> &
-  Partial<Pick<AgentSideConnection, "writeTextFile" | "extNotification" | "signal">>
+  Partial<Pick<AgentSideConnection, "writeTextFile">>
 
 type Catalog = {
   readonly providers: ConfigOptionProvider[]
@@ -72,7 +64,6 @@ type Catalog = {
 type Attached = {
   readonly id: string
   readonly cwd: string
-  readonly abort: AbortController
   catalog: Catalog
   model: ModelRef
   modeID: string
@@ -109,7 +100,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
   const catalogs = new Map<string, Promise<Catalog>>()
   const registeredMcp = new Map<string, Set<string>>()
   const active = new Map<string, TurnControl>()
-  const capabilities = { writeTextFile: false, childSessionUpdates: false }
+  const capabilities = { writeTextFile: false }
 
   const catalog = (cwd: string) => {
     const cached = catalogs.get(cwd)
@@ -128,19 +119,11 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
     throw new ACPError.SessionNotFoundError({ sessionId: sessionID })
   }
 
-  const detach = (sessionID: string) => {
-    sessions.get(sessionID)?.abort.abort()
-    sessions.delete(sessionID)
-    registeredMcp.delete(sessionID)
-  }
-
   const attach = async (session: SessionInfo, cwd: string, mcpServers: readonly McpServer[]) => {
     const currentCatalog = await catalog(cwd)
-    sessions.get(session.id)?.abort.abort()
     const state: Attached = {
       id: session.id,
       cwd,
-      abort: new AbortController(),
       catalog: currentCatalog,
       model: session.model ?? currentCatalog.defaultModel,
       modeID: session.agent ?? currentCatalog.defaultModeID,
@@ -178,7 +161,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
   return {
     initialize: async (params) => {
       capabilities.writeTextFile = params.clientCapabilities?.fs?.writeTextFile === true
-      capabilities.childSessionUpdates = params.clientCapabilities?._meta?.[ChildSessionUpdatesCapability] === true
       const authMethod: AuthMethod = {
         description: "Run `opencode auth login` in the terminal",
         name: "Login with opencode",
@@ -196,7 +178,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
           mcpCapabilities: { http: true, sse: false },
           promptCapabilities: { embeddedContext: true, image: true },
           sessionCapabilities: { close: {}, delete: {}, fork: {}, list: {}, resume: {} },
-          _meta: { [ChildSessionUpdatesCapability]: true },
         },
         authMethods: [authMethod],
         agentInfo: { name: "OpenCode", version: OPENCODE_VERSION },
@@ -243,7 +224,8 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
       await input.client.session.remove({ sessionID: params.sessionId }).catch((error) => {
         if (!isSessionNotFoundError(error)) throw error
       })
-      detach(params.sessionId)
+      sessions.delete(params.sessionId)
+      registeredMcp.delete(params.sessionId)
       return {}
     },
     resumeSession: async (params) => {
@@ -252,7 +234,8 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
       return { configOptions: configOptions(state) }
     },
     closeSession: async (params) => {
-      detach(params.sessionId)
+      sessions.delete(params.sessionId)
+      registeredMcp.delete(params.sessionId)
       const turn = active.get(params.sessionId)
       if (turn) {
         turn.cancelled = true
@@ -313,11 +296,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
       const messageID = SessionMessage.ID.create()
       const prepared = preparePrompt(state.catalog, params.prompt, messageID)
       const control: TurnControl = { cancelled: false, admission: new AbortController() }
-      const extNotification = input.connection.extNotification
-      const childSessionUpdate =
-        capabilities.childSessionUpdates && extNotification
-          ? (update: ChildSessionUpdate) => extNotification(ChildSessionUpdateMethod, update).then(() => {})
-          : undefined
       active.set(state.id, control)
       const response = await streamTurn({
         client: input.client,
@@ -327,10 +305,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
         start: prepared.start,
         writeTextFile: capabilities.writeTextFile,
         control,
-        connectionSignal: input.connection.signal,
-        sessionSignal: state.abort.signal,
         submit: (signal) => submitPrompt(input.client, state, prepared, signal),
-        ...(childSessionUpdate ? { childSessionUpdate } : {}),
       }).finally(() => {
         if (active.get(state.id) === control) active.delete(state.id)
       })

packages/cli/test/acp/event-behavior.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test"
 import type { AgentSideConnection } from "@agentclientprotocol/sdk"
 import type { SessionMessageInfo } from "@opencode-ai/client/promise"
 import { resolve } from "node:path"
-import { replayMessages, streamTurn, type ChildSessionUpdate, type TurnControl } from "../../src/acp/event"
+import { replayMessages, streamTurn, type TurnControl } from "../../src/acp/event"
 import { createSseFixture, durableEvent, ephemeralEvent, withTimeout } from "./sse-fixture"
 
 type SessionUpdateParams = Parameters<AgentSideConnection["sessionUpdate"]>[0]
@@ -191,181 +191,6 @@ describe("acp event behavior", () => {
     }
   })
 
-  test("projects foreground child session updates onto the parent turn", async () => {
-    const updates: SessionUpdateParams[] = []
-    const fixture = createSseFixture({
-      onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
-        send(
-          durableEvent("session.created", {
-            sessionID: "ses_child",
-            info: childSession("ses_child", "ses_parent", "Explore code"),
-          }),
-        )
-        send(durableEvent("session.execution.started", { sessionID: "ses_child" }))
-        send(
-          durableEvent("session.tool.input.started", {
-            sessionID: "ses_child",
-            assistantMessageID: "msg_child",
-            id: "call_read",
-            name: "read",
-          }),
-        )
-        send(
-          durableEvent("session.tool.called", {
-            sessionID: "ses_child",
-            assistantMessageID: "msg_child",
-            id: "call_read",
-            input: { path: "/workspace/src/index.ts" },
-            executed: false,
-          }),
-        )
-        send(
-          durableEvent("session.tool.success", {
-            sessionID: "ses_child",
-            assistantMessageID: "msg_child",
-            id: "call_read",
-            metadata: {},
-            content: [{ type: "text", text: "source" }],
-            executed: true,
-          }),
-        )
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_child" }))
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_parent" }))
-      },
-    })
-
-    try {
-      const response = await turn({
-        fixture,
-        connection: recordingConnection(updates),
-        sessionID: "ses_parent",
-        inputID: "input_parent",
-      })
-
-      expect(updates.map((item) => [item.sessionId, item.update.sessionUpdate])).toEqual([
-        ["ses_parent", "tool_call"],
-        ["ses_parent", "tool_call_update"],
-        ["ses_parent", "tool_call_update"],
-      ])
-      expect(updates.map((item) => ("toolCallId" in item.update ? item.update.toolCallId : undefined))).toEqual([
-        "ses_child:call_read",
-        "ses_child:call_read",
-        "ses_child:call_read",
-      ])
-      expect(updates[0]?.update).toMatchObject({
-        title: "Explore code: read",
-        _meta: {
-          "opencode/child-session": {
-            id: "ses_child",
-            parentID: "ses_parent",
-            depth: 1,
-            title: "Explore code",
-          },
-        },
-      })
-      expect(response.stopReason).toBe("end_turn")
-    } finally {
-      await fixture.stop()
-    }
-  })
-
-  test("continues child extension updates after the parent turn ends", async () => {
-    const updates: SessionUpdateParams[] = []
-    const childUpdates: ChildSessionUpdate[] = []
-    const completed = Promise.withResolvers<void>()
-    const fixture = createSseFixture({
-      onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
-        send(
-          durableEvent("session.created", {
-            sessionID: "ses_background",
-            info: childSession("ses_background", "ses_parent", "Background research"),
-          }),
-        )
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_parent" }))
-      },
-    })
-
-    try {
-      const response = await turn({
-        fixture,
-        connection: recordingConnection(updates),
-        sessionID: "ses_parent",
-        inputID: "input_parent",
-        childSessionUpdate: async (update) => {
-          childUpdates.push(update)
-          if (update.type === "status" && update.status === "completed") completed.resolve()
-        },
-      })
-      expect(response.stopReason).toBe("end_turn")
-
-      fixture.send(
-        durableEvent("session.created", {
-          sessionID: "ses_future",
-          info: childSession("ses_future", "ses_parent", "Later turn child"),
-        }),
-      )
-      fixture.send(durableEvent("session.execution.started", { sessionID: "ses_future" }))
-      fixture.send(durableEvent("session.execution.started", { sessionID: "ses_background" }))
-      fixture.send(
-        durableEvent("session.tool.input.started", {
-          sessionID: "ses_background",
-          assistantMessageID: "msg_background",
-          id: "call_shell",
-          name: "shell",
-        }),
-      )
-      fixture.send(
-        durableEvent("session.tool.called", {
-          sessionID: "ses_background",
-          assistantMessageID: "msg_background",
-          id: "call_shell",
-          input: { command: "pwd" },
-          executed: false,
-        }),
-      )
-      fixture.send(
-        durableEvent("session.tool.success", {
-          sessionID: "ses_background",
-          assistantMessageID: "msg_background",
-          id: "call_shell",
-          metadata: { exit: 0 },
-          content: [{ type: "text", text: "/workspace" }],
-          executed: true,
-        }),
-      )
-      fixture.send(durableEvent("session.execution.succeeded", { sessionID: "ses_background" }))
-      await withTimeout(completed.promise, "background child completion was not delivered")
-
-      expect(updates).toEqual([])
-      expect(
-        childUpdates.map((update) =>
-          update.type === "status" ? [update.type, update.status] : [update.type, update.update.sessionUpdate],
-        ),
-      ).toEqual([
-        ["status", "created"],
-        ["status", "running"],
-        ["update", "tool_call"],
-        ["update", "tool_call_update"],
-        ["update", "tool_call_update"],
-        ["status", "completed"],
-      ])
-      expect(childUpdates[2]).toMatchObject({
-        rootSessionId: "ses_parent",
-        childSessionId: "ses_background",
-        parentSessionId: "ses_parent",
-        depth: 1,
-        title: "Background research",
-        type: "update",
-        update: { toolCallId: "ses_background:call_shell" },
-      })
-      expect(childUpdates.some((update) => update.childSessionId === "ses_future")).toBe(false)
-    } finally {
-      await fixture.stop()
-    }
-  })
-
   test("streams tool pending, progress, success, and failure updates", async () => {
     const updates: SessionUpdateParams[] = []
     const fixture = createSseFixture({
@@ -731,7 +556,6 @@ function turn(input: {
   readonly connection: Connection
   readonly sessionID: string
   readonly inputID: string
-  readonly childSessionUpdate?: (update: ChildSessionUpdate) => Promise<void>
 }) {
   return streamTurn({
     client: input.fixture.client,
@@ -741,25 +565,11 @@ function turn(input: {
     start: { type: "input", id: input.inputID },
     writeTextFile: false,
     control: { cancelled: false, admission: new AbortController() },
-    childSessionUpdate: input.childSessionUpdate,
     submit: (signal) =>
       input.fixture.client.session.prompt({ sessionID: input.sessionID, id: input.inputID, text: "hello" }, { signal }),
   })
 }
 
-function childSession(id: string, parentID: string, title: string) {
-  return {
-    id,
-    slug: id,
-    projectID: "project",
-    directory: "/workspace",
-    parentID,
-    title,
-    version: "test",
-    time: { created: 1, updated: 1 },
-  }
-}
-
 function tokens() {
   return { input: 1, output: 1, reasoning: 0, cache: { read: 0, write: 0 } }
 }

packages/cli/test/acp/permission-behavior.test.ts

@@ -153,68 +153,6 @@ describe("acp permission behavior", () => {
     }
   })
 
-  test("routes foreground child permissions through the parent ACP session", async () => {
-    const permissionRequests: RequestPermissionRequest[] = []
-    const fixture = createSseFixture({
-      onPrompt({ id, send }) {
-        send(durableEvent("session.input.promoted", { sessionID: "ses_parent", inputID: id }))
-        send(
-          durableEvent("session.created", {
-            sessionID: "ses_child",
-            info: {
-              id: "ses_child",
-              slug: "ses_child",
-              projectID: "project",
-              directory: "/workspace",
-              parentID: "ses_parent",
-              title: "Review code",
-              version: "test",
-              time: { created: 1, updated: 1 },
-            },
-          }),
-        )
-        send(durableEvent("session.execution.started", { sessionID: "ses_child" }))
-        send(
-          permissionAsked("ses_child", "perm_child", {
-            action: "read",
-            metadata: { path: "/workspace/child.ts" },
-            source: { type: "tool", messageID: "msg_child", id: "call_child" },
-          }),
-        )
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_child" }))
-        send(durableEvent("session.execution.succeeded", { sessionID: "ses_parent" }))
-      },
-    })
-    const connection = {
-      sessionUpdate: async () => {},
-      requestPermission: async (request) => {
-        permissionRequests.push(request)
-        return { outcome: { outcome: "selected", optionId: "once" } } as const
-      },
-    } satisfies Connection
-
-    try {
-      await startTurn(fixture, connection, "ses_parent", "input_parent")
-
-      expect(permissionRequests).toHaveLength(1)
-      expect(permissionRequests[0]).toMatchObject({
-        sessionId: "ses_parent",
-        toolCall: {
-          toolCallId: "ses_child:call_child",
-          title: "Review code: /workspace/child.ts",
-        },
-      })
-      expect(fixture.requests).toContainEqual(
-        expect.objectContaining({
-          method: "POST",
-          path: "/api/session/ses_child/permission/perm_child/reply",
-        }),
-      )
-    } finally {
-      await fixture.stop()
-    }
-  })
-
   test("previews edits during approval and syncs the completed file", async () => {
     const cwd = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-acp-permission-"))
     const file = path.join(cwd, "file.ts")

packages/cli/test/acp/service.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test"
 import type { AgentSideConnection } from "@agentclientprotocol/sdk"
 import { OpenCode } from "@opencode-ai/client/promise"
 import { ACPService } from "../../src/acp/service"
-import { ChildSessionUpdatesCapability } from "../../src/acp/event"
 
 describe("acp service", () => {
   test("creates a v2 session, registers mcp, and publishes commands", async () => {
@@ -40,17 +39,11 @@ describe("acp service", () => {
     })
 
     try {
-      const initialized = await service.initialize({
-        protocolVersion: 1,
-        clientCapabilities: { _meta: { [ChildSessionUpdatesCapability]: true } },
-        clientInfo: { name: "test", version: "1" },
-      })
       const result = await service.newSession({
         cwd: "/workspace",
         mcpServers: [{ name: "docs", command: "bun", args: ["docs.ts"], env: [{ name: "TOKEN", value: "x" }] }],
       })
       expect(result.sessionId).toBe("ses_acp")
-      expect(initialized.agentCapabilities?._meta).toEqual({ [ChildSessionUpdatesCapability]: true })
       expect(result.configOptions?.map((option) => option.id)).toEqual(["model", "effort", "mode"])
       expect(requests).toContainEqual({
         method: "PUT",

packages/core/src/file-mutation.ts

@@ -53,6 +53,10 @@ export interface RemoveResult {
 }
 
 export interface Interface {
+  /** Serialize a complete read/prepare/write mutation transaction by canonical target. */
+  readonly withLock: (
+    targets: ReadonlyArray<Target>,
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /** Create without replacing an existing target. */
   readonly create: (input: WriteInput) => Effect.Effect<WriteResult, TargetExistsError | FSUtil.Error>
   readonly write: (input: WriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
@@ -67,6 +71,9 @@ export interface Interface {
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/FileMutation") {}
 
+/** Share transaction locks across Location graphs that address the same file. */
+const transactionLocks = KeyedMutex.makeUnsafe<string>()
+
 /**
  * Serialize file changes by canonical target. Conditional writes compare and
  * write under the same process-local lock so cooperating OpenCode mutations do
@@ -77,6 +84,10 @@ const layer = Layer.effect(
   Effect.gen(function* () {
     const fs = yield* FSUtil.Service
     const locks = KeyedMutex.makeUnsafe<string>()
+    const withLock: Interface["withLock"] = (targets) => (effect) =>
+      [...new Set(targets.map((target) => target.canonical))]
+        .sort()
+        .reduceRight((result, target) => transactionLocks.withLock(target)(result), effect)
     const withTargetLock =
       (target: Target) =>
       <A, E, R>(effect: Effect.Effect<A, E, R>) =>
@@ -169,7 +180,7 @@ const layer = Layer.effect(
       ),
     )
 
-    return Service.of({ create, write, writeTextPreservingBom, writeIfUnchanged, remove })
+    return Service.of({ withLock, create, write, writeTextPreservingBom, writeIfUnchanged, remove })
   }),
 )
 

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

@@ -11,9 +11,11 @@ import { ToolFailure } from "@opencode-ai/ai"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
 import { Bom } from "@opencode-ai/util/bom"
 import { Effect, Schema } from "effect"
+import path from "path"
 import { FileMutation } from "../../file-mutation"
 import { Formatter } from "../../formatter"
 import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Location } from "../../location"
 import { LocationMutation } from "../../location-mutation"
 import { Permission } from "../../permission"
 import { fileDiff } from "./file-diff"
@@ -112,6 +114,7 @@ export const Plugin = {
     const files = yield* FileMutation.Service
     const formatter = yield* Formatter.Service
     const fs = yield* FSUtil.Service
+    const location = yield* Location.Service
     const permission = yield* Permission.Service
 
     yield* ctx.tool
@@ -125,7 +128,9 @@ export const Plugin = {
               input: Input,
               output: Output,
               execute: (input, context) => {
-                return Effect.gen(function* () {
+                return files.withLock([
+                  { canonical: FSUtil.resolve(path.resolve(location.directory, input.path)), resource: input.path },
+                ])(Effect.gen(function* () {
                   const permissionSource = {
                     type: "tool" as const,
                     messageID: context.messageID,
@@ -219,7 +224,7 @@ export const Plugin = {
                     files: [fileDiff(result.resource, source, formatted)],
                     replacements,
                   } satisfies Output
-                }).pipe(
+                })).pipe(
                   Effect.map((output) => ({
                     output,
                     content: `Edited ${output.files[0]?.file} (${output.replacements} replacement${output.replacements === 1 ? "" : "s"})`,

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

@@ -4,12 +4,13 @@ import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin
 import { ToolFailure } from "@opencode-ai/ai"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
 import { createTwoFilesPatch, diffLines } from "diff"
-import { Effect, Schema } from "effect"
+import { Effect, Result, Schema } from "effect"
 import { PlatformError } from "effect/PlatformError"
 import path from "path"
 import { Bom } from "@opencode-ai/util/bom"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Formatter } from "../../formatter"
+import { FileMutation } from "../../file-mutation"
 import { Location } from "../../location"
 import { Patch } from "@opencode-ai/util/patch"
 import { Permission } from "../../permission"
@@ -70,6 +71,7 @@ export const Plugin = {
   id: "opencode.tool.patch",
   effect: Effect.fn("PatchTool.Plugin")(function* (ctx: PluginContext) {
     const fs = yield* FSUtil.Service
+    const mutation = yield* FileMutation.Service
     const formatter = yield* Formatter.Service
     const location = yield* Location.Service
     const permission = yield* Permission.Service
@@ -85,13 +87,30 @@ export const Plugin = {
               output: Output,
               execute: (input, context) => {
                 const applied: Array<typeof Applied.Type> = []
+                const parsed = Patch.parse(input.patchText)
+                const lockTargets = Result.isSuccess(parsed)
+                  ? parsed.success.flatMap((hunk) => [
+                      {
+                        ...resolveTarget(location, hunk.path),
+                        canonical: FSUtil.resolve(path.resolve(location.directory, hunk.path)),
+                      },
+                      ...(hunk.type === "update" && hunk.movePath
+                        ? [
+                            {
+                              ...resolveTarget(location, hunk.movePath),
+                              canonical: FSUtil.resolve(path.resolve(location.directory, hunk.movePath)),
+                            },
+                          ]
+                        : []),
+                    ])
+                  : []
                 const fail = (operation: string, error: unknown) => {
                   const completed = applied.map((item) => item.resource).join(", ")
                   return new ToolFailure({
                     message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`,
                   })
                 }
-                return Effect.gen(function* () {
+                return mutation.withLock(lockTargets)(Effect.gen(function* () {
                   const source = {
                     type: "tool" as const,
                     messageID: context.messageID,
@@ -322,7 +341,7 @@ export const Plugin = {
                     return Effect.succeed(patchFile(change, formatted.get(target.canonical)))
                   })
                   return { applied, files }
-                }).pipe(
+                })).pipe(
                   Effect.map((output) => ({
                     output,
                     content: toModelOutput(output),

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

@@ -257,6 +257,59 @@ describe("FileMutation", () => {
     ),
   )
 
+  it.live("shares transaction locks across Location service instances", () =>
+    withTmp((directory) =>
+      Effect.gen(function* () {
+        const firstStarted = yield* Deferred.make<void>()
+        const releaseFirst = yield* Deferred.make<void>()
+        const secondStarted = yield* Deferred.make<void>()
+        const target = { canonical: path.join(directory, "shared.txt"), resource: "shared.txt" }
+        const first = yield* Effect.gen(function* () {
+          const files = yield* FileMutation.Service
+          yield* files.withLock([target])(
+            Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst))),
+          )
+        }).pipe(provide(directory), Effect.forkChild)
+        yield* Deferred.await(firstStarted)
+        const second = yield* Effect.gen(function* () {
+          const files = yield* FileMutation.Service
+          yield* files.withLock([target])(Deferred.succeed(secondStarted, undefined))
+        }).pipe(provide(directory), 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)
+      }),
+    ),
+  )
+
+  it.live("allows transaction locks for distinct canonical 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 files = yield* FileMutation.Service
+        const first = yield* files
+          .withLock([{ canonical: path.join(directory, "first.txt"), resource: "first.txt" }])(
+            Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst))),
+          )
+          .pipe(Effect.forkChild)
+        yield* Deferred.await(firstStarted)
+        yield* files.withLock([{ canonical: path.join(directory, "second.txt"), resource: "second.txt" }])(
+          Deferred.succeed(secondFinished, undefined),
+        )
+        expect(yield* Deferred.isDone(secondFinished)).toBe(true)
+
+        yield* Deferred.succeed(releaseFirst, undefined)
+        yield* Fiber.join(first)
+      }).pipe(provide(directory)),
+    ),
+  )
+
   it.live("allows only one concurrent conditional write based on the same bytes", () =>
     withTmp((directory) =>
       Effect.gen(function* () {

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

@@ -23,7 +23,7 @@ import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "
 const editToolNode = makeLocationNode({
   name: "test/edit-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(EditTool.Plugin)),
-  deps: [Tool.node, LocationMutation.node, FileMutation.node, Formatter.node, FSUtil.node, Permission.node],
+  deps: [Tool.node, LocationMutation.node, FileMutation.node, Formatter.node, FSUtil.node, Location.node, Permission.node],
 })
 
 const sessionID = Session.ID.make("ses_edit_tool_test")
@@ -645,6 +645,43 @@ describe("EditTool", () => {
     ),
   )
 
+  it.live("serializes concurrent edit transactions", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => {
+        reset()
+        const target = path.join(tmp.path, "concurrent.txt")
+        afterRead = () => (reads === 1 ? Effect.sleep("50 millis") : Effect.void)
+        return Effect.promise(() => fs.writeFile(target, "one\ntwo\n")).pipe(
+          Effect.andThen(
+            withTool(tmp.path, (registry) =>
+              Effect.all(
+                [
+                  executeTool(
+                    registry,
+                    call({ path: "concurrent.txt", oldString: "one", newString: "ONE" }, "call-edit-one"),
+                  ),
+                  executeTool(
+                    registry,
+                    call({ path: "concurrent.txt", oldString: "two", newString: "TWO" }, "call-edit-two"),
+                  ),
+                ],
+                { concurrency: "unbounded" },
+              ),
+            ),
+          ),
+          Effect.andThen((results) =>
+            Effect.gen(function* () {
+              expect(results.map((result) => result.status)).toEqual(["completed", "completed"])
+              expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("ONE\nTWO\n")
+            }),
+          ),
+        )
+      },
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ),
+  )
+
   it.live("applies the edit when content changes after matching", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

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

@@ -7,6 +7,7 @@ import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Formatter } from "@opencode-ai/core/formatter"
+import { FileMutation } from "@opencode-ai/core/file-mutation"
 import { Location } from "@opencode-ai/core/location"
 import { Permission } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -22,7 +23,7 @@ import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "
 const patchToolNode = makeLocationNode({
   name: "test/patch-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(PatchTool.Plugin)),
-  deps: [Tool.node, Formatter.node, FSUtil.node, Location.node, Permission.node],
+  deps: [Tool.node, FileMutation.node, Formatter.node, FSUtil.node, Location.node, Permission.node],
 })
 
 const sessionID = Session.ID.make("ses_patch_tool_test")
@@ -139,7 +140,7 @@ const withTool = <A, E, R>(
     return yield* body(yield* Tool.Service)
   }).pipe(
     Effect.provide(
-      AppNodeBuilder.build(LayerNode.group([Tool.node, patchToolNode]), [
+      AppNodeBuilder.build(LayerNode.group([Tool.node, FileMutation.node, patchToolNode]), [
         [FSUtil.node, filesystem],
         [Location.node, activeLocation],
         [Formatter.node, formatter],
@@ -262,6 +263,45 @@ describe("PatchTool", () => {
     ),
   )
 
+  it.live("serializes concurrent patch transactions", () =>
+    withTempTool((directory, registry) => {
+      const target = path.join(directory, "concurrent.txt")
+      afterEditApproval = () =>
+        assertions.filter((input) => input.action === "edit").length === 1
+          ? Effect.sleep("50 millis")
+          : Effect.void
+      return Effect.promise(() => fs.writeFile(target, "one\ntwo\n")).pipe(
+        Effect.andThen(
+          Effect.all(
+            [
+              executeTool(
+                registry,
+                call(
+                  "*** Begin Patch\n*** Update File: concurrent.txt\n@@\n-one\n+ONE\n*** End Patch",
+                  "call-patch-one",
+                ),
+              ),
+              executeTool(
+                registry,
+                call(
+                  "*** Begin Patch\n*** Update File: concurrent.txt\n@@\n-two\n+TWO\n*** End Patch",
+                  "call-patch-two",
+                ),
+              ),
+            ],
+            { concurrency: "unbounded" },
+          ),
+        ),
+        Effect.andThen((results) =>
+          Effect.gen(function* () {
+            expect(results.map((result) => result.status)).toEqual(["completed", "completed"])
+            expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("ONE\nTWO\n")
+          }),
+        ),
+      )
+    }),
+  )
+
   it.live("returns file diffs for final formatted content", () =>
     withTempTool((directory, registry) => {
       const target = path.join(directory, "formatted.txt")