@ai-workbench/remote-agent 0.8.10 → 0.8.11

package/README.md

@@ -1,14 +1,14 @@
-**`@ai-workbench/remote-agent@0.8.10` 发布形态包；编排放行用于 leo 真机自验 Claude 线、设置界面和 D24 重开。Codex 线因主机适配器 aw.2 实装失败（UNSAFE_MODE_MISMATCH），待 S 修复后另验，当前未验证可用。由编排统一发布，X 未执行 publish。**
+**`@ai-workbench/remote-agent@0.8.11` 发布形态包；由编排发布后通过官方插件 → 添加插件安装。修复 Claude 模型目录及旧默认模型，供 leo 真机复验。Codex 线因主机适配器 aw.2 实装失败（UNSAFE_MODE_MISMATCH），待 S 修复后另验，当前未验证可用。由编排统一发布，X 未执行 publish。**
 
 # 远程ACP插件
 
 一个插件提供 **Claude（远程主机）** 和 **Codex（远程主机）**，通过员工主机上的官方CLI运行。Codex保留单次模式；Claude固定会话模式。只用官方模型列表、插件管理和配置入口，不提供自制面板、问答或登录按钮。登录和原生工作区绑定唯一归连接插件L。
 
-当前为0.8.10，包名采用`@ai-workbench/remote-agent`以涵盖两个品牌；本轮按编排放行准备发布形态包，供 leo 真机自验；X 不执行实际发布，由编排统一发布。开发fixture逐字节保留L0.7.17固定包，公开类型与SSH导出从该包消费。运行时仍要求L的`getContractInfo()`同时返回API0.7.0、implemented、native-local-v1；旧L包、draft.3或只有版本号的不完整实现会明确报缺项。依赖范围为`~0.7.17`，L由官方插件管理单独安装，不打进X。组件验证不代表真实开通、模型或leo E通过；HanaMesh另验。
+当前为0.8.11，包名采用`@ai-workbench/remote-agent`以涵盖两个品牌；本轮按编排放行准备发布形态包，供 leo 真机自验；X 不执行实际发布，由编排统一发布。开发fixture逐字节保留L0.7.17固定包，公开类型与SSH导出从该包消费。运行时仍要求L的`getContractInfo()`同时返回API0.7.0、implemented、native-local-v1；旧L包、draft.3或只有版本号的不完整实现会明确报缺项。依赖范围为`~0.7.17`，L由官方插件管理单独安装，不打进X。组件验证不代表真实开通、模型或leo E通过；HanaMesh另验。
 
 ## 员工路径
 
-从官方插件管理安装，照常使用默认工作区/会话/模型入口。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组件联测；真实N/S员工端仍NOT_RUN，产品验收以 leo 实际执行结果为准。本地文件不自动上传，X不猜目录、不选首项。首次说明使用官方普通回复；先经官方会话提交、持久化并读回核对，才向L确认。持久记录不等于员工已看见，GUI另验；日志丢失后的未知claim由L保留，不宣称端到端恰好一次。
 
 未登录时两个模型均回复：**需要登录，请到设置 → 远程主机连接 点登录**。无L或缺正式能力时直接说明缺项，不让员工填写主机、用户、路径或密钥。
 
@@ -72,7 +72,7 @@ D21（0.8.5）：两个品牌的官方模型菜单从 L 的 `modelCatalogTarget:
 
 每轮先核对目录代次和所选模型，再经 ACP 逐项配置模型及推理等级，收到完整配置确认后才发送输入。Claude 别名必须有当前会话的具体型号证据；没有就明确拒绝。真实回复追加所选值和远端确认值，并在恢复标识与技术详情保留，确认配置不等于验证推理效果。连接/身份/目录变化清除旧确认；远端清理待定或结果未知时阻止派发，不自动清理重试或另开替代会话。Codex 单次模式当前不能确认此选择，会在发送前明确拒绝。新增设置 0；本轮工程证据、真实只读链路与产品未验项见 `docs/evidence/2026-10-22-X2-D21/`。
 
-0.8.5统一包原依赖L `~0.7.13`；当前0.8.10对齐L `~0.7.17`。D8模型目录双事件长期监听保留；同epoch的recovery提示/失败消息变化不触发执行状态失效，真实实例/epoch/phase/可信目标/登录变化仍失效。完整D9两品牌正文/状态/就绪门呈现按编排00:50允许的范围记下一版，本版不宣称已消费完成；L的connectionMessages.administratorAfterMs仍只由L管理，X新增设置0。
+0.8.5统一包原依赖L `~0.7.13`；当前0.8.11对齐L `~0.7.17`。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 会话继续处理，原会话仍保留。”，并新建远端承接公开对话，保留旧标识和查询记录；旧/非法初建摘要明确拒绝，不能猜测。
 
@@ -97,3 +97,19 @@ D20（0.8.8开发记录）：本地来源的Codex原生文件与命令通过固
 当前明确不支持本地单次模式、断开后的冷恢复/load/fork、快捷命令、主机文件报告及附加MCP/hooks/plugins。主机同路径的启用项目配置、会话层项目发现/信任覆盖也会明确拒绝；配置检查不静默清空或改写原配置。普通原生shell/patch/fs使用所选员工环境，未覆盖的辅助入口保留具体原因到员工回复与技术详情。位置、身份或代次改变只撤回对应执行器，在途结果保持UNKNOWN，不自动重放。新增产品设置0，执行通道和桥队列沿已有`acpMaxMessageBytes`控制容量。当前工程进度、首红和开放门见`docs/evidence/2026-10-23-X2-D20-088/STATUS.md`。
 
 0.8.10仅增加公开插件参数页，不改变上述七项执行语义。mode/ACP/frame/control/grace的修改不改变运行中当轮；保留会话下一轮配置签名不一致会停止，须新建会话。ACP容量还在下一次独立目录查询读取新值。sandbox与approval仅单次通道适用，当前单次仍明确拒绝执行。GUI与真实链路门仍NOT_RUN；本次由编排在 leo 验证 Claude 线、设置界面和 D24 重开，Codex 线另验。完整逐项盘点见 docs/evidence/2026-10-23-X-settings-0810/INVENTORY.md。
+
+
+## 0.8.11 模型目录与选择
+
+不提供推理档位的模型省略官方 reasoning 元数据；单项资料不合法时只剔除该项，在官方“设置 → 模型”页按模型名称显示中文原因和诊断代码。整组查询失败在菜单显示中文，可到同一设置页核对技术原因。没有会话的目录查询不写入其他会话的技术详情。
+
+只修正属于本插件的旧版或失效全局默认：Claude 只取目录 value 为 default 的唯一别名，resolvedModel 原值包括 null 都保留；Codex 只取 source.isDefault 为 true 的唯一项。有效的员工明确选择保持不变。没有唯一默认时不选首项，发送前提示“请先选择模型”。官方默认设置只有字符串 model、没有 nullable 清除接口；此时写入空字符串，原生界面可能显示提供方加斜线，而无实际模型选中。通过官方 configEditor.entries/edit 找到唯一默认模型设置，在配置锁内重新核对员工选择后才更新；不使用缺少条件保护的 saveSelection。保存失败或选择已变化时在官方模型设置页明示。全局默认也会影响没有独立选择的旧空白会话，已有持久模型选择的老会话不改。
+
+老会话存着 remote 时，请在该会话的模型菜单重新选择当前目录中的型号。插件不会替员工改写会话选择。
+
+官方 loop 在 prepareCall 成功后才把原话追加到对话正文。插件不能更改此核心顺序；由实际 X 准备入口标记、同一错误对象及同一信号可核对的零发送准备失败，会在官方 agent 空闲后，把原话（原 ID、附件及顺序）恢复到官方持久待发送队列，核验落盘后在模型设置诊断中说明；员工可在原生输入区待发送队列查看。恢复本身不会唤醒、重试或再发模型请求；更换模型后由员工手动发送，新的外部输入仍可能触发官方队列消费。取消、卸载、未知错误、已进入模型派发、无法证明来自 X 的官方外围元数据/effort 校验错误，以及早于公开 pre-step 的附件准入/assembly 失败不盲目重排。没有承诺把这些失败直接补成正文气泡；这一能力位于官方 loop 的核心追加顺序，插件的最佳可用结果是持久待发送队列。恢复/持久化不能确认时显示明确诊断。
+
+工程验证使用 emp-a 实际完整 Claude 13 项及 Codex 7 项只读目录，交官方 rc.2 校验；不代表本版 leo 菜单、输入显示或真实模型执行已经验收。新增设置、上限、阈值为 0；七项参数沿用 0.8.10。
+
+
+0.8.11 同时包含 main f8cddc5 的旧来源一次确认：先确认唯一原生工作区、原始输入与连接代次，再按 L0.7.17 公开 CAS 选择本机来源，接纳后继续原本这一轮。不会自动保留主机作为替代，也不会重发旧任务。确认前后失败的私有耐久记录随本版提供；L 可见的前置诊断入口尚待 L0.7.18 后续交付，本版不宣称已显示该详情。

package/dist/acp.js

@@ -369,7 +369,7 @@ export class AcpSession {
         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.10' },
+                protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.8.11' },
                 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);

package/dist/employee-mcp.js

@@ -121,7 +121,7 @@ export async function openEmployeeMcp(options) {
             socket.destroy();
             return;
         }
-        const mcp = new Server({ name: 'ai-workbench-employee', version: '0.8.10' }, { capabilities: { tools: {} } }), transport = new EmployeeSocketTransport(socket, options.maxBytes);
+        const mcp = new Server({ name: 'ai-workbench-employee', version: '0.8.11' }, { capabilities: { tools: {} } }), transport = new EmployeeSocketTransport(socket, options.maxBytes);
         clients.add(mcp);
         transports.add(transport);
         mcp.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: EMPLOYEE_MCP_TOOLS }));

package/dist/index.js

@@ -24,11 +24,14 @@ import { verifyRecoveryCheckpoint, currentInputIds } from "./recovery-checkpoint
 import { ModelCatalog, modelInfo } from "./model-catalog.js";
 import { ModelConfigurationError } from "./model-configuration.js";
 import { officialEmployeeWorkspace } from "./employee-workspace.js";
+import { nativeWorkspaceSourceConfirmation } from "./workspace-source-confirmation.js";
 import { resolveEmployeeNative } from "./employee-native.js";
 import { createLocalUserTurnObserver } from "./local-user-turn.js";
 import { createClaudeLocalProvider } from "./claude-local.js";
 import { readLocalUserTurn } from "./local-user-turn.js";
 import { readEmployeeWorkspace } from "./employee-workspace.js";
+import { createModelDefaults, createDefaultSelectionWriter } from "./model-defaults.js";
+import { installModelInputRetention, markModelPreparationFailure } from "./model-input-retention.js";
 export const name = 'ai-workbench-remote-agent';
 export const settingsNamespace = 'ai-workbench-codex';
 // L can be installed/enabled after X; keeping X mounted lets it explain the prerequisite.
@@ -100,14 +103,21 @@ export class CodexRemoteAdapter extends LlmAdapter {
     finally {
         catalog.release();
     } }
-    async resolveModel(provider, id, signal) { const catalog = await this.catalog(signal); try {
-        const model = catalog.models.find(model => model.id === id);
-        if (!model)
-            throw new LlmError('无法获取模型列表：所选模型已不在当前主机目录中', 'MODEL_CATALOG_UNAVAILABLE');
-        return modelInfo(provider, model);
+    async resolveModel(provider, id, signal) { try {
+        const catalog = await this.catalog(signal);
+        try {
+            const model = catalog.models.find(model => model.id === id);
+            if (!model)
+                throw new LlmError(id === 'remote' ? '无法获取模型列表：这个会话保存的是旧版模型选择，请打开本会话的模型菜单，重新选择模型后再发送。' : '所选模型已不在当前主机目录中，请打开本会话的模型菜单重新选择模型。', 'MODEL_CATALOG_UNAVAILABLE');
+            return modelInfo(provider, model);
+        }
+        finally {
+            catalog.release();
+        }
     }
-    finally {
-        catalog.release();
+    catch (error) {
+        markModelPreparationFailure(provider, error, signal);
+        throw error;
     } }
     async invalidateModelState() { for (const turn of this.turns.values())
         turn.abort(); await Promise.all([...this.sessions.keys()].map(id => this.disposeSession(id))); }
@@ -206,6 +216,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
         const signal = AbortSignal.any([this.lifetime.signal, turn.signal, ...(original.signal ? [original.signal] : [])]);
         const options = { ...original, signal };
         const timing = new StageTiming();
+        let request;
+        let earlyStage = 'input-prepare';
         let runtime;
         let session;
         let live;
@@ -236,7 +248,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             const configuration = JSON.stringify([mode, config.acpMaxMessageBytes, config.brokerMaxFrameBytes, config.brokerControlMaxBytes, config.employeeShellKillGraceMs]);
             if (live && live.configuration !== configuration)
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '会话运行设置已改变，请新建会话', '原会话运行设置');
-            const request = { timing, acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, recoveryCheckpointId: previous?.recoveryCheckpointId, sessionId: options.sessionId, mode, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, retainProcess: !!key && mode === 'session', signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) };
+            request = { timing, acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, recoveryCheckpointId: previous?.recoveryCheckpointId, sessionId: options.sessionId, mode, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, retainProcess: !!key && mode === 'session', signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) };
             const after = options.messages.findLastIndex(message => message.role === 'assistant' && !isWorkspaceNoticeMessage(message));
             request.userInputIds = Object.freeze(options.messages.slice(after + 1).flatMap(message => message.role === 'user' && message.source?.kind === 'user' && typeof message.id === 'string' ? [message.id] : []));
             request.userMessageIds = request.userInputIds;
@@ -270,6 +282,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (mode === 'one-shot')
                 throw new NeedError('MODEL_CONFIGURATION_UNSUPPORTED', '单次模式不支持确认当前模型与推理等级，请改用会话模式', '支持模型配置确认的会话模式');
             request.localAdmissionCheck?.();
+            earlyStage = 'model-catalog';
             catalog = await this.catalog(signal);
             selected = catalog.models.find(model => model.id === options.model);
             if (!selected)
@@ -279,6 +292,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             let modelSignal = AbortSignal.any([signal, catalog.signal]);
             options.signal = modelSignal;
             request.signal = modelSignal;
+            earlyStage = 'runtime-resolve';
             runtime = await this.resolveRuntime(request);
             signal.throwIfAborted();
             if (runtime.execution?.signal) {
@@ -315,6 +329,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (!details)
                 throw new NeedError('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用，请更新远程主机连接组件。', 'L技术详情持久接收能力');
             timing.bind(detail => details.record(detail));
+            request.recordEarlyFailure = undefined;
             const mapper = new StreamMapper(mode === 'session' && !contextChanged ? (runtime.restartNotice ? undefined : live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined, observation => details.record(observation));
             activeMapper = mapper;
             let id;
@@ -505,11 +520,29 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (live && (remoteAttempted || runtime === live.runtime))
                 live.failure = { cause: error };
             let reportingFailure;
+            if (request?.recordEarlyFailure) {
+                const record = request.recordEarlyFailure;
+                request.recordEarlyFailure = undefined;
+                const code = error instanceof NeedError || error instanceof ModelConfigurationError ? error.code : error instanceof LlmError ? error.failure.code : signal.aborted ? 'ABORTED' : 'WORKSPACE_SOURCE_CONFIRMATION_FAILED';
+                try {
+                    await record(new NeedError(code, '来源确认后本轮在执行前失败。', '白名单阶段与错误代码'), earlyStage);
+                }
+                catch (failure) {
+                    reportingFailure = { cause: failure };
+                }
+            }
             try {
                 await runtime?.details?.flush();
             }
             catch (failure) {
-                reportingFailure = { cause: failure };
+                if (reportingFailure === undefined)
+                    reportingFailure = { cause: failure };
+                else {
+                    const first = reportingFailure.cause;
+                    const originalCode = error instanceof NeedError || error instanceof ModelConfigurationError ? error.code : error instanceof LlmError ? error.failure.code : 'WORKSPACE_SOURCE_CONFIRMATION_FAILED';
+                    const flushCode = failure instanceof NeedError || failure instanceof ModelConfigurationError ? failure.code : failure instanceof LlmError ? failure.failure.code : 'CONVERSATION_DETAILS_FAILED';
+                    reportingFailure = { cause: Object.assign(new NeedError('CONVERSATION_DETAILS_FAILED', '本轮诊断保存及详情收尾失败，已停止。', '原错误代码 ' + originalCode + '；' + (first instanceof NeedError ? first.requires : '早期诊断保存失败') + '；详情收尾代码 ' + flushCode), { cause: new AggregateError([error, first, failure], 'ADMISSION_DIAGNOSTIC_AND_FLUSH_FAILED') }) };
+                }
             }
             if (activeMapper)
                 yield* activeMapper.flush();
@@ -582,8 +615,26 @@ export function apply(ctx, live) {
         }
         return manager;
     };
-    let changed = () => { };
-    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes, undefined, () => changed());
+    let changed = () => { }, publishDiagnostics = () => { };
+    const diagnostics = new Map();
+    const diagnostic = (scope, provider, message) => {
+        let entry = diagnostics.get(provider);
+        if (!entry) {
+            entry = new Map();
+            diagnostics.set(provider, entry);
+        }
+        if (entry.get(scope) === message)
+            return;
+        if (message === undefined)
+            entry.delete(scope);
+        else
+            entry.set(scope, message);
+        publishDiagnostics();
+    };
+    let defaults;
+    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes, undefined, () => changed(), (brand, message) => {
+        diagnostic('catalog', AGENTS.find(agent => agent.loginProvider === brand).id, message);
+    }, (agent, models, assertCurrent) => defaults?.observe(agent, models, assertCurrent));
     const adapter = new RemoteAgentsAdapter(config, agent => {
         const details = async (request, api, connection, target) => {
             return managerForProfile().open({ sessionId: request.sessionId, provider: agent.loginProvider, identity: `${target.username}@${target.host}:${target.port}`, connection, localAcceptanceId: request.localAcceptanceId ?? request.localAcceptance?.acceptanceId });
@@ -618,15 +669,19 @@ export function apply(ctx, live) {
             return runtime;
         };
         const local = agent.loginProvider === 'claude' ? createClaudeLocalProvider({ getConnect: get, getNetwork: () => ctx.get('aiWorkbenchNetwork'), readWorkspace: id => readEmployeeWorkspace(ctx, id), readUserTurn: request => readLocalUserTurn(ctx, { sessionId: request.sessionId, route: agent.id, userMessageIds: request.userMessageIds ?? [] }), reportAdmissionFailure: (request, code) => managerForProfile().recordLocalFailure({ sessionId: request.sessionId, provider: 'claude', code }), recordUnscoped: (request, observation) => managerForProfile().recordLocalFailure({ sessionId: request.sessionId, provider: 'claude', code: observation.code, observation }), configuration: config, details, open }) : undefined;
-        return connectProvider(get, { agent, ...(agent.loginProvider === 'codex' ? { employee: {
+        const workspace = async (request) => {
+            const services = ctx;
+            const registry = services.get('workspaceRegistry');
+            const sessions = services.get('sessions');
+            return officialEmployeeWorkspace(request.sessionId, registry, sessions?.get(request.sessionId)?.header);
+        };
+        return connectProvider(get, { agent, workspaceSource: {
+                workspace, currentUserTurn: request => localTurns.current(request), confirm: nativeWorkspaceSourceConfirmation(ctx),
+                record: (request, observation) => managerForProfile().recordLocalFailure({ sessionId: request.sessionId, provider: agent.loginProvider, code: observation.code, observation }),
+            }, ...(agent.loginProvider === 'codex' ? { employee: {
                     currentUserTurn: request => localTurns.current(request),
                     getNetwork: () => ctx.get('aiWorkbenchNetwork'),
-                    workspace: async (request) => {
-                        const services = ctx;
-                        const registry = services.get('workspaceRegistry');
-                        const sessions = services.get('sessions');
-                        return officialEmployeeWorkspace(request.sessionId, registry, sessions?.get(request.sessionId)?.header);
-                    }, native: () => resolveEmployeeNative(),
+                    workspace, native: () => resolveEmployeeNative(),
                 } } : {}), notice: createWorkspaceNoticeConsumer(ctx, agent), details, open, local });
     }, dshApproval(ctx), agent => agent.name[language], readImage, (sessionId, code, diagnostic) => {
         const events = sessionId ? ctx.get('agents')?.get(SessionId(sessionId))?.session.snapshotEvents() : undefined;
@@ -648,11 +703,30 @@ export function apply(ctx, live) {
         return managerForProfile().recordLoginFailure({ sessionId, code, diagnostic, context: { turn, step } });
     }, modelDirectory);
     const ids = AGENTS.map(agent => agent.id);
-    const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: settingsNamespace, settingsPath: [] }));
+    const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: settingsNamespace, settingsPath: [], ...(diagnostics.get(agent.id)?.size ? { error: [...diagnostics.get(agent.id).values()].join('\n') } : {}) }));
     const directory = ctx.llm.registerConfigurableProviders(entries());
     const registration = ctx.llm.registerAdapter(ids, adapter);
-    changed = () => { registration.replace(ids); void adapter.invalidateModelState().catch(() => { ctx.logger('remote-agent').warn('原会话清理结果未确认，已阻断继续发送；请联系管理员核对。'); }); };
+    installModelInputRetention(ctx, { isOurProvider: provider => ids.includes(provider), diagnostic: (provider, message) => diagnostic('input', provider, message) });
     const serviceValue = (name) => ctx.get(name);
+    publishDiagnostics = () => directory.replace(entries());
+    const refreshDefault = () => {
+        const service = serviceValue('agentDefaultModel');
+        const selected = service?.currentSelection();
+        const agent = AGENTS.find(agent => agent.id === selected?.provider);
+        if (!defaults || !agent)
+            return;
+        // Read through the same trusted, fresh catalog. Failures are already recorded there.
+        void modelDirectory.read(agent).then(lease => lease.release(), () => { });
+    };
+    ctx.inject(['agentDefaultModel'], child => {
+        const service = child.get('agentDefaultModel');
+        const current = createModelDefaults(service, (provider, message) => diagnostic('default', provider, message), createDefaultSelectionWriter(service, () => serviceValue('configEditor')));
+        defaults = current;
+        refreshDefault();
+        child.effect(() => () => { current.dispose(); if (defaults === current)
+            defaults = undefined; });
+    });
+    changed = () => { registration.replace(ids); refreshDefault(); void adapter.invalidateModelState().catch(() => { ctx.logger('remote-agent').warn('原会话清理结果未确认，已阻断继续发送；请联系管理员核对。'); }); };
     let employeeConnect = serviceValue('aiWorkbenchConnect'), employeeNetwork = serviceValue('aiWorkbenchNetwork');
     ctx.on('internal/service', service => {
         if (service === 'aiWorkbenchConnect')

package/dist/model-catalog.d.ts

@@ -28,7 +28,19 @@ export interface ModelDirectory {
     read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;
 }
 export type CatalogRunner = (target: ConnectTarget, command: string, signal: AbortSignal, maxBytes: number) => Promise<string>;
-export declare function parseHostCatalog(input: string, provider: string, username: string): HostModel[];
+export interface CatalogIssue {
+    readonly modelName: string;
+    readonly reason: string;
+    readonly code: string;
+}
+export interface ParsedCatalog {
+    readonly models: readonly HostModel[];
+    readonly issues: readonly CatalogIssue[];
+}
+export declare function catalogDiagnostic(issues: readonly CatalogIssue[]): string | undefined;
+/** Defaults are provider declarations, never catalog order or display names. */
+export declare function declaredDefault(agent: AgentDefinition, models: readonly HostModel[]): HostModel | undefined;
+export declare function parseHostCatalog(input: string, provider: string, username: string): ParsedCatalog;
 /** Only the public L sshArgs function chooses SSH trust and transport arguments. */
 export declare const runCatalog: CatalogRunner;
 /** No cache: every query binds to L's current object, host-user and generation. */
@@ -37,6 +49,8 @@ export declare class ModelCatalog implements ModelDirectory {
     private maxBytes;
     private run;
     private changed;
+    private diagnostic;
+    private loaded;
     private api?;
     private unsubscribe?;
     private signature?;
@@ -44,7 +58,9 @@ export declare class ModelCatalog implements ModelDirectory {
     private disposed;
     private initialized;
     private active;
-    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void);
+    private serial;
+    private latest;
+    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void, diagnostic?: (provider: 'claude' | 'codex', message: string | undefined) => void, loaded?: (agent: AgentDefinition, models: readonly HostModel[], assertCurrent: () => void) => void | Promise<void>);
     refresh(): void;
     private trusted;
     read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;

package/dist/model-catalog.js

@@ -13,12 +13,25 @@ import { ModelConfigurationError } from "./model-configuration.js";
 import { sanitizeObservation } from "./conversation-details.js";
 const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
 const text = (value) => typeof value === 'string' && value.trim().length > 0;
-function fail(reason) { throw new LlmError('无法获取模型列表：' + reason, 'MODEL_CATALOG_UNAVAILABLE'); }
+class CatalogError extends LlmError {
+    diagnostic;
+    constructor(reason, diagnostic) { super('无法获取模型列表：' + reason, 'MODEL_CATALOG_UNAVAILABLE'); this.diagnostic = diagnostic + '（诊断代码：MODEL_CATALOG_UNAVAILABLE）'; }
+}
+const safe = (value) => sanitizeObservation({ kind: 'session', severity: 'warning', code: 'MODEL_CATALOG_DIAGNOSTIC', summary: value, payload: {} }).summary;
+function fail(reason, diagnostic = reason) { throw new CatalogError(reason, diagnostic); }
 function freeze(value) { if (value && typeof value === 'object') {
     for (const item of Object.values(value))
         freeze(item);
     Object.freeze(value);
 } return value; }
+export function catalogDiagnostic(issues) {
+    return issues.length ? '以下模型未加入可选列表：\n' + issues.map(issue => `模型「${issue.modelName}」：${issue.reason}（诊断代码：${issue.code}）`).join('\n') : undefined;
+}
+/** Defaults are provider declarations, never catalog order or display names. */
+export function declaredDefault(agent, models) {
+    const selected = models.filter(model => agent.loginProvider === 'claude' ? model.value === 'default' : object(model.source) && model.source.isDefault === true);
+    return selected.length === 1 ? selected[0] : undefined;
+}
 export function parseHostCatalog(input, provider, username) {
     let wire;
     try {
@@ -32,36 +45,60 @@ export function parseHostCatalog(input, provider, username) {
     if (wire.ok === false) {
         const error = object(wire.error) ? wire.error : undefined;
         const code = typeof error?.code === 'string' && /^[A-Z][A-Z0-9_]*$/.test(error.code) ? error.code : 'PROTOCOL_INVALID';
-        const reason = text(error?.message) ? sanitizeObservation({ kind: 'session', severity: 'warning', code, summary: error.message, payload: {} }).summary : '主机未提供失败说明';
-        fail('主机目录查询失败（' + code + '）：' + reason);
+        const reason = text(error?.message) ? safe(error.message) : '主机未提供失败说明';
+        fail('主机目录查询失败，请到设置 → 模型查看诊断。', `主机目录查询失败（诊断代码：${code}）：${reason}`);
     }
     if (wire.ok !== true || wire.permissionProbe !== false || !object(wire.subject) || wire.subject.username !== username || !Number.isSafeInteger(wire.subject.uid) || !text(wire.observedAt) || !object(wire.source) || !object(wire.settings) || !Array.isArray(wire.models))
         fail('主机目录缺少完整元数据');
-    const ids = new Set(), values = new Set();
-    for (const model of wire.models) {
-        if (!object(model) || !text(model.id) || !text(model.value) || !text(model.name) || (model.resolvedModel !== null && !text(model.resolvedModel)) || !object(model.source) || !object(model.reasoning))
-            fail('主机模型条目不完整');
-        if (provider === 'codex' && model.resolvedModel !== model.value)
-            fail('Codex目录具体型号与模型值不一致');
-        if (ids.has(model.id) || values.has(model.value))
-            fail('主机目录含重复模型标识或值');
-        ids.add(model.id);
-        values.add(model.value);
+    const ids = new Map(), values = new Map();
+    for (const model of wire.models)
+        if (object(model)) {
+            if (text(model.id))
+                ids.set(model.id, (ids.get(model.id) ?? 0) + 1);
+            if (text(model.value))
+                values.set(model.value, (values.get(model.value) ?? 0) + 1);
+        }
+    const models = [], issues = [];
+    for (const [index, model] of wire.models.entries()) {
+        const modelName = object(model) && text(model.name) ? safe(model.name) : object(model) && text(model.id) ? safe(model.id) : `第 ${index + 1} 项（缺少模型名称）`;
+        const reject = (reason, code = 'MODEL_CATALOG_ITEM_INVALID') => issues.push({ modelName, reason, code });
+        if (!object(model) || !text(model.id) || !text(model.value) || !text(model.name) || (model.resolvedModel !== null && !text(model.resolvedModel)) || !object(model.source) || !object(model.reasoning)) {
+            reject('模型标识、名称或能力资料不完整');
+            continue;
+        }
+        if ((ids.get(model.id) ?? 0) > 1 || (values.get(model.value) ?? 0) > 1) {
+            reject('模型标识或发送值重复，无法确定对应关系', 'MODEL_CATALOG_DUPLICATE');
+            continue;
+        }
+        if (provider === 'codex' && model.resolvedModel !== model.value) {
+            reject('具体型号与发送模型值不一致');
+            continue;
+        }
         const r = model.reasoning;
-        if (!Array.isArray(r.options) || typeof r.defaultKnown !== 'boolean' || (r.defaultValue !== null && !text(r.defaultValue)) || (!r.defaultKnown && r.defaultValue !== null))
-            fail('主机推理等级或默认值无效');
+        if (!Array.isArray(r.options) || typeof r.defaultKnown !== 'boolean' || (r.defaultValue !== null && !text(r.defaultValue)) || (!r.defaultKnown && r.defaultValue !== null)) {
+            reject('推理档位或默认档位资料无效', 'MODEL_REASONING_INVALID');
+            continue;
+        }
         const efforts = new Set();
+        let invalid = false;
         for (const effort of r.options) {
-            if (!object(effort) || !text(effort.value) || !text(effort.name) || efforts.has(effort.value))
-                fail('主机推理等级条目无效或重复');
+            if (!object(effort) || !text(effort.value) || !text(effort.name) || efforts.has(effort.value)) {
+                invalid = true;
+                break;
+            }
             efforts.add(effort.value);
         }
-        if (r.defaultKnown && (r.defaultValue === null || !efforts.has(r.defaultValue)))
-            fail('主机默认推理等级缺少对应选项');
+        if (invalid) {
+            reject('推理档位缺少名称、值无效或重复', 'MODEL_REASONING_INVALID');
+            continue;
+        }
+        if (r.defaultKnown && (r.defaultValue === null || !efforts.has(r.defaultValue))) {
+            reject('默认推理档位不在该模型提供的选项中', 'MODEL_REASONING_DEFAULT_INVALID');
+            continue;
+        }
+        models.push(model);
     }
-    if (!wire.models.length)
-        fail('主机返回的完整模型目录为空');
-    return freeze(structuredClone(wire.models));
+    return freeze(structuredClone({ models, issues }));
 }
 /** Only the public L sshArgs function chooses SSH trust and transport arguments. */
 export const runCatalog = async (target, command, signal, maxBytes) => {
@@ -141,6 +178,8 @@ export class ModelCatalog {
     maxBytes;
     run;
     changed;
+    diagnostic;
+    loaded;
     api;
     unsubscribe;
     signature;
@@ -148,11 +187,15 @@ export class ModelCatalog {
     disposed = false;
     initialized = false;
     active = new Set();
-    constructor(get, maxBytes, run = runCatalog, changed = () => { }) {
+    serial = 0;
+    latest = new Map();
+    constructor(get, maxBytes, run = runCatalog, changed = () => { }, diagnostic = () => { }, loaded = () => { }) {
         this.get = get;
         this.maxBytes = maxBytes;
         this.run = run;
         this.changed = changed;
+        this.diagnostic = diagnostic;
+        this.loaded = loaded;
         this.refresh();
     }
     refresh() {
@@ -183,9 +226,12 @@ export class ModelCatalog {
         this.signature = signature;
         if (changed) {
             this.revision++;
+            this.latest.clear();
             for (const controller of this.active)
                 controller.abort();
             this.active.clear();
+            this.diagnostic('claude', undefined);
+            this.diagnostic('codex', undefined);
             this.changed();
         }
     }
@@ -198,7 +244,7 @@ export class ModelCatalog {
             fail('当前没有已验证的远程主机连接');
         const result = api.getModelCatalogTarget(agent.loginProvider);
         if (!result.ok)
-            fail(result.error.message);
+            fail('远程主机连接暂未提供可信的模型目录目标，请到设置 → 模型查看诊断。', `模型目录目标不可用（诊断代码：${safe(result.error.code)}）：${safe(result.error.message)}`);
         const target = result.value;
         if (target.version !== 1 || target.purpose !== 'model-catalog' || target.scope !== 'host-user' || target.provider !== agent.loginProvider || target.instanceId !== state.instanceId || target.epoch !== state.epoch)
             fail('模型目录目标与当前连接或品牌不匹配');
@@ -212,43 +258,62 @@ export class ModelCatalog {
     }
     async read(agent, signal) {
         let controller;
+        let api;
+        let revision = this.revision;
+        const serial = ++this.serial;
+        this.latest.set(agent.loginProvider, serial);
+        const current = () => !this.disposed && revision === this.revision && api === this.get() && this.latest.get(agent.loginProvider) === serial;
+        let reported = false;
+        const report = (message) => { if (current()) {
+            reported = true;
+            this.diagnostic(agent.loginProvider, message);
+        } };
         try {
             if (this.disposed)
                 fail('远程模型插件已关闭');
             this.refresh();
-            const api = this.get();
+            api = this.get();
+            revision = this.revision;
             if (!api)
                 fail('远程主机连接组件没有装好');
-            const target = freeze(this.trusted(agent, api)), revision = this.revision;
+            // refresh may clear reads from the previous connection generation.
+            this.latest.set(agent.loginProvider, serial);
+            const trustedApi = api, target = freeze(this.trusted(agent, trustedApi));
             const max = this.maxBytes();
             if (!Number.isSafeInteger(max) || max < 1)
                 fail('acpMaxMessageBytes 设置无效');
             controller = new AbortController();
             this.active.add(controller);
             const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-            const assertCurrent = () => { if (combined.aborted || this.disposed || this.get() !== api || revision !== this.revision)
-                fail('连接已改变，原模型目录已失效'); const current = this.trusted(agent, api); if (current.instanceId !== target.instanceId || current.epoch !== target.epoch || current.provider !== target.provider || !sameTarget(current.target, target.target))
+            const assertCurrent = () => { if (combined.aborted || this.disposed || this.get() !== trustedApi || revision !== this.revision)
+                fail('连接已改变，原模型目录已失效'); const current = this.trusted(agent, trustedApi); if (current.instanceId !== target.instanceId || current.epoch !== target.epoch || current.provider !== target.provider || !sameTarget(current.target, target.target))
                 fail('可信目标或连接代次已改变，原模型目录已失效'); };
             assertCurrent();
             const output = await this.run(target.target, '/usr/local/aw-host/bin/aw-model-catalog --provider ' + agent.loginProvider, combined, max);
             assertCurrent();
-            const models = parseHostCatalog(output, agent.loginProvider, target.target.username);
+            const parsed = parseHostCatalog(output, agent.loginProvider, target.target.username), diagnostic = catalogDiagnostic(parsed.issues);
+            if (!parsed.models.length)
+                fail('当前没有可选模型，请到设置 → 模型查看诊断。', diagnostic ?? '主机返回的完整模型目录为空（诊断代码：MODEL_CATALOG_EMPTY）');
+            report(diagnostic);
+            if (current())
+                await this.loaded(agent, parsed.models, assertCurrent);
+            assertCurrent();
             const own = controller;
-            return { target, models, signal: combined, assertCurrent, release: () => this.active.delete(own) };
+            return { target, models: parsed.models, signal: combined, assertCurrent, release: () => this.active.delete(own) };
         }
         catch (error) {
             if (controller)
                 this.active.delete(controller);
-            if (error instanceof LlmError)
-                throw error;
-            if (error instanceof ModelConfigurationError)
-                fail(error.message.replace(/^无法获取模型列表：/, ''));
-            fail('目录查询失败，根因未查明');
+            const failure = error instanceof CatalogError ? error : new CatalogError(error instanceof ModelConfigurationError ? error.message.replace(/^无法获取模型列表：/, '') : '目录查询失败，请到设置 → 模型查看诊断。', error instanceof Error ? `${error instanceof LlmError ? error.code : 'MODEL_CATALOG_QUERY_FAILED'}：${safe(error.message)}` : 'MODEL_CATALOG_QUERY_FAILED：目录查询失败，根因未查明');
+            if (!reported)
+                report(failure.diagnostic);
+            throw failure;
         }
     }
     dispose() { this.disposed = true; this.unsubscribe?.(); for (const controller of this.active)
         controller.abort(); this.active.clear(); }
 }
 export function modelInfo(provider, model) {
-    return { provider, id: model.id, name: model.name, inputModalities: ['text', 'image'], reasoning: { efforts: model.reasoning.options.map(option => ({ id: ReasoningEffortId(option.value), name: option.name })), ...(model.reasoning.defaultKnown && model.reasoning.defaultValue !== null ? { defaultEffort: ReasoningEffortId(model.reasoning.defaultValue) } : {}) }, catalog: model };
+    // Official rc.2 represents no reasoning levels by absence, and rejects an empty efforts array.
+    return { provider, id: model.id, name: model.name, inputModalities: ['text', 'image'], ...(model.reasoning.options.length ? { reasoning: { efforts: model.reasoning.options.map(option => ({ id: ReasoningEffortId(option.value), name: option.name })), ...(model.reasoning.defaultKnown && model.reasoning.defaultValue !== null ? { defaultEffort: ReasoningEffortId(model.reasoning.defaultValue) } : {}) } } : {}), catalog: model };
 }

package/dist/model-defaults.d.ts

@@ -0,0 +1,29 @@
+import type { AgentDefinition } from './agents.ts';
+import { type HostModel } from './model-catalog.ts';
+export interface DefaultSelection {
+    provider: string;
+    model: string;
+    reasoningEffort?: string;
+}
+/** Public agentDefaultModel service; writes below use the atomic config editor. */
+export interface DefaultModelService {
+    currentSelection(): DefaultSelection;
+}
+interface DefaultEntry {
+    options: {
+        name?: string;
+    };
+}
+/** Public rc.2 configEditor.entries/edit subset; no ownerContext/private config access. */
+export interface DefaultConfigEditor {
+    entries(): readonly DefaultEntry[];
+    edit(entry: DefaultEntry, change: (current: Record<string, unknown>, inherited: Record<string, unknown>) => Record<string, unknown>): Promise<void>;
+}
+export type DefaultSelectionWriter = (expected: DefaultSelection, next: DefaultSelection, assertCurrent: () => void) => Promise<void>;
+/** The editor invokes the guard synchronously under its profile lock after reconciliation. */
+export declare function createDefaultSelectionWriter(service: DefaultModelService, getEditor: () => DefaultConfigEditor | undefined): DefaultSelectionWriter;
+export declare function createModelDefaults(service: DefaultModelService, report: (provider: string, message: string | undefined) => void, write?: DefaultSelectionWriter): {
+    observe(agent: AgentDefinition, models: readonly HostModel[], assertCurrent?: () => void): Promise<void>;
+    dispose(): void;
+};
+export {};

package/dist/model-defaults.js

@@ -0,0 +1,62 @@
+import { declaredDefault } from "./model-catalog.js";
+const same = (a, b) => a.provider === b.provider && a.model === b.model && a.reasoningEffort === b.reasoningEffort;
+/** The editor invokes the guard synchronously under its profile lock after reconciliation. */
+export function createDefaultSelectionWriter(service, getEditor) {
+    return async (expected, next, assertCurrent) => {
+        const editor = getEditor();
+        const entries = editor?.entries().filter(entry => entry.options.name === '@deepseek-ai/dsh-agent-default-model');
+        if (!editor || entries?.length !== 1)
+            throw Error('缺少唯一可原子编辑的官方默认模型设置');
+        await editor.edit(entries[0], current => {
+            assertCurrent();
+            if (!same(expected, service.currentSelection()))
+                throw Error('员工已改变模型选择，本次默认更新已撤回');
+            const updated = { ...current, provider: next.provider, model: next.model };
+            Reflect.deleteProperty(updated, 'reasoningEffort');
+            if (next.reasoningEffort !== undefined)
+                Object.assign(updated, { reasoningEffort: next.reasoningEffort });
+            return updated;
+        });
+    };
+}
+export function createModelDefaults(service, report, write) {
+    let disposed = false, queue = Promise.resolve();
+    return {
+        observe(agent, models, assertCurrent = () => { }) {
+            const snapshot = { ...service.currentSelection() };
+            const job = queue.then(async () => {
+                if (disposed || snapshot.provider !== agent.id || !same(snapshot, service.currentSelection()))
+                    return;
+                if (snapshot.model !== 'remote' && models.some(model => model.id === snapshot.model)) {
+                    report(agent.id, undefined);
+                    return;
+                }
+                const model = declaredDefault(agent, models);
+                const notice = model ? undefined : '提供方没有声明唯一的默认模型，请先选择模型。（诊断代码：MODEL_DEFAULT_UNAVAILABLE）';
+                const next = { provider: agent.id, model: model?.id ?? '', ...(model?.reasoning.defaultKnown && model.reasoning.defaultValue !== null ? { reasoningEffort: model.reasoning.defaultValue } : {}) };
+                try {
+                    const guard = () => { assertCurrent(); if (disposed)
+                        throw Error('默认设置消费已撤回'); };
+                    guard();
+                    if (!same(snapshot, next)) {
+                        if (!write)
+                            throw Error('缺少原子配置能力');
+                        await write(snapshot, next, guard);
+                    }
+                    if (disposed)
+                        return;
+                    if (!same(next, service.currentSelection()))
+                        throw Error('未确认官方默认模型设置已保存');
+                    report(agent.id, notice);
+                }
+                catch {
+                    if (!disposed)
+                        report(agent.id, (notice ? notice + '\n' : '') + '未能确认默认模型设置已更新，员工新选择不会被迟到的自动更新覆盖；请在模型菜单选择当前目录中的模型。（诊断代码：MODEL_DEFAULT_SAVE_FAILED）');
+                }
+            });
+            queue = job;
+            return job;
+        },
+        dispose() { disposed = true; },
+    };
+}

package/dist/model-input-retention.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@deepseek-ai/cordis';
+export interface ModelInputRetentionOptions {
+    isOurProvider: (provider: string) => boolean;
+    diagnostic: (provider: string, message: string | undefined) => void;
+}
+/** Mark only at the actual X adapter's preparation catch, then rethrow the same
+ * error. One error object can prove only its first preparation, for that signal.
+ * Public request config is an intermediate proposal and is not route evidence. */
+export declare function markModelPreparationFailure(provider: string, error: unknown, signal?: AbortSignal): void;
+/**
+ * Retain a claimed human batch only after a known, undispatched metadata prepare
+ * failure. Restoration uses the public durable inbox without sending or waking
+ * the agent. This cannot cover errors before pre-step/request, or unknown core
+ * admission failures; it never manufactures transcript messages or model routes.
+ */
+export declare function installModelInputRetention(ctx: Context, options: ModelInputRetentionOptions): void;

package/dist/model-input-retention.js

@@ -0,0 +1,129 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { Session } from '@deepseek-ai/dsh-session';
+import { isDeepStrictEqual } from 'node:util';
+const preparationFailures = new WeakMap();
+/** Mark only at the actual X adapter's preparation catch, then rethrow the same
+ * error. One error object can prove only its first preparation, for that signal.
+ * Public request config is an intermediate proposal and is not route evidence. */
+export function markModelPreparationFailure(provider, error, signal) {
+    if (!signal || signal.aborted || error === null || typeof error !== 'object' || preparationFailures.has(error))
+        return;
+    preparationFailures.set(error, { provider, signal, consumed: false });
+}
+// Even a source-proven unknown early failure is deliberately not replayed.
+const preparationCodes = new Set(['MODEL_REQUIRED', 'MODEL_CATALOG_UNAVAILABLE', 'INVALID_MODEL_INFO', 'INVALID_MODEL_CONTEXT', 'INVALID_MODEL_MAX_TOKENS', 'INVALID_MODEL_REASONING', 'UNSUPPORTED_REASONING_EFFORT']);
+function codeOf(error) {
+    const code = error !== null && typeof error === 'object' && 'code' in error ? error.code : undefined;
+    return typeof code === 'string' && /^[A-Z][A-Z0-9_]*$/u.test(code) ? code : undefined;
+}
+function committed(events, messages) {
+    return events.some(event => event.type === 'user/message' && messages.some(message => message.id === event.data.id));
+}
+/**
+ * Retain a claimed human batch only after a known, undispatched metadata prepare
+ * failure. Restoration uses the public durable inbox without sending or waking
+ * the agent. This cannot cover errors before pre-step/request, or unknown core
+ * admission failures; it never manufactures transcript messages or model routes.
+ */
+export function installModelInputRetention(ctx, options) {
+    const attempts = new Map();
+    let disposed = false;
+    const live = (a) => !disposed && attempts.get(a.agent) === a && !a.signal.aborted
+        && ctx.get('agents')?.get(a.agent.id) === a.agent && ctx.get('sessions')?.get(a.session.id) === a.session && a.agent.session === a.session;
+    const safe = (a) => {
+        const events = a.session.snapshotEvents();
+        return !a.dispatched && !committed(events, a.messages) && !events.slice(a.offset).some(event => event.type === 'request/header' || event.type === 'assistant/message' || event.type === 'assistant/attempt');
+    };
+    const report = (a, message) => { if (!disposed && a.provider)
+        options.diagnostic(a.provider, message); };
+    const restore = async (a, originalCode) => {
+        try {
+            await a.agent.whenIdle();
+            if (!live(a) || !safe(a))
+                return;
+            // Claim true idle synchronously. A competing maintenance claim is reported,
+            // not retried. Input waking during this task remains the driver's own work.
+            await a.agent.runMaintenance(async (signal) => {
+                if (!live(a) || signal.aborted || !safe(a))
+                    return;
+                const queue = [...a.agent.inbox.nextTurn, ...a.agent.inbox.nextStep];
+                if (a.messages.some(message => queue.some(item => item.id === message.id)))
+                    return;
+                a.agent.inbox.splice('next-turn', 0, 0, a.messages);
+                const store = ctx.get('sessions'), persistence = ctx.get('sessionPersistence');
+                if (!store || typeof persistence?.open !== 'function' || !await store.flush(a.session))
+                    throw Object.assign(new Error('缺少官方持久化能力'), { code: 'INPUT_RETENTION_PERSISTENCE_REQUIRED' });
+                if (!live(a) || signal.aborted)
+                    return;
+                const handle = await persistence.open(a.session.id, 'read');
+                try {
+                    if (handle.id !== a.session.id || handle.header?.id !== a.session.id || handle.access !== 'read')
+                        throw Object.assign(new Error('持久会话身份不符'), { code: 'INPUT_RETENTION_VERIFY_FAILED' });
+                    const { events } = await handle.read();
+                    // Replay through the official Session validator and registered inbox fold,
+                    // including exact fork metadata. Do not normalize invalid durable splices.
+                    const replay = Session.create(a.session.id, events, handle.header, handle.inheritedEventCount);
+                    const inbox = ctx.get('sessionProjections')?.snapshot(replay, ['inbox']).values.inbox;
+                    if (!inbox)
+                        throw Object.assign(new Error('缺少官方待发队列投影'), { code: 'INPUT_RETENTION_PROJECTION_REQUIRED' });
+                    const restored = [...inbox['next-turn'], ...inbox['next-step']];
+                    if (committed(events, a.messages) || a.messages.some(message => restored.filter(item => item !== null && typeof item === 'object' && !Array.isArray(item) && item.id === message.id).length !== 1 || !restored.some(item => isDeepStrictEqual(item, message))))
+                        throw Object.assign(new Error('持久待发队列核对失败'), { code: 'INPUT_RETENTION_VERIFY_FAILED' });
+                }
+                finally {
+                    await handle.close();
+                }
+                if (live(a) && !signal.aborted)
+                    report(a, `本次模型准备失败，员工原话已保留在待发送队列；请先选择模型或修正设置后手动发送。没有自动重试。（诊断代码：${originalCode}）`);
+            });
+        }
+        catch (error) {
+            report(a, `本次模型准备失败；员工原话的恢复或持久化未能确认，请联系管理员核对，不要重复发送。没有自动重试。（原诊断代码：${originalCode}；恢复诊断代码：${codeOf(error) ?? 'INPUT_RETENTION_FAILED'}）`);
+        }
+        finally {
+            if (attempts.get(a.agent) === a)
+                attempts.delete(a.agent);
+        }
+    };
+    ctx.on('agent/pre-step', async (payload, next) => {
+        const decision = await next();
+        if (disposed)
+            return decision;
+        const messages = payload.messages.filter(message => message.source.kind === 'user');
+        if (decision.kind !== 'enter' || messages.length === 0 || messages.some(message => !decision.messages.some(accepted => accepted === message || isDeepStrictEqual(accepted, message)))) {
+            attempts.delete(payload.agent);
+            return decision;
+        }
+        attempts.set(payload.agent, { agent: payload.agent, session: payload.agent.session, turn: payload.turn, step: payload.step, signal: payload.signal, messages, offset: payload.agent.session.snapshotEvents().length, scheduled: false, dispatched: false });
+        return decision;
+    });
+    ctx.on('agent/request', async (payload, next) => {
+        const config = await next(), a = attempts.get(payload.agent);
+        if (a && a.turn === payload.turn && a.step === payload.step && a.signal === payload.signal && options.isOurProvider(config.provider)) {
+            if (!config.model?.trim()) {
+                const error = new LlmError('请先选择模型', 'MODEL_REQUIRED');
+                markModelPreparationFailure(config.provider, error, payload.signal);
+                throw error;
+            }
+        }
+        return config;
+    });
+    ctx.on('agent/assistant-stream', ({ agent, frame }) => { const a = attempts.get(agent); if (a && frame.type === 'start' && frame.turn === a.turn && frame.step === a.step)
+        a.dispatched = true; });
+    ctx.on('agent/error', ({ agent, turn, step, error }) => {
+        const a = attempts.get(agent), code = codeOf(error);
+        const proof = error !== null && typeof error === 'object' ? preparationFailures.get(error) : undefined;
+        if (!a || a.turn !== turn || a.step !== step || !proof || proof.consumed || proof.signal !== a.signal || !options.isOurProvider(proof.provider))
+            return;
+        // Consume before further checks: canceled/unsafe attempts must not leave a
+        // reusable proof that could authorize a later failure of the same object.
+        proof.consumed = true;
+        if (a.scheduled || !code || !preparationCodes.has(code) || !live(a) || !safe(a))
+            return;
+        a.provider = proof.provider;
+        a.scheduled = true;
+        void restore(a, code);
+    });
+    ctx.on('agent/disposed', ({ agent }) => { attempts.delete(agent); });
+    ctx.effect(() => () => { disposed = true; attempts.clear(); });
+}

package/dist/presentation.js

@@ -5,6 +5,12 @@ export const TEST_HOST_NOTICE = '远程主机正在使用测试配置，遇到
 /** Employee failures use business language; diagnostic codes remain separately available. */
 export function employeeFailure(code, brand = 'codex') {
     const messages = {
+        WORKSPACE_SOURCE_CONFIRMATION_DECLINED: '你没有确认改用本机文件夹，本轮未执行；你的原话仍保留。',
+        WORKSPACE_SOURCE_CONFIRMATION_UNAVAILABLE: '我需要打开工作区来源确认，目前无法显示确认动作；本轮未执行，你的原话仍保留。',
+        WORKSPACE_SOURCE_SELECTION_UNCONFIRMED: '无法核对工作区来源的确认结果，本轮已停止；你的原话仍保留。',
+        WORKSPACE_SOURCE_CONFIRMATION_FAILED: '工作区来源确认未完成，本轮已停止；你的原话仍保留。',
+        WORKSPACE_LOCATION_REQUIRED: '我需要你确认这个工作区使用哪一个文件夹，本轮未执行；你的原话仍保留。',
+        WORKSPACE_LOCATION_CONFLICT: '工作区来源选择已更新，本次确认不能覆盖新的选择；本轮未执行，你的原话仍保留。',
         LOCAL_USER_TURN_CHANGED: '本次输入已变化，本轮已停止，请确认对话后重新发送。',
         LOCAL_USER_TURN_UNCONFIRMED: '无法核对本次员工输入，本轮已停止；请在当前会话重新发送。',
         LOCAL_USER_TURN_ACCEPTANCE_INVALID: '本次输入的核验回执不一致，本轮已停止，请联系管理员。',

package/dist/provider.d.ts

@@ -12,6 +12,7 @@ import type { WorkspaceNoticePresentation } from './workspace-notice.ts';
 import { StageTiming } from './stage-timing.ts';
 import type { RecoveryJournal, AcpRecovery } from './recovery.ts';
 import type { EmployeeProviderOptions } from './employee-provider.ts';
+import { type WorkspaceSourceOptions, type SourceAdmissionStage } from './workspace-source.ts';
 import type { LocalUserTurnAcceptance } from '@ai-workbench/connect/api';
 import type { EmployeeRouting } from './employee-relay.ts';
 export interface EmployeeExecution {
@@ -64,6 +65,7 @@ export interface Runtime {
     employeePresentation?: string;
 }
 export interface RuntimeRequest extends Invocation {
+    recordEarlyFailure?: (error: unknown, stage: SourceAdmissionStage) => Promise<void>;
     userInputIds?: readonly string[];
     localAcceptance?: Readonly<LocalUserTurnAcceptance>;
     localAdmissionCheck?: () => void;
@@ -135,7 +137,7 @@ type Result<T> = {
     } & Pick<ConnectNeed, 'officialReason'>;
 };
 /** 消费正式connect-api 0.7公开子集；X不响应L登录票据、不直接调用登录。 */
-export interface ConnectApi extends Pick<LConnectApi, 'getConnectionState' | 'getLoginPromptState' | 'requestLoginPrompt' | 'refreshLoginPrompts'>, Partial<NativeWorkspaceApi>, Partial<Pick<LConnectApi, 'getWorkspaceBindingState' | 'getModelCatalogTarget' | 'onConnectionState' | 'onLoginPromptState' | 'appendRemoteConversationDetail' | 'getRemoteConversationDetailReceipt' | 'listRemoteConversationDetails' | 'getWorkspaceLocationState' | 'getLocalWorkspaceContext' | 'onWorkspaceLocationState' | 'acceptLocalWorkspaceUserTurn'>> {
+export interface ConnectApi extends Pick<LConnectApi, 'getConnectionState' | 'getLoginPromptState' | 'requestLoginPrompt' | 'refreshLoginPrompts'>, Partial<NativeWorkspaceApi>, Partial<Pick<LConnectApi, 'getWorkspaceBindingState' | 'getModelCatalogTarget' | 'onConnectionState' | 'onLoginPromptState' | 'appendRemoteConversationDetail' | 'getRemoteConversationDetailReceipt' | 'listRemoteConversationDetails' | 'getWorkspaceLocationState' | 'getLocalWorkspaceContext' | 'onWorkspaceLocationState' | 'acceptLocalWorkspaceUserTurn' | 'selectWorkspaceLocation'>> {
     getState?(): ConnectState;
     getSshTarget(): Promise<Result<ConnectTarget>>;
     checkLogin(provider: LoginProvider): Promise<Result<{
@@ -189,6 +191,7 @@ export declare function connectProvider(get: () => ConnectApi | undefined, optio
     agent?: AgentDefinition;
     ask?: Interaction;
     notice?: NoticeConsumer;
+    workspaceSource?: WorkspaceSourceOptions;
     employee?: EmployeeProviderOptions;
     local?: LocalRuntimeProvider;
     details?: (request: RuntimeRequest, api: ConnectApi, connection: ConnectionState, target: ConnectTarget) => Promise<DetailChannel>;

package/dist/provider.js

@@ -3,6 +3,7 @@ import { NeedError } from "./remote.js";
 import { CONNECTION_REQUIRED, TEST_HOST_NOTICE } from "./presentation.js";
 import { CODEX_AGENT } from "./agents.js";
 import { StageTiming } from "./stage-timing.js";
+import { confirmLegacyWorkspaceSource } from "./workspace-source.js";
 export function requireLoginCoordinator(api) {
     if (!['getConnectionState', 'getLoginPromptState', 'requestLoginPrompt', 'refreshLoginPrompts'].every(key => typeof api[key] === 'function'))
         throw new NeedError('CONNECT_API_MISMATCH', '我需要 connect-api 0.6.1 的统一登录询问与连接状态能力', 'L >=0.6.1');
@@ -168,28 +169,49 @@ export function connectProvider(get, options = {}) {
         requireLoginCoordinator(api);
         if (request.mode === 'one-shot' && !agent.oneShot)
             throw new NeedError('MODE_UNSUPPORTED', '此远程模型仅支持会话模式', '使用会话模式');
-        if (options.employee) {
-            const module = await import("./employee-provider.js");
-            request.localAcceptance = await module.acceptEmployeeUserTurn(get, options.employee, agent, api, request);
-        }
-        const { target, connection } = await request.timing.run('login-ready', async () => {
+        const confirmedSource = options.workspaceSource ? await confirmLegacyWorkspaceSource(get, api, request, options.workspaceSource) : undefined;
+        let sourceStage = 'input-acceptance';
+        if (confirmedSource)
+            request.recordEarlyFailure = (error, stage) => confirmedSource.recordFailure(error, stage);
+        try {
+            confirmedSource?.assertCurrent();
+            if (options.employee) {
+                const module = await import("./employee-provider.js");
+                request.localAcceptance = await module.acceptEmployeeUserTurn(get, options.employee, agent, api, request);
+            }
+            confirmedSource?.assertCurrent();
+            if (confirmedSource) {
+                const previous = request.localAdmissionCheck;
+                request.localAdmissionCheck = () => { confirmedSource.assertCurrent(); previous?.(); };
+            }
+            sourceStage = 'login-readiness';
+            const { target, connection } = await request.timing.run('login-ready', async () => {
+                request.localAdmissionCheck?.();
+                const before = api.getConnectionState();
+                const target = await ensureReady(api, agent.loginProvider, request.signal);
+                validateTarget(target);
+                request.signal?.throwIfAborted();
+                if (get() !== api)
+                    throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
+                const connection = await waitForLogin(api, agent.loginProvider, before, get, request.signal);
+                return { target, connection };
+            });
+            if (request.identity && request.identity !== identity(target))
+                throw new NeedError('SESSION_CONTEXT_MISMATCH', '员工主机与原会话不一致，请新建会话', '原员工主机');
+            if (options.employee && request.localAcceptance)
+                await (await import("./employee-provider.js")).validateEmployeeUserTurn(get, options.employee, api, request, connection);
             request.localAdmissionCheck?.();
-            const before = api.getConnectionState();
-            const target = await ensureReady(api, agent.loginProvider, request.signal);
-            validateTarget(target);
-            request.signal?.throwIfAborted();
-            if (get() !== api)
-                throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
-            const connection = await waitForLogin(api, agent.loginProvider, before, get, request.signal);
-            return { target, connection };
-        });
-        if (request.identity && request.identity !== identity(target))
-            throw new NeedError('SESSION_CONTEXT_MISMATCH', '员工主机与原会话不一致，请新建会话', '原员工主机');
-        if (options.employee && request.localAcceptance)
-            await (await import("./employee-provider.js")).validateEmployeeUserTurn(get, options.employee, api, request, connection);
-        request.localAdmissionCheck?.();
-        admissions.set(request, { api, target, connection });
-        await options.local?.admit?.(request, api, connection, target);
+            admissions.set(request, { api, target, connection });
+            sourceStage = 'local-admission';
+            await options.local?.admit?.(request, api, connection, target);
+            confirmedSource?.assertCurrent();
+        }
+        catch (error) {
+            admissions.delete(request);
+            request.recordEarlyFailure = undefined;
+            await confirmedSource?.recordFailure(error, sourceStage);
+            throw error;
+        }
     };
     const resolve = async (request) => {
         if (!admissions.has(request))
@@ -199,6 +221,7 @@ export function connectProvider(get, options = {}) {
         const { api, target, connection } = admitted;
         const stable = () => request.timing.run('connection-confirm', () => waitForLogin(api, agent.loginProvider, connection, get, request.signal));
         await stable();
+        request.localAdmissionCheck?.();
         if (!request.sessionId)
             throw new NeedError('PROJECT_BINDING_REQUIRED', '我需要当前会话和已选择的工作区，请使用原生工作区入口', 'DSH会话与原生工作区');
         if (options.employee) {

package/dist/workspace-source-confirmation.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { WorkspaceSourceOptions } from './workspace-source.ts';
+/** Official same-turn one-shot question; never changes policy or fabricates a tool call. */
+export declare function nativeWorkspaceSourceConfirmation(ctx: Context): WorkspaceSourceOptions['confirm'];

package/dist/workspace-source-confirmation.js

@@ -0,0 +1,12 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+/** Official same-turn one-shot question; never changes policy or fabricates a tool call. */
+export function nativeWorkspaceSourceConfirmation(ctx) {
+    return async (question, request) => {
+        const agent = request.sessionId ? ctx.get('agents')?.get(SessionId(request.sessionId)) : undefined;
+        const approval = ctx.get('approval');
+        const session = request.sessionId ? ctx.get('sessions')?.get(SessionId(request.sessionId)) : undefined;
+        if (!agent || !approval || !session || agent.session !== session)
+            return 'unavailable';
+        return approval.request({ agent, toolName: question.action, reason: question.question, signal: request.signal });
+    };
+}

package/dist/workspace-source.d.ts

@@ -0,0 +1,25 @@
+import type { ConnectApi, RuntimeRequest } from './provider.ts';
+import type { DetailObservation } from './conversation-details.ts';
+export type SourceDecision = 'allowed-once' | 'rejected' | 'cancelled' | 'unavailable';
+export type SourceAdmissionStage = 'source-context' | 'source-confirmation' | 'input-acceptance' | 'login-readiness' | 'local-admission' | 'input-prepare' | 'model-catalog' | 'runtime-resolve';
+export interface WorkspaceSourceAdmission {
+    assertCurrent(): void;
+    recordFailure(error: unknown, stage: SourceAdmissionStage): Promise<void>;
+}
+export interface WorkspaceSourceOptions {
+    workspace(request: RuntimeRequest): Promise<{
+        id: string;
+        path: string;
+    }>;
+    currentUserTurn(request: RuntimeRequest): {
+        turn: number;
+        userMessageId: string;
+    };
+    confirm(question: {
+        question: string;
+        action: string;
+    }, request: RuntimeRequest): Promise<SourceDecision>;
+    record(request: RuntimeRequest, observation: DetailObservation): Promise<void>;
+}
+/** Explicit human source transition only. No source selection is inferred from a folder path. */
+export declare function confirmLegacyWorkspaceSource(get: () => ConnectApi | undefined, api: ConnectApi, request: RuntimeRequest, hooks: WorkspaceSourceOptions): Promise<WorkspaceSourceAdmission | undefined>;

package/dist/workspace-source.js

@@ -0,0 +1,136 @@
+import { isDeepStrictEqual } from 'node:util';
+import { sanitizeDisplayLabel } from "./conversation-details.js";
+import { NeedError } from "./remote.js";
+const fail = (code) => new NeedError(code, '工作区来源尚未确认，本轮未执行；你的原话仍保留。', '当前工作区来源及原始员工输入');
+const codeOf = (value) => value instanceof NeedError ? value.code : 'WORKSPACE_SOURCE_CONFIRMATION_FAILED';
+const diagnosticFailure = (error, diagnostic) => Object.assign(new NeedError('CONVERSATION_DETAILS_FAILED', '工作区来源诊断未能保存，本轮已停止；原话保留。', '原错误代码 ' + codeOf(error) + '；诊断错误代码 ' + codeOf(diagnostic)), { cause: new AggregateError([error, diagnostic], 'WORKSPACE_SOURCE_AND_DIAGNOSTIC_FAILED') });
+/** Explicit human source transition only. No source selection is inferred from a folder path. */
+export async function confirmLegacyWorkspaceSource(get, api, request, hooks) {
+    let initialContext = { workspaceId: null, bindingId: null, source: null, status: null };
+    let diagnosticAttempted = false;
+    try {
+        request.signal?.throwIfAborted();
+        if (api.getContractInfo?.().workspaceLocations !== 1 || typeof api.getWorkspaceLocationState !== 'function')
+            return;
+        if (!api.getWorkspaceLocationState().items.some(item => item.source === 'legacy-host' && item.status === 'legacy-confirmation-required'))
+            return;
+        const workspace = { ...await hooks.workspace(request) };
+        request.signal?.throwIfAborted();
+        const snapshot = api.getWorkspaceLocationState(), rows = snapshot.items.filter(item => item.workspaceId === workspace.id), row = rows[0];
+        if (rows.length !== 1 || row?.status !== 'legacy-confirmation-required' || row.source !== 'legacy-host')
+            return;
+        const frozen = structuredClone(row);
+        initialContext = { workspaceId: frozen.workspaceId, bindingId: frozen.bindingId, source: frozen.source, status: frozen.status };
+        const connection = api.getConnectionState(), turn = { ...hooks.currentUserTurn(request) };
+        const name = sanitizeDisplayLabel(row.workspaceName).replace(/[\u0000-\u001f\u007f\u202a-\u202e\u2066-\u2069]/g, '').trim();
+        if (!name || name.includes('[已脱敏：'))
+            throw fail('WORKSPACE_SOURCE_CONFIRMATION_UNAVAILABLE');
+        const question = '这个工作区以前用的是主机上的文件夹。要改用本机的『' + name + '』文件夹吗？';
+        const record = (code, outcome, current = frozen, stage = 'source-confirmation') => hooks.record(request, { kind: 'need', severity: outcome === 'confirmed' ? 'info' : 'action-required', code, summary: outcome === 'confirmation-required' ? question : outcome === 'confirmed' ? '已确认改用本机文件夹，继续处理本轮原始请求。' : '本轮工作区来源确认未完成；原始请求保留，未执行。', payload: { phase: 'workspace-source-admission', stage, workspaceId: workspace.id, bindingId: current.bindingId, source: current.source, status: current.status, outcome } });
+        // Persistence precedes the question; a failed diagnostic is not retried in this path.
+        diagnosticAttempted = true;
+        await record('WORKSPACE_SOURCE_CONFIRMATION_REQUIRED', 'confirmation-required');
+        let terminalDiagnostic = false;
+        async function stable(requireOldSource) {
+            request.signal?.throwIfAborted();
+            if (get() !== api || api.getContractInfo?.().workspaceLocations !== 1 || typeof api.getWorkspaceLocationState !== 'function')
+                throw fail('EMPLOYEE_CONTEXT_CHANGED');
+            const now = api.getConnectionState(), location = api.getWorkspaceLocationState();
+            if (now.phase !== 'connected' || connection.phase !== 'connected' || now.instanceId !== connection.instanceId || now.epoch !== connection.epoch || location.phase !== 'ready' || location.instanceId !== connection.instanceId || location.epoch !== connection.epoch || snapshot.phase !== 'ready' || snapshot.instanceId !== connection.instanceId || snapshot.epoch !== connection.epoch)
+                throw fail('EMPLOYEE_CONTEXT_CHANGED');
+            const currentWorkspace = await hooks.workspace(request);
+            request.signal?.throwIfAborted();
+            if (!isDeepStrictEqual(currentWorkspace, workspace))
+                throw fail('EMPLOYEE_CONTEXT_CHANGED');
+            if (!isDeepStrictEqual(hooks.currentUserTurn(request), turn))
+                throw fail('LOCAL_USER_TURN_CHANGED');
+            // Re-read after awaits. Only the explicit successful L selection may replace the frozen binding.
+            if (get() !== api)
+                throw fail('EMPLOYEE_CONTEXT_CHANGED');
+            const after = api.getConnectionState(), state = api.getWorkspaceLocationState();
+            if (after.phase !== 'connected' || after.instanceId !== connection.instanceId || after.epoch !== connection.epoch || state.phase !== 'ready' || state.instanceId !== connection.instanceId || state.epoch !== connection.epoch)
+                throw fail('EMPLOYEE_CONTEXT_CHANGED');
+            const current = state.items.filter(item => item.workspaceId === workspace.id);
+            if (current.length !== 1 || current[0].localPath !== workspace.path || requireOldSource && (current[0].bindingId !== frozen.bindingId || current[0].source !== frozen.source || current[0].status !== frozen.status))
+                throw fail('EMPLOYEE_CONTEXT_CHANGED');
+            return current[0];
+        }
+        try {
+            await stable(true);
+            if (typeof api.selectWorkspaceLocation !== 'function')
+                throw fail('DEPENDENCY_REQUIRED');
+            const decision = await hooks.confirm({ question, action: '改用本机文件夹' }, request);
+            request.signal?.throwIfAborted();
+            if (decision !== 'allowed-once') {
+                const code = decision === 'rejected' ? 'WORKSPACE_SOURCE_CONFIRMATION_DECLINED' : decision === 'cancelled' ? 'ABORTED' : 'WORKSPACE_SOURCE_CONFIRMATION_UNAVAILABLE';
+                terminalDiagnostic = true;
+                await record(code, decision === 'rejected' ? 'declined' : decision === 'cancelled' ? 'cancelled' : 'failed');
+                throw fail(code);
+            }
+            await stable(true);
+            // The await continuation itself is a boundary: already-observed cancellation,
+            // replacement input or source withdrawal must not start the L mutation.
+            request.signal?.throwIfAborted();
+            if (get() !== api || typeof api.getWorkspaceLocationState !== 'function')
+                throw fail('EMPLOYEE_CONTEXT_CHANGED');
+            const atChoice = api.getConnectionState(), choiceState = api.getWorkspaceLocationState(), choiceRows = choiceState.items.filter(item => item.workspaceId === workspace.id);
+            if (atChoice.phase !== 'connected' || atChoice.instanceId !== connection.instanceId || atChoice.epoch !== connection.epoch || choiceState.phase !== 'ready' || choiceState.instanceId !== connection.instanceId || choiceState.epoch !== connection.epoch || choiceRows.length !== 1 || choiceRows[0].bindingId !== frozen.bindingId || choiceRows[0].source !== frozen.source || choiceRows[0].status !== frozen.status || choiceRows[0].localPath !== workspace.path)
+                throw fail('EMPLOYEE_CONTEXT_CHANGED');
+            if (!isDeepStrictEqual(hooks.currentUserTurn(request), turn))
+                throw fail('LOCAL_USER_TURN_CHANGED');
+            const selected = await api.selectWorkspaceLocation({ instanceId: connection.instanceId, epoch: connection.epoch, workspaceId: workspace.id, expectedBindingId: frozen.bindingId, source: 'local' });
+            request.signal?.throwIfAborted();
+            if (!selected.ok)
+                throw new NeedError(selected.error.code, selected.error.message, selected.error.requires);
+            const current = await stable(false), value = selected.value, returned = value.items.filter(item => item.workspaceId === workspace.id);
+            if (value.phase !== 'ready' || value.instanceId !== connection.instanceId || value.epoch !== connection.epoch || returned.length !== 1 || returned[0].source !== 'local' || returned[0].status !== 'selected' || !returned[0].bindingId || returned[0].bindingId === frozen.bindingId || returned[0].localPath !== workspace.path || current.source !== 'local' || current.status !== 'selected' || current.bindingId !== returned[0].bindingId)
+                throw fail('WORKSPACE_SOURCE_SELECTION_UNCONFIRMED');
+            const selectedBinding = returned[0].bindingId;
+            const assertSelected = () => {
+                request.signal?.throwIfAborted();
+                if (get() !== api || typeof api.getWorkspaceLocationState !== 'function')
+                    throw fail('EMPLOYEE_CONTEXT_CHANGED');
+                const c = api.getConnectionState(), s = api.getWorkspaceLocationState(), items = s.items.filter(item => item.workspaceId === workspace.id);
+                if (c.phase !== 'connected' || c.instanceId !== connection.instanceId || c.epoch !== connection.epoch || s.phase !== 'ready' || s.instanceId !== connection.instanceId || s.epoch !== connection.epoch || items.length !== 1 || items[0].source !== 'local' || items[0].status !== 'selected' || items[0].bindingId !== selectedBinding || items[0].localPath !== workspace.path)
+                    throw fail('EMPLOYEE_CONTEXT_CHANGED');
+                if (!isDeepStrictEqual(hooks.currentUserTurn(request), turn))
+                    throw fail('LOCAL_USER_TURN_CHANGED');
+            };
+            terminalDiagnostic = true;
+            await record('WORKSPACE_SOURCE_CONFIRMED', 'confirmed', current);
+            terminalDiagnostic = false;
+            await stable(false);
+            assertSelected();
+            return { assertCurrent: assertSelected, async recordFailure(error, stage) {
+                    try {
+                        await record(request.signal?.aborted ? 'ABORTED' : codeOf(error), request.signal?.aborted ? 'cancelled' : 'failed', current, stage);
+                    }
+                    catch (diagnostic) {
+                        throw diagnosticFailure(error, diagnostic);
+                    }
+                } };
+        }
+        catch (error) {
+            if (!terminalDiagnostic) {
+                try {
+                    await record(request.signal?.aborted ? 'ABORTED' : codeOf(error), request.signal?.aborted ? 'cancelled' : 'failed');
+                }
+                catch (diagnostic) {
+                    throw diagnosticFailure(error, diagnostic);
+                }
+            }
+            throw error;
+        }
+    }
+    catch (error) {
+        if (!diagnosticAttempted) {
+            try {
+                await hooks.record(request, { kind: 'need', severity: 'action-required', code: request.signal?.aborted ? 'ABORTED' : codeOf(error), summary: '无法核对本轮工作区来源，已停止；原话保留。', payload: { phase: 'workspace-source-admission', stage: 'source-context', ...initialContext, outcome: request.signal?.aborted ? 'cancelled' : 'failed' } });
+            }
+            catch (diagnostic) {
+                throw diagnosticFailure(error, diagnostic);
+            }
+        }
+        throw error;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.10",
+  "version": "0.8.11",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,8 +17,7 @@
     "dist",
     "locale",
     "cordis.patch.yml",
-    "helpers",
-    "CANDIDATE-NOT-FOR-INSTALL.json"
+    "helpers"
   ],
   "scripts": {
     "test": "npm run build && node --test --test-concurrency=1 lib/test/*.test.js",
@@ -48,6 +47,7 @@
     "@deepseek-ai/cordis-plugin-loader": "1.0.5",
     "@deepseek-ai/cordis-plugin-timer": "1.1.6",
     "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-agent-loop": "0.2.0-rc.2",
     "@deepseek-ai/dsh-api-gateway": "0.2.0-rc.2",
     "@deepseek-ai/dsh-attachment": "0.2.0-rc.2",
     "@deepseek-ai/dsh-client-connection": "0.2.0-rc.2",