@ai-workbench/remote-agent 0.8.0 → 0.8.2

package/README.md

@@ -1,4 +1,4 @@
-在 DSH「插件 → 添加插件」填 `@ai-workbench/remote-agent@0.8.0`（由编排发布后可用），或运行 `dsh plugin --profile desktop add @ai-workbench/remote-agent@0.8.0`。
+在 DSH「插件 → 添加插件」填 `@ai-workbench/remote-agent@0.8.2`（由编排发布后可用），或运行 `dsh plugin --profile desktop add @ai-workbench/remote-agent@0.8.2`。
 
 # 远程ACP插件
 
@@ -52,3 +52,13 @@ Codex单次模式首版仅文本，不转接中途审批；图片或系统/开
 ## 验证范围
 
 当前准备结果与限制记入源码仓`docs/evidence/2026-10-21-X-npm-prep/`（不进npm包）。先前真实emp-a协议诊断及固定三件套GUI是不同轮次，不能代替本次新包安装门。L完整绑定/登录、真实模型、物理断网、HanaMesh及leo E以实际已执行证据为准。主机命令安装来自S，X不修改S仓/安装脚本或登录状态。
+
+
+D19（0.8.1）：相邻正文增量合成连续文本块，工作区首次说明合入真实回复，按官方持久记录核对后才回报“已记入可核对回复”。这不代表界面已经显示。
+
+技术详情由 L 0.7.11 的唯一“远程主机连接”设置节展示，正文只放模型文本。命令目录保留完整描述；未知事件和工具输入输出保留字段、JSON类型及处理结果，未获准原文明确脱敏，数字用量可核对。没有 `remoteConversationDetails:1` 时明确提示“技术详情暂不可用”，本轮不发送模型请求。X 在官方当前 profile 的 `ai-workbench-remote-agent/diagnostics/` 保存私有诊断日志（目录700、文件600、落盘同步）；写入/归属/顺序/容量失败中止本轮，不自动重发、换代重投、过期或淘汰。结果未知时只读核对原事件完整回执，未找到仍保持未知。X本轮无新增设置/阈值；L的单事件容量和分页设置在L设置节可见。
+
+
+0.8.2 登录检查：需要 L `~0.7.11`，失败来源及固定分支保留到 L“登录前技术详情”（`loginDiagnostics:1`），员工正文保持原文。按 L 明确的本品牌 queued/checking/authorizing 状态订阅等待；不以全局checking猜测在途，不新增刷新、轮询、超时或重试。每轮ensureReady仍是合同规定的显式检查，L的新可信结果可以替代旧检查，较早返回不得覆盖它。
+
+L安全规范的officialReason原串完整保留；旧/不支持格式明确记OFFICIAL_REASON_UNSUPPORTED与字节数/SHA，秘密原文不保存。L0.7.11的LOGIN_INSTANCE_MISMATCH记录通过observedLoginInstanceId与原始login.instanceId保存实际观测ID，事件及connection仍绑定当前可信ID/代次；L技术详情和X私有日志均保留真实双ID，不归一、不清空快照。复合未知官方原因以固定summary完整保存OFFICIAL_REASON_UNSUPPORTED及bytes/SHA，不交原文。X私有原快照先同步落盘，再追加L；ACK未知只读核实原事件，跨代不重写/重发。此版本的工程验证不替代leo员工路径复验，真实故障根因尚未证实。

package/dist/acp.d.ts

@@ -2,12 +2,14 @@ import * as stable from '@agentclientprotocol/sdk';
 import * as acp from '@agentclientprotocol/sdk/unstable';
 import { NeedError, type Need } from './remote.ts';
 import type { BrokerTransport } from './broker.ts';
+import { type SanitizedObservation } from './conversation-details.ts';
 export type ApprovalOutcome = 'allowed-once' | 'rejected' | 'cancelled' | 'unavailable';
 export interface AcpHooks {
     onUpdate?: (notification: acp.SessionNotification) => void;
     onResponse?: (response: acp.PromptResponse) => void;
     approve?: (request: acp.RequestPermissionRequest, signal?: AbortSignal) => Promise<ApprovalOutcome>;
     onNeed?: (need: Need) => void;
+    onDetail?: (detail: Readonly<SanitizedObservation>) => void;
     broker?: BrokerTransport;
 }
 export interface AcpStartContext {
@@ -29,6 +31,12 @@ export declare class AcpSession {
     private updating;
     private cwd?;
     private systemPrompt;
+    private reports;
+    private reportingFailure;
+    get diagnostics(): readonly Readonly<SanitizedObservation>[];
+    private detail;
+    private need;
+    private checkReporting;
     constructor(transport: acp.Stream | acp.AgentApp | stable.AgentApp, hooks: AcpHooks);
     private observe;
     get id(): string | undefined;

package/dist/acp.js

@@ -1,5 +1,6 @@
 import * as acp from '@agentclientprotocol/sdk/unstable';
 import { NeedError } from "./remote.js";
+import { sanitizeObservation } from "./conversation-details.js";
 /** ACP v1 with explicitly negotiated SDK 2.0 lifecycle/context extensions. */
 export class AcpSession {
     connection;
@@ -15,19 +16,45 @@ export class AcpSession {
     updating = false;
     cwd;
     systemPrompt = '';
+    reports = [];
+    reportingFailure;
+    get diagnostics() { return this.reports.map(entry => sanitizeObservation(entry)); }
+    detail(observation) {
+        const safe = sanitizeObservation(observation);
+        this.reports.push(safe);
+        try {
+            this.hooks.onDetail?.(safe);
+        }
+        catch (cause) {
+            this.reportingFailure ??= { cause };
+            this.connection?.close();
+        }
+    }
+    need(need) {
+        this.detail({ kind: 'need', severity: 'action-required', code: need.code, summary: need.message, payload: { requires: need.requires } });
+        this.hooks.onNeed?.(need);
+    }
+    checkReporting() { if (this.reportingFailure)
+        throw new NeedError('CONVERSATION_DETAILS_FAILED', '技术详情未能记录；本轮未继续发送', '可用的技术详情记录渠道'); }
     constructor(transport, hooks) {
         this.hooks = hooks;
         const app = acp.client({ name: '@ai-workbench/remote-agent' })
             .onNotification(acp.methods.client.session.update, ({ params: notification }) => {
-            if (this.busy && notification.sessionId === this.sessionId) {
-                // Session metadata is not evidence that the current prompt was accepted.
+            if (this.sessionId && notification.sessionId !== this.sessionId) {
+                this.detail({ kind: 'session', severity: 'warning', code: 'ACP_FOREIGN_SESSION_UPDATE', summary: '收到不属于当前远端会话的通知，未作为正文处理', method: 'session/update', payload: notification });
+                return;
+            }
+            const meta = record(notification._meta);
+            if (meta && Object.keys(meta).length)
+                this.detail({ kind: 'extension', severity: 'info', code: 'ACP_NOTIFICATION_META', summary: '远端通知扩展', method: 'session/update', payload: notification._meta });
+            if (this.busy) {
+                // Only actual turn output acknowledges prompt acceptance.
                 if (['agent_message_chunk', 'agent_thought_chunk', 'tool_call', 'tool_call_update'].includes(notification.update.sessionUpdate))
                     this.hooks.broker?.acknowledge(acp.methods.agent.session.prompt);
-                const meta = record(notification._meta);
-                if (meta && Object.keys(meta).length)
-                    this.hooks.onNeed?.({ code: 'ACP_EXTENSION_UNSUPPORTED', message: `首版不支持：远端通知扩展字段 ${Object.keys(meta).map(safeLabel).join('、')}；扩展值未展开`, requires: '对应的公开扩展映射' });
                 this.hooks.onUpdate?.(notification);
             }
+            else
+                this.detail({ kind: notification.update.sessionUpdate === 'available_commands_update' ? 'commands' : 'session', severity: 'info', code: 'ACP_IDLE_UPDATE', summary: '远端会话建立、恢复或空闲时的轨迹', method: 'session/update', payload: notification });
         })
             .onRequest(acp.methods.client.session.requestPermission, async ({ params: request, signal: rpcSignal, requestId }) => {
             if (request.sessionId !== this.sessionId || !this.busy || this.turnSignal?.aborted)
@@ -35,7 +62,7 @@ export class AcpSession {
             this.hooks.broker?.acknowledge(acp.methods.agent.session.prompt);
             const toolName = request.toolCall.name ?? record(request.toolCall._meta?.claudeCode)?.toolName;
             if (toolName === 'AskUserQuestion') {
-                this.hooks.onNeed?.({ code: 'INTERACTION_UNSUPPORTED', message: '首版不支持：远端提问；已取消，未提交答案', requires: '可承载此提问的官方交互接口' });
+                this.need({ code: 'INTERACTION_UNSUPPORTED', message: '首版不支持：远端提问；已取消，未提交答案', requires: '可承载此提问的官方交互接口' });
                 return { outcome: { outcome: 'cancelled' } };
             }
             const eligible = request.options.filter(option => {
@@ -43,11 +70,13 @@ export class AcpSession {
                 const sameKind = request.options.filter(candidate => candidate.kind === option.kind);
                 const unique = single && sameKind.length === 1 && request.options.filter(candidate => candidate.optionId === option.optionId).length === 1;
                 if (!unique)
-                    this.hooks.onNeed?.({ code: 'APPROVAL_OPTION_UNSUPPORTED', message: `首版不支持：${option.name} / ${option.optionId} / ${option.kind}`, requires: '唯一对应的允许一次或拒绝一次选项' });
+                    this.detail({ kind: 'tool', severity: 'info', code: 'APPROVAL_OPTION_NOT_OFFERED', summary: '此远端审批选项未映射到单次审批', method: 'session/request_permission', payload: option });
                 return unique;
             });
-            if (!eligible.length)
+            if (!eligible.length) {
+                this.need({ code: 'APPROVAL_OPTION_UNSUPPORTED', message: '远端没有可唯一映射的单次审批选项，此动作未获授权', requires: '唯一对应的允许一次或拒绝一次选项' });
                 return { outcome: { outcome: 'cancelled' } };
+            }
             const presented = { ...request, options: eligible };
             const token = this.turnToken;
             const id = this.sessionId;
@@ -78,7 +107,7 @@ export class AcpSession {
                 }
             }
             catch {
-                this.hooks.onNeed?.({ code: 'APPROVAL_FAILED', message: '审批渠道失败或连接已结束；此动作未获授权', requires: '可用的 DSH 审批渠道和原连接' });
+                this.need({ code: 'APPROVAL_FAILED', message: '审批渠道失败或连接已结束；此动作未获授权', requires: '可用的 DSH 审批渠道和原连接' });
             }
             const kind = outcome === 'allowed-once' ? 'allow_once' : outcome === 'rejected' ? 'reject_once' : undefined;
             const option = kind && eligible.find(item => item.kind === kind);
@@ -87,23 +116,24 @@ export class AcpSession {
                     broker.authorizeResponse(requestId, generation);
                 return { outcome: { outcome: 'selected', optionId: option.optionId } };
             }
-            this.hooks.onNeed?.({ code: outcome === 'allowed-once' ? 'APPROVAL_OPTION_UNSUPPORTED' : 'APPROVAL_UNAVAILABLE',
+            this.need({ code: outcome === 'allowed-once' ? 'APPROVAL_OPTION_UNSUPPORTED' : 'APPROVAL_UNAVAILABLE',
                 message: '此动作未获授权；审批已取消、不可用或没有可映射的单次选项', requires: '本次动作的有效审批' });
             return { outcome: { outcome: 'cancelled' } };
         })
             .onRequest(acp.methods.client.elicitation.create, () => {
-            this.hooks.onNeed?.({ code: 'INTERACTION_UNSUPPORTED', message: '首版不支持：远端提问或信息收集；已取消，未提交答案', requires: '可承载此提问的官方交互接口' });
+            this.need({ code: 'INTERACTION_UNSUPPORTED', message: '首版不支持：远端提问或信息收集；已取消，未提交答案', requires: '可承载此提问的官方交互接口' });
             return { action: 'cancel' };
         })
             .onNotification(acp.methods.client.elicitation.complete, () => {
-            this.hooks.onNeed?.({ code: 'INTERACTION_UNSUPPORTED', message: '首版不支持：远端提问完成通知；未提交答案', requires: '可承载此提问的官方交互接口' });
+            this.need({ code: 'INTERACTION_UNSUPPORTED', message: '首版不支持：远端提问完成通知；未提交答案', requires: '可承载此提问的官方交互接口' });
         })
-            .onRequest('*', () => {
-            this.hooks.onNeed?.({ code: 'ACP_EXTENSION_UNSUPPORTED', message: '首版不支持：远端请求的扩展交互；未授权此动作', requires: '受支持的公开 ACP 交互接口' });
+            .onRequest('*', ({ method, params }) => {
+            this.detail({ kind: 'extension', severity: 'action-required', code: 'ACP_UNKNOWN_REQUEST', summary: '未知远端交互请求未获授权', method, payload: params });
+            this.need({ code: 'ACP_EXTENSION_UNSUPPORTED', message: '首版不支持：远端请求的扩展交互；未授权此动作', requires: '受支持的公开 ACP 交互接口' });
             throw new acp.RequestError(-32601, '不支持此扩展交互');
         })
-            .onNotification('*', () => {
-            this.hooks.onNeed?.({ code: 'ACP_EXTENSION_UNSUPPORTED', message: '首版不支持：收到未知的远端扩展通知', requires: '受支持的公开 ACP 通知接口' });
+            .onNotification('*', ({ method, params }) => {
+            this.detail({ kind: 'extension', severity: 'warning', code: 'ACP_UNKNOWN_NOTIFICATION', summary: '收到未知远端扩展通知，已保留技术记录', method, payload: params });
         });
         if ('readable' in transport && 'writable' in transport)
             this.connection = app.connect(this.observe(transport));
@@ -126,8 +156,7 @@ export class AcpSession {
                 const params = record(raw?.params);
                 const update = record(params?.update);
                 if (raw?.method === acp.methods.client.session.update && typeof update?.sessionUpdate === 'string' && !knownUpdates.has(update.sessionUpdate)) {
-                    if (this.busy && params?.sessionId === this.sessionId)
-                        this.hooks.onNeed?.({ code: 'ACP_UPDATE_UNSUPPORTED', message: `首版不支持：远端事件 ${safeLabel(update.sessionUpdate)}；未展开未知事件内容`, requires: '对应的公开 ACP 显示映射' });
+                    this.detail({ kind: 'extension', severity: 'warning', code: 'ACP_UNKNOWN_UPDATE', summary: '收到未知远端会话事件，已保留结构', method: 'session/update', payload: params });
                     return;
                 }
                 controller.enqueue(message);
@@ -166,12 +195,13 @@ export class AcpSession {
         signal?.addEventListener('abort', abort, { once: true });
         try {
             const hello = await this.connection.agent.request(acp.methods.agent.initialize, {
-                protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.8.0' },
+                protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.8.1' },
                 clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false, session: { notices: {} } },
             }, { cancellationSignal: signal });
             this.hooks.broker?.acknowledge(acp.methods.agent.initialize);
             if (hello.protocolVersion !== acp.PROTOCOL_VERSION)
                 throw new NeedError('ACP_VERSION_MISMATCH', 'ACP 协议版本不兼容', '支持 ACP v1 的远端 agent');
+            this.checkReporting();
             this.negotiated = hello.agentCapabilities ?? {};
             const systemPrompt = context?.systemPrompt;
             if (systemPrompt && !this.negotiated.sessionCapabilities?.systemPrompt) {
@@ -197,6 +227,7 @@ export class AcpSession {
                 this.method = acp.methods.agent.session.new;
             }
             this.hooks.broker?.acknowledge(this.method);
+            this.checkReporting();
             this.ready = true;
             this.cwd = cwd;
             this.systemPrompt = systemPrompt ?? '';
@@ -205,6 +236,7 @@ export class AcpSession {
         catch (error) {
             if (signal?.aborted)
                 throw new NeedError('ABORTED', '会话建立已取消；尚无本轮输出', '重新连接主机');
+            this.checkReporting();
             throw acpNeed(error);
         }
         finally {
@@ -212,6 +244,7 @@ export class AcpSession {
         }
     }
     async updateContext(context, signal) {
+        this.checkReporting();
         if (!this.ready || !this.sessionId || !this.cwd)
             throw new NeedError('SESSION_REQUIRED', '我需要先建立远端会话', 'ACP 会话');
         if (this.busy || this.updating)
@@ -233,12 +266,14 @@ export class AcpSession {
             this.hooks.broker?.acknowledge(method);
             this.systemPrompt = text;
             this.ready = true;
-            this.hooks.onNeed?.({ code: 'SYSTEM_PROMPT_UPDATE_DEFERRED', message: '系统与开发者上下文变更已通过原会话恢复接口传送。Claude 恢复会话沿用首次系统提示，新要求在下次上下文整理后生效；不能据此认定本轮已立即生效。', requires: '远端实际应用新要求；Claude 须完成下一次上下文整理' });
+            this.need({ code: 'SYSTEM_PROMPT_UPDATE_DEFERRED', message: '系统与开发者上下文变更已通过原会话恢复接口传送。Claude 恢复会话沿用首次系统提示，新要求在下次上下文整理后生效；不能据此认定本轮已立即生效。', requires: '远端实际应用新要求；Claude 须完成下一次上下文整理' });
+            this.checkReporting();
             return method;
         }
         catch (error) {
             if (signal?.aborted)
                 throw new NeedError('ABORTED', '上下文更新已取消；原会话状态需确认', '重新连接原会话');
+            this.checkReporting();
             throw acpNeed(error);
         }
         finally {
@@ -254,6 +289,7 @@ export class AcpSession {
         signal?.throwIfAborted();
         const prompt = typeof input === 'string' ? [{ type: 'text', text: input }] : input;
         this.validatePrompt(prompt);
+        this.checkReporting();
         this.busy = true;
         this.turnSignal = signal;
         this.turnToken = Symbol('turn');
@@ -262,7 +298,7 @@ export class AcpSession {
         const cancel = () => {
             rejectAbort?.(new NeedError('ABORTED', '已请求取消本轮，远端状态需确认', '确认主机取消状态'));
             void this.connection.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.sessionId }).catch(() => {
-                this.hooks.onNeed?.({ code: 'CANCEL_UNCONFIRMED', message: '连接中断，无法确认主机已取消本轮', requires: '恢复连接以确认远端状态' });
+                this.need({ code: 'CANCEL_UNCONFIRMED', message: '连接中断，无法确认主机已取消本轮', requires: '恢复连接以确认远端状态' });
             });
         };
         signal?.addEventListener('abort', cancel, { once: true });
@@ -272,12 +308,14 @@ export class AcpSession {
             this.hooks.broker?.acknowledge(acp.methods.agent.session.prompt);
             signal?.throwIfAborted();
             this.hooks.broker?.completePrompt();
+            this.checkReporting();
             this.hooks.onResponse?.(result);
             return result.stopReason;
         }
         catch (error) {
             if (signal?.aborted)
                 throw new NeedError('ABORTED', '本轮已取消；已请求主机停止', '确认主机取消状态');
+            this.checkReporting();
             throw acpNeed(error);
         }
         finally {

package/dist/auth-reason.d.ts

@@ -0,0 +1 @@
+export declare function validOfficialReason(value: unknown): value is string;

package/dist/auth-reason.js

@@ -0,0 +1,27 @@
+/** L 0.7.10 officialReason v1 consumer validation; preserve canonical bytes only. */
+const markers = ['AW_REMOTE_COMMAND_KILL_FAILED', 'AUTH_STATUS_JSON_INVALID:SyntaxError', 'Permission denied', 'Host key verification failed', 'Connection refused', 'Connection closed', 'command not found', 'No such file or directory'];
+const names = ['Error', 'TypeError', 'SyntaxError', 'RangeError', 'AbortError', 'DOMException', 'UnknownError'];
+const codes = ['ENOENT', 'EPERM', 'ESRCH', 'EACCES', 'EINVAL', 'EPIPE', 'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ABORT_ERR', 'UNKNOWN'];
+const stages = ['ssh-status', 'ssh-result', 'remote-frame', 'auth-status', 'connect-check-login', 'integration-pre-login', 'process-spawn', 'process-stdin', 'process-output', 'process-runner'];
+const reasons = ['CANCELLED', 'SSH_EXIT_NONZERO', 'SSH_STDERR_NONEMPTY', 'FRAME_TRUNCATED', 'FRAME_JSON_INVALID', 'FRAME_OBJECT_INVALID', 'FRAME_VERSION_INVALID', 'FRAME_NONCE_INVALID', 'FRAME_AFTER_END', 'FRAME_KEYS_INVALID', 'FRAME_START_MISSING', 'FRAME_BASE64_INVALID', 'REMOTE_COMMAND_SIGNAL', 'FRAME_END_EXIT_INVALID', 'FRAME_SEQUENCE_OR_VALUE_INVALID', 'FRAME_END_MISSING', 'STATUS_ARGUMENT_INVALID', 'STATUS_EXECUTION_FAILED', 'STATUS_JSON_INVALID', 'STATUS_OBJECT_INVALID', 'STATUS_KEYS_INVALID', 'STATUS_VERSION_INVALID', 'STATUS_PROVIDER_INVALID', 'STATUS_EXIT_MISMATCH', 'STATUS_LOGGED_IN_INVALID', 'STATUS_STDERR_NONEMPTY', 'STATUS_EXIT_INVALID', 'STATUS_EXCEPTION', 'STATUS_SUPERSEDED', 'SSH_PORT_MISSING', 'STDIN_FAILED', 'SPAWN_FAILED', 'OUTPUT_LIMIT_EXCEEDED', 'PROCESS_SIGNAL'];
+const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const integer = (v) => Number.isSafeInteger(v) && Number(v) >= 0;
+const member = (list, v) => typeof v === 'string' && list.includes(v);
+function summary(v) {
+    return object(v) && Object.keys(v).every(k => ['bytes', 'sha256', 'markers', 'cleanupErrors'].includes(k)) && integer(v.bytes) && typeof v.sha256 === 'string' && /^[a-f0-9]{64}$/.test(v.sha256) && Array.isArray(v.markers) && v.markers.every(m => member(markers, m)) && (v.cleanupErrors === undefined || Array.isArray(v.cleanupErrors) && v.cleanupErrors.every(e => object(e) && Object.keys(e).sort().join(',') === 'errorCode,errorName' && member(['Error', 'TypeError', 'RangeError', 'UnknownError'], e.errorName) && member(['EPERM', 'EACCES', 'EINVAL', 'UNKNOWN'], e.errorCode)));
+}
+export function validOfficialReason(value) {
+    if (typeof value !== 'string')
+        return false;
+    let v;
+    try {
+        v = JSON.parse(value);
+    }
+    catch {
+        return false;
+    }
+    if (!object(v) || JSON.stringify(v) !== value || v.version !== 1 || !member(stages, v.stage) || !member(reasons, v.reason))
+        return false;
+    const fields = { version: x => x === 1, stage: x => member(stages, x), reason: x => member(reasons, x), errorName: x => member(names, x), errorCode: x => member(codes, x), exitCode: x => x === null || typeof x === 'number' && Number.isFinite(x) && Number.isInteger(x), signal: x => member(['SIGTERM', 'SIGKILL', 'SIGABRT', 'SIGHUP', 'SIGINT', 'SIGSEGV', 'OTHER'], x), index: integer, unexpectedCount: integer, maxOutputBytes: x => integer(x) && Number(x) > 0, observedBytes: integer, stderr: summary, output: summary, missing: x => Array.isArray(x) && x.every(k => member(['nonce', 'protocolVersion', 'type', 'data', 'exitCode', 'signal', 'loggedIn', 'provider'], k)), loggedInType: x => member(['null', 'undefined', 'object', 'boolean', 'number', 'string', 'function', 'symbol', 'bigint'], x), exitCodeType: x => member(['undefined', 'object', 'boolean', 'number', 'string', 'function', 'symbol', 'bigint'], x) };
+    return Object.entries(v).every(([key, item]) => Object.hasOwn(fields, key) && fields[key](item));
+}

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

@@ -0,0 +1,47 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface DetailScope {
+    instanceId: string;
+    epoch: number;
+    sessionId: string;
+    provider: 'claude' | 'codex';
+    turn: number;
+    step: number;
+}
+export interface DetailObservation {
+    kind: 'extension' | 'commands' | 'tool' | 'usage' | 'notice' | 'need' | 'session';
+    severity: 'info' | 'warning' | 'action-required';
+    code: string;
+    summary: string;
+    method?: string;
+    payload?: unknown;
+}
+export type SanitizedObservation = Omit<DetailObservation, 'payload'> & {
+    payload: JsonValue;
+};
+export interface DetailRecord extends Omit<DetailObservation, 'payload'>, DetailScope {
+    version: 1;
+    eventId: string;
+    sequence: number;
+    payload: JsonValue;
+}
+export type DetailSink = {
+    append(record: Readonly<DetailRecord>): Promise<void>;
+};
+/** Only objects created by this module are trusted as redaction markers. */
+export declare function isSanitizedRedaction(value: unknown): boolean;
+/** 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. */
+export declare class ConversationDetails {
+    private readonly scope;
+    private readonly sink;
+    private readonly records;
+    private tail;
+    private firstFailure;
+    constructor(scope: DetailScope, sink: DetailSink);
+    record(observation: DetailObservation): void;
+    flush(): Promise<void>;
+    snapshot(): readonly DetailRecord[];
+}