byterover-cli 3.10.1 → 3.10.2

package/dist/server/infra/executor/dream-executor.d.ts

@@ -48,6 +48,8 @@ export type DreamExecutorDeps = {
         save(entry: DreamLogEntry): Promise<void>;
     };
     dreamStateService: {
+        drainStaleSummaryPaths(): Promise<string[]>;
+        enqueueStaleSummaryPaths(paths: string[]): Promise<void>;
         read(): Promise<import('../dream/dream-state-schema.js').DreamState>;
         update(updater: (state: import('../dream/dream-state-schema.js').DreamState) => import('../dream/dream-state-schema.js').DreamState): Promise<import('../dream/dream-state-schema.js').DreamState>;
         write(state: import('../dream/dream-state-schema.js').DreamState): Promise<void>;
@@ -106,6 +108,20 @@ export declare class DreamExecutor {
         signal: AbortSignal;
         taskId: string;
     }): Promise<void>;
+    /**
+     * Regenerate parent `_index.md` files for the given paths and rebuild the
+     * manifest. Extracted as a seam so tests can override and assert which
+     * paths were passed (the A ∪ B merge in step 5 is the central correctness
+     * invariant of the deferral). Production constructs the services here so
+     * the dependency surface of {@link DreamExecutorDeps} stays narrow.
+     */
+    protected runStaleSummaryPropagation(args: {
+        agent: ICipherAgent;
+        parentTaskId?: string;
+        paths: string[];
+        projectRoot: string;
+    }): Promise<void>;
+    /** Errors are tracked at the log level (status='error'), not per-operation — always 0 here. */
     private computeSummary;
     /**
      * Dual-write: create curate log entries for dream operations that need human review.

package/dist/server/infra/executor/dream-executor.js

@@ -74,7 +74,12 @@ export class DreamExecutor {
                 preState = await snapshotService.getCurrentState(projectRoot);
             }
             catch {
-                // Fail-open: if snapshot fails, skip propagation
+                // Fail-open: leaving preState undefined skips the entire step 5 block
+                // (queue drain + propagation), so the stale-summary queue is left
+                // intact for the next successful dream cycle. Skipping drain here is
+                // safer than drain-then-fail: the atomic-drain design clears entries
+                // synchronously inside the RMW, so if we drained and then threw
+                // before reaching the catch's re-enqueue, the snapshot would be lost.
             }
             // Step 2: Load dream state
             const dreamState = await this.deps.dreamStateService.read();
@@ -94,19 +99,37 @@ export class DreamExecutor {
                 taskId: options.taskId,
             });
             // Step 5: Post-dream propagation (fail-open)
+            // Two sources of stale summary paths:
+            //   A. The stale-summary queue, drained from dream state — paths from
+            //      curate operations that ran since the last dream cycle (the LLM
+            //      cascade work was deferred from curate's hot path to here).
+            //   B. Dream's own snapshot diff — paths changed by this dream's
+            //      consolidate/synthesize/prune operations.
+            // Merging A ∪ B before calling propagateStaleness lets a path touched
+            // by both sources regenerate exactly once. The queue is drained
+            // atomically (cleared in the same RMW that captures the snapshot) so
+            // any concurrent curate enqueueing during propagation appends a fresh
+            // entry to the now-empty queue and the next dream picks it up.
             if (preState) {
+                let drainedSnapshot = [];
                 try {
+                    drainedSnapshot = await this.deps.dreamStateService.drainStaleSummaryPaths();
                     const postState = await snapshotService.getCurrentState(projectRoot);
                     const changedPaths = diffStates(preState, postState);
-                    if (changedPaths.length > 0) {
-                        const summaryService = new FileContextTreeSummaryService();
-                        await summaryService.propagateStaleness(changedPaths, agent, projectRoot, options.taskId);
-                        const manifestService = new FileContextTreeManifestService({ baseDirectory: projectRoot });
-                        await manifestService.buildManifest(projectRoot);
+                    const merged = [...new Set([...changedPaths, ...drainedSnapshot])];
+                    if (merged.length > 0) {
+                        await this.runStaleSummaryPropagation({ agent, parentTaskId: options.taskId, paths: merged, projectRoot });
                     }
                 }
                 catch {
-                    // Fail-open: propagation errors never block dream
+                    // Fail-open: propagation errors never block dream. Re-enqueue the
+                    // drained snapshot so the next dream cycle retries — atomic drain
+                    // already removed them, so without this they would be lost.
+                    if (drainedSnapshot.length > 0) {
+                        await this.deps.dreamStateService.enqueueStaleSummaryPaths(drainedSnapshot).catch(() => {
+                            // If the re-enqueue itself fails, there is nothing more to do here.
+                        });
+                    }
                 }
             }
             // Step 6: Write dream log
@@ -237,6 +260,20 @@ export class DreamExecutor {
             taskId,
         })));
     }
+    /**
+     * Regenerate parent `_index.md` files for the given paths and rebuild the
+     * manifest. Extracted as a seam so tests can override and assert which
+     * paths were passed (the A ∪ B merge in step 5 is the central correctness
+     * invariant of the deferral). Production constructs the services here so
+     * the dependency surface of {@link DreamExecutorDeps} stays narrow.
+     */
+    async runStaleSummaryPropagation(args) {
+        const summaryService = new FileContextTreeSummaryService();
+        await summaryService.propagateStaleness(args.paths, args.agent, args.projectRoot, args.parentTaskId);
+        const manifestService = new FileContextTreeManifestService({ baseDirectory: args.projectRoot });
+        await manifestService.buildManifest(args.projectRoot);
+    }
+    /** Errors are tracked at the log level (status='error'), not per-operation — always 0 here. */
     computeSummary(operations) {
         const summary = { consolidated: 0, errors: 0, flaggedForReview: 0, pruned: 0, synthesized: 0 };
         for (const op of operations) {

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

@@ -6,6 +6,16 @@ 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);
@@ -148,7 +158,7 @@ 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
@@ -187,7 +197,14 @@ export class ProviderHandler {
             // "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)
+            //
+            // 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,
@@ -253,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/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,
         },
     });