byterover-cli 3.5.1 → 3.6.1

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

@@ -21,6 +21,7 @@
 import { connectToTransport } from '@campfirein/brv-transport-client';
 import { randomUUID } from 'node:crypto';
 import { appendFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { SESSIONS_DIR } from '../../../agent/core/domain/session/session-metadata.js';
 import { CipherAgent } from '../../../agent/infra/agent/index.js';
 import { FileSystemService } from '../../../agent/infra/file-system/file-system-service.js';
@@ -30,14 +31,22 @@ import { createSearchKnowledgeService } from '../../../agent/infra/tools/impleme
 import { AuthEvents } from '../../../shared/transport/events/auth-events.js';
 import { decodeSearchContent } from '../../../shared/transport/search-content.js';
 import { getCurrentConfig } from '../../config/environment.js';
-import { DEFAULT_LLM_MODEL, PROJECT } from '../../constants.js';
+import { BRV_DIR, DEFAULT_LLM_MODEL, PROJECT } from '../../constants.js';
 import { serializeTaskError, TaskError, TaskErrorCode } from '../../core/domain/errors/task-error.js';
 import { loadSources } from '../../core/domain/source/source-schema.js';
 import { TransportAgentEventNames, TransportDaemonEventNames, TransportStateEventNames, TransportTaskEventNames, } from '../../core/domain/transport/schemas.js';
+import { FileContextTreeArchiveService } from '../context-tree/file-context-tree-archive-service.js';
+import { DreamLockService } from '../dream/dream-lock-service.js';
+import { DreamLogStore } from '../dream/dream-log-store.js';
+import { DreamStateService } from '../dream/dream-state-service.js';
+import { DreamTrigger } from '../dream/dream-trigger.js';
 import { CurateExecutor } from '../executor/curate-executor.js';
+import { DreamExecutor } from '../executor/dream-executor.js';
 import { FolderPackExecutor } from '../executor/folder-pack-executor.js';
 import { QueryExecutor } from '../executor/query-executor.js';
 import { SearchExecutor } from '../executor/search-executor.js';
+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 { resolveSessionId } from './session-resolver.js';
@@ -198,7 +207,7 @@ async function start() {
     const sharedAllowedPaths = (sourcesData?.origins ?? []).map((o) => o.contextTreeRoot);
     const envConfig = getCurrentConfig();
     const agentConfig = {
-        apiBaseUrl: envConfig.llmApiBaseUrl,
+        apiBaseUrl: envConfig.llmBaseUrl,
         fileSystem: { allowedPaths: ['.', ...sharedAllowedPaths], workingDirectory: projectPath },
         llm: {
             maxIterations: 10,
@@ -307,7 +316,7 @@ async function start() {
     transport.on(TransportTaskEventNames.EXECUTE, (task) => {
         agentLog(`task:execute received taskId=${task.taskId} type=${task.type} activeTaskCount=${activeTaskCount + 1}`);
         // eslint-disable-next-line no-void
-        void executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor);
+        void executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor, searchService, configResult.storagePath);
     });
     // 8. Register with transport server (for TransportHandlers tracking)
     await transport.requestWithAck('agent:register', { projectPath });
@@ -315,8 +324,8 @@ async function start() {
     process.send?.({ clientId, type: 'ready' });
     agentLog('Ready — listening for tasks');
 }
-async function executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor) {
-    const { clientCwd, clientId, content, files, folderPath, taskId, type, worktreeRoot } = task;
+async function executeTask(task, curateExecutor, folderPackExecutor, queryExecutor, searchExecutor, searchKnowledgeService, storagePath) {
+    const { clientCwd, clientId, content, files, folderPath, force, taskId, trigger, type, worktreeRoot } = task;
     if (!transport || !agent)
         return;
     // Search tasks are pure BM25 retrieval — no LLM, no provider needed.
@@ -385,9 +394,17 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
         }
         try {
             let result;
+            let logId;
             switch (type) {
                 case 'curate': {
-                    result = await curateExecutor.executeWithAgent(agent, { clientCwd, content, files, projectRoot: projectPath, taskId, worktreeRoot });
+                    result = await curateExecutor.executeWithAgent(agent, {
+                        clientCwd,
+                        content,
+                        files,
+                        projectRoot: projectPath,
+                        taskId,
+                        worktreeRoot,
+                    });
                     break;
                 }
                 case 'curate-folder': {
@@ -401,8 +418,61 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
                     });
                     break;
                 }
+                case 'dream': {
+                    const brvDir = join(projectPath, BRV_DIR);
+                    const dreamLockService = new DreamLockService({ baseDir: brvDir });
+                    const dreamStateService = new DreamStateService({ baseDir: brvDir });
+                    // Run trigger check (acquires lock if eligible).
+                    // Gate 3 (queue) is pre-checked by the daemon (TransportHandlers.preDispatchCheck
+                    // for CLI dispatch, onAgentIdle for idle-trigger dispatch), so the agent treats
+                    // its own queue view as empty. Gates 1 (time) and 2 (activity) are re-checked here
+                    // as defense-in-depth in case state drifted between dispatch and execution.
+                    const dreamTrigger = new DreamTrigger({
+                        dreamLockService,
+                        dreamStateService,
+                        getQueueLength: () => 0,
+                    });
+                    const eligibility = await dreamTrigger.tryStartDream(projectPath, force);
+                    if (!eligibility.eligible) {
+                        result = `Dream skipped: ${eligibility.reason}`;
+                        break;
+                    }
+                    const dreamExecutor = new DreamExecutor({
+                        archiveService: new FileContextTreeArchiveService(),
+                        curateLogStore: new FileCurateLogStore({ baseDir: storagePath }),
+                        dreamLockService,
+                        dreamLogStore: new DreamLogStore({ baseDir: brvDir }),
+                        dreamStateService,
+                        reviewBackupStore: new FileReviewBackupStore(brvDir),
+                        searchService: searchKnowledgeService,
+                    });
+                    const dreamResult = await dreamExecutor.executeWithAgent(agent, {
+                        priorMtime: eligibility.priorMtime,
+                        projectRoot: projectPath,
+                        taskId,
+                        trigger: trigger ?? 'cli',
+                    });
+                    result = dreamResult.result;
+                    logId = dreamResult.logId;
+                    break;
+                }
                 case 'query': {
-                    result = await queryExecutor.executeWithAgent(agent, { query: content, taskId, worktreeRoot });
+                    const queryResult = await queryExecutor.executeWithAgent(agent, { query: content, taskId, worktreeRoot });
+                    result = queryResult.response;
+                    // Send query metadata to daemon for QueryLogHandler (crosses process boundary via transport).
+                    // Must arrive BEFORE task:completed so setQueryResult runs before onTaskCompleted.
+                    try {
+                        transport.request(TransportTaskEventNames.QUERY_RESULT, {
+                            matchedDocs: queryResult.matchedDocs,
+                            searchMetadata: queryResult.searchMetadata,
+                            taskId,
+                            tier: queryResult.tier,
+                            timing: queryResult.timing,
+                        });
+                    }
+                    catch {
+                        agentLog(`task:queryResult send failed taskId=${taskId}`);
+                    }
                     break;
                 }
                 case 'search': {
@@ -415,7 +485,7 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
             // Emit task:completed
             agentLog(`task:completed taskId=${taskId}`);
             try {
-                transport.request(TransportTaskEventNames.COMPLETED, { clientId, result, taskId });
+                transport.request(TransportTaskEventNames.COMPLETED, { clientId, ...(logId ? { logId } : {}), projectPath, result, taskId });
             }
             catch (error) {
                 agentLog(`task:completed send failed taskId=${taskId}: ${error instanceof Error ? error.message : String(error)}`);
@@ -426,7 +496,7 @@ async function executeTask(task, curateExecutor, folderPackExecutor, queryExecut
             const errorData = serializeTaskError(error);
             agentLog(`task:error taskId=${taskId} error=${errorData.message}`);
             try {
-                transport.request(TransportTaskEventNames.ERROR, { clientId, error: errorData, taskId });
+                transport.request(TransportTaskEventNames.ERROR, { clientId, error: errorData, projectPath, taskId });
             }
             catch (error_) {
                 agentLog(`task:error send failed taskId=${taskId}: ${error_ instanceof Error ? error_.message : String(error_)}`);

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

@@ -23,21 +23,25 @@
 import { GlobalInstanceManager } from '@campfirein/brv-transport-client';
 import express from 'express';
 import { fork } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { mkdirSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ReviewEvents } from '../../../shared/transport/events/review-events.js';
 import { AGENT_IDLE_CHECK_INTERVAL_MS, AGENT_IDLE_TIMEOUT_MS, AGENT_POOL_MAX_SIZE, BRV_DIR, HEARTBEAT_FILE, } from '../../constants.js';
-import { TransportStateEventNames } from '../../core/domain/transport/schemas.js';
+import { TransportStateEventNames, TransportTaskEventNames, } from '../../core/domain/transport/schemas.js';
 import { getGlobalDataDir } from '../../utils/global-data-path.js';
 import { getProjectDataDir } from '../../utils/path-utils.js';
 import { crashLog, processLog } from '../../utils/process-logger.js';
 import { ClientManager } from '../client/client-manager.js';
 import { ProjectConfigStore } from '../config/file-config-store.js';
+import { DreamStateService } from '../dream/dream-state-service.js';
+import { DreamTrigger } from '../dream/dream-trigger.js';
 import { createReviewApiRouter } from '../http/review-api-handler.js';
 import { broadcastToProjectRoom } from '../process/broadcast-utils.js';
 import { CurateLogHandler } from '../process/curate-log-handler.js';
 import { setupFeatureHandlers } from '../process/feature-handlers.js';
+import { QueryLogHandler } from '../process/query-log-handler.js';
 import { TransportHandlers } from '../process/transport-handlers.js';
 import { ProjectRegistry } from '../project/project-registry.js';
 import { createProviderOAuthTokenStore } from '../provider-oauth/provider-oauth-token-store.js';
@@ -188,12 +192,26 @@ async function main() {
             log,
             projectRegistry,
         });
+        // 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 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().
+        const makeDreamPreCheckTrigger = (projectPath) => new DreamTrigger({
+            dreamLockService: {
+                tryAcquire() {
+                    throw new Error('Lock must not be acquired during daemon eligibility pre-check');
+                },
+            },
+            dreamStateService: new DreamStateService({ baseDir: join(projectPath, BRV_DIR) }),
+            getQueueLength,
+        });
         // Agent idle timeout policy — kills agents after period of inactivity
         const agentIdleTimeoutPolicy = new AgentIdleTimeoutPolicy({
             checkIntervalMs: AGENT_IDLE_CHECK_INTERVAL_MS,
-            getQueueLength: (projectPath) => agentPool?.getQueueState().find((q) => q.projectPath === projectPath)?.queueLength ?? 0,
+            getQueueLength,
             log,
-            onAgentIdle(projectPath, queueLength) {
+            async onAgentIdle(projectPath, queueLength) {
                 // Don't kill agents that have queued tasks waiting
                 if (queueLength > 0) {
                     log(`Skipping idle cleanup: ${projectPath} has ${queueLength} queued tasks`);
@@ -205,7 +223,28 @@ async function main() {
                     log(`Skipping idle cleanup: ${projectPath} has active task`);
                     return;
                 }
-                log(`Killing idle agent: ${projectPath}`);
+                // Check dream eligibility before killing (gates 1-3 only, no lock).
+                // Lock acquisition happens in the agent process when the dream task executes.
+                try {
+                    const result = await makeDreamPreCheckTrigger(projectPath).checkEligibility(projectPath);
+                    if (result.eligible) {
+                        log(`Dream eligible, dispatching dream task: ${projectPath}`);
+                        agentPool?.submitTask({
+                            clientId: 'daemon',
+                            content: 'Memory consolidation (idle trigger)',
+                            force: false,
+                            projectPath,
+                            taskId: randomUUID(),
+                            trigger: 'agent-idle',
+                            type: 'dream',
+                        });
+                        return;
+                    }
+                    log(`Dream not eligible (${result.reason}), killing idle agent: ${projectPath}`);
+                }
+                catch {
+                    log(`Dream eligibility check failed, killing idle agent: ${projectPath}`);
+                }
                 agentPool?.handleAgentDisconnected(projectPath);
             },
             timeoutMs: AGENT_IDLE_TIMEOUT_MS,
@@ -247,15 +286,45 @@ async function main() {
             // Also broadcast to the project room so TUI and other connected clients are notified
             broadcastToProjectRoom(projectRegistry, projectRouter, info.projectPath, ReviewEvents.NOTIFY, payload, info.clientId);
         });
+        const queryLogHandler = new QueryLogHandler();
         const transportHandlers = new TransportHandlers({
             agentPool,
             clientManager,
-            lifecycleHooks: [curateLogHandler],
+            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
+            // gate 3 (queue). The agent-side check kept gate 3 hardcoded to skip,
+            // which made the CLI ignore the spec when other tasks were queued.
+            async preDispatchCheck(task, projectPath) {
+                if (task.type !== 'dream' || task.force)
+                    return { eligible: true };
+                if (!projectPath)
+                    return { eligible: true };
+                try {
+                    const result = await makeDreamPreCheckTrigger(projectPath).checkEligibility(projectPath);
+                    return result.eligible ? { eligible: true } : { eligible: false, skipResult: `Dream skipped: ${result.reason}` };
+                }
+                catch {
+                    // Fail-open on pre-check errors: let the agent's own gate check be the fallback.
+                    return { eligible: true };
+                }
+            },
             projectRegistry,
             projectRouter,
             transport: transportServer,
         });
         transportHandlers.setup();
+        // Wire query metadata from agent process → QueryLogHandler.
+        // Agent sends task:queryResult BEFORE task:completed (Socket.IO preserves order),
+        // so setQueryResult runs before onTaskCompleted merges the metadata.
+        transportServer.onRequest(TransportTaskEventNames.QUERY_RESULT, (data) => {
+            queryLogHandler.setQueryResult(data.taskId, {
+                matchedDocs: data.matchedDocs,
+                searchMetadata: data.searchMetadata,
+                tier: data.tier,
+                timing: data.timing,
+            });
+        });
         // 8. Create idle timeout policy + shutdown handler
         //    (must be created before wiring closures that reference them)
         // onIdle captures shutdownHandler via closure; safe because

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

@@ -0,0 +1,37 @@
+type DreamLockServiceOptions = {
+    baseDir: string;
+    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.
+ */
+export declare class DreamLockService {
+    private readonly lockFilePath;
+    private readonly staleTimeoutMs;
+    constructor(opts: DreamLockServiceOptions);
+    /** Clear PID content but keep the file. mtime becomes "last dream completion time". */
+    release(): Promise<void>;
+    /**
+     * Restore mtime after a failed dream so the time gate isn't fooled.
+     * If priorMtime is 0 (lock didn't exist before), delete the file.
+     */
+    rollback(priorMtime: number): Promise<void>;
+    /**
+     * Try to acquire the dream lock.
+     *
+     * Returns `{ acquired: true, priorMtime }` on success, where priorMtime
+     * is the lock file's mtime before acquisition (0 if file didn't exist).
+     *
+     * Returns `{ acquired: false }` if another live, non-stale process holds the lock.
+     */
+    tryAcquire(): Promise<{
+        acquired: false;
+    } | {
+        acquired: true;
+        priorMtime: number;
+    }>;
+}
+export {};

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

@@ -0,0 +1,88 @@
+import { mkdir, readFile, stat, unlink, utimes, writeFile } from 'node:fs/promises';
+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.
+ */
+export class DreamLockService {
+    lockFilePath;
+    staleTimeoutMs;
+    constructor(opts) {
+        this.lockFilePath = join(opts.baseDir, LOCK_FILENAME);
+        this.staleTimeoutMs = opts.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS;
+    }
+    /** Clear PID content but keep the file. mtime becomes "last dream completion time". */
+    async release() {
+        await writeFile(this.lockFilePath, '', 'utf8');
+    }
+    /**
+     * Restore mtime after a failed dream so the time gate isn't fooled.
+     * If priorMtime is 0 (lock didn't exist before), delete the file.
+     */
+    async rollback(priorMtime) {
+        if (priorMtime === 0) {
+            await unlink(this.lockFilePath).catch(() => { });
+            return;
+        }
+        await writeFile(this.lockFilePath, '', 'utf8');
+        const time = new Date(priorMtime);
+        await utimes(this.lockFilePath, time, time);
+    }
+    /**
+     * Try to acquire the dream lock.
+     *
+     * Returns `{ acquired: true, priorMtime }` on success, where priorMtime
+     * is the lock file's mtime before acquisition (0 if file didn't exist).
+     *
+     * Returns `{ acquired: false }` if another live, non-stale process holds the lock.
+     */
+    async tryAcquire() {
+        let priorMtime = 0;
+        try {
+            const lockStat = await stat(this.lockFilePath);
+            priorMtime = lockStat.mtimeMs;
+            const content = await readFile(this.lockFilePath, 'utf8');
+            const pid = Number.parseInt(content.trim(), 10);
+            if (!Number.isNaN(pid) && pid > 0) {
+                const alive = isProcessAlive(pid);
+                const stale = Date.now() - lockStat.mtimeMs > this.staleTimeoutMs;
+                if (alive && !stale) {
+                    return { acquired: false };
+                }
+            }
+        }
+        catch {
+            // File doesn't exist — priorMtime stays 0
+        }
+        // Write our PID
+        await mkdir(dirname(this.lockFilePath), { recursive: true });
+        await writeFile(this.lockFilePath, String(process.pid), 'utf8');
+        // Write-then-verify: re-read to confirm we won the race
+        try {
+            const content = await readFile(this.lockFilePath, 'utf8');
+            if (content.trim() !== String(process.pid)) {
+                return { acquired: false };
+            }
+        }
+        catch {
+            return { acquired: false };
+        }
+        return { acquired: true, priorMtime };
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM: process exists but we can't signal it — treat as alive
+        if (error.code === 'EPERM')
+            return true;
+        return false;
+    }
+}