@ai-workbench/remote-agent 0.8.10 → 0.8.12

package/dist/index.js

@@ -1,3 +1,5 @@
+import { runCatalog } from "./catalog-ssh.js";
+import { createCatalogDiagnostics, CatalogDiagnosticsRemote } from "./catalog-diagnostics.js";
 import { SessionId } from '@deepseek-ai/dsh-session';
 import Schema from '@deepseek-ai/schemastery';
 import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
@@ -24,11 +26,15 @@ import { verifyRecoveryCheckpoint, currentInputIds } from "./recovery-checkpoint
 import { ModelCatalog, modelInfo } from "./model-catalog.js";
 import { ModelConfigurationError } from "./model-configuration.js";
 import { officialEmployeeWorkspace } from "./employee-workspace.js";
+import { nativeWorkspaceSourceConfirmation } from "./workspace-source-confirmation.js";
 import { resolveEmployeeNative } from "./employee-native.js";
 import { createLocalUserTurnObserver } from "./local-user-turn.js";
 import { createClaudeLocalProvider } from "./claude-local.js";
 import { readLocalUserTurn } from "./local-user-turn.js";
 import { readEmployeeWorkspace } from "./employee-workspace.js";
+import { createModelDefaults, createDefaultSelectionWriter } from "./model-defaults.js";
+import { createPreflightDiagnostics } from "./preflight-diagnostic.js";
+import { installModelInputRetention, markModelPreparationFailure } from "./model-input-retention.js";
 export const name = 'ai-workbench-remote-agent';
 export const settingsNamespace = 'ai-workbench-codex';
 // L can be installed/enabled after X; keeping X mounted lets it explain the prerequisite.
@@ -65,6 +71,23 @@ function readPointer(options, agent) {
         throw new NeedError('SESSION_CONTEXT_DIGEST_INVALID', '原Codex会话的初建上下文摘要未知或无效，不能猜测是否相同，本轮未发送', '原会话合法的64位十六进制初建上下文摘要');
     return pointer;
 }
+// A reporting failure can wrap the original admission error. Preserve its
+// already-safe login snapshot even when a newer preflight delivery is unknown.
+function originalLoginFailure(error) {
+    const pending = [error], seen = new Set();
+    while (pending.length) {
+        const current = pending.pop();
+        if (!current || typeof current !== 'object' || seen.has(current))
+            continue;
+        seen.add(current);
+        if (current instanceof NeedError && current.technical)
+            return current;
+        if (current instanceof AggregateError)
+            pending.push(...current.errors);
+        if (current instanceof Error && current.cause !== undefined)
+            pending.push(current.cause);
+    }
+}
 export class CodexRemoteAdapter extends LlmAdapter {
     resolveRuntime;
     approve;
@@ -73,6 +96,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
     readImage;
     reportLoginFailure;
     directory;
+    preflightDiagnostics;
     config;
     sessions = new Map();
     turns = new Map();
@@ -80,7 +104,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
     shuttingDown = false;
     detached = new Set();
     cleanups = new WeakMap();
-    constructor(config, resolveRuntime, approve, providerName = () => PROVIDER_NAMES.en, agent = CODEX_AGENT, readImage, reportLoginFailure, directory) {
+    constructor(config, resolveRuntime, approve, providerName = () => PROVIDER_NAMES.en, agent = CODEX_AGENT, readImage, reportLoginFailure, directory, preflightDiagnostics) {
         super();
         this.resolveRuntime = resolveRuntime;
         this.approve = approve;
@@ -89,6 +113,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
         this.readImage = readImage;
         this.reportLoginFailure = reportLoginFailure;
         this.directory = directory;
+        this.preflightDiagnostics = preflightDiagnostics;
         this.config = typeof config === 'function' ? config : () => config;
     }
     providerInfo(provider) { return { id: provider, name: this.providerName() }; }
@@ -100,14 +125,21 @@ export class CodexRemoteAdapter extends LlmAdapter {
     finally {
         catalog.release();
     } }
-    async resolveModel(provider, id, signal) { const catalog = await this.catalog(signal); try {
-        const model = catalog.models.find(model => model.id === id);
-        if (!model)
-            throw new LlmError('无法获取模型列表：所选模型已不在当前主机目录中', 'MODEL_CATALOG_UNAVAILABLE');
-        return modelInfo(provider, model);
+    async resolveModel(provider, id, signal) { try {
+        const catalog = await this.catalog(signal);
+        try {
+            const model = catalog.models.find(model => model.id === id);
+            if (!model)
+                throw new LlmError(id === 'remote' ? '无法获取模型列表：这个会话保存的是旧版模型选择，请打开本会话的模型菜单，重新选择模型后再发送。' : '所选模型已不在当前主机目录中，请打开本会话的模型菜单重新选择模型。', 'MODEL_CATALOG_UNAVAILABLE');
+            return modelInfo(provider, model);
+        }
+        finally {
+            catalog.release();
+        }
     }
-    finally {
-        catalog.release();
+    catch (error) {
+        markModelPreparationFailure(provider, error, signal);
+        throw error;
     } }
     async invalidateModelState() { for (const turn of this.turns.values())
         turn.abort(); await Promise.all([...this.sessions.keys()].map(id => this.disposeSession(id))); }
@@ -177,10 +209,11 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (error instanceof NeedError) {
                 const rpc = /RPC 错误码 (-?\d+)/u.exec(error.requires)?.[1];
                 const message = employeeFailure(error.code, this.agent.loginProvider) + (rpc ? `（技术详情：RPC 错误码 ${rpc}）` : '');
-                let diagnostic = error.technical ? JSON.stringify(error.technical) : '';
-                if (error.technical && this.reportLoginFailure) {
+                const login = originalLoginFailure(error);
+                let diagnostic = login?.technical ? JSON.stringify(login.technical) : '';
+                if (login?.technical && this.reportLoginFailure) {
                     try {
-                        const receipt = await this.reportLoginFailure(options.sessionId, error.code, error.technical);
+                        const receipt = await this.reportLoginFailure(options.sessionId, login.code, login.technical);
                         diagnostic += '；诊断 eventId=' + receipt.eventId;
                     }
                     catch (failure) {
@@ -206,6 +239,8 @@ export class CodexRemoteAdapter extends LlmAdapter {
         const signal = AbortSignal.any([this.lifetime.signal, turn.signal, ...(original.signal ? [original.signal] : [])]);
         const options = { ...original, signal };
         const timing = new StageTiming();
+        let request;
+        let earlyStage = 'input-prepare';
         let runtime;
         let session;
         let live;
@@ -218,6 +253,10 @@ export class CodexRemoteAdapter extends LlmAdapter {
         let modelConfiguration;
         const config = this.config();
         const mode = this.agent.oneShot ? config.mode : 'session';
+        request = { sessionId: options.sessionId, mode: mode ?? 'session', timing, signal };
+        this.preflightDiagnostics?.begin(request, this.agent.loginProvider);
+        if (this.preflightDiagnostics)
+            request.recordEarlyFailure = (error, stage) => this.preflightDiagnostics.failure(request, this.agent.loginProvider, error, stage);
         try {
             if (!mode || (mode === 'session' && (!Number.isSafeInteger(config.acpMaxMessageBytes) || config.acpMaxMessageBytes < 1)))
                 throw new NeedError('SETTINGS_REQUIRED', '远程模型连接设置无效，请联系管理员检查', '有效的mode/acpMaxMessageBytes');
@@ -236,11 +275,13 @@ export class CodexRemoteAdapter extends LlmAdapter {
             const configuration = JSON.stringify([mode, config.acpMaxMessageBytes, config.brokerMaxFrameBytes, config.brokerControlMaxBytes, config.employeeShellKillGraceMs]);
             if (live && live.configuration !== configuration)
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '会话运行设置已改变，请新建会话', '原会话运行设置');
-            const request = { timing, acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, recoveryCheckpointId: previous?.recoveryCheckpointId, sessionId: options.sessionId, mode, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, retainProcess: !!key && mode === 'session', signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) };
+            Object.assign(request, { timing, acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, recoveryCheckpointId: previous?.recoveryCheckpointId, sessionId: options.sessionId, mode, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, retainProcess: !!key && mode === 'session', signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) });
             const after = options.messages.findLastIndex(message => message.role === 'assistant' && !isWorkspaceNoticeMessage(message));
             request.userInputIds = Object.freeze(options.messages.slice(after + 1).flatMap(message => message.role === 'user' && message.source?.kind === 'user' && typeof message.id === 'string' ? [message.id] : []));
             request.userMessageIds = request.userInputIds;
+            earlyStage = 'source-context';
             await this.resolveRuntime.preflight?.(request);
+            earlyStage = 'input-prepare';
             let input = await timing.run('input-prepare', () => prepareInput(options, this.readImage));
             const contextSha256 = createHash('sha256').update(input.systemPrompt ?? '').digest('hex');
             request.contextSha256 = contextSha256;
@@ -270,6 +311,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (mode === 'one-shot')
                 throw new NeedError('MODEL_CONFIGURATION_UNSUPPORTED', '单次模式不支持确认当前模型与推理等级，请改用会话模式', '支持模型配置确认的会话模式');
             request.localAdmissionCheck?.();
+            earlyStage = 'model-catalog';
             catalog = await this.catalog(signal);
             selected = catalog.models.find(model => model.id === options.model);
             if (!selected)
@@ -279,6 +321,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             let modelSignal = AbortSignal.any([signal, catalog.signal]);
             options.signal = modelSignal;
             request.signal = modelSignal;
+            earlyStage = 'runtime-resolve';
             runtime = await this.resolveRuntime(request);
             signal.throwIfAborted();
             if (runtime.execution?.signal) {
@@ -315,6 +358,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (!details)
                 throw new NeedError('TECHNICAL_DETAILS_UNAVAILABLE', '技术详情暂不可用，请更新远程主机连接组件。', 'L技术详情持久接收能力');
             timing.bind(detail => details.record(detail));
+            request.recordEarlyFailure = undefined;
             const mapper = new StreamMapper(mode === 'session' && !contextChanged ? (runtime.restartNotice ? undefined : live ? live.usageSnapshot : previous ? (previous.usageSnapshot ?? null) : undefined) : undefined, observation => details.record(observation));
             activeMapper = mapper;
             let id;
@@ -505,11 +549,29 @@ export class CodexRemoteAdapter extends LlmAdapter {
             if (live && (remoteAttempted || runtime === live.runtime))
                 live.failure = { cause: error };
             let reportingFailure;
+            if (request?.recordEarlyFailure) {
+                const record = request.recordEarlyFailure;
+                request.recordEarlyFailure = undefined;
+                const code = error instanceof NeedError || error instanceof ModelConfigurationError ? error.code : error instanceof LlmError ? error.failure.code : signal.aborted ? 'ABORTED' : 'WORKSPACE_SOURCE_CONFIRMATION_FAILED';
+                try {
+                    await record(Object.assign(new NeedError(code, '本轮在执行前失败。', '白名单阶段与错误代码'), { cause: error }), earlyStage);
+                }
+                catch (failure) {
+                    reportingFailure = { cause: failure };
+                }
+            }
             try {
                 await runtime?.details?.flush();
             }
             catch (failure) {
-                reportingFailure = { cause: failure };
+                if (reportingFailure === undefined)
+                    reportingFailure = { cause: failure };
+                else {
+                    const first = reportingFailure.cause;
+                    const originalCode = error instanceof NeedError || error instanceof ModelConfigurationError ? error.code : error instanceof LlmError ? error.failure.code : 'WORKSPACE_SOURCE_CONFIRMATION_FAILED';
+                    const flushCode = failure instanceof NeedError || failure instanceof ModelConfigurationError ? failure.code : failure instanceof LlmError ? failure.failure.code : 'CONVERSATION_DETAILS_FAILED';
+                    reportingFailure = { cause: Object.assign(new NeedError('CONVERSATION_DETAILS_FAILED', '本轮诊断保存及详情收尾失败，已停止。', '原错误代码 ' + originalCode + '；' + (first instanceof NeedError ? first.requires : '早期诊断保存失败') + '；详情收尾代码 ' + flushCode), { cause: new AggregateError([error, first, failure], 'ADMISSION_DIAGNOSTIC_AND_FLUSH_FAILED') }) };
+                }
             }
             if (activeMapper)
                 yield* activeMapper.flush();
@@ -543,8 +605,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, reportLoginFailure, directory) { super(); for (const agent of AGENTS)
-        this.adapters.set(agent.id, new CodexRemoteAdapter(config, makeRuntime(agent), approve, () => nameFor(agent), agent, readImage, reportLoginFailure, directory)); }
+    constructor(config, makeRuntime, approve, nameFor, readImage, reportLoginFailure, directory, preflightDiagnostics) { super(); for (const agent of AGENTS)
+        this.adapters.set(agent.id, new CodexRemoteAdapter(config, makeRuntime(agent), approve, () => nameFor(agent), agent, readImage, reportLoginFailure, directory, preflightDiagnostics)); }
     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); }
@@ -582,8 +644,30 @@ export function apply(ctx, live) {
         }
         return manager;
     };
+    const preflightDiagnostics = createPreflightDiagnostics({ ctx, getApi: get, manager: managerForProfile });
     let changed = () => { };
-    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes, undefined, () => changed());
+    const diagnostics = new Map();
+    const diagnostic = (scope, provider, message) => {
+        let entry = diagnostics.get(provider);
+        if (!entry) {
+            entry = new Map();
+            diagnostics.set(provider, entry);
+        }
+        if (entry.get(scope) === message)
+            return;
+        if (message === undefined)
+            entry.delete(scope);
+        else
+            entry.set(scope, message);
+    };
+    let defaults;
+    const catalogDiagnostics = createCatalogDiagnostics(() => { const profile = ctx.get('profileContext'); return profile?.dir; });
+    // Public Loader Entry.options.id; optional when mounted without Loader.
+    const actualSettingsNamespace = ctx.fiber.entry?.options.id;
+    new CatalogDiagnosticsRemote(ctx, async () => ({ ...await catalogDiagnostics.snapshot(), settingsNamespace: actualSettingsNamespace ?? null, providers: AGENTS.map(agent => ({ provider: agent.id, name: agent.name[language], messages: [...(diagnostics.get(agent.id)?.values() ?? [])] })) }));
+    const modelDirectory = new ModelCatalog(get, () => config().acpMaxMessageBytes, (...args) => { const state = get()?.getConnectionState(); const connection = state ? { instanceId: state.instanceId, epoch: state.epoch, phase: state.phase } : null; return runCatalog(...args, event => catalogDiagnostics.record({ ...event, connection })); }, () => changed(), (brand, message) => {
+        diagnostic('catalog', AGENTS.find(agent => agent.loginProvider === brand).id, message);
+    }, (agent, models, assertCurrent) => defaults?.observe(agent, models, assertCurrent));
     const adapter = new RemoteAgentsAdapter(config, agent => {
         const details = async (request, api, connection, target) => {
             return managerForProfile().open({ sessionId: request.sessionId, provider: agent.loginProvider, identity: `${target.username}@${target.host}:${target.port}`, connection, localAcceptanceId: request.localAcceptanceId ?? request.localAcceptance?.acceptanceId });
@@ -617,16 +701,20 @@ export function apply(ctx, live) {
             };
             return runtime;
         };
-        const local = agent.loginProvider === 'claude' ? createClaudeLocalProvider({ getConnect: get, getNetwork: () => ctx.get('aiWorkbenchNetwork'), readWorkspace: id => readEmployeeWorkspace(ctx, id), readUserTurn: request => readLocalUserTurn(ctx, { sessionId: request.sessionId, route: agent.id, userMessageIds: request.userMessageIds ?? [] }), reportAdmissionFailure: (request, code) => managerForProfile().recordLocalFailure({ sessionId: request.sessionId, provider: 'claude', code }), recordUnscoped: (request, observation) => managerForProfile().recordLocalFailure({ sessionId: request.sessionId, provider: 'claude', code: observation.code, observation }), configuration: config, details, open }) : undefined;
-        return connectProvider(get, { agent, ...(agent.loginProvider === 'codex' ? { employee: {
+        const local = agent.loginProvider === 'claude' ? createClaudeLocalProvider({ getConnect: get, getNetwork: () => ctx.get('aiWorkbenchNetwork'), readWorkspace: id => readEmployeeWorkspace(ctx, id), readUserTurn: request => readLocalUserTurn(ctx, { sessionId: request.sessionId, route: agent.id, userMessageIds: request.userMessageIds ?? [] }), reportAdmissionFailure: (request, code) => preflightDiagnostics.failure(request, 'claude', code, 'local-admission'), recordUnscoped: (request, observation) => managerForProfile().recordLocalFailure({ sessionId: request.sessionId, provider: 'claude', code: observation.code, observation }), configuration: config, details, open }) : undefined;
+        const workspace = async (request) => {
+            const services = ctx;
+            const registry = services.get('workspaceRegistry');
+            const sessions = services.get('sessions');
+            return officialEmployeeWorkspace(request.sessionId, registry, sessions?.get(request.sessionId)?.header);
+        };
+        return connectProvider(get, { agent, workspaceSource: {
+                workspace, currentUserTurn: request => localTurns.current(request), confirm: nativeWorkspaceSourceConfirmation(ctx),
+                record: (request, observation) => preflightDiagnostics.record(request, agent.loginProvider, observation),
+            }, ...(agent.loginProvider === 'codex' ? { employee: {
                     currentUserTurn: request => localTurns.current(request),
                     getNetwork: () => ctx.get('aiWorkbenchNetwork'),
-                    workspace: async (request) => {
-                        const services = ctx;
-                        const registry = services.get('workspaceRegistry');
-                        const sessions = services.get('sessions');
-                        return officialEmployeeWorkspace(request.sessionId, registry, sessions?.get(request.sessionId)?.header);
-                    }, native: () => resolveEmployeeNative(),
+                    workspace, native: () => resolveEmployeeNative(),
                 } } : {}), notice: createWorkspaceNoticeConsumer(ctx, agent), details, open, local });
     }, dshApproval(ctx), agent => agent.name[language], readImage, (sessionId, code, diagnostic) => {
         const events = sessionId ? ctx.get('agents')?.get(SessionId(sessionId))?.session.snapshotEvents() : undefined;
@@ -646,13 +734,31 @@ export function apply(ctx, live) {
                 step = null;
         }
         return managerForProfile().recordLoginFailure({ sessionId, code, diagnostic, context: { turn, step } });
-    }, modelDirectory);
+    }, modelDirectory, preflightDiagnostics);
     const ids = AGENTS.map(agent => agent.id);
-    const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: settingsNamespace, settingsPath: [] }));
+    const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: actualSettingsNamespace ?? settingsNamespace, settingsPath: [] }));
     const directory = ctx.llm.registerConfigurableProviders(entries());
     const registration = ctx.llm.registerAdapter(ids, adapter);
-    changed = () => { registration.replace(ids); void adapter.invalidateModelState().catch(() => { ctx.logger('remote-agent').warn('原会话清理结果未确认，已阻断继续发送；请联系管理员核对。'); }); };
+    installModelInputRetention(ctx, { isOurProvider: provider => ids.includes(provider), diagnosticForAttempt: position => preflightDiagnostics.forPreparation(position.sessionId, position), preflightDiagnostic: (provider, message) => diagnostic('preflight', provider, message), diagnostic: (provider, message) => diagnostic('input', provider, message) });
     const serviceValue = (name) => ctx.get(name);
+    const refreshDefault = () => {
+        const service = serviceValue('agentDefaultModel');
+        const selected = service?.currentSelection();
+        const agent = AGENTS.find(agent => agent.id === selected?.provider);
+        if (!defaults || !agent)
+            return;
+        // Read through the same trusted, fresh catalog. Failures are already recorded there.
+        void modelDirectory.read(agent).then(lease => lease.release(), () => { });
+    };
+    ctx.inject(['agentDefaultModel'], child => {
+        const service = child.get('agentDefaultModel');
+        const current = createModelDefaults(service, (provider, message) => diagnostic('default', provider, message), createDefaultSelectionWriter(service, () => serviceValue('configEditor')));
+        defaults = current;
+        refreshDefault();
+        child.effect(() => () => { current.dispose(); if (defaults === current)
+            defaults = undefined; });
+    });
+    changed = () => { registration.replace(ids); refreshDefault(); void adapter.invalidateModelState().catch(() => { ctx.logger('remote-agent').warn('原会话清理结果未确认，已阻断继续发送；请联系管理员核对。'); }); };
     let employeeConnect = serviceValue('aiWorkbenchConnect'), employeeNetwork = serviceValue('aiWorkbenchNetwork');
     ctx.on('internal/service', service => {
         if (service === 'aiWorkbenchConnect')

package/dist/model-catalog.d.ts

@@ -2,6 +2,7 @@ import { type LlmResolvedModelInfo } from '@deepseek-ai/dsh-llm';
 import type { ModelCatalogTarget } from '@ai-workbench/connect/api';
 import type { AgentDefinition } from './agents.ts';
 import { type ConnectApi, type ConnectTarget } from './provider.ts';
+export { runCatalog } from './catalog-ssh.ts';
 export interface HostModel {
     id: string;
     value: string;
@@ -28,15 +29,27 @@ export interface ModelDirectory {
     read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;
 }
 export type CatalogRunner = (target: ConnectTarget, command: string, signal: AbortSignal, maxBytes: number) => Promise<string>;
-export declare function parseHostCatalog(input: string, provider: string, username: string): HostModel[];
-/** Only the public L sshArgs function chooses SSH trust and transport arguments. */
-export declare const runCatalog: CatalogRunner;
-/** No cache: every query binds to L's current object, host-user and generation. */
+export interface CatalogIssue {
+    readonly modelName: string;
+    readonly reason: string;
+    readonly code: string;
+}
+export interface ParsedCatalog {
+    readonly models: readonly HostModel[];
+    readonly issues: readonly CatalogIssue[];
+}
+export declare function catalogDiagnostic(issues: readonly CatalogIssue[]): string | undefined;
+/** Defaults are provider declarations, never catalog order or display names. */
+export declare function declaredDefault(agent: AgentDefinition, models: readonly HostModel[]): HostModel | undefined;
+export declare function parseHostCatalog(input: string, provider: string, username: string): ParsedCatalog;
+/** Share only pending work; settled results are never cached. */
 export declare class ModelCatalog implements ModelDirectory {
     private get;
     private maxBytes;
     private run;
     private changed;
+    private diagnostic;
+    private loaded;
     private api?;
     private unsubscribe?;
     private signature?;
@@ -44,9 +57,15 @@ export declare class ModelCatalog implements ModelDirectory {
     private disposed;
     private initialized;
     private active;
-    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void);
+    private flights;
+    private serial;
+    private latest;
+    constructor(get: () => ConnectApi | undefined, maxBytes: () => number | undefined, run?: CatalogRunner, changed?: () => void, diagnostic?: (provider: 'claude' | 'codex', message: string | undefined) => void, loaded?: (agent: AgentDefinition, models: readonly HostModel[], assertCurrent: () => void) => void | Promise<void>);
     refresh(): void;
     private trusted;
+    private assertFlight;
+    private failure;
+    private start;
     read(agent: AgentDefinition, signal?: AbortSignal): Promise<CatalogLease>;
     dispose(): void;
 }