byterover-cli 2.6.0 → 3.0.1

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

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

@@ -0,0 +1,162 @@
+import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { ReviewEvents, } from '../../../../shared/transport/events/review-events.js';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../../constants.js';
+import { resolveRequiredProjectPath } from './handler-types.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+async function writeFileWithDirs(absolutePath, content) {
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, content, 'utf8');
+}
+// ── Handler ──────────────────────────────────────────────────────────────────
+/**
+ * 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 class ReviewHandler {
+    curateLogStoreFactory;
+    onResolved;
+    resolveProjectPath;
+    reviewBackupStoreFactory;
+    transport;
+    constructor(deps) {
+        this.curateLogStoreFactory = deps.curateLogStoreFactory;
+        this.onResolved = deps.onResolved;
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.reviewBackupStoreFactory = deps.reviewBackupStoreFactory;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.transport.onRequest(ReviewEvents.DECIDE_TASK, (data, clientId) => this.handleDecideTask(data, clientId));
+        this.transport.onRequest(ReviewEvents.PENDING, (_data, clientId) => this.handlePending(clientId));
+    }
+    async handleDecideTask({ decision, filePaths: filterPaths, taskId }, clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
+        const store = this.curateLogStoreFactory(projectPath);
+        const backupStore = this.reviewBackupStoreFactory(projectPath);
+        const entries = await store.list();
+        // Collect pending ops grouped by relative file path for this taskId
+        const pendingByPath = new Map();
+        for (const entry of entries) {
+            if (entry.taskId !== taskId)
+                continue;
+            for (let i = 0; i < entry.operations.length; i++) {
+                const op = entry.operations[i];
+                if (op.reviewStatus !== 'pending' || !op.filePath)
+                    continue;
+                const rel = relative(contextTreeDir, op.filePath);
+                if (rel.startsWith('..'))
+                    continue;
+                let ops = pendingByPath.get(rel);
+                if (!ops) {
+                    ops = [];
+                    pendingByPath.set(rel, ops);
+                }
+                ops.push({ additionalFilePaths: op.additionalFilePaths, logId: entry.id, operationIndex: i });
+            }
+        }
+        // If filePaths filter is provided, only process those files
+        if (filterPaths?.length) {
+            const filterSet = new Set(filterPaths);
+            const keysToDelete = [...pendingByPath.keys()].filter((key) => !filterSet.has(key));
+            for (const key of keysToDelete)
+                pendingByPath.delete(key);
+        }
+        // Apply decision for each affected file in parallel.
+        // allSettled so a single file failure does not block log updates for files that succeeded.
+        const settled = await Promise.allSettled([...pendingByPath.entries()].map(async ([relPath, ops]) => {
+            let reverted = false;
+            const allAdditionalPaths = [...new Set(ops.flatMap((o) => o.additionalFilePaths ?? []))];
+            if (decision === 'rejected') {
+                const absolutePath = join(contextTreeDir, relPath);
+                const backupContent = await backupStore.read(relPath);
+                // null backup = ADD operation (new file) → remove it; existing backup → restore
+                await (backupContent === null
+                    ? unlink(absolutePath).catch(() => { })
+                    : writeFileWithDirs(absolutePath, backupContent));
+                // Restore additional paths (MERGE source, folder DELETE contents).
+                // Best-effort: partial failures must not block the log update below.
+                await Promise.allSettled(allAdditionalPaths.map(async (absPath) => {
+                    const rel = relative(contextTreeDir, absPath);
+                    const content = await backupStore.read(rel);
+                    if (content !== null)
+                        await writeFileWithDirs(absPath, content);
+                }));
+                reverted = true;
+            }
+            // Clear backups for both approve and reject (current state becomes new baseline)
+            await backupStore.delete(relPath);
+            await Promise.allSettled(allAdditionalPaths.map((absPath) => backupStore.delete(relative(contextTreeDir, absPath))));
+            return { ops, path: relPath, reverted };
+        }));
+        // Only update log entries for files that were successfully processed.
+        // Files that failed remain pending and can be retried.
+        const fileResults = settled
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+        // Batch-update review status grouped by logId (one read+write per entry file)
+        const byLogId = new Map();
+        for (const { ops } of fileResults) {
+            for (const { logId, operationIndex } of ops) {
+                let batch = byLogId.get(logId);
+                if (!batch) {
+                    batch = [];
+                    byLogId.set(logId, batch);
+                }
+                batch.push({ operationIndex, reviewStatus: decision });
+            }
+        }
+        await Promise.all([...byLogId.entries()].map(([logId, updates]) => store.batchUpdateOperationReviewStatus(logId, updates)));
+        try {
+            this.onResolved?.({ projectPath, taskId });
+        }
+        catch {
+            // Best-effort notification — never block the response
+        }
+        const totalCount = fileResults.reduce((sum, { ops }) => sum + ops.length, 0);
+        return { files: fileResults.map(({ path, reverted }) => ({ path, reverted })), totalCount };
+    }
+    async handlePending(clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
+        const store = this.curateLogStoreFactory(projectPath);
+        const entries = await store.list({ status: ['completed'] });
+        const taskMap = new Map();
+        for (const entry of entries) {
+            for (const op of entry.operations) {
+                // Skip failed ops (e.g. validation errors) — they were never applied to disk
+                if (op.reviewStatus !== 'pending' || op.status === 'failed')
+                    continue;
+                let ops = taskMap.get(entry.taskId);
+                if (!ops) {
+                    ops = [];
+                    taskMap.set(entry.taskId, ops);
+                }
+                const pendingOp = { path: op.path, type: op.type };
+                if (op.filePath) {
+                    const rel = relative(contextTreeDir, op.filePath);
+                    if (!rel.startsWith('..'))
+                        pendingOp.filePath = rel;
+                }
+                if (op.impact)
+                    pendingOp.impact = op.impact;
+                if (op.reason)
+                    pendingOp.reason = op.reason;
+                if (op.previousSummary)
+                    pendingOp.previousSummary = op.previousSummary;
+                if (op.summary)
+                    pendingOp.summary = op.summary;
+                ops.push(pendingOp);
+            }
+        }
+        const tasks = [...taskMap.entries()].map(([taskId, operations]) => ({
+            operations,
+            taskId,
+        }));
+        const pendingCount = tasks.reduce((sum, t) => sum + t.operations.length, 0);
+        return { pendingCount, tasks };
+    }
+}