byterover-cli 3.10.0 → 3.10.2

package/dist/server/infra/dream/dream-state-schema.d.ts

@@ -15,6 +15,22 @@ export declare const PendingMergeSchema: z.ZodObject<{
     sourceFile: string;
     suggestedByDreamId: string;
 }>;
+/**
+ * One entry in the stale-summary queue drained at the next dream cycle.
+ * `enqueuedAt` is preserved across dedup'd re-enqueues so future telemetry
+ * (e.g., "oldest waiting path") can read meaningful wait times even though
+ * no consumer reads it today.
+ */
+export declare const StaleSummaryEntrySchema: z.ZodObject<{
+    enqueuedAt: z.ZodNumber;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    enqueuedAt: number;
+}, {
+    path: string;
+    enqueuedAt: number;
+}>;
 export declare const DreamStateSchema: z.ZodObject<{
     curationsSinceDream: z.ZodNumber;
     lastDreamAt: z.ZodNullable<z.ZodString>;
@@ -35,6 +51,16 @@ export declare const DreamStateSchema: z.ZodObject<{
         sourceFile: string;
         suggestedByDreamId: string;
     }>, "many">>>;
+    staleSummaryPaths: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        enqueuedAt: z.ZodNumber;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        enqueuedAt: number;
+    }, {
+        path: string;
+        enqueuedAt: number;
+    }>, "many">>>;
     totalDreams: z.ZodNumber;
     version: z.ZodLiteral<1>;
 }, "strip", z.ZodTypeAny, {
@@ -48,6 +74,10 @@ export declare const DreamStateSchema: z.ZodObject<{
         sourceFile: string;
         suggestedByDreamId: string;
     }[];
+    staleSummaryPaths: {
+        path: string;
+        enqueuedAt: number;
+    }[];
     totalDreams: number;
 }, {
     version: 1;
@@ -61,7 +91,12 @@ export declare const DreamStateSchema: z.ZodObject<{
         sourceFile: string;
         suggestedByDreamId: string;
     }[] | undefined;
+    staleSummaryPaths?: {
+        path: string;
+        enqueuedAt: number;
+    }[] | undefined;
 }>;
 export type DreamState = z.infer<typeof DreamStateSchema>;
 export type PendingMerge = z.infer<typeof PendingMergeSchema>;
+export type StaleSummaryEntry = z.infer<typeof StaleSummaryEntrySchema>;
 export declare const EMPTY_DREAM_STATE: DreamState;

package/dist/server/infra/dream/dream-state-schema.js

@@ -5,11 +5,25 @@ export const PendingMergeSchema = z.object({
     sourceFile: z.string(),
     suggestedByDreamId: z.string(),
 });
+/**
+ * One entry in the stale-summary queue drained at the next dream cycle.
+ * `enqueuedAt` is preserved across dedup'd re-enqueues so future telemetry
+ * (e.g., "oldest waiting path") can read meaningful wait times even though
+ * no consumer reads it today.
+ */
+export const StaleSummaryEntrySchema = z.object({
+    enqueuedAt: z.number().int().nonnegative(),
+    // Empty paths indicate a bug at the call site (a malformed diff entry would
+    // resolve to an empty parent dir); reject them at the schema boundary so
+    // garbage cannot persist into dream-state.json.
+    path: z.string().min(1),
+});
 export const DreamStateSchema = z.object({
     curationsSinceDream: z.number().int().min(0),
     lastDreamAt: z.string().datetime().nullable(),
     lastDreamLogId: z.string().nullable(),
     pendingMerges: z.array(PendingMergeSchema).optional().default([]),
+    staleSummaryPaths: z.array(StaleSummaryEntrySchema).optional().default([]),
     totalDreams: z.number().int().min(0),
     version: z.literal(1),
 });
@@ -18,6 +32,7 @@ export const EMPTY_DREAM_STATE = {
     lastDreamAt: null,
     lastDreamLogId: null,
     pendingMerges: [],
+    staleSummaryPaths: [],
     totalDreams: 0,
     version: 1,
 };

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

@@ -11,6 +11,28 @@ type DreamStateServiceOptions = {
 export declare class DreamStateService {
     private readonly stateFilePath;
     constructor(opts: DreamStateServiceOptions);
+    /**
+     * Atomic drain — reads the current queue and clears it in a single RMW,
+     * returning the deduped path list. The caller is responsible for retrying
+     * (re-enqueueing the returned snapshot) if the downstream work fails.
+     *
+     * Atomicity is the load-bearing property: any enqueue that runs after the
+     * drain returns sees an empty queue, so it always appends a fresh entry
+     * that survives independently of whether the downstream propagation succeeds
+     * or fails. Earlier "snapshot + clear-later" approaches lost same-path
+     * enqueues: the dedup check on enqueue saw the still-present snapshot entry
+     * and skipped, then `clear()` removed it.
+     */
+    drainStaleSummaryPaths(): Promise<string[]>;
+    /**
+     * Append the given file paths to the stale-summary queue, deduping by path.
+     * A path already in the queue keeps its original `enqueuedAt` timestamp so
+     * "how long has this been waiting?" telemetry stays meaningful.
+     *
+     * Serialized through {@link update} so concurrent enqueues from parallel
+     * curate tasks do not lose entries. Empty input is a no-op (no write).
+     */
+    enqueueStaleSummaryPaths(paths: string[]): Promise<void>;
     /**
      * Read-modify-write under a per-file mutex. Serializes concurrent increments
      * from parallel curate tasks within the same agent process so no updates are lost.

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

@@ -37,6 +37,57 @@ export class DreamStateService {
     constructor(opts) {
         this.stateFilePath = join(opts.baseDir, STATE_FILENAME);
     }
+    /**
+     * Atomic drain — reads the current queue and clears it in a single RMW,
+     * returning the deduped path list. The caller is responsible for retrying
+     * (re-enqueueing the returned snapshot) if the downstream work fails.
+     *
+     * Atomicity is the load-bearing property: any enqueue that runs after the
+     * drain returns sees an empty queue, so it always appends a fresh entry
+     * that survives independently of whether the downstream propagation succeeds
+     * or fails. Earlier "snapshot + clear-later" approaches lost same-path
+     * enqueues: the dedup check on enqueue saw the still-present snapshot entry
+     * and skipped, then `clear()` removed it.
+     */
+    async drainStaleSummaryPaths() {
+        let snapshot = [];
+        await this.update((state) => {
+            snapshot = state.staleSummaryPaths.map((e) => e.path);
+            if (snapshot.length === 0)
+                return state;
+            return { ...state, staleSummaryPaths: [] };
+        });
+        return snapshot;
+    }
+    /**
+     * Append the given file paths to the stale-summary queue, deduping by path.
+     * A path already in the queue keeps its original `enqueuedAt` timestamp so
+     * "how long has this been waiting?" telemetry stays meaningful.
+     *
+     * Serialized through {@link update} so concurrent enqueues from parallel
+     * curate tasks do not lose entries. Empty input is a no-op (no write).
+     */
+    async enqueueStaleSummaryPaths(paths) {
+        if (paths.length === 0)
+            return;
+        // Dedup the input itself before checking against the queue — callers may
+        // pass non-unique arrays (e.g. multiple changed paths within a single
+        // curate that round-trip through the same parent dir).
+        const incoming = [...new Set(paths)];
+        const enqueuedAt = Date.now();
+        await this.update((state) => {
+            const existing = new Set(state.staleSummaryPaths.map((e) => e.path));
+            const additions = incoming
+                .filter((p) => !existing.has(p))
+                .map((p) => ({ enqueuedAt, path: p }));
+            if (additions.length === 0)
+                return state;
+            return {
+                ...state,
+                staleSummaryPaths: [...state.staleSummaryPaths, ...additions],
+            };
+        });
+    }
     /**
      * Read-modify-write under a per-file mutex. Serializes concurrent increments
      * from parallel curate tasks within the same agent process so no updates are lost.
@@ -49,11 +100,11 @@ export class DreamStateService {
             const raw = await readFile(this.stateFilePath, 'utf8');
             const parsed = DreamStateSchema.safeParse(JSON.parse(raw));
             if (!parsed.success)
-                return { ...EMPTY_DREAM_STATE, pendingMerges: [] };
+                return { ...EMPTY_DREAM_STATE };
             return parsed.data;
         }
         catch {
-            return { ...EMPTY_DREAM_STATE, pendingMerges: [] };
+            return { ...EMPTY_DREAM_STATE };
         }
     }
     /**
@@ -68,7 +119,15 @@ export class DreamStateService {
         return mutex.withLock(async () => {
             const state = await this.read();
             const next = updater(state);
-            await this.write(next);
+            // Skip the write when the updater returned the same state reference.
+            // Existing call sites (drainStaleSummaryPaths on empty queue,
+            // enqueueStaleSummaryPaths with all-duplicate input) already follow
+            // this convention by returning `state` unchanged — making the no-op
+            // contract observable at the disk level avoids a tmpfile + rename on
+            // every empty drain.
+            if (next !== state) {
+                await this.write(next);
+            }
             return next;
         });
     }

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

@@ -48,8 +48,12 @@ export class DreamTrigger {
                 return { eligible: false, reason: `Too recent (${hoursSince.toFixed(1)}h < ${minHours}h)` };
             }
         }
-        // Gate 2: Activity
-        if (state.curationsSinceDream < minCurations) {
+        // Gate 2: Activity. Bypassed when the stale-summary queue has deferred
+        // work — leaving entries indefinitely strands `_index.md` regeneration
+        // in low-activity projects (the very projects ENG-2485 most affects,
+        // since 1–2 curates over a 12h window otherwise sit under minCurations
+        // forever). Dream is the canonical drain point; if it has work, run.
+        if (state.curationsSinceDream < minCurations && state.staleSummaryPaths.length === 0) {
             return {
                 eligible: false,
                 reason: `Not enough activity (${state.curationsSinceDream} < ${minCurations} curations)`,

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.
@@ -52,4 +69,20 @@ export declare class CurateExecutor implements ICurateExecutor {
      * @throws {FileValidationError} If all files fail validation
      */
     private processFileReferences;
+    /**
+     * Phase 4: snapshot diff → enqueue stale paths for dream → rebuild manifest.
+     *
+     * Summary cascade regeneration (the LLM-driven `propagateStaleness` walk) is
+     * deferred to the next dream cycle to keep curate's hot path free of LLM
+     * calls. The manifest is rebuilt inline because it is a pure file scan (no
+     * LLM) and keeps newly-curated leaf files immediately discoverable via
+     * manifest-driven retrieval.
+     *
+     * Two independent fail-open concerns: (a) enqueue the deferred summary-cascade
+     * work to dream's queue; (b) rebuild the search manifest. They share
+     * `changedPaths` but otherwise are unrelated — a transient disk error on the
+     * dream-state write must not skip the pure-filesystem manifest scan. Each
+     * runs in its own try block so one failure cannot mask the other's work.
+     */
+    private propagateAndRebuild;
 }

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

@@ -1,11 +1,11 @@
 import path from 'node:path';
+import { recon as reconHelper } from '../../../agent/infra/sandbox/curation-helpers.js';
 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 { DreamStateService } from '../dream/dream-state-service.js';
 import { PreCompactionService } from './pre-compaction/pre-compaction-service.js';
@@ -37,7 +37,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 +72,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,
@@ -82,12 +96,30 @@ export class CurateExecutor {
                 preview: effectiveContext.slice(0, 500),
                 type: 'string',
             };
-            // Inject context, metadata, empty history, and taskId into the TASK session's sandbox
+            // Pre-pipeline the recon step (deterministic helper) so the agent loop
+            // doesn't spend its first iteration calling tools.curation.recon. The
+            // result is injected as a sandbox variable for code-exec access AND
+            // its key findings are surfaced inline in the prompt so the agent's
+            // first iteration can proceed directly to extraction. recon is pure
+            // JS — no LLM judgment is needed for whether to call it; the answer
+            // is always "yes, first thing." Surfacing it as an agent-tool meant
+            // paying a full LLM iteration just to invoke a deterministic helper.
+            const initialHistory = { entries: [], totalProcessed: 0 };
+            // The `metadata` arg is currently unused by `recon` — the helper
+            // recomputes char/line/message counts from `effectiveContext`
+            // directly. Passed through here to match the helper's existing
+            // signature; do NOT assume changing `metadata` will alter
+            // `reconResult`.
+            const reconResult = reconHelper(effectiveContext, metadata, initialHistory);
+            const reconVar = `__recon_result_${taskIdSafe}`;
+            // Inject context, metadata, empty history, taskId, and pre-computed
+            // recon result into the TASK session's sandbox.
             const taskIdVar = `__taskId_${taskIdSafe}`;
             agent.setSandboxVariableOnSession(taskSessionId, ctxVar, effectiveContext);
-            agent.setSandboxVariableOnSession(taskSessionId, histVar, { entries: [], totalProcessed: 0 });
+            agent.setSandboxVariableOnSession(taskSessionId, histVar, initialHistory);
             agent.setSandboxVariableOnSession(taskSessionId, metaVar, metadata);
             agent.setSandboxVariableOnSession(taskSessionId, taskIdVar, taskId);
+            agent.setSandboxVariableOnSession(taskSessionId, reconVar, reconResult);
             // Prompt with curation helpers guidance (tools.curation.* replaces manual infrastructure code)
             const prompt = [
                 `Curate using RLM approach.`,
@@ -95,7 +127,8 @@ export class CurateExecutor {
                 `History variable: ${histVar}`,
                 `Metadata variable: ${metaVar}`,
                 `Task ID variable: ${taskIdVar} (pass as bare variable, not a string)`,
-                `IMPORTANT: Do NOT print raw context. Start with tools.curation.recon(${ctxVar}, ${metaVar}, ${histVar}) to assess.`,
+                `Recon already computed in ${reconVar}: suggestedMode=${reconResult.suggestedMode}, suggestedChunkCount=${reconResult.suggestedChunkCount}, charCount=${reconResult.meta.charCount}, lineCount=${reconResult.meta.lineCount}, messageCount=${reconResult.meta.messageCount}.`,
+                `IMPORTANT: Do NOT print raw context. Do NOT call tools.curation.recon — it has been pre-computed. Proceed directly to extraction.`,
                 `For chunked extraction use tools.curation.mapExtract(). Pass taskId: ${taskIdVar} (bare variable).`,
                 `IMPORTANT: Any code_exec call containing mapExtract MUST use timeout: 300000 on the code_exec tool call itself (not inside mapExtract options).`,
                 `Use tools.curation.groupBySubject() and tools.curation.dedup() to organize extractions.`,
@@ -103,46 +136,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 this.propagateAndRebuild({ baseDir, preState, snapshotService });
+                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 +202,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.
@@ -264,4 +294,54 @@ export class CurateExecutor {
         // Format with actual content
         return this.formatFileContentsForPrompt(readResults, skippedFiles, projectRoot);
     }
+    /**
+     * Phase 4: snapshot diff → enqueue stale paths for dream → rebuild manifest.
+     *
+     * Summary cascade regeneration (the LLM-driven `propagateStaleness` walk) is
+     * deferred to the next dream cycle to keep curate's hot path free of LLM
+     * calls. The manifest is rebuilt inline because it is a pure file scan (no
+     * LLM) and keeps newly-curated leaf files immediately discoverable via
+     * manifest-driven retrieval.
+     *
+     * Two independent fail-open concerns: (a) enqueue the deferred summary-cascade
+     * work to dream's queue; (b) rebuild the search manifest. They share
+     * `changedPaths` but otherwise are unrelated — a transient disk error on the
+     * dream-state write must not skip the pure-filesystem manifest scan. Each
+     * runs in its own try block so one failure cannot mask the other's work.
+     */
+    async propagateAndRebuild(args) {
+        const { baseDir, preState, snapshotService } = args;
+        if (!preState)
+            return;
+        let changedPaths = [];
+        try {
+            const postState = await snapshotService.getCurrentState(baseDir);
+            changedPaths = diffStates(preState, postState);
+        }
+        catch {
+            // Fail-open: snapshot errors leave changedPaths empty → no enqueue,
+            // no manifest rebuild. Next curate's snapshot will pick up the diff.
+        }
+        if (changedPaths.length === 0)
+            return;
+        try {
+            const dreamStateService = new DreamStateService({ baseDir: path.join(baseDir, BRV_DIR) });
+            await dreamStateService.enqueueStaleSummaryPaths(changedPaths);
+        }
+        catch {
+            // Fail-open: queue write errors never block curation. If this write
+            // fails the changed paths are lost from the deferred queue; they will
+            // only be re-captured if the same files are modified in a later curate
+            // (diffStates compares a fresh pre/post snapshot pair, not a persistent
+            // accumulator) or picked up by dream's own snapshot diff if dream
+            // touches them.
+        }
+        try {
+            const manifestService = new FileContextTreeManifestService({ baseDirectory: baseDir });
+            await manifestService.buildManifest(baseDir);
+        }
+        catch {
+            // Fail-open: manifest rebuild is best-effort pre-warming.
+        }
+    }
 }

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

@@ -48,6 +48,8 @@ export type DreamExecutorDeps = {
         save(entry: DreamLogEntry): Promise<void>;
     };
     dreamStateService: {
+        drainStaleSummaryPaths(): Promise<string[]>;
+        enqueueStaleSummaryPaths(paths: string[]): Promise<void>;
         read(): Promise<import('../dream/dream-state-schema.js').DreamState>;
         update(updater: (state: import('../dream/dream-state-schema.js').DreamState) => import('../dream/dream-state-schema.js').DreamState): Promise<import('../dream/dream-state-schema.js').DreamState>;
         write(state: import('../dream/dream-state-schema.js').DreamState): Promise<void>;
@@ -67,6 +69,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,9 +99,28 @@ 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>;
+    /**
+     * 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.
+     */
+    protected runStaleSummaryPropagation(args: {
+        agent: ICipherAgent;
+        parentTaskId?: string;
+        paths: string[];
+        projectRoot: string;
+    }): Promise<void>;
     /** Errors are tracked at the log level (status='error'), not per-operation — always 0 here. */
     private computeSummary;
     /**