@ai-workbench/remote-agent 0.8.1 → 0.8.5

package/dist/broker.js

@@ -1,17 +1,8 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { protectedOneShotLayout } from "./host-layout.js";
+import { ProtocolBoundary } from "./protocol-boundary.js";
 import { NeedError, shellQuote } from "./remote.js";
 import { CODEX_AGENT } from "./agents.js";
-import { identity, unwrap, validateTarget, sameTarget } from "./provider.js";
 /** One byte stream / SDK app, multiple SSH attachments. Input is never replayed. */
 export class BrokerTransport {
     readable;
@@ -30,10 +21,23 @@ export class BrokerTransport {
     approvalSent = false;
     unconfirmed = new Set();
     failure;
+    heartbeat;
+    boundary;
+    recovering = false;
+    promptSent = false;
+    preparingInputs = 0;
+    inputTail = Promise.resolve();
+    exclusive(operation) { const task = this.inputTail.then(operation); this.inputTail = task.catch(() => { }); return task; }
     constructor(options) {
         if (!Number.isSafeInteger(options.maxFrameBytes) || options.maxFrameBytes < 1)
             throw new NeedError('SETTINGS_REQUIRED', '我需要 brokerMaxFrameBytes', '管理员确认 brokerMaxFrameBytes');
         this.options = options;
+        this.cursor = options.initialSequence ?? 0;
+        if (!Number.isSafeInteger(this.cursor) || this.cursor < 0)
+            throw new NeedError('RECOVERY_CURSOR_INVALID', '会话恢复位置无效', '已处理的安全游标');
+        if (options.maxMessageBytes)
+            this.boundary = new ProtocolBoundary(options.maxMessageBytes);
+        this.recovering = !!options.recoverySessionId;
         this.lease.abort();
         this.readable = new ReadableStream({ start: c => { this.output = c; }, pull: () => { this.attachment?.stdout.resume(); }, cancel: () => { this.close(); } });
         this.writable = new WritableStream({ write: bytes => this.write(bytes), close: () => this.close(), abort: () => this.close() });
@@ -43,11 +47,46 @@ export class BrokerTransport {
     get signal() { return this.lease.signal; }
     get lastSequence() { return this.cursor; }
     get error() { return this.failure; }
+    get promptInFlight() { return this.promptSent; }
+    processedMessage(message) { this.boundary?.consumed(message); }
+    checkpointSequence() { return this.online && this.preparingInputs === 0 && !!this.boundary?.complete && !this.approvalSent && this.unconfirmed.size === 0 ? this.cursor : null; }
+    async commitCheckpoint(commit) { return this.exclusive(async () => { const cursor = this.checkpointSequence(); if (cursor === null)
+        return false; await commit(cursor); return true; }); }
+    finishRecovery() { if (!this.boundary?.wholeLine)
+        throw new NeedError('RECOVERY_INCOMPLETE_OUTPUT', '原会话输出停在不完整消息中', '安全结束并新建会话'); this.recovering = false; }
+    async replayThrough(sequence, signal) {
+        const inspect = () => { signal?.throwIfAborted(); if (this.failure)
+            throw this.failure; if (this.cursor >= sequence) {
+            if (!this.boundary?.wholeLine)
+                throw new NeedError('RECOVERY_INCOMPLETE_OUTPUT', '原会话输出不完整', '安全结束并新建会话');
+            return true;
+        } return false; };
+        if (inspect())
+            return;
+        await new Promise((resolve, reject) => { let off = () => { }; const clear = () => { off(); signal?.removeEventListener('abort', changed); }; const changed = () => { try {
+            if (inspect()) {
+                clear();
+                resolve();
+            }
+        }
+        catch (error) {
+            clear();
+            reject(error);
+        } }; off = this.onChange(changed); signal?.addEventListener('abort', changed, { once: true }); changed(); });
+    }
+    stopHeartbeat() { if (this.heartbeat !== undefined)
+        clearInterval(this.heartbeat); this.heartbeat = undefined; }
+    recoveryMessage(message) {
+        const params = message.params;
+        if (Object.hasOwn(message, 'id') || message.method !== 'session/update' || params?.sessionId !== this.options.recoverySessionId || !['available_commands_update', 'current_mode_update', 'config_option_update', 'session_info_update', 'usage_update'].includes(params?.update?.sessionUpdate ?? ''))
+            throw new NeedError('RECOVERY_UNSAFE_OUTPUT', '原会话有未确认输出或旧交互，不能代答', '安全结束并新建会话');
+        this.options.onRecoveryUpdate?.(message);
+    }
     authorizeResponse(id, generation) { this.permits.set(JSON.stringify(id), generation); }
     /** Called only by the ACP protocol layer after a matching result or current-turn output. */
     acknowledge(method) { this.unconfirmed.delete(method); }
     /** A matching terminal prompt response settles all approval replies in that turn. */
-    completePrompt() { this.unconfirmed.delete('session/prompt'); this.approvalSent = false; for (const key of this.unconfirmed)
+    completePrompt() { this.promptSent = false; this.unconfirmed.delete('session/prompt'); this.approvalSent = false; for (const key of this.unconfirmed)
         if (key.startsWith('response:'))
             this.unconfirmed.delete(key); }
     onChange(fn) { this.listeners.add(fn); return () => this.listeners.delete(fn); }
@@ -57,6 +96,7 @@ export class BrokerTransport {
     fail(error) {
         if (this.ended)
             return;
+        this.stopHeartbeat();
         this.failure = error;
         this.ended = true;
         this.attached = false;
@@ -72,6 +112,7 @@ export class BrokerTransport {
     close() {
         if (this.ended)
             return;
+        this.stopHeartbeat();
         this.ended = true;
         this.attached = false;
         this.lease.abort();
@@ -127,6 +168,7 @@ export class BrokerTransport {
         child.stdin.on('error', () => { });
         let partial = Buffer.alloc(0);
         let ready = false;
+        let attemptClosed = false;
         const connected = Promise.withResolvers();
         // A local end suppresses detached(), so settle the handshake independently.
         const off = this.onChange(() => { if (this.ended)
@@ -136,6 +178,23 @@ export class BrokerTransport {
             if (f.type === 'ready') {
                 if (ready)
                     throw new NeedError('BROKER_PROTOCOL_INVALID', 'broker 重复 ready', '有效的 broker 帧');
+                if (this.options.instanceId && f.instanceId !== this.options.instanceId)
+                    throw new NeedError('SESSION_INSTANCE_MISMATCH', '主机会话已被替换，未接入或结束替代进程', '当前会话实例');
+                if (this.options.leased) {
+                    if (f.controlMaxBytes !== this.options.controlMaxBytes || !Number.isSafeInteger(f.controlMaxBytes) || f.controlMaxBytes < Buffer.byteLength(JSON.stringify({ type: 'input', data: '' })) + 4)
+                        throw new NeedError('LEASE_CAPACITY_INVALID', '主机会话容量无法承载租约输入', 'S实际冻结的controlMaxBytes');
+                    const policy = f.lifecycle;
+                    if (!policy || typeof policy.enabled !== 'boolean' || policy.enabled && (!Number.isSafeInteger(policy.heartbeatIntervalMs) || policy.heartbeatIntervalMs < 1 || !Number.isSafeInteger(policy.attachLeaseMs) || policy.attachLeaseMs < 3 * policy.heartbeatIntervalMs))
+                        throw new NeedError('LEASE_POLICY_INVALID', '主机未给出有效客户端租约策略', 'S实际冻结的生命周期策略');
+                    if (policy.enabled) {
+                        this.stopHeartbeat();
+                        this.heartbeat = setInterval(() => { if (this.online && this.attachment === child) {
+                            child.stdin.write('{"type":"heartbeat"}\n', error => { if (error)
+                                child.kill('SIGTERM'); });
+                        } }, policy.heartbeatIntervalMs);
+                        this.heartbeat.unref?.();
+                    }
+                }
                 ready = true;
                 this.attached = true;
                 this.lease = new AbortController();
@@ -143,8 +202,17 @@ export class BrokerTransport {
                 connected.resolve();
                 return;
             }
-            if (f.type === 'error')
-                throw new NeedError(typeof f.code === 'string' ? f.code : 'BROKER_FAILED', '主机会话无法续接（' + (typeof f.code === 'string' ? f.code : '未知错误') + '）；没有重放输入或代答审批', '恢复或显式结束原会话');
+            if (f.type === 'error') {
+                const code = typeof f.code === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/.test(f.code) ? f.code : 'BROKER_PROTOCOL_INVALID';
+                const error = new NeedError(code, '主机会话无法续接（' + code + '）；没有重放输入或代答审批', '恢复或显式结束原会话');
+                if (!ready && f.code === 'ATTACH_BUSY') {
+                    attemptClosed = true;
+                    connected.reject(error);
+                    child.kill('SIGTERM');
+                    return;
+                }
+                throw error;
+            }
             if (f.type === 'exit') {
                 connected.reject(new NeedError('AGENT_EXITED', '主机 agent 已退出', '重新建立会话'));
                 this.fail(new NeedError('AGENT_EXITED', '主机 agent 已退出，退出状态不代表本轮完成', '确认主机状态'));
@@ -157,14 +225,19 @@ export class BrokerTransport {
                 return;
             if (seq !== this.cursor + 1)
                 throw new NeedError('REPLAY_GAP', '主机输出存在缺口，不能安全继续审批', '显式结束或恢复原会话');
-            if (f.channel === 'stdout')
-                this.output.enqueue(Buffer.from(f.data, 'base64'));
+            if (f.channel === 'stdout') {
+                const bytes = Buffer.from(f.data, 'base64');
+                this.boundary?.receive(bytes, this.recovering ? message => this.recoveryMessage(message) : undefined);
+                if (!this.recovering && !this.options.discardOutput)
+                    this.output.enqueue(bytes);
+            }
             this.cursor = seq;
+            this.changed();
             if ((this.output.desiredSize ?? 0) <= 0)
                 child.stdout.pause();
         };
         child.stdout.on('data', (bytes) => {
-            if (this.ended || generation !== this.epoch)
+            if (attemptClosed || this.ended || generation !== this.epoch)
                 return;
             try {
                 partial = Buffer.concat([partial, bytes]);
@@ -178,7 +251,7 @@ export class BrokerTransport {
                     if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object')
                         throw Error('frame');
                     frame(parsed);
-                    if (this.ended)
+                    if (this.ended || attemptClosed)
                         return;
                 }
                 if (partial.length > this.options.maxFrameBytes)
@@ -189,8 +262,9 @@ export class BrokerTransport {
             }
         });
         const detached = () => {
-            if (generation !== this.epoch || this.ended)
+            if (attemptClosed || generation !== this.epoch || this.ended)
                 return;
+            this.stopHeartbeat();
             this.attached = false;
             this.lease.abort();
             this.changed();
@@ -212,6 +286,15 @@ export class BrokerTransport {
         return connected.promise.finally(off);
     }
     async write(bytes) {
+        this.preparingInputs++;
+        try {
+            return await this.exclusive(() => this.send(bytes));
+        }
+        finally {
+            this.preparingInputs--;
+        }
+    }
+    async send(bytes) {
         if (!this.online || !this.attachment)
             throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '连接不在线，输入没有排队或重放', '恢复连接并确认原会话状态');
         let response;
@@ -222,22 +305,46 @@ export class BrokerTransport {
             throw new NeedError('ACP_INPUT_INVALID', 'ACP 输出不是一条完整 JSON 消息', '有效的 ACP SDK 字节输出');
         }
         const selected = response.result?.outcome?.outcome === 'selected';
-        if (selected) {
-            const key = JSON.stringify(response.id);
-            const permit = this.permits.get(key);
-            this.permits.delete(key);
-            if (permit !== this.epoch)
+        const generation = this.epoch;
+        const child = this.attachment;
+        const eligible = () => {
+            if (!this.online || this.attachment !== child || this.epoch !== generation)
+                throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '连接已改变，未重放输入或审批', '原连接的有效发送许可');
+            if (selected && this.permits.get(JSON.stringify(response.id)) !== generation)
                 throw new NeedError('APPROVAL_STALE', '连接已改变，旧审批未发送', '重连后的本次审批');
+        };
+        eligible();
+        await this.options.beforeInput?.();
+        eligible();
+        if (selected) {
+            this.permits.delete(JSON.stringify(response.id));
             this.approvalSent = true;
         }
         this.unconfirmed.add(response.method ?? 'response:' + JSON.stringify(response.id));
-        const child = this.attachment;
-        await new Promise((resolve, reject) => {
-            const closed = () => { cleanup(); reject(new NeedError('INPUT_DELIVERY_UNCONFIRMED', '输入送达未确认，未重发', '确认原进程状态')); };
-            const cleanup = () => { child.removeListener('close', closed); };
-            child.once('close', closed);
-            child.stdin.write(bytes, error => { cleanup(); error ? reject(new NeedError('INPUT_DELIVERY_UNCONFIRMED', '输入送达失败，未重发', '确认原进程状态')) : resolve(); });
-        });
+        const chunks = [];
+        if (this.options.leased) {
+            const size = Math.floor((this.options.controlMaxBytes - Buffer.byteLength(JSON.stringify({ type: 'input', data: '' }))) / 4) * 3;
+            if (size < 1)
+                throw new NeedError('LEASE_CAPACITY_INVALID', '主机会话容量无法承载输入', '有效controlMaxBytes');
+            for (let offset = 0; offset < bytes.byteLength; offset += size)
+                chunks.push(Buffer.from(JSON.stringify({ type: 'input', data: Buffer.from(bytes.subarray(offset, offset + size)).toString('base64') }) + '\n'));
+        }
+        else
+            chunks.push(Buffer.from(bytes));
+        for (const [index, chunk] of chunks.entries()) {
+            if (!this.online || this.attachment !== child || this.epoch !== generation)
+                throw new NeedError('INPUT_DELIVERY_UNCONFIRMED', '分块发送期间断线，未重放输入', '原主机连接');
+            await new Promise((resolve, reject) => {
+                const closed = () => { cleanup(); reject(new NeedError('INPUT_DELIVERY_UNCONFIRMED', '输入送达未确认，未重发', '确认原进程状态')); };
+                const cleanup = () => { child.removeListener('close', closed); };
+                child.once('close', closed);
+                if (response.method === 'session/prompt' && index === chunks.length - 1)
+                    this.promptSent = true;
+                child.stdin.write(chunk, error => { cleanup(); error ? reject(new NeedError('INPUT_DELIVERY_UNCONFIRMED', '输入送达失败，未重发', '确认原进程状态')) : resolve(); });
+            });
+        }
+        if (!response.method)
+            this.boundary?.responded(response.id);
     }
 }
 export function controlNeed(stderr) {
@@ -277,8 +384,9 @@ export function sshIo(target, argv, maxControlBytes) {
         }) };
 }
 export function brokerCommand(t, args) { return `AW_SESSION_ROOT=${shellQuote(t.session.root)} ${shellQuote(t.session.command)} ${args.map(shellQuote).join(' ')}`; }
-export function brokerId(sessionId, agentId = CODEX_AGENT.id) { return (agentId === CODEX_AGENT.id ? 'x' : 'a') + createHash('sha256').update(agentId === CODEX_AGENT.id ? sessionId : agentId + '/' + sessionId).digest('hex').slice(0, 23); }
-function controlJson(text) {
+export function legacyBrokerId(sessionId, agentId = CODEX_AGENT.id) { return (agentId === CODEX_AGENT.id ? 'x' : 'a') + createHash('sha256').update(agentId === CODEX_AGENT.id ? sessionId : agentId + '/' + sessionId).digest('hex').slice(0, 23); }
+export function brokerId(sessionId, agentId = CODEX_AGENT.id) { return 'r' + createHash('sha256').update(agentId + '/' + sessionId).digest('hex').slice(0, 23); }
+export function controlJson(text) {
     try {
         return JSON.parse(text);
     }
@@ -286,112 +394,4 @@ function controlJson(text) {
         throw new NeedError('BROKER_PROTOCOL_INVALID', 'broker 控制响应不是有效 JSON，未复制原始输出', '有效的 broker 控制响应');
     }
 }
-export function brokerFactory(get, _ask, configuration, provided) {
-    const active = new Set();
-    const retained = new Map();
-    const open = async (target, project, request) => {
-        const settings = request.brokerSettings ?? (typeof configuration === 'function' ? configuration() : configuration);
-        if (!request.sessionId)
-            throw new NeedError('SESSION_REQUIRED', '我需要当前 DSH 会话标识', 'DSH sessionId');
-        if (request.mode === 'one-shot') {
-            return { identity: identity(target), cwd: project.path, oneShot: { target, cwd: project.path, ...protectedOneShotLayout(target) } };
-        }
-        if (![settings.brokerMaxFrameBytes, settings.brokerControlMaxBytes].every(n => Number.isSafeInteger(n) && n > 0))
-            throw new NeedError('SETTINGS_REQUIRED', '我需要管理员确认 broker 帧和控制响应大小设置', 'brokerMaxFrameBytes / brokerControlMaxBytes（无默认）');
-        let argv = provided?.argv;
-        if (!provided?.io && !argv) {
-            try {
-                const moduleName = '@ai-workbench/connect';
-                const supplied = await import(__rewriteRelativeImportExtension(moduleName));
-                if (typeof supplied.sshArgs !== 'function')
-                    throw Error('missing sshArgs');
-                argv = supplied.sshArgs;
-            }
-            catch {
-                throw new NeedError('DEPENDENCY_REQUIRED', '我需要 connect 0.3.0 包导出的 sshArgs 来执行可信 SSH', '@ai-workbench/connect 0.3.0');
-            }
-        }
-        const ioFor = (t) => provided?.io?.(t) ?? sshIo(t, argv, settings.brokerControlMaxBytes);
-        const agent = request.agent ?? CODEX_AGENT;
-        let io = ioFor(target);
-        const id = brokerId(request.sessionId, agent.id);
-        const command = (args) => brokerCommand(target, args);
-        const list = controlJson(await io.run(command(['list']), request.signal));
-        if (!Array.isArray(list) || list.some(s => typeof s?.id !== 'string'))
-            throw new NeedError('BROKER_PROTOCOL_INVALID', '主机会话列表无效', '有效的 broker 列表');
-        if (list.some(s => s.id === id)) {
-            throw new NeedError('ACP_CLIENT_LOST', '我需要管理员确认并结束遗留的主机会话；当前保留原进程，没有代答旧审批', '管理员核对并明确结束对应主机会话');
-        }
-        const started = controlJson(await io.run(command(['start', id, '--cwd', project.path, '--settings', target.session.settingsPath, '--', agent.command]), request.signal));
-        if (started?.protocolVersion !== 1 || started.id !== id || !Number.isSafeInteger(started.pid) || started.pid < 1 || typeof started.socket !== 'string')
-            throw new NeedError('BROKER_START_UNCONFIRMED', 'broker 未返回匹配的启动确认，需确认遗留会话；未自动新建替代进程', `确认主机会话 ${id} 的状态`);
-        let transport;
-        transport = new BrokerTransport({ maxFrameBytes: settings.brokerMaxFrameBytes, attach: after => io.attach(command(['attach', id, '--after', String(after), '--framed'])), onDisconnect: async () => {
-                const connect = get();
-                if (!connect)
-                    throw new NeedError('DEPENDENCY_REQUIRED', '我需要连接插件恢复员工连接', 'aiWorkbenchConnect');
-                const next = unwrap(await connect.getSshTarget());
-                validateTarget(next);
-                if (!sameTarget(next, target))
-                    throw new NeedError('SESSION_CONTEXT_MISMATCH', '重连目标与原会话不一致', '原员工主机、可信SSH参数和broker');
-                io = ioFor(next);
-                await transport.connect();
-            } });
-        const aborted = () => transport.fail(new NeedError('ABORTED', '本轮已取消，正在结束主机进程', '确认主机状态'));
-        request.signal?.addEventListener('abort', aborted, { once: true });
-        if (request.signal?.aborted)
-            aborted();
-        const dispose = async () => { request.signal?.removeEventListener('abort', aborted); transport.close(); try {
-            await io.run(command(['kill', id]));
-        }
-        catch {
-            throw new NeedError('REMOTE_CLEANUP_UNCONFIRMED', '无法确认原主机会话已结束；不会自动新建替代进程', '恢复连接并结束对应主机会话');
-        } };
-        try {
-            await transport.connect();
-            request.signal?.throwIfAborted();
-            if (request.retainProcess)
-                request.signal?.removeEventListener('abort', aborted);
-        }
-        catch (error) {
-            await dispose();
-            throw error;
-        }
-        return { identity: identity(target), cwd: project.path, broker: transport, acpTransport: transport, dispose };
-    };
-    return async (target, project, request) => {
-        const key = (request.agent ?? CODEX_AGENT).id + '/' + identity(target) + '/' + request.sessionId;
-        const existing = request.retainProcess ? retained.get(key) : undefined;
-        if (existing) {
-            const settings = request.brokerSettings ?? (typeof configuration === 'function' ? configuration() : configuration);
-            if (existing.cwd !== project.path || existing.settings.brokerMaxFrameBytes !== settings.brokerMaxFrameBytes || existing.settings.brokerControlMaxBytes !== settings.brokerControlMaxBytes || !sameTarget(existing.target, target))
-                throw new NeedError('SESSION_CONTEXT_MISMATCH', '会话工作区、可信SSH参数或主机运行设置已改变，请新建会话', '原会话的可信主机、工作区与运行设置');
-            if (existing.runtime.broker?.error)
-                throw existing.runtime.broker.error;
-            return existing.runtime;
-        }
-        if (active.has(key))
-            throw new NeedError('TURN_BUSY', '当前 DSH 会话已有远端运行，不能当作遗留进程结束', '等待当前运行结束');
-        active.add(key);
-        try {
-            const runtime = await open(target, project, request);
-            const dispose = runtime.dispose;
-            let disposed = false;
-            runtime.dispose = async () => { if (disposed)
-                return; disposed = true; try {
-                await dispose?.();
-            }
-            finally {
-                active.delete(key);
-                retained.delete(key);
-            } };
-            if (request.retainProcess && request.mode === 'session')
-                retained.set(key, { runtime, cwd: project.path, settings: { ...(request.brokerSettings ?? (typeof configuration === 'function' ? configuration() : configuration)) }, target });
-            return runtime;
-        }
-        catch (error) {
-            active.delete(key);
-            throw error;
-        }
-    };
-}
+export { brokerFactory } from "./broker-runtime.js";

package/dist/connect-contract.d.ts

@@ -1,3 +1,4 @@
+import type { ConnectNeed } from '@ai-workbench/connect/api';
 import type { ConnectTarget } from './provider.ts';
 import type { ContractInfo, Provider, WorkspaceUse, WorkspaceNoticeReceipt as LWorkspaceNoticeReceipt } from '@ai-workbench/connect/api';
 /** 正式L0.7公开类型；消费子集不表示已安装或已通过真实产品门。 */
@@ -16,7 +17,7 @@ export type ConnectResult<T> = {
         code: string;
         message: string;
         requires: string;
-    };
+    } & Pick<ConnectNeed, 'officialReason'>;
 };
 export interface NativeWorkspaceApi {
     getContractInfo(): ContractInfo;

package/dist/conversation-details.d.ts

@@ -31,6 +31,7 @@ export type DetailSink = {
 };
 /** Only objects created by this module are trusted as redaction markers. */
 export declare function isSanitizedRedaction(value: unknown): boolean;
+export declare function sanitizeDisplayLabel(value: string): string;
 /** Sanitize an internal observation without attaching any L wire semantics. */
 export declare function sanitizeObservation(observation: DetailObservation, protectModelMaterial?: boolean): Readonly<SanitizedObservation>;
 /** Internal diagnostic recorder; a sink is not an assertion that an L wire API exists. */

package/dist/conversation-details.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { STAGES } from "./stage-timing.js";
 const redactionMarkers = new WeakSet();
 function redaction(fields) {
     const marker = { redacted: true, ...fields };
@@ -92,7 +93,7 @@ function safeText(value) {
     const url = cleanUrls(value);
     return url.changed ? redaction({ reason: 'URL敏感部分', value: url.value }) : value;
 }
-function safeLabel(value) {
+export function sanitizeDisplayLabel(value) {
     if (typeof value !== 'string')
         throw new TypeError('Detail observation labels must be strings');
     // Inspect credentials before removing control characters, so a bearer newline cannot evade detection.
@@ -254,19 +255,68 @@ function usageStructure(value, key = '') {
         return value;
     return opaqueStructure(value);
 }
+/** Only fixed local stage names and finite nonnegative millisecond observations. */
+function timingStructure(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return opaqueStructure(value);
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+        if (key === 'phase' && typeof child === 'string' && Object.hasOwn(STAGES, child))
+            return [key, child];
+        if (key === 'clock' && child === 'client-monotonic' || key === 'outcome' && (child === 'ok' || child === 'failed'))
+            return [key, child];
+        if (['durationMs', 'elapsedMs'].includes(key) && typeof child === 'number' && Number.isFinite(child) && child >= 0)
+            return [key, child];
+        return [key, opaqueStructure(child)];
+    }));
+}
+/** Only our two model-configuration observations approve these exact diagnostic
+ * paths. Directory source, config metadata and arbitrary subtrees stay opaque. */
+function modelConfigurationStructure(value, level = 'root') {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return opaqueStructure(value);
+    if (isSanitizedRedaction(value))
+        return value;
+    const strings = {
+        root: ['resolvedModel', 'requestedEffort', 'reason'], selected: ['id', 'value', 'name', 'resolvedModel', 'effort'],
+        actual: ['model', 'effort', 'modelConfigId', 'effortConfigId'], reasoning: ['defaultValue'], effort: ['value', 'name'],
+    };
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+        if (typeof child === 'string' && strings[level].includes(key))
+            return [key, child];
+        if (level === 'root' && key === 'status' && child === 'remote-configured')
+            return [key, child];
+        if (level === 'actual' && typeof child === 'boolean' && ['confirmed', 'effortAvailable'].includes(key))
+            return [key, child];
+        if (level === 'reasoning' && key === 'defaultKnown' && typeof child === 'boolean')
+            return [key, child];
+        if (child === null && ((level === 'root' && ['actual', 'requestedEffort'].includes(key)) || (level === 'selected' && key === 'resolvedModel') || (level === 'reasoning' && key === 'defaultValue')))
+            return [key, null];
+        if (level === 'root' && key === 'selected')
+            return [key, modelConfigurationStructure(child, 'selected')];
+        if (level === 'root' && ['configured', 'actual'].includes(key))
+            return [key, modelConfigurationStructure(child, 'actual')];
+        if (level === 'selected' && key === 'reasoning')
+            return [key, modelConfigurationStructure(child, 'reasoning')];
+        if (level === 'reasoning' && key === 'options' && Array.isArray(child))
+            return [key, child.map(option => modelConfigurationStructure(option, 'effort'))];
+        return [key, opaqueStructure(child)];
+    }));
+}
 /** Sanitize an internal observation without attaching any L wire semantics. */
 export function sanitizeObservation(observation, protectModelMaterial = false) {
     const payload = snapshotPayload(observation.payload, new Set(), protectModelMaterial && observation.kind !== 'commands');
     return freezeDeep({
         kind: observation.kind, severity: observation.severity,
-        code: safeLabel(observation.code), summary: safeLabel(observation.summary),
-        ...(observation.method === undefined ? {} : { method: safeLabel(observation.method) }),
+        code: sanitizeDisplayLabel(observation.code), summary: sanitizeDisplayLabel(observation.summary),
+        ...(observation.method === undefined ? {} : { method: sanitizeDisplayLabel(observation.method) }),
         payload: !protectModelMaterial ? payload
-            : observation.kind === 'commands' ? catalogStructure(payload)
-                : observation.kind === 'usage' ? usageStructure(payload)
-                    : observation.kind === 'need' ? payload
-                        : observation.kind === 'tool' || ['SDK_ITEM', 'SDK_TOOL', 'ACP_SESSION_UPDATE', 'ACP_IDLE_UPDATE'].includes(observation.code) ? toolStructure(payload)
-                            : opaqueStructure(payload),
+            : observation.kind === 'session' && ['MODEL_CONFIGURATION_CONFIRMED', 'MODEL_CONFIGURATION_FAILED'].includes(observation.code) ? modelConfigurationStructure(payload)
+                : observation.kind === 'commands' ? catalogStructure(payload)
+                    : observation.kind === 'usage' ? usageStructure(payload)
+                        : observation.kind === 'session' && observation.code === 'REMOTE_STAGE_TIMING' ? timingStructure(payload)
+                            : observation.kind === 'need' ? payload
+                                : observation.kind === 'tool' || ['SDK_ITEM', 'SDK_TOOL', 'ACP_SESSION_UPDATE', 'ACP_IDLE_UPDATE'].includes(observation.code) ? toolStructure(payload)
+                                    : opaqueStructure(payload),
     });
 }
 function validatedScope(scope) {

package/dist/index.d.ts

@@ -5,6 +5,8 @@ import { type AcpHooks } from './acp.ts';
 import { type RuntimeProvider } from './provider.ts';
 import { type AgentDefinition } from './agents.ts';
 import { type ImageReader } from './input.ts';
+import type { LoginDiagnostic } from './login-diagnostic.ts';
+import { type ModelDirectory, type HostModel } from './model-catalog.ts';
 export declare const name = "ai-workbench-remote-agent";
 export declare const settingsNamespace = "ai-workbench-codex";
 export declare const inject: string[];
@@ -47,27 +49,38 @@ type LiveConfig = {
 };
 /** DSH volatile settings are handles; adapters freeze their values once per invocation. */
 export declare function readConfig(config: LiveConfig): PluginConfig;
+export type LoginFailureReporter = (sessionId: string | undefined, code: string, diagnostic: LoginDiagnostic) => Promise<{
+    eventId: string;
+    recorded: true;
+}>;
 export declare class CodexRemoteAdapter extends LlmAdapter {
     private resolveRuntime;
     private approve?;
     private readonly providerName;
     private readonly agent;
     private readonly readImage?;
+    private readonly reportLoginFailure?;
+    private readonly directory?;
     private config;
     private sessions;
     private turns;
     private lifetime;
-    constructor(config: PluginConfig | (() => PluginConfig), resolveRuntime: RuntimeProvider, approve?: InvocationApproval | undefined, providerName?: () => string, agent?: AgentDefinition, readImage?: ImageReader | undefined);
+    private shuttingDown;
+    private detached;
+    private cleanups;
+    constructor(config: PluginConfig | (() => PluginConfig), resolveRuntime: RuntimeProvider, approve?: InvocationApproval | undefined, providerName?: () => string, agent?: AgentDefinition, readImage?: ImageReader | undefined, reportLoginFailure?: LoginFailureReporter | undefined, directory?: ModelDirectory | undefined);
     providerInfo(provider: string): {
         id: string;
         name: string;
     };
-    listModels(provider: string): Promise<{
-        provider: string;
-        id: string;
-        name: string;
-        inputModalities: ("text" | "image")[];
-    }[]>;
+    private catalog;
+    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;
+    }>;
+    invalidateModelState(): Promise<void>;
     providerRetryPolicy(): {
         mode: "normal";
         maxRetries: number;
@@ -76,7 +89,9 @@ export declare class CodexRemoteAdapter extends LlmAdapter {
         maxDelayMs: number;
         jitterRatio: number;
     };
+    private cleanupRuntime;
     disposeSession(sessionId: string): Promise<void>;
+    detachSession(sessionId: string): Promise<void>;
     dispose(): Promise<void>;
     stream(options: GenerateOptions): AsyncGenerator<StreamChunk>;
     private generate;
@@ -84,18 +99,19 @@ export declare class CodexRemoteAdapter extends LlmAdapter {
 /** One official registration owns both routes, preserving opaque replay ownership. */
 export declare class RemoteAgentsAdapter extends LlmAdapter {
     private adapters;
-    constructor(config: () => PluginConfig, makeRuntime: (agent: AgentDefinition) => RuntimeProvider, approve: InvocationApproval, nameFor: (agent: AgentDefinition) => string, readImage?: ImageReader);
+    constructor(config: () => PluginConfig, makeRuntime: (agent: AgentDefinition) => RuntimeProvider, approve: InvocationApproval, nameFor: (agent: AgentDefinition) => string, readImage?: ImageReader, reportLoginFailure?: LoginFailureReporter, directory?: ModelDirectory);
     private adapter;
     providerInfo(provider: string): {
         id: string;
         name: string;
     };
-    listModels(provider: string): Promise<{
-        provider: string;
-        id: string;
-        name: string;
-        inputModalities: ("text" | "image")[];
-    }[]>;
+    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;
+    }>;
+    invalidateModelState(): Promise<void>;
     providerRetryPolicy(): {
         mode: "normal";
         maxRetries: number;
@@ -106,6 +122,7 @@ export declare class RemoteAgentsAdapter extends LlmAdapter {
     };
     stream(options: GenerateOptions): AsyncGenerator<StreamChunk, any, any>;
     disposeSession(sessionId: string): Promise<void>;
+    detachSession(sessionId: string): Promise<void>;
     dispose(): Promise<void>;
 }
 export declare function apply(ctx: Context, live: LiveConfig): void;