byterover-cli 3.9.0 → 3.10.1

package/dist/server/infra/http/callback-server.js

@@ -1,5 +1,161 @@
 import express from 'express';
 import { AuthenticationError } from '../../core/domain/errors/auth-error.js';
+const PAGE_STYLE = `
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+  html, body { height: 100%; }
+  body {
+    font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: #000;
+    color: #e5e5e5;
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 64px 24px 24px;
+    position: relative;
+    overflow: hidden;
+    -webkit-font-smoothing: antialiased;
+  }
+  body::before {
+    content: "";
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+    background:
+      radial-gradient(900px 500px at 50% -10%, rgba(23, 178, 106, 0.35), transparent 60%),
+      radial-gradient(700px 400px at 95% 10%, rgba(220, 130, 50, 0.18), transparent 60%);
+  }
+  body::after {
+    content: "";
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+    background-image:
+      linear-gradient(to right, rgba(255,255,255,0.04) 1px, transparent 1px),
+      linear-gradient(to bottom, rgba(255,255,255,0.04) 1px, transparent 1px);
+    background-size: 56px 56px;
+    -webkit-mask-image: radial-gradient(ellipse 80% 60% at 50% 30%, #000 55%, transparent 100%);
+    mask-image: radial-gradient(ellipse 80% 60% at 50% 30%, #000 55%, transparent 100%);
+  }
+  .brand { position: relative; z-index: 1; display: flex; align-items: center; gap: 10px; margin-bottom: 96px; }
+  .brand svg { width: 28px; height: 28px; }
+  .brand span { font-weight: 700; letter-spacing: 0.08em; font-size: 18px; color: #fff; }
+  .card {
+    position: relative;
+    z-index: 1;
+    width: 100%;
+    max-width: 560px;
+    background: rgba(20, 22, 26, 0.85);
+    border: 1px solid rgba(255, 255, 255, 0.06);
+    border-radius: 16px;
+    padding: 40px 32px;
+    text-align: center;
+    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.05);
+    backdrop-filter: blur(8px);
+    -webkit-backdrop-filter: blur(8px);
+  }
+  .icon-circle {
+    width: 56px; height: 56px; border-radius: 50%;
+    background: rgba(255, 255, 255, 0.05);
+    border: 1px solid rgba(255, 255, 255, 0.06);
+    margin: 0 auto 20px;
+    display: flex; align-items: center; justify-content: center;
+  }
+  .icon-circle svg { width: 28px; height: 28px; }
+  h1 { font-size: 22px; font-weight: 600; color: #fff; margin-bottom: 10px; letter-spacing: -0.01em; }
+  p { font-size: 14px; color: #a3a3a3; line-height: 1.5; max-width: 340px; margin: 0 auto; }
+  .error-detail {
+    margin-top: 20px;
+    padding: 12px 14px;
+    background: rgba(248, 113, 113, 0.08);
+    border: 1px solid rgba(248, 113, 113, 0.18);
+    border-radius: 8px;
+    color: #fca5a5;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+    font-size: 12px;
+    text-align: left;
+    word-break: break-word;
+  }
+`;
+const BRAND_LOGO_SVG = `<svg viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><rect width="32" height="32" rx="16" fill="black"/><path d="M16.01 1.88257C7.97727 1.88257 1.4502 8.42761 1.4502 16.4814C1.4502 24.5352 7.97727 31.0803 16.01 31.0803C24.0427 31.0803 30.5698 24.5352 30.5698 16.4814C30.5698 8.42761 24.0427 1.88257 16.01 1.88257ZM16.01 2.51825C23.7077 2.51825 29.9365 8.76029 29.9365 16.4814C29.9365 24.1994 23.7077 30.4446 16.01 30.4446C8.30917 30.4446 2.08354 24.1994 2.08354 16.4814C2.08354 8.7595 8.30839 2.51825 16.01 2.51825Z" fill="white"/><path d="M29.2815 12.0991L29.1269 11.6188C28.9465 11.1643 28.7091 10.5575 28.5076 10.1132C25.829 5.39161 14.5601 3.45957 9.52303 3.78834C16.6663 3.90392 27.6361 7.1206 29.2815 12.0983M29.1699 20.8487C29.3393 20.2638 29.5439 19.4766 29.6736 18.8846L29.7423 18.477C30.1812 12.3435 15.3879 8.24593 5.58008 8.58564C18.268 9.40875 31.0488 14.8277 29.1699 20.8487Z" fill="white"/><path d="M23.6739 28.1234C24.1828 27.748 24.6799 27.3568 25.1647 26.9505C25.4349 26.6904 25.798 26.3476 26.0542 26.0735C30.9545 20.3008 15.6279 15.4886 3.76074 15.644C21.5575 17.2864 29.4309 23.651 24.0807 27.8274C23.9581 27.9212 23.7965 28.0328 23.6739 28.1234Z" fill="white"/><path d="M15.606 30.0481C17.6653 31.0766 21.4888 30.0192 21.6942 27.9794C21.9823 25.1891 13.3123 22.4269 5.12891 22.7049C16.6969 23.5421 22.144 27.3007 19.5731 29.3077" fill="white"/></svg>`;
+const USER_ICON_SVG = `<svg viewBox="0 0 24 24" fill="#17b26a" aria-hidden="true"><path d="M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z"/></svg>`;
+const ALERT_ICON_SVG = `<svg viewBox="0 0 24 24" fill="#f87171" aria-hidden="true"><path d="M12 2 1 21h22L12 2zm0 5.5L19.5 19h-15L12 7.5zM11 11v4h2v-4h-2zm0 5v2h2v-2h-2z"/></svg>`;
+/**
+ * Escape characters that have meaning in HTML so user-controlled error
+ * messages cannot break out of attribute or text contexts.
+ */
+export function escapeHtml(text) {
+    return text
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+/**
+ * Express parses repeated query keys (e.g. `?error=foo&error=bar`) into
+ * arrays, and nested syntax (`?error[code]=x`) into objects. Authoritative
+ * OAuth providers always send a single string per key, but the wire is
+ * untrusted — coerce any non-string shape to undefined and pick the first
+ * string when given an array, so we never feed `[object Object]` or a
+ * comma-joined value into a user-facing message.
+ */
+export function firstQueryParam(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value)) {
+        const first = value[0];
+        if (typeof first === 'string')
+            return first;
+    }
+    return undefined;
+}
+const SUCCESS_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>ByteRover - Authentication Successful</title>
+<style>${PAGE_STYLE}</style>
+</head>
+<body>
+<div class="brand">${BRAND_LOGO_SVG}<span>BYTEROVER</span></div>
+<div class="card">
+  <div class="icon-circle">${USER_ICON_SVG}</div>
+  <h1>Authentication Successful</h1>
+  <p>You can now safely close this tab and return to where you left off.</p>
+</div>
+</body>
+</html>`;
+/**
+ * Render the failure card. `details` is rendered in a monospace red-tint block
+ * underneath the body copy when present and non-empty; omit it for blank or
+ * undefined input so we don't show an empty `.error-detail` box.
+ */
+function errorHtml(details) {
+    const trimmed = details?.trim() ?? '';
+    const detailBlock = trimmed.length > 0
+        ? `<div class="error-detail">${escapeHtml(trimmed)}</div>`
+        : '';
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>ByteRover - Authentication Failed</title>
+<style>${PAGE_STYLE}</style>
+</head>
+<body>
+<div class="brand">${BRAND_LOGO_SVG}<span>BYTEROVER</span></div>
+<div class="card">
+  <div class="icon-circle">${ALERT_ICON_SVG}</div>
+  <h1>Authentication Failed</h1>
+  <p>Something went wrong while signing you in. Return to the CLI and try again.</p>
+  ${detailBlock}
+</div>
+</body>
+</html>`;
+}
 export class CallbackServer {
     app = express();
     connections = new Set();
@@ -74,20 +230,28 @@ export class CallbackServer {
     }
     setupRoutes() {
         this.app.get('/callback', (req, res) => {
-            const { code, error, error_description, state } = req.query;
+            const error = firstQueryParam(req.query.error);
+            const errorDescription = firstQueryParam(req.query.error_description);
+            const code = firstQueryParam(req.query.code);
+            const state = firstQueryParam(req.query.state);
             if (error !== undefined) {
-                const errorMessage = error_description ?? error;
-                this.app.locals.onError?.(String(errorMessage));
-                res.status(400).send(`Authentication failed: ${String(errorMessage)}`);
+                // `??` would let `?error_description=` (empty string) through and render
+                // an empty red detail box; `||` falls back to the error code instead.
+                const detail = (errorDescription && errorDescription.length > 0) ? errorDescription : error;
+                this.app.locals.onError?.(detail);
+                res.status(400).type('html').send(errorHtml(detail));
                 return;
             }
             if (code === undefined || state === undefined) {
+                // Keep the OAuth-jargon string for the CLI-facing onError callback (it
+                // surfaces in `brv login` stderr / logs where it's actionable), but
+                // render the user-facing card with the friendlier copy + no detail box.
                 this.app.locals.onError?.('Missing code or state parameter');
-                res.status(400).send('Authentication failed: Missing required parameters');
+                res.status(400).type('html').send(errorHtml());
                 return;
             }
-            this.app.locals.onCallback?.(String(code), String(state));
-            res.status(200).send('Authentication successful. You can close this window.');
+            this.app.locals.onCallback?.(code, state);
+            res.status(200).type('html').send(SUCCESS_HTML);
         });
     }
 }

package/dist/server/infra/process/curate-log-handler.d.ts

@@ -31,6 +31,9 @@ export declare class CurateLogHandler implements ITaskLifecycleHook {
     /**
      * @param createStore - Optional factory for testing. Default: FileCurateLogStore.
      * @param onPendingReviews - Optional callback fired when curate completes with pending review ops.
+     *
+     * Whether reviews are disabled is read directly from `task.reviewDisabled` (snapshotted by
+     * the daemon at task-create time). Undefined means review enabled (fail-open).
      */
     constructor(createStore?: ((projectPath: string) => ICurateLogStore) | undefined, onPendingReviews?: ((info: PendingReviewsInfo) => void) | undefined);
     cleanup(taskId: string): void;

package/dist/server/infra/process/curate-log-handler.js

@@ -53,6 +53,9 @@ export class CurateLogHandler {
     /**
      * @param createStore - Optional factory for testing. Default: FileCurateLogStore.
      * @param onPendingReviews - Optional callback fired when curate completes with pending review ops.
+     *
+     * Whether reviews are disabled is read directly from `task.reviewDisabled` (snapshotted by
+     * the daemon at task-create time). Undefined means review enabled (fail-open).
      */
     constructor(createStore, onPendingReviews) {
         this.createStore = createStore;
@@ -155,7 +158,8 @@ export class CurateLogHandler {
         // Caching `entry` here lets onTaskCompleted/onTaskError rebuild the final entry
         // without a getById round-trip — so completion is never lost even if this initial
         // save fails.
-        this.tasks.set(task.taskId, { entry, operations: [], projectPath: task.projectPath });
+        const reviewDisabled = task.reviewDisabled ?? false;
+        this.tasks.set(task.taskId, { entry, operations: [], projectPath: task.projectPath, reviewDisabled });
         this.activeTaskCount.set(task.projectPath, (this.activeTaskCount.get(task.projectPath) ?? 0) + 1);
         // Fire-and-forget: logId is already known, save is best-effort.
         // Callers receive logId immediately without waiting for disk I/O.
@@ -187,7 +191,7 @@ export class CurateLogHandler {
             return;
         const ops = extractCurateOperations(payload);
         for (const op of ops) {
-            if (op.needsReview && op.status === 'success') {
+            if (op.needsReview && op.status === 'success' && !state.reviewDisabled) {
                 op.reviewStatus = 'pending';
             }
             // Deduplicate by filePath: keep only the latest operation per file.

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

@@ -167,6 +167,7 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
         onResolved({ projectPath, taskId }) {
             broadcastToProject(projectPath, ReviewEvents.NOTIFY, { pendingCount: 0, reviewUrl: '', taskId });
         },
+        projectConfigStore,
         resolveProjectPath,
         reviewBackupStoreFactory: (projectPath) => new FileReviewBackupStore(join(projectPath, BRV_DIR)),
         transport,

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,12 @@ 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';
+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 +25,7 @@ export class ProviderHandler {
     providerKeychainStore;
     providerOAuthTokenStore;
     transport;
+    validateOpenAICompatibleEndpoint;
     constructor(deps) {
         this.authStateStore = deps.authStateStore;
         this.browserLauncher = deps.browserLauncher;
@@ -30,6 +36,8 @@ export class ProviderHandler {
         this.providerKeychainStore = deps.providerKeychainStore;
         this.providerOAuthTokenStore = deps.providerOAuthTokenStore;
         this.transport = deps.transport;
+        this.validateOpenAICompatibleEndpoint =
+            deps.validateOpenAICompatibleEndpoint ?? defaultValidateOpenAICompatibleEndpoint;
     }
     setup() {
         this.setupConnect();
@@ -142,15 +150,50 @@ export class ProviderHandler {
             if (providerId === 'byterover' && !this.isByteRoverAuthSatisfied()) {
                 return { error: 'ByteRover Provider requires authentication. Run /login or brv login to sign in', 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.
+            const willHaveActiveModel = 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 +229,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,

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/server/infra/transport/socket-io-transport-server.js

@@ -81,14 +81,9 @@ export class SocketIOTransportServer {
         this.disconnectionHandlers.push(handler);
     }
     onRequest(event, handler) {
-        const { io } = this;
-        if (!io) {
-            throw new TransportServerNotStartedError('onRequest');
-        }
-        // Store handler wrapped to accept unknown types (avoids type assertion)
+        // Pre-start registration is supported: start()'s connection handler iterates this.requestHandlers.
         const wrappedHandler = (data, clientId) => handler(data, clientId);
         this.requestHandlers.set(event, wrappedHandler);
-        // Apply handler to all existing sockets
         for (const socket of this.sockets.values()) {
             this.registerEventHandler(socket, event, wrappedHandler);
         }