@ai-workbench/remote-agent 0.8.2 → 0.8.10

package/dist/model-configuration.js

@@ -0,0 +1,212 @@
+export class ModelConfigurationError extends Error {
+    code = 'MODEL_CATALOG_UNAVAILABLE';
+    constructor(reason, options) {
+        super(`无法获取模型列表：${reason}`, options);
+        this.name = 'ModelConfigurationError';
+    }
+}
+function unavailable(reason) { throw new ModelConfigurationError(reason); }
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function text(value) { return typeof value === 'string' && value.trim().length > 0; }
+function label(value) {
+    if (!text(value.name))
+        unavailable('配置名称为空或无效');
+    if (value.description !== undefined && value.description !== null && typeof value.description !== 'string')
+        unavailable('配置说明无效');
+}
+function select(option) {
+    if (!text(option.currentValue) || !Array.isArray(option.options) || !option.options.length)
+        unavailable('选择器缺少实际当前值或可选列表');
+    const values = [];
+    const seen = new Set();
+    const add = (value) => {
+        if (!record(value) || !text(value.value) || 'group' in value || 'options' in value)
+            unavailable('可选值格式无效');
+        label(value);
+        if (seen.has(value.value))
+            unavailable('选择器包含重复可选值');
+        seen.add(value.value);
+        values.push({ value: value.value, name: value.name, ...(value.description === undefined ? {} : { description: value.description }) });
+    };
+    const grouped = record(option.options[0]) && 'group' in option.options[0];
+    const groups = new Set();
+    for (const entry of option.options) {
+        if (grouped) {
+            if (!record(entry) || !text(entry.group) || 'value' in entry || !Array.isArray(entry.options) || !entry.options.length)
+                unavailable('分组选择器格式无效或分组为空');
+            label(entry);
+            if (groups.has(entry.group))
+                unavailable('选择器包含重复分组标识');
+            groups.add(entry.group);
+            for (const value of entry.options)
+                add(value);
+        }
+        else
+            add(entry);
+    }
+    if (!seen.has(option.currentValue))
+        unavailable('实际当前值不在远端可选列表中');
+    return { id: option.id, currentValue: option.currentValue, values };
+}
+function parse(options) {
+    if (!Array.isArray(options) || !options.length)
+        unavailable('远端没有提供完整配置列表');
+    const ids = new Set();
+    const models = [];
+    const efforts = [];
+    for (const option of options) {
+        if (!record(option) || !text(option.id))
+            unavailable('配置标识为空或无效');
+        label(option);
+        if (ids.has(option.id))
+            unavailable('配置列表包含重复标识');
+        ids.add(option.id);
+        if (option.category !== undefined && option.category !== null && typeof option.category !== 'string')
+            unavailable('配置类别无效');
+        if (option.type === 'select') {
+            const selector = select(option);
+            if (option.category === 'model')
+                models.push(selector);
+            if (option.category === 'thought_level')
+                efforts.push(selector);
+        }
+        else if (option.type === 'boolean') {
+            if (typeof option.currentValue !== 'boolean')
+                unavailable('布尔配置当前值无效');
+            if (option.category === 'model' || option.category === 'thought_level')
+                unavailable('模型或推理等级配置不是选择器');
+        }
+        else
+            unavailable('配置类型无法识别');
+    }
+    if (models.length !== 1)
+        unavailable(models.length ? '模型选择器不唯一' : '没有可识别的模型选择器');
+    if (efforts.length > 1)
+        unavailable('推理等级选择器不唯一');
+    return { model: models[0], effort: efforts[0] };
+}
+function freeze(value, seen = new WeakSet()) {
+    if (value !== null && typeof value === 'object' && !seen.has(value)) {
+        seen.add(value);
+        for (const item of Object.values(value))
+            freeze(item, seen);
+        Object.freeze(value);
+    }
+    return value;
+}
+/** Pure ACP configuration state. All IDs and values come from the given peer data. */
+export class ModelConfiguration {
+    rpcSet;
+    state;
+    parsed;
+    revision = 0;
+    busy = false;
+    constructor(options, rpcSet) {
+        this.rpcSet = rpcSet;
+        this.update(options);
+    }
+    get models() {
+        if (!this.parsed)
+            throw new ModelConfigurationError('当前远端配置列表无效');
+        return this.state.models;
+    }
+    get snapshot() { return this.state; }
+    update(options) {
+        this.revision++;
+        let copy = [];
+        try {
+            // The wire is JSON data; clone before validation so caller mutations cannot race ACK checks.
+            const copied = structuredClone(options);
+            if (Array.isArray(copied))
+                copy = copied;
+            const parsed = parse(copied);
+            this.parsed = parsed;
+            this.state = freeze({
+                configOptions: copy, models: parsed.model.values,
+                modelConfigId: parsed.model.id, model: parsed.model.currentValue,
+                ...(parsed.effort ? { effortConfigId: parsed.effort.id, effort: parsed.effort.currentValue } : {}),
+                effortAvailable: !!parsed.effort, confirmed: false,
+            });
+        }
+        catch (cause) {
+            const error = cause instanceof ModelConfigurationError ? cause : new ModelConfigurationError('配置数据无法复制或解析', { cause });
+            this.parsed = undefined;
+            this.state = freeze({ configOptions: copy, models: [], effortAvailable: false, confirmed: false, failure: { code: error.code, message: error.message } });
+            throw error;
+        }
+    }
+    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;
+        let response;
+        try {
+            response = await this.rpcSet(id, value);
+        }
+        catch (cause) {
+            throw new ModelConfigurationError(`${stage}配置请求失败，未获得远端确认`, { cause });
+        }
+        if (revision !== this.revision)
+            unavailable(`${stage}配置请求期间收到其他配置更新，无法确认回执顺序`);
+        if (!record(response) || !Array.isArray(response.configOptions))
+            unavailable(`${stage}配置回执缺少完整配置列表`);
+        this.update(response.configOptions);
+        return this.revision;
+    }
+    async select(model, effort) {
+        if (this.busy)
+            throw new ModelConfigurationError('另一个配置选择尚未完成');
+        this.busy = true;
+        this.state = freeze({ ...this.state, confirmed: false });
+        try {
+            if (!this.parsed)
+                unavailable('当前远端配置列表无效');
+            if (!this.parsed.model.values.some(entry => entry.value === model))
+                unavailable('所选模型不在实际远端列表中');
+            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))
+                    unavailable('所选推理等级不在模型回执的实际列表中');
+                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 });
+            return this.state;
+        }
+        catch (cause) {
+            const error = cause instanceof ModelConfigurationError ? cause : new ModelConfigurationError('配置选择未能完成核对', { cause });
+            this.fail(error);
+            throw error;
+        }
+        finally {
+            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/presentation.d.ts

@@ -3,4 +3,4 @@ export declare const REMOTE_CODEX_NAME = "Codex\uFF08\u8FDC\u7A0B\u4E3B\u673A\uF
 export declare const CONNECTION_REQUIRED = "\u8FDC\u7A0B\u4E3B\u673A\u8FDE\u63A5\u7EC4\u4EF6\u6CA1\u6709\u88C5\u597D\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u3002";
 export declare const TEST_HOST_NOTICE = "\u8FDC\u7A0B\u4E3B\u673A\u6B63\u5728\u4F7F\u7528\u6D4B\u8BD5\u914D\u7F6E\uFF0C\u9047\u5230\u95EE\u9898\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u3002";
 /** Employee failures use business language; diagnostic codes remain separately available. */
-export declare function employeeFailure(code: string): string;
+export declare function employeeFailure(code: string, brand?: 'codex' | 'claude'): string;

package/dist/presentation.js

@@ -3,11 +3,19 @@ export const REMOTE_CODEX_NAME = 'Codex（远程主机）';
 export const CONNECTION_REQUIRED = '远程主机连接组件没有装好，请联系管理员。';
 export const TEST_HOST_NOTICE = '远程主机正在使用测试配置，遇到问题请联系管理员。';
 /** Employee failures use business language; diagnostic codes remain separately available. */
-export function employeeFailure(code) {
+export function employeeFailure(code, brand = 'codex') {
     const messages = {
+        LOCAL_USER_TURN_CHANGED: '本次输入已变化，本轮已停止，请确认对话后重新发送。',
+        LOCAL_USER_TURN_UNCONFIRMED: '无法核对本次员工输入，本轮已停止；请在当前会话重新发送。',
+        LOCAL_USER_TURN_ACCEPTANCE_INVALID: '本次输入的核验回执不一致，本轮已停止，请联系管理员。',
         TECHNICAL_DETAILS_UNAVAILABLE: '技术详情暂不可用，请更新远程主机连接组件。',
         REMOTE_DETAIL_STORAGE_FAILED: '技术详情保存失败，本轮已停止，请联系管理员检查。',
         REMOTE_DETAIL_DELIVERY_UNKNOWN: '技术详情的持久结果无法核对，本轮已停止。',
+        REMOTE_DETAIL_SCOPE_INVALID: '无法核对当前会话的技术详情，本轮已停止；我需要更新后的远程主机连接组件。',
+        EMPLOYEE_CONTEXT_UNAVAILABLE: '我需要远程主机连接组件提供当前本机工作区，本轮未执行。',
+        EMPLOYEE_ENDPOINT_UNAVAILABLE: '我需要员工电脑的执行连接就绪，本轮未执行；请联系管理员检查连接组件。',
+        EMPLOYEE_CONTEXT_CHANGED: '本机文件夹或连接已改变，原工具已停止；请在当前工作区重新开始。',
+        EMPLOYEE_WORKSPACE_INVALID: '无法核对这条对话所属的本机文件夹，本轮未执行；请在工作区中重新打开对话。',
         REMOTE_DETAIL_TOO_LARGE: '技术详情超过已配置的单事件容量，本轮已停止；请联系管理员调整conversationDetails.maxEventBytes。',
         DEPENDENCY_REQUIRED: CONNECTION_REQUIRED,
         LOGIN_REQUIRED: '需要登录，请到设置 → 远程主机连接 点登录',
@@ -33,6 +41,12 @@ export function employeeFailure(code) {
         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: '我需要官方附件组件读取这张图片，请联系管理员检查组件。',
@@ -40,6 +54,40 @@ export function employeeFailure(code) {
         ACP_MESSAGE_TOO_LARGE: '本轮输入超过会话消息容量，未截断或发送；请联系管理员调整acpMaxMessageBytes。',
         ACP_CLIENT_LOST: '我需要管理员核对并结束遗留的主机会话；当前保留原进程，没有代答旧审批。',
         ONESHOT_CONTEXT_REQUIRED: '首版单次模式不支持图片或系统与开发者上下文，请改用会话模式。',
+        MODEL_CONFIGURATION_UNSUPPORTED: '单次模式不支持确认当前模型与推理等级，本轮未发送；请改用会话模式。',
+        MODEL_SELECTION_REQUIRED: '旧远端恢复记录没有明确模型选择，本轮未发送；请新建会话并选择模型。',
+        MODEL_RESOLUTION_UNCONFIRMED: '所选模型的具体型号尚未获得当前会话确认，本轮未发送；请重新选择模型或联系管理员。',
+        REMOTE_CLEANUP_UNCONFIRMED: '原主机会话的清理结果尚未确认，已阻断继续发送；请联系管理员核对，不能自动重开。',
     };
-    return messages[code] ?? `远程主机暂时无法完成这次操作，请联系管理员。技术详情：诊断代码 ${code}`;
+    if (messages[code])
+        return messages[code];
+    if (code === 'EMPLOYEE_OPERATION_UNSUPPORTED')
+        return '当前本机工作区暂不支持单次运行和断开后的冷恢复；请使用会话模式新建会话，原记录保留可查。';
+    if (code === 'AW_EMPLOYEE_COLD_RESUME_UNSUPPORTED' || code === 'EMPLOYEE_RECOVERY_UNSUPPORTED')
+        return '当前版本暂不支持恢复已关闭的本机执行会话；请新建会话，原记录保留可查。';
+    if (code === 'AW_EMPLOYEE_HOST_AUXILIARY_CONFIG_UNSUPPORTED')
+        return '当前主机启用的MCP、hooks或插件尚未支持改到员工电脑，本轮没有执行，请联系管理员。';
+    if (code === 'AW_EMPLOYEE_HOST_PROJECT_CONFIG_UNSUPPORTED')
+        return '主机上存在与本机工作区路径重合的项目配置，当前版本无法安全应用，本轮没有执行，请联系管理员。';
+    if (code === 'AW_EMPLOYEE_EXECUTOR_MCP_UNSUPPORTED')
+        return '本机工作区配置了附加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工具改到员工电脑，本轮没有执行。';
+    if (code === 'AW_EMPLOYEE_HOST_AUXILIARY_UNSUPPORTED')
+        return '这项辅助操作尚未支持在员工电脑执行，本轮没有执行。';
+    if (code === 'AW_EMPLOYEE_SLASH_COMMAND_UNSUPPORTED')
+        return '这项快捷命令暂不支持本机执行，请直接描述任务。';
+    if (code === 'AW_EMPLOYEE_HOST_FILE_REPORT_UNSUPPORTED')
+        return '这项文件报告暂不支持本机工作区；请查看对话和技术详情中的已有执行记录。';
+    if (code === 'AW_EMPLOYEE_CONFIG_DISCOVERY_OVERRIDE_UNSUPPORTED')
+        return '当前助手的项目配置覆盖与本机执行不兼容，本轮没有执行，请联系管理员。';
+    if (code === 'EMPLOYEE_PLATFORM_UNSUPPORTED')
+        return brand === 'claude' ? '本机执行目前只支持Mac；当前设备尚不支持，本轮未执行。' : '当前版本的Codex本机执行仅验证了Apple芯片Mac，本轮没有执行。';
+    if (code.startsWith('AW_EMPLOYEE_BINARY_'))
+        return 'Codex本机执行组件缺失或校验失败，本轮没有执行，请联系管理员。';
+    if (code.startsWith('AW_EMPLOYEE_') || code.startsWith('EMPLOYEE_'))
+        return '员工电脑的执行连接不可用或工作区已变化，本轮已停止；在途操作结果尚待确认，请查看技术详情。';
+    return `远程主机暂时无法完成这次操作，请联系管理员。技术详情：诊断代码 ${code}`;
 }

package/dist/protocol-boundary.d.ts

@@ -0,0 +1,13 @@
+/** Byte fragments remain only in memory. A cursor is clean only after SDK consumption. */
+export declare class ProtocolBoundary {
+    private readonly maxBytes;
+    private partial;
+    private pending;
+    private requests;
+    constructor(maxBytes: number);
+    receive(bytes: Uint8Array, gate?: (message: Record<string, unknown>) => void): void;
+    consumed(message: Record<string, unknown>): void;
+    responded(id: unknown): void;
+    get complete(): boolean;
+    get wholeLine(): boolean;
+}

package/dist/protocol-boundary.js

@@ -0,0 +1,49 @@
+import { createHash } from 'node:crypto';
+import { NeedError } from "./remote.js";
+const fingerprint = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+/** Byte fragments remain only in memory. A cursor is clean only after SDK consumption. */
+export class ProtocolBoundary {
+    maxBytes;
+    partial = Buffer.alloc(0);
+    pending = [];
+    requests = new Set();
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+    }
+    receive(bytes, gate) {
+        this.partial = Buffer.concat([this.partial, bytes]);
+        let end;
+        while ((end = this.partial.indexOf(10)) >= 0) {
+            if (end > this.maxBytes)
+                throw new NeedError('ACP_MESSAGE_TOO_LARGE', '主机消息超过具名会话容量', 'acpMaxMessageBytes');
+            const line = this.partial.subarray(0, end).toString('utf8').trim();
+            this.partial = this.partial.subarray(end + 1);
+            if (!line)
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                throw new NeedError('ACP_OUTPUT_INVALID', '主机消息不是有效JSON', '完整ACP消息');
+            }
+            if (!message || typeof message !== 'object' || Array.isArray(message))
+                throw new NeedError('ACP_OUTPUT_INVALID', '主机消息结构无效', '完整ACP消息');
+            if (gate)
+                gate(message);
+            else
+                this.pending.push(fingerprint(message));
+        }
+        if (this.partial.length > this.maxBytes)
+            throw new NeedError('ACP_MESSAGE_TOO_LARGE', '主机消息超过具名会话容量', 'acpMaxMessageBytes');
+    }
+    consumed(message) {
+        if (this.pending.shift() !== fingerprint(message))
+            throw new NeedError('ACP_BOUNDARY_UNCONFIRMED', '主机消息处理位置无法确认', '完整按序的ACP消息');
+        if (typeof message.method === 'string' && Object.hasOwn(message, 'id'))
+            this.requests.add(JSON.stringify(message.id));
+    }
+    responded(id) { this.requests.delete(JSON.stringify(id)); }
+    get complete() { return this.partial.length === 0 && this.pending.length === 0 && this.requests.size === 0; }
+    get wholeLine() { return this.partial.length === 0; }
+}

package/dist/provider.d.ts

@@ -9,9 +9,25 @@ import { type AgentDefinition } from './agents.ts';
 import type { NativeWorkspaceApi, SessionProjectTarget, WorkspaceNotice, 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 { LocalUserTurnAcceptance } from '@ai-workbench/connect/api';
+import type { EmployeeRouting } from './employee-relay.ts';
+export interface EmployeeExecution {
+    hostCwd: string;
+    routing: EmployeeRouting;
+    notice: string;
+    scope: Record<string, unknown>;
+    signal?: AbortSignal;
+    beginTurn(signal: AbortSignal): Promise<void>;
+    endTurn(): void;
+    validate(signal?: AbortSignal): Promise<void>;
+}
 export interface Runtime {
     identity: string;
     cwd: string;
+    execution?: EmployeeExecution;
     acpTransport?: {
         writable: WritableStream<Uint8Array>;
         readable: ReadableStream<Uint8Array>;
@@ -28,12 +44,43 @@ export interface Runtime {
     connection?: ConnectionState;
     workspaceNotice?: WorkspaceNoticePresentation;
     details?: DetailChannel;
+    recoveredSession?: AcpRecovery;
+    restartNotice?: string;
+    detach?: () => Promise<void>;
+    restartInputIds?: readonly string[];
+    saveCheckpoint?: (id: string, acp: AcpRecovery) => Promise<boolean>;
     detailContext?: () => {
         turn: string | number | null;
         step: string | number | null;
     };
+    employeeExecutionMeta?: {
+        version: 1;
+        bindingId: string;
+        workspaceId: string;
+        cwd: string;
+        acpMaxMessageBytes: number;
+    };
+    employeeExecution?: (params: unknown, signal?: AbortSignal) => Promise<Record<string, unknown>>;
+    employeePresentation?: string;
 }
 export interface RuntimeRequest extends Invocation {
+    userInputIds?: readonly string[];
+    localAcceptance?: Readonly<LocalUserTurnAcceptance>;
+    localAdmissionCheck?: () => void;
+    readonly localAcceptanceId?: string;
+    userMessageIds?: readonly string[];
+    recoveryJournal?: RecoveryJournal;
+    detailChannel?: DetailChannel;
+    validateContext?: (ignoreCancellation?: boolean) => Promise<void>;
+    verifyRecovery?: () => Promise<boolean>;
+    acpMaxMessageBytes?: number;
+    employeeScope?: string;
+    contextSha256?: string;
+    resumeSessionId?: string;
+    recoveryCheckpointId?: string;
+    bindingRevision?: number;
+    currentInputIds?: readonly string[];
+    timing?: StageTiming;
     mode: 'session' | 'one-shot';
     cwd?: string;
     identity?: string;
@@ -88,7 +135,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, 'onConnectionState' | 'onLoginPromptState' | 'appendRemoteConversationDetail' | 'getRemoteConversationDetailReceipt' | 'listRemoteConversationDetails'>> {
+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'>> {
     getState?(): ConnectState;
     getSshTarget(): Promise<Result<ConnectTarget>>;
     checkLogin(provider: LoginProvider): Promise<Result<{
@@ -112,7 +159,7 @@ export declare function requireLoginCoordinator(api: ConnectApi): void;
 export declare function requireLoginState(state: LoginPromptState): void;
 declare module '@deepseek-ai/cordis' {
     interface Context {
-        aiWorkbenchConnect: ConnectApi;
+        aiWorkbenchConnect: LConnectApi;
     }
     interface Events {
         'ai-workbench/connection-state': (state: ConnectionState) => void;
@@ -134,11 +181,16 @@ 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>;
+};
 export declare function sameTarget(a: ConnectTarget, b: ConnectTarget): boolean;
 export declare function connectProvider(get: () => ConnectApi | undefined, options?: {
     agent?: AgentDefinition;
     ask?: Interaction;
     notice?: NoticeConsumer;
+    employee?: EmployeeProviderOptions;
+    local?: LocalRuntimeProvider;
     details?: (request: RuntimeRequest, api: ConnectApi, connection: ConnectionState, target: ConnectTarget) => Promise<DetailChannel>;
     open?: (target: ConnectTarget, project: Project, request: RuntimeRequest) => Promise<Runtime>;
 }): RuntimeProvider;

package/dist/provider.js

@@ -2,6 +2,7 @@ import { loginDiagnostic, loginReason } from "./login-diagnostic.js";
 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";
 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');
@@ -153,8 +154,12 @@ export function sameTarget(a, b) {
 }
 export function connectProvider(get, options = {}) {
     const agent = options.agent ?? CODEX_AGENT;
+    // Keep the legacy source SDK wrapper's strip-only import graph free of broker runtime syntax.
+    // Cache the initialization promise so concurrent sessions share this provider's binding lifetimes.
+    let employee;
     const admissions = new WeakMap();
     const preflight = async (request) => {
+        request.timing ??= new StageTiming();
         request.signal?.throwIfAborted();
         const api = get();
         if (!api)
@@ -163,16 +168,28 @@ export function connectProvider(get, options = {}) {
         requireLoginCoordinator(api);
         if (request.mode === 'one-shot' && !agent.oneShot)
             throw new NeedError('MODE_UNSUPPORTED', '此远程模型仅支持会话模式', '使用会话模式');
-        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);
+        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 () => {
+            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);
     };
     const resolve = async (request) => {
         if (!admissions.has(request))
@@ -180,13 +197,34 @@ export function connectProvider(get, options = {}) {
         const admitted = admissions.get(request);
         admissions.delete(request);
         const { api, target, connection } = admitted;
-        const stable = () => waitForLogin(api, agent.loginProvider, connection, get, request.signal);
+        const stable = () => request.timing.run('connection-confirm', () => waitForLogin(api, agent.loginProvider, connection, get, request.signal));
         await stable();
         if (!request.sessionId)
             throw new NeedError('PROJECT_BINDING_REQUIRED', '我需要当前会话和已选择的工作区，请使用原生工作区入口', 'DSH会话与原生工作区');
+        if (options.employee) {
+            employee ??= import("./employee-provider.js").then(module => module.createEmployeeProvider(get, options, agent));
+            const local = await (await employee)({ api, target, connection, request, stable: signal => request.timing.run('connection-confirm', () => waitForLogin(api, agent.loginProvider, connection, get, signal)) });
+            if (local) {
+                local.loginRequired = () => offerLogin(api, request, get, agent);
+                return local;
+            }
+        }
+        if (agent.loginProvider === 'claude' && options.local) {
+            const runtime = await options.local(request, api, connection, target);
+            if (runtime) {
+                try {
+                    await stable();
+                }
+                catch (error) {
+                    await runtime.dispose?.();
+                    throw error;
+                }
+                return runtime;
+            }
+        }
         await options.notice?.reconcile(request, api);
         await stable();
-        const resolved = unwrap(await awaitL(() => api.resolveSessionProject(request.sessionId, { provider: agent.loginProvider, purpose: 'user-turn' }), request.signal));
+        const resolved = await request.timing.run('workspace-resolve', async () => unwrap(await awaitL(() => api.resolveSessionProject(request.sessionId, { provider: agent.loginProvider, purpose: 'user-turn' }), request.signal)));
         await stable();
         if (!resolved || resolved.instanceId !== connection.instanceId || resolved.epoch !== connection.epoch)
             throw new NeedError('CONNECTION_LOST', '工作区解析回复已失效', '当前连接代次');
@@ -196,32 +234,57 @@ export function connectProvider(get, options = {}) {
             throw new NeedError('PROJECT_BINDING_INVALID', '工作区绑定与当前会话或可信主机不一致', 'L核验的原生工作区绑定');
         if (request.cwd && request.cwd !== project.path || request.bindingId && request.bindingId !== resolved.bindingId || request.workspaceId && request.workspaceId !== resolved.workspaceId)
             throw new NeedError('SESSION_CONTEXT_MISMATCH', '原会话的工作区绑定已改变，请新建会话', '原工作区绑定');
-        const details = await options.details?.(request, api, connection, target);
-        await stable();
-        let workspaceNotice = undefined;
-        if (resolved.notice) {
-            if (!options.notice)
-                throw new NeedError('DEPENDENCY_REQUIRED', '我需要官方会话持久记录来确认工作区说明', '官方会话与持久化服务');
-            workspaceNotice = await options.notice.deliver(resolved.notice, resolved, request, api);
-            await stable();
-        }
-        if (!options.open)
-            throw new NeedError('RUNTIME_REQUIRED', '我需要主机运行适配器', '主机broker适配');
-        const runtime = await options.open(resolved.target, project, { ...request, agent });
+        const details = await request.timing.run('details-open', async () => options.details?.(request, api, connection, target));
         try {
+            if (details)
+                request.timing.bind(detail => details.record(detail));
             await stable();
+            let workspaceNotice = undefined;
+            if (resolved.notice) {
+                if (!options.notice)
+                    throw new NeedError('DEPENDENCY_REQUIRED', '我需要官方会话持久记录来确认工作区说明', '官方会话与持久化服务');
+                workspaceNotice = await request.timing.run('workspace-notice', () => options.notice.deliver(resolved.notice, resolved, request, api));
+                await stable();
+            }
+            if (!options.open)
+                throw new NeedError('RUNTIME_REQUIRED', '我需要主机运行适配器', '主机broker适配');
+            const observedBinding = api.getWorkspaceBindingState?.();
+            const validateContext = async (ignoreCancellation = false) => {
+                const check = () => waitForLogin(api, agent.loginProvider, connection, get, ignoreCancellation ? undefined : request.signal);
+                await check();
+                if (observedBinding) {
+                    const current = api.getWorkspaceBindingState();
+                    if (current.instanceId !== observedBinding.instanceId || !current.items.some(item => item.bindingId === resolved.bindingId && item.workspaceId === resolved.workspaceId && item.status === 'ready'))
+                        throw new NeedError('SESSION_CONTEXT_MISMATCH', '当前工作区绑定已改变，原会话操作未执行', '原生会话原绑定');
+                }
+                await check();
+            };
+            const runtime = await options.open(resolved.target, project, { ...request, agent, bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, bindingRevision: resolved.bindingRevision, detailChannel: details, validateContext });
+            try {
+                await stable();
+            }
+            catch (error) {
+                await runtime.dispose?.();
+                throw error;
+            }
+            // The transport can outlive a turn; presentation belongs only to this invocation.
+            runtime.workspaceNotice = workspaceNotice || undefined;
+            runtime.details = details ?? runtime.details;
+            runtime.binding = { bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, revision: resolved.bindingRevision };
+            runtime.connection = { ...connection };
+            runtime.loginRequired = () => offerLogin(api, request, get, agent);
+            return runtime;
         }
         catch (error) {
-            await runtime.dispose?.();
+            try {
+                await details?.flush();
+            }
+            catch (diagnostic) {
+                const code = (value) => value instanceof NeedError && /^[A-Z][A-Z0-9_]*$/.test(value.code) ? value.code : 'UNKNOWN_FAILURE';
+                throw new NeedError('CONVERSATION_DETAILS_FAILED', '技术详情未能保存；本轮已停止', `原错误代码 ${code(error)}；诊断错误代码 ${code(diagnostic)}`);
+            }
             throw error;
         }
-        // The transport can outlive a turn; presentation belongs only to this invocation.
-        runtime.workspaceNotice = workspaceNotice || undefined;
-        runtime.details = details ?? runtime.details;
-        runtime.binding = { bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, revision: resolved.bindingRevision };
-        runtime.connection = { ...connection };
-        runtime.loginRequired = () => offerLogin(api, request, get, agent);
-        return runtime;
     };
     resolve.preflight = preflight;
     return resolve;

package/dist/readiness.js

@@ -46,7 +46,7 @@ function details(target) {
     return [{ label: '主机配置', value: h.enforcement }, { label: '检查退出码', value: String(h.checkExitCode) }, ...h.failedChecks.map(item => ({ label: '未通过检查', value: `${item.id}（${item.status}）` })), ...h.unverifiedChecks.map(item => ({ label: '未核实检查', value: `${item.id}（${item.status}）` }))];
 }
 function blocked(code, technical = [], agent = CODEX_AGENT) {
-    return { phase: 'blocked', loginStatus: 'unknown', title: `无法确认 ${agent.name.zh} 登录状态`, message: employeeFailure(code), technical: [...technical, { label: '诊断代码', value: code }] };
+    return { phase: 'blocked', loginStatus: 'unknown', title: `无法确认 ${agent.name.zh} 登录状态`, message: employeeFailure(code, agent.loginProvider), technical: [...technical, { label: '诊断代码', value: code }] };
 }
 /** L owns both evidence and inquiry. Missing per-brand evidence is never false. */
 function snapshot(api, agent = CODEX_AGENT) {