byterover-cli 3.0.1 → 3.2.0

package/.env.production

@@ -1,3 +1,7 @@
+# ByteRover CLI - Environment Configuration
+# Copy this file to .env.development (for dev) or .env.production (for production)
+# and fill in the values for your environment.
+
 BRV_API_BASE_URL=https://iam.byterover.dev/api/v1
 BRV_AUTHORIZATION_URL=https://iam.byterover.dev/api/v1/oidc/authorize
 BRV_COGIT_API_BASE_URL=https://v3-cgit.byterover.dev/api/v1

package/README.md

@@ -241,6 +241,23 @@ ByteRover CLI supports 18 LLM providers out of the box. Use `brv providers conne
 
 </details>
 
+## Worktrees and Knowledge Sources
+
+> **Vocabulary**
+> - **Worktree link** — a subdirectory pointer to a parent project (`brv worktree`)
+> - **Source** — a read-only reference to another project's knowledge (`brv source`)
+> - **Origin** — where an indexed search result came from (`local` vs `shared`)
+
+ByteRover can run from a linked subdirectory without creating a nested `.brv/`.
+
+- `projectRoot`: the directory that owns `.brv/config.json`
+- `worktreeRoot`: the linked worktree directory, or `projectRoot` when unlinked
+- `clientCwd`: the shell cwd where you ran `brv`
+
+When you run `brv query` or `brv curate` from a linked worktree, implicit defaults use `worktreeRoot` so scope stays stable even if `clientCwd` drifts deeper into the package. Explicit relative paths that you pass yourself, such as `brv curate -f ./src/auth.ts`, still resolve from `clientCwd` to match normal shell behavior.
+
+Use `brv worktree add` from the project root to register a subdirectory (or sibling) as a worktree. This creates a `.brv` pointer file in the target directory that redirects to the parent project — the same pattern git uses for `git worktree`. Use `brv worktree remove` to unregister, and `brv worktree list` to inspect. To search another project's knowledge from here, use `brv source add <path>` (with `brv source list` / `brv source remove` to inspect or detach).
+
 ## Documentation
 
 Visit [**docs.byterover.dev**](https://docs.byterover.dev) for full guides on setup, integrations, and advanced usage.

package/dist/agent/core/domain/tools/constants.d.ts

@@ -9,6 +9,7 @@ export declare const ToolName: {
     readonly EXPAND_KNOWLEDGE: 'expand_knowledge';
     readonly GLOB_FILES: 'glob_files';
     readonly GREP_CONTENT: 'grep_content';
+    readonly INGEST_RESOURCE: 'ingest_resource';
     readonly LIST_DIRECTORY: 'list_directory';
     readonly LLM_MAP: 'llm_map';
     readonly READ_FILE: 'read_file';

package/dist/agent/core/domain/tools/constants.js

@@ -9,6 +9,7 @@ export const ToolName = {
     EXPAND_KNOWLEDGE: 'expand_knowledge',
     GLOB_FILES: 'glob_files',
     GREP_CONTENT: 'grep_content',
+    INGEST_RESOURCE: 'ingest_resource',
     LIST_DIRECTORY: 'list_directory',
     LLM_MAP: 'llm_map',
     READ_FILE: 'read_file',

package/dist/agent/core/interfaces/cipher-services.d.ts

@@ -1,6 +1,7 @@
 import type { AgentEventBus, SessionEventBus } from '../../infra/events/event-emitter.js';
 import type { FileSystemService } from '../../infra/file-system/file-system-service.js';
 import type { CompactionService } from '../../infra/llm/context/compaction/compaction-service.js';
+import type { AbstractGenerationQueue } from '../../infra/map/abstract-queue.js';
 import type { MemoryManager } from '../../infra/memory/memory-manager.js';
 import type { ProcessService } from '../../infra/process/process-service.js';
 import type { MessageStorageService } from '../../infra/storage/message-storage-service.js';
@@ -30,6 +31,11 @@ import type { IToolScheduler } from './i-tool-scheduler.js';
  * - ToolProvider: Provides available tools
  */
 export interface CipherAgentServices {
+    /**
+     * Background queue for generating L0/L1 abstract files (.abstract.md, .overview.md).
+     * Generator is injected lazily via setGenerator() from rebindCurateTools().
+     */
+    abstractQueue: AbstractGenerationQueue;
     agentEventBus: AgentEventBus;
     blobStorage: IBlobStorage;
     /**
@@ -50,6 +56,8 @@ export interface CipherAgentServices {
     toolManager: ToolManager;
     toolProvider: ToolProvider;
     toolScheduler: IToolScheduler;
+    /** Absolute path to the project working directory. */
+    workingDirectory: string;
 }
 /**
  * Session-specific services created per conversation session.

package/dist/agent/core/interfaces/i-cipher-agent.d.ts

@@ -78,6 +78,7 @@ export interface ICipherAgent {
      */
     createTaskSession(taskId: string, commandType: string, options?: {
         mapRootEligible?: boolean;
+        userFacing?: boolean;
     }): Promise<string>;
     /**
      * Delete a sandbox variable from the agent's default session.

package/dist/agent/infra/agent/agent-error-codes.d.ts

@@ -1,6 +1,5 @@
 /**
  * Agent-specific error codes.
- * Follows DextoAgent pattern for typed error identification.
  */
 export declare enum AgentErrorCode {
     ALREADY_STARTED = "agent_already_started",

package/dist/agent/infra/agent/agent-error-codes.js

@@ -1,6 +1,5 @@
 /**
  * Agent-specific error codes.
- * Follows DextoAgent pattern for typed error identification.
  */
 export var AgentErrorCode;
 (function (AgentErrorCode) {

package/dist/agent/infra/agent/agent-error.d.ts

@@ -4,7 +4,6 @@ import { AgentErrorCode } from './agent-error-codes.js';
  * Agent-specific error with typed error codes.
  * Extends ExitError for oclif CLI integration.
  *
- * Follows DextoAgent pattern with static factory methods
  * for creating well-typed errors.
  */
 export declare class AgentError extends ExitError {

package/dist/agent/infra/agent/agent-error.js

@@ -4,7 +4,6 @@ import { AgentErrorCode } from './agent-error-codes.js';
  * Agent-specific error with typed error codes.
  * Extends ExitError for oclif CLI integration.
  *
- * Follows DextoAgent pattern with static factory methods
  * for creating well-typed errors.
  */
 export class AgentError extends ExitError {

package/dist/agent/infra/agent/agent-schemas.d.ts

@@ -46,13 +46,16 @@ export type ValidatedSessionConfig = z.output<typeof SessionConfigSchema>;
  */
 export declare const FileSystemConfigSchema: z.ZodObject<{
     allowedExtensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     maxFileSize: z.ZodOptional<z.ZodNumber>;
     workingDirectory: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
+    allowedPaths?: string[] | undefined;
     allowedExtensions?: string[] | undefined;
     workingDirectory?: string | undefined;
     maxFileSize?: number | undefined;
 }, {
+    allowedPaths?: string[] | undefined;
     allowedExtensions?: string[] | undefined;
     workingDirectory?: string | undefined;
     maxFileSize?: number | undefined;
@@ -101,13 +104,16 @@ export declare const AgentConfigSchema: z.ZodObject<{
     }>>;
     fileSystem: z.ZodOptional<z.ZodObject<{
         allowedExtensions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        allowedPaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         maxFileSize: z.ZodOptional<z.ZodNumber>;
         workingDirectory: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
+        allowedPaths?: string[] | undefined;
         allowedExtensions?: string[] | undefined;
         workingDirectory?: string | undefined;
         maxFileSize?: number | undefined;
     }, {
+        allowedPaths?: string[] | undefined;
         allowedExtensions?: string[] | undefined;
         workingDirectory?: string | undefined;
         maxFileSize?: number | undefined;
@@ -185,6 +191,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
         storageDir: string;
     } | undefined;
     fileSystem?: {
+        allowedPaths?: string[] | undefined;
         allowedExtensions?: string[] | undefined;
         workingDirectory?: string | undefined;
         maxFileSize?: number | undefined;
@@ -223,6 +230,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
         maxBlobSize?: number | undefined;
     } | undefined;
     fileSystem?: {
+        allowedPaths?: string[] | undefined;
         allowedExtensions?: string[] | undefined;
         workingDirectory?: string | undefined;
         maxFileSize?: number | undefined;

package/dist/agent/infra/agent/agent-schemas.js

@@ -27,6 +27,7 @@ export const SessionConfigSchema = z
 export const FileSystemConfigSchema = z
     .object({
     allowedExtensions: z.array(z.string()).optional().describe('Allowed file extensions'),
+    allowedPaths: z.array(z.string()).optional().describe('Allowed paths for file operations (default: ["."])'),
     maxFileSize: z.number().positive().optional().describe('Maximum file size in bytes'),
     workingDirectory: z.string().optional().describe('Working directory for file operations'),
 })

package/dist/agent/infra/agent/agent-state-manager.d.ts

@@ -9,11 +9,9 @@ export interface SessionOverride {
     llm?: Partial<ValidatedLLMConfig>;
 }
 /**
- * Unified agent state manager combining DextoAgent config patterns with execution state tracking.
- *
  * Manages two concerns:
  *
- * 1. Configuration State (DextoAgent pattern):
+ * 1. Configuration State:
  *    - baselineConfig: Original validated config, never mutated
  *    - runtimeConfig: Current active config, can be mutated
  *    - sessionOverrides: Per-session config overrides

package/dist/agent/infra/agent/agent-state-manager.js

@@ -1,9 +1,7 @@
 /**
- * Unified agent state manager combining DextoAgent config patterns with execution state tracking.
- *
  * Manages two concerns:
  *
- * 1. Configuration State (DextoAgent pattern):
+ * 1. Configuration State:
  *    - baselineConfig: Original validated config, never mutated
  *    - runtimeConfig: Current active config, can be mutated
  *    - sessionOverrides: Per-session config overrides

package/dist/agent/infra/agent/base-agent.d.ts

@@ -3,7 +3,7 @@ import type { AgentEventBus } from '../events/event-emitter.js';
 import { type LLMUpdates, type ValidatedAgentConfig, type ValidatedLLMConfig } from './agent-schemas.js';
 import { AgentStateManager } from './agent-state-manager.js';
 /**
- * Abstract base agent class encapsulating DextoAgent patterns.
+ * Abstract base agent class encapsulating.
  *
  * Provides:
  * - Two-phase initialization (constructor + start)

package/dist/agent/infra/agent/base-agent.js

@@ -2,7 +2,7 @@ import { AgentError } from './agent-error.js';
 import { AgentConfigSchema, LLMUpdatesSchema } from './agent-schemas.js';
 import { AgentStateManager } from './agent-state-manager.js';
 /**
- * Abstract base agent class encapsulating DextoAgent patterns.
+ * Abstract base agent class encapsulating.
  *
  * Provides:
  * - Two-phase initialization (constructor + start)

package/dist/agent/infra/agent/cipher-agent.d.ts

@@ -25,7 +25,7 @@ import { BaseAgent } from './base-agent.js';
  * - Typed error handling
  * - Configuration validation (Zod)
  *
- * Architecture (DextoAgent pattern):
+ * Architecture:
  * - Agent creates AgentEventBus in constructor (available before start)
  * - Agent creates and owns shared services (ToolManager, SystemPromptManager, etc.)
  * - SessionManager creates session-specific services (LLM, SessionEventBus)
@@ -57,7 +57,11 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      * Used for bulk deregistration on agent teardown (cleanupServices).
      */
     private readonly rootEligibleSessions;
+    /** Lazily-created session compressor, rebuilt on each rebindCurateTools() call. */
+    private sessionCompressor?;
     private sessionManager?;
+    /** Tracks user-facing task sessions for post-session memory extraction. */
+    private readonly userFacingTaskSessions;
     /**
      * Creates a new CipherAgent instance.
      * Does NOT initialize services - call start() for async initialization.
@@ -114,6 +118,7 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      */
     createTaskSession(taskId: string, commandType: string, options?: {
         mapRootEligible?: boolean;
+        userFacing?: boolean;
     }): Promise<string>;
     /**
      * Delete a sandbox variable from the agent's default session.
@@ -131,6 +136,11 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      * Delete a task session and all its resources (sandbox + history).
      */
     deleteTaskSession(sessionId: string): Promise<void>;
+    /**
+     * Wait for shared background work (such as abstract generation) to finish.
+     * Used by task executors before reporting task completion.
+     */
+    drainBackgroundWork(): Promise<void>;
     /**
      * Execute the agent with user input.
      * Uses the agent's default session (created during start()).
@@ -260,6 +270,8 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      * Uses lazy providers when injected (child process mode), otherwise static config.
      */
     private buildHttpConfig;
+    private createFreshRetryableGenerator;
+    private drainAbstractQueue;
     private getHistoryStorageInternal;
     private getSessionIdInternal;
     private getSessionManagerInternal;
@@ -273,7 +285,9 @@ export declare class CipherAgent extends BaseAgent implements ICipherAgent {
      * Rebuild map tool dependencies and update ToolProvider + SandboxService.
      * Called from both start() (initial setup) and refreshProviderConfig() (hot-swap).
      */
+    private rebindCurateTools;
     private rebindMapTools;
+    private refreshSessionCompressorFromTransport;
     /**
      * Register a session as root-eligible and track it for lifecycle cleanup.
      * Routes all root-eligible registrations through a single point.

package/dist/agent/infra/agent/cipher-agent.js

@@ -1,17 +1,25 @@
 import { randomUUID } from 'node:crypto';
 import { setMaxListeners } from 'node:events';
+import { TransportStateEventNames } from '../../../server/core/domain/transport/schemas.js';
+import { agentLog } from '../../../server/utils/process-logger.js';
 import { getEffectiveMaxInputTokens, resolveRegistryProvider } from '../../core/domain/llm/index.js';
 import { STREAMING_EVENT_NAMES } from '../../core/domain/streaming/types.js';
 import { ToolName } from '../../core/domain/tools/constants.js';
 import { AgentEventBus } from '../events/event-emitter.js';
+import { RetryableContentGenerator } from '../llm/generators/index.js';
 import { createGeneratorForProvider } from '../llm/providers/index.js';
+import { DEFAULT_RETRY_POLICY } from '../llm/retry/retry-policy.js';
 import { EventBasedLogger } from '../logger/event-based-logger.js';
 import { deregisterRootEligibleSession, registerRootEligibleSession } from '../map/agentic-map-service.js';
+import { MemoryDeduplicator } from '../memory/memory-deduplicator.js';
+import { createCurateService } from '../sandbox/curate-service.js';
+import { SessionCompressor } from '../session/session-compressor.js';
 import { SessionManager } from '../session/session-manager.js';
 import { TransportEventBridge } from '../transport/transport-event-bridge.js';
 import { AgentError } from './agent-error.js';
 import { BaseAgent } from './base-agent.js';
 import { createCipherAgentServices } from './service-initializer.js';
+const QUEUE_TRACE_ENABLED = process.env.BRV_QUEUE_TRACE === '1';
 /**
  * CipherAgent - Main agent implementation extending BaseAgent.
  *
@@ -22,7 +30,7 @@ import { createCipherAgentServices } from './service-initializer.js';
  * - Typed error handling
  * - Configuration validation (Zod)
  *
- * Architecture (DextoAgent pattern):
+ * Architecture:
  * - Agent creates AgentEventBus in constructor (available before start)
  * - Agent creates and owns shared services (ToolManager, SystemPromptManager, etc.)
  * - SessionManager creates session-specific services (LLM, SessionEventBus)
@@ -55,7 +63,11 @@ export class CipherAgent extends BaseAgent {
      * Used for bulk deregistration on agent teardown (cleanupServices).
      */
     rootEligibleSessions = new Set();
+    /** Lazily-created session compressor, rebuilt on each rebindCurateTools() call. */
+    sessionCompressor;
     sessionManager;
+    /** Tracks user-facing task sessions for post-session memory extraction. */
+    userFacingTaskSessions = new Set();
     /**
      * Creates a new CipherAgent instance.
      * Does NOT initialize services - call start() for async initialization.
@@ -72,7 +84,7 @@ export class CipherAgent extends BaseAgent {
     constructor(config, brvConfig, options) {
         // Call parent constructor (validates with Zod)
         super(config);
-        // Create event bus early (DextoAgent pattern - available before start)
+        // Create event bus early (available before start)
         this._agentEventBus = new AgentEventBus();
         this._brvConfig = brvConfig;
         this._projectIdProvider = options?.projectIdProvider;
@@ -146,6 +158,8 @@ export class CipherAgent extends BaseAgent {
     }
     // === Public Methods (alphabetical order) ===
     async cleanupServices() {
+        // Drain abstract generation queue before session disposal
+        await this.drainAbstractQueue();
         // Abort all active streams and clear controllers
         for (const controller of this.activeStreamControllers.values()) {
             controller.abort();
@@ -207,6 +221,10 @@ export class CipherAgent extends BaseAgent {
         if (options?.mapRootEligible) {
             this.registerSessionInternal(childSession.id);
         }
+        // Track user-facing sessions for post-session memory extraction.
+        if (options?.userFacing) {
+            this.userFacingTaskSessions.add(childSession.id);
+        }
         return childSession.id;
     }
     /**
@@ -248,6 +266,38 @@ export class CipherAgent extends BaseAgent {
      */
     async deleteTaskSession(sessionId) {
         this.ensureStarted();
+        // Compress memories for user-facing sessions before disposal (fail-open).
+        if (this.userFacingTaskSessions.has(sessionId) && this.sessionCompressor) {
+            try {
+                // Refresh OAuth token and rebuild compressor before compression
+                if (this._transportClient && this.services) {
+                    try {
+                        await this.refreshSessionCompressorFromTransport();
+                    }
+                    catch {
+                        // Fail-open: use existing compressor with potentially stale token
+                    }
+                }
+                const session = this.getSessionManagerInternal().getSession(sessionId);
+                if (session) {
+                    const messages = session.getLLMService().getContextManager().getComprehensiveMessages();
+                    const commandType = this.getSessionManagerInternal().getSessionCommandType(sessionId) ?? 'curate';
+                    // Task sessions often contain a compact prompt/response trace, so use a
+                    // lower threshold than the interactive default to preserve useful memories.
+                    await this.sessionCompressor.compress(messages, commandType, { minMessages: 2 }).catch((error) => {
+                        const msg = error instanceof Error ? error.message : String(error);
+                        console.debug(`[CipherAgent] Session compression failed for ${sessionId}: ${msg}`);
+                    });
+                }
+            }
+            catch (error) {
+                // Fail-open: synchronous errors in the session accessor chain (e.g. corrupted
+                // session state) must not prevent clearSession + deleteSession from running.
+                const msg = error instanceof Error ? error.message : String(error);
+                console.debug(`[CipherAgent] Session compression setup failed for ${sessionId}: ${msg}`);
+            }
+            this.userFacingTaskSessions.delete(sessionId);
+        }
         await this.services.sandboxService.clearSession(sessionId);
         await this.getSessionManagerInternal().deleteSession(sessionId);
         // Deregister root-eligible record if this agent owns it.
@@ -258,6 +308,14 @@ export class CipherAgent extends BaseAgent {
             this.rootEligibleSessions.delete(sessionId);
         }
     }
+    /**
+     * Wait for shared background work (such as abstract generation) to finish.
+     * Used by task executors before reporting task completion.
+     */
+    async drainBackgroundWork() {
+        this.ensureStarted();
+        await this.drainAbstractQueue();
+    }
     /**
      * Execute the agent with user input.
      * Uses the agent's default session (created during start()).
@@ -388,7 +446,7 @@ export class CipherAgent extends BaseAgent {
         return this.getSystemPromptManagerInternal().build({});
     }
     async initializeServices() {
-        // Pass pre-created event bus to service initializer (DextoAgent pattern)
+        // Pass pre-created event bus to service initializer
         return createCipherAgentServices(this.config, this._agentEventBus);
     }
     /**
@@ -461,6 +519,8 @@ export class CipherAgent extends BaseAgent {
         this.services.sandboxService.setSessionManager?.(this.sessionManager);
         // Rebind map tools with fresh generator/tokenizer/maxContextTokens
         this.rebindMapTools(services, httpConfig, sessionLLMConfig);
+        // Rebind curate tools with fresh generator + abstract queue
+        this.rebindCurateTools(services, httpConfig, sessionLLMConfig);
     }
     /**
      * Reset the agent to initial state.
@@ -562,6 +622,8 @@ export class CipherAgent extends BaseAgent {
         // Uses rebindMapTools() which atomically replaces map tools with fresh deps
         // (generator, tokenizer, maxContextTokens, logger).
         this.rebindMapTools(services, httpConfig, sessionLLMConfig);
+        // Wire abstract generation queue with curate generator + rebuild curate service.
+        this.rebindCurateTools(services, httpConfig, sessionLLMConfig);
         // Create event bridge if transport client is injected (child process mode).
         // The bridge forwards AgentEventBus llmservice:* events to the transport server.
         if (this._transportClient) {
@@ -778,6 +840,64 @@ export class CipherAgent extends BaseAgent {
         };
     }
     // === Private Helpers (alphabetical order) ===
+    createFreshRetryableGenerator(fresh, options) {
+        if (fresh.providerKeyMissing || !fresh.activeProvider) {
+            return;
+        }
+        const provider = fresh.provider ?? (fresh.openRouterApiKey ? 'openrouter' : 'byterover');
+        const freshGenerator = createGeneratorForProvider(provider, {
+            apiKey: provider === 'openrouter'
+                ? (fresh.openRouterApiKey ?? fresh.providerApiKey)
+                : fresh.providerApiKey,
+            baseUrl: fresh.providerBaseUrl,
+            headers: fresh.providerHeaders,
+            httpConfig: options.httpConfig,
+            httpReferer: options.httpReferer,
+            maxTokens: 4096,
+            model: fresh.activeModel ?? options.modelFallback,
+            siteName: options.siteName,
+            temperature: 0,
+        });
+        return new RetryableContentGenerator(freshGenerator, { policy: DEFAULT_RETRY_POLICY });
+    }
+    async drainAbstractQueue() {
+        const abstractQueue = this.services?.abstractQueue;
+        if (!abstractQueue) {
+            return;
+        }
+        const settleDeadline = Date.now() + 5000;
+        let idleSince;
+        let pass = 0;
+        /* eslint-disable no-await-in-loop */
+        while (Date.now() <= settleDeadline) {
+            pass++;
+            if (QUEUE_TRACE_ENABLED) {
+                agentLog(`drainAbstractQueue:pass:${pass}:start`);
+            }
+            await abstractQueue.drain();
+            const status = abstractQueue.getStatus();
+            if (QUEUE_TRACE_ENABLED) {
+                agentLog(`drainAbstractQueue:pass:${pass}:status pending=${status.pending} processing=${status.processing} processed=${status.processed} failed=${status.failed}`);
+            }
+            if (!status.processing && status.pending === 0) {
+                idleSince ??= Date.now();
+                if (Date.now() - idleSince >= 250) {
+                    if (QUEUE_TRACE_ENABLED) {
+                        agentLog(`drainAbstractQueue:settled pass=${pass}`);
+                    }
+                    return;
+                }
+            }
+            else {
+                idleSince = undefined;
+            }
+            await new Promise((resolve) => { setTimeout(resolve, 100); });
+        }
+        /* eslint-enable no-await-in-loop */
+        if (QUEUE_TRACE_ENABLED) {
+            agentLog('drainAbstractQueue:deadline-reached');
+        }
+    }
     getHistoryStorageInternal() {
         const storage = this.services?.historyStorage;
         if (!storage) {
@@ -818,6 +938,54 @@ export class CipherAgent extends BaseAgent {
      * Rebuild map tool dependencies and update ToolProvider + SandboxService.
      * Called from both start() (initial setup) and refreshProviderConfig() (hot-swap).
      */
+    rebindCurateTools(services, httpConfig, sessionLLMConfig) {
+        const curateProvider = sessionLLMConfig.provider
+            ?? (sessionLLMConfig.openRouterApiKey ? 'openrouter' : 'byterover');
+        const curateGenerator = createGeneratorForProvider(curateProvider, {
+            apiKey: curateProvider === 'openrouter'
+                ? (sessionLLMConfig.openRouterApiKey ?? sessionLLMConfig.providerApiKey)
+                : sessionLLMConfig.providerApiKey,
+            baseUrl: sessionLLMConfig.providerBaseUrl,
+            headers: sessionLLMConfig.providerHeaders,
+            httpConfig: httpConfig,
+            httpReferer: sessionLLMConfig.httpReferer,
+            maxTokens: 4096,
+            model: sessionLLMConfig.model,
+            siteName: sessionLLMConfig.siteName,
+            temperature: 0,
+        });
+        // Wrap with retry for background resilience (no event bus — background tasks have no UI)
+        const retryableCurateGenerator = new RetryableContentGenerator(curateGenerator, {
+            policy: DEFAULT_RETRY_POLICY,
+        });
+        // Wire generator into the abstract queue so background generation can proceed
+        services.abstractQueue.setGenerator(retryableCurateGenerator);
+        // Refresh OAuth token before each background generation (tokens expire between tasks)
+        if (this._transportClient) {
+            const transportClient = this._transportClient;
+            services.abstractQueue.setBeforeProcess(async () => {
+                const fresh = await transportClient.requestWithAck(TransportStateEventNames.GET_PROVIDER_CONFIG);
+                const retryableFreshGenerator = this.createFreshRetryableGenerator(fresh, {
+                    httpConfig,
+                    httpReferer: sessionLLMConfig.httpReferer,
+                    modelFallback: sessionLLMConfig.model,
+                    siteName: sessionLLMConfig.siteName,
+                });
+                if (!retryableFreshGenerator) {
+                    return;
+                }
+                services.abstractQueue.setGenerator(retryableFreshGenerator);
+            });
+        }
+        // Rebuild sandbox CurateService with the queue — reuses existing hot-swap path
+        const newCurateService = createCurateService(services.workingDirectory, services.abstractQueue);
+        services.sandboxService.setCurateService?.(newCurateService);
+        // Atomically rebuild CURATE + INGEST_RESOURCE tools so both enqueue abstracts
+        services.toolProvider.replaceTools([ToolName.CURATE, ToolName.INGEST_RESOURCE], { abstractQueue: services.abstractQueue, contentGenerator: retryableCurateGenerator });
+        // Rebuild session compressor with the new generator (used in deleteTaskSession)
+        const deduplicator = new MemoryDeduplicator(retryableCurateGenerator);
+        this.sessionCompressor = new SessionCompressor(deduplicator, retryableCurateGenerator, services.memoryManager);
+    }
     rebindMapTools(services, httpConfig, sessionLLMConfig) {
         const mapProvider = sessionLLMConfig.provider
             ?? (sessionLLMConfig.openRouterApiKey ? 'openrouter' : 'byterover');
@@ -855,6 +1023,23 @@ export class CipherAgent extends BaseAgent {
         // Update sandbox for tools.curation.mapExtract()
         services.sandboxService.setContentGenerator?.(mapGenerator);
     }
+    async refreshSessionCompressorFromTransport() {
+        if (!this._transportClient || !this.services) {
+            return;
+        }
+        const fresh = await this._transportClient.requestWithAck(TransportStateEventNames.GET_PROVIDER_CONFIG);
+        const retryable = this.createFreshRetryableGenerator(fresh, {
+            httpConfig: this.buildHttpConfig(),
+            httpReferer: this.config.httpReferer,
+            modelFallback: this.stateManager?.getModel() ?? this.config.model,
+            siteName: this.config.siteName,
+        });
+        if (!retryable) {
+            return;
+        }
+        const deduplicator = new MemoryDeduplicator(retryable);
+        this.sessionCompressor = new SessionCompressor(deduplicator, retryable, this.services.memoryManager);
+    }
     /**
      * Register a session as root-eligible and track it for lifecycle cleanup.
      * Routes all root-eligible registrations through a single point.

package/dist/agent/infra/agent/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Agent module - Complete cipher agent implementation following DextoAgent patterns
+ * Agent module - Complete cipher agent implementation
  *
  * This module provides the full agent architecture with:
  * - CipherAgent: Main agent class for LLM interactions

package/dist/agent/infra/agent/index.js

@@ -1,5 +1,5 @@
 /**
- * Agent module - Complete cipher agent implementation following DextoAgent patterns
+ * Agent module - Complete cipher agent implementation
  *
  * This module provides the full agent architecture with:
  * - CipherAgent: Main agent class for LLM interactions

package/dist/agent/infra/agent/service-initializer.d.ts

@@ -4,7 +4,7 @@
  * This module is responsible for initializing and wiring together all core agent services.
  * It provides a single entry point for constructing the service graph.
  *
- * Following DextoAgent pattern:
+ * Following pattern:
  * - Config file is source of truth (ValidatedAgentConfig)
  * - Centralized function (not factory class) for service creation
  * - Explicit dependency order with numbered steps
@@ -61,7 +61,7 @@ export type { CipherAgentServices, SessionManagerConfig, SessionServices } from
  * Creates shared services for CipherAgent.
  * These services are singletons shared across all sessions.
  *
- * Initialization order follows DextoAgent pattern (explicit numbered steps):
+ * Initialization order (explicit numbered steps):
  * 1. Logger (uses provided event bus)
  * 2. File system service (no dependencies)
  * 3. Process service (no dependencies)
@@ -76,7 +76,7 @@ export type { CipherAgentServices, SessionManagerConfig, SessionServices } from
  * 12. Return all services
  *
  * @param config - Validated agent configuration (Zod-validated)
- * @param agentEventBus - Pre-created event bus from agent constructor (DextoAgent pattern)
+ * @param agentEventBus - Pre-created event bus from agent constructor
  * @returns Initialized shared services
  */
 export declare function createCipherAgentServices(config: ValidatedAgentConfig, agentEventBus: AgentEventBus): Promise<CipherAgentServices>;