byterover-cli 3.2.0 → 3.4.0

package/dist/server/core/interfaces/executor/i-search-executor.d.ts

@@ -0,0 +1,34 @@
+import type { SearchKnowledgeResult } from '../../../../agent/infra/sandbox/tools-sdk.js';
+/**
+ * Options for executing a context tree search.
+ * Search is stateless — no agent session, no LLM, no task isolation needed.
+ */
+export interface SearchExecuteOptions {
+    /** Maximum number of results to return (default: 10) */
+    limit?: number;
+    /** Search query */
+    query: string;
+    /** Path prefix to scope results (e.g. "auth/" for auth domain only) */
+    scope?: string;
+}
+/**
+ * ISearchExecutor - Executes search against the context tree's BM25 index.
+ *
+ * Unlike QueryExecutor (which requires a CipherAgent for LLM synthesis),
+ * SearchExecutor is stateless and returns raw search results directly.
+ * No agent session, no sandbox, no LLM call.
+ *
+ * Architecture:
+ * - SearchKnowledgeService provides BM25-indexed search
+ * - Executor wraps it with option validation
+ * - Results are SearchKnowledgeResult (paths, scores, excerpts)
+ */
+export interface ISearchExecutor {
+    /**
+     * Execute a context tree search.
+     *
+     * @param options - Search options (query, limit, scope)
+     * @returns Raw search results with paths, scores, and excerpts
+     */
+    execute(options: SearchExecuteOptions): Promise<SearchKnowledgeResult>;
+}

package/dist/server/core/interfaces/executor/i-search-executor.js

@@ -0,0 +1 @@
+export {};

package/dist/server/core/interfaces/executor/index.d.ts

@@ -1,3 +1,4 @@
 export * from './i-curate-executor.js';
 export * from './i-folder-pack-executor.js';
 export * from './i-query-executor.js';
+export * from './i-search-executor.js';

package/dist/server/core/interfaces/executor/index.js

@@ -1,3 +1,4 @@
 export * from './i-curate-executor.js';
 export * from './i-folder-pack-executor.js';
 export * from './i-query-executor.js';
+export * from './i-search-executor.js';

package/dist/server/infra/daemon/agent-process.js

@@ -28,6 +28,7 @@ import { FolderPackService } from '../../../agent/infra/folder-pack/folder-pack-
 import { SessionMetadataStore } from '../../../agent/infra/session/session-metadata-store.js';
 import { createSearchKnowledgeService } from '../../../agent/infra/tools/implementations/search-knowledge-service.js';
 import { AuthEvents } from '../../../shared/transport/events/auth-events.js';
+import { decodeSearchContent } from '../../../shared/transport/search-content.js';
 import { getCurrentConfig } from '../../config/environment.js';
 import { DEFAULT_LLM_MODEL, PROJECT } from '../../constants.js';
 import { serializeTaskError, TaskError, TaskErrorCode } from '../../core/domain/errors/task-error.js';
@@ -36,6 +37,7 @@ import { TransportAgentEventNames, TransportDaemonEventNames, TransportStateEven
 import { CurateExecutor } from '../executor/curate-executor.js';
 import { FolderPackExecutor } from '../executor/folder-pack-executor.js';
 import { QueryExecutor } from '../executor/query-executor.js';
+import { SearchExecutor } from '../executor/search-executor.js';
 import { AgentInstanceDiscovery } from '../transport/agent-instance-discovery.js';
 import { createAgentLogger } from './agent-logger.js';
 import { resolveSessionId } from './session-resolver.js';
@@ -301,10 +303,11 @@ async function start() {
         fileSystem: fileSystemService,
         searchService,
     });
+    const searchExecutor = new SearchExecutor(searchService);
     transport.on(TransportTaskEventNames.EXECUTE, (task) => {
         agentLog(`task:execute received taskId=${task.taskId} type=${task.type} activeTaskCount=${activeTaskCount + 1}`);
         // eslint-disable-next-line no-void
-        void executeTask(task, curateExecutor, folderPackExecutor, queryExecutor);
+        void executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor);
     });
     // 8. Register with transport server (for TransportHandlers tracking)
     await transport.requestWithAck('agent:register', { projectPath });
@@ -312,15 +315,19 @@ async function start() {
     process.send?.({ clientId, type: 'ready' });
     agentLog('Ready — listening for tasks');
 }
-async function executeTask(task, curateExecutor, folderPackExecutor, queryExecutor) {
+async function executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor) {
     const { clientCwd, clientId, content, files, folderPath, taskId, type, worktreeRoot } = task;
     if (!transport || !agent)
         return;
-    const freshProviderConfig = await transport.requestWithAck(TransportStateEventNames.GET_PROVIDER_CONFIG);
-    const validationError = validateProviderForTask(freshProviderConfig);
-    if (validationError) {
-        transport.request(TransportTaskEventNames.ERROR, { clientId, error: validationError, taskId });
-        return;
+    // Search tasks are pure BM25 retrieval — no LLM, no provider needed.
+    // Skip provider validation so search works even without a configured provider.
+    if (type !== 'search') {
+        const freshProviderConfig = await transport.requestWithAck(TransportStateEventNames.GET_PROVIDER_CONFIG);
+        const validationError = validateProviderForTask(freshProviderConfig);
+        if (validationError) {
+            transport.request(TransportTaskEventNames.ERROR, { clientId, error: validationError, taskId });
+            return;
+        }
     }
     activeTaskCount++;
     try {
@@ -398,6 +405,12 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
                     result = await queryExecutor.executeWithAgent(agent, { query: content, taskId, worktreeRoot });
                     break;
                 }
+                case 'search': {
+                    const searchOptions = decodeSearchContent(content);
+                    const searchResult = await searchExecutor.execute(searchOptions);
+                    result = JSON.stringify(searchResult);
+                    break;
+                }
             }
             // Emit task:completed
             agentLog(`task:completed taskId=${taskId}`);

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

@@ -0,0 +1,17 @@
+/**
+ * SearchExecutor - Executes context tree searches via SearchKnowledgeService.
+ *
+ * Unlike QueryExecutor (Tier 0-4 with LLM synthesis), SearchExecutor is
+ * pure retrieval: BM25 index lookup → scored results. No LLM, no agent
+ * session, no sandbox, no token cost.
+ *
+ * This is the engine behind `brv search`. The CLI command and transport
+ * layer handle I/O; this module handles the search logic.
+ */
+import type { ISearchKnowledgeService, SearchKnowledgeResult } from '../../../agent/infra/sandbox/tools-sdk.js';
+import type { ISearchExecutor, SearchExecuteOptions } from '../../core/interfaces/executor/i-search-executor.js';
+export declare class SearchExecutor implements ISearchExecutor {
+    private readonly searchService;
+    constructor(searchService: ISearchKnowledgeService);
+    execute(options: SearchExecuteOptions): Promise<SearchKnowledgeResult>;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * SearchExecutor - Executes context tree searches via SearchKnowledgeService.
+ *
+ * Unlike QueryExecutor (Tier 0-4 with LLM synthesis), SearchExecutor is
+ * pure retrieval: BM25 index lookup → scored results. No LLM, no agent
+ * session, no sandbox, no token cost.
+ *
+ * This is the engine behind `brv search`. The CLI command and transport
+ * layer handle I/O; this module handles the search logic.
+ */
+const DEFAULT_LIMIT = 10;
+const MAX_LIMIT = 50;
+export class SearchExecutor {
+    searchService;
+    constructor(searchService) {
+        this.searchService = searchService;
+    }
+    async execute(options) {
+        const query = options.query.trim();
+        if (!query) {
+            return { message: 'Empty query', results: [], totalFound: 0 };
+        }
+        const scope = options.scope?.trim() || undefined;
+        const limit = Math.min(MAX_LIMIT, Math.max(1, Math.trunc(options.limit ?? DEFAULT_LIMIT)));
+        return this.searchService.search(query, {
+            limit,
+            ...(scope ? { scope } : {}),
+        });
+    }
+}

package/dist/server/infra/http/provider-model-fetchers.js

@@ -121,6 +121,7 @@ export const CODEX_ALLOWED_MODELS = new Set([
     'gpt-5.2-codex',
     'gpt-5.3-codex',
     'gpt-5.4',
+    'gpt-5.4-mini',
 ]);
 /**
  * Fallback Codex models used when models.dev is unreachable and no disk cache exists.

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

@@ -4,6 +4,7 @@
  * Registers all feature handlers (auth, init, status, etc.) on the transport server.
  * These handlers implement the TUI ↔ Server event contract.
  */
+import { access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { ReviewEvents } from '../../../shared/transport/events/review-events.js';
 import { getAuthConfig } from '../../config/auth.config.js';
@@ -106,6 +107,18 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
     new LocationsHandler({
         contextTreeService,
         getActiveProjectPaths,
+        async pathExists(path) {
+            try {
+                await access(path);
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                    return false;
+                }
+                throw error;
+            }
+        },
         projectRegistry,
         resolveProjectPath,
         transport,

package/dist/server/infra/project/project-registry.js

@@ -82,7 +82,19 @@ export class ProjectRegistry {
         return info;
     }
     unregister(projectPath) {
-        const resolved = resolvePath(projectPath);
+        let resolved;
+        try {
+            resolved = resolvePath(projectPath);
+        }
+        catch (error) {
+            // ENOENT — path deleted from disk. Keys are already resolved, so try the raw input.
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                resolved = projectPath;
+            }
+            else {
+                throw error;
+            }
+        }
         if (!this.projects.has(resolved)) {
             return false;
         }

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

@@ -5,6 +5,7 @@ import { type ProjectPathResolver } from './handler-types.js';
 export interface LocationsHandlerDeps {
     contextTreeService: IContextTreeService;
     getActiveProjectPaths: () => string[];
+    pathExists: (path: string) => Promise<boolean>;
     projectRegistry: IProjectRegistry;
     resolveProjectPath: ProjectPathResolver;
     transport: ITransportServer;
@@ -16,6 +17,7 @@ export interface LocationsHandlerDeps {
 export declare class LocationsHandler {
     private readonly contextTreeService;
     private readonly getActiveProjectPaths;
+    private readonly pathExists;
     private readonly projectRegistry;
     private readonly resolveProjectPath;
     private readonly transport;

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

@@ -9,12 +9,14 @@ import { resolveRequiredProjectPath } from './handler-types.js';
 export class LocationsHandler {
     contextTreeService;
     getActiveProjectPaths;
+    pathExists;
     projectRegistry;
     resolveProjectPath;
     transport;
     constructor(deps) {
         this.contextTreeService = deps.contextTreeService;
         this.getActiveProjectPaths = deps.getActiveProjectPaths;
+        this.pathExists = deps.pathExists;
         this.projectRegistry = deps.projectRegistry;
         this.resolveProjectPath = deps.resolveProjectPath;
         this.transport = deps.transport;
@@ -35,6 +37,18 @@ export class LocationsHandler {
         const all = this.projectRegistry.getAll();
         const activeSet = new Set(this.getActiveProjectPaths());
         const results = await Promise.all([...all.entries()].map(async ([path]) => {
+            try {
+                const exists = await this.pathExists(path);
+                if (!exists) {
+                    this.projectRegistry.unregister(path);
+                    return null;
+                }
+            }
+            catch {
+                // pathExists threw unexpectedly — skip this entry but do NOT unregister,
+                // since the path may still exist (e.g. a transient permission error).
+                return null;
+            }
             let isInitialized = false;
             try {
                 isInitialized = await this.contextTreeService.exists(path);
@@ -50,8 +64,9 @@ export class LocationsHandler {
                 projectPath: path,
             };
         }));
+        const filtered = results.filter((r) => r !== null);
         // Sort: current first → active (has clients) → initialized → rest, all by registeredAt desc
-        return results.sort((a, b) => {
+        return filtered.sort((a, b) => {
             if (a.isCurrent !== b.isCurrent)
                 return a.isCurrent ? -1 : 1;
             if (a.isActive !== b.isActive)

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

@@ -1,5 +1,5 @@
 import { PullEvents, } from '../../../../shared/transport/events/pull-events.js';
-import { LocalChangesExistError, NotAuthenticatedError, ProjectNotInitError, SpaceNotConfiguredError, } from '../../../core/domain/errors/task-error.js';
+import { LegacySyncUnavailableError, LocalChangesExistError, NotAuthenticatedError, ProjectNotInitError, } from '../../../core/domain/errors/task-error.js';
 import { guardAgainstGitVc, hasAnyChanges, resolveRequiredProjectPath, } from './handler-types.js';
 /**
  * Handles pull:* events.
@@ -42,7 +42,7 @@ export class PullHandler {
             throw new ProjectNotInitError();
         }
         if (!config.teamId || !config.spaceId) {
-            throw new SpaceNotConfiguredError();
+            throw new LegacySyncUnavailableError();
         }
         // Check for local changes that would be overwritten
         const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
@@ -79,7 +79,7 @@ export class PullHandler {
             throw new ProjectNotInitError();
         }
         if (!config.teamId || !config.spaceId) {
-            throw new SpaceNotConfiguredError();
+            throw new LegacySyncUnavailableError();
         }
         const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
         const hasLocalChanges = hasAnyChanges(changes);

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

@@ -1,6 +1,6 @@
 import { join, relative } from 'node:path';
 import { PushEvents, } from '../../../../shared/transport/events/push-events.js';
-import { NotAuthenticatedError, ProjectNotInitError, SpaceNotConfiguredError, } from '../../../core/domain/errors/task-error.js';
+import { LegacySyncUnavailableError, NotAuthenticatedError, ProjectNotInitError, } from '../../../core/domain/errors/task-error.js';
 import { mapToPushContexts } from '../../cogit/context-tree-to-push-context-mapper.js';
 import { guardAgainstGitVc, resolveRequiredProjectPath, } from './handler-types.js';
 /** Path prefix of the context tree relative to the project root. */
@@ -88,7 +88,7 @@ export class PushHandler {
             throw new ProjectNotInitError();
         }
         if (!config.teamId || !config.spaceId) {
-            throw new SpaceNotConfiguredError();
+            throw new LegacySyncUnavailableError();
         }
         this.broadcastToProject(projectPath, PushEvents.PROGRESS, { message: 'Reading context files...', step: 'reading' });
         const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
@@ -163,7 +163,7 @@ export class PushHandler {
             throw new ProjectNotInitError();
         }
         if (!config.teamId || !config.spaceId) {
-            throw new SpaceNotConfiguredError();
+            throw new LegacySyncUnavailableError();
         }
         const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(projectPath);
         if (!hasSnapshot) {

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

@@ -84,13 +84,14 @@ export class StatusHandler {
             result.authStatus = 'unknown';
         }
         // Project status — use effectiveProjectPath for consistency with resolved root
+        let projectConfig;
         try {
             const isInitialized = await this.projectConfigStore.exists(effectiveProjectPath);
             if (isInitialized) {
-                const config = await this.projectConfigStore.read(effectiveProjectPath);
-                if (config) {
-                    result.teamName = config.teamName;
-                    result.spaceName = config.spaceName;
+                projectConfig = await this.projectConfigStore.read(effectiveProjectPath);
+                if (projectConfig) {
+                    result.teamName = projectConfig.teamName;
+                    result.spaceName = projectConfig.spaceName;
                 }
             }
         }
@@ -115,22 +116,28 @@ export class StatusHandler {
                 else {
                     result.contextTreeDir = join(effectiveProjectPath, BRV_DIR, CONTEXT_TREE_DIR);
                     result.contextTreeRelativeDir = join(BRV_DIR, CONTEXT_TREE_DIR);
-                    const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(effectiveProjectPath);
-                    if (!hasSnapshot) {
-                        await this.contextTreeSnapshotService.initEmptySnapshot(effectiveProjectPath);
-                    }
-                    const changes = await this.contextTreeSnapshotService.getChanges(effectiveProjectPath);
-                    const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
-                    if (hasChanges) {
-                        result.contextTreeStatus = 'has_changes';
-                        result.contextTreeChanges = {
-                            added: changes.added,
-                            deleted: changes.deleted,
-                            modified: changes.modified,
-                        };
+                    const hasLegacySyncConfig = Boolean(projectConfig?.teamId && projectConfig?.spaceId);
+                    if (hasLegacySyncConfig) {
+                        const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(effectiveProjectPath);
+                        if (!hasSnapshot) {
+                            await this.contextTreeSnapshotService.initEmptySnapshot(effectiveProjectPath);
+                        }
+                        const changes = await this.contextTreeSnapshotService.getChanges(effectiveProjectPath);
+                        const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
+                        if (hasChanges) {
+                            result.contextTreeStatus = 'has_changes';
+                            result.contextTreeChanges = {
+                                added: changes.added,
+                                deleted: changes.deleted,
+                                modified: changes.modified,
+                            };
+                        }
+                        else {
+                            result.contextTreeStatus = 'no_changes';
+                        }
                     }
                     else {
-                        result.contextTreeStatus = 'no_changes';
+                        result.contextTreeStatus = 'no_vc';
                     }
                 }
             }

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

@@ -41,10 +41,6 @@ export declare class VcHandler {
     setup(): void;
     private buildAuthorHint;
     private buildNoRemoteMessage;
-    /**
-     * Writes a .gitignore to the context-tree directory only if one does not already exist.
-     */
-    private ensureGitignore;
     /**
      * When force is NOT set, checks for uncommitted changes and throws
      * VcError(UNCOMMITTED_CHANGES) if the working tree is dirty.

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

@@ -1,13 +1,12 @@
 import fs from 'node:fs';
 import { join } from 'node:path';
 import { VcErrorCode, VcEvents, } from '../../../../shared/transport/events/vc-events.js';
-import { CONTEXT_TREE_GITIGNORE } from '../../../constants.js';
 import { BrvConfig } from '../../../core/domain/entities/brv-config.js';
 import { Space } from '../../../core/domain/entities/space.js';
 import { GitAuthError, GitError } from '../../../core/domain/errors/git-error.js';
 import { NotAuthenticatedError } from '../../../core/domain/errors/task-error.js';
 import { VcError } from '../../../core/domain/errors/vc-error.js';
-import { ensureGitignoreEntries } from '../../../utils/gitignore.js';
+import { ensureContextTreeGitignore, ensureGitignoreEntries } from '../../../utils/gitignore.js';
 import { buildCogitRemoteUrl, isValidBranchName, parseUserFacingUrl } from '../../git/cogit-url.js';
 import { resolveRequiredProjectPath } from './handler-types.js';
 /**
@@ -101,18 +100,6 @@ export class VcHandler {
             `  3. Run: brv vc remote add origin <url>\n` +
             `  4. Then: ${nextStep}`);
     }
-    /**
-     * Writes a .gitignore to the context-tree directory only if one does not already exist.
-     */
-    async ensureGitignore(contextTreeDir) {
-        const gitignorePath = join(contextTreeDir, '.gitignore');
-        try {
-            await fs.promises.access(gitignorePath);
-        }
-        catch {
-            await fs.promises.writeFile(gitignorePath, CONTEXT_TREE_GITIGNORE, 'utf8');
-        }
-    }
     /**
      * When force is NOT set, checks for uncommitted changes and throws
      * VcError(UNCOMMITTED_CHANGES) if the working tree is dirty.
@@ -134,6 +121,7 @@ export class VcHandler {
         if (!gitInitialized) {
             throw new VcError('ByteRover version control not initialized.', VcErrorCode.GIT_NOT_INITIALIZED);
         }
+        await ensureContextTreeGitignore(directory);
         const statusBefore = await this.gitService.status({ directory });
         const stagedBefore = new Set(statusBefore.files.filter((f) => f.staged).map((f) => f.path));
         const hadUnstagedBefore = new Set(statusBefore.files.filter((f) => !f.staged).map((f) => f.path));
@@ -350,7 +338,7 @@ export class VcHandler {
                 await this.projectConfigStore.write(updated, projectPath);
             }
             // Ensure .gitignore exists (remote may not have one)
-            await this.ensureGitignore(contextTreeDir);
+            await ensureContextTreeGitignore(contextTreeDir);
             // Add .brv entries to project .gitignore (prevents `git add .` fatal error from nested .git)
             await ensureGitignoreEntries(projectPath);
         }
@@ -456,7 +444,7 @@ export class VcHandler {
         const reinitialized = await this.gitService.isInitialized({ directory: contextTreeDir });
         await this.gitService.init({ defaultBranch: 'main', directory: contextTreeDir });
         // 3. Ensure .gitignore exists with correct content (idempotent)
-        await this.ensureGitignore(contextTreeDir);
+        await ensureContextTreeGitignore(contextTreeDir);
         // 4. Add .brv entries to project .gitignore (prevents `git add .` fatal error from nested .git)
         await ensureGitignoreEntries(projectPath);
         return {
@@ -818,6 +806,7 @@ export class VcHandler {
                 untracked: [],
             };
         }
+        await ensureContextTreeGitignore(contextTreeDir);
         const branch = await this.gitService.getCurrentBranch({ directory: contextTreeDir });
         const gitStatus = await this.gitService.status({ directory: contextTreeDir });
         // Detect empty repo (no commits yet)