prep release

Allow agent to write plans and todos to its config directory
Use official sdk types for tools
2026-10-27 12:40:32 +00:00 · 2025-12-11 14:02:33 +01:00 · 2025-12-11 14:00:24 +01:00 · 2025-12-11 13:19:22 +01:00
40 changed files with 4283 additions and 22599 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,18 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      # Check for updates to GitHub Actions every week
-      interval: "weekly"
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    allow:
-      - dependency-type: "all"
-    groups:
-      minor:
-        update-types:
-          - "minor"
-          - "patch"
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,12 +21,12 @@ jobs:
    timeout-minutes: 5

    steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8

      - name: Use Node.js
-        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020
        with:
-          node-version: "lts/*"
+          node-version: latest
          cache: "npm"

      - name: Install dependencies
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -1,55 +1,36 @@
-name: Publish and Release
+name: Publish Package to npmjs
 on:
  push:
-    branches:
-      - main
-
+    tags:
+      - "v*.*.*"
 jobs:
-  release-please:
-    runs-on: ubuntu-latest
-    environment: release # Optional: for enhanced security
-    permissions:
-      contents: write
-      issues: write
-      pull-requests: write
-    steps:
-      # Generating a GitHub token, so that PRs and tags created by
-      # the release-please-action can trigger actions workflows.
-      - name: Generate GitHub token
-        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1
-        id: generate-token
-        with:
-          # GitHub App ID secret name
-          app-id: ${{ secrets.RELEASE_PLZ_APP_ID }}
-          # GitHub App private key secret name
-          private-key: ${{ secrets.RELEASE_PLZ_APP_PRIVATE_KEY }}
-      - uses: googleapis/release-please-action@45996ed1f6d02564a971a2fa1b5860e934307cf7
-        id: release
-        with:
-          token: ${{ steps.generate-token.outputs.token }}
-          release-type: node
-          config-file: release-please-config.json
-          manifest-file: .release-please-manifest.json
-    outputs:
-      release_created: ${{ steps.release.outputs.release_created }}
-      tag_name: ${{ steps.release.outputs.tag_name }}
-
  publish-npm:
-    name: Publish to npm
    runs-on: ubuntu-latest
-    needs: [release-please]
-    if: ${{ needs.release-please.outputs.release_created }}
    environment: release # Optional: for enhanced security
    permissions:
      contents: read
      id-token: write
    steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8
      # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e
+      - uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020
        with:
          node-version: "lts/*"
          registry-url: "https://registry.npmjs.org"
+      - name: Update npm
+        run: npm install -g npm@latest
      - run: npm ci
      - run: npm run build
      - run: npm publish
+  release:
+    runs-on: ubuntu-latest
+    needs: [publish-npm]
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8
+      - name: Create Release
+        id: create_release
+        uses: softprops/action-gh-release@6da8fa9354ddfdc4aeace5fc48d7f679b5214090
+        with:
+          draft: true
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,3 @@
 node_modules
 dist
 .DS_Store
-.claude/*.local.*
-CLAUDE.local.md
--- a/.prettierignore
+++ b/.prettierignore
@@ -1,7 +0,0 @@
-node_modules
-dist
-.agent-shell
-
-.release-please-manifest.json
-release-please-config.json
-CHANGELOG.md
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +0,0 @@
-{
-  ".": "0.58.1"
-}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,707 +1,7 @@
 # Changelog

-## [0.58.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.58.0...v0.58.1) (2026-07-09)
-
-
-### Bug Fixes
-
-* Use valid npm version for publish ([#855](https://github.com/agentclientprotocol/claude-agent-acp/issues/855)) ([8b366d8](https://github.com/agentclientprotocol/claude-agent-acp/commit/8b366d8e9ad55e9237bf2d618cfc99b57fac570d))
-
-## [0.58.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.57.0...v0.58.0) (2026-07-09)
-
-
-### Features
-
-* **deps:** update to @anthropic-ai/claude-agent-sdk 0.3.205 ([#854](https://github.com/agentclientprotocol/claude-agent-acp/issues/854)) ([f664ced](https://github.com/agentclientprotocol/claude-agent-acp/commit/f664ced76df00674d88aedd018a4261da3bc3f3a))
-
-
-### Bug Fixes
-
-* Preserve live model on resumed sessions ([#848](https://github.com/agentclientprotocol/claude-agent-acp/issues/848)) ([f3d8ae3](https://github.com/agentclientprotocol/claude-agent-acp/commit/f3d8ae3eb389ee9367f48c8762562a55280ade0a)), closes [#845](https://github.com/agentclientprotocol/claude-agent-acp/issues/845)
-* Report usage for cancelled active turns ([#846](https://github.com/agentclientprotocol/claude-agent-acp/issues/846)) ([b03318f](https://github.com/agentclientprotocol/claude-agent-acp/commit/b03318f59c6165146c8d8e036227f35c3abd0ff4)), closes [#844](https://github.com/agentclientprotocol/claude-agent-acp/issues/844)
-* tolerate missing text in streamed thinking chunks ([#852](https://github.com/agentclientprotocol/claude-agent-acp/issues/852)) ([e944ced](https://github.com/agentclientprotocol/claude-agent-acp/commit/e944ceddea79950d6bfb6339266862507c4b964f))
-* Use SDK guards for elicitation validation ([#850](https://github.com/agentclientprotocol/claude-agent-acp/issues/850)) ([32b9350](https://github.com/agentclientprotocol/claude-agent-acp/commit/32b93501d7a35a3b405b5022b4caaad492eed11c))
-
-## [0.57.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.56.0...v0.57.0) (2026-07-07)
-
-
-### Features
-
-* Update @anthropic-ai/claude-agent-sdk to 0.3.202 ([#843](https://github.com/agentclientprotocol/claude-agent-acp/issues/843)) ([1612c07](https://github.com/agentclientprotocol/claude-agent-acp/commit/1612c078953c134e12368a2d968a9bcf14d31b55))
-
-
-### Bug Fixes
-
-* don't emit empty agent_message_chunk ([#841](https://github.com/agentclientprotocol/claude-agent-acp/issues/841)) ([d74dd1d](https://github.com/agentclientprotocol/claude-agent-acp/commit/d74dd1d9d356050fc87f9fdab8599f1546b12a2c))
-
-## [0.56.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.55.0...v0.56.0) (2026-07-06)
-
-
-### Features
-
-* **deps:** bump @anthropic-ai/claude-agent-sdk to 0.3.201 ([#837](https://github.com/agentclientprotocol/claude-agent-acp/issues/837)) ([ff2a8a9](https://github.com/agentclientprotocol/claude-agent-acp/commit/ff2a8a963536a4265700e4f2003a0ffff93c9087))
-
-## [0.55.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.54.1...v0.55.0) (2026-07-02)
-
-
-### Features
-
-* Add refusal fallback consent dialog support ([#834](https://github.com/agentclientprotocol/claude-agent-acp/issues/834)) ([15dfd83](https://github.com/agentclientprotocol/claude-agent-acp/commit/15dfd83daa84ced98ecbaa7c83fd5a53124030c1))
-* **deps-dev:** bump the minor group with 3 updates ([#831](https://github.com/agentclientprotocol/claude-agent-acp/issues/831)) ([8d5febf](https://github.com/agentclientprotocol/claude-agent-acp/commit/8d5febf85485c1ad19b81501fb5c6d4275448a7c))
-* Update to claude-agent-sdk 0.3.198 ([#836](https://github.com/agentclientprotocol/claude-agent-acp/issues/836)) ([307ab82](https://github.com/agentclientprotocol/claude-agent-acp/commit/307ab82712213413446466d808e161073e94fc7f))
-
-
-### Bug Fixes
-
-* Handle model refusal fallback updates ([#833](https://github.com/agentclientprotocol/claude-agent-acp/issues/833)) ([648e3f6](https://github.com/agentclientprotocol/claude-agent-acp/commit/648e3f60bd7e6eadb5f86b0dc475104ab12e7b02))
-* Handle SDK idle turns without results ([#835](https://github.com/agentclientprotocol/claude-agent-acp/issues/835)) ([57b00cc](https://github.com/agentclientprotocol/claude-agent-acp/commit/57b00ccac610e2eeaf0a753934a0c3b78d27ccb0))
-
-## [0.54.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.54.0...v0.54.1) (2026-06-30)
-
-
-### Bug Fixes
-
-* apply modelOverrides when resolving availableModels allowlist ([#827](https://github.com/agentclientprotocol/claude-agent-acp/issues/827)) ([98c284b](https://github.com/agentclientprotocol/claude-agent-acp/commit/98c284bb871a96710596dfdc2b9ea25d2400f6b2))
-
-## [0.54.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.53.0...v0.54.0) (2026-06-30)
-
-
-### Features
-
-* Add Fast mode session config support ([#828](https://github.com/agentclientprotocol/claude-agent-acp/issues/828)) ([fa949a2](https://github.com/agentclientprotocol/claude-agent-acp/commit/fa949a20db0e33f2d63aebeb37e9fea212d8ee95))
-* **deps-dev:** bump prettier from 3.9.1 to 3.9.3 in the minor group ([#821](https://github.com/agentclientprotocol/claude-agent-acp/issues/821)) ([b8df8e0](https://github.com/agentclientprotocol/claude-agent-acp/commit/b8df8e0e5460fd782214f4dde488f7476c80c454))
-* **deps:** bump @anthropic-ai/claude-agent-sdk to 0.3.197 for Sonnet 5 ([#826](https://github.com/agentclientprotocol/claude-agent-acp/issues/826)) ([ef42c46](https://github.com/agentclientprotocol/claude-agent-acp/commit/ef42c46e5aea3bb53f433b9f9dd36a62a9f2df6a))
-* **deps:** bump fast-uri from 3.1.2 to 3.1.3 ([#822](https://github.com/agentclientprotocol/claude-agent-acp/issues/822)) ([64aa130](https://github.com/agentclientprotocol/claude-agent-acp/commit/64aa130c66c299f9835193796ba372b3ed40e7c1))
-
-## [0.53.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.52.0...v0.53.0) (2026-06-29)
-
-
-### Features
-
-* Add ACP logout support ([#816](https://github.com/agentclientprotocol/claude-agent-acp/issues/816)) ([0a0468c](https://github.com/agentclientprotocol/claude-agent-acp/commit/0a0468c72092b7ceccc551b4353dd92f9c22cbb8))
-* **deps:** bump @anthropic-ai/claude-agent-sdk to 0.3.195 ([#818](https://github.com/agentclientprotocol/claude-agent-acp/issues/818)) ([5dd8746](https://github.com/agentclientprotocol/claude-agent-acp/commit/5dd87462376597eb7b695200f4c716af46e764d6))
-
-
-### Bug Fixes
-
-* Emit tool_call before permission request ([#820](https://github.com/agentclientprotocol/claude-agent-acp/issues/820)) ([c95fc88](https://github.com/agentclientprotocol/claude-agent-acp/commit/c95fc884e82e5a297d1b17b8965690260867835b))
-
-## [0.52.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.51.0...v0.52.0) (2026-06-25)
-
-
-### Features
-
-* Add version flag handling ([#813](https://github.com/agentclientprotocol/claude-agent-acp/issues/813)) ([9616bda](https://github.com/agentclientprotocol/claude-agent-acp/commit/9616bdac47505e4a14c36d667fcffc9ae97e1f2a)), closes [#809](https://github.com/agentclientprotocol/claude-agent-acp/issues/809)
-* **deps-dev:** bump expect-type from 1.3.0 to 1.4.0 in the minor group ([#814](https://github.com/agentclientprotocol/claude-agent-acp/issues/814)) ([61272ac](https://github.com/agentclientprotocol/claude-agent-acp/commit/61272acb30dcafaa2455d334b11ce2ad97339707))
-* **deps:** Update @anthropic-ai/claude-agent-sdk to 0.3.191 ([#810](https://github.com/agentclientprotocol/claude-agent-acp/issues/810)) ([228f02e](https://github.com/agentclientprotocol/claude-agent-acp/commit/228f02ecfb23be16e59e121c6b42c0f2b2f40a4e))
-* Push session title updates at turn end ([#812](https://github.com/agentclientprotocol/claude-agent-acp/issues/812)) ([1fe7ec0](https://github.com/agentclientprotocol/claude-agent-acp/commit/1fe7ec09a3a7bcb7501231dae4b0ffe6ef9b70a4))
-
-## [0.51.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.50.0...v0.51.0) (2026-06-24)
-
-
-### Features
-
-* **deps:** bump the minor group with 11 updates ([#807](https://github.com/agentclientprotocol/claude-agent-acp/issues/807)) ([8f6ebd1](https://github.com/agentclientprotocol/claude-agent-acp/commit/8f6ebd1d9198edf723f4c8c1aa2b49b906c46646))
-
-## [0.50.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.49.0...v0.50.0) (2026-06-23)
-
-
-### Features
-
-* **acp:** Handle ACP request cancellation signals ([#801](https://github.com/agentclientprotocol/claude-agent-acp/issues/801)) ([9013d1d](https://github.com/agentclientprotocol/claude-agent-acp/commit/9013d1d46883a7f3774a63a9dca16c4a0f634a97))
-* **deps:** bump actions/checkout from 6.0.3 to 7.0.0 ([#803](https://github.com/agentclientprotocol/claude-agent-acp/issues/803)) ([044c43e](https://github.com/agentclientprotocol/claude-agent-acp/commit/044c43e0c894082b9e747c01e9dbde6e21036823))
-* **deps:** upgrade to @anthropic-ai/claude-agent-sdk@0.3.186 ([#806](https://github.com/agentclientprotocol/claude-agent-acp/issues/806)) ([a7e6137](https://github.com/agentclientprotocol/claude-agent-acp/commit/a7e6137f6877b72b8daa39e74971c3559db8d28f))
-
-## [0.49.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.48.0...v0.49.0) (2026-06-22)
-
-
-### Features
-
-* Update to claude-agent-sdk 0.3.185 ([#798](https://github.com/agentclientprotocol/claude-agent-acp/issues/798)) ([8dc8c86](https://github.com/agentclientprotocol/claude-agent-acp/commit/8dc8c864263fa50d03bec7ebff7aee776604cb3d))
-
-
-### Bug Fixes
-
-* Deduplicate streamed assistant blocks by content ([#800](https://github.com/agentclientprotocol/claude-agent-acp/issues/800)) ([960f62d](https://github.com/agentclientprotocol/claude-agent-acp/commit/960f62d76582ae5c9c5575ab66974809049ce1d0))
-* Infer 1M context from model descriptions ([#799](https://github.com/agentclientprotocol/claude-agent-acp/issues/799)) ([508453c](https://github.com/agentclientprotocol/claude-agent-acp/commit/508453c288b4a12701abd507199e7fa0ab172171))
-
-## [0.48.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.47.0...v0.48.0) (2026-06-19)
-
-
-### Features
-
-* Agent selection dropdown in config options ([#794](https://github.com/agentclientprotocol/claude-agent-acp/issues/794)) ([5729c47](https://github.com/agentclientprotocol/claude-agent-acp/commit/5729c471f92e1d2a191eb2a6d18c2be47821e9ec))
-* **deps:** bump the minor group with 11 updates ([#787](https://github.com/agentclientprotocol/claude-agent-acp/issues/787)) ([ad3b5fe](https://github.com/agentclientprotocol/claude-agent-acp/commit/ad3b5fe74527f83964695a1e8056d010b981fc79))
-* Update to claude-agent-sdk 0.3.183 ([#791](https://github.com/agentclientprotocol/claude-agent-acp/issues/791)) ([744b2d4](https://github.com/agentclientprotocol/claude-agent-acp/commit/744b2d41128f67091d4136283594c0db11ea4db5))
-* Update to new ACP SDK patterns ([#790](https://github.com/agentclientprotocol/claude-agent-acp/issues/790)) ([2554c7b](https://github.com/agentclientprotocol/claude-agent-acp/commit/2554c7bf980472760a6e7810b826f030d2c3af25))
-
-
-### Bug Fixes
-
-* duplicate assistant text when turn activates mid-message ([#789](https://github.com/agentclientprotocol/claude-agent-acp/issues/789)) ([1c80bf8](https://github.com/agentclientprotocol/claude-agent-acp/commit/1c80bf8e56a9279dc799e7bbdcae87241e99c18b))
-* Skip empty thinking chunks ([#793](https://github.com/agentclientprotocol/claude-agent-acp/issues/793)) ([15fdf26](https://github.com/agentclientprotocol/claude-agent-acp/commit/15fdf26fc7d3a6c51e89d3e56fc91dd00cb3d7ae))
-* surface Bash tool image output instead of dropping it ([#617](https://github.com/agentclientprotocol/claude-agent-acp/issues/617)) ([a759e64](https://github.com/agentclientprotocol/claude-agent-acp/commit/a759e64ef6d9b7c5bfe9a6e6b182db835f8ed3b6))
-
-## [0.47.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.46.0...v0.47.0) (2026-06-17)
-
-
-### Features
-
-* Update to claude-agent-sdk 0.3.179 ([#783](https://github.com/agentclientprotocol/claude-agent-acp/issues/783)) ([59a098c](https://github.com/agentclientprotocol/claude-agent-acp/commit/59a098c2b530bbae034e9a2dfbd31f8b4ef2a4d0))
-
-
-### Bug Fixes
-
-* Duplicate assistant messages in feed ([#785](https://github.com/agentclientprotocol/claude-agent-acp/issues/785)) ([12d34e6](https://github.com/agentclientprotocol/claude-agent-acp/commit/12d34e64e53564602ac1c38a30127e234c5c25ff))
-
-## [0.46.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.45.1...v0.46.0) (2026-06-16)
-
-
-### Features
-
-* Update to claude-agent-sdk 0.3.178 ([#777](https://github.com/agentclientprotocol/claude-agent-acp/issues/777)) ([58549ff](https://github.com/agentclientprotocol/claude-agent-acp/commit/58549ffe6a8b02ce59894e567407bd4299c11428))
-
-
-### Bug Fixes
-
-* Better handle out of turn events ([#780](https://github.com/agentclientprotocol/claude-agent-acp/issues/780)) ([4f273a2](https://github.com/agentclientprotocol/claude-agent-acp/commit/4f273a20d870c9c69f71556b8e0519f1de30f285))
-* Forward option details in elicitation meta ([#779](https://github.com/agentclientprotocol/claude-agent-acp/issues/779)) ([b364059](https://github.com/agentclientprotocol/claude-agent-acp/commit/b3640599ae685beecacd93e012d5bbc9dac716f7)), closes [#764](https://github.com/agentclientprotocol/claude-agent-acp/issues/764)
-
-## [0.45.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.45.0...v0.45.1) (2026-06-16)
-
-
-### Bug Fixes
-
-* Fix terminal error printing as text instead of terminal output ([#776](https://github.com/agentclientprotocol/claude-agent-acp/issues/776)) ([db6eaaf](https://github.com/agentclientprotocol/claude-agent-acp/commit/db6eaaf71484a321e47093ad65bcf8994943cb31))
-* Scope custom answers per question ([#774](https://github.com/agentclientprotocol/claude-agent-acp/issues/774)) ([d58004a](https://github.com/agentclientprotocol/claude-agent-acp/commit/d58004a34880e0a76833697319eb2a9efa6a43c7))
-
-## [0.45.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.44.0...v0.45.0) (2026-06-15)
-
-
-### Features
-
-* **deps-dev:** bump the minor group with 3 updates ([#763](https://github.com/agentclientprotocol/claude-agent-acp/issues/763)) ([7de5e4b](https://github.com/agentclientprotocol/claude-agent-acp/commit/7de5e4bcca9bfea70593092060f82bc8abe33e0e))
-* **deps:** bump @anthropic-ai/claude-agent-sdk to 0.3.177 ([#771](https://github.com/agentclientprotocol/claude-agent-acp/issues/771)) ([1be5ca5](https://github.com/agentclientprotocol/claude-agent-acp/commit/1be5ca57ee772fe90e41126365dc4186a18ad257))
-
-
-### Bug Fixes
-
-* preserve ANTHROPIC_CUSTOM_MODEL_OPTION when availableModels is set ([#768](https://github.com/agentclientprotocol/claude-agent-acp/issues/768)) ([cc2885f](https://github.com/agentclientprotocol/claude-agent-acp/commit/cc2885f6a9993cf61e759c3c770015f94c218627))
-
-## [0.44.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.43.0...v0.44.0) (2026-06-09)
-
-
-### Features
-
-* **deps:** bump the minor group with 14 updates ([#758](https://github.com/agentclientprotocol/claude-agent-acp/issues/758)) ([7a70162](https://github.com/agentclientprotocol/claude-agent-acp/commit/7a701623df2e05aec8e552bdfd1cf573413c3471))
-* **deps:** update to @anthropic-ai/claude-agent-sdk 0.3.170 ([#761](https://github.com/agentclientprotocol/claude-agent-acp/issues/761)) ([d8af943](https://github.com/agentclientprotocol/claude-agent-acp/commit/d8af943a1efef9be27d771cec089d2f1cb56c523))
-
-## [0.43.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.42.0...v0.43.0) (2026-06-09)
-
-
-### Features
-
-* Add experimental elicitation support ([#756](https://github.com/agentclientprotocol/claude-agent-acp/issues/756)) ([12bd276](https://github.com/agentclientprotocol/claude-agent-acp/commit/12bd2762d9ba0ccb7497a3848a5928b8bb2ce820))
-* **deps:** update to @anthropic-ai/claude-agent-sdk 0.3.169 ([#754](https://github.com/agentclientprotocol/claude-agent-acp/issues/754)) ([bd0ae4d](https://github.com/agentclientprotocol/claude-agent-acp/commit/bd0ae4dde160f59559ab4ac1bf703fcf151eff17))
-* Update ACP SDK to 0.25.0 ([#753](https://github.com/agentclientprotocol/claude-agent-acp/issues/753)) ([0dbccf5](https://github.com/agentclientprotocol/claude-agent-acp/commit/0dbccf588ff702015494dd29969d47f0b7402feb))
-
-
-### Bug Fixes
-
-* Forward unstreamed assistant text blocks ([#757](https://github.com/agentclientprotocol/claude-agent-acp/issues/757)) ([7ff6b7f](https://github.com/agentclientprotocol/claude-agent-acp/commit/7ff6b7fd6b157aedbce0c636087f51ae7d1df3a7))
-* Validate cwd before creating sessions ([#751](https://github.com/agentclientprotocol/claude-agent-acp/issues/751)) ([9854b0c](https://github.com/agentclientprotocol/claude-agent-acp/commit/9854b0c6790ebafff514e3c4c8e03a131f065a4a)), closes [#749](https://github.com/agentclientprotocol/claude-agent-acp/issues/749)
-
-## [0.42.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.41.0...v0.42.0) (2026-06-05)
-
-
-### Features
-
-* **deps-dev:** bump obug from 2.1.1 to 2.1.2 in the minor group ([#743](https://github.com/agentclientprotocol/claude-agent-acp/issues/743)) ([7ffb78c](https://github.com/agentclientprotocol/claude-agent-acp/commit/7ffb78c57280fc32af77862896c0035ce0e690b7))
-* Send message ids for assistant and user messages ([#750](https://github.com/agentclientprotocol/claude-agent-acp/issues/750)) ([18516a3](https://github.com/agentclientprotocol/claude-agent-acp/commit/18516a3088f847a38f5eee0fe81ad5ca3e2a751c))
-* Update Claude Agent SDK to 0.3.165 ([#746](https://github.com/agentclientprotocol/claude-agent-acp/issues/746)) ([23cbe6f](https://github.com/agentclientprotocol/claude-agent-acp/commit/23cbe6f58fa9e10ad736f664c4cf94dbd1c6ad65))
-
-
-### Bug Fixes
-
-* Prevent cross-family model matching in resolveModelPreference ([#731](https://github.com/agentclientprotocol/claude-agent-acp/issues/731)) ([f4704c1](https://github.com/agentclientprotocol/claude-agent-acp/commit/f4704c168f917e6710f2b3cd49e1fef49613a469))
-* Prune tool cache per session after results ([#748](https://github.com/agentclientprotocol/claude-agent-acp/issues/748)) ([ec14211](https://github.com/agentclientprotocol/claude-agent-acp/commit/ec142110561f680330c6976783805685c5c069ec))
-* Update to better utilize existing SDK data ([#747](https://github.com/agentclientprotocol/claude-agent-acp/issues/747)) ([398f763](https://github.com/agentclientprotocol/claude-agent-acp/commit/398f763f71bd2fe2ca9e8269de120d26a744b7a8))
-
-## [0.41.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.40.0...v0.41.0) (2026-06-04)
-
-
-### Features
-
-* **deps:** upgrade to @anthropic-ai/claude-agent-sdk@0.3.162 ([#740](https://github.com/agentclientprotocol/claude-agent-acp/issues/740)) ([add7e31](https://github.com/agentclientprotocol/claude-agent-acp/commit/add7e31704581aa70febb6341ca0e8cee5d93b43))
-
-
-### Bug Fixes
-
-* Force cancellation when SDK query hangs ([#742](https://github.com/agentclientprotocol/claude-agent-acp/issues/742)) ([cffea4b](https://github.com/agentclientprotocol/claude-agent-acp/commit/cffea4be28e6def91027110433a99e80b1be8a0c)), closes [#680](https://github.com/agentclientprotocol/claude-agent-acp/issues/680)
-
-## [0.40.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.39.0...v0.40.0) (2026-06-02)
-
-
-### Features
-
-* **deps-dev:** bump the minor group with 2 updates ([#726](https://github.com/agentclientprotocol/claude-agent-acp/issues/726)) ([51a370e](https://github.com/agentclientprotocol/claude-agent-acp/commit/51a370e4feb8a74279698b156e35b96631a74d74))
-* **deps:** bump actions/checkout from 6.0.2 to 6.0.3 ([#736](https://github.com/agentclientprotocol/claude-agent-acp/issues/736)) ([9cda07b](https://github.com/agentclientprotocol/claude-agent-acp/commit/9cda07ba9df27b48bd94332e365eed982e3f5613))
-* **deps:** bump the minor group with 50 updates ([#737](https://github.com/agentclientprotocol/claude-agent-acp/issues/737)) ([32175b8](https://github.com/agentclientprotocol/claude-agent-acp/commit/32175b83a0227d0baa1f7d7eedabe743b4b870e8))
-
-
-### Bug Fixes
-
-* Optimize local command marker stripping ([#738](https://github.com/agentclientprotocol/claude-agent-acp/issues/738)) ([895422c](https://github.com/agentclientprotocol/claude-agent-acp/commit/895422c72d5f955903f227dc6887df823d2730e6)), closes [#727](https://github.com/agentclientprotocol/claude-agent-acp/issues/727)
-
-## [0.39.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.38.0...v0.39.0) (2026-05-29)
-
-
-### Features
-
-* **deps:** update Claude Agent SDK to 0.3.156 ([#722](https://github.com/agentclientprotocol/claude-agent-acp/issues/722)) ([3fb6db4](https://github.com/agentclientprotocol/claude-agent-acp/commit/3fb6db4e5ee5bd1f431cf5d2ce5331ce983f9597))
-
-## [0.38.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.37.0...v0.38.0) (2026-05-28)
-
-
-### Features
-
-* **deps:** bump to @anthropic-ai/claude-agent-sdk 0.3.154 (Opus 4.8) ([#716](https://github.com/agentclientprotocol/claude-agent-acp/issues/716)) ([a172885](https://github.com/agentclientprotocol/claude-agent-acp/commit/a172885c80fc32c108a8501268a543641088f543))
-* Support Opus 4.8 ([#718](https://github.com/agentclientprotocol/claude-agent-acp/issues/718)) ([98b54a0](https://github.com/agentclientprotocol/claude-agent-acp/commit/98b54a02c267cdef619becceccf6ef519fbf8f6f))
-
-
-### Bug Fixes
-
-* Remove hide Claude auth flag handling ([#707](https://github.com/agentclientprotocol/claude-agent-acp/issues/707)) ([7ed1daf](https://github.com/agentclientprotocol/claude-agent-acp/commit/7ed1daf7b42088ad149e9bf742f764752b82d093))
-
-## [0.37.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.36.1...v0.37.0) (2026-05-21)
-
-
-### Features
-
-* add 'Default' option to effort level config ([#701](https://github.com/agentclientprotocol/claude-agent-acp/issues/701)) ([9e259d1](https://github.com/agentclientprotocol/claude-agent-acp/commit/9e259d128aa58dbb8107e53362781ca4e8ee071e))
-* **deps:** bump the claude-agent-sdk to 0.3.146 ([#700](https://github.com/agentclientprotocol/claude-agent-acp/issues/700)) ([72875b2](https://github.com/agentclientprotocol/claude-agent-acp/commit/72875b248c7b90a89638de2f1709eec9e2153e7e))
-* **deps:** bump the minor group with 13 updates ([#689](https://github.com/agentclientprotocol/claude-agent-acp/issues/689)) ([f66bc31](https://github.com/agentclientprotocol/claude-agent-acp/commit/f66bc31ae4bea73b48eeeb7f1db90c7d69cc0dac))
-* Emit tool calls for memory recall events ([#703](https://github.com/agentclientprotocol/claude-agent-acp/issues/703)) ([a0bfb98](https://github.com/agentclientprotocol/claude-agent-acp/commit/a0bfb98ba73eaf37e9c071e886c054f90a5d5629)), closes [#650](https://github.com/agentclientprotocol/claude-agent-acp/issues/650)
-
-
-### Bug Fixes
-
-* Avoid cross-version model alias matches ([#702](https://github.com/agentclientprotocol/claude-agent-acp/issues/702)) ([e1e1c69](https://github.com/agentclientprotocol/claude-agent-acp/commit/e1e1c69029ef08579c841e6fbdffb32a5b94df06))
-* Avoid redundant initial model sync ([#704](https://github.com/agentclientprotocol/claude-agent-acp/issues/704)) ([b275f6f](https://github.com/agentclientprotocol/claude-agent-acp/commit/b275f6ff7f0f2e21adedbd8e63a6fc3d63cbbb8d)), closes [#646](https://github.com/agentclientprotocol/claude-agent-acp/issues/646)
-* Don't expose /clear in commands ([#705](https://github.com/agentclientprotocol/claude-agent-acp/issues/705)) ([cfce130](https://github.com/agentclientprotocol/claude-agent-acp/commit/cfce1307076e93f43a3ed8cc0134f9bb14a0f2d6))
-* emit  "cancelled" instead of "end_turn" when the session was interrupted. ([#694](https://github.com/agentclientprotocol/claude-agent-acp/issues/694)) ([2414a6f](https://github.com/agentclientprotocol/claude-agent-acp/commit/2414a6f98bec5bf50f3a13af528aa38d5a0fc974))
-* Recover prompt stream after a failed turn ([#706](https://github.com/agentclientprotocol/claude-agent-acp/issues/706)) ([2711f50](https://github.com/agentclientprotocol/claude-agent-acp/commit/2711f506d5799f0ae25160de311a4459ffb46c49)), closes [#654](https://github.com/agentclientprotocol/claude-agent-acp/issues/654)
-
-## [0.36.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.36.0...v0.36.1) (2026-05-18)
-
-
-### Bug Fixes
-
-* flaky authentication bypass for gateway ([#686](https://github.com/agentclientprotocol/claude-agent-acp/issues/686)) ([db852dc](https://github.com/agentclientprotocol/claude-agent-acp/commit/db852dcf7c8e3b461fabb1bdcf0c80a27d1da77d))
-
-## [0.36.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.35.0...v0.36.0) (2026-05-18)
-
-
-### Features
-
-* Add experimental session delete support ([#682](https://github.com/agentclientprotocol/claude-agent-acp/issues/682)) ([2162d5a](https://github.com/agentclientprotocol/claude-agent-acp/commit/2162d5af62d493a82381bd88bc8fc67d376e358b))
-* Support experimental additionalDirectories field ([#684](https://github.com/agentclientprotocol/claude-agent-acp/issues/684)) ([f37e9a0](https://github.com/agentclientprotocol/claude-agent-acp/commit/f37e9a0d47d8d201d98b2177083664a6781895cc))
-
-## [0.35.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.34.1...v0.35.0) (2026-05-16)
-
-
-### Features
-
-* **deps:** bump actions/create-github-app-token from 3.1.1 to 3.2.0 ([#669](https://github.com/agentclientprotocol/claude-agent-acp/issues/669)) ([47df1f2](https://github.com/agentclientprotocol/claude-agent-acp/commit/47df1f2a0be57ddb8873ae8e341f748471c7bc53))
-* **deps:** bump hono from 4.12.18 to 4.12.19 in the minor group ([#671](https://github.com/agentclientprotocol/claude-agent-acp/issues/671)) ([5d7165d](https://github.com/agentclientprotocol/claude-agent-acp/commit/5d7165d96158da2ddf3087676cdb0a19d1ff57aa))
-* **deps:** update to claude-agent-sdk 0.3.143 ([#664](https://github.com/agentclientprotocol/claude-agent-acp/issues/664)) ([27ca2e5](https://github.com/agentclientprotocol/claude-agent-acp/commit/27ca2e5d40917887671cc4c39a854fd8f92c01e6))
-* Use SDK settings resolution for defaults ([#677](https://github.com/agentclientprotocol/claude-agent-acp/issues/677)) ([eb1259c](https://github.com/agentclientprotocol/claude-agent-acp/commit/eb1259cf88375ca3c20a219ab99f12f5488fb360))
-
-
-### Bug Fixes
-
-* Add task hooks for plan state updates ([#676](https://github.com/agentclientprotocol/claude-agent-acp/issues/676)) ([5ff7d50](https://github.com/agentclientprotocol/claude-agent-acp/commit/5ff7d50f0ec7f34a7d9d901223aed73e2dbcce68))
-* render local-command-stdout messages instead of dropping them ([#649](https://github.com/agentclientprotocol/claude-agent-acp/issues/649)) ([3b9b7d5](https://github.com/agentclientprotocol/claude-agent-acp/commit/3b9b7d5a56defd925eb2038fa97b6484ad951587))
-
-## [0.34.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.34.0...v0.34.1) (2026-05-16)
-
-
-### Bug Fixes
-
-* load credential error for bedrock gateway ([#667](https://github.com/agentclientprotocol/claude-agent-acp/issues/667)) ([8d76be3](https://github.com/agentclientprotocol/claude-agent-acp/commit/8d76be356a3e74c58a7c93c3c201cca6a317d784))
-
-## [0.34.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.33.1...v0.34.0) (2026-05-15)
-
-
-### Features
-
-* add bedrock gateway authentication ([#665](https://github.com/agentclientprotocol/claude-agent-acp/issues/665)) ([002c63a](https://github.com/agentclientprotocol/claude-agent-acp/commit/002c63a78b844c168d3dfc744cf408362a6adf97))
-
-## [0.33.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.33.0...v0.33.1) (2026-05-07)
-
-
-### Bug Fixes
-
-* Honor availableModels settings allowlist ([#637](https://github.com/agentclientprotocol/claude-agent-acp/issues/637)) ([867a3a0](https://github.com/agentclientprotocol/claude-agent-acp/commit/867a3a0de2a050592d79aa76d7dd3dd5b478162d)), closes [#620](https://github.com/agentclientprotocol/claude-agent-acp/issues/620)
-
-## [0.33.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.32.0...v0.33.0) (2026-05-07)
-
-
-### Features
-
-* **deps:** bump the minor group with 14 updates ([#631](https://github.com/agentclientprotocol/claude-agent-acp/issues/631)) ([8b43ee8](https://github.com/agentclientprotocol/claude-agent-acp/commit/8b43ee813f05f5087a213a7f42154e39d6bc4a5a))
-* **deps:** Update to claude-agent-sdk 0.2.132 ([#636](https://github.com/agentclientprotocol/claude-agent-acp/issues/636)) ([0c8ff27](https://github.com/agentclientprotocol/claude-agent-acp/commit/0c8ff277f2af8d3085cc1b5cf33891630dede0b1))
-
-
-### Bug Fixes
-
-* Handle result origins in ACP agent ([#627](https://github.com/agentclientprotocol/claude-agent-acp/issues/627)) ([dba1998](https://github.com/agentclientprotocol/claude-agent-acp/commit/dba199839a25ba405f04b9d4409e647150fe0290))
-
-## [0.32.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.31.4...v0.32.0) (2026-05-03)
-
-
-### Features
-
-* **deps-dev:** Bump nanoid from 3.3.11 to 3.3.12 ([#622](https://github.com/agentclientprotocol/claude-agent-acp/issues/622)) ([c78ac62](https://github.com/agentclientprotocol/claude-agent-acp/commit/c78ac62d05283e5683b87b198923818f9f556a03))
-* **deps:** Bump the minor group with 2 updates ([#619](https://github.com/agentclientprotocol/claude-agent-acp/issues/619)) ([6ccd37c](https://github.com/agentclientprotocol/claude-agent-acp/commit/6ccd37ce947fbd55691f676344b15ef1266191ad))
-* **deps:** update to @anthropic-ai/claude-agent-sdk 0.2.126 ([#621](https://github.com/agentclientprotocol/claude-agent-acp/issues/621)) ([becc3b8](https://github.com/agentclientprotocol/claude-agent-acp/commit/becc3b86e60eb33e7823a0ef27d5aa99758750d7))
-* **deps:** Update to @anthropic-ai/claude-agent-sdk@0.2.123 ([#614](https://github.com/agentclientprotocol/claude-agent-acp/issues/614)) ([5b93119](https://github.com/agentclientprotocol/claude-agent-acp/commit/5b9311938d97f47400debd66f2b4792e50639c6b))
-
-
-### Bug Fixes
-
-* emit a real diff when Write overwrites an existing file ([#618](https://github.com/agentclientprotocol/claude-agent-acp/issues/618)) ([8d7e220](https://github.com/agentclientprotocol/claude-agent-acp/commit/8d7e22026e15d54208414bd9ad128eb86d41b451))
-
-## [0.31.4](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.31.3...v0.31.4) (2026-04-28)
-
-
-### Bug Fixes
-
-* gate auto mode on model support ([#604](https://github.com/agentclientprotocol/claude-agent-acp/issues/604)) ([ec47d34](https://github.com/agentclientprotocol/claude-agent-acp/commit/ec47d3446fa22e5895621f57c0a4497dbe044505))
-
-## [0.31.3](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.31.2...v0.31.3) (2026-04-28)
-
-
-### Bug Fixes
-
-* Rename effort config category to thought_level ([#609](https://github.com/agentclientprotocol/claude-agent-acp/issues/609)) ([76b4e96](https://github.com/agentclientprotocol/claude-agent-acp/commit/76b4e9650832e59a6b4915ad898fc66a065022fa))
-
-## [0.31.2](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.31.1...v0.31.2) (2026-04-28)
-
-
-### Bug Fixes
-
-* tolerate invalid values in settings.json ([#601](https://github.com/agentclientprotocol/claude-agent-acp/issues/601)) ([67af018](https://github.com/agentclientprotocol/claude-agent-acp/commit/67af018d0216238d8f3cd5bad04a55200518239b))
-
-## [0.31.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.31.0...v0.31.1) (2026-04-27)
-
-
-### Bug Fixes
-
-* detect glibc and use correct binary ([#599](https://github.com/agentclientprotocol/claude-agent-acp/issues/599)) ([f0801d5](https://github.com/agentclientprotocol/claude-agent-acp/commit/f0801d50b2390a3c48150b9b8507d30a70c18b84))
-
-## [0.31.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.30.0...v0.31.0) (2026-04-24)
-
-
-### Features
-
-* allow configuring models through env vars ([#586](https://github.com/agentclientprotocol/claude-agent-acp/issues/586)) ([1e15f3d](https://github.com/agentclientprotocol/claude-agent-acp/commit/1e15f3d8b0a06076ee62764ab576ac29fe056a38))
-* Support effort levels ([#464](https://github.com/agentclientprotocol/claude-agent-acp/issues/464)) ([9e1185b](https://github.com/agentclientprotocol/claude-agent-acp/commit/9e1185bfd55cbf83a653a0ff8c194f986cbd1574))
-* Update to acp sdk v0.20 ([#589](https://github.com/agentclientprotocol/claude-agent-acp/issues/589)) ([92adcbd](https://github.com/agentclientprotocol/claude-agent-acp/commit/92adcbd1ace2f2103742ffcf5c589eb1ca41b9b8))
-* Update to claude-agent-sdk 0.2.119 ([#587](https://github.com/agentclientprotocol/claude-agent-acp/issues/587)) ([ef1dbd1](https://github.com/agentclientprotocol/claude-agent-acp/commit/ef1dbd1cb457f0524d221ea07235abf49dc941a0))
-
-
-### Bug Fixes
-
-* Forward full systemPrompt preset options from _meta ([#591](https://github.com/agentclientprotocol/claude-agent-acp/issues/591)) ([b3ddfc3](https://github.com/agentclientprotocol/claude-agent-acp/commit/b3ddfc3b86703c23fe99d93611885c12b1e4812c))
-* Session Replay and Permission rendering ([#593](https://github.com/agentclientprotocol/claude-agent-acp/issues/593)) ([5faefab](https://github.com/agentclientprotocol/claude-agent-acp/commit/5faefab8ab9b725f7a3374808bf5579e411884bc)), closes [#579](https://github.com/agentclientprotocol/claude-agent-acp/issues/579)
-
-## [0.30.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.29.2...v0.30.0) (2026-04-20)
-
-
-### Features
-
-* Update to claude-agent-sdk 0.2.114 ([#572](https://github.com/agentclientprotocol/claude-agent-acp/issues/572)) ([e9dd452](https://github.com/agentclientprotocol/claude-agent-acp/commit/e9dd45207d396302f20de82561135bf9558c0e76))
-
-## [0.29.2](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.29.1...v0.29.2) (2026-04-17)
-
-
-### Bug Fixes
-
-* Guard against null usage tokens ([#565](https://github.com/agentclientprotocol/claude-agent-acp/issues/565)) ([f7dc300](https://github.com/agentclientprotocol/claude-agent-acp/commit/f7dc300a165e70f6426f53920f12e24c04033cdc)), closes [#564](https://github.com/agentclientprotocol/claude-agent-acp/issues/564)
-
-## [0.29.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.29.0...v0.29.1) (2026-04-17)
-
-
-### Bug Fixes
-
-* emit usage updates from Claude stream events ([#506](https://github.com/agentclientprotocol/claude-agent-acp/issues/506)) ([dd67450](https://github.com/agentclientprotocol/claude-agent-acp/commit/dd67450fd9bddc82db3e71273b535e07b2672804))
-* Remove dot from auto mode description ([#561](https://github.com/agentclientprotocol/claude-agent-acp/issues/561)) ([2ecfa83](https://github.com/agentclientprotocol/claude-agent-acp/commit/2ecfa83b26db58deaded210463fa6ff21d0dff70))
-* Update to claude-agent-sdk 0.2.112 to fix Auto bug with Opus 4.7 ([#562](https://github.com/agentclientprotocol/claude-agent-acp/issues/562)) ([079614a](https://github.com/agentclientprotocol/claude-agent-acp/commit/079614ab05afba17e2cce0d3d238df7b90e17389))
-
-## [0.29.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.28.0...v0.29.0) (2026-04-16)
-
-
-### Features
-
-* Update to claude-agent-sdk 0.2.111 (Opus 4.7) ([#557](https://github.com/agentclientprotocol/claude-agent-acp/issues/557)) ([85cd70c](https://github.com/agentclientprotocol/claude-agent-acp/commit/85cd70c9f3be47c9c404958547c4046d866db1c9))
-
-## [0.28.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.27.0...v0.28.0) (2026-04-15)
-
-
-### Features
-
-* Update to claude-agent-sdk 0.2.109 ([#549](https://github.com/agentclientprotocol/claude-agent-acp/issues/549)) ([07a0fbc](https://github.com/agentclientprotocol/claude-agent-acp/commit/07a0fbc2f6bc388541d064a436412bdd850772cb))
-
-## [0.27.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.26.0...v0.27.0) (2026-04-13)
-
-
-### Features
-
-* allow clients to opt into receiving raw SDK messages ([#527](https://github.com/agentclientprotocol/claude-agent-acp/issues/527)) ([403a668](https://github.com/agentclientprotocol/claude-agent-acp/commit/403a668078c067868062ed26cd4d3e36665b66b6))
-* Update to claude-agent-sdk 0.2.104 ([#537](https://github.com/agentclientprotocol/claude-agent-acp/issues/537)) ([6811943](https://github.com/agentclientprotocol/claude-agent-acp/commit/6811943f57ef08616be633a8197223d4072663cf))
-
-
-### Bug Fixes
-
-* Allow auto mode after plan mode and send description for auto mode ([#528](https://github.com/agentclientprotocol/claude-agent-acp/issues/528)) ([fb9aced](https://github.com/agentclientprotocol/claude-agent-acp/commit/fb9aced3151c40694f1f01fd95665c4f5d90eb67))
-* Better remote check for auth methods ([#538](https://github.com/agentclientprotocol/claude-agent-acp/issues/538)) ([93f58c0](https://github.com/agentclientprotocol/claude-agent-acp/commit/93f58c0d2fcf7365c7ca5a6e52f56663e2065ddb))
-* better shutdown logic ([#543](https://github.com/agentclientprotocol/claude-agent-acp/issues/543)) ([9fb631f](https://github.com/agentclientprotocol/claude-agent-acp/commit/9fb631f5d76a5c5f6f0a1b61bdef05fe368c754c))
-* exit process when ACP connection closes ([#530](https://github.com/agentclientprotocol/claude-agent-acp/issues/530)) ([5c81e99](https://github.com/agentclientprotocol/claude-agent-acp/commit/5c81e99fe5ccdf774819b7ff3a2bc78a6519d730))
-* guard tool info rendering when tool_use input is undefined ([#536](https://github.com/agentclientprotocol/claude-agent-acp/issues/536)) ([d627b8c](https://github.com/agentclientprotocol/claude-agent-acp/commit/d627b8c5e95be31ac03923ef67d91748ec8564c5))
-* Remove backup auth check from new session ([#544](https://github.com/agentclientprotocol/claude-agent-acp/issues/544)) ([32b16c1](https://github.com/agentclientprotocol/claude-agent-acp/commit/32b16c1ad99394238b0e5cd6c2f761c12debe142))
-
-## [0.26.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.25.3...v0.26.0) (2026-04-08)
-
-
-### Features
-
-* Update claude-agent-sdk to 0.2.96 ([#526](https://github.com/agentclientprotocol/claude-agent-acp/issues/526)) ([c073131](https://github.com/agentclientprotocol/claude-agent-acp/commit/c07313148808a55f27f385c10babbaf7511a7f12))
-
-
-### Bug Fixes
-
-* Remove bun builds from release ([#525](https://github.com/agentclientprotocol/claude-agent-acp/issues/525)) ([fcf5aaf](https://github.com/agentclientprotocol/claude-agent-acp/commit/fcf5aaf06dfe9f7d1b285b976eeb2d1e20ea8dec))
-* Use TUI login for remote environments ([#523](https://github.com/agentclientprotocol/claude-agent-acp/issues/523)) ([cc73e37](https://github.com/agentclientprotocol/claude-agent-acp/commit/cc73e37b41678aa67813c4fbef66ba33ca538743))
-
-## [0.25.3](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.25.2...v0.25.3) (2026-04-06)
-
-
-### Bug Fixes
-
-* Drop claude-agent-sdk back to 0.2.91 to fix broken import ([#513](https://github.com/agentclientprotocol/claude-agent-acp/issues/513)) ([26f3e8a](https://github.com/agentclientprotocol/claude-agent-acp/commit/26f3e8a5216295985fadb80fb3b977045c0c1b2c))
-* Recreate resumed sessions when params change ([#515](https://github.com/agentclientprotocol/claude-agent-acp/issues/515)) ([aa82193](https://github.com/agentclientprotocol/claude-agent-acp/commit/aa82193330026bae132fed8391c47dde777dcf5a))
-
-## [0.25.2](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.25.1...v0.25.2) (2026-04-06)
-
-
-### Bug Fixes
-
-* prioritize ANTHROPIC_MODEL env var over settings.model in model … ([#505](https://github.com/agentclientprotocol/claude-agent-acp/issues/505)) ([bea1a40](https://github.com/agentclientprotocol/claude-agent-acp/commit/bea1a40e9bfe1e06672b118a727f9339def3be23))
-
-## [0.25.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.25.0...v0.25.1) (2026-04-06)
-
-
-### Bug Fixes
-
-* add `auto` to valid modes in applySessionMode to fix mode cycling ([#507](https://github.com/agentclientprotocol/claude-agent-acp/issues/507)) ([15e91fb](https://github.com/agentclientprotocol/claude-agent-acp/commit/15e91fb5c3449de2600b583cb7a8d36b5b510443))
-
-## [0.25.0](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.24.2...v0.25.0) (2026-04-03)
-
-
-### Features
-
-* Add auto permission mode support ([#501](https://github.com/agentclientprotocol/claude-agent-acp/issues/501)) ([a161453](https://github.com/agentclientprotocol/claude-agent-acp/commit/a16145396fe2e6ead8734478961b2de65707e335))
-* Add separate Claude and Console terminal logins ([#502](https://github.com/agentclientprotocol/claude-agent-acp/issues/502)) ([063cd35](https://github.com/agentclientprotocol/claude-agent-acp/commit/063cd353809df8f3dda9e57d8ea848c0a6d44257))
-* Update to claude-agent-sdk 0.2.91 ([#500](https://github.com/agentclientprotocol/claude-agent-acp/issues/500)) ([65a2230](https://github.com/agentclientprotocol/claude-agent-acp/commit/65a223038576d72b74e1483fed10e982a1f842bd))
-
-
-### Bug Fixes
-
-* log warnings for malformed settings files instead of silent fallback ([#486](https://github.com/agentclientprotocol/claude-agent-acp/issues/486)) ([ae6c388](https://github.com/agentclientprotocol/claude-agent-acp/commit/ae6c38831415f9fc1de2d3dd1d4a247becbbd32f))
-* prevent race conditions in SettingsManager setCwd and debounce ([#485](https://github.com/agentclientprotocol/claude-agent-acp/issues/485)) ([7506223](https://github.com/agentclientprotocol/claude-agent-acp/commit/7506223cffb1aba4b4560feda11f69a1395a8c9d))
-* use current model's context window for usage_update size ([#412](https://github.com/agentclientprotocol/claude-agent-acp/issues/412)) ([d07799d](https://github.com/agentclientprotocol/claude-agent-acp/commit/d07799d7b3b4e438c8b158266c79723a0b592c07))
-
-## [0.24.2](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.24.1...v0.24.2) (2026-03-27)
-
-
-### Bug Fixes
-
-* Add explicit type checks for MCP servers (http/sse) ([#487](https://github.com/agentclientprotocol/claude-agent-acp/issues/487)) ([e00a439](https://github.com/agentclientprotocol/claude-agent-acp/commit/e00a43901fa2b4fd7d582e1de57277be88233007))
-
-## [0.24.1](https://github.com/agentclientprotocol/claude-agent-acp/compare/v0.24.0...v0.24.1) (2026-03-26)
-
-
-### Bug Fixes
-
-* Cleanup based on new idle state [#463](https://github.com/agentclientprotocol/claude-agent-acp/issues/463) ([#480](https://github.com/agentclientprotocol/claude-agent-acp/issues/480)) ([23b3073](https://github.com/agentclientprotocol/claude-agent-acp/commit/23b30730253752f0bc4e30b619a6236f16fafdb9))
-
-## 0.24.0
-
-Rename from `@zed-industries/claude-agent-acp` to `@agentclientprotocol/claude-agent-acp`.
-
-We are moving this to the main ACP org to better allow multiple teams to contribute and maintain this adapter.
-
-## 0.23.1
-
- Add back error_during_execution break point (#469)
-
-## 0.23.0
-
- Use idle session state as end of turn (#463)
- Update claude-agent-sdk to 0.2.83 (#462)
- Fix handling of local-only slash commands (#432)
- fix: correct null check for gatewayAuthMeta in subscription validation (#455)
- fix: include both stdout and stderr in Bash tool output (#456)
- fix: prevent prompt loop hang when cancel races with first result (#458)
- fix: dispose SettingsManager on session close to prevent resource leaks (#454)
- fix: restore plan content in ExitPlanMode tool call (#451)
-
-## 0.22.2
-
- Add experimental meta param for testing additional directories
-
-## 0.22.1
-
- Fix: invalid auth required state in gateway mode
-
-## 0.22.0
-
- Use stable list sessions method (#429)
- Use correct Claude CLI path for static binaries (#428)
- Update claude-agent-sdk to 0.2.76 (#427)
- fix: resolve model aliases in setSessionConfigOption (#401) (#403)
- Reuse existing sessions for load/resume if possible (#426)
- Remove interrupt flag from deny responses (#425)
- Allow Bypass permissions mode after Exiting plan (#410)
- Don't get out of sync when background task creates new init/result (try 2) (#400)
- Add session/close support (#409)
-
-## 0.21.0
-
- Update to claude-agent-sdk 0.2.71
- show project-relative paths in tool call titles
- Lib: pass through tools array to control built-in tool availability
- fix: skip user replay
- fix: handle renamed Agent tool in toolInfoFromToolUse
-
-## 0.20.2
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.68
-
-## 0.20.1
-
- fix: inherit process.env when spawning agent subprocess
-
-## 0.20.0
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.63
- Respect user settings for permission mode and model selection
- Better handling of concurrent prompts
- Support --cli for node as well
- Propagate max_tokens stop reason instead of throwing internal error
- fix: throw resourceNotFound when loadSession fails to resume
- fix: add missing zod dependency
- Surface better error message when Claude Code process exits unexpectedly
-
-## 0.19.2
-
- Fix for broken notifications when reloading session messages
-
-## 0.19.1
-
- Support windows arm builds and clean up artifact files
-
-## 0.19.0
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.62
- Use SDK functions for listing and loading session history
- Build single-file executables using bun.
- Fix for overwritten disallowed tools.
-
-## 0.18.0
-
- Switch over to built-in Claude tools. We no longer replicate specific ACP tools and just rely on sending updates based on Claude's internal tools. This means it won't use client capabilities for files or terminals, but also means there will be less difference and hopefully issues arising from the differences in behavior.
- Support ACP session config options: https://agentclientprotocol.com/protocol/session-config-options
- Fix for image output from tool calls.
-
-## 0.17.1
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.45 to add access to Sonnet 4.6
-
-## 0.17.0
-
-Rename from `@zed-industries/claude-code-acp` to `@zed-industries/claude-agent-acp` to align with the current [branding guidelines](https://platform.claude.com/docs/en/agent-sdk/overview#branding-guidelines)
-
-## 0.16.2
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.44
- fix: Replace all non-alphanumeric characters for session loading in encodeProjectPath (#307)
- don't include /login slash command in login command (#315)
-
-## 0.16.1
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.38
- Fix incorrect paths for session/list
- Fix available commands after loading a session
- Make loading session more permissive for finding events
- Fix overriding user-provided disallowedTools
-
-## 0.16.0
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.34
- Experimental support for session loading
-
-## 0.15.0
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.32 (adds support for Opus 4.6 and 1M context Opus)
-
-## 0.14.0
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.29
- Update to using the recommended `CLAUDE_CONFIG_DIR` env variable for setting where config files are kept
- Support /context command
- Fix incorrect context type mapping for tool calls
- Fix glob metching for file permissions on Windows
- Support the `IS_SANDBOX` env var for supporting bypass permissions in root mode
- Fix missing notification for entering plan mode
- Experimental unstable support for listing sessions
-
-## 0.13.2
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.22
- Fix: return content from ACP write tool to help with issues with alternate providers.
-
-## 0.13.1
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.7
- Add TypeScript declaration files for library users
- Fixed error handling in custom ACP focused MCP tools
-
-## 0.13.0
-
- Update to @anthropic-ai/claude-agent-sdk@0.2.6
- Update to @agentclientprotocol/sdk@0.13.0
-
-## 0.12.6
-
- Fix model selection
-
-## 0.12.5
-
- Update to @anthropic-ai/claude-agent-sdk@v0.1.70
- Unstable implementation of resuming sessions
-
-## 0.12.4
-
- Update to @anthropic-ai/claude-agent-sdk@v0.1.67
- Better respect permissions specified in settings files
- Unstable implementation of forking
-
 ## 0.12.3

- Update to @anthropic-ai/claude-agent-sdk@v0.1.65
- Update to @agentclientprotocol/sdk@0.9.0
 - Allow agent to write plans and todos to its config directory
 - Fix experimental resume ids

--- a/61
+++ b/61
@@ -1,18 +1,42 @@
+Copyright 2022 - 2025 Zed Industries, Inc.

-                                 Apache License
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+
+
+Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

+
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

+
   1. Definitions.

+
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

+
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

+
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
@@ -21,23 +45,28 @@
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

+
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

+
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

+
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

+
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

+
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
@@ -46,6 +75,7 @@
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

+
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
@@ -60,10 +90,12 @@
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

+
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

+
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
@@ -71,6 +103,7 @@
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

+
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
@@ -87,23 +120,28 @@
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

+
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

+
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

+
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

+
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

+
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
@@ -121,6 +159,7 @@
          that such additional attribution notices cannot be construed
          as modifying the License.

+
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
@@ -128,6 +167,7 @@
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

+
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
@@ -136,11 +176,13 @@
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

+
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

+
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
@@ -151,6 +193,7 @@
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

+
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
@@ -163,6 +206,7 @@
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

+
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
@@ -174,18 +218,5 @@
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

+
   END OF TERMS AND CONDITIONS
-
-   Copyright 2025 Zed Industries, Inc. and contributors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# ACP adapter for the Claude Agent SDK
+# ACP adapter for Claude Code

-[![npm](https://img.shields.io/npm/v/%40agentclientprotocol%2Fclaude-agent-acp)](https://www.npmjs.com/package/@agentclientprotocol/claude-agent-acp)
+[![npm](https://img.shields.io/npm/v/%40zed-industries%2Fclaude-code-acp)](https://www.npmjs.com/package/@zed-industries/claude-code-acp)

-Use [Claude Agent SDK](https://platform.claude.com/docs/en/agent-sdk/overview#branding-guidelines) from [ACP-compatible](https://agentclientprotocol.com) clients!
+Use [Claude Code](https://www.anthropic.com/claude-code) from [ACP-compatible](https://agentclientprotocol.com) clients such as [Zed](https://zed.dev)!

-This tool implements an ACP agent by using the official [Claude Agent SDK](https://platform.claude.com/docs/en/agent-sdk/overview), supporting:
+This tool implements an ACP agent by using the official [Claude Code SDK](https://docs.anthropic.com/en/docs/claude-code/sdk/sdk-overview), supporting:

 - Context @-mentions
 - Images
@@ -18,8 +18,42 @@ This tool implements an ACP agent by using the official [Claude Agent SDK](https

 Learn more about the [Agent Client Protocol](https://agentclientprotocol.com/).

-## Contribution Policy
+## How to use

-This project does not require a Contributor License Agreement (CLA). Instead, contributions are accepted under the following terms:
+### Zed

-> By contributing to this project, you agree that your contributions will be licensed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0). You affirm that you have the legal right to submit your work, that you are not including code you do not have rights to, and that you understand contributions are made without requiring a Contributor License Agreement (CLA).
+The latest version of Zed can already use this adapter out of the box.
+
+To use Claude Code, open the Agent Panel and click "New Claude Code Thread" from the `+` button menu in the top-right:
+
+https://github.com/user-attachments/assets/ddce66c7-79ac-47a3-ad59-4a6a3ca74903
+
+Read the docs on [External Agent](https://zed.dev/docs/ai/external-agents) support.
+
+### Other clients
+
+- Emacs via [agent-shell.el](https://github.com/xenodium/agent-shell)
+- [marimo notebook](https://github.com/marimo-team/marimo)
+- Neovim
+  - via [CodeCompanion.nvim](https://codecompanion.olimorris.dev/configuration/adapters#setup-claude-code-via-acp)
+  - via [yetone/avante.nvim](https://github.com/yetone/avante.nvim)
+
+[Submit a PR](https://github.com/zed-industries/claude-code-acp/pulls) to add yours!
+
+#### Installation
+
+Install the adapter from `npm`:
+
+```bash
+npm install @zed-industries/claude-code-acp
+```
+
+You can then use `claude-code-acp` as a regular ACP agent:
+
+```
+ANTHROPIC_API_KEY=sk-... claude-code-acp
+```
+
+## License
+
+Apache-2.0
--- a/docs/model-configuration.md
+++ b/docs/model-configuration.md
@@ -1,56 +0,0 @@
-# Model Configuration
-
-When using claude-agent-acp with alternative providers (e.g. AWS Bedrock), model IDs differ from the direct Anthropic API. The `CLAUDE_MODEL_CONFIG` environment variable lets you configure model overrides and availability at the deployment level.
-
-## `CLAUDE_MODEL_CONFIG`
-
-A JSON string with two optional fields:
-
-| Field             | Type                     | Description                                                                                                   |
-| ----------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------- |
-| `modelOverrides`  | `Record<string, string>` | Maps Anthropic model IDs to provider-specific model IDs (e.g. Bedrock model IDs or ARNs)                      |
-| `availableModels` | `string[]`               | Restricts which models are offered to users. Accepts aliases (`"opus"`), prefixes (`"opus-4-5"`), or full IDs |
-
-### Examples
-
-**Bedrock model overrides:**
-
-```bash
-CLAUDE_MODEL_CONFIG='{"modelOverrides":{"claude-opus-4-6":"us.anthropic.claude-opus-4-6-v1","claude-sonnet-4-5":"us.anthropic.claude-sonnet-4-5-v1"}}'
-```
-
-**Restrict available models:**
-
-```bash
-CLAUDE_MODEL_CONFIG='{"availableModels":["opus","sonnet"]}'
-```
-
-**Both together:**
-
-```bash
-CLAUDE_MODEL_CONFIG='{"modelOverrides":{"claude-opus-4-6":"us.anthropic.claude-opus-4-6-v1","claude-sonnet-4-5":"us.anthropic.claude-sonnet-4-5-v1"},"availableModels":["opus","sonnet"]}'
-```
-
-**Full Bedrock example:**
-
-```bash
-CLAUDE_CODE_USE_BEDROCK=1 \
-AWS_REGION=us-west-2 \
-CLAUDE_MODEL_CONFIG='{"modelOverrides":{"claude-opus-4-6":"us.anthropic.claude-opus-4-6-v1"}}' \
-node dist/index.js
-```
-
-## Precedence
-
-When an ACP caller provides `settings` via `_meta.claudeCode.options.settings` in the `sessions/create` request, `CLAUDE_MODEL_CONFIG` is ignored entirely. The env var is a deployment-level fallback for cases where the caller does not configure model settings itself.
-
-| Source                                       | Priority                                              |
-| -------------------------------------------- | ----------------------------------------------------- |
-| `_meta.claudeCode.options.settings` (caller) | Highest — used if present                             |
-| `CLAUDE_MODEL_CONFIG` (env var)              | Fallback — used only when caller provides no settings |
-
-## Format details
-
- The value must be valid JSON. Invalid JSON will cause session creation to fail with a parse error.
- Only `modelOverrides` and `availableModels` keys are read; other keys in the JSON are ignored.
- Both fields map directly to the Claude Agent SDK's `Settings` type.
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -40,7 +40,7 @@ export default [
      "default-case": "error",
      "prefer-const": "error",
      "no-var": "error",
-      eqeqeq: ["error", "smart"],
+      eqeqeq: ["error", "always"],
      curly: ["error", "all"],
    },
  },
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,26 +1,17 @@
 {
-  "name": "@agentclientprotocol/claude-agent-acp",
+  "name": "@zed-industries/claude-code-acp",
  "publishConfig": {
    "access": "public"
  },
-  "version": "0.58.1",
-  "description": "An ACP-compatible coding agent powered by the Claude Agent SDK (TypeScript)",
+  "version": "0.12.3",
+  "description": "An ACP-compatible coding agent powered by the Claude Code SDK (TypeScript)",
  "main": "dist/lib.js",
-  "types": "dist/lib.d.ts",
  "bin": {
-    "claude-agent-acp": "dist/index.js"
+    "claude-code-acp": "./dist/index.js"
  },
  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist/lib.d.ts",
-      "import": "./dist/lib.js"
-    },
-    "./*": "./*"
-  },
  "files": [
    "dist/",
-    "!dist/tests/",
    "README.md",
    "LICENSE",
    "package.json"
@@ -49,37 +40,33 @@
    "sdk",
    "code"
  ],
-  "homepage": "https://github.com/agentclientprotocol/claude-agent-acp#readme",
+  "homepage": "https://github.com/zed-industries/claude-code-acp#readme",
  "bugs": {
-    "url": "https://github.com/agentclientprotocol/claude-agent-acp/issues"
+    "url": "https://github.com/zed-industries/claude-code-acp/issues"
  },
  "repository": {
    "type": "git",
-    "url": "git+https://github.com/agentclientprotocol/claude-agent-acp.git"
+    "url": "git+https://github.com/zed-industries/claude-code-acp.git"
  },
  "author": "Zed Industries",
  "license": "Apache-2.0",
-  "engines": {
-    "node": ">=22"
-  },
  "dependencies": {
-    "@agentclientprotocol/sdk": "1.2.1",
-    "@anthropic-ai/claude-agent-sdk": "0.3.205",
-    "zod": "^3.25.0 || ^4.0.0"
+    "@agentclientprotocol/sdk": "0.8.0",
+    "@anthropic-ai/claude-agent-sdk": "0.1.61",
+    "@modelcontextprotocol/sdk": "1.24.3",
+    "diff": "8.0.2"
  },
  "devDependencies": {
-    "@anthropic-ai/sdk": "0.110.0",
-    "@eslint/js": "10.0.1",
-    "@tsconfig/node22": "22.0.5",
-    "@types/node": "26.1.1",
-    "@typescript-eslint/eslint-plugin": "8.63.0",
-    "@typescript-eslint/parser": "8.63.0",
-    "eslint": "10.6.0",
+    "@anthropic-ai/sdk": "0.71.2",
+    "@types/node": "24.10.1",
+    "@typescript-eslint/eslint-plugin": "8.48.1",
+    "@typescript-eslint/parser": "8.48.1",
+    "eslint": "9.39.1",
    "eslint-config-prettier": "10.1.8",
-    "globals": "17.7.0",
-    "prettier": "3.9.4",
+    "globals": "16.5.0",
+    "prettier": "3.7.4",
    "ts-node": "10.9.2",
-    "typescript": "6.0.3",
-    "vitest": "4.1.10"
+    "typescript": "5.9.3",
+    "vitest": "4.0.15"
  }
 }
--- a/release-please-config.json
+++ b/release-please-config.json
@@ -1,13 +0,0 @@
-{
-  "bump-minor-pre-major": true,
-  "bump-patch-for-minor-pre-major": true,
-  "packages": {
-    ".": {
-      "changelog-path": "CHANGELOG.md",
-      "release-type": "node",
-      "bump-minor-pre-major": true,
-      "bump-patch-for-minor-pre-major": true
-    }
-  },
-  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json"
-}
--- a/src/acp-agent.ts
+++ b/src/acp-agent.ts
--- a/src/elicitation.ts
+++ b/src/elicitation.ts
@@ -1,404 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { CreateElicitationResponse } from "@agentclientprotocol/sdk";
-import type {
-  CreateElicitationRequest,
-  ElicitationAcceptAction,
-  ElicitationPropertySchema,
-  ElicitationSchema,
-  EnumOption,
-} from "@agentclientprotocol/sdk";
-import type { ElicitationRequest, ElicitationResult } from "@anthropic-ai/claude-agent-sdk";
-import type {
-  AskUserQuestionInput,
-  AskUserQuestionOutput,
-} from "@anthropic-ai/claude-agent-sdk/sdk-tools.js";
-
-/**
- * Bridges between the Claude Agent SDK's elicitation/dialog callbacks and ACP's
- * (unstable) elicitation protocol.
- *
- * Two distinct SDK surfaces flow through here:
- *
- *   1. `onElicitation` — fired when an MCP server requests user input. These map
- *      directly onto ACP `session/create_elicitation` (form or url mode).
- *   2. The built-in AskUserQuestion tool — when a `canUseTool` callback is
- *      registered the SDK routes its permission check through `canUseTool`
- *      (not the interactive `permission_ask_user_question` dialog). We render
- *      its questions as an ACP form elicitation and feed the user's selections
- *      back as the tool's `updatedInput`, which the tool's own `call()` reads.
- */
-
-/** Modes the connected client advertised support for. */
-export type ElicitationSupport = {
-  form: boolean;
-  url: boolean;
-};
-
-/**
- * Convert an MCP elicitation request (from the SDK's `onElicitation` callback)
- * into an ACP `CreateElicitationRequest`. Returns `null` when the request can't
- * be represented (e.g. a url-mode request with no url).
- */
-export function mcpElicitationToCreateRequest(
-  request: ElicitationRequest,
-  sessionId: string,
-): CreateElicitationRequest | null {
-  if (request.mode === "url") {
-    if (!request.url) {
-      return null;
-    }
-    return {
-      mode: "url",
-      sessionId,
-      message: request.message,
-      url: request.url,
-      // URL elicitations need a stable id so the client can correlate the
-      // later `session/complete_elicitation` notification. MCP servers usually
-      // provide one; fall back to a generated id if not.
-      elicitationId: request.elicitationId ?? randomUUID(),
-    };
-  }
-
-  // Form mode (the default). The MCP `requestedSchema` is already a JSON Schema
-  // with primitive-typed properties, which is structurally what ACP expects.
-  return {
-    mode: "form",
-    sessionId,
-    message: request.message,
-    requestedSchema: normalizeElicitationSchema(request.requestedSchema),
-  };
-}
-
-/**
- * Content of an accepted elicitation response.
- *
- * Uses the SDK's validating guard rather than an `action === "accept"` check:
- * the guard both narrows past the union's custom/future variant and validates
- * the payload, so a malformed accept (right tag, ill-typed content) yields
- * empty content — the same classification the SDK's wire validators apply.
- */
-function acceptedElicitationContent(
-  response: CreateElicitationResponse,
-): NonNullable<ElicitationAcceptAction["content"]> {
-  return CreateElicitationResponse.isAccept(response) ? (response.content ?? {}) : {};
-}
-
-/**
- * Map an ACP elicitation response back to the MCP `ElicitResult` the SDK expects
- * to hand back to the requesting server.
- */
-export function createElicitationResponseToElicitResult(
-  response: CreateElicitationResponse,
-): ElicitationResult {
-  switch (response.action) {
-    case "accept":
-      return { action: "accept", content: acceptedElicitationContent(response) };
-    case "decline":
-      return { action: "decline" };
-    case "cancel":
-    default:
-      return { action: "cancel" };
-  }
-}
-
-/**
- * A single question as supplied by the AskUserQuestion tool. Derived from the
- * SDK's input type so the shape stays in sync; the SDK validates the model's
- * tool call against this schema before it reaches us.
- */
-export type AskUserQuestion = AskUserQuestionInput["questions"][number];
-
-/**
- * Pull the well-formed questions out of an AskUserQuestion tool input. Returns
- * `null` when there are no usable questions — including the case where every
- * entry is malformed and filtering leaves an empty list — so callers can treat
- * "nothing to ask" uniformly.
- */
-export function extractAskUserQuestions(input: Record<string, unknown>): AskUserQuestion[] | null {
-  const questions = (input as { questions?: unknown }).questions;
-  if (!Array.isArray(questions)) {
-    return null;
-  }
-  const valid = questions.filter(
-    (q): q is AskUserQuestion =>
-      !!q && typeof q.question === "string" && Array.isArray(q.options) && q.options.length > 0,
-  );
-  return valid.length > 0 ? valid : null;
-}
-
-/** Stable form-field key for the question at the given index. */
-function questionFieldKey(index: number): string {
-  return `question_${index}`;
-}
-
-/**
- * Form-field key for the per-question free-text "custom answer" field that sits
- * alongside `question_<n>`. Mirrors the first-party clients, where every
- * question carries its own "Other" box rather than one form-level field.
- */
-function questionCustomFieldKey(index: number): string {
-  return `question_${index}_custom`;
-}
-
-/**
- * `_meta` key under which a bridged enum option carries its `preview`, the one
- * option field ACP's `EnumOption` still has no slot for (descriptions are
- * first-class as of schema 1.19). Namespaced like the agent's other `_meta`
- * extensions (`_claude/...`).
- */
-const OPTION_META_KEY = "_claude/askUserQuestionOption";
-
-/**
- * Render the AskUserQuestion tool's questions as an ACP form elicitation.
- *
- * Fields are keyed by a short stable id (`question_<n>`) rather than the full
- * question text, so the question text appears in exactly one place per field.
- * Single-select questions use a titled `oneOf` enum; multi-select questions use
- * an array with a titled `anyOf` item enum. The enum `const` is always the
- * option label, since that is what the tool records as the answer; an option's
- * secondary text travels in the enum option's own `description` field.
- *
- * Each question is followed by its own optional free-text "custom answer" field
- * (`question_<n>_custom`), mirroring the CLI's per-question "Other" box: the
- * user can type their own answer instead of picking an option, scoped to that
- * specific question. Nothing is marked required, so the user can also just skip
- * — matching the built-in tool, which always offers Skip + a free-text box.
- */
-export function askUserQuestionsToCreateRequest(
-  questions: AskUserQuestion[],
-  sessionId: string,
-  toolCallId: string | undefined,
-): CreateElicitationRequest {
-  const single = questions.length === 1;
-  const properties: Record<string, ElicitationPropertySchema> = {};
-
-  questions.forEach((question, index) => {
-    const options: EnumOption[] = question.options.map((option) => {
-      const enumOption: EnumOption = {
-        const: option.label,
-        title: option.label,
-      };
-      if (option.description) {
-        enumOption.description = option.description;
-      }
-      // The SDK option's `preview` (mockups, code snippets, comparisons shown
-      // on focus) still has no structural slot in `EnumOption`, so forward it
-      // under ACP's reserved `_meta` extension point for clients that render it.
-      if (option.preview) {
-        enumOption._meta = { [OPTION_META_KEY]: { preview: option.preview } };
-      }
-      return enumOption;
-    });
-
-    // For a single question the prompt is carried by `message`, so we don't
-    // repeat it in the field description. With multiple questions each field
-    // needs its own question text.
-    const description = single ? undefined : question.question;
-    const title = question.header || undefined;
-
-    properties[questionFieldKey(index)] = question.multiSelect
-      ? { type: "array", title, description, items: { anyOf: options } }
-      : { type: "string", title, description, oneOf: options };
-
-    properties[questionCustomFieldKey(index)] = {
-      type: "string",
-      title: "Other",
-      description: "Type your own answer instead of choosing an option above (optional).",
-    };
-  });
-
-  const requestedSchema: ElicitationSchema = {
-    type: "object",
-    properties,
-  };
-
-  const message = single ? questions[0].question : "Please answer the following questions.";
-
-  return {
-    mode: "form",
-    sessionId,
-    ...(toolCallId ? { toolCallId } : {}),
-    message,
-    requestedSchema,
-  };
-}
-
-/** Outcome of an AskUserQuestion elicitation, decoupled from any transport. */
-export type AskUserQuestionOutcome =
-  { action: "answered"; updatedInput: Record<string, unknown> } | { action: "cancel" };
-
-/**
- * Fold an ACP elicitation response into the AskUserQuestion tool's input.
- *
- * Selected labels are read back from the indexed form fields and written into
- * `answers` as a `{ [questionText]: label }` map (comma-joining multi-selects)
- * — the key shape the tool's own `call()` reads. A non-empty per-question
- * custom-answer field (`question_<n>_custom`) takes precedence over that
- * question's selection, since the user typed their own answer instead of
- * picking one. Decline yields empty answers (the model is told the user skipped
- * rather than the turn aborting); cancel — and any custom/future action we
- * don't understand — aborts the tool call.
- */
-export function applyAskElicitationResponse(
-  response: CreateElicitationResponse,
-  toolInput: Record<string, unknown>,
-  questions: AskUserQuestion[],
-): AskUserQuestionOutcome {
-  if (response.action === "decline") {
-    return { action: "answered", updatedInput: { ...toolInput, answers: {} } };
-  }
-
-  if (response.action !== "accept") {
-    return { action: "cancel" };
-  }
-
-  const content = acceptedElicitationContent(response);
-  // Typed against the tool's own output schema so the answer/response shapes
-  // stay in sync with what the built-in tool's call() expects to read back.
-  const answers: AskUserQuestionOutput["answers"] = {};
-  questions.forEach((question, index) => {
-    // A typed custom answer wins over the selection: the user chose to write
-    // their own answer for this question instead of picking an option.
-    const custom = content[questionCustomFieldKey(index)];
-    if (typeof custom === "string" && custom.trim() !== "") {
-      answers[question.question] = custom.trim();
-      return;
-    }
-
-    const value = content[questionFieldKey(index)];
-    if (value === undefined || value === null) {
-      return;
-    }
-    const text = Array.isArray(value) ? value.join(", ") : String(value);
-    if (text === "") {
-      return;
-    }
-    answers[question.question] = text;
-  });
-
-  return { action: "answered", updatedInput: { ...toolInput, answers } };
-}
-
-/**
- * Coerce an arbitrary MCP `requestedSchema` into an ACP `ElicitationSchema`.
- * The two are structurally compatible JSON Schemas; we just guarantee the
- * `type: "object"` discriminator is present.
- */
-function normalizeElicitationSchema(
-  schema: Record<string, unknown> | undefined,
-): ElicitationSchema {
-  if (!schema || typeof schema !== "object") {
-    return { type: "object", properties: {} };
-  }
-  return { ...(schema as ElicitationSchema), type: "object" };
-}
-
-/**
- * The `request_user_dialog` kind the CLI emits when a model refusal has a
- * fallback available but needs user consent before retrying (e.g. Claude Fable
- * declining a request with Opus available as the fallback). Declaring this
- * kind in `supportedDialogKinds` is the opt-in: the CLI fails closed and never
- * emits an undeclared kind — the flow degrades to the classic refusal error
- * ending the turn.
- */
-export const REFUSAL_FALLBACK_DIALOG_KIND = "refusal_fallback_prompt";
-
-/**
- * Payload of the `refusal_fallback_prompt` dialog. The dialog protocol
- * transports payloads opaquely, so this shape is recovered from the CLI's own
- * schema (v2.1.177): `originalModel`/`fallbackModel` are required strings;
- * `apiRefusalCategory` (nullable), `guidanceText`, and
- * `retractedMessageUuids` are optional. We ignore `retractedMessageUuids` —
- * ACP has no way to retract already-streamed chunks.
- */
-export type RefusalFallbackPrompt = {
-  originalModel: string;
-  fallbackModel: string;
-  apiRefusalCategory: string | null;
-  guidanceText?: string;
-};
-
-/**
- * Validate the opaque dialog payload into a {@link RefusalFallbackPrompt}.
- * Returns `null` when the required fields are missing or mistyped (a newer CLI
- * may reshape the payload), so the caller can cancel the dialog and let the
- * CLI apply its default behavior instead of rendering something misleading.
- */
-export function extractRefusalFallbackPrompt(
-  payload: Record<string, unknown>,
-): RefusalFallbackPrompt | null {
-  const { originalModel, fallbackModel, apiRefusalCategory, guidanceText } = payload;
-  if (typeof originalModel !== "string" || typeof fallbackModel !== "string") {
-    return null;
-  }
-  return {
-    originalModel,
-    fallbackModel,
-    apiRefusalCategory: typeof apiRefusalCategory === "string" ? apiRefusalCategory : null,
-    ...(typeof guidanceText === "string" && guidanceText ? { guidanceText } : {}),
-  };
-}
-
-/** Form-field key carrying the user's choice in the refusal-fallback form. */
-const REFUSAL_FALLBACK_CHOICE_KEY = "choice";
-
-/** Wire values of the dialog's result enum (CLI schema). `edit_prompt` is
- *  deliberately not offered: in the CLI it prefills the composer with the
- *  refused prompt for edit-and-retry, and ACP has no composer-prefill surface
- *  — the user can simply edit and resend on their own. */
-const RETRY_FALLBACK_RESULT = "retry_fallback";
-const KEEP_REFUSAL_RESULT = "cancelled";
-
-/**
- * Render the refusal-fallback consent prompt as an ACP form elicitation: a
- * single-select between retrying on the fallback model and keeping the
- * refusal. The enum `const`s are the dialog's wire result values, so the
- * response maps back without a translation table.
- */
-export function refusalFallbackToCreateRequest(
-  prompt: RefusalFallbackPrompt,
-  sessionId: string,
-): CreateElicitationRequest {
-  const category = prompt.apiRefusalCategory ? ` (${prompt.apiRefusalCategory})` : "";
-  const guidance = prompt.guidanceText ? `\n\n${prompt.guidanceText}` : "";
-  return {
-    mode: "form",
-    sessionId,
-    message:
-      `${prompt.originalModel} declined this request${category}. ` +
-      `Retry with ${prompt.fallbackModel}?` +
-      guidance,
-    requestedSchema: {
-      type: "object",
-      properties: {
-        [REFUSAL_FALLBACK_CHOICE_KEY]: {
-          type: "string",
-          oneOf: [
-            {
-              const: RETRY_FALLBACK_RESULT,
-              title: `Retry with ${prompt.fallbackModel}`,
-              description: `The session continues on ${prompt.fallbackModel}.`,
-            },
-            {
-              const: KEEP_REFUSAL_RESULT,
-              title: "Keep the refusal",
-              description: "You can send a new message.",
-            },
-          ],
-        },
-      },
-    },
-  };
-}
-
-/**
- * Map the elicitation response back to the dialog's result enum. Only an
- * explicit accept-with-retry resolves to `retry_fallback`; decline, cancel, a
- * skipped field, or an unrecognized value all keep the refusal — the dialog's
- * own default — so a dismissed or half-filled form can never trigger a model
- * switch the user didn't ask for.
- */
-export function refusalFallbackResultFromResponse(response: CreateElicitationResponse): string {
-  const choice = acceptedElicitationContent(response)[REFUSAL_FALLBACK_CHOICE_KEY];
-  return choice === RETRY_FALLBACK_RESULT ? RETRY_FALLBACK_RESULT : KEEP_REFUSAL_RESULT;
-}
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,83 +1,26 @@
 #!/usr/bin/env node

-import { resolveSettings } from "@anthropic-ai/claude-agent-sdk";
-import { claudeCliPath, runAcp } from "./acp-agent.js";
-import packageJson from "../package.json" with { type: "json" };
+// Load managed settings and apply environment variables
+import { loadManagedSettings, applyEnvironmentSettings } from "./utils.js";

-// `--cli` is checked first so that `--version`/`-v` (and any other flags) are
-// forwarded to the wrapped native CLI rather than swallowed by our own version
-// handler below. Our version flag only applies when not delegating.
-if (process.argv.includes("--cli")) {
-  const { spawn } = await import("node:child_process");
-  const args = process.argv.slice(2).filter((arg) => arg !== "--cli");
-  const child = spawn(await claudeCliPath(), args, { stdio: "inherit" });
-
-  const signals =
-    process.platform === "win32"
-      ? (["SIGINT", "SIGTERM"] as const)
-      : (["SIGINT", "SIGTERM", "SIGHUP"] as const);
-  for (const sig of signals) {
-    process.on(sig, () => {
-      if (!child.killed) child.kill(sig);
-    });
-  }
-
-  child.on("exit", (code, signal) => {
-    if (signal && process.platform !== "win32") {
-      // Remove our listener so re-raising actually terminates instead of
-      // re-entering the no-op handler, which would let us exit with code 0
-      // instead of the signal's conventional 128+N.
-      process.removeAllListeners(signal);
-      process.kill(process.pid, signal);
-    } else {
-      process.exit(code ?? 1);
-    }
-  });
-  child.on("error", (err) => {
-    console.error(err);
-    process.exit(1);
-  });
-} else if (process.argv.includes("--version") || process.argv.includes("-v")) {
-  console.log(packageJson.version);
-  process.exit(0);
-} else {
-  // Apply env vars from the managed-policy tier before any SDK call so the
-  // SDK subprocess inherits them. Going through resolveSettings (vs. a raw
-  // read of managed-settings.json) also picks up MDM sources on macOS and
-  // HKLM/HKCU on Windows.
-  const policy = await resolveSettings({ settingSources: [] });
-  for (const [key, value] of Object.entries(policy.effective.env ?? {})) {
-    process.env[key] = value;
-  }
-
-  // stdout is used to send messages to the client
-  // we redirect everything else to stderr to make sure it doesn't interfere with ACP
-  console.log = console.error;
-  console.info = console.error;
-  console.warn = console.error;
-  console.debug = console.error;
-
-  process.on("unhandledRejection", (reason, promise) => {
-    console.error("Unhandled Rejection at:", promise, "reason:", reason);
-  });
-
-  const { connection, agent } = runAcp();
-
-  async function shutdown() {
-    await agent.dispose().catch((err) => {
-      console.error("Error during cleanup:", err);
-    });
-    process.exit(0);
-  }
-
-  // Exit cleanly when the ACP connection closes (e.g. stdin EOF, transport
-  // error). Without this, `process.stdin.resume()` keeps the event loop
-  // alive indefinitely, causing orphan process accumulation in oneshot mode.
-  connection.closed.then(shutdown);
-
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-
-  // Keep process alive while connection is open
-  process.stdin.resume();
+const managedSettings = loadManagedSettings();
+if (managedSettings) {
+  applyEnvironmentSettings(managedSettings);
 }
+
+// stdout is used to send messages to the client
+// we redirect everything else to stderr to make sure it doesn't interfere with ACP
+console.log = console.error;
+console.info = console.error;
+console.warn = console.error;
+console.debug = console.error;
+
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("Unhandled Rejection at:", promise, "reason:", reason);
+});
+
+import { runAcp } from "./acp-agent.js";
+runAcp();
+
+// Keep process alive
+process.stdin.resume();
--- a/src/lib.ts
+++ b/src/lib.ts
@@ -1,23 +1,22 @@
 // Export the main agent class and utilities for library usage
 export {
  ClaudeAcpAgent,
-  isLocalCommandMetadata,
-  stripLocalCommandMetadata,
  runAcp,
  toAcpNotifications,
  streamEventToAcpNotifications,
  type ToolUpdateMeta,
  type NewSessionMeta,
-  type SDKMessageFilter,
 } from "./acp-agent.js";
-export { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
 export {
-  toolInfoFromToolUse,
-  toDisplayPath,
-  planEntries,
-  toolUpdateFromToolResult,
-} from "./tools.js";
-export { SettingsManager, type SettingsManagerOptions } from "./settings.js";
+  loadManagedSettings,
+  applyEnvironmentSettings,
+  nodeToWebReadable,
+  nodeToWebWritable,
+  Pushable,
+  unreachable,
+} from "./utils.js";
+export { createMcpServer, toolNames } from "./mcp-server.js";
+export { toolInfoFromToolUse, planEntries, toolUpdateFromToolResult } from "./tools.js";

 // Export types
 export type { ClaudePlanEntry } from "./tools.js";
--- a/src/mcp-server.ts
+++ b/src/mcp-server.ts
@@ -0,0 +1,814 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  BashInput,
+  BashOutputInput,
+  FileEditInput,
+  FileReadInput,
+  FileWriteInput,
+  KillShellInput,
+} from "@anthropic-ai/claude-agent-sdk/sdk-tools.js";
+import { z } from "zod";
+import { CLAUDE_CONFIG_DIR, ClaudeAcpAgent } from "./acp-agent.js";
+import {
+  ClientCapabilities,
+  ReadTextFileResponse,
+  TerminalOutputResponse,
+} from "@agentclientprotocol/sdk";
+import * as diff from "diff";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+
+import { sleep, unreachable, extractLinesWithByteLimit } from "./utils.js";
+
+export const SYSTEM_REMINDER = `
+
+<system-reminder>
+Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.
+</system-reminder>`;
+
+const defaults = { maxFileSize: 50000, linesToRead: 2000 };
+
+const unqualifiedToolNames = {
+  read: "Read",
+  edit: "Edit",
+  write: "Write",
+  bash: "Bash",
+  killShell: "KillShell",
+  bashOutput: "BashOutput",
+};
+
+const SERVER_PREFIX = "mcp__acp__";
+export const toolNames = {
+  read: SERVER_PREFIX + unqualifiedToolNames.read,
+  edit: SERVER_PREFIX + unqualifiedToolNames.edit,
+  write: SERVER_PREFIX + unqualifiedToolNames.write,
+  bash: SERVER_PREFIX + unqualifiedToolNames.bash,
+  killShell: SERVER_PREFIX + unqualifiedToolNames.killShell,
+  bashOutput: SERVER_PREFIX + unqualifiedToolNames.bashOutput,
+};
+
+export const EDIT_TOOL_NAMES = [toolNames.edit, toolNames.write];
+
+export function createMcpServer(
+  agent: ClaudeAcpAgent,
+  sessionId: string,
+  clientCapabilities: ClientCapabilities | undefined,
+): McpServer {
+  /**
+   * This checks if a given path is related to internal agent persistence and if the agent should be allowed to read/write from here.
+   * We let the agent do normal fs operations on these paths so that it can persist its state.
+   * However, we block access to settings files for security reasons.
+   */
+  function internalPath(file_path: string) {
+    return (
+      file_path.startsWith(CLAUDE_CONFIG_DIR) &&
+      !file_path.startsWith(path.join(CLAUDE_CONFIG_DIR, "settings.json")) &&
+      !file_path.startsWith(path.join(CLAUDE_CONFIG_DIR, "session-env"))
+    );
+  }
+
+  async function readTextFile(input: FileReadInput): Promise<ReadTextFileResponse> {
+    if (internalPath(input.file_path)) {
+      const content = await fs.readFile(input.file_path, "utf8");
+
+      // eslint-disable-next-line eqeqeq
+      if (input.offset != null || input.limit != null) {
+        const lines = content.split("\n");
+
+        // Apply offset and limit if provided
+        const offset = input.offset ?? 1;
+        const limit = input.limit ?? lines.length;
+
+        // Extract the requested lines (offset is 1-based)
+        const startIndex = Math.max(0, offset - 1);
+        const endIndex = Math.min(lines.length, startIndex + limit);
+        const selectedLines = lines.slice(startIndex, endIndex);
+
+        return { content: selectedLines.join("\n") };
+      } else {
+        return { content };
+      }
+    }
+
+    return agent.readTextFile({
+      sessionId,
+      path: input.file_path,
+      line: input.offset,
+      limit: input.limit,
+    });
+  }
+
+  async function writeTextFile(input: FileWriteInput): Promise<void> {
+    if (internalPath(input.file_path)) {
+      await fs.writeFile(input.file_path, input.content, "utf8");
+    } else {
+      await agent.writeTextFile({
+        sessionId,
+        path: input.file_path,
+        content: input.content,
+      });
+    }
+  }
+
+  // Create MCP server
+  const server = new McpServer({ name: "acp", version: "1.0.0" }, { capabilities: { tools: {} } });
+
+  if (clientCapabilities?.fs?.readTextFile) {
+    server.registerTool(
+      unqualifiedToolNames.read,
+      {
+        title: unqualifiedToolNames.read,
+        description: `Reads the content of the given file in the project.
+
+In sessions with ${toolNames.read} always use it instead of Read as it contains the most up-to-date contents.
+
+Reads a file from the local filesystem. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to ${defaults.linesToRead} lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Any files larger than ${defaults.maxFileSize} bytes will be truncated
+- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
+- This tool can only read files, not directories. To read a directory, use an ls command via the ${toolNames.bash} tool.
+- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.`,
+        inputSchema: {
+          file_path: z.string().describe("The absolute path to the file to read"),
+          offset: z
+            .number()
+            .optional()
+            .default(1)
+            .describe(
+              "The line number to start reading from. Only provide if the file is too large to read at once",
+            ),
+          limit: z
+            .number()
+            .optional()
+            .default(defaults.linesToRead)
+            .describe(
+              `The number of lines to read. Only provide if the file is too large to read at once.`,
+            ),
+        },
+        annotations: {
+          title: "Read file",
+          readOnlyHint: true,
+          destructiveHint: false,
+          openWorldHint: false,
+          idempotentHint: false,
+        },
+      },
+      async (input: FileReadInput) => {
+        try {
+          const session = agent.sessions[sessionId];
+          if (!session) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "The user has left the building",
+                },
+              ],
+            };
+          }
+
+          const readResponse = await readTextFile(input);
+
+          if (typeof readResponse?.content !== "string") {
+            throw new Error(`No file contents for ${input.file_path}.`);
+          }
+
+          // Extract lines with byte limit enforcement
+          const result = extractLinesWithByteLimit(readResponse.content, defaults.maxFileSize);
+
+          // Construct informative message about what was read
+          let readInfo = "";
+          if ((input.offset && input.offset > 1) || result.wasLimited) {
+            readInfo = "\n\n<file-read-info>";
+
+            if (result.wasLimited) {
+              readInfo += `Read ${result.linesRead} lines (hit 50KB limit). `;
+            } else {
+              readInfo += `Read lines ${input.offset}-${result.linesRead}. `;
+            }
+
+            if (result.wasLimited) {
+              readInfo += `Continue with offset=${result.linesRead}.`;
+            }
+
+            readInfo += "</file-read-info>";
+          }
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: result.content + readInfo + SYSTEM_REMINDER,
+              },
+            ],
+          };
+        } catch (error: any) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Reading file failed: " + error.message,
+              },
+            ],
+          };
+        }
+      },
+    );
+  }
+
+  if (clientCapabilities?.fs?.writeTextFile) {
+    server.registerTool(
+      unqualifiedToolNames.write,
+      {
+        title: unqualifiedToolNames.write,
+        description: `Writes a file to the local filesystem..
+
+In sessions with ${toolNames.write} always use it instead of Write as it will
+allow the user to conveniently review changes.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the ${toolNames.read} tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.`,
+        inputSchema: {
+          file_path: z
+            .string()
+            .describe("The absolute path to the file to write (must be absolute, not relative)"),
+          content: z.string().describe("The content to write to the file"),
+        },
+        annotations: {
+          title: "Write file",
+          readOnlyHint: false,
+          destructiveHint: false,
+          openWorldHint: false,
+          idempotentHint: false,
+        },
+      },
+      async (input: FileWriteInput) => {
+        try {
+          const session = agent.sessions[sessionId];
+          if (!session) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "The user has left the building",
+                },
+              ],
+            };
+          }
+          await writeTextFile(input);
+
+          return {
+            content: [],
+          };
+        } catch (error: any) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Writing file failed: " + error.message,
+              },
+            ],
+          };
+        }
+      },
+    );
+
+    server.registerTool(
+      unqualifiedToolNames.edit,
+      {
+        title: unqualifiedToolNames.edit,
+        description: `Performs exact string replacements in files.
+
+In sessions with ${toolNames.edit} always use it instead of Edit as it will
+allow the user to conveniently review changes.
+
+Usage:
+- You must use your \`${toolNames.read}\` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file.
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`,
+        inputSchema: {
+          file_path: z.string().describe("The absolute path to the file to modify"),
+          old_string: z.string().describe("The text to replace"),
+          new_string: z
+            .string()
+            .describe("The text to replace it with (must be different from old_string)"),
+          replace_all: z
+            .boolean()
+            .default(false)
+            .optional()
+            .describe("Replace all occurrences of old_string (default false)"),
+        },
+        annotations: {
+          title: "Edit file",
+          readOnlyHint: false,
+          destructiveHint: false,
+          openWorldHint: false,
+          idempotentHint: false,
+        },
+      },
+      async (input: FileEditInput) => {
+        try {
+          const session = agent.sessions[sessionId];
+          if (!session) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "The user has left the building",
+                },
+              ],
+            };
+          }
+
+          const readResponse = await readTextFile({
+            file_path: input.file_path,
+          });
+
+          if (typeof readResponse?.content !== "string") {
+            throw new Error(`No file contents for ${input.file_path}.`);
+          }
+
+          const { newContent } = replaceAndCalculateLocation(readResponse.content, [
+            {
+              oldText: input.old_string,
+              newText: input.new_string,
+              replaceAll: input.replace_all,
+            },
+          ]);
+
+          const patch = diff.createPatch(input.file_path, readResponse.content, newContent);
+
+          await writeTextFile({ file_path: input.file_path, content: newContent });
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: patch,
+              },
+            ],
+          };
+        } catch (error: any) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Editing file failed: " + (error?.message ?? String(error)),
+              },
+            ],
+          };
+        }
+      },
+    );
+  }
+
+  if (agent.clientCapabilities?.terminal) {
+    server.registerTool(
+      unqualifiedToolNames.bash,
+      {
+        title: unqualifiedToolNames.bash,
+        description: `Executes a bash command
+
+In sessions with ${toolNames.bash} always use it instead of Bash`,
+        inputSchema: {
+          command: z.string().describe("The command to execute"),
+          timeout: z.number().describe(`Optional timeout in milliseconds (max ${2 * 60 * 1000})`),
+          description: z.string().optional()
+            .describe(`Clear, concise description of what this command does in 5-10 words, in active voice. Examples:
+Input: ls
+Output: List files in current directory
+
+Input: git status
+Output: Show working tree status
+
+Input: npm install
+Output: Install package dependencies
+
+Input: mkdir foo
+Output: Create directory 'foo'`),
+          run_in_background: z
+            .boolean()
+            .default(false)
+            .describe(
+              `Set to true to run this command in the background. The tool returns an \`id\` that can be used with the \`${toolNames.bashOutput}\` tool to retrieve the current output, or the \`${toolNames.killShell}\` tool to stop it early.`,
+            ),
+        },
+      },
+      async (input: BashInput, extra) => {
+        const session = agent.sessions[sessionId];
+        if (!session) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "The user has left the building",
+              },
+            ],
+          };
+        }
+
+        const toolCallId = extra._meta?.["claudecode/toolUseId"];
+
+        if (typeof toolCallId !== "string") {
+          throw new Error("No tool call ID found");
+        }
+
+        if (!agent.clientCapabilities?.terminal || !agent.client.createTerminal) {
+          throw new Error("unreachable");
+        }
+
+        const handle = await agent.client.createTerminal({
+          command: input.command,
+          env: [{ name: "CLAUDECODE", value: "1" }],
+          sessionId,
+          outputByteLimit: 32_000,
+        });
+
+        await agent.client.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "tool_call_update",
+            toolCallId,
+            status: "in_progress",
+            title: input.description,
+            content: [{ type: "terminal", terminalId: handle.id }],
+          },
+        });
+
+        const abortPromise = new Promise((resolve) => {
+          if (extra.signal.aborted) {
+            resolve(null);
+          } else {
+            extra.signal.addEventListener("abort", () => {
+              resolve(null);
+            });
+          }
+        });
+
+        const statusPromise = Promise.race([
+          handle.waitForExit().then((exitStatus) => ({ status: "exited" as const, exitStatus })),
+          abortPromise.then(() => ({ status: "aborted" as const, exitStatus: null })),
+          sleep(input.timeout ?? 2 * 60 * 1000).then(async () => {
+            if (agent.backgroundTerminals[handle.id]?.status === "started") {
+              await handle.kill();
+            }
+            return { status: "timedOut" as const, exitStatus: null };
+          }),
+        ]);
+
+        if (input.run_in_background) {
+          agent.backgroundTerminals[handle.id] = {
+            handle,
+            lastOutput: null,
+            status: "started",
+          };
+
+          statusPromise.then(async ({ status, exitStatus }) => {
+            const bgTerm = agent.backgroundTerminals[handle.id];
+
+            if (bgTerm.status !== "started") {
+              return;
+            }
+
+            const currentOutput = await handle.currentOutput();
+
+            agent.backgroundTerminals[handle.id] = {
+              status,
+              pendingOutput: {
+                ...currentOutput,
+                output: stripCommonPrefix(bgTerm.lastOutput?.output ?? "", currentOutput.output),
+                exitStatus: exitStatus ?? currentOutput.exitStatus,
+              },
+            };
+
+            return handle.release();
+          });
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Command started in background with id: ${handle.id}`,
+              },
+            ],
+          };
+        }
+
+        await using terminal = handle;
+
+        const { status } = await statusPromise;
+
+        if (status === "aborted") {
+          return {
+            content: [{ type: "text", text: "Tool cancelled by user" }],
+          };
+        }
+
+        const output = await terminal.currentOutput();
+
+        return {
+          content: [{ type: "text", text: toolCommandOutput(status, output) }],
+        };
+      },
+    );
+
+    server.registerTool(
+      unqualifiedToolNames.bashOutput,
+      {
+        title: unqualifiedToolNames.bashOutput,
+        description: `- Retrieves output from a running or completed background bash shell
+- Takes a bash_id parameter identifying the shell
+- Always returns only new output since the last check
+- Returns stdout and stderr output along with shell status
+- Use this tool when you need to monitor or check the output of a long-running shell
+
+In sessions with ${toolNames.bashOutput} always use it instead of BashOutput.`,
+        inputSchema: {
+          bash_id: z
+            .string()
+            .describe(`The id of the background bash command as returned by \`${toolNames.bash}\``),
+        },
+      },
+      async (input: BashOutputInput) => {
+        const bgTerm = agent.backgroundTerminals[input.bash_id];
+
+        if (!bgTerm) {
+          throw new Error(`Unknown shell ${input.bash_id}`);
+        }
+
+        if (bgTerm.status === "started") {
+          const newOutput = await bgTerm.handle.currentOutput();
+          const strippedOutput = stripCommonPrefix(
+            bgTerm.lastOutput?.output ?? "",
+            newOutput.output,
+          );
+          bgTerm.lastOutput = newOutput;
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: toolCommandOutput(bgTerm.status, {
+                  ...newOutput,
+                  output: strippedOutput,
+                }),
+              },
+            ],
+          };
+        } else {
+          return {
+            content: [
+              {
+                type: "text",
+                text: toolCommandOutput(bgTerm.status, bgTerm.pendingOutput),
+              },
+            ],
+          };
+        }
+      },
+    );
+
+    server.registerTool(
+      unqualifiedToolNames.killShell,
+      {
+        title: unqualifiedToolNames.killShell,
+        description: `- Kills a running background bash shell by its ID
+- Takes a shell_id parameter identifying the shell to kill
+- Returns a success or failure status
+- Use this tool when you need to terminate a long-running shell
+
+In sessions with ${toolNames.killShell} always use it instead of KillShell.`,
+        inputSchema: {
+          shell_id: z
+            .string()
+            .describe(`The id of the background bash command as returned by \`${toolNames.bash}\``),
+        },
+      },
+      async (input: KillShellInput) => {
+        const bgTerm = agent.backgroundTerminals[input.shell_id];
+
+        if (!bgTerm) {
+          throw new Error(`Unknown shell ${input.shell_id}`);
+        }
+
+        switch (bgTerm.status) {
+          case "started": {
+            await bgTerm.handle.kill();
+            const currentOutput = await bgTerm.handle.currentOutput();
+            agent.backgroundTerminals[bgTerm.handle.id] = {
+              status: "killed",
+              pendingOutput: {
+                ...currentOutput,
+                output: stripCommonPrefix(bgTerm.lastOutput?.output ?? "", currentOutput.output),
+              },
+            };
+            await bgTerm.handle.release();
+
+            return {
+              content: [{ type: "text", text: "Command killed successfully." }],
+            };
+          }
+          case "aborted":
+            return {
+              content: [{ type: "text", text: "Command aborted by user." }],
+            };
+          case "exited":
+            return {
+              content: [{ type: "text", text: "Command had already exited." }],
+            };
+          case "killed":
+            return {
+              content: [{ type: "text", text: "Command was already killed." }],
+            };
+          case "timedOut":
+            return {
+              content: [{ type: "text", text: "Command killed by timeout." }],
+            };
+          default: {
+            unreachable(bgTerm);
+            throw new Error("Unexpected background terminal status");
+          }
+        }
+      },
+    );
+  }
+
+  return server;
+}
+
+function stripCommonPrefix(a: string, b: string): string {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) {
+    i++;
+  }
+  return b.slice(i);
+}
+
+function toolCommandOutput(
+  status: "started" | "aborted" | "exited" | "killed" | "timedOut",
+  output: TerminalOutputResponse,
+): string {
+  const { exitStatus, output: commandOutput, truncated } = output;
+
+  let toolOutput = "";
+
+  switch (status) {
+    case "started":
+    case "exited": {
+      if (exitStatus && (exitStatus.exitCode ?? null) === null) {
+        toolOutput += `Interrupted by the user. `;
+      }
+      break;
+    }
+    case "killed":
+      toolOutput += `Killed. `;
+      break;
+    case "timedOut":
+      toolOutput += `Timed out. `;
+      break;
+    case "aborted":
+      break;
+    default: {
+      const unreachable: never = status;
+      return unreachable;
+    }
+  }
+
+  if (exitStatus) {
+    if (typeof exitStatus.exitCode === "number") {
+      toolOutput += `Exited with code ${exitStatus.exitCode}.`;
+    }
+
+    if (typeof exitStatus.signal === "string") {
+      toolOutput += `Signal \`${exitStatus.signal}\`. `;
+    }
+
+    toolOutput += "Final output:\n\n";
+  } else {
+    toolOutput += "New output:\n\n";
+  }
+
+  toolOutput += commandOutput;
+
+  if (truncated) {
+    toolOutput += `\n\nCommand output was too long, so it was truncated to ${commandOutput.length} bytes.`;
+  }
+
+  return toolOutput;
+}
+
+/**
+ * Replace text in a file and calculate the line numbers where the edits occurred.
+ *
+ * @param fileContent - The full file content
+ * @param edits - Array of edit operations to apply sequentially
+ * @returns the new content and the line numbers where replacements occurred in the final content
+ */
+export function replaceAndCalculateLocation(
+  fileContent: string,
+  edits: Array<{
+    oldText: string;
+    newText: string;
+    replaceAll?: boolean;
+  }>,
+): { newContent: string; lineNumbers: number[] } {
+  let currentContent = fileContent;
+
+  // Use unique markers to track where replacements happen
+  const markerPrefix = `__REPLACE_MARKER_${Math.random().toString(36).substr(2, 9)}_`;
+  let markerCounter = 0;
+  const markers: string[] = [];
+
+  // Apply edits sequentially, inserting markers at replacement positions
+  for (const edit of edits) {
+    // Skip empty oldText
+    if (edit.oldText === "") {
+      throw new Error(`The provided \`old_string\` is empty.\n\nNo edits were applied.`);
+    }
+
+    if (edit.replaceAll) {
+      // Replace all occurrences with marker + newText
+      const parts: string[] = [];
+      let lastIndex = 0;
+      let searchIndex = 0;
+
+      while (true) {
+        const index = currentContent.indexOf(edit.oldText, searchIndex);
+        if (index === -1) {
+          if (searchIndex === 0) {
+            throw new Error(
+              `The provided \`old_string\` does not appear in the file: "${edit.oldText}".\n\nNo edits were applied.`,
+            );
+          }
+          break;
+        }
+
+        // Add content before the match
+        parts.push(currentContent.substring(lastIndex, index));
+
+        // Add marker and replacement
+        const marker = `${markerPrefix}${markerCounter++}__`;
+        markers.push(marker);
+        parts.push(marker + edit.newText);
+
+        lastIndex = index + edit.oldText.length;
+        searchIndex = lastIndex;
+      }
+
+      // Add remaining content
+      parts.push(currentContent.substring(lastIndex));
+      currentContent = parts.join("");
+    } else {
+      // Replace first occurrence only
+      const index = currentContent.indexOf(edit.oldText);
+      if (index === -1) {
+        throw new Error(
+          `The provided \`old_string\` does not appear in the file: "${edit.oldText}".\n\nNo edits were applied.`,
+        );
+      } else {
+        const marker = `${markerPrefix}${markerCounter++}__`;
+        markers.push(marker);
+        currentContent =
+          currentContent.substring(0, index) +
+          marker +
+          edit.newText +
+          currentContent.substring(index + edit.oldText.length);
+      }
+    }
+  }
+
+  // Find line numbers where markers appear in the content
+  const lineNumbers: number[] = [];
+  for (const marker of markers) {
+    const index = currentContent.indexOf(marker);
+    if (index !== -1) {
+      const lineNumber = Math.max(
+        0,
+        currentContent.substring(0, index).split(/\r\n|\r|\n/).length - 1,
+      );
+      lineNumbers.push(lineNumber);
+    }
+  }
+
+  // Remove all markers from the final content
+  let finalContent = currentContent;
+  for (const marker of markers) {
+    finalContent = finalContent.replace(marker, "");
+  }
+
+  // Dedupe and sort line numbers
+  const uniqueLineNumbers = [...new Set(lineNumbers)].sort();
+
+  return { newContent: finalContent, lineNumbers: uniqueLineNumbers };
+}
--- a/src/settings.ts
+++ b/src/settings.ts
@@ -1,212 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-// resolveSettings and filterEscalatingDefaultMode are marked @alpha in the
-// SDK; API may shift in a future release.
-import {
-  filterEscalatingDefaultMode,
-  resolveSettings,
-  type Settings,
-} from "@anthropic-ai/claude-agent-sdk";
-import { CLAUDE_CONFIG_DIR } from "./acp-agent.js";
-
-/**
- * Permission rule format examples:
- * - "Read" - matches all Read tool calls
- * - "Read(./.env)" - matches specific path
- * - "Read(./.env.*)" - glob pattern
- * - "Read(./secrets/**)" - recursive glob
- * - "Bash(npm run lint)" - exact command prefix
- * - "Bash(npm run:*)" - command prefix with wildcard
- *
- * Docs: https://code.claude.com/docs/en/iam#tool-specific-permission-rules
- */
-
-function getManagedSettingsPath(): string {
-  switch (process.platform) {
-    case "darwin":
-      return "/Library/Application Support/ClaudeCode/managed-settings.json";
-    case "win32":
-      return "C:\\Program Files\\ClaudeCode\\managed-settings.json";
-    default:
-      return "/etc/claude-code/managed-settings.json";
-  }
-}
-
-export interface SettingsManagerOptions {
-  onChange?: () => void;
-  logger?: { log: (...args: any[]) => void; error: (...args: any[]) => void };
-}
-
-/**
- * Manages Claude Code settings using the SDK's `resolveSettings` merge engine
- * so the values we see match what `query()` would observe.
- *
- * Watches the user/project/local/managed settings files for changes and
- * re-resolves through the SDK on update. Escalating `permissions.defaultMode`
- * values from repo-committed sources are filtered out via
- * `filterEscalatingDefaultMode`, matching the CLI's trust policy.
- */
-export class SettingsManager {
-  private cwd: string;
-  private effective: Settings = {};
-  private watchers: fs.FSWatcher[] = [];
-  private onChange?: () => void;
-  private logger: { log: (...args: any[]) => void; error: (...args: any[]) => void };
-  private initialized = false;
-  private disposed = false;
-  private debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  private initPromise: Promise<void> | null = null;
-
-  constructor(cwd: string, options?: SettingsManagerOptions) {
-    this.cwd = cwd;
-    this.onChange = options?.onChange;
-    this.logger = options?.logger ?? console;
-  }
-
-  /**
-   * Initialize the settings manager by loading all settings and setting up file watchers
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-    if (this.initPromise) {
-      return this.initPromise;
-    }
-
-    this.disposed = false;
-    this.initPromise = this.loadAllSettings().then(() => {
-      if (!this.disposed) {
-        this.setupWatchers();
-        this.initialized = true;
-      }
-      this.initPromise = null;
-    });
-    return this.initPromise;
-  }
-
-  /**
-   * Paths the SDK reads when resolving settings for this cwd. Watching the
-   * containing directories means we pick up file creation as well as edits.
-   */
-  private getWatchedPaths(): string[] {
-    return [
-      path.join(CLAUDE_CONFIG_DIR, "settings.json"),
-      path.join(this.cwd, ".claude", "settings.json"),
-      path.join(this.cwd, ".claude", "settings.local.json"),
-      getManagedSettingsPath(),
-    ];
-  }
-
-  /**
-   * Resolves the effective settings via the SDK and applies the CLI's trust
-   * filter for escalating `permissions.defaultMode` values.
-   */
-  private async loadAllSettings(): Promise<void> {
-    try {
-      const resolved = await resolveSettings({ cwd: this.cwd });
-      this.effective = filterEscalatingDefaultMode(resolved);
-    } catch (error) {
-      this.logger.error("Failed to resolve settings:", error);
-      this.effective = {};
-    }
-  }
-
-  /**
-   * Sets up file watchers for all settings files
-   */
-  private setupWatchers(): void {
-    for (const filePath of this.getWatchedPaths()) {
-      try {
-        const dir = path.dirname(filePath);
-        const filename = path.basename(filePath);
-
-        if (fs.existsSync(dir)) {
-          const watcher = fs.watch(dir, (eventType, changedFilename) => {
-            if (changedFilename === filename) {
-              this.handleSettingsChange();
-            }
-          });
-
-          watcher.on("error", (error) => {
-            this.logger.error(`Settings watcher error for ${filePath}:`, error);
-          });
-
-          this.watchers.push(watcher);
-        }
-      } catch (error) {
-        this.logger.error(`Failed to set up watcher for ${filePath}:`, error);
-      }
-    }
-  }
-
-  /**
-   * Handles settings file changes with debouncing to avoid rapid reloads
-   */
-  private handleSettingsChange(): void {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-    }
-
-    this.debounceTimer = setTimeout(async () => {
-      this.debounceTimer = null;
-      if (this.disposed) {
-        return;
-      }
-      try {
-        await this.loadAllSettings();
-        if (!this.disposed) {
-          this.onChange?.();
-        }
-      } catch (error) {
-        this.logger.error("Failed to reload settings:", error);
-      }
-    }, 100);
-  }
-
-  /**
-   * Returns the current merged settings
-   */
-  getSettings(): Settings {
-    return this.effective;
-  }
-
-  /**
-   * Returns the current working directory
-   */
-  getCwd(): string {
-    return this.cwd;
-  }
-
-  /**
-   * Updates the working directory and reloads project-specific settings
-   */
-  async setCwd(cwd: string): Promise<void> {
-    if (this.cwd === cwd) {
-      return;
-    }
-
-    this.dispose();
-    this.cwd = cwd;
-    await this.initialize();
-  }
-
-  /**
-   * Disposes of file watchers and cleans up resources
-   */
-  dispose(): void {
-    this.disposed = true;
-    this.initialized = false;
-    this.initPromise = null;
-
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.debounceTimer = null;
-    }
-
-    for (const watcher of this.watchers) {
-      watcher.close();
-    }
-    this.watchers = [];
-  }
-}
--- a/src/tests/.claude/commands/say-hello.md
+++ b/src/tests/.claude/commands/say-hello.md
@@ -1,6 +1,6 @@
 ---
 description: Say hello
-argument-hint: name
+argument-hint: [name]
 ---

-Respond with "Hello $ARGUMENTS" and nothing else.
+Respond with "Hello $1" and nothing else.
--- a/src/tests/acp-agent-settings.test.ts
+++ b/src/tests/acp-agent-settings.test.ts
--- a/src/tests/acp-agent.test.ts
+++ b/src/tests/acp-agent.test.ts
--- a/src/tests/additional-roots.test.ts
+++ b/src/tests/additional-roots.test.ts
@@ -1,108 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { SessionNotification } from "@agentclientprotocol/sdk";
-import type { Options } from "@anthropic-ai/claude-agent-sdk";
-import type { AcpClient, ClaudeAcpAgent as ClaudeAcpAgentType } from "../acp-agent.js";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-let capturedOptions: Options | undefined;
-vi.mock("@anthropic-ai/claude-agent-sdk", async () => ({
-  ...(await vi.importActual<typeof import("@anthropic-ai/claude-agent-sdk")>(
-    "@anthropic-ai/claude-agent-sdk",
-  )),
-  query: ({ options }: { options: Options }) => {
-    capturedOptions = options;
-    return {
-      initializationResult: async () => ({
-        models: [
-          {
-            value: "claude-sonnet-4-6",
-            displayName: "Claude Sonnet",
-            description: "Fast",
-            supportsAutoMode: true,
-          },
-        ],
-      }),
-      setModel: async () => {},
-      setPermissionMode: async () => {},
-      supportedCommands: async () => [],
-      [Symbol.asyncIterator]: async function* () {},
-    };
-  },
-}));
-vi.mock("../tools.js", async () => ({
-  ...(await vi.importActual<typeof import("../tools.js")>("../tools.js")),
-  registerHookCallback: vi.fn(),
-}));
-
-describe("additionalRoots", () => {
-  let agent: ClaudeAcpAgentType;
-  const tempDirs: string[] = [];
-  const newSession = (meta: Record<string, unknown>, cwd = process.cwd()) =>
-    agent.newSession({ cwd, mcpServers: [], _meta: meta });
-
-  beforeEach(async () => {
-    capturedOptions = undefined;
-    tempDirs.length = 0;
-    vi.resetModules();
-    const { ClaudeAcpAgent } = await import("../acp-agent.js");
-    agent = new ClaudeAcpAgent({
-      sessionUpdate: async (_notification: SessionNotification) => {},
-      requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
-      readTextFile: async () => ({ content: "" }),
-      writeTextFile: async () => ({}),
-    } as unknown as AcpClient);
-  });
-
-  afterEach(
-    async () =>
-      void (await Promise.all(tempDirs.map((dir) => rm(dir, { recursive: true, force: true })))),
-  );
-
-  it("passes through relative roots as provided", async () => {
-    const projectRoot = await mkdtemp(path.join(os.tmpdir(), "claude-project-"));
-    tempDirs.push(projectRoot);
-    await newSession({ additionalRoots: ["."] }, projectRoot);
-    expect(capturedOptions!.additionalDirectories).toEqual(["."]);
-  });
-
-  it("merges additionalRoots with user additionalDirectories without normalization", async () => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "claude-root-"));
-    tempDirs.push(root);
-    await newSession({
-      additionalRoots: ["", root],
-      claudeCode: { options: { additionalDirectories: ["/workspace/shared"] } },
-    });
-    expect(capturedOptions!.additionalDirectories).toEqual(["/workspace/shared", "", root]);
-  });
-
-  it("prefers the official ACP additionalDirectories field over _meta.additionalRoots", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      additionalDirectories: ["/from/official"],
-      _meta: { additionalRoots: ["/from/meta"] },
-    });
-    expect(capturedOptions!.additionalDirectories).toEqual(["/from/official"]);
-  });
-
-  it("merges official ACP additionalDirectories with claudeCode SDK additionalDirectories", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      additionalDirectories: ["/from/official"],
-      _meta: { claudeCode: { options: { additionalDirectories: ["/from/sdk"] } } },
-    });
-    expect(capturedOptions!.additionalDirectories).toEqual(["/from/sdk", "/from/official"]);
-  });
-
-  it("falls back to _meta.additionalRoots when the official field is omitted", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: { additionalRoots: ["/from/meta"] },
-    });
-    expect(capturedOptions!.additionalDirectories).toEqual(["/from/meta"]);
-  });
-});
--- a/src/tests/agent-discovery.test.ts
+++ b/src/tests/agent-discovery.test.ts
@@ -1,42 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { randomUUID } from "crypto";
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import type { SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
-import { Pushable } from "../utils.js";
-import { discoverCustomAgents, BUILTIN_AGENT_NAMES } from "../acp-agent.js";
-
-// `discoverCustomAgents` distinguishes user/plugin-configured agents from
-// Claude Code's built-in subagents by name (BUILTIN_AGENT_NAMES), since the
-// SDK's `AgentInfo` carries no built-in/source flag. That hardcoded set drifts
-// silently if the SDK changes its default roster: a newly added built-in would
-// leak into the ACP "Agent" picker as if the user had configured it. This
-// integration test runs the real SDK so the set is flagged the moment it does.
-describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("agent discovery (SDK)", () => {
-  it("BUILTIN_AGENT_NAMES exactly covers the SDK's default agent roster", async () => {
-    const input = new Pushable<SDKUserMessage>();
-    const q = query({
-      prompt: input,
-      options: {
-        systemPrompt: { type: "preset", preset: "claude_code" },
-        sessionId: randomUUID(),
-        // No setting sources → no user/project/local custom agents are loaded,
-        // so `supportedAgents()` reports exactly the intrinsic built-ins
-        // regardless of what the developer has in ~/.claude/agents.
-        settingSources: [],
-        includePartialMessages: true,
-      },
-    });
-
-    try {
-      const reported = (await q.supportedAgents()).map((a) => a.name).sort();
-      expect(reported).toEqual([...BUILTIN_AGENT_NAMES].sort());
-
-      // With the built-ins being the only agents present, discovery surfaces
-      // nothing — the ACP "Agent" picker is correctly omitted.
-      expect(await discoverCustomAgents(q)).toEqual([]);
-    } finally {
-      input.end();
-      q.return(undefined);
-    }
-  }, 30000);
-});
--- a/src/tests/authorization.test.ts
+++ b/src/tests/authorization.test.ts
@@ -1,298 +0,0 @@
-import { describe, expect, it, Mock, vi, afterEach, beforeEach } from "vitest";
-import { AcpClient, ClaudeAcpAgent } from "../acp-agent.js";
-
-const mockQuery = vi.hoisted(() =>
-  vi.fn(() => ({
-    initializationResult: vi.fn().mockResolvedValue({
-      models: [
-        { value: "id", displayName: "name", description: "description", supportsAutoMode: true },
-      ],
-    }),
-    setModel: vi.fn(),
-    setPermissionMode: vi.fn(),
-    supportedCommands: vi.fn().mockResolvedValue([]),
-  })),
-);
-
-vi.mock("@anthropic-ai/claude-agent-sdk", async () => ({
-  ...(await vi.importActual<typeof import("@anthropic-ai/claude-agent-sdk")>(
-    "@anthropic-ai/claude-agent-sdk",
-  )),
-  query: mockQuery,
-}));
-
-describe("authorization", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    //await all pending events like
-    vi.runAllTimers();
-    vi.useRealTimers();
-
-    vi.unstubAllGlobals();
-    vi.resetAllMocks();
-  });
-
-  async function createAgentMock(): Promise<[ClaudeAcpAgent, Mock]> {
-    const connectionMock = {
-      sessionUpdate: async (_: any) => {},
-    } as AcpClient;
-
-    const agent = new ClaudeAcpAgent(connectionMock);
-
-    return [agent, mockQuery];
-  }
-
-  it("gateway auth not offered without capability", async () => {
-    const [agent] = await createAgentMock();
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {},
-    });
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "gateway" }),
-    );
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "gateway-bedrock" }),
-    );
-  });
-
-  it("gateway auth offered when client advertises auth._meta.gateway capability", async () => {
-    const [agent] = await createAgentMock();
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {
-        auth: { _meta: { gateway: true } },
-      } as any,
-    });
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({
-        id: "gateway",
-        _meta: { gateway: { protocol: "anthropic" } },
-      }),
-    );
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({
-        id: "gateway-bedrock",
-        _meta: { gateway: { protocol: "bedrock" } },
-      }),
-    );
-  });
-
-  it("uses gateway env after anthropic gateway auth", async () => {
-    const [agent, mockQuery] = await createAgentMock();
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {
-        auth: { terminal: true, _meta: { gateway: true } },
-      } as any,
-    });
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({ id: "gateway" }),
-    );
-
-    await agent.authenticate({
-      methodId: "gateway",
-      _meta: { gateway: { baseUrl: "https://gateway.example", headers: { "x-api-key": "test" } } },
-    });
-
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        claudeCode: {
-          options: {
-            env: {
-              userEnv: "userEnv",
-            },
-          },
-        },
-      },
-    });
-
-    expect(mockQuery).toHaveBeenCalledWith(
-      expect.objectContaining({
-        options: expect.objectContaining({
-          env: expect.objectContaining({
-            ANTHROPIC_AUTH_TOKEN: " ",
-            ANTHROPIC_BASE_URL: "https://gateway.example",
-            ANTHROPIC_CUSTOM_HEADERS: "x-api-key: test",
-            userEnv: "userEnv",
-          }),
-        }),
-      }),
-    );
-  });
-
-  it("uses gateway env after gateway auth", async () => {
-    const [agent, mockQuery] = await createAgentMock();
-
-    await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {
-        auth: { terminal: true, _meta: { gateway: true } },
-      } as any,
-    });
-
-    await agent.authenticate({
-      methodId: "gateway-bedrock",
-      _meta: {
-        gateway: { baseUrl: "https://gateway.example", headers: { "custom-header": "test" } },
-      },
-    });
-
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-    });
-
-    expect(mockQuery).toHaveBeenCalledWith(
-      expect.objectContaining({
-        options: expect.objectContaining({
-          env: expect.objectContaining({
-            CLAUDE_CODE_USE_BEDROCK: "1",
-            AWS_BEARER_TOKEN_BEDROCK: " ",
-            ANTHROPIC_BEDROCK_BASE_URL: "https://gateway.example",
-            ANTHROPIC_CUSTOM_HEADERS: "custom-header: test",
-          }),
-        }),
-      }),
-    );
-  });
-
-  it("hide claude authentication without terminal-auth", async () => {
-    const [agent] = await createAgentMock();
-    vi.stubGlobal("process", { ...process, argv: ["--hide-claude-auth"] });
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {
-        auth: { _meta: { gateway: true } },
-      } as any,
-    });
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "claude-ai-login" }),
-    );
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "console-login" }),
-    );
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({ id: "gateway" }),
-    );
-  });
-
-  it("hide claude auth but still show console login when terminal-auth is set", async () => {
-    const [agent] = await createAgentMock();
-    vi.stubGlobal("process", { ...process, argv: ["--hide-claude-auth"] });
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {
-        _meta: { "terminal-auth": true },
-      },
-    });
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "claude-ai-login" }),
-    );
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({ id: "console-login" }),
-    );
-  });
-
-  it("hide claude auth but still show console login with terminal capability", async () => {
-    const [agent] = await createAgentMock();
-    vi.stubGlobal("process", { ...process, argv: ["--hide-claude-auth"] });
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: {
-        auth: { terminal: true },
-      },
-    });
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "claude-ai-login" }),
-    );
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({ id: "console-login" }),
-    );
-  });
-
-  it("SSH session falls back to single legacy login method", async () => {
-    const [agent] = await createAgentMock();
-    vi.stubGlobal("process", { ...process, env: { ...process.env, SSH_TTY: "/dev/pts/0" } });
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: { auth: { terminal: true } },
-    });
-
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({ id: "claude-login" }),
-    );
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "claude-ai-login" }),
-    );
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "console-login" }),
-    );
-  });
-
-  it("CLAUDE_CODE_REMOTE falls back to single legacy login method", async () => {
-    const [agent] = await createAgentMock();
-    vi.stubGlobal("process", { ...process, env: { ...process.env, CLAUDE_CODE_REMOTE: "1" } });
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: { auth: { terminal: true } },
-    });
-
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({ id: "claude-login" }),
-    );
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "claude-ai-login" }),
-    );
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "console-login" }),
-    );
-  });
-
-  it("remote environment respects hide-claude-auth", async () => {
-    const [agent] = await createAgentMock();
-    vi.stubGlobal("process", {
-      ...process,
-      argv: ["--hide-claude-auth"],
-      env: { ...process.env, SSH_CONNECTION: "192.168.1.1 12345 192.168.1.2 22" },
-    });
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: { auth: { terminal: true } },
-    });
-
-    expect(initializeResponse.authMethods).not.toContainEqual(
-      expect.objectContaining({ id: "claude-login" }),
-    );
-  });
-
-  it("show claude authentication", async () => {
-    const [agent] = await createAgentMock();
-
-    const initializeResponse = await agent.initialize({
-      protocolVersion: 1,
-      clientCapabilities: { auth: { terminal: true } },
-    });
-
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({ id: "claude-ai-login" }),
-    );
-    expect(initializeResponse.authMethods).toContainEqual(
-      expect.objectContaining({ id: "console-login" }),
-    );
-  });
-});
--- a/src/tests/create-session-options.test.ts
+++ b/src/tests/create-session-options.test.ts
@@ -1,739 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { RequestError, SessionNotification } from "@agentclientprotocol/sdk";
-import type { Options } from "@anthropic-ai/claude-agent-sdk";
-import type { AcpClient, ClaudeAcpAgent as ClaudeAcpAgentType } from "../acp-agent.js";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-
-let capturedOptions: Options | undefined;
-vi.mock("@anthropic-ai/claude-agent-sdk", async () => {
-  const actual = await vi.importActual<typeof import("@anthropic-ai/claude-agent-sdk")>(
-    "@anthropic-ai/claude-agent-sdk",
-  );
-  return {
-    ...actual,
-    query: (args: { prompt: unknown; options: Options }) => {
-      capturedOptions = args.options;
-      return {
-        initializationResult: async () => ({
-          models: [
-            {
-              value: "claude-sonnet-4-6",
-              displayName: "Claude Sonnet",
-              description: "Fast",
-              supportsAutoMode: true,
-            },
-          ],
-        }),
-        setModel: async () => {},
-        setPermissionMode: async () => {},
-        supportedCommands: async () => [],
-        [Symbol.asyncIterator]: async function* () {},
-      };
-    },
-  };
-});
-
-vi.mock("../tools.js", async () => {
-  const actual = await vi.importActual<typeof import("../tools.js")>("../tools.js");
-  return {
-    ...actual,
-    registerHookCallback: vi.fn(),
-  };
-});
-
-describe("createSession options merging", () => {
-  let agent: ClaudeAcpAgentType;
-  let ClaudeAcpAgent: typeof ClaudeAcpAgentType;
-
-  function createMockClient(): AcpClient {
-    return {
-      sessionUpdate: async (_notification: SessionNotification) => {},
-      requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
-      readTextFile: async () => ({ content: "" }),
-      writeTextFile: async () => ({}),
-    } as unknown as AcpClient;
-  }
-
-  beforeEach(async () => {
-    capturedOptions = undefined;
-
-    vi.resetModules();
-    const acpAgent = await import("../acp-agent.js");
-    ClaudeAcpAgent = acpAgent.ClaudeAcpAgent;
-
-    agent = new ClaudeAcpAgent(createMockClient());
-  });
-
-  it("merges user-provided disallowedTools with ACP internal list", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        claudeCode: {
-          options: {
-            disallowedTools: ["WebSearch", "WebFetch"],
-          },
-        },
-      },
-    });
-
-    // User-provided tools should be present
-    expect(capturedOptions!.disallowedTools).toContain("WebSearch");
-    expect(capturedOptions!.disallowedTools).toContain("WebFetch");
-    // ACP's internal disallowed tool should also be present
-    expect(capturedOptions!.disallowedTools).toContain("AskUserQuestion");
-  });
-
-  it("works when user provides no disallowedTools", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-    });
-
-    expect(capturedOptions!.disallowedTools).toContain("AskUserQuestion");
-  });
-
-  it("works when user provides empty disallowedTools", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        claudeCode: {
-          options: {
-            disallowedTools: [],
-          },
-        },
-      },
-    });
-
-    expect(capturedOptions!.disallowedTools).toContain("AskUserQuestion");
-  });
-
-  it("sets tools to empty array when disableBuiltInTools is true", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        disableBuiltInTools: true,
-        claudeCode: {
-          options: {
-            disallowedTools: ["CustomTool"],
-          },
-        },
-      },
-    });
-
-    // disableBuiltInTools removes all built-in tools from context
-    expect(capturedOptions!.tools).toEqual([]);
-    // User-provided and ACP disallowedTools still apply
-    expect(capturedOptions!.disallowedTools).toContain("CustomTool");
-    expect(capturedOptions!.disallowedTools).toContain("AskUserQuestion");
-  });
-
-  it("merges user-provided hooks with ACP hooks", async () => {
-    const userPreToolUseHook = { hooks: [{ command: "echo pre" }] };
-
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        claudeCode: {
-          options: {
-            hooks: {
-              PreToolUse: [userPreToolUseHook],
-              PostToolUse: [{ hooks: [{ command: "echo user-post" }] }],
-            },
-          },
-        },
-      },
-    });
-
-    // User's PreToolUse hooks should be preserved
-    expect(capturedOptions!.hooks?.PreToolUse).toEqual([userPreToolUseHook]);
-    // PostToolUse should contain both user and ACP hooks
-    expect(capturedOptions!.hooks?.PostToolUse).toHaveLength(2);
-  });
-
-  it("inherits HOME and PATH from process.env when no env is provided", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-    });
-
-    expect(capturedOptions?.env?.HOME).toBe(process.env.HOME);
-    expect(capturedOptions?.env?.PATH).toBe(process.env.PATH);
-  });
-
-  it("merges user-provided env vars on top of process.env", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        claudeCode: {
-          options: {
-            env: {
-              CUSTOM_VAR: "custom-value",
-            },
-          },
-        },
-      },
-    });
-
-    expect(capturedOptions?.env?.HOME).toBe(process.env.HOME);
-    expect(capturedOptions?.env?.PATH).toBe(process.env.PATH);
-    expect(capturedOptions?.env?.CUSTOM_VAR).toBe("custom-value");
-  });
-
-  it("allows user-provided env vars to override process.env entries", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        claudeCode: {
-          options: {
-            env: {
-              HOME: "/custom/home",
-            },
-          },
-        },
-      },
-    });
-
-    expect(capturedOptions?.env?.HOME).toBe("/custom/home");
-  });
-
-  it("defaults tools to claude_code preset when not provided", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-    });
-
-    expect(capturedOptions!.tools).toEqual({ type: "preset", preset: "claude_code" });
-  });
-
-  it("passes through user-provided tools string array", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        claudeCode: {
-          options: {
-            tools: ["Read", "Glob"],
-          },
-        },
-      },
-    });
-
-    expect(capturedOptions!.tools).toEqual(["Read", "Glob"]);
-  });
-
-  it("explicit tools array takes precedence over disableBuiltInTools", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        disableBuiltInTools: true,
-        claudeCode: {
-          options: {
-            tools: ["Read", "Glob"],
-          },
-        },
-      },
-    });
-
-    expect(capturedOptions!.tools).toEqual(["Read", "Glob"]);
-  });
-
-  it("passes through empty tools array to disable all built-in tools", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-      _meta: {
-        claudeCode: {
-          options: {
-            tools: [],
-          },
-        },
-      },
-    });
-
-    expect(capturedOptions!.tools).toEqual([]);
-  });
-
-  describe("systemPrompt via _meta", () => {
-    it("defaults to the claude_code preset when not provided", async () => {
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.systemPrompt).toEqual({
-        type: "preset",
-        preset: "claude_code",
-      });
-    });
-
-    it("replaces the preset when a string is provided", async () => {
-      await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-        _meta: { systemPrompt: "custom prompt" },
-      });
-
-      expect(capturedOptions!.systemPrompt).toBe("custom prompt");
-    });
-
-    it("forwards append", async () => {
-      await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-        _meta: { systemPrompt: { append: "extra instructions" } },
-      });
-
-      expect(capturedOptions!.systemPrompt).toEqual({
-        type: "preset",
-        preset: "claude_code",
-        append: "extra instructions",
-      });
-    });
-
-    it("forwards excludeDynamicSections", async () => {
-      await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-        _meta: { systemPrompt: { excludeDynamicSections: true } },
-      });
-
-      expect(capturedOptions!.systemPrompt).toEqual({
-        type: "preset",
-        preset: "claude_code",
-        excludeDynamicSections: true,
-      });
-    });
-
-    it("forwards append and excludeDynamicSections together", async () => {
-      await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-        _meta: {
-          systemPrompt: {
-            append: "extra instructions",
-            excludeDynamicSections: true,
-          },
-        },
-      });
-
-      expect(capturedOptions!.systemPrompt).toEqual({
-        type: "preset",
-        preset: "claude_code",
-        append: "extra instructions",
-        excludeDynamicSections: true,
-      });
-    });
-
-    it("ignores caller-provided type/preset overrides", async () => {
-      await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-        _meta: {
-          systemPrompt: {
-            type: "something-else",
-            preset: "other-preset",
-            append: "extra",
-          },
-        },
-      });
-
-      expect(capturedOptions!.systemPrompt).toEqual({
-        type: "preset",
-        preset: "claude_code",
-        append: "extra",
-      });
-    });
-  });
-
-  describe("CLAUDE_MODEL_CONFIG", () => {
-    let originalModelConfig: string | undefined;
-
-    beforeEach(() => {
-      originalModelConfig = process.env.CLAUDE_MODEL_CONFIG;
-      delete process.env.CLAUDE_MODEL_CONFIG;
-    });
-
-    afterEach(() => {
-      if (originalModelConfig !== undefined) {
-        process.env.CLAUDE_MODEL_CONFIG = originalModelConfig;
-      } else {
-        delete process.env.CLAUDE_MODEL_CONFIG;
-      }
-    });
-
-    it("passes modelOverrides as settings", async () => {
-      process.env.CLAUDE_MODEL_CONFIG = JSON.stringify({
-        modelOverrides: { "claude-opus-4-6": "us.anthropic.claude-opus-4-6-v1" },
-      });
-
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.settings).toEqual({
-        modelOverrides: { "claude-opus-4-6": "us.anthropic.claude-opus-4-6-v1" },
-      });
-    });
-
-    it("passes availableModels as settings", async () => {
-      process.env.CLAUDE_MODEL_CONFIG = JSON.stringify({
-        availableModels: ["opus", "sonnet"],
-      });
-
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.settings).toEqual({
-        availableModels: ["opus", "sonnet"],
-      });
-    });
-
-    it("passes both modelOverrides and availableModels", async () => {
-      process.env.CLAUDE_MODEL_CONFIG = JSON.stringify({
-        modelOverrides: { "claude-opus-4-6": "us.anthropic.claude-opus-4-6-v1" },
-        availableModels: ["opus"],
-      });
-
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.settings).toEqual({
-        modelOverrides: { "claude-opus-4-6": "us.anthropic.claude-opus-4-6-v1" },
-        availableModels: ["opus"],
-      });
-    });
-
-    it("does not add settings when env var is not set", async () => {
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.settings).toBeUndefined();
-    });
-
-    it("ignores env var when _meta provides settings", async () => {
-      process.env.CLAUDE_MODEL_CONFIG = JSON.stringify({
-        modelOverrides: { "claude-opus-4-6": "us.anthropic.claude-opus-4-6-v1" },
-      });
-
-      await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-        _meta: {
-          claudeCode: {
-            options: {
-              settings: {
-                model: "claude-sonnet-4-6",
-                modelOverrides: { "claude-opus-4-6": "meta-value" },
-              },
-            },
-          },
-        },
-      });
-
-      // _meta settings take precedence; env var is ignored entirely
-      expect(capturedOptions!.settings).toEqual({
-        model: "claude-sonnet-4-6",
-        modelOverrides: { "claude-opus-4-6": "meta-value" },
-      });
-    });
-
-    it("throws on invalid JSON", async () => {
-      process.env.CLAUDE_MODEL_CONFIG = "not-json";
-
-      await expect(agent.newSession({ cwd: process.cwd(), mcpServers: [] })).rejects.toThrow();
-    });
-  });
-
-  it("merges user-provided mcpServers with ACP mcpServers", async () => {
-    await agent.newSession({
-      cwd: process.cwd(),
-      mcpServers: [
-        {
-          name: "acp-server",
-          command: "node",
-          args: ["acp-server.js"],
-          env: [],
-        },
-      ],
-      _meta: {
-        claudeCode: {
-          options: {
-            mcpServers: {
-              "user-server": {
-                type: "stdio",
-                command: "node",
-                args: ["server.js"],
-              },
-            },
-          },
-        },
-      },
-    });
-
-    // User-provided MCP server should be present
-    expect(capturedOptions!.mcpServers).toHaveProperty("user-server");
-    // ACP-provided MCP server should also be present
-    expect(capturedOptions!.mcpServers).toHaveProperty("acp-server");
-  });
-
-  describe("thinking config from MAX_THINKING_TOKENS", () => {
-    let originalMaxThinking: string | undefined;
-
-    beforeEach(() => {
-      originalMaxThinking = process.env.MAX_THINKING_TOKENS;
-      delete process.env.MAX_THINKING_TOKENS;
-    });
-
-    afterEach(() => {
-      if (originalMaxThinking !== undefined) {
-        process.env.MAX_THINKING_TOKENS = originalMaxThinking;
-      } else {
-        delete process.env.MAX_THINKING_TOKENS;
-      }
-    });
-
-    it("leaves thinking unset (SDK default) when env var is absent", async () => {
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-      expect(capturedOptions!.thinking).toBeUndefined();
-      // The deprecated option must not be set either.
-      expect(capturedOptions!.maxThinkingTokens).toBeUndefined();
-    });
-
-    it("maps 0 to disabled thinking", async () => {
-      process.env.MAX_THINKING_TOKENS = "0";
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-      expect(capturedOptions!.thinking).toEqual({ type: "disabled" });
-    });
-
-    it("maps a positive value to a fixed thinking budget", async () => {
-      process.env.MAX_THINKING_TOKENS = "12000";
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-      expect(capturedOptions!.thinking).toEqual({ type: "enabled", budgetTokens: 12000 });
-    });
-
-    it("ignores a non-numeric value", async () => {
-      process.env.MAX_THINKING_TOKENS = "lots";
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-      expect(capturedOptions!.thinking).toBeUndefined();
-    });
-
-    it("lets a user-provided thinking option override the env default", async () => {
-      process.env.MAX_THINKING_TOKENS = "12000";
-      await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-        _meta: {
-          claudeCode: {
-            options: {
-              thinking: { type: "adaptive" },
-            },
-          },
-        },
-      });
-      expect(capturedOptions!.thinking).toEqual({ type: "adaptive" });
-    });
-  });
-
-  describe("cwd validation", () => {
-    it("rejects a relative cwd with invalidParams", async () => {
-      await expect(
-        agent.newSession({ cwd: "relative/path", mcpServers: [] }),
-      ).rejects.toMatchObject({ code: RequestError.invalidParams().code });
-    });
-
-    it("rejects a non-existent cwd with invalidParams", async () => {
-      const missing = path.join(os.tmpdir(), "claude-acp-does-not-exist-xyz");
-      await expect(agent.newSession({ cwd: missing, mcpServers: [] })).rejects.toMatchObject({
-        code: RequestError.invalidParams().code,
-      });
-    });
-
-    it("rejects a cwd that points at a file with invalidParams", async () => {
-      const dir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-acp-cwd-is-a-file-"));
-      const file = path.join(dir, "not-a-directory.txt");
-      fs.writeFileSync(file, "not a directory");
-      try {
-        await expect(agent.newSession({ cwd: file, mcpServers: [] })).rejects.toMatchObject({
-          code: RequestError.invalidParams().code,
-        });
-      } finally {
-        fs.rmSync(dir, { recursive: true, force: true });
-      }
-    });
-
-    it("accepts an existing absolute directory", async () => {
-      await expect(agent.newSession({ cwd: process.cwd(), mcpServers: [] })).resolves.toBeDefined();
-    });
-  });
-
-  describe("elicitation", () => {
-    it("keeps AskUserQuestion disabled and omits callbacks without elicitation capability", async () => {
-      await agent.initialize({ protocolVersion: 1, clientCapabilities: {} });
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.disallowedTools).toContain("AskUserQuestion");
-      expect(capturedOptions!.onElicitation).toBeUndefined();
-    });
-
-    it("enables AskUserQuestion and wires the elicitation callback when form is supported", async () => {
-      await agent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: { elicitation: { form: {} } },
-      });
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.disallowedTools).not.toContain("AskUserQuestion");
-      expect(typeof capturedOptions!.onElicitation).toBe("function");
-    });
-
-    it("wires callbacks for url-only elicitation but keeps AskUserQuestion disabled", async () => {
-      await agent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: { elicitation: { url: {} } },
-      });
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.disallowedTools).toContain("AskUserQuestion");
-      expect(typeof capturedOptions!.onElicitation).toBe("function");
-    });
-
-    it("still merges user-provided disallowedTools when AskUserQuestion is enabled", async () => {
-      await agent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: { elicitation: { form: {} } },
-      });
-      await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-        _meta: { claudeCode: { options: { disallowedTools: ["WebSearch"] } } },
-      });
-
-      expect(capturedOptions!.disallowedTools).toContain("WebSearch");
-      expect(capturedOptions!.disallowedTools).not.toContain("AskUserQuestion");
-    });
-  });
-
-  describe("refusal fallback dialog", () => {
-    it("declares the dialog kind and callback when the client supports form elicitation", async () => {
-      await agent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: { elicitation: { form: {} } },
-      });
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      expect(capturedOptions!.supportedDialogKinds).toEqual(["refusal_fallback_prompt"]);
-      expect(typeof capturedOptions!.onUserDialog).toBe("function");
-    });
-
-    it("omits the dialog wiring without form elicitation support (url-only included)", async () => {
-      await agent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: { elicitation: { url: {} } },
-      });
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-
-      // The CLI fails closed on the undeclared kind, so the flow degrades to
-      // the classic refusal error instead of parking a dialog we can't render.
-      expect(capturedOptions!.supportedDialogKinds).toBeUndefined();
-      expect(capturedOptions!.onUserDialog).toBeUndefined();
-    });
-
-    /** Wire the session up with form support and return the captured dialog
-     *  callback plus a mock the test can point the elicitation response at. */
-    async function setupDialog() {
-      await agent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: { elicitation: { form: {} } },
-      });
-      await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
-      const createElicitation = vi.fn();
-      (
-        agent as unknown as { client: { unstable_createElicitation: unknown } }
-      ).client.unstable_createElicitation = createElicitation;
-      return { onUserDialog: capturedOptions!.onUserDialog!, createElicitation };
-    }
-
-    const signal = () => ({ signal: new AbortController().signal });
-
-    it("renders the prompt as a form elicitation and maps the retry choice", async () => {
-      const { onUserDialog, createElicitation } = await setupDialog();
-      createElicitation.mockResolvedValue({
-        action: "accept",
-        content: { choice: "retry_fallback" },
-      });
-
-      const result = await onUserDialog(
-        {
-          dialogKind: "refusal_fallback_prompt",
-          payload: {
-            originalModel: "claude-fable-5",
-            fallbackModel: "claude-opus-4-8",
-            apiRefusalCategory: "cyber",
-          },
-        },
-        signal(),
-      );
-
-      expect(result).toEqual({ behavior: "completed", result: "retry_fallback" });
-      const request = createElicitation.mock.calls[0][0];
-      expect(request.mode).toBe("form");
-      expect(request.message).toContain("claude-fable-5");
-      expect(request.message).toContain("claude-opus-4-8");
-    });
-
-    it("completes with cancelled when the user keeps the refusal", async () => {
-      const { onUserDialog, createElicitation } = await setupDialog();
-      createElicitation.mockResolvedValue({ action: "cancel" });
-
-      const result = await onUserDialog(
-        {
-          dialogKind: "refusal_fallback_prompt",
-          payload: { originalModel: "a", fallbackModel: "b" },
-        },
-        signal(),
-      );
-
-      expect(result).toEqual({ behavior: "completed", result: "cancelled" });
-    });
-
-    it("cancels unrecognized dialog kinds without presenting anything", async () => {
-      const { onUserDialog, createElicitation } = await setupDialog();
-
-      const result = await onUserDialog(
-        { dialogKind: "some_future_dialog", payload: {} },
-        signal(),
-      );
-
-      expect(result).toEqual({ behavior: "cancelled" });
-      expect(createElicitation).not.toHaveBeenCalled();
-    });
-
-    it("cancels on a malformed payload without presenting anything", async () => {
-      const { onUserDialog, createElicitation } = await setupDialog();
-
-      const result = await onUserDialog(
-        { dialogKind: "refusal_fallback_prompt", payload: { fallbackModel: 42 } },
-        signal(),
-      );
-
-      expect(result).toEqual({ behavior: "cancelled" });
-      expect(createElicitation).not.toHaveBeenCalled();
-    });
-
-    it("cancels when the elicitation request fails", async () => {
-      const { onUserDialog, createElicitation } = await setupDialog();
-      createElicitation.mockRejectedValue(new Error("client exploded"));
-
-      const result = await onUserDialog(
-        {
-          dialogKind: "refusal_fallback_prompt",
-          payload: { originalModel: "a", fallbackModel: "b" },
-        },
-        signal(),
-      );
-
-      expect(result).toEqual({ behavior: "cancelled" });
-    });
-  });
-});
--- a/src/tests/elicitation.test.ts
+++ b/src/tests/elicitation.test.ts
@@ -1,504 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type {
-  CreateElicitationRequest,
-  CreateElicitationResponse,
-  EnumOption,
-} from "@agentclientprotocol/sdk";
-import type { ElicitationRequest } from "@anthropic-ai/claude-agent-sdk";
-import {
-  applyAskElicitationResponse,
-  askUserQuestionsToCreateRequest,
-  AskUserQuestion,
-  createElicitationResponseToElicitResult,
-  extractAskUserQuestions,
-  extractRefusalFallbackPrompt,
-  mcpElicitationToCreateRequest,
-  refusalFallbackResultFromResponse,
-  refusalFallbackToCreateRequest,
-} from "../elicitation.js";
-
-const SESSION_ID = "session-1";
-
-/**
- * Build a question matching the SDK's (strict) AskUserQuestion schema while
- * keeping test sites terse. Option descriptions default to "" (the tool always
- * provides one); pass a description to exercise the enum option's description.
- */
-function mkQuestion(
-  question: string,
-  options: Array<{ label: string; description?: string; preview?: string }>,
-  opts: { header?: string; multiSelect?: boolean } = {},
-): AskUserQuestion {
-  return {
-    question,
-    header: opts.header ?? "",
-    multiSelect: opts.multiSelect ?? false,
-    options: options.map((o) => ({
-      label: o.label,
-      description: o.description ?? "",
-      ...(o.preview ? { preview: o.preview } : {}),
-    })),
-  } as AskUserQuestion;
-}
-
-describe("mcpElicitationToCreateRequest", () => {
-  it("maps a form-mode request, defaulting the schema type to object", () => {
-    const request: ElicitationRequest = {
-      serverName: "server",
-      message: "Need your name",
-      mode: "form",
-      requestedSchema: { properties: { name: { type: "string" } } },
-    };
-
-    const result = mcpElicitationToCreateRequest(request, SESSION_ID);
-
-    expect(result).toEqual({
-      mode: "form",
-      sessionId: SESSION_ID,
-      message: "Need your name",
-      requestedSchema: { type: "object", properties: { name: { type: "string" } } },
-    });
-  });
-
-  it("maps a url-mode request and preserves the elicitation id", () => {
-    const request: ElicitationRequest = {
-      serverName: "server",
-      message: "Authorize",
-      mode: "url",
-      url: "https://example.com/auth",
-      elicitationId: "el-123",
-    };
-
-    expect(mcpElicitationToCreateRequest(request, SESSION_ID)).toEqual({
-      mode: "url",
-      sessionId: SESSION_ID,
-      message: "Authorize",
-      url: "https://example.com/auth",
-      elicitationId: "el-123",
-    });
-  });
-
-  it("generates an elicitation id when a url request omits one", () => {
-    const request: ElicitationRequest = {
-      serverName: "server",
-      message: "Authorize",
-      mode: "url",
-      url: "https://example.com/auth",
-    };
-
-    const result = mcpElicitationToCreateRequest(request, SESSION_ID);
-    expect(result?.mode).toBe("url");
-    expect((result as { elicitationId: string }).elicitationId).toMatch(/.+/);
-  });
-
-  it("returns null for a url request with no url", () => {
-    const request: ElicitationRequest = {
-      serverName: "server",
-      message: "Authorize",
-      mode: "url",
-    };
-
-    expect(mcpElicitationToCreateRequest(request, SESSION_ID)).toBeNull();
-  });
-});
-
-describe("createElicitationResponseToElicitResult", () => {
-  it("maps accept with content", () => {
-    const response = { action: "accept", content: { name: "Ada" } } as CreateElicitationResponse;
-    expect(createElicitationResponseToElicitResult(response)).toEqual({
-      action: "accept",
-      content: { name: "Ada" },
-    });
-  });
-
-  it("defaults accept content to an empty object", () => {
-    const response = { action: "accept" } as CreateElicitationResponse;
-    expect(createElicitationResponseToElicitResult(response)).toEqual({
-      action: "accept",
-      content: {},
-    });
-  });
-
-  it("maps decline and cancel", () => {
-    expect(
-      createElicitationResponseToElicitResult({ action: "decline" } as CreateElicitationResponse),
-    ).toEqual({ action: "decline" });
-    expect(
-      createElicitationResponseToElicitResult({ action: "cancel" } as CreateElicitationResponse),
-    ).toEqual({ action: "cancel" });
-  });
-
-  it("maps a custom/future action to cancel", () => {
-    expect(
-      createElicitationResponseToElicitResult({
-        action: "_zed/snooze",
-      } as CreateElicitationResponse),
-    ).toEqual({ action: "cancel" });
-  });
-});
-
-describe("extractAskUserQuestions", () => {
-  const question = mkQuestion("Which?", [{ label: "A" }, { label: "B" }]);
-
-  it("reads questions off the tool input", () => {
-    expect(extractAskUserQuestions({ questions: [question] })).toEqual([question]);
-  });
-
-  it("returns null when there are no questions", () => {
-    expect(extractAskUserQuestions({})).toBeNull();
-    expect(extractAskUserQuestions({ questions: [] })).toBeNull();
-  });
-
-  it("filters out malformed questions (missing options, empty options, bad question)", () => {
-    const input = {
-      questions: [
-        question,
-        { question: "missing options" },
-        { options: [] },
-        { options: [], question: "empty" },
-      ],
-    } as unknown as Record<string, unknown>;
-    expect(extractAskUserQuestions(input)).toEqual([question]);
-  });
-
-  it("returns null when every question is filtered out", () => {
-    const input = {
-      questions: [{ question: "no options" }, { options: [{ label: "A" }] }],
-    } as unknown as Record<string, unknown>;
-    expect(extractAskUserQuestions(input)).toBeNull();
-  });
-});
-
-describe("askUserQuestionsToCreateRequest", () => {
-  it("keys a single-select question by a stable id and carries the prompt in message only", () => {
-    const questions = [
-      mkQuestion(
-        "Which library?",
-        [{ label: "date-fns", description: "Lightweight" }, { label: "luxon" }],
-        {
-          header: "Library",
-        },
-      ),
-    ];
-
-    const result = askUserQuestionsToCreateRequest(questions, SESSION_ID, "tool-1");
-
-    expect(result).toMatchObject({
-      mode: "form",
-      sessionId: SESSION_ID,
-      toolCallId: "tool-1",
-      message: "Which library?",
-    });
-    const schema = (result as Extract<CreateElicitationRequest, { mode: "form" }>).requestedSchema;
-    // Nothing is required; the user can pick, type a custom answer, or skip.
-    expect(schema.required).toBeUndefined();
-    // Single question → no duplicated description (prompt is in `message`).
-    expect(schema.properties?.["question_0"]).toEqual({
-      type: "string",
-      title: "Library",
-      description: undefined,
-      oneOf: [
-        // The description travels in the enum option's first-class field; the
-        // title stays the clean label (no "label — description" flattening).
-        { const: "date-fns", title: "date-fns", description: "Lightweight" },
-        // No description → the field is omitted entirely.
-        { const: "luxon", title: "luxon" },
-      ],
-    });
-    // The full question text is not used as a property key.
-    expect(schema.properties?.["Which library?"]).toBeUndefined();
-  });
-
-  it("carries descriptions structurally and forwards previews under _meta", () => {
-    const questions = [
-      mkQuestion("Which layout?", [
-        {
-          label: "Grid",
-          description: "Cards in a responsive grid",
-          preview: "```\n[ ] [ ] [ ]\n[ ] [ ] [ ]\n```",
-        },
-        { label: "List", description: "Stacked rows" },
-        { label: "Plain" },
-      ]),
-    ];
-
-    const schema = (
-      askUserQuestionsToCreateRequest(questions, SESSION_ID, undefined) as Extract<
-        CreateElicitationRequest,
-        { mode: "form" }
-      >
-    ).requestedSchema;
-    const oneOf = (schema.properties?.["question_0"] as { oneOf: EnumOption[] }).oneOf;
-
-    // The description uses the enum option's own field; only the preview —
-    // which still has no structural slot — rides under `_meta`.
-    expect(oneOf[0]).toEqual({
-      const: "Grid",
-      title: "Grid",
-      description: "Cards in a responsive grid",
-      _meta: {
-        "_claude/askUserQuestionOption": {
-          preview: "```\n[ ] [ ] [ ]\n[ ] [ ] [ ]\n```",
-        },
-      },
-    });
-    // Description only → no _meta needed.
-    expect(oneOf[1]).toEqual({ const: "List", title: "List", description: "Stacked rows" });
-    // Neither → just the label.
-    expect(oneOf[2]).toEqual({ const: "Plain", title: "Plain" });
-  });
-
-  it("includes a per-question optional free-text custom-answer field", () => {
-    const questions = [
-      mkQuestion("Which?", [{ label: "A" }, { label: "B" }]),
-      mkQuestion("What else?", [{ label: "C" }, { label: "D" }]),
-    ];
-    const schema = (
-      askUserQuestionsToCreateRequest(questions, SESSION_ID, undefined) as Extract<
-        CreateElicitationRequest,
-        { mode: "form" }
-      >
-    ).requestedSchema;
-
-    // Each question gets its own "Other" box, not one shared form-level field.
-    expect(schema.properties?.["question_0_custom"]).toMatchObject({
-      type: "string",
-      title: "Other",
-    });
-    expect(schema.properties?.["question_1_custom"]).toMatchObject({
-      type: "string",
-      title: "Other",
-    });
-  });
-
-  it("builds an array property for multi-select questions and includes per-field question text", () => {
-    const questions = [
-      mkQuestion("Pick one?", [{ label: "A" }, { label: "B" }]),
-      mkQuestion("Which features?", [{ label: "auth" }, { label: "logging" }], {
-        multiSelect: true,
-      }),
-    ];
-
-    const result = askUserQuestionsToCreateRequest(questions, SESSION_ID, undefined);
-    const schema = (result as Extract<CreateElicitationRequest, { mode: "form" }>).requestedSchema;
-
-    expect(result).not.toHaveProperty("toolCallId");
-    // Multiple questions → generic message, each field carries its own question.
-    expect(result.message).toBe("Please answer the following questions.");
-    expect(schema.properties?.["question_1"]).toEqual({
-      type: "array",
-      title: undefined,
-      description: "Which features?",
-      items: {
-        anyOf: [
-          { const: "auth", title: "auth" },
-          { const: "logging", title: "logging" },
-        ],
-      },
-    });
-  });
-});
-
-describe("applyAskElicitationResponse", () => {
-  const questions = [
-    mkQuestion("Single?", [{ label: "A" }, { label: "B" }]),
-    mkQuestion("Multi?", [{ label: "X" }, { label: "Y" }], { multiSelect: true }),
-  ];
-  const toolInput = { questions, metadata: { source: "test" } };
-
-  it("writes selected labels (keyed by indexed fields) into updatedInput on accept", () => {
-    const response = {
-      action: "accept",
-      content: { question_0: "A", question_1: ["X", "Y"] },
-    } as CreateElicitationResponse;
-
-    expect(applyAskElicitationResponse(response, toolInput, questions)).toEqual({
-      action: "answered",
-      updatedInput: {
-        questions,
-        metadata: { source: "test" },
-        answers: { "Single?": "A", "Multi?": "X, Y" },
-      },
-    });
-  });
-
-  it("folds a per-question custom answer into that question's answer", () => {
-    const response = {
-      action: "accept",
-      content: { question_0: "A", question_1_custom: "something else entirely" },
-    } as CreateElicitationResponse;
-
-    expect(applyAskElicitationResponse(response, toolInput, questions)).toEqual({
-      action: "answered",
-      updatedInput: {
-        questions,
-        metadata: { source: "test" },
-        answers: { "Single?": "A", "Multi?": "something else entirely" },
-      },
-    });
-  });
-
-  it("prefers a question's custom answer over its selection", () => {
-    const response = {
-      action: "accept",
-      content: { question_0: "A", question_0_custom: "  my own take  " },
-    } as CreateElicitationResponse;
-
-    expect(applyAskElicitationResponse(response, toolInput, questions)).toEqual({
-      action: "answered",
-      updatedInput: {
-        questions,
-        metadata: { source: "test" },
-        answers: { "Single?": "my own take" },
-      },
-    });
-  });
-
-  it("ignores empty selections and blank custom answers", () => {
-    const response = {
-      action: "accept",
-      content: { question_1: [], question_0_custom: "   " },
-    } as CreateElicitationResponse;
-
-    expect(applyAskElicitationResponse(response, toolInput, questions)).toEqual({
-      action: "answered",
-      updatedInput: { questions, metadata: { source: "test" }, answers: {} },
-    });
-  });
-
-  it("treats decline as answered with no answers", () => {
-    const response = { action: "decline" } as CreateElicitationResponse;
-    expect(applyAskElicitationResponse(response, toolInput, questions)).toEqual({
-      action: "answered",
-      updatedInput: { questions, metadata: { source: "test" }, answers: {} },
-    });
-  });
-
-  it("returns cancel on cancel", () => {
-    const response = { action: "cancel" } as CreateElicitationResponse;
-    expect(applyAskElicitationResponse(response, toolInput, questions)).toEqual({
-      action: "cancel",
-    });
-  });
-
-  it("returns cancel for a custom/future action it does not understand", () => {
-    const response = { action: "_zed/snooze" } as CreateElicitationResponse;
-    expect(applyAskElicitationResponse(response, toolInput, questions)).toEqual({
-      action: "cancel",
-    });
-  });
-
-  it("omits answers for questions the user left unanswered", () => {
-    const response = {
-      action: "accept",
-      content: { question_0: "B" },
-    } as CreateElicitationResponse;
-
-    const result = applyAskElicitationResponse(response, toolInput, questions);
-    expect(result.action).toBe("answered");
-    expect((result as Extract<typeof result, { action: "answered" }>).updatedInput.answers).toEqual(
-      { "Single?": "B" },
-    );
-  });
-});
-
-describe("extractRefusalFallbackPrompt", () => {
-  it("extracts required and optional fields", () => {
-    expect(
-      extractRefusalFallbackPrompt({
-        originalModel: "claude-fable-5",
-        fallbackModel: "claude-opus-4-8",
-        apiRefusalCategory: "cyber",
-        guidanceText: "You can retry with the fallback model.",
-        retractedMessageUuids: ["u1"],
-      }),
-    ).toEqual({
-      originalModel: "claude-fable-5",
-      fallbackModel: "claude-opus-4-8",
-      apiRefusalCategory: "cyber",
-      guidanceText: "You can retry with the fallback model.",
-    });
-  });
-
-  it("returns null when a required model field is missing or mistyped", () => {
-    expect(extractRefusalFallbackPrompt({ fallbackModel: "claude-opus-4-8" })).toBeNull();
-    expect(
-      extractRefusalFallbackPrompt({ originalModel: 5, fallbackModel: "claude-opus-4-8" }),
-    ).toBeNull();
-  });
-
-  it("normalizes a non-string category to null and drops empty guidance", () => {
-    expect(
-      extractRefusalFallbackPrompt({
-        originalModel: "a",
-        fallbackModel: "b",
-        apiRefusalCategory: null,
-        guidanceText: "",
-      }),
-    ).toEqual({ originalModel: "a", fallbackModel: "b", apiRefusalCategory: null });
-  });
-});
-
-describe("refusalFallbackToCreateRequest", () => {
-  const prompt = {
-    originalModel: "claude-fable-5",
-    fallbackModel: "claude-opus-4-8",
-    apiRefusalCategory: "cyber" as string | null,
-  };
-
-  it("builds a single-choice form whose enum consts are the dialog's wire results", () => {
-    const request = refusalFallbackToCreateRequest(prompt, SESSION_ID) as Extract<
-      CreateElicitationRequest,
-      { mode: "form" }
-    >;
-    expect(request.mode).toBe("form");
-    expect(request).toMatchObject({ sessionId: SESSION_ID });
-    expect(request.message).toContain("claude-fable-5");
-    expect(request.message).toContain("(cyber)");
-    expect(request.message).toContain("claude-opus-4-8");
-
-    const choice = request.requestedSchema.properties?.choice as {
-      type: string;
-      oneOf: Array<{ const: string; title: string; description?: string }>;
-    };
-    expect(choice.type).toBe("string");
-    expect(choice.oneOf.map((o) => o.const)).toEqual(["retry_fallback", "cancelled"]);
-    expect(choice.oneOf[0].title).toContain("claude-opus-4-8");
-    // Each option explains its consequence in the description field.
-    expect(choice.oneOf[0].description).toContain("claude-opus-4-8");
-    expect(choice.oneOf[1].description).toBeTruthy();
-  });
-
-  it("omits the category marker and appends guidance when provided", () => {
-    const request = refusalFallbackToCreateRequest(
-      { ...prompt, apiRefusalCategory: null, guidanceText: "Consider rephrasing." },
-      SESSION_ID,
-    );
-    expect(request.message).not.toContain("(");
-    expect(request.message).toContain("Consider rephrasing.");
-  });
-});
-
-describe("refusalFallbackResultFromResponse", () => {
-  it("maps an accepted retry choice to retry_fallback", () => {
-    const response = {
-      action: "accept",
-      content: { choice: "retry_fallback" },
-    } as CreateElicitationResponse;
-    expect(refusalFallbackResultFromResponse(response)).toBe("retry_fallback");
-  });
-
-  it("keeps the refusal for every other outcome", () => {
-    const cases = [
-      { action: "accept", content: { choice: "cancelled" } },
-      { action: "accept", content: {} },
-      { action: "accept", content: { choice: "something-new" } },
-      { action: "accept" },
-      { action: "decline" },
-      { action: "cancel" },
-    ] as CreateElicitationResponse[];
-    for (const response of cases) {
-      expect(refusalFallbackResultFromResponse(response)).toBe("cancelled");
-    }
-  });
-});
--- a/src/tests/extract-lines.test.ts
+++ b/src/tests/extract-lines.test.ts
@@ -0,0 +1,103 @@
+import { describe, it, expect } from "vitest";
+import { extractLinesWithByteLimit } from "../utils.js";
+
+describe("extractLinesWithByteLimit", () => {
+  const simpleContent = "Line 1\nLine 2\nLine 3\nLine 4\nLine 5";
+
+  it("should extract all lines when under byte limit", () => {
+    const result = extractLinesWithByteLimit(simpleContent, 1000);
+
+    expect(result.content).toBe(simpleContent);
+    expect(result.wasLimited).toBe(false);
+    expect(result.linesRead).toBe(5);
+  });
+
+  it("should limit output when exceeding byte limit", () => {
+    // Create content that will exceed byte limit
+    const longLine = "x".repeat(100);
+    const manyLines = Array(10).fill(longLine).join("\n");
+
+    const result = extractLinesWithByteLimit(manyLines, 250);
+
+    expect(result.wasLimited).toBe(true);
+    expect(result.linesRead).toBe(2);
+  });
+
+  it("should handle empty content", () => {
+    const result = extractLinesWithByteLimit("", 1000);
+
+    expect(result.content).toBe("");
+    expect(result.wasLimited).toBe(false);
+    expect(result.linesRead).toBe(1); // We read the one empty line
+  });
+
+  it("should handle single line file", () => {
+    const singleLine = "This is a single line without newline";
+    const result = extractLinesWithByteLimit(singleLine, 1000);
+
+    expect(result.content).toBe(singleLine);
+    expect(result.wasLimited).toBe(false);
+    expect(result.linesRead).toBe(1);
+  });
+
+  it("should correctly count bytes with multi-byte characters", () => {
+    const unicodeContent = "Hello 世界\n你好 World\nEmoji: 🌍\nNormal line";
+    const result = extractLinesWithByteLimit(unicodeContent, 1000);
+
+    expect(result.content).toBe(unicodeContent);
+    expect(result.linesRead).toBe(4);
+  });
+
+  it("should stop at byte limit even with one more line available", () => {
+    // Create lines where adding one more would exceed limit
+    const line1 = "a".repeat(40);
+    const line2 = "b".repeat(40);
+    const line3 = "c".repeat(40);
+    const content = `${line1}\n${line2}\n${line3}`;
+
+    const result = extractLinesWithByteLimit(content, 85);
+
+    expect(result.content).toBe(`${line1}\n${line2}\n`);
+    expect(result.wasLimited).toBe(true);
+    expect(result.linesRead).toBe(2);
+  });
+
+  it("should read exactly to limit when possible", () => {
+    const exactContent = "12345\n67890\n12345"; // 17 bytes total
+    const result = extractLinesWithByteLimit(exactContent, 17);
+
+    expect(result.content).toBe(exactContent);
+    expect(result.wasLimited).toBe(false);
+    expect(result.linesRead).toBe(3);
+  });
+
+  it("should handle Windows-style line endings", () => {
+    const windowsContent = "Line 1\r\nLine 2\r\nLine 3";
+    const result = extractLinesWithByteLimit(windowsContent, 1000);
+
+    // Note: split("\n") will keep the \r characters
+    expect(result.content).toBe("Line 1\r\nLine 2\r\nLine 3");
+    expect(result.linesRead).toBe(3);
+  });
+
+  it("should handle very large files efficiently", () => {
+    // Create a 100KB file
+    const largeLine = "x".repeat(1000);
+    const largeContent = Array(110).fill(largeLine).join("\n");
+
+    const result = extractLinesWithByteLimit(largeContent, 50000);
+
+    expect(result.wasLimited).toBe(true);
+  });
+
+  it("should allow at least one line even if it exceeds byte limit", () => {
+    const veryLongLine = "x".repeat(100000); // 100KB line
+    const result = extractLinesWithByteLimit(veryLongLine, 50000);
+
+    // Should return the line even though it exceeds the byte limit
+    // because we always allow at least one line if no lines have been added yet
+    expect(result.content).toBe(veryLongLine);
+    expect(result.linesRead).toBe(1);
+    expect(result.wasLimited).toBe(false);
+  });
+});
--- a/src/tests/fast-mode-config.test.ts
+++ b/src/tests/fast-mode-config.test.ts
@@ -1,341 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import type { ClientCapabilities, SessionNotification } from "@agentclientprotocol/sdk";
-import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
-import {
-  buildConfigOptions,
-  clientSupportsBooleanConfigOptions,
-  createFastModeConfigOption,
-  fastModeStateEnabled,
-  resolveFastModeEnabled,
-  FAST_MODE_CONFIG_ID,
-  FAST_MODE_ON,
-  FAST_MODE_OFF,
-  ClaudeAcpAgent,
-  type AcpClient,
-} from "../acp-agent.js";
-
-const MODES = {
-  currentModeId: "default",
-  availableModes: [{ id: "default", name: "Default", description: "Standard behavior" }],
-};
-
-const MODELS = {
-  currentModelId: "claude-opus-4-8",
-  availableModels: [
-    { modelId: "claude-opus-4-8", name: "Claude Opus", description: "Most capable" },
-  ],
-};
-
-const MODEL_INFOS: ModelInfo[] = [
-  { value: "claude-opus-4-8", displayName: "Claude Opus", description: "Most capable" },
-];
-
-describe("createFastModeConfigOption", () => {
-  it("produces a native boolean toggle when the client opted in", () => {
-    expect(createFastModeConfigOption(true, true)).toEqual({
-      id: FAST_MODE_CONFIG_ID,
-      name: "Fast mode",
-      description: expect.any(String),
-      category: "model_config",
-      type: "boolean",
-      currentValue: true,
-    });
-  });
-
-  it("falls back to an on/off select when the client did not opt in", () => {
-    const option = createFastModeConfigOption(false, false);
-    expect(option).toMatchObject({
-      id: FAST_MODE_CONFIG_ID,
-      type: "select",
-      category: "model_config",
-      currentValue: FAST_MODE_OFF,
-      options: [
-        { value: FAST_MODE_ON, name: "On" },
-        { value: FAST_MODE_OFF, name: "Off" },
-      ],
-    });
-    expect(option).not.toHaveProperty("currentValue", true);
-  });
-});
-
-describe("clientSupportsBooleanConfigOptions", () => {
-  it("is true only when session.configOptions.boolean is present", () => {
-    expect(
-      clientSupportsBooleanConfigOptions({ session: { configOptions: { boolean: {} } } }),
-    ).toBe(true);
-  });
-
-  it("is false when the capability is omitted or null at any level", () => {
-    expect(clientSupportsBooleanConfigOptions(undefined)).toBe(false);
-    expect(clientSupportsBooleanConfigOptions(null)).toBe(false);
-    expect(clientSupportsBooleanConfigOptions({})).toBe(false);
-    expect(clientSupportsBooleanConfigOptions({ session: { configOptions: {} } })).toBe(false);
-    expect(
-      clientSupportsBooleanConfigOptions({ session: { configOptions: { boolean: null } } }),
-    ).toBe(false);
-  });
-});
-
-describe("resolveFastModeEnabled", () => {
-  const base = { sessionId: "s", configId: FAST_MODE_CONFIG_ID };
-
-  it("accepts native boolean values", () => {
-    expect(resolveFastModeEnabled({ ...base, type: "boolean", value: true })).toBe(true);
-    expect(resolveFastModeEnabled({ ...base, type: "boolean", value: false })).toBe(false);
-  });
-
-  it("accepts the on/off select fallback", () => {
-    expect(resolveFastModeEnabled({ ...base, value: FAST_MODE_ON })).toBe(true);
-    expect(resolveFastModeEnabled({ ...base, value: FAST_MODE_OFF })).toBe(false);
-  });
-
-  it("rejects any other value", () => {
-    expect(() => resolveFastModeEnabled({ ...base, value: "maybe" })).toThrow(
-      /Invalid value for config option fast/,
-    );
-  });
-});
-
-describe("fastModeStateEnabled", () => {
-  it("treats cooldown as on (the user's intent persists through rate-limit cooldown)", () => {
-    expect(fastModeStateEnabled("on")).toBe(true);
-    expect(fastModeStateEnabled("cooldown")).toBe(true);
-    expect(fastModeStateEnabled("off")).toBe(false);
-  });
-});
-
-describe("buildConfigOptions Fast mode", () => {
-  it("omits the Fast mode option when the model does not support it", () => {
-    const options = buildConfigOptions(MODES, MODELS, MODEL_INFOS, undefined, [], "default", {
-      supported: false,
-      enabled: false,
-      useBooleanOption: true,
-    });
-    expect(options.find((o) => o.id === FAST_MODE_CONFIG_ID)).toBeUndefined();
-  });
-
-  it("omits the Fast mode option when no fast mode state is provided", () => {
-    const options = buildConfigOptions(MODES, MODELS, MODEL_INFOS, undefined, [], "default");
-    expect(options.find((o) => o.id === FAST_MODE_CONFIG_ID)).toBeUndefined();
-  });
-
-  it("surfaces a boolean toggle when supported and the client opted in", () => {
-    const options = buildConfigOptions(MODES, MODELS, MODEL_INFOS, undefined, [], "default", {
-      supported: true,
-      enabled: true,
-      useBooleanOption: true,
-    });
-    expect(options).toContainEqual(createFastModeConfigOption(true, true));
-  });
-
-  it("surfaces a select fallback when supported but the client did not opt in", () => {
-    const options = buildConfigOptions(MODES, MODELS, MODEL_INFOS, undefined, [], "default", {
-      supported: true,
-      enabled: false,
-      useBooleanOption: false,
-    });
-    expect(options).toContainEqual(createFastModeConfigOption(false, false));
-  });
-});
-
-describe("setSessionConfigOption Fast mode toggle", () => {
-  const SESSION_ID = "fast-session";
-
-  function setup(opts: { useBooleanOption: boolean }) {
-    const sessionUpdates: SessionNotification[] = [];
-    const client = {
-      sessionUpdate: async (n: SessionNotification) => {
-        sessionUpdates.push(n);
-      },
-      requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
-      readTextFile: async () => ({ content: "" }),
-      writeTextFile: async () => ({}),
-    } as unknown as AcpClient;
-
-    const agent = new ClaudeAcpAgent(client);
-    const clientCapabilities: ClientCapabilities = opts.useBooleanOption
-      ? { session: { configOptions: { boolean: {} } } }
-      : {};
-    (agent as unknown as { clientCapabilities: ClientCapabilities }).clientCapabilities =
-      clientCapabilities;
-
-    const applyFlagSettings = vi.fn();
-    (agent as unknown as { sessions: Record<string, unknown> }).sessions[SESSION_ID] = {
-      query: { applyFlagSettings },
-      fastModeEnabled: false,
-      configOptions: [createFastModeConfigOption(false, opts.useBooleanOption)],
-    };
-
-    return { agent, applyFlagSettings, sessionUpdates };
-  }
-
-  it("toggles Fast mode on/off through a boolean value", async () => {
-    const { agent, applyFlagSettings } = setup({ useBooleanOption: true });
-
-    const onResponse = await agent.setSessionConfigOption({
-      sessionId: SESSION_ID,
-      configId: FAST_MODE_CONFIG_ID,
-      type: "boolean",
-      value: true,
-    });
-    expect(applyFlagSettings).toHaveBeenCalledWith({ fastMode: true });
-    expect(onResponse.configOptions).toContainEqual(createFastModeConfigOption(true, true));
-    expect(
-      (agent as unknown as { sessions: Record<string, { fastModeEnabled: boolean }> }).sessions[
-        SESSION_ID
-      ].fastModeEnabled,
-    ).toBe(true);
-
-    const offResponse = await agent.setSessionConfigOption({
-      sessionId: SESSION_ID,
-      configId: FAST_MODE_CONFIG_ID,
-      type: "boolean",
-      value: false,
-    });
-    expect(applyFlagSettings).toHaveBeenLastCalledWith({ fastMode: false });
-    expect(offResponse.configOptions).toContainEqual(createFastModeConfigOption(false, true));
-  });
-
-  it("toggles Fast mode through the on/off select fallback", async () => {
-    const { agent, applyFlagSettings } = setup({ useBooleanOption: false });
-
-    const response = await agent.setSessionConfigOption({
-      sessionId: SESSION_ID,
-      configId: FAST_MODE_CONFIG_ID,
-      value: FAST_MODE_ON,
-    });
-    expect(applyFlagSettings).toHaveBeenCalledWith({ fastMode: true });
-    expect(response.configOptions).toContainEqual(createFastModeConfigOption(true, false));
-  });
-
-  it("does not change session state when the SDK rejects the flag", async () => {
-    const { agent, applyFlagSettings } = setup({ useBooleanOption: true });
-    applyFlagSettings.mockRejectedValueOnce(new Error("nope"));
-
-    await expect(
-      agent.setSessionConfigOption({
-        sessionId: SESSION_ID,
-        configId: FAST_MODE_CONFIG_ID,
-        type: "boolean",
-        value: true,
-      }),
-    ).rejects.toThrow("nope");
-
-    const session = (agent as unknown as { sessions: Record<string, { fastModeEnabled: boolean }> })
-      .sessions[SESSION_ID];
-    expect(session.fastModeEnabled).toBe(false);
-  });
-});
-
-describe("syncFastModeState (SDK-driven state changes)", () => {
-  const SESSION_ID = "fast-session";
-
-  function setup(opts: { fastModeEnabled: boolean; withOption: boolean }) {
-    const sessionUpdates: SessionNotification[] = [];
-    const client = {
-      sessionUpdate: async (n: SessionNotification) => {
-        sessionUpdates.push(n);
-      },
-      requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
-      readTextFile: async () => ({ content: "" }),
-      writeTextFile: async () => ({}),
-    } as unknown as AcpClient;
-
-    const agent = new ClaudeAcpAgent(client);
-    (agent as unknown as { clientCapabilities: ClientCapabilities }).clientCapabilities = {
-      session: { configOptions: { boolean: {} } },
-    };
-
-    const session = {
-      query: {},
-      fastModeEnabled: opts.fastModeEnabled,
-      configOptions: opts.withOption
-        ? [createFastModeConfigOption(opts.fastModeEnabled, true)]
-        : [],
-    };
-    (agent as unknown as { sessions: Record<string, unknown> }).sessions[SESSION_ID] = session;
-
-    const sync = (
-      agent as unknown as {
-        syncFastModeState: (
-          sessionId: string,
-          session: unknown,
-          state: string | undefined,
-        ) => Promise<void>;
-      }
-    ).syncFastModeState.bind(agent);
-
-    return { sync, session, sessionUpdates };
-  }
-
-  it("emits a config_option_update when the SDK reports a new state", async () => {
-    const { sync, session, sessionUpdates } = setup({ fastModeEnabled: false, withOption: true });
-
-    await sync(SESSION_ID, session, "on");
-
-    expect(session.fastModeEnabled).toBe(true);
-    expect(session.configOptions).toContainEqual(createFastModeConfigOption(true, true));
-    expect(sessionUpdates).toHaveLength(1);
-    expect(sessionUpdates[0].update).toMatchObject({
-      sessionUpdate: "config_option_update",
-    });
-    const updated = (
-      sessionUpdates[0].update as { configOptions: ReturnType<typeof createFastModeConfigOption>[] }
-    ).configOptions;
-    expect(updated).toContainEqual(createFastModeConfigOption(true, true));
-  });
-
-  it("leaves the toggle on and quiet during a rate-limit cooldown", async () => {
-    const { sync, session, sessionUpdates } = setup({ fastModeEnabled: true, withOption: true });
-
-    // cooldown is a transient suspension of an already-enabled fast mode.
-    await sync(SESSION_ID, session, "cooldown");
-
-    expect(session.fastModeEnabled).toBe(true);
-    expect(sessionUpdates).toHaveLength(0);
-  });
-
-  it("never lets a stray cooldown spuriously enable a toggle the user has off", async () => {
-    const { sync, session, sessionUpdates } = setup({ fastModeEnabled: false, withOption: true });
-
-    await sync(SESSION_ID, session, "cooldown");
-
-    expect(session.fastModeEnabled).toBe(false);
-    expect(sessionUpdates).toHaveLength(0);
-  });
-
-  it("clears the toggle when the SDK reports off", async () => {
-    const { sync, session, sessionUpdates } = setup({ fastModeEnabled: true, withOption: true });
-
-    await sync(SESSION_ID, session, "off");
-
-    expect(session.fastModeEnabled).toBe(false);
-    expect(session.configOptions).toContainEqual(createFastModeConfigOption(false, true));
-    expect(sessionUpdates).toHaveLength(1);
-  });
-
-  it("is a no-op when the reported state is undefined or unchanged", async () => {
-    const { sync, session, sessionUpdates } = setup({ fastModeEnabled: false, withOption: true });
-
-    await sync(SESSION_ID, session, undefined);
-    await sync(SESSION_ID, session, "off");
-
-    expect(sessionUpdates).toHaveLength(0);
-  });
-
-  it("preserves the retained setting (no clobber) when the model has no Fast mode option", async () => {
-    // Model without fast support: the SDK reports a capability-driven state, not
-    // the user's intent. We must leave session.fastModeEnabled untouched so it's
-    // correct when a supporting model is reselected — reconciling here was the
-    // original intent-clobber bug.
-    const enabledCase = setup({ fastModeEnabled: true, withOption: false });
-    await enabledCase.sync(SESSION_ID, enabledCase.session, "off");
-    expect(enabledCase.session.fastModeEnabled).toBe(true);
-    expect(enabledCase.sessionUpdates).toHaveLength(0);
-
-    const disabledCase = setup({ fastModeEnabled: false, withOption: false });
-    await disabledCase.sync(SESSION_ID, disabledCase.session, "on");
-    expect(disabledCase.session.fastModeEnabled).toBe(false);
-    expect(disabledCase.sessionUpdates).toHaveLength(0);
-  });
-});
--- a/src/tests/model-resolution.test.ts
+++ b/src/tests/model-resolution.test.ts
@@ -1,272 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { randomUUID } from "crypto";
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
-import {
-  resolveModelPreference,
-  applyAvailableModelsAllowlist,
-  matchResumedModel,
-} from "../acp-agent.js";
-
-// Mirrors a real `supportedModels()` response: alias rows carry
-// `resolvedModel`, and "Sonnet 5" has no `major.minor` dot unlike older
-// "claude-opus-4-6"-style ids.
-const LIVE_SHAPED_MODELS: ModelInfo[] = [
-  {
-    value: "default",
-    resolvedModel: "claude-opus-4-8[1m]",
-    displayName: "Default (recommended)",
-    description: "Use the default model (currently Opus 4.8 (1M context))",
-  },
-  {
-    value: "opus[1m]",
-    resolvedModel: "claude-opus-4-8[1m]",
-    displayName: "Opus",
-    description: "Opus 4.8 with 1M context · Best for everyday, complex tasks",
-  },
-  {
-    value: "sonnet",
-    resolvedModel: "claude-sonnet-5",
-    displayName: "Sonnet",
-    description: "Sonnet 5 · Efficient for routine tasks",
-  },
-  {
-    value: "haiku",
-    resolvedModel: "claude-haiku-4-5-20251001",
-    displayName: "Haiku",
-    description: "Haiku 4.5 · Fastest for quick answers",
-  },
-];
-
-describe("resolveModelPreference - resolvedModel matching", () => {
-  it("matches a preference that equals an alias's resolvedModel exactly", () => {
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "claude-sonnet-5")?.value).toBe("sonnet");
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "claude-opus-4-8[1m]")?.value).toBe(
-      "opus[1m]",
-    );
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "claude-haiku-4-5-20251001")?.value).toBe(
-      "haiku",
-    );
-  });
-
-  it("is case-insensitive", () => {
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "CLAUDE-SONNET-5")?.value).toBe("sonnet");
-  });
-
-  it("still resolves plain aliases via the direct-match tier", () => {
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "sonnet")?.value).toBe("sonnet");
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "opus[1m]")?.value).toBe("opus[1m]");
-  });
-
-  it("does not let a retired dated id drift onto a same-family alias of a different generation", () => {
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "claude-sonnet-4-6")).toBeNull();
-  });
-
-  // "opus[1m]"'s `value` has no dotted version, just the context-hint digit
-  // in "[1m]" — unstripped, that reads as version "1" and blocks the match
-  // before the matcher reaches the description's real "4.8".
-  it("does not mistake an alias's context-hint suffix for its version", () => {
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "claude-opus-4-8")?.value).toBe("opus[1m]");
-  });
-
-  it("returns null for a preference that matches nothing", () => {
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "claude-gpt-99")).toBeNull();
-  });
-
-  it("matches a '-1m' id-suffix preference against a '[1m]'-spelled resolvedModel", () => {
-    // Without hint canonicalization the exact tier misses and the substring
-    // tier lands on the bare 200k sibling, silently downgrading a 1M pin.
-    const models: ModelInfo[] = [
-      {
-        value: "sonnet",
-        resolvedModel: "claude-sonnet-5",
-        displayName: "Sonnet",
-        description: "Sonnet 5 · Efficient for routine tasks",
-      },
-      {
-        value: "sonnet[1m]",
-        resolvedModel: "claude-sonnet-5[1m]",
-        displayName: "Sonnet",
-        description: "Sonnet 5 with 1M context",
-      },
-    ];
-    expect(resolveModelPreference(models, "claude-sonnet-5-1m")?.value).toBe("sonnet[1m]");
-  });
-
-  it("matches a '-1m'-suffix alias directly against a '[1m]'-spelled value", () => {
-    expect(resolveModelPreference(LIVE_SHAPED_MODELS, "opus-1m")?.value).toBe("opus[1m]");
-  });
-
-  // Rows without resolvedModel (older SDKs, allowlist-synthesized entries,
-  // option-derived lists) can't use the exact resolved tier, so the hinted
-  // preference must not be absorbed by the bare sibling in the substring
-  // tier — the tokenized tier scores the hinted row correctly instead.
-  it("does not let a bare sibling absorb a hinted preference when resolvedModel is absent", () => {
-    const models: ModelInfo[] = [
-      { value: "sonnet", displayName: "Sonnet", description: "" },
-      { value: "sonnet[1m]", displayName: "Sonnet", description: "" },
-    ];
-    expect(resolveModelPreference(models, "claude-sonnet-5[1m]")?.value).toBe("sonnet[1m]");
-    expect(resolveModelPreference(models, "claude-sonnet-5-1m")?.value).toBe("sonnet[1m]");
-    // Bare preferences still land on the bare row via the substring tier.
-    expect(resolveModelPreference(models, "claude-sonnet-5")?.value).toBe("sonnet");
-  });
-});
-
-describe("matchResumedModel", () => {
-  // Environment shape from issue #845: the default resolves to Sonnet, the
-  // session was explicitly switched to Opus before the process restart.
-  const SONNET_DEFAULT_MODELS: ModelInfo[] = [
-    {
-      value: "default",
-      resolvedModel: "claude-sonnet-5",
-      displayName: "Default (recommended)",
-      description: "Use the default model (currently Sonnet 5)",
-    },
-    {
-      value: "opus",
-      resolvedModel: "claude-opus-4-6[1m]",
-      displayName: "Opus",
-      description: "Opus 4.6 · Most capable for complex work",
-    },
-    {
-      value: "sonnet",
-      resolvedModel: "claude-sonnet-5",
-      displayName: "Sonnet",
-      description: "Sonnet 5 · Efficient for routine tasks",
-    },
-    {
-      value: "sonnet[1m]",
-      resolvedModel: "claude-sonnet-5[1m]",
-      displayName: "Sonnet",
-      description: "Sonnet 5 with 1M context",
-    },
-  ];
-
-  it("maps an explicitly-switched session's live model to its picker alias", () => {
-    expect(matchResumedModel(SONNET_DEFAULT_MODELS, "claude-opus-4-6").value).toBe("opus");
-    expect(matchResumedModel(SONNET_DEFAULT_MODELS, "claude-opus-4-6[1m]").value).toBe("opus");
-  });
-
-  it("keeps Default selected when the live model is what Default resolves to", () => {
-    expect(matchResumedModel(SONNET_DEFAULT_MODELS, "claude-sonnet-5").value).toBe("default");
-  });
-
-  it("prefers an exact named-row resolvedModel match over the hint-stripped Default tier", () => {
-    // "claude-sonnet-5[1m]" differs from Default's "claude-sonnet-5" only by
-    // the context hint; stripping both would misreport the explicit 1M row as
-    // Default (and infer the wrong context window downstream). Both hint
-    // spellings must land on the row regardless of which one it uses.
-    expect(matchResumedModel(SONNET_DEFAULT_MODELS, "claude-sonnet-5[1m]").value).toBe(
-      "sonnet[1m]",
-    );
-    expect(matchResumedModel(SONNET_DEFAULT_MODELS, "claude-sonnet-5-1m").value).toBe("sonnet[1m]");
-  });
-
-  it("normalizes the '-1m' id-suffix hint form and casing against Default's resolution", () => {
-    expect(matchResumedModel(LIVE_SHAPED_MODELS, "claude-opus-4-8-1m").value).toBe("default");
-    expect(matchResumedModel(LIVE_SHAPED_MODELS, "Claude-Opus-4-8[1M]").value).toBe("default");
-  });
-
-  it("prefers Default over a named row sharing the identical resolvedModel", () => {
-    // "opus[1m]" carries the same resolvedModel as Default; the live id can't
-    // tell the two apart, so a never-customized session stays on Default.
-    expect(matchResumedModel(LIVE_SHAPED_MODELS, "claude-opus-4-8[1m]").value).toBe("default");
-  });
-
-  it("ignores '[1m]' context hints when comparing against Default's resolution", () => {
-    // The transcript-restored model drops the "[1m]" context hint, so a
-    // session that never left the 1M-context default resumes as the bare id.
-    expect(matchResumedModel(LIVE_SHAPED_MODELS, "claude-opus-4-8").value).toBe("default");
-  });
-
-  it("still resolves non-default live models against the picker entries", () => {
-    expect(matchResumedModel(LIVE_SHAPED_MODELS, "claude-sonnet-5").value).toBe("sonnet");
-    expect(matchResumedModel(LIVE_SHAPED_MODELS, "claude-haiku-4-5-20251001").value).toBe("haiku");
-  });
-
-  it("tracks a live model with no picker counterpart verbatim", () => {
-    const result = matchResumedModel(LIVE_SHAPED_MODELS, "claude-gpt-99");
-    expect(result.value).toBe("claude-gpt-99");
-    expect(result.displayName).toBe("claude-gpt-99");
-  });
-});
-
-describe("applyAvailableModelsAllowlist - resolvedModel matching", () => {
-  it("resolves an allowlist entry pinned to a canonical resolvedModel id", () => {
-    const result = applyAvailableModelsAllowlist(LIVE_SHAPED_MODELS, ["claude-sonnet-5"]);
-    const entry = result.find((m) => m.value === "claude-sonnet-5");
-    expect(entry).toBeDefined();
-    expect(entry?.displayName).toBe("Sonnet");
-  });
-});
-
-describe("applyAvailableModelsAllowlist - modelOverrides", () => {
-  const SDK_MODELS: ModelInfo[] = [
-    { value: "default", displayName: "Default", description: "Default model" },
-    {
-      value: "opus",
-      displayName: "Opus",
-      description: "Claude Opus 4.6",
-      supportsEffort: true,
-      supportedEffortLevels: ["low", "high"],
-    },
-  ];
-
-  it("surfaces the override target as the value while keeping the alias's display metadata", () => {
-    // The override target is an opaque Bedrock ARN with no "opus" substring,
-    // so matching against it (instead of the "claude-opus-4-6" alias) would
-    // find nothing and silently drop displayName/description/supportsEffort.
-    const overrides = {
-      "claude-opus-4-6": "arn:aws:bedrock:us-west-2:111122223333:inference-profile/custom-7f3a",
-    };
-    const result = applyAvailableModelsAllowlist(SDK_MODELS, ["claude-opus-4-6"], overrides);
-
-    const entry = result.find((m) => m.value === overrides["claude-opus-4-6"]);
-    expect(entry).toEqual({
-      value: overrides["claude-opus-4-6"],
-      displayName: "Opus",
-      description: "Claude Opus 4.6",
-      supportsEffort: true,
-      supportedEffortLevels: ["low", "high"],
-    });
-  });
-});
-
-// Runs against the real SDK (no mocks) so the fixture above is flagged the
-// moment the SDK's actual model list shape drifts from it. Requires a usable
-// ANTHROPIC_API_KEY, hence opt-in via RUN_INTEGRATION_TESTS.
-describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("model resolution (real SDK)", () => {
-  it("every model's resolvedModel (when present) resolves back to that same row", async () => {
-    const q = query({ prompt: "hi", options: { sessionId: randomUUID() } });
-    try {
-      const models = await q.supportedModels();
-      expect(models.length).toBeGreaterThan(0);
-
-      for (const model of models) {
-        // "default" shares a resolvedModel with the CLI's recommended named
-        // alias, and resolution intentionally prefers that alias on a tie.
-        if (!model.resolvedModel || model.value === "default") continue;
-        const resolved = resolveModelPreference(models, model.resolvedModel);
-        expect(resolved?.value).toBe(model.value);
-      }
-    } finally {
-      q.return(undefined);
-    }
-  }, 30000);
-
-  it("resolves the well-known 'sonnet' and 'opus' aliases to a model bearing their family name", async () => {
-    const q = query({ prompt: "hi", options: { sessionId: randomUUID() } });
-    try {
-      const models = await q.supportedModels();
-
-      const sonnet = resolveModelPreference(models, "sonnet");
-      expect(sonnet?.resolvedModel?.toLowerCase()).toContain("sonnet");
-
-      const opus = resolveModelPreference(models, "opus");
-      expect(opus?.resolvedModel?.toLowerCase()).toContain("opus");
-    } finally {
-      q.return(undefined);
-    }
-  }, 30000);
-});
--- a/src/tests/replace-and-calculate-location.test.ts
+++ b/src/tests/replace-and-calculate-location.test.ts
@@ -0,0 +1,334 @@
+import { describe, it, expect } from "vitest";
+import { replaceAndCalculateLocation } from "../mcp-server.js";
+
+describe("replaceAndCalculateLocation", () => {
+  it("should replace first occurrence and return correct line number", () => {
+    const content = "line 1\nline 2 with text\nline 3 with text\nline 4";
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
+
+    expect(result.newContent).toBe("line 1\nline 2 with replaced\nline 3 with text\nline 4");
+    expect(result.lineNumbers).toEqual([1]); // Line 2 (0-based indexing)
+  });
+
+  it("should replace all occurrences when replaceAll is true", () => {
+    const content = "line 1\nline 2 with text\nline 3 with text\nline 4";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "text", newText: "replaced", replaceAll: true },
+    ]);
+
+    expect(result.newContent).toBe("line 1\nline 2 with replaced\nline 3 with replaced\nline 4");
+    expect(result.lineNumbers).toEqual([1, 2]); // Lines 2 and 3 (0-based)
+  });
+
+  it("should return empty line numbers array when no match found", () => {
+    const content = "line 1\nline 2\nline 3";
+    expect(() => {
+      replaceAndCalculateLocation(content, [{ oldText: "notfound", newText: "replaced" }]);
+    }).toThrow('The provided `old_string` does not appear in the file: "notfound"');
+  });
+
+  it("should handle Windows line endings (CRLF)", () => {
+    const content = "line 1\r\nline 2 with text\r\nline 3 with text\r\nline 4";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "text", newText: "replaced", replaceAll: true },
+    ]);
+
+    expect(result.newContent).toBe(
+      "line 1\r\nline 2 with replaced\r\nline 3 with replaced\r\nline 4",
+    );
+    expect(result.lineNumbers).toEqual([1, 2]);
+  });
+
+  it("should handle old Mac line endings (CR)", () => {
+    const content = "line 1\rline 2 with text\rline 3 with text\rline 4";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "text", newText: "replaced", replaceAll: true },
+    ]);
+
+    expect(result.newContent).toBe("line 1\rline 2 with replaced\rline 3 with replaced\rline 4");
+    expect(result.lineNumbers).toEqual([1, 2]);
+  });
+
+  it("should handle mixed line endings", () => {
+    const content = "line 1\nline 2 with text\r\nline 3 with text\rline 4";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "text", newText: "replaced", replaceAll: true },
+    ]);
+
+    expect(result.newContent).toBe("line 1\nline 2 with replaced\r\nline 3 with replaced\rline 4");
+    expect(result.lineNumbers).toEqual([1, 2]);
+  });
+
+  it("should handle text at the beginning of file", () => {
+    const content = "text at start\nline 2\nline 3";
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
+
+    expect(result.newContent).toBe("replaced at start\nline 2\nline 3");
+    expect(result.lineNumbers).toEqual([0]); // First line (0-based)
+  });
+
+  it("should handle text at the end of file", () => {
+    const content = "line 1\nline 2\nlast line with text";
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
+
+    expect(result.newContent).toBe("line 1\nline 2\nlast line with replaced");
+    expect(result.lineNumbers).toEqual([2]); // Last line (0-based)
+  });
+
+  it("should handle multiple occurrences on the same line", () => {
+    const content = "line 1\ntext text text\nline 3";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "text", newText: "replaced", replaceAll: true },
+    ]);
+
+    expect(result.newContent).toBe("line 1\nreplaced replaced replaced\nline 3");
+    expect(result.lineNumbers).toEqual([1]); // All on line 2 (0-based), deduplicated
+  });
+
+  it("should handle empty file content", () => {
+    expect(() => {
+      replaceAndCalculateLocation("", [{ oldText: "text", newText: "replaced" }]);
+    }).toThrowError(
+      'The provided `old_string` does not appear in the file: "text".\n\nNo edits were applied.',
+    );
+  });
+
+  it("should handle empty search text", () => {
+    // Test with replaceAll false (default)
+    const content1 = "line 1\nline 2\nline 3";
+    expect(() => {
+      replaceAndCalculateLocation(content1, [{ oldText: "", newText: "replaced" }]);
+    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
+
+    // Test with replaceAll true on single line
+    const content2 = "abc";
+    expect(() => {
+      replaceAndCalculateLocation(content2, [{ oldText: "", newText: "X", replaceAll: true }]);
+    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
+
+    // Test with replaceAll true on multiline content
+    const content3 = "ab\ncd";
+    expect(() => {
+      replaceAndCalculateLocation(content3, [{ oldText: "", newText: "X", replaceAll: true }]);
+    }).toThrowError("The provided `old_string` is empty.\n\nNo edits were applied.");
+  });
+
+  it("should handle single line content", () => {
+    const content = "single line with text here";
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
+
+    expect(result.newContent).toBe("single line with replaced here");
+    expect(result.lineNumbers).toEqual([0]); // Line 1 (0-based)
+  });
+
+  it("should handle special characters in search text", () => {
+    const content = "line 1\nline with $special.chars*\nline 3";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "$special.chars*", newText: "replaced" },
+    ]);
+
+    expect(result.newContent).toBe("line 1\nline with replaced\nline 3");
+    expect(result.lineNumbers).toEqual([1]);
+  });
+
+  it("should handle newlines in search text", () => {
+    const content = "line 1\nline 2\nline 3";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "1\nline", newText: "1\nmodified line" },
+    ]);
+
+    expect(result.newContent).toBe("line 1\nmodified line 2\nline 3");
+    expect(result.lineNumbers).toEqual([0]); // Match starts at line 1 (0-based)
+  });
+
+  it("should handle newlines in replacement text", () => {
+    const content = "line 1\nline 2\nline 3";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "line 2", newText: "line 2a\nline 2b" },
+    ]);
+
+    expect(result.newContent).toBe("line 1\nline 2a\nline 2b\nline 3");
+    expect(result.lineNumbers).toEqual([1]);
+  });
+
+  it("should handle very long lines", () => {
+    const longLine = "a".repeat(10000) + "text" + "b".repeat(10000);
+    const content = `line 1\n${longLine}\nline 3`;
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
+
+    expect(result.newContent).toBe(
+      `line 1\n${"a".repeat(10000)}replaced${"b".repeat(10000)}\nline 3`,
+    );
+    expect(result.lineNumbers).toEqual([1]);
+  });
+
+  it("should handle many lines", () => {
+    const lines = Array.from({ length: 1000 }, (_, i) => `line ${i}`);
+    lines[500] = "line with text";
+    const content = lines.join("\n");
+
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
+
+    expect(result.lineNumbers).toEqual([500]);
+    expect(result.newContent).includes("line with replaced");
+  });
+
+  it("should handle overlapping matches correctly", () => {
+    const content = "aaaa\nbbbb\ncccc";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "aa", newText: "xx", replaceAll: true },
+    ]);
+
+    // Should replace non-overlapping occurrences
+    expect(result.newContent).toBe("xxxx\nbbbb\ncccc");
+    expect(result.lineNumbers).toEqual([0]); // Two matches on first line, deduplicated
+  });
+
+  it("should preserve content after replacement with different lengths", () => {
+    const content = "short\nmedium line\nlong line here";
+
+    // Replacing with longer text
+    const result1 = replaceAndCalculateLocation(content, [
+      { oldText: "short", newText: "very very long text" },
+    ]);
+    expect(result1.newContent).toBe("very very long text\nmedium line\nlong line here");
+    expect(result1.lineNumbers).toEqual([0]);
+
+    // Replacing with shorter text
+    const result2 = replaceAndCalculateLocation(content, [
+      { oldText: "medium line", newText: "m" },
+    ]);
+    expect(result2.newContent).toBe("short\nm\nlong line here");
+    expect(result2.lineNumbers).toEqual([1]);
+  });
+
+  it("should handle consecutive replacements", () => {
+    const content = "text1 text2 text3";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "text", newText: "replaced", replaceAll: true },
+    ]);
+
+    expect(result.newContent).toBe("replaced1 replaced2 replaced3");
+    expect(result.lineNumbers).toEqual([0]); // All on first line, deduplicated
+  });
+
+  it("should handle case-sensitive replacements", () => {
+    const content = "Text TEXT text";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "text", newText: "replaced", replaceAll: true },
+    ]);
+
+    // Should only replace exact matches
+    expect(result.newContent).toBe("Text TEXT replaced");
+    expect(result.lineNumbers).toEqual([0]); // Only lowercase "text" matched
+  });
+
+  it("should handle replacement at exact end of line", () => {
+    const content = "line ends with text\nnext line";
+    const result = replaceAndCalculateLocation(content, [{ oldText: "text", newText: "replaced" }]);
+
+    expect(result.newContent).toBe("line ends with replaced\nnext line");
+    expect(result.lineNumbers).toEqual([0]);
+  });
+
+  it("should handle replacement spanning multiple lines", () => {
+    const content = "line 1\nspan\nacross\nlines\nline 5";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "span\nacross\nlines", newText: "single" },
+    ]);
+
+    expect(result.newContent).toBe("line 1\nsingle\nline 5");
+    expect(result.lineNumbers).toEqual([1]); // Match starts at line 2 (0-based)
+  });
+
+  it("should default replaceAll to false", () => {
+    const content = "match match match";
+
+    // Without passing replaceAll parameter
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "match", newText: "replaced" },
+    ]);
+
+    expect(result.newContent).toBe("replaced match match");
+    expect(result.lineNumbers).toEqual([0]); // Only first match
+  });
+
+  it("should handle multiple edits with correct line numbers", () => {
+    const content = "line 1\nfoo bar\nline 3\nfoo baz\nline 5\nbar foo\nline 7";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "foo", newText: "FOO", replaceAll: true },
+      { oldText: "bar", newText: "BAR", replaceAll: false },
+      { oldText: "line 3", newText: "LINE THREE" },
+    ]);
+
+    // Should replace:
+    // - All "foo" occurrences (lines 1, 3, 5 in original)
+    // - First "bar" occurrence (line 1 after first edit)
+    // - "line 3" (line 2 after previous edits)
+    expect(result.newContent).toBe("line 1\nFOO BAR\nLINE THREE\nFOO baz\nline 5\nbar FOO\nline 7");
+
+    // Line numbers reflect position in final content, deduplicated and sorted
+    expect(result.lineNumbers).toEqual([
+      1, // FOO and BAR on line 1
+      2, // LINE THREE on line 2
+      3, // FOO on line 3
+      5, // FOO on line 5
+    ]);
+  });
+
+  it("should handle multiple edits with overlapping text", () => {
+    const content = "hello world\nhello hello\nworld hello world";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "hello", newText: "hi", replaceAll: false },
+      { oldText: "world", newText: "earth", replaceAll: true },
+      { oldText: "hello", newText: "greetings", replaceAll: true },
+    ]);
+
+    // First edit replaces first "hello" only
+    // Second edit replaces all "world" in the modified content
+    // Third edit replaces remaining "hello"s in the modified content
+    expect(result.newContent).toBe("hi earth\ngreetings greetings\nearth greetings earth");
+
+    // Line numbers reflect position in final content, deduplicated and sorted
+    expect(result.lineNumbers).toEqual([
+      0, // hi and earth on line 0
+      1, // greetings (multiple) on line 1
+      2, // earth and greetings on line 2
+    ]);
+  });
+
+  it("should handle complex scenarios with marker-like text", () => {
+    // Test that our marker approach doesn't get confused by similar text
+    const content = "line 1\n__MARKER__text\nline 3\n__REPLACE_MARKER_abc__\nline 5";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "__MARKER__", newText: "REPLACED", replaceAll: true },
+      { oldText: "text", newText: "content" },
+      { oldText: "__REPLACE_MARKER_abc__", newText: "DONE" },
+    ]);
+
+    expect(result.newContent).toBe("line 1\nREPLACEDcontent\nline 3\nDONE\nline 5");
+
+    // Line numbers should be correct even with marker-like text
+    expect(result.lineNumbers).toEqual([
+      1, // REPLACED on line 1
+      3, // DONE on line 3
+    ]);
+  });
+
+  it("should handle edits where newText matches subsequent oldText", () => {
+    const content = "foo\nbar\nbaz";
+    const result = replaceAndCalculateLocation(content, [
+      { oldText: "foo", newText: "bar" },
+      { oldText: "bar", newText: "baz", replaceAll: true },
+      { oldText: "baz", newText: "qux", replaceAll: true },
+    ]);
+
+    // First edit: foo -> bar
+    // Second edit: both original bar and new bar -> baz
+    // Third edit: all baz instances -> qux
+    expect(result.newContent).toBe("qux\nqux\nqux");
+
+    // All replacements end up on their respective lines
+    expect(result.lineNumbers).toEqual([0, 1, 2]);
+  });
+});
--- a/src/tests/resolve-permission-mode.test.ts
+++ b/src/tests/resolve-permission-mode.test.ts
@@ -1,64 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { resolvePermissionMode, type Logger } from "../acp-agent.js";
-
-function mockLogger() {
-  const error = vi.fn<(...args: any[]) => void>();
-  const log = vi.fn<(...args: any[]) => void>();
-  const logger: Logger = { log, error };
-  return { logger, error, log };
-}
-
-describe("resolvePermissionMode", () => {
-  it("returns 'default' when no mode is provided", () => {
-    expect(resolvePermissionMode()).toBe("default");
-    expect(resolvePermissionMode(undefined)).toBe("default");
-  });
-
-  it("resolves exact canonical modes", () => {
-    expect(resolvePermissionMode("default")).toBe("default");
-    expect(resolvePermissionMode("acceptEdits")).toBe("acceptEdits");
-    expect(resolvePermissionMode("dontAsk")).toBe("dontAsk");
-    expect(resolvePermissionMode("plan")).toBe("plan");
-    expect(resolvePermissionMode("bypassPermissions")).toBe("bypassPermissions");
-  });
-
-  it("resolves case-insensitive aliases", () => {
-    expect(resolvePermissionMode("DontAsk")).toBe("dontAsk");
-    expect(resolvePermissionMode("DONTASK")).toBe("dontAsk");
-    expect(resolvePermissionMode("AcceptEdits")).toBe("acceptEdits");
-    expect(resolvePermissionMode("bypass")).toBe("bypassPermissions");
-  });
-
-  it("resolves 'manual' as an alias for 'default'", () => {
-    const { logger, error } = mockLogger();
-    expect(resolvePermissionMode("manual", logger)).toBe("default");
-    expect(resolvePermissionMode("Manual", logger)).toBe("default");
-    expect(error).not.toHaveBeenCalled();
-  });
-
-  it("trims whitespace", () => {
-    expect(resolvePermissionMode("  dontAsk  ")).toBe("dontAsk");
-  });
-
-  it("falls back to 'default' and logs on non-string values", () => {
-    for (const value of [123, true, {}]) {
-      const { logger, error } = mockLogger();
-      expect(resolvePermissionMode(value, logger)).toBe("default");
-      expect(error).toHaveBeenCalledWith(expect.stringContaining("expected a string"));
-    }
-  });
-
-  it("falls back to 'default' and logs on empty string", () => {
-    for (const value of ["", "  "]) {
-      const { logger, error } = mockLogger();
-      expect(resolvePermissionMode(value, logger)).toBe("default");
-      expect(error).toHaveBeenCalledWith(expect.stringContaining("expected a non-empty string"));
-    }
-  });
-
-  it("falls back to 'default' and logs on unknown mode", () => {
-    const { logger, error } = mockLogger();
-    expect(resolvePermissionMode("yolo", logger)).toBe("default");
-    expect(error).toHaveBeenCalledWith(expect.stringContaining("yolo"));
-  });
-});
--- a/src/tests/session-config-options.test.ts
+++ b/src/tests/session-config-options.test.ts
--- a/src/tests/session-load.test.ts
+++ b/src/tests/session-load.test.ts
@@ -1,383 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { randomUUID } from "crypto";
-import { RequestError, SessionNotification } from "@agentclientprotocol/sdk";
-import { query, getSessionMessages } from "@anthropic-ai/claude-agent-sdk";
-import { AcpClient, ClaudeAcpAgent } from "../acp-agent.js";
-import { Pushable } from "../utils.js";
-import type { SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
-
-function createMockClient(
-  sessionUpdate: (notification: SessionNotification) => Promise<void> = async () => {},
-): AcpClient {
-  return {
-    sessionUpdate,
-    requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
-    readTextFile: async () => ({ content: "" }),
-    writeTextFile: async () => ({}),
-  } as unknown as AcpClient;
-}
-
-describe.skipIf(!process.env.RUN_INTEGRATION_TESTS)("session load/resume lifecycle", () => {
-  it("SDK: session created but never prompted has no messages and is not resumable", async () => {
-    // Create a session via the SDK, initialize it, but never send a prompt
-    const sessionId = randomUUID();
-    const input = new Pushable<SDKUserMessage>();
-
-    const q = query({
-      prompt: input,
-      options: {
-        systemPrompt: { type: "preset", preset: "claude_code" },
-        sessionId,
-        settingSources: ["user", "project", "local"],
-        includePartialMessages: true,
-      },
-    });
-
-    // initializationResult() works without needing a prompt pushed
-    const initResult = await q.initializationResult();
-    expect(initResult).toBeDefined();
-
-    // Close without ever prompting
-    input.end();
-    q.return(undefined);
-
-    // Verify no messages were stored
-    const messages = await getSessionMessages(sessionId);
-    expect(messages).toEqual([]);
-
-    // Verify the session is not resumable
-    const input2 = new Pushable<SDKUserMessage>();
-    const q2 = query({
-      prompt: input2,
-      options: {
-        systemPrompt: { type: "preset", preset: "claude_code" },
-        resume: sessionId,
-        settingSources: ["user", "project", "local"],
-        includePartialMessages: true,
-      },
-    });
-
-    await expect(q2.initializationResult()).rejects.toThrow(
-      /No conversation found with session ID/,
-    );
-
-    input2.end();
-    q2.return(undefined);
-  }, 30000);
-
-  it("ACP: loadSession throws resourceNotFound for a non-existent session", async () => {
-    const agent = new ClaudeAcpAgent(createMockClient());
-    const bogusSessionId = randomUUID();
-
-    try {
-      await expect(
-        agent.loadSession({
-          sessionId: bogusSessionId,
-          cwd: process.cwd(),
-          mcpServers: [],
-        }),
-      ).rejects.toThrow(RequestError);
-    } finally {
-      await agent.dispose();
-    }
-  }, 30000);
-
-  it("ACP: resumeSession throws resourceNotFound for a non-existent session", async () => {
-    const agent = new ClaudeAcpAgent(createMockClient());
-    const bogusSessionId = randomUUID();
-
-    try {
-      await expect(
-        agent.resumeSession({
-          sessionId: bogusSessionId,
-          cwd: process.cwd(),
-          mcpServers: [],
-        }),
-      ).rejects.toThrow(RequestError);
-    } finally {
-      await agent.dispose();
-    }
-  }, 30000);
-
-  it("ACP: newSession without prompt, then loadSession on fresh agent throws resourceNotFound", async () => {
-    // Step 1: Create a real session via ACP, never prompt, dispose
-    const agentA = new ClaudeAcpAgent(createMockClient());
-    const { sessionId } = await agentA.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-    });
-    expect(sessionId).toBeDefined();
-    await agentA.dispose();
-
-    // Step 2: Fresh agent tries to load that session
-    const agentB = new ClaudeAcpAgent(createMockClient());
-
-    try {
-      await expect(
-        agentB.loadSession({
-          sessionId,
-          cwd: process.cwd(),
-          mcpServers: [],
-        }),
-      ).rejects.toThrow(RequestError);
-    } finally {
-      await agentB.dispose();
-    }
-  }, 30000);
-
-  it("ACP: newSession without prompt, then resumeSession on fresh agent throws resourceNotFound", async () => {
-    const agentA = new ClaudeAcpAgent(createMockClient());
-    const { sessionId } = await agentA.newSession({
-      cwd: process.cwd(),
-      mcpServers: [],
-    });
-    await agentA.dispose();
-
-    const agentB = new ClaudeAcpAgent(createMockClient());
-
-    try {
-      await expect(
-        agentB.resumeSession({
-          sessionId,
-          cwd: process.cwd(),
-          mcpServers: [],
-        }),
-      ).rejects.toThrow(RequestError);
-    } finally {
-      await agentB.dispose();
-    }
-  }, 30000);
-
-  // Regression test for https://github.com/zed-industries/claude-code-acp/issues/579
-  // The client (Zed) renders its own local slash commands — e.g. `/model` —
-  // by injecting user-message prompts whose text is wrapped in
-  // `<command-name>` / `<local-command-stdout>` markers. The Claude SDK
-  // persists those messages verbatim in the session transcript. Without
-  // filtering, `loadSession` replays the markers as user_message_chunks
-  // ahead of the real prompt, leaking CLI internals into the transcript.
-  it("ACP: loadSession does not replay local-command metadata user messages", async () => {
-    const recordedUserChunks: string[] = [];
-    const client = {
-      sessionUpdate: async (notification: SessionNotification) => {
-        if (notification.update.sessionUpdate === "user_message_chunk") {
-          const content = notification.update.content;
-          if (content.type === "text") recordedUserChunks.push(content.text);
-        }
-      },
-      requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
-      readTextFile: async () => ({ content: "" }),
-      writeTextFile: async () => ({}),
-    } as unknown as AcpClient;
-
-    const commandName =
-      "<command-name>/model</command-name>\n            <command-message>model</command-message>\n            <command-args>opus</command-args>";
-    const commandStdout =
-      "<local-command-stdout>Set model to opus (claude-opus-4-7)</local-command-stdout>";
-
-    // Step 1: create a session via the SDK, push the marker user messages
-    // followed by a real "hi" prompt. We bypass the ACP agent's prompt loop
-    // so we're only testing what the loadSession replay path does, not how
-    // prompts get routed.
-    const sessionId = randomUUID();
-    const input = new Pushable<SDKUserMessage>();
-    const q = query({
-      prompt: input,
-      options: {
-        systemPrompt: { type: "preset", preset: "claude_code" },
-        sessionId,
-        settingSources: ["user", "project", "local"],
-        includePartialMessages: true,
-      },
-    });
-    await q.initializationResult();
-
-    // Zed renders its local slash commands by mixing the marker blocks into
-    // the user's prompt content array alongside the real text. The Claude
-    // SDK persists the message verbatim — including the marker blocks —
-    // which is what loadSession must filter when it replays.
-    input.push({
-      type: "user",
-      message: {
-        role: "user",
-        content: [
-          { type: "text", text: commandName },
-          { type: "text", text: commandStdout },
-          { type: "text", text: "hi" },
-        ],
-      },
-      session_id: sessionId,
-      parent_tool_use_id: null,
-    });
-
-    for await (const msg of q) {
-      if (msg.type === "result") break;
-    }
-    input.end();
-    q.return(undefined);
-
-    // Sanity check: the SDK transcript contains the metadata we're filtering.
-    const sdkMessages = await getSessionMessages(sessionId);
-    const sdkTexts = sdkMessages
-      .map((m) => {
-        const c = (m as { message?: { content?: unknown } }).message?.content;
-        if (typeof c === "string") return c;
-        if (Array.isArray(c))
-          return c
-            .map((b) =>
-              b && typeof b === "object" && "text" in b
-                ? String((b as { text: unknown }).text)
-                : "",
-            )
-            .join("");
-        return "";
-      })
-      .join("\n");
-    expect(sdkTexts).toContain("<command-name>");
-    expect(sdkTexts).toContain("<local-command-stdout>");
-    expect(sdkTexts).toContain("hi");
-
-    // Step 2: load the session through the ACP agent and confirm the markers
-    // never reach the client as user_message_chunks, while the real "hi"
-    // prompt does.
-    const agent = new ClaudeAcpAgent(client);
-    try {
-      await agent.loadSession({
-        sessionId,
-        cwd: process.cwd(),
-        mcpServers: [],
-      });
-    } finally {
-      await agent.dispose();
-    }
-
-    for (const chunk of recordedUserChunks) {
-      expect(chunk).not.toContain("<command-name>");
-      expect(chunk).not.toContain("<command-message>");
-      expect(chunk).not.toContain("<command-args>");
-      expect(chunk).not.toContain("<local-command-stdout>");
-      expect(chunk).not.toContain("<local-command-stderr>");
-    }
-    expect(recordedUserChunks.some((c) => c.includes("hi"))).toBe(true);
-  }, 60000);
-
-  // Second regression: the original issue showed the markers and the real
-  // "hi" prompt all concatenated into a single string ending with "hi".
-  // loadSession must strip the marker tags in-place rather than dropping the
-  // whole message.
-  it("ACP: loadSession strips marker tags from a concatenated single-string prompt", async () => {
-    const recordedUserChunks: string[] = [];
-    const client = {
-      sessionUpdate: async (notification: SessionNotification) => {
-        if (notification.update.sessionUpdate === "user_message_chunk") {
-          const content = notification.update.content;
-          if (content.type === "text") recordedUserChunks.push(content.text);
-        }
-      },
-      requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
-      readTextFile: async () => ({ content: "" }),
-      writeTextFile: async () => ({}),
-    } as unknown as AcpClient;
-
-    // Exact shape from https://github.com/zed-industries/claude-code-acp/issues/579.
-    const concatenated =
-      "<command-name>/model</command-name>\n            <command-message>model</command-message>\n            <command-args>opus</command-args>" +
-      "<local-command-stdout>Set model to opus (claude-opus-4-7)</local-command-stdout>\n" +
-      "<command-name>/model</command-name>\n            <command-message>model</command-message>\n            <command-args>opus[1m]</command-args>" +
-      "<local-command-stdout>Set model to opus[1m] (claude-opus-4-7[1m])</local-command-stdout>" +
-      "hi";
-
-    const sessionId = randomUUID();
-    const input = new Pushable<SDKUserMessage>();
-    const q = query({
-      prompt: input,
-      options: {
-        systemPrompt: { type: "preset", preset: "claude_code" },
-        sessionId,
-        settingSources: ["user", "project", "local"],
-        includePartialMessages: true,
-      },
-    });
-    await q.initializationResult();
-
-    input.push({
-      type: "user",
-      message: { role: "user", content: concatenated },
-      session_id: sessionId,
-      parent_tool_use_id: null,
-    });
-    for await (const msg of q) {
-      if (msg.type === "result") break;
-    }
-    input.end();
-    q.return(undefined);
-
-    const agent = new ClaudeAcpAgent(client);
-    try {
-      await agent.loadSession({
-        sessionId,
-        cwd: process.cwd(),
-        mcpServers: [],
-      });
-    } finally {
-      await agent.dispose();
-    }
-
-    expect(recordedUserChunks.length).toBeGreaterThan(0);
-    for (const chunk of recordedUserChunks) {
-      expect(chunk).not.toContain("<command-name>");
-      expect(chunk).not.toContain("<command-message>");
-      expect(chunk).not.toContain("<command-args>");
-      expect(chunk).not.toContain("<local-command-stdout>");
-      expect(chunk).not.toContain("<local-command-stderr>");
-    }
-    expect(recordedUserChunks.some((c) => c.includes("hi"))).toBe(true);
-  }, 60000);
-
-  // Regression test for https://github.com/agentclientprotocol/claude-agent-acp/issues/845
-  // On resume the CLI restores the model the session's transcript was running,
-  // so loadSession must report that live model instead of recomputing the
-  // env/settings/default choice from scratch. Haiku is used because no account
-  // resolves its default there, so the restored model provably differs from
-  // the freshly-computed default. Requires no ANTHROPIC_MODEL env var and no
-  // "model" key in settings.json (either would pin the model on resume and
-  // mask the reconciliation this test covers).
-  it("ACP: loadSession reports the model the resumed session is actually running", async () => {
-    const agentChunks: string[] = [];
-    const client = createMockClient(async (notification) => {
-      if (notification.update.sessionUpdate === "agent_message_chunk") {
-        const content = notification.update.content;
-        if (content.type === "text") agentChunks.push(content.text);
-      }
-    });
-
-    const modelOf = (opts: { id: string; currentValue?: unknown }[] | null | undefined) =>
-      opts?.find((o) => o.id === "model")?.currentValue;
-
-    const agent = new ClaudeAcpAgent(client);
-    try {
-      const cwd = process.cwd();
-      const { sessionId, configOptions } = await agent.newSession({ cwd, mcpServers: [] });
-      expect(modelOf(configOptions)).not.toBe("haiku");
-
-      await agent.setSessionConfigOption({ sessionId, configId: "model", value: "haiku" });
-      // A real turn on Haiku, so the transcript's last assistant message —
-      // which is what the CLI restores the model from — records it.
-      await agent.prompt({
-        sessionId,
-        prompt: [{ type: "text", text: "Reply with only the word OK" }],
-      });
-      await agent.closeSession({ sessionId });
-
-      const loadResp = await agent.loadSession({ sessionId, cwd, mcpServers: [] });
-      expect(modelOf(loadResp.configOptions)).toBe("haiku");
-
-      // And the reported option agrees with the live session (`/context`).
-      agentChunks.length = 0;
-      await agent.prompt({ sessionId, prompt: [{ type: "text", text: "/context" }] });
-      const liveModel = agentChunks.join("\n").match(/\*\*Model:\*\*\s*(\S+)/)?.[1];
-      expect(liveModel).toContain("haiku");
-    } finally {
-      await agent.dispose();
-    }
-  }, 120000);
-});
--- a/src/tests/settings.test.ts
+++ b/src/tests/settings.test.ts
@@ -1,219 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { SettingsManager } from "../settings.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-
-describe("SettingsManager", () => {
-  let tempDir: string;
-  let settingsManager: SettingsManager;
-  let originalConfigDir: string | undefined;
-
-  beforeEach(async () => {
-    tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "settings-test-"));
-    // Isolate the user tier. resolveSettings reads the user settings.json from
-    // CLAUDE_CONFIG_DIR at call time; without this it falls back to the real
-    // ~/.claude and the developer's own settings (e.g. availableModels) leak
-    // into the merge, making union-based assertions fail on their machine.
-    originalConfigDir = process.env.CLAUDE_CONFIG_DIR;
-    process.env.CLAUDE_CONFIG_DIR = path.join(tempDir, "user-config");
-    await fs.promises.mkdir(process.env.CLAUDE_CONFIG_DIR, { recursive: true });
-  });
-
-  afterEach(async () => {
-    settingsManager?.dispose();
-    if (originalConfigDir === undefined) {
-      delete process.env.CLAUDE_CONFIG_DIR;
-    } else {
-      process.env.CLAUDE_CONFIG_DIR = originalConfigDir;
-    }
-    await fs.promises.rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe("settings merging", () => {
-    it("should merge model setting with later sources taking precedence", async () => {
-      const claudeDir = path.join(tempDir, ".claude");
-      await fs.promises.mkdir(claudeDir, { recursive: true });
-
-      // Project settings with one model
-      await fs.promises.writeFile(
-        path.join(claudeDir, "settings.json"),
-        JSON.stringify({
-          model: "claude-3-5-sonnet",
-        }),
-      );
-
-      settingsManager = new SettingsManager(tempDir);
-      await settingsManager.initialize();
-
-      let settings = settingsManager.getSettings();
-      expect(settings.model).toBe("claude-3-5-sonnet");
-
-      // Add local settings that override the model
-      await fs.promises.writeFile(
-        path.join(claudeDir, "settings.local.json"),
-        JSON.stringify({
-          model: "claude-3-5-haiku",
-        }),
-      );
-
-      // Re-initialize to pick up local settings
-      settingsManager.dispose();
-      settingsManager = new SettingsManager(tempDir);
-      await settingsManager.initialize();
-
-      settings = settingsManager.getSettings();
-      expect(settings.model).toBe("claude-3-5-haiku");
-    });
-
-    it("should expose availableModels from settings", async () => {
-      const claudeDir = path.join(tempDir, ".claude");
-      await fs.promises.mkdir(claudeDir, { recursive: true });
-
-      await fs.promises.writeFile(
-        path.join(claudeDir, "settings.json"),
-        JSON.stringify({
-          availableModels: ["claude-haiku-4-5", "claude-opus-4-7[1m]"],
-        }),
-      );
-
-      settingsManager = new SettingsManager(tempDir);
-      await settingsManager.initialize();
-
-      const settings = settingsManager.getSettings();
-      expect(settings.availableModels).toEqual(["claude-haiku-4-5", "claude-opus-4-7[1m]"]);
-    });
-
-    it("should union and dedupe availableModels across sources", async () => {
-      // Per Claude Code docs: "When `availableModels` is set at multiple
-      // levels, such as user settings and project settings, arrays are
-      // merged and deduplicated."
-      // https://code.claude.com/docs/en/model-config#merge-behavior
-      const claudeDir = path.join(tempDir, ".claude");
-      await fs.promises.mkdir(claudeDir, { recursive: true });
-
-      await fs.promises.writeFile(
-        path.join(claudeDir, "settings.json"),
-        JSON.stringify({
-          availableModels: ["claude-haiku-4-5", "claude-opus-4-7[1m]"],
-        }),
-      );
-      await fs.promises.writeFile(
-        path.join(claudeDir, "settings.local.json"),
-        JSON.stringify({
-          // claude-opus-4-7[1m] overlaps with project; should be deduped.
-          availableModels: ["claude-opus-4-7[1m]", "claude-sonnet-4-6[1m]"],
-        }),
-      );
-
-      settingsManager = new SettingsManager(tempDir);
-      await settingsManager.initialize();
-
-      const settings = settingsManager.getSettings();
-      expect(settings.availableModels).toEqual([
-        "claude-haiku-4-5",
-        "claude-opus-4-7[1m]",
-        "claude-sonnet-4-6[1m]",
-      ]);
-    });
-
-    it("should merge permissions.defaultMode with later sources taking precedence", async () => {
-      const claudeDir = path.join(tempDir, ".claude");
-      await fs.promises.mkdir(claudeDir, { recursive: true });
-
-      await fs.promises.writeFile(
-        path.join(claudeDir, "settings.json"),
-        JSON.stringify({
-          permissions: {
-            defaultMode: "dontAsk",
-          },
-        }),
-      );
-
-      settingsManager = new SettingsManager(tempDir);
-      await settingsManager.initialize();
-
-      let settings = settingsManager.getSettings();
-      expect(settings.permissions?.defaultMode).toBe("dontAsk");
-
-      // Local settings override the mode
-      await fs.promises.writeFile(
-        path.join(claudeDir, "settings.local.json"),
-        JSON.stringify({
-          permissions: {
-            defaultMode: "plan",
-          },
-        }),
-      );
-
-      settingsManager.dispose();
-      settingsManager = new SettingsManager(tempDir);
-      await settingsManager.initialize();
-
-      settings = settingsManager.getSettings();
-      expect(settings.permissions?.defaultMode).toBe("plan");
-    });
-  });
-
-  describe("escalating defaultMode trust filter", () => {
-    // The SDK's filterEscalatingDefaultMode drops escalating values
-    // (bypassPermissions / auto / acceptEdits) that came from a repo-committed
-    // tier (.claude/settings.json), preventing a checked-in file from
-    // silently escalating permissions. Local (.claude/settings.local.json)
-    // and user-tier sources are not committed by convention, so escalating
-    // values from those tiers are preserved.
-
-    it.each(["bypassPermissions", "auto", "acceptEdits"] as const)(
-      "drops %s when set in project-tier settings",
-      async (mode) => {
-        const claudeDir = path.join(tempDir, ".claude");
-        await fs.promises.mkdir(claudeDir, { recursive: true });
-
-        await fs.promises.writeFile(
-          path.join(claudeDir, "settings.json"),
-          JSON.stringify({ permissions: { defaultMode: mode } }),
-        );
-
-        settingsManager = new SettingsManager(tempDir);
-        await settingsManager.initialize();
-
-        expect(settingsManager.getSettings().permissions?.defaultMode).toBeUndefined();
-      },
-    );
-
-    it.each(["plan", "dontAsk"] as const)(
-      "preserves non-escalating %s from project-tier settings",
-      async (mode) => {
-        const claudeDir = path.join(tempDir, ".claude");
-        await fs.promises.mkdir(claudeDir, { recursive: true });
-
-        await fs.promises.writeFile(
-          path.join(claudeDir, "settings.json"),
-          JSON.stringify({ permissions: { defaultMode: mode } }),
-        );
-
-        settingsManager = new SettingsManager(tempDir);
-        await settingsManager.initialize();
-
-        expect(settingsManager.getSettings().permissions?.defaultMode).toBe(mode);
-      },
-    );
-
-    it("preserves escalating defaultMode when it comes from local-tier settings", async () => {
-      // settings.local.json is git-ignored by convention, so the trust
-      // filter does not apply.
-      const claudeDir = path.join(tempDir, ".claude");
-      await fs.promises.mkdir(claudeDir, { recursive: true });
-
-      await fs.promises.writeFile(
-        path.join(claudeDir, "settings.local.json"),
-        JSON.stringify({ permissions: { defaultMode: "acceptEdits" } }),
-      );
-
-      settingsManager = new SettingsManager(tempDir);
-      await settingsManager.initialize();
-
-      expect(settingsManager.getSettings().permissions?.defaultMode).toBe("acceptEdits");
-    });
-  });
-});
--- a/src/tests/tools.test.ts
+++ b/src/tests/tools.test.ts
--- a/src/tools.ts
+++ b/src/tools.ts
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -2,6 +2,8 @@

 import { Readable, Writable } from "node:stream";
 import { WritableStream, ReadableStream } from "node:stream/web";
+import { readFileSync } from "node:fs";
+import { platform } from "node:os";
 import { Logger } from "./acp-agent.js";

 // Useful for bridging push-based and async-iterator-based code.
@@ -87,3 +89,107 @@ export function unreachable(value: never, logger: Logger = console) {
 export function sleep(time: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, time));
 }
+
+interface ManagedSettings {
+  permissions?: {
+    allow?: string[];
+    deny?: string[];
+  };
+  env?: Record<string, string>;
+}
+
+// Following the rules in https://docs.anthropic.com/en/docs/claude-code/settings#settings-files
+// This can be removed once the SDK supports it natively.
+function getManagedSettingsPath(): string {
+  const os = platform();
+  switch (os) {
+    case "darwin":
+      return "/Library/Application Support/ClaudeCode/managed-settings.json";
+    case "linux": // including WSL
+      return "/etc/claude-code/managed-settings.json";
+    case "win32":
+      return "C:\\ProgramData\\ClaudeCode\\managed-settings.json";
+    default:
+      return "/etc/claude-code/managed-settings.json";
+  }
+}
+
+export function loadManagedSettings(): ManagedSettings | null {
+  try {
+    return JSON.parse(readFileSync(getManagedSettingsPath(), "utf8")) as ManagedSettings;
+  } catch {
+    return null;
+  }
+}
+
+export function applyEnvironmentSettings(settings: ManagedSettings): void {
+  if (settings.env) {
+    for (const [key, value] of Object.entries(settings.env)) {
+      process.env[key] = value;
+    }
+  }
+}
+
+export interface ExtractLinesResult {
+  content: string;
+  wasLimited: boolean;
+  linesRead: number;
+}
+
+/**
+ * Extracts lines from file content with byte limit enforcement.
+ *
+ * @param fullContent - The complete file content
+ * @param maxContentLength - Maximum number of UTF-16 Code Units to return
+ * @returns Object containing extracted content and metadata
+ */
+export function extractLinesWithByteLimit(
+  fullContent: string,
+  maxContentLength: number,
+): ExtractLinesResult {
+  if (fullContent === "") {
+    return {
+      content: "",
+      wasLimited: false,
+      linesRead: 1,
+    };
+  }
+
+  let linesSeen = 0;
+  let index = 0;
+  linesSeen = 0;
+
+  let contentLength = 0;
+  let wasLimited = false;
+
+  while (true) {
+    const nextIndex = fullContent.indexOf("\n", index);
+
+    if (nextIndex < 0) {
+      // Last line in file (no trailing newline)
+      if (linesSeen > 0 && fullContent.length > maxContentLength) {
+        wasLimited = true;
+        break;
+      }
+      linesSeen += 1;
+      contentLength = fullContent.length;
+      break;
+    } else {
+      // Line with newline - include up to the newline
+      const newContentLength = nextIndex + 1;
+      if (linesSeen > 0 && newContentLength > maxContentLength) {
+        wasLimited = true;
+        break;
+      }
+      linesSeen += 1;
+      contentLength = newContentLength;
+      index = newContentLength;
+    }
+  }
+
+  return {
+    content: fullContent.slice(0, contentLength),
+    wasLimited,
+    linesRead: linesSeen,
+  };
+}
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,11 +1,15 @@
 {
-  "extends": "@tsconfig/node22/tsconfig.json",
  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2020"],
+    "strict": true,
+    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
    "outDir": "dist",
-    "rootDir": "src",
-    "declaration": true,
-    "declarationMap": true
+    "rootDir": "src"
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules", "dist"]
Author	SHA1	Message	Date
Ben Brandt	fda22f227c	prep release	2025-12-11 14:02:33 +01:00
Ben Brandt	7643799805	Allow agent to write plans and todos to its config directory	2025-12-11 14:00:24 +01:00
Ben Brandt	ce4ae06993	Use official sdk types for tools	2025-12-11 13:19:22 +01:00