@ai-workbench/remote-agent 0.8.13 → 0.8.15

package/dist/employee-tools.js

@@ -94,13 +94,14 @@ export function createEmployeeTools(options) {
         throw failure('EMPLOYEE_OUTPUT_TOO_LARGE'); };
     async function run(command, args, signal, detail, timeout) {
         signal.throwIfAborted();
+        const diagnostics = options.closeDiagnostics?.child(detail);
         const operation = new Promise((yes, no) => {
             const child = spawn(command, args, { cwd: options.cwd, env: process.env, stdio: ['pipe', 'pipe', 'pipe'] });
             child.stdin.end();
             let bytes = 0, stdout = [], stderr = [], failed, killTimer, timeoutTimer;
-            const kill = (which) => { if (child.exitCode === null && child.signalCode === null)
+            const kill = (which) => { diagnostics?.record({ layer: 'executor', initiator: 'tools.process-kill', reason: failed?.code ?? 'PROCESS_CLEANUP', action: 'terminate', signal: which }); if (child.exitCode === null && child.signalCode === null)
                 child.kill(which); };
-            const stop = (code) => { if (failed)
+            const stop = (code) => { diagnostics?.record({ layer: 'executor', initiator: 'tools.process-stop', reason: code, action: 'terminate', changes: [{ field: 'tools.stop-code', before: failed?.code ?? null, after: failed?.code ?? code }] }); if (failed)
                 return; failed = failure(code); kill('SIGTERM'); killTimer = setTimeout(() => kill('SIGKILL'), options.killGraceMs); killTimer.unref(); };
             const aborted = () => stop('EMPLOYEE_CANCELLED_UNKNOWN');
             const collect = (dest, chunk) => { bytes += chunk.length; if (bytes > options.maxBytes) {
@@ -116,8 +117,8 @@ export function createEmployeeTools(options) {
                 stop('CONVERSATION_DETAILS_FAILED');
             } if (signal.aborted)
                 aborted(); });
-            child.on('error', e => { failed ??= failure(e.code === 'ENOENT' ? 'EMPLOYEE_COMMAND_UNAVAILABLE' : 'EMPLOYEE_PROCESS_FAILED'); });
-            child.on('close', (exitCode, exitSignal) => { signal.removeEventListener('abort', aborted); if (killTimer)
+            child.on('error', e => { diagnostics?.record({ layer: 'executor', initiator: 'tools.process-error', reason: e.code === 'ENOENT' ? 'EMPLOYEE_COMMAND_UNAVAILABLE' : 'EMPLOYEE_PROCESS_FAILED', action: 'failure' }); failed ??= failure(e.code === 'ENOENT' ? 'EMPLOYEE_COMMAND_UNAVAILABLE' : 'EMPLOYEE_PROCESS_FAILED'); });
+            child.on('close', (exitCode, exitSignal) => { diagnostics?.record({ layer: 'executor', initiator: 'tools.process-close', reason: failed?.code ?? 'PROCESS_EXIT', action: 'exit', exitCode, signal: exitSignal }); signal.removeEventListener('abort', aborted); if (killTimer)
                 clearTimeout(killTimer); if (timeoutTimer)
                 clearTimeout(timeoutTimer); failed ? no(failed) : yes({ stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8'), exitCode, signal: exitSignal }); });
             signal.addEventListener('abort', aborted, { once: true });
@@ -287,6 +288,6 @@ export function createEmployeeTools(options) {
     }
     return {
         call(name, input, requestSignal, observer) { const operation = call(name, input, requestSignal, observer); calls.add(operation); void operation.then(() => calls.delete(operation), () => calls.delete(operation)); return operation; },
-        async close() { lifetime.abort(); await Promise.allSettled([...calls, ...children]); },
+        async close(cause = { layer: 'executor', initiator: 'tools.close', reason: 'EMPLOYEE_TOOLS_CLOSED', action: 'close' }) { options.closeDiagnostics?.record({ ...cause, changes: cause.changes ?? [{ field: 'tools.aborted', before: lifetime.signal.aborted, after: true }] }); lifetime.abort(); await Promise.allSettled([...calls, ...children]); },
     };
 }

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { type CloseChange } from './close-diagnostics.ts';
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import { LlmAdapter, type GenerateOptions, type StreamChunk } from '@deepseek-ai/dsh-llm';
@@ -74,6 +75,9 @@ export declare class CodexRemoteAdapter extends LlmAdapter {
     private shuttingDown;
     private detached;
     private cleanups;
+    private preparationFailures;
+    private modelPresentation;
+    private employeeNoticeSessions;
     constructor(config: PluginConfig | (() => PluginConfig), resolveRuntime: RuntimeProvider, approve?: InvocationApproval | undefined, providerName?: () => string, agent?: AgentDefinition, readImage?: ImageReader | undefined, reportLoginFailure?: LoginFailureReporter | undefined, directory?: ModelDirectory | undefined, preflightDiagnostics?: PreflightDiagnostics | undefined);
     providerInfo(provider: string): {
         id: string;
@@ -83,9 +87,14 @@ export declare class CodexRemoteAdapter extends LlmAdapter {
     listModels(provider: string): Promise<(import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo & {
         catalog: HostModel;
     })[]>;
-    resolveModel(provider: string, id: string, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo & {
-        catalog: HostModel;
+    resolveModel(provider: string, id: string, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo>;
+    prepareCall(provider: string, id: string, signal?: AbortSignal): Promise<{
+        model: import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo & {
+            catalog: HostModel;
+        };
+        stream: (options: GenerateOptions) => AsyncGenerator<StreamChunk, any, any>;
     }>;
+    observeModelInvalidation(fields: readonly string[], changes?: readonly CloseChange[]): void;
     invalidateModelState(): Promise<void>;
     invalidateEmployeeState(): Promise<void>;
     providerRetryPolicy(): {
@@ -115,9 +124,14 @@ export declare class RemoteAgentsAdapter extends LlmAdapter {
     listModels(provider: string): Promise<(import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo & {
         catalog: HostModel;
     })[]>;
-    resolveModel(provider: string, model: string, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo & {
-        catalog: HostModel;
+    resolveModel(provider: string, model: string, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo>;
+    prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<{
+        model: import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo & {
+            catalog: HostModel;
+        };
+        stream: (options: GenerateOptions) => AsyncGenerator<StreamChunk, any, any>;
     }>;
+    observeModelInvalidation(fields: readonly string[], changes?: readonly CloseChange[]): void;
     invalidateModelState(): Promise<void>;
     invalidateEmployeeState(): Promise<void>;
     providerRetryPolicy(): {

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';
@@ -24,6 +25,8 @@ import { approvalLabel } from "./approval-label.js";
 import { StageTiming } from "./stage-timing.js";
 import { verifyRecoveryCheckpoint, currentInputIds } from "./recovery-checkpoint.js";
 import { ModelCatalog, modelInfo } from "./model-catalog.js";
+import { ModelPresentation, unavailableModelInfo } from "./model-presentation.js";
+import { EMPLOYEE_EXECUTION_NOTICE, employeeNoticePreviouslyShown } from "./employee-presentation.js";
 import { ModelConfigurationError } from "./model-configuration.js";
 import { officialEmployeeWorkspace } from "./employee-workspace.js";
 import { nativeWorkspaceSourceConfirmation } from "./workspace-source-confirmation.js";
@@ -54,13 +57,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 +114,9 @@ export class CodexRemoteAdapter extends LlmAdapter {
     shuttingDown = false;
     detached = new Set();
     cleanups = new WeakMap();
+    preparationFailures = new Map();
+    modelPresentation = new ModelPresentation();
+    employeeNoticeSessions = new Set();
     constructor(config, resolveRuntime, approve, providerName = () => PROVIDER_NAMES.en, agent = CODEX_AGENT, readImage, reportLoginFailure, directory, preflightDiagnostics) {
         super();
         this.resolveRuntime = resolveRuntime;
@@ -120,18 +133,21 @@ export class CodexRemoteAdapter extends LlmAdapter {
     catalog(signal) { if (!this.directory)
         throw new LlmError('无法获取模型列表：缺少可信主机目录能力', 'MODEL_CATALOG_UNAVAILABLE'); return this.directory.read(this.agent, signal); }
     async listModels(provider) { const catalog = await this.catalog(); try {
+        this.modelPresentation.remember(catalog);
         return catalog.models.map(model => modelInfo(provider, model));
     }
     finally {
         catalog.release();
     } }
     async resolveModel(provider, id, signal) { try {
+        signal?.throwIfAborted();
+        const displayed = this.modelPresentation.resolve(provider, id);
+        if (displayed)
+            return displayed;
         const catalog = await this.catalog(signal);
         try {
             const model = catalog.models.find(model => model.id === id);
-            if (!model)
-                throw new LlmError(id === 'remote' ? '无法获取模型列表：这个会话保存的是旧版模型选择，请打开本会话的模型菜单，重新选择模型后再发送。' : '所选模型已不在当前主机目录中，请打开本会话的模型菜单重新选择模型。', 'MODEL_CATALOG_UNAVAILABLE');
-            return modelInfo(provider, model);
+            return model ? modelInfo(provider, model) : unavailableModelInfo(provider, id);
         }
         finally {
             catalog.release();
@@ -141,16 +157,43 @@ 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))); }
+    async prepareCall(provider, id, signal) {
+        try {
+            const catalog = await this.catalog(signal);
+            try {
+                catalog.assertCurrent();
+                const selected = catalog.models.find(model => model.id === id);
+                if (!selected)
+                    throw new LlmError('所选模型已不在当前主机目录中，请在模型菜单重新选择后再发送；本次输入尚未发送。', 'MODEL_CATALOG_UNAVAILABLE');
+                return { model: modelInfo(provider, selected), stream: (options) => this.stream(options) };
+            }
+            finally {
+                catalog.release();
+            }
+        }
+        catch (error) {
+            markModelPreparationFailure(provider, error, signal);
+            throw error;
+        }
+    }
+    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 +205,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 +221,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,7 +237,11 @@ 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;
+        this.modelPresentation.clear();
+        this.employeeNoticeSessions.clear();
         const results = await Promise.allSettled([...new Set([...this.sessions.keys(), ...this.turns.keys()])].map(id => this.detachSession(id)));
         this.lifetime.abort();
         const failure = results.find(result => result.status === 'rejected');
@@ -239,6 +288,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 +296,26 @@ 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;
+        let employeeNoticeShown = false;
+        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 +323,42 @@ 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);
+            employeeNoticeShown = !!key && this.employeeNoticeSessions.has(key) || employeeNoticePreviouslyShown(options);
+            if (employeeNoticeShown && key)
+                this.employeeNoticeSessions.add(key);
+            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 +376,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 +396,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,14 +448,26 @@ 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));
             activeMapper = mapper;
             let id;
             let stop;
-            if (runtime.employeePresentation) {
-                yield* mapper.text(runtime.employeePresentation + '\n\n');
+            if (runtime.employeePresentation)
+                details.record({ kind: 'session', severity: 'warning', code: 'EMPLOYEE_EXECUTION_SCOPE', summary: runtime.employeePresentation, payload: { source: 'local' } });
+            if (runtime.execution)
+                details.record({ kind: 'session', severity: 'warning', code: 'CLAUDE_EMPLOYEE_SCOPE', summary: runtime.execution.notice, payload: runtime.execution.scope });
+            if ((runtime.employeePresentation || runtime.execution) && !employeeNoticeShown) {
+                for (const chunk of mapper.text(EMPLOYEE_EXECUTION_NOTICE + '\n\n')) {
+                    if (chunk.type === 'text-delta') {
+                        employeeNoticeShown = true;
+                        if (key)
+                            this.employeeNoticeSessions.add(key);
+                    }
+                    yield chunk;
+                }
                 yield* mapper.flush();
             }
             if (runtime.workspaceNotice) {
@@ -375,11 +478,6 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 yield* mapper.text(runtime.restartNotice + '\n\n');
                 yield* mapper.flush();
             }
-            if (runtime.execution) {
-                details.record({ kind: 'session', severity: 'warning', code: 'CLAUDE_EMPLOYEE_SCOPE', summary: '本机工具路由及未覆盖操作范围', payload: runtime.execution.scope });
-                yield* mapper.text(runtime.execution.notice + '\n\n');
-                yield* mapper.flush();
-            }
             if (mode === 'session') {
                 if (live && live.runtime !== runtime)
                     throw new NeedError('SESSION_TRANSPORT_MISMATCH', '原会话的主机通道已更换，不能自动切换进程', '原主机会话通道');
@@ -390,7 +488,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 +508,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 +524,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 +535,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 +560,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 +621,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 +631,12 @@ 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.flush();
             let recoveryCheckpointId;
@@ -541,12 +646,16 @@ export class CodexRemoteAdapter extends LlmAdapter {
                     recoveryCheckpointId = id;
             }
             const previousRemoteSessions = [...(previous?.previousRemoteSessions ?? []), ...(contextChanged ? [{ sessionId: previous.sessionId, contextSha256: previous.contextSha256 }] : [])];
-            const pointer = { ...(previousRemoteSessions.length ? { previousRemoteSessions } : {}), ...(modelConfiguration ? { modelConfiguration } : {}), ...(recoveryCheckpointId ? { recoveryCheckpointId } : {}), ...(runtime.workspaceNotice ? { presentation: { workspaceNotice: runtime.workspaceNotice } } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), mode, identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
+            const presentation = { ...(runtime.workspaceNotice ? { workspaceNotice: runtime.workspaceNotice } : {}), ...(employeeNoticeShown ? { employeeExecutionNotice: 'local-v1' } : {}) };
+            const pointer = { ...(previousRemoteSessions.length ? { previousRemoteSessions } : {}), ...(modelConfiguration ? { modelConfiguration } : {}), ...(recoveryCheckpointId ? { recoveryCheckpointId } : {}), ...(Object.keys(presentation).length ? { presentation } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), mode, identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
             succeeded = true;
             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 +689,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 +735,9 @@ 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); }
+    prepareCall(provider, model, signal) { return this.adapter(provider).prepareCall(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 +772,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 +794,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 +885,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 => {