byterover-cli 3.10.0 → 3.10.2

package/dist/server/infra/process/task-router.d.ts

@@ -35,10 +35,20 @@ export type PreDispatchCheckResult = {
     eligible: true;
 };
 export type PreDispatchCheck = (task: TaskCreateRequest, projectPath?: string) => Promise<PreDispatchCheckResult>;
+/**
+ * Resolves whether the review log is disabled for the given project. Called once
+ * at task-create and the result is stamped onto TaskInfo + TaskExecute, so daemon
+ * (CurateLogHandler) and agent (curate backups, dream review entries) observe a
+ * single value across the daemon→agent process boundary. Errors → undefined →
+ * downstream treats as enabled (fail-open).
+ */
+export type IsReviewDisabledResolver = (projectPath: string) => Promise<boolean>;
 type TaskRouterOptions = {
     agentPool?: IAgentPool;
     /** Function to resolve agent clientId for a given project */
     getAgentForProject: (projectPath?: string) => string | undefined;
+    /** Resolves project's review-disabled flag at task-create. Optional; missing → undefined → enabled. */
+    isReviewDisabled?: IsReviewDisabledResolver;
     /** Lifecycle hooks for task events (e.g. CurateLogHandler). */
     lifecycleHooks?: ITaskLifecycleHook[];
     /**
@@ -63,6 +73,7 @@ export declare class TaskRouter {
      */
     private completedTasks;
     private readonly getAgentForProject;
+    private readonly isReviewDisabled;
     private readonly lifecycleHooks;
     private readonly preDispatchCheck;
     private readonly projectRegistry;
@@ -177,5 +188,23 @@ export declare class TaskRouter {
      * Each hook is called independently; errors are caught and logged.
      */
     private runCreateHooks;
+    /**
+     * Reads the project's reviewDisabled flag at task-create.
+     *
+     * Returns `undefined` only when no resolver is wired or no projectPath was
+     * resolved — those are legitimate "not configured" cases where downstream
+     * consumers fall back to their own resolution path.
+     *
+     * On resolver THROW, returns the explicit boolean `false` (review enabled =
+     * fail-open) so the daemon and the agent observe a single concrete value.
+     * Returning `undefined` here would re-introduce the exact divergence the
+     * snapshot is supposed to prevent: daemon stamps no field → CurateLogHandler
+     * uses `?? false` (enabled) while the agent process opens no ALS scope and
+     * may read `reviewDisabled: true` from `.brv/config.json` in the
+     * curate-tool fallback, producing pending review entries without backups
+     * (or vice versa). Aligns with the agent-side `isReviewDisabledForBrvDir`
+     * which also fails open.
+     */
+    private snapshotReviewDisabled;
 }
 export {};

package/dist/server/infra/process/task-router.js

@@ -54,6 +54,7 @@ export class TaskRouter {
      */
     completedTasks = new Map();
     getAgentForProject;
+    isReviewDisabled;
     lifecycleHooks;
     preDispatchCheck;
     projectRegistry;
@@ -66,6 +67,7 @@ export class TaskRouter {
         this.transport = options.transport;
         this.agentPool = options.agentPool;
         this.getAgentForProject = options.getAgentForProject;
+        this.isReviewDisabled = options.isReviewDisabled;
         this.lifecycleHooks = options.lifecycleHooks ?? [];
         this.preDispatchCheck = options.preDispatchCheck;
         this.projectRegistry = options.projectRegistry;
@@ -328,7 +330,18 @@ export class TaskRouter {
         this.transport.sendTo(clientId, TransportTaskEventNames.CREATED, createdPayload);
         // Broadcast to other clients in the project room (exclude creator to avoid duplicate)
         broadcastToProjectRoom(this.projectRegistry, this.projectRouter, projectPath, TransportTaskEventNames.CREATED, createdPayload, clientId);
-        // ── Await lifecycle hooks ─────────────────────────────────────────────────
+        // ── Snapshot reviewDisabled + await lifecycle hooks ───────────────────────
+        // Snapshot the project's review-disabled flag once at the task-create boundary.
+        // Placed after the synchronous tasks.set/task:created so callers that don't
+        // await the create handler still see the task in this.tasks immediately.
+        // The value is stamped onto TaskInfo (for CurateLogHandler) and TaskExecute
+        // (forwarded to the agent) so both sides observe a single consistent value
+        // even if the user toggles mid-task. Errors → undefined → fail-open enabled.
+        const reviewDisabled = await this.snapshotReviewDisabled(projectPath);
+        const taskAfterSnapshot = this.tasks.get(taskId);
+        if (taskAfterSnapshot && reviewDisabled !== undefined) {
+            this.tasks.set(taskId, { ...taskAfterSnapshot, reviewDisabled });
+        }
         const logId = await this.runCreateHooks(taskId);
         const task = this.tasks.get(taskId);
         if (task && logId) {
@@ -369,6 +382,7 @@ export class TaskRouter {
             ...(data.folderPath ? { folderPath: data.folderPath } : {}),
             ...(data.force === undefined ? {} : { force: data.force }),
             ...(projectPath ? { projectPath } : {}),
+            ...(reviewDisabled === undefined ? {} : { reviewDisabled }),
             taskId,
             type: data.type,
             ...(worktreeRoot ? { worktreeRoot } : {}),
@@ -683,4 +697,32 @@ export class TaskRouter {
         }));
         return logIds.find((id) => typeof id === 'string');
     }
+    /**
+     * Reads the project's reviewDisabled flag at task-create.
+     *
+     * Returns `undefined` only when no resolver is wired or no projectPath was
+     * resolved — those are legitimate "not configured" cases where downstream
+     * consumers fall back to their own resolution path.
+     *
+     * On resolver THROW, returns the explicit boolean `false` (review enabled =
+     * fail-open) so the daemon and the agent observe a single concrete value.
+     * Returning `undefined` here would re-introduce the exact divergence the
+     * snapshot is supposed to prevent: daemon stamps no field → CurateLogHandler
+     * uses `?? false` (enabled) while the agent process opens no ALS scope and
+     * may read `reviewDisabled: true` from `.brv/config.json` in the
+     * curate-tool fallback, producing pending review entries without backups
+     * (or vice versa). Aligns with the agent-side `isReviewDisabledForBrvDir`
+     * which also fails open.
+     */
+    async snapshotReviewDisabled(projectPath) {
+        if (!this.isReviewDisabled || !projectPath)
+            return undefined;
+        try {
+            return await this.isReviewDisabled(projectPath);
+        }
+        catch (error_) {
+            transportLog(`TaskRouter: isReviewDisabled resolver threw for ${projectPath} — defaulting to enabled: ${error_ instanceof Error ? error_.message : String(error_)}`);
+            return false;
+        }
+    }
 }

package/dist/server/infra/process/transport-handlers.d.ts

@@ -32,12 +32,14 @@ import type { ITaskLifecycleHook } from '../../core/interfaces/process/i-task-li
 import type { IProjectRegistry } from '../../core/interfaces/project/i-project-registry.js';
 import type { IProjectRouter } from '../../core/interfaces/routing/i-project-router.js';
 import type { ITransportServer } from '../../core/interfaces/transport/i-transport-server.js';
-import type { PreDispatchCheck } from './task-router.js';
-export type { PreDispatchCheck, PreDispatchCheckResult } from './task-router.js';
+import type { IsReviewDisabledResolver, PreDispatchCheck } from './task-router.js';
+export type { IsReviewDisabledResolver, PreDispatchCheck, PreDispatchCheckResult } from './task-router.js';
 export type { TaskInfo } from './types.js';
 type TransportHandlersOptions = {
     agentPool?: IAgentPool;
     clientManager?: IClientManager;
+    /** Resolves project's review-disabled flag at task-create. Snapshotted once into TaskInfo + TaskExecute. */
+    isReviewDisabled?: IsReviewDisabledResolver;
     /** Lifecycle hooks for task events (e.g. CurateLogHandler). */
     lifecycleHooks?: ITaskLifecycleHook[];
     /** Optional daemon-side gate run before dispatching a task to the agent pool. */

package/dist/server/infra/process/transport-handlers.js

@@ -41,6 +41,7 @@ export class TransportHandlers {
         this.taskRouter = new TaskRouter({
             agentPool: options.agentPool,
             getAgentForProject: (projectPath) => this.connectionCoordinator.getAgentForProject(projectPath),
+            isReviewDisabled: options.isReviewDisabled,
             lifecycleHooks: options.lifecycleHooks,
             preDispatchCheck: options.preDispatchCheck,
             projectRegistry: options.projectRegistry,

package/dist/server/infra/storage/file-provider-config-store.d.ts

@@ -27,13 +27,16 @@ export declare class FileProviderConfigStore implements IProviderConfigStore {
      */
     clearCache(): void;
     /**
-     * Marks a provider as connected.
+     * Marks a provider as connected. Defaults to also marking it as active —
+     * pass `setAsActive: false` to skip the activate step (used when the
+     * provider has no usable model yet).
      */
     connectProvider(providerId: string, options?: {
         activeModel?: string;
         authMethod?: 'api-key' | 'oauth';
         baseUrl?: string;
         oauthAccountId?: string;
+        setAsActive?: boolean;
     }): Promise<void>;
     /**
      * Removes a provider connection.

package/dist/server/infra/storage/file-provider-config-store.js

@@ -34,11 +34,14 @@ export class FileProviderConfigStore {
         this.cachedConfig = undefined;
     }
     /**
-     * Marks a provider as connected.
+     * Marks a provider as connected. Defaults to also marking it as active —
+     * pass `setAsActive: false` to skip the activate step (used when the
+     * provider has no usable model yet).
      */
     async connectProvider(providerId, options) {
         const config = await this.read();
-        const newConfig = config.withProviderConnected(providerId, options).withActiveProvider(providerId);
+        const connected = config.withProviderConnected(providerId, options);
+        const newConfig = options?.setAsActive === false ? connected : connected.withActiveProvider(providerId);
         await this.write(newConfig);
     }
     /**

package/dist/server/infra/transport/handlers/provider-handler.d.ts

@@ -22,6 +22,14 @@ export interface ProviderHandlerDeps {
     providerKeychainStore: IProviderKeychainStore;
     providerOAuthTokenStore: IProviderOAuthTokenStore;
     transport: ITransportServer;
+    /** Validator for openai-compatible base URL (injectable for testing) */
+    validateOpenAICompatibleEndpoint?: (params: {
+        apiKey: string;
+        baseUrl: string;
+    }) => Promise<{
+        error?: string;
+        isValid: boolean;
+    }>;
 }
 /**
  * Handles provider:* events.
@@ -38,6 +46,7 @@ export declare class ProviderHandler {
     private readonly providerKeychainStore;
     private readonly providerOAuthTokenStore;
     private readonly transport;
+    private readonly validateOpenAICompatibleEndpoint;
     constructor(deps: ProviderHandlerDeps);
     setup(): void;
     private cleanupFlowsForClient;

package/dist/server/infra/transport/handlers/provider-handler.js

@@ -4,7 +4,22 @@ import { TransportDaemonEventNames } from '../../../core/domain/transport/schema
 import { getErrorMessage } from '../../../utils/error-helpers.js';
 import { processLog } from '../../../utils/process-logger.js';
 import { validateApiKey as validateApiKeyViaFetcher } from '../../http/provider-model-fetcher-registry.js';
+import { OpenAICompatibleModelFetcher } from '../../http/provider-model-fetchers.js';
 import { computeExpiresAt, exchangeCodeForTokens as defaultExchangeCodeForTokens, generatePkce as defaultGeneratePkce, parseAccountIdFromIdToken, ProviderCallbackServer, ProviderCallbackTimeoutError, } from '../../provider-oauth/index.js';
+const BYTEROVER_AUTH_REQUIRED_MESSAGE = [
+    'ByteRover Provider requires a ByteRover account.',
+    '',
+    '  • Interactive shell: brv login',
+    '  • Headless / SSH / CI: create an account at https://app.byterover.dev,',
+    '    generate an API key at https://app.byterover.dev/settings/keys, then:',
+    '      brv login --api-key <key>',
+    '',
+    'Once signed in, retry: brv providers connect byterover',
+].join('\n');
+async function defaultValidateOpenAICompatibleEndpoint(params) {
+    const fetcher = new OpenAICompatibleModelFetcher(params.baseUrl, 'OpenAI Compatible');
+    return fetcher.validateApiKey(params.apiKey);
+}
 /**
  * Handles provider:* events.
  * Business logic for provider management — no terminal/UI calls.
@@ -20,6 +35,7 @@ export class ProviderHandler {
     providerKeychainStore;
     providerOAuthTokenStore;
     transport;
+    validateOpenAICompatibleEndpoint;
     constructor(deps) {
         this.authStateStore = deps.authStateStore;
         this.browserLauncher = deps.browserLauncher;
@@ -30,6 +46,8 @@ export class ProviderHandler {
         this.providerKeychainStore = deps.providerKeychainStore;
         this.providerOAuthTokenStore = deps.providerOAuthTokenStore;
         this.transport = deps.transport;
+        this.validateOpenAICompatibleEndpoint =
+            deps.validateOpenAICompatibleEndpoint ?? defaultValidateOpenAICompatibleEndpoint;
     }
     setup() {
         this.setupConnect();
@@ -140,17 +158,59 @@ export class ProviderHandler {
         this.transport.onRequest(ProviderEvents.CONNECT, async (data) => {
             const { apiKey, baseUrl, providerId } = data;
             if (providerId === 'byterover' && !this.isByteRoverAuthSatisfied()) {
-                return { error: 'ByteRover Provider requires authentication. Run /login or brv login to sign in', success: false };
+                return { error: BYTEROVER_AUTH_REQUIRED_MESSAGE, success: false };
+            }
+            // Verify openai-compatible endpoint is reachable before persisting anything —
+            // a failed setup must not leave a placeholder config that masquerades as
+            // connected. Falls back to existing baseUrl/keychain key on reconfigure
+            // when the request omits them, so a partial reconfigure (e.g. only changing
+            // the URL) still validates with the user's stored credentials.
+            if (providerId === 'openai-compatible') {
+                const existingBaseUrl = await this.providerConfigStore.read().then((c) => c.getBaseUrl(providerId));
+                const effectiveBaseUrl = baseUrl ?? existingBaseUrl;
+                if (!effectiveBaseUrl) {
+                    return {
+                        error: 'A base URL is required for OpenAI-compatible providers (e.g. http://localhost:11434/v1)',
+                        success: false,
+                    };
+                }
+                const effectiveApiKey = apiKey ?? (await this.providerKeychainStore.getApiKey(providerId)) ?? '';
+                const validation = await this.validateOpenAICompatibleEndpoint({
+                    apiKey: effectiveApiKey,
+                    baseUrl: effectiveBaseUrl,
+                });
+                if (!validation.isValid) {
+                    const detail = validation.error ? `: ${validation.error}` : '';
+                    return {
+                        error: `Could not reach OpenAI-compatible endpoint at ${effectiveBaseUrl}${detail}`,
+                        success: false,
+                    };
+                }
             }
             // Store API key if provided (supports optional keys for openai-compatible)
             if (apiKey) {
                 await this.providerKeychainStore.setApiKey(providerId, apiKey);
             }
             const provider = getProviderById(providerId);
+            // Skip activating the provider when it ends up with no active model —
+            // the welcome view treats `activeProvider w/o activeModel` as
+            // "needs setup" and unmounts any in-flight setup flow on the home
+            // page. The model:setActive handler activates the provider when the
+            // user picks a model, which is the right moment.
+            //
+            // byterover bypasses this gate: it has no model fetcher and no
+            // `brv model switch` recovery path, so deferring would strand it as
+            // connected-but-never-active. Its model is resolved at runtime via
+            // DEFAULT_LLM_MODEL in agent-process.ts rather than persisted here,
+            // so future default changes roll out without a per-user migration.
+            const willHaveActiveModel = providerId === 'byterover'
+                || Boolean(provider?.defaultModel)
+                || Boolean(await this.providerConfigStore.getActiveModel(providerId));
             await this.providerConfigStore.connectProvider(providerId, {
                 activeModel: provider?.defaultModel,
                 authMethod: apiKey ? 'api-key' : undefined,
                 baseUrl,
+                setAsActive: willHaveActiveModel,
             });
             this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});
             return { success: true };
@@ -186,6 +246,7 @@ export class ProviderHandler {
                 const providerConfig = config?.providers[def.id];
                 const authMethod = providerConfig?.authMethod;
                 return {
+                    activeModel: providerConfig?.activeModel,
                     apiKeyUrl: def.apiKeyUrl,
                     authMethod,
                     category: def.category,
@@ -209,7 +270,7 @@ export class ProviderHandler {
     setupSetActive() {
         this.transport.onRequest(ProviderEvents.SET_ACTIVE, async (data) => {
             if (data.providerId === 'byterover' && !this.isByteRoverAuthSatisfied()) {
-                return { error: 'ByteRover Provider requires authentication. Run /login or brv login to sign in', success: false };
+                return { error: BYTEROVER_AUTH_REQUIRED_MESSAGE, success: false };
             }
             await this.providerConfigStore.setActiveProvider(data.providerId);
             this.transport.broadcast(TransportDaemonEventNames.PROVIDER_UPDATED, {});

package/dist/server/infra/transport/handlers/review-handler.d.ts

@@ -1,4 +1,5 @@
 import type { ICurateLogStore } from '../../../core/interfaces/storage/i-curate-log-store.js';
+import type { IProjectConfigStore } from '../../../core/interfaces/storage/i-project-config-store.js';
 import type { IReviewBackupStore } from '../../../core/interfaces/storage/i-review-backup-store.js';
 import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
 import { type ProjectPathResolver } from './handler-types.js';
@@ -11,6 +12,7 @@ export interface ReviewHandlerDeps {
         projectPath: string;
         taskId: string;
     }) => void;
+    projectConfigStore: IProjectConfigStore;
     resolveProjectPath: ProjectPathResolver;
     reviewBackupStoreFactory: ReviewBackupStoreFactory;
     transport: ITransportServer;
@@ -24,12 +26,15 @@ export interface ReviewHandlerDeps {
 export declare class ReviewHandler {
     private readonly curateLogStoreFactory;
     private readonly onResolved;
+    private readonly projectConfigStore;
     private readonly resolveProjectPath;
     private readonly reviewBackupStoreFactory;
     private readonly transport;
     constructor(deps: ReviewHandlerDeps);
     setup(): void;
     private handleDecideTask;
+    private handleGetDisabled;
     private handlePending;
+    private handleSetDisabled;
 }
 export {};

package/dist/server/infra/transport/handlers/review-handler.js

@@ -18,19 +18,23 @@ async function writeFileWithDirs(absolutePath, content) {
 export class ReviewHandler {
     curateLogStoreFactory;
     onResolved;
+    projectConfigStore;
     resolveProjectPath;
     reviewBackupStoreFactory;
     transport;
     constructor(deps) {
         this.curateLogStoreFactory = deps.curateLogStoreFactory;
         this.onResolved = deps.onResolved;
+        this.projectConfigStore = deps.projectConfigStore;
         this.resolveProjectPath = deps.resolveProjectPath;
         this.reviewBackupStoreFactory = deps.reviewBackupStoreFactory;
         this.transport = deps.transport;
     }
     setup() {
         this.transport.onRequest(ReviewEvents.DECIDE_TASK, (data, clientId) => this.handleDecideTask(data, clientId));
+        this.transport.onRequest(ReviewEvents.GET_DISABLED, (_data, clientId) => this.handleGetDisabled(clientId));
         this.transport.onRequest(ReviewEvents.PENDING, (_data, clientId) => this.handlePending(clientId));
+        this.transport.onRequest(ReviewEvents.SET_DISABLED, (data, clientId) => this.handleSetDisabled(data, clientId));
     }
     async handleDecideTask({ decision, filePaths: filterPaths, taskId }, clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
@@ -119,6 +123,14 @@ export class ReviewHandler {
         const totalCount = fileResults.reduce((sum, { ops }) => sum + ops.length, 0);
         return { files: fileResults.map(({ path, reverted }) => ({ path, reverted })), totalCount };
     }
+    async handleGetDisabled(clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const config = await this.projectConfigStore.read(projectPath);
+        if (!config) {
+            throw new Error(`Project not initialized: ${projectPath}. Run \`brv init\` first.`);
+        }
+        return { reviewDisabled: config.reviewDisabled === true };
+    }
     async handlePending(clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
         const contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
@@ -159,4 +171,14 @@ export class ReviewHandler {
         const pendingCount = tasks.reduce((sum, t) => sum + t.operations.length, 0);
         return { pendingCount, tasks };
     }
+    async handleSetDisabled({ reviewDisabled }, clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const config = await this.projectConfigStore.read(projectPath);
+        if (!config) {
+            throw new Error(`Project not initialized: ${projectPath}. Run \`brv init\` first.`);
+        }
+        const updated = config.withReviewDisabled(reviewDisabled);
+        await this.projectConfigStore.write(updated, projectPath);
+        return { reviewDisabled };
+    }
 }

package/dist/shared/transport/events/index.d.ts

@@ -124,8 +124,10 @@ export declare const AllEventGroups: readonly [{
     readonly EXECUTE: "reset:execute";
 }, {
     readonly DECIDE_TASK: "review:decideTask";
+    readonly GET_DISABLED: "review:getDisabled";
     readonly NOTIFY: "review:notify";
     readonly PENDING: "review:pending";
+    readonly SET_DISABLED: "review:setDisabled";
 }, {
     readonly SWITCHED: "session:switched";
 }, {

package/dist/shared/transport/events/review-events.d.ts

@@ -1,8 +1,19 @@
 export declare const ReviewEvents: {
     readonly DECIDE_TASK: "review:decideTask";
+    readonly GET_DISABLED: "review:getDisabled";
     readonly NOTIFY: "review:notify";
     readonly PENDING: "review:pending";
+    readonly SET_DISABLED: "review:setDisabled";
 };
+export interface ReviewGetDisabledResponse {
+    reviewDisabled: boolean;
+}
+export interface ReviewSetDisabledRequest {
+    reviewDisabled: boolean;
+}
+export interface ReviewSetDisabledResponse {
+    reviewDisabled: boolean;
+}
 export interface ReviewNotifyEvent {
     pendingCount: number;
     reviewUrl: string;

package/dist/shared/transport/events/review-events.js

@@ -1,5 +1,7 @@
 export const ReviewEvents = {
     DECIDE_TASK: 'review:decideTask',
+    GET_DISABLED: 'review:getDisabled',
     NOTIFY: 'review:notify',
     PENDING: 'review:pending',
+    SET_DISABLED: 'review:setDisabled',
 };

package/dist/shared/transport/types/dto.d.ts

@@ -50,6 +50,8 @@ export interface ConnectorDTO {
     supportedTypes: ConnectorType[];
 }
 export interface ProviderDTO {
+    /** Currently selected model for this provider, if any. Absent means connected but model not yet picked. */
+    activeModel?: string;
     apiKeyUrl?: string;
     authMethod?: 'api-key' | 'oauth';
     category: 'other' | 'popular';

package/dist/tui/features/auth/api/get-auth-state.js

@@ -5,9 +5,12 @@ export const getAuthState = () => {
     const { apiClient } = useTransportStore.getState();
     if (!apiClient)
         return Promise.reject(new Error('Not connected'));
-    // Use 500ms timeout to fail fast if handler not ready yet
-    // React Query will retry automatically with exponential backoff
-    return apiClient.request(AuthEvents.GET_STATE, undefined, { timeout: 500 });
+    // The daemon-side handler does a network round-trip to /user/me. Measured
+    // p99 across multiple networks ranges 1.2-3.1s with occasional outliers,
+    // so 4000ms gives ~1.3x headroom over the worst observed sample with
+    // margin left for slower connections (mobile, international, VPN).
+    // React Query retries once on failure for transient blips.
+    return apiClient.request(AuthEvents.GET_STATE, undefined, { timeout: 4000 });
 };
 export const getAuthStateQueryOptions = () => queryOptions({
     gcTime: 5 * 60 * 1000,

package/dist/tui/features/auth/components/auth-initializer.js

@@ -23,8 +23,10 @@ export function AuthInitializer({ children }) {
     const { data: authState, isFetched, isLoading, } = useGetAuthState({
         queryConfig: {
             enabled: apiClient !== null,
-            retry: 5,
-            retryDelay: (attemptIndex) => Math.min(500 * 2 ** attemptIndex, 2000),
+            // One retry covers transient blips; the per-attempt timeout is now generous
+            // (3s) so we don't need 5+ retries that would block startup for ~17s when offline.
+            retry: 1,
+            retryDelay: 500,
             staleTime: 2 * 60 * 1000,
         },
     });

package/dist/tui/features/provider/components/provider-flow.js

@@ -29,6 +29,16 @@ import { BaseUrlDialog } from './base-url-dialog.js';
 import { ModelSelectStep } from './model-select-step.js';
 import { OAuthDialog } from './oauth-dialog.js';
 import { ProviderDialog } from './provider-dialog.js';
+/**
+ * Throws on transport responses that ack with `success: false` so the
+ * existing try/catch surfaces server-side errors instead of silently
+ * marching forward into the next step.
+ */
+function ensureSuccess(response) {
+    if (!response.success) {
+        throw new Error(response.error ?? 'Operation failed');
+    }
+}
 export const ProviderFlow = ({ hideCancelButton = false, isActive = true, onCancel, onComplete, providerDialogTitle, }) => {
     const { theme: { colors } } = useTheme();
     const [step, setStep] = useState('select');
@@ -113,9 +123,17 @@ export const ProviderFlow = ({ hideCancelButton = false, isActive = true, onCanc
             onComplete(`Connected to ${provider.name}`);
             return;
         }
-        // Already connected → show actions menu
+        // Already connected → show actions menu. Exception: openai-compatible
+        // is the only provider that can land in a connected-but-no-active-model
+        // state (no canonical defaultModel exists for arbitrary endpoints), so
+        // when it's the current provider we jump straight to the model picker
+        // so the welcome view's user can finish setup. For non-current
+        // half-configured providers we still show the actions menu so
+        // Disconnect / Set as active stay reachable (the picker would otherwise
+        // be a dead-end if the endpoint is down).
         if (provider.isConnected) {
-            setStep('provider_actions');
+            const needsModelPick = provider.id === 'openai-compatible' && !provider.activeModel && provider.isCurrent;
+            setStep(needsModelPick ? 'model_select' : 'provider_actions');
             return;
         }
         // ByteRover + not connected → connect + activate directly, no model select
@@ -249,16 +267,23 @@ export const ProviderFlow = ({ hideCancelButton = false, isActive = true, onCanc
             return;
         setStep('connecting');
         try {
-            await connectMutation.mutateAsync({
+            ensureSuccess(await connectMutation.mutateAsync({
                 apiKey: apiKey || undefined,
                 baseUrl: baseUrl || undefined,
                 providerId: selectedProvider.id,
-            });
+            }));
             setStep('model_select');
         }
         catch (error_) {
             setError(formatTransportError(error_));
-            setStep('api_key');
+            // Server rejection (e.g. unreachable openai-compatible URL) — return to
+            // the provider list where the error is rendered. The user can re-enter
+            // the flow with a corrected URL or API key. Mirror the other failure
+            // paths (e.g. handleSelect at the byterover branch) by clearing the
+            // selected provider too.
+            setStep('select');
+            setSelectedProvider(null);
+            setBaseUrl(null);
         }
     }, [baseUrl, connectMutation, selectedProvider]);
     const handleApiKeyCancel = useCallback(() => {

package/node_modules/@tanstack/query-core/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Tanner Linsley
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@tanstack/query-core/build/legacy/chunk-PXG64RU4.js

@@ -0,0 +1,25 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
+export {
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  __privateWrapper
+};
+//# sourceMappingURL=chunk-PXG64RU4.js.map

package/node_modules/@tanstack/query-core/build/legacy/chunk-PXG64RU4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}