byterover-cli 3.10.0 → 3.10.2

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

@@ -60,6 +60,12 @@ export class DreamExecutor {
         // flag, a failure that occurs after step 6b succeeds (e.g. step 7
         // dreamStateService.update throws) would re-write the same review entries.
         let reviewEntriesWritten = false;
+        // The disable flag is captured once at task-create on the daemon and forwarded via
+        // TaskExecute → executeTask → here. Reading it from options (instead of re-resolving
+        // from .brv/config.json on the agent side) means backup-creation and review-entry
+        // writing observe the same value as the daemon-side curate log handler, even if the
+        // user toggles mid-run.
+        const reviewDisabled = options.reviewDisabled ?? false;
         try {
             // Step 1: Capture pre-state
             const snapshotService = new FileContextTreeSnapshotService({ baseDirectory: projectRoot });
@@ -68,7 +74,12 @@ export class DreamExecutor {
                 preState = await snapshotService.getCurrentState(projectRoot);
             }
             catch {
-                // Fail-open: if snapshot fails, skip propagation
+                // Fail-open: leaving preState undefined skips the entire step 5 block
+                // (queue drain + propagation), so the stale-summary queue is left
+                // intact for the next successful dream cycle. Skipping drain here is
+                // safer than drain-then-fail: the atomic-drain design clears entries
+                // synchronously inside the RMW, so if we drained and then threw
+                // before reaching the catch's re-enqueue, the snapshot would be lost.
             }
             // Step 2: Load dream state
             const dreamState = await this.deps.dreamStateService.read();
@@ -83,23 +94,42 @@ export class DreamExecutor {
                 logId,
                 out: allOperations,
                 projectRoot,
+                reviewDisabled,
                 signal: controller.signal,
                 taskId: options.taskId,
             });
             // Step 5: Post-dream propagation (fail-open)
+            // Two sources of stale summary paths:
+            //   A. The stale-summary queue, drained from dream state — paths from
+            //      curate operations that ran since the last dream cycle (the LLM
+            //      cascade work was deferred from curate's hot path to here).
+            //   B. Dream's own snapshot diff — paths changed by this dream's
+            //      consolidate/synthesize/prune operations.
+            // Merging A ∪ B before calling propagateStaleness lets a path touched
+            // by both sources regenerate exactly once. The queue is drained
+            // atomically (cleared in the same RMW that captures the snapshot) so
+            // any concurrent curate enqueueing during propagation appends a fresh
+            // entry to the now-empty queue and the next dream picks it up.
             if (preState) {
+                let drainedSnapshot = [];
                 try {
+                    drainedSnapshot = await this.deps.dreamStateService.drainStaleSummaryPaths();
                     const postState = await snapshotService.getCurrentState(projectRoot);
                     const changedPaths = diffStates(preState, postState);
-                    if (changedPaths.length > 0) {
-                        const summaryService = new FileContextTreeSummaryService();
-                        await summaryService.propagateStaleness(changedPaths, agent, projectRoot, options.taskId);
-                        const manifestService = new FileContextTreeManifestService({ baseDirectory: projectRoot });
-                        await manifestService.buildManifest(projectRoot);
+                    const merged = [...new Set([...changedPaths, ...drainedSnapshot])];
+                    if (merged.length > 0) {
+                        await this.runStaleSummaryPropagation({ agent, parentTaskId: options.taskId, paths: merged, projectRoot });
                     }
                 }
                 catch {
-                    // Fail-open: propagation errors never block dream
+                    // Fail-open: propagation errors never block dream. Re-enqueue the
+                    // drained snapshot so the next dream cycle retries — atomic drain
+                    // already removed them, so without this they would be lost.
+                    if (drainedSnapshot.length > 0) {
+                        await this.deps.dreamStateService.enqueueStaleSummaryPaths(drainedSnapshot).catch(() => {
+                            // If the re-enqueue itself fails, there is nothing more to do here.
+                        });
+                    }
                 }
             }
             // Step 6: Write dream log
@@ -117,7 +147,7 @@ export class DreamExecutor {
             await this.deps.dreamLogStore.save(completedEntry);
             // Step 6b: Create curate log entries for needsReview operations (dual-write for review system).
             // Runs after the completed dream log is durably written so review tasks never outlive their dream log.
-            await this.createReviewEntries(allOperations, contextTreeDir, options.taskId);
+            await this.createReviewEntries({ contextTreeDir, operations: allOperations, reviewDisabled, taskId: options.taskId });
             reviewEntriesWritten = true;
             // Step 7: Update dream state — atomic RMW under the per-file mutex so a
             // concurrent curate's incrementCurationCount can't be overwritten by the
@@ -130,7 +160,7 @@ export class DreamExecutor {
                 totalDreams: state.totalDreams + 1,
             }));
             succeeded = true;
-            return { logId, result: this.formatResult(logId, summary) };
+            return { logId, result: this.formatResult(logId, summary, reviewDisabled) };
         }
         catch (error) {
             // Save error/partial log entry (best-effort). Use allOperations so any work
@@ -172,7 +202,7 @@ export class DreamExecutor {
             // already wrote the entries (i.e. step 7 threw after step 6b succeeded)
             // to prevent duplicate review items.
             if (allOperations.length > 0 && !reviewEntriesWritten) {
-                await this.createReviewEntries(allOperations, contextTreeDir, options.taskId);
+                await this.createReviewEntries({ contextTreeDir, operations: allOperations, reviewDisabled, taskId: options.taskId });
             }
             throw error;
         }
@@ -193,13 +223,15 @@ export class DreamExecutor {
      * each step. Extracted so the executor can preserve partial work when a later step
      * throws — and so tests can inject controlled ops without a full LLM round-trip.
      */
+    // protected is required for test subclassing (ProbeExecutor, makePartialRunExecutor)
     async runOperations(args) {
-        const { agent, changedFiles, contextTreeDir, logId, out, projectRoot, signal, taskId } = args;
+        const { agent, changedFiles, contextTreeDir, logId, out, projectRoot, reviewDisabled, signal, taskId } = args;
+        const reviewBackupStore = reviewDisabled === true ? undefined : this.deps.reviewBackupStore;
         out.push(...(await consolidate([...changedFiles], {
             agent,
             contextTreeDir,
             dreamStateService: this.deps.dreamStateService,
-            reviewBackupStore: this.deps.reviewBackupStore,
+            reviewBackupStore,
             runtimeSignalStore: this.deps.runtimeSignalStore,
             searchService: this.deps.searchService,
             signal,
@@ -222,12 +254,25 @@ export class DreamExecutor {
             dreamLogId: logId,
             dreamStateService: this.deps.dreamStateService,
             projectRoot,
-            reviewBackupStore: this.deps.reviewBackupStore,
+            reviewBackupStore,
             runtimeSignalStore: this.deps.runtimeSignalStore,
             signal,
             taskId,
         })));
     }
+    /**
+     * Regenerate parent `_index.md` files for the given paths and rebuild the
+     * manifest. Extracted as a seam so tests can override and assert which
+     * paths were passed (the A ∪ B merge in step 5 is the central correctness
+     * invariant of the deferral). Production constructs the services here so
+     * the dependency surface of {@link DreamExecutorDeps} stays narrow.
+     */
+    async runStaleSummaryPropagation(args) {
+        const summaryService = new FileContextTreeSummaryService();
+        await summaryService.propagateStaleness(args.paths, args.agent, args.projectRoot, args.parentTaskId);
+        const manifestService = new FileContextTreeManifestService({ baseDirectory: args.projectRoot });
+        await manifestService.buildManifest(args.projectRoot);
+    }
     /** Errors are tracked at the log level (status='error'), not per-operation — always 0 here. */
     computeSummary(operations) {
         const summary = { consolidated: 0, errors: 0, flaggedForReview: 0, pruned: 0, synthesized: 0 };
@@ -247,10 +292,16 @@ export class DreamExecutor {
      * Dual-write: create curate log entries for dream operations that need human review.
      * This surfaces them in `brv review pending` without modifying the review system.
      */
-    async createReviewEntries(operations, contextTreeDir, taskId) {
+    async createReviewEntries(args) {
+        const { contextTreeDir, operations, reviewDisabled, taskId } = args;
         const reviewOps = operations.filter((op) => op.needsReview);
         if (reviewOps.length === 0)
             return;
+        // Honor `brv review --disable`: when disabled, dream's needsReview ops are not surfaced
+        // through the curate-log dual-write, so they don't appear in `brv review pending`.
+        // The flag is the daemon-stamped snapshot passed in via DreamExecuteOptions.
+        if (reviewDisabled)
+            return;
         const curateOps = reviewOps.map((op) => mapDreamOpToCurateOp(op, contextTreeDir));
         try {
             const logId = await this.deps.curateLogStore.getNextId();
@@ -316,7 +367,7 @@ export class DreamExecutor {
         const results = await Promise.all(checks);
         return new Set(results.filter((f) => f !== null));
     }
-    formatResult(logId, summary) {
+    formatResult(logId, summary, reviewDisabled) {
         const parts = [`Dream completed (${logId})`];
         const counts = [
             summary.consolidated > 0 ? `${summary.consolidated} consolidated` : '',
@@ -332,7 +383,10 @@ export class DreamExecutor {
         if (summary.errors > 0) {
             parts.push(`${summary.errors} operations failed`);
         }
-        if (summary.flaggedForReview > 0) {
+        // Suppress when review is disabled — the count comes from LLM `needsReview` tags
+        // computed before the dual-write gate, so the ops were intentionally not enqueued
+        // and would not appear in `brv review pending`.
+        if (summary.flaggedForReview > 0 && !reviewDisabled) {
             parts.push(`${summary.flaggedForReview} operations flagged for review`);
         }
         return parts.join('\n');

package/dist/server/infra/executor/folder-pack-executor.d.ts

@@ -20,7 +20,17 @@ import type { FolderPackExecuteOptions, IFolderPackExecutor } from '../../core/i
 export declare class FolderPackExecutor implements IFolderPackExecutor {
     private readonly folderPackService;
     constructor(folderPackService: IFolderPackService);
+    /** Synchronous wrapper — runs the agent body and awaits Phase 4 inline. */
     executeWithAgent(agent: ICipherAgent, options: FolderPackExecuteOptions): Promise<string>;
+    /**
+     * Returns the response after the agent body, plus a `finalize` thunk for
+     * Phase 4 (snapshot diff → propagateStaleness → manifest rebuild → drain).
+     * Caller invokes `finalize` exactly once.
+     */
+    runAgentBody(agent: ICipherAgent, options: FolderPackExecuteOptions): Promise<{
+        finalize: () => Promise<void>;
+        response: string;
+    }>;
     /**
      * Build iterative extraction prompt with file-based access.
      * Folder data is stored in a temporary file to avoid token limits.

package/dist/server/infra/executor/folder-pack-executor.js

@@ -1,10 +1,8 @@
 import { appendFileSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { FileContextTreeManifestService } from '../context-tree/file-context-tree-manifest-service.js';
 import { FileContextTreeSnapshotService } from '../context-tree/file-context-tree-snapshot-service.js';
-import { FileContextTreeSummaryService } from '../context-tree/file-context-tree-summary-service.js';
-import { diffStates } from '../context-tree/snapshot-diff.js';
+import { propagateSummariesUnderLock } from '../context-tree/propagate-summaries.js';
 const LOG_PATH = process.env.BRV_SESSION_LOG;
 function folderPackLog(message) {
     if (!LOG_PATH)
@@ -37,7 +35,18 @@ export class FolderPackExecutor {
     constructor(folderPackService) {
         this.folderPackService = folderPackService;
     }
+    /** Synchronous wrapper — runs the agent body and awaits Phase 4 inline. */
     async executeWithAgent(agent, options) {
+        const { finalize, response } = await this.runAgentBody(agent, options);
+        await finalize();
+        return response;
+    }
+    /**
+     * Returns the response after the agent body, plus a `finalize` thunk for
+     * Phase 4 (snapshot diff → propagateStaleness → manifest rebuild → drain).
+     * Caller invokes `finalize` exactly once.
+     */
+    async runAgentBody(agent, options) {
         const { clientCwd, content, folderPath, projectRoot, taskId, worktreeRoot } = options;
         // Resolve folder path:
         // - Absent folderPath → default to worktreeRoot (implicit workspace default)
@@ -71,28 +80,17 @@ export class FolderPackExecutor {
             maxLinesPerFile: 5000, // Limit lines for large files
         });
         // Use iterative extraction strategy (inspired by rlm)
-        // Stores packed folder in sandbox environment and lets agent iteratively query/extract
-        // This avoids token limits entirely - works for folders of any size
         const response = await this.executeIterative(agent, packResult, content, absoluteFolderPath, taskId, tempFileDir);
-        if (preState) {
-            try {
-                const postState = await snapshotService.getCurrentState(tempFileDir);
-                const changedPaths = diffStates(preState, postState);
-                if (changedPaths.length > 0) {
-                    const summaryService = new FileContextTreeSummaryService();
-                    const results = await summaryService.propagateStaleness(changedPaths, agent, tempFileDir, taskId);
-                    if (results.some((result) => result.actionTaken)) {
-                        const manifestService = new FileContextTreeManifestService({ baseDirectory: tempFileDir });
-                        await manifestService.buildManifest(tempFileDir);
-                    }
-                }
-            }
-            catch {
-                // Fail-open: summary/manifest errors never block curation
-            }
-        }
-        await agent.drainBackgroundWork?.();
-        return response;
+        // Build the Phase 4 thunk. Note: unlike CurateExecutor, the task session
+        // was already deleted inside `executeIterative`'s `finally`, so Phase 4's
+        // `propagateStaleness` runs against the agent's default session. That
+        // is fine for folder-pack — it has no per-task sandbox state to preserve
+        // through Phase 4.
+        const finalize = async () => {
+            await propagateSummariesUnderLock({ agent, baseDir: tempFileDir, preState, snapshotService, taskId });
+            await agent.drainBackgroundWork?.();
+        };
+        return { finalize, response };
     }
     /**
      * Build iterative extraction prompt with file-based access.

package/dist/server/infra/git/git-error-messages.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Working-tree-overwrite error messages, unified across pull / merge / checkout
+ * paths. Trailer says "commit or discard" so users know `brv vc reset` is the
+ * escape hatch (brv has no stash).
+ *
+ * The "would be overwritten" anchor is preserved verbatim because vc-handler
+ * pattern-matches on it to map GitError → VcError(UNCOMMITTED_CHANGES).
+ */
+export type OverwriteOperation = 'checkout' | 'merge' | 'pull';
+export declare function formatOverwriteMessage(operation: OverwriteOperation, files: string[]): string;

package/dist/server/infra/git/git-error-messages.js

@@ -0,0 +1,12 @@
+function trailerFor(operation) {
+    const action = operation === 'checkout' ? 'switch branches' : operation;
+    return `Please commit or discard your changes before you ${action}.`;
+}
+export function formatOverwriteMessage(operation, files) {
+    const trailer = trailerFor(operation);
+    if (files.length === 0) {
+        return `Your local changes would be overwritten by ${operation}. ${trailer}`;
+    }
+    const list = files.map((f) => `\t${f}`).join('\n');
+    return `Your local changes to the following files would be overwritten by ${operation}:\n${list}\n${trailer}`;
+}

package/dist/server/infra/git/isomorphic-git-service.js

@@ -3,7 +3,9 @@ import fs from 'node:fs';
 import { join } from 'node:path';
 import { hasConflictMarkers } from '../../../shared/utils/conflict-markers.js';
 import { GitAuthError, GitError } from '../../core/domain/errors/git-error.js';
+import { formatOverwriteMessage } from './git-error-messages.js';
 import { gitHttpWrapper as http } from './git-http-wrapper.js';
+import { classifyTuple } from './status-row-classifier.js';
 /** Max commit depth for ahead/behind calculation. Counts beyond this are truncated. */
 const MAX_AHEAD_BEHIND_DEPTH = 500;
 export class IsomorphicGitService {
@@ -124,8 +126,7 @@ export class IsomorphicGitService {
         }
         catch (error) {
             if (error instanceof git.Errors.CheckoutConflictError) {
-                throw new GitError('Your local changes to the following files would be overwritten by checkout. ' +
-                    'Commit your changes or stash them before you switch branches.');
+                throw new GitError(formatOverwriteMessage('checkout', []));
             }
             throw error;
         }
@@ -512,7 +513,7 @@ export class IsomorphicGitService {
                 if (localSha && currentBranch) {
                     await git.writeRef({ dir, force: true, fs, ref: `refs/heads/${currentBranch}`, value: localSha });
                 }
-                throw new GitError('Local changes would be overwritten by merge. Commit or discard your changes first.');
+                throw new GitError(formatOverwriteMessage('merge', []));
             }
             if (error instanceof git.Errors.MergeConflictError) {
                 // isomorphic-git does not write MERGE_HEAD/MERGE_MSG — write them so
@@ -580,7 +581,9 @@ export class IsomorphicGitService {
         // Abort if any dirty local file would be overwritten by the incoming changes
         if (localSha && remoteSha) {
             const matrix = await git.statusMatrix({ dir, fs });
-            const dirtyFiles = matrix.filter((row) => row[2] !== 1 || row[3] !== 1).map((row) => String(row[0]));
+            const dirtyFiles = matrix
+                .filter(([, head, workdir, stage]) => classifyTuple(head, workdir, stage).dirty)
+                .map((row) => String(row[0]));
             const localRef = localSha;
             const remoteRef = remoteSha;
             const wouldBeOverwritten = await Promise.all(dirtyFiles.map(async (filepath) => {
@@ -596,8 +599,9 @@ export class IsomorphicGitService {
                 ]);
                 return localFileOid !== remoteFileOid;
             }));
-            if (wouldBeOverwritten.some(Boolean)) {
-                throw new GitError('Local changes would be overwritten by pull. Commit or discard your changes first.');
+            const overwrittenFiles = dirtyFiles.filter((_, i) => wouldBeOverwritten[i]);
+            if (overwrittenFiles.length > 0) {
+                throw new GitError(formatOverwriteMessage('pull', overwrittenFiles));
             }
         }
         const author = params.author ?? this.getAuthor();
@@ -646,7 +650,7 @@ export class IsomorphicGitService {
                 if (localSha) {
                     await git.writeRef({ dir, force: true, fs, ref: `refs/heads/${localBranch}`, value: localSha });
                 }
-                throw new GitError('Local changes would be overwritten by pull. Commit or discard your changes first.');
+                throw new GitError(formatOverwriteMessage('pull', []));
             }
             throw error;
         }
@@ -789,26 +793,14 @@ export class IsomorphicGitService {
         return results.filter((r) => r !== undefined).sort((a, b) => a.path.localeCompare(b.path));
     }
     classifyStagedRow(row) {
-        const [filepath, head, , stage] = row;
-        const path = String(filepath);
-        if (head === 0 && (stage === 2 || stage === 3))
-            return { path, status: 'added' };
-        if (head === 1 && stage === 0)
-            return { path, status: 'deleted' };
-        if (head === 1 && (stage === 2 || stage === 3))
-            return { path, status: 'modified' };
-        return undefined;
+        const [filepath, head, workdir, stage] = row;
+        const status = classifyTuple(head, workdir, stage).stagedDiff;
+        return status ? { path: String(filepath), status } : undefined;
     }
     classifyUnstagedRow(row) {
         const [filepath, head, workdir, stage] = row;
-        const path = String(filepath);
-        if (head === 0 && stage === 0)
-            return undefined; // skip untracked
-        if (workdir === 0 && (stage === 1 || stage === 2 || stage === 3))
-            return { path, status: 'deleted' };
-        if (workdir === 2 && (stage === 1 || stage === 3))
-            return { path, status: 'modified' };
-        return undefined;
+        const status = classifyTuple(head, workdir, stage).unstagedDiff;
+        return status ? { path: String(filepath), status } : undefined;
     }
     conflictsFromError(error) {
         if (!IsomorphicGitService.isConflictError(error))
@@ -869,9 +861,9 @@ export class IsomorphicGitService {
      */
     async guardStagedConflicts(dir, sourceBranch, targetRef) {
         const matrix = await git.statusMatrix({ dir, fs });
-        // Staged files: index (col 3) differs from HEAD (col 1)
-        // [1,_,2] modified+staged, [1,_,0] deleted+staged, [0,_,2] new+staged
-        const stagedFiles = matrix.filter(([, head, , stage]) => stage !== head).map(([filepath]) => String(filepath));
+        const stagedFiles = matrix
+            .filter(([, head, workdir, stage]) => classifyTuple(head, workdir, stage).staged)
+            .map(([filepath]) => String(filepath));
         if (stagedFiles.length === 0)
             return;
         const sourceOid = await git.resolveRef({ dir, fs, ref: sourceBranch });
@@ -887,9 +879,7 @@ export class IsomorphicGitService {
         }
         /* eslint-enable no-await-in-loop */
         if (conflicting.length > 0) {
-            throw new GitError('Your local changes to the following files would be overwritten by checkout:\n' +
-                conflicting.map((f) => `\t${f}`).join('\n') +
-                '\nPlease commit your changes or stash them before you switch branches.');
+            throw new GitError(formatOverwriteMessage('checkout', conflicting));
         }
     }
     async hashWorkdirFile(dir, path) {
@@ -1031,46 +1021,14 @@ export class IsomorphicGitService {
         });
         return { success: true };
     }
-    // eslint-disable-next-line complexity
     parseMatrix(matrix) {
         const files = [];
         for (const [filepath, head, workdir, stage] of matrix) {
             const path = String(filepath);
-            if (head === 1 && workdir === 0 && stage === 0) {
-                files.push({ path, staged: true, status: 'deleted' }); // [1,0,0] staged deletion (git rm)
-            }
-            else if (head === 1 && workdir === 0 && stage === 1) {
-                files.push({ path, staged: false, status: 'deleted' }); // [1,0,1] unstaged deletion (rm without git rm)
-            }
-            else if (head === 1 && workdir === 0 && stage === 2) {
-                files.push({ path, staged: false, status: 'deleted' }); // [1,0,2] absent from disk, index differs from HEAD (e.g. post-merge-conflict)
-            }
-            else if (head === 1 && workdir === 0 && stage === 3) {
-                // [1,0,3] staged modification then deleted from disk → show both staged mod and unstaged deletion
-                files.push({ path, staged: true, status: 'modified' }, { path, staged: false, status: 'deleted' });
-            }
-            else if (head === 1 && workdir === 1 && stage === 0) {
-                files.push({ path, staged: true, status: 'deleted' }, { path, staged: false, status: 'untracked' }); // [1,1,0] git rm --cached: staged deletion + file still in workdir → untracked
-            }
-            else if (head === 1 && workdir === 2 && stage === 1) {
-                files.push({ path, staged: false, status: 'modified' }); // [1,2,1] unstaged modification
-            }
-            else if (head === 1 && workdir === 2 && stage === 2) {
-                files.push({ path, staged: true, status: 'modified' }); // [1,2,2] staged modification
+            const classification = classifyTuple(head, workdir, stage);
+            for (const entry of classification.files) {
+                files.push({ path, staged: entry.staged, status: entry.status });
             }
-            else if (head === 1 && workdir === 2 && stage === 3) {
-                files.push({ path, staged: true, status: 'modified' }, { path, staged: false, status: 'modified' }); // [1,2,3] partially staged modification
-            }
-            else if (head === 0 && workdir === 2 && stage === 0) {
-                files.push({ path, staged: false, status: 'untracked' }); // [0,2,0] untracked new file
-            }
-            else if (head === 0 && workdir === 2 && stage === 2) {
-                files.push({ path, staged: true, status: 'added' }); // [0,2,2] staged new file
-            }
-            else if (head === 0 && workdir === 2 && stage === 3) {
-                files.push({ path, staged: true, status: 'added' }, { path, staged: false, status: 'modified' }); // [0,2,3] partially staged new file
-            }
-            // [1,1,1] unmodified → skip
         }
         return files;
     }
@@ -1143,17 +1101,7 @@ export class IsomorphicGitService {
         const headSha = await git.resolveRef({ dir, fs, ref: 'HEAD' }).catch(() => null);
         const matrix = await git.statusMatrix({ dir, fs });
         // Identify staged rows — any file where the index differs from HEAD
-        const stagedRows = matrix.filter(([, head, , stage]) => {
-            if (head === 1 && stage === 0)
-                return true; // staged deletion or git rm --cached ([1,0,0] and [1,1,0])
-            if (head === 0 && stage === 2)
-                return true; // staged new file ([0,2,2])
-            if (head === 1 && stage === 2)
-                return true; // staged modification ([1,2,2])
-            if (stage === 3)
-                return true; // partially staged ([*,*,3])
-            return false;
-        });
+        const stagedRows = matrix.filter(([, head, workdir, stage]) => classifyTuple(head, workdir, stage).staged);
         const toUnstage = filePaths && filePaths.length > 0
             ? stagedRows
                 .filter(([filepath]) => {

package/dist/server/infra/git/status-row-classifier.d.ts

@@ -0,0 +1,32 @@
+import type { ChangedFile, GitStatusFile } from '../../core/interfaces/services/i-git-service.js';
+/** Status entry projected to status() output. The caller adds `path`. */
+export type StatusEntry = Pick<GitStatusFile, 'staged' | 'status'>;
+/**
+ * Classification of a single statusMatrix row's `[head, workdir, stage]` tuple,
+ * shared across every consumer of `git.statusMatrix`. Six call sites used to
+ * derive their own dirty/staged/diff projections from raw column comparisons;
+ * routing every consumer through this single classifier is what guarantees
+ * they all agree on what each tuple means.
+ */
+export type RowClassification = {
+    /** True for any tuple other than `[1,1,1]`. Drives `status.isClean` and `pull`'s overwrite check. */
+    dirty: boolean;
+    /**
+     * Status entries for `status()` output. The caller attaches the path. 0-2
+     * entries per row, ordered staged-first then unstaged.
+     */
+    files: StatusEntry[];
+    /** True when `stage !== head`. Drives `guardStagedConflicts` and `resetUnstage`. */
+    staged: boolean;
+    /** HEAD->INDEX diff for `brv vc diff --staged`. Undefined when INDEX matches HEAD. */
+    stagedDiff?: ChangedFile['status'];
+    /** INDEX->WORKDIR diff for `brv vc diff` (default). Undefined when WORKDIR matches INDEX. */
+    unstagedDiff?: ChangedFile['status'];
+};
+/**
+ * Classify a `[head, workdir, stage]` tuple from `git.statusMatrix` into the
+ * shared projection. Total over the encoding's value range; throws only when
+ * a column is outside that range, which is the cleanest signal that upstream
+ * changed the encoding shape.
+ */
+export declare function classifyTuple(h: number, w: number, s: number): RowClassification;

package/dist/server/infra/git/status-row-classifier.js

@@ -0,0 +1,78 @@
+import { GitError } from '../../core/domain/errors/git-error.js';
+/**
+ * isomorphic-git statusMatrix encoding:
+ *   HEAD    (h): 0 = absent,           1 = present
+ *   WORKDIR (w): 0 = absent,           1 = matches HEAD,    2 = differs from HEAD
+ *   STAGE   (s): 0 = absent,           1 = matches HEAD,    2 = matches WORKDIR,    3 = differs from both
+ *
+ * The XY columns native git derives from these are:
+ *   staged column   = HEAD vs INDEX
+ *   unstaged column = INDEX vs WORKDIR
+ * The two helpers below project the encoding into those two columns.
+ */
+function stagedDiffFor(h, s) {
+    if (h === 0 && s === 0)
+        return undefined; // not tracked anywhere
+    if (h === 1 && s === 0)
+        return 'deleted'; // HEAD has it, INDEX doesn't
+    if (h === 0)
+        return 'added'; // h=0, s>0
+    if (s === 1)
+        return undefined; // INDEX matches HEAD, no staged change
+    return 'modified'; // h=1, s in {2,3}: INDEX differs from HEAD
+}
+function unstagedDiffFor(s, w) {
+    if (s === 0)
+        return undefined; // INDEX absent: file is either gone or untracked, not a diff
+    if (w === 0)
+        return 'deleted'; // s>0, WORKDIR absent: INDEX has a blob, disk does not
+    // (s=2,w=0) is unreachable by the encoding (s=2 means INDEX==WORKDIR, so WORKDIR
+    // absent forces INDEX absent => s=0); the w===0 guard above handles it safely either way.
+    if (s === 2)
+        return undefined; // INDEX matches WORKDIR by definition
+    if (s === 1 && w === 1)
+        return undefined; // INDEX=HEAD and WORKDIR=HEAD => INDEX=WORKDIR transitively
+    return 'modified'; // s=1,w=2  or  s=3,w>0
+}
+function validateEncoding(h, w, s) {
+    if (h !== 0 && h !== 1) {
+        throw new GitError(`HEAD column out of range: ${h}; isomorphic-git encoding may have changed`);
+    }
+    if (w !== 0 && w !== 1 && w !== 2) {
+        throw new GitError(`WORKDIR column out of range: ${w}; isomorphic-git encoding may have changed`);
+    }
+    if (s !== 0 && s !== 1 && s !== 2 && s !== 3) {
+        throw new GitError(`STAGE column out of range: ${s}; isomorphic-git encoding may have changed`);
+    }
+}
+/**
+ * Classify a `[head, workdir, stage]` tuple from `git.statusMatrix` into the
+ * shared projection. Total over the encoding's value range; throws only when
+ * a column is outside that range, which is the cleanest signal that upstream
+ * changed the encoding shape.
+ */
+export function classifyTuple(h, w, s) {
+    validateEncoding(h, w, s);
+    const stagedDiff = stagedDiffFor(h, s);
+    const unstagedDiff = unstagedDiffFor(s, w);
+    const untracked = s === 0 && w > 0;
+    const files = [];
+    if (stagedDiff)
+        files.push({ staged: true, status: stagedDiff });
+    if (untracked) {
+        files.push({ staged: false, status: 'untracked' });
+    }
+    else if (unstagedDiff) {
+        files.push({ staged: false, status: unstagedDiff });
+    }
+    return {
+        // Every tuple except clean [1,1,1]. Note: [0,0,0] (file absent everywhere) would
+        // evaluate true here with files=[], but is unreachable in practice because
+        // statusMatrix won't emit a row for a file absent from HEAD, INDEX, and WORKDIR.
+        dirty: !(h === 1 && w === 1 && s === 1),
+        files,
+        staged: stagedDiff !== undefined,
+        stagedDiff,
+        unstagedDiff,
+    };
+}

package/dist/server/infra/process/curate-log-handler.d.ts

@@ -31,6 +31,9 @@ export declare class CurateLogHandler implements ITaskLifecycleHook {
     /**
      * @param createStore - Optional factory for testing. Default: FileCurateLogStore.
      * @param onPendingReviews - Optional callback fired when curate completes with pending review ops.
+     *
+     * Whether reviews are disabled is read directly from `task.reviewDisabled` (snapshotted by
+     * the daemon at task-create time). Undefined means review enabled (fail-open).
      */
     constructor(createStore?: ((projectPath: string) => ICurateLogStore) | undefined, onPendingReviews?: ((info: PendingReviewsInfo) => void) | undefined);
     cleanup(taskId: string): void;

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

@@ -53,6 +53,9 @@ export class CurateLogHandler {
     /**
      * @param createStore - Optional factory for testing. Default: FileCurateLogStore.
      * @param onPendingReviews - Optional callback fired when curate completes with pending review ops.
+     *
+     * Whether reviews are disabled is read directly from `task.reviewDisabled` (snapshotted by
+     * the daemon at task-create time). Undefined means review enabled (fail-open).
      */
     constructor(createStore, onPendingReviews) {
         this.createStore = createStore;
@@ -155,7 +158,8 @@ export class CurateLogHandler {
         // Caching `entry` here lets onTaskCompleted/onTaskError rebuild the final entry
         // without a getById round-trip — so completion is never lost even if this initial
         // save fails.
-        this.tasks.set(task.taskId, { entry, operations: [], projectPath: task.projectPath });
+        const reviewDisabled = task.reviewDisabled ?? false;
+        this.tasks.set(task.taskId, { entry, operations: [], projectPath: task.projectPath, reviewDisabled });
         this.activeTaskCount.set(task.projectPath, (this.activeTaskCount.get(task.projectPath) ?? 0) + 1);
         // Fire-and-forget: logId is already known, save is best-effort.
         // Callers receive logId immediately without waiting for disk I/O.
@@ -187,7 +191,7 @@ export class CurateLogHandler {
             return;
         const ops = extractCurateOperations(payload);
         for (const op of ops) {
-            if (op.needsReview && op.status === 'success') {
+            if (op.needsReview && op.status === 'success' && !state.reviewDisabled) {
                 op.reviewStatus = 'pending';
             }
             // Deduplicate by filePath: keep only the latest operation per file.

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

@@ -167,6 +167,7 @@ export async function setupFeatureHandlers({ authStateStore, broadcastToProject,
         onResolved({ projectPath, taskId }) {
             broadcastToProject(projectPath, ReviewEvents.NOTIFY, { pendingCount: 0, reviewUrl: '', taskId });
         },
+        projectConfigStore,
         resolveProjectPath,
         reviewBackupStoreFactory: (projectPath) => new FileReviewBackupStore(join(projectPath, BRV_DIR)),
         transport,