@ai-workbench/remote-agent 0.8.27 → 0.8.28

package/README.md

@@ -1,4 +1,4 @@
-# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.27 · 插件 → 添加插件
+# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.28 · 插件 → 添加插件
 
 通过官方 DSH 插件入口使用 Claude（远程主机）与 Codex（远程主机）。登录和工作区来源由“远程主机连接”组件提供；员工在原生工作区和模型菜单中选择文件夹与型号。
 
@@ -14,7 +14,9 @@ Claude 本机 Bash 会单独消费员工桥代理的控制诊断，不把它交
 
 每轮启动一个新助手进程，按原生会话编号恢复上下文；不接回旧进程或重放上一轮输入。主机会话始终使用创建时保存的主机和目录；工作区之后的选择只影响新会话。
 
-断线会结束本轮；操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止下一轮。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
+同一 DSH 会话切换 Claude/Codex 时，切回会接本品牌最近的远端会话，并补充它尚未见过的可见对话；首次使用某品牌则带入全部可见历史。工具内部状态、推理和技术详情不转交。历史超出既有 `acpMaxMessageBytes` 容量时，只带能容纳的最近完整轮，并在技术详情说明省略数量；当前输入保持完整，超限仍明确失败。没有新增设置、重试或时限。
+
+断线会结束本轮；已派发的操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止发起下一轮；如果上一轮仍占用原生线程，续接会明确失败并说明本轮输入未发送，不新建替代线程。自动定位、清理同一会话/线程的已断开旧进程仍需 S 提供公开能力，当前不会自动杀旧进程或冒称已恢复。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
 
 DSH 启动和打开模型菜单时读取一次主机型号列表。发送时不再查询目录或预核所选型号；所选型号不可用时，请在模型菜单重新选择。
 

package/dist/acp.js

@@ -605,6 +605,8 @@ export function acpNeed(error) {
     if (error instanceof NeedError)
         return error;
     if (error instanceof acp.RequestError) {
+        if (record(error.data)?.reason === 'thread_active_writer')
+            return new NeedError('REMOTE_SESSION_BUSY', employeeFailure('REMOTE_SESSION_BUSY'), '原远端线程仍被占用；需要按同一DSH会话和远端线程定位已断开的旧broker并确认释放；RPC 错误码 ' + error.code);
         // Host SDK1.9 uses Internal error + data.details for thrown adapter errors.
         // Only fixed codes cross this boundary; arbitrary detail strings are never copied.
         for (const value of [error.message, record(error.data)?.details]) {

package/dist/index.js

@@ -12,7 +12,7 @@ import { StreamMapper } from "./mapping.js";
 import { connectProvider } from "./provider.js";
 import { brokerFactory } from "./broker.js";
 import { AGENTS, CODEX_AGENT } from "./agents.js";
-import { prepareInput, projectHostWorkspaceInput } from "./input.js";
+import { prepareInput, prepareContinuation } from "./input.js";
 import { NeedError } from "./remote.js";
 import { employeeFailure } from "./presentation.js";
 import { createRemoteDetails } from "./remote-details.js";
@@ -53,16 +53,16 @@ function modelResolutionLabel(configuration) {
         : `具体型号：${configuration.resolvedModel}`;
 }
 function readPointer(options, agent) {
-    const last = options.messages.findLast(message => message.role === 'assistant');
-    if (!last || last.role !== 'assistant')
-        return;
-    if (last.source.provider !== options.provider)
-        return;
-    const envelope = last.source.replayState;
-    const pointer = envelope?.response;
-    if (pointer?.version !== 2 || pointer.agent !== agent.id || pointer.dshSessionId !== options.sessionId || ![pointer.identity, pointer.cwd, pointer.sessionId].every(value => typeof value === 'string' && value.length > 0))
-        return;
-    return pointer;
+    for (let index = options.messages.length - 1; index >= 0; index--) {
+        const message = options.messages[index];
+        if (message.role !== 'assistant' || message.source.provider !== options.provider)
+            continue;
+        const envelope = message.source.replayState;
+        const pointer = envelope?.response;
+        if (pointer?.version !== 2 || pointer.agent !== agent.id || pointer.dshSessionId !== options.sessionId || ![pointer.identity, pointer.cwd, pointer.sessionId].every(value => typeof value === 'string' && value.length > 0) || pointer.contextSha256 !== undefined && typeof pointer.contextSha256 !== 'string')
+            continue;
+        return { pointer: pointer, index };
+    }
 }
 // A reporting failure can wrap the original admission error. Preserve its
 // already-safe login snapshot even when a newer preflight delivery is unknown.
@@ -197,16 +197,17 @@ export class CodexRemoteAdapter extends LlmAdapter {
             throw failure.reason;
     }
     async *stream(options) {
+        let promptDispatched = false;
         try {
-            yield* this.generate(options);
+            yield* this.generate(options, () => { promptDispatched = true; });
         }
         catch (error) {
             if (error instanceof ModelConfigurationError)
-                throw new LlmError(employeeFailure(error.code, this.agent.loginProvider), error.code, { cause: error });
+                throw new LlmError(employeeFailure(error.code, this.agent.loginProvider, promptDispatched), error.code, { cause: error });
             if (error instanceof NeedError) {
                 const rpc = /RPC 错误码 (-?\d+)/u.exec(error.requires)?.[1];
                 const evidence = failureEvidenceSummary(error);
-                const message = connectNeedMessage(error) ?? employeeFailure(error.code, this.agent.loginProvider);
+                const message = connectNeedMessage(error) ?? employeeFailure(error.code, this.agent.loginProvider, promptDispatched);
                 const login = originalLoginFailure(error);
                 let diagnostic = login?.technical ? JSON.stringify(login.technical) : '';
                 if (login?.technical && this.reportLoginFailure) {
@@ -220,10 +221,10 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 }
                 throw new LlmError(message, error.code, { cause: new Error(`诊断代码：${error.code}；${error.requires}` + (evidence ? '；' + evidence : '') + (diagnostic ? '；' + diagnostic : '')) });
             }
-            throw new LlmError(employeeFailure('TURN_FAILED', this.agent.loginProvider), 'TURN_FAILED', { cause: error });
+            throw new LlmError(employeeFailure('TURN_FAILED', this.agent.loginProvider, promptDispatched), 'TURN_FAILED', { cause: error });
         }
     }
-    async *generate(original) {
+    async *generate(original, onPromptDispatched) {
         if (original.purpose)
             throw new NeedError('PURPOSE_UNSUPPORTED', '此远程模型不处理后台标题或上下文整理请求，未发送模型请求', '独立的后台请求能力');
         if (this.lifetime.signal.aborted)
@@ -272,12 +273,10 @@ export class CodexRemoteAdapter extends LlmAdapter {
         try {
             if (!Number.isSafeInteger(config.acpMaxMessageBytes) || config.acpMaxMessageBytes < 1)
                 throw new NeedError('SETTINGS_REQUIRED', '远程模型连接设置无效，请联系管理员检查', '有效的acpMaxMessageBytes');
-            const previous = readPointer(options, this.agent);
+            const checkpoint = readPointer(options, this.agent), previous = checkpoint?.pointer;
             employeeNoticeShown = !!key && this.employeeNoticeSessions.has(key) || false;
             if (employeeNoticeShown && key)
                 this.employeeNoticeSessions.add(key);
-            const last = options.messages.findLast(message => message.role === 'assistant');
-            const missingPointer = !!last && !previous;
             live = undefined;
             const configuration = JSON.stringify([config.acpMaxMessageBytes, config.brokerMaxFrameBytes, config.brokerControlMaxBytes, config.employeeShellKillGraceMs]);
             Object.assign(request, { acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, sessionId: options.sessionId, mode, hostSource: previous?.hostSource, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) });
@@ -307,7 +306,6 @@ export class CodexRemoteAdapter extends LlmAdapter {
             // New Codex transport scopes are independent of the native context digest.
             if (contextChanged)
                 request.contextSha256 = undefined;
-            const claudeContextChanged = !!previous && !codex && previous.contextSha256 !== contextSha256;
             if (mode === 'session' && Buffer.byteLength(JSON.stringify({ prompt: input.prompt, systemPrompt: input.systemPrompt }), 'utf8') > config.acpMaxMessageBytes)
                 throw new NeedError('ACP_MESSAGE_TOO_LARGE', '本轮输入超过已设置的会话消息容量，未截断或发送', '管理员调整acpMaxMessageBytes');
             selected = this.modelPresentation.find(options.model) ?? { id: options.model, value: options.model, name: options.model, resolvedModel: null, reasoning: { options: [], defaultValue: null, defaultKnown: false }, source: null };
@@ -327,12 +325,14 @@ export class CodexRemoteAdapter extends LlmAdapter {
             }
             if (previous && !runtime.hostSource && (previous.identity !== runtime.identity || previous.cwd !== runtime.cwd || previous.bindingId && previous.bindingId !== runtime.binding?.bindingId || previous.workspaceId && previous.workspaceId !== runtime.binding?.workspaceId))
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '原会话的员工主机或工作区已改变，请新建会话', '原会话的可信目标和工作区');
-            input = projectHostWorkspaceInput(input, runtime.hostWorkspace);
+            input = await prepareContinuation({ ...options, messages: options.messages.slice((checkpoint?.index ?? -1) + 1) }, input, this.readImage, { maxBytes: config.acpMaxMessageBytes, host: runtime.hostWorkspace });
             if (runtime.hostWorkspace && mode === 'session' && Buffer.byteLength(JSON.stringify({ prompt: input.prompt, systemPrompt: input.systemPrompt }), 'utf8') > config.acpMaxMessageBytes)
                 throw new NeedError('ACP_MESSAGE_TOO_LARGE', '本轮输入超过已设置的会话消息容量，未截断或发送', '管理员调整acpMaxMessageBytes');
             const details = runtime.details ?? await createRemoteDetails({ warn: line => console.warn(line) }).open({ sessionId: options.sessionId ?? 'unscoped', provider: this.agent.loginProvider, identity: runtime.identity, connection: runtime.connection });
             recordInformation();
             request.recordEarlyFailure = undefined;
+            if (input.historyTransfer)
+                details.record({ kind: 'session', severity: input.historyTransfer.omittedRounds ? 'warning' : 'info', code: input.historyTransfer.omittedRounds ? 'HISTORY_TRANSFER_TRIMMED' : 'HISTORY_TRANSFER', summary: input.historyTransfer.omittedRounds ? `可见历史超过既有会话消息容量，保留最近${input.historyTransfer.retainedRounds}轮，省略较早${input.historyTransfer.omittedRounds}轮；当前输入完整保留。` : '已补充当前远端会话尚未见过的可见对话，未重放工具或审批。', payload: input.historyTransfer });
             if (runtime.hostWorkspace)
                 details.record({ kind: 'session', severity: 'info', code: 'HOST_WORKSPACE_CONTEXT', summary: '本轮模型工作区上下文及审批会话目录使用已确认的主机目录。', payload: { source: 'host', cwd: runtime.hostWorkspace.cwd } });
             const mapper = new StreamMapper(mode === 'session' && !contextChanged ? (previous ? (previous.usageSnapshot ?? null) : undefined) : undefined, observation => details.record(observation));
@@ -438,6 +438,12 @@ export class CodexRemoteAdapter extends LlmAdapter {
                     remoteAttempted = true;
                     try {
                         await session.start(runtime.execution?.hostCwd ?? runtime.cwd, previous?.sessionId, modelSignal, { systemPrompt: input.systemPrompt, ...(runtime.execution ? { employeeRouting: runtime.execution.routing } : {}), ...(codex ? { codexNewSessionOnly: true } : {}), ...(runtime.employeeExecutionMeta ? { employeeExecution: runtime.employeeExecutionMeta } : {}) }, input.prompt);
+                    }
+                    catch (error) {
+                        details.record({ kind: 'session', severity: 'action-required', code: 'SESSION_START_FAILED', summary: '远端会话建立或恢复失败，本轮用户输入未发送。', payload: { operation: previous ? 'resume-or-load' : 'new', reason: closeCode(error, 'ACP_FAILED'), promptDispatched: false } });
+                        throw error;
+                    }
+                    try {
                         const actual = await session.selectModel(selected.value, options.reasoningEffort, modelSignal);
                         // This lease is tied to the trusted host-user and instance/epoch.
                         // Its mapping and this turn's exact setter ACK are different facts.
@@ -532,6 +538,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
             yield { type: 'finish', reason: { kind: stop === 'max_tokens' || stop === 'max_turn_requests' ? 'max-tokens' : 'stop' }, replayState: { response: pointer } };
         }
         catch (error) {
+            if (session && session.promptDispatchCount > promptBaseline)
+                onPromptDispatched();
             turnFailure = error;
             runtime?.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.turn-failure', reason: closeCode(error, signal.aborted ? 'ABORTED' : 'TURN_FAILED'), action: 'failure' });
             recordInformation();

package/dist/input.d.ts

@@ -11,6 +11,9 @@ export interface HistoryTransfer {
     offloadedImagePlaceholders: number;
     omittedReasoningBlocks: number;
     reasoningOmissionReason: 'dsh-internal-reasoning';
+    retainedRounds: number;
+    omittedRounds: number;
+    maxBytes: number;
 }
 export interface HostWorkspacePresentation {
     readonly cwd: string;
@@ -32,7 +35,10 @@ export interface PreparedInput {
 /** Invocation-only model context; never modifies the native session/history. */
 export declare function projectHostWorkspaceInput(input: PreparedInput, host?: HostWorkspacePresentation): PreparedInput;
 /** Role-labelled public history only; never serialize source/replay/tool internals. */
-export declare function prepareContinuation(options: GenerateOptions, input: PreparedInput, readImage?: ImageReader): Promise<PreparedInput>;
+export declare function prepareContinuation(options: GenerateOptions, input: PreparedInput, readImage: ImageReader | undefined, capacity: {
+    maxBytes: number;
+    host?: HostWorkspacePresentation;
+}): Promise<PreparedInput>;
 /** The attachment service supplies verified bytes; client paths never cross SSH. */
 export declare function prepareInput(options: GenerateOptions, readImage?: ImageReader): Promise<PreparedInput>;
 export {};

package/dist/input.js

@@ -50,45 +50,64 @@ async function publicBlock(block, options, readImage, history = false) {
     throw new NeedError(history ? 'HISTORY_CONTENT_UNSUPPORTED' : 'INPUT_TYPE_REQUIRED', `我需要此${history ? '历史' : '输入'}类型的远程转接能力：${block.type}；本轮未新建或发送`, '对应类型的公开ACP输入映射；内部推理及工具记录不可降为用户要求');
 }
 /** Role-labelled public history only; never serialize source/replay/tool internals. */
-export async function prepareContinuation(options, input, readImage) {
-    const messages = options.messages;
-    for (const message of messages)
-        if (!['user', 'assistant', 'system', 'developer'].includes(message.role))
-            throw new NeedError('HISTORY_CONTENT_UNSUPPORTED', `此前含有无法可靠承接的历史角色：${message.role}；本轮未新建或发送`, '完整公开的用户及助手历史；工具记录的公开内容映射');
-    const after = messages.findLastIndex(message => message.role === 'assistant');
-    const prompt = [];
-    const runtimeSnapshots = new Map(input.runtimeSnapshots);
-    const historyTransfer = { scope: 'visible-user-assistant-text-and-images', textBlocks: 0, imageBlocks: 0, offloadedImagePlaceholders: 0, omittedReasoningBlocks: 0, reasoningOmissionReason: 'dsh-internal-reasoning' };
-    for (const message of messages.slice(0, after + 1)) {
-        if (message.role === 'system' || message.role === 'developer')
+export async function prepareContinuation(options, input, readImage, capacity) {
+    const after = options.messages.findLastIndex(message => message.role === 'assistant');
+    const groups = [];
+    for (const message of options.messages.slice(0, after + 1)) {
+        // Runtime snapshots, approval answers and tool state are not employee-visible
+        // conversation. Current runtime/system context stays on its original path.
+        if (message.role !== 'assistant' && (message.role !== 'user' || message.source?.kind !== 'user'))
             continue;
-        if (message.role !== 'user' && message.role !== 'assistant')
-            throw new NeedError('HISTORY_CONTENT_UNSUPPORTED', `此前含有无法可靠承接的历史角色：${message.role}；本轮未新建或发送`, '完整公开的用户及助手历史；工具记录的公开内容映射');
-        prompt.push({ type: 'text', text: `此前可见对话（历史角色：${message.role}；仅为历史记录）：\n` });
-        const sections = runtimeSections(message);
-        for (const block of message.content) {
-            // DSH explicitly distinguishes internal thinking from visible user text.
-            if (block.type === 'reasoning') {
-                historyTransfer.omittedReasoningBlocks++;
-                continue;
-            }
-            const prepared = await publicBlock(block, options, readImage, true);
-            prompt.push(prepared);
-            if (sections)
-                runtimeSnapshots.set(prepared, sections);
-            if (block.type === 'text')
-                historyTransfer.textBlocks++;
-            else if (block.type === 'image') {
-                if (block.offloaded)
-                    historyTransfer.offloadedImagePlaceholders++;
+        if (!message.content.some(block => block.type === 'text' || block.type === 'image'))
+            continue;
+        if (message.role === 'user' || !groups.length)
+            groups.push([]);
+        groups.at(-1).push(message);
+    }
+    const base = projectHostWorkspaceInput(input, capacity.host);
+    if (!groups.length)
+        return base;
+    const historyTransfer = { scope: 'visible-user-assistant-text-and-images', textBlocks: 0, imageBlocks: 0, offloadedImagePlaceholders: 0, omittedReasoningBlocks: 0, reasoningOmissionReason: 'dsh-internal-reasoning', retainedRounds: 0, omittedRounds: groups.length, maxBytes: capacity.maxBytes };
+    const separator = { type: 'text', text: '此前可见对话结束。以下为当前用户输入：\n' };
+    const retained = [];
+    // prepareInput guarantees a nonempty current prompt. Each inserted block adds
+    // its JSON bytes and one comma; count each round once, not the whole prefix.
+    let bytes = Buffer.byteLength(JSON.stringify({ prompt: base.prompt, systemPrompt: base.systemPrompt }), 'utf8') + Buffer.byteLength(JSON.stringify(separator), 'utf8') + 1;
+    // Whole consecutive rounds, newest first. The existing byte capacity is the
+    // only bound; N is computed from actual encoded text/image sizes, not a cap.
+    for (const group of groups.toReversed()) {
+        const blocks = [], counts = { textBlocks: 0, imageBlocks: 0, offloadedImagePlaceholders: 0, omittedReasoningBlocks: 0 };
+        for (const message of group) {
+            options.signal?.throwIfAborted();
+            blocks.push({ type: 'text', text: `此前可见对话（历史角色：${message.role}；仅为历史记录）：\n` });
+            for (const block of message.content) {
+                if (block.type === 'reasoning') {
+                    counts.omittedReasoningBlocks++;
+                    continue;
+                }
+                if (block.type !== 'text' && block.type !== 'image')
+                    continue;
+                blocks.push(await publicBlock(block, options, readImage, true));
+                if (block.type === 'text')
+                    counts.textBlocks++;
+                else if (block.offloaded)
+                    counts.offloadedImagePlaceholders++;
                 else
-                    historyTransfer.imageBlocks++;
+                    counts.imageBlocks++;
             }
+            blocks.push({ type: 'text', text: `\n（历史角色：${message.role} 的记录结束）\n` });
         }
-        prompt.push({ type: 'text', text: `\n（历史角色：${message.role} 的记录结束）\n` });
+        const additional = Buffer.byteLength(JSON.stringify(blocks), 'utf8') - 1; // Strip [] and add the comma before the retained suffix.
+        if (bytes + additional > capacity.maxBytes)
+            break;
+        bytes += additional;
+        retained.push(blocks);
+        historyTransfer.retainedRounds++;
+        historyTransfer.omittedRounds--;
+        for (const key of ['textBlocks', 'imageBlocks', 'offloadedImagePlaceholders', 'omittedReasoningBlocks'])
+            historyTransfer[key] += counts[key];
     }
-    prompt.push({ type: 'text', text: '此前可见对话结束。以下为当前用户输入：\n' }, ...input.prompt);
-    return { ...input, prompt, historyTransfer, runtimeSnapshots };
+    return { ...base, prompt: retained.length ? [...retained.toReversed().flat(), separator, ...base.prompt] : base.prompt, historyTransfer };
 }
 /** The attachment service supplies verified bytes; client paths never cross SSH. */
 export async function prepareInput(options, readImage) {

package/dist/presentation.d.ts

@@ -2,4 +2,4 @@
 export declare const REMOTE_CODEX_NAME = "Codex\uFF08\u8FDC\u7A0B\u4E3B\u673A\uFF09";
 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";
 /** Employee failures use business language; diagnostic codes remain separately available. */
-export declare function employeeFailure(code: string, brand?: 'codex' | 'claude'): string;
+export declare function employeeFailure(code: string, brand?: 'codex' | 'claude', promptDispatched?: boolean): string;

package/dist/presentation.js

@@ -2,7 +2,7 @@
 export const REMOTE_CODEX_NAME = 'Codex（远程主机）';
 export const CONNECTION_REQUIRED = '远程主机连接组件没有装好，请联系管理员。';
 /** Employee failures use business language; diagnostic codes remain separately available. */
-export function employeeFailure(code, brand = 'codex') {
+export function employeeFailure(code, brand = 'codex', promptDispatched = true) {
     const messages = {
         PERMISSION_POLICY_REQUIRED: '我需要读取这条对话的权限设置，目前没有读到；本轮未执行，你的原话仍保留。',
         PERMISSION_MODE_UNSUPPORTED: '这个权限档位还没有对应的远程执行能力；我需要主机连接组件支持该档位，本轮未执行，你的原话仍保留。',
@@ -23,7 +23,7 @@ export function employeeFailure(code, brand = 'codex') {
         EMPLOYEE_CONTEXT_CHANGED: '本机文件夹或连接已变化，本轮已停止；恢复后可在原会话继续。',
         EMPLOYEE_WORKSPACE_INVALID: '无法核对这条对话所属的本机文件夹，本轮未执行；请在工作区中重新打开对话。',
         DEPENDENCY_REQUIRED: CONNECTION_REQUIRED,
-        MODEL_CATALOG_UNAVAILABLE: '所选型号暂时不可用，请打开模型菜单重新选择后再发送。',
+        MODEL_CATALOG_UNAVAILABLE: '所选型号暂时不可用，请打开模型菜单重新选择后再发送。' + (!promptDispatched ? ' 本轮输入未发送。' : ''),
         LOGIN_REQUIRED: '需要登录，请到设置 → 远程主机连接 点登录',
         LOGIN_COMPLETED: '登录已完成，请重新发送本轮内容。',
         LOGIN_FAILED: '登录未完成，请到设置 → 远程主机连接 点登录；如仍有问题，请联系管理员。',
@@ -41,7 +41,8 @@ export function employeeFailure(code, brand = 'codex') {
         HOST_TRUST_REQUIRED: '远程主机连接信息还未准备好，请联系管理员。',
         POLICY_DENIED: '这个账号暂时不能使用，请联系公司账号管理员。',
         SESSION_CONTEXT_MISMATCH: '远程主机连接已改变，请重新开始本次检查。',
-        ABORTED: '本轮已停止。操作可能已部分执行，请先确认文件；恢复连接后可在原会话继续。',
+        REMOTE_SESSION_BUSY: '原会话仍被主机上的上一轮占用，' + (promptDispatched ? '本轮请求未能完成' : '本轮输入未发送') + '；请稍后在原会话重新发送。若持续占用，请联系管理员检查上一轮主机会话。',
+        ABORTED: promptDispatched ? '本轮已停止。操作可能已部分执行，请先确认文件；恢复连接后可在原会话继续。' : '本轮已停止，本轮输入未发送；恢复连接后可在原会话重新发送。',
         CONFIRMATION_REQUIRED: '请先选择是否打开授权窗口。',
         CONTEXT_UNSUPPORTED: '远程 Codex 暂不支持这类会话内容，请联系管理员。',
         CONTENT_UNSUPPORTED: '远程 Codex 暂不支持这类附件，请联系管理员。',
@@ -79,6 +80,6 @@ export function employeeFailure(code, brand = 'codex') {
     if (code === 'AW_EMPLOYEE_BINARY_MISSING')
         return '本机执行组件没有装齐，本轮没有执行，请重新安装插件。';
     if (code.startsWith('AW_EMPLOYEE_') || code.startsWith('EMPLOYEE_'))
-        return '你电脑上的执行连接已中断，本轮已停止；操作可能已部分执行，请先确认文件，恢复后可在原会话继续。';
-    return '本轮没有完成。请检查连接，恢复后可在原会话继续；操作可能已部分执行，请先确认文件。';
+        return promptDispatched ? '你电脑上的执行连接已中断，本轮已停止；操作可能已部分执行，请先确认文件，恢复后可在原会话继续。' : '你电脑上的执行连接尚未就绪，本轮输入未发送；请检查连接，恢复后可在原会话重新发送。';
+    return promptDispatched ? '本轮没有完成。请检查连接，恢复后可在原会话继续；操作可能已部分执行，请先确认文件。' : '本轮输入未发送。请检查连接，恢复后可在原会话继续。';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.27",
+  "version": "0.8.28",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",