@ai-workbench/remote-agent 0.8.19 → 0.8.23

package/dist/claude-local.js

@@ -6,18 +6,18 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { CLAUDE_EMPLOYEE_SCOPE_NOTICE as NOTICE } from "./employee-presentation.js";
+import { EMPLOYEE_EXECUTION_NOTICE as NOTICE } from "./employee-presentation.js";
 import { CloseDiagnostics, closeCode } from "./close-diagnostics.js";
 import { isDeepStrictEqual } from 'node:util';
 import { openEmployeeLease } from "./employee-endpoint.js";
 import { openEmployeeMcp } from "./employee-mcp.js";
 import { createEmployeeShell } from "./employee-shell.js";
-import { sameTarget, unwrap } from "./provider.js";
+import { unwrap } from "./provider.js";
 import { sshIo } from "./broker.js";
 import { NeedError, shellQuote } from "./remote.js";
 import { awaitL } from "./provider.js";
 const failure = (code) => new NeedError(code, '当前本机执行上下文无法确认，本轮已停止；没有改在主机执行。', 'L当前本地绑定、N员工端点与S同代桥');
-/** Local source only. Host and legacy-host remain with the original provider. */
+/** Local source only. Host source remains with the host provider. */
 export function createClaudeLocalProvider(options) {
     const entries = new Map();
     const admitted = new WeakMap();
@@ -38,22 +38,17 @@ export function createClaudeLocalProvider(options) {
             const item = matches[0];
             if (item.source !== 'local')
                 return;
-            if (item.status !== 'selected' || !item.bindingId || api.getContractInfo?.().localUserTurnAcceptance !== 1 || typeof api.acceptLocalWorkspaceUserTurn !== 'function' || typeof local.getLocalWorkspaceContext !== 'function')
+            if (item.status !== 'selected' || !item.bindingId || api.getContractInfo?.().localWorkspaceContext !== 1 || typeof local.getLocalWorkspaceContext !== 'function')
                 throw failure('EMPLOYEE_CONTEXT_UNAVAILABLE');
             const context = unwrap(await awaitL(() => local.getLocalWorkspaceContext({ instanceId: connection.instanceId, epoch: connection.epoch, workspaceId: workspace.workspaceId, expectedBindingId: item.bindingId }), request.signal));
             if (context.instanceId !== connection.instanceId || context.epoch !== connection.epoch || context.workspaceId !== workspace.workspaceId || context.bindingId !== item.bindingId || context.source !== 'local' || !isDeepStrictEqual(context.directory, workspace.directory))
                 throw failure('EMPLOYEE_CONTEXT_CHANGED');
             const proof = await options.readUserTurn(request);
             proof.assertCurrent();
-            const accepted = unwrap(await awaitL(() => api.acceptLocalWorkspaceUserTurn({ instanceId: connection.instanceId, epoch: connection.epoch, sessionId: request.sessionId, provider: 'claude', purpose: 'user-turn', workspaceId: workspace.workspaceId, expectedBindingId: item.bindingId, expectedDirectory: { device: workspace.directory.device, inode: workspace.directory.inode }, expectedUserTurn: { ...proof.expectedUserTurn } }), request.signal));
-            proof.assertCurrent();
             request.signal?.throwIfAborted();
             const now = api.getConnectionState();
             if (options.getConnect() !== api || now.phase !== 'connected' || now.instanceId !== connection.instanceId || now.epoch !== connection.epoch)
                 throw failure('CONNECTION_LOST');
-            if (!accepted || accepted.version !== 1 || typeof accepted.acceptanceId !== 'string' || !accepted.acceptanceId.trim() || accepted.instanceId !== connection.instanceId || accepted.epoch !== connection.epoch || accepted.sessionId !== request.sessionId || accepted.provider !== 'claude' || accepted.workspaceId !== workspace.workspaceId || accepted.bindingId !== item.bindingId || accepted.source !== 'local' || !isDeepStrictEqual(accepted.directory, workspace.directory) || accepted.userTurn?.turn !== proof.expectedUserTurn.turn || accepted.userTurn.userMessageId !== proof.expectedUserTurn.userMessageId || accepted.userTurn.startSequence !== proof.startSequence || accepted.userTurn.userMessageSequence !== proof.userMessageSequence)
-                throw failure('REMOTE_DETAIL_RESPONSE_INVALID');
-            Object.defineProperty(request, 'localAcceptanceId', { value: accepted.acceptanceId, enumerable: true });
             request.detailChannel = await options.details(request, api, connection, target);
             admitted.set(request, { api, workspace: structuredClone(workspace), bindingId: item.bindingId, connection: structuredClone(connection) });
         }
@@ -94,36 +89,17 @@ export function createClaudeLocalProvider(options) {
             throw failure('SETTINGS_REQUIRED');
         const scope = { target, workspace, bindingId: item.bindingId, instanceId: connection.instanceId, epoch: connection.epoch, maximum, control, grace };
         let entry = entries.get(request.sessionId);
-        if (entry && (entry.closing || !isDeepStrictEqual(entry.scope, scope) || entry.lease.signal.aborted))
-            throw failure('EMPLOYEE_CONTEXT_CHANGED');
+        if (entry) {
+            entries.delete(request.sessionId);
+            void entry.runtime.dispose?.({ layer: 'runtime', initiator: 'claude.next-round', reason: 'NEXT_ROUND', action: 'dispose' }).catch(() => console.warn('CLAUDE_CLEANUP_FAILED'));
+            entry = undefined;
+        }
         const details = request.detailChannel;
-        const closeDiagnostics = entry?.runtime.closeDiagnostics ?? new CloseDiagnostics(event => details.record(event));
+        const closeDiagnostics = new CloseDiagnostics(event => details.record(event));
         closeDiagnostics.bind(event => details.record(event));
         request.closeDiagnostics = closeDiagnostics;
-        request.timing?.bind(observation => details.record(observation));
-        const trusted = async (ignoreCancellation = false) => {
-            if (!ignoreCancellation)
-                request.signal?.throwIfAborted();
-            if (options.getConnect() !== api)
-                throw failure('CONNECTION_LOST');
-            const now = api.getConnectionState();
-            if (now.phase !== 'connected' || now.instanceId !== connection.instanceId || now.epoch !== connection.epoch || !sameTarget(unwrap(await api.getSshTarget()), target))
-                throw failure('CONNECTION_LOST');
-        };
-        const openRequest = (row, cold = false) => ({ ...request, detailChannel: details, bindingId: item.bindingId, workspaceId: workspace.workspaceId, bindingRevision: state.revision, ...cold ? { recoveryCheckpointId: undefined } : {}, validateContext: async (cleanup = false) => { await trusted(cleanup); if (!cleanup)
-                await row.lease.validate(request.signal); } });
-        if (entry) {
-            entry.details = details;
-            entry.request = request;
-            await entry.lease.validate(request.signal);
-            const base = await options.open(target, { name: workspace.workspaceId, path: target.session.root }, openRequest(entry));
-            if (base.acpTransport !== entry.runtime.acpTransport)
-                throw failure('SESSION_TRANSPORT_MISMATCH');
-            entry.runtime.details = details;
-            entry.runtime.restartNotice = base.restartNotice;
-            entry.runtime.restartInputIds = base.restartInputIds;
-            return entry.runtime;
-        }
+        details.record({ kind: 'session', severity: 'info', code: 'CLAUDE_EMPLOYEE_VALIDATION_POLICY', summary: '本机执行不可改到主机：每轮开始从L读取一次本机工作区上下文，核验所选物理目录、N端点与主机目标，并新建本轮工具通道。之后不逐消息、审批或工具重复核验；既有连接、位置、网络事件和通道关闭只终止本轮，下一轮重新核验。' });
+        const openRequest = () => ({ ...request, detailChannel: details, bindingId: item.bindingId, workspaceId: workspace.workspaceId, bindingRevision: state.revision });
         let io;
         const transport = async () => { if (!io) {
             const name = '@ai-workbench/connect';
@@ -133,61 +109,44 @@ export function createClaudeLocalProvider(options) {
             io = sshIo(target, l.sshArgs, control);
         } return io; };
         let lease, mcp, base;
-        let privateFailure, privateTail = Promise.resolve();
+        let privateTail = Promise.resolve();
         try {
-            const unscoped = (observation) => { if (privateFailure)
-                throw privateFailure; privateTail = privateTail.then(() => options.recordUnscoped(request, observation)).catch(error => { privateFailure ??= error; closeDiagnostics.record({ layer: 'runtime', initiator: 'claude.private-diagnostic-failure', reason: 'CONVERSATION_DETAILS_FAILED', action: 'failure' }); void lease?.close({ layer: 'endpoint', initiator: 'claude.private-diagnostic-failure', reason: 'CONVERSATION_DETAILS_FAILED', action: 'close' }).catch(failure => { privateFailure ??= failure; }); }); };
+            const unscoped = (observation) => { privateTail = privateTail.then(() => options.recordUnscoped(request, observation)).catch(() => { console.warn('CLAUDE_DIAGNOSTIC_DROPPED'); }); };
+            const network = options.getNetwork();
             lease = await (options.ports?.lease ?? openEmployeeLease)({ closeDiagnostics, getConnect: () => options.getConnect(), getNetwork: options.getNetwork, readWorkspace: () => options.readWorkspace(request.sessionId), host: target, sessionId: request.sessionId, control: async (_target, command, signal) => (await transport()).run(command, signal), detail: unscoped }, request.signal);
-            const shell = (options.ports?.shell ?? createEmployeeShell)({ closeDiagnostics, target: lease.target, maxBytes: maximum, killGraceMs: grace, attach: async (spec) => (await transport()).attach([spec.command, ...spec.args].map(shellQuote).join(' ')) });
+            const shell = (options.ports?.shell ?? createEmployeeShell)({ closeDiagnostics, target: lease.target, sshArgs: lease.sshArgs, maxBytes: maximum, killGraceMs: grace, attach: async (spec) => (await transport()).attach([spec.command, ...spec.args].map(shellQuote).join(' ')) });
             mcp = await (options.ports?.mcp ?? openEmployeeMcp)({ closeDiagnostics, lease, maxBytes: maximum, killGraceMs: grace, runShell: shell, activeSignal: () => entry?.active?.signal, captureDetail: () => { const sink = entry?.active?.details; if (!sink)
                     throw failure('EMPLOYEE_NO_ACTIVE_TURN'); return observation => sink.record(observation); }, detail: unscoped });
             entry = { runtime: undefined, scope, lease, details, request };
             const row = entry;
-            base = await options.open(target, { name: workspace.workspaceId, path: target.session.root }, openRequest(row, true));
+            base = await options.open(target, { name: workspace.workspaceId, path: target.session.root }, openRequest());
+            // The old per-step identity check runs once when this round finishes opening.
+            if (options.getConnect() !== api || options.getNetwork() !== network)
+                throw failure('EMPLOYEE_CONTEXT_CHANGED');
             const underlying = base, endpoint = mcp;
             const close = (detach, cause = { layer: 'runtime', initiator: detach ? 'claude.runtime-detach' : 'claude.runtime-dispose', reason: detach ? 'RUNTIME_DETACH' : 'RUNTIME_DISPOSE', action: detach ? 'detach' : 'dispose' }) => {
+                // Unlink synchronously. A slow/failed cleanup must not hold the next round.
+                if (entries.get(request.sessionId) === row)
+                    entries.delete(request.sessionId);
                 closeDiagnostics.record(cause);
                 return row.closing ??= Promise.resolve().then(async () => {
                     row.active = undefined;
-                    const errors = [];
-                    try {
-                        await endpoint.close({ layer: 'relay', initiator: 'claude.cleanup-mcp', reason: 'RUNTIME_CLEANUP', action: 'close' });
-                    }
-                    catch (error) {
-                        errors.push(error);
-                    }
-                    await privateTail;
-                    if (privateFailure)
-                        errors.push(privateFailure);
-                    try {
-                        await (detach ? underlying.detach?.(cause) : underlying.dispose?.(cause));
-                    }
-                    catch (error) {
-                        errors.push(error);
-                    }
-                    try {
-                        await row.details.flush();
+                    const clean = async (action) => { try {
+                        await action();
                     }
-                    catch (error) {
-                        errors.push(error);
-                    }
-                    try {
-                        closeDiagnostics.assertRecorded();
-                    }
-                    catch (error) {
-                        errors.push(error);
-                    }
-                    if (errors.length)
-                        throw new AggregateError(errors, 'EMPLOYEE_CLEANUP_UNCONFIRMED');
-                    if (entries.get(request.sessionId) === row)
-                        entries.delete(request.sessionId);
+                    catch {
+                        console.warn('CLAUDE_CLEANUP_FAILED');
+                    } };
+                    await clean(() => endpoint.close({ layer: 'relay', initiator: 'claude.cleanup-mcp', reason: 'RUNTIME_CLEANUP', action: 'close' }));
+                    await clean(() => row.lease.close({ layer: 'endpoint', initiator: 'claude.cleanup-lease', reason: 'RUNTIME_CLEANUP', action: 'close' }));
+                    await clean(() => detach ? underlying.detach?.(cause) : underlying.dispose?.(cause));
                 });
             };
             const executionSignal = AbortSignal.any([lease.signal, ...mcp.signal ? [mcp.signal] : []]);
-            row.runtime = { ...underlying, closeDiagnostics, cwd: workspace.directory.path, details, connection: { ...connection }, binding: { bindingId: item.bindingId, workspaceId: workspace.workspaceId, revision: state.revision }, execution: { hostCwd: target.session.root, routing: mcp.routing, notice: NOTICE, signal: executionSignal, scope: { source: 'local', cwd: workspace.directory.path, hostCwd: target.session.root, uid: lease.target.endpoint.remoteUid, claudeAcpVersion: '0.94.0', sdkVersion: '0.3.303', unsupported: ['subagents', 'internal-direct-calls', 'binary-read', 'background-shell'] }, validate: async (signal) => { executionSignal.throwIfAborted(); await row.lease.validate(signal); }, beginTurn: async (signal) => { executionSignal.throwIfAborted(); if (row.closing || row.active)
-                        throw failure('TURN_BUSY'); await row.lease.validate(signal); executionSignal.throwIfAborted(); row.active = { signal, details: row.details }; }, endTurn: () => { row.active = undefined; } }, dispose: cause => close(false, cause), detach: cause => close(true, cause) };
+            row.runtime = { ...underlying, closeDiagnostics, cwd: workspace.directory.path, details, connection: { ...connection }, binding: { bindingId: item.bindingId, workspaceId: workspace.workspaceId, revision: state.revision }, execution: { hostCwd: target.session.root, routing: mcp.routing, notice: NOTICE, signal: executionSignal, scope: { source: 'local', cwd: workspace.directory.path, hostCwd: target.session.root, uid: lease.target.endpoint.remoteUid, claudeAcpVersion: '0.94.0', sdkVersion: '0.3.303', unsupported: ['subagents', 'internal-direct-calls', 'binary-read', 'background-shell'] }, validate: async (signal) => { signal?.throwIfAborted(); executionSignal.throwIfAborted(); }, beginTurn: async (signal) => { signal?.throwIfAborted(); executionSignal.throwIfAborted(); if (row.closing || row.active)
+                        throw failure('TURN_BUSY'); row.active = { signal, details: row.details }; }, endTurn: () => { row.active = undefined; } }, dispose: cause => close(false, cause), detach: cause => close(true, cause) };
             entries.set(request.sessionId, row);
-            lease.signal.addEventListener('abort', () => { void close(false, { layer: 'endpoint', initiator: 'claude.lease-abort', reason: closeCode(lease?.signal.reason, 'EMPLOYEE_CONTEXT_CHANGED'), action: 'abort' }).catch(() => { }); }, { once: true });
+            lease.signal.addEventListener('abort', () => { void close(false, { layer: 'endpoint', initiator: 'claude.lease-abort', reason: closeCode(lease?.signal.reason, 'EMPLOYEE_CONTEXT_CHANGED'), action: 'abort' }).catch(() => console.warn('CLAUDE_CLEANUP_FAILED')); }, { once: true });
             if (lease.signal.aborted) {
                 await close(false, { layer: 'endpoint', initiator: 'claude.open-aborted', reason: closeCode(lease.signal.reason, 'EMPLOYEE_CONTEXT_CHANGED'), action: 'abort' });
                 throw failure('EMPLOYEE_CONTEXT_CHANGED');
@@ -197,37 +156,14 @@ export function createClaudeLocalProvider(options) {
         catch (error) {
             closeDiagnostics.record({ layer: 'runtime', initiator: 'claude.open-failure', reason: closeCode(error, 'EMPLOYEE_OPEN_FAILED'), action: 'failure' });
             const cause = { layer: 'runtime', initiator: 'claude.open-cleanup', reason: 'EMPLOYEE_OPEN_FAILED', action: 'close' };
-            const cleanup = [];
-            try {
-                await mcp?.close(cause);
-                await lease?.close(cause);
-            }
-            catch (e) {
-                cleanup.push(e);
-            }
-            try {
-                await base?.dispose?.(cause);
-            }
-            catch (e) {
-                cleanup.push(e);
-            }
-            await privateTail;
-            if (privateFailure)
-                cleanup.push(privateFailure);
-            try {
-                await details.flush();
-            }
-            catch (e) {
-                cleanup.push(e);
-            }
-            try {
-                closeDiagnostics.assertRecorded();
-            }
-            catch (e) {
-                cleanup.push(e);
+            for (const clean of [() => mcp?.close(cause), () => lease?.close(cause), () => base?.dispose?.(cause)]) {
+                try {
+                    await clean();
+                }
+                catch {
+                    console.warn('CLAUDE_CLEANUP_FAILED');
+                }
             }
-            if (cleanup.length)
-                throw new AggregateError([error, ...cleanup], 'EMPLOYEE_OPEN_CLEANUP_UNCONFIRMED');
             throw error;
         }
     };

package/dist/client.js

@@ -1,145 +1,53 @@
-/* Official locale and provider-registration updates only; no custom UI or refresh. */
 window.__ModuleLoader__.load({id:'@ai-workbench/remote-agent',factory(require){
-  const messages={"en":{"administratorNote":"Settings → Built-in plugins → 远程助手参数. Eight named settings with defaults, scope and effects.","providerName":"Codex (Remote Host)"},"zh":{"administratorNote":"管理员：设置 → 内置插件 → 远程助手参数。八项设置含默认值、范围、生效和后果说明。","providerName":"Codex（远程主机）"}};
-  const settingsFields=[{"key":"mode","name":"Codex 运行方式","kind":"select","options":[{"value":"session","name":"会话模式"},{"value":"one-shot","name":"单次模式（当前版本不可运行）"}],"range":"session / one-shot","scope":"仅 Codex；Claude 始终使用会话模式。","when":"当前轮不变；更改后原会话下一轮会拒绝继续，需新建会话。","consequence":"会话模式保留连续对话；当前单次模式会明确拒绝运行，不会发给模型。不提供关闭会话身份核对的选项。","defaultValue":"session"},{"key":"acpMaxMessageBytes","name":"完整消息与工具输出容量（字节）","kind":"number","min":1,"max":9007199254740991,"range":"1～9007199254740991 的整数；0不能关闭上限","scope":"两位远程助手的完整会话消息；也用于模型目录、本机 MCP、员工执行 RPC 和工具输出容量。","when":"当轮快照不变；下一次独立目录查询读取新值；已有会话需新建后使用。","consequence":"调大可接收更大消息、占用更多内存；调小更早拒绝超限。超限明确停止，不截断、不自动重试；不能用0取消完整消息保护。","defaultValue":4194304},{"key":"brokerMaxFrameBytes","name":"主机会话回传单段容量（字节）","kind":"number","min":1,"max":9007199254740991,"range":"1～9007199254740991 的整数；0不能关闭上限","scope":"本插件接收主机会话单段输出的容量；不会替主机修改它自己的输出策略。","when":"当轮快照不变；更改后已有会话需新建。","consequence":"调大允许更大回传段、占用更多内存；调小可能拒绝主机合法输出。超限停止，不截断；不能关闭协议帧核验。","defaultValue":2097152},{"key":"brokerControlMaxBytes","name":"主机会话管理回复容量（字节）","kind":"number","min":1,"max":9007199254740991,"range":"1～9007199254740991 的整数；0不能关闭上限","scope":"主机会话管理命令的标准输出、标准错误各自容量；也用于本机执行桥的管理回复。","when":"当轮快照不变；更改后已有会话需新建。","consequence":"调大允许更长管理回复、占用更多内存；调小可能无法核实状态。超限明确停止，不能把不完整回复当成功；0不表示无限。","defaultValue":1048576},{"key":"oneShotSandbox","name":"Codex 单次任务权限模式","kind":"select","options":[{"value":"read-only","name":"只读"},{"value":"workspace-write","name":"工作区内可写"},{"value":"danger-full-access","name":"完全访问（高权限）"}],"range":"read-only / workspace-write / danger-full-access","scope":"仅 Codex 单次通道；不改变会话模式、本机工具或员工账号的系统权限。","when":"仅单次任务启动时适用；当前版本单次任务被拒绝，因此目前不生效。","consequence":"只读不允许单次任务写入；工作区内可写允许该目录写入；完全访问放宽单次沙箱。此项不是员工目录的权限开关，也不会解锁当前不可用的单次模式。","defaultValue":"workspace-write"},{"key":"oneShotApproval","name":"Codex 单次任务审批方式","kind":"fixed","readOnly":true,"range":"固定 never；不能切换","scope":"仅 Codex 单次通道；不改变会话模式的员工审批。","when":"仅单次启动参数；当前单次模式不可运行。","consequence":"单次通道没有中途交互审批能力，所以必须固定为无中途交互；不表示自动批准或允许所有操作。不能切换为自动回答旧审批。","defaultValue":"never"},{"key":"employeeShellKillGraceMs","name":"本机命令外层连接清理宽限（毫秒）","kind":"number","min":0,"max":2147483647,"range":"0～2147483647 的整数","scope":"仅 Claude 本机 Bash 取消后，本插件自己的外层 SSH 进程清理；不控制员工命令或 Codex 执行器。","when":"当轮快照不变；更改后已有会话需新建。","consequence":"大于0时先请求外层连接退出，再等待所设毫秒后强制清理；0表示不留宽限、立即强制清理外层连接，不是关闭取消。没有员工端退出确认时结果仍未知，不能据此自动重放或声称命令已停止。","defaultValue":1000},{"key":"employeeHttpMcpPolicy","name":"本机 HTTP MCP 策略","kind":"select","options":[{"value":"reject","name":"拒绝（默认）"},{"value":"ignore","name":"忽略后继续"}],"range":"reject / ignore","scope":"仅 Codex 员工本机执行器实际会采用的 HTTP MCP；stdio 始终依原生过滤忽略并说明名称。","when":"新连接建立时读取并冻结；修改不停止当轮或已有会话，需新建会话使用新值。","consequence":"默认 reject 会以明确代码拒绝这些 HTTP 条目；ignore 仅剔除会话投影后继续，不改员工配置、不启动 MCP、不新增网络路径。两种模式都显示实际忽略的安全名称。","defaultValue":"reject"}];
-  /* Public settings.plugins.tab + shared ConfigForms. No private client services. */
+ const messages={"en":{"administratorNote":"Settings → Built-in plugins → 远程助手参数. Eight named settings with defaults, scope and effects.","providerName":"Codex (Remote Host)"},"zh":{"administratorNote":"管理员：设置 → 内置插件 → 远程助手参数。八项设置含默认值、范围、生效和后果说明。","providerName":"Codex（远程主机）"}};
+ const settingsFields=[{"key":"acpMaxMessageBytes","name":"完整消息与工具输出容量（字节）","kind":"number","min":1,"max":9007199254740991,"range":"1～9007199254740991 的整数；0不能关闭上限","scope":"两位远程助手的完整会话消息；也用于模型目录、本机 MCP、员工执行 RPC 和工具输出容量。","when":"当轮快照不变；下一次独立目录查询读取新值；已有会话需新建后使用。","consequence":"调大可接收更大消息、占用更多内存；调小更早拒绝超限。超限明确停止，不截断、不自动重试；不能用0取消完整消息保护。","defaultValue":4194304},{"key":"brokerMaxFrameBytes","name":"主机会话回传单段容量（字节）","kind":"number","min":1,"max":9007199254740991,"range":"1～9007199254740991 的整数；0不能关闭上限","scope":"本插件接收主机会话单段输出的容量；不会替主机修改它自己的输出策略。","when":"当轮快照不变；更改后已有会话需新建。","consequence":"调大允许更大回传段、占用更多内存；调小可能拒绝主机合法输出。超限停止，不截断；不能关闭协议帧核验。","defaultValue":2097152},{"key":"brokerControlMaxBytes","name":"主机会话管理回复容量（字节）","kind":"number","min":1,"max":9007199254740991,"range":"1～9007199254740991 的整数；0不能关闭上限","scope":"主机会话管理命令的标准输出、标准错误各自容量；也用于本机执行桥的管理回复。","when":"当轮快照不变；更改后已有会话需新建。","consequence":"调大允许更长管理回复、占用更多内存；调小可能无法核实状态。超限明确停止，不能把不完整回复当成功；0不表示无限。","defaultValue":1048576},{"key":"employeeShellKillGraceMs","name":"本机命令外层连接清理宽限（毫秒）","kind":"number","min":0,"max":2147483647,"range":"0～2147483647 的整数","scope":"仅 Claude 本机 Bash 取消后，本插件自己的外层 SSH 进程清理；不控制员工命令或 Codex 执行器。","when":"当轮快照不变；更改后已有会话需新建。","consequence":"大于0时先请求外层连接退出，再等待所设毫秒后强制清理；0表示不留宽限、立即强制清理外层连接，不是关闭取消。没有员工端退出确认时结果仍未知，不能据此自动重放或声称命令已停止。","defaultValue":1000}];
+ /* Public settings.plugins.tab + shared ConfigForms. No private client services. */
 function mountRuntimeSettings(ctx,React,fields){
  const h=React.createElement;
  const invariants=[
-  ['员工、主机和文件夹核对','始终开启，不可关闭','每次派发前核对当前连接、员工与工作区，避免操作到别人的文件或旧位置；核对失败即停止。'],
-  ['本轮输入与技术详情归属','始终开启，不可关闭','真实输入须先接纳，技术详情须确认保存；迟到结果仍属于原轮次，不能借下一轮的记录继续执行。'],
-  ['模型选择确认','始终开启，不可关闭','主机须完整确认所选模型和推理等级，不能静默换模型继续。'],
-  ['完整消息与精确整数','始终开启，不可关闭','容量不能用0关闭，超限明确停止、不截断；整数必须能精确表示，防止消息缺失或容量计算失真。'],
-  ['未知结果与旧审批保护','始终开启，不可关闭','断线或取消不等于员工命令已结束；不自动重放未知操作，不代答旧审批，清理未确认时不擅自重开。'],
-  ['本机执行位置','始终开启，不可关闭','已提供的本机工具通道不悄悄回退主机；文件夹不是权限隔离根，也不新增目录白名单。Claude子代理及内部直接调用尚未完整覆盖，可能仍在主机，每轮另有范围提示。']
+  ['执行位置','始终开启，不可关闭','每轮开始核对文件夹来源和位置。本机执行组件报告就绪后才开通道；本机通道失败就结束本轮，绝不改在主机执行。'],
+  ['凭据保护','始终开启，不可关闭','订阅凭据只在主机，不放进命令参数、日志或技术详情。'],
+  ['权限跟随当前档位','始终开启，不可关闭','完全权限不问（Claude bypassPermissions / Codex agent-full-access）；工作区内修改先问（Claude default / Codex workspace-write）；仅可查看只读（Claude plan / Codex read-only）。'],
+  ['会话来源','始终开启，不可关闭','同一会话使用一个工作区来源，换来源请新建会话。断线恢复后可在原会话继续；旧资源清理和技术详情记录不会阻止下一轮。']
+
  ];
  const unavailable={status:'unavailable',mode:'memory',writable:false};
  const unavailableForm={subscribe:()=>()=>{},getSnapshot:()=>unavailable};
- const formIdentities=new WeakMap();let nextFormIdentity=0;
- function RuntimePanel({showParameters=true}){
-  const [snapshot,setSnapshot]=React.useState(null),[failure,setFailure]=React.useState(''),[busy,setBusy]=React.useState(false);
-  const active=React.useRef(null),serial=React.useRef(0),alive=React.useRef(false);
-  const load=async()=>{
-   active.current?.abort();const controller=new AbortController(),mine=++serial.current;active.current=controller;
-   if(ctx.connection.state.getSnapshot()!=='connected'){setSnapshot(null);setFailure('尚未连上本机服务，暂时无法读取目录诊断。');setBusy(false);return;}
-   setBusy(true);setFailure('');
-   try{
-    const result=await ctx.connection.rpc.call('/api','awRemoteModelDiagnostics/read',{args:{request:null}},controller.signal);
-    if(!alive.current||controller.signal.aborted||mine!==serial.current)return;
-    const value=result?.value;
-    if(result?.ok!==true||!value||!Array.isArray(value.providers)||!Array.isArray(value.records)||!value.providers.every(provider=>provider&&['claude-code-workbench','codex-remote'].includes(provider.provider)&&typeof provider.name==='string'&&Array.isArray(provider.messages)&&provider.messages.every(message=>typeof message==='string'))||!value.records.every(record=>record&&['claude','codex'].includes(record.provider)))throw Error('INVALID_DIAGNOSTICS');
-    setSnapshot(value);
-   }catch{if(alive.current&&!controller.signal.aborted&&mine===serial.current){setFailure('目录诊断暂时无法读取。请检查本机服务连接，再点“刷新本机诊断”；这不会重新查询主机或发送原话。');}}
-   finally{if(alive.current&&mine===serial.current)setBusy(false);}
-  };
-  React.useEffect(()=>{alive.current=true;void load();const off=ctx.connection.state.subscribe(()=>{void load();});return()=>{alive.current=false;serial.current++;active.current?.abort();off();};},[]);
-  const ns=snapshot?.settingsNamespace,form=typeof ns==='string'&&ns?ctx.configForms.get(ns):unavailableForm;
-  if(!formIdentities.has(form))formIdentities.set(form,++nextFormIdentity);
-  return h('div',null,
-   h('section',{'aria-label':'模型目录诊断'},h('h2',null,'模型目录诊断'),
-    h('p',null,'这里显示本客户端最近的目录查询记录。读取本页只查看本机记录，不会重试主机查询、登录或发送待发送的原话。每次查询都保留本机诊断历史，不自动过期；记录容量沿用下方会话消息容量，超限会明确停止并标明记录不完整。'),
-    h('button',{type:'button',disabled:busy,onClick:()=>{void load();}},busy?'正在读取本机诊断…':'刷新本机诊断'),
-    failure&&h('p',{role:'alert'},failure),snapshot?.storageError&&h('p',{role:'alert'},snapshot.storageError),
-    ...(snapshot?.providers??[]).map(provider=>{
-     const record=snapshot.records.find(item=>item.provider===(provider.provider==='claude-code-workbench'?'claude':'codex'));
-     return h('article',{key:provider.provider},h('h3',null,provider.name),
-      h('p',null,provider.messages.length?'本提供方有目录或模型设置诊断，请展开技术详情。':record?'当前没有新增的模型设置诊断；以下为最近一次查询记录，不代表此刻连接可用。':'尚无本客户端的目录查询记录；旧版本未保存的错误无法还原。'),
-      record&&h('p',null,'最近查询：'+record.startedAt+'；'+(record.stage==='started'?'尚未确认结束':record.failureCode||record.hostErrorCode?'未完成':'已返回主机响应')+'。'),
-      (record||provider.messages.length>0)&&h('details',null,h('summary',null,'技术详情（'+provider.name+'）'),
-       ...provider.messages.map((message,index)=>h('pre',{key:index,style:{whiteSpace:'pre-wrap',overflowWrap:'anywhere'}},message)),
-       record&&h('pre',{style:{whiteSpace:'pre-wrap',overflowWrap:'anywhere'}},JSON.stringify(record,null,2))));
-    })),
-   showParameters&&!ns&&h('p',{role:'status'},'尚未确认本插件的官方配置入口，参数暂不可编辑；上方目录诊断仍可读取。'),
-   showParameters&&h(Panel,{key:(ns??'unavailable')+':'+formIdentities.get(form),form}));
+ function RuntimePanel(){
+  const [ns,setNamespace]=React.useState(null);
+  React.useEffect(()=>{let active=true;
+   void ctx.remote.llm.listConfigurableProviders().then(result=>{
+    if(!active)return;
+    const rows=result?.ok===true&&Array.isArray(result.value)?result.value.filter(row=>['claude-code-workbench','codex-remote'].includes(row.provider)):[];
+    const names=[...new Set(rows.map(row=>row.settingsNs).filter(value=>typeof value==='string'&&value))];
+    setNamespace(names.length===1?names[0]:null);
+   },()=>{if(active)setNamespace(null);});
+   return()=>{active=false;};
+  },[]);
+  const form=ns?ctx.configForms.get(ns):unavailableForm;
+  return h('div',null,!ns&&h('p',{role:'status'},'尚未读取到本插件的官方配置入口，参数当前值暂不可用。'),h(Panel,{key:ns??'unavailable',form}));
  }
  function Panel({form}){
   const snapshot=React.useSyncExternalStore(fn=>form.subscribe(fn),()=>form.getSnapshot(),()=>form.getSnapshot());
-  const [draft,setDraft]=React.useState({}),[busy,setBusy]=React.useState(false),[notice,setNotice]=React.useState('');
-  const revision=React.useRef(undefined),saving=React.useRef(false),alive=React.useRef(true),prefix=React.useId();
-  React.useEffect(()=>{alive.current=true;return()=>{alive.current=false;};},[]);
-  const ready=snapshot.status==='ready',writable=ready&&snapshot.writable===true&&snapshot.mode==='host'&&snapshot.revision!==undefined;
-  const changed=Object.keys(draft).length>0,stale=changed&&revision.current!==snapshot.revision;
-  const edit=(key,value)=>{if(saving.current||!writable)return;if(!changed)revision.current=snapshot.revision;setDraft(previous=>({...previous,[key]:value}));setNotice('修改尚未保存。');};
-  const discard=()=>{if(saving.current)return;setDraft({});revision.current=undefined;setNotice('已放弃未保存修改，显示当前配置。');};
-  const save=async()=>{
-   if(saving.current||!writable||!changed||stale)return;
-   const ops=[];
-   for(const field of fields){const entry=draft[field.key];if(!entry)continue;
-    if(field.readOnly){setNotice('固定约束不能修改。');return;}
-    if(entry.op==='unset'){ops.push({op:'unset',path:[field.key]});continue;}
-    const raw=entry.value,value=field.kind==='number'?Number(raw):raw;
-    if(field.kind==='number'&&(String(raw).trim()===''||!Number.isSafeInteger(value)||value<field.min||value>field.max)||field.kind==='select'&&!field.options.some(option=>option.value===value)){setNotice(field.name+'的值不在所列范围内，未保存。');return;}
-    ops.push({op:'set',path:[field.key],value});
-   }
-   saving.current=true;setBusy(true);setNotice('正在保存，请稍候。');
-   try{
-    const accepted=await form.mutate(ops,revision.current);
-    if(!alive.current)return;
-    if(accepted===true){setDraft({});revision.current=undefined;setNotice('已保存。运行中的这一轮不变；请按各项生效说明使用新会话。');}
-    else setNotice('未保存：配置已变化或官方设置服务拒绝了修改。草稿已保留；核对当前值后可放弃草稿重新修改，不会自动重试。');
-   }catch{if(alive.current)setNotice('保存失败，草稿已保留。请检查连接及官方配置状态；不会自动重试。');}
-   finally{saving.current=false;if(alive.current)setBusy(false);}
-  };
-  const stateMessage=snapshot.mode!=='host'?'当前连接不提供持久配置写入，本页不能保存。':!ready?'尚未取得官方配置，当前不能修改。':!snapshot.writable?'当前配置由更高层覆盖或不可写，本页不能修改。':stale?'其他地方已更新配置；本页草稿保留。请放弃草稿后按最新值重新修改。':'';
+  const ready=snapshot.status==='ready';
   return h('section',{'aria-label':'远程助手参数',style:{maxWidth:850}},
    h('h2',null,'远程助手参数'),
-   h('p',null,'这些参数用于本客户端当前配置下的 Claude（远程主机）和 Codex（远程主机），不改变其他模型或主机账号权限。没有总开关；关闭整个插件请使用官方插件管理。'),
-   stateMessage&&h('p',{role:'status'},stateMessage),
-   h('form',{onSubmit:event=>{event.preventDefault();void save();}},
-    ...fields.map(field=>{
-     const entry=draft[field.key],accepted=ready?snapshot.value?.[field.key]:undefined;
-     const base=snapshot.base,hasBase=base!==null&&typeof base==='object'&&Object.hasOwn(base,field.key)&&base[field.key]!==undefined;
-     const value=entry?.op==='set'?entry.value:entry?.op==='unset'&&hasBase?base[field.key]:accepted;
-     const id=prefix+'-'+field.key,description=id+'-description';
-     const control=field.readOnly?h('p',{'aria-label':field.name+'当前值'},String(value??'尚未读取')+'（固定，不可切换）'):field.kind==='select'?h('select',{id,value:value??'',disabled:!writable||busy,'aria-describedby':description,onChange:event=>edit(field.key,{op:'set',value:event.target.value})},value===undefined&&h('option',{value:'',disabled:true},'尚未读取'),...field.options.map(option=>h('option',{key:option.value,value:option.value},option.name))):h('input',{id,type:'number',step:1,min:field.min,max:field.max,value:value??'',disabled:!writable||busy,'aria-describedby':description,onChange:event=>edit(field.key,{op:'set',value:event.target.value})});
-     return h('fieldset',{key:field.key,style:{marginBottom:18,padding:14,border:'1px solid currentColor',borderRadius:6}},
-      h('legend',null,field.name),h('label',{htmlFor:field.readOnly?undefined:id},field.name+'（'+field.key+'）'),
-      h('div',null,control),h('div',{id:description},
-       h('p',null,'默认值：'+field.defaultValue+'；范围：'+field.range),
-       h('p',null,'生效范围：'+field.scope),h('p',null,'生效时间：'+field.when),h('p',null,'调整或关闭的后果：'+field.consequence)),
-      entry?.op==='unset'&&h('p',null,hasBase?'将移除本项覆盖，恢复所示继承值；尚未保存。':'将移除本项覆盖；继承层未设此项，保存后由官方配置确定（默认值：'+field.defaultValue+'）。输入框仍显示保存前值，尚未保存。'),
-      !field.readOnly&&h('button',{type:'button',disabled:!writable||busy,onClick:()=>edit(field.key,{op:'unset'})},'恢复继承值：'+field.name));
-    }),
-    h('div',null,h('button',{type:'submit',disabled:!writable||!changed||busy||stale},busy?'正在保存…':'保存修改'),h('button',{type:'button',disabled:!changed||busy,onClick:discard},'放弃未保存修改'))),
-   h('p',{role:'status','aria-live':'polite'},notice),h('h3',null,'必须保持的正确性约束'),
+   h('p',null,'这里只显示本客户端当前配置下的 Claude（远程主机）和 Codex（远程主机）参数。请通过 DSH 官方 Config 配置文件入口修改。关闭整个插件请使用官方插件管理。'),
+   !ready&&h('p',{role:'status'},'尚未取得官方配置，暂时无法显示当前值。'),
+   ...fields.map(field=>h('fieldset',{key:field.key,style:{marginBottom:18,padding:14,border:'1px solid currentColor',borderRadius:6}},
+    h('legend',null,field.name),h('p',null,field.key),
+    h('p',{'aria-label':field.name+'当前值'},String(ready?snapshot.value?.[field.key]??'尚未读取':'尚未读取')),
+    h('p',null,'默认值：'+field.defaultValue+'；范围：'+field.range),
+    h('p',null,'生效范围：'+field.scope),h('p',null,'生效时间：'+field.when),h('p',null,'调整或关闭的后果：'+field.consequence))),
+   h('h3',null,'必须保持的正确性约束'),
    h('p',null,'以下保护默认开启且不能关闭。关闭会使输入、审批、执行位置或记录失去可信归属，并非可以放宽的偏好。'),
    h('dl',null,...invariants.flatMap(([name,state,why])=>[h('dt',{key:name},name+'：'+state),h('dd',{key:name+'-why'},why)])));
  }
- ctx.effect(()=>ctx.slots.inject('settings.models.footer',()=>ctx.slots.register({name:'settings.models.footer',id:'ai-workbench-remote-model-diagnostics',order:90,inject:()=>({showParameters:false})},RuntimePanel)));
  ctx.effect(()=>ctx.slots.inject('settings.plugins.tab',()=>ctx.slots.register({name:'settings.plugins.tab',id:'ai-workbench-remote-parameters',order:90,label:()=> '远程助手参数',inject:()=>({})},RuntimePanel)));
 }
 
-  return{inject:['locale','connection'],apply(ctx){
-    ctx.inject(['slots','configForms'],settings=>mountRuntimeSettings(settings,require('react'),settingsFields));
-    ctx.effect(()=>ctx.locale.register('ai-workbench-codex',messages),'Codex official translations');
-    ctx.effect(()=>{
-      let disposed=false,connected=false,previous,generation=0,request=new AbortController(),queue=Promise.resolve();
-      const sync=()=>{
-        if(disposed||!connected)return;
-        const active=ctx.locale.getSnapshot().active;
-        const language=active.split('-')[0].toLowerCase()==='zh'?'zh':'en';
-        if(language===previous)return;
-        previous=language;
-        const mine=generation,signal=request.signal;
-        queue=queue.then(async()=>{
-          if(disposed||signal.aborted||mine!==generation)return;
-          const result=await ctx.connection.rpc.call('/api','awCodexPresentation/setLocale',{args:{language}},signal);
-          signal.throwIfAborted();
-          if(result?.ok!==true||result.value?.language!==language||result.value?.name!==messages[language].providerName){
-            throw Object.assign(new Error('Provider-name locale sync was not confirmed'),{code:result?.ok===false&&typeof result.error?.code==='string'?result.error.code:'LOCALE_SYNC_INVALID'});
-          }
-        }).catch(error=>{
-          if(!disposed&&!signal.aborted&&mine===generation)ctx.logger.warn('Codex provider-name locale update failed',typeof error?.code==='string'?error.code:'LOCALE_SYNC_FAILED');
-        });
-      };
-      const link=()=>{
-        const next=ctx.connection.state.getSnapshot()==='connected';
-        if(next===connected)return;
-        connected=next;generation++;previous=undefined;request.abort();request=new AbortController();
-        if(connected)sync();
-      };
-      const offLocale=ctx.locale.subscribe(sync),offConnection=ctx.connection.state.subscribe(link);link();
-      return()=>{disposed=true;offLocale();offConnection();request.abort();};
-    },'Codex provider names follow the official locale');
-  }};
+ return{inject:['locale'],apply(ctx){
+  ctx.inject(['slots','configForms','remote'],settings=>mountRuntimeSettings(settings,require('react'),settingsFields));
+  ctx.effect(()=>ctx.locale.register('ai-workbench-codex',messages),'Remote assistant translations');
+ }};
 }});

package/dist/close-diagnostics.d.ts

@@ -17,35 +17,21 @@ export interface CloseCause {
     changes?: readonly CloseChange[];
 }
 export type CloseObserver = (cause: CloseCause) => void;
-export { closeCode, closeErrorCodes, closeFailure, withFailureEvidence, withFirstFailureEvidence, failureEvidenceSummary, primaryFailureCode } from './failure-evidence.ts';
-/** Assign order before abort/kill; persist through the existing asynchronous D19 outbox. */
+export { closeCode, closeErrorCodes, withFirstFailureEvidence, failureEvidenceSummary, primaryFailureCode } from './failure-evidence.ts';
+/** One first-close observation per runtime, including its child resources. */
 export declare class CloseDiagnostics {
     private sink;
-    readonly parentId?: string | undefined;
-    private state;
-    readonly id: `${string}-${string}-${string}-${string}-${string}`;
-    private sequence;
-    private pending;
-    private firstValue?;
+    private readonly state;
     private readonly started;
     stage: string;
-    constructor(sink: (detail: DetailObservation) => void, parentId?: string | undefined, state?: {
-        failure?: {
-            error: unknown;
-        };
+    constructor(sink: (detail: DetailObservation) => void, state?: {
+        first?: Readonly<Record<string, unknown>>;
     });
-    run<T>(operation: string, work: () => Promise<T>): Promise<T>;
-    get recordingFailureCode(): string | undefined;
+    run<T>(_operation: string, work: () => Promise<T>): Promise<T>;
     get first(): Readonly<Record<string, unknown>> | undefined;
     bind(sink: (detail: DetailObservation) => void): void;
-    /** A delayed resource callback retains its original accepted detail channel. */
     capture(): CloseObserver;
     child(sink?: (detail: DetailObservation) => void): CloseDiagnostics;
     record(cause: CloseCause): void;
     private recordUsing;
-    assertRecorded(): void;
 }
-/** Run after owned cleanup; expose both the primary error code and persistence failure. */
-export declare function flushCloseDiagnostics(diagnostics: CloseDiagnostics, flush: (() => Promise<void>) | undefined, primary?: {
-    error: unknown;
-}): Promise<void>;

package/dist/close-diagnostics.js

@@ -1,74 +1,30 @@
-import { randomUUID } from 'node:crypto';
-import { NeedError } from "./remote.js";
-import { closeCode, closeErrorCodes, withFailureEvidence } from "./failure-evidence.js";
-export { closeCode, closeErrorCodes, closeFailure, withFailureEvidence, withFirstFailureEvidence, failureEvidenceSummary, primaryFailureCode } from "./failure-evidence.js";
-/** Assign order before abort/kill; persist through the existing asynchronous D19 outbox. */
+export { closeCode, closeErrorCodes, withFirstFailureEvidence, failureEvidenceSummary, primaryFailureCode } from "./failure-evidence.js";
+/** One first-close observation per runtime, including its child resources. */
 export class CloseDiagnostics {
     sink;
-    parentId;
     state;
-    id = randomUUID();
-    sequence = 0;
-    pending = new Map();
-    firstValue;
     started = performance.now();
     stage = 'runtime-admission';
-    constructor(sink, parentId, state = {}) {
+    constructor(sink, state = {}) {
         this.sink = sink;
-        this.parentId = parentId;
         this.state = state;
     }
-    async run(operation, work) { this.pending.set(operation, (this.pending.get(operation) ?? 0) + 1); try {
-        return await work();
-    }
-    finally {
-        const count = this.pending.get(operation) - 1;
-        if (count)
-            this.pending.set(operation, count);
-        else
-            this.pending.delete(operation);
-    } }
-    get recordingFailureCode() { return this.state.failure ? closeCode(this.state.failure.error, 'CLOSE_RECORD_FAILED') : undefined; }
-    get first() { return this.firstValue; }
+    run(_operation, work) { return work(); }
+    get first() { return this.state.first; }
     bind(sink) { this.sink = sink; }
-    /** A delayed resource callback retains its original accepted detail channel. */
     capture() { const sink = this.sink; return cause => this.recordUsing(sink, cause); }
-    child(sink = this.sink) { const child = new CloseDiagnostics(sink, this.id, this.state); child.stage = this.stage; return child; }
+    child(sink = this.sink) { return new CloseDiagnostics(sink, this.state); }
     record(cause) { this.recordUsing(this.sink, cause); }
     recordUsing(sink, cause) {
-        const first = this.sequence === 0;
-        const metadata = { ...cause.changedFields ? { changedFields: Object.freeze([...cause.changedFields]) } : {}, changes: Object.freeze((cause.changes ?? [{ field: 'observer.close-sequence', before: this.sequence, after: this.sequence + 1 }]).map(change => Object.freeze({ field: change.field, before: change.before, after: change.after }))), layer: cause.layer, initiator: cause.initiator, reason: cause.reason, ...cause.action ? { action: cause.action } : {}, ...cause.operation ? { operation: cause.operation } : {}, ...cause.exitCode !== undefined ? { exitCode: cause.exitCode } : {}, ...cause.signal !== undefined ? { signal: cause.signal } : {}, ...cause.remoteReason ? { remoteReason: cause.remoteReason } : {} };
-        const payload = Object.freeze({ ...metadata, pendingOperations: Object.freeze([...this.pending.keys()]), closeId: this.id, ...this.parentId ? { parentCloseId: this.parentId } : {}, closeSequence: ++this.sequence, first, stage: this.stage, clock: 'client-monotonic', elapsedMs: performance.now() - this.started });
-        this.firstValue ??= payload;
+        if (this.state.first)
+            return;
+        const payload = Object.freeze({ layer: cause.layer, initiator: cause.initiator, reason: cause.reason, ...cause.remoteReason ? { remoteReason: cause.remoteReason } : {}, ...cause.exitCode !== undefined ? { exitCode: cause.exitCode } : {}, ...cause.signal !== undefined ? { signal: cause.signal } : {}, stage: this.stage, clock: 'client-monotonic', elapsedMs: performance.now() - this.started });
+        this.state.first = payload;
         try {
-            sink({ kind: 'session', severity: 'warning', code: first ? 'REMOTE_CLOSE_FIRST' : 'REMOTE_CLOSE_NEXT', summary: cause.changedFields?.includes('selected-model') ? '最新可信目录已不再提供本轮所选型号，本轮已停止；请在模型菜单核对选择。' : first ? '首次观察到关闭（不等同根因）' : '后续关闭或清理', payload });
+            sink({ kind: 'session', severity: 'warning', code: 'REMOTE_CLOSE_REASON', summary: '首次观察到的关闭原因', payload });
         }
-        catch (error) {
-            this.state.failure ??= { error };
+        catch {
+            console.warn('[remote-agent] 首次关闭原因未保存');
         }
     }
-    assertRecorded() { if (this.state.failure)
-        throw new NeedError('CONVERSATION_DETAILS_FAILED', '关闭原因保存未完成；首次观察原因 ' + String(this.firstValue?.reason ?? 'CLOSE_REASON_UNKNOWN') + '。', '关闭诊断保存代码 ' + this.recordingFailureCode + '；不将保存失败当作原始关闭原因'); }
-}
-/** Run after owned cleanup; expose both the primary error code and persistence failure. */
-export async function flushCloseDiagnostics(diagnostics, flush, primary) {
-    const reporting = [];
-    try {
-        await flush?.();
-    }
-    catch (error) {
-        reporting.push(...closeErrorCodes(error, 'CLOSE_FLUSH_FAILED'));
-    }
-    try {
-        diagnostics.assertRecorded();
-    }
-    catch (error) {
-        reporting.push(diagnostics.recordingFailureCode ?? closeCode(error, 'CLOSE_RECORD_FAILED'));
-    }
-    if (reporting.length) {
-        const primaryCodes = primary ? closeErrorCodes(primary.error, 'REMOTE_CLEANUP_UNCONFIRMED') : [];
-        throw withFailureEvidence(primary?.error ?? new NeedError(primaryCodes[0] ?? 'REMOTE_CLEANUP_UNCONFIRMED', '关闭收尾未确认', '核对实际结果'), reporting.map(code => new NeedError(code, '诊断保存未确认', '只读核对')), 'diagnostic', diagnostics.first?.reason);
-    }
-    if (primary)
-        throw primary.error;
 }

package/dist/connect-contract.d.ts

@@ -1,13 +1,10 @@
 import type { ConnectNeed } from '@ai-workbench/connect/api';
 import type { ConnectTarget } from './provider.ts';
-import type { ContractInfo, Provider, WorkspaceUse, WorkspaceNoticeReceipt as LWorkspaceNoticeReceipt } from '@ai-workbench/connect/api';
+import type { ContractInfo, Provider, WorkspaceUse } from '@ai-workbench/connect/api';
 /** 正式L0.7公开类型；消费子集不表示已安装或已通过真实产品门。 */
-export type { WorkspaceNotice, SessionProjectTarget, HostWorkspaceResolveContext, HostSessionProjectTarget } from '@ai-workbench/connect/api';
-import type { SessionProjectTarget, HostWorkspaceResolveContext, HostSessionProjectTarget } from '@ai-workbench/connect/api';
+export type { HostWorkspaceResolveContext, HostSessionProjectTarget } from '@ai-workbench/connect/api';
+import type { HostWorkspaceResolveContext, HostSessionProjectTarget } from '@ai-workbench/connect/api';
 export type LoginProvider = Provider;
-export type WorkspaceNoticeReceipt = Extract<LWorkspaceNoticeReceipt, {
-    surface: 'provider';
-}>;
 export type ConnectResult<T> = {
     ok: true;
     value: T;
@@ -19,10 +16,9 @@ export type ConnectResult<T> = {
         requires: string;
     } & Partial<Pick<ConnectNeed, 'officialReason' | 'layer' | 'actor' | 'action' | 'lastSeen'>>;
 };
-export type SessionProjectResolution = SessionProjectTarget | HostSessionProjectTarget;
+export type SessionProjectResolution = HostSessionProjectTarget;
 export interface NativeWorkspaceApi {
     getContractInfo(): ContractInfo;
     ensureReady(provider: LoginProvider): Promise<ConnectResult<ConnectTarget>>;
     resolveSessionProject(sessionId: string, use: WorkspaceUse, location?: HostWorkspaceResolveContext): Promise<ConnectResult<SessionProjectResolution>>;
-    acknowledgeWorkspaceNotice(receipt: WorkspaceNoticeReceipt): Promise<ConnectResult<void>>;
 }