@ai-workbench/remote-agent 0.8.13 → 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/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;

package/dist/model-catalog.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { sameTarget, validateTarget } from "./provider.js";
 import { ModelConfigurationError } from "./model-configuration.js";
@@ -92,6 +93,45 @@ export function parseHostCatalog(input, provider, username) {
     }
     return freeze(structuredClone({ models, issues }));
 }
+function changedCatalogFields(previous, next, switched) {
+    const before = previous ? JSON.parse(previous) : {}, after = JSON.parse(next), fields = [];
+    if (switched)
+        fields.push('api-instance');
+    for (const [key, label] of [['instanceId', 'connection-instance'], ['epoch', 'connection-epoch'], ['phase', 'connection-phase'], ['needCode', 'connection-need-code']])
+        if (JSON.stringify(before.state?.[key]) !== JSON.stringify(after.state?.[key]))
+            fields.push(label);
+    if (before.capability !== after.capability)
+        fields.push('catalog-capability');
+    for (const [index, label] of [[0, 'codex-target'], [1, 'claude-target']])
+        if (JSON.stringify(before.targets?.[index]) !== JSON.stringify(after.targets?.[index]))
+            fields.push(label);
+    return fields.length ? fields : ['other-metadata'];
+}
+function catalogChanges(previous, next, switched) {
+    const before = previous ? JSON.parse(previous) : {}, after = JSON.parse(next), changes = [];
+    const scalar = (value) => typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' ? value : null;
+    const compare = (field, old, current) => { if (JSON.stringify(old) !== JSON.stringify(current))
+        changes.push({ field, before: scalar(old), after: scalar(current) }); };
+    const fingerprint = (value) => value === undefined ? null : createHash('sha256').update(JSON.stringify(value)).digest('hex');
+    if (switched)
+        changes.push({ field: 'catalog.api-replaced', before: false, after: true });
+    for (const [key, name] of [['instanceId', 'instance-id'], ['epoch', 'epoch'], ['phase', 'phase'], ['needCode', 'need-code']])
+        compare('connection.' + name, before.state?.[key], after.state?.[key]);
+    compare('catalog.capability', before.capability, after.capability);
+    for (const [index, provider] of [[0, 'codex'], [1, 'claude']]) {
+        const a = before.targets?.[index], b = after.targets?.[index], prefix = 'catalog.' + provider + '.';
+        compare(prefix + 'ok', a?.ok, b?.ok);
+        compare(prefix + 'error-code', a?.code, b?.code);
+        for (const [key, name] of [['instanceId', 'instance-id'], ['epoch', 'epoch'], ['provider', 'provider']])
+            compare(prefix + name, a?.value?.[key], b?.value?.[key]);
+        // Protect executable argv, trust/config paths and arbitrary future metadata: values are digests.
+        compare(prefix + 'target-sha256', fingerprint(a?.value?.target), fingerprint(b?.value?.target));
+        compare(prefix + 'metadata-sha256', fingerprint(a), fingerprint(b));
+    }
+    if (!changes.length)
+        changes.push({ field: 'catalog.signature-sha256', before: fingerprint(before), after: fingerprint(after) });
+    return changes;
+}
 /** Share only pending work; settled results are never cached. */
 export class ModelCatalog {
     get;
@@ -100,6 +140,7 @@ export class ModelCatalog {
     changed;
     diagnostic;
     loaded;
+    revoking;
     api;
     unsubscribe;
     signature;
@@ -107,16 +148,20 @@ export class ModelCatalog {
     disposed = false;
     initialized = false;
     active = new Set();
+    presentation;
+    presentationNeedCode;
+    information = new Set();
     flights = new Map();
     serial = 0;
     latest = new Map();
-    constructor(get, maxBytes, run = runCatalog, changed = () => { }, diagnostic = () => { }, loaded = () => { }) {
+    constructor(get, maxBytes, run = runCatalog, changed = () => { }, diagnostic = () => { }, loaded = () => { }, revoking = () => { }) {
         this.get = get;
         this.maxBytes = maxBytes;
         this.run = run;
         this.changed = changed;
         this.diagnostic = diagnostic;
         this.loaded = loaded;
+        this.revoking = revoking;
         this.refresh();
     }
     refresh() {
@@ -125,11 +170,19 @@ export class ModelCatalog {
         const info = api?.getContractInfo?.();
         const targets = info?.modelCatalogTarget === 1 && api?.getModelCatalogTarget ? ['codex', 'claude'].map(brand => api.getModelCatalogTarget(brand)) : undefined;
         // L's same-epoch recovery wording is presentation metadata, not an execution change.
-        const executionState = state && { instanceId: state.instanceId, epoch: state.epoch, phase: state.phase, needCode: state.need?.code };
+        const executionState = state && { instanceId: state.instanceId, epoch: state.epoch, phase: state.phase };
         const executionTargets = targets?.map(result => result.ok ? result : { ok: false, code: result.error.code });
         const signature = JSON.stringify({ state: executionState, capability: info?.modelCatalogTarget, targets: executionTargets });
         const switched = api !== this.api;
         const changed = this.initialized && (switched || signature !== this.signature);
+        const presentation = createHash('sha256').update(JSON.stringify({ need: { code: state?.need?.code, message: state?.need?.message, requires: state?.need?.requires }, recovery: state?.recovery && { phase: state.recovery.phase, message: state.recovery.message, startedAt: state.recovery.startedAt, administratorAfterMs: state.recovery.administratorAfterMs } })).digest('hex');
+        if (this.initialized && !changed && presentation !== this.presentation) {
+            const entry = { kind: 'session', severity: 'info', code: 'CATALOG_SCOPE_INFORMATION', summary: '连接说明已变化；主机身份、连接代际和可信目标未变，本轮继续。', payload: { reason: 'CATALOG_PRESENTATION_CHANGED', before: { needCode: this.presentationNeedCode ?? null, presentationSha256: this.presentation ?? null }, after: { needCode: state?.need?.code ?? null, presentationSha256: presentation } } };
+            for (const listener of this.information)
+                listener(entry);
+        }
+        this.presentation = presentation;
+        this.presentationNeedCode = state?.need?.code;
         this.initialized = true;
         if (switched) {
             this.unsubscribe?.();
@@ -143,8 +196,10 @@ export class ModelCatalog {
             this.unsubscribe = () => { for (const stop of off)
                 stop(); };
         }
+        const changedFields = changed ? changedCatalogFields(this.signature, signature, switched) : [], changes = changed ? catalogChanges(this.signature, signature, switched) : [];
         this.signature = signature;
         if (changed) {
+            this.revoking(changedFields, changes);
             this.revision++;
             this.latest.clear();
             for (const controller of this.active)
@@ -224,8 +279,10 @@ export class ModelCatalog {
     }
     async read(agent, signal) {
         let flight, released = false;
+        const listeners = new Set();
         const release = () => { if (released || !flight)
-            return; released = true; flight.users--; if (!flight.users) {
+            return; released = true; for (const listener of listeners)
+            this.information.delete(listener); listeners.clear(); flight.users--; if (!flight.users) {
             if (flight.pending)
                 flight.controller.abort();
             else
@@ -277,7 +334,8 @@ export class ModelCatalog {
                     abort();
             });
             assertCurrent();
-            return { target: own.target, models, signal: combined, assertCurrent, release };
+            return { target: own.target, models, signal: combined, assertCurrent, release, onInformation: listener => { if (released)
+                    return () => { }; listeners.add(listener); this.information.add(listener); return () => { listeners.delete(listener); this.information.delete(listener); }; } };
         }
         catch (error) {
             release();
@@ -288,7 +346,7 @@ export class ModelCatalog {
         }
     }
     dispose() { this.disposed = true; this.unsubscribe?.(); this.flights.clear(); for (const controller of this.active)
-        controller.abort(); this.active.clear(); }
+        controller.abort(); this.active.clear(); this.information.clear(); }
 }
 export function modelInfo(provider, model) {
     // Official rc.2 represents no reasoning levels by absence, and rejects an empty efforts array.