@ai-workbench/remote-agent 0.8.26 → 0.8.28

package/README.md

@@ -1,4 +1,4 @@
-# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.26 · 插件 → 添加插件
+# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.28 · 插件 → 添加插件
 
 通过官方 DSH 插件入口使用 Claude（远程主机）与 Codex（远程主机）。登录和工作区来源由“远程主机连接”组件提供；员工在原生工作区和模型菜单中选择文件夹与型号。
 
@@ -8,11 +8,15 @@
 
 Claude 本机 Bash 会单独消费员工桥代理的控制诊断，不把它交给模型当作命令输出；真实传输中断仍提示结果未知。命令自身的标准输出、标准错误与退出码照常返回。
 
+模型列表读取会随连接状态或连接代际变化取消，连接恢复时通过官方机制刷新。目录失败原因写入当前 profile 的 `ai-workbench-remote-agent/logs/model-catalog.jsonl`（脱敏）；未增加单次读取时限或重试。
+
 ## 会话行为
 
 每轮启动一个新助手进程，按原生会话编号恢复上下文；不接回旧进程或重放上一轮输入。主机会话始终使用创建时保存的主机和目录；工作区之后的选择只影响新会话。
 
-断线会结束本轮；操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止下一轮。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
+同一 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/catalog-ssh.d.ts

@@ -14,7 +14,8 @@ export interface CatalogSshEvent {
 export declare function catalogSafeText(value: string): string;
 export declare class CatalogSshError extends ModelConfigurationError {
     readonly event: CatalogSshEvent;
-    constructor(reason: string, event: CatalogSshEvent);
+    private readonly stderr;
+    constructor(reason: string, event: CatalogSshEvent, stderr?: string);
     get diagnostic(): string;
 }
 export type CatalogSshObserver = (event: Readonly<CatalogSshEvent>) => void | Promise<void>;

package/dist/catalog-ssh.js

@@ -49,11 +49,13 @@ export function catalogSafeText(value) {
 }
 export class CatalogSshError extends ModelConfigurationError {
     event;
-    constructor(reason, event) {
+    stderr;
+    constructor(reason, event, stderr = '') {
         super(reason);
         this.event = event;
+        this.stderr = stderr;
     }
-    get diagnostic() { return '目录连接技术详情：' + JSON.stringify(this.event); }
+    get diagnostic() { return '目录连接技术详情：' + JSON.stringify(this.event) + (this.stderr ? '\nSSH诊断：' + this.stderr : ''); }
 }
 /** Each query starts a fresh strict L SSH invocation. No connection pool or retry. */
 export async function runCatalog(target, command, signal, maxBytes, observe) {
@@ -76,10 +78,12 @@ export async function runCatalog(target, command, signal, maxBytes, observe) {
     return new Promise((resolve, reject) => {
         const child = spawn('ssh', argv, { stdio: ['ignore', 'pipe', 'pipe'] });
         const output = [], diagnostics = [];
-        let total = 0, stdoutBytes = 0, stderrBytes = 0, processErrorCode = null, failure;
-        const abort = () => { failure ??= { code: 'MODEL_CATALOG_CANCELLED', reason: '连接已改变或目录查询已取消' }; child.kill('SIGTERM'); };
+        let settled = false, total = 0, stdoutBytes = 0, stderrBytes = 0, processErrorCode = null, failure;
+        const abort = () => { failure ??= { code: 'MODEL_CATALOG_CANCELLED', reason: '连接已变化或读取已取消；连接恢复后请重新打开模型菜单。' }; child.kill('SIGTERM'); complete(null, null); };
         signal.addEventListener('abort', abort, { once: true });
         const receive = (buffer, stdout) => {
+            if (settled)
+                return;
             if (stdout)
                 stdoutBytes += buffer.length;
             else
@@ -88,46 +92,49 @@ export async function runCatalog(target, command, signal, maxBytes, observe) {
             if (failure)
                 return;
             if (total > maxBytes) {
-                failure = { code: 'MODEL_CATALOG_OUTPUT_LIMIT', reason: '目录响应超过 acpMaxMessageBytes，未截断返回' };
+                failure = { code: 'MODEL_CATALOG_OUTPUT_LIMIT', reason: '主机返回的模型列表过大，暂时无法显示；请联系管理员检查后重新打开模型菜单。' };
                 child.kill('SIGTERM');
+                complete(null, null);
                 return;
             }
             (stdout ? output : diagnostics).push(buffer);
         };
         child.stdout.on('data', (b) => receive(b, true));
         child.stderr.on('data', (b) => receive(b, false));
-        child.on('error', (error) => { processErrorCode = typeof error.code === 'string' && /^[A-Z0-9_]+$/.test(error.code) ? error.code : 'SSH_SPAWN_FAILED'; failure ??= { code: processErrorCode, reason: '可信 SSH 进程启动失败' }; });
-        child.once('close', (code, closeSignal) => {
-            void (async () => {
-                signal.removeEventListener('abort', abort);
-                let value = '', typed = false;
-                try {
-                    value = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(output));
-                }
-                catch {
-                    failure ??= { code: 'MODEL_CATALOG_UTF8_INVALID', reason: '主机目录响应不是有效 UTF-8，未替换模型值' };
-                }
-                try {
-                    typed = JSON.parse(value)?.ok === false;
-                }
-                catch { }
-                if (!failure && code !== 0 && !typed)
-                    failure = { code: 'SSH_EXIT_NONZERO', reason: '模型列表暂时无法读取，请检查连接后重新打开模型菜单。' };
-                const final = { provider, exitCode: code ?? null, signal: closeSignal ?? null, stdoutBytes, stderrBytes, elapsedMs: performance.now() - tick, failureCode: failure?.code ?? null, processErrorCode };
-                console.info('[remote-agent] model-list ' + provider + ' exit=' + final.exitCode + ' bytes=' + stdoutBytes + ' elapsedMs=' + final.elapsedMs.toFixed(1));
-                try {
-                    void Promise.resolve(observe?.(final)).catch(() => console.warn('[remote-agent] 模型列表查询日志未保存'));
-                }
-                catch {
-                    console.warn('[remote-agent] 模型列表查询日志未保存');
-                }
-                if (failure) {
-                    reject(new CatalogSshError(failure.reason, final));
-                    return;
-                }
-                resolve(value);
-            })().catch(reject);
-        });
+        child.on('error', (error) => { processErrorCode = typeof error.code === 'string' && /^[A-Z0-9_]+$/.test(error.code) ? error.code : 'SSH_SPAWN_FAILED'; failure ??= { code: processErrorCode, reason: '连接程序未能启动，暂时读不到模型列表；请从远程主机连接检查组件后重新打开模型菜单。' }; complete(null, null); });
+        const complete = (code, closeSignal) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', abort);
+            let value = '', typed = false;
+            try {
+                value = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(output));
+            }
+            catch {
+                failure ??= { code: 'MODEL_CATALOG_UTF8_INVALID', reason: '主机返回的模型列表内容损坏，暂时无法读取；请联系管理员检查后重新打开模型菜单。' };
+            }
+            try {
+                typed = JSON.parse(value)?.ok === false;
+            }
+            catch { }
+            if (!failure && code !== 0 && !typed)
+                failure = { code: 'SSH_EXIT_NONZERO', reason: '模型列表暂时无法读取，请检查远程主机连接后重新打开模型菜单。' };
+            const final = { provider, exitCode: code ?? null, signal: closeSignal ?? null, stdoutBytes, stderrBytes, elapsedMs: performance.now() - tick, failureCode: failure?.code ?? null, processErrorCode };
+            console.info('[remote-agent] model-list ' + provider + ' exit=' + final.exitCode + ' bytes=' + stdoutBytes + ' elapsedMs=' + final.elapsedMs.toFixed(1));
+            try {
+                void Promise.resolve(observe?.(final)).catch(() => console.warn('[remote-agent] 模型列表查询日志未保存'));
+            }
+            catch {
+                console.warn('[remote-agent] 模型列表查询日志未保存');
+            }
+            if (failure) {
+                reject(new CatalogSshError(failure.reason, final, catalogSafeText(Buffer.concat(diagnostics).toString('utf8'))));
+                return;
+            }
+            resolve(value);
+        };
+        child.once('close', (code, closeSignal) => complete(code, closeSignal));
         if (signal.aborted)
             abort();
     });

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.
@@ -115,7 +115,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
     providerInfo(provider) { return { id: provider, name: this.providerName() }; }
     catalog(signal) { if (!this.directory)
         throw new LlmError('无法获取模型列表：缺少可信主机目录能力', 'MODEL_CATALOG_UNAVAILABLE'); return this.directory.read(this.agent, signal); }
-    async listModels(provider) { const catalog = await this.catalog(); try {
+    async listModels(provider) { const catalog = await this.catalog(this.lifetime.signal); try {
+        this.lifetime.signal.throwIfAborted();
         this.modelPresentation.remember(catalog);
         return catalog.models.map(model => modelInfo(provider, model));
     }
@@ -196,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) {
@@ -219,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)
@@ -271,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 }) });
@@ -306,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 };
@@ -326,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));
@@ -437,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.
@@ -531,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();
@@ -621,7 +630,7 @@ export function apply(ctx, live) {
     };
     // Public Loader Entry.options.id; optional when mounted without Loader.
     const actualSettingsNamespace = ctx.fiber.entry?.options.id;
-    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes);
+    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes, undefined, (provider, error) => managerForProfile().recordCatalogFailure(provider, error));
     const adapter = new RemoteAgentsAdapter(config, agent => {
         const details = async (request, api, connection, target) => {
             return managerForProfile().open({ sessionId: request.sessionId, provider: agent.loginProvider, identity: `${target.username}@${target.host}:${target.port}`, connection });
@@ -689,8 +698,10 @@ export function apply(ctx, live) {
         const previous = connection;
         connection = state;
         // Official replacement invalidates the browser's shared catalog and loads it.
-        if (state.phase === 'connected' && (previous?.phase !== 'connected' || previous.instanceId !== state.instanceId || previous.epoch !== state.epoch))
+        if (previous?.phase !== state.phase || previous.instanceId !== state.instanceId || previous.epoch !== state.epoch) {
+            modelDirectory.cancelPending();
             registration.replace(ids);
+        }
     });
     installModelInputRetention(ctx, { isOurProvider: provider => ids.includes(provider), diagnosticForAttempt: position => preflightDiagnostics.forPreparation(position.sessionId, position), preflightDiagnostic: (provider, message) => diagnostic('preflight', provider, message), diagnostic: (provider, message) => diagnostic('input', provider, message) });
     const cleanup = async (id) => { try {

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/model-catalog.d.ts

@@ -44,7 +44,10 @@ export declare class ModelCatalog implements ModelDirectory {
     private get;
     private maxBytes;
     private run;
-    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner);
+    private reportFailure?;
+    private pending;
+    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, reportFailure?: ((provider: "claude" | "codex", error: unknown) => void) | undefined);
+    cancelPending(): void;
     read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;
     dispose(): void;
 }

package/dist/model-catalog.js

@@ -1,5 +1,6 @@
 import { LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { validateTarget } from "./provider.js";
+import { ModelConfigurationError } from "./model-configuration.js";
 import { runCatalog, catalogSafeText } from "./catalog-ssh.js";
 export { runCatalog } from "./catalog-ssh.js";
 const object = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
@@ -91,32 +92,72 @@ export class ModelCatalog {
     get;
     maxBytes;
     run;
-    constructor(get, maxBytes, run = runCatalog) {
+    reportFailure;
+    pending = new Set();
+    constructor(get, maxBytes, run = runCatalog, reportFailure) {
         this.get = get;
         this.maxBytes = maxBytes;
         this.run = run;
+        this.reportFailure = reportFailure;
+    }
+    cancelPending() {
+        for (const controller of this.pending)
+            controller.abort(new CatalogError('连接已变化，本次模型列表读取已停止；连接恢复后请重新打开模型菜单。', 'MODEL_CATALOG_CONNECTION_CHANGED'));
+        this.pending.clear();
     }
     async read(agent, signal) {
-        signal?.throwIfAborted();
-        const api = this.get();
-        if (!api || typeof api.getModelCatalogTarget !== 'function')
-            fail('远程主机连接组件没有提供模型目录');
-        const reply = api.getModelCatalogTarget(agent.loginProvider);
-        if (!reply.ok)
-            fail(reply.error.message);
-        const target = reply.value;
-        validateTarget(target.target);
         const controller = new AbortController(), combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
-        const max = this.maxBytes();
-        if (!Number.isSafeInteger(max) || max < 1)
-            fail('模型目录容量设置无效');
-        const output = await this.run(target.target, '/usr/local/aw-host/bin/aw-model-catalog --provider ' + agent.loginProvider, combined, max);
-        const parsed = parseHostCatalog(output, agent.loginProvider, target.target.username);
-        if (parsed.issues.length)
-            console.warn('[remote-agent] 模型菜单部分条目无效：' + parsed.issues.map(issue => issue.code).join(','));
-        return { target, models: parsed.models, signal: combined, release() { } };
+        let off;
+        this.pending.add(controller);
+        try {
+            combined.throwIfAborted();
+            const api = this.get();
+            if (!api || typeof api.getModelCatalogTarget !== 'function')
+                fail('远程主机连接组件尚未就绪，请等待连接恢复后重新打开模型菜单。');
+            const reply = api.getModelCatalogTarget(agent.loginProvider);
+            if (!reply.ok)
+                fail(reply.error.message);
+            const target = reply.value;
+            validateTarget(target.target);
+            off = api.onConnectionState?.(() => {
+                const state = api.getConnectionState();
+                if (state.phase !== 'connected' || state.instanceId !== target.instanceId || state.epoch !== target.epoch)
+                    controller.abort(new CatalogError('连接已变化，本次模型列表读取已停止；连接恢复后请重新打开模型菜单。', 'MODEL_CATALOG_CONNECTION_CHANGED'));
+            });
+            const max = this.maxBytes();
+            if (!Number.isSafeInteger(max) || max < 1)
+                fail('模型目录容量设置无效，请联系管理员检查插件配置。');
+            const output = await this.run(target.target, '/usr/local/aw-host/bin/aw-model-catalog --provider ' + agent.loginProvider, combined, max);
+            combined.throwIfAborted();
+            let parsed;
+            try {
+                parsed = parseHostCatalog(output, agent.loginProvider, target.target.username);
+            }
+            catch (error) {
+                if (error instanceof CatalogError)
+                    throw new CatalogError(error.message.slice('无法获取模型列表：'.length), error.diagnostic + '\n主机响应：' + safe(output));
+                throw error;
+            }
+            if (parsed.issues.length)
+                console.warn('[remote-agent] 模型菜单部分条目无效：' + parsed.issues.map(issue => issue.code).join(','));
+            return { target, models: parsed.models, signal: combined, release() { } };
+        }
+        catch (error) {
+            const failure = signal?.aborted ? signal.reason : error instanceof CatalogError || error instanceof ModelConfigurationError ? error : new CatalogError('暂时无法读取模型列表，请检查远程主机连接后重新打开模型菜单。', safe(error instanceof Error ? error.message : String(error)));
+            try {
+                this.reportFailure?.(agent.loginProvider, failure);
+            }
+            catch {
+                console.warn('[remote-agent] 模型列表失败日志未保存');
+            }
+            throw failure;
+        }
+        finally {
+            off?.();
+            this.pending.delete(controller);
+        }
     }
-    dispose() { }
+    dispose() { this.cancelPending(); }
 }
 export function modelInfo(provider, model) {
     // Official rc.2 represents no reasoning levels by absence, and rejects an empty efforts array.

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/dist/remote-details.d.ts

@@ -50,6 +50,8 @@ export declare function createRemoteDetails(options: {
     getApi?: () => unknown;
     warn?: (line: string) => void;
 }): {
+    /** Menu failures have no Session; keep them in the same private local logs. */
+    recordCatalogFailure(provider: "claude" | "codex", error: unknown): void;
     /** Await queued best-effort writes only when releasing the profile, never before dispatch. */
     dispose(): Promise<void>;
     releaseSession(sessionId: string): void;

package/dist/remote-details.js

@@ -1,3 +1,4 @@
+import { catalogSafeText } from "./catalog-ssh.js";
 import { closeCode } from "./close-diagnostics.js";
 import { randomUUID, createHash } from 'node:crypto';
 import { constants } from 'node:fs';
@@ -74,6 +75,14 @@ export function createRemoteDetails(options) {
         return { eventId };
     }
     return {
+        /** Menu failures have no Session; keep them in the same private local logs. */
+        recordCatalogFailure(provider, error) {
+            const reason = error instanceof Error ? error.message : typeof error === 'string' ? error : '模型目录查询失败';
+            const diagnostic = error && typeof error === 'object' && 'diagnostic' in error && typeof error.diagnostic === 'string' ? error.diagnostic : reason;
+            const line = { version: 1, at: new Date().toISOString(), provider, code: 'MODEL_CATALOG_UNAVAILABLE', message: catalogSafeText(reason), diagnostic: catalogSafeText(diagnostic) };
+            writes = writes.then(async () => { if (!root)
+                throw failure('DIAGNOSTIC_CONTEXT_UNAVAILABLE'); await privateDirectory(join(root, '..')); await privateDirectory(root); await appendFile(join(root, 'model-catalog.jsonl'), JSON.stringify(line) + '\n', { mode: 0o600, flag: constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW }); }).catch(warn);
+        },
         /** Await queued best-effort writes only when releasing the profile, never before dispatch. */
         async dispose() { await writes; memory.clear(); },
         releaseSession(sessionId) { for (const provider of ['claude', 'codex'])

package/package.json

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