byterover-cli 2.6.0 → 3.0.0

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

@@ -29,24 +29,21 @@ export function computeSummary(operations) {
                 break;
             }
             case 'UPSERT': {
-                // UPSERT is intentionally counted as "updated" — CurateLogSummary has no separate upserted field.
-                summary.updated++;
+                if (op.message?.includes('created new')) {
+                    summary.added++;
+                }
+                else {
+                    summary.updated++;
+                }
                 break;
             }
         }
     }
     return summary;
 }
-// ── CurateLogHandler ──────────────────────────────────────────────────────────
-/**
- * Lifecycle hook that transparently logs curate task execution.
- *
- * Wired into TaskRouter via lifecycleHooks[]. Writes log entries to
- * per-project FileCurateLogStore. All I/O errors are swallowed — logging
- * must never block or affect curate task execution.
- */
 export class CurateLogHandler {
     createStore;
+    onPendingReviews;
     /** Active task count per projectPath — used to evict idle stores. */
     activeTaskCount = new Map();
     /** Per-project store cache (one store per projectPath). Evicted when no active tasks remain. */
@@ -55,9 +52,11 @@ export class CurateLogHandler {
     tasks = new Map();
     /**
      * @param createStore - Optional factory for testing. Default: FileCurateLogStore.
+     * @param onPendingReviews - Optional callback fired when curate completes with pending review ops.
      */
-    constructor(createStore) {
+    constructor(createStore, onPendingReviews) {
         this.createStore = createStore;
+        this.onPendingReviews = onPendingReviews;
     }
     cleanup(taskId) {
         const state = this.tasks.get(taskId);
@@ -73,6 +72,18 @@ export class CurateLogHandler {
             }
         }
     }
+    /**
+     * Synchronously returns the pending review count from in-memory state.
+     * Included in the task:completed payload so the client receives it atomically
+     * without relying on a separate review:notify event that arrives after disk I/O.
+     */
+    getTaskCompletionData(taskId) {
+        const state = this.tasks.get(taskId);
+        if (!state)
+            return {};
+        const pendingReviewCount = state.operations.filter((op) => op.reviewStatus === 'pending').length;
+        return pendingReviewCount > 0 ? { pendingReviewCount } : {};
+    }
     async onTaskCancelled(taskId, _task) {
         const state = this.tasks.get(taskId);
         if (!state)
@@ -89,7 +100,7 @@ export class CurateLogHandler {
             transportLog(`CurateLogHandler: failed to save cancelled entry for ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
         });
     }
-    async onTaskCompleted(taskId, result, _task) {
+    async onTaskCompleted(taskId, result, task) {
         const state = this.tasks.get(taskId);
         if (!state)
             return;
@@ -105,6 +116,18 @@ export class CurateLogHandler {
         await store.save(updated).catch((error) => {
             transportLog(`CurateLogHandler: failed to save completed entry for ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
         });
+        // Notify about pending reviews (fire-and-forget)
+        if (this.onPendingReviews) {
+            const pendingCount = state.operations.filter((op) => op.reviewStatus === 'pending').length;
+            if (pendingCount > 0) {
+                try {
+                    this.onPendingReviews({ clientId: task.clientId, pendingCount, projectPath: state.projectPath, taskId });
+                }
+                catch {
+                    // Best-effort notification — never block task completion
+                }
+            }
+        }
     }
     async onTaskCreate(task) {
         if (!CURATE_TASK_TYPES.includes(task.type))
@@ -163,7 +186,21 @@ export class CurateLogHandler {
         if (!state)
             return;
         const ops = extractCurateOperations(payload);
-        state.operations.push(...ops);
+        for (const op of ops) {
+            if (op.needsReview && op.status === 'success') {
+                op.reviewStatus = 'pending';
+            }
+            // Deduplicate by filePath: keep only the latest operation per file.
+            // This ensures the reviewer sees the final version, not intermediate states.
+            if (op.filePath) {
+                const existingIndex = state.operations.findIndex((existing) => existing.filePath === op.filePath);
+                if (existingIndex !== -1) {
+                    state.operations[existingIndex] = op;
+                    continue;
+                }
+            }
+            state.operations.push(op);
+        }
     }
     // ── Private helpers ─────────────────────────────────────────────────────────
     getOrCreateStore(projectPath) {

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

@@ -4,8 +4,12 @@
  * Registers all feature handlers (auth, init, status, etc.) on the transport server.
  * These handlers implement the TUI ↔ Server event contract.
  */
+import { join } from 'node:path';
+import { ReviewEvents } from '../../../shared/transport/events/review-events.js';
 import { getAuthConfig } from '../../config/auth.config.js';
 import { getCurrentConfig } from '../../config/environment.js';
+import { BRV_DIR } from '../../constants.js';
+import { getProjectDataDir } from '../../utils/path-utils.js';
 import { OAuthService } from '../auth/oauth-service.js';
 import { OidcDiscoveryService } from '../auth/oidc-discovery-service.js';
 import { SystemBrowserLauncher } from '../browser/system-browser-launcher.js';
@@ -21,16 +25,20 @@ import { FileContextTreeService } from '../context-tree/file-context-tree-servic
 import { FileContextTreeSnapshotService } from '../context-tree/file-context-tree-snapshot-service.js';
 import { FileContextTreeWriterService } from '../context-tree/file-context-tree-writer-service.js';
 import { FsFileService } from '../file/fs-file-service.js';
+import { IsomorphicGitService } from '../git/isomorphic-git-service.js';
 import { CallbackHandler } from '../http/callback-handler.js';
 import { HubInstallService } from '../hub/hub-install-service.js';
 import { createHubKeychainStore } from '../hub/hub-keychain-store.js';
 import { HubRegistryConfigStore } from '../hub/hub-registry-config-store.js';
 import { HttpSpaceService } from '../space/http-space-service.js';
+import { FileCurateLogStore } from '../storage/file-curate-log-store.js';
+import { FileReviewBackupStore } from '../storage/file-review-backup-store.js';
 import { createTokenStore } from '../storage/token-store.js';
 import { HttpTeamService } from '../team/http-team-service.js';
 import { FsTemplateLoader } from '../template/fs-template-loader.js';
-import { AuthHandler, ConfigHandler, ConnectorsHandler, HubHandler, InitHandler, LocationsHandler, ModelHandler, ProviderHandler, PullHandler, PushHandler, ResetHandler, SpaceHandler, StatusHandler, } from '../transport/handlers/index.js';
+import { AuthHandler, ConfigHandler, ConnectorsHandler, HubHandler, InitHandler, LocationsHandler, ModelHandler, ProviderHandler, PullHandler, PushHandler, ResetHandler, ReviewHandler, SpaceHandler, StatusHandler, VcHandler, } from '../transport/handlers/index.js';
 import { HttpUserService } from '../user/http-user-service.js';
+import { FileVcGitConfigStore } from '../vc/file-vc-git-config-store.js';
 /**
  * Setup all feature handlers on the transport server.
  * These handlers implement the TUI ↔ Server event contract (auth:*, config:*, status:*, etc.).
@@ -85,9 +93,11 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
     const templateService = new RuleTemplateService(templateLoader);
     const connectorManagerFactory = (projectRoot) => new ConnectorManager({ fileService, projectRoot, templateService });
     // Project-scoped handlers (receive resolveProjectPath for client → project resolution)
+    const gitService = new IsomorphicGitService(authStateStore);
     new StatusHandler({
         contextTreeService,
         contextTreeSnapshotService,
+        curateLogStoreFactory: (projectPath) => new FileCurateLogStore({ baseDir: getProjectDataDir(projectPath) }),
         projectConfigStore,
         resolveProjectPath,
         tokenStore,
@@ -104,9 +114,12 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
         broadcastToProject,
         cogitPushService,
         contextFileReader,
+        contextTreeService,
         contextTreeSnapshotService,
+        curateLogStoreFactory: (projectPath) => new FileCurateLogStore({ baseDir: getProjectDataDir(projectPath) }),
         projectConfigStore,
         resolveProjectPath,
+        reviewBackupStoreFactory: (projectPath) => new FileReviewBackupStore(join(projectPath, BRV_DIR)),
         tokenStore,
         transport,
         webAppUrl: envConfig.webAppUrl,
@@ -114,6 +127,7 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
     new PullHandler({
         broadcastToProject,
         cogitPullService,
+        contextTreeService,
         contextTreeSnapshotService,
         contextTreeWriterService,
         projectConfigStore,
@@ -124,13 +138,25 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
     new ResetHandler({
         contextTreeService,
         contextTreeSnapshotService,
+        curateLogStoreFactory: (projectPath) => new FileCurateLogStore({ baseDir: getProjectDataDir(projectPath) }),
+        resolveProjectPath,
+        reviewBackupStoreFactory: (projectPath) => new FileReviewBackupStore(join(projectPath, BRV_DIR)),
+        transport,
+    }).setup();
+    new ReviewHandler({
+        curateLogStoreFactory: (projectPath) => new FileCurateLogStore({ baseDir: getProjectDataDir(projectPath) }),
+        onResolved({ projectPath, taskId }) {
+            broadcastToProject(projectPath, ReviewEvents.NOTIFY, { pendingCount: 0, reviewUrl: '', taskId });
+        },
         resolveProjectPath,
+        reviewBackupStoreFactory: (projectPath) => new FileReviewBackupStore(join(projectPath, BRV_DIR)),
         transport,
     }).setup();
     new SpaceHandler({
         broadcastToProject,
         cogitPullService,
         contextTreeMerger,
+        contextTreeService,
         contextTreeSnapshotService,
         contextTreeWriterService,
         projectConfigStore,
@@ -171,5 +197,19 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
         tokenStore,
         transport,
     }).setup();
+    new VcHandler({
+        broadcastToProject,
+        contextTreeService,
+        gitRemoteBaseUrl: envConfig.gitRemoteBaseUrl,
+        gitService,
+        projectConfigStore,
+        resolveProjectPath,
+        spaceService,
+        teamService,
+        tokenStore,
+        transport,
+        vcGitConfigStore: new FileVcGitConfigStore(),
+        webAppUrl: envConfig.webAppUrl,
+    }).setup();
     log('Feature handlers registered');
 }

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

@@ -171,15 +171,31 @@ export class TaskRouter {
         const { result, taskId } = data;
         const task = this.tasks.get(taskId);
         transportLog(`Task completed: ${taskId}`);
+        // Collect synchronous completion data from hooks (e.g. pendingReviewCount from CurateLogHandler).
+        // This runs before task:completed is emitted so the client receives everything atomically,
+        // avoiding the race where review:notify would otherwise arrive after task:completed.
+        const hookData = {};
+        for (const hook of this.lifecycleHooks) {
+            if (hook.getTaskCompletionData) {
+                try {
+                    Object.assign(hookData, hook.getTaskCompletionData(taskId));
+                }
+                catch {
+                    // Best-effort: never block task:completed delivery
+                }
+            }
+        }
         if (task) {
             this.transport.sendTo(task.clientId, TransportTaskEventNames.COMPLETED, {
                 ...(task.logId ? { logId: task.logId } : {}),
+                ...hookData,
                 result,
                 taskId,
             });
         }
         broadcastToProjectRoom(this.projectRegistry, this.projectRouter, task?.projectPath, TransportTaskEventNames.COMPLETED, {
             ...(task?.logId ? { logId: task.logId } : {}),
+            ...hookData,
             result,
             taskId,
         }, task?.clientId);

package/dist/server/infra/space/http-space-service.js

@@ -67,8 +67,10 @@ export class HttpSpaceService {
             id: spaceData.id,
             isDefault: spaceData.is_default,
             name: spaceData.name,
+            slug: spaceData.slug,
             teamId: spaceData.team_id,
             teamName: spaceData.team.name,
+            teamSlug: spaceData.team.slug,
         });
     }
 }

package/dist/server/infra/storage/file-curate-log-store.d.ts

@@ -18,6 +18,10 @@ export declare class FileCurateLogStore implements ICurateLogStore {
     private readonly logDir;
     private readonly maxEntries;
     constructor(opts: FileCurateLogStoreOptions);
+    batchUpdateOperationReviewStatus(logId: string, updates: Array<{
+        operationIndex: number;
+        reviewStatus: 'approved' | 'rejected';
+    }>): Promise<boolean>;
     /**
      * Retrieve an entry by ID. Returns null if:
      * - ID format is invalid (security: prevents path traversal)
@@ -49,6 +53,12 @@ export declare class FileCurateLogStore implements ICurateLogStore {
      * After saving, prunes oldest entries if count exceeds maxEntries (best-effort).
      */
     save(entry: CurateLogEntry): Promise<void>;
+    /**
+     * Update the reviewStatus of a specific operation within a log entry.
+     * Reads the entry, updates the operation at the given index, and saves back atomically.
+     * Returns false if the entry or operation index is not found.
+     */
+    updateOperationReviewStatus(logId: string, operationIndex: number, reviewStatus: 'approved' | 'rejected'): Promise<boolean>;
     private entryPath;
     private pruneOldest;
     /**

package/dist/server/infra/storage/file-curate-log-store.js

@@ -5,10 +5,18 @@ import { z } from 'zod';
 import { CURATE_LOG_DIR, CURATE_LOG_ID_PREFIX } from '../../constants.js';
 // ── Zod schema for file validation ────────────────────────────────────────────
 const CurateLogOperationFileSchema = z.object({
+    additionalFilePaths: z.array(z.string()).optional(),
+    confidence: z.enum(['high', 'low']).optional(),
     filePath: z.string().optional(),
+    impact: z.enum(['high', 'low']).optional(),
     message: z.string().optional(),
+    needsReview: z.boolean().optional(),
     path: z.string(),
+    previousSummary: z.string().optional(),
+    reason: z.string().optional(),
+    reviewStatus: z.enum(['approved', 'pending', 'rejected']).optional(),
     status: z.enum(['failed', 'success']),
+    summary: z.string().optional(),
     type: z.enum(['ADD', 'DELETE', 'MERGE', 'UPDATE', 'UPSERT']),
 });
 const CurateLogSummaryFileSchema = z.object({
@@ -69,6 +77,18 @@ export class FileCurateLogStore {
         this.logDir = join(opts.baseDir, CURATE_LOG_DIR);
         this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
     }
+    async batchUpdateOperationReviewStatus(logId, updates) {
+        const entry = await this.getById(logId);
+        if (!entry)
+            return false;
+        for (const { operationIndex, reviewStatus } of updates) {
+            if (operationIndex < 0 || operationIndex >= entry.operations.length)
+                continue;
+            entry.operations[operationIndex].reviewStatus = reviewStatus;
+        }
+        await this.save(entry);
+        return true;
+    }
     /**
      * Retrieve an entry by ID. Returns null if:
      * - ID format is invalid (security: prevents path traversal)
@@ -159,6 +179,21 @@ export class FileCurateLogStore {
         // Prune oldest entries (best-effort — ignore errors)
         this.pruneOldest().catch(() => { });
     }
+    /**
+     * Update the reviewStatus of a specific operation within a log entry.
+     * Reads the entry, updates the operation at the given index, and saves back atomically.
+     * Returns false if the entry or operation index is not found.
+     */
+    async updateOperationReviewStatus(logId, operationIndex, reviewStatus) {
+        const entry = await this.getById(logId);
+        if (!entry)
+            return false;
+        if (operationIndex < 0 || operationIndex >= entry.operations.length)
+            return false;
+        entry.operations[operationIndex].reviewStatus = reviewStatus;
+        await this.save(entry);
+        return true;
+    }
     // ── Private helpers ─────────────────────────────────────────────────────────
     entryPath(id) {
         return join(this.logDir, `${id}.json`);

package/dist/server/infra/storage/file-review-backup-store.d.ts

@@ -0,0 +1,29 @@
+import type { IReviewBackupStore } from '../../core/interfaces/storage/i-review-backup-store.js';
+/**
+ * File-based implementation of IReviewBackupStore.
+ *
+ * Stores pre-curate file content in {projectBrvDir}/review-backups/{relativePath}.
+ * The directory mirrors the context tree structure.
+ *
+ * First-write-wins: once a backup exists for a path, subsequent save() calls are no-ops.
+ * This ensures the backup always reflects the state at the time of the last push (snapshot version).
+ */
+export declare class FileReviewBackupStore implements IReviewBackupStore {
+    private readonly backupDir;
+    constructor(brvDir: string);
+    clear(): Promise<void>;
+    delete(relativePath: string): Promise<void>;
+    has(relativePath: string): Promise<boolean>;
+    /**
+     * List all backed-up file paths (relative to backup dir).
+     * Useful for the review UI to enumerate all files with backups.
+     */
+    list(): Promise<string[]>;
+    read(relativePath: string): Promise<null | string>;
+    save(relativePath: string, content: string): Promise<void>;
+    /**
+     * Remove empty ancestor directories up to and including the backup root.
+     * Called after each file deletion to keep the directory tree clean.
+     */
+    private pruneEmptyDirs;
+}

package/dist/server/infra/storage/file-review-backup-store.js

@@ -0,0 +1,121 @@
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { REVIEW_BACKUPS_DIR } from '../../constants.js';
+/**
+ * File-based implementation of IReviewBackupStore.
+ *
+ * Stores pre-curate file content in {projectBrvDir}/review-backups/{relativePath}.
+ * The directory mirrors the context tree structure.
+ *
+ * First-write-wins: once a backup exists for a path, subsequent save() calls are no-ops.
+ * This ensures the backup always reflects the state at the time of the last push (snapshot version).
+ */
+export class FileReviewBackupStore {
+    backupDir;
+    constructor(brvDir) {
+        this.backupDir = join(brvDir, REVIEW_BACKUPS_DIR);
+    }
+    async clear() {
+        try {
+            await rm(this.backupDir, { force: true, recursive: true });
+        }
+        catch {
+            // Directory may not exist — that's fine
+        }
+    }
+    async delete(relativePath) {
+        const absPath = join(this.backupDir, relativePath);
+        try {
+            await rm(absPath);
+        }
+        catch {
+            // File may not exist — that's fine
+        }
+        await this.pruneEmptyDirs(dirname(absPath));
+    }
+    async has(relativePath) {
+        try {
+            await stat(join(this.backupDir, relativePath));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * List all backed-up file paths (relative to backup dir).
+     * Useful for the review UI to enumerate all files with backups.
+     */
+    async list() {
+        const paths = [];
+        const scan = async (dir, prefix) => {
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            const subdirTasks = [];
+            for (const entry of entries) {
+                const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    subdirTasks.push(scan(join(dir, entry.name), relativePath));
+                }
+                else if (entry.isFile() && !entry.name.endsWith('.tmp')) {
+                    paths.push(relativePath);
+                }
+            }
+            await Promise.all(subdirTasks);
+        };
+        await scan(this.backupDir, '');
+        return paths;
+    }
+    async read(relativePath) {
+        try {
+            return await readFile(join(this.backupDir, relativePath), 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    async save(relativePath, content) {
+        const backupPath = join(this.backupDir, relativePath);
+        // First-write-wins: skip if backup already exists
+        if (await this.has(relativePath))
+            return;
+        await mkdir(dirname(backupPath), { recursive: true });
+        // Write atomically: write to a .tmp sibling then rename so a crash mid-write
+        // never leaves a partial (corrupt) backup that first-write-wins would preserve.
+        const tmpPath = `${backupPath}.tmp`;
+        try {
+            await writeFile(tmpPath, content, 'utf8');
+            await rename(tmpPath, backupPath);
+        }
+        catch (error) {
+            await rm(tmpPath, { force: true }).catch(() => { });
+            throw error;
+        }
+    }
+    /**
+     * Remove empty ancestor directories up to and including the backup root.
+     * Called after each file deletion to keep the directory tree clean.
+     */
+    async pruneEmptyDirs(startDir) {
+        let dir = startDir;
+        while (dir.startsWith(this.backupDir) && dir !== this.backupDir) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const entries = await readdir(dir);
+                if (entries.length > 0)
+                    return;
+                // eslint-disable-next-line no-await-in-loop
+                await rm(dir, { recursive: true });
+            }
+            catch {
+                return;
+            }
+            dir = dirname(dir);
+        }
+    }
+}

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

@@ -50,7 +50,7 @@ export class AuthHandler {
             const user = await this.userService.getCurrentUser(token.sessionKey);
             this.transport.broadcast(AuthEvents.STATE_CHANGED, {
                 isAuthorized: true,
-                user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id },
+                user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id, name: user.name },
             });
         }
         catch {
@@ -73,15 +73,16 @@ export class AuthHandler {
                 tokenType: tokenData.tokenType,
                 userEmail: user.email,
                 userId: user.id,
+                userName: user.name,
             });
             await this.tokenStore.save(authToken);
             this.transport.broadcast(AuthEvents.LOGIN_COMPLETED, {
                 success: true,
-                user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id },
+                user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id, name: user.name },
             });
             this.transport.broadcast(AuthEvents.STATE_CHANGED, {
                 isAuthorized: true,
-                user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id },
+                user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id, name: user.name },
             });
         }
         catch (error) {
@@ -152,6 +153,7 @@ export class AuthHandler {
                         email: user.email,
                         hasOnboardedCli: user.hasOnboardedCli,
                         id: user.id,
+                        name: user.name,
                     },
                 };
             }
@@ -172,11 +174,12 @@ export class AuthHandler {
                     tokenType: 'unnecessary',
                     userEmail: user.email,
                     userId: user.id,
+                    userName: user.name,
                 });
                 await this.tokenStore.save(authToken);
                 this.transport.broadcast(AuthEvents.STATE_CHANGED, {
                     isAuthorized: true,
-                    user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id },
+                    user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id, name: user.name },
                 });
                 return { success: true, userEmail: user.email };
             }
@@ -214,11 +217,12 @@ export class AuthHandler {
                     tokenType: refreshedTokenData.tokenType,
                     userEmail: user.email,
                     userId: user.id,
+                    userName: user.name,
                 });
                 await this.tokenStore.save(newToken);
                 this.transport.broadcast(AuthEvents.STATE_CHANGED, {
                     isAuthorized: true,
-                    user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id },
+                    user: { email: user.email, hasOnboardedCli: user.hasOnboardedCli, id: user.id, name: user.name },
                 });
                 return { success: true };
             }

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

@@ -1,4 +1,5 @@
 import type { ContextTreeChanges } from '../../../../shared/types/context-tree-changes.js';
+import type { IContextTreeService } from '../../../core/interfaces/context-tree/i-context-tree-service.js';
 /**
  * Resolves a transport client ID to its associated project path.
  * Returns undefined for global-scope clients that haven't been associated with a project.
@@ -21,3 +22,11 @@ export type ProjectBroadcaster = <T = unknown>(projectPath: string, event: strin
  * Returns true if the changes object has any additions, modifications, or deletions.
  */
 export declare function hasAnyChanges(changes: ContextTreeChanges): boolean;
+/**
+ * Throws GitVcInitializedError if the project has ByteRover version control initialized.
+ * Used by old snapshot-based handlers to block operations when the user has switched to /vc commands.
+ */
+export declare function guardAgainstGitVc(params: {
+    contextTreeService: IContextTreeService;
+    projectPath: string;
+}): Promise<void>;

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

@@ -1,3 +1,4 @@
+import { GitVcInitializedError } from '../../../core/domain/errors/task-error.js';
 /**
  * Resolves the project path for a client, throwing if unavailable.
  * Use this in handlers that REQUIRE a project context.
@@ -19,3 +20,13 @@ export function resolveRequiredProjectPath(resolver, clientId) {
 export function hasAnyChanges(changes) {
     return changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
 }
+/**
+ * Throws GitVcInitializedError if the project has ByteRover version control initialized.
+ * Used by old snapshot-based handlers to block operations when the user has switched to /vc commands.
+ */
+export async function guardAgainstGitVc(params) {
+    const hasGitVc = await params.contextTreeService.hasGitRepo(params.projectPath);
+    if (hasGitVc) {
+        throw new GitVcInitializedError('ByteRover version control is initialized');
+    }
+}

package/dist/server/infra/transport/handlers/index.d.ts

@@ -22,7 +22,11 @@ export { PushHandler } from './push-handler.js';
 export type { PushHandlerDeps } from './push-handler.js';
 export { ResetHandler } from './reset-handler.js';
 export type { ResetHandlerDeps } from './reset-handler.js';
+export { ReviewHandler } from './review-handler.js';
+export type { ReviewHandlerDeps } from './review-handler.js';
 export { SpaceHandler } from './space-handler.js';
 export type { SpaceHandlerDeps } from './space-handler.js';
 export { StatusHandler } from './status-handler.js';
 export type { StatusHandlerDeps } from './status-handler.js';
+export { VcHandler } from './vc-handler.js';
+export type { IVcHandlerDeps } from './vc-handler.js';

package/dist/server/infra/transport/handlers/index.js

@@ -10,5 +10,7 @@ export { ProviderHandler } from './provider-handler.js';
 export { PullHandler } from './pull-handler.js';
 export { PushHandler } from './push-handler.js';
 export { ResetHandler } from './reset-handler.js';
+export { ReviewHandler } from './review-handler.js';
 export { SpaceHandler } from './space-handler.js';
 export { StatusHandler } from './status-handler.js';
+export { VcHandler } from './vc-handler.js';

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

@@ -47,4 +47,5 @@ export declare class InitHandler {
     private handleGetAgents;
     private handleGetSpaces;
     private handleGetTeams;
+    private handleLocalInit;
 }