@ai-workbench/remote-agent 0.8.12 → 0.8.14

package/dist/index.js

@@ -1,3 +1,4 @@
+import { CloseDiagnostics, closeCode, closeErrorCodes, closeFailure } from "./close-diagnostics.js";
 import { runCatalog } from "./catalog-ssh.js";
 import { createCatalogDiagnostics, CatalogDiagnosticsRemote } from "./catalog-diagnostics.js";
 import { SessionId } from '@deepseek-ai/dsh-session';
@@ -54,13 +55,20 @@ export const Config = Schema.object({
 export function readConfig(config) {
     return Object.fromEntries(Object.entries(config).map(([key, value]) => [key, typeof value === 'object' && value !== null && 'get' in value ? value.get() : value]));
 }
+function modelResolutionLabel(configuration) {
+    return configuration.resolvedModelSource === 'host-user-catalog'
+        ? `型号：${configuration.resolvedModel}（来源：主机目录映射 ${configuration.selected.value}；会话未单独回报具体型号）`
+        : `具体型号：${configuration.resolvedModel}`;
+}
 function validContextDigest(value) { return typeof value === 'string' && /^[a-fA-F0-9]{64}$/u.test(value); }
 function readPointer(options, agent) {
     const last = options.messages.findLast(message => message.role === 'assistant' && !isWorkspaceNoticeMessage(message));
     if (!last || last.role !== 'assistant')
         return;
-    if (last.source.provider !== options.provider || last.source.replayState === undefined)
-        throw new NeedError('SESSION_STATE_MISSING', '已有对话缺少当前模型的远端恢复标识，请新建会话', '当前模型的远端恢复记录');
+    if (last.source.provider !== options.provider)
+        throw new NeedError('SESSION_STATE_MISSING', '已有对话属于其他模型通道，不能沿用其远端进程', '当前模型的远端恢复记录');
+    if (last.source.replayState === undefined)
+        return;
     const envelope = last.source.replayState;
     const pointer = envelope?.response;
     if (pointer?.version !== 2 || pointer.agent !== agent.id || (pointer.mode !== 'session' && pointer.mode !== 'one-shot') || ![pointer.identity, pointer.cwd, pointer.sessionId].every(value => typeof value === 'string' && value.length > 0))
@@ -104,6 +112,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
     shuttingDown = false;
     detached = new Set();
     cleanups = new WeakMap();
+    preparationFailures = new Map();
     constructor(config, resolveRuntime, approve, providerName = () => PROVIDER_NAMES.en, agent = CODEX_AGENT, readImage, reportLoginFailure, directory, preflightDiagnostics) {
         super();
         this.resolveRuntime = resolveRuntime;
@@ -141,16 +150,24 @@ export class CodexRemoteAdapter extends LlmAdapter {
         markModelPreparationFailure(provider, error, signal);
         throw error;
     } }
-    async invalidateModelState() { for (const turn of this.turns.values())
-        turn.abort(); await Promise.all([...this.sessions.keys()].map(id => this.disposeSession(id))); }
-    async invalidateEmployeeState() { await Promise.all([...this.sessions].filter(([, live]) => live.runtime.employeeExecutionMeta || live.runtime.execution).map(([id]) => this.disposeSession(id))); }
+    observeModelInvalidation(fields, changes = []) { for (const live of this.sessions.values())
+        live.runtime.closeDiagnostics?.record({ layer: 'adapter', initiator: 'catalog.signature-change', reason: 'MODEL_CATALOG_SIGNATURE_CHANGED', action: 'invalidate', changedFields: fields, changes }); }
+    async invalidateModelState() { for (const [id, turn] of this.turns) {
+        this.sessions.get(id)?.runtime.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.model-invalidation', reason: 'MODEL_STATE_INVALIDATED', action: 'abort', changes: [{ field: 'adapter.turn-aborted', before: turn.signal.aborted, after: true }] });
+        turn.abort();
+    } await Promise.all([...this.sessions.keys()].map(id => this.disposeSession(id))); }
+    async invalidateEmployeeState() { for (const live of this.sessions.values())
+        if (live.runtime.employeeExecutionMeta || live.runtime.execution)
+            live.runtime.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.employee-invalidation', reason: 'EMPLOYEE_SERVICE_CHANGED', action: 'invalidate' }); await Promise.all([...this.sessions].filter(([, live]) => live.runtime.employeeExecutionMeta || live.runtime.execution).map(([id]) => this.disposeSession(id))); }
     providerRetryPolicy() { return { mode: 'normal', maxRetries: 0, retryableCodes: [], initialDelayMs: 0, maxDelayMs: 0, jitterRatio: 0 }; }
-    cleanupRuntime(runtime) {
+    cleanupRuntime(runtime, cause = { layer: 'adapter', initiator: 'adapter.cleanup-runtime', reason: 'RUNTIME_CLEANUP', action: 'dispose' }) {
+        runtime.closeDiagnostics?.record(cause);
         const existing = this.cleanups.get(runtime);
         if (existing)
             return existing;
-        const cleanup = Promise.resolve().then(() => runtime.dispose?.()).catch(() => {
-            const failure = new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '原主机会话的清理结果未确认，不能继续或重开此会话', '管理员核对并结束原主机会话');
+        const cleanup = Promise.resolve().then(() => runtime.dispose?.(cause)).catch(error => {
+            const codes = closeErrorCodes(error, 'REMOTE_CLEANUP_UNCONFIRMED');
+            const failure = closeFailure('REMOTE_CLEANUP_UNCONFIRMED', '原主机会话的清理结果未确认，不能继续或重开此会话', '管理员核对原主机会话；收尾代码 ' + codes.join(','), codes);
             for (const live of this.sessions.values())
                 if (live.runtime === runtime) {
                     live.cleanupFailure = failure;
@@ -162,13 +179,14 @@ export class CodexRemoteAdapter extends LlmAdapter {
         return cleanup;
     }
     async disposeSession(sessionId) {
+        this.sessions.get(sessionId)?.runtime.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.dispose-session', reason: 'SESSION_DISPOSED', action: 'abort' });
         this.turns.get(sessionId)?.abort();
         const current = this.sessions.get(sessionId);
         if (!current)
             return;
         if (current.disposal)
             return current.disposal;
-        current.session.close();
+        current.session.close({ layer: 'adapter', initiator: 'adapter.dispose-session', reason: 'SESSION_DISPOSED', action: 'close' });
         current.disposal = this.cleanupRuntime(current.runtime).then(() => { if (this.sessions.get(sessionId) === current)
             this.sessions.delete(sessionId); });
         return current.disposal;
@@ -177,13 +195,14 @@ export class CodexRemoteAdapter extends LlmAdapter {
         const current = this.sessions.get(sessionId), turn = this.turns.get(sessionId);
         if (!current && !turn)
             return;
+        current?.runtime.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.detach-session', reason: 'SESSION_DETACHED', action: 'detach', changes: [{ field: 'adapter.detached', before: this.detached.has(sessionId), after: true }] });
         this.detached.add(sessionId);
         if (current) {
             try {
-                await current.runtime.detach?.();
+                await current.runtime.detach?.({ layer: 'adapter', initiator: 'adapter.detach-session', reason: 'SESSION_DETACHED', action: 'detach' });
             }
             finally {
-                current.session.close();
+                current.session.close({ layer: 'adapter', initiator: 'adapter.detach-finally', reason: 'SESSION_DETACHED', action: 'close' });
                 this.sessions.delete(sessionId);
                 turn?.abort();
             }
@@ -192,6 +211,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
             turn?.abort();
     }
     async dispose() {
+        for (const live of this.sessions.values())
+            live.runtime.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.dispose', reason: 'PLUGIN_DISPOSED', action: 'dispose', changes: [{ field: 'adapter.shutting-down', before: this.shuttingDown, after: true }] });
         this.shuttingDown = true;
         const results = await Promise.allSettled([...new Set([...this.sessions.keys(), ...this.turns.keys()])].map(id => this.detachSession(id)));
         this.lifetime.abort();
@@ -239,6 +260,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
         const signal = AbortSignal.any([this.lifetime.signal, turn.signal, ...(original.signal ? [original.signal] : [])]);
         const options = { ...original, signal };
         const timing = new StageTiming();
+        const abortOffs = [];
         let request;
         let earlyStage = 'input-prepare';
         let runtime;
@@ -246,14 +268,25 @@ export class CodexRemoteAdapter extends LlmAdapter {
         let live;
         let succeeded = false;
         let remoteAttempted = false;
+        let promptBaseline = 0;
+        let failureCode;
         let preserveRecoveredRuntime = false;
         let activeMapper;
         let catalog;
         let selected;
         let modelConfiguration;
+        const information = [];
+        const recordInformation = () => { if (runtime?.details)
+            for (const entry of information.splice(0))
+                runtime.details.record(entry); };
         const config = this.config();
         const mode = this.agent.oneShot ? config.mode : 'session';
         request = { sessionId: options.sessionId, mode: mode ?? 'session', timing, signal };
+        const observeAbort = (source, initiator, reason) => { if (!source)
+            return; const record = () => { (request?.closeDiagnostics ?? runtime?.closeDiagnostics)?.record({ layer: 'adapter', initiator, reason, action: 'abort', changes: [{ field: 'adapter.turn-aborted', before: false, after: source.aborted }] }); }; source.addEventListener('abort', record, { once: true }); abortOffs.push(() => source.removeEventListener('abort', record)); };
+        observeAbort(original.signal, 'signal.caller', 'CALLER_ABORTED');
+        observeAbort(this.lifetime.signal, 'signal.plugin-lifetime', 'PLUGIN_DISPOSED');
+        observeAbort(turn.signal, 'signal.adapter-turn', 'TURN_ABORTED');
         this.preflightDiagnostics?.begin(request, this.agent.loginProvider);
         if (this.preflightDiagnostics)
             request.recordEarlyFailure = (error, stage) => this.preflightDiagnostics.failure(request, this.agent.loginProvider, error, stage);
@@ -261,21 +294,39 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (!mode || (mode === 'session' && (!Number.isSafeInteger(config.acpMaxMessageBytes) || config.acpMaxMessageBytes < 1)))
                 throw new NeedError('SETTINGS_REQUIRED', '远程模型连接设置无效，请联系管理员检查', '有效的mode/acpMaxMessageBytes');
             const previous = readPointer(options, this.agent);
+            const last = options.messages.findLast(message => message.role === 'assistant' && !isWorkspaceNoticeMessage(message));
+            const missingPointer = !!last && !previous;
+            let requireFreshSession = missingPointer || !!key && this.preparationFailures.has(key);
             if (previous && previous.mode !== mode)
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '运行模式与原会话不一致，请新建会话', '原会话模式');
             if (previous && !previous.modelConfiguration)
-                throw new NeedError('MODEL_SELECTION_REQUIRED', '旧远端恢复记录没有明确模型选择，请新建会话并选择模型', '本轮明确选择的模型');
+                information.push({ kind: 'session', severity: 'info', code: 'TURN_GATE_INFORMATION', summary: '历史回复没有模型配置资料；本轮会重新确认你当前选择的模型。', payload: { reason: 'HISTORICAL_MODEL_CONFIGURATION_ABSENT' } });
             live = key ? this.sessions.get(key) : undefined;
             if (live?.disposal || live?.cleanupFailure)
                 throw live.cleanupFailure ?? new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '原主机会话正在结束，清理结果尚未确认，不能继续或重开此会话', '管理员核对原主机会话清理结果');
             if (live?.failure)
-                throw new NeedError('SESSION_STATE_UNCONFIRMED', '上轮远端状态未确认，不能自动重发或重开，请新建会话并核对项目', '管理员核对原会话状态');
-            if (live && !previous)
-                throw new NeedError('SESSION_STATE_MISSING', '上一轮回复尚无持久恢复记录，不能继续当前远端会话', '原会话的持久回复记录');
+                throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '上一轮输入已经交给远端，但结果未确认，不能自动重发', '核对已发送输入及原主机会话状态');
+            if (live && !previous) {
+                if (typeof live.runtime.dispose !== 'function')
+                    throw new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '原会话不能确认已安全结束，本轮尚未发送', '可确认结束原实例的通道');
+                live.session.close({ layer: 'adapter', initiator: 'adapter.missing-pointer', reason: 'PRIVATE_RECOVERY_POINTER_ABSENT', action: 'close' });
+                await this.cleanupRuntime(live.runtime, { layer: 'adapter', initiator: 'adapter.missing-pointer', reason: 'PRIVATE_RECOVERY_POINTER_ABSENT', action: 'dispose' });
+                if (key && this.sessions.get(key) === live)
+                    this.sessions.delete(key);
+                live = undefined;
+                requireFreshSession = true;
+            }
             const configuration = JSON.stringify([mode, config.acpMaxMessageBytes, config.brokerMaxFrameBytes, config.brokerControlMaxBytes, config.employeeShellKillGraceMs]);
             if (live && live.configuration !== configuration)
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '会话运行设置已改变，请新建会话', '原会话运行设置');
             Object.assign(request, { timing, acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, recoveryCheckpointId: previous?.recoveryCheckpointId, sessionId: options.sessionId, mode, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, retainProcess: !!key && mode === 'session', signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) });
+            if (requireFreshSession) {
+                request.requireFreshSession = true;
+                request.resumeSessionId = undefined;
+                request.recoveryCheckpointId = undefined;
+                information.push({ kind: 'session', severity: 'warning', code: 'TURN_GATE_INFORMATION', summary: '缺少可用的旧会话恢复资料，或上次在发送前已失败；将核对旧实例安全结束后，只处理本次接纳的输入。', payload: { reason: missingPointer ? 'PRIVATE_RECOVERY_POINTER_ABSENT' : 'PRIOR_PREPARATION_FAILED' } });
+            }
+            request.previousContextSha256 = previous?.contextSha256;
             const after = options.messages.findLastIndex(message => message.role === 'assistant' && !isWorkspaceNoticeMessage(message));
             request.userInputIds = Object.freeze(options.messages.slice(after + 1).flatMap(message => message.role === 'user' && message.source?.kind === 'user' && typeof message.id === 'string' ? [message.id] : []));
             request.userMessageIds = request.userInputIds;
@@ -293,8 +344,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             // New Codex transport scopes are independent of the native context digest.
             if (contextChanged)
                 request.contextSha256 = undefined;
-            if (previous && this.agent.loginProvider === 'claude' && previous.contextSha256 !== contextSha256)
-                throw new NeedError('SYSTEM_PROMPT_UPDATE_PENDING', 'Claude原会话的系统或开发者要求已变化；主机仅承诺下次上下文整理后生效，本轮未发送，请新建会话应用新要求', '新建Claude会话以立即应用当前系统与开发者要求');
+            const claudeContextChanged = !!previous && !codex && previous.contextSha256 !== contextSha256;
             if (contextChanged)
                 input = await prepareContinuation(options, input, this.readImage);
             if (live) {
@@ -314,16 +364,25 @@ export class CodexRemoteAdapter extends LlmAdapter {
             earlyStage = 'model-catalog';
             catalog = await this.catalog(signal);
             selected = catalog.models.find(model => model.id === options.model);
+            catalog.onInformation?.(entry => information.push(entry));
             if (!selected)
                 throw new ModelConfigurationError('所选模型不在本次可信主机目录中，请重新选择模型');
             if (options.reasoningEffort !== undefined && !selected.reasoning.options.some(option => option.value === options.reasoningEffort))
                 throw new ModelConfigurationError('所选推理等级不在本次模型目录中');
+            const observeSignal = (source, initiator, reason) => { const observed = () => { const diagnostic = request?.closeDiagnostics ?? runtime?.closeDiagnostics; if (diagnostic)
+                diagnostic.record({ layer: 'adapter', initiator, reason, action: 'abort', changes: [{ field: 'adapter.turn-aborted', before: false, after: source.aborted }] }); }; source.addEventListener('abort', observed, { once: true }); abortOffs.push(() => source.removeEventListener('abort', observed)); };
+            observeSignal(catalog.signal, 'signal.model-catalog', 'MODEL_CATALOG_REVOKED');
+            observeSignal(signal, 'signal.turn-composite', 'ABORTED');
             let modelSignal = AbortSignal.any([signal, catalog.signal]);
             options.signal = modelSignal;
             request.signal = modelSignal;
             earlyStage = 'runtime-resolve';
             runtime = await this.resolveRuntime(request);
+            const closeSink = runtime.details;
+            runtime.closeDiagnostics ??= new CloseDiagnostics(event => closeSink?.record(event));
             signal.throwIfAborted();
+            if (requireFreshSession && (!runtime.freshSessionConfirmed || !runtime.restartNotice))
+                throw new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '未确认原实例安全结束或原位置为空，本轮没有发送', '同UUID条件结束与list消失证明，或原slot不存在证明');
             if (runtime.execution?.signal) {
                 modelSignal = AbortSignal.any([modelSignal, runtime.execution.signal]);
                 options.signal = modelSignal;
@@ -357,6 +416,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             const details = runtime.details;
             if (!details)
                 throw new NeedError('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用，请更新远程主机连接组件。', 'L技术详情持久接收能力');
+            recordInformation();
             timing.bind(detail => details.record(detail));
             request.recordEarlyFailure = undefined;
             const mapper = new StreamMapper(mode === 'session' && !contextChanged ? (runtime.restartNotice ? undefined : live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined, observation => details.record(observation));
@@ -390,7 +450,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 let done = false;
                 let failure;
                 const push = (chunks) => { queue.push(...chunks); wake?.(); wake = undefined; };
-                const hooks = { broker: runtime.broker, employeeExecution: runtime.employeeExecution, timing, approve: async (permission, approvalSignal) => {
+                const hooks = { closeDiagnostics: runtime.closeDiagnostics, broker: runtime.broker, employeeExecution: runtime.employeeExecution, timing, approve: async (permission, approvalSignal) => {
                         const execution = runtime.execution;
                         const toolName = permission.toolCall.name ?? permission.toolCall._meta?.claudeCode?.toolName;
                         if (execution) {
@@ -410,7 +470,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                     }
                     catch (error) {
                         failure = error;
-                        session?.close();
+                        session?.close({ layer: 'adapter', initiator: 'adapter.mapper-failure', reason: closeCode(error, 'MAPPING_FAILED'), action: 'close' });
                     } }, onResponse: response => push(mapper.acpResponse(response)), onDetail: detail => details.record(detail) };
                 const fresh = !live;
                 if (fresh) {
@@ -426,6 +486,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                     if (previous?.sessionId !== session.id)
                         throw new NeedError('SESSION_STATE_INVALID', '持久会话标识与当前进程不一致', '原会话的恢复标识');
                 }
+                promptBaseline = session.promptDispatchCount;
                 const task = (async () => {
                     remoteAttempted = true;
                     try {
@@ -436,16 +497,20 @@ export class CodexRemoteAdapter extends LlmAdapter {
                             session.validatePrompt(input.prompt);
                             if (contextChanged)
                                 await session.newContextSession({ systemPrompt: input.systemPrompt }, modelSignal);
+                            else if (claudeContextChanged)
+                                await session.updateContext({ systemPrompt: input.systemPrompt }, modelSignal, true);
                         }
                         else if (fresh)
                             await session.start(runtime.execution?.hostCwd ?? runtime.cwd, contextChanged || runtime.restartNotice ? undefined : previous?.sessionId, modelSignal, { systemPrompt: contextChanged ? (input.systemPrompt ?? '') : input.systemPrompt, ...(runtime.execution ? { employeeRouting: runtime.execution.routing } : {}), ...(codex ? { codexNewSessionOnly: true } : {}), ...(runtime.employeeExecutionMeta ? { employeeExecution: runtime.employeeExecutionMeta } : {}) }, input.prompt);
                         else if (contextChanged)
                             await session.newContextSession({ systemPrompt: input.systemPrompt }, modelSignal);
                         else {
-                            const updated = await session.updateContext({ systemPrompt: input.systemPrompt }, modelSignal);
-                            if (updated && this.agent.loginProvider === 'claude')
-                                throw new NeedError('SYSTEM_PROMPT_UPDATE_PENDING', 'Claude原会话的系统或开发者要求已变化；主机仅承诺下次上下文整理后生效，本轮未发送，请新建会话应用新要求', '新建Claude会话以立即应用当前系统与开发者要求');
+                            await session.updateContext({ systemPrompt: input.systemPrompt }, modelSignal);
                         }
+                        if (fresh && claudeContextChanged && !runtime.recoveredSession && !runtime.restartNotice)
+                            details.record({ kind: 'session', severity: 'warning', code: 'SYSTEM_PROMPT_UPDATE_DEFERRED', summary: '新要求已通过原会话恢复接口传送；官方仅承诺下次上下文整理后生效，本轮不能保证已立即采用。', payload: { reason: 'OFFICIAL_CONTEXT_UPDATE_DEFERRED' } });
+                        if (!codex)
+                            live.contextSha256 = contextSha256;
                         if (contextChanged) {
                             if (session.id === previous.sessionId)
                                 throw new NeedError('SESSION_STATE_INVALID', '新会话标识与原会话相同，无法确认独立承接，本轮未发送', '独立的新远端会话标识');
@@ -457,24 +522,23 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         const actual = await session.selectModel(selected.value, options.reasoningEffort, modelSignal);
                         catalog.assertCurrent();
                         session.assertModelSelection(selected.value, options.reasoningEffort);
-                        let resolved = selected.resolvedModel;
-                        if (this.agent.loginProvider === 'claude') {
-                            const evidence = session.resolvedModelEvidence;
-                            if (!resolved || (selected.value !== resolved && (!evidence || evidence.modelValue !== selected.value || evidence.resolvedModel !== resolved)))
-                                throw new NeedError('MODEL_RESOLUTION_UNCONFIRMED', '所选模型的具体型号未获得当前会话确认，本轮未发送', '当前会话的具体型号证据');
-                            if (evidence && evidence.resolvedModel !== resolved)
-                                throw new NeedError('MODEL_RESOLUTION_UNCONFIRMED', '当前会话具体型号与所选目录不一致，本轮未发送', '完全一致的具体型号证据');
-                        }
-                        if (!resolved)
-                            throw new NeedError('MODEL_RESOLUTION_UNCONFIRMED', '远端没有提供具体型号证据，本轮未发送', '具体型号证据');
-                        modelConfiguration = { selected: { ...selected, ...(options.reasoningEffort === undefined ? {} : { effort: options.reasoningEffort }) }, configured: actual, resolvedModel: resolved, status: 'remote-configured' };
-                        details.record({ kind: 'session', severity: 'info', code: 'MODEL_CONFIGURATION_CONFIRMED', summary: '本轮选择已由远端配置回执确认；不代表推理效果已验证', payload: modelConfiguration });
+                        // This lease is tied to the trusted host-user and instance/epoch.
+                        // Its mapping and this turn's exact setter ACK are different facts.
+                        const mapping = catalog.models.filter(model => model.value === selected.value);
+                        if (mapping.length !== 1 || mapping[0].id !== selected.id)
+                            throw new NeedError('MODEL_RESOLUTION_UNCONFIRMED', '所选模型在当前主机目录中没有唯一对应型号，本轮未发送', 'CATALOG_VALUE_MAPPING_NOT_UNIQUE');
+                        const resolved = mapping[0].resolvedModel;
+                        if (typeof resolved !== 'string' || !resolved.trim())
+                            throw new NeedError('MODEL_RESOLUTION_UNCONFIRMED', '主机目录没有提供所选模型的具体型号，本轮未发送', 'CATALOG_RESOLVED_MODEL_MISSING');
+                        modelConfiguration = { selected: { ...selected, ...(options.reasoningEffort === undefined ? {} : { effort: options.reasoningEffort }) }, configured: actual, resolvedModel: resolved, status: 'remote-configured', ...(this.agent.loginProvider === 'claude' ? { resolvedModelSource: 'host-user-catalog', sessionModelReported: false } : {}) };
+                        details.record({ kind: 'session', severity: 'info', code: 'MODEL_CONFIGURATION_CONFIRMED', summary: '本轮选择已由远端配置回执确认；' + modelResolutionLabel(modelConfiguration) + '；不代表推理效果已验证', payload: modelConfiguration });
                     }
                     catch (error) {
-                        details.record({ kind: 'session', severity: 'action-required', code: 'MODEL_CONFIGURATION_FAILED', summary: '本轮模型配置未获完整确认，未发送用户输入', payload: { selected, requestedEffort: options.reasoningEffort ?? null, actual: session.modelConfiguration ?? null, reason: error instanceof NeedError ? error.code : error instanceof ModelConfigurationError ? error.message : 'MODEL_CONFIGURATION_FAILED' } });
+                        details.record({ kind: 'session', severity: 'action-required', code: 'MODEL_CONFIGURATION_FAILED', summary: '本轮模型配置未获完整确认，未发送用户输入', payload: { selected, requestedEffort: options.reasoningEffort ?? null, actual: session.modelConfiguration ?? null, reason: error instanceof NeedError ? (error.code === 'MODEL_RESOLUTION_UNCONFIRMED' ? error.requires : error.code) : error instanceof ModelConfigurationError ? error.message : 'MODEL_CONFIGURATION_FAILED' } });
                         throw error;
                     }
                     await timing.run('details-flush', () => details.flush());
+                    recordInformation();
                     await details.flush();
                     details.beginTurn(runtime.detailContext?.() ?? { turn: null, step: null });
                     catalog.assertCurrent();
@@ -519,6 +583,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         yield chunk;
                 }
             }
+            recordInformation();
             details.endTurn();
             await timing.run('details-flush', () => details.flush());
             await details.flush(); // The timing record is a new ordered write, not a retry.
@@ -528,10 +593,13 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 live.usageSnapshot = mapper.usageSnapshot;
             if (modelConfiguration) {
                 const actual = session.modelConfiguration;
-                if (!actual?.confirmed || actual.model !== modelConfiguration.configured.model || actual.effort !== modelConfiguration.configured.effort)
-                    throw new ModelConfigurationError('远端会话在本轮期间改变了模型配置，不能沿用旧回执');
+                const changed = !actual?.confirmed || actual.model !== modelConfiguration.configured.model || actual.effort !== modelConfiguration.configured.effort;
                 catalog.assertCurrent();
-                yield* mapper.text(`\n\n本轮所选模型：${modelConfiguration.selected.name}（${modelConfiguration.selected.value}）；推理等级：${modelConfiguration.selected.effort ?? '沿用远端配置'}。远端已配置模型：${modelConfiguration.configured.model}；具体型号：${modelConfiguration.resolvedModel}；推理等级：${modelConfiguration.configured.effort ?? '远端未提供'}（配置已确认，推理效果未验证）。`);
+                if (changed) {
+                    details.record({ kind: 'session', severity: 'warning', code: 'MODEL_CONFIGURATION_CHANGED_DURING_TURN', summary: '本轮回复已经完成，期间远端配置发生变化；保留真实回复，具体执行型号未单独回报。', payload: { reason: 'POST_PROMPT_CONFIGURATION_CHANGED', configured: modelConfiguration.configured, actual: actual ?? null } });
+                    await details.flush();
+                }
+                yield* mapper.text(`\n\n本轮所选模型：${modelConfiguration.selected.name}（${modelConfiguration.selected.value}）；推理等级：${modelConfiguration.selected.effort ?? '沿用远端配置'}。发送前远端配置回执：${modelConfiguration.configured.model}；${modelResolutionLabel(modelConfiguration)}；推理等级：${modelConfiguration.configured.effort ?? '远端未提供'}（${changed ? '本轮期间配置有变化，实际执行型号未单独回报' : '发送前配置已确认，推理效果未验证'}）。`);
             }
             yield* mapper.flush();
             let recoveryCheckpointId;
@@ -546,7 +614,10 @@ 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 (live && (remoteAttempted || runtime === live.runtime))
+            runtime?.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.turn-failure', reason: closeCode(error, signal.aborted ? 'ABORTED' : 'TURN_FAILED'), action: 'failure' });
+            recordInformation();
+            failureCode = error instanceof NeedError || error instanceof ModelConfigurationError ? error.code : error instanceof LlmError ? error.code : 'TURN_PREPARATION_FAILED';
+            if (live && session && session.promptDispatchCount > promptBaseline)
                 live.failure = { cause: error };
             let reportingFailure;
             if (request?.recordEarlyFailure) {
@@ -580,18 +651,32 @@ export class CodexRemoteAdapter extends LlmAdapter {
             throw error;
         }
         finally {
+            for (const off of abortOffs)
+                off();
             runtime?.execution?.endTurn();
             catalog?.release();
             try {
                 if (preserveRecoveredRuntime || this.shuttingDown || key && this.detached.has(key)) {
-                    session?.close();
-                    await runtime?.detach?.();
+                    session?.close({ layer: 'adapter', initiator: 'adapter.turn-detach', reason: 'TURN_DETACHED', action: 'close' });
+                    await runtime?.detach?.({ layer: 'adapter', initiator: 'adapter.turn-detach', reason: 'TURN_DETACHED', action: 'detach' });
                 }
                 else if (!succeeded || !key || mode !== 'session') {
-                    session?.close();
-                    if (runtime)
+                    session?.close({ layer: 'adapter', initiator: 'adapter.turn-finally', reason: succeeded ? 'TURN_FINISHED' : 'TURN_FAILED', action: 'close' });
+                    if (runtime) {
                         await this.cleanupRuntime(runtime);
+                        if (key && live && !live.failure && this.sessions.get(key) === live) {
+                            if (typeof runtime.dispose === 'function') {
+                                this.sessions.delete(key);
+                                if (!succeeded)
+                                    this.preparationFailures.set(key, failureCode ?? 'TURN_PREPARATION_FAILED');
+                            }
+                            else
+                                live.cleanupFailure = new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '缺少原实例结束证明，不能重开或重发', '原实例的条件结束与list消失证明');
+                        }
+                    }
                 }
+                if (succeeded && key)
+                    this.preparationFailures.delete(key);
             }
             finally {
                 if (key && this.turns.get(key) === turn)
@@ -612,6 +697,8 @@ export class RemoteAgentsAdapter extends LlmAdapter {
     providerInfo(provider) { return this.adapter(provider).providerInfo(provider); }
     listModels(provider) { return this.adapter(provider).listModels(provider); }
     resolveModel(provider, model, signal) { return this.adapter(provider).resolveModel(provider, model, signal); }
+    observeModelInvalidation(fields, changes = []) { for (const adapter of this.adapters.values())
+        adapter.observeModelInvalidation(fields, changes); }
     async invalidateModelState() { await Promise.all([...this.adapters.values()].map(adapter => adapter.invalidateModelState())); }
     async invalidateEmployeeState() { await Promise.all([...this.adapters.values()].map(adapter => adapter.invalidateEmployeeState())); }
     providerRetryPolicy() { return { mode: 'normal', maxRetries: 0, retryableCodes: [], initialDelayMs: 0, maxDelayMs: 0, jitterRatio: 0 }; }
@@ -646,6 +733,7 @@ export function apply(ctx, live) {
     };
     const preflightDiagnostics = createPreflightDiagnostics({ ctx, getApi: get, manager: managerForProfile });
     let changed = () => { };
+    let observeCatalogRevocation = () => { };
     const diagnostics = new Map();
     const diagnostic = (scope, provider, message) => {
         let entry = diagnostics.get(provider);
@@ -667,7 +755,7 @@ export function apply(ctx, live) {
     new CatalogDiagnosticsRemote(ctx, async () => ({ ...await catalogDiagnostics.snapshot(), settingsNamespace: actualSettingsNamespace ?? null, providers: AGENTS.map(agent => ({ provider: agent.id, name: agent.name[language], messages: [...(diagnostics.get(agent.id)?.values() ?? [])] })) }));
     const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes, (...args) => { const state = get()?.getConnectionState(); const connection = state ? { instanceId: state.instanceId, epoch: state.epoch, phase: state.phase } : null; return runCatalog(...args, event => catalogDiagnostics.record({ ...event, connection })); }, () => changed(), (brand, message) => {
         diagnostic('catalog', AGENTS.find(agent => agent.loginProvider === brand).id, message);
-    }, (agent, models, assertCurrent) => defaults?.observe(agent, models, assertCurrent));
+    }, (agent, models, assertCurrent) => defaults?.observe(agent, models, assertCurrent), (fields, changes) => observeCatalogRevocation(fields, changes));
     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, localAcceptanceId: request.localAcceptanceId ?? request.localAcceptance?.acceptanceId });
@@ -758,6 +846,7 @@ export function apply(ctx, live) {
         child.effect(() => () => { current.dispose(); if (defaults === current)
             defaults = undefined; });
     });
+    observeCatalogRevocation = (fields, changes) => adapter.observeModelInvalidation(fields, changes);
     changed = () => { registration.replace(ids); refreshDefault(); void adapter.invalidateModelState().catch(() => { ctx.logger('remote-agent').warn('原会话清理结果未确认，已阻断继续发送；请联系管理员核对。'); }); };
     let employeeConnect = serviceValue('aiWorkbenchConnect'), employeeNetwork = serviceValue('aiWorkbenchNetwork');
     ctx.on('internal/service', service => {

package/dist/local-user-turn.js

@@ -1,4 +1,5 @@
 import { SessionId } from '@deepseek-ai/dsh-session';
+import { sameStoredSessionHeader } from "./session-header.js";
 import { isDeepStrictEqual } from 'node:util';
 import { NeedError } from "./remote.js";
 const failure = (code = 'REMOTE_DETAIL_SCOPE_INVALID') => new NeedError(code, '本轮输入无法核对，已停止本次处理。', '官方当前员工输入与所选远程品牌');
@@ -20,7 +21,7 @@ export async function readLocalUserTurn(ctx, request) {
     let proof, firstFailure;
     try {
         assertCurrent();
-        if (handle.id !== id || handle.access !== 'read' || !isDeepStrictEqual(handle.header, header) || handle.inheritedEventCount !== session.inheritedEventCount)
+        if (handle.id !== id || handle.access !== 'read' || !sameStoredSessionHeader(handle.header, header) || handle.inheritedEventCount !== session.inheritedEventCount)
             throw failure();
         const { events } = await handle.read();
         assertCurrent();

package/dist/model-catalog.d.ts

@@ -1,7 +1,9 @@
+import type { CloseChange } from './close-diagnostics.ts';
 import { type LlmResolvedModelInfo } from '@deepseek-ai/dsh-llm';
 import type { ModelCatalogTarget } from '@ai-workbench/connect/api';
 import type { AgentDefinition } from './agents.ts';
 import { type ConnectApi, type ConnectTarget } from './provider.ts';
+import type { DetailObservation } from './conversation-details.ts';
 export { runCatalog } from './catalog-ssh.ts';
 export interface HostModel {
     id: string;
@@ -24,6 +26,7 @@ export interface CatalogLease {
     readonly signal: AbortSignal;
     assertCurrent(): void;
     release(): void;
+    onInformation?(listener: (entry: DetailObservation) => void): () => void;
 }
 export interface ModelDirectory {
     read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;
@@ -42,6 +45,7 @@ export declare function catalogDiagnostic(issues: readonly CatalogIssue[]): stri
 /** Defaults are provider declarations, never catalog order or display names. */
 export declare function declaredDefault(agent: AgentDefinition, models: readonly HostModel[]): HostModel | undefined;
 export declare function parseHostCatalog(input: string, provider: string, username: string): ParsedCatalog;
+export type CatalogChangeField = 'api-instance' | 'connection-instance' | 'connection-epoch' | 'connection-phase' | 'connection-need-code' | 'catalog-capability' | 'codex-target' | 'claude-target' | 'other-metadata';
 /** Share only pending work; settled results are never cached. */
 export declare class ModelCatalog implements ModelDirectory {
     private get;
@@ -50,6 +54,7 @@ export declare class ModelCatalog implements ModelDirectory {
     private changed;
     private diagnostic;
     private loaded;
+    private revoking;
     private api?;
     private unsubscribe?;
     private signature?;
@@ -57,10 +62,13 @@ export declare class ModelCatalog implements ModelDirectory {
     private disposed;
     private initialized;
     private active;
+    private presentation?;
+    private presentationNeedCode?;
+    private information;
     private flights;
     private serial;
     private latest;
-    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void, diagnostic?: (provider: 'claude' | 'codex', message: string | undefined) => void, loaded?: (agent: AgentDefinition, models: readonly HostModel[], assertCurrent: () => void) => void | Promise<void>);
+    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void, diagnostic?: (provider: 'claude' | 'codex', message: string | undefined) => void, loaded?: (agent: AgentDefinition, models: readonly HostModel[], assertCurrent: () => void) => void | Promise<void>, revoking?: (fields: readonly CatalogChangeField[], changes: readonly CloseChange[]) => void);
     refresh(): void;
     private trusted;
     private assertFlight;