@ai-workbench/remote-agent 0.8.10 → 0.8.12

package/dist/model-input-retention.js

@@ -0,0 +1,137 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { Session } from '@deepseek-ai/dsh-session';
+import { isDeepStrictEqual } from 'node:util';
+const preparationFailures = new WeakMap();
+/** Mark only at the actual X adapter's preparation catch, then rethrow the same
+ * error. One error object can prove only its first preparation, for that signal.
+ * Public request config is an intermediate proposal and is not route evidence. */
+export function markModelPreparationFailure(provider, error, signal) {
+    if (!signal || signal.aborted || error === null || typeof error !== 'object' || preparationFailures.has(error))
+        return;
+    preparationFailures.set(error, { provider, signal, consumed: false });
+}
+// Even a source-proven unknown early failure is deliberately not replayed.
+const preparationCodes = new Set(['MODEL_REQUIRED', 'MODEL_CATALOG_UNAVAILABLE', 'INVALID_MODEL_INFO', 'INVALID_MODEL_CONTEXT', 'INVALID_MODEL_MAX_TOKENS', 'INVALID_MODEL_REASONING', 'UNSUPPORTED_REASONING_EFFORT']);
+function codeOf(error) {
+    const code = error !== null && typeof error === 'object' && 'code' in error ? error.code : undefined;
+    return typeof code === 'string' && /^[A-Z][A-Z0-9_]*$/u.test(code) ? code : undefined;
+}
+function committed(events, messages) {
+    return events.some(event => event.type === 'user/message' && messages.some(message => message.id === event.data.id));
+}
+/**
+ * Retain a claimed human batch only after a known, undispatched metadata prepare
+ * failure. Restoration uses the public durable inbox without sending or waking
+ * the agent. This cannot cover errors before pre-step/request, or unknown core
+ * admission failures; it never manufactures transcript messages or model routes.
+ */
+export function installModelInputRetention(ctx, options) {
+    const attempts = new Map(), pending = new Set();
+    let disposed = false;
+    const live = (a) => !disposed && attempts.get(a.agent) === a && !a.signal.aborted
+        && ctx.get('agents')?.get(a.agent.id) === a.agent && ctx.get('sessions')?.get(a.session.id) === a.session && a.agent.session === a.session;
+    const safe = (a) => {
+        const events = a.session.snapshotEvents();
+        return !a.dispatched && !committed(events, a.messages) && !events.slice(a.offset).some(event => event.type === 'request/header' || event.type === 'assistant/message' || event.type === 'assistant/attempt');
+    };
+    const report = (a, message) => { if (!disposed && a.provider)
+        options.diagnostic(a.provider, message); };
+    const restore = async (a, originalCode) => {
+        try {
+            await a.agent.whenIdle();
+            if (!live(a) || !safe(a))
+                return;
+            // Claim true idle synchronously. A competing maintenance claim is reported,
+            // not retried. Input waking during this task remains the driver's own work.
+            await a.agent.runMaintenance(async (signal) => {
+                if (!live(a) || signal.aborted || !safe(a))
+                    return;
+                const queue = [...a.agent.inbox.nextTurn, ...a.agent.inbox.nextStep];
+                if (a.messages.some(message => queue.some(item => item.id === message.id)))
+                    return;
+                a.agent.inbox.splice('next-turn', 0, 0, a.messages);
+                const store = ctx.get('sessions'), persistence = ctx.get('sessionPersistence');
+                if (!store || typeof persistence?.open !== 'function' || !await store.flush(a.session))
+                    throw Object.assign(new Error('缺少官方持久化能力'), { code: 'INPUT_RETENTION_PERSISTENCE_REQUIRED' });
+                if (!live(a) || signal.aborted)
+                    return;
+                const handle = await persistence.open(a.session.id, 'read');
+                try {
+                    if (handle.id !== a.session.id || handle.header?.id !== a.session.id || handle.access !== 'read')
+                        throw Object.assign(new Error('持久会话身份不符'), { code: 'INPUT_RETENTION_VERIFY_FAILED' });
+                    const { events } = await handle.read();
+                    // Replay through the official Session validator and registered inbox fold,
+                    // including exact fork metadata. Do not normalize invalid durable splices.
+                    const replay = Session.create(a.session.id, events, handle.header, handle.inheritedEventCount);
+                    const inbox = ctx.get('sessionProjections')?.snapshot(replay, ['inbox']).values.inbox;
+                    if (!inbox)
+                        throw Object.assign(new Error('缺少官方待发队列投影'), { code: 'INPUT_RETENTION_PROJECTION_REQUIRED' });
+                    const restored = [...inbox['next-turn'], ...inbox['next-step']];
+                    if (committed(events, a.messages) || a.messages.some(message => restored.filter(item => item !== null && typeof item === 'object' && !Array.isArray(item) && item.id === message.id).length !== 1 || !restored.some(item => isDeepStrictEqual(item, message))))
+                        throw Object.assign(new Error('持久待发队列核对失败'), { code: 'INPUT_RETENTION_VERIFY_FAILED' });
+                }
+                finally {
+                    await handle.close();
+                }
+                if (live(a) && !signal.aborted)
+                    report(a, `本次模型准备失败，员工原话已保留在待发送队列；请先选择模型或修正设置后手动发送。没有自动重试。（诊断代码：${originalCode}）`);
+            });
+        }
+        catch (error) {
+            report(a, `本次模型准备失败；员工原话的恢复或持久化未能确认，请联系管理员核对，不要重复发送。没有自动重试。（原诊断代码：${originalCode}；恢复诊断代码：${codeOf(error) ?? 'INPUT_RETENTION_FAILED'}）`);
+        }
+        finally {
+            if (attempts.get(a.agent) === a)
+                attempts.delete(a.agent);
+        }
+    };
+    ctx.on('agent/pre-step', async (payload, next) => {
+        const decision = await next();
+        if (disposed)
+            return decision;
+        const messages = payload.messages.filter(message => message.source.kind === 'user');
+        if (decision.kind !== 'enter' || messages.length === 0 || messages.some(message => !decision.messages.some(accepted => accepted === message || isDeepStrictEqual(accepted, message)))) {
+            attempts.delete(payload.agent);
+            return decision;
+        }
+        attempts.set(payload.agent, { agent: payload.agent, session: payload.agent.session, turn: payload.turn, step: payload.step, signal: payload.signal, messages, offset: payload.agent.session.snapshotEvents().length, scheduled: false, dispatched: false, preflight: options.diagnosticForAttempt?.({ sessionId: payload.agent.session.id, turn: payload.turn, step: payload.step }) });
+        return decision;
+    });
+    ctx.on('agent/request', async (payload, next) => {
+        const config = await next(), a = attempts.get(payload.agent);
+        if (a && a.turn === payload.turn && a.step === payload.step && a.signal === payload.signal && options.isOurProvider(config.provider)) {
+            if (!config.model?.trim()) {
+                const error = new LlmError('请先选择模型', 'MODEL_REQUIRED');
+                markModelPreparationFailure(config.provider, error, payload.signal);
+                throw error;
+            }
+        }
+        return config;
+    });
+    ctx.on('agent/assistant-stream', ({ agent, frame }) => { const a = attempts.get(agent); if (a && frame.type === 'start' && frame.turn === a.turn && frame.step === a.step)
+        a.dispatched = true; });
+    ctx.on('agent/error', ({ agent, turn, step, error }) => {
+        const a = attempts.get(agent), code = codeOf(error);
+        const proof = error !== null && typeof error === 'object' ? preparationFailures.get(error) : undefined;
+        if (!a || a.turn !== turn || a.step !== step || !proof || proof.consumed || proof.signal !== a.signal || !options.isOurProvider(proof.provider))
+            return;
+        // Consume before further checks: canceled/unsafe attempts must not leave a
+        // reusable proof that could authorize a later failure of the same object.
+        proof.consumed = true;
+        if (a.scheduled || !live(a) || !safe(a))
+            return;
+        a.provider = proof.provider;
+        if (a.preflight) {
+            const writing = a.preflight(proof.provider, code ?? 'PREFLIGHT_FAILED').catch(error => { if (!disposed)
+                options.preflightDiagnostic?.(proof.provider, `连接前诊断保存未能确认；没有自动重发。（原诊断代码：${code ?? 'PREFLIGHT_FAILED'}；保存诊断代码：${codeOf(error) ?? 'DIAGNOSTIC_WRITE_FAILED'}）`); });
+            pending.add(writing);
+            void writing.finally(() => pending.delete(writing));
+        }
+        if (!code || !preparationCodes.has(code))
+            return;
+        a.scheduled = true;
+        void restore(a, code);
+    });
+    ctx.on('agent/disposed', ({ agent }) => { attempts.delete(agent); });
+    ctx.effect(() => async () => { disposed = true; attempts.clear(); await Promise.allSettled(pending); });
+}

package/dist/preflight-diagnostic.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ConnectApi, RuntimeRequest } from './provider.ts';
+import type { DetailObservation } from './conversation-details.ts';
+import type { createRemoteDetails } from './remote-details.ts';
+import type { SourceAdmissionStage } from './workspace-source.ts';
+type Position = {
+    turn: string | number | null;
+    step: string | number | null;
+};
+export declare function preflightCode(error: unknown): string;
+export declare function createPreflightDiagnostics(options: {
+    ctx: Pick<Context, 'get'>;
+    getApi: () => ConnectApi | undefined;
+    manager: () => Pick<ReturnType<typeof createRemoteDetails>, 'recordPreflightCheck'>;
+}): {
+    begin(request: RuntimeRequest, _provider: "claude" | "codex"): void;
+    record: (request: RuntimeRequest, provider: "claude" | "codex", observation: DetailObservation) => Promise<void>;
+    failure(request: RuntimeRequest, provider: "claude" | "codex", error: unknown, stage: SourceAdmissionStage): Promise<void>;
+    forPreparation(sessionId: string, context: Position): (provider: string, code: string) => Promise<void>;
+};
+export type PreflightDiagnostics = ReturnType<typeof createPreflightDiagnostics>;
+export {};

package/dist/preflight-diagnostic.js

@@ -0,0 +1,112 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { isDeepStrictEqual } from 'node:util';
+import { NeedError } from "./remote.js";
+import { ModelConfigurationError } from "./model-configuration.js";
+import { officialEmployeeWorkspace } from "./employee-workspace.js";
+import { AGENTS } from "./agents.js";
+import { validPreflightPayload } from "./preflight-payload.js";
+const unknownSource = () => ({ workspaceId: null, bindingId: null, source: null, status: null });
+export function preflightCode(error) {
+    if (typeof error === 'string' && /^[A-Z][A-Z0-9_]*$/.test(error))
+        return error;
+    if (error instanceof NeedError || error instanceof LlmError || error instanceof ModelConfigurationError)
+        return error.code;
+    return error instanceof Error && error.name === 'AbortError' ? 'ABORTED' : 'PREFLIGHT_FAILED';
+}
+export function createPreflightDiagnostics(options) {
+    const scopes = new WeakMap();
+    function capture(sessionId, position) {
+        const api = options.getApi();
+        let connection, session, header, source = unknownSource(), captureError;
+        let context = position ? { ...position } : { turn: null, step: null };
+        try {
+            connection = api?.getConnectionState();
+            session = sessionId ? options.ctx.get('sessions')?.get(SessionId(sessionId)) : undefined;
+            header = session && structuredClone(session.header);
+            if (!position)
+                for (const event of session?.snapshotEvents() ?? []) {
+                    if (event.type === 'turn/start')
+                        context = { turn: event.data.turn, step: null };
+                    else if (event.type === 'turn/end')
+                        context = { turn: null, step: null };
+                    else if (event.type === 'step/start' && event.data.turn === context.turn)
+                        context.step = event.data.step;
+                    else if (event.type === 'step/end')
+                        context.step = null;
+                }
+            if (sessionId && session) {
+                let workspace;
+                try {
+                    workspace = officialEmployeeWorkspace(sessionId, options.ctx.get('workspaceRegistry'), session.header);
+                }
+                catch (error) {
+                    if (!(error instanceof NeedError && error.code === 'EMPLOYEE_WORKSPACE_UNAVAILABLE'))
+                        throw error;
+                }
+                if (workspace) {
+                    source.workspaceId = workspace.id;
+                    const state = api?.getWorkspaceLocationState?.();
+                    const rows = state?.items.filter(row => row.workspaceId === workspace.id) ?? [];
+                    if (state?.phase === 'ready' && state.instanceId === connection?.instanceId && state.epoch === connection.epoch && rows.length === 1) {
+                        const row = rows[0];
+                        source = { workspaceId: row.workspaceId, bindingId: row.bindingId, source: row.source, status: row.status };
+                    }
+                }
+            }
+        }
+        catch (error) {
+            captureError = error;
+        }
+        const assertScope = () => {
+            if (captureError !== undefined)
+                throw Object.assign(new NeedError('REMOTE_DETAIL_SCOPE_INVALID', '连接前诊断上下文无法核对。', '真实官方会话与连接快照'), { cause: captureError });
+            if (!sessionId || !session || options.ctx.get('sessions')?.get(SessionId(sessionId)) !== session || !isDeepStrictEqual(session.header, header))
+                throw new NeedError('REMOTE_DETAIL_SCOPE_INVALID', '连接前诊断所属会话已变化。', '原官方session/header');
+        };
+        return { sessionId, binding: { api, connection }, context, source, assertScope };
+    }
+    const scopeFor = (request) => { let scope = scopes.get(request); if (!scope) {
+        scope = capture(request.sessionId);
+        scopes.set(request, scope);
+    } return scope; };
+    const write = (scope, provider, observation) => options.manager().recordPreflightCheck({ sessionId: scope.sessionId, provider, observation, context: scope.context, binding: scope.binding, assertScope: scope.assertScope });
+    async function record(request, provider, observation) {
+        const scope = scopeFor(request), payload = observation.payload;
+        if (validPreflightPayload(payload) && ['failed', 'declined', 'cancelled'].includes(payload.outcome))
+            request.preflightFailureRecorded = true;
+        try {
+            await write(scope, provider, observation);
+            if (validPreflightPayload(payload) && payload.outcome === 'confirmed')
+                scope.source = { workspaceId: payload.workspaceId, bindingId: payload.bindingId, source: payload.source, status: payload.status };
+        }
+        catch (error) {
+            request.preflightFailureRecorded = true;
+            throw error;
+        }
+    }
+    return {
+        begin(request, _provider) { scopeFor(request); }, record,
+        async failure(request, provider, error, stage) {
+            if (request.preflightFailureRecorded)
+                return;
+            request.preflightFailureRecorded = true;
+            const scope = scopeFor(request), code = preflightCode(error);
+            try {
+                await record(request, provider, { kind: 'need', severity: 'action-required', code, summary: '本轮在连接前准备阶段停止；原始请求保留，未重发。', payload: { phase: 'workspace-source-admission', stage, ...scope.source, outcome: code === 'ABORTED' ? 'cancelled' : 'failed' } });
+            }
+            catch (diagnostic) {
+                throw Object.assign(new NeedError('CONVERSATION_DETAILS_FAILED', '本轮连接前诊断未能保存，已停止。', '原错误代码 ' + code + '；诊断错误代码 ' + preflightCode(diagnostic)), { cause: new AggregateError([error, diagnostic], 'PREFLIGHT_AND_DIAGNOSTIC_FAILED') });
+            }
+        },
+        forPreparation(sessionId, context) {
+            const scope = capture(sessionId, context);
+            return async (provider, code) => {
+                const brand = AGENTS.find(agent => agent.id === provider)?.loginProvider;
+                if (!brand)
+                    throw new NeedError('REMOTE_DETAIL_SCOPE_INVALID', '不是本插件的远程品牌。', '真实X品牌');
+                await write(scope, brand, { kind: 'need', severity: 'action-required', code, summary: '模型准备在派发前失败；没有自动重发任务。', payload: { phase: 'workspace-source-admission', stage: code === 'MODEL_REQUIRED' ? 'input-prepare' : 'model-catalog', ...scope.source, outcome: code === 'ABORTED' ? 'cancelled' : 'failed' } });
+            };
+        },
+    };
+}

package/dist/preflight-payload.d.ts

@@ -0,0 +1,11 @@
+import type { SourceAdmissionStage } from './workspace-source.ts';
+export interface PreflightPayload {
+    phase: 'workspace-source-admission';
+    stage: SourceAdmissionStage;
+    workspaceId: string | null;
+    bindingId: string | null;
+    source: 'local' | 'host' | 'legacy-host' | null;
+    status: 'unselected' | 'selected' | 'legacy-confirmation-required' | 'invalid' | null;
+    outcome: 'confirmation-required' | 'confirmed' | 'declined' | 'cancelled' | 'failed';
+}
+export declare function validPreflightPayload(value: unknown): value is PreflightPayload;

package/dist/preflight-payload.js

@@ -0,0 +1,11 @@
+export function validPreflightPayload(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const p = value, keys = ['phase', 'stage', 'workspaceId', 'bindingId', 'source', 'status', 'outcome'];
+    const id = (v) => v === null || typeof v === 'string' && v.length > 0 && !/[\x00-\x1f\x7f]/.test(v);
+    return Object.keys(p).length === keys.length && keys.every(key => Object.hasOwn(p, key)) && p.phase === 'workspace-source-admission'
+        && ['source-context', 'source-confirmation', 'input-acceptance', 'login-readiness', 'local-admission', 'input-prepare', 'model-catalog', 'runtime-resolve'].includes(p.stage)
+        && id(p.workspaceId) && id(p.bindingId) && [null, 'local', 'host', 'legacy-host'].includes(p.source)
+        && [null, 'unselected', 'selected', 'legacy-confirmation-required', 'invalid'].includes(p.status)
+        && ['confirmation-required', 'confirmed', 'declined', 'cancelled', 'failed'].includes(p.outcome);
+}

package/dist/presentation.js

@@ -5,6 +5,12 @@ export const TEST_HOST_NOTICE = '远程主机正在使用测试配置，遇到
 /** Employee failures use business language; diagnostic codes remain separately available. */
 export function employeeFailure(code, brand = 'codex') {
     const messages = {
+        WORKSPACE_SOURCE_CONFIRMATION_DECLINED: '你没有确认改用本机文件夹，本轮未执行；你的原话仍保留。',
+        WORKSPACE_SOURCE_CONFIRMATION_UNAVAILABLE: '我需要打开工作区来源确认，目前无法显示确认动作；本轮未执行，你的原话仍保留。',
+        WORKSPACE_SOURCE_SELECTION_UNCONFIRMED: '无法核对工作区来源的确认结果，本轮已停止；你的原话仍保留。',
+        WORKSPACE_SOURCE_CONFIRMATION_FAILED: '工作区来源确认未完成，本轮已停止；你的原话仍保留。',
+        WORKSPACE_LOCATION_REQUIRED: '我需要你确认这个工作区使用哪一个文件夹，本轮未执行；你的原话仍保留。',
+        WORKSPACE_LOCATION_CONFLICT: '工作区来源选择已更新，本次确认不能覆盖新的选择；本轮未执行，你的原话仍保留。',
         LOCAL_USER_TURN_CHANGED: '本次输入已变化，本轮已停止，请确认对话后重新发送。',
         LOCAL_USER_TURN_UNCONFIRMED: '无法核对本次员工输入，本轮已停止；请在当前会话重新发送。',
         LOCAL_USER_TURN_ACCEPTANCE_INVALID: '本次输入的核验回执不一致，本轮已停止，请联系管理员。',

package/dist/provider.d.ts

@@ -12,6 +12,7 @@ import type { WorkspaceNoticePresentation } from './workspace-notice.ts';
 import { StageTiming } from './stage-timing.ts';
 import type { RecoveryJournal, AcpRecovery } from './recovery.ts';
 import type { EmployeeProviderOptions } from './employee-provider.ts';
+import { type WorkspaceSourceOptions, type SourceAdmissionStage } from './workspace-source.ts';
 import type { LocalUserTurnAcceptance } from '@ai-workbench/connect/api';
 import type { EmployeeRouting } from './employee-relay.ts';
 export interface EmployeeExecution {
@@ -64,6 +65,8 @@ export interface Runtime {
     employeePresentation?: string;
 }
 export interface RuntimeRequest extends Invocation {
+    preflightFailureRecorded?: boolean;
+    recordEarlyFailure?: (error: unknown, stage: SourceAdmissionStage) => Promise<void>;
     userInputIds?: readonly string[];
     localAcceptance?: Readonly<LocalUserTurnAcceptance>;
     localAdmissionCheck?: () => void;
@@ -135,7 +138,7 @@ type Result<T> = {
     } & Pick<ConnectNeed, 'officialReason'>;
 };
 /** 消费正式connect-api 0.7公开子集；X不响应L登录票据、不直接调用登录。 */
-export interface ConnectApi extends Pick<LConnectApi, 'getConnectionState' | 'getLoginPromptState' | 'requestLoginPrompt' | 'refreshLoginPrompts'>, Partial<NativeWorkspaceApi>, Partial<Pick<LConnectApi, 'getWorkspaceBindingState' | 'getModelCatalogTarget' | 'onConnectionState' | 'onLoginPromptState' | 'appendRemoteConversationDetail' | 'getRemoteConversationDetailReceipt' | 'listRemoteConversationDetails' | 'getWorkspaceLocationState' | 'getLocalWorkspaceContext' | 'onWorkspaceLocationState' | 'acceptLocalWorkspaceUserTurn'>> {
+export interface ConnectApi extends Pick<LConnectApi, 'getConnectionState' | 'getLoginPromptState' | 'requestLoginPrompt' | 'refreshLoginPrompts'>, Partial<NativeWorkspaceApi>, Partial<Pick<LConnectApi, 'getWorkspaceBindingState' | 'getModelCatalogTarget' | 'onConnectionState' | 'onLoginPromptState' | 'appendRemoteConversationDetail' | 'getRemoteConversationDetailReceipt' | 'listRemoteConversationDetails' | 'getWorkspaceLocationState' | 'getLocalWorkspaceContext' | 'onWorkspaceLocationState' | 'acceptLocalWorkspaceUserTurn' | 'selectWorkspaceLocation'>> {
     getState?(): ConnectState;
     getSshTarget(): Promise<Result<ConnectTarget>>;
     checkLogin(provider: LoginProvider): Promise<Result<{
@@ -189,6 +192,7 @@ export declare function connectProvider(get: () => ConnectApi | undefined, optio
     agent?: AgentDefinition;
     ask?: Interaction;
     notice?: NoticeConsumer;
+    workspaceSource?: WorkspaceSourceOptions;
     employee?: EmployeeProviderOptions;
     local?: LocalRuntimeProvider;
     details?: (request: RuntimeRequest, api: ConnectApi, connection: ConnectionState, target: ConnectTarget) => Promise<DetailChannel>;

package/dist/provider.js

@@ -3,6 +3,7 @@ import { NeedError } from "./remote.js";
 import { CONNECTION_REQUIRED, TEST_HOST_NOTICE } from "./presentation.js";
 import { CODEX_AGENT } from "./agents.js";
 import { StageTiming } from "./stage-timing.js";
+import { confirmLegacyWorkspaceSource } from "./workspace-source.js";
 export function requireLoginCoordinator(api) {
     if (!['getConnectionState', 'getLoginPromptState', 'requestLoginPrompt', 'refreshLoginPrompts'].every(key => typeof api[key] === 'function'))
         throw new NeedError('CONNECT_API_MISMATCH', '我需要 connect-api 0.6.1 的统一登录询问与连接状态能力', 'L >=0.6.1');
@@ -168,28 +169,53 @@ export function connectProvider(get, options = {}) {
         requireLoginCoordinator(api);
         if (request.mode === 'one-shot' && !agent.oneShot)
             throw new NeedError('MODE_UNSUPPORTED', '此远程模型仅支持会话模式', '使用会话模式');
-        if (options.employee) {
-            const module = await import("./employee-provider.js");
-            request.localAcceptance = await module.acceptEmployeeUserTurn(get, options.employee, agent, api, request);
-        }
-        const { target, connection } = await request.timing.run('login-ready', async () => {
+        const confirmedSource = options.workspaceSource ? await confirmLegacyWorkspaceSource(get, api, request, options.workspaceSource) : undefined;
+        let sourceStage = 'input-acceptance';
+        if (confirmedSource && !request.recordEarlyFailure)
+            request.recordEarlyFailure = (error, stage) => confirmedSource.recordFailure(error, stage);
+        try {
+            confirmedSource?.assertCurrent();
+            if (options.employee) {
+                const module = await import("./employee-provider.js");
+                request.localAcceptance = await module.acceptEmployeeUserTurn(get, options.employee, agent, api, request);
+            }
+            confirmedSource?.assertCurrent();
+            if (confirmedSource) {
+                const previous = request.localAdmissionCheck;
+                request.localAdmissionCheck = () => { confirmedSource.assertCurrent(); previous?.(); };
+            }
+            sourceStage = 'login-readiness';
+            const { target, connection } = await request.timing.run('login-ready', async () => {
+                request.localAdmissionCheck?.();
+                const before = api.getConnectionState();
+                const target = await ensureReady(api, agent.loginProvider, request.signal);
+                validateTarget(target);
+                request.signal?.throwIfAborted();
+                if (get() !== api)
+                    throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
+                const connection = await waitForLogin(api, agent.loginProvider, before, get, request.signal);
+                return { target, connection };
+            });
+            if (request.identity && request.identity !== identity(target))
+                throw new NeedError('SESSION_CONTEXT_MISMATCH', '员工主机与原会话不一致，请新建会话', '原员工主机');
+            if (options.employee && request.localAcceptance)
+                await (await import("./employee-provider.js")).validateEmployeeUserTurn(get, options.employee, api, request, connection);
             request.localAdmissionCheck?.();
-            const before = api.getConnectionState();
-            const target = await ensureReady(api, agent.loginProvider, request.signal);
-            validateTarget(target);
-            request.signal?.throwIfAborted();
-            if (get() !== api)
-                throw new NeedError('CONNECTION_LOST', '远程主机连接组件已更换', '当前员工连接');
-            const connection = await waitForLogin(api, agent.loginProvider, before, get, request.signal);
-            return { target, connection };
-        });
-        if (request.identity && request.identity !== identity(target))
-            throw new NeedError('SESSION_CONTEXT_MISMATCH', '员工主机与原会话不一致，请新建会话', '原员工主机');
-        if (options.employee && request.localAcceptance)
-            await (await import("./employee-provider.js")).validateEmployeeUserTurn(get, options.employee, api, request, connection);
-        request.localAdmissionCheck?.();
-        admissions.set(request, { api, target, connection });
-        await options.local?.admit?.(request, api, connection, target);
+            admissions.set(request, { api, target, connection });
+            sourceStage = 'local-admission';
+            await options.local?.admit?.(request, api, connection, target);
+            confirmedSource?.assertCurrent();
+        }
+        catch (error) {
+            admissions.delete(request);
+            const record = request.recordEarlyFailure;
+            request.recordEarlyFailure = undefined;
+            if (record)
+                await record(error, sourceStage);
+            else
+                await confirmedSource?.recordFailure(error, sourceStage);
+            throw error;
+        }
     };
     const resolve = async (request) => {
         if (!admissions.has(request))
@@ -199,6 +225,7 @@ export function connectProvider(get, options = {}) {
         const { api, target, connection } = admitted;
         const stable = () => request.timing.run('connection-confirm', () => waitForLogin(api, agent.loginProvider, connection, get, request.signal));
         await stable();
+        request.localAdmissionCheck?.();
         if (!request.sessionId)
             throw new NeedError('PROJECT_BINDING_REQUIRED', '我需要当前会话和已选择的工作区，请使用原生工作区入口', 'DSH会话与原生工作区');
         if (options.employee) {

package/dist/remote-details.d.ts

@@ -23,6 +23,10 @@ export interface DetailRequest {
 export declare function privateDirectory(path: string): Promise<void>;
 export declare function durableWrite(path: string, value: unknown): Promise<void>;
 export declare function readJournal(path: string): Promise<unknown>;
+export interface DiagnosticBinding {
+    api: RemoteDetailsApi | undefined;
+    connection: Connection | undefined;
+}
 export declare function createRemoteDetails(options: {
     profileDir: string;
     getApi: () => RemoteDetailsApi | undefined;
@@ -45,5 +49,19 @@ export declare function createRemoteDetails(options: {
         eventId: string;
         recorded: true;
     }>;
+    recordPreflightCheck(request: {
+        sessionId?: string;
+        provider: "claude" | "codex";
+        observation: DetailObservation;
+        context?: {
+            turn: string | number | null;
+            step: string | number | null;
+        };
+        binding?: DiagnosticBinding;
+        assertScope?: () => void;
+    }): Promise<{
+        eventId: string;
+        recorded: true;
+    }>;
     open(request: DetailRequest): Promise<DetailChannel>;
 };