byterover-cli 2.5.2 → 3.0.0

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;
 }

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

@@ -5,8 +5,9 @@ import { BrvConfig } from '../../../core/domain/entities/brv-config.js';
 import { NotAuthenticatedError, SpaceNotFoundError } from '../../../core/domain/errors/task-error.js';
 import { syncConfigToXdg } from '../../../utils/config-xdg-sync.js';
 import { getErrorMessage } from '../../../utils/error-helpers.js';
+import { ensureProjectInitialized } from '../../config/auto-init.js';
 import { mapAgentsToDTOs } from './agent-dto-mapper.js';
-import { resolveRequiredProjectPath } from './handler-types.js';
+import { guardAgainstGitVc, resolveRequiredProjectPath, } from './handler-types.js';
 /**
  * Handles init:* events.
  * Business logic for project initialization — no terminal/UI calls.
@@ -44,9 +45,11 @@ export class InitHandler {
         this.transport.onRequest(InitEvents.GET_SPACES, (data) => this.handleGetSpaces(data));
         this.transport.onRequest(InitEvents.GET_AGENTS, () => this.handleGetAgents());
         this.transport.onRequest(InitEvents.EXECUTE, (data, clientId) => this.handleExecute(data, clientId));
+        this.transport.onRequest(InitEvents.LOCAL, (data, clientId) => this.handleLocalInit(data, clientId));
     }
     async handleExecute(data, clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        await guardAgainstGitVc({ contextTreeService: this.contextTreeService, projectPath });
         const token = await this.tokenStore.load();
         if (!token || !token.isValid()) {
             throw new NotAuthenticatedError();
@@ -154,4 +157,13 @@ export class InitHandler {
             })),
         };
     }
+    async handleLocalInit(data, clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const exists = await this.projectConfigStore.exists(projectPath);
+        if (exists && !data.force) {
+            return { alreadyInitialized: true, success: true };
+        }
+        await ensureProjectInitialized({ contextTreeService: this.contextTreeService, projectConfigStore: this.projectConfigStore }, projectPath);
+        return { alreadyInitialized: false, success: true };
+    }
 }

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

@@ -1,4 +1,5 @@
 import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.js';
+import type { IContextTreeService } from '../../../core/interfaces/context-tree/i-context-tree-service.js';
 import type { IContextTreeSnapshotService } from '../../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
 import type { IContextTreeWriterService } from '../../../core/interfaces/context-tree/i-context-tree-writer-service.js';
 import type { ICogitPullService } from '../../../core/interfaces/services/i-cogit-pull-service.js';
@@ -8,6 +9,7 @@ import { type ProjectBroadcaster, type ProjectPathResolver } from './handler-typ
 export interface PullHandlerDeps {
     broadcastToProject: ProjectBroadcaster;
     cogitPullService: ICogitPullService;
+    contextTreeService: IContextTreeService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
     contextTreeWriterService: IContextTreeWriterService;
     projectConfigStore: IProjectConfigStore;
@@ -22,6 +24,7 @@ export interface PullHandlerDeps {
 export declare class PullHandler {
     private readonly broadcastToProject;
     private readonly cogitPullService;
+    private readonly contextTreeService;
     private readonly contextTreeSnapshotService;
     private readonly contextTreeWriterService;
     private readonly projectConfigStore;

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

@@ -1,6 +1,6 @@
 import { PullEvents, } from '../../../../shared/transport/events/pull-events.js';
 import { LocalChangesExistError, NotAuthenticatedError, ProjectNotInitError, SpaceNotConfiguredError, } from '../../../core/domain/errors/task-error.js';
-import { hasAnyChanges, resolveRequiredProjectPath } from './handler-types.js';
+import { guardAgainstGitVc, hasAnyChanges, resolveRequiredProjectPath, } from './handler-types.js';
 /**
  * Handles pull:* events.
  * Business logic for pulling context tree from cloud — no terminal/UI calls.
@@ -8,6 +8,7 @@ import { hasAnyChanges, resolveRequiredProjectPath } from './handler-types.js';
 export class PullHandler {
     broadcastToProject;
     cogitPullService;
+    contextTreeService;
     contextTreeSnapshotService;
     contextTreeWriterService;
     projectConfigStore;
@@ -17,6 +18,7 @@ export class PullHandler {
     constructor(deps) {
         this.broadcastToProject = deps.broadcastToProject;
         this.cogitPullService = deps.cogitPullService;
+        this.contextTreeService = deps.contextTreeService;
         this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
         this.contextTreeWriterService = deps.contextTreeWriterService;
         this.projectConfigStore = deps.projectConfigStore;
@@ -30,6 +32,7 @@ export class PullHandler {
     }
     async handleExecute(data, clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        await guardAgainstGitVc({ contextTreeService: this.contextTreeService, projectPath });
         const token = await this.tokenStore.load();
         if (!token || !token.isValid()) {
             throw new NotAuthenticatedError();
@@ -66,6 +69,7 @@ export class PullHandler {
     }
     async handlePrepare(_data, clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        await guardAgainstGitVc({ contextTreeService: this.contextTreeService, projectPath });
         const token = await this.tokenStore.load();
         if (!token || !token.isValid()) {
             throw new NotAuthenticatedError();

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

@@ -1,17 +1,25 @@
 import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.js';
 import type { IContextFileReader } from '../../../core/interfaces/context-tree/i-context-file-reader.js';
+import type { IContextTreeService } from '../../../core/interfaces/context-tree/i-context-tree-service.js';
 import type { IContextTreeSnapshotService } from '../../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
 import type { ICogitPushService } from '../../../core/interfaces/services/i-cogit-push-service.js';
+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 ProjectBroadcaster, type ProjectPathResolver } from './handler-types.js';
+/** Factory that creates a curate log store scoped to a project directory. */
+export type CurateLogStoreFactory = (projectPath: string) => ICurateLogStore;
 export interface PushHandlerDeps {
     broadcastToProject: ProjectBroadcaster;
     cogitPushService: ICogitPushService;
     contextFileReader: IContextFileReader;
+    contextTreeService: IContextTreeService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
+    curateLogStoreFactory: CurateLogStoreFactory;
     projectConfigStore: IProjectConfigStore;
     resolveProjectPath: ProjectPathResolver;
+    reviewBackupStoreFactory: (projectPath: string) => IReviewBackupStore;
     tokenStore: ITokenStore;
     transport: ITransportServer;
     webAppUrl: string;
@@ -24,14 +32,26 @@ export declare class PushHandler {
     private readonly broadcastToProject;
     private readonly cogitPushService;
     private readonly contextFileReader;
+    private readonly contextTreeService;
     private readonly contextTreeSnapshotService;
+    private readonly curateLogStoreFactory;
     private readonly projectConfigStore;
     private readonly resolveProjectPath;
+    private readonly reviewBackupStoreFactory;
     private readonly tokenStore;
     private readonly transport;
     private readonly webAppUrl;
     constructor(deps: PushHandlerDeps);
     setup(): void;
+    /**
+     * Filter a list of file paths, removing any with pending or rejected review status.
+     */
+    private filterPushablePaths;
+    /**
+     * Build a map of context-tree-relative file path → review status from the curate log.
+     * Uses newest-wins strategy for the same file across multiple entries.
+     */
+    private getFileReviewStatuses;
     private handleExecute;
     private handlePrepare;
 }

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

@@ -1,7 +1,10 @@
+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 { mapToPushContexts } from '../../cogit/context-tree-to-push-context-mapper.js';
-import { resolveRequiredProjectPath } from './handler-types.js';
+import { guardAgainstGitVc, resolveRequiredProjectPath, } from './handler-types.js';
+/** Path prefix of the context tree relative to the project root. */
+const CONTEXT_TREE_RELATIVE = join('.brv', 'context-tree');
 /**
  * Handles push:* events.
  * Business logic for pushing context tree to cloud — no terminal/UI calls.
@@ -10,9 +13,12 @@ export class PushHandler {
     broadcastToProject;
     cogitPushService;
     contextFileReader;
+    contextTreeService;
     contextTreeSnapshotService;
+    curateLogStoreFactory;
     projectConfigStore;
     resolveProjectPath;
+    reviewBackupStoreFactory;
     tokenStore;
     transport;
     webAppUrl;
@@ -20,9 +26,12 @@ export class PushHandler {
         this.broadcastToProject = deps.broadcastToProject;
         this.cogitPushService = deps.cogitPushService;
         this.contextFileReader = deps.contextFileReader;
+        this.contextTreeService = deps.contextTreeService;
         this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
+        this.curateLogStoreFactory = deps.curateLogStoreFactory;
         this.projectConfigStore = deps.projectConfigStore;
         this.resolveProjectPath = deps.resolveProjectPath;
+        this.reviewBackupStoreFactory = deps.reviewBackupStoreFactory;
         this.tokenStore = deps.tokenStore;
         this.transport = deps.transport;
         this.webAppUrl = deps.webAppUrl;
@@ -31,8 +40,45 @@ export class PushHandler {
         this.transport.onRequest(PushEvents.PREPARE, (data, clientId) => this.handlePrepare(data, clientId));
         this.transport.onRequest(PushEvents.EXECUTE, (data, clientId) => this.handleExecute(data, clientId));
     }
+    /**
+     * Filter a list of file paths, removing any with pending or rejected review status.
+     */
+    filterPushablePaths(paths, reviewStatuses) {
+        return paths.filter((path) => {
+            const status = reviewStatuses.get(path);
+            return status !== 'pending' && status !== 'rejected';
+        });
+    }
+    /**
+     * Build a map of context-tree-relative file path → review status from the curate log.
+     * Uses newest-wins strategy for the same file across multiple entries.
+     */
+    async getFileReviewStatuses(projectPath) {
+        const map = new Map();
+        try {
+            const store = this.curateLogStoreFactory(projectPath);
+            const entries = await store.list({ limit: 500, status: ['completed'] });
+            const contextTreeRoot = join(projectPath, CONTEXT_TREE_RELATIVE);
+            // Process oldest-first so the newest entry wins for each path
+            for (const entry of [...entries].reverse()) {
+                for (const op of entry.operations) {
+                    if (!op.filePath || !op.reviewStatus)
+                        continue;
+                    const relativePath = relative(contextTreeRoot, op.filePath);
+                    if (relativePath.startsWith('..'))
+                        continue;
+                    map.set(relativePath, op.reviewStatus);
+                }
+            }
+        }
+        catch {
+            // Best-effort
+        }
+        return map;
+    }
     async handleExecute(data, clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        await guardAgainstGitVc({ contextTreeService: this.contextTreeService, projectPath });
         const token = await this.tokenStore.load();
         if (!token || !token.isValid()) {
             throw new NotAuthenticatedError();
@@ -46,13 +92,18 @@ export class PushHandler {
         }
         this.broadcastToProject(projectPath, PushEvents.PROGRESS, { message: 'Reading context files...', step: 'reading' });
         const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
+        // Filter out files with pending/rejected review status
+        const reviewStatuses = await this.getFileReviewStatuses(projectPath);
+        const pushableAdded = this.filterPushablePaths(changes.added, reviewStatuses);
+        const pushableModified = this.filterPushablePaths(changes.modified, reviewStatuses);
+        const pushableDeleted = this.filterPushablePaths(changes.deleted, reviewStatuses);
         const [addedFiles, modifiedFiles] = await Promise.all([
-            this.contextFileReader.readMany(changes.added, projectPath),
-            this.contextFileReader.readMany(changes.modified, projectPath),
+            this.contextFileReader.readMany(pushableAdded, projectPath),
+            this.contextFileReader.readMany(pushableModified, projectPath),
         ]);
         const pushContexts = mapToPushContexts({
             addedFiles,
-            deletedPaths: changes.deleted,
+            deletedPaths: pushableDeleted,
             modifiedFiles,
         });
         this.broadcastToProject(projectPath, PushEvents.PROGRESS, { message: 'Pushing to cloud...', step: 'pushing' });
@@ -64,11 +115,37 @@ export class PushHandler {
             spaceId: config.spaceId,
             teamId: config.teamId,
         });
-        await this.contextTreeSnapshotService.saveSnapshot(projectPath);
+        // Save snapshot selectively: only record pushed files so excluded files
+        // still appear as changes in the next push.
+        const oldSnapshot = await this.contextTreeSnapshotService.getSnapshotState(projectPath);
+        const currentState = await this.contextTreeSnapshotService.getCurrentState(projectPath);
+        const newSnapshot = new Map(oldSnapshot);
+        for (const path of pushableAdded) {
+            const state = currentState.get(path);
+            if (state)
+                newSnapshot.set(path, state);
+        }
+        for (const path of pushableModified) {
+            const state = currentState.get(path);
+            if (state)
+                newSnapshot.set(path, state);
+        }
+        for (const path of pushableDeleted) {
+            newSnapshot.delete(path);
+        }
+        await this.contextTreeSnapshotService.saveSnapshotFromState(newSnapshot, projectPath);
+        // Best-effort: clear backups for pushed files so the pushed state becomes the new diff baseline
+        try {
+            const backupStore = this.reviewBackupStoreFactory(projectPath);
+            await Promise.all([...pushableAdded, ...pushableModified, ...pushableDeleted].map((p) => backupStore.delete(p)));
+        }
+        catch {
+            // Backup cleanup must never block the push response
+        }
         const url = `${this.webAppUrl}/${config.teamName}/${config.spaceName}`;
         return {
             added: addedFiles.length,
-            deleted: changes.deleted.length,
+            deleted: pushableDeleted.length,
             edited: modifiedFiles.length,
             success: true,
             url,
@@ -76,6 +153,7 @@ export class PushHandler {
     }
     async handlePrepare(_data, clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        await guardAgainstGitVc({ contextTreeService: this.contextTreeService, projectPath });
         const token = await this.tokenStore.load();
         if (!token || !token.isValid()) {
             throw new NotAuthenticatedError();
@@ -92,17 +170,41 @@ export class PushHandler {
             await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
         }
         const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
+        // Get review statuses and filter pushable files
+        const reviewStatuses = await this.getFileReviewStatuses(projectPath);
+        const pushableAdded = this.filterPushablePaths(changes.added, reviewStatuses);
+        const pushableModified = this.filterPushablePaths(changes.modified, reviewStatuses);
+        const pushableDeleted = this.filterPushablePaths(changes.deleted, reviewStatuses);
         const totalChanges = changes.added.length + changes.modified.length + changes.deleted.length;
+        const pushableTotal = pushableAdded.length + pushableModified.length + pushableDeleted.length;
+        const excludedReviewCount = totalChanges - pushableTotal;
+        // Count pending reviews from review statuses map
+        let pendingReviewCount = 0;
+        for (const status of reviewStatuses.values()) {
+            if (status === 'pending')
+                pendingReviewCount++;
+        }
         const parts = [];
-        if (changes.added.length > 0)
-            parts.push(`${changes.added.length} added`);
-        if (changes.modified.length > 0)
-            parts.push(`${changes.modified.length} modified`);
-        if (changes.deleted.length > 0)
-            parts.push(`${changes.deleted.length} deleted`);
+        if (pushableAdded.length > 0)
+            parts.push(`${pushableAdded.length} added`);
+        if (pushableModified.length > 0)
+            parts.push(`${pushableModified.length} modified`);
+        if (pushableDeleted.length > 0)
+            parts.push(`${pushableDeleted.length} deleted`);
+        let reviewUrl;
+        if (pendingReviewCount > 0) {
+            const port = this.transport.getPort();
+            if (port) {
+                const encoded = Buffer.from(projectPath).toString('base64url');
+                reviewUrl = `http://127.0.0.1:${port}/review?project=${encoded}`;
+            }
+        }
         return {
-            fileCount: totalChanges,
-            hasChanges: totalChanges > 0,
+            excludedReviewCount,
+            fileCount: pushableTotal,
+            hasChanges: pushableTotal > 0,
+            pendingReviewCount,
+            ...(reviewUrl ? { reviewUrl } : {}),
             summary: parts.length > 0 ? parts.join(', ') : 'No changes',
         };
     }

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

@@ -1,11 +1,15 @@
 import type { IContextTreeService } from '../../../core/interfaces/context-tree/i-context-tree-service.js';
 import type { IContextTreeSnapshotService } from '../../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
+import type { ICurateLogStore } from '../../../core/interfaces/storage/i-curate-log-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';
 export interface ResetHandlerDeps {
     contextTreeService: IContextTreeService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
+    curateLogStoreFactory: (projectPath: string) => ICurateLogStore;
     resolveProjectPath: ProjectPathResolver;
+    reviewBackupStoreFactory: (projectPath: string) => IReviewBackupStore;
     transport: ITransportServer;
 }
 /**
@@ -15,9 +19,16 @@ export interface ResetHandlerDeps {
 export declare class ResetHandler {
     private readonly contextTreeService;
     private readonly contextTreeSnapshotService;
+    private readonly curateLogStoreFactory;
     private readonly resolveProjectPath;
+    private readonly reviewBackupStoreFactory;
     private readonly transport;
     constructor(deps: ResetHandlerDeps);
     setup(): void;
+    /**
+     * Mark all pending review operations as 'rejected' so they no longer appear in /status.
+     * The context tree has been wiped, so these reviews are no longer actionable.
+     */
+    private clearPendingReviews;
     private handleExecute;
 }

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

@@ -1,6 +1,6 @@
 import { ResetEvents } from '../../../../shared/transport/events/reset-events.js';
 import { ContextTreeNotInitializedError } from '../../../core/domain/errors/task-error.js';
-import { resolveRequiredProjectPath } from './handler-types.js';
+import { guardAgainstGitVc, resolveRequiredProjectPath } from './handler-types.js';
 /**
  * Handles reset:execute event.
  * Deletes and re-initializes the context tree — no terminal/UI calls.
@@ -8,19 +8,42 @@ import { resolveRequiredProjectPath } from './handler-types.js';
 export class ResetHandler {
     contextTreeService;
     contextTreeSnapshotService;
+    curateLogStoreFactory;
     resolveProjectPath;
+    reviewBackupStoreFactory;
     transport;
     constructor(deps) {
         this.contextTreeService = deps.contextTreeService;
         this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
+        this.curateLogStoreFactory = deps.curateLogStoreFactory;
         this.resolveProjectPath = deps.resolveProjectPath;
+        this.reviewBackupStoreFactory = deps.reviewBackupStoreFactory;
         this.transport = deps.transport;
     }
     setup() {
         this.transport.onRequest(ResetEvents.EXECUTE, (_data, clientId) => this.handleExecute(clientId));
     }
+    /**
+     * Mark all pending review operations as 'rejected' so they no longer appear in /status.
+     * The context tree has been wiped, so these reviews are no longer actionable.
+     */
+    async clearPendingReviews(projectPath) {
+        const store = this.curateLogStoreFactory(projectPath);
+        // Only completed entries can carry reviewable operations; pending reviews are assigned at completion time.
+        const entries = await store.list({ status: ['completed'] });
+        const updates = entries
+            .map((entry) => {
+            const pendingIndices = entry.operations
+                .map((op, i) => (op.reviewStatus === 'pending' ? { operationIndex: i, reviewStatus: 'rejected' } : null))
+                .filter((u) => u !== null);
+            return pendingIndices.length > 0 ? { id: entry.id, pendingIndices } : null;
+        })
+            .filter((u) => u !== null);
+        await Promise.all(updates.map((u) => store.batchUpdateOperationReviewStatus(u.id, u.pendingIndices)));
+    }
     async handleExecute(clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        await guardAgainstGitVc({ contextTreeService: this.contextTreeService, projectPath });
         const exists = await this.contextTreeService.exists(projectPath);
         if (!exists) {
             throw new ContextTreeNotInitializedError();
@@ -28,6 +51,19 @@ export class ResetHandler {
         await this.contextTreeService.delete(projectPath);
         await this.contextTreeService.initialize(projectPath);
         await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
+        // Best-effort: clear review backups and pending review statuses so /status starts fresh
+        try {
+            await this.reviewBackupStoreFactory(projectPath).clear();
+        }
+        catch {
+            // Backup cleanup must never block the reset response
+        }
+        try {
+            await this.clearPendingReviews(projectPath);
+        }
+        catch {
+            // Review status cleanup must never block the reset response
+        }
         return { success: true };
     }
 }

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

@@ -0,0 +1,35 @@
+import type { ICurateLogStore } from '../../../core/interfaces/storage/i-curate-log-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';
+type CurateLogStoreFactory = (projectPath: string) => ICurateLogStore;
+type ReviewBackupStoreFactory = (projectPath: string) => IReviewBackupStore;
+export interface ReviewHandlerDeps {
+    curateLogStoreFactory: CurateLogStoreFactory;
+    /** Called after all pending ops for a task are decided. Used to notify TUI clients. */
+    onResolved?: (info: {
+        projectPath: string;
+        taskId: string;
+    }) => void;
+    resolveProjectPath: ProjectPathResolver;
+    reviewBackupStoreFactory: ReviewBackupStoreFactory;
+    transport: ITransportServer;
+}
+/**
+ * Handles review:decideTask — approves or rejects all pending review operations
+ * for a given task ID in a single transport request.
+ *
+ * Mirrors the per-file logic in review-api-handler.ts but operates at task scope.
+ */
+export declare class ReviewHandler {
+    private readonly curateLogStoreFactory;
+    private readonly onResolved;
+    private readonly resolveProjectPath;
+    private readonly reviewBackupStoreFactory;
+    private readonly transport;
+    constructor(deps: ReviewHandlerDeps);
+    setup(): void;
+    private handleDecideTask;
+    private handlePending;
+}
+export {};