byterover-cli 3.10.0 → 3.10.1

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

@@ -28,6 +28,7 @@ import { FileSystemService } from '../../../agent/infra/file-system/file-system-
 import { FolderPackService } from '../../../agent/infra/folder-pack/folder-pack-service.js';
 import { SessionMetadataStore } from '../../../agent/infra/session/session-metadata-store.js';
 import { FileKeyStorage } from '../../../agent/infra/storage/file-key-storage.js';
+import { runWithReviewDisabled } from '../../../agent/infra/tools/implementations/curate-tool-task-context.js';
 import { createSearchKnowledgeService } from '../../../agent/infra/tools/implementations/search-knowledge-service.js';
 import { AuthEvents } from '../../../shared/transport/events/auth-events.js';
 import { decodeSearchContent } from '../../../shared/transport/search-content.js';
@@ -51,6 +52,7 @@ import { FileCurateLogStore } from '../storage/file-curate-log-store.js';
 import { FileReviewBackupStore } from '../storage/file-review-backup-store.js';
 import { AgentInstanceDiscovery } from '../transport/agent-instance-discovery.js';
 import { createAgentLogger } from './agent-logger.js';
+import { PostWorkRegistry } from './post-work-registry.js';
 import { resolveSessionId } from './session-resolver.js';
 import { validateProviderForTask } from './task-validation.js';
 // ============================================================================
@@ -73,6 +75,15 @@ if (!portEnv || !projectPathEnv) {
 const port = portEnv;
 const projectPath = projectPathEnv;
 const agentLog = createAgentLogger(process.env.BRV_SESSION_LOG, `[agent-process:${projectPath}]`);
+/**
+ * Holds detached post-curate work so `task:completed` can fire as soon as
+ * the agent body finishes. Drained on shutdown to avoid truncated writes.
+ */
+const postWorkRegistry = new PostWorkRegistry({
+    onError(_projectPath, error) {
+        agentLog(`post-work error: ${error instanceof Error ? error.message : String(error)}`);
+    },
+});
 /**
  * Persist a brand-new session's metadata and set it as active.
  * Best-effort — failures are logged but never block the caller.
@@ -345,7 +356,7 @@ async function start() {
     agentLog('Ready — listening for tasks');
 }
 async function executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor, searchKnowledgeService, storagePath, runtimeSignalStore) {
-    const { clientCwd, clientId, content, files, folderPath, force, taskId, trigger, type, worktreeRoot } = task;
+    const { clientCwd, clientId, content, files, folderPath, force, reviewDisabled, taskId, trigger, type, worktreeRoot } = task;
     if (!transport || !agent)
         return;
     // Search tasks are pure BM25 retrieval — no LLM, no provider needed.
@@ -359,7 +370,19 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
         }
     }
     activeTaskCount++;
-    try {
+    // Body of the task — extracted so the daemon-stamped reviewDisabled snapshot can be
+    // opened as an AsyncLocalStorage scope around it. Tools that run inside this task
+    // (curate-tool.executeCurate, including the sandbox `tools.curate(...)` path via
+    // CurateService where _context.taskId is not threaded through) read the snapshot
+    // from the ALS scope instead of re-reading .brv/config.json — that read can race
+    // with mid-task user toggles, which is exactly the inconsistency we are eliminating.
+    // We only open the scope when the daemon stamped a value; otherwise consumers fall
+    // back to the file read, preserving behavior for legacy clients without a stamp.
+    const runTaskBody = async () => {
+        // Re-narrow inside the closure: TypeScript loses the function-scope narrowing
+        // from the early-return guard above once we hand control to a callback.
+        if (!transport || !agent)
+            return;
         // Only refresh config and hot-swap provider when this is the first concurrent task.
         // Subsequent concurrent tasks reuse cached config to avoid race conditions
         // on provider hot-swap (which replaces SessionManager).
@@ -412,12 +435,23 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
             agentLog(`task:started send failed taskId=${taskId}: ${error instanceof Error ? error.message : String(error)}`);
             // Socket dropped — continue executing so we can still emit task:completed/error when socket reconnects
         }
+        // Block new tree-writers until any detached Phase 4 from a prior task
+        // on this project drains. `query` / `search` are intentionally NOT
+        // gated — they read the manifest and tolerate a stale snapshot via
+        // `readManifestIfFresh` + rebuild fallback, so blocking them would
+        // be a needless latency hit.
+        if (type === 'curate' || type === 'curate-folder' || type === 'dream') {
+            await postWorkRegistry.awaitProject(projectPath);
+        }
         try {
             let result;
             let logId;
+            // Captured during curate / curate-folder; submitted to the registry
+            // after `task:completed` so the user does not wait on Phase 4.
+            let postWork;
             switch (type) {
                 case 'curate': {
-                    result = await curateExecutor.executeWithAgent(agent, {
+                    const curateResult = await curateExecutor.runAgentBody(agent, {
                         clientCwd,
                         content,
                         files,
@@ -425,10 +459,12 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
                         taskId,
                         worktreeRoot,
                     });
+                    result = curateResult.response;
+                    postWork = curateResult.finalize;
                     break;
                 }
                 case 'curate-folder': {
-                    result = await folderPackExecutor.executeWithAgent(agent, {
+                    const folderResult = await folderPackExecutor.runAgentBody(agent, {
                         clientCwd,
                         content,
                         folderPath: folderPath,
@@ -436,6 +472,8 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
                         taskId,
                         worktreeRoot,
                     });
+                    result = folderResult.response;
+                    postWork = folderResult.finalize;
                     break;
                 }
                 case 'dream': {
@@ -470,6 +508,7 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
                     const dreamResult = await dreamExecutor.executeWithAgent(agent, {
                         priorMtime: eligibility.priorMtime,
                         projectRoot: projectPath,
+                        ...(reviewDisabled === undefined ? {} : { reviewDisabled }),
                         taskId,
                         trigger: trigger ?? 'cli',
                     });
@@ -503,7 +542,8 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
                     break;
                 }
             }
-            // Emit task:completed
+            // Emit task:completed BEFORE the detached Phase 4 so the user sees
+            // the response as soon as the agent body finishes.
             agentLog(`task:completed taskId=${taskId}`);
             try {
                 transport.request(TransportTaskEventNames.COMPLETED, { clientId, ...(logId ? { logId } : {}), projectPath, result, taskId });
@@ -511,6 +551,12 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
             catch (error) {
                 agentLog(`task:completed send failed taskId=${taskId}: ${error instanceof Error ? error.message : String(error)}`);
             }
+            // Submit detached post-curate work to the registry. Mutex'd per project
+            // and drained on shutdown so SIGTERM mid-work cannot truncate `_index.md`.
+            if (postWork) {
+                agentLog(`post-work queued taskId=${taskId}`);
+                postWorkRegistry.submit(projectPath, postWork);
+            }
         }
         catch (error) {
             // Emit task:error
@@ -526,13 +572,27 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
         finally {
             cleanupForwarding?.();
         }
+    };
+    try {
+        await (reviewDisabled === undefined ? runTaskBody() : runWithReviewDisabled(reviewDisabled, runTaskBody));
     }
     finally {
         activeTaskCount--;
-        // Deferred hot-swap: if provider changed while tasks were in-flight,
-        // trigger swap now that all tasks are done
+        // Deferred hot-swap when provider changed mid-task. Wait on detached
+        // Phase 4 first — rebuilding SessionManager during an in-flight
+        // `propagateStaleness` LLM call would silently corrupt Phase 4.
+        // Reserve the swap slot synchronously by clearing the dirty flag now;
+        // a task arriving during the awaitAll wait then sees a clean flag and
+        // skips its inline swap, so only the deferred chain runs hotSwap.
         if (activeTaskCount === 0 && providerConfigDirty && agent && transport) {
-            hotSwapProvider(agent, transport).catch((error) => {
+            providerConfigDirty = false;
+            const swapAgent = agent;
+            const swapTransport = transport;
+            postWorkRegistry
+                .awaitAll()
+                .then(() => hotSwapProvider(swapAgent, swapTransport))
+                .catch((error) => {
+                providerConfigDirty = true;
                 agentLog(`deferred hotSwapProvider failed: ${error instanceof Error ? error.message : String(error)}`);
             });
         }
@@ -663,6 +723,16 @@ async function hotSwapProvider(currentAgent, transportClient) {
 // ============================================================================
 async function shutdown() {
     agentLog('Shutting down...');
+    // Drain detached Phase 4 BEFORE stopping the agent — `propagateStaleness`
+    // mid-write would otherwise leave `_index.md` truncated on SIGTERM.
+    try {
+        const drainStart = Date.now();
+        const drainResult = await postWorkRegistry.drain(30_000);
+        agentLog(`post-work drain (${Date.now() - drainStart}ms): drained=${drainResult.drained} abandoned=${drainResult.abandoned}`);
+    }
+    catch (error) {
+        agentLog(`post-work drain failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
     try {
         if (agent) {
             await agent.stop();

package/dist/server/infra/daemon/brv-server.js

@@ -224,6 +224,15 @@ async function main() {
         });
         // Shared queue-length resolver — used by both idle timeout policy and dream trigger
         const getQueueLength = (projectPath) => agentPool?.getQueueState().find((q) => q.projectPath === projectPath)?.queueLength ?? 0;
+        // Shared project-config resolver — used by the idle-dream dispatch and the
+        // task-router resolver wired into TransportHandlers below. Both paths must
+        // stamp the same reviewDisabled value so review semantics are consistent
+        // regardless of dispatch source (CLI task:create vs idle trigger).
+        const curateConfigStore = new ProjectConfigStore();
+        const resolveReviewDisabled = async (projectPath) => {
+            const config = await curateConfigStore.read(projectPath);
+            return config?.reviewDisabled === true;
+        };
         // Shared dream pre-check trigger factory.
         // The lock service explicitly throws if invoked — gate 4 (lock) is the agent's job;
         // the daemon must only ever evaluate gates 1-3 via checkEligibility().
@@ -259,11 +268,18 @@ async function main() {
                     const result = await makeDreamPreCheckTrigger(projectPath).checkEligibility(projectPath);
                     if (result.eligible) {
                         log(`Dream eligible, dispatching dream task: ${projectPath}`);
+                        // Idle dispatch bypasses TaskRouter.handleTaskCreate, so the
+                        // reviewDisabled snapshot that the task-router stamps for the CLI
+                        // path must be reproduced inline here. Without it, idle dreams
+                        // would always default to review-enabled regardless of project
+                        // setting (see resolveReviewDisabled above).
+                        const reviewDisabled = await resolveReviewDisabled(projectPath);
                         agentPool?.submitTask({
                             clientId: 'daemon',
                             content: 'Memory consolidation (idle trigger)',
                             force: false,
                             projectPath,
+                            reviewDisabled,
                             taskId: randomUUID(),
                             trigger: 'agent-idle',
                             type: 'dream',
@@ -321,6 +337,13 @@ async function main() {
         const transportHandlers = new TransportHandlers({
             agentPool,
             clientManager,
+            // Resolves the project's review-disabled flag once at task-create. The result
+            // is stamped onto TaskInfo + TaskExecute so daemon hooks (CurateLogHandler) and
+            // the agent process (curate-tool backups, dream review entries) all observe a
+            // single value across the daemon→agent process boundary. Shared with the
+            // idle-dream dispatch above so review semantics are identical regardless of
+            // dispatch source (CLI task:create vs agent-idle trigger).
+            isReviewDisabled: resolveReviewDisabled,
             lifecycleHooks: [curateLogHandler, queryLogHandler],
             // Daemon-side gate for dream task:create — mirrors the idle-trigger pre-check
             // in this file so the CLI path (brv dream without --force) actually honors

package/dist/server/infra/daemon/post-work-registry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Per-project serialized fire-and-forget queue with bounded shutdown drain.
+ * Different projects run concurrently; same project runs serially so two
+ * writers cannot race on `_index.md`. Thunk errors are swallowed (via
+ * `onError`) so one bad thunk cannot block the chain.
+ */
+export type PostWorkThunk = () => Promise<void>;
+export type PostWorkRegistryOptions = {
+    onError?: (projectPath: string, error: unknown) => void;
+};
+export declare class PostWorkRegistry {
+    /** Optional logger called when a thunk throws. */
+    private readonly onError?;
+    /**
+     * Per-project tail promise. Each `submit(project, thunk)` chains the new
+     * thunk after the previous tail. The tail is replaced atomically so the
+     * next submission picks up the latest one without races.
+     */
+    private readonly tails;
+    constructor(options?: PostWorkRegistryOptions);
+    /**
+     * Wait on the snapshot of tails captured at call time across all projects.
+     * Submissions arriving during the await are not awaited.
+     */
+    awaitAll(): Promise<void>;
+    /**
+     * Wait on the project's tail captured at call time. Submissions arriving
+     * during the await are not awaited — keeps `--wait-finalize` deterministic.
+     */
+    awaitProject(projectPath: string): Promise<void>;
+    /**
+     * Wait up to `timeoutMs` for in-flight work across all projects.
+     * Errored thunks count as `drained` (work resolved, surfaced to onError);
+     * thunks still running at the deadline count as `abandoned`.
+     */
+    drain(timeoutMs: number): Promise<{
+        abandoned: number;
+        drained: number;
+    }>;
+    /**
+     * Submit a thunk to run after any prior work for `projectPath` finishes.
+     * Returns synchronously; the thunk runs on the microtask queue.
+     */
+    submit(projectPath: string, thunk: PostWorkThunk): void;
+}

package/dist/server/infra/daemon/post-work-registry.js

@@ -0,0 +1,82 @@
+/**
+ * Per-project serialized fire-and-forget queue with bounded shutdown drain.
+ * Different projects run concurrently; same project runs serially so two
+ * writers cannot race on `_index.md`. Thunk errors are swallowed (via
+ * `onError`) so one bad thunk cannot block the chain.
+ */
+export class PostWorkRegistry {
+    /** Optional logger called when a thunk throws. */
+    onError;
+    /**
+     * Per-project tail promise. Each `submit(project, thunk)` chains the new
+     * thunk after the previous tail. The tail is replaced atomically so the
+     * next submission picks up the latest one without races.
+     */
+    tails = new Map();
+    constructor(options = {}) {
+        this.onError = options.onError;
+    }
+    /**
+     * Wait on the snapshot of tails captured at call time across all projects.
+     * Submissions arriving during the await are not awaited.
+     */
+    async awaitAll() {
+        const tails = [...this.tails.values()];
+        if (tails.length === 0)
+            return;
+        await Promise.all(tails);
+    }
+    /**
+     * Wait on the project's tail captured at call time. Submissions arriving
+     * during the await are not awaited — keeps `--wait-finalize` deterministic.
+     */
+    async awaitProject(projectPath) {
+        const tail = this.tails.get(projectPath);
+        if (tail) {
+            await tail;
+        }
+    }
+    /**
+     * Wait up to `timeoutMs` for in-flight work across all projects.
+     * Errored thunks count as `drained` (work resolved, surfaced to onError);
+     * thunks still running at the deadline count as `abandoned`.
+     */
+    async drain(timeoutMs) {
+        const tails = [...this.tails.values()];
+        if (tails.length === 0) {
+            return { abandoned: 0, drained: 0 };
+        }
+        let timeoutHandle;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutHandle = setTimeout(() => resolve('timeout'), timeoutMs);
+        });
+        const results = await Promise.all(tails.map(async (tail) => {
+            const outcome = await Promise.race([tail.then(() => 'done'), timeoutPromise]);
+            return outcome;
+        }));
+        if (timeoutHandle !== undefined)
+            clearTimeout(timeoutHandle);
+        const drained = results.filter((r) => r === 'done').length;
+        const abandoned = results.filter((r) => r === 'timeout').length;
+        return { abandoned, drained };
+    }
+    /**
+     * Submit a thunk to run after any prior work for `projectPath` finishes.
+     * Returns synchronously; the thunk runs on the microtask queue.
+     */
+    submit(projectPath, thunk) {
+        const previousTail = this.tails.get(projectPath) ?? Promise.resolve();
+        const newTail = previousTail
+            .then(thunk)
+            .catch((error) => {
+            this.onError?.(projectPath, error);
+        })
+            .finally(() => {
+            // Drop the map entry only if no follow-up submission appended.
+            if (this.tails.get(projectPath) === newTail) {
+                this.tails.delete(projectPath);
+            }
+        });
+        this.tails.set(projectPath, newTail);
+    }
+}

package/dist/server/infra/dream/dream-lock-service.d.ts

@@ -3,10 +3,9 @@ type DreamLockServiceOptions = {
     staleTimeoutMs?: number;
 };
 /**
- * PID-based lock for dream execution.
- *
- * Lock file contains the owning process PID. Staleness is determined by mtime.
- * Uses write-then-verify to handle race conditions between concurrent acquirers.
+ * PID-based file lock for context-tree writers (dream and curate's detached
+ * post-work). Lock file holds the owner PID; staleness is mtime-based. Uses
+ * write-then-verify to settle races between concurrent acquirers.
  */
 export declare class DreamLockService {
     private readonly lockFilePath;

package/dist/server/infra/dream/dream-lock-service.js

@@ -3,10 +3,9 @@ import { dirname, join } from 'node:path';
 const LOCK_FILENAME = 'dream.lock';
 const DEFAULT_STALE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 /**
- * PID-based lock for dream execution.
- *
- * Lock file contains the owning process PID. Staleness is determined by mtime.
- * Uses write-then-verify to handle race conditions between concurrent acquirers.
+ * PID-based file lock for context-tree writers (dream and curate's detached
+ * post-work). Lock file holds the owner PID; staleness is mtime-based. Uses
+ * write-then-verify to settle races between concurrent acquirers.
  */
 export class DreamLockService {
     lockFilePath;

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

@@ -28,7 +28,19 @@ export declare class CurateExecutor implements ICurateExecutor {
     private readonly fileContentReader;
     private readonly preCompactionService;
     constructor(fileContentReader?: FileContentReader);
+    /** Synchronous wrapper — runs Phases 1-3 and awaits Phase 4 inline. */
     executeWithAgent(agent: ICipherAgent, options: CurateExecuteOptions): Promise<string>;
+    /**
+     * Returns the response after Phases 1-3 plus a `finalize` thunk for Phase 4
+     * (snapshot diff, summary regen, manifest rebuild, dream counter, drain,
+     * task-session cleanup). Caller invokes `finalize` exactly once. The thunk
+     * is fail-open. If the agent body itself throws, the task session is cleaned
+     * up before propagating and no `finalize` is returned.
+     */
+    runAgentBody(agent: ICipherAgent, options: CurateExecuteOptions): Promise<{
+        finalize: () => Promise<void>;
+        response: string;
+    }>;
     /**
      * Format file contents for inclusion in the prompt.
      */
@@ -37,6 +49,11 @@ export declare class CurateExecutor implements ICurateExecutor {
      * Get human-readable label for file type.
      */
     private getFileTypeLabel;
+    /**
+     * Phase 4d: bump the dream-state curation counter. Fail-open — dream state
+     * tracking is non-critical and must never block curate completion.
+     */
+    private incrementDreamCounter;
     /**
      * Parse curation status from the agent response.
      * Extracts JSON status block if present, otherwise infers from response text.

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

@@ -3,10 +3,8 @@ import { BRV_DIR } from '../../constants.js';
 import { FileValidationError } from '../../core/domain/errors/task-error.js';
 import { createFileContentReader, } from '../../utils/file-content-reader.js';
 import { validateFileForCurate } from '../../utils/file-validator.js';
-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';
 import { DreamStateService } from '../dream/dream-state-service.js';
 import { PreCompactionService } from './pre-compaction/pre-compaction-service.js';
 /**
@@ -37,7 +35,20 @@ export class CurateExecutor {
     constructor(fileContentReader) {
         this.fileContentReader = fileContentReader ?? createFileContentReader();
     }
+    /** Synchronous wrapper — runs Phases 1-3 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 Phases 1-3 plus a `finalize` thunk for Phase 4
+     * (snapshot diff, summary regen, manifest rebuild, dream counter, drain,
+     * task-session cleanup). Caller invokes `finalize` exactly once. The thunk
+     * is fail-open. If the agent body itself throws, the task session is cleaned
+     * up before propagating and no `finalize` is returned.
+     */
+    async runAgentBody(agent, options) {
         const { clientCwd, content, files, projectRoot, taskId } = options;
         // --- Phase 1: Preprocessing (no sessions created yet — safe to throw) ---
         const fileReferenceInstructions = await this.processFileReferences(files ?? [], clientCwd);
@@ -59,6 +70,7 @@ export class CurateExecutor {
             // Fail-open: if snapshot fails, skip summary propagation
         }
         const taskSessionId = await agent.createTaskSession(taskId, 'curate', { mapRootEligible: true, userFacing: true });
+        let response;
         try {
             // Task-scoped variable names for RLM pattern.
             // Replace hyphens with underscores: UUIDs have hyphens which are invalid in JS identifiers,
@@ -103,46 +115,30 @@ export class CurateExecutor {
             ].join('\n');
             // Execute on the task session (isolated sandbox + history)
             // Task lifecycle is managed by Transport (task:started, task:completed, task:error)
-            const response = await agent.executeOnSession(taskSessionId, prompt, {
+            response = await agent.executeOnSession(taskSessionId, prompt, {
                 executionContext: { clearHistory: true, commandType: 'curate', maxIterations: 50 },
                 taskId,
             });
             // Parse curation status from agent response for status tracking
             this.lastStatus = this.parseCurationStatus(taskId, response);
-            // --- Phase 4: Post-curation summary propagation (fail-open) ---
-            if (preState) {
-                try {
-                    const postState = await snapshotService.getCurrentState(baseDir);
-                    const changedPaths = diffStates(preState, postState);
-                    if (changedPaths.length > 0) {
-                        const summaryService = new FileContextTreeSummaryService();
-                        const results = await summaryService.propagateStaleness(changedPaths, agent, baseDir, taskId);
-                        // Opportunistic manifest rebuild (pre-warm for next query)
-                        if (results.some((r) => r.actionTaken)) {
-                            const manifestService = new FileContextTreeManifestService({ baseDirectory: baseDir });
-                            await manifestService.buildManifest(baseDir);
-                        }
-                    }
-                }
-                catch {
-                    // Fail-open: summary/manifest errors never block curation
-                }
-            }
-            // Increment dream curation counter (fail-open: non-critical for curation)
-            try {
-                const dreamStateService = new DreamStateService({ baseDir: path.join(baseDir, BRV_DIR) });
-                await dreamStateService.incrementCurationCount();
-            }
-            catch {
-                // Dream state tracking is non-critical — don't block curation
-            }
-            await agent.drainBackgroundWork?.();
-            return response;
         }
-        finally {
-            // Clean up entire task session (sandbox + history) in one call
+        catch (error) {
+            // Clean up before propagating — error path returns no finalize.
             await agent.deleteTaskSession(taskSessionId);
+            throw error;
         }
+        const finalize = async () => {
+            try {
+                await propagateSummariesUnderLock({ agent, baseDir, preState, snapshotService, taskId });
+                await this.incrementDreamCounter(baseDir);
+                await agent.drainBackgroundWork?.();
+            }
+            finally {
+                // In `finally` so the session is deleted even if Phase 4 throws.
+                await agent.deleteTaskSession(taskSessionId);
+            }
+        };
+        return { finalize, response };
     }
     /**
      * Format file contents for inclusion in the prompt.
@@ -185,6 +181,19 @@ export class CurateExecutor {
             }
         }
     }
+    /**
+     * Phase 4d: bump the dream-state curation counter. Fail-open — dream state
+     * tracking is non-critical and must never block curate completion.
+     */
+    async incrementDreamCounter(baseDir) {
+        try {
+            const dreamStateService = new DreamStateService({ baseDir: path.join(baseDir, BRV_DIR) });
+            await dreamStateService.incrementCurationCount();
+        }
+        catch {
+            // Dream state tracking is non-critical
+        }
+    }
     /**
      * Parse curation status from the agent response.
      * Extracts JSON status block if present, otherwise infers from response text.

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

@@ -67,6 +67,14 @@ export type DreamExecutorDeps = {
 type DreamExecuteOptions = {
     priorMtime: number;
     projectRoot: string;
+    /**
+     * Snapshot of the project's reviewDisabled flag captured at task-create on the
+     * daemon side and passed through TaskExecute. When true, the dream-side dual-write
+     * of needsReview operations into the curate log is skipped — they won't surface in
+     * `brv review pending` and won't appear as review entries in the curate log folder.
+     * Undefined → treated as enabled (fail-open).
+     */
+    reviewDisabled?: boolean;
     taskId: string;
     trigger: 'agent-idle' | 'cli' | 'manual';
 };
@@ -89,10 +97,15 @@ export declare class DreamExecutor {
         logId: string;
         out: DreamOperation[];
         projectRoot: string;
+        /**
+         * When true, the dream-side review system (backups + curate-log dual-write) is suppressed.
+         * Backups exist only to support review rejection; with reviews disabled they are dead state,
+         * so consolidate/prune are run without a `reviewBackupStore` so review-backups/ stays empty.
+         */
+        reviewDisabled?: boolean;
         signal: AbortSignal;
         taskId: string;
     }): Promise<void>;
-    /** Errors are tracked at the log level (status='error'), not per-operation — always 0 here. */
     private computeSummary;
     /**
      * Dual-write: create curate log entries for dream operations that need human review.