diff --git a/AGENTS.md b/AGENTS.md
index 88570f030..513c8b764 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -112,4 +112,6 @@
 
     - 兜底值的单一 owner 与失败归因：当同一个业务值（工作目录、根路径、身份、超时）既被**预备阶段**（草稿 / 预览 / 校验）消费、又被**执行阶段**（提交 / 启动 / 发送）消费时，它必须由同一个 resolver 从同一个请求源解析。触发条件：两阶段各自算一遍，且其中一个带兜底（如 stdio 缺目录时退到用户主目录）而另一个不带。原生期望行为是兜底规则连同其**分类依据**（此处为传输类型）一起收进那个 resolver，调用方只传原始请求值与分类依据。**此类缺陷最隐蔽的形态是「预备阶段成功、执行阶段失败」**：草稿能建、按钮亮着、选择器认为选择合法，用户点下去才失败，且失败文案是「请稍后重试」——而重试永远不会让缺失的值长出来。因此不可重试的失败必须呈现 resolver 自己的原因（「请先选择远程目录」而非「请稍后重试」），并且**不得只靠一道守卫**：既有的选择器/命令门禁拦住的是它能判定的子集，resolver 守卫是第二道，二者断言不同契约、不可互相替代。禁止做法：为「不是真实实体」的合法哨兵值（未归类 / 全部 / 默认）返回 null 再让下游当错误；在执行阶段新写一份兜底；把不可重试失败呈现为可重试；留下第二个 resolver 并让其唯一调用点传常量参数（它退化成 Trim 包装，看起来仍是「架构层」）。验证覆盖：哨兵值 + 各传输类型的组合各跑一遍（本地兜底必须成功启动、远程必须拒绝并给出原因）；**反向验证必须把缺陷种回去**并确认新增测试见红（仅新测试全绿不构成证据）；删除第二个 owner 时以 fail-closed 门禁断言其文件不存在且执行阶段只出现唯一 resolver 调用；以及审计**所有**触达执行阶段的既有测试——它们可能把缺陷行为写成断言（如 `Assert.Null(cwd)`），也可能因为夹具从未配置分类依据而在守卫前 return，使 `await 某个只在下游置位的 TaskCompletionSource` 永久挂死：表现为整套测试**无任何失败输出地超时**，而单跑新测试却是秒级全绿。
    - 测试进程级监听器与可释放资源隔离：当测试创建会注册进程级 listener、provider、event source 或其它全局回调的 `IDisposable` 对象时，每个用例必须在自身作用域内确定释放。原生期望行为是用例结束后全局注册恢复到进入前的状态，后续用例的采样、事件与回调只由自身夹具决定；禁止依赖串行执行、GC、终结器、平台速度、重试或固定延时清理泄漏，也禁止把多个 live listener 聚合后的全局标志误当成单个 provider 的裁决。验证覆盖同一测试类完整顺序、多轮进程级重复运行和完整程序集；诊断时用受控的共存 listener 量化污染率，并在交付前删除临时探针。
+   - 入站交互的应答与展示所有权：当 agent 请求需要用户输入，而 UI 无法展示、只承载一张表单的 UI 已有未答表单或响应发送失败时，请求必须由同一 pending owner 收敛；不可展示的请求按协议允许的取消结果应答，连接仍有效时已展示表单保留到成功响应。连接仍有效时发送成功才移除 pending，失败允许重试，取消意图不得因在途发送失败而丢失；清理同时核对请求实例与连接归属，URL completion 按连接关联并忽略未知或已完成 ID。禁止静默丢弃、覆盖未答表单、按会话或复用 ID 清除新请求、用按钮状态代替协议层单次应答门控。验证覆盖真实传输响应、无 sessionId、未知必填字段、同时到达的表单、发送失败与取消竞态、断连重连和 ID 复用。
+   - 短命令的管道与进程收尾：当版本探测或平台授权服务启动重定向 stdout/stderr 的命令时，共享 runner 必须并发排空两条流、限制保留输出，并在调用方取消或超时时终止仍归属该进程树的命令、限时等待退出、观察所有读取任务；调用方取消时，清理失败保留在取消异常的内层原因中。禁止只读一条流、用 Process.Dispose 代替终止、让清理异常改写取消语义，或声称退出父进程的 PID 能回收已被系统重新托管的子进程。验证使用真实管道覆盖超出容量的双流输出、调用方取消、超时、终止失败及父退出后子进程持有管道；夹具记录并回收自身 PID，不按进程名清理。
    - 安装器拥有命令的 PATH 注册：当同一产品既分发 GUI 又分发命令行入口时，命令必须由**每个安装包**用该平台安装器自己的机制注册（MSIX 的 `windows.appExecutionAlias`、MSI 的 `Environment` 表、dpkg 拥有的符号链接、pkg 的 postinstall），且命令二进制必须由单一 publish 脚本产出后被各安装包嵌入。禁止做法：脚本编辑 `.bashrc` / `.zshrc` / 用户 PATH 字符串或调 `setx`（安装、升级、卸载必须同属一个所有者）；每条打包链各自构建命令二进制（四份产物都能构建成功，正是它们开始漂移的形态）；把注册断言写成只在打 tag 时才跑的内联脚本。验证方式：注册必须对**本次构建产出的安装物**断言（读包内清单、`Environment` / `File` 表、文件列表），断言规则要与读取产物的平台 API 分离，使其正反例能在任意平台的每次 push 上跑；能真装真卸的平台必须有安装→命令解析→卸载→残留检查全链门禁；符号链接必须断言**解析结果**而非链接文本（相对深度错误只在解析时暴露，包的文件列表看不出来）；平台把辅助可执行文件放进包内哪个目录若非文档化契约，消费方必须探测候选位置并报告命中项，禁止赌一个位置。唯一例外是**该平台的包格式没有安装钩子**（macOS 拖拽 .app）：此时应用自身可以拥有该注册，但必须写与该平台安装器**同一路径、同一形状**（先删再链），必须同时提供移除入口，且该逻辑要拆成可在任意平台用假根跑的脚本/服务 —— 应用与安装器各写一套是同一个双所有者缺陷。
diff --git a/BUILD_GUIDE.md b/BUILD_GUIDE.md
index a83a4f9a4..5409d8833 100644
--- a/BUILD_GUIDE.md
+++ b/BUILD_GUIDE.md
@@ -371,7 +371,9 @@ scripts/gates/run-wasm-smoke-gates.sh Debug
 - 设置持久化：通过 UI 切换应用语言并修改外观、数据与存储、快捷键、ACP 和 MCP 服务器状态，验证 shell 重载后的 `x:Uid` 与 singleton ViewModel 文案，并在刷新后从可见设置页确认状态仍存在；
 - ACP / 平台能力边界：保存 ACP WebSocket profile，验证 WASM 不声明 `clientCapabilities.fs` / `terminal=true`，并确认受限平台不会暴露桌面文件系统入口；
 - Gamepad 能力边界：确认 BrowserWasm 通过浏览器 Gamepad API 投影标准手柄读数，并验证 DPad / A 键进入 Diagnostics 的 pressed 槽位与 ActiveInputs 意图事实（`MoveDown` / `Activate`）。原生焦点由键盘/XYFocus 与控件 consumer 拥有；壳层不再对轮询手柄做全局 SendInput / FocusManager 焦点 bridge，避免双路径分发；
-- WASM ACP 全链路：用同一 profile 和 remote directory 从 Start 页面创建远端会话，断言 mock ACP Server 收到 `initialize`、`session/new`（`cwd` 为所选 remote path）和 `session/prompt`，并确认 agent reply 投影到 Chat UI。
+- WASM ACP 全链路：用同一 profile 和 remote directory 从 Start 页面创建远端会话，断言 mock ACP Server 收到 `initialize`、`session/new`（`cwd` 为所选 remote path）和 `session/prompt`，并确认 agent reply 投影到 Chat UI；在 `session/new` 完成前验证请求级 elicitation 收到 `cancel`，再通过真实表单填写验证必填校验、字符串与布尔值回包，以及未知必填字段禁止提交且可取消。
+
+设置持久化与 ACP 全链路在刷新前，只读等待本轮配置出现在 IDBFS 的 IndexedDB 已提交记录中，再从重载后的 UI 验证；内存 `FS.readFile`、按钮恢复可用或固定等待均不代表落盘完成，gate 不代应用调用 `syncfs`。
 
 它补充 Windows FlaUI gate，专门覆盖 WASM 浏览器里的原生 Uno 控件行为与当前构建产物的浏览器持久化链路。
 
diff --git a/SalmonEgg/SalmonEgg/DependencyInjection.cs b/SalmonEgg/SalmonEgg/DependencyInjection.cs
index f1f7c502d..d7a418c6b 100644
--- a/SalmonEgg/SalmonEgg/DependencyInjection.cs
+++ b/SalmonEgg/SalmonEgg/DependencyInjection.cs
@@ -26,6 +26,7 @@
 using SalmonEgg.Infrastructure.Services;
 using SalmonEgg.Infrastructure.Storage;
 using SalmonEgg.Infrastructure.Transport;
+using SalmonEgg.Presentation.Core.Localization;
 using SalmonEgg.Presentation.Core.Mvux.Chat;
 using SalmonEgg.Presentation.Core.Mvux.ShellLayout;
 using SalmonEgg.Presentation.Core.Resources;
@@ -512,6 +513,7 @@ private static void RegisterInfrastructureServices(IServiceCollection services)
                 ? new TerminalSessionManager()
                 : new UnsupportedTerminalSessionManager());
 #endif
+        services.AddSingleton<ITransportErrorMessageFormatter, TransportErrorMessageFormatter>();
         services.AddSingleton<IAcpClientFactory, AcpClientFactory>();
 
         // ACP setup wizard. The catalog is pure data and safe everywhere; every probing, installing and
@@ -942,6 +944,9 @@ private static void RegisterInfrastructureServices(IServiceCollection services)
         services.AddSingleton<ICliCommandRegistrationInspector, UnsupportedCliCommandRegistrationInspector>();
         services.AddSingleton<ICliCommandLinkService, UnsupportedCliCommandLinkService>();
 #endif
+        // Intentional exception to coding-standards §3.1: these commands operate on one machine-wide
+        // registration. Settings page instances share the command owner and IsBusy so their buttons
+        // observe the same in-flight inspect/link operation instead of maintaining separate busy state.
         services.AddSingleton<CommandLineSettingsViewModel>();
         services.AddSingleton<McpSettingsViewModel>(sp =>
             new McpSettingsViewModel(
diff --git a/SalmonEgg/SalmonEgg/Presentation/Views/Chat/ChatView.xaml b/SalmonEgg/SalmonEgg/Presentation/Views/Chat/ChatView.xaml
index 8fbd9730b..cd9e07b8e 100644
--- a/SalmonEgg/SalmonEgg/Presentation/Views/Chat/ChatView.xaml
+++ b/SalmonEgg/SalmonEgg/Presentation/Views/Chat/ChatView.xaml
@@ -13,6 +13,17 @@
     AllowDrop="False">
 
     <Page.Resources>
+        <!-- Form grouping follows the existing chat card rhythm; keep these dimensions in one
+             resource scope so theme/layout changes do not require editing individual controls. -->
+        <Thickness x:Key="ChatElicitationMargin">12,0,12,8</Thickness>
+        <Thickness x:Key="ChatElicitationPadding">16</Thickness>
+        <Thickness x:Key="ChatElicitationBorderThickness">1</Thickness>
+        <Thickness x:Key="ChatElicitationFieldMargin">0,0,0,12</Thickness>
+        <CornerRadius x:Key="ChatElicitationCornerRadius">12</CornerRadius>
+        <x:Double x:Key="ChatElicitationSectionSpacing">16</x:Double>
+        <x:Double x:Key="ChatElicitationHeadingSpacing">4</x:Double>
+        <x:Double x:Key="ChatElicitationFieldSpacing">6</x:Double>
+        <x:Double x:Key="ChatElicitationActionSpacing">8</x:Double>
     </Page.Resources>
 
     <Grid>
@@ -465,14 +476,14 @@
                                                 Visibility="{x:Bind ViewModel.HasPendingElicitationRequest, Mode=OneWay, Converter={StaticResource BoolToVisibilityConverter}}">
                     <controls:ResponsiveContentHost.Child>
                         <Border x:Name="ElicitationHost"
-                                Margin="12,0,12,8"
-                                Padding="16"
-                                CornerRadius="12"
+                                Margin="{StaticResource ChatElicitationMargin}"
+                                Padding="{StaticResource ChatElicitationPadding}"
+                                CornerRadius="{StaticResource ChatElicitationCornerRadius}"
                                 Background="{ThemeResource LayerFillColorDefaultBrush}"
                                 BorderBrush="{ThemeResource DividerStrokeColorDefaultBrush}"
-                                BorderThickness="1">
-                            <StackPanel Spacing="16">
-                                <StackPanel Spacing="4">
+                                BorderThickness="{StaticResource ChatElicitationBorderThickness}">
+                            <StackPanel Spacing="{StaticResource ChatElicitationSectionSpacing}">
+                                <StackPanel Spacing="{StaticResource ChatElicitationHeadingSpacing}">
                                     <TextBlock x:Uid="ChatViewElicitationTitle"
                                                FontSize="14"
                                                FontWeight="SemiBold"
@@ -485,7 +496,8 @@
                                 <ItemsControl ItemsSource="{x:Bind ViewModel.ElicitationFields, Mode=OneWay}">
                                     <ItemsControl.ItemTemplate>
                                         <DataTemplate x:DataType="elicitationVm:ElicitationFieldViewModel">
-                                            <StackPanel Spacing="6" Margin="0,0,0,12">
+                                            <StackPanel Spacing="{StaticResource ChatElicitationFieldSpacing}"
+                                                        Margin="{StaticResource ChatElicitationFieldMargin}">
                                                 <TextBlock Text="{x:Bind Title}" FontWeight="SemiBold"/>
                                                 <TextBlock Text="{x:Bind Description}"
                                                            TextWrapping="WrapWholeWords"
@@ -523,7 +535,8 @@
                                            Foreground="{ThemeResource SystemFillColorCriticalBrush}"
                                            TextWrapping="WrapWholeWords"/>
 
-                                <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Spacing="8">
+                                <StackPanel Orientation="Horizontal" HorizontalAlignment="Right"
+                                            Spacing="{StaticResource ChatElicitationActionSpacing}">
                                     <Button x:Uid="ChatViewElicitationCancelButton"
                                             Command="{x:Bind ViewModel.ElicitationCancelCommand, Mode=OneWay}"/>
                                     <Button x:Uid="ChatViewElicitationDeclineButton"
diff --git a/scripts/gates/wasm-acp-full-chain-smoke.mjs b/scripts/gates/wasm-acp-full-chain-smoke.mjs
index 9b489df12..df9db8fad 100644
--- a/scripts/gates/wasm-acp-full-chain-smoke.mjs
+++ b/scripts/gates/wasm-acp-full-chain-smoke.mjs
@@ -1,3 +1,4 @@
+import assert from "node:assert/strict";
 import { chromium } from "playwright";
 import {
   normalizeBaseUrl,
@@ -21,6 +22,15 @@ import {
   waitForInitializeWithDiagnostics,
   createSessionAndSendPromptFromStart
 } from "./wasm-smoke-lib/acp-ui-fixture.mjs";
+import {
+  clickVisibleControl,
+  collectVisibleInteractiveDebug,
+  typeIntoVisibleTextField,
+  waitForControlEnabledState,
+  waitForLaidOutControl,
+  waitForPersistedLocalFileContains,
+  waitForSemanticText
+} from "./wasm-smoke-lib/ui-affordances.mjs";
 
 const baseUrl = normalizeBaseUrl(process.argv[2], "wasm-acp-full-chain-smoke.mjs");
 const profileName = `WASM full chain ${Date.now()}`;
@@ -29,12 +39,17 @@ const remoteDirectoryPath = `/remote/wasm-full-chain-${Date.now()}`;
 const fullChainPromptText = `WASM full chain prompt ${Date.now()}`;
 const fullChainAgentReplyText = `WASM full chain agent reply ${Date.now()}`;
 const browser = await chromium.launch({ headless: true });
-const acpServer = await startAcpWebSocketServer({
-  agentReplyText: fullChainAgentReplyText,
-  sessionTitle: "WASM full chain session"
-});
+let acpServer;
+const submitButton = { labels: ["Submit"], role: "button" };
+const cancelButton = { labels: ["Cancel"], role: "button" };
+const elicitationRequests = [];
 
 try {
+  acpServer = await startAcpWebSocketServer({
+    agentReplyText: fullChainAgentReplyText,
+    sessionTitle: "WASM full chain session",
+    deferSessionNewResponse: true
+  });
   await clearBrowserOriginStorage(browser, baseUrl);
   const { context, page, fatalConsoleMessages } = await createInstrumentedContext(browser);
 
@@ -49,14 +64,17 @@ try {
     await createWebSocketProfile(page, profileName, acpServer.url);
     await expectProfilePresence(page, profileName, "saved ACP profile");
     await createRemoteDirectory(page, remoteDirectoryName, remoteDirectoryPath);
-    await page.waitForTimeout(1_500);
+    await waitForPersistedLocalFileContains(page, "/local/SalmonEgg/config/app.yaml",
+      [remoteDirectoryName, remoteDirectoryPath], "remote directory settings");
 
     await expectPersistedProfileAfterReload(page, baseUrl, profileName);
     await expectRemoteDirectoryPresence(page, remoteDirectoryName, remoteDirectoryPath, "persisted remote directory");
 
     await ensureAcpProfilesReady(page);
     await clickProfileConnectionToggle(page, profileName);
-    await waitForInitializeWithDiagnostics(acpServer, page, profileName);
+    const initialize = await waitForInitializeWithDiagnostics(acpServer, page, profileName);
+    assert.ok(initialize.params.clientCapabilities?.elicitation?.form,
+      "The production client must advertise form elicitation before the server sends one.");
     await createSessionAndSendPromptFromStart(
       page,
       acpServer,
@@ -64,14 +82,248 @@ try {
       remoteDirectoryName,
       remoteDirectoryPath,
       fullChainPromptText,
-      fullChainAgentReplyText);
+      fullChainAgentReplyText,
+      {
+        beforeSessionNewResponse: async sessionNew => {
+          const request = acpServer.requestClient("elicitation/create", {
+            requestId: sessionNew.id,
+            mode: "form",
+            message: "WASM request-scoped input before a session exists",
+            requestedSchema: { type: "object", properties: {} }
+          });
+          elicitationRequests.push(request);
+          const response = await request.waitForResponse();
+          assert.deepEqual(response, { jsonrpc: "2.0", id: request.id, result: { action: "cancel" } },
+            "Request-scoped input must be cancelled instead of leaving session/new waiting.");
+          assert.equal(request.responses().length, 1);
+          acpServer.completeSessionNew();
+          console.log("WASM request-scoped elicitation returned cancel before session/new completed");
+        }
+      });
 
-    assertNoFatalConsoleMessages(fatalConsoleMessages);
-    console.log("WASM ACP full-chain smoke passed");
+    elicitationRequests.push(await verifyKnownFormSubmission(page, acpServer));
+    elicitationRequests.push(await verifyUnknownRequiredFieldCancellation(page, acpServer));
   } finally {
     await context.close();
   }
+
+  // Check again after closing the client: duplicate responses can arrive after the first reply,
+  // while the view is dismissing or while the next request is being exercised.
+  for (const request of elicitationRequests) {
+    assert.equal(request.responses().length, 1, `Elicitation ${request.id} must receive exactly one response.`);
+  }
+  assertNoFatalConsoleMessages(fatalConsoleMessages);
+  console.log("WASM ACP full-chain and elicitation smoke passed");
 } finally {
-  await browser.close();
-  await acpServer.close();
+  try {
+    await browser.close();
+  } finally {
+    await acpServer?.close();
+  }
+}
+
+async function verifyKnownFormSubmission(page, server) {
+  const existingControlIds = await page.evaluate(() => Array.from(document.querySelectorAll(
+    "#uno-semantics-root input,#uno-semantics-root [role='checkbox'],#uno-semantics-root [aria-checked]"))
+    .filter(element => !element.closest("[hidden]"))
+    .map(element => element.id));
+  const fieldValue = `WASM form value ${Date.now()}`;
+  const prompt = `WASM required input ${Date.now()}`;
+  const request = server.requestClient("elicitation/create", {
+    sessionId: server.sessionId,
+    mode: "form",
+    message: prompt,
+    requestedSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", title: "Smoke name" },
+        enabled: { type: "boolean", title: "Smoke enabled", default: true }
+      },
+      required: ["name", "enabled"]
+    }
+  });
+
+  await waitForSemanticText(page, new RegExp(prompt), "known-type elicitation form");
+  await waitForLaidOutControl(page, submitButton, "elicitation Submit button");
+  const formNodeIds = await waitForVisibleForm(page);
+  await waitForControlEnabledState(page, submitButton, false, "empty required field blocks Submit");
+  assert.equal(request.responses().length, 0, "An incomplete form must not send a response.");
+
+  const inputSelector = await findSingleVisibleFormInput(page, existingControlIds);
+  await typeIntoVisibleTextField(page, { selector: inputSelector }, fieldValue, "required elicitation name");
+  await toggleSingleVisibleFormCheckbox(page, existingControlIds);
+  await waitForControlEnabledState(page, submitButton, true, "filled form enables Submit");
+  await clickVisibleControl(page, submitButton);
+
+  const response = await request.waitForResponse();
+  assert.deepEqual(response, {
+    jsonrpc: "2.0",
+    id: request.id,
+    result: { action: "accept", content: { name: fieldValue, enabled: false } }
+  }, "Form values must survive the real UI binding and ACP wire response.");
+  assert.equal(request.responses().length, 1);
+  await waitForFormDismissal(page, formNodeIds);
+  assert.equal(request.responses().length, 1, "Dismissing the accepted form must not send another response.");
+  console.log("WASM known-type elicitation blocked empty input and returned typed string/boolean content");
+  return request;
+}
+
+async function verifyUnknownRequiredFieldCancellation(page, server) {
+  const prompt = `WASM unsupported required input ${Date.now()}`;
+  const request = server.requestClient("elicitation/create", {
+    sessionId: server.sessionId,
+    mode: "form",
+    message: prompt,
+    requestedSchema: {
+      type: "object",
+      properties: { future: { type: "_future", title: "Unsupported required field" } },
+      required: ["future"]
+    }
+  });
+
+  // Uno can omit the prompt TextBlock's semantic node when this surface reappears. The error is
+  // unique to this request, so it proves the new form arrived without relying on the old heading.
+  await waitForSemanticText(page, /This form contains required fields that cannot be displayed/,
+    "localized unsupported-required explanation");
+  const formNodeIds = await waitForVisibleForm(page);
+  await waitForControlEnabledState(page, submitButton, false, "unsupported required field blocks Submit");
+  assert.equal(request.responses().length, 0, "An unsupported required field must never be accepted.");
+  await waitForControlEnabledState(page, cancelButton, true, "unsupported form remains cancellable");
+  await clickVisibleControl(page, cancelButton);
+
+  const response = await request.waitForResponse();
+  assert.deepEqual(response, { jsonrpc: "2.0", id: request.id, result: { action: "cancel" } });
+  assert.equal(request.responses().length, 1, "Cancelling must send exactly one response.");
+  await waitForFormDismissal(page, formNodeIds);
+  assert.equal(request.responses().length, 1, "Dismissing the cancelled form must not send another response.");
+  console.log("WASM unknown required field prevented accept and returned cancel");
+  return request;
+}
+
+async function findSingleVisibleFormInput(page, existingControlIds) {
+  // The form's TextBox has no automation id or accessible name. Chat's composer is a textarea,
+  // and the shell already owns a search input. Only this request's newly visible single-line
+  // input belongs to the form; count it explicitly instead of choosing the first page input.
+  const handle = await page.waitForFunction(existingIds => {
+    const inputs = Array.from(document.querySelectorAll("#uno-semantics-root input"))
+      .filter(element => {
+        const rect = element.getBoundingClientRect();
+        return element.type === "text"
+          && element.id !== ""
+          && !existingIds.includes(element.id)
+          && !element.closest("[hidden]")
+          && !element.disabled
+          && !element.readOnly
+          && rect.width >= 12
+          && rect.height >= 12;
+      });
+    return inputs.length === 1 ? `#${inputs[0].id}` : null;
+  }, existingControlIds, { timeout: 15_000 }).catch(async error => {
+    throw new Error(`Expected one editable elicitation input. Semantic DOM=${JSON.stringify(
+      await collectVisibleInteractiveDebug(page))}`, { cause: error });
+  });
+  try {
+    return await handle.jsonValue();
+  } finally {
+    await handle.dispose();
+  }
+}
+
+async function waitForVisibleForm(page) {
+  const handle = await page.waitForFunction(() => {
+    const isVisible = element => {
+      const rect = element.getBoundingClientRect();
+      return !element.closest("[hidden]") && rect.width >= 12 && rect.height >= 12;
+    };
+    const hosts = Array.from(document.querySelectorAll(
+      "#uno-semantics-root [xamlautomationid='ElicitationHost']")).filter(isVisible);
+    if (hosts.length !== 1) {
+      return null;
+    }
+    const buttons = Array.from(document.querySelectorAll(
+      "#uno-semantics-root button,#uno-semantics-root [role='button']")).filter(isVisible);
+    const ids = [hosts[0].id];
+    for (const label of ["Submit", "Cancel", "Decline"]) {
+      const matches = buttons.filter(element => element.getAttribute("aria-label") === label);
+      if (matches.length !== 1 || matches[0].id === "") {
+        return null;
+      }
+      ids.push(matches[0].id);
+    }
+    return ids;
+  }, null, { timeout: 15_000 });
+  try {
+    return await handle.jsonValue();
+  } finally {
+    await handle.dispose();
+  }
+}
+
+async function waitForFormDismissal(page, formNodeIds) {
+  // These nodes must first have been visible. Text may disappear before the form collapses, and
+  // collapsed controls can retain old bounds, so require native removal/hidden state for the host
+  // and every action, and reject a replacement host that is still present.
+  const handle = await page.waitForFunction(ids => {
+    const isDismissed = node => !node || Boolean(node.closest("[hidden]"));
+    return ids.every(id => isDismissed(document.getElementById(id)))
+      && Array.from(document.querySelectorAll(
+        "#uno-semantics-root [xamlautomationid='ElicitationHost']")).every(isDismissed);
+  }, formNodeIds, { timeout: 15_000 }).catch(async error => {
+    throw new Error(`Elicitation host and actions did not dismiss. Semantic DOM=${JSON.stringify(
+      await collectVisibleInteractiveDebug(page))}`, { cause: error });
+  });
+  await handle.dispose();
+}
+
+async function toggleSingleVisibleFormCheckbox(page, existingControlIds) {
+  // Uno may expose Toggle through aria-checked without an explicit checkbox role. The only
+  // new toggle in this form is its boolean field; wait for its native default and enabled state
+  // before one activation, then wait for the same node's state to change before submitting.
+  const handle = await page.waitForFunction(existingIds => {
+    const checkboxes = Array.from(document.querySelectorAll(
+      "#uno-semantics-root input[type='checkbox'],#uno-semantics-root [role='checkbox'],#uno-semantics-root [aria-checked]"))
+      .filter(element => {
+        const rect = element.getBoundingClientRect();
+        return element.id !== "" && !existingIds.includes(element.id)
+          && !element.closest("[hidden]") && rect.width >= 12 && rect.height >= 12;
+      });
+    if (checkboxes.length !== 1) {
+      return null;
+    }
+    const checkbox = checkboxes[0];
+    const ariaChecked = checkbox.getAttribute("aria-checked");
+    const checked = ariaChecked === "true" || (ariaChecked === null && checkbox.checked === true);
+    const enabled = !checkbox.disabled && checkbox.getAttribute("aria-disabled") !== "true";
+    return checked && enabled ? checkbox.id : null;
+  }, existingControlIds, { timeout: 15_000 }).catch(async error => {
+    throw new Error(`Expected one enabled elicitation checkbox with its true default. Semantic DOM=${JSON.stringify(
+      await collectVisibleInteractiveDebug(page))}`, { cause: error });
+  });
+  let checkboxId;
+  try {
+    checkboxId = await handle.jsonValue();
+  } finally {
+    await handle.dispose();
+  }
+
+  const activated = await page.evaluate(id => {
+    const checkbox = document.getElementById(id);
+    if (!checkbox || checkbox.closest("[hidden]")
+      || checkbox.disabled || checkbox.getAttribute("aria-disabled") === "true") {
+      return false;
+    }
+    checkbox.click();
+    return true;
+  }, checkboxId);
+  assert.equal(activated, true, "The elicitation checkbox must remain enabled for activation.");
+
+  const unchecked = await page.waitForFunction(id => {
+    const checkbox = document.getElementById(id);
+    if (!checkbox || checkbox.closest("[hidden]")) {
+      return false;
+    }
+    const ariaChecked = checkbox.getAttribute("aria-checked");
+    return ariaChecked === "false" || (ariaChecked === null && checkbox.checked === false);
+  }, checkboxId, { timeout: 15_000 });
+  await unchecked.dispose();
 }
diff --git a/scripts/gates/wasm-settings-persistence-smoke.mjs b/scripts/gates/wasm-settings-persistence-smoke.mjs
index d5f1c9381..b34b0560b 100644
--- a/scripts/gates/wasm-settings-persistence-smoke.mjs
+++ b/scripts/gates/wasm-settings-persistence-smoke.mjs
@@ -23,6 +23,7 @@ import {
   scrollToVisibleControl,
   typeIntoVisibleTextField,
   waitForBodyText,
+  waitForPersistedLocalFileContains,
   readLocalTextFile
 } from "./wasm-smoke-lib/ui-affordances.mjs";
 import {
@@ -107,7 +108,7 @@ try {
     await verifyAcpSettings(page);
     await changeMcpSettings(page);
 
-    await waitForLocalFileContains(
+    await waitForPersistedLocalFileContains(
       page,
       appSettingsPath,
       [
@@ -120,7 +121,7 @@ try {
         "keyboard_shortcuts_enabled: false"
       ],
       "app settings YAML");
-    await waitForLocalFileContains(
+    await waitForPersistedLocalFileContains(
       page,
       mcpSettingsPath,
       [
@@ -607,23 +608,3 @@ function cssContrastRatio(foreground, background) {
   const darker = Math.min(foregroundLuminance, backgroundLuminance);
   return (lighter + 0.05) / (darker + 0.05);
 }
-
-async function waitForLocalFileContains(page, path, requiredSnippets, label, timeoutMs = 15_000) {
-  const deadline = Date.now() + timeoutMs;
-  let lastResult = null;
-
-  while (Date.now() < deadline) {
-    lastResult = await readLocalTextFile(page, path);
-    const content = lastResult?.content ?? "";
-    if (!lastResult?.error && requiredSnippets.every(snippet => content.includes(snippet))) {
-      return content;
-    }
-
-    await page.waitForTimeout(250);
-  }
-
-  throw new Error(
-    `${label} did not contain expected settings. `
-    + `Expected=${JSON.stringify(requiredSnippets)} `
-    + `Actual=${JSON.stringify(lastResult)}`);
-}
diff --git a/scripts/gates/wasm-smoke-lib/acp-test-server.mjs b/scripts/gates/wasm-smoke-lib/acp-test-server.mjs
index 8d2e5c565..2f1e8becf 100644
--- a/scripts/gates/wasm-smoke-lib/acp-test-server.mjs
+++ b/scripts/gates/wasm-smoke-lib/acp-test-server.mjs
@@ -8,7 +8,11 @@ export async function startAcpWebSocketServer(options = {}) {
 
   let initializeRequest;
   let sessionNewRequest;
+  let sessionNewSocket;
+  let deferNextSessionNewResponse = options.deferSessionNewResponse === true;
+  let deferredSessionNew;
   let sessionPromptRequest;
+  let clientRequestSequence = 0;
   let resolveInitialize;
   let resolveSessionNew;
   let resolveSessionPrompt;
@@ -22,6 +26,48 @@ export async function startAcpWebSocketServer(options = {}) {
     resolveSessionPrompt = resolve;
   });
   const sockets = new Set();
+  const clientRequests = new Map();
+
+  const sendSessionNewResponse = (socket, request) => {
+    if (!request || !socket || socket.destroyed) {
+      throw new Error("No live session/new request is available to complete.");
+    }
+
+    writeJsonRpc(socket, {
+      jsonrpc: "2.0",
+      id: request.id,
+      result: {
+        sessionId,
+        modes: {
+          currentModeId: "planner",
+          availableModes: [
+            { id: "agent", name: "Agent 01", description: "General conversation mode" },
+            { id: "planner", name: "Planner 01", description: "Structured planning mode" }
+          ]
+        },
+        configOptions: [{
+          id: "mode",
+          name: "Mode",
+          description: "Conversation mode",
+          type: "select",
+          currentValue: "planner",
+          options: [
+            { value: "agent", name: "Agent 01" },
+            { value: "planner", name: "Planner 01" }
+          ]
+        }]
+      }
+    });
+    writeSessionUpdate(socket, sessionId, {
+      sessionUpdate: "session_info_update",
+      title: sessionTitle
+    });
+  };
+
+  const finishClientRequest = (entry, outcome) => {
+    clearTimeout(entry.timeoutId);
+    entry.resolve(outcome);
+  };
 
   const server = createServer();
   server.on("upgrade", (request, socket) => {
@@ -53,6 +99,13 @@ export async function startAcpWebSocketServer(options = {}) {
 
       for (const text of result.messages) {
         const message = JSON.parse(text);
+        const clientRequest = clientRequests.get(message.id);
+        if (message.method === undefined && clientRequest?.socket === socket) {
+          clientRequest.responses.push(message);
+          finishClientRequest(clientRequest, { response: message });
+          continue;
+        }
+
         if (message.method === "initialize") {
           initializeRequest = message;
           resolveInitialize(message);
@@ -73,53 +126,19 @@ export async function startAcpWebSocketServer(options = {}) {
         }
 
         if (message.method === "session/new") {
-          sessionNewRequest = message;
-          resolveSessionNew(message);
-          writeJsonRpc(socket, {
-            jsonrpc: "2.0",
-            id: message.id,
-            result: {
-              sessionId,
-              modes: {
-                currentModeId: "planner",
-                availableModes: [
-                  {
-                    id: "agent",
-                    name: "Agent 01",
-                    description: "General conversation mode"
-                  },
-                  {
-                    id: "planner",
-                    name: "Planner 01",
-                    description: "Structured planning mode"
-                  }
-                ]
-              },
-              configOptions: [
-                {
-                  id: "mode",
-                  name: "Mode",
-                  description: "Conversation mode",
-                  type: "select",
-                  currentValue: "planner",
-                  options: [
-                    {
-                      value: "agent",
-                      name: "Agent 01"
-                    },
-                    {
-                      value: "planner",
-                      name: "Planner 01"
-                    }
-                  ]
-                }
-              ]
-            }
-          });
-          writeSessionUpdate(socket, sessionId, {
-            sessionUpdate: "session_info_update",
-            title: sessionTitle
-          });
+          if (!sessionNewRequest) {
+            sessionNewRequest = message;
+            resolveSessionNew(message);
+          }
+          sessionNewSocket = socket;
+          if (deferNextSessionNewResponse) {
+            // Only the first request is held for the request-scoped elicitation exercise.
+            // Retain its connection and id even if another session/new arrives before completion.
+            deferNextSessionNewResponse = false;
+            deferredSessionNew = { socket, request: message };
+          } else {
+            sendSessionNewResponse(socket, message);
+          }
           continue;
         }
 
@@ -144,7 +163,14 @@ export async function startAcpWebSocketServer(options = {}) {
         }
       }
     });
-    socket.on("close", () => sockets.delete(socket));
+    socket.on("close", () => {
+      sockets.delete(socket);
+      for (const entry of clientRequests.values()) {
+        if (entry.socket === socket) {
+          finishClientRequest(entry, { error: new Error("ACP socket closed before the client replied.") });
+        }
+      }
+    });
     socket.on("error", () => sockets.delete(socket));
   });
 
@@ -154,6 +180,45 @@ export async function startAcpWebSocketServer(options = {}) {
 
   return {
     url: `ws://127.0.0.1:${port}/acp`,
+    sessionId,
+    completeSessionNew: () => {
+      if (!deferredSessionNew) {
+        throw new Error("No deferred session/new request remains to complete.");
+      }
+      const pending = deferredSessionNew;
+      deferredSessionNew = undefined;
+      sendSessionNewResponse(pending.socket, pending.request);
+    },
+    requestClient: (method, params) => {
+      const socket = deferredSessionNew?.socket ?? sessionNewSocket;
+      if (!socket || socket.destroyed) {
+        throw new Error("No live ACP session/new connection is available for a client request.");
+      }
+
+      const id = `wasm-smoke-client-request-${++clientRequestSequence}`;
+      let resolve;
+      // Store an outcome instead of a rejecting promise: a GUI assertion may fail before the
+      // caller reaches waitForResponse, and cleanup must not produce an unhandled rejection.
+      const outcome = new Promise(settle => { resolve = settle; });
+      const entry = { socket, resolve, responses: [], timeoutId: null };
+      entry.timeoutId = setTimeout(() => finishClientRequest(entry, {
+        error: new Error(`Timed out waiting for client response to ${method} (${id}).`)
+      }), 30_000);
+      clientRequests.set(id, entry);
+      writeJsonRpc(socket, { jsonrpc: "2.0", id, method, params });
+
+      return {
+        id,
+        responses: () => [...entry.responses],
+        waitForResponse: async () => {
+          const result = await outcome;
+          if (result.error) {
+            throw result.error;
+          }
+          return result.response;
+        }
+      };
+    },
     waitForInitialize: async () => {
       if (initializeRequest) {
         return initializeRequest;
@@ -185,6 +250,11 @@ export async function startAcpWebSocketServer(options = {}) {
         30_000);
     },
     close: async () => {
+      deferredSessionNew = undefined;
+      for (const entry of clientRequests.values()) {
+        finishClientRequest(entry, { error: new Error("ACP smoke server closed.") });
+      }
+      clientRequests.clear();
       for (const socket of sockets) {
         socket.destroy();
       }
diff --git a/scripts/gates/wasm-smoke-lib/acp-ui-fixture.mjs b/scripts/gates/wasm-smoke-lib/acp-ui-fixture.mjs
index ae943ebfb..ff01fdc11 100644
--- a/scripts/gates/wasm-smoke-lib/acp-ui-fixture.mjs
+++ b/scripts/gates/wasm-smoke-lib/acp-ui-fixture.mjs
@@ -13,6 +13,7 @@ import {
   selectComboBoxItem,
   typeIntoVisibleTextField,
   waitForBodyText,
+  waitForControlEnabledState,
   waitForControlState,
   waitForSemanticText
 } from "./ui-affordances.mjs";
@@ -150,6 +151,7 @@ export async function createRemoteDirectory(page, displayName, remotePath) {
       `The remote directory editor did not open after ${profileEditorAttempts} activations of its Add affordance.`);
   }
 
+  await waitForControlEnabledState(page, remoteDirectoryAddAffordance, false, "remote directory editor is active");
   await typeIntoVisibleTextField(
     page,
     { labels: ["项目名称", "Project name"], automationIds: ["Acp.RemoteDirectories.DisplayName"] },
@@ -161,6 +163,9 @@ export async function createRemoteDirectory(page, displayName, remotePath) {
     remotePath,
     "remote directory path");
   await clickVisibleNavigationTarget(page, { labels: ["保存", "Save"], automationIds: ["Acp.RemoteDirectories.Save"] });
+  // The command commits the row synchronously; Add becomes enabled only after editing ends.
+  // This proves the UI accepted Save, while the caller separately waits for durable persistence.
+  await waitForControlEnabledState(page, remoteDirectoryAddAffordance, true, "remote directory editor has closed");
   await expectRemoteDirectoryPresence(page, displayName, remotePath, "saved remote directory");
 }
 
@@ -309,7 +314,8 @@ export async function createSessionAndSendPromptFromStart(
   directoryName,
   directoryPath,
   promptText,
-  expectedAgentReply) {
+  expectedAgentReply,
+  options = {}) {
   // The composer is located by shape, not by id: StartView sets its automation id through an x:Bind
   // on AutomationProperties.AutomationId, which never reaches the exported accessibility node on
   // Skia - the node has no id and its accessible name is the localized placeholder. The Start shell
@@ -337,6 +343,12 @@ export async function createSessionAndSendPromptFromStart(
     throw new Error(`session/new used unexpected cwd. Expected=${directoryPath} Request=${JSON.stringify(sessionNewRequest)}`);
   }
 
+  // Request-scoped elicitation belongs before the session exists. Let the caller answer that
+  // interaction while the server deliberately keeps this real session/new request in flight.
+  if (options.beforeSessionNewResponse) {
+    await options.beforeSessionNewResponse(sessionNewRequest);
+  }
+
   // The mode selector is what shows the session's modes arrived, and a collapsed ComboBox on Skia
   // mirrors no selection text at all - its value is only readable by opening the dropdown, which is
   // what this helper does. Waiting for the mode names in body text could never pass here.
diff --git a/scripts/gates/wasm-smoke-lib/browser-app.mjs b/scripts/gates/wasm-smoke-lib/browser-app.mjs
index 714a72a32..957fb70a9 100644
--- a/scripts/gates/wasm-smoke-lib/browser-app.mjs
+++ b/scripts/gates/wasm-smoke-lib/browser-app.mjs
@@ -311,6 +311,53 @@ const semanticRuntimeScript = `
     }
   };
 
+  // IDBFS writes reach the in-memory FS before syncfs commits them to IndexedDB. Read the
+  // existing mount's backing store without opening a database, flushing, or closing the app's
+  // connection: a reload gate must observe persistence, never perform it for the application.
+  // https://emscripten.org/docs/api_reference/Filesystem-API.html#filesystem-api-idbfs
+  const readPersistedLocalTextFile = async (filePath, timeoutMs) => {
+    const result = { path: filePath, content: null, error: null };
+    try {
+      const mount = globalThis.FS?.lookupPath(filePath)?.node?.mount;
+      const database = mount?.type?.dbs?.[mount.mountpoint];
+      const storeName = mount?.type?.DB_STORE_NAME;
+      if (!database || !storeName) {
+        result.error = "The persistent IDBFS database is not ready.";
+        return result;
+      }
+
+      result.content = await new Promise((resolve, reject) => {
+        const transaction = database.transaction(storeName, "readonly");
+        const request = transaction.objectStore(storeName).get(filePath);
+        const timer = setTimeout(() => {
+          try { transaction.abort(); } catch { /* The transaction may already have completed. */ }
+          reject(new Error("Timed out reading the persisted file from IndexedDB."));
+        }, timeoutMs);
+        transaction.oncomplete = () => {
+          clearTimeout(timer);
+          try {
+            const contents = request.result?.contents;
+            if (!contents) {
+              throw new Error("The file has not been persisted to IndexedDB.");
+            }
+
+            resolve(new TextDecoder("utf-8", { fatal: true }).decode(contents));
+          } catch (error) {
+            reject(error);
+          }
+        };
+        transaction.onabort = () => {
+          clearTimeout(timer);
+          reject(transaction.error ?? new Error("The persisted file read was aborted."));
+        };
+      });
+    } catch (error) {
+      result.error = error?.message ?? String(error);
+    }
+
+    return result;
+  };
+
   const persistenceDebug = input => {
     const element = matchNode(input.controlOptions);
     const editable = element ? findEditable(element) : null;
@@ -363,6 +410,7 @@ const semanticRuntimeScript = `
     focusControl,
     focusedSnapshot,
     readLocalTextFile,
+    readPersistedLocalTextFile,
     persistenceDebug,
     collectDebug: () => Array.from(semanticRoot()?.querySelectorAll("[id^='uno-semantics-']") ?? [])
       .map(describeNode)
diff --git a/scripts/gates/wasm-smoke-lib/ui-affordances.mjs b/scripts/gates/wasm-smoke-lib/ui-affordances.mjs
index 37972485d..42ea7e364 100644
--- a/scripts/gates/wasm-smoke-lib/ui-affordances.mjs
+++ b/scripts/gates/wasm-smoke-lib/ui-affordances.mjs
@@ -955,6 +955,27 @@ export async function readLocalTextFile(page, path) {
     path);
 }
 
+export async function waitForPersistedLocalFileContains(page, path, requiredSnippets, label, timeoutMs = defaultTimeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastResult = null;
+
+  while (Date.now() < deadline) {
+    lastResult = await page.evaluate(
+      input => window.__salmoneggSmoke.semantic.readPersistedLocalTextFile(input.path, input.timeoutMs),
+      { path, timeoutMs: Math.max(1, deadline - Date.now()) });
+    if (!lastResult.error && requiredSnippets.every(snippet => lastResult.content?.includes(snippet))) {
+      return lastResult.content;
+    }
+
+    await page.waitForTimeout(250);
+  }
+
+  throw new Error(
+    `${label} was not committed to IndexedDB before reload. Path=${path} `
+    + `Missing=${JSON.stringify(requiredSnippets.filter(snippet => !lastResult?.content?.includes(snippet)))} `
+    + `Read error=${lastResult?.error ?? "none"}`);
+}
+
 // ---- page-side callbacks (self-contained by contract; passed straight to page.evaluate) -------
 
 // The semantic DOM is the interactive set; these collectors are what the ACP fixture dumps on
diff --git a/src/SalmonEgg.Acp/Client/AcpClient.cs b/src/SalmonEgg.Acp/Client/AcpClient.cs
index 816beef74..d63faade0 100644
--- a/src/SalmonEgg.Acp/Client/AcpClient.cs
+++ b/src/SalmonEgg.Acp/Client/AcpClient.cs
@@ -51,6 +51,10 @@ public PendingInboundRequest(
 
             public CreateElicitationRequest? ElicitationRequest { get; }
 
+            public bool IsElicitationResponseInFlight { get; set; }
+
+            public bool IsElicitationCancellationRequested { get; set; }
+
             public PendingInboundRequest WithSessionId(string sessionId)
                 => new(Method, MessageId, sessionId, AskUserRequest, ElicitationRequest);
 
@@ -61,14 +65,6 @@ public PendingInboundRequest WithAskUserRequest(AskUserRequest request)
                     request.SessionId,
                     request,
                     ElicitationRequest);
-
-            public PendingInboundRequest WithElicitationRequest(CreateElicitationRequest request)
-                => new(
-                    string.IsNullOrWhiteSpace(Method) ? ElicitationMethods.Create : Method,
-                    MessageId,
-                    request.Scope.SessionId ?? SessionId,
-                    AskUserRequest,
-                    request);
         }
         private readonly IAcpTransport _transport;
         private readonly MessageParser _parser;
@@ -81,6 +77,9 @@ public PendingInboundRequest WithElicitationRequest(CreateElicitationRequest req
         private readonly ConcurrentDictionary<string, TaskCompletionSource<JsonRpcResponse>> _pendingRequests = new();
         // Inbound tool requests (agent -> client) are correlated by request id so we can format responses correctly.
         private readonly ConcurrentDictionary<string, PendingInboundRequest> _pendingInboundRequests = new();
+        // URL completion outlives the JSON-RPC response. Both indexes refer to the same request identity;
+        // the lock also protects response claims and connection teardown from stale callbacks.
+        private readonly Dictionary<string, PendingInboundRequest> _pendingUrlElicitations = new(StringComparer.Ordinal);
 
         private readonly object _lock = new();
         private bool _disposed;
@@ -97,7 +96,7 @@ public PendingInboundRequest WithElicitationRequest(CreateElicitationRequest req
 
         // Projection rather than a second field: a copy could drift from the contract actually in use,
         // and the two disagreeing is exactly the class of defect this refactor exists to remove.
-        private int _protocolVersion => _wire.Version;
+        private int ProtocolVersion => _wire.Version;
         private AgentInfo? _agentInfo;
         private AgentCapabilities? _agentCapabilities;
         private IReadOnlyList<AuthMethodDefinition>? _authMethods;
@@ -111,10 +110,10 @@ public PendingInboundRequest WithElicitationRequest(CreateElicitationRequest req
         private bool SupportsSessionAdditionalDirectories => _agentCapabilities?.SupportsSessionAdditionalDirectories == true;
         private bool SupportsAuthenticationSurface => _authMethods is { Count: > 0 };
         private bool SupportsAdvertisedTerminalExecution =>
-            _protocolVersion == AcpProtocolVersion.V1
+            ProtocolVersion == AcpProtocolVersion.V1
                 && _clientCapabilities?.Terminal == true;
         private bool SupportsLogout =>
-            _protocolVersion == AcpProtocolVersion.V2
+            ProtocolVersion == AcpProtocolVersion.V2
                 ? SupportsAuthenticationSurface
                 : _agentCapabilities?.SupportsLogout == true;
 
@@ -400,7 +399,7 @@ public async Task<SessionResumeResponse> ResumeSessionAsync(SessionResumeParams
         {
             EnsureInitialized();
             ArgumentNullException.ThrowIfNull(@params);
-            if (_protocolVersion == AcpProtocolVersion.V1 && @params.ReplayFrom is not null)
+            if (ProtocolVersion == AcpProtocolVersion.V1 && @params.ReplayFrom is not null)
             {
                 throw new AcpException(
                     JsonRpcErrorCode.InvalidParams,
@@ -772,7 +771,7 @@ public async Task<AuthenticateResponse> AuthenticateAsync(AuthenticateParams @pa
                     $"Authentication method '{@params.MethodId}' has type '{advertised.ResolvedType}', which must not be passed to authenticate");
             }
 
-            var methodName = _protocolVersion == AcpProtocolVersion.V2 ? "auth/login" : "authenticate";
+            var methodName = ProtocolVersion == AcpProtocolVersion.V2 ? "auth/login" : "authenticate";
 
             var request = new JsonRpcRequest(
                 Interlocked.Increment(ref _nextMessageId),
@@ -809,7 +808,7 @@ public async Task<LogoutResponse> LogoutAsync(LogoutParams @params, Cancellation
                     "Agent does not support logout capability");
             }
 
-            var methodName = _protocolVersion == AcpProtocolVersion.V2 ? "auth/logout" : "logout";
+            var methodName = ProtocolVersion == AcpProtocolVersion.V2 ? "auth/logout" : "logout";
 
             var request = new JsonRpcRequest(
                 Interlocked.Increment(ref _nextMessageId),
@@ -894,32 +893,126 @@ public async Task<bool> CancelElicitationRequestAsync(object messageId)
                 new ElicitationCancelResponse()).ConfigureAwait(false);
         }
 
-        private async Task<bool> TrySendElicitationResponseAsync(
+        private Task<bool> TrySendElicitationResponseAsync(
             object messageId,
             CreateElicitationResponse response)
         {
             var idStr = messageId?.ToString() ?? string.Empty;
-            if (string.IsNullOrWhiteSpace(idStr))
+            return TryGetPendingInboundRequest(idStr, out var pending)
+                ? TrySendElicitationResponseAsync(pending, response)
+                : Task.FromResult(false);
+        }
+
+        private async Task<bool> TrySendElicitationResponseAsync(
+            PendingInboundRequest pending,
+            CreateElicitationResponse response,
+            bool cancelForSession = false)
+        {
+            var idStr = pending.MessageId?.ToString() ?? string.Empty;
+            CancellationToken connectionCancellation;
+            lock (_lock)
             {
-                return false;
+                if (_disposed || !_transport.IsConnected || pending.ElicitationRequest is null
+                    || !TryGetPendingInboundRequest(idStr, out var current)
+                    || !ReferenceEquals(current, pending))
+                {
+                    return false;
+                }
+
+                if (cancelForSession)
+                {
+                    pending.IsElicitationCancellationRequested = true;
+                }
+
+                if (pending.IsElicitationResponseInFlight
+                    || (pending.IsElicitationCancellationRequested && response is not ElicitationCancelResponse))
+                {
+                    return false;
+                }
+
+                // Claim without removing: a failed send must remain retryable, while a second action
+                // cannot race the first one onto the wire. The callback owns this exact request object,
+                // so reusing its JSON-RPC id never lets an old form answer a later request.
+                pending.IsElicitationResponseInFlight = true;
+                connectionCancellation = _messageLoopCts?.Token ?? CancellationToken.None;
             }
 
-            // Taking the pending entry is what makes the three actions mutually exclusive: whichever one
-            // runs first removes the correlation, so a late second action cannot answer the same request
-            // twice.
-            if (!TryTakePendingInboundRequest(idStr, out var pending)
-                || pending.ElicitationRequest == null)
+            var sent = false;
+            try
+            {
+                sent = await SendResponseAsync(new JsonRpcResponse(
+                    pending.MessageId,
+                    ToElement<CreateElicitationResponse>(response)), connectionCancellation).ConfigureAwait(false);
+                return sent;
+            }
+            finally
             {
+                if (CompleteElicitationResponse(pending, response, sent))
+                {
+                    await SendPendingElicitationCancellationAsync(pending, connectionCancellation).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private bool CompleteElicitationResponse(PendingInboundRequest pending, CreateElicitationResponse response, bool sent)
+        {
+            var idStr = pending.MessageId?.ToString() ?? string.Empty;
+            lock (_lock)
+            {
+                if (sent)
+                {
+                    _pendingInboundRequests.TryRemove(new KeyValuePair<string, PendingInboundRequest>(idStr, pending));
+                    if (response is not ElicitationAcceptResponse)
+                    {
+                        RemovePendingUrlElicitation(pending);
+                    }
+                }
+                else if (pending.IsElicitationCancellationRequested && response is not ElicitationCancelResponse
+                    && !_disposed && _transport.IsConnected
+                    && TryGetPendingInboundRequest(idStr, out var current) && ReferenceEquals(current, pending))
+                {
+                    // Session cancellation must survive a failed in-flight answer. Keep the claim
+                    // for exactly one cancel send; another user action cannot overtake this intent.
+                    return true;
+                }
+
+                pending.IsElicitationResponseInFlight = false;
                 return false;
             }
+        }
+
+        private async Task SendPendingElicitationCancellationAsync(PendingInboundRequest pending, CancellationToken cancellationToken)
+        {
+            var response = new ElicitationCancelResponse();
+            var sent = false;
+            try
+            {
+                sent = await SendResponseAsync(new JsonRpcResponse(
+                    pending.MessageId,
+                    ToElement<CreateElicitationResponse>(response)), cancellationToken).ConfigureAwait(false);
+            }
+            finally
+            {
+                // A failed cancellation remains explicitly retryable; it never schedules another send.
+                CompleteElicitationResponse(pending, response, sent);
+            }
+        }
 
-            return await SendResponseAsync(
-                new JsonRpcResponse(
-                    messageId!,
-                    ToElement<CreateElicitationResponse>(response))).ConfigureAwait(false);
+        private void RemovePendingUrlElicitation(PendingInboundRequest pending)
+        {
+            if (pending.ElicitationRequest is UrlElicitationRequest url
+                && _pendingUrlElicitations.TryGetValue(url.ElicitationId, out var current)
+                && ReferenceEquals(current, pending))
+            {
+                _pendingUrlElicitations.Remove(url.ElicitationId);
+            }
         }
 
-        private async Task<bool> TrySendPermissionOutcomeResponseAsync(object? messageId, string outcome, string? optionId)
+        private async Task<bool> TrySendPermissionOutcomeResponseAsync(
+            object? messageId,
+            string outcome,
+            string? optionId,
+            PendingInboundRequest? expectedRequest = null)
         {
             if (messageId == null)
             {
@@ -929,8 +1022,15 @@ private async Task<bool> TrySendPermissionOutcomeResponseAsync(object? messageId
             // Only respond once per inbound request id. Unknown or stale ids are not a
             // protocol payload, so they should not fail ACP schema validation.
             var idStr = messageId.ToString() ?? string.Empty;
-            if (string.IsNullOrWhiteSpace(idStr)
-                || !TryTakePendingInboundRequest(idStr, out _))
+            if (string.IsNullOrWhiteSpace(idStr))
+            {
+                return false;
+            }
+
+            var claimed = expectedRequest is null
+                ? TryTakePendingInboundRequest(idStr, out _)
+                : _pendingInboundRequests.TryRemove(new KeyValuePair<string, PendingInboundRequest>(idStr, expectedRequest));
+            if (!claimed)
             {
                 return false;
             }
@@ -1030,7 +1130,7 @@ private async Task<bool> TrySendAskUserResponseAsync(object messageId, IReadOnly
         /// </summary>
         public async Task<bool> DisconnectAsync()
         {
-            _messageLoopCts?.Cancel();
+            ResetConnectionState();
             CancelPendingRequests();
 
             await _transport.DisconnectAsync();
@@ -1213,13 +1313,17 @@ private void CancelPendingRequests(string? transportErrorMessage = null)
         /// <summary>
         /// Sends a response (used to answer inbound requests).
         /// </summary>
-        private async Task<bool> SendResponseAsync(JsonRpcResponse response)
+        private async Task<bool> SendResponseAsync(JsonRpcResponse response, CancellationToken cancellationToken = default)
         {
             try
             {
+                cancellationToken.ThrowIfCancellationRequested();
                 var json = _parser.SerializeMessage(response);
-                await _transport.SendMessageAsync(json).ConfigureAwait(false);
-                return true;
+                return await _transport.SendMessageAsync(json, cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                return false;
             }
             catch (Exception ex)
             {
@@ -1401,11 +1505,6 @@ private void HandleRequest(JsonRpcRequest request)
                         break;
                     }
 
-                    if (!string.IsNullOrWhiteSpace(requestIdStr))
-                    {
-                        TrackPendingInboundRequest(requestIdStr, request.Method, request.Id);
-                    }
-
                     HandleElicitationRequest(request);
                     break;
                 case ClientCapabilityMetadata.AskUserExtensionMethod:
@@ -1432,7 +1531,7 @@ private void HandleRequest(JsonRpcRequest request)
         }
 
         private bool SupportsAdvertisedFileSystemCapability(string method)
-            => _protocolVersion == AcpProtocolVersion.V1
+            => ProtocolVersion == AcpProtocolVersion.V1
                 && (method switch
                 {
                     "fs/read_text_file" => _clientCapabilities?.Fs?.ReadTextFile == true,
@@ -1443,16 +1542,6 @@ private bool SupportsAdvertisedFileSystemCapability(string method)
         private bool SupportsAdvertisedAskUserExtension(string method)
             => _clientCapabilities?.SupportsExtension(method) == true;
 
-        /// <summary>
-        /// Whether the client advertised the elicitation mode the agent asked for.
-        /// </summary>
-        /// <remarks>
-        /// Unlike the fs and terminal gates, an un-advertised mode is answered with
-        /// <c>-32602 Invalid params</c> rather than <c>-32601</c>: the elicitation specification names that
-        /// code explicitly, because the method itself exists and only the requested mode is unavailable.
-        /// A request whose mode this client does not model at all is never advertised, so it lands here
-        /// too instead of being rendered as a known mode.
-        /// </remarks>
         /// <summary>
         /// Whether the client advertised elicitation at all.
         /// </summary>
@@ -1464,6 +1553,16 @@ private bool SupportsAdvertisedAskUserExtension(string method)
         /// </remarks>
         private bool SupportsAdvertisedElicitation => _clientCapabilities?.Elicitation is not null;
 
+        /// <summary>
+        /// Whether the client advertised the elicitation mode the agent asked for.
+        /// </summary>
+        /// <remarks>
+        /// Unlike the fs and terminal gates, an un-advertised mode is answered with
+        /// <c>-32602 Invalid params</c> rather than <c>-32601</c>: the elicitation specification names that
+        /// code explicitly, because the method itself exists and only the requested mode is unavailable.
+        /// A request whose mode this client does not model at all is never advertised, so it lands here
+        /// too instead of being rendered as a known mode.
+        /// </remarks>
         private bool SupportsAdvertisedElicitationMode(CreateElicitationRequest request)
             => request switch
             {
@@ -1793,16 +1892,11 @@ private void HandleAskUserRequest(JsonRpcRequest request)
         /// </summary>
         private void HandleElicitationRequest(JsonRpcRequest request)
         {
-            var requestIdStr = request.Id?.ToString() ?? string.Empty;
-
             try
             {
                 if (!request.Params.HasValue)
                 {
-                    RemovePendingInboundTracking(requestIdStr);
-                    _ = SendResponseAsync(new JsonRpcResponse(
-                        request.Id,
-                        JsonRpcError.CreateInvalidParams("Missing params")));
+                    FailPendingInboundRequest(request, JsonRpcError.CreateInvalidParams("Missing params"));
                     return;
                 }
 
@@ -1810,72 +1904,55 @@ private void HandleElicitationRequest(JsonRpcRequest request)
                     request.Params.Value);
                 if (elicitationRequest == null)
                 {
-                    RemovePendingInboundTracking(requestIdStr);
-                    _ = SendResponseAsync(new JsonRpcResponse(
-                        request.Id,
-                        JsonRpcError.CreateInvalidParams("Failed to deserialize elicitation/create request.")));
+                    FailPendingInboundRequest(request, JsonRpcError.CreateInvalidParams("Failed to deserialize elicitation/create request."));
                     return;
                 }
 
                 if (request.Id == null)
                 {
-                    RemovePendingInboundTracking(requestIdStr);
-                    _ = SendResponseAsync(new JsonRpcResponse(
-                        request.Id,
-                        JsonRpcError.CreateInvalidRequest("Missing request id")));
+                    _ = SendResponseAsync(new JsonRpcResponse(null, JsonRpcError.CreateInvalidRequest("Missing request id")));
                     return;
                 }
 
                 if (!SupportsAdvertisedElicitationMode(elicitationRequest))
                 {
-                    RemovePendingInboundTracking(requestIdStr);
-                    _ = SendResponseAsync(new JsonRpcResponse(
-                        request.Id,
+                    FailPendingInboundRequest(request,
                         JsonRpcError.CreateInvalidParams(
-                            $"Elicitation mode '{elicitationRequest.Mode}' was not advertised by the client.")));
+                            $"Elicitation mode '{elicitationRequest.Mode}' was not advertised by the client."));
                     return;
                 }
 
-                var messageId = request.Id!;
-                if (!string.IsNullOrWhiteSpace(requestIdStr))
+                var handler = ElicitationRequestReceived;
+                if (handler == null)
                 {
-                    SetPendingInboundElicitationRequest(requestIdStr, elicitationRequest);
+                    FailPendingInboundRequest(request,
+                        new JsonRpcError(JsonRpcErrorCode.CapabilityNotSupported, "Elicitation requests are not supported."));
+                    return;
                 }
 
-                if (ElicitationRequestReceived == null)
+                var pending = TrackInboundElicitationRequest(request.Id, elicitationRequest);
+                if (pending is null)
                 {
-                    RemovePendingInboundTracking(requestIdStr);
-                    _ = SendResponseAsync(new JsonRpcResponse(
-                        messageId,
-                        new JsonRpcError(
-                            JsonRpcErrorCode.CapabilityNotSupported,
-                            "Elicitation requests are not supported.")));
                     return;
                 }
 
                 var eventArgs = new ElicitationRequestEventArgs(
-                    messageId,
+                    request.Id,
                     elicitationRequest,
-                    content => RespondToElicitationRequestAsync(messageId, content),
-                    () => DeclineElicitationRequestAsync(messageId),
-                    () => CancelElicitationRequestAsync(messageId));
+                    content => TrySendElicitationResponseAsync(pending, new ElicitationAcceptResponse { Content = content?.ToWireContent() }),
+                    () => TrySendElicitationResponseAsync(pending, new ElicitationDeclineResponse()),
+                    () => TrySendElicitationResponseAsync(pending, new ElicitationCancelResponse()));
 
-                ElicitationRequestReceived.Invoke(this, eventArgs);
+                handler.Invoke(this, eventArgs);
             }
             catch (JsonException ex)
             {
-                RemovePendingInboundTracking(requestIdStr);
-                _ = SendResponseAsync(new JsonRpcResponse(
-                    request.Id,
-                    JsonRpcError.CreateInvalidParams(ex.Message)));
+                FailPendingInboundRequest(request, JsonRpcError.CreateInvalidParams(ex.Message));
             }
             catch (Exception ex)
             {
-                RemovePendingInboundTracking(requestIdStr);
                 OnErrorOccurred($"Failed to process elicitation/create request: {ex.Message}");
-                _ = SendResponseAsync(new JsonRpcResponse(
-                    request.Id,
-                    JsonRpcError.CreateInternalError(ex.Message)));
+                FailPendingInboundRequest(request, JsonRpcError.CreateInternalError(ex.Message));
             }
         }
 
@@ -1906,12 +1983,18 @@ private void HandleElicitationCompleted(JsonRpcNotification notification)
                 return;
             }
 
-            if (completion == null || string.IsNullOrWhiteSpace(completion.ElicitationId))
+            lock (_lock)
             {
-                return;
-            }
+                // IDs are opaque, and only outstanding URL interactions on this connection qualify.
+                // Removing before publication makes duplicate notifications harmless even on re-entry.
+                if (_disposed || !_transport.IsConnected || completion?.ElicitationId is not { } id
+                    || !_pendingUrlElicitations.Remove(id))
+                {
+                    return;
+                }
 
-            ElicitationCompleted?.Invoke(this, new ElicitationCompletedEventArgs(completion.ElicitationId));
+                ElicitationCompleted?.Invoke(this, new ElicitationCompletedEventArgs(id));
+            }
         }
 
         /// <summary>
@@ -2129,32 +2212,36 @@ private async Task CancelPendingInboundRequestsForSessionAsync(string sessionId)
                 return;
             }
 
-            var pendingIds = _pendingInboundRequests
+            // Each awaited send lets the peer finish and reuse other request ids. Cancellation
+            // belongs to these request instances, never to a later request with the same id.
+            var pendingRequests = _pendingInboundRequests
                 .Where(pair => string.Equals(pair.Value.SessionId, sessionId, StringComparison.Ordinal))
-                .Select(pair => pair.Key)
                 .ToArray();
 
-            foreach (var pendingId in pendingIds)
+            foreach (var (pendingId, pending) in pendingRequests)
             {
-                if (!TryGetPendingInboundRequest(pendingId, out var pending))
+                if (pending.ElicitationRequest is not null)
                 {
-                    RemovePendingInboundTracking(pendingId);
+                    await TrySendElicitationResponseAsync(pending, new ElicitationCancelResponse(), cancelForSession: true).ConfigureAwait(false);
                     continue;
                 }
 
-                if (pending.MessageId == null)
+                if (string.Equals(pending.Method, "session/request_permission", StringComparison.Ordinal))
                 {
-                    RemovePendingInboundTracking(pendingId);
+                    await TrySendPermissionOutcomeResponseAsync(pending.MessageId, "cancelled", null, pending).ConfigureAwait(false);
                     continue;
                 }
 
-                if (string.Equals(pending.Method, "session/request_permission", StringComparison.Ordinal))
+                if (!_pendingInboundRequests.TryRemove(new KeyValuePair<string, PendingInboundRequest>(pendingId, pending)))
+                {
+                    continue;
+                }
+
+                if (pending.MessageId == null)
                 {
-                    await TrySendPermissionOutcomeResponseAsync(pending.MessageId, "cancelled", null).ConfigureAwait(false);
                     continue;
                 }
 
-                RemovePendingInboundTracking(pendingId);
                 await SendResponseAsync(new JsonRpcResponse(
                     pending.MessageId,
                     new JsonRpcError(
@@ -2170,7 +2257,13 @@ private void RemovePendingInboundTracking(string idStr)
                 return;
             }
 
-            _pendingInboundRequests.TryRemove(idStr, out _);
+            lock (_lock)
+            {
+                if (_pendingInboundRequests.TryRemove(idStr, out var pending))
+                {
+                    RemovePendingUrlElicitation(pending);
+                }
+            }
         }
 
         private void FailPendingInboundRequest(JsonRpcRequest request, JsonRpcError error)
@@ -2233,22 +2326,31 @@ private void SetPendingInboundSessionId(string idStr, string sessionId)
             }
         }
 
-        private void SetPendingInboundElicitationRequest(string idStr, CreateElicitationRequest request)
+        private PendingInboundRequest? TrackInboundElicitationRequest(object messageId, CreateElicitationRequest request)
         {
-            if (string.IsNullOrWhiteSpace(idStr))
+            lock (_lock)
             {
-                return;
-            }
+                if (_disposed || !_transport.IsConnected)
+                {
+                    return null;
+                }
 
-            _pendingInboundRequests.AddOrUpdate(
-                idStr,
-                _ => new PendingInboundRequest(
+                var pending = new PendingInboundRequest(
                     ElicitationMethods.Create,
-                    null,
+                    messageId,
                     request.Scope.SessionId,
                     null,
-                    request),
-                (_, existing) => existing.WithElicitationRequest(request));
+                    request);
+                if (request is UrlElicitationRequest url && !_pendingUrlElicitations.TryAdd(url.ElicitationId, pending))
+                {
+                    _ = SendResponseAsync(new JsonRpcResponse(messageId,
+                        JsonRpcError.CreateInvalidParams("The elicitationId is already outstanding on this connection.")));
+                    return null;
+                }
+
+                _pendingInboundRequests[messageId.ToString() ?? string.Empty] = pending;
+                return pending;
+            }
         }
 
         private void SetPendingInboundAskUserRequest(string idStr, AskUserRequest request)
@@ -2296,12 +2398,12 @@ private void OnTransportError(object? sender, AcpTransportErrorEventArgs e)
                 return;
             }
 
-            var enrichedErrorMessage = EnrichTransportErrorMessage(e.ErrorMessage, e.Kind);
-            _lastTransportErrorMessage = enrichedErrorMessage;
-            OnErrorOccurred(enrichedErrorMessage);
+            _lastTransportErrorMessage = e.ErrorMessage;
+            OnErrorOccurred(e.ErrorMessage);
             if (!_transport.IsConnected)
             {
-                CancelPendingRequests(enrichedErrorMessage);
+                ResetConnectionState();
+                CancelPendingRequests(e.ErrorMessage);
             }
         }
 
@@ -2314,34 +2416,6 @@ private void OnErrorOccurred(string errorMessage)
             ErrorOccurred?.Invoke(this, errorMessage);
         }
 
-        private static string EnrichTransportErrorMessage(string errorMessage, AcpTransportErrorKind kind)
-        {
-            if (string.IsNullOrWhiteSpace(errorMessage))
-            {
-                return errorMessage;
-            }
-
-            if (!ShouldAppendStdioBridgeGuidance(errorMessage, kind))
-            {
-                return errorMessage;
-            }
-
-            const string sshBridgeGuidance =
-                " If this is an SSH stdio bridge, avoid ssh -t, ensure stdout emits only ACP frames, and prefer BatchMode=yes.";
-
-            return errorMessage.Contains("ssh -t", StringComparison.Ordinal)
-                ? errorMessage
-                : errorMessage + sshBridgeGuidance;
-        }
-
-        private static bool ShouldAppendStdioBridgeGuidance(string errorMessage, AcpTransportErrorKind kind)
-        {
-            return kind is AcpTransportErrorKind.ProcessStartFailed
-                    or AcpTransportErrorKind.ProcessExited
-                    or AcpTransportErrorKind.StdoutReadFailed
-                || errorMessage.Contains("stdout", StringComparison.OrdinalIgnoreCase);
-        }
-
         private void ClearLastTransportError()
         {
             _lastTransportErrorMessage = null;
@@ -2352,7 +2426,7 @@ private string CreateTransportConnectFailureMessage()
             var transportErrorMessage = _lastTransportErrorMessage;
             return string.IsNullOrWhiteSpace(transportErrorMessage)
                 ? "Failed to connect to the transport."
-                : "Failed to connect to the transport: " + transportErrorMessage;
+                : transportErrorMessage;
         }
 
         private string CreateTransportSendFailureMessage(string method)
@@ -2390,12 +2464,38 @@ private async Task MonitorTransportConnectionAsync(CancellationToken cancellatio
                 return;
             }
 
-            if (!cancellationToken.IsCancellationRequested)
+            lock (_lock)
             {
+                // A previous watchdog can finish after explicit disconnect and reinitialization.
+                // Only the token still owned by this connection may clear its request state.
+                if (cancellationToken.IsCancellationRequested || _messageLoopCts?.Token != cancellationToken)
+                {
+                    return;
+                }
+
+                ResetConnectionState();
                 CancelPendingRequests(_lastTransportErrorMessage ?? "The transport is no longer connected.");
             }
         }
 
+        private void ResetConnectionState()
+        {
+            lock (_lock)
+            {
+                _messageLoopCts?.Cancel();
+                _messageLoopCts?.Dispose();
+                _messageLoopCts = null;
+                _pendingInboundRequests.Clear();
+                _pendingUrlElicitations.Clear();
+                _clientCapabilities = null;
+                _agentInfo = null;
+                _agentCapabilities = null;
+                _authMethods = null;
+                _wire = AcpWireFormat.For(AcpProtocolVersion.Default);
+                _isInitialized = false;
+            }
+        }
+
         /// <summary>
         /// Ensures the client has been initialized.
         /// </summary>
@@ -2511,7 +2611,7 @@ public void Dispose()
             }
 
             _disposed = true;
-            _messageLoopCts?.Cancel();
+            ResetConnectionState();
 
             // Detach the transport events first so callbacks during teardown cannot re-enter disposed
             // handlers, then fault every pending request. Otherwise callers awaiting tcs.Task would hang
diff --git a/src/SalmonEgg.Application/Services/Acp/ITransportErrorMessageFormatter.cs b/src/SalmonEgg.Application/Services/Acp/ITransportErrorMessageFormatter.cs
new file mode 100644
index 000000000..c84d748fa
--- /dev/null
+++ b/src/SalmonEgg.Application/Services/Acp/ITransportErrorMessageFormatter.cs
@@ -0,0 +1,11 @@
+using SalmonEgg.Domain.Interfaces.Transport;
+
+namespace SalmonEgg.Application.Services.Acp;
+
+/// <summary>
+/// Lets a host present transport failures before the SDK's string-only error boundary.
+/// </summary>
+public interface ITransportErrorMessageFormatter
+{
+    string Format(TransportErrorEventArgs error);
+}
diff --git a/src/SalmonEgg.Domain/Interfaces/Transport/ITransport.cs b/src/SalmonEgg.Domain/Interfaces/Transport/ITransport.cs
index 0cbf83cae..c9164de57 100644
--- a/src/SalmonEgg.Domain/Interfaces/Transport/ITransport.cs
+++ b/src/SalmonEgg.Domain/Interfaces/Transport/ITransport.cs
@@ -126,6 +126,8 @@ public class TransportErrorEventArgs : EventArgs
 
         public TransportErrorKind Kind { get; set; } = TransportErrorKind.General;
 
+        public StdioCommandResolutionFailure? CommandResolutionFailure { get; init; }
+
         /// <summary>
         /// 创建新的传输错误事件参数。
         /// </summary>
diff --git a/src/SalmonEgg.Domain/Interfaces/Transport/StdioCommandResolutionFailure.cs b/src/SalmonEgg.Domain/Interfaces/Transport/StdioCommandResolutionFailure.cs
new file mode 100644
index 000000000..88ee672fc
--- /dev/null
+++ b/src/SalmonEgg.Domain/Interfaces/Transport/StdioCommandResolutionFailure.cs
@@ -0,0 +1,6 @@
+namespace SalmonEgg.Domain.Interfaces.Transport;
+
+/// <summary>
+/// Facts from the launcher's command resolution, retained independently of diagnostic wording.
+/// </summary>
+public sealed record StdioCommandResolutionFailure(string Command, bool SearchedOnPath);
diff --git a/src/SalmonEgg.Infrastructure.Desktop/Services/CliCommandProbeEnvironment.cs b/src/SalmonEgg.Infrastructure.Desktop/Services/CliCommandProbeEnvironment.cs
index 7f7a9e3f9..80a411196 100644
--- a/src/SalmonEgg.Infrastructure.Desktop/Services/CliCommandProbeEnvironment.cs
+++ b/src/SalmonEgg.Infrastructure.Desktop/Services/CliCommandProbeEnvironment.cs
@@ -103,46 +103,28 @@ public sealed class SystemCliCommandProbeEnvironment : ICliCommandProbeEnvironme
 
     public async Task<CliVersionProbe> ProbeVersionAsync(string executablePath, CancellationToken cancellationToken)
     {
-        var startInfo = new ProcessStartInfo(executablePath)
-        {
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
-            UseShellExecute = false,
-            CreateNoWindow = true,
-        };
+        var startInfo = new ProcessStartInfo(executablePath);
         startInfo.ArgumentList.Add("--version");
 
         try
         {
-            using var process = Process.Start(startInfo);
-            if (process is null)
+            var result = await CliCommandProcessRunner.RunAsync(startInfo, ProbeTimeout, cancellationToken).ConfigureAwait(false);
+            if (result is null)
             {
                 return CliVersionProbe.Failure("the operating system did not start the process");
             }
 
-            using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-            timeout.CancelAfter(ProbeTimeout);
-
-            var stdoutTask = process.StandardOutput.ReadToEndAsync(timeout.Token);
-            try
-            {
-                await process.WaitForExitAsync(timeout.Token).ConfigureAwait(false);
-            }
-            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            if (result.TimedOut)
             {
-                // The whole tree: the single-file host extracts to a temporary directory and can leave a
-                // child behind, and a probe must not outlive its own timeout.
-                TryKill(process);
                 return CliVersionProbe.Failure($"the command did not exit within {ProbeTimeout.TotalSeconds:0} seconds");
             }
 
-            var stdout = await stdoutTask.ConfigureAwait(false);
-            if (process.ExitCode != 0)
+            if (result.ExitCode != 0)
             {
-                return CliVersionProbe.Failure($"the command exited with code {process.ExitCode}");
+                return CliVersionProbe.Failure($"the command exited with code {result.ExitCode}");
             }
 
-            var version = stdout.Trim();
+            var version = result.StandardOutput.Trim();
             return string.IsNullOrEmpty(version)
                 ? CliVersionProbe.Failure("the command printed no version")
                 : CliVersionProbe.Success(version);
@@ -152,17 +134,4 @@ public async Task<CliVersionProbe> ProbeVersionAsync(string executablePath, Canc
             return CliVersionProbe.Failure(ex.Message);
         }
     }
-
-    private static void TryKill(Process process)
-    {
-        try
-        {
-            process.Kill(entireProcessTree: true);
-        }
-        catch (Exception ex) when (ex is InvalidOperationException or System.ComponentModel.Win32Exception or NotSupportedException)
-        {
-            // It exited on its own between the timeout and here, or the platform refused. Either way the
-            // probe's answer is already decided.
-        }
-    }
 }
diff --git a/src/SalmonEgg.Infrastructure.Desktop/Services/CliCommandProcessRunner.cs b/src/SalmonEgg.Infrastructure.Desktop/Services/CliCommandProcessRunner.cs
new file mode 100644
index 000000000..ae4dfa1ca
--- /dev/null
+++ b/src/SalmonEgg.Infrastructure.Desktop/Services/CliCommandProcessRunner.cs
@@ -0,0 +1,159 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.ExceptionServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SalmonEgg.Infrastructure.Desktop.Services;
+
+internal sealed record CliCommandProcessResult(int ExitCode, string StandardOutput, string StandardError, bool TimedOut);
+
+internal static class CliCommandProcessRunner
+{
+    internal const int MaxCapturedCharacters = 64 * 1024;
+
+    private static readonly TimeSpan TerminationTimeout = TimeSpan.FromSeconds(5);
+
+    public static Task<CliCommandProcessResult?> RunAsync(
+        ProcessStartInfo startInfo,
+        TimeSpan timeout,
+        CancellationToken cancellationToken)
+        => RunAsync(startInfo, timeout, cancellationToken, TerminateAndReapAsync);
+
+    internal static async Task<CliCommandProcessResult?> RunAsync(
+        ProcessStartInfo startInfo,
+        TimeSpan timeout,
+        CancellationToken cancellationToken,
+        Func<Process, Task> terminateAndReapAsync)
+    {
+        ArgumentNullException.ThrowIfNull(startInfo);
+        ArgumentNullException.ThrowIfNull(terminateAndReapAsync);
+        cancellationToken.ThrowIfCancellationRequested();
+        startInfo.RedirectStandardOutput = true;
+        startInfo.RedirectStandardError = true;
+        startInfo.UseShellExecute = false;
+        startInfo.CreateNoWindow = true;
+
+        using var deadline = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        deadline.CancelAfter(timeout);
+        using var process = Process.Start(startInfo);
+        if (process is null)
+        {
+            return null;
+        }
+
+        using var readers = new CancellationTokenSource();
+        var stdout = CaptureTailAsync(process.StandardOutput, readers.Token);
+        var stderr = CaptureTailAsync(process.StandardError, readers.Token);
+        var output = Task.WhenAll(stdout, stderr);
+        var timedOut = false;
+        try
+        {
+            await process.WaitForExitAsync(deadline.Token).ConfigureAwait(false);
+            await output.WaitAsync(deadline.Token).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) when (deadline.IsCancellationRequested)
+        {
+            timedOut = true;
+        }
+        finally
+        {
+            await CleanupAsync(process, readers, output, terminateAndReapAsync, cancellationToken).ConfigureAwait(false);
+        }
+
+        cancellationToken.ThrowIfCancellationRequested();
+        return new(process.ExitCode, await stdout.ConfigureAwait(false), await stderr.ConfigureAwait(false), timedOut);
+    }
+
+    private static async Task CleanupAsync(
+        Process process,
+        CancellationTokenSource readers,
+        Task output,
+        Func<Process, Task> terminateAndReapAsync,
+        CancellationToken cancellationToken)
+    {
+        Exception? failure = null;
+        try
+        {
+            await terminateAndReapAsync(process).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            failure = ex;
+        }
+
+        try
+        {
+            // Even a refused kill must release and observe both readers. Process.Dispose only releases
+            // handles; it does not own these tasks or any child the OS has already reparented.
+            await Task.WhenAll(readers.CancelAsync(), output).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            failure = failure is null ? ex : new AggregateException(failure, ex);
+        }
+
+        if (failure is not null)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                throw new OperationCanceledException("The command was cancelled, but process cleanup failed.", failure, cancellationToken);
+            }
+
+            ExceptionDispatchInfo.Capture(failure).Throw();
+        }
+    }
+
+    private static async Task TerminateAndReapAsync(Process process)
+    {
+        try
+        {
+            if (!process.HasExited)
+            {
+                process.Kill(entireProcessTree: true);
+            }
+        }
+        catch (Exception ex) when ((ex is InvalidOperationException or Win32Exception) && process.HasExited)
+        {
+            // The command exited between the inspection and the kill.
+        }
+
+        using var deadline = new CancellationTokenSource(TerminationTimeout);
+        try
+        {
+            // Process.Dispose releases handles; it neither terminates nor waits for the OS process.
+            await process.WaitForExitAsync(deadline.Token).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException ex)
+        {
+            throw new IOException("The command did not exit after termination was requested.", ex);
+        }
+    }
+
+    private static async Task<string> CaptureTailAsync(StreamReader reader, CancellationToken cancellationToken)
+    {
+        var tail = new StringBuilder();
+        var buffer = new char[4096];
+        try
+        {
+            int count;
+            while ((count = await reader.ReadAsync(buffer.AsMemory(), cancellationToken).ConfigureAwait(false)) > 0)
+            {
+                tail.Append(buffer, 0, count);
+                if (tail.Length > MaxCapturedCharacters)
+                {
+                    tail.Remove(0, tail.Length - MaxCapturedCharacters);
+                }
+            }
+        }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            // Cancellation still preserves bounded diagnostics already emitted by the child.
+        }
+
+        return tail.ToString();
+    }
+}
diff --git a/src/SalmonEgg.Infrastructure.Desktop/Services/MacOsCliCommandLinkService.cs b/src/SalmonEgg.Infrastructure.Desktop/Services/MacOsCliCommandLinkService.cs
index 130da0357..8a023653c 100644
--- a/src/SalmonEgg.Infrastructure.Desktop/Services/MacOsCliCommandLinkService.cs
+++ b/src/SalmonEgg.Infrastructure.Desktop/Services/MacOsCliCommandLinkService.cs
@@ -151,42 +151,33 @@ private static CliCommandLinkResult Translate(PrivilegedShellResult result, CliC
             _ => CliCommandLinkResult.Failed(result.Detail ?? "the authorized command failed"),
         };
 
-    private static async Task<PrivilegedShellResult> RunOsaScriptAsync(string shellCommand, CancellationToken cancellationToken)
+    private static Task<PrivilegedShellResult> RunOsaScriptAsync(string shellCommand, CancellationToken cancellationToken)
     {
-        var startInfo = new ProcessStartInfo("/usr/bin/osascript")
-        {
-            RedirectStandardOutput = true,
-            RedirectStandardError = true,
-            UseShellExecute = false,
-            CreateNoWindow = true,
-        };
+        var startInfo = new ProcessStartInfo("/usr/bin/osascript");
         startInfo.ArgumentList.Add("-e");
         startInfo.ArgumentList.Add(MacOsPrivilegedShellScript.BuildOsaScriptStatement(shellCommand));
+        return RunAuthorizationProcessAsync(startInfo, AuthorizationTimeout, cancellationToken);
+    }
 
+    internal static async Task<PrivilegedShellResult> RunAuthorizationProcessAsync(
+        ProcessStartInfo startInfo,
+        TimeSpan timeout,
+        CancellationToken cancellationToken)
+    {
         try
         {
-            using var process = Process.Start(startInfo);
-            if (process is null)
+            var result = await CliCommandProcessRunner.RunAsync(startInfo, timeout, cancellationToken).ConfigureAwait(false);
+            if (result is null)
             {
                 return PrivilegedShellResult.Failed("the operating system did not start osascript");
             }
 
-            using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-            timeout.CancelAfter(AuthorizationTimeout);
-
-            var stderrTask = process.StandardError.ReadToEndAsync(timeout.Token);
-            try
-            {
-                await process.WaitForExitAsync(timeout.Token).ConfigureAwait(false);
-            }
-            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
+            if (result.TimedOut)
             {
-                TryKill(process);
                 return PrivilegedShellResult.Failed("the authorization prompt was not answered in time");
             }
 
-            var stderr = await stderrTask.ConfigureAwait(false);
-            if (process.ExitCode == 0)
+            if (result.ExitCode == 0)
             {
                 return PrivilegedShellResult.Succeeded();
             }
@@ -194,27 +185,17 @@ private static async Task<PrivilegedShellResult> RunOsaScriptAsync(string shellC
             // osascript reports a dismissed authorization dialog as AppleScript error -128, the same code
             // any user cancellation produces. Treating it as a failure would show an error for a deliberate
             // choice, so it is matched on the code rather than on the localized message text.
-            return stderr.Contains("-128", StringComparison.Ordinal)
+            return result.StandardError.Contains("-128", StringComparison.Ordinal)
                 ? PrivilegedShellResult.Cancelled()
-                : PrivilegedShellResult.Failed(string.IsNullOrWhiteSpace(stderr) ? $"osascript exited with {process.ExitCode}" : stderr.Trim());
+                : PrivilegedShellResult.Failed(string.IsNullOrWhiteSpace(result.StandardError)
+                    ? $"osascript exited with {result.ExitCode}"
+                    : result.StandardError.Trim());
         }
         catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or InvalidOperationException or IOException)
         {
             return PrivilegedShellResult.Failed(ex.Message);
         }
     }
-
-    private static void TryKill(Process process)
-    {
-        try
-        {
-            process.Kill(entireProcessTree: true);
-        }
-        catch (Exception ex) when (ex is InvalidOperationException or System.ComponentModel.Win32Exception or NotSupportedException)
-        {
-            // Already gone, or the platform refused. The outcome is decided either way.
-        }
-    }
 }
 
 /// <summary>How an authorized shell command ended.</summary>
diff --git a/src/SalmonEgg.Infrastructure.Desktop/Transport/StdioCommandPreflight.cs b/src/SalmonEgg.Infrastructure.Desktop/Transport/StdioCommandPreflight.cs
index 554ae5d4d..6735f7536 100644
--- a/src/SalmonEgg.Infrastructure.Desktop/Transport/StdioCommandPreflight.cs
+++ b/src/SalmonEgg.Infrastructure.Desktop/Transport/StdioCommandPreflight.cs
@@ -1,5 +1,4 @@
-using System;
-using System.IO;
+using SalmonEgg.Domain.Interfaces.Transport;
 
 namespace SalmonEgg.Infrastructure.Transport;
 
@@ -12,7 +11,7 @@ namespace SalmonEgg.Infrastructure.Transport;
 internal static class StdioCommandPreflight
 {
     /// <summary>
-    /// Returns an actionable error message when the invocation's resolved command does not name an
+    /// Returns an actionable error when the invocation's resolved command does not name an
     /// existing file, or null when the command is startable as resolved. Pure — the existence verdict
     /// was made by <see cref="StdioCommandResolver"/> at resolution time; nothing is probed here.
     /// </summary>
@@ -21,15 +20,21 @@ internal static class StdioCommandPreflight
     /// <see cref="LauncherInvocation.FileName"/>: a batch launcher is wrapped in <c>cmd.exe</c>, which
     /// always exists, so the underlying command is the only thing worth judging.
     /// </remarks>
-    public static string? BuildMissingCommandError(LauncherInvocation invocation)
+    public static TransportErrorEventArgs? BuildMissingCommandError(LauncherInvocation invocation)
     {
         if (invocation.ResolvedToExistingFile)
         {
             return null;
         }
 
-        return invocation.SearchedOnPath
+        var fallbackMessage = invocation.SearchedOnPath
             ? $"Agent command '{invocation.ResolvedCommand}' was not found on PATH. Install the agent or configure the full path to its executable."
             : $"The configured agent command '{invocation.ResolvedCommand}' does not exist. Check the path in the agent configuration.";
+        return new TransportErrorEventArgs(fallbackMessage, kind: TransportErrorKind.ProcessStartFailed)
+        {
+            CommandResolutionFailure = new StdioCommandResolutionFailure(
+                invocation.ResolvedCommand,
+                invocation.SearchedOnPath)
+        };
     }
 }
diff --git a/src/SalmonEgg.Infrastructure.Desktop/Transport/StdioTransport.cs b/src/SalmonEgg.Infrastructure.Desktop/Transport/StdioTransport.cs
index 1d78864f6..c911ed75b 100644
--- a/src/SalmonEgg.Infrastructure.Desktop/Transport/StdioTransport.cs
+++ b/src/SalmonEgg.Infrastructure.Desktop/Transport/StdioTransport.cs
@@ -146,7 +146,7 @@ public async Task<bool> ConnectAsync(CancellationToken cancellationToken = defau
                         "Agent command not found during preflight. Command={Command} SearchedDirectories={SearchedDirectories}",
                         _invocation.ResolvedCommand,
                         _invocation.SearchedDirectories);
-                    OnErrorOccurred(new TransportErrorEventArgs(preflightError, kind: TransportErrorKind.ProcessStartFailed));
+                    OnErrorOccurred(preflightError);
                     return false;
                 }
 
diff --git a/src/SalmonEgg.Infrastructure/Client/AcpClientFactory.cs b/src/SalmonEgg.Infrastructure/Client/AcpClientFactory.cs
index aa4e5a9f8..0323fcd83 100644
--- a/src/SalmonEgg.Infrastructure/Client/AcpClientFactory.cs
+++ b/src/SalmonEgg.Infrastructure/Client/AcpClientFactory.cs
@@ -11,20 +11,25 @@ public sealed class AcpClientFactory : IAcpClientFactory
     private readonly IErrorLogger _errorLogger;
     private readonly ISessionManager _sessionManager;
     private readonly ITerminalSessionManager _terminalSessionManager;
+    private readonly ITransportErrorMessageFormatter? _transportErrorMessageFormatter;
 
     public AcpClientFactory(
         IErrorLogger errorLogger,
         ISessionManager sessionManager,
-        ITerminalSessionManager terminalSessionManager)
+        ITerminalSessionManager terminalSessionManager,
+        ITransportErrorMessageFormatter? transportErrorMessageFormatter = null)
     {
         _errorLogger = errorLogger ?? throw new ArgumentNullException(nameof(errorLogger));
         _sessionManager = sessionManager ?? throw new ArgumentNullException(nameof(sessionManager));
         _terminalSessionManager = terminalSessionManager ?? throw new ArgumentNullException(nameof(terminalSessionManager));
+        _transportErrorMessageFormatter = transportErrorMessageFormatter;
     }
 
     public IAcpClient CreateClient(ITransport transport)
         => new SalmonEgg.Acp.Client.AcpClient(
-            new DomainAcpTransportAdapter(transport ?? throw new ArgumentNullException(nameof(transport))),
+            new DomainAcpTransportAdapter(
+                transport ?? throw new ArgumentNullException(nameof(transport)),
+                _transportErrorMessageFormatter),
             new DomainAcpClientLogger(_errorLogger),
             new DomainAcpClientSessionStore(_sessionManager),
             _terminalSessionManager);
diff --git a/src/SalmonEgg.Infrastructure/Client/DomainAcpClientAdapters.cs b/src/SalmonEgg.Infrastructure/Client/DomainAcpClientAdapters.cs
index 7c3b867bc..1b247292b 100644
--- a/src/SalmonEgg.Infrastructure/Client/DomainAcpClientAdapters.cs
+++ b/src/SalmonEgg.Infrastructure/Client/DomainAcpClientAdapters.cs
@@ -2,6 +2,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using SalmonEgg.Acp.Client;
+using SalmonEgg.Application.Services.Acp;
 using SalmonEgg.Domain.Interfaces.Transport;
 using SalmonEgg.Domain.Services;
 using SalmonEgg.Infrastructure.Logging;
@@ -11,11 +12,13 @@ namespace SalmonEgg.Infrastructure.Client;
 internal sealed class DomainAcpTransportAdapter : IAcpTransport
 {
     private readonly ITransport _inner;
+    private readonly ITransportErrorMessageFormatter? _messageFormatter;
     private bool _disposed;
 
-    public DomainAcpTransportAdapter(ITransport inner)
+    public DomainAcpTransportAdapter(ITransport inner, ITransportErrorMessageFormatter? messageFormatter = null)
     {
         _inner = inner ?? throw new ArgumentNullException(nameof(inner));
+        _messageFormatter = messageFormatter;
         _inner.MessageReceived += OnMessageReceived;
         _inner.ErrorOccurred += OnErrorOccurred;
     }
@@ -62,7 +65,7 @@ private void OnErrorOccurred(object? sender, TransportErrorEventArgs e)
         ErrorOccurred?.Invoke(
             this,
             new AcpTransportErrorEventArgs(
-                e.ErrorMessage,
+                _messageFormatter?.Format(e) ?? e.ErrorMessage,
                 e.Exception,
                 MapErrorKind(e.Kind)));
     }
diff --git a/src/SalmonEgg.Presentation.Core/Localization/TransportErrorMessageFormatter.cs b/src/SalmonEgg.Presentation.Core/Localization/TransportErrorMessageFormatter.cs
new file mode 100644
index 000000000..e1cf23a96
--- /dev/null
+++ b/src/SalmonEgg.Presentation.Core/Localization/TransportErrorMessageFormatter.cs
@@ -0,0 +1,36 @@
+using Microsoft.Extensions.Localization;
+using SalmonEgg.Application.Services.Acp;
+using SalmonEgg.Domain.Interfaces.Transport;
+using SalmonEgg.Presentation.Core.Resources;
+
+namespace SalmonEgg.Presentation.Core.Localization;
+
+public sealed class TransportErrorMessageFormatter : ITransportErrorMessageFormatter
+{
+    public const string CommandNotFoundOnPathResourceKey = "AcpConnection_CommandNotFoundOnPath";
+    public const string CommandPathMissingResourceKey = "AcpConnection_CommandPathMissing";
+
+    private readonly IStringLocalizer<CoreStrings> _localizer;
+
+    public TransportErrorMessageFormatter(IStringLocalizer<CoreStrings> localizer)
+    {
+        _localizer = localizer ?? throw new ArgumentNullException(nameof(localizer));
+    }
+
+    public string Format(TransportErrorEventArgs error)
+    {
+        ArgumentNullException.ThrowIfNull(error);
+        if (error.CommandResolutionFailure is not { } failure)
+        {
+            return error.ErrorMessage;
+        }
+
+        var resourceKey = failure.SearchedOnPath
+            ? CommandNotFoundOnPathResourceKey
+            : CommandPathMissingResourceKey;
+        // The original diagnostic already contains the command. It is not a format string: paths
+        // may contain braces, so only the resource template is formatted before falling back.
+        var message = CoreStringResolver.ResolveFormat(_localizer, resourceKey, string.Empty, failure.Command);
+        return string.IsNullOrWhiteSpace(message) ? error.ErrorMessage : message;
+    }
+}
diff --git a/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.en-US.resx b/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.en-US.resx
index b5e421be7..390c5be79 100644
--- a/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.en-US.resx
+++ b/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.en-US.resx
@@ -837,6 +837,12 @@ Create the corresponding Markdown file in:
   <data name="AcpConnection_TransportStdio" xml:space="preserve">
     <value>Stdio (subprocess)</value>
   </data>
+  <data name="AcpConnection_CommandNotFoundOnPath" xml:space="preserve">
+    <value>Agent command '{0}' was not found on PATH. Install the agent or configure the full path to its executable.</value>
+  </data>
+  <data name="AcpConnection_CommandPathMissing" xml:space="preserve">
+    <value>The configured agent command '{0}' does not exist. Check the path in the agent configuration.</value>
+  </data>
   <data name="AcpConnection_TransportWebSocket" xml:space="preserve">
     <value>WebSocket</value>
   </data>
@@ -1307,6 +1313,9 @@ Create the corresponding Markdown file in:
   <data name="Elicitation_InvalidValue" xml:space="preserve">
     <value>This value is not valid.</value>
   </data>
+  <data name="Elicitation_UnsupportedRequiredFields" xml:space="preserve">
+    <value>This form contains required fields that cannot be displayed. Decline or cancel the request.</value>
+  </data>
   <data name="SettingsSection_CommandLine" xml:space="preserve">
     <value>Command line</value>
   </data>
diff --git a/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.en.resx b/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.en.resx
index e9746da5d..02fa7a634 100644
--- a/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.en.resx
+++ b/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.en.resx
@@ -837,6 +837,12 @@ Create the corresponding Markdown file in:
   <data name="AcpConnection_TransportStdio" xml:space="preserve">
     <value>Stdio (subprocess)</value>
   </data>
+  <data name="AcpConnection_CommandNotFoundOnPath" xml:space="preserve">
+    <value>Agent command '{0}' was not found on PATH. Install the agent or configure the full path to its executable.</value>
+  </data>
+  <data name="AcpConnection_CommandPathMissing" xml:space="preserve">
+    <value>The configured agent command '{0}' does not exist. Check the path in the agent configuration.</value>
+  </data>
   <data name="AcpConnection_TransportWebSocket" xml:space="preserve">
     <value>WebSocket</value>
   </data>
@@ -1307,6 +1313,9 @@ Create the corresponding Markdown file in:
   <data name="Elicitation_InvalidValue" xml:space="preserve">
     <value>This value is not valid.</value>
   </data>
+  <data name="Elicitation_UnsupportedRequiredFields" xml:space="preserve">
+    <value>This form contains required fields that cannot be displayed. Decline or cancel the request.</value>
+  </data>
   <data name="SettingsSection_CommandLine" xml:space="preserve">
     <value>Command line</value>
   </data>
diff --git a/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.resx b/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.resx
index c70ab4b01..7a056274b 100644
--- a/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.resx
+++ b/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.resx
@@ -843,6 +843,12 @@
   <data name="AcpConnection_TransportStdio" xml:space="preserve">
     <value>Stdio（子进程）</value>
   </data>
+  <data name="AcpConnection_CommandNotFoundOnPath" xml:space="preserve">
+    <value>Agent command '{0}' was not found on PATH. Install the agent or configure the full path to its executable.</value>
+  </data>
+  <data name="AcpConnection_CommandPathMissing" xml:space="preserve">
+    <value>The configured agent command '{0}' does not exist. Check the path in the agent configuration.</value>
+  </data>
   <data name="AcpConnection_TransportWebSocket" xml:space="preserve">
     <value>WebSocket</value>
   </data>
@@ -1313,6 +1319,9 @@
   <data name="Elicitation_InvalidValue" xml:space="preserve">
     <value>This value is not valid.</value>
   </data>
+  <data name="Elicitation_UnsupportedRequiredFields" xml:space="preserve">
+    <value>This form contains required fields that cannot be displayed. Decline or cancel the request.</value>
+  </data>
   <data name="SettingsSection_CommandLine" xml:space="preserve">
     <value>Command line</value>
   </data>
diff --git a/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.zh-Hans.resx b/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.zh-Hans.resx
index 0b1dc129f..1261a54b4 100644
--- a/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.zh-Hans.resx
+++ b/src/SalmonEgg.Presentation.Core/Resources/CoreStrings.zh-Hans.resx
@@ -843,6 +843,12 @@
   <data name="AcpConnection_TransportStdio" xml:space="preserve">
     <value>Stdio（子进程）</value>
   </data>
+  <data name="AcpConnection_CommandNotFoundOnPath" xml:space="preserve">
+    <value>在 PATH 中找不到 Agent 命令“{0}”。请安装该 Agent，或在配置中填写可执行文件的完整路径。</value>
+  </data>
+  <data name="AcpConnection_CommandPathMissing" xml:space="preserve">
+    <value>配置的 Agent 命令“{0}”不存在。请检查 Agent 配置中的路径。</value>
+  </data>
   <data name="AcpConnection_TransportWebSocket" xml:space="preserve">
     <value>WebSocket</value>
   </data>
@@ -1313,6 +1319,9 @@
   <data name="Elicitation_InvalidValue" xml:space="preserve">
     <value>这个值无效。</value>
   </data>
+  <data name="Elicitation_UnsupportedRequiredFields" xml:space="preserve">
+    <value>此表单包含暂不支持的必填项。请选择拒绝或取消。</value>
+  </data>
   <data name="SettingsSection_CommandLine" xml:space="preserve">
     <value>命令行工具</value>
   </data>
diff --git a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatAuthenticationCoordinator.cs b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatAuthenticationCoordinator.cs
index f2174688e..69d009bc1 100644
--- a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatAuthenticationCoordinator.cs
+++ b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatAuthenticationCoordinator.cs
@@ -155,6 +155,14 @@ await chatService
             ClearAuthenticationRequirement(coordinator);
             return true;
         }
+        catch (OperationCanceledException)
+        {
+            return false;
+        }
+        catch (Exception ex) when (AcpErrorClassifier.IsRequestCancelled(ex))
+        {
+            return false;
+        }
         catch (AcpException ex) when (ex.ErrorCode == JsonRpcErrorCode.MethodNotFound)
         {
             MarkAuthenticationRequired(
diff --git a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.AcpSessionLifecycle.cs b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.AcpSessionLifecycle.cs
index 4305e71e2..463d64ae1 100644
--- a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.AcpSessionLifecycle.cs
+++ b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.AcpSessionLifecycle.cs
@@ -1769,37 +1769,52 @@ private void OnElicitationRequestReceived(object? sender, ElicitationRequestEven
 
     private async Task ProcessElicitationRequestAsync(ElicitationRequestEventArgs e)
     {
+        var foregroundServiceGeneration = Volatile.Read(ref _foregroundChatServiceGeneration);
         try
         {
             var projection = await _interactionEventBridge.BuildElicitationRequestAsync(
                 e,
-                conversationId => PostToUiAsync(() => RemovePendingElicitationRequestState(conversationId)),
+                (conversationId, request) => PostToUiAsync(() => RemovePendingElicitationRequestState(conversationId, request)),
                 Logger).ConfigureAwait(false);
             if (projection is null)
             {
                 return;
             }
 
+            var displayed = false;
             await PostToUiAsync(() =>
             {
-                _panelStateCoordinator.StoreElicitationRequest(projection.Value.ConversationId, projection.Value.ViewModel);
+                // Routing and dispatcher work may finish after the foreground owner was replaced.
+                // A stale form must not occupy the new connection's only interaction slot.
+                if (_disposed || foregroundServiceGeneration != Volatile.Read(ref _foregroundChatServiceGeneration))
+                {
+                    return;
+                }
+
+                displayed = _panelStateCoordinator.TryStoreElicitationRequest(projection.Value.ConversationId, projection.Value.ViewModel);
                 PendingElicitationRequest = _panelStateCoordinator.GetPendingElicitationRequest(CurrentSessionId);
             }).ConfigureAwait(true);
+            if (!displayed)
+            {
+                // This surface holds one form per conversation. Keep the visible request and cancel
+                // the unshown one instead of replacing an interaction the user still needs to answer.
+                await ChatInteractionEventBridge.CancelUndisplayedElicitationAsync(e, Logger).ConfigureAwait(false);
+            }
         }
         catch (Exception ex)
         {
             Logger.LogError(ex, "Error processing elicitation request");
+            await ChatInteractionEventBridge.CancelUndisplayedElicitationAsync(e, Logger).ConfigureAwait(false);
         }
     }
 
-    private void RemovePendingElicitationRequestState(string conversationId)
+    private void RemovePendingElicitationRequestState(string conversationId, ElicitationRequestViewModel request)
     {
-        if (string.IsNullOrWhiteSpace(conversationId))
+        if (!_panelStateCoordinator.RemoveElicitationRequest(conversationId, request))
         {
             return;
         }
 
-        _panelStateCoordinator.RemoveElicitationRequest(conversationId);
         if (string.Equals(CurrentSessionId, conversationId, StringComparison.Ordinal))
         {
             PendingElicitationRequest = _panelStateCoordinator.GetPendingElicitationRequest(conversationId);
diff --git a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.CommandWorkflow.cs b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.CommandWorkflow.cs
index e75ff8ac7..f2bfa6c0b 100644
--- a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.CommandWorkflow.cs
+++ b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.CommandWorkflow.cs
@@ -1749,6 +1749,8 @@ partial void OnPendingElicitationRequestChanged(ElicitationRequestViewModel? val
         _observedPendingElicitationRequest = value;
         if (_observedPendingElicitationRequest != null)
         {
+            // A background conversation may retain a form across a language change.
+            _observedPendingElicitationRequest.ReprojectLocalizedState();
             _observedPendingElicitationRequest.PropertyChanged += OnPendingElicitationRequestPropertyChanged;
         }
 
diff --git a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.cs b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.cs
index 2620ac675..3dbb86e0f 100644
--- a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.cs
+++ b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/ChatViewModel.cs
@@ -1732,6 +1732,7 @@ private async void OnLanguageChanged(object? sender, EventArgs e)
             NotifyComposerProjectionChanged();
             RaiseOverlayStateChanged();
             PendingAskUserRequest?.ReprojectLocalizedState();
+            PendingElicitationRequest?.ReprojectLocalizedState();
             ReprojectConversationOperationFailureMessage();
             // SessionActivationFailureMessage re-localizes from snapshot resource identity on get.
             NotifySessionActivationFailureProjectionChanged();
diff --git a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Elicitation/ElicitationInteractionViewModels.cs b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Elicitation/ElicitationInteractionViewModels.cs
index 40ada2d26..55ccd2b23 100644
--- a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Elicitation/ElicitationInteractionViewModels.cs
+++ b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Elicitation/ElicitationInteractionViewModels.cs
@@ -17,6 +17,7 @@ namespace SalmonEgg.Presentation.ViewModels.Chat.Elicitation;
 public sealed partial class ElicitationRequestViewModel : ObservableObject
 {
     private readonly IStringLocalizer<CoreStrings>? _localizer;
+    private readonly bool _hasUnsupportedRequiredFields;
     private string? _errorResourceKey;
 
     public ElicitationRequestViewModel(
@@ -24,18 +25,25 @@ public ElicitationRequestViewModel(
         string? sessionId,
         string prompt,
         IEnumerable<ElicitationFieldViewModel> fields,
-        IStringLocalizer<CoreStrings>? localizer = null)
+        IStringLocalizer<CoreStrings>? localizer = null,
+        bool hasUnsupportedRequiredFields = false)
     {
         MessageId = messageId ?? throw new ArgumentNullException(nameof(messageId));
         SessionId = sessionId;
         Prompt = prompt ?? string.Empty;
         _localizer = localizer;
+        _hasUnsupportedRequiredFields = hasUnsupportedRequiredFields;
 
         foreach (var field in fields)
         {
             field.Changed += OnFieldChanged;
             Fields.Add(field);
         }
+
+        if (_hasUnsupportedRequiredFields)
+        {
+            SetUnsupportedRequiredFieldsError();
+        }
     }
 
     public object MessageId { get; }
@@ -62,7 +70,7 @@ public ElicitationRequestViewModel(
 
     public bool HasError => !string.IsNullOrWhiteSpace(ErrorMessage);
 
-    public bool CanSubmit => !IsSubmitting && ValidateFields();
+    public bool CanSubmit => !IsSubmitting && !_hasUnsupportedRequiredFields && ValidateFields();
 
     [RelayCommand(CanExecute = nameof(CanSubmit))]
     private async Task SubmitAsync()
@@ -75,7 +83,14 @@ private async Task SubmitAsync()
 
         if (!ValidateFields())
         {
-            SetLocalizedError("Elicitation_InvalidForm", "Check the highlighted fields before submitting.");
+            if (_hasUnsupportedRequiredFields)
+            {
+                SetUnsupportedRequiredFieldsError();
+            }
+            else
+            {
+                SetLocalizedError("Elicitation_InvalidForm", "Check the highlighted fields before submitting.");
+            }
             return;
         }
 
@@ -155,6 +170,11 @@ private async Task RespondAsync(Func<Task<bool>> respond)
 
     private bool ValidateFields()
     {
+        if (_hasUnsupportedRequiredFields)
+        {
+            return false;
+        }
+
         var valid = true;
         foreach (var field in Fields)
         {
@@ -167,6 +187,10 @@ private bool ValidateFields()
     private void OnFieldChanged(object? sender, EventArgs e)
     {
         ClearError();
+        if (_hasUnsupportedRequiredFields)
+        {
+            SetUnsupportedRequiredFieldsError();
+        }
         OnPropertyChanged(nameof(CanSubmit));
         SubmitCommand.NotifyCanExecuteChanged();
     }
@@ -177,6 +201,10 @@ private void SetLocalizedError(string resourceKey, string fallback)
         ErrorMessage = Localize(resourceKey, fallback);
     }
 
+    private void SetUnsupportedRequiredFieldsError()
+        => SetLocalizedError("Elicitation_UnsupportedRequiredFields",
+            "This form contains required fields that cannot be displayed. Decline or cancel the request.");
+
     private void SetRawError(string message)
     {
         _errorResourceKey = null;
@@ -263,6 +291,10 @@ public virtual bool BooleanValue
 
     public virtual void ReprojectLocalizedState()
     {
+        if (HasError)
+        {
+            Validate();
+        }
     }
 
     protected void RaiseChanged()
@@ -669,7 +701,7 @@ public static class ElicitationInteractionViewModelFactory
 {
     public static ElicitationRequestViewModel Create(
         ElicitationRequestEventArgs args,
-        Func<Task> clearPendingRequestAsync,
+        Func<ElicitationRequestViewModel, Task> clearPendingRequestAsync,
         IStringLocalizer<CoreStrings>? localizer = null)
     {
         ArgumentNullException.ThrowIfNull(args);
@@ -688,10 +720,14 @@ public static ElicitationRequestViewModel Create(
             }
         }
 
-        var viewModel = new ElicitationRequestViewModel(args.MessageId, args.SessionId, args.Request.Message, fields, localizer);
-        viewModel.OnAccept = async content => await RespondAndClearAsync(() => args.Accept(content), clearPendingRequestAsync).ConfigureAwait(true);
-        viewModel.OnDecline = async () => await RespondAndClearAsync(args.Decline, clearPendingRequestAsync).ConfigureAwait(true);
-        viewModel.OnCancel = async () => await RespondAndClearAsync(args.Cancel, clearPendingRequestAsync).ConfigureAwait(true);
+        // Preserve unknown schemas in the SDK, but never submit a form missing a required input.
+        // A required name absent from properties is equally unrenderable; optional unknowns may be omitted.
+        var hasUnsupportedRequiredFields = required.Except(fields.Select(static field => field.Name), StringComparer.Ordinal).Any();
+        var viewModel = new ElicitationRequestViewModel(args.MessageId, args.SessionId, args.Request.Message,
+            fields, localizer, hasUnsupportedRequiredFields);
+        viewModel.OnAccept = async content => await RespondAndClearAsync(() => args.Accept(content), () => clearPendingRequestAsync(viewModel)).ConfigureAwait(true);
+        viewModel.OnDecline = async () => await RespondAndClearAsync(args.Decline, () => clearPendingRequestAsync(viewModel)).ConfigureAwait(true);
+        viewModel.OnCancel = async () => await RespondAndClearAsync(args.Cancel, () => clearPendingRequestAsync(viewModel)).ConfigureAwait(true);
         return viewModel;
     }
 
diff --git a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Interactions/ChatInteractionEventBridge.cs b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Interactions/ChatInteractionEventBridge.cs
index d1720ec97..58b6b824e 100644
--- a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Interactions/ChatInteractionEventBridge.cs
+++ b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Interactions/ChatInteractionEventBridge.cs
@@ -79,7 +79,7 @@ public FileSystemRequestViewModel CreateFileSystemRequestViewModel(
 
     public async Task<(string ConversationId, ElicitationRequestViewModel ViewModel)?> BuildElicitationRequestAsync(
         ElicitationRequestEventArgs args,
-        Func<string, Task> clearPendingRequestAsync,
+        Func<string, ElicitationRequestViewModel, Task> clearPendingRequestAsync,
         ILogger logger)
     {
         ArgumentNullException.ThrowIfNull(args);
@@ -89,19 +89,32 @@ public FileSystemRequestViewModel CreateFileSystemRequestViewModel(
         if (args.Request is not FormElicitationRequest || string.IsNullOrWhiteSpace(args.SessionId))
         {
             logger.LogWarning(
-                "Elicitation request ignored because it is not a session-scoped form. Mode={ElicitationMode}",
+                "Elicitation request cannot be displayed because it is not a session-scoped form. Mode={ElicitationMode}",
                 args.Request.Mode);
+            await CancelUndisplayedElicitationAsync(args, logger).ConfigureAwait(false);
+            return null;
+        }
+
+        string? conversationId;
+        try
+        {
+            conversationId = await _authoritativeRemoteSessionRouter
+                .ResolveConversationIdAsync(args.SessionId)
+                .ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Elicitation request could not be routed to its conversation");
+            await CancelUndisplayedElicitationAsync(args, logger).ConfigureAwait(false);
             return null;
         }
 
-        var conversationId = await _authoritativeRemoteSessionRouter
-            .ResolveConversationIdAsync(args.SessionId)
-            .ConfigureAwait(false);
         if (string.IsNullOrWhiteSpace(conversationId))
         {
             logger.LogWarning(
-                "Elicitation request ignored because no bound conversation matched remote session {RemoteSessionId}",
+                "Elicitation request cannot be displayed because no bound conversation matched remote session {RemoteSessionId}",
                 args.SessionId);
+            await CancelUndisplayedElicitationAsync(args, logger).ConfigureAwait(false);
             return null;
         }
 
@@ -109,10 +122,27 @@ public FileSystemRequestViewModel CreateFileSystemRequestViewModel(
             conversationId,
             ElicitationInteractionViewModelFactory.Create(
                 args,
-                () => clearPendingRequestAsync(conversationId),
+                viewModel => clearPendingRequestAsync(conversationId, viewModel),
                 _localizer));
     }
 
+    internal static async Task CancelUndisplayedElicitationAsync(ElicitationRequestEventArgs args, ILogger logger)
+    {
+        // Request scope is valid ACP. This conversation surface cannot present it, so dismiss it
+        // explicitly instead of inventing a session or leaving the peer waiting for user input.
+        try
+        {
+            if (!await args.Cancel().ConfigureAwait(false))
+            {
+                logger.LogWarning("Could not send cancellation for undisplayed elicitation request {MessageId}", args.MessageId);
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Could not cancel undisplayed elicitation request {MessageId}", args.MessageId);
+        }
+    }
+
     public async Task<(string ConversationId, ChatConversationPanelSelection Selection)?> BuildTerminalRequestSelectionAsync(
         TerminalRequestEventArgs args,
         ChatConversationPanelStateCoordinator panelStateCoordinator,
diff --git a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Panels/ChatConversationPanelStateCoordinator.cs b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Panels/ChatConversationPanelStateCoordinator.cs
index deeaeba4b..f20a08f04 100644
--- a/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Panels/ChatConversationPanelStateCoordinator.cs
+++ b/src/SalmonEgg.Presentation.Core/ViewModels/Chat/Panels/ChatConversationPanelStateCoordinator.cs
@@ -77,21 +77,24 @@ public void ClearAskUserRequests()
             : null;
     }
 
-    public void StoreElicitationRequest(string conversationId, ElicitationRequestViewModel request)
+    public bool TryStoreElicitationRequest(string conversationId, ElicitationRequestViewModel request)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(conversationId);
         ArgumentNullException.ThrowIfNull(request);
-        _pendingElicitationRequestsByConversation[conversationId] = request;
+        return _pendingElicitationRequestsByConversation.TryAdd(conversationId, request);
     }
 
-    public void RemoveElicitationRequest(string conversationId)
+    public bool RemoveElicitationRequest(string conversationId, ElicitationRequestViewModel request)
     {
-        if (string.IsNullOrWhiteSpace(conversationId))
+        // A response can finish after disconnect and another form's arrival, even with the same id.
+        // Only its original projection may be removed by that response callback.
+        if (string.IsNullOrWhiteSpace(conversationId)
+            || !ReferenceEquals(GetPendingElicitationRequest(conversationId), request))
         {
-            return;
+            return false;
         }
 
-        _pendingElicitationRequestsByConversation.Remove(conversationId);
+        return _pendingElicitationRequestsByConversation.Remove(conversationId);
     }
 
     public void ClearElicitationRequests()
diff --git a/tests/SalmonEgg.Acp.Tests/Client/AcpClientElicitationTests.cs b/tests/SalmonEgg.Acp.Tests/Client/AcpClientElicitationTests.cs
index 2566b8d3f..1dce5883e 100644
--- a/tests/SalmonEgg.Acp.Tests/Client/AcpClientElicitationTests.cs
+++ b/tests/SalmonEgg.Acp.Tests/Client/AcpClientElicitationTests.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
@@ -58,7 +60,7 @@ public AcpClientElicitationTests()
     public async Task ElicitationCreate_WhenFormAdvertised_DeliversRequestAndSendsAcceptedContent()
     {
         var parser = new MessageParser();
-        var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
+        using var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
         var sentMessages = CaptureSentMessages();
         ElicitationRequestEventArgs? published = null;
 
@@ -100,7 +102,7 @@ public async Task ElicitationCreate_WhenFormAdvertised_DeliversRequestAndSendsAc
     public async Task ElicitationCreate_DeclineAndCancel_SendOmitContent(bool decline)
     {
         var parser = new MessageParser();
-        var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
+        using var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
         var sentMessages = CaptureSentMessages();
 
         client.ElicitationRequestReceived += async (_, args) =>
@@ -127,7 +129,7 @@ public async Task ElicitationCreate_DeclineAndCancel_SendOmitContent(bool declin
     public async Task ElicitationCreate_SecondResponseAttempt_IsRejectedSoOneRequestGetsOneAnswer()
     {
         var parser = new MessageParser();
-        var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
+        using var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
         var sentMessages = CaptureSentMessages();
         var firstSucceeded = false;
         var secondSucceeded = true;
@@ -149,7 +151,7 @@ public async Task ElicitationCreate_SecondResponseAttempt_IsRejectedSoOneRequest
     public async Task ElicitationCreate_WhenElicitationNotAdvertised_ReturnsMethodNotFound()
     {
         var parser = new MessageParser();
-        var client = await CreateInitializedClientAsync(new ClientCapabilities());
+        using var client = await CreateInitializedClientAsync(new ClientCapabilities());
         var sentMessages = CaptureSentMessages();
         var delivered = false;
         client.ElicitationRequestReceived += (_, _) => delivered = true;
@@ -168,7 +170,7 @@ public async Task ElicitationCreate_WhenModeNotAdvertised_ReturnsInvalidParams()
         var parser = new MessageParser();
         // Form is advertised, URL is not: the family exists, so the refusal is a mode-level -32602 rather
         // than -32601, exactly as the elicitation spec prescribes.
-        var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
+        using var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
         var sentMessages = CaptureSentMessages();
         var delivered = false;
         client.ElicitationRequestReceived += (_, _) => delivered = true;
@@ -188,7 +190,7 @@ public async Task ElicitationCreate_WhenModeNotAdvertised_ReturnsInvalidParams()
     public async Task ElicitationCreate_WithUnknownMode_IsNeverDeliveredAsAKnownMode(string mode)
     {
         var parser = new MessageParser();
-        var client = await CreateInitializedClientAsync(
+        using var client = await CreateInitializedClientAsync(
             new ClientCapabilities
             {
                 Elicitation = new ElicitationCapabilities
@@ -219,7 +221,7 @@ public async Task ElicitationCreate_WithUnknownMode_IsNeverDeliveredAsAKnownMode
     public async Task ElicitationCreate_WhenNoHandlerSubscribed_ReturnsCapabilityNotSupported()
     {
         var parser = new MessageParser();
-        var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
+        using var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
         var sentMessages = CaptureSentMessages();
 
         RaiseRequest(parser, 307, ElicitationMethods.Create, FormParamsJson);
@@ -230,10 +232,10 @@ public async Task ElicitationCreate_WhenNoHandlerSubscribed_ReturnsCapabilityNot
     }
 
     [Fact]
-    public async Task ElicitationComplete_RaisesCompletionForKnownIdAndIgnoresMalformedPayload()
+    public async Task ElicitationComplete_UnknownOrMalformedIds_DoNotRaiseCompletion()
     {
         var parser = new MessageParser();
-        var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
         var completions = new List<string>();
         client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
 
@@ -241,8 +243,608 @@ public async Task ElicitationComplete_RaisesCompletionForKnownIdAndIgnoresMalfor
         RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":""}""");
         RaiseNotification(parser, ElicitationMethods.Complete, """{}""");
 
-        await WaitUntilAsync(() => completions.Count >= 1);
+        Assert.Empty(completions);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ElicitationComplete_KnownUrlBeforeSuccessfulReply_RecordsExternalCompletionOnce(bool failedReply)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = CaptureSentMessages();
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+        var request = ReceiveRequest(client, parser, 317, UrlParamsJson);
+        if (failedReply)
+        {
+            _transportMock
+                .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(false);
+            Assert.False(await request.Accept(null));
+            sentMessages = CaptureSentMessages();
+        }
+
+        // Completion is the peer's external fact, not consent to navigate. Correlate the known URL
+        // even before its JSON-RPC reply succeeds, while leaving the user's response independent.
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        Assert.Equal(["oauth-1"], completions);
+        Assert.Empty(sentMessages);
+        Assert.True(await request.Cancel());
+        var response = await WaitForResponseAsync(parser, sentMessages, 317);
+        Assert.Equal("""{"action":"cancel"}""", response.Result!.Value.GetRawText());
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ElicitationComplete_AcceptedUrl_RaisesOnceEvenWhenCompletionRacesResponse(bool completeDuringSend)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = CaptureSentMessages();
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+        var request = ReceiveRequest(client, parser, 308, UrlParamsJson);
+        if (completeDuringSend)
+        {
+            _transportMock
+                .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .Callback<string, CancellationToken>((message, _) =>
+                {
+                    sentMessages.Enqueue(message);
+                    RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+                })
+                .ReturnsAsync(true);
+        }
+
+        Assert.True(await request.Accept(null));
+        var response = await WaitForResponseAsync(parser, sentMessages, 308);
+        Assert.Equal("""{"action":"accept"}""", response.Result!.Value.GetRawText());
+        if (!completeDuringSend)
+        {
+            Assert.Empty(completions);
+        }
+
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+
         Assert.Equal(["oauth-1"], completions);
+        Assert.False(await request.Cancel());
+        Assert.Empty(sentMessages);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task ElicitationComplete_DeclinedOrCancelledUrl_DoesNotRaiseCompletion(bool decline)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = CaptureSentMessages();
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+        var request = ReceiveRequest(client, parser, 309, UrlParamsJson);
+
+        Assert.True(await (decline ? request.Decline() : request.Cancel()));
+        var response = await WaitForResponseAsync(parser, sentMessages, 309);
+        Assert.Equal(decline ? """{"action":"decline"}""" : """{"action":"cancel"}""", response.Result!.Value.GetRawText());
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+
+        Assert.Empty(completions);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ElicitationComplete_RejectedUrl_DoesNotRaiseCompletion(bool advertiseUrl)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(advertiseUrl ? UrlCapabilities() : ClientCapabilityDefaults.Create());
+        var sentMessages = CaptureSentMessages();
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+
+        RaiseRequest(parser, 310, ElicitationMethods.Create, UrlParamsJson);
+        var response = await WaitForResponseAsync(parser, sentMessages, 310);
+        Assert.Equal(advertiseUrl ? JsonRpcErrorCode.CapabilityNotSupported : JsonRpcErrorCode.InvalidParams, response.Error!.Code);
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+
+        Assert.Empty(completions);
+    }
+
+    [Theory]
+    [InlineData(false, false)]
+    [InlineData(false, true)]
+    [InlineData(true, false)]
+    [InlineData(true, true)]
+    public async Task ElicitationResponse_WhenSendingFails_AllowsRetryWithoutAnsweringTwice(bool url, bool throws)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = new ConcurrentQueue<string>();
+        var attempts = 0;
+        _transportMock
+            .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Returns<string, CancellationToken>((message, _) =>
+            {
+                if (++attempts == 1)
+                {
+                    return throws ? Task.FromException<bool>(new IOException("Response write failed.")) : Task.FromResult(false);
+                }
+
+                sentMessages.Enqueue(message);
+                return Task.FromResult(true);
+            });
+        var request = ReceiveRequest(client, parser, 311, url ? UrlParamsJson : FormParamsJson);
+
+        Assert.False(await request.Accept(null));
+        Assert.Empty(sentMessages);
+        Assert.True(await request.Accept(null));
+        var response = await WaitForResponseAsync(parser, sentMessages, 311);
+        Assert.Equal("""{"action":"accept"}""", response.Result!.Value.GetRawText());
+        Assert.False(await request.Decline());
+        Assert.Equal(2, attempts);
+    }
+
+    [Fact]
+    public async Task ElicitationResponse_ConcurrentActions_SendOnlyOneResponse()
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = new ConcurrentQueue<string>();
+        var sendResult = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        _transportMock
+            .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Callback<string, CancellationToken>((message, _) => sentMessages.Enqueue(message))
+            .Returns(sendResult.Task);
+        var request = ReceiveRequest(client, parser, 312, UrlParamsJson);
+        var accepted = request.Accept(null);
+
+        try
+        {
+            Assert.False(await request.Cancel());
+            Assert.Single(sentMessages);
+        }
+        finally
+        {
+            sendResult.TrySetResult(true);
+        }
+
+        Assert.True(await accepted);
+        var response = await WaitForResponseAsync(parser, sentMessages, 312);
+        Assert.Equal("""{"action":"accept"}""", response.Result!.Value.GetRawText());
+        Assert.Empty(sentMessages);
+    }
+
+    [Fact]
+    public async Task ElicitationResponse_SessionCancelledWhileAcceptIsSending_DoesNotSendASecondResponse()
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = new ConcurrentQueue<string>();
+        var sendResult = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        _transportMock
+            .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Returns<string, CancellationToken>((message, _) =>
+            {
+                sentMessages.Enqueue(message);
+                return parser.ParseMessage(message) is JsonRpcResponse response
+                    && response.Result?.GetProperty("action").GetString() == ElicitationActions.Accept
+                        ? sendResult.Task
+                        : Task.FromResult(true);
+            });
+        var request = ReceiveRequest(client, parser, 323, FormParamsJson);
+        var accept = request.Accept(null);
+
+        try
+        {
+            await client.CancelSessionAsync(new SessionCancelParams("session-1"), TestContext.Current.CancellationToken);
+            var messages = sentMessages.Select(parser.ParseMessage).ToArray();
+            var response = Assert.Single(messages.OfType<JsonRpcResponse>());
+            Assert.Equal("""{"action":"accept"}""", response.Result!.Value.GetRawText());
+            Assert.Equal("session/cancel", Assert.Single(messages.OfType<JsonRpcNotification>()).Method);
+        }
+        finally
+        {
+            sendResult.TrySetResult(true);
+        }
+
+        Assert.True(await accept);
+        Assert.False(await request.Cancel());
+        Assert.Equal(2, sentMessages.Count);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ElicitationResponse_SessionCancelledWhileAcceptFails_SendsCancellationOnce(bool throws)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = new ConcurrentQueue<string>();
+        var sendResult = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var acceptAttempts = 0;
+        _transportMock
+            .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Returns<string, CancellationToken>((message, _) =>
+            {
+                if (parser.ParseMessage(message) is JsonRpcResponse response
+                    && response.Result?.GetProperty("action").GetString() == ElicitationActions.Accept)
+                {
+                    acceptAttempts++;
+                    return sendResult.Task;
+                }
+
+                sentMessages.Enqueue(message);
+                return Task.FromResult(true);
+            });
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+        var request = ReceiveRequest(client, parser, 325,
+            UrlParamsJson.Replace("\"requestId\": 12", "\"sessionId\": \"session-1\"", StringComparison.Ordinal));
+        var accept = request.Accept(null);
+
+        try
+        {
+            await client.CancelSessionAsync(new SessionCancelParams("session-1"), TestContext.Current.CancellationToken);
+            Assert.Empty(sentMessages.Select(parser.ParseMessage).OfType<JsonRpcResponse>());
+        }
+        finally
+        {
+            if (throws)
+            {
+                sendResult.TrySetException(new IOException("Response write failed."));
+            }
+            else
+            {
+                sendResult.TrySetResult(false);
+            }
+        }
+
+        Assert.False(await accept);
+        var messages = sentMessages.Select(parser.ParseMessage).ToArray();
+        Assert.Equal("session/cancel", Assert.Single(messages.OfType<JsonRpcNotification>()).Method);
+        var cancelled = Assert.Single(messages.OfType<JsonRpcResponse>());
+        Assert.Equal("""{"action":"cancel"}""", cancelled.Result!.Value.GetRawText());
+        Assert.False(await request.Accept(null));
+        Assert.False(await request.Cancel());
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        Assert.Empty(completions);
+        Assert.Equal(1, acceptAttempts);
+        Assert.Equal(2, sentMessages.Count);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ElicitationResponse_SessionCancellationSendFails_RequiresExplicitCancelRetry(bool throws)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = new ConcurrentQueue<string>();
+        var sendResult = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var acceptAttempts = 0;
+        var cancelAttempts = 0;
+        _transportMock
+            .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Returns<string, CancellationToken>((message, _) =>
+            {
+                if (parser.ParseMessage(message) is JsonRpcResponse response)
+                {
+                    if (response.Result?.GetProperty("action").GetString() == ElicitationActions.Accept)
+                    {
+                        acceptAttempts++;
+                        return sendResult.Task;
+                    }
+
+                    if (++cancelAttempts == 1)
+                    {
+                        return throws ? Task.FromException<bool>(new IOException("Cancellation write failed.")) : Task.FromResult(false);
+                    }
+                }
+
+                sentMessages.Enqueue(message);
+                return Task.FromResult(true);
+            });
+        var request = ReceiveRequest(client, parser, 326, FormParamsJson);
+        var accept = request.Accept(null);
+
+        try
+        {
+            await client.CancelSessionAsync(new SessionCancelParams("session-1"), TestContext.Current.CancellationToken);
+        }
+        finally
+        {
+            sendResult.TrySetResult(false);
+        }
+
+        Assert.False(await accept);
+        Assert.Equal(1, cancelAttempts);
+        Assert.Empty(sentMessages.Select(parser.ParseMessage).OfType<JsonRpcResponse>());
+        Assert.False(await request.Accept(null));
+        Assert.False(await request.Decline());
+        Assert.Equal(1, acceptAttempts);
+        Assert.Equal(1, cancelAttempts);
+
+        Assert.True(await request.Cancel());
+        var cancelled = Assert.Single(sentMessages.Select(parser.ParseMessage).OfType<JsonRpcResponse>());
+        Assert.Equal("""{"action":"cancel"}""", cancelled.Result!.Value.GetRawText());
+        Assert.False(await request.Cancel());
+        Assert.Equal(2, cancelAttempts);
+    }
+
+    [Fact]
+    public async Task CancelSessionAsync_WhenAnotherSessionReusesPendingMessageId_DoesNotCancelNewRequest()
+    {
+        // Arrange: whichever request the dictionary visits first holds the cancellation loop.
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(ClientCapabilityDefaults.Create());
+        var sentMessages = new ConcurrentQueue<string>();
+        var firstCancellation = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var releaseCancellation = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        _transportMock
+            .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Returns<string, CancellationToken>((message, cancellationToken) =>
+            {
+                sentMessages.Enqueue(message);
+                if (parser.ParseMessage(message) is JsonRpcResponse response
+                    && response.Result?.GetProperty("action").GetString() == ElicitationActions.Cancel
+                    && firstCancellation.TrySetResult(response.Id!.ToString()!))
+                {
+                    return releaseCancellation.Task.WaitAsync(cancellationToken);
+                }
+
+                return Task.FromResult(true);
+            });
+        var first = ReceiveRequest(client, parser, 327, FormParamsJson);
+        var second = ReceiveRequest(client, parser, 328, FormParamsJson);
+        var cancellation = client.CancelSessionAsync(new SessionCancelParams("session-1"), TestContext.Current.CancellationToken);
+
+        try
+        {
+            // Act: finish the other request and reuse its ID on a different session before resuming.
+            var cancellingId = await firstCancellation.Task.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+            var previous = cancellingId == first.MessageId.ToString() ? second : first;
+            var reusedId = ReferenceEquals(previous, first) ? 327L : 328L;
+            Assert.True(await previous.Accept(null));
+            var current = ReceiveRequest(client, parser, reusedId,
+                FormParamsJson.Replace("\"session-1\"", "\"session-2\"", StringComparison.Ordinal));
+            releaseCancellation.TrySetResult(true);
+            await cancellation.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+
+            // Assert on serialized responses before the new request receives any user action.
+            var response = Assert.Single(sentMessages.Select(parser.ParseMessage).OfType<JsonRpcResponse>(),
+                message => message.Id?.ToString() == previous.MessageId.ToString());
+            Assert.Equal("""{"action":"accept"}""", response.Result!.Value.GetRawText());
+            Assert.True(await current.Accept(null));
+            var reusedResponses = sentMessages.Select(parser.ParseMessage).OfType<JsonRpcResponse>()
+                .Where(message => message.Id?.ToString() == previous.MessageId.ToString()).ToArray();
+            Assert.Equal(2, reusedResponses.Length);
+            Assert.All(reusedResponses, message => Assert.Equal("""{"action":"accept"}""", message.Result!.Value.GetRawText()));
+            Assert.Equal(4, sentMessages.Count);
+        }
+        finally
+        {
+            releaseCancellation.TrySetResult(true);
+            await cancellation.WaitAsync(TimeSpan.FromSeconds(5), CancellationToken.None);
+        }
+    }
+
+    [Fact]
+    public async Task ElicitationResponse_SessionCancelledBeforeResponse_SendsCancelAndDropsUrlCompletion()
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = CaptureSentMessages();
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+        var request = ReceiveRequest(client, parser, 324,
+            UrlParamsJson.Replace("\"requestId\": 12", "\"sessionId\": \"session-1\"", StringComparison.Ordinal));
+
+        await client.CancelSessionAsync(new SessionCancelParams("session-1"), TestContext.Current.CancellationToken);
+
+        var messages = sentMessages.Select(parser.ParseMessage).ToArray();
+        Assert.Equal("session/cancel", Assert.Single(messages.OfType<JsonRpcNotification>()).Method);
+        var response = Assert.Single(messages.OfType<JsonRpcResponse>());
+        Assert.Equal("""{"action":"cancel"}""", response.Result!.Value.GetRawText());
+        Assert.False(await request.Accept(null));
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        Assert.Empty(completions);
+        Assert.Equal(2, sentMessages.Count);
+    }
+
+    [Theory]
+    [InlineData("explicit")]
+    [InlineData("error")]
+    [InlineData("silent")]
+    public async Task ElicitationState_DisconnectedConnection_DropsCompletionsAndPendingCallbacks(string disconnect)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = CaptureSentMessages();
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+        var accepted = ReceiveRequest(client, parser, 313, UrlParamsJson);
+        var pending = ReceiveRequest(client, parser, 314, FormParamsJson);
+        Assert.True(await accepted.Accept(null));
+        await WaitForResponseAsync(parser, sentMessages, 313);
+        _transportMock.SetupGet(t => t.IsConnected).Returns(false);
+
+        if (disconnect == "explicit")
+        {
+            await client.DisconnectAsync();
+        }
+        else if (disconnect == "error")
+        {
+            _transportMock.Raise(t => t.ErrorOccurred += null,
+                new AcpTransportErrorEventArgs("Connection closed.", kind: AcpTransportErrorKind.NotConnected));
+        }
+        else
+        {
+            await WaitUntilAsync(() => !client.IsInitialized);
+        }
+
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        Assert.Empty(completions);
+        Assert.False(await pending.Accept(null));
+        Assert.Empty(sentMessages);
+        Assert.False(client.IsInitialized);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ElicitationResponse_ReusedMessageId_OldCallbackCannotAnswerNewRequest(bool reconnect)
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        CaptureSentMessages();
+        var previous = ReceiveRequest(client, parser, 315, FormParamsJson);
+        if (reconnect)
+        {
+            await client.DisconnectAsync();
+            await InitializeClientAsync(client, UrlCapabilities());
+        }
+        else
+        {
+            Assert.True(await previous.Cancel());
+        }
+
+        var sentMessages = CaptureSentMessages();
+        var current = ReceiveRequest(client, parser, 315, FormParamsJson);
+        Assert.False(await previous.Accept(null));
+        Assert.Empty(sentMessages);
+        Assert.True(await current.Accept(null));
+        var response = await WaitForResponseAsync(parser, sentMessages, 315);
+        Assert.Equal("""{"action":"accept"}""", response.Result!.Value.GetRawText());
+        Assert.False(await previous.Cancel());
+        Assert.Empty(sentMessages);
+    }
+
+    [Fact]
+    public async Task ElicitationResponse_PreviousConnectionSendFails_DoesNotRestoreItsPendingRequest()
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sendResult = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        _transportMock
+            .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Returns(sendResult.Task);
+        var previous = ReceiveRequest(client, parser, 316, UrlParamsJson);
+        var previousSend = previous.Accept(null);
+
+        try
+        {
+            await client.DisconnectAsync();
+            await InitializeClientAsync(client, UrlCapabilities());
+            var sentMessages = CaptureSentMessages();
+            var current = ReceiveRequest(client, parser, 316, UrlParamsJson);
+            sendResult.TrySetResult(false);
+
+            Assert.False(await previousSend);
+            Assert.False(await previous.Cancel());
+            Assert.Empty(sentMessages);
+            Assert.True(await current.Accept(null));
+            var response = await WaitForResponseAsync(parser, sentMessages, 316);
+            Assert.Equal("""{"action":"accept"}""", response.Result!.Value.GetRawText());
+            Assert.Empty(sentMessages);
+        }
+        finally
+        {
+            sendResult.TrySetResult(false);
+        }
+    }
+
+    [Fact]
+    public async Task ElicitationComplete_UrlIdsAreOpaqueAndMayBeReusedAfterCompletion()
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        CaptureSentMessages();
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+        var spacedId = UrlParamsJson.Replace("oauth-1", " oauth-1 ", StringComparison.Ordinal);
+        var first = ReceiveRequest(client, parser, 318, spacedId);
+        Assert.True(await first.Accept(null));
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        Assert.Empty(completions);
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":" oauth-1 "}""");
+        var second = ReceiveRequest(client, parser, 319, spacedId);
+        Assert.True(await second.Accept(null));
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":" oauth-1 "}""");
+
+        Assert.Equal([" oauth-1 ", " oauth-1 "], completions);
+    }
+
+    [Fact]
+    public async Task ElicitationCreate_DuplicateOutstandingUrlId_PreservesTheOriginalInteraction()
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = CaptureSentMessages();
+        var completions = new List<string>();
+        client.ElicitationCompleted += (_, args) => completions.Add(args.ElicitationId);
+        var first = ReceiveRequest(client, parser, 321, UrlParamsJson);
+        var duplicateDelivered = false;
+        client.ElicitationRequestReceived += (_, _) => duplicateDelivered = true;
+
+        RaiseRequest(parser, 322, ElicitationMethods.Create, UrlParamsJson);
+
+        var duplicate = await WaitForResponseAsync(parser, sentMessages, 322);
+        Assert.Equal(JsonRpcErrorCode.InvalidParams, duplicate.Error!.Code);
+        Assert.False(duplicateDelivered);
+        Assert.True(await first.Accept(null));
+        var accepted = await WaitForResponseAsync(parser, sentMessages, 321);
+        Assert.Equal("""{"action":"accept"}""", accepted.Result!.Value.GetRawText());
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        RaiseNotification(parser, ElicitationMethods.Complete, """{"elicitationId":"oauth-1"}""");
+        Assert.Equal(["oauth-1"], completions);
+    }
+
+    [Fact]
+    public async Task ElicitationResponse_DisposedClient_CannotSendTheCapturedCallback()
+    {
+        var parser = new MessageParser();
+        using var client = await CreateInitializedClientAsync(UrlCapabilities());
+        var sentMessages = CaptureSentMessages();
+        var request = ReceiveRequest(client, parser, 320, UrlParamsJson);
+
+        client.Dispose();
+
+        Assert.False(await request.Accept(null));
+        Assert.False(await request.Decline());
+        Assert.False(await request.Cancel());
+        Assert.Empty(sentMessages);
+    }
+
+    private static ClientCapabilities UrlCapabilities()
+        => new()
+        {
+            Elicitation = new ElicitationCapabilities
+            {
+                Form = new ElicitationFormCapabilities(),
+                Url = new ElicitationUrlCapabilities()
+            }
+        };
+
+    private ElicitationRequestEventArgs ReceiveRequest(AcpClient client, MessageParser parser, long id, string paramsJson)
+    {
+        ElicitationRequestEventArgs? received = null;
+        void OnRequest(object? sender, ElicitationRequestEventArgs args) => received = args;
+        client.ElicitationRequestReceived += OnRequest;
+        try
+        {
+            RaiseRequest(parser, id, ElicitationMethods.Create, paramsJson);
+            Assert.NotNull(received);
+            return received;
+        }
+        finally
+        {
+            client.ElicitationRequestReceived -= OnRequest;
+        }
     }
 
     private ConcurrentQueue<string> CaptureSentMessages()
@@ -275,8 +877,14 @@ private void RaiseNotification(MessageParser parser, string method, string param
 
     private async Task<AcpClient> CreateInitializedClientAsync(ClientCapabilities clientCapabilities)
     {
-        var parser = new MessageParser();
         var client = new AcpClient(_transportMock.Object, _loggerMock.Object);
+        await InitializeClientAsync(client, clientCapabilities);
+        return client;
+    }
+
+    private async Task InitializeClientAsync(AcpClient client, ClientCapabilities clientCapabilities)
+    {
+        var parser = new MessageParser();
 
         _transportMock
             .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
@@ -304,8 +912,6 @@ private async Task<AcpClient> CreateInitializedClientAsync(ClientCapabilities cl
         await client.InitializeAsync(new InitializeParams(
             new ClientInfo("Test", "1.0.0"),
             clientCapabilities));
-
-        return client;
     }
 
     private static async Task<JsonRpcResponse> WaitForResponseAsync(
diff --git a/tests/SalmonEgg.Acp.Tests/Client/AcpClientTests.cs b/tests/SalmonEgg.Acp.Tests/Client/AcpClientTests.cs
index 618da8c0d..3832283a7 100644
--- a/tests/SalmonEgg.Acp.Tests/Client/AcpClientTests.cs
+++ b/tests/SalmonEgg.Acp.Tests/Client/AcpClientTests.cs
@@ -659,26 +659,29 @@ await Assert.ThrowsAnyAsync<OperationCanceledException>(
             }
         }
 
-        [Fact]
-        public async Task InitializeAsync_WhenTransportConnectReturnsFalse_IncludesLastTransportError()
+        [Theory]
+        [InlineData("Unable to start process: stdio command not found")]
+        [InlineData("未找到 Agent 命令。请检查配置中的可执行文件路径。")]
+        public async Task InitializeAsync_WhenTransportConnectReturnsFalse_PreservesLastTransportError(string transportError)
         {
-            var parser = new MessageParser();
             _transportMock.SetupGet(t => t.IsConnected).Returns(false);
             _transportMock
                 .Setup(t => t.ConnectAsync(It.IsAny<CancellationToken>()))
                 .Callback(() => _transportMock.Raise(
                     t => t.ErrorOccurred += null,
-                    new AcpTransportErrorEventArgs("Unable to start process: stdio command not found")))
+                    new AcpTransportErrorEventArgs(transportError, kind: AcpTransportErrorKind.ProcessStartFailed)))
                 .ReturnsAsync(false);
-            var client = CreateClient();
+            using var client = CreateClient();
+            var errors = new List<string>();
+            client.ErrorOccurred += (_, error) => errors.Add(error);
 
             var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
                 client.InitializeAsync(new InitializeParams(
                     new ClientInfo("Test", "1.0.0"),
                     ClientCapabilityDefaults.Create()), TestContext.Current.CancellationToken));
 
-            Assert.Contains("Failed to connect to the transport", ex.Message, StringComparison.Ordinal);
-            Assert.Contains("Unable to start process: stdio command not found", ex.Message, StringComparison.Ordinal);
+            Assert.Equal(transportError, ex.Message);
+            Assert.Equal([transportError], errors);
         }
 
         [Fact]
@@ -950,24 +953,24 @@ public void InitializeResponse_V2WireShape_DoesNotSynthesizeLoadSessionOrAuthCap
             Assert.Equal("agent", root.GetProperty("authMethods")[0].GetProperty("type").GetString());
         }
 
-        [Fact]
-        public void TransportErrors_ForStdioBridgeFailures_ShouldAppendSshGuidance()
+        [Theory]
+        [InlineData(AcpTransportErrorKind.ProcessStartFailed, "Agent command was not found on PATH.")]
+        [InlineData(AcpTransportErrorKind.ProcessExited, "Process exited. ExitCode=1")]
+        [InlineData(AcpTransportErrorKind.StdoutReadFailed, "Could not read agent output.")]
+        [InlineData(AcpTransportErrorKind.General, "The stdout connection closed.")]
+        public void TransportErrors_WithoutSshIdentity_PreserveTheTransportMessage(AcpTransportErrorKind kind, string transportError)
         {
-            var parser = new MessageParser();
-            var client = CreateClient();
+            using var client = CreateClient();
             string? receivedError = null;
             client.ErrorOccurred += (_, error) => receivedError = error;
 
             _transportMock.Raise(
                 t => t.ErrorOccurred += null,
                 new AcpTransportErrorEventArgs(
-                    "Process exited immediately after start. ExitCode=255",
-                    kind: AcpTransportErrorKind.ProcessStartFailed));
+                    transportError,
+                    kind: kind));
 
-            Assert.NotNull(receivedError);
-            Assert.Contains("ssh -t", receivedError, StringComparison.Ordinal);
-            Assert.Contains("stdout", receivedError, StringComparison.OrdinalIgnoreCase);
-            Assert.Contains("BatchMode=yes", receivedError, StringComparison.Ordinal);
+            Assert.Equal(transportError, receivedError);
         }
 
         [Fact]
@@ -2252,6 +2255,84 @@ public async Task CancelSessionAsync_WhenPermissionPromptIsPending_SendsCancelle
                 resultDoc.RootElement.GetProperty("outcome").GetProperty("outcome").GetString());
         }
 
+        [Theory]
+        [InlineData("session/request_permission")]
+        [InlineData("fs/read_text_file")]
+        public async Task CancelSessionAsync_WhenRequestIdIsReusedByAnotherSession_DoesNotCancelNewRequest(string method)
+        {
+            // Arrange: pause the first cancellation regardless of dictionary enumeration order.
+            var parser = new MessageParser();
+            using var client = await CreateInitializedClientAsync(
+                clientCapabilities: new ClientCapabilities(fs: new FsCapability()));
+            client.PermissionRequestReceived += (_, _) => { };
+            client.FileSystemRequestReceived += (_, _) => { };
+            var sentMessages = new ConcurrentQueue<string>();
+            var firstCancellation = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+            var releaseCancellation = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+            _transportMock
+                .Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .Returns<string, CancellationToken>((message, cancellationToken) =>
+                {
+                    sentMessages.Enqueue(message);
+                    if (parser.ParseMessage(message) is JsonRpcResponse response
+                        && firstCancellation.TrySetResult(response.Id!.ToString()!))
+                    {
+                        return releaseCancellation.Task.WaitAsync(cancellationToken);
+                    }
+
+                    return Task.FromResult(true);
+                });
+            RaisePendingRequestForCancellationTest(parser, method, 302, "session-1");
+            RaisePendingRequestForCancellationTest(parser, method, 303, "session-1");
+            var cancellation = client.CancelSessionAsync(new SessionCancelParams("session-1"), TestContext.Current.CancellationToken);
+
+            try
+            {
+                // Act: complete the other request and reuse its ID before cancellation resumes.
+                var cancellingId = await firstCancellation.Task.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+                var reusedId = cancellingId == "302" ? 303L : 302L;
+                Assert.True(await CompleteRequestAsync(reusedId));
+                RaisePendingRequestForCancellationTest(parser, method, reusedId, "session-2");
+                releaseCancellation.TrySetResult(true);
+                await cancellation.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+
+                // Assert: cancellation leaves the new request pending and able to respond normally.
+                var previousResponse = Assert.Single(sentMessages.Select(parser.ParseMessage).OfType<JsonRpcResponse>(),
+                    response => response.Id?.ToString() == reusedId.ToString());
+                Assert.False(previousResponse.IsError);
+                Assert.True(await CompleteRequestAsync(reusedId));
+                var reusedResponses = sentMessages.Select(parser.ParseMessage).OfType<JsonRpcResponse>()
+                    .Where(response => response.Id?.ToString() == reusedId.ToString()).ToArray();
+                Assert.Equal(2, reusedResponses.Length);
+                var expectedResult = method == "session/request_permission"
+                    ? """{"outcome":{"outcome":"selected","optionId":"allow"}}"""
+                    : """{"content":"file content"}""";
+                Assert.All(reusedResponses, response => Assert.Equal(expectedResult, response.Result!.Value.GetRawText()));
+                var cancelledResponse = Assert.Single(sentMessages.Select(parser.ParseMessage).OfType<JsonRpcResponse>(),
+                    response => response.Id?.ToString() == cancellingId);
+                if (method == "session/request_permission")
+                {
+                    Assert.Equal("""{"outcome":{"outcome":"cancelled"}}""", cancelledResponse.Result!.Value.GetRawText());
+                }
+                else
+                {
+                    Assert.Equal(JsonRpcErrorCode.MethodNotAllowed, cancelledResponse.Error!.Code);
+                }
+
+                Assert.Equal(4, sentMessages.Count);
+            }
+            finally
+            {
+                releaseCancellation.TrySetResult(true);
+                await cancellation.WaitAsync(TimeSpan.FromSeconds(5), CancellationToken.None);
+            }
+
+            Task<bool> CompleteRequestAsync(long messageId)
+                => method == "session/request_permission"
+                    ? client.RespondToPermissionRequestAsync(messageId, "selected", "allow")
+                    : client.RespondToFileSystemRequestAsync(messageId, success: true, content: "file content");
+        }
+
         [Fact]
         public async Task CancelSessionAsync_SendsSessionCancelAsNotificationWithoutRequestId()
         {
@@ -3220,6 +3301,26 @@ private static async Task<JsonRpcResponse> WaitForResponseAsync(
             throw new TimeoutException($"Timed out waiting for JSON-RPC response {responseId}.");
         }
 
+        private void RaisePendingRequestForCancellationTest(MessageParser parser, string method, long messageId, string sessionId)
+        {
+            var requestParams = method == "session/request_permission"
+                ? ElementFromJson(
+                    $$"""
+                    {
+                      "sessionId": "{{sessionId}}",
+                      "toolCall": {
+                        "toolCallId": "call-1",
+                        "title": "Read file",
+                        "kind": "read",
+                        "status": "pending"
+                      },
+                      "options": [{ "optionId": "allow", "name": "Allow", "kind": "allow_once" }]
+                    }
+                    """)
+                : ElementFromJson($$"""{"sessionId":"{{sessionId}}","path":"/workspace/file.txt"}""");
+            RaiseTransportMessage(parser.SerializeMessage(new JsonRpcRequest(messageId, method, requestParams)));
+        }
+
         private static JsonElement ElementFromJson(string json)
         {
             using var document = JsonDocument.Parse(json);
diff --git a/tests/SalmonEgg.Infrastructure.Tests/Services/CliCommandProcessFixture.cs b/tests/SalmonEgg.Infrastructure.Tests/Services/CliCommandProcessFixture.cs
new file mode 100644
index 000000000..f60786aca
--- /dev/null
+++ b/tests/SalmonEgg.Infrastructure.Tests/Services/CliCommandProcessFixture.cs
@@ -0,0 +1,164 @@
+using System.Diagnostics;
+
+namespace SalmonEgg.Infrastructure.Tests.Services;
+
+internal sealed class CliCommandProcessFixture : IAsyncDisposable
+{
+    private static readonly TimeSpan ProcessTimeout = TimeSpan.FromSeconds(5);
+
+    private readonly string _root;
+    private Process? _process;
+    private Process? _childProcess;
+
+    private CliCommandProcessFixture(string root, string executablePath)
+    {
+        _root = root;
+        ExecutablePath = executablePath;
+    }
+
+    public string ExecutablePath { get; }
+
+    public static async Task<CliCommandProcessFixture> CreateAsync(string body)
+    {
+        Assert.SkipWhen(OperatingSystem.IsWindows(), "The fake commands are POSIX scripts.");
+        var root = Path.Combine(Path.GetTempPath(), "salmon-egg-cli-process-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(root);
+        var executablePath = Path.Combine(root, "command");
+        try
+        {
+            // The shell records its own PID before the test payload. No process-name search can match
+            // another test's process, and exec keeps that same PID for a long-lived command.
+            await File.WriteAllTextAsync(
+                executablePath,
+                "#!/bin/sh\nprintf '%s\\n' \"$$\" > \"$0.pid\"\n" + body + "\n",
+                TestContext.Current.CancellationToken);
+            if (!OperatingSystem.IsWindows())
+            {
+                File.SetUnixFileMode(executablePath, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
+            }
+
+            return new CliCommandProcessFixture(root, executablePath);
+        }
+        catch
+        {
+            Directory.Delete(root, recursive: true);
+            throw;
+        }
+    }
+
+    public async Task<Process?> ObserveStartedProcessAsync()
+    {
+        using var timeout = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        timeout.CancelAfter(ProcessTimeout);
+        var pidFile = ExecutablePath + ".pid";
+        while (true)
+        {
+            if (File.Exists(pidFile)
+                && int.TryParse(await File.ReadAllTextAsync(pidFile, timeout.Token), out var processId))
+            {
+                try
+                {
+                    _process = Process.GetProcessById(processId);
+                    _ = _process.HasExited;
+                    return _process;
+                }
+                catch (ArgumentException)
+                {
+                    // A successful command may already have exited before the first observation.
+                    return null;
+                }
+            }
+
+            await Task.Delay(TimeSpan.FromMilliseconds(20), timeout.Token);
+        }
+    }
+
+    public async Task StopAsync()
+    {
+        using var cleanup = new CancellationTokenSource(ProcessTimeout);
+        try
+        {
+            _process ??= await ReadRecordedProcessAsync(ExecutablePath + ".pid", cleanup.Token);
+            await StopProcessAsync(_process, cleanup.Token);
+        }
+        finally
+        {
+            using var childCleanup = new CancellationTokenSource(ProcessTimeout);
+            _childProcess ??= await ReadRecordedProcessAsync(ExecutablePath + ".child.pid", childCleanup.Token);
+            await StopProcessAsync(_childProcess, childCleanup.Token);
+        }
+    }
+
+    public async Task<Process> ObserveStartedChildProcessAsync()
+    {
+        using var timeout = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        timeout.CancelAfter(ProcessTimeout);
+        while (true)
+        {
+            _childProcess ??= await ReadRecordedProcessAsync(ExecutablePath + ".child.pid", timeout.Token);
+            if (_childProcess is not null)
+            {
+                return _childProcess;
+            }
+
+            await Task.Delay(TimeSpan.FromMilliseconds(20), timeout.Token);
+        }
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        try
+        {
+            await StopAsync();
+        }
+        finally
+        {
+            _process?.Dispose();
+            _childProcess?.Dispose();
+            Directory.Delete(_root, recursive: true);
+        }
+    }
+
+    private static async Task<Process?> ReadRecordedProcessAsync(string pidFile, CancellationToken cancellationToken)
+    {
+        if (!File.Exists(pidFile)
+            || !int.TryParse(await File.ReadAllTextAsync(pidFile, cancellationToken), out var processId))
+        {
+            return null;
+        }
+
+        try
+        {
+            var process = Process.GetProcessById(processId);
+            _ = process.HasExited;
+            return process;
+        }
+        catch (ArgumentException)
+        {
+            // An assertion can fail after a short-lived command has already exited.
+            return null;
+        }
+    }
+
+    private static async Task StopProcessAsync(Process? process, CancellationToken cancellationToken)
+    {
+        if (process is null)
+        {
+            return;
+        }
+
+        try
+        {
+            if (!process.HasExited)
+            {
+                process.Kill(entireProcessTree: true);
+            }
+        }
+        catch (InvalidOperationException)
+        {
+            // The command exited between inspection and termination.
+        }
+
+        await process.WaitForExitAsync(cancellationToken);
+    }
+}
diff --git a/tests/SalmonEgg.Infrastructure.Tests/Services/CliCommandProcessRunnerTests.cs b/tests/SalmonEgg.Infrastructure.Tests/Services/CliCommandProcessRunnerTests.cs
new file mode 100644
index 000000000..117da87ef
--- /dev/null
+++ b/tests/SalmonEgg.Infrastructure.Tests/Services/CliCommandProcessRunnerTests.cs
@@ -0,0 +1,139 @@
+using System.Diagnostics;
+using SalmonEgg.Infrastructure.Desktop.Services;
+
+namespace SalmonEgg.Infrastructure.Tests.Services;
+
+public sealed class CliCommandProcessRunnerTests
+{
+    private static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(20);
+
+    [Fact]
+    public async Task RunAsync_WhenBothStreamsExceedCaptureLimit_DrainsBothAndKeepsBoundedTails()
+    {
+        // Arrange
+        var outputSize = CliCommandProcessRunner.MaxCapturedCharacters * 16;
+        await using var command = await CliCommandProcessFixture.CreateAsync($"""
+            printf '%{outputSize}s' ''
+            printf 'stdout-tail'
+            printf '%{outputSize}s' '' >&2
+            printf 'stderr-tail' >&2
+            """);
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        var timeout = TimeSpan.FromSeconds(10);
+
+        // Act
+        var run = CliCommandProcessRunner.RunAsync(new ProcessStartInfo(command.ExecutablePath), timeout, cancellation.Token);
+        try
+        {
+            await command.ObserveStartedProcessAsync();
+            var result = await run.WaitAsync(TimeSpan.FromSeconds(20), TestContext.Current.CancellationToken);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.False(result.TimedOut);
+            Assert.Equal(0, result.ExitCode);
+            Assert.Equal(CliCommandProcessRunner.MaxCapturedCharacters, result.StandardOutput.Length);
+            Assert.Equal(CliCommandProcessRunner.MaxCapturedCharacters, result.StandardError.Length);
+            Assert.EndsWith("stdout-tail", result.StandardOutput, StringComparison.Ordinal);
+            Assert.EndsWith("stderr-tail", result.StandardError, StringComparison.Ordinal);
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            using var cleanup = new CancellationTokenSource(TimeSpan.FromSeconds(20));
+            try
+            {
+                await run.WaitAsync(cleanup.Token);
+            }
+            catch (OperationCanceledException) when (!cleanup.IsCancellationRequested)
+            {
+                // An assertion failure still cancels and observes the invocation.
+            }
+        }
+    }
+
+    [Fact]
+    public async Task RunAsync_WhenCancelledAndTerminationFails_PreservesCancellationAndCleanupError()
+    {
+        // Arrange
+        await using var command = await CliCommandProcessFixture.CreateAsync("exec /bin/sleep 600");
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        var cleanupFailure = new IOException("The operating system refused termination.");
+
+        // Act
+        var run = CliCommandProcessRunner.RunAsync(
+            new ProcessStartInfo(command.ExecutablePath),
+            TimeSpan.FromSeconds(10),
+            cancellation.Token,
+            _ => Task.FromException(cleanupFailure));
+        try
+        {
+            var process = await command.ObserveStartedProcessAsync();
+            Assert.NotNull(process);
+            await cancellation.CancelAsync();
+
+            // Assert
+            var exception = await Assert.ThrowsAnyAsync<OperationCanceledException>(
+                () => run.WaitAsync(TestTimeout, TestContext.Current.CancellationToken));
+            Assert.Equal(cancellation.Token, exception.CancellationToken);
+            Assert.Same(cleanupFailure, exception.InnerException);
+            Assert.False(process.HasExited, "The injected kill failure must leave a live pipe for reader cancellation to exercise.");
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            await ObserveCompletionAsync(run);
+        }
+    }
+
+    [Fact]
+    public async Task RunAsync_WhenParentExitsButChildHoldsPipes_ReturnsAtDeadline()
+    {
+        // Arrange
+        await using var command = await CliCommandProcessFixture.CreateAsync("""
+            /bin/sleep 600 &
+            printf '%s\n' "$!" > "$0.child.pid"
+            exit 0
+            """);
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+
+        // Act
+        var run = CliCommandProcessRunner.RunAsync(
+            new ProcessStartInfo(command.ExecutablePath), TimeSpan.FromSeconds(1), cancellation.Token);
+        try
+        {
+            await command.ObserveStartedProcessAsync();
+            var child = await command.ObserveStartedChildProcessAsync();
+            var result = await run.WaitAsync(TestTimeout, TestContext.Current.CancellationToken);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.True(result.TimedOut);
+            Assert.Equal(0, result.ExitCode);
+            // An exited parent's PID cannot identify a child that the OS has already reparented.
+            // The runner must stop its readers; the fixture owns and reaps this deliberately orphaned PID.
+            Assert.False(child.HasExited);
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            await ObserveCompletionAsync(run);
+        }
+    }
+
+    private static async Task ObserveCompletionAsync(Task task)
+    {
+        using var cleanup = new CancellationTokenSource(TestTimeout);
+        try
+        {
+            await task.WaitAsync(cleanup.Token);
+        }
+        catch (OperationCanceledException) when (!cleanup.IsCancellationRequested)
+        {
+            // Test failure cleanup must still observe a cancelled invocation.
+        }
+    }
+}
diff --git a/tests/SalmonEgg.Infrastructure.Tests/Services/MacOsCliCommandLinkServiceProcessTests.cs b/tests/SalmonEgg.Infrastructure.Tests/Services/MacOsCliCommandLinkServiceProcessTests.cs
new file mode 100644
index 000000000..c3b30423f
--- /dev/null
+++ b/tests/SalmonEgg.Infrastructure.Tests/Services/MacOsCliCommandLinkServiceProcessTests.cs
@@ -0,0 +1,142 @@
+using System.Diagnostics;
+using SalmonEgg.Infrastructure.Desktop.Services;
+
+namespace SalmonEgg.Infrastructure.Tests.Services;
+
+public sealed class MacOsCliCommandLinkServiceProcessTests
+{
+    private static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(20);
+    private static readonly TimeSpan CommandTimeout = TimeSpan.FromSeconds(10);
+
+    [Fact]
+    public async Task RunAuthorizationProcessAsync_WhenCallerCancels_TerminatesCommand()
+    {
+        // Arrange
+        await using var command = await CliCommandProcessFixture.CreateAsync("exec /bin/sleep 600");
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+
+        // Act
+        var authorization = RunAsync(command, CommandTimeout, cancellation.Token);
+        try
+        {
+            var process = await command.ObserveStartedProcessAsync();
+            Assert.NotNull(process);
+            await cancellation.CancelAsync();
+
+            // Assert
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() => authorization.WaitAsync(TestTimeout, TestContext.Current.CancellationToken));
+            Assert.True(process.HasExited, "The cancelled authorization returned while its command was still running.");
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            await ObserveCompletionAsync(authorization);
+        }
+    }
+
+    [Fact]
+    public async Task RunAuthorizationProcessAsync_WhenDeadlineExpires_TerminatesCommandAndReportsFailure()
+    {
+        // Arrange
+        await using var command = await CliCommandProcessFixture.CreateAsync("exec /bin/sleep 600");
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+
+        // Act
+        var authorization = RunAsync(command, TimeSpan.FromSeconds(1), cancellation.Token);
+        try
+        {
+            var process = await command.ObserveStartedProcessAsync();
+            Assert.NotNull(process);
+            var result = await authorization.WaitAsync(TestTimeout, TestContext.Current.CancellationToken);
+
+            // Assert
+            Assert.Equal(PrivilegedShellStatus.Failed, result.Status);
+            Assert.Equal("the authorization prompt was not answered in time", result.Detail);
+            Assert.True(process.HasExited, "The timeout returned while its command was still running.");
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            await ObserveCompletionAsync(authorization);
+        }
+    }
+
+    [Fact]
+    public async Task RunAuthorizationProcessAsync_WhenStandardOutputExceedsPipeCapacity_Succeeds()
+    {
+        // Arrange
+        await using var command = await CliCommandProcessFixture.CreateAsync("printf '%1048576s' ''");
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+
+        // Act
+        var authorization = RunAsync(command, CommandTimeout, cancellation.Token);
+        try
+        {
+            await command.ObserveStartedProcessAsync();
+            var result = await authorization.WaitAsync(TestTimeout, TestContext.Current.CancellationToken);
+
+            // Assert
+            Assert.Equal(PrivilegedShellStatus.Succeeded, result.Status);
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            await ObserveCompletionAsync(authorization);
+        }
+    }
+
+    [Theory]
+    [InlineData("execution error: cancelled (-128)", PrivilegedShellStatus.Cancelled)]
+    [InlineData("authorization failed", PrivilegedShellStatus.Failed)]
+    public async Task RunAuthorizationProcessAsync_WhenCommandFails_PreservesDiagnosticMeaning(
+        string diagnostic,
+        PrivilegedShellStatus expected)
+    {
+        // Arrange
+        await using var command = await CliCommandProcessFixture.CreateAsync($"printf '%s' '{diagnostic}' >&2\nexit 1");
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+
+        // Act
+        var authorization = RunAsync(command, CommandTimeout, cancellation.Token);
+        try
+        {
+            await command.ObserveStartedProcessAsync();
+            var result = await authorization.WaitAsync(TestTimeout, TestContext.Current.CancellationToken);
+
+            // Assert
+            Assert.Equal(expected, result.Status);
+            Assert.Equal(expected == PrivilegedShellStatus.Failed ? diagnostic : null, result.Detail);
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            await ObserveCompletionAsync(authorization);
+        }
+    }
+
+    private static Task<PrivilegedShellResult> RunAsync(
+        CliCommandProcessFixture command,
+        TimeSpan timeout,
+        CancellationToken cancellationToken)
+        // This is the same lifecycle and result translation osascript uses. The test never opens an
+        // authorization dialog or changes /usr/local/bin on the machine that runs it.
+        => MacOsCliCommandLinkService.RunAuthorizationProcessAsync(
+            new ProcessStartInfo(command.ExecutablePath), timeout, cancellationToken);
+
+    private static async Task ObserveCompletionAsync(Task task)
+    {
+        using var cleanup = new CancellationTokenSource(TestTimeout);
+        try
+        {
+            await task.WaitAsync(cleanup.Token);
+        }
+        catch (OperationCanceledException) when (!cleanup.IsCancellationRequested)
+        {
+            // A cancelled command is expected when cleanup follows an assertion failure.
+        }
+    }
+}
diff --git a/tests/SalmonEgg.Infrastructure.Tests/Services/SystemCliCommandProbeEnvironmentTests.cs b/tests/SalmonEgg.Infrastructure.Tests/Services/SystemCliCommandProbeEnvironmentTests.cs
new file mode 100644
index 000000000..b54548732
--- /dev/null
+++ b/tests/SalmonEgg.Infrastructure.Tests/Services/SystemCliCommandProbeEnvironmentTests.cs
@@ -0,0 +1,79 @@
+using SalmonEgg.Infrastructure.Desktop.Services;
+
+namespace SalmonEgg.Infrastructure.Tests.Services;
+
+public sealed class SystemCliCommandProbeEnvironmentTests
+{
+    private static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(20);
+
+    [Fact]
+    public async Task ProbeVersionAsync_WhenCallerCancels_TerminatesStartedCommand()
+    {
+        // Arrange
+        await using var command = await CliCommandProcessFixture.CreateAsync("exec /bin/sleep 600");
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        var environment = new SystemCliCommandProbeEnvironment();
+
+        // Act
+        var probe = environment.ProbeVersionAsync(command.ExecutablePath, cancellation.Token);
+        try
+        {
+            var process = await command.ObserveStartedProcessAsync();
+            Assert.NotNull(process);
+            await cancellation.CancelAsync();
+
+            // Assert
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() => probe.WaitAsync(TestTimeout, TestContext.Current.CancellationToken));
+            Assert.True(process.HasExited, "The cancelled probe returned while its command was still running.");
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            await ObserveCompletionAsync(probe);
+        }
+    }
+
+    [Fact]
+    public async Task ProbeVersionAsync_WhenStandardErrorExceedsPipeCapacity_ReturnsVersion()
+    {
+        // Arrange
+        await using var command = await CliCommandProcessFixture.CreateAsync("""
+            printf '%1048576s' '' >&2
+            printf 'probe-version\n'
+            """);
+        using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
+        var environment = new SystemCliCommandProbeEnvironment();
+
+        // Act
+        var probe = environment.ProbeVersionAsync(command.ExecutablePath, cancellation.Token);
+        try
+        {
+            await command.ObserveStartedProcessAsync();
+            var result = await probe.WaitAsync(TestTimeout, TestContext.Current.CancellationToken);
+
+            // Assert
+            Assert.Equal("probe-version", result.Version);
+            Assert.Null(result.FailureDetail);
+        }
+        finally
+        {
+            await cancellation.CancelAsync();
+            await command.StopAsync();
+            await ObserveCompletionAsync(probe);
+        }
+    }
+
+    private static async Task ObserveCompletionAsync(Task task)
+    {
+        using var cleanup = new CancellationTokenSource(TestTimeout);
+        try
+        {
+            await task.WaitAsync(cleanup.Token);
+        }
+        catch (OperationCanceledException) when (!cleanup.IsCancellationRequested)
+        {
+            // Cancellation is the expected outcome during cleanup, including after a failed assertion.
+        }
+    }
+}
diff --git a/tests/SalmonEgg.Infrastructure.Tests/Transport/StdioCommandPreflightTests.cs b/tests/SalmonEgg.Infrastructure.Tests/Transport/StdioCommandPreflightTests.cs
index d3254cdb5..9a95a5899 100644
--- a/tests/SalmonEgg.Infrastructure.Tests/Transport/StdioCommandPreflightTests.cs
+++ b/tests/SalmonEgg.Infrastructure.Tests/Transport/StdioCommandPreflightTests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using SalmonEgg.Domain.Interfaces.Transport;
 using SalmonEgg.Infrastructure.Transport;
 using Xunit;
 
@@ -23,8 +24,9 @@ public void BuildMissingCommandError_SearchedOnPath_SaysNotFoundOnPath()
         var error = StdioCommandPreflight.BuildMissingCommandError(invocation);
 
         Assert.NotNull(error);
-        Assert.Contains("not found on PATH", error, StringComparison.Ordinal);
-        Assert.Contains("absent-agent", error, StringComparison.Ordinal);
+        Assert.Contains("not found on PATH", error.ErrorMessage, StringComparison.Ordinal);
+        Assert.Contains("absent-agent", error.ErrorMessage, StringComparison.Ordinal);
+        Assert.Equal(new StdioCommandResolutionFailure("absent-agent", SearchedOnPath: true), error.CommandResolutionFailure);
     }
 
     [Fact]
@@ -41,8 +43,9 @@ public void BuildMissingCommandError_ExplicitLocation_SaysDoesNotExist()
         var error = StdioCommandPreflight.BuildMissingCommandError(invocation);
 
         Assert.NotNull(error);
-        Assert.Contains("does not exist", error, StringComparison.Ordinal);
-        Assert.Contains(@"C:\tools\absent-agent.exe", error, StringComparison.Ordinal);
+        Assert.Contains("does not exist", error.ErrorMessage, StringComparison.Ordinal);
+        Assert.Contains(@"C:\tools\absent-agent.exe", error.ErrorMessage, StringComparison.Ordinal);
+        Assert.Equal(new StdioCommandResolutionFailure(@"C:\tools\absent-agent.exe", SearchedOnPath: false), error.CommandResolutionFailure);
     }
 
     [Fact]
@@ -62,7 +65,7 @@ public void BuildMissingCommandError_UnlaunchableCommand_SaysDoesNotExist()
         var error = StdioCommandPreflight.BuildMissingCommandError(invocation);
 
         Assert.NotNull(error);
-        Assert.Contains("does not exist", error, StringComparison.Ordinal);
+        Assert.Contains("does not exist", error.ErrorMessage, StringComparison.Ordinal);
     }
 
     [Fact]
@@ -95,7 +98,8 @@ public void BuildMissingCommandError_BatchLauncherWrappedInCmdExe_StillJudgesUnd
         var error = StdioCommandPreflight.BuildMissingCommandError(invocation);
 
         Assert.NotNull(error);
-        Assert.Contains("does not exist", error, StringComparison.Ordinal);
-        Assert.Contains(@"C:\tools\absent-agent.cmd", error, StringComparison.Ordinal);
+        Assert.Contains("does not exist", error.ErrorMessage, StringComparison.Ordinal);
+        Assert.Contains(@"C:\tools\absent-agent.cmd", error.ErrorMessage, StringComparison.Ordinal);
+        Assert.Equal(new StdioCommandResolutionFailure(@"C:\tools\absent-agent.cmd", SearchedOnPath: false), error.CommandResolutionFailure);
     }
 }
diff --git a/tests/SalmonEgg.Infrastructure.Tests/Transport/StdioPreflightPresentationTests.cs b/tests/SalmonEgg.Infrastructure.Tests/Transport/StdioPreflightPresentationTests.cs
new file mode 100644
index 000000000..6d2dfe829
--- /dev/null
+++ b/tests/SalmonEgg.Infrastructure.Tests/Transport/StdioPreflightPresentationTests.cs
@@ -0,0 +1,94 @@
+using Moq;
+using SalmonEgg.Acp.Client;
+using SalmonEgg.Acp.Protocol;
+using SalmonEgg.Application.Services.Acp;
+using SalmonEgg.Domain.Interfaces.Transport;
+using SalmonEgg.Domain.Services;
+using SalmonEgg.Infrastructure.Client;
+using SalmonEgg.Infrastructure.Services;
+using SalmonEgg.Infrastructure.Transport;
+
+namespace SalmonEgg.Infrastructure.Tests.Transport;
+
+public sealed class StdioPreflightPresentationTests
+{
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task InitializeAsync_WhenConfiguredCommandIsMissing_PreservesPresentedFailure(bool searchedOnPath)
+    {
+        // Arrange
+        var command = CreateMissingCommand(searchedOnPath);
+        var formatter = new RecordingFormatter();
+        using var transport = new StdioTransport(command, []);
+        var factory = new AcpClientFactory(
+            Mock.Of<IErrorLogger>(),
+            new SessionManager(),
+            new UnsupportedTerminalSessionManager(),
+            formatter);
+        using var client = factory.CreateClient(transport);
+        var errors = new List<string>();
+        client.ErrorOccurred += (_, error) => errors.Add(error);
+
+        // Act
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => client.InitializeAsync(
+            new InitializeParams(new ClientInfo("test", "1.0"), ClientCapabilityDefaults.Create()),
+            TestContext.Current.CancellationToken));
+
+        // Assert
+        var failure = Assert.IsType<StdioCommandResolutionFailure>(formatter.LastError?.CommandResolutionFailure);
+        Assert.Equal(command, failure.Command);
+        Assert.Equal(searchedOnPath, failure.SearchedOnPath);
+        Assert.Equal(formatter.PresentedMessage, Assert.Single(errors));
+        Assert.Equal(formatter.PresentedMessage, exception.Message);
+        Assert.False(transport.IsConnected);
+    }
+
+    [Theory]
+    [InlineData(true, "not found on PATH")]
+    [InlineData(false, "does not exist")]
+    public async Task InitializeAsync_WithoutFormatter_PreservesActionableFallback(bool searchedOnPath, string expectedPhrase)
+    {
+        // Arrange
+        var command = CreateMissingCommand(searchedOnPath);
+        using var transport = new StdioTransport(command, []);
+        using var adapter = new DomainAcpTransportAdapter(transport);
+        using var client = new AcpClient(adapter);
+        var errors = new List<string>();
+        client.ErrorOccurred += (_, error) => errors.Add(error);
+
+        // Act
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => client.InitializeAsync(
+            new InitializeParams(new ClientInfo("test", "1.0"), ClientCapabilityDefaults.Create()),
+            TestContext.Current.CancellationToken));
+
+        // Assert
+        var message = Assert.Single(errors);
+        Assert.Contains(expectedPhrase, message, StringComparison.Ordinal);
+        Assert.Contains(command, message, StringComparison.Ordinal);
+        Assert.DoesNotContain("ssh -t", message, StringComparison.Ordinal);
+        Assert.Equal(message, exception.Message);
+    }
+
+    private static string CreateMissingCommand(bool searchedOnPath)
+    {
+        var command = "salmonegg-absent-agent-" + Guid.NewGuid().ToString("N");
+        return searchedOnPath ? command : Path.Combine(Path.GetTempPath(), command);
+    }
+
+    private sealed class RecordingFormatter : ITransportErrorMessageFormatter
+    {
+        public TransportErrorEventArgs? LastError { get; private set; }
+
+        public string? PresentedMessage { get; private set; }
+
+        public string Format(TransportErrorEventArgs error)
+        {
+            LastError = error;
+            PresentedMessage = error.CommandResolutionFailure is { } failure
+                ? $"找不到命令“{failure.Command}”。请检查 Agent 配置。"
+                : error.ErrorMessage;
+            return PresentedMessage;
+        }
+    }
+}
diff --git a/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatAuthenticationCoordinatorTests.cs b/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatAuthenticationCoordinatorTests.cs
index 9614cb204..162600e08 100644
--- a/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatAuthenticationCoordinatorTests.cs
+++ b/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatAuthenticationCoordinatorTests.cs
@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using SalmonEgg.Application.Services.Chat;
+using SalmonEgg.Acp.JsonRpc;
 using SalmonEgg.Acp.Protocol;
 using SalmonEgg.Presentation.Core.Mvux.Chat;
 using SalmonEgg.Presentation.Core.Services.Chat;
@@ -419,6 +420,39 @@ public async Task TryAuthenticateAsync_WhenAuthenticationFails_StoresFailureReso
             It.IsAny<CancellationToken>()), Times.Once);
     }
 
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task TryAuthenticateAsync_WhenCancelled_PreservesRequirementWithoutFailure(bool remoteCancellation)
+    {
+        var sut = new ChatAuthenticationCoordinator();
+        sut.CacheAuthMethods(CreateInitializeResponse(new AuthMethodDefinition { Id = "login", Name = "Login" }));
+        var coordinator = CreateConnectionCoordinator();
+        var service = new Mock<IChatService>();
+        using var cancellation = new CancellationTokenSource();
+        Exception failure = remoteCancellation
+            ? new AcpException(JsonRpcErrorCode.Cancelled, "Cancelled by agent")
+            : new OperationCanceledException(cancellation.Token);
+        service.Setup(x => x.AuthenticateAsync(It.IsAny<AuthenticateParams>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(failure);
+        var notifications = new List<string>();
+        var formattedFailures = 0;
+
+        var result = await sut.TryAuthenticateAsync(service.Object, true, coordinator.Object,
+            NullLogger.Instance, notifications.Add, cancellation.Token,
+            requiredFallback: new AuthenticationHintPresentation("Please sign in"),
+            formatAuthenticationFailed: detail =>
+            {
+                formattedFailures++;
+                return new AuthenticationHintPresentation(detail);
+            });
+
+        Assert.False(result);
+        Assert.Equal(0, formattedFailures);
+        Assert.Equal(["Please sign in"], notifications);
+        coordinator.Verify(x => x.ClearAuthenticationRequiredAsync(It.IsAny<CancellationToken>()), Times.Never);
+    }
+
     private static readonly AuthenticationHintPresentation UnsupportedMethodTypeHint = new(
         "无法使用的登录方式",
         ResourceKey: "ChatAuth_UnsupportedMethodType",
diff --git a/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatViewModelElicitationTests.cs b/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatViewModelElicitationTests.cs
new file mode 100644
index 000000000..b59fd44e7
--- /dev/null
+++ b/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatViewModelElicitationTests.cs
@@ -0,0 +1,179 @@
+using System.Collections.Immutable;
+using SalmonEgg.Acp.Client;
+using SalmonEgg.Acp.Protocol;
+using SalmonEgg.Presentation.Core.Mvux.Chat;
+using SalmonEgg.Presentation.Core.Services.Chat;
+
+namespace SalmonEgg.Presentation.Core.Tests.Chat;
+
+public partial class ChatViewModelTests
+{
+    [Fact]
+    public async Task ElicitationRequestReceived_WhenOwnerChangesBeforeUiDispatch_DoesNotOccupyNewFormSlot()
+    {
+        var syncContext = new QueueingSynchronizationContext();
+        await using var fixture = CreateViewModel(syncContext);
+        var viewModel = fixture.ViewModel;
+        var previousService = CreateConnectedChatService();
+        await syncContext.RunUntilCompletedAsync(viewModel.ReplaceChatServiceAsync(previousService.Object, TestContext.Current.CancellationToken));
+        await fixture.UpdateStateAsync(state => state with
+        {
+            HydratedConversationId = "conv-1",
+            Bindings = ImmutableDictionary<string, ConversationBindingSlice>.Empty
+                .Add("conv-1", new ConversationBindingSlice("conv-1", "remote-1", "profile-1"))
+        });
+        await syncContext.RunUntilIdleAsync();
+        var currentService = CreateConnectedChatService();
+        var previousCancelled = 0;
+        previousService.Raise(service => service.ElicitationRequestReceived += null,
+            new ElicitationRequestEventArgs("same-id", new FormElicitationRequest
+            {
+                Scope = ElicitationScope.ForSession("remote-1"),
+                Message = "Stale form"
+            }, _ => Task.FromResult(false), () => Task.FromResult(false),
+                () => { Interlocked.Increment(ref previousCancelled); return Task.FromResult(false); }));
+        Assert.Null(viewModel.PendingElicitationRequest);
+
+        // Replace the owner on the UI thread while the previous request's insertion remains queued.
+        var originalContext = SynchronizationContext.Current;
+        try
+        {
+            SynchronizationContext.SetSynchronizationContext(syncContext);
+            viewModel.ReplaceChatService(currentService.Object);
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(originalContext);
+        }
+        syncContext.RunAll();
+        Assert.Null(viewModel.PendingElicitationRequest);
+        await WaitForConditionAsync(() => Task.FromResult(Volatile.Read(ref previousCancelled) == 1));
+        var currentCancelled = 0;
+        currentService.Raise(service => service.ElicitationRequestReceived += null,
+            new ElicitationRequestEventArgs("same-id", new FormElicitationRequest
+            {
+                Scope = ElicitationScope.ForSession("remote-1"),
+                Message = "Current form"
+            }, _ => Task.FromResult(true), () => Task.FromResult(true),
+                () => { Interlocked.Increment(ref currentCancelled); return Task.FromResult(true); }));
+        syncContext.RunAll();
+
+        Assert.Equal("Current form", viewModel.PendingElicitationRequest?.Prompt);
+        Assert.Equal(0, Volatile.Read(ref currentCancelled));
+        await syncContext.RunUntilCompletedAsync(viewModel.PendingElicitationRequest!.SubmitCommand.ExecuteAsync(null));
+        Assert.Null(viewModel.PendingElicitationRequest);
+    }
+
+    [Fact]
+    public async Task ElicitationRequestReceived_WhenDisposedBeforeUiDispatch_DoesNotRepopulateForm()
+    {
+        var syncContext = new QueueingSynchronizationContext();
+        await using var fixture = CreateViewModel(syncContext);
+        var service = CreateConnectedChatService();
+        await syncContext.RunUntilCompletedAsync(fixture.ViewModel.ReplaceChatServiceAsync(service.Object, TestContext.Current.CancellationToken));
+        await fixture.UpdateStateAsync(state => state with
+        {
+            HydratedConversationId = "conv-1",
+            Bindings = ImmutableDictionary<string, ConversationBindingSlice>.Empty
+                .Add("conv-1", new ConversationBindingSlice("conv-1", "remote-1", "profile-1"))
+        });
+        await syncContext.RunUntilIdleAsync();
+        var cancelled = 0;
+        service.Raise(chat => chat.ElicitationRequestReceived += null,
+            new ElicitationRequestEventArgs("form-1", new FormElicitationRequest
+            {
+                Scope = ElicitationScope.ForSession("remote-1"),
+                Message = "Stale form"
+            }, _ => Task.FromResult(false), () => Task.FromResult(false),
+                () => { Interlocked.Increment(ref cancelled); return Task.FromResult(false); }));
+
+        fixture.ViewModel.Dispose();
+        syncContext.RunAll();
+
+        Assert.Null(fixture.ViewModel.PendingElicitationRequest);
+        await WaitForConditionAsync(() => Task.FromResult(Volatile.Read(ref cancelled) == 1));
+    }
+
+    [Fact]
+    public async Task ElicitationRequestReceived_WhenPoolServiceChangesBeforeUiDispatch_PreservesForm()
+    {
+        var syncContext = new QueueingSynchronizationContext();
+        await using var fixture = CreateViewModel(syncContext);
+        var service = CreateConnectedChatService();
+        await syncContext.RunUntilCompletedAsync(fixture.ViewModel.ReplaceChatServiceAsync(service.Object, TestContext.Current.CancellationToken));
+        await fixture.UpdateStateAsync(state => state with
+        {
+            HydratedConversationId = "conv-1",
+            Bindings = ImmutableDictionary<string, ConversationBindingSlice>.Empty
+                .Add("conv-1", new ConversationBindingSlice("conv-1", "remote-1", "profile-1"))
+        });
+        await syncContext.RunUntilIdleAsync();
+        var cancelled = 0;
+        var replacement = ((IAcpChatCoordinatorSink)fixture.ViewModel).ReplaceChatServiceAsync(
+            CreateConnectedChatService().Object, ServiceReplaceIntent.PoolOnly, TestContext.Current.CancellationToken);
+        service.Raise(chat => chat.ElicitationRequestReceived += null,
+            new ElicitationRequestEventArgs("form-1", new FormElicitationRequest
+            {
+                Scope = ElicitationScope.ForSession("remote-1"),
+                Message = "Current form"
+            }, _ => Task.FromResult(true), () => Task.FromResult(true),
+                () => { Interlocked.Increment(ref cancelled); return Task.FromResult(true); }));
+        await syncContext.RunUntilCompletedAsync(replacement);
+
+        Assert.Equal("Current form", fixture.ViewModel.PendingElicitationRequest?.Prompt);
+        Assert.Equal(0, Volatile.Read(ref cancelled));
+        await syncContext.RunUntilCompletedAsync(fixture.ViewModel.PendingElicitationRequest!.SubmitCommand.ExecuteAsync(null));
+        Assert.Null(fixture.ViewModel.PendingElicitationRequest);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ElicitationRequestReceived_WhenFormAlreadyHeld_CancelsNewRequest(bool firstResponseInFlight)
+    {
+        await using var fixture = CreateViewModel();
+        var viewModel = fixture.ViewModel;
+        var chatService = CreateConnectedChatService();
+        viewModel.ReplaceChatService(chatService.Object);
+        var initialState = (await fixture.GetStateAsync()) with
+        {
+            HydratedConversationId = "conv-1",
+            Bindings = ImmutableDictionary<string, ConversationBindingSlice>.Empty
+                .Add("conv-1", new ConversationBindingSlice("conv-1", "remote-1", "profile-1"))
+        };
+        await fixture.UpdateStateAsync(_ => initialState);
+        await WaitForConditionAsync(() => Task.FromResult(viewModel.CurrentSessionId == "conv-1"));
+        var responseSent = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var form = new FormElicitationRequest
+        {
+            Scope = ElicitationScope.ForSession("remote-1"),
+            Message = "First request"
+        };
+        chatService.Raise(service => service.ElicitationRequestReceived += null,
+            new ElicitationRequestEventArgs("form-1", form,
+                _ => responseSent.Task, () => Task.FromResult(true), () => Task.FromResult(true)));
+        await WaitForConditionAsync(() => Task.FromResult(viewModel.PendingElicitationRequest is not null));
+        var first = viewModel.PendingElicitationRequest!;
+        var sending = firstResponseInFlight ? first.SubmitCommand.ExecuteAsync(null) : Task.CompletedTask;
+        var secondCancelled = 0;
+
+        chatService.Raise(service => service.ElicitationRequestReceived += null,
+            new ElicitationRequestEventArgs("form-2", new FormElicitationRequest
+            {
+                Scope = ElicitationScope.ForSession("remote-1"),
+                Message = "Second request"
+            }, _ => Task.FromResult(true), () => Task.FromResult(true),
+                () => { Interlocked.Increment(ref secondCancelled); return Task.FromResult(true); }));
+        await WaitForConditionAsync(() => Task.FromResult(Volatile.Read(ref secondCancelled) == 1));
+
+        Assert.Same(first, viewModel.PendingElicitationRequest);
+        Assert.False(viewModel.IsInputEnabled);
+        responseSent.SetResult(true);
+        await sending.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        if (!firstResponseInFlight)
+        {
+            await first.CancelCommand.ExecuteAsync(null);
+        }
+        Assert.Null(viewModel.PendingElicitationRequest);
+    }
+}
diff --git a/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatViewModelTests.cs b/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatViewModelTests.cs
index f0a85bf4b..03ddd76cd 100644
--- a/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatViewModelTests.cs
+++ b/tests/SalmonEgg.Presentation.Core.Tests/Chat/ChatViewModelTests.cs
@@ -43,6 +43,7 @@
 using SalmonEgg.Presentation.Core.ViewModels.ShellLayout;
 using SalmonEgg.Presentation.Models.Navigation;
 using SalmonEgg.Presentation.ViewModels.Chat;
+using SalmonEgg.Presentation.ViewModels.Chat.Elicitation;
 using SalmonEgg.Presentation.ViewModels.Settings;
 using SalmonEgg.Presentation.ViewModels.Navigation;
 using SalmonEgg.Presentation.ViewModels.Start;
@@ -698,6 +699,27 @@ await WaitForConditionAsync(() =>
         }
     }
 
+    [Fact]
+    public async Task LanguageChanged_WhenElicitationErrorIsHeld_ReprojectsLocalizedMessage()
+    {
+        var syncContext = new QueueingSynchronizationContext();
+        var localizer = new MutableTestCoreStringLocalizer();
+        localizer.Set("zh-Hans", "Elicitation_InvalidValue", "请检查填写内容");
+        localizer.Set("en-US", "Elicitation_InvalidValue", "Check this value");
+        var languageService = new Mock<IAppLanguageService>();
+        await using var fixture = CreateViewModel(syncContext, localizer: localizer, languageService: languageService.Object);
+        var field = new ElicitationStringFieldViewModel("name", new StringPropertySchema(), true, localizer);
+        fixture.ViewModel.PendingElicitationRequest = new ElicitationRequestViewModel("form", "session", "Choose", [field], localizer);
+        Assert.False(field.Validate());
+        Assert.Equal("请检查填写内容", field.ErrorMessage);
+
+        localizer.SetLanguageTag("en-US");
+        languageService.Raise(service => service.LanguageChanged += null, EventArgs.Empty);
+        syncContext.RunAll();
+
+        Assert.Equal("Check this value", field.ErrorMessage);
+    }
+
     [Fact]
     public async Task LanguageChanged_WhenAuthenticationHintIsHeld_ReprojectsLocalizedMessage()
     {
@@ -6168,6 +6190,7 @@ public async Task EnsureNewSessionDraftAsync_WhenCancelledAfterSessionNew_Closes
     {
         await using var fixture = CreateViewModel();
         using var cts = new CancellationTokenSource();
+        var closeCalled = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously);
         var chatService = CreateConnectedChatService();
         chatService.SetupGet(service => service.AgentCapabilities)
             .Returns(new AgentCapabilities(sessionCapabilities: new SessionCapabilities
@@ -6183,6 +6206,7 @@ public async Task EnsureNewSessionDraftAsync_WhenCancelledAfterSessionNew_Closes
         chatService.Setup(service => service.CloseSessionAsync(
                 It.Is<SessionCloseParams>(p => p.SessionId == "remote-draft"),
                 It.IsAny<CancellationToken>()))
+            .Callback(() => closeCalled.TrySetResult(null))
             .ReturnsAsync(SessionCloseResponse.Completed);
 
         await fixture.ViewModel.ReplaceChatServiceAsync(chatService.Object, TestContext.Current.CancellationToken);
@@ -6193,8 +6217,10 @@ public async Task EnsureNewSessionDraftAsync_WhenCancelledAfterSessionNew_Closes
         await Assert.ThrowsAnyAsync<OperationCanceledException>(() =>
             fixture.ViewModel.EnsureNewSessionDraftAsync(@"C:\Repo\App", cts.Token));
 
-        await WaitForConditionAsync(async () =>
-            (await fixture.GetConnectionStateAsync()).NewSessionDraft is null);
+        // The draft is cleared before asynchronous remote cleanup. Wait for this operation's close,
+        // rather than treating the empty local projection as evidence that cleanup has finished.
+        await closeCalled.Task.WaitAsync(TimeSpan.FromSeconds(2), TestContext.Current.CancellationToken);
+        Assert.Null((await fixture.GetConnectionStateAsync()).NewSessionDraft);
         chatService.Verify(service => service.CloseSessionAsync(
             It.Is<SessionCloseParams>(p => p.SessionId == "remote-draft"),
             It.IsAny<CancellationToken>()), Times.Once);
diff --git a/tests/SalmonEgg.Presentation.Core.Tests/Chat/Elicitation/ElicitationInteractionViewModelTests.cs b/tests/SalmonEgg.Presentation.Core.Tests/Chat/Elicitation/ElicitationInteractionViewModelTests.cs
new file mode 100644
index 000000000..51296713d
--- /dev/null
+++ b/tests/SalmonEgg.Presentation.Core.Tests/Chat/Elicitation/ElicitationInteractionViewModelTests.cs
@@ -0,0 +1,159 @@
+using System.Text.Json;
+using SalmonEgg.Acp.Client;
+using SalmonEgg.Acp.Protocol;
+using SalmonEgg.Presentation.Core.Tests.Localization;
+using SalmonEgg.Presentation.ViewModels.Chat.Elicitation;
+
+namespace SalmonEgg.Presentation.Core.Tests.Chat.Elicitation;
+
+public sealed class ElicitationInteractionViewModelTests
+{
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task SubmitAsync_WhenRequiredFieldCannotBeRendered_NeverAccepts(bool declaredProperty)
+    {
+        var schema = new ElicitationSchema { Required = ["future"] };
+        if (declaredProperty)
+        {
+            schema.Properties.Add("future", new CustomPropertySchema { SchemaType = "_future" });
+        }
+
+        var accepted = 0;
+        var cancelled = 0;
+        var cleared = 0;
+        var request = Create(schema,
+            _ => { accepted++; return Task.FromResult(true); },
+            () => { cancelled++; return Task.FromResult(true); },
+            () => { cleared++; return Task.CompletedTask; });
+
+        // Executing the command directly must obey the same contract as the disabled button.
+        await request.SubmitCommand.ExecuteAsync(null);
+
+        Assert.Equal(0, accepted);
+        Assert.False(request.CanSubmit);
+        Assert.True(request.HasError);
+        Assert.Equal(0, cleared);
+        await request.CancelCommand.ExecuteAsync(null);
+        Assert.Equal(1, cancelled);
+        Assert.Equal(1, cleared);
+    }
+
+    [Fact]
+    public async Task SubmitAsync_WhenOnlyOptionalFieldIsUnknown_OmitsItAndPreservesKnownValues()
+    {
+        var schema = new ElicitationSchema
+        {
+            Properties = new()
+            {
+                ["future"] = new CustomPropertySchema { SchemaType = "_future" },
+                ["name"] = new StringPropertySchema { Default = "Salmon" },
+                ["count"] = new IntegerPropertySchema { Default = 3 },
+                ["ratio"] = new NumberPropertySchema { Default = 0.5 },
+                ["enabled"] = new BooleanPropertySchema { Default = true },
+                ["targets"] = new MultiSelectPropertySchema
+                {
+                    Items = new StringMultiSelectItems { Enum = ["api", "ui"] },
+                    Default = ["api"]
+                }
+            },
+            Required = ["name", "enabled"]
+        };
+        ElicitationAcceptContent? accepted = null;
+        var request = Create(schema, content => { accepted = content; return Task.FromResult(true); });
+
+        Assert.True(request.CanSubmit);
+        await request.SubmitCommand.ExecuteAsync(null);
+
+        Assert.NotNull(accepted);
+        Assert.Equal(5, request.Fields.Count);
+        Assert.False(accepted.Values.ContainsKey("future"));
+        Assert.Equal("Salmon", accepted.Values["name"].RawValue.GetString());
+        Assert.Equal(JsonValueKind.Number, accepted.Values["count"].RawValue.ValueKind);
+        Assert.Equal(3, accepted.Values["count"].RawValue.GetInt64());
+        Assert.Equal(0.5, accepted.Values["ratio"].RawValue.GetDouble());
+        Assert.True(accepted.Values["enabled"].RawValue.GetBoolean());
+        Assert.Equal("[\"api\"]", accepted.Values["targets"].RawValue.GetRawText());
+    }
+
+    [Theory]
+    [InlineData("string")]
+    [InlineData("integer")]
+    [InlineData("number")]
+    [InlineData("array")]
+    public void ReprojectLocalizedState_WhenValidationErrorIsVisible_RefreshesLanguage(string kind)
+    {
+        var localizer = new MutableTestCoreStringLocalizer();
+        localizer.Set("zh-Hans", "Elicitation_InvalidValue", "请检查填写内容");
+        localizer.Set("en-US", "Elicitation_InvalidValue", "Check this value");
+        ElicitationPropertySchema property = kind switch
+        {
+            "integer" => new IntegerPropertySchema(),
+            "number" => new NumberPropertySchema(),
+            "array" => new MultiSelectPropertySchema(),
+            _ => new StringPropertySchema()
+        };
+        var schema = new ElicitationSchema { Properties = new() { ["value"] = property }, Required = ["value"] };
+        var args = CreateArgs(schema, _ => Task.FromResult(true));
+        var request = ElicitationInteractionViewModelFactory.Create(args, _ => Task.CompletedTask, localizer);
+        var field = Assert.Single(request.Fields);
+
+        Assert.False(field.Validate());
+        Assert.Equal("请检查填写内容", field.ErrorMessage);
+        localizer.SetLanguageTag("en-US");
+        request.ReprojectLocalizedState();
+
+        Assert.Equal("Check this value", field.ErrorMessage);
+    }
+
+    [Fact]
+    public async Task SubmitAsync_WhenResponseFails_KeepsFormForRetry()
+    {
+        var attempts = 0;
+        var cleared = 0;
+        var request = Create(new ElicitationSchema(),
+            _ => Task.FromResult(++attempts > 1),
+            clear: () => { cleared++; return Task.CompletedTask; });
+
+        await request.SubmitCommand.ExecuteAsync(null);
+        Assert.True(request.HasError);
+        Assert.Equal(0, cleared);
+        await request.SubmitCommand.ExecuteAsync(null);
+        Assert.Equal(2, attempts);
+        Assert.Equal(1, cleared);
+        Assert.False(request.HasError);
+    }
+
+    [Fact]
+    public async Task CanSubmit_AfterUnsupportedFormCancelFails_PreservesResponseFailure()
+    {
+        var request = Create(new ElicitationSchema { Required = ["future"] },
+            _ => Task.FromResult(true), () => Task.FromResult(false));
+
+        await request.CancelCommand.ExecuteAsync(null);
+        var responseError = request.ErrorMessage;
+
+        Assert.Contains("response could not be sent", responseError, StringComparison.Ordinal);
+        Assert.False(request.CanSubmit);
+        Assert.Equal(responseError, request.ErrorMessage);
+    }
+
+    private static ElicitationRequestViewModel Create(
+        ElicitationSchema schema,
+        Func<ElicitationAcceptContent?, Task<bool>> accept,
+        Func<Task<bool>>? cancel = null,
+        Func<Task>? clear = null)
+        => ElicitationInteractionViewModelFactory.Create(
+            CreateArgs(schema, accept, cancel), _ => clear?.Invoke() ?? Task.CompletedTask);
+
+    private static ElicitationRequestEventArgs CreateArgs(
+        ElicitationSchema schema,
+        Func<ElicitationAcceptContent?, Task<bool>> accept,
+        Func<Task<bool>>? cancel = null)
+        => new("request-1", new FormElicitationRequest
+        {
+            Scope = ElicitationScope.ForSession("session-1"),
+            Message = "Choose settings",
+            RequestedSchema = schema
+        }, accept, () => Task.FromResult(true), cancel ?? (() => Task.FromResult(true)));
+}
diff --git a/tests/SalmonEgg.Presentation.Core.Tests/Chat/Interactions/ChatElicitationRoutingTests.cs b/tests/SalmonEgg.Presentation.Core.Tests/Chat/Interactions/ChatElicitationRoutingTests.cs
new file mode 100644
index 000000000..7331a0a49
--- /dev/null
+++ b/tests/SalmonEgg.Presentation.Core.Tests/Chat/Interactions/ChatElicitationRoutingTests.cs
@@ -0,0 +1,110 @@
+using System.Text.Json;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using SalmonEgg.Acp.Client;
+using SalmonEgg.Acp.Protocol;
+using SalmonEgg.Application.Services.Chat;
+using SalmonEgg.Domain.Services;
+using SalmonEgg.Presentation.Core.Services.Chat;
+using SalmonEgg.Presentation.ViewModels.Chat.Elicitation;
+using SalmonEgg.Presentation.ViewModels.Chat.Interactions;
+using SalmonEgg.Presentation.ViewModels.Chat.Panels;
+
+namespace SalmonEgg.Presentation.Core.Tests.Chat.Interactions;
+
+public sealed class ChatElicitationRoutingTests
+{
+    [Theory]
+    [InlineData("request")]
+    [InlineData("unbound-session")]
+    [InlineData("routing-failure")]
+    public async Task BuildElicitationRequestAsync_WhenFormCannotBeShown_SendsOneCancelResponse(string scenario)
+    {
+        var transport = new Mock<IAcpTransport>();
+        var responses = new List<JsonElement>();
+        SetupTransport(transport, responses);
+        using var client = new AcpClient(transport.Object, Mock.Of<IAcpClientLogger>());
+        using var service = new ChatService(client, Mock.Of<IErrorLogger>(), Mock.Of<ISessionManager>());
+        await client.InitializeAsync(new InitializeParams(new ClientInfo("Test", "1"), ClientCapabilityDefaults.Create()), TestContext.Current.CancellationToken);
+        var router = new Mock<IAuthoritativeRemoteSessionRouter>();
+        if (scenario == "routing-failure")
+        {
+            router.Setup(x => x.ResolveConversationIdAsync("remote", It.IsAny<CancellationToken>()))
+                .ThrowsAsync(new InvalidOperationException("Route unavailable"));
+        }
+
+        var bridge = new ChatInteractionEventBridge(router.Object, new ChatTerminalProjectionCoordinator());
+        Task<(string ConversationId, ElicitationRequestViewModel ViewModel)?>? projection = null;
+        ElicitationRequestEventArgs? received = null;
+        service.ElicitationRequestReceived += (_, args) =>
+        {
+            received = args;
+            projection = bridge.BuildElicitationRequestAsync(args, (_, _) => Task.CompletedTask, NullLogger.Instance);
+        };
+        var scope = scenario == "request" ? "\"requestId\":12" : "\"sessionId\":\"remote\"";
+        transport.Raise(t => t.MessageReceived += null, new AcpTransportMessageReceivedEventArgs(
+            $$$"""{"jsonrpc":"2.0","id":"form-1","method":"elicitation/create","params":{ {{{scope}}},"mode":"form","message":"Choose","requestedSchema":{"type":"object","properties":{}} }}"""));
+
+        Assert.NotNull(projection);
+        Assert.Null(await projection.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken));
+        var response = Assert.Single(responses);
+        Assert.Equal("form-1", response.GetProperty("id").GetString());
+        Assert.False(response.TryGetProperty("error", out _));
+        Assert.Equal("{\"action\":\"cancel\"}", response.GetProperty("result").GetRawText());
+        Assert.NotNull(received);
+        Assert.False(await received.Cancel());
+        Assert.Single(responses);
+    }
+
+    [Fact]
+    public async Task BuildElicitationRequestAsync_WhenConversationResolves_WaitsForUserAndClearsAfterResponse()
+    {
+        var router = new Mock<IAuthoritativeRemoteSessionRouter>();
+        router.Setup(x => x.ResolveConversationIdAsync("remote", It.IsAny<CancellationToken>())).ReturnsAsync("conversation");
+        var bridge = new ChatInteractionEventBridge(router.Object, new ChatTerminalProjectionCoordinator());
+        var accepted = 0;
+        var cancelled = 0;
+        string? cleared = null;
+        ElicitationRequestViewModel? clearedRequest = null;
+        var args = new ElicitationRequestEventArgs("form-1", new FormElicitationRequest
+        {
+            Scope = ElicitationScope.ForSession("remote"),
+            Message = "Choose"
+        }, _ => { accepted++; return Task.FromResult(true); }, () => Task.FromResult(true),
+            () => { cancelled++; return Task.FromResult(true); });
+
+        var result = await bridge.BuildElicitationRequestAsync(args,
+            (id, request) => { cleared = id; clearedRequest = request; return Task.CompletedTask; }, NullLogger.Instance);
+
+        Assert.NotNull(result);
+        Assert.Equal("conversation", result.Value.ConversationId);
+        Assert.Equal(0, accepted);
+        Assert.Equal(0, cancelled);
+        Assert.Null(cleared);
+        await result.Value.ViewModel.SubmitCommand.ExecuteAsync(null);
+        Assert.Equal(1, accepted);
+        Assert.Equal("conversation", cleared);
+        Assert.Same(result.Value.ViewModel, clearedRequest);
+    }
+
+    private static void SetupTransport(Mock<IAcpTransport> transport, List<JsonElement> responses)
+    {
+        transport.SetupGet(t => t.IsConnected).Returns(true);
+        transport.Setup(t => t.SendMessageAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+            .Callback<string, CancellationToken>((message, cancellationToken) =>
+            {
+                using var document = JsonDocument.Parse(message);
+                var root = document.RootElement;
+                if (root.TryGetProperty("method", out var method) && method.GetString() == "initialize")
+                {
+                    var id = root.GetProperty("id").GetRawText();
+                    transport.Raise(t => t.MessageReceived += null, new AcpTransportMessageReceivedEventArgs(
+                        $$$$"""{"jsonrpc":"2.0","id":{{{{id}}}},"result":{"protocolVersion":1,"agentInfo":{"name":"Test agent","version":"1"},"agentCapabilities":{}}}"""));
+                }
+                else if (root.TryGetProperty("id", out _) && !root.TryGetProperty("method", out _))
+                {
+                    responses.Add(root.Clone());
+                }
+            }).ReturnsAsync(true);
+    }
+}
diff --git a/tests/SalmonEgg.Presentation.Core.Tests/Chat/Panels/ChatConversationPanelStateCoordinatorTests.cs b/tests/SalmonEgg.Presentation.Core.Tests/Chat/Panels/ChatConversationPanelStateCoordinatorTests.cs
index 39b5379a6..a45dad97d 100644
--- a/tests/SalmonEgg.Presentation.Core.Tests/Chat/Panels/ChatConversationPanelStateCoordinatorTests.cs
+++ b/tests/SalmonEgg.Presentation.Core.Tests/Chat/Panels/ChatConversationPanelStateCoordinatorTests.cs
@@ -1,4 +1,5 @@
 using SalmonEgg.Presentation.ViewModels.Chat;
+using SalmonEgg.Presentation.ViewModels.Chat.Elicitation;
 using SalmonEgg.Presentation.ViewModels.Chat.Panels;
 using Xunit;
 
@@ -58,4 +59,21 @@ public void RemoveConversation_WhenCurrentConversation_ReturnsEmptySelection()
         Assert.Null(selection.SelectedTerminal);
         Assert.Null(selection.PendingAskUserRequest);
     }
+
+    [Fact]
+    public void RemoveElicitationRequest_WhenPreviousOwnerCompletes_DoesNotRemoveReusedId()
+    {
+        var sut = new ChatConversationPanelStateCoordinator();
+        var previous = new ElicitationRequestViewModel("same-id", "remote", "First", []);
+        var current = new ElicitationRequestViewModel("same-id", "remote", "Second", []);
+        Assert.True(sut.TryStoreElicitationRequest("conversation", previous));
+        sut.ClearElicitationRequests();
+        Assert.True(sut.TryStoreElicitationRequest("conversation", current));
+
+        Assert.False(sut.RemoveElicitationRequest("conversation", previous));
+
+        Assert.Same(current, sut.GetPendingElicitationRequest("conversation"));
+        Assert.True(sut.RemoveElicitationRequest("conversation", current));
+        Assert.Null(sut.GetPendingElicitationRequest("conversation"));
+    }
 }
diff --git a/tests/SalmonEgg.Presentation.Core.Tests/Localization/TransportErrorMessageFormatterTests.cs b/tests/SalmonEgg.Presentation.Core.Tests/Localization/TransportErrorMessageFormatterTests.cs
new file mode 100644
index 000000000..76f4094f4
--- /dev/null
+++ b/tests/SalmonEgg.Presentation.Core.Tests/Localization/TransportErrorMessageFormatterTests.cs
@@ -0,0 +1,124 @@
+using System.Globalization;
+using System.Resources;
+using Microsoft.Extensions.Localization;
+using SalmonEgg.Domain.Interfaces.Transport;
+using SalmonEgg.Presentation.Core.Localization;
+using SalmonEgg.Presentation.Core.Resources;
+
+namespace SalmonEgg.Presentation.Core.Tests.Localization;
+
+public sealed class TransportErrorMessageFormatterTests
+{
+    [Theory]
+    [InlineData("zh-Hans", true, "在 PATH 中找不到 Agent 命令“my-agent”。请安装该 Agent，或在配置中填写可执行文件的完整路径。")]
+    [InlineData("zh-Hans", false, "配置的 Agent 命令“my-agent”不存在。请检查 Agent 配置中的路径。")]
+    [InlineData("en-US", true, "Agent command 'my-agent' was not found on PATH. Install the agent or configure the full path to its executable.")]
+    [InlineData("en-US", false, "The configured agent command 'my-agent' does not exist. Check the path in the agent configuration.")]
+    public void Format_WhenCommandResolutionFailed_UsesLocalizedResource(string languageTag, bool searchedOnPath, string expected)
+    {
+        // Arrange
+        var formatter = new TransportErrorMessageFormatter(new ResourceLocalizer(languageTag));
+        var error = new TransportErrorEventArgs("Original transport detail.", kind: TransportErrorKind.ProcessStartFailed)
+        {
+            CommandResolutionFailure = new StdioCommandResolutionFailure("my-agent", searchedOnPath)
+        };
+
+        // Act
+        var message = formatter.Format(error);
+
+        // Assert
+        Assert.Equal(expected, message);
+        Assert.Equal("Original transport detail.", error.ErrorMessage);
+    }
+
+    [Fact]
+    public void Format_AfterLanguageChanges_UsesCurrentLanguage()
+    {
+        // Arrange
+        var localizer = new ResourceLocalizer("zh-Hans");
+        var formatter = new TransportErrorMessageFormatter(localizer);
+        var error = new TransportErrorEventArgs("Original transport detail.", kind: TransportErrorKind.ProcessStartFailed)
+        {
+            CommandResolutionFailure = new StdioCommandResolutionFailure("my-agent", SearchedOnPath: true)
+        };
+
+        // Act
+        var chineseMessage = formatter.Format(error);
+        localizer.LanguageTag = "en-US";
+        var englishMessage = formatter.Format(error);
+
+        // Assert
+        Assert.StartsWith("在 PATH 中找不到", chineseMessage, StringComparison.Ordinal);
+        Assert.StartsWith("Agent command", englishMessage, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Format_WithoutResolutionFailure_PreservesDiagnosticsAndInnerException()
+    {
+        // Arrange
+        var exception = new IOException("Read interrupted.");
+        var error = new TransportErrorEventArgs("stdout closed", exception, TransportErrorKind.StdoutReadFailed);
+        var formatter = new TransportErrorMessageFormatter(new ResourceLocalizer("zh-Hans"));
+
+        // Act
+        var message = formatter.Format(error);
+
+        // Assert
+        Assert.Equal(error.ErrorMessage, message);
+        Assert.Same(exception, error.Exception);
+    }
+
+    [Fact]
+    public void Format_WhenResourceIsMissing_PreservesOriginalFallback()
+    {
+        // Arrange
+        var formatter = new TransportErrorMessageFormatter(new MutableTestCoreStringLocalizer());
+        var error = new TransportErrorEventArgs("The configured agent command '/tmp/{agent.exe' does not exist.")
+        {
+            CommandResolutionFailure = new StdioCommandResolutionFailure("/tmp/{agent.exe", SearchedOnPath: false)
+        };
+
+        // Act
+        var message = formatter.Format(error);
+
+        // Assert
+        Assert.Equal(error.ErrorMessage, message);
+    }
+
+    [Fact]
+    public void Format_WhenCommandContainsBraces_PreservesLiteralPath()
+    {
+        // Arrange
+        var formatter = new TransportErrorMessageFormatter(new ResourceLocalizer("zh-Hans"));
+        var error = new TransportErrorEventArgs("Original transport detail.", kind: TransportErrorKind.ProcessStartFailed)
+        {
+            CommandResolutionFailure = new StdioCommandResolutionFailure("/tmp/{agent.exe", SearchedOnPath: false)
+        };
+
+        // Act
+        var message = formatter.Format(error);
+
+        // Assert
+        Assert.Equal("配置的 Agent 命令“/tmp/{agent.exe”不存在。请检查 Agent 配置中的路径。", message);
+    }
+
+    private sealed class ResourceLocalizer(string languageTag) : IStringLocalizer<CoreStrings>
+    {
+        private static readonly ResourceManager Resources = new(typeof(CoreStrings).FullName!, typeof(CoreStrings).Assembly);
+
+        public string LanguageTag { get; set; } = languageTag;
+
+        public LocalizedString this[string name] => GetString(name, []);
+
+        public LocalizedString this[string name, params object[] arguments] => GetString(name, arguments);
+
+        public IEnumerable<LocalizedString> GetAllStrings(bool includeParentCultures) => [];
+
+        private LocalizedString GetString(string name, object[] arguments)
+        {
+            var culture = CultureInfo.GetCultureInfo(LanguageTag);
+            var value = Resources.GetString(name, culture);
+            return new LocalizedString(name, value is null ? name : string.Format(culture, value, arguments), value is null);
+        }
+    }
+}