@ai-workbench/remote-agent 0.8.0 → 0.8.2

package/dist/conversation-details.js

@@ -0,0 +1,319 @@
+import { randomUUID } from 'node:crypto';
+const redactionMarkers = new WeakSet();
+function redaction(fields) {
+    const marker = { redacted: true, ...fields };
+    redactionMarkers.add(marker);
+    return marker;
+}
+/** Only objects created by this module are trusted as redaction markers. */
+export function isSanitizedRedaction(value) {
+    return value !== null && typeof value === 'object' && redactionMarkers.has(value);
+}
+const sensitiveWords = new Set(['auth', 'token', 'tokens', 'password', 'passwords', 'passwd', 'secret', 'secrets', 'authorization', 'cookie', 'cookies', 'credential', 'credentials', 'key', 'keys']);
+const sensitiveCompounds = new Set([
+    'apikey', 'privatekey', 'publickey', 'accesskey', 'secretkey', 'sshkey', 'encryptionkey', 'signingkey',
+    'devicecode', 'usercode', 'onetimecode', 'verificationcode', 'codeverifier', 'authcode', 'authorizationcode', 'authpayload', 'authorizationpayload',
+    'accesstoken', 'refreshtoken', 'idtoken', 'apitoken', 'authtoken', 'sessiontoken', 'bearertoken',
+    'clientsecret', 'tokenpayload', 'tokenvalue', 'passwordpayload', 'passwordvalue', 'secretpayload', 'secretvalue',
+    'credentialpayload', 'credentialspayload', 'cookiepayload', 'keypayload',
+]);
+// These whole words are safe despite containing a credential-like substring.
+// redactedKeys is the recorder's explicit entry-wrapper marker and is stable
+// across repeated sanitization. It is not an exception for arbitrary values.
+const safeWholeFieldWords = new Set(['author', 'monkey', 'keyboard', 'secretary', 'keyword', 'keywords', 'tokenizer', 'tokenization', 'redactedkeys']);
+// A recognized suffix supplies a field boundary after case information is lost.
+// Prefixes remain unrestricted: employeePassword and customApiKey must not depend
+// on an inventory of employee/customer/application-specific field prefixes.
+const sensitiveFieldSuffixes = new Set([
+    '', 'code', 'payload', 'value', 'values', 'data', 'header', 'headers', 'config', 'configuration',
+    'option', 'options', 'detail', 'details', 'info',
+]);
+const unsafeKeys = new Set(['__proto__', 'constructor', 'prototype']);
+function isSensitiveFieldWord(word) {
+    if (safeWholeFieldWords.has(word))
+        return false;
+    if (sensitiveWords.has(word) || sensitiveCompounds.has(word))
+        return true;
+    for (const root of sensitiveWords) {
+        for (let index = word.indexOf(root); index !== -1; index = word.indexOf(root, index + 1)) {
+            // Match roots at the start, or roots ending a field (possibly followed by
+            // a known suffix), rather than fuzzy containment at any word position.
+            if (index === 0 || sensitiveFieldSuffixes.has(word.slice(index + root.length)))
+                return true;
+        }
+    }
+    return false;
+}
+function isSensitiveKey(key) {
+    if (safeWholeFieldWords.has(key.toLowerCase()))
+        return false;
+    // Preserve the original camel/delimiter rule. Anchored field-shape matching
+    // additionally recognizes the same common fields after case normalization.
+    const camelWords = key.replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9]+/);
+    const words = key.toLowerCase().split(/[^a-z0-9]+/);
+    return camelWords.some(word => sensitiveWords.has(word)) || words.some(isSensitiveFieldWord)
+        || sensitiveCompounds.has(key.replace(/[^a-z0-9]/gi, '').toLowerCase());
+}
+function unsupported(type, reason) {
+    return { unsupported: true, type, reason };
+}
+function credentialText(value) {
+    return /\bBearer\s+\S+/i.test(value)
+        || /\bsk-[a-z\d_-]+/i.test(value)
+        || /-----BEGIN (?:[A-Z\d]+ )*PRIVATE KEY-----/i.test(value)
+        || /\b(?:gh[pousr]_|github_pat_|xox[baprs]-)[a-z\d_-]+/i.test(value);
+}
+function cleanUrls(value) {
+    let changed = false;
+    const safe = value.replace(/\b[a-z][a-z\d+.-]*:\/\/[^\s<>"'`]+/gi, raw => {
+        let url;
+        try {
+            url = new URL(raw);
+        }
+        catch {
+            changed = true;
+            return '[已脱敏：无法解析URL]';
+        }
+        const userinfo = /^[a-z][a-z\d+.-]*:\/\/[^/?#]*@/i.test(raw);
+        if (!userinfo && !raw.includes('?') && !raw.includes('#'))
+            return raw;
+        url.username = '';
+        url.password = '';
+        url.search = '';
+        url.hash = '';
+        changed = true;
+        return url.toString();
+    });
+    return { value: safe, changed };
+}
+function safeText(value) {
+    if (credentialText(value))
+        return redaction({ reason: '凭据文本' });
+    const url = cleanUrls(value);
+    return url.changed ? redaction({ reason: 'URL敏感部分', value: url.value }) : value;
+}
+function safeLabel(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.
+    if (credentialText(value))
+        return '[已脱敏：凭据文本]';
+    const cleaned = value.replace(/[\u0000-\u001f\u007f-\u009f]/g, '');
+    if (credentialText(cleaned))
+        return '[已脱敏：凭据文本]';
+    const url = cleanUrls(cleaned);
+    return url.changed ? `[已脱敏：URL敏感部分] ${url.value}` : cleaned;
+}
+/** JSON-only snapshot. Non-JSON input is represented, never coerced or executed. */
+function snapshotPayload(value, ancestors = new Set(), protectModelMaterial = false) {
+    if (isSanitizedRedaction(value))
+        return value;
+    if (value === null || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string')
+        return safeText(value);
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : unsupported('number', '非有限数值不能表示为JSON');
+    if (typeof value !== 'object')
+        return unsupported(typeof value, '非JSON值');
+    if (ancestors.has(value))
+        return unsupported('object', '循环引用');
+    let descriptors;
+    let isArray;
+    try {
+        isArray = Array.isArray(value);
+        const prototype = Object.getPrototypeOf(value);
+        if (!isArray && prototype !== Object.prototype && prototype !== null)
+            return unsupported('object', '非JSON普通对象');
+        if (Object.getOwnPropertySymbols(value).some(symbol => Object.getOwnPropertyDescriptor(value, symbol)?.enumerable)) {
+            return unsupported('object', 'JSON不能表示符号字段');
+        }
+        descriptors = Object.getOwnPropertyDescriptors(value);
+    }
+    catch {
+        return unsupported('object', '无法读取对象结构');
+    }
+    if (Object.keys(descriptors).some(key => descriptors[key].enumerable && unsafeKeys.has(key))) {
+        return unsupported('object', '不允许的原型字段');
+    }
+    ancestors.add(value);
+    try {
+        if (isArray) {
+            // Array metadata beyond indexed items is not representable in a JSON array.
+            const length = descriptors.length?.value;
+            if (Object.keys(descriptors).some(key => descriptors[key].enumerable && (!/^(0|[1-9]\d*)$/.test(key) || Number(key) >= length))) {
+                return unsupported('array', 'JSON数组不能表示额外字段');
+            }
+            return Array.from({ length }, (_, index) => {
+                const descriptor = descriptors[String(index)];
+                return !descriptor ? unsupported('undefined', '数组空位')
+                    : 'value' in descriptor ? snapshotPayload(descriptor.value, ancestors, protectModelMaterial)
+                        : unsupported('accessor', '不执行访问器');
+            });
+        }
+        const result = {};
+        const entries = [];
+        let redactedKeys = false;
+        for (const [key, descriptor] of Object.entries(descriptors)) {
+            if (!descriptor.enumerable)
+                continue;
+            const name = safeText(key);
+            const value = 'value' in descriptor ? descriptor.value : undefined;
+            const normalized = key.replace(/[^a-z0-9]/gi, '').toLowerCase();
+            const counterNames = new Set(['inputtokens', 'outputtokens', 'cachedinputtokens', 'cachedreadtokens', 'cachedwritetokens', 'thoughtTokens'.toLowerCase(), 'totaltokens', 'cachewriteinputtokens', 'cachereadinputtokens', 'reasoningoutputtokens']);
+            const validCounter = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+            const counter = counterNames.has(normalized) && validCounter(value)
+                || normalized === 'tokencount' && value !== null && typeof value === 'object' && Object.values(Object.getOwnPropertyDescriptors(value)).every(d => 'value' in d && validCounter(d.value)) && Object.keys(value).every(k => counterNames.has(k.replace(/[^a-z0-9]/gi, '').toLowerCase()));
+            const material = protectModelMaterial && (/(?:headers?|body|oldtext|newtext|aggregatedoutput|stdout|stderr)$/.test(normalized)
+                || ['text', 'content', 'prompt', 'input', 'output', 'rawinput', 'rawoutput', 'messages', 'modelinput', 'modeloutput', 'patch', 'diff', 'arguments', 'command', 'commandline', 'filecontent', 'data', 'message', 'usercode', 'devicecode', 'onetimecode'].includes(normalized));
+            const child = ((!counter && isSensitiveKey(key)) || material) ? redaction({ reason: '敏感字段' })
+                : 'value' in descriptor ? snapshotPayload(descriptor.value, ancestors, protectModelMaterial)
+                    : unsupported('accessor', '不执行访问器');
+            if (typeof name !== 'string')
+                redactedKeys = true;
+            // Only safe property names may become object keys. The entry form keeps
+            // distinct original fields even when multiple names redact identically.
+            if (typeof name === 'string')
+                result[name] = child;
+            entries.push({ name, value: child });
+        }
+        return redactedKeys ? { redactedKeys: true, entries } : result;
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function freezeDeep(value) {
+    if (value !== null && typeof value === 'object') {
+        for (const child of Object.values(value))
+            freezeDeep(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+function cloneFrozen(value) { return freezeDeep(structuredClone(value)); }
+/** No raw values from unclassified events or tool I/O are approved. The
+ * structure and original JSON types remain inspectable, including unknown keys. */
+function opaqueStructure(value) {
+    if (Array.isArray(value))
+        return value.map(opaqueStructure);
+    if (value !== null && typeof value === 'object') {
+        if (isSanitizedRedaction(value))
+            return value;
+        return Object.fromEntries(Object.entries(value).map(([name, child]) => [name, opaqueStructure(child)]));
+    }
+    return redaction({ valueType: value === null ? 'null' : typeof value });
+}
+/** Structural identifiers are approved only at the SDK/ACP envelope and its
+ * immediate item/update. Arbitrary result subtrees never inherit that trust. */
+function toolStructure(value, level = 'envelope') {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return opaqueStructure(value);
+    if (isSanitizedRedaction(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+        const field = key.replace(/[^a-z0-9]/gi, '').toLowerCase();
+        if (typeof child === 'string' && ['id', 'type', 'kind', 'status', 'code', 'name', 'toolcallid', 'optionid', 'sessionid', 'sessionupdate'].includes(field))
+            return [key, child];
+        if (typeof child === 'number' && ['exitcode', 'durationms'].includes(field))
+            return [key, child];
+        if (level === 'envelope' && ['item', 'update', 'toolCall'].includes(key))
+            return [key, toolStructure(child, 'item')];
+        return [key, opaqueStructure(child)];
+    }));
+}
+function catalogStructure(value, level = 'root') {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return opaqueStructure(value);
+    if (isSanitizedRedaction(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+        if (typeof child === 'string' && ((level === 'entry' && ['name', 'description'].includes(key)) || (level === 'input' && key === 'hint') || (level === 'root' && ['sessionId', 'sessionUpdate'].includes(key))))
+            return [key, child];
+        if (level === 'root' && key === 'update')
+            return [key, catalogStructure(child)];
+        if (level === 'root' && key === 'availableCommands' && Array.isArray(child))
+            return [key, child.map(v => catalogStructure(v, 'entry'))];
+        if (level === 'entry' && key === 'input')
+            return [key, child === null ? null : catalogStructure(child, 'input')];
+        return [key, opaqueStructure(child)];
+    }));
+}
+function usageStructure(value, key = '') {
+    if (Array.isArray(value))
+        return value.map(child => usageStructure(child));
+    if (value !== null && typeof value === 'object') {
+        if (isSanitizedRedaction(value))
+            return value;
+        return Object.fromEntries(Object.entries(value).map(([name, child]) => [name, usageStructure(child, name)]));
+    }
+    const field = key.replace(/[^a-z0-9]/gi, '').toLowerCase();
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && ['inputtokens', 'outputtokens', 'cachedinputtokens', 'cachedreadtokens', 'cachedwritetokens', 'thoughttokens', 'totaltokens', 'cachewriteinputtokens', 'cachereadinputtokens', 'reasoningoutputtokens'].includes(field))
+        return value;
+    if (key === 'stopReason' && typeof value === 'string' && ['end_turn', 'max_tokens', 'max_turn_requests', 'refusal', 'cancelled'].includes(value))
+        return value;
+    return opaqueStructure(value);
+}
+/** 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) }),
+        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),
+    });
+}
+function validatedScope(scope) {
+    for (const name of ['instanceId', 'sessionId']) {
+        if (typeof scope[name] !== 'string' || scope[name].trim().length === 0)
+            throw new TypeError(`Invalid detail scope ${name}`);
+    }
+    for (const name of ['epoch', 'turn', 'step']) {
+        if (!Number.isInteger(scope[name]) || scope[name] < (name === 'epoch' ? 0 : 1))
+            throw new TypeError(`Invalid detail scope ${name}`);
+    }
+    if (scope.provider !== 'claude' && scope.provider !== 'codex')
+        throw new TypeError('Invalid detail scope provider');
+    return { instanceId: scope.instanceId, epoch: scope.epoch, sessionId: scope.sessionId, provider: scope.provider, turn: scope.turn, step: scope.step };
+}
+/** Internal diagnostic recorder; a sink is not an assertion that an L wire API exists. */
+export class ConversationDetails {
+    scope;
+    sink;
+    records = [];
+    tail = Promise.resolve();
+    firstFailure;
+    constructor(scope, sink) {
+        this.scope = freezeDeep(validatedScope(scope));
+        this.sink = sink;
+    }
+    record(observation) {
+        const record = freezeDeep({
+            ...this.scope, version: 1, eventId: randomUUID(), sequence: this.records.length + 1,
+            ...sanitizeObservation(observation),
+        });
+        this.records.push(record);
+        this.tail = this.tail.then(async () => {
+            try {
+                await this.sink.append(cloneFrozen(record));
+            }
+            catch (error) {
+                // Keep processing later entries in order, but never turn a failed flush green.
+                if (!this.firstFailure)
+                    this.firstFailure = { error };
+            }
+        });
+    }
+    async flush() {
+        await this.tail;
+        if (this.firstFailure)
+            throw this.firstFailure.error;
+    }
+    snapshot() { return cloneFrozen(this.records); }
+}

package/dist/index.d.ts

@@ -5,6 +5,7 @@ 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';
 export declare const name = "ai-workbench-remote-agent";
 export declare const settingsNamespace = "ai-workbench-codex";
 export declare const inject: string[];
@@ -47,17 +48,22 @@ 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 config;
     private sessions;
     private turns;
     private lifetime;
-    constructor(config: PluginConfig | (() => PluginConfig), resolveRuntime: RuntimeProvider, approve?: InvocationApproval | undefined, providerName?: () => string, agent?: AgentDefinition, readImage?: ImageReader | undefined);
+    constructor(config: PluginConfig | (() => PluginConfig), resolveRuntime: RuntimeProvider, approve?: InvocationApproval | undefined, providerName?: () => string, agent?: AgentDefinition, readImage?: ImageReader | undefined, reportLoginFailure?: LoginFailureReporter | undefined);
     providerInfo(provider: string): {
         id: string;
         name: string;
@@ -84,7 +90,7 @@ 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);
     private adapter;
     providerInfo(provider: string): {
         id: string;

package/dist/index.js

@@ -1,3 +1,4 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
 import Schema from '@deepseek-ai/schemastery';
 import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
 import { fileURLToPath } from 'node:url';
@@ -14,6 +15,7 @@ import { prepareInput } from "./input.js";
 import { createWorkspaceNoticeConsumer, isWorkspaceNoticeMessage } from "./workspace-notice.js";
 import { NeedError } from "./remote.js";
 import { employeeFailure } from "./presentation.js";
+import { createRemoteDetails } from "./remote-details.js";
 import { PROVIDER_NAMES, ProviderLocaleRemote } from "./provider-locale.js";
 export const name = 'ai-workbench-remote-agent';
 export const settingsNamespace = 'ai-workbench-codex';
@@ -53,17 +55,19 @@ export class CodexRemoteAdapter extends LlmAdapter {
     providerName;
     agent;
     readImage;
+    reportLoginFailure;
     config;
     sessions = new Map();
     turns = new Map();
     lifetime = new AbortController();
-    constructor(config, resolveRuntime, approve, providerName = () => PROVIDER_NAMES.en, agent = CODEX_AGENT, readImage) {
+    constructor(config, resolveRuntime, approve, providerName = () => PROVIDER_NAMES.en, agent = CODEX_AGENT, readImage, reportLoginFailure) {
         super();
         this.resolveRuntime = resolveRuntime;
         this.approve = approve;
         this.providerName = providerName;
         this.agent = agent;
         this.readImage = readImage;
+        this.reportLoginFailure = reportLoginFailure;
         this.config = typeof config === 'function' ? config : () => config;
     }
     providerInfo(provider) { return { id: provider, name: this.providerName() }; }
@@ -93,7 +97,17 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (error instanceof NeedError) {
                 const rpc = /RPC 错误码 (-?\d+)/u.exec(error.requires)?.[1];
                 const message = employeeFailure(error.code) + (rpc ? `（技术详情：RPC 错误码 ${rpc}）` : '');
-                throw new LlmError(message, error.code, { cause: new Error(`诊断代码：${error.code}；${error.requires}`) });
+                let diagnostic = error.technical ? JSON.stringify(error.technical) : '';
+                if (error.technical && this.reportLoginFailure) {
+                    try {
+                        const receipt = await this.reportLoginFailure(options.sessionId, error.code, error.technical);
+                        diagnostic += '；诊断 eventId=' + receipt.eventId;
+                    }
+                    catch (failure) {
+                        diagnostic += '；诊断保存失败：' + (failure instanceof NeedError ? failure.code : 'DIAGNOSTIC_WRITE_FAILED');
+                    }
+                }
+                throw new LlmError(message, error.code, { cause: new Error(`诊断代码：${error.code}；${error.requires}` + (diagnostic ? '；' + diagnostic : '')) });
             }
             throw error;
         }
@@ -116,6 +130,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
         let live;
         let succeeded = false;
         let remoteAttempted = false;
+        let activeMapper;
         const config = this.config();
         const mode = this.agent.oneShot ? config.mode : 'session';
         try {
@@ -150,9 +165,17 @@ export class CodexRemoteAdapter extends LlmAdapter {
             signal.throwIfAborted();
             if (previous && (previous.identity !== runtime.identity || previous.cwd !== runtime.cwd || previous.bindingId && previous.bindingId !== runtime.binding?.bindingId || previous.workspaceId && previous.workspaceId !== runtime.binding?.workspaceId))
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '原会话的员工主机或工作区已改变，请新建会话', '原会话的可信目标和工作区');
-            const mapper = new StreamMapper(mode === 'session' ? (live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined);
+            const details = runtime.details;
+            if (!details)
+                throw new NeedError('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用，请更新远程主机连接组件。', 'L技术详情持久接收能力');
+            const mapper = new StreamMapper(mode === 'session' ? (live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined, observation => details.record(observation));
+            activeMapper = mapper;
             let id;
             let stop;
+            if (runtime.workspaceNotice) {
+                yield* mapper.text(runtime.workspaceNotice.text);
+                yield* mapper.flush();
+            }
             if (mode === 'session') {
                 if (live && live.runtime !== runtime)
                     throw new NeedError('SESSION_TRANSPORT_MISMATCH', '原会话的主机通道已更换，不能自动切换进程', '原主机会话通道');
@@ -169,7 +192,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                     catch (error) {
                         failure = error;
                         session?.close();
-                    } }, onResponse: response => push(mapper.acpResponse(response)), onNeed: need => push(mapper.text(`\n[需要处理] ${need.message}\n`)) };
+                    } }, onResponse: response => push(mapper.acpResponse(response)), onDetail: detail => details.record(detail) };
                 const fresh = !live;
                 if (fresh) {
                     const transport = runtime.acpTransport instanceof acp.AgentApp || runtime.acpTransport instanceof unstable.AgentApp ? runtime.acpTransport : acp.ndJsonStream(runtime.acpTransport.writable, runtime.acpTransport.readable, { maxMessageBytes: config.acpMaxMessageBytes });
@@ -193,8 +216,15 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         if (updated && this.agent.loginProvider === 'claude')
                             throw new NeedError('SYSTEM_PROMPT_UPDATE_PENDING', 'Claude原会话的系统或开发者要求已变化；主机仅承诺下次上下文整理后生效，本轮未发送，请新建会话应用新要求', '新建Claude会话以立即应用当前系统与开发者要求');
                     }
+                    await details.flush();
+                    details.beginTurn(runtime.detailContext?.() ?? { turn: null, step: null });
                     id = session.id;
-                    return await session.prompt(input.prompt, signal);
+                    try {
+                        return await session.prompt(input.prompt, signal);
+                    }
+                    finally {
+                        details.endTurn();
+                    }
                 })();
                 void task.then(value => { stop = value; }, error => { failure ??= runtime.broker?.error ?? error; }).finally(() => { done = true; wake?.(); wake = undefined; });
                 while (!done || queue.length) {
@@ -214,6 +244,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             else {
                 if (!runtime.oneShot)
                     throw new NeedError('DEPENDENCY_REQUIRED', '我需要主机单次运行助手', 'S安装的aw-codex-once');
+                details.beginTurn(runtime.detailContext?.() ?? { turn: null, step: null });
                 const text = input.prompt.map(block => block.type === 'text' ? block.text : '').join('\n');
                 for await (const event of runOneShot(runtime.oneShot, { wrapperPath: fileURLToPath(new URL('./sdk-ssh-wrapper.js', import.meta.url)), sandboxMode: config.oneShotSandbox, approvalPolicy: config.oneShotApproval }, text, previous?.sessionId, signal)) {
                     if (event.type === 'thread.started')
@@ -222,17 +253,31 @@ export class CodexRemoteAdapter extends LlmAdapter {
                         yield chunk;
                 }
             }
+            details.endTurn();
+            await details.flush();
             if (!id)
                 throw new NeedError('SESSION_ID_MISSING', '远端没有返回会话标识', '有效的远端会话标识');
             if (live)
                 live.usageSnapshot = mapper.usageSnapshot;
-            const pointer = { 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 } : {}) };
+            yield* mapper.flush();
+            const pointer = { ...(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 } : {}) };
             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))
-                live.failure = error;
+                live.failure = { cause: error };
+            let reportingFailure;
+            try {
+                await runtime?.details?.flush();
+            }
+            catch (failure) {
+                reportingFailure = { cause: failure };
+            }
+            if (activeMapper)
+                yield* activeMapper.flush();
+            if (reportingFailure !== undefined)
+                throw reportingFailure.cause;
             throw error;
         }
         finally {
@@ -248,8 +293,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
 /** One official registration owns both routes, preserving opaque replay ownership. */
 export class RemoteAgentsAdapter extends LlmAdapter {
     adapters = new Map();
-    constructor(config, makeRuntime, approve, nameFor, readImage) { super(); for (const agent of AGENTS)
-        this.adapters.set(agent.id, new CodexRemoteAdapter(config, makeRuntime(agent), approve, () => nameFor(agent), agent, readImage)); }
+    constructor(config, makeRuntime, approve, nameFor, readImage, reportLoginFailure) { super(); for (const agent of AGENTS)
+        this.adapters.set(agent.id, new CodexRemoteAdapter(config, makeRuntime(agent), approve, () => nameFor(agent), agent, readImage, reportLoginFailure)); }
     adapter(provider) { const adapter = this.adapters.get(provider); if (!adapter)
         throw new LlmError('远程模型未注册', 'PROVIDER_NOT_FOUND'); return adapter; }
     providerInfo(provider) { return this.adapter(provider).providerInfo(provider); }
@@ -269,7 +314,62 @@ export function apply(ctx, live) {
             throw new NeedError('ATTACHMENT_REQUIRED', '我需要官方附件组件读取这张图片', '官方attachments.readImage');
         return attachments.readImage(ref, signal);
     };
-    const adapter = new RemoteAgentsAdapter(config, agent => connectProvider(get, { agent, notice: createWorkspaceNoticeConsumer(ctx, agent), open: brokerFactory(get, undefined, config) }), dshApproval(ctx), agent => agent.name[language], readImage);
+    const openByAgent = new Map(AGENTS.map(agent => [agent.id, brokerFactory(get, undefined, config)]));
+    const detailManagers = new Map();
+    const managerForProfile = () => {
+        const profile = ctx.get('profileContext');
+        if (typeof profile?.dir !== 'string')
+            throw new NeedError('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用：缺少官方profile目录。', '官方profileContext.dir');
+        let manager = detailManagers.get(profile.dir);
+        if (!manager) {
+            manager = createRemoteDetails({ profileDir: profile.dir, getApi: get });
+            detailManagers.set(profile.dir, manager);
+        }
+        return manager;
+    };
+    const adapter = new RemoteAgentsAdapter(config, agent => connectProvider(get, { agent, notice: createWorkspaceNoticeConsumer(ctx, agent), details: async (request, api, connection, target) => {
+            return managerForProfile().open({ sessionId: request.sessionId, provider: agent.loginProvider, identity: `${target.username}@${target.host}:${target.port}`, connection });
+        }, open: async (...args) => {
+            const runtime = await openByAgent.get(agent.id)(...args);
+            runtime.detailContext = () => {
+                const events = args[2].sessionId ? ctx.get('agents')?.get(SessionId(args[2].sessionId))?.session.snapshotEvents() : undefined;
+                let turn = null, step = null;
+                for (const event of events ?? []) {
+                    if (event.type === 'turn/start') {
+                        turn = event.data.turn;
+                        step = null;
+                    }
+                    else if (event.type === 'turn/end') {
+                        turn = null;
+                        step = null;
+                    }
+                    else if (event.type === 'step/start' && event.data.turn === turn)
+                        step = event.data.step;
+                    else if (event.type === 'step/end')
+                        step = null;
+                }
+                return { turn, step };
+            };
+            return runtime;
+        } }), dshApproval(ctx), agent => agent.name[language], readImage, (sessionId, code, diagnostic) => {
+        const events = sessionId ? ctx.get('agents')?.get(SessionId(sessionId))?.session.snapshotEvents() : undefined;
+        let turn = null, step = null;
+        for (const event of events ?? []) {
+            if (event.type === 'turn/start') {
+                turn = event.data.turn;
+                step = null;
+            }
+            else if (event.type === 'turn/end') {
+                turn = null;
+                step = null;
+            }
+            else if (event.type === 'step/start' && event.data.turn === turn)
+                step = event.data.step;
+            else if (event.type === 'step/end')
+                step = null;
+        }
+        return managerForProfile().recordLoginFailure({ sessionId, code, diagnostic, context: { turn, step } });
+    });
     const ids = AGENTS.map(agent => agent.id);
     const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: settingsNamespace, settingsPath: [] }));
     const directory = ctx.llm.registerConfigurableProviders(entries());

package/dist/input.js

@@ -1,9 +1,9 @@
 import { NeedError } from "./remote.js";
-import { isWorkspaceNoticeMessage } from "./workspace-notice.js";
+import { isWorkspaceNoticeMessage, withoutWorkspaceNotice } from "./workspace-notice.js";
 /** The attachment service supplies verified bytes; client paths never cross SSH. */
 export async function prepareInput(options, readImage) {
     options.signal?.throwIfAborted();
-    const messages = options.messages.filter(message => !isWorkspaceNoticeMessage(message));
+    const messages = options.messages.filter(message => !isWorkspaceNoticeMessage(message)).map(withoutWorkspaceNotice);
     const context = [];
     if (options.system)
         context.push('系统上下文：\n' + options.system);

package/dist/login-diagnostic.d.ts

@@ -0,0 +1,38 @@
+import type { ConnectionState, LoginPromptState } from '@ai-workbench/connect/api';
+export type LoginReason = 'LOGIN_INSTANCE_MISMATCH' | 'LOGIN_PHASE_BLOCKED' | 'LOGIN_PHASE_DISPOSED' | 'LOGIN_CHECKING' | 'LOGIN_AUTHORIZING' | 'LOGIN_PROVIDER_NEED' | 'LOGIN_VALUE_INVALID' | 'LOGIN_REQUIRED' | 'L_ENSURE_READY_FAILED' | 'LOGIN_QUEUED';
+/** Allowlisted protocol facts only: never messages, requires, host details or status command output. */
+export interface LoginDiagnostic {
+    version: 1;
+    source: 'verified-login' | 'readiness' | 'ensure-ready';
+    reason: LoginReason;
+    provider: 'claude' | 'codex';
+    officialReason?: string;
+    officialReasonRejected?: {
+        bytes: number;
+        sha256: string;
+    };
+    connection: {
+        instanceId: string;
+        phase: string;
+        epoch: number;
+    };
+    login: {
+        instanceId: string;
+        phase: string;
+        revision: number;
+        provider: 'claude' | 'codex' | null;
+        logins: {
+            claude: boolean | 'absent' | 'invalid';
+            codex: boolean | 'absent' | 'invalid';
+        };
+        queuedProviders: ('claude' | 'codex')[];
+        checkingProviders: ('claude' | 'codex')[];
+        providerNeeds: {
+            claude: string | null;
+            codex: string | null;
+        };
+        code: string | null;
+    };
+}
+export declare function loginDiagnostic(source: LoginDiagnostic['source'], reason: LoginReason, provider: 'claude' | 'codex', connection: ConnectionState, state: LoginPromptState, officialReason?: string): LoginDiagnostic;
+export declare function loginReason(state: LoginPromptState, connection: ConnectionState, provider: 'claude' | 'codex'): LoginReason | undefined;