byterover-cli 3.0.1 → 3.1.0

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-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>;

package/dist/agent/infra/agent/service-initializer.js

@@ -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
@@ -26,6 +26,7 @@ import { createGeneratorForProvider } from '../llm/providers/index.js';
 import { DEFAULT_RETRY_POLICY } from '../llm/retry/retry-policy.js';
 import { GeminiTokenizer } from '../llm/tokenizers/gemini-tokenizer.js';
 import { EventBasedLogger } from '../logger/event-based-logger.js';
+import { AbstractGenerationQueue } from '../map/abstract-queue.js';
 import { MemoryManager } from '../memory/memory-manager.js';
 import { ProcessService } from '../process/process-service.js';
 import { SandboxService } from '../sandbox/sandbox-service.js';
@@ -45,7 +46,7 @@ import { ToolProvider } from '../tools/tool-provider.js';
  * 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)
@@ -60,11 +61,11 @@ import { ToolProvider } from '../tools/tool-provider.js';
  * 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 async function createCipherAgentServices(config, agentEventBus) {
-    // 1. Logger (uses provided event bus - DextoAgent pattern)
+    // 1. Logger (uses provided event bus )
     const logger = new EventBasedLogger(agentEventBus, 'CipherAgent');
     // 2. File system service (no dependencies)
     const fileSystemService = new FileSystemService(config.fileSystem);
@@ -132,10 +133,13 @@ export async function createCipherAgentServices(config, agentEventBus) {
     // Priority 16 — right after context tree structure, before memories
     const mapSelectionContributor = new MapSelectionContributor('mapSelection', 16);
     systemPromptManager.registerContributor(mapSelectionContributor);
-    // 7. Tool provider (depends on FileSystemService, ProcessService, MemoryManager, SystemPromptManager)
+    // 7. Abstract generation queue (generator injected later via rebindCurateTools)
+    const abstractQueue = new AbstractGenerationQueue(workingDirectory);
+    // 8. Tool provider (depends on FileSystemService, ProcessService, MemoryManager, SystemPromptManager)
     const verbose = config.llm.verbose ?? false;
     const descriptionLoader = new ToolDescriptionLoader();
     const toolProvider = new ToolProvider({
+        abstractQueue,
         environmentContext,
         fileSystemService,
         getToolProvider: () => toolProvider,
@@ -144,14 +148,14 @@ export async function createCipherAgentServices(config, agentEventBus) {
         sandboxService,
     }, systemPromptManager, descriptionLoader);
     await toolProvider.initialize();
-    // 8. Policy engine with default rules for autonomous execution
+    // 9. Policy engine with default rules for autonomous execution
     const policyEngine = new PolicyEngine({ defaultDecision: 'ALLOW' });
     policyEngine.addRules(DEFAULT_POLICY_RULES);
-    // 9. Tool scheduler (orchestrates policy check → execution)
+    // 10. Tool scheduler (orchestrates policy check → execution)
     const toolScheduler = new CoreToolScheduler(toolProvider, policyEngine, undefined, {
         verbose,
     });
-    // 10. Tool manager (with scheduler for policy-based execution)
+    // 11. Tool manager (with scheduler for policy-based execution)
     const toolManager = new ToolManager(toolProvider, toolScheduler);
     await toolManager.initialize();
     // 11. History storage - granular file-based storage
@@ -177,6 +181,7 @@ export async function createCipherAgentServices(config, agentEventBus) {
         workingDirectory,
     });
     return {
+        abstractQueue,
         agentEventBus,
         blobStorage,
         compactionService,
@@ -191,6 +196,7 @@ export async function createCipherAgentServices(config, agentEventBus) {
         toolManager,
         toolProvider,
         toolScheduler,
+        workingDirectory,
     };
 }
 /**

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

@@ -19,7 +19,6 @@ export interface AgentExecutionContext {
 /**
  * Agent event subscriber interface.
  * Objects implementing this can be registered for event subscription.
- * Follows DextoAgent's AgentEventSubscriber pattern.
  */
 export interface AgentEventSubscriber {
     /**