@ai-workbench/remote-agent 0.8.19 → 0.8.23

package/dist/model-configuration.js

@@ -168,30 +168,15 @@ export class ModelConfiguration {
     fail(error) {
         this.state = freeze({ ...this.state, confirmed: false, failure: { code: error.code, message: error.message } });
     }
-    checkAckRevision(revision, stage) {
-        if (revision !== this.revision)
-            unavailable(`${stage}回执之后收到其他配置更新，原选择未获确认`);
-    }
     async set(id, value, stage) {
-        const revision = this.revision, modelId = this.parsed?.model.id, effortId = this.parsed?.effort?.id;
-        let response;
         try {
-            response = await this.rpcSet(id, value);
+            const response = await this.rpcSet(id, value);
+            if (record(response) && Array.isArray(response.configOptions))
+                this.apply(this.prepare(response.configOptions));
         }
         catch (cause) {
-            throw new ModelConfigurationError(`${stage}配置请求失败，未获得远端确认`, { cause });
+            throw new ModelConfigurationError(`${stage}配置请求失败`, { cause });
         }
-        if (!record(response) || !Array.isArray(response.configOptions))
-            unavailable(`${stage}配置回执缺少完整配置列表`);
-        const prepared = this.prepare(response.configOptions);
-        if (prepared.parsed.model.id !== modelId || stage === '推理等级' && prepared.parsed.effort && prepared.parsed.effort.id !== effortId)
-            unavailable('配置回执改用了其他入口，原请求没有得到确认');
-        // Notifications can precede their own setter ACK. Only a conflicting real
-        // selection, rather than unrelated/same-value UI updates, invalidates it.
-        if (revision !== this.revision && !sameSelection(this.parsed, prepared.parsed))
-            unavailable(`${stage}配置请求期间收到不同的实际配置，无法确认回执顺序`);
-        this.apply(prepared);
-        return this.revision;
     }
     async select(model, effort) {
         if (this.busy)
@@ -203,25 +188,10 @@ export class ModelConfiguration {
                 unavailable('当前远端配置列表无效');
             if (!this.parsed.model.values.some(entry => entry.value === model))
                 this.inform('PICKER_INCOMPLETE');
-            let ackRevision = await this.set(this.parsed.model.id, model, '模型');
-            this.checkAckRevision(ackRevision, '模型');
-            if (this.state.model !== model)
-                unavailable('模型配置回执与所选模型不一致');
-            if (effort !== undefined) {
-                const selector = this.parsed?.effort;
-                if (!selector)
-                    unavailable('远端没有提供实际推理等级选择器');
-                if (!selector.values.some(entry => entry.value === effort))
-                    this.inform('PICKER_INCOMPLETE');
-                ackRevision = await this.set(selector.id, effort, '推理等级');
-                this.checkAckRevision(ackRevision, '推理等级');
-                if (this.state.model !== model)
-                    unavailable('推理等级回执中的模型发生变化');
-                if (!this.state.effortAvailable || this.state.effort !== effort)
-                    unavailable('推理等级配置回执与所选等级不一致');
-            }
-            this.checkAckRevision(ackRevision, '选择');
-            this.state = freeze({ ...this.state, confirmed: true });
+            await this.set(this.parsed.model.id, model, '模型');
+            if (effort !== undefined && this.parsed?.effort)
+                await this.set(this.parsed.effort.id, effort, '推理等级');
+            this.state = freeze({ ...this.state, confirmed: this.state.model === model && (effort === undefined || this.state.effort === effort) });
             return this.state;
         }
         catch (cause) {
@@ -233,13 +203,4 @@ export class ModelConfiguration {
             this.busy = false;
         }
     }
-    /** Call immediately before prompt; an idle/new/load/resume update withdraws the ACK. */
-    assertSelection(model, effort) {
-        if (this.busy || !this.parsed || !this.state.confirmed)
-            unavailable('当前模型选择尚未获得完整远端确认');
-        if (this.state.model !== model)
-            unavailable('当前实际模型与待发送选择不一致');
-        if (effort !== undefined && (!this.state.effortAvailable || this.state.effort !== effort))
-            unavailable('当前实际推理等级与待发送选择不一致');
-    }
 }

package/dist/model-presentation.d.ts

@@ -4,6 +4,7 @@ import { type CatalogLease, type HostModel } from './model-catalog.ts';
 export declare class ModelPresentation {
     private snapshot?;
     remember(catalog: CatalogLease): void;
+    find(id: string): HostModel | undefined;
     resolve(provider: string, id: string): (LlmResolvedModelInfo & {
         catalog: HostModel;
     }) | undefined;

package/dist/model-presentation.js

@@ -2,12 +2,12 @@ import { modelInfo } from "./model-catalog.js";
 /** One displayed directory, never an execution/admission cache. No clock or TTL. */
 export class ModelPresentation {
     snapshot;
-    remember(catalog) { catalog.assertCurrent(); this.snapshot = { models: structuredClone(catalog.models), assertCurrent: catalog.assertCurrent }; }
+    remember(catalog) { this.snapshot = { models: structuredClone(catalog.models) }; }
+    find(id) { return this.snapshot?.models.find(row => row.id === id); }
     resolve(provider, id) {
         const snapshot = this.snapshot, model = snapshot?.models.find(row => row.id === id);
         if (!model)
             return;
-        snapshot.assertCurrent();
         return modelInfo(provider, structuredClone(model));
     }
     clear() { this.snapshot = undefined; }

package/dist/permissions.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from '@deepseek-ai/cordis';
+export interface DshPermissions {
+    sandbox: 'read-only' | 'workspace-write' | 'danger-full-access';
+    approval: 'ask' | 'never';
+    preset?: 'auto';
+}
+export interface PermissionSource {
+    read(sessionId: string | undefined): DshPermissions;
+    subscribe(sessionId: string, changed: () => void): () => void;
+}
+/** Read effective official knobs. Never infer privileges from a prompt or a label. */
+export declare function readDshPermissions(ctx: Pick<Context, 'get'>, sessionId: string | undefined): DshPermissions;
+export declare function dshPermissionSource(ctx: Context): PermissionSource;
+/** Three native mappings approved by orchestration on 2026-10-24. */
+export declare function permissionMode(brand: 'claude' | 'codex', policy: DshPermissions): string;

package/dist/permissions.js

@@ -0,0 +1,30 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { NeedError } from "./remote.js";
+const required = () => new NeedError('PERMISSION_POLICY_REQUIRED', '我需要读取当前会话的DSH权限设置，才能按你选择的权限执行。', '官方会话、sandboxPolicy和approval公开服务');
+/** Read effective official knobs. Never infer privileges from a prompt or a label. */
+export function readDshPermissions(ctx, sessionId) {
+    const session = sessionId ? ctx.get('sessions')?.get(SessionId(sessionId)) : undefined;
+    const sandbox = ctx.get('sandboxPolicy'), approval = ctx.get('approval');
+    if (!session || !sandbox || !approval || typeof sandbox.resolve !== 'function' || typeof approval.overrideOf !== 'function')
+        throw required();
+    // This is the official ApprovalService.effectivePolicy default, not a
+    // plugin-specific privilege fallback. It never implies automatic approval.
+    const mode = sandbox.resolve({ session }).mode, policy = approval.overrideOf(session) ?? approval.config.policy ?? 'ask';
+    if (!['read-only', 'workspace-write', 'danger-full-access'].includes(mode) || !['ask', 'never'].includes(policy))
+        throw required();
+    const presets = ctx.get('permissionPresets');
+    return { sandbox: mode, approval: policy, ...(presets?.current?.(session) === 'auto' ? { preset: 'auto' } : {}) };
+}
+export function dshPermissionSource(ctx) {
+    return { read: id => readDshPermissions(ctx, id), subscribe: (id, changed) => ctx.on('session/event', (session, event) => {
+            if (session.id === id && ['permission/preset', 'sandbox/mode', 'approval/policy'].includes(event.type))
+                changed();
+        }) };
+}
+/** Three native mappings approved by orchestration on 2026-10-24. */
+export function permissionMode(brand, policy) {
+    if (policy.preset === 'auto' || policy.sandbox === 'danger-full-access' && policy.approval !== 'never')
+        throw new NeedError('PERMISSION_MODE_UNSUPPORTED', '这个DSH权限组合还没有对应的远程执行模式；我需要主机连接组件支持该组合。', 'sandbox=' + policy.sandbox + '; approval=' + policy.approval + '; preset=' + (policy.preset ?? 'custom'));
+    return brand === 'claude' ? (policy.sandbox === 'read-only' ? 'plan' : policy.sandbox === 'workspace-write' ? 'default' : 'bypassPermissions') :
+        policy.sandbox === 'danger-full-access' ? 'agent-full-access' : policy.sandbox;
+}

package/dist/preflight-diagnostic.js

@@ -1,7 +1,6 @@
-import { withFailureEvidence, failureEvidenceSummary, primaryFailureCode } from "./close-diagnostics.js";
+import { failureEvidenceSummary, primaryFailureCode } from "./close-diagnostics.js";
 import { SessionId } from '@deepseek-ai/dsh-session';
 import { LlmError } from '@deepseek-ai/dsh-llm';
-import { isDeepStrictEqual } from 'node:util';
 import { NeedError } from "./remote.js";
 import { ModelConfigurationError } from "./model-configuration.js";
 import { officialEmployeeWorkspace } from "./employee-workspace.js";
@@ -19,12 +18,11 @@ export function createPreflightDiagnostics(options) {
     const scopes = new WeakMap();
     function capture(sessionId, position) {
         const api = options.getApi();
-        let connection, session, header, source = unknownSource(), captureError;
+        let connection, session, source = unknownSource();
         let context = position ? { ...position } : { turn: null, step: null };
         try {
             connection = api?.getConnectionState();
             session = sessionId ? options.ctx.get('sessions')?.get(SessionId(sessionId)) : undefined;
-            header = session && structuredClone(session.header);
             if (!position)
                 for (const event of session?.snapshotEvents() ?? []) {
                     if (event.type === 'turn/start')
@@ -51,39 +49,30 @@ export function createPreflightDiagnostics(options) {
                     const rows = state?.items.filter(row => row.workspaceId === workspace.id) ?? [];
                     if (state?.phase === 'ready' && state.instanceId === connection?.instanceId && state.epoch === connection.epoch && rows.length === 1) {
                         const row = rows[0];
-                        source = { workspaceId: row.workspaceId, bindingId: row.bindingId, source: row.source, status: row.status };
+                        source = { workspaceId: row.workspaceId, bindingId: row.bindingId, source: row.source === 'local' || row.source === 'host' ? row.source : null, status: row.status };
                     }
                 }
             }
         }
-        catch (error) {
-            captureError = error;
+        catch {
+            console.warn('[remote-agent] 预检日志上下文未读取');
         }
-        const assertScope = () => {
-            if (captureError !== undefined)
-                throw Object.assign(new NeedError('REMOTE_DETAIL_SCOPE_INVALID', '连接前诊断上下文无法核对。', '真实官方会话与连接快照'), { cause: captureError });
-            if (!sessionId || !session || options.ctx.get('sessions')?.get(SessionId(sessionId)) !== session || !isDeepStrictEqual(session.header, header))
-                throw new NeedError('REMOTE_DETAIL_SCOPE_INVALID', '连接前诊断所属会话已变化。', '原官方session/header');
-        };
-        return { sessionId, binding: { api, connection }, context, source, assertScope };
+        return { sessionId, binding: { api, connection }, context, source };
     }
     const scopeFor = (request) => { let scope = scopes.get(request); if (!scope) {
         scope = capture(request.sessionId);
         scopes.set(request, scope);
     } return scope; };
-    const write = (scope, provider, observation) => options.manager().recordPreflightCheck({ sessionId: scope.sessionId, provider, observation, context: scope.context, binding: scope.binding, assertScope: scope.assertScope });
+    const write = (scope, provider, observation) => options.manager().recordPreflightCheck({ sessionId: scope.sessionId, provider, observation, context: scope.context, binding: scope.binding });
     async function record(request, provider, observation) {
         const scope = scopeFor(request), payload = observation.payload;
         if (validPreflightPayload(payload) && ['failed', 'declined', 'cancelled'].includes(payload.outcome))
             request.preflightFailureRecorded = true;
         try {
             await write(scope, provider, observation);
-            if (validPreflightPayload(payload) && payload.outcome === 'confirmed')
-                scope.source = { workspaceId: payload.workspaceId, bindingId: payload.bindingId, source: payload.source, status: payload.status };
         }
-        catch (error) {
-            request.preflightFailureRecorded = true;
-            throw error;
+        catch {
+            console.warn('[remote-agent] 预检诊断未保存');
         }
     }
     return {
@@ -96,8 +85,8 @@ export function createPreflightDiagnostics(options) {
             try {
                 await record(request, provider, { kind: 'need', severity: 'action-required', code, summary: '本轮在连接前准备阶段停止；原始请求保留，未重发。' + failureEvidenceSummary(error), payload: { phase: 'workspace-source-admission', stage, ...scope.source, outcome: code === 'ABORTED' ? 'cancelled' : 'failed' } });
             }
-            catch (diagnostic) {
-                throw withFailureEvidence(error, [diagnostic], 'diagnostic', undefined, preflightCode(error));
+            catch {
+                console.warn('[remote-agent] 预检诊断未保存');
             }
         },
         forPreparation(sessionId, context) {

package/dist/preflight-payload.d.ts

@@ -4,7 +4,7 @@ export interface PreflightPayload {
     stage: SourceAdmissionStage;
     workspaceId: string | null;
     bindingId: string | null;
-    source: 'local' | 'host' | 'legacy-host' | null;
+    source: 'local' | 'host' | null;
     status: 'unselected' | 'selected' | 'legacy-confirmation-required' | 'invalid' | null;
     outcome: 'confirmation-required' | 'confirmed' | 'declined' | 'cancelled' | 'failed';
 }

package/dist/preflight-payload.js

@@ -4,8 +4,8 @@ export function validPreflightPayload(value) {
     const p = value, keys = ['phase', 'stage', 'workspaceId', 'bindingId', 'source', 'status', 'outcome'];
     const id = (v) => v === null || typeof v === 'string' && v.length > 0 && !/[\x00-\x1f\x7f]/.test(v);
     return Object.keys(p).length === keys.length && keys.every(key => Object.hasOwn(p, key)) && p.phase === 'workspace-source-admission'
-        && ['source-context', 'source-confirmation', 'input-acceptance', 'login-readiness', 'local-admission', 'input-prepare', 'model-catalog', 'runtime-resolve'].includes(p.stage)
-        && id(p.workspaceId) && id(p.bindingId) && [null, 'local', 'host', 'legacy-host'].includes(p.source)
+        && ['source-context', 'input-acceptance', 'login-readiness', 'local-admission', 'input-prepare', 'model-catalog', 'runtime-resolve'].includes(p.stage)
+        && id(p.workspaceId) && id(p.bindingId) && [null, 'local', 'host'].includes(p.source)
         && [null, 'unselected', 'selected', 'legacy-confirmation-required', 'invalid'].includes(p.status)
         && ['confirmation-required', 'confirmed', 'declined', 'cancelled', 'failed'].includes(p.outcome);
 }

package/dist/presentation.js

@@ -5,35 +5,31 @@ 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: '工作区来源确认未完成，本轮已停止；你的原话仍保留。',
+        PERMISSION_POLICY_REQUIRED: '我需要读取这条对话的权限设置，目前没有读到；本轮未执行，你的原话仍保留。',
+        PERMISSION_MODE_UNSUPPORTED: '这个权限档位还没有对应的远程执行能力；我需要主机连接组件支持该档位，本轮未执行，你的原话仍保留。',
+        PERMISSION_MODE_UNCONFIRMED: '远端没有确认按当前权限执行，本轮未继续；你的原话仍保留，具体原因见技术详情。',
+        PERMISSION_MODE_CHANGED: '远端权限已超出本会话选择，本次未发送；你的原话仍保留，具体原因见技术详情。',
+        CLAUDE_BYPASS_UNAVAILABLE: '主机没有为本会话开放完全权限，本轮未发送；我需要主机允许完全权限模式。',
+        PERMISSION_POLICY_CHANGED: '当前权限已变化或无法核对，这次派发已停止；没有自动重发，你的原话仍保留，在途结果请查看技术详情。',
+        APPROVAL_STALE: '连接或权限已变化，原审批已失效；没有自动重发，在途结果请查看技术详情。',
         PROJECT_BINDING_INVALID: '文件来源已改，请新建会话继续；原会话历史仍可查看。',
         WORKSPACE_LOCATION_REQUIRED: '我需要你确认这个工作区使用哪一个文件夹，本轮未执行；你的原话仍保留。',
         WORKSPACE_LOCATION_CONFLICT: '工作区来源选择已更新，本次确认不能覆盖新的选择；本轮未执行，你的原话仍保留。',
         LOCAL_USER_TURN_CHANGED: '本次输入已变化，本轮已停止，请确认对话后重新发送。',
         LOCAL_USER_TURN_UNCONFIRMED: '无法核对本次员工输入，本轮已停止；请在当前会话重新发送。',
-        LOCAL_USER_TURN_ACCEPTANCE_INVALID: '本次输入的核验回执不一致，本轮已停止，请联系管理员。',
-        MODEL_CATALOG_REVOKED: '所选型号已不在当前主机目录中，本轮已停止；请在模型菜单核对选择。',
-        MODEL_CATALOG_SCOPE_CHANGED: '远程主机连接或可信目标已改变，本轮已停止；原输入没有自动重发。',
-        CONVERSATION_DETAILS_FAILED: '本轮已停止，技术详情保存未确认；下方分别列出运行与保存原因。',
-        TECHNICAL_DETAILS_UNAVAILABLE: '技术详情暂不可用，请更新远程主机连接组件。',
-        REMOTE_DETAIL_STORAGE_FAILED: '技术详情保存失败，本轮已停止，请联系管理员检查。',
-        REMOTE_DETAIL_DELIVERY_UNKNOWN: '技术详情的持久结果无法核对，本轮已停止。',
-        REMOTE_DETAIL_SCOPE_INVALID: '无法核对本次输入与当前会话的关联，本轮已停止；请联系管理员核对技术详情。',
+        AW_EMPLOYEE_ENVIRONMENTS_CONFIG_UNSUPPORTED: '主机环境配置会覆盖本机执行位置，本轮已停止；请联系管理员调整后在原会话重试。',
         EMPLOYEE_CONTEXT_UNAVAILABLE: '我需要远程主机连接组件提供当前本机工作区，本轮未执行。',
         EMPLOYEE_ENDPOINT_UNAVAILABLE: '我需要员工电脑的执行连接就绪，本轮未执行；请联系管理员检查连接组件。',
-        EMPLOYEE_CONTEXT_CHANGED: '本机文件夹或连接已改变，原工具已停止；请在当前工作区重新开始。',
+        EMPLOYEE_CONTEXT_CHANGED: '本机文件夹或连接已变化，本轮已停止；恢复后可在原会话继续。',
         EMPLOYEE_WORKSPACE_INVALID: '无法核对这条对话所属的本机文件夹，本轮未执行；请在工作区中重新打开对话。',
-        REMOTE_DETAIL_TOO_LARGE: '技术详情超过已配置的单事件容量，本轮已停止；请联系管理员调整conversationDetails.maxEventBytes。',
         DEPENDENCY_REQUIRED: CONNECTION_REQUIRED,
+        MODEL_CATALOG_UNAVAILABLE: '所选型号暂时不可用，请打开模型菜单重新选择后再发送。',
         LOGIN_REQUIRED: '需要登录，请到设置 → 远程主机连接 点登录',
         LOGIN_COMPLETED: '登录已完成，请重新发送本轮内容。',
         LOGIN_FAILED: '登录未完成，请到设置 → 远程主机连接 点登录；如仍有问题，请联系管理员。',
         AUTH_STATUS_INVALID: '登录检查没有返回有效结果，请重新检查；如仍有问题，请联系管理员。',
         HOST_OFFLINE: '暂时无法连接远程主机，请联系管理员。',
-        CONNECTION_LOST: '远程主机连接已中断，请检查网络后重新连接。',
+        CONNECTION_LOST: '远程主机连接已中断；请检查网络，恢复后可在原会话继续。',
         SETTINGS_REQUIRED: '远程主机连接尚未设置好，请联系管理员。',
         CONNECT_API_MISMATCH: '远程主机连接组件需要更新，请联系管理员。',
         ENROLLMENT_REQUIRED: '我需要连接资料，请联系管理员发放。',
@@ -45,47 +41,31 @@ export function employeeFailure(code, brand = 'codex') {
         HOST_TRUST_REQUIRED: '远程主机连接信息还未准备好，请联系管理员。',
         POLICY_DENIED: '这个账号暂时不能使用，请联系公司账号管理员。',
         SESSION_CONTEXT_MISMATCH: '远程主机连接已改变，请重新开始本次检查。',
-        ABORTED: '本次检查已取消。',
+        ABORTED: '本轮已停止。操作可能已部分执行，请先确认文件；恢复连接后可在原会话继续。',
         CONFIRMATION_REQUIRED: '请先选择是否打开授权窗口。',
         CONTEXT_UNSUPPORTED: '远程 Codex 暂不支持这类会话内容，请联系管理员。',
         CONTENT_UNSUPPORTED: '远程 Codex 暂不支持这类附件，请联系管理员。',
-        SYSTEM_PROMPT_UPDATE_PENDING: 'Claude原会话无法保证立即应用已变化的系统或开发者要求，本轮未发送；请新建会话应用新要求。',
-        SYSTEM_PROMPT_UNSUPPORTED: '远端没有声明系统与开发者上下文能力，本轮未发送；需要管理员提供支持该能力的远端适配器。',
         SYSTEM_CONTEXT_TYPE_UNSUPPORTED: '系统或开发者要求包含暂不支持的非文本内容，本轮未新建或发送；请使用文本要求或联系管理员。',
-        RECOVERY_CONTEXT_POLICY_UNSUPPORTED: '旧版会话恢复记录仍绑定模型要求，无法安全接回；本轮未发送，请联系管理员核对原会话。',
-        SYSTEM_PROMPT_POLICY_UNSUPPORTED: '远端还不支持保留原会话并按新要求继续，请联系管理员更新远端适配器；本轮未发送。',
-        SYSTEM_PROMPT_NEW_SESSION_REQUIRED: '会话要求已变化，需要新建 Codex 会话并承接历史后继续；本轮未发送。',
-        SESSION_CONTEXT_DIGEST_INVALID: '原会话的要求记录无法核对，本轮未发送；请联系管理员核对原会话。',
         HISTORY_CONTENT_UNSUPPORTED: '此前对话含有暂时无法完整承接的内容，本轮未新建或发送；请联系管理员检查历史内容类型。',
-        SYSTEM_PROMPT_UPDATE_UNSUPPORTED: '远端不能更新原会话的系统与开发者要求，本轮未发送；请新建会话。',
         PROMPT_CONTENT_UNSUPPORTED: '远端没有声明这类输入能力，本轮未发送；请使用受支持的内容或联系管理员。',
         ATTACHMENT_REQUIRED: '我需要官方附件组件读取这张图片，请联系管理员检查组件。',
         ATTACHMENT_INVALID: '图片附件没有返回匹配的已核验内容，本轮未发送；请重新添加图片或联系管理员。',
         ACP_MESSAGE_TOO_LARGE: '本轮输入超过会话消息容量，未截断或发送；请联系管理员调整acpMaxMessageBytes。',
-        ACP_CLIENT_LOST: '我需要管理员核对并结束遗留的主机会话；当前保留原进程，没有代答旧审批。',
-        ONESHOT_CONTEXT_REQUIRED: '首版单次模式不支持图片或系统与开发者上下文，请改用会话模式。',
-        MODEL_CONFIGURATION_UNSUPPORTED: '单次模式不支持确认当前模型与推理等级，本轮未发送；请改用会话模式。',
-        INPUT_DELIVERY_UNCONFIRMED: '上一轮输入的处理结果尚未确认；没有自动重发，你的原话仍保留，请先核对技术详情。',
-        MODEL_SELECTION_REQUIRED: '旧远端恢复记录没有明确模型选择，本轮未发送；请新建会话并选择模型。',
-        MODEL_RESOLUTION_UNCONFIRMED: '主机目录尚未给出所选模型的唯一具体型号，本轮未发送；你的原话仍保留，请联系管理员核对模型目录。',
-        REMOTE_CLEANUP_UNCONFIRMED: '原主机会话的清理结果尚未确认，已阻断继续发送；请联系管理员核对，不能自动重开。',
     };
     if (messages[code])
         return messages[code];
     if (code === 'EMPLOYEE_OPERATION_UNSUPPORTED')
-        return '当前本机工作区暂不支持单次运行和断开后的冷恢复；请使用会话模式新建会话，原记录保留可查。';
-    if (code === 'AW_EMPLOYEE_COLD_RESUME_UNSUPPORTED' || code === 'EMPLOYEE_RECOVERY_UNSUPPORTED')
-        return '当前版本暂不支持恢复已关闭的本机执行会话；请新建会话，原记录保留可查。';
+        return '这项操作暂不支持在本机工作区执行；本轮已停止，原记录仍可查看。';
+    if (code === 'AW_EMPLOYEE_COLD_RESUME_UNSUPPORTED')
+        return '本机执行连接已关闭；恢复连接后可在原会话重新发送，原记录仍可查看。';
     if (code === 'AW_EMPLOYEE_HOST_AUXILIARY_CONFIG_UNSUPPORTED')
-        return '当前主机启用的MCP、hooks或插件尚未支持改到员工电脑，本轮没有执行，请联系管理员。';
+        return '主机上的一项扩展暂不能在你电脑上使用，本轮未执行，请查看技术详情。';
     if (code === 'AW_EMPLOYEE_HOST_PROJECT_CONFIG_UNSUPPORTED')
         return '主机上存在与本机工作区路径重合的项目配置，当前版本无法安全应用，本轮没有执行，请联系管理员。';
-    if (code === 'AW_EMPLOYEE_EXECUTOR_MCP_UNSUPPORTED')
-        return '本机 HTTP MCP 当前配置策略为拒绝，本轮没有继续执行；管理员可在远程助手参数中调整本机 HTTP MCP 策略，新建会话后生效。';
     if (['AW_EMPLOYEE_CONFIG_ADMISSION_INVALID', 'AW_EMPLOYEE_CONFIG_ADMISSION_FAILED', 'AW_EMPLOYEE_EXECUTOR_CONFIG_PROTOCOL_INVALID', 'AW_EMPLOYEE_EXECUTOR_CONFIG_READ_FAILED'].includes(code))
         return '无法核验这次本机工作区的助手配置，本轮没有继续执行，请联系管理员查看技术详情。';
     if (code === 'AW_EMPLOYEE_MCP_UNSUPPORTED')
-        return '当前版本尚不支持把附加MCP工具改到员工电脑，本轮没有执行。';
+        return '这项扩展暂不能在你电脑上使用，本轮未执行。';
     if (code === 'AW_EMPLOYEE_HOST_AUXILIARY_UNSUPPORTED')
         return '这项辅助操作尚未支持在员工电脑执行，本轮没有执行。';
     if (code === 'AW_EMPLOYEE_SLASH_COMMAND_UNSUPPORTED')
@@ -96,9 +76,9 @@ export function employeeFailure(code, brand = 'codex') {
         return '当前助手的项目配置覆盖与本机执行不兼容，本轮没有执行，请联系管理员。';
     if (code === 'EMPLOYEE_PLATFORM_UNSUPPORTED')
         return brand === 'claude' ? '本机执行目前只支持Mac；当前设备尚不支持，本轮未执行。' : '当前版本的Codex本机执行仅验证了Apple芯片Mac，本轮没有执行。';
-    if (code.startsWith('AW_EMPLOYEE_BINARY_'))
-        return 'Codex本机执行组件缺失或校验失败，本轮没有执行，请联系管理员。';
+    if (code === 'AW_EMPLOYEE_BINARY_MISSING')
+        return '本机执行组件没有装齐，本轮没有执行，请重新安装插件。';
     if (code.startsWith('AW_EMPLOYEE_') || code.startsWith('EMPLOYEE_'))
-        return '员工电脑的执行连接不可用或工作区已变化，本轮已停止；在途操作结果尚待确认，请查看技术详情。';
-    return `远程主机暂时无法完成这次操作，请联系管理员。技术详情：诊断代码 ${code}`;
+        return '你电脑上的执行连接已中断，本轮已停止；操作可能已部分执行，请先确认文件，恢复后可在原会话继续。';
+    return '本轮没有完成。请检查连接，恢复后可在原会话继续；操作可能已部分执行，请先确认文件。';
 }

package/dist/provider.d.ts

@@ -3,18 +3,14 @@ import type { AgentApp } from '@agentclientprotocol/sdk';
 import type { AgentApp as ExtendedAgentApp } from '@agentclientprotocol/sdk/unstable';
 import type { ConnectState, ConnectNeed, ConnectApi as LConnectApi, ConnectionState, LoginPromptState } from '@ai-workbench/connect/api';
 export type { ConnectionState, LoginPromptState } from '@ai-workbench/connect/api';
-import type { OneShotRuntime } from './job.ts';
 import type { BrokerTransport, BrokerSettings } from './broker.ts';
 import type { Interaction, Invocation } from './interaction.ts';
 import { type AgentDefinition } from './agents.ts';
-import type { NativeWorkspaceApi, SessionProjectTarget, WorkspaceNotice, LoginProvider } from './connect-contract.ts';
+import type { NativeWorkspaceApi, LoginProvider } from './connect-contract.ts';
 import type { DetailChannel } from './remote-details.ts';
-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 { SourceAdmissionStage } from './workspace-source.ts';
+import type { LocalWorkspaceContext } from '@ai-workbench/connect/api';
 import type { EmployeeRouting } from './employee-relay.ts';
 import type { HostWorkspacePresentation } from './input.ts';
 export interface EmployeeExecution {
@@ -38,7 +34,6 @@ export interface Runtime {
         readable: ReadableStream<Uint8Array>;
     } | AgentApp | ExtendedAgentApp;
     broker?: BrokerTransport;
-    oneShot?: OneShotRuntime;
     loginRequired?: () => Promise<void>;
     dispose?: (cause?: CloseCause) => Promise<void>;
     binding?: {
@@ -47,14 +42,8 @@ export interface Runtime {
         revision: number;
     };
     connection?: ConnectionState;
-    workspaceNotice?: WorkspaceNoticePresentation;
     details?: DetailChannel;
-    recoveredSession?: AcpRecovery;
-    restartNotice?: string;
     detach?: (cause?: CloseCause) => Promise<void>;
-    restartInputIds?: readonly string[];
-    freshSessionConfirmed?: boolean;
-    saveCheckpoint?: (id: string, acp: AcpRecovery) => Promise<boolean>;
     detailContext?: () => {
         turn: string | number | null;
         step: string | number | null;
@@ -65,7 +54,6 @@ export interface Runtime {
         workspaceId: string;
         cwd: string;
         acpMaxMessageBytes: number;
-        httpMcpPolicy?: 'reject' | 'ignore';
     };
     employeeExecution?: (params: unknown, signal?: AbortSignal) => Promise<Record<string, unknown>>;
     employeePresentation?: string;
@@ -74,29 +62,21 @@ export interface Runtime {
 }
 export interface RuntimeRequest extends Invocation {
     closeDiagnostics?: CloseDiagnostics;
-    requireFreshSession?: boolean;
     previousContextSha256?: string;
     preflightFailureRecorded?: boolean;
     recordEarlyFailure?: (error: unknown, stage: SourceAdmissionStage) => Promise<void>;
     userInputIds?: readonly string[];
-    localAcceptance?: Readonly<LocalUserTurnAcceptance>;
+    localContext?: Readonly<LocalWorkspaceContext>;
     localAdmissionCheck?: () => void;
-    readonly localAcceptanceId?: string;
     userMessageIds?: readonly string[];
-    recoveryJournal?: RecoveryJournal;
     detailChannel?: DetailChannel;
-    validateContext?: (ignoreCancellation?: boolean) => Promise<void>;
-    verifyRecovery?: () => Promise<boolean>;
-    employeeHttpMcpPolicy?: 'reject' | 'ignore';
     acpMaxMessageBytes?: number;
     employeeScope?: string;
     contextSha256?: string;
     resumeSessionId?: string;
-    recoveryCheckpointId?: string;
     bindingRevision?: number;
     currentInputIds?: readonly string[];
-    timing?: StageTiming;
-    mode: 'session' | 'one-shot';
+    mode?: 'session';
     cwd?: string;
     identity?: string;
     bindingId?: string;
@@ -150,7 +130,7 @@ type Result<T> = {
     } & Partial<Pick<ConnectNeed, 'officialReason' | 'layer' | 'actor' | 'action' | 'lastSeen'>>;
 };
 /** 消费正式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' | 'selectWorkspaceLocation'>> {
+export interface ConnectApi extends Pick<LConnectApi, 'getConnectionState' | 'getLoginPromptState' | 'requestLoginPrompt' | 'refreshLoginPrompts'>, Partial<NativeWorkspaceApi>, Partial<Pick<LConnectApi, 'getModelCatalogTarget' | 'onConnectionState' | 'onLoginPromptState' | 'getWorkspaceLocationState' | 'getLocalWorkspaceContext' | 'onWorkspaceLocationState' | 'selectWorkspaceLocation'>> {
     getState?(): ConnectState;
     getSshTarget(): Promise<Result<ConnectTarget>>;
     checkLogin(provider: LoginProvider): Promise<Result<{
@@ -161,14 +141,14 @@ export interface ConnectApi extends Pick<LConnectApi, 'getConnectionState' | 'ge
         provider: string;
         loggedIn: boolean;
     }>>;
-    listProjects(): Promise<Result<{
+    listProjects?(): Promise<Result<{
         projects: Project[];
         unavailable: {
             name: string;
             reason: string;
         }[];
     }>>;
-    createProject(name: string): Promise<Result<Project>>;
+    createProject?(name: string): Promise<Result<Project>>;
 }
 export declare function requireLoginCoordinator(api: ConnectApi): void;
 export declare function requireLoginState(state: LoginPromptState): void;
@@ -192,10 +172,6 @@ export declare function identity(t: ConnectTarget): string;
 export declare function requireNativeWorkspace(api: ConnectApi): asserts api is ConnectApi & NativeWorkspaceApi;
 /** Authorization stays in L; ensureReady only checks and records the need. */
 export declare function offerLogin(connect: ConnectApi, request: Invocation, currentApi?: () => ConnectApi | undefined, agent?: AgentDefinition): Promise<void>;
-export interface NoticeConsumer {
-    reconcile(request: RuntimeRequest, api: ConnectApi): Promise<void>;
-    deliver(notice: WorkspaceNotice, resolved: SessionProjectTarget, request: RuntimeRequest, api: ConnectApi): Promise<WorkspaceNoticePresentation | void>;
-}
 export type LocalRuntimeProvider = ((request: RuntimeRequest, api: ConnectApi, connection: ConnectionState, target: ConnectTarget) => Promise<Runtime | undefined>) & {
     admit?: (request: RuntimeRequest, api: ConnectApi, connection: ConnectionState, target: ConnectTarget) => Promise<void>;
 };
@@ -203,8 +179,10 @@ export declare function sameTarget(a: ConnectTarget, b: ConnectTarget): boolean;
 export declare function connectProvider(get: () => ConnectApi | undefined, options?: {
     agent?: AgentDefinition;
     ask?: Interaction;
-    notice?: NoticeConsumer;
-    workspaceSource?: WorkspaceSourceOptions;
+    workspace?: (request: RuntimeRequest) => Promise<{
+        id: string;
+        path: string;
+    }>;
     employee?: EmployeeProviderOptions;
     local?: LocalRuntimeProvider;
     details?: (request: RuntimeRequest, api: ConnectApi, connection: ConnectionState, target: ConnectTarget) => Promise<DetailChannel>;