@ai-workbench/remote-agent 0.8.13 → 0.8.14

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.14` 发布形态包；消费审定的 B1–B9 校验分类及 X2 首次关闭原因观测，供 leo 真机复验。Claude 型号按本轮 setter 精确回执与同域目录映射确认，并如实注明来源。Codex 上次 `EMPLOYEE_EXEC_CLOSED` 的真机根因仍未查明，本版补充首因留痕，不宣称其已在真机修复。由编排发布后，通过官方插件 → 添加插件安装；X 不执行 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.14；包名采用`@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验收。
 
@@ -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.14对齐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 会话继续处理，原会话仍保留。”，并新建远端承接公开对话，保留旧标识和查询记录；旧/非法初建摘要明确拒绝，不能猜测。
 
@@ -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.14' },
                 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)

package/dist/broker-runtime.js

@@ -6,6 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import { CloseDiagnostics, closeCode, flushCloseDiagnostics } from "./close-diagnostics.js";
 import { BrokerTransport, brokerCommand, brokerId, legacyBrokerId, sshIo, controlJson } from "./broker.js";
 import { CODEX_AGENT } from "./agents.js";
 import { protectedOneShotLayout } from "./host-layout.js";
@@ -63,15 +64,24 @@ export function brokerFactory(get, _ask, configuration, provided) {
         const contextBoundScope = recoveryKey([...scopeParts, request.contextSha256]);
         // A Codex ACP process can own several immutable native sessions. D18's durable
         // pointer controls their context; the broker still binds every transport identity.
-        const scope = agent.loginProvider === 'codex' ? recoveryKey([...scopeParts, undefined]) : contextBoundScope;
+        const scope = recoveryKey([...scopeParts, undefined]);
+        const previousContextScope = agent.loginProvider === 'claude' && request.previousContextSha256 ? recoveryKey([...scopeParts, request.previousContextSha256]) : contextBoundScope;
         const existing = request.retainProcess ? retained.get(key) : undefined;
         if (existing) {
             if (existing.scope !== scope)
                 throw need('SESSION_CONTEXT_MISMATCH');
             if (existing.runtime.broker?.error)
                 throw existing.runtime.broker.error;
+            if (request.requireFreshSession) {
+                if (existing.runtime.broker?.promptInFlight)
+                    throw need('INPUT_DELIVERY_UNCONFIRMED');
+                await existing.runtime.dispose?.({ layer: 'broker', initiator: 'broker.fresh-session-required', reason: 'PRIVATE_RECOVERY_POINTER_ABSENT', action: 'dispose' });
+                return open(target, project, request);
+            }
             existing.update(request);
             existing.runtime.restartNotice = undefined;
+            existing.runtime.restartInputIds = undefined;
+            existing.runtime.freshSessionConfirmed = undefined;
             existing.runtime.recoveredSession = undefined;
             return existing.runtime;
         }
@@ -83,7 +93,7 @@ export function brokerFactory(get, _ask, configuration, provided) {
             if (!journal)
                 throw need('RECOVERY_STORAGE_REQUIRED');
             let state = await journal.read();
-            const legacyContextScope = !!state && state.scope !== scope && agent.loginProvider === 'codex' && state.scope === contextBoundScope;
+            const legacyContextScope = !!state && state.scope !== scope && state.scope === previousContextScope;
             if (state && state.scope !== scope && !legacyContextScope)
                 throw need(agent.loginProvider === 'codex' ? 'RECOVERY_CONTEXT_POLICY_UNSUPPORTED' : 'SESSION_CONTEXT_MISMATCH');
             if (legacyContextScope && state?.phase !== 'clean')
@@ -106,9 +116,11 @@ export function brokerFactory(get, _ask, configuration, provided) {
             const report = async (code, extra = {}, cleanup = false) => { request.detailChannel?.record({ kind: 'need', severity: 'warning', code, summary: '远端会话恢复状态：' + code, payload: extra }); await request.detailChannel?.flush(); await validate(cleanup); };
             const list = async (cleanup = false) => timing.run('broker-list', async () => { const rows = controlJson(await io.run(command(['list']), cleanup ? undefined : request.signal)); if (!Array.isArray(rows) || rows.some(row => typeof row?.id !== 'string'))
                 throw need('BROKER_PROTOCOL_INVALID'); return rows; });
+            const detailSink = request.detailChannel;
+            const closeDiagnostics = request.closeDiagnostics ?? new CloseDiagnostics(event => detailSink?.record(event));
             let rows = await list();
             const id = brokerId(request.sessionId, employeeScope ? agent.id + '/employee/' + employeeScope : agent.id), oldId = legacyBrokerId(request.sessionId, agent.id);
-            let restarted = false;
+            let restarted = !!request.requireFreshSession;
             const attachArgs = (entry, after) => ['attach', entry.id, '--after', String(after), '--framed', ...(modern(entry) ? ['--leased', '--if-instance', entry.instanceId] : [])];
             const connectWithLease = async (transport, entry, cleanup = false) => {
                 try {
@@ -143,13 +155,13 @@ export function brokerFactory(get, _ask, configuration, provided) {
                 }
             };
             const claim = async (entry, cleanup = false) => {
-                const probe = new BrokerTransport({ discardOutput: true, onNeed: n => request.detailChannel?.record({ kind: 'need', severity: 'warning', code: n.code, summary: '主机会话连接状态', payload: { brokerId: entry.id, instanceId: entry.instanceId ?? null } }), maxFrameBytes: settings.brokerMaxFrameBytes, initialSequence: entry.lastSequence, instanceId: entry.instanceId, leased: modern(entry), controlMaxBytes: entry.controlMaxBytes, attach: after => io.attach(command(attachArgs(entry, after))) });
+                const probe = new BrokerTransport({ observeClose: closeDiagnostics.child().capture(), discardOutput: true, onNeed: n => request.detailChannel?.record({ kind: 'need', severity: 'warning', code: n.code, summary: '主机会话连接状态', payload: { brokerId: entry.id, instanceId: entry.instanceId ?? null } }), maxFrameBytes: settings.brokerMaxFrameBytes, initialSequence: entry.lastSequence, instanceId: entry.instanceId, leased: modern(entry), controlMaxBytes: entry.controlMaxBytes, attach: after => io.attach(command(attachArgs(entry, after))) });
                 try {
                     await connectWithLease(probe, entry, cleanup);
                 }
                 catch (error) {
                     if (!(entry.state === 'exited' && error instanceof NeedError && error.code === 'AGENT_EXITED')) {
-                        probe.close();
+                        probe.close({ layer: 'broker', initiator: 'broker.probe-close', reason: 'BROKER_PROBE_FINISHED', action: 'close' });
                         throw error;
                     }
                 }
@@ -183,7 +195,7 @@ export function brokerFactory(get, _ask, configuration, provided) {
                         throw need('REMOTE_CLEANUP_UNCONFIRMED');
                 }
                 finally {
-                    probe.close();
+                    probe.close({ layer: 'broker', initiator: 'broker.probe-close', reason: 'BROKER_PROBE_FINISHED', action: 'close' });
                 }
             };
             const legacy = employeeScope ? undefined : rows.find(row => row.id === oldId);
@@ -192,13 +204,13 @@ export function brokerFactory(get, _ask, configuration, provided) {
             let entry = rows.find(row => row.id === id);
             if (entry)
                 validEntry(entry);
-            if (legacyContextScope && !entry)
+            if (legacyContextScope && !entry && !request.requireFreshSession)
                 throw need('RECOVERY_CONTEXT_POLICY_UNSUPPORTED');
             if (legacy && !entry)
                 restarted = true;
             let transport;
             let resume;
-            const build = (entry, after, recovery) => new BrokerTransport({ onNeed: n => request.detailChannel?.record({ kind: 'need', severity: 'warning', code: n.code, summary: '主机会话连接状态', payload: { brokerId: entry.id, instanceId: entry.instanceId } }), maxFrameBytes: settings.brokerMaxFrameBytes, maxMessageBytes: request.acpMaxMessageBytes ?? settings.brokerMaxFrameBytes, initialSequence: after, instanceId: entry.instanceId, leased: true, controlMaxBytes: entry.controlMaxBytes, beforeInput: async () => { await validate(); if (state?.phase !== 'dirty' || state.instanceId !== entry.instanceId) {
+            const build = (entry, after, recovery) => new BrokerTransport({ observeClose: closeDiagnostics.capture(), onNeed: n => request.detailChannel?.record({ kind: 'need', severity: 'warning', code: n.code, summary: '主机会话连接状态', payload: { brokerId: entry.id, instanceId: entry.instanceId } }), maxFrameBytes: settings.brokerMaxFrameBytes, maxMessageBytes: request.acpMaxMessageBytes ?? settings.brokerMaxFrameBytes, initialSequence: after, instanceId: entry.instanceId, leased: true, controlMaxBytes: entry.controlMaxBytes, beforeInput: async () => { await validate(); if (state?.phase !== 'dirty' || state.instanceId !== entry.instanceId) {
                     const dirty = { version: 1, scope, brokerId: id, instanceId: entry.instanceId, pid: entry.pid, phase: 'dirty' };
                     await journal.write(dirty);
                     state = dirty;
@@ -225,6 +237,15 @@ export function brokerFactory(get, _ask, configuration, provided) {
             if (entry) {
                 if (!modern(entry))
                     throw need('BROKER_CAPABILITY_REQUIRED');
+                if (request.requireFreshSession) {
+                    if (!state || !['clean', 'ended'].includes(state.phase) || state.instanceId !== entry.instanceId)
+                        throw need('INPUT_DELIVERY_UNCONFIRMED');
+                    await stop(entry, 'PRIVATE_RECOVERY_POINTER_ABSENT');
+                    restarted = true;
+                    entry = undefined;
+                }
+            }
+            if (entry) {
                 const clean = !employeeScope && state?.phase === 'clean' && state.instanceId === entry.instanceId && state.acp?.sessionId === request.resumeSessionId && state.checkpointId === request.recoveryCheckpointId && state.cursor >= entry.firstSequence - 1 && state.cursor <= entry.lastSequence && entry.state === 'running' && (legacyContextScope ? await request.verifyRecovery?.() === true : await request.verifyRecovery?.() !== false);
                 if (legacyContextScope && !clean)
                     throw need('RECOVERY_CONTEXT_POLICY_UNSUPPORTED');
@@ -237,14 +258,14 @@ export function brokerFactory(get, _ask, configuration, provided) {
                         await validate();
                         if (legacyContextScope) {
                             const migrated = { ...state, scope };
-                            await report('CODEX_RECOVERY_SCOPE_MIGRATED', { oldScope: state.scope, newScope: scope, sessionId: state.acp.sessionId, checkpointId: state.checkpointId, instanceId: entry.instanceId, cursor: state.cursor });
+                            await report(agent.loginProvider === 'codex' ? 'CODEX_RECOVERY_SCOPE_MIGRATED' : 'CLAUDE_RECOVERY_SCOPE_MIGRATED', { oldScope: state.scope, newScope: scope, sessionId: state.acp.sessionId, checkpointId: state.checkpointId, instanceId: entry.instanceId, cursor: state.cursor });
                             await journal.write(migrated);
                             state = migrated;
                         }
                         resume = state.acp;
                     }
                     catch (error) {
-                        transport.close();
+                        transport.close({ layer: 'broker', initiator: 'broker.replay-failure', reason: closeCode(error, 'RECOVERY_UNCONFIRMED'), action: 'close' });
                         if (legacyContextScope || error instanceof NeedError && ['ATTACH_BUSY', 'SESSION_IN_USE', 'SESSION_INSTANCE_MISMATCH', 'ABORTED'].includes(error.code))
                             throw error;
                         await report('SESSION_REPLAY_UNRECOVERABLE', { brokerId: id, instanceId: entry.instanceId, reason: error instanceof NeedError ? error.code : 'UNKNOWN_FAILURE', recordedCursor: state?.cursor ?? null, firstSequence: entry.firstSequence, lastSequence: entry.lastSequence });
@@ -274,7 +295,7 @@ export function brokerFactory(get, _ask, configuration, provided) {
                 validEntry(entry);
                 transport = build(entry, 0);
                 const opening = transport;
-                const aborted = () => opening.fail(need('ABORTED'));
+                const aborted = () => opening.fail(need('ABORTED'), { layer: 'broker', initiator: 'broker.open-signal', reason: 'ABORTED', action: 'abort' });
                 request.signal?.addEventListener('abort', aborted, { once: true });
                 try {
                     request.signal?.throwIfAborted();
@@ -284,7 +305,7 @@ export function brokerFactory(get, _ask, configuration, provided) {
                 catch (error) {
                     if (!(error instanceof NeedError && ['ATTACH_BUSY', 'SESSION_IN_USE', 'SESSION_INSTANCE_MISMATCH'].includes(error.code)))
                         await stop(entry, 'SESSION_OPEN_FAILED', opening, true, true);
-                    opening.close();
+                    opening.close({ layer: 'broker', initiator: 'broker.open-failure', reason: closeCode(error), action: 'close' });
                     throw error;
                 }
                 finally {
@@ -294,8 +315,8 @@ export function brokerFactory(get, _ask, configuration, provided) {
             const ownedEntry = entry, ownedTransport = transport;
             let disposed = false;
             let disposal;
-            const runtime = { identity: identity(target), cwd: project.path, broker: ownedTransport, acpTransport: ownedTransport,
-                ...(resume ? { recoveredSession: resume } : {}), ...(restarted ? { restartNotice: '上次会话无法接回，已新建会话；本次从你的这条请求继续。', restartInputIds: request.currentInputIds } : {}),
+            const runtime = { closeDiagnostics, identity: identity(target), cwd: project.path, broker: ownedTransport, acpTransport: ownedTransport,
+                ...(resume ? { recoveredSession: resume } : {}), ...(restarted ? { restartNotice: '上次会话无法接回，已新建会话；本次从你的这条请求继续。', restartInputIds: request.currentInputIds } : {}), ...(request.requireFreshSession ? { freshSessionConfirmed: true } : {}),
                 saveCheckpoint: async (checkpointId, acp) => { await validate(); const saved = await ownedTransport.commitCheckpoint(async (cursor) => { await validate(); const clean = { version: 1, phase: 'clean', scope, brokerId: id, instanceId: ownedEntry.instanceId, pid: ownedEntry.pid, cursor, checkpointId, acp }; try {
                     await journal.write(clean);
                     state = clean;
@@ -305,24 +326,29 @@ export function brokerFactory(get, _ask, configuration, provided) {
                     throw error;
                 } }); if (!saved)
                     await report('SESSION_CHECKPOINT_NOT_CLEAN', { brokerId: id, instanceId: ownedEntry.instanceId }); return saved; },
-                detach: async () => { ownedTransport.close(); active.delete(key); retained.delete(key); },
-                dispose: () => disposal ??= (async () => { if (disposed)
-                    return; try {
+                detach: async (cause = { layer: 'broker', initiator: 'broker.runtime-detach', reason: 'BROKER_DETACH', action: 'detach' }) => { const sink = request.detailChannel; closeDiagnostics.record(cause); ownedTransport.close(cause); active.delete(key); retained.delete(key); await flushCloseDiagnostics(closeDiagnostics, sink ? () => sink.flush() : undefined); },
+                dispose: (cause = { layer: 'broker', initiator: 'broker.runtime-dispose', reason: 'BROKER_DISPOSE', action: 'dispose' }) => { const sink = request.detailChannel; closeDiagnostics.record(cause); return disposal ??= (async () => { if (disposed)
+                    return; let primary; try {
                     await stop(ownedEntry, 'SESSION_ENDED', ownedTransport, true);
                     await journal.write({ version: 1, phase: 'ended', scope, brokerId: id, instanceId: ownedEntry.instanceId, pid: ownedEntry.pid });
                     disposed = true;
                 }
+                catch (error) {
+                    primary = { error };
+                }
                 finally {
-                    ownedTransport.close();
+                    ownedTransport.close({ layer: 'broker', initiator: 'broker.dispose-finally', reason: 'BROKER_DISPOSE_CLEANUP', action: 'close' });
                     active.delete(key);
                     retained.delete(key);
-                } })(), };
+                } await flushCloseDiagnostics(closeDiagnostics, sink ? () => sink.flush() : undefined, primary); })(); },
+            };
             if (employeeScope) {
                 runtime.saveCheckpoint = undefined;
                 runtime.detach = runtime.dispose;
             }
             if (request.retainProcess)
-                retained.set(key, { runtime, scope, update: next => { request = next; timing = next.timing ?? new StageTiming(); } });
+                retained.set(key, { runtime, scope, update: next => { const sink = next.detailChannel; if (sink)
+                        closeDiagnostics.bind(event => sink.record(event)); request = next; timing = next.timing ?? new StageTiming(); } });
             return runtime;
         }
         catch (error) {