@ai-workbench/remote-agent 0.8.27 → 0.8.29

package/README.md

@@ -1,10 +1,10 @@
-# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.27 · 插件 → 添加插件
+# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.29 · 插件 → 添加插件
 
 通过官方 DSH 插件入口使用 Claude（远程主机）与 Codex（远程主机）。登录和工作区来源由“远程主机连接”组件提供；员工在原生工作区和模型菜单中选择文件夹与型号。
 
 文件和命令在所选的本机或主机目录执行，订阅凭据留在主机。插件不改写 DSH 的默认模型，不为员工创建同名主机目录，已有主机会话只提取一次原有主机来源并保存。
 
-需要远程主机连接组件 0.7.29 或更新的 0.7.x，以及联网助手 0.4.9。主机来源保存于官方 storage.domain 的会话元数据表，每轮仅由连接组件检查一次主机目录，不检查本机占位目录。
+需要远程主机连接组件 0.7.29 或更新的 0.7.x、联网助手 0.4.9，以及支持公开会话归属接口的主机组件 S0.4.26。主机来源保存于官方 storage.domain 的会话元数据表，每轮仅由连接组件检查一次主机目录，不检查本机占位目录。
 
 Claude 本机 Bash 会单独消费员工桥代理的控制诊断，不把它交给模型当作命令输出；真实传输中断仍提示结果未知。命令自身的标准输出、标准错误与退出码照常返回。
 
@@ -14,7 +14,9 @@ Claude 本机 Bash 会单独消费员工桥代理的控制诊断，不把它交
 
 每轮启动一个新助手进程，按原生会话编号恢复上下文；不接回旧进程或重放上一轮输入。主机会话始终使用创建时保存的主机和目录；工作区之后的选择只影响新会话。
 
-断线会结束本轮；操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止下一轮。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
+同一 DSH 会话切换 Claude/Codex 时，切回会接本品牌最近的远端会话，并补充它尚未见过的可见对话；首次使用某品牌则带入全部可见历史。工具内部状态、推理和技术详情不转交。历史超出既有 `acpMaxMessageBytes` 容量时，只带能容纳的最近完整轮，并在技术详情说明省略数量；当前输入保持完整，超限仍明确失败。没有新增设置、重试或时限。
+
+断线会结束本轮；已派发的操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止发起下一轮。续接明确遇到原线程被占用时，使用 S0.4.26 的会话归属和原子结束接口：只有唯一匹配的旧进程确实已断开、主机明确确认退出后，才接回同一线程一次；不会新建替代线程、重发用户输入或抢占活跃会话。旧版无归属进程不能安全清理，需等待主机按现有策略回收；失败或释放结果未知则说明本轮输入未发送。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
 
 DSH 启动和打开模型菜单时读取一次主机型号列表。发送时不再查询目录或预核所选型号；所选型号不可用时，请在模型菜单重新选择。
 

package/dist/acp.d.ts

@@ -6,6 +6,7 @@ import type { BrokerTransport } from './broker.ts';
 import { type SanitizedObservation } from './conversation-details.ts';
 import { type ModelConfigurationSnapshot } from './model-configuration.ts';
 import type { EmployeeRouting } from './employee-relay.ts';
+import type { SessionOwnership } from './broker-ownership.ts';
 export type ApprovalOutcome = 'allowed-once' | 'rejected' | 'cancelled' | 'unavailable';
 export interface AcpHooks {
     closeDiagnostics?: CloseDiagnostics;
@@ -25,6 +26,7 @@ export interface AcpHooks {
     onEmployeeNotice?: (notice: string) => void;
     onDetail?: (detail: Readonly<SanitizedObservation>) => void;
     broker?: BrokerTransport;
+    sessionOwnership?: SessionOwnership;
     employeeExecution?: (params: unknown, signal?: AbortSignal) => Promise<Record<string, unknown>>;
 }
 export interface EmployeeExecutionMeta {

package/dist/acp.js

@@ -1,6 +1,6 @@
 import { employeeExecutionInfo, employeeMcpSummary, employeeHttpNotice } from "./employee-info.js";
 import { employeeAdapterCodes, employeeOpenCauseCodes } from "./employee-reasons.js";
-import { CloseDiagnostics, withFirstFailureEvidence } from "./close-diagnostics.js";
+import { CloseDiagnostics, closeCode, withFirstFailureEvidence } from "./close-diagnostics.js";
 import * as acp from '@agentclientprotocol/sdk/unstable';
 import { NeedError } from "./remote.js";
 import { employeeFailure } from "./presentation.js";
@@ -505,17 +505,37 @@ export class AcpSession {
             this.employeeRouting = routing;
             const params = { cwd, mcpServers: routing ? structuredClone(routing.mcpServers) : [], ...((routing || this.employeeMeta) ? { _meta: { ...(this.employeeMeta ? { awEmployeeExecution: this.employeeMeta } : {}), ...(routing ? { claudeCode: { options: employeeClaudeOptions(routing) } } : {}) } } : {}), ...(systemPrompt && !(resumeId && this.codexNewSessionOnly) ? { systemPrompt: { mode: 'append', content: [{ type: 'text', text: systemPrompt }] } } : {}) };
             const configRevision = this.resetConfiguration();
+            const restore = async (operation) => {
+                try {
+                    return await operation();
+                }
+                catch (error) {
+                    if (!resumeId || acpNeed(error).code !== 'REMOTE_SESSION_BUSY' || !this.hooks.sessionOwnership)
+                        throw error;
+                    this.detail({ kind: 'session', severity: 'info', code: 'REMOTE_SESSION_BUSY', summary: '原远端会话被占用，正在核对同一会话与线程的已断开旧进程；尚未发送用户输入。' });
+                    try {
+                        await this.hooks.sessionOwnership.stopDetached(resumeId, signal);
+                        signal?.throwIfAborted();
+                    }
+                    catch (failure) {
+                        this.detail({ kind: 'session', severity: 'warning', code: 'REMOTE_SESSION_RELEASE_UNCONFIRMED', summary: '旧会话释放未获确认，本轮没有再次接续或发送用户输入。', payload: { reason: failure instanceof NeedError ? failure.requires : closeCode(failure, 'BROKER_CONTROL_FAILED') } });
+                        throw failure;
+                    }
+                    this.detail({ kind: 'session', severity: 'info', code: 'REMOTE_SESSION_RELEASE_CONFIRMED', summary: '主机已确认原会话的已断开旧进程退出，继续接回同一远端会话一次。' });
+                    return operation(); // Exactly one continuation, only after the explicit release receipt.
+                }
+            };
             if (resumeId) {
                 this.sessionId = resumeId;
                 if (this.negotiated.sessionCapabilities?.resume) {
-                    const result = await this.stage('acp-session-resume', () => this.connection.agent.request(acp.methods.agent.session.resume, { ...params, sessionId: resumeId }, { cancellationSignal: signal }));
+                    const result = await restore(() => this.stage('acp-session-resume', () => this.connection.agent.request(acp.methods.agent.session.resume, { ...params, sessionId: resumeId }, { cancellationSignal: signal })));
                     this.lifecycleConfiguration(result, configRevision);
                     this.method = acp.methods.agent.session.resume;
                 }
                 else {
                     if (!this.negotiated.loadSession)
                         throw new NeedError('RESUME_UNSUPPORTED', '远端未声明会话恢复或加载能力，不能恢复原会话', '支持 session/resume 或 session/load 的 agent');
-                    const result = await this.stage('acp-session-load', () => this.connection.agent.request(acp.methods.agent.session.load, { ...params, sessionId: resumeId }, { cancellationSignal: signal }));
+                    const result = await restore(() => this.stage('acp-session-load', () => this.connection.agent.request(acp.methods.agent.session.load, { ...params, sessionId: resumeId }, { cancellationSignal: signal })));
                     this.lifecycleConfiguration(result, configRevision);
                     this.method = acp.methods.agent.session.load;
                 }
@@ -528,6 +548,7 @@ export class AcpSession {
                 this.lifecycleConfiguration(result, configRevision);
                 this.method = acp.methods.agent.session.new;
             }
+            await this.hooks.sessionOwnership?.bind(this.sessionId, signal);
             this.ready = true;
             this.cwd = cwd;
             this.systemPrompt = systemPrompt ?? '';
@@ -605,6 +626,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/broker-ownership.d.ts

@@ -0,0 +1,10 @@
+import { type BrokerIo } from './broker.ts';
+export interface SessionOwnership {
+    bind(remoteSessionId: string, signal?: AbortSignal): Promise<void>;
+    stopDetached(remoteSessionId: string, signal?: AbortSignal): Promise<void>;
+}
+/** S0426 public control only: no process/lock scans or client ownership journal. */
+export declare function brokerOwnership(io: BrokerIo, command: (args: string[]) => string, started: {
+    id: string;
+    instanceId: string;
+}, receipt: unknown, dshSessionId: string, provider: 'codex' | 'claude'): SessionOwnership;

package/dist/broker-ownership.js

@@ -0,0 +1,59 @@
+import { controlJson } from "./broker.js";
+import { NeedError } from "./remote.js";
+import { closeCode } from "./close-diagnostics.js";
+const record = (v) => v !== null && typeof v === 'object' && !Array.isArray(v) ? v : undefined;
+const line = (v) => typeof v === 'string' && v.length > 0 && !/[\r\n\0]/.test(v);
+const same = (value, expected) => { const row = record(value); return row?.dshSessionId === expected.dshSessionId && row.provider === expected.provider && row.remoteSessionId === expected.remoteSessionId; };
+const busy = (reason) => new NeedError('REMOTE_SESSION_BUSY', '原会话仍被上一轮占用，本轮输入未发送。', '已断开旧会话的安全释放尚未确认；' + reason + (reason === 'OWNERSHIP_NOT_FOUND_OR_LEGACY' ? '；没有可证明归属的旧会话，不结束任何旧进程，请等待主机按现有策略回收。' : ''));
+/** S0426 public control only: no process/lock scans or client ownership journal. */
+export function brokerOwnership(io, command, started, receipt, dshSessionId, provider) {
+    let owner = { dshSessionId, provider, remoteSessionId: null };
+    const initial = record(receipt);
+    if (!line(dshSessionId) || initial?.ownershipProtocolVersion !== 1 || !same(initial.ownership, owner))
+        throw new NeedError('BROKER_OWNERSHIP_UNAVAILABLE', '主机会话缺少归属能力，本轮输入未发送；请联系管理员更新主机组件。', 'S >=0.4.26 / ownershipProtocolVersion:1');
+    const flags = (value) => ['--dsh-session-id', value.dshSessionId, '--provider', value.provider, '--remote-session-id', value.remoteSessionId];
+    const confirmed = (value, id, instanceId, expected) => value?.id === id && value.instanceId === instanceId && value.ownershipProtocolVersion === 1 && same(value.ownership, expected);
+    return {
+        async bind(remoteSessionId, signal) {
+            signal?.throwIfAborted();
+            if (!line(remoteSessionId))
+                throw new NeedError('BROKER_OWNERSHIP_INVALID', '远端会话编号无法绑定，本轮输入未发送。', 'S0426单行原生会话编号');
+            const next = { ...owner, remoteSessionId };
+            const value = record(controlJson(await io.run(command(['bind', started.id, '--if-instance', started.instanceId, ...flags(next), ...(owner.remoteSessionId === null ? [] : ['--if-remote-session-id', owner.remoteSessionId])]), signal)));
+            signal?.throwIfAborted();
+            if (value?.type !== 'bound' || !confirmed(value, started.id, started.instanceId, next))
+                throw new NeedError('BROKER_OWNERSHIP_UNCONFIRMED', '主机未确认会话归属，本轮输入未发送。', 'S0426精确归属绑定回执');
+            owner = next;
+        },
+        async stopDetached(remoteSessionId, signal) {
+            try {
+                signal?.throwIfAborted();
+                if (!line(remoteSessionId))
+                    throw busy('OWNERSHIP_INVALID');
+                const wanted = { ...owner, remoteSessionId };
+                const entries = controlJson(await io.run(command(['list']), signal));
+                signal?.throwIfAborted();
+                if (!Array.isArray(entries) || entries.some(row => !record(row)))
+                    throw busy('OWNERSHIP_LIST_INVALID');
+                const matches = entries.map(record).filter(row => same(row?.ownership, wanted));
+                if (matches.length !== 1)
+                    throw busy(matches.length ? 'OWNERSHIP_AMBIGUOUS' : 'OWNERSHIP_NOT_FOUND_OR_LEGACY');
+                const row = matches[0];
+                if (row.id === started.id || !line(row.id) || !line(row.instanceId) || row.ownershipProtocolVersion !== 1)
+                    throw busy('OWNERSHIP_UNAVAILABLE');
+                const lifecycle = record(row.lifecycle);
+                if (!['running', 'exited'].includes(row.state) || lifecycle?.attached !== false || !line(lifecycle.detachedAt))
+                    throw busy('SESSION_NOT_DETACHED');
+                const value = record(controlJson(await io.run(command(['stop-detached', row.id, '--if-instance', row.instanceId, ...flags(wanted)]), signal)));
+                signal?.throwIfAborted();
+                if (value?.type !== 'killed' || !confirmed(value, row.id, row.instanceId, wanted) || value.agentExited !== true || value.processGroupExited !== true)
+                    throw busy('STOP_UNCONFIRMED');
+            }
+            catch (error) {
+                if (error instanceof NeedError && error.code === 'REMOTE_SESSION_BUSY')
+                    throw error;
+                throw busy(closeCode(error, 'BROKER_CONTROL_FAILED'));
+            }
+        },
+    };
+}

package/dist/broker-runtime.js

@@ -12,6 +12,7 @@ import { BrokerTransport, brokerCommand, brokerId, sshIo, controlJson } from "./
 import { CODEX_AGENT } from "./agents.js";
 import { NeedError } from "./remote.js";
 import { identity } from "./provider.js";
+import { brokerOwnership } from "./broker-ownership.js";
 /** Each invocation owns a new agent. Context resumes by native session ID, never by reattaching a broker. */
 export function brokerFactory(_get, _ask, configuration, provided) {
     return async (target, project, request) => {
@@ -25,7 +26,7 @@ export function brokerFactory(_get, _ask, configuration, provided) {
         const command = (args) => brokerCommand(target, args);
         const diagnostics = request.closeDiagnostics ?? new CloseDiagnostics(detail => request.detailChannel?.record(detail));
         const id = brokerId(request.sessionId + '/' + randomUUID(), agent.id);
-        const startCommand = command(['start', id, '--cwd', project.path, '--settings', target.session.settingsPath, '--', agent.command]);
+        const startCommand = command(['start', id, '--cwd', project.path, '--settings', target.session.settingsPath, '--dsh-session-id', request.sessionId, '--provider', agent.loginProvider, '--', agent.command]);
         // environments.toml overrides CODEX_EXEC_SERVER_URL. Refuse that host default rather
         // than allowing a local-workspace resume to select a host executor.
         const employeeStart = request.employeeScope && agent.loginProvider === 'codex';
@@ -47,7 +48,9 @@ export function brokerFactory(_get, _ask, configuration, provided) {
         };
         const aborted = () => channel.fail(new NeedError('ABORTED', '本轮已取消。', '确认主机状态'), { layer: 'broker', initiator: 'broker.open-signal', reason: 'ABORTED', action: 'abort' });
         request.signal?.addEventListener('abort', aborted, { once: true });
+        let sessionOwnership;
         try {
+            sessionOwnership = brokerOwnership(io, command, { id, instanceId: started.instanceId }, started, request.sessionId, agent.loginProvider);
             request.signal?.throwIfAborted();
             await channel.connect();
         }
@@ -58,6 +61,6 @@ export function brokerFactory(_get, _ask, configuration, provided) {
         finally {
             request.signal?.removeEventListener('abort', aborted);
         }
-        return { identity: identity(target), cwd: project.path, closeDiagnostics: diagnostics, broker: channel, acpTransport: channel, dispose, detach: dispose };
+        return { identity: identity(target), cwd: project.path, closeDiagnostics: diagnostics, broker: channel, sessionOwnership, acpTransport: channel, dispose, detach: dispose };
     };
 }

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));
@@ -363,7 +363,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 let failure;
                 const push = (chunks) => { queue.push(...chunks); wake?.(); wake = undefined; };
                 let promptPermit;
-                const hooks = { closeDiagnostics: runtime.closeDiagnostics, broker: runtime.broker, employeeExecution: runtime.employeeExecution, ...this.permissions ? { promptGuard: () => {
+                const hooks = { closeDiagnostics: runtime.closeDiagnostics, broker: runtime.broker, sessionOwnership: runtime.sessionOwnership, employeeExecution: runtime.employeeExecution, ...this.permissions ? { promptGuard: () => {
                             if (!promptPermit)
                                 throw new NeedError('PERMISSION_POLICY_CHANGED', '当前权限没有保持确认，本次没有继续派发。', '当前权限代次和同值回执');
                             return promptPermit;
@@ -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,11 @@ export function employeeFailure(code, brand = 'codex') {
         HOST_TRUST_REQUIRED: '远程主机连接信息还未准备好，请联系管理员。',
         POLICY_DENIED: '这个账号暂时不能使用，请联系公司账号管理员。',
         SESSION_CONTEXT_MISMATCH: '远程主机连接已改变，请重新开始本次检查。',
-        ABORTED: '本轮已停止。操作可能已部分执行，请先确认文件；恢复连接后可在原会话继续。',
+        REMOTE_SESSION_BUSY: '原会话仍被主机上的上一轮占用，' + (promptDispatched ? '本轮请求未能完成' : '本轮输入未发送') + '；请稍后在原会话重新发送。若持续占用，请联系管理员检查上一轮主机会话。',
+        BROKER_OWNERSHIP_UNAVAILABLE: '主机会话组件缺少安全续接能力，本轮输入未发送；请联系管理员更新主机组件。',
+        BROKER_OWNERSHIP_UNCONFIRMED: '主机尚未确认这条会话的归属，本轮输入未发送；请检查远程主机连接后在原会话重试。',
+        BROKER_OWNERSHIP_INVALID: '远端会话编号无法确认，本轮输入未发送；请联系管理员查看技术详情。',
+        ABORTED: promptDispatched ? '本轮已停止。操作可能已部分执行，请先确认文件；恢复连接后可在原会话继续。' : '本轮已停止，本轮输入未发送；恢复连接后可在原会话重新发送。',
         CONFIRMATION_REQUIRED: '请先选择是否打开授权窗口。',
         CONTEXT_UNSUPPORTED: '远程 Codex 暂不支持这类会话内容，请联系管理员。',
         CONTENT_UNSUPPORTED: '远程 Codex 暂不支持这类附件，请联系管理员。',
@@ -79,6 +83,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/provider.d.ts

@@ -14,6 +14,7 @@ import type { SourceAdmissionStage } from './workspace-source.ts';
 import type { LocalWorkspaceContext } from '@ai-workbench/connect/api';
 import type { EmployeeRouting } from './employee-relay.ts';
 import type { HostWorkspacePresentation } from './input.ts';
+import type { SessionOwnership } from './broker-ownership.ts';
 export interface EmployeeExecution {
     hostCwd: string;
     routing: EmployeeRouting;
@@ -37,6 +38,7 @@ export interface Runtime {
         readable: ReadableStream<Uint8Array>;
     } | AgentApp | ExtendedAgentApp;
     broker?: BrokerTransport;
+    sessionOwnership?: SessionOwnership;
     loginRequired?: () => Promise<void>;
     dispose?: (cause?: CloseCause) => Promise<void>;
     binding?: {

package/package.json

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