@ai-workbench/remote-agent 0.8.13 → 0.8.15

package/README.md

@@ -1,10 +1,10 @@
-**`@ai-workbench/remote-agent@0.8.13` 发布形态包；由编排发布后通过官方插件 → 添加插件安装。修复 Claude 模型目录及旧默认模型，供 leo 真机复验。Codex 线因主机适配器 aw.2 实装失败（UNSAFE_MODE_MISMATCH），待 S 修复后另验，当前未验证可用。由编排统一发布，X 未执行 publish。**
+**`@ai-workbench/remote-agent@0.8.15` 发布形态包。模型菜单逐项解析与同次展示目录保持一致；失效选择明确提示重新选择，发送准备和每轮发送仍独立查可信目录。模型型号、推理等级和来源只进技术详情；本机执行说明每个会话首次一句，完整限制可在技术详情查阅。编排已回证0.8.14 Claude在leo本地文件夹首轮成功；0.8.15仍待真机复验，Codex历史EMPLOYEE_EXEC_CLOSED根因仍未查明。X2出固定包及SHA，不publish。通过官方插件 → 添加插件安装，由编排发布；X2不publish。**
 
 # 远程ACP插件
 
 一个插件提供 **Claude（远程主机）** 和 **Codex（远程主机）**，通过员工主机上的官方CLI运行。Codex保留单次模式；Claude固定会话模式。只用官方模型列表、插件管理和配置入口，不提供自制面板、问答或登录按钮。登录和原生工作区绑定唯一归连接插件L。
 
-当前版本号为0.8.13；包名采用`@ai-workbench/remote-agent`以涵盖两个品牌；本轮按编排放行准备发布形态包，供 leo 真机自验；X 不执行实际发布，由编排统一发布。开发fixture逐字节保留L0.7.19固定包，公开类型与SSH导出从该包消费。运行时仍要求L的`getContractInfo()`同时返回API0.7.0、implemented、native-local-v1；旧L包、draft.3或只有版本号的不完整实现会明确报缺项。依赖范围为`~0.7.19`，L由官方插件管理单独安装，不打进X。组件验证不代表真实开通、模型或leo E通过；HanaMesh另验。
+当前版本号为0.8.15；包名采用`@ai-workbench/remote-agent`以涵盖两个品牌；本轮按编排放行准备发布形态包，供 leo 真机自验；X 不执行实际发布，由编排统一发布。开发fixture逐字节保留L0.7.19固定包，公开类型与SSH导出从该包消费。运行时仍要求L的`getContractInfo()`同时返回API0.7.0、implemented、native-local-v1；旧L包、draft.3或只有版本号的不完整实现会明确报缺项。依赖范围为`~0.7.19`，L由官方插件管理单独安装，不打进X。组件验证不代表真实开通、模型或leo E通过；HanaMesh另验。
 
 已包含L0.7.18消费增量：来源确认、输入接纳、登录、本机接纳、输入准备、模型目录及运行时解析的早期失败，用正式`preflightDiagnostics:1` / `preflight-check`进入L「连接前技术详情（含登录与工作区确认）」。阶段、真实来源/状态和错误代码可展开；未知来源为null，旧login-check的完整安全原因保留。记录不选择来源、不接纳输入、不自动重发；无原生会话的菜单查询仍在模型设置报告。当前工程和设置组件验证不等于leo GUI验收。
 
@@ -12,7 +12,7 @@
 
 ## 员工路径
 
-从官方插件管理安装，照常使用默认工作区/会话/模型入口。L0.7.17沿唯一“远程主机连接”设置节记录文件来源；主机来源沿用L既有解析；本地来源接入N0.4.4/S0.4.11员工端点。旧映射可在本轮官方一次确认中选择改用本机文件夹；拒绝、取消或输入/来源变化时不切换、不执行。也可在L设置逐工作区确认沿用原主机关联，新主机位置仍按L现有合同停止为WORKSPACE_LOCATION_PROVIDER_REQUIRED。本地六类工具经Claude公开toolAliases路由到员工电脑：cwd是员工选定目录，Git使用本机仓库，不回退主机同名目录。本地真实员工输入先取得官方当前轮次CAS预期，再调用L0.7.17 acceptLocalWorkspaceUserTurn；核回包后才打开D19和本轮主机目录/执行。每轮localAcceptanceId冻结进原详情sink，迟到结果不借新轮ID；LOCAL_USER_TURN_CHANGED立即停止本轮，不重接纳或退legacy。已用固定真包完成本地D19组件联测；真实N/S员工端仍NOT_RUN，产品验收以 leo 实际执行结果为准。本地文件不自动上传，X不猜目录、不选首项。首次说明使用官方普通回复；先经官方会话提交、持久化并读回核对，才向L确认。持久记录不等于员工已看见，GUI另验；日志丢失后的未知claim由L保留，不宣称端到端恰好一次。
+从官方插件管理安装，照常使用默认工作区/会话/模型入口。L0.7.17沿唯一“远程主机连接”设置节记录文件来源；主机来源沿用L既有解析；本地来源接入N0.4.4/S0.4.11员工端点。旧映射可在本轮官方一次确认中选择改用本机文件夹；拒绝、取消或输入/来源变化时不切换、不执行。也可在L设置逐工作区确认沿用原主机关联，新主机位置仍按L现有合同停止为WORKSPACE_LOCATION_PROVIDER_REQUIRED。本地六类工具经Claude公开toolAliases路由到员工电脑：cwd是员工选定目录，Git使用本机仓库，不回退主机同名目录。本地真实员工输入先取得官方当前轮次CAS预期，再调用L0.7.17 acceptLocalWorkspaceUserTurn；核回包后才打开D19和本轮主机目录/执行。每轮localAcceptanceId冻结进原详情sink，迟到结果不借新轮ID；LOCAL_USER_TURN_CHANGED立即停止本轮，不重接纳或退legacy。已用固定真包完成本地D19组件联测；编排已回证0.8.14 Claude/Opus5/Default在leo本地目录首轮写文件成功；该回证不覆盖本0.8.15或Codex，产品验收以各版本leo实际结果为准。本地文件不自动上传，X不猜目录、不选首项。首次说明使用官方普通回复；先经官方会话提交、持久化并读回核对，才向L确认。持久记录不等于员工已看见，GUI另验；日志丢失后的未知claim由L保留，不宣称端到端恰好一次。
 
 未登录时两个模型均回复：**需要登录，请到设置 → 远程主机连接 点登录**。无L或缺正式能力时直接说明缺项，不让员工填写主机、用户、路径或密钥。
 
@@ -24,11 +24,11 @@
 
 文本、思考、工具步骤/正文/补丁、计划、通知映射为官方普通流；远端工具不变成本机工具调用。图片输入由官方附件服务读取已核验字节，经ACP传给主机，不传员工文件路径。非文本输出无法得到官方持久附件引用时，明确说明收到的内容类型与所缺能力，不假造图片引用。远端结构化提问、未映射扩展会明确提示并取消，不静默丢弃。
 
-首次系统/开发者上下文按协商的ACP系统能力传入。**首版不支持：已有Claude会话中立即生效的系统/开发者上下文变更。** 固定适配器说明恢复后的变更要到下次上下文整理才生效；X发现变更会停止本轮派发并提示新建会话，避免按旧约束执行，不自动整理、重试或新建替代会话。未声明系统能力的agent会明确报缺项。
+首次系统/开发者上下文按协商的ACP系统能力传入。**首版不支持：已有Claude会话中立即生效的系统/开发者上下文变更。** 固定适配器说明恢复后的变更要到下次上下文整理才生效；X按已有公开 resume/load 传送新要求，技术详情注明延迟生效，继续本轮；不宣称本轮已立即采用，不自动整理或重试。实际 RPC 拒绝或缺少公开更新能力仍会明确停止。未声明系统能力的agent会明确报缺项。
 
 `usage_update`的used/size是上下文占用，不能当作本轮输入/输出计费量；远端真实prompt响应usage及Claude quota令牌计数是会话累计，按保存在当前实例/恢复标识中的可信基线减差后进入DSH本轮用量；重复值不重复结算。恢复缺少基线、计数缺失、回退或来源改变时明确不计入该轮，重建可信基线，不能把历史用量算成本轮。
 
-会话模式跨轮保留同一ACP客户端和主机进程；关闭实际agent/session或插件时精确清理。重开恢复优先协商resume，无能力时明确使用load，不静默新建。恢复标识绑定品牌、员工目标、DSH会话和L工作区；复制/分叉不能沿用父远端会话。主机来源沿用D24同实例自动恢复/安全重建。本地来源重开后原MCP socket失效，先由既有S同实例条件流程结束旧broker再重建，不代答旧审批；未获真实清理确认时保留未知，不自动重放。无TTL或隐式淘汰上限。
+会话模式跨轮保留同一ACP客户端和主机进程；关闭实际agent/session或插件时精确清理。重开恢复优先协商resume，无能力时明确使用load，不静默新建。恢复标识绑定品牌、员工目标、DSH会话和L工作区；复制/分叉不能沿用父远端会话。主机来源沿用D24同实例自动恢复/安全重建。本地来源重开后原MCP socket失效，先由既有S同实例条件流程结束旧broker再重建，不代答旧审批；未获真实清理确认时保留未知，不自动重放。无TTL或隐式淘汰上限。缺私有恢复 pointer 只撤回恢复资格；只有原 slot 不存在已核实，或同 UUID 条件结束与 list 消失均确认，才新建并仅使用官方本次接纳的输入 ID。纯发送前失败经确认清理后不永久封住新轮；真实输入送达未知、dirty 或清理未知仍阻断重放。
 
 Codex单次模式首版仅文本，不转接中途审批；图片或系统/开发者上下文需使用会话模式。文件传输、远端VFS与自动同步不在本轮。其他模型不锁定、不拦截、不记录。
 
@@ -74,9 +74,9 @@ D22阶段耗时进入技术详情；D23文件审批用中文动作，原工具
 
 D21（0.8.5）：两个品牌的官方模型菜单从 L 的 `modelCatalogTarget:1` / `getModelCatalogTarget` 取得当前可信员工目标，再只读调用 S 的 `aw-model-catalog --provider codex|claude`。目录按 host-user 作用域展示完整模型与逐模型推理等级，保留远端标识原值；失败显示“无法获取模型列表：原因”，不登录、不创建项目、不返回替代模型。L 必须宣告该正式能力，S 必须安装保护入口；这两项未就绪时不能据组件测试声称菜单可用。
 
-每轮先核对目录代次和所选模型，再经 ACP 逐项配置模型及推理等级，收到完整配置确认后才发送输入。Claude 别名必须有当前会话的具体型号证据；没有就明确拒绝。真实回复追加所选值和远端确认值，并在恢复标识与技术详情保留，确认配置不等于验证推理效果。连接/身份/目录变化清除旧确认；远端清理待定或结果未知时阻止派发，不自动清理重试或另开替代会话。Codex 单次模式当前不能确认此选择，会在发送前明确拒绝。新增设置 0；本轮工程证据、真实只读链路与产品未验项见 `docs/evidence/2026-10-22-X2-D21/`。
+每轮先核对目录代次和所选模型，再经 ACP 逐项配置模型及推理等级，收到完整配置确认后才发送输入。Claude 别名每轮须有精确的模型配置成功回执，并由同一员工主机、同一连接代际的目录唯一映射到具体型号。具体型号注明来自主机目录，会话未单独回报；旧恢复记录不作本轮证据。目录缺项、映射不唯一、回执不符或身份/代际变化时不发送输入。所选值、远端确认值及型号来源仅在恢复标识与技术详情保留，插件不向真实回复追加技术参数，确认配置不等于验证推理效果。连接/身份/目录变化清除旧确认；远端清理待定或结果未知时阻止派发，不自动清理重试或另开替代会话。Codex 单次模式当前不能确认此选择，会在发送前明确拒绝。新增设置 0；本轮工程证据、真实只读链路与产品未验项见 `docs/evidence/2026-10-22-X2-D21/`。
 
-0.8.5统一包原依赖L `~0.7.13`；当前0.8.13对齐L `~0.7.19`。D8模型目录双事件长期监听保留；同epoch的recovery提示/失败消息变化不触发执行状态失效，真实实例/epoch/phase/可信目标/登录变化仍失效。完整D9两品牌正文/状态/就绪门呈现按编排00:50允许的范围记下一版，本版不宣称已消费完成；L的connectionMessages.administratorAfterMs仍只由L管理，X新增设置0。
+0.8.5统一包原依赖L `~0.7.13`；当前0.8.15对齐L `~0.7.19`。D8模型目录双事件长期监听保留；同epoch的recovery提示/失败消息变化不触发执行状态失效，真实实例/epoch/phase/可信目标/登录变化仍失效。完整D9两品牌正文/状态/就绪门呈现按编排00:50允许的范围记下一版，本版不宣称已消费完成；L的connectionMessages.administratorAfterMs仍只由L管理，X新增设置0。
 
 D18（0.8.6）：Codex 需要主机自有 adapter `2.2.2-aw.1` 的明确新建会话上下文政策，官方 CLI 仍为未改的0.160.1。系统/开发者要求仅在新建时生效；恢复时与初建摘要相同则正常恢复且省略新建专用字段，不声称恢复接口会更新指令。要求不同或清空时，在同一真实回复说明“会话要求已变化，已新建 Codex 会话继续处理，原会话仍保留。”，并新建远端承接公开对话，保留旧标识和查询记录；旧/非法初建摘要明确拒绝，不能猜测。
 
@@ -88,7 +88,7 @@ D18（0.8.6）：Codex 需要主机自有 adapter `2.2.2-aw.1` 的明确新建
 
 Read/Write/Edit/Glob/Grep由员工DSH同UID后端执行；Bash经L严格SSH到S同代桥再经N员工SSH端点执行，命令正文只走stdin。每次调用核官方会话唯一工作区、L实例/epoch/绑定/目录身份、N真实prepare及S实时target。取消、SSH255或退出证明缺失记录UNKNOWN，不重放。只关闭自己的绑定执行器，不撤其他工作区或设备服务。cwd不是权限根，绝对路径和上级访问遵循真实OS权限；不增加目录白名单。
 
-每轮同一官方回复明确：子代理和harness内部直接工具调用尚未证明可在员工端执行，可能仍在主机；已识别的原生未改道工具/Agent审批拒绝。PDF等二进制读取及后台命令明确不支持，不静默主机代跑。六类组件/MCP/配置转交证明不等于真实Claude原生alias执行或真实员工链路通过。实际Git依赖员工环境中已有Git，缺失会返回实际命令失败，不在主机替代，也不自动安装。
+本机执行在每个DSH会话首次用一句“文件和命令在你的电脑上执行”说明；既有0.8.14说明也计为已显示。完整限制每轮记录在技术详情，遇到不支持的操作再明确提示：子代理和harness内部直接工具调用尚未证明可在员工端执行，可能仍在主机；已识别的原生未改道工具/Agent审批拒绝。PDF等二进制读取及后台命令明确不支持，不静默主机代跑。六类组件/MCP/配置转交证明不等于真实Claude原生alias执行或真实员工链路通过。实际Git依赖员工环境中已有Git，缺失会返回实际命令失败，不在主机替代，也不自动安装。
 
 本地目前仅支持macOS（arm64/x64）；Grep固定携带微软@vscode/ripgrep-universal1.18.0的两架构原字节并核SHA，无员工PATH搜索或安装下载。主机需S0.4.11，N可选peer~0.4.4（缺失明确报能力缺项），L当前~0.7.18，本地接纳与D19工程路径已接，真实员工端门仍开放。无DSH/CLI修改、额外设置节或npm发布。
 
@@ -122,3 +122,5 @@ D20（0.8.8开发记录）：本地来源的Codex原生文件与命令通过固
 0.8.12目录诊断修复：入口为“设置 → 模型 → 模型目录诊断”，官方既有 settings.models.footer 公开扩展位直接显示；“内置插件 → 远程助手参数”也可只读查看，即使参数命名空间暂未提供也保留入口；参数编辑使用当前插件公开Loader entry id对应的官方ConfigForms。该页只读本机记录，刷新不查询主机、不登录、不发送待发送原话。模型页原错误行仍通过公开提供方目录发布，诊断数据不再调用directory.replace或发布适配器拓扑变化；changed只负责真实连接/目标代次变化，菜单提示指向上述实际入口。
 
 每次目录SSH保独立事件ID、品牌、UTC起止、耗时、PID、L实例/epoch/phase、严格L argv/目标/known_hosts/ProxyCommand、退出码/信号、完整脱敏stderr与原字节数/SHA256、stdout字节数/SHA及主机typed错误；不记录凭据或整份模型目录。日志在官方profile的 `ai-workbench-remote-agent/catalog-diagnostics/<eventId>-started.json` 与 `-closed.json`，700目录/600文件、fsync；无自动过期，最新两品牌在界面可展开，旧调用保留不可变历史。容量沿现有`acpMaxMessageBytes`，超限停止并标记stderrComplete=false，UTF-8替换另显式标记，未返回部分模型；保存失败明确显示仅内存，不冒称耐久。旧0811丢失的stderr无法还原。同品牌、instanceId、epoch只合并仍在进行的查询；完成后不缓存，身份/代际/可信目标改变即作废。调用方各持独立lease/取消与错误身份，一个取消不会取消其他等待者；全员取消才撤销该次查询，取消中的旧进程结束前同作用域新调用等待清理。登录检查的显示变化不会取消无需登录的host-user目录。此次没有增加超时、重试、SSH连接复用或产品设置；不等于255、Claude主机错误及N层根因已修复，也未进行leo GUI验收。
+
+0.8.14 不把空菜单、非穷举 picker、可选 UI category/label 或同值配置通知当作额外发送门槛；每轮仍要求可靠模型入口与 fresh exact setter ACK。本轮完成后的配置变化只记录 warning，保留真实回复与 finish，并明确未获单独的实际执行型号回报。同一身份、代际与可信目标的 needCode/诊断变化只记 info；真实身份、代际、目标或能力失效仍撤回。每次关闭/取消保留 caller、字段前后值和首次观测原因（不等于根因）。新增配置、阈值、超时、重试为 0。

package/dist/acp.d.ts

@@ -1,3 +1,4 @@
+import { CloseDiagnostics, type CloseCause } from './close-diagnostics.ts';
 import * as stable from '@agentclientprotocol/sdk';
 import * as acp from '@agentclientprotocol/sdk/unstable';
 import { NeedError, type Need } from './remote.ts';
@@ -9,6 +10,7 @@ import { type ModelConfigurationSnapshot } from './model-configuration.ts';
 import type { EmployeeRouting } from './employee-relay.ts';
 export type ApprovalOutcome = 'allowed-once' | 'rejected' | 'cancelled' | 'unavailable';
 export interface AcpHooks {
+    closeDiagnostics?: CloseDiagnostics;
     timing?: StageTiming;
     onUpdate?: (notification: acp.SessionNotification) => void;
     onResponse?: (response: acp.PromptResponse) => void;
@@ -36,6 +38,7 @@ export type AcpStartMethod = 'session/new' | 'session/resume' | 'session/load';
 export declare class AcpSession {
     private connection;
     private hooks;
+    private closeDiagnostics;
     private sessionId?;
     private turnSignal?;
     private turnToken?;
@@ -44,6 +47,7 @@ export declare class AcpSession {
     private negotiated;
     private method?;
     private ready;
+    private closeRequested;
     private updating;
     private cwd?;
     private systemPrompt;
@@ -55,15 +59,13 @@ export declare class AcpSession {
     private configRevision;
     private selected?;
     private selecting;
-    private resolvedEvidence?;
     private pendingConfigurations;
+    private dispatchedPrompts;
+    get promptDispatchCount(): number;
     get modelConfiguration(): ModelConfigurationSnapshot | undefined;
-    get resolvedModelEvidence(): Readonly<{
-        modelValue: string;
-        resolvedModel: string;
-    }> | undefined;
     get models(): readonly import("./model-configuration.ts").ModelCatalogValue[];
     private receiveConfiguration;
+    private pendingConfiguration;
     private resetConfiguration;
     private lifecycleConfiguration;
     selectModel(model: string, effort?: string, signal?: AbortSignal): Promise<ModelConfigurationSnapshot>;
@@ -77,6 +79,9 @@ export declare class AcpSession {
     private need;
     private checkReporting;
     constructor(transport: acp.Stream | acp.AgentApp | stable.AgentApp, hooks: AcpHooks);
+    /** A rejected request on an already-closed SDK never reaches this write.
+     * Once a transport write starts, failure remains delivery-unknown. */
+    private observeDispatch;
     private observe;
     get id(): string | undefined;
     get capabilities(): Readonly<acp.AgentCapabilities>;
@@ -92,8 +97,8 @@ export declare class AcpSession {
     start(cwd: string, resumeId?: string, signal?: AbortSignal, context?: AcpStartContext, prompt?: acp.ContentBlock[]): Promise<string>;
     /** Codex context is immutable after creation; keep the old remote session intact. */
     newContextSession(context: AcpStartContext, signal?: AbortSignal): Promise<string>;
-    updateContext(context: AcpStartContext, signal?: AbortSignal): Promise<AcpStartMethod | undefined>;
+    updateContext(context: AcpStartContext, signal?: AbortSignal, force?: boolean): Promise<AcpStartMethod | undefined>;
     prompt(input: string | acp.ContentBlock[], signal?: AbortSignal): Promise<acp.StopReason>;
-    close(): void;
+    close(cause?: CloseCause, error?: Error): void;
 }
 export declare function acpNeed(error: unknown): NeedError;

package/dist/acp.js

@@ -1,3 +1,4 @@
+import { CloseDiagnostics } from "./close-diagnostics.js";
 import * as acp from '@agentclientprotocol/sdk/unstable';
 import { NeedError } from "./remote.js";
 import { employeeFailure } from "./presentation.js";
@@ -10,6 +11,7 @@ import { ModelConfiguration, ModelConfigurationError } from "./model-configurati
 export class AcpSession {
     connection;
     hooks;
+    closeDiagnostics;
     sessionId;
     turnSignal;
     turnToken;
@@ -18,6 +20,7 @@ export class AcpSession {
     negotiated = {};
     method;
     ready = false;
+    closeRequested = false;
     updating = false;
     cwd;
     systemPrompt = '';
@@ -29,33 +32,29 @@ export class AcpSession {
     configRevision = 0;
     selected;
     selecting = false;
-    resolvedEvidence;
     pendingConfigurations = new Map();
+    dispatchedPrompts = 0;
+    get promptDispatchCount() { return this.dispatchedPrompts; }
     get modelConfiguration() { return this.configuration?.snapshot; }
-    get resolvedModelEvidence() { return this.resolvedEvidence; }
     get models() { if (!this.configuration)
         throw new ModelConfigurationError('远端没有提供完整配置列表'); return this.configuration.models; }
-    receiveConfiguration(options) {
+    receiveConfiguration(options, routing) {
         this.configRevision++;
         if (this.configuration)
             this.configuration.update(options);
         else
             this.configuration = new ModelConfiguration(options, async (configId, value) => {
                 const result = await this.connection.agent.request(acp.methods.agent.session.setConfigOption, { sessionId: this.sessionId, configId, value }, { cancellationSignal: this.turnSignal });
-                if (this.resolvedEvidence && (this.configuration?.snapshot.model !== this.resolvedEvidence.modelValue || (configId === this.configuration?.snapshot.modelConfigId && value !== this.resolvedEvidence.modelValue)))
-                    this.resolvedEvidence = undefined;
                 this.hooks.broker?.acknowledge(acp.methods.agent.session.setConfigOption);
                 return result;
-            });
-        if (this.resolvedEvidence && this.configuration.snapshot.model !== this.resolvedEvidence.modelValue)
-            this.resolvedEvidence = undefined;
+            }, reason => this.detail({ kind: 'session', severity: 'info', code: 'MODEL_CONFIGURATION_INFORMATION', summary: ({ PICKER_INCOMPLETE: '远端菜单没有穷举当前或所选值；以本轮精确配置回执为准。', CONFIG_UI_METADATA_INVALID: '远端配置的显示资料不完整；没有改变本轮选择。', UNRELATED_CONFIG_IGNORED: '远端有未使用的界面配置；未把它当模型配置入口。', OPTIONAL_CATEGORY_OMITTED: '远端省略了显示类别；继续使用本会话已核实的配置入口。', SAME_SELECTION_UPDATE: '收到同值或无关配置更新，本轮真实配置回执仍有效。' })[reason], payload: { reason } }), routing);
     }
-    resetConfiguration() {
+    pendingConfiguration(sessionId, options) { const pending = this.pendingConfigurations.get(sessionId) ?? []; pending.push(options); this.pendingConfigurations.set(sessionId, pending); }
+    resetConfiguration(clearRoles = true) {
         this.selected = undefined;
-        this.resolvedEvidence = undefined;
         if (this.configuration) {
             try {
-                this.receiveConfiguration([]);
+                this.configuration.invalidate(clearRoles);
             }
             catch { /* Invalidated until this lifecycle operation supplies new evidence. */ }
         }
@@ -64,14 +63,22 @@ export class AcpSession {
     lifecycleConfiguration(result, revision) {
         const pending = this.pendingConfigurations.get(this.sessionId);
         this.pendingConfigurations.clear();
-        if (pending)
-            this.receiveConfiguration(pending);
+        if (pending) {
+            // A lifecycle response can identify selectors for this same session even
+            // when newer notifications omit UX categories. It never supplies an ACK.
+            if (result.configOptions)
+                try {
+                    this.receiveConfiguration(result.configOptions);
+                }
+                catch {
+                    this.detail({ kind: 'session', severity: 'info', code: 'MODEL_CONFIGURATION_INFORMATION', summary: '会话建立回执的配置资料由本会话较新通知重新核对，仍需本轮真实配置回执。', payload: { reason: 'LIFECYCLE_CONFIGURATION_SUPERSEDED' } });
+                }
+            for (const options of pending)
+                this.receiveConfiguration(options);
+        }
         // A notification observed during the operation is newer than its in-flight response.
         else if (this.configRevision === revision && result.configOptions)
             this.receiveConfiguration(result.configOptions);
-        const model = this.configuration?.snapshot.model;
-        if (!pending && this.configRevision === revision + 1 && model && typeof result.models?.currentModelId === 'string' && result.models.currentModelId)
-            this.resolvedEvidence = { modelValue: model, resolvedModel: result.models.currentModelId };
     }
     async selectModel(model, effort, signal) {
         if (!this.ready || !this.sessionId)
@@ -104,7 +111,14 @@ export class AcpSession {
     reports = [];
     reportingFailure;
     timing = new StageTiming();
-    stage(phase, operation) { return (this.hooks.timing ?? this.timing).run(phase, operation); }
+    async stage(phase, operation) { this.closeDiagnostics.stage = phase; try {
+        return await this.closeDiagnostics.run(phase, () => (this.hooks.timing ?? this.timing).run(phase, operation));
+    }
+    catch (error) {
+        if (['acp-session-new', 'acp-session-resume', 'acp-session-load', 'acp-initialize'].includes(phase))
+            this.closeDiagnostics.record({ layer: 'acp', initiator: phase === 'acp-session-new' ? 'acp.session-new.failure' : 'acp.lifecycle.failure', reason: acpNeed(error).code, operation: phase, action: 'failure' });
+        throw error;
+    } }
     get diagnostics() { return this.reports.map(entry => sanitizeObservation(entry)); }
     detail(observation, hooks = this.hooks) {
         const safe = sanitizeObservation(observation);
@@ -113,8 +127,10 @@ export class AcpSession {
             hooks.onDetail?.(safe);
         }
         catch (cause) {
+            const first = !this.reportingFailure;
             this.reportingFailure ??= { cause };
-            this.connection?.close();
+            if (first)
+                this.close({ layer: 'acp', initiator: 'acp.reporting-failure', reason: 'CONVERSATION_DETAILS_FAILED', action: 'close' });
         }
     }
     need(need, hooks = this.hooks) {
@@ -125,12 +141,13 @@ export class AcpSession {
         throw new NeedError('CONVERSATION_DETAILS_FAILED', '技术详情未能记录；本轮未继续发送', '可用的技术详情记录渠道'); }
     constructor(transport, hooks) {
         this.hooks = hooks;
+        this.closeDiagnostics = hooks.closeDiagnostics ?? new CloseDiagnostics(event => this.detail(event));
         this.timing.bind(detail => this.detail(detail));
         const app = acp.client({ name: '@ai-workbench/remote-agent' })
             .onNotification(acp.methods.client.session.update, ({ params: notification }) => {
             if (this.creatingReplacement) {
                 if (notification.sessionId !== this.sessionId && notification.update.sessionUpdate === 'config_option_update')
-                    this.pendingConfigurations.set(notification.sessionId, notification.update.configOptions);
+                    this.pendingConfiguration(notification.sessionId, notification.update.configOptions);
                 this.detail({ kind: 'session', severity: 'info', code: 'ACP_IDLE_UPDATE', summary: '新会话建立期间的轨迹，未作为正文处理', method: 'session/update', payload: notification });
                 return;
             }
@@ -140,9 +157,8 @@ export class AcpSession {
             }
             const meta = record(notification._meta);
             if (notification.update.sessionUpdate === 'config_option_update') {
-                this.resolvedEvidence = undefined;
                 if (!this.sessionId)
-                    this.pendingConfigurations.set(notification.sessionId, notification.update.configOptions);
+                    this.pendingConfiguration(notification.sessionId, notification.update.configOptions);
                 else
                     try {
                         this.receiveConfiguration(notification.update.configOptions);
@@ -258,21 +274,27 @@ export class AcpSession {
             this.detail({ kind: 'extension', severity: 'warning', code: 'ACP_UNKNOWN_NOTIFICATION', summary: '收到未知远端扩展通知，已保留技术记录', method, payload: params });
         });
         if ('readable' in transport && 'writable' in transport)
-            this.connection = app.connect(isolateRpcIds(this.observe(transport)));
+            this.connection = app.connect(isolateRpcIds(this.observe(transport), message => this.observeDispatch(message)));
         else {
             // Stable and unstable apps use distinct private symbols. Bridge only their
             // public stream interfaces so either SDK entry point remains supported.
             const outward = new TransformStream();
             const inward = new TransformStream();
             const peer = transport.connect({ readable: outward.readable, writable: inward.writable });
-            this.connection = app.connect(isolateRpcIds(this.observe({ readable: inward.readable, writable: outward.writable })));
-            void this.connection.closed.then(() => peer.close());
-            void peer.closed.then(() => this.connection.close());
+            this.connection = app.connect(isolateRpcIds(this.observe({ readable: inward.readable, writable: outward.writable }), message => this.observeDispatch(message)));
+            const observeConnection = this.closeDiagnostics.capture();
+            void this.connection.closed.then(() => { observeConnection({ layer: 'acp', initiator: 'acp.connection-closed', reason: 'ACP_CONNECTION_CLOSED', action: 'close' }); peer.close(); });
+            void peer.closed.then(() => { observeConnection({ layer: 'acp', initiator: 'acp.peer-closed', reason: 'ACP_PEER_CLOSED', action: 'close' }); this.connection.close(); });
         }
     }
+    /** A rejected request on an already-closed SDK never reaches this write.
+     * Once a transport write starts, failure remains delivery-unknown. */
+    observeDispatch(message) { if (record(message)?.method === 'session/prompt' && Object.hasOwn(message, 'id'))
+        this.dispatchedPrompts++; }
     observe(stream) {
         // Observe already-parsed public Stream messages: no NDJSON parsing, second
         // byte buffer, message-size policy, or transport fallback is introduced.
+        const observe = this.closeDiagnostics.capture();
         const readable = stream.readable.pipeThrough(new TransformStream({ transform: (message, controller) => {
                 const raw = record(message);
                 const params = record(raw?.params);
@@ -289,13 +311,13 @@ export class AcpSession {
                     return;
                 }
                 controller.enqueue(message);
-            } }));
+            }, flush: () => observe({ layer: 'acp', initiator: 'acp.read-eof', reason: 'ACP_STREAM_EOF', action: 'eof' }) }));
         return { readable, writable: stream.writable };
     }
     get id() { return this.sessionId; }
     get capabilities() { return this.negotiated; }
     get startMethod() { return this.method; }
-    get checkpoint() { return this.ready && !this.busy && !this.updating && !this.selecting && this.sessionId ? { sessionId: this.sessionId, capabilities: recoveryCapabilities(this.negotiated), ...(this.configuration ? { modelConfiguration: { configOptions: JSON.parse(JSON.stringify(this.configuration.snapshot.configOptions)), ...(this.resolvedEvidence ? { resolvedEvidence: { ...this.resolvedEvidence } } : {}) } } : {}) } : undefined; }
+    get checkpoint() { return this.ready && !this.busy && !this.updating && !this.selecting && this.sessionId ? { sessionId: this.sessionId, capabilities: recoveryCapabilities(this.negotiated), ...(this.configuration ? { modelConfiguration: { configOptions: JSON.parse(JSON.stringify(this.configuration.snapshot.configOptions)), selectorRoles: { model: this.configuration.snapshot.modelConfigId, effort: this.configuration.snapshot.effortConfigId } } } : {}) } : undefined; }
     restore(cwd, saved, context, verifiedSameContext = false) {
         if (context.employeeRouting)
             throw new NeedError('EMPLOYEE_CHECKPOINT_STALE', '本机工具通道需要重新建立，旧审批没有代答。', '按原主机实例安全结束后新建本机会话');
@@ -311,13 +333,12 @@ export class AcpSession {
         // Old journals may lack new-only metadata; never manufacture it for them.
         if (this.codexNewSessionOnly && !verifiedSameContext)
             this.validateNewContext(this.systemPrompt, context.systemPrompt !== undefined);
+        // Legacy currentModelId/resolvedEvidence is not a per-turn setter ACK and
+        // never proves the concrete model. Only restore selectable config options.
         if (saved.modelConfiguration) {
-            this.receiveConfiguration(saved.modelConfiguration.configOptions);
-            this.resolvedEvidence = saved.modelConfiguration.resolvedEvidence;
-            for (const update of saved.configUpdates ?? []) {
-                this.resolvedEvidence = undefined;
+            this.receiveConfiguration(saved.modelConfiguration.configOptions, saved.modelConfiguration.selectorRoles);
+            for (const update of saved.configUpdates ?? [])
                 this.receiveConfiguration(update);
-            }
         }
         this.hooks.broker?.finishRecovery();
         this.detail({ kind: 'need', severity: 'info', code: 'ACP_CLIENT_REATTACHED', summary: '已接回原模型会话', payload: { sessionId: saved.sessionId } });
@@ -364,12 +385,12 @@ export class AcpSession {
             throw new NeedError('SESSION_ALREADY_STARTED', '此连接已用于建立会话，不能转用工作区或身份', '新的独立远端连接');
         this.startAttempted = true;
         this.employeeMeta = context?.employeeExecution;
-        const abort = () => this.connection.close(new NeedError('ABORTED', '会话建立已取消', '重新连接主机'));
+        const abort = () => this.close({ layer: 'acp', initiator: 'acp.start-signal', reason: 'ABORTED', action: 'abort' }, new NeedError('ABORTED', '会话建立已取消', '重新连接主机'));
         signal?.throwIfAborted();
         signal?.addEventListener('abort', abort, { once: true });
         try {
             const hello = await this.stage('acp-initialize', () => this.connection.agent.request(acp.methods.agent.initialize, {
-                protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.8.13' },
+                protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.8.15' },
                 clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false, session: { notices: {} }, ...(this.employeeMeta ? { _meta: { awEmployeeExecution: { version: 1 } } } : {}) },
             }, { cancellationSignal: signal }));
             this.hooks.broker?.acknowledge(acp.methods.agent.initialize);
@@ -453,7 +474,7 @@ export class AcpSession {
         this.ready = false;
         this.creatingReplacement = true;
         this.pendingConfigurations.clear();
-        const abort = () => this.connection.close(new NeedError('ABORTED', '新会话建立已取消，远端状态需确认', '管理员核对远端状态'));
+        const abort = () => this.close({ layer: 'acp', initiator: 'acp.new-context-signal', reason: 'ABORTED', action: 'abort' }, new NeedError('ABORTED', '新会话建立已取消，远端状态需确认', '管理员核对远端状态'));
         signal?.addEventListener('abort', abort, { once: true });
         try {
             const revision = this.resetConfiguration();
@@ -481,32 +502,34 @@ export class AcpSession {
             signal?.removeEventListener('abort', abort);
         }
     }
-    async updateContext(context, signal) {
+    async updateContext(context, signal, force = false) {
         this.checkReporting();
         if (!this.ready || !this.sessionId || !this.cwd)
             throw new NeedError('SESSION_REQUIRED', '我需要先建立远端会话', 'ACP 会话');
         if (this.busy || this.updating || this.selecting)
             throw new NeedError('TURN_BUSY', '此远端会话正在处理上一轮或更新配置', '上一轮结束');
         const text = context.systemPrompt ?? '';
-        if (text === this.systemPrompt)
+        if (!force && text === this.systemPrompt)
             return undefined;
         this.validateContext(context);
+        if (force && (!this.negotiated.sessionCapabilities?.systemPrompt || !this.negotiated.sessionCapabilities?.resume && !this.negotiated.loadSession))
+            throw new NeedError('SYSTEM_PROMPT_UPDATE_UNSUPPORTED', '远端没有可传送更新要求的公开恢复能力', 'session/resume 或 session/load 的 systemPrompt 能力');
         const resume = !!this.negotiated.sessionCapabilities?.resume;
         signal?.throwIfAborted();
         this.updating = true;
         this.ready = false;
-        const abort = () => this.connection.close(new NeedError('ABORTED', '上下文更新已取消，原会话状态需确认', '重新连接原会话'));
+        const abort = () => this.close({ layer: 'acp', initiator: 'acp.update-context-signal', reason: 'ABORTED', action: 'abort' }, new NeedError('ABORTED', '上下文更新已取消，原会话状态需确认', '重新连接原会话'));
         signal?.addEventListener('abort', abort, { once: true });
         try {
             const method = resume ? acp.methods.agent.session.resume : acp.methods.agent.session.load;
             const params = { sessionId: this.sessionId, cwd: this.cwd, mcpServers: [], systemPrompt: { mode: 'append', content: [{ type: 'text', text }] } };
-            const configRevision = this.resetConfiguration();
+            const configRevision = this.resetConfiguration(false);
             const result = await this.stage(resume ? 'acp-session-resume' : 'acp-session-load', () => this.connection.agent.request(method, params, { cancellationSignal: signal }));
             this.lifecycleConfiguration(result, configRevision);
             this.hooks.broker?.acknowledge(method);
             this.systemPrompt = text;
             this.ready = true;
-            this.need({ code: 'SYSTEM_PROMPT_UPDATE_DEFERRED', message: '系统与开发者上下文变更已通过原会话恢复接口传送。Claude 恢复会话沿用首次系统提示，新要求在下次上下文整理后生效；不能据此认定本轮已立即生效。', requires: '远端实际应用新要求；Claude 须完成下一次上下文整理' });
+            this.detail({ kind: 'session', severity: 'warning', code: 'SYSTEM_PROMPT_UPDATE_DEFERRED', summary: '系统与开发者要求已通过原会话恢复接口传送；新要求在下次上下文整理后生效，本轮不能保证已立即采用。', payload: { reason: 'OFFICIAL_CONTEXT_UPDATE_DEFERRED' } });
             this.checkReporting();
             return method;
         }
@@ -542,6 +565,7 @@ export class AcpSession {
         let rejectAbort;
         const interrupted = new Promise((_resolve, reject) => { rejectAbort = reject; });
         const cancel = () => {
+            this.closeDiagnostics.record({ layer: 'acp', initiator: 'acp.prompt-cancel', reason: 'ABORTED', operation: 'session/prompt', action: 'abort' });
             rejectAbort?.(new NeedError('ABORTED', '已请求取消本轮，远端状态需确认', '确认主机取消状态'));
             void this.connection.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.sessionId }).catch(() => {
                 this.need({ code: 'CANCEL_UNCONFIRMED', message: '连接中断，无法确认主机已取消本轮', requires: '恢复连接以确认远端状态' });
@@ -573,7 +597,7 @@ export class AcpSession {
             this.turnToken = undefined;
         }
     }
-    close() { this.connection.close(); }
+    close(cause = { layer: 'acp', initiator: 'acp.close', reason: 'ACP_CLOSE_REQUESTED', action: 'close' }, error) { this.closeDiagnostics.record({ ...cause, changes: cause.changes ?? [{ field: 'acp.close-requested', before: this.closeRequested, after: true }] }); this.closeRequested = true; this.connection?.close(error); }
 }
 export function acpNeed(error) {
     if (error instanceof NeedError)