byterover-cli 3.10.0 → 3.10.1

package/dist/agent/infra/tools/implementations/curate-tool-task-context.d.ts

@@ -0,0 +1,2 @@
+export declare function runWithReviewDisabled<T>(reviewDisabled: boolean, fn: () => Promise<T>): Promise<T>;
+export declare function getCurrentReviewDisabled(): boolean | undefined;

package/dist/agent/infra/tools/implementations/curate-tool-task-context.js

@@ -0,0 +1,28 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * Async-context scope for the daemon-stamped `reviewDisabled` value.
+ *
+ * The daemon snapshots the project's reviewDisabled flag once at task-create
+ * and forwards it via TaskExecute. The agent process opens an
+ * `AsyncLocalStorage` scope around the task body so any descendant async
+ * callsite — direct curate-tool invocation, sandbox `tools.curate(...)` via
+ * CurateService, or anything else awaiting under the same chain — observes the
+ * single snapshot value instead of re-reading `.brv/config.json` (which can
+ * race with mid-task user toggles).
+ *
+ * Same propagation pattern as `CurateResultCollector`
+ * (src/agent/infra/sandbox/curate-result-collector.ts): AsyncLocalStorage flows
+ * through the LLM streaming pipeline and the in-process sandbox, so callers
+ * without an explicit taskId still see the right value.
+ *
+ * Outside any scope, `getCurrentReviewDisabled()` returns `undefined` and the
+ * caller falls back to its own resolution path (currently a `.brv/config.json`
+ * read in `executeCurate`).
+ */
+const reviewDisabledStorage = new AsyncLocalStorage();
+export function runWithReviewDisabled(reviewDisabled, fn) {
+    return reviewDisabledStorage.run(reviewDisabled, fn);
+}
+export function getCurrentReviewDisabled() {
+    return reviewDisabledStorage.getStore();
+}

package/dist/agent/infra/tools/implementations/curate-tool.js

@@ -10,6 +10,7 @@ import { toSnakeCase } from '../../../../server/utils/file-helpers.js';
 import { deriveImpactFromLoss, detectStructuralLoss } from '../../../core/domain/knowledge/conflict-detector.js';
 import { resolveStructuralLoss } from '../../../core/domain/knowledge/conflict-resolver.js';
 import { ToolName } from '../../../core/domain/tools/constants.js';
+import { getCurrentReviewDisabled } from './curate-tool-task-context.js';
 /**
  * Derive the sidecar relPath (forward-slash, relative to the context tree
  * root) from an absolute context-file path and the operation basePath.
@@ -323,7 +324,13 @@ function deriveReviewMetadata(type, confidence, impact) {
  * @param filePath - Absolute path to the context tree file being modified
  * @param basePath - Context tree base path (e.g., '.brv/context-tree')
  */
-async function backupBeforeWrite(filePath, basePath) {
+async function backupBeforeWrite(filePath, basePath, reviewDisabled) {
+    // Honor `brv review --disable`: backups exist solely to support review rejection
+    // (restore from backup). With reviews disabled, they are dead state — skip creation
+    // so review-backups/ stays empty. Snapshot taken once at executeCurate top so all
+    // ops in this tool call observe a consistent value even if the user toggles mid-task.
+    if (reviewDisabled)
+        return;
     try {
         const brvDir = dirname(resolve(basePath));
         const relativePath = relative(resolve(basePath), resolve(filePath));
@@ -340,6 +347,29 @@ async function backupBeforeWrite(filePath, basePath) {
         // Best-effort: backup failure must never block curate operations
     }
 }
+/**
+ * Type guard: narrows an unknown JSON value to a shape that may carry the
+ * `reviewDisabled` flag. Used as the fallback when the agent process has no
+ * AsyncLocalStorage scope (direct sandbox callers without a TaskExecute).
+ */
+function hasReviewDisabledField(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Reads `<brvDir>/config.json` and returns the `reviewDisabled` flag.
+ * Returns false (review enabled) on any error so a missing/corrupt config never
+ * silently swallows backups that protect the rejection path.
+ */
+async function isReviewDisabledForBrvDir(brvDir) {
+    try {
+        const raw = await DirectoryManager.readFile(join(brvDir, 'config.json'));
+        const parsed = JSON.parse(raw);
+        return hasReviewDisabledField(parsed) && parsed.reviewDisabled === true;
+    }
+    catch {
+        return false;
+    }
+}
 function generateDomainContextMarkdown(domainName, context) {
     const sections = [`# Domain: ${domainName}`, '', '## Purpose', context.purpose, '', '## Scope'];
     if (context.scope.included.length > 0) {
@@ -636,7 +666,7 @@ function maxImpact(a, b) {
 /**
  * Execute UPDATE operation - modify existing {title}.md
  */
-async function executeUpdate(basePath, operation, onAfterWrite, runtimeSignalStore, logger) {
+async function executeUpdate(basePath, operation, reviewDisabled, onAfterWrite, runtimeSignalStore, logger) {
     const { confidence, content, domainContext, impact, path, reason, subtopicContext, summary, title, topicContext } = operation;
     // Used for early-exit validation failures (before structural loss can be assessed)
     const baseReviewMeta = deriveReviewMetadata('UPDATE', confidence, impact);
@@ -727,7 +757,7 @@ async function executeUpdate(basePath, operation, onAfterWrite, runtimeSignalSto
             summary,
             timestamps,
         });
-        await backupBeforeWrite(contextPath, basePath);
+        await backupBeforeWrite(contextPath, basePath, reviewDisabled);
         await DirectoryManager.writeFileAtomic(contextPath, contextContent);
         onAfterWrite?.(contextPath, contextContent);
         // Dual-write: mirror the curate-update bumps (importance +5, recency=1,
@@ -762,7 +792,7 @@ async function executeUpdate(basePath, operation, onAfterWrite, runtimeSignalSto
  * Execute UPSERT operation - automatically creates or updates based on file existence
  * This is the recommended operation type as it eliminates the need for pre-checks.
  */
-async function executeUpsert(basePath, operation, onAfterWrite, runtimeSignalStore, logger) {
+async function executeUpsert(basePath, operation, reviewDisabled, onAfterWrite, runtimeSignalStore, logger) {
     const { path, reason, title } = operation;
     const reviewMeta = deriveReviewMetadata('UPSERT', operation.confidence, operation.impact);
     if (!title) {
@@ -804,7 +834,7 @@ async function executeUpsert(basePath, operation, onAfterWrite, runtimeSignalSto
         const exists = await DirectoryManager.fileExists(contextPath);
         if (exists) {
             // File exists - delegate to UPDATE logic
-            const result = await executeUpdate(basePath, { ...operation, type: 'UPDATE' }, onAfterWrite, runtimeSignalStore, logger);
+            const result = await executeUpdate(basePath, { ...operation, type: 'UPDATE' }, reviewDisabled, onAfterWrite, runtimeSignalStore, logger);
             // Return with UPSERT type but indicate it was an update
             return {
                 ...result,
@@ -835,7 +865,7 @@ async function executeUpsert(basePath, operation, onAfterWrite, runtimeSignalSto
 /**
  * Execute MERGE operation - combine source file into target file, delete source file
  */
-async function executeMerge(basePath, operation, onAfterWrite, runtimeSignalStore, logger) {
+async function executeMerge(basePath, operation, reviewDisabled, onAfterWrite, runtimeSignalStore, logger) {
     const { confidence, domainContext, impact, mergeTarget, mergeTargetTitle, path, reason, subtopicContext, summary, title, topicContext, } = operation;
     const reviewMeta = deriveReviewMetadata('MERGE', confidence, impact);
     if (!title) {
@@ -917,8 +947,8 @@ async function executeMerge(basePath, operation, onAfterWrite, runtimeSignalStor
         const targetParsedContent = MarkdownWriter.parseContent(targetContent, mergeTargetTitle);
         const previousSummary = targetParsedContent.summary;
         // Backup both files before merge modifies target and deletes source
-        await backupBeforeWrite(targetContextPath, basePath);
-        await backupBeforeWrite(sourceContextPath, basePath);
+        await backupBeforeWrite(targetContextPath, basePath, reviewDisabled);
+        await backupBeforeWrite(sourceContextPath, basePath, reviewDisabled);
         // Capture source sidecar signals BEFORE any destructive operation so a
         // mid-flow crash cannot leave the target unmerged with an orphaned
         // source entry. The sidecar merge happens after the markdown writes
@@ -1001,7 +1031,7 @@ async function executeMerge(basePath, operation, onAfterWrite, runtimeSignalStor
  * Execute DELETE operation - remove specific file or entire folder
  * If title is provided, deletes specific file; if omitted, deletes entire folder
  */
-async function executeDelete(basePath, operation, runtimeSignalStore, logger) {
+async function executeDelete(basePath, operation, reviewDisabled, runtimeSignalStore, logger) {
     const { path, reason, title } = operation;
     const reviewMeta = deriveReviewMetadata('DELETE', operation.confidence, operation.impact);
     try {
@@ -1032,7 +1062,7 @@ async function executeDelete(basePath, operation, runtimeSignalStore, logger) {
             catch {
                 // Best-effort: summary extraction failure must never block delete
             }
-            await backupBeforeWrite(filePath, basePath);
+            await backupBeforeWrite(filePath, basePath, reviewDisabled);
             await DirectoryManager.deleteFile(filePath);
             await deleteDerivedSiblings(filePath);
             // Dual-write: drop the deleted file's sidecar entry so it does not
@@ -1083,7 +1113,7 @@ async function executeDelete(basePath, operation, runtimeSignalStore, logger) {
         catch {
             // Best-effort: summary extraction failure must never block delete
         }
-        await Promise.all(mdFiles.map((f) => backupBeforeWrite(f, basePath)));
+        await Promise.all(mdFiles.map((f) => backupBeforeWrite(f, basePath, reviewDisabled)));
         await DirectoryManager.deleteTopicRecursive(fullPath);
         // Dual-write: drop sidecar entries for every markdown file that was
         // deleted. Without this, folder deletes leak orphan signal entries.
@@ -1144,8 +1174,19 @@ export async function executeCurate(input, _context, abstractQueue, runtimeSigna
         };
     }
     const { basePath, operations } = parseResult.data;
+    // Prefer the daemon-stamped value (snapshotted at task-create on the daemon side,
+    // forwarded via TaskExecute, opened as an AsyncLocalStorage scope in agent-process so
+    // it propagates through any async chain — direct tool call, sandbox `tools.curate(...)`
+    // via CurateService, or ingest-resource-tool). The `.brv/config.json` read is the
+    // fall-back for callers outside any scope. Sharing one value across daemon
+    // (CurateLogHandler) and agent (this tool) keeps reviewStatus and backups consistent:
+    // without it, a user toggle mid-task could mark ops as pending review (daemon snapshot
+    // held) while skipping backups (agent re-read picks up new value), making rejection
+    // un-restorable.
+    const scopedReviewDisabled = getCurrentReviewDisabled();
+    const reviewDisabled = scopedReviewDisabled ?? (await isReviewDisabledForBrvDir(dirname(resolve(basePath))));
     const onAfterWrite = abstractQueue
-        ? (contextPath, content) => { abstractQueue.enqueue({ contextPath, fullContent: content }); }
+        ? (contextPath, content) => abstractQueue.enqueue({ contextPath, fullContent: content })
         : undefined;
     const applied = [];
     const summary = {
@@ -1166,25 +1207,25 @@ export async function executeCurate(input, _context, abstractQueue, runtimeSigna
                 break;
             }
             case 'DELETE': {
-                result = await executeDelete(basePath, operation, runtimeSignalStore, logger);
+                result = await executeDelete(basePath, operation, reviewDisabled, runtimeSignalStore, logger);
                 if (result.status === 'success')
                     summary.deleted++;
                 break;
             }
             case 'MERGE': {
-                result = await executeMerge(basePath, operation, onAfterWrite, runtimeSignalStore, logger);
+                result = await executeMerge(basePath, operation, reviewDisabled, onAfterWrite, runtimeSignalStore, logger);
                 if (result.status === 'success')
                     summary.merged++;
                 break;
             }
             case 'UPDATE': {
-                result = await executeUpdate(basePath, operation, onAfterWrite, runtimeSignalStore, logger);
+                result = await executeUpdate(basePath, operation, reviewDisabled, onAfterWrite, runtimeSignalStore, logger);
                 if (result.status === 'success')
                     summary.updated++;
                 break;
             }
             case 'UPSERT': {
-                result = await executeUpsert(basePath, operation, onAfterWrite, runtimeSignalStore, logger);
+                result = await executeUpsert(basePath, operation, reviewDisabled, onAfterWrite, runtimeSignalStore, logger);
                 // UPSERT counts as either added or updated based on what happened
                 if (result.status === 'success') {
                     if (result.message?.includes('created new')) {

package/dist/oclif/commands/review.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+import { type DaemonClientOptions } from '../lib/daemon-client.js';
+export default class Review extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        disable: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        enable: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getDaemonClientOptions(): DaemonClientOptions;
+    run(): Promise<void>;
+    private reportError;
+    private reportStatus;
+    private reportToggle;
+}

package/dist/oclif/commands/review.js

@@ -0,0 +1,96 @@
+import { Command, Flags } from '@oclif/core';
+import { ReviewEvents, } from '../../shared/transport/events/review-events.js';
+import { formatConnectionError, withDaemonRetry } from '../lib/daemon-client.js';
+import { writeJsonResponse } from '../lib/json-response.js';
+export default class Review extends Command {
+    static description = `Toggle the HITL review log for the current project
+
+When disabled:
+- 'brv curate' (sync mode) no longer prints the "X operations require review" prompt
+- Curate-log entries written in '--detach' mode no longer carry the per-operation review marker
+- 'brv dream' no longer surfaces its own needsReview operations as pending reviews
+- 'brv review pending' will not list any new entries until re-enabled`;
+    static examples = [
+        '# Show current state',
+        '<%= config.bin %> <%= command.id %>',
+        '',
+        '# Disable the review log for this project',
+        '<%= config.bin %> <%= command.id %> --disable',
+        '',
+        '# Re-enable the review log',
+        '<%= config.bin %> <%= command.id %> --enable',
+    ];
+    static flags = {
+        disable: Flags.boolean({
+            default: false,
+            description: 'Disable the HITL review log for this project',
+            exclusive: ['enable'],
+        }),
+        enable: Flags.boolean({
+            default: false,
+            description: 'Re-enable the HITL review log for this project',
+            exclusive: ['disable'],
+        }),
+        format: Flags.string({
+            default: 'text',
+            description: 'Output format (text or json)',
+            options: ['text', 'json'],
+        }),
+    };
+    getDaemonClientOptions() {
+        return {};
+    }
+    async run() {
+        const { flags } = await this.parse(Review);
+        const format = flags.format === 'json' ? 'json' : 'text';
+        try {
+            if (flags.disable || flags.enable) {
+                const target = flags.disable;
+                const response = await withDaemonRetry((client) => client.requestWithAck(ReviewEvents.SET_DISABLED, { reviewDisabled: target }), this.getDaemonClientOptions());
+                this.reportToggle(response.reviewDisabled, format);
+                return;
+            }
+            const response = await withDaemonRetry((client) => client.requestWithAck(ReviewEvents.GET_DISABLED, {}), this.getDaemonClientOptions());
+            this.reportStatus(response.reviewDisabled, format);
+        }
+        catch (error) {
+            this.reportError(error, format);
+        }
+    }
+    reportError(error, format) {
+        const message = error instanceof Error ? error.message : 'Review failed';
+        if (format === 'json') {
+            writeJsonResponse({
+                command: 'review',
+                data: { error: message, status: 'error' },
+                success: false,
+            });
+            return;
+        }
+        this.log(formatConnectionError(error));
+    }
+    reportStatus(disabled, format) {
+        if (format === 'json') {
+            writeJsonResponse({
+                command: 'review',
+                data: { reviewDisabled: disabled, status: 'success' },
+                success: true,
+            });
+            return;
+        }
+        this.log(disabled ? 'Review log is disabled.' : 'Review log is enabled.');
+    }
+    reportToggle(disabled, format) {
+        if (format === 'json') {
+            writeJsonResponse({
+                command: 'review',
+                data: { reviewDisabled: disabled, status: 'success' },
+                success: true,
+            });
+            return;
+        }
+        this.log(disabled
+            ? `Review log disabled. To re-enable: ${this.config.bin} review --enable`
+            : `Review log enabled. To disable: ${this.config.bin} review --disable`);
+    }
+}

package/dist/server/core/domain/entities/brv-config.d.ts

@@ -13,6 +13,7 @@ export type BrvConfigParams = {
     createdAt: string;
     cwd?: string;
     ide?: Agent;
+    reviewDisabled?: boolean;
     spaceId?: string;
     spaceName?: string;
     teamId?: string;
@@ -47,6 +48,7 @@ export declare class BrvConfig {
     readonly createdAt: string;
     readonly cwd?: string;
     readonly ide?: Agent;
+    readonly reviewDisabled?: boolean;
     readonly spaceId?: string;
     readonly spaceName?: string;
     readonly teamId?: string;
@@ -89,6 +91,10 @@ export declare class BrvConfig {
      * Creates a new BrvConfig with space fields cleared, preserving all other fields.
      */
     withoutSpace(): BrvConfig;
+    /**
+     * Creates a new BrvConfig with the reviewDisabled flag updated, preserving all other fields.
+     */
+    withReviewDisabled(reviewDisabled: boolean): BrvConfig;
     /**
      * Creates a new BrvConfig with space fields replaced, preserving all other fields.
      */

package/dist/server/core/domain/entities/brv-config.js

@@ -50,6 +50,8 @@ const isBrvConfigJson = (json) => {
         return false;
     if (obj.version !== undefined && typeof obj.version !== 'string')
         return false;
+    if (obj.reviewDisabled !== undefined && typeof obj.reviewDisabled !== 'boolean')
+        return false;
     return true;
 };
 /**
@@ -64,6 +66,7 @@ export class BrvConfig {
     createdAt;
     cwd;
     ide;
+    reviewDisabled;
     spaceId;
     spaceName;
     teamId;
@@ -80,6 +83,7 @@ export class BrvConfig {
         this.createdAt = params.createdAt;
         this.cwd = params.cwd;
         this.ide = params.ide;
+        this.reviewDisabled = params.reviewDisabled;
         this.spaceId = params.spaceId;
         this.spaceName = params.spaceName;
         this.teamId = params.teamId;
@@ -163,6 +167,7 @@ export class BrvConfig {
             createdAt: this.createdAt,
             cwd: this.cwd,
             ide: this.ide,
+            reviewDisabled: this.reviewDisabled,
             spaceId: this.spaceId,
             spaceName: this.spaceName,
             teamId: this.teamId,
@@ -182,6 +187,26 @@ export class BrvConfig {
             teamName: undefined,
         });
     }
+    /**
+     * Creates a new BrvConfig with the reviewDisabled flag updated, preserving all other fields.
+     */
+    withReviewDisabled(reviewDisabled) {
+        return new BrvConfig({
+            chatLogPath: this.chatLogPath,
+            cipherAgentContext: this.cipherAgentContext,
+            cipherAgentModes: this.cipherAgentModes,
+            cipherAgentSystemPrompt: this.cipherAgentSystemPrompt,
+            createdAt: this.createdAt,
+            cwd: this.cwd,
+            ide: this.ide,
+            reviewDisabled,
+            spaceId: this.spaceId,
+            spaceName: this.spaceName,
+            teamId: this.teamId,
+            teamName: this.teamName,
+            version: this.version,
+        });
+    }
     /**
      * Creates a new BrvConfig with space fields replaced, preserving all other fields.
      */
@@ -194,6 +219,7 @@ export class BrvConfig {
             createdAt: new Date().toISOString(),
             cwd: this.cwd,
             ide: this.ide,
+            reviewDisabled: this.reviewDisabled,
             spaceId: space.id,
             spaceName: space.name,
             teamId: space.teamId,
@@ -213,6 +239,7 @@ export class BrvConfig {
             createdAt: this.createdAt,
             cwd: this.cwd,
             ide: this.ide,
+            reviewDisabled: this.reviewDisabled,
             spaceId: this.spaceId,
             spaceName: this.spaceName,
             teamId: this.teamId,

package/dist/server/core/domain/entities/provider-registry.js

@@ -186,7 +186,6 @@ export const PROVIDER_REGISTRY = {
     'openai-compatible': {
         baseUrl: '',
         category: 'other',
-        defaultModel: 'llama3',
         description: 'OpenAI-compatible endpoint (Ollama, LM Studio, etc.)',
         envVars: ['OPENAI_COMPATIBLE_API_KEY'],
         headers: {},

package/dist/server/core/domain/transport/schemas.d.ts

@@ -515,6 +515,12 @@ export declare const TaskExecuteSchema: z.ZodObject<{
     force: z.ZodOptional<z.ZodBoolean>;
     /** Project path this task belongs to (for multi-project routing) */
     projectPath: z.ZodOptional<z.ZodString>;
+    /**
+     * Snapshot of the project's review-disabled flag captured at task-create time.
+     * Stamped by the daemon so the agent does not re-read .brv/config.json and
+     * race with mid-task toggles.
+     */
+    reviewDisabled: z.ZodOptional<z.ZodBoolean>;
     /** Unique task identifier */
     taskId: z.ZodString;
     /** Dream trigger source — how this dream was initiated */
@@ -530,6 +536,7 @@ export declare const TaskExecuteSchema: z.ZodObject<{
     clientId: string;
     files?: string[] | undefined;
     force?: boolean | undefined;
+    reviewDisabled?: boolean | undefined;
     clientCwd?: string | undefined;
     folderPath?: string | undefined;
     projectPath?: string | undefined;
@@ -542,6 +549,7 @@ export declare const TaskExecuteSchema: z.ZodObject<{
     clientId: string;
     files?: string[] | undefined;
     force?: boolean | undefined;
+    reviewDisabled?: boolean | undefined;
     clientCwd?: string | undefined;
     folderPath?: string | undefined;
     projectPath?: string | undefined;

package/dist/server/core/domain/transport/schemas.js

@@ -318,6 +318,12 @@ export const TaskExecuteSchema = z.object({
     force: z.boolean().optional(),
     /** Project path this task belongs to (for multi-project routing) */
     projectPath: z.string().optional(),
+    /**
+     * Snapshot of the project's review-disabled flag captured at task-create time.
+     * Stamped by the daemon so the agent does not re-read .brv/config.json and
+     * race with mid-task toggles.
+     */
+    reviewDisabled: z.boolean().optional(),
     /** Unique task identifier */
     taskId: z.string(),
     /** Dream trigger source — how this dream was initiated */

package/dist/server/core/domain/transport/task-info.d.ts

@@ -22,6 +22,13 @@ export type TaskInfo = {
     projectPath?: string;
     /** Set on successful completion */
     result?: string;
+    /**
+     * Snapshot of the project's review-disabled flag captured at task-create time.
+     * Stamped once at the daemon boundary so daemon (CurateLogHandler) and agent
+     * (curate-tool backups, dream review entries) observe the same value even if
+     * the user toggles the flag mid-task.
+     */
+    reviewDisabled?: boolean;
     /** Set when agent picks up the task */
     startedAt?: number;
     /** Lifecycle status — defaults to 'created' on construction */

package/dist/server/core/interfaces/i-provider-config-store.d.ts

@@ -8,13 +8,17 @@ export interface IProviderConfigStore {
      * Marks a provider as connected.
      *
      * @param providerId The provider ID to mark as connected
-     * @param options Optional settings like default model
+     * @param options Optional settings like default model. Pass `setAsActive: false`
+     *   to skip flipping the active provider (used when the provider has no
+     *   active model yet — activating it would put the app in a half-configured
+     *   state that the welcome view interprets as "needs setup").
      */
     connectProvider: (providerId: string, options?: {
         activeModel?: string;
         authMethod?: 'api-key' | 'oauth';
         baseUrl?: string;
         oauthAccountId?: string;
+        setAsActive?: boolean;
     }) => Promise<void>;
     /**
      * Removes a provider connection.

package/dist/server/infra/context-tree/propagate-summaries.d.ts

@@ -0,0 +1,18 @@
+import type { ICipherAgent } from '../../../agent/core/interfaces/i-cipher-agent.js';
+import type { FileState } from '../../core/domain/entities/context-tree-snapshot.js';
+import type { FileContextTreeSnapshotService } from './file-context-tree-snapshot-service.js';
+export type PropagateSummariesUnderLockOptions = {
+    agent: ICipherAgent;
+    baseDir: string;
+    preState: Map<string, FileState> | undefined;
+    snapshotService: FileContextTreeSnapshotService;
+    taskId: string;
+};
+/**
+ * Phase 4 write block shared by curate and folder-pack post-work: snapshot
+ * diff → `propagateStaleness` → opportunistic manifest rebuild. Holds the
+ * dream lock around the writes so a concurrent dream cannot interleave on
+ * `_index.md` / `_manifest.json`; if the lock is held, this skips because
+ * dream's own propagation covers the same diff. Fail-open.
+ */
+export declare function propagateSummariesUnderLock(options: PropagateSummariesUnderLockOptions): Promise<void>;

package/dist/server/infra/context-tree/propagate-summaries.js

@@ -0,0 +1,52 @@
+import path from 'node:path';
+import { BRV_DIR } from '../../constants.js';
+import { DreamLockService } from '../dream/dream-lock-service.js';
+import { FileContextTreeManifestService } from './file-context-tree-manifest-service.js';
+import { FileContextTreeSummaryService } from './file-context-tree-summary-service.js';
+import { diffStates } from './snapshot-diff.js';
+/**
+ * Phase 4 write block shared by curate and folder-pack post-work: snapshot
+ * diff → `propagateStaleness` → opportunistic manifest rebuild. Holds the
+ * dream lock around the writes so a concurrent dream cannot interleave on
+ * `_index.md` / `_manifest.json`; if the lock is held, this skips because
+ * dream's own propagation covers the same diff. Fail-open.
+ */
+export async function propagateSummariesUnderLock(options) {
+    const { agent, baseDir, preState, snapshotService, taskId } = options;
+    if (!preState)
+        return;
+    const dreamLockService = new DreamLockService({ baseDir: path.join(baseDir, BRV_DIR) });
+    let acquireResult;
+    try {
+        acquireResult = await dreamLockService.tryAcquire();
+    }
+    catch {
+        return;
+    }
+    if (!acquireResult.acquired)
+        return;
+    let succeeded = false;
+    try {
+        const postState = await snapshotService.getCurrentState(baseDir);
+        const changedPaths = diffStates(preState, postState);
+        if (changedPaths.length === 0) {
+            succeeded = true;
+            return;
+        }
+        const summaryService = new FileContextTreeSummaryService();
+        const results = await summaryService.propagateStaleness(changedPaths, agent, baseDir, taskId);
+        if (results.some((result) => result.actionTaken)) {
+            const manifestService = new FileContextTreeManifestService({ baseDirectory: baseDir });
+            await manifestService.buildManifest(baseDir);
+        }
+        succeeded = true;
+    }
+    catch {
+        // Fail-open: summary/manifest errors never block the caller.
+    }
+    finally {
+        await (succeeded
+            ? dreamLockService.release()
+            : dreamLockService.rollback(acquireResult.priorMtime)).catch(() => { });
+    }
+}