byterover-cli 1.8.0 → 2.0.0

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

@@ -16,11 +16,10 @@ import { createBlobStorage } from '../blob/blob-storage-factory.js';
 import { EnvironmentContextBuilder } from '../environment/environment-context-builder.js';
 import { SessionEventBus } from '../events/event-emitter.js';
 import { FileSystemService } from '../file-system/file-system-service.js';
-import { ByteRoverLlmHttpService } from '../http/internal-llm-http-service.js';
+import { AgentLLMService } from '../llm/agent-llm-service.js';
 import { CompactionService } from '../llm/context/compaction/compaction-service.js';
-import { ByteRoverContentGenerator, LoggingContentGenerator, RetryableContentGenerator } from '../llm/generators/index.js';
-import { ByteRoverLLMService } from '../llm/internal-llm-service.js';
-import { OpenRouterLLMService } from '../llm/openrouter-llm-service.js';
+import { LoggingContentGenerator, RetryableContentGenerator, } from '../llm/generators/index.js';
+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';
@@ -81,11 +80,13 @@ export async function createCipherAgentServices(config, agentEventBus) {
         workingDirectory,
     });
     await processService.initialize();
+    // Storage base path: XDG storagePath (always required, provided by daemon)
+    const storageBasePath = config.storagePath;
     // 4. Blob storage (no dependencies)
     const blobStorage = createBlobStorage(config.blobStorage ?? {
         maxBlobSize: 100 * 1024 * 1024, // 100MB
         maxTotalSize: 1024 * 1024 * 1024, // 1GB
-        storageDir: join(workingDirectory, '.brv', 'blobs'),
+        storageDir: storageBasePath,
     });
     await blobStorage.initialize();
     // 5. Memory system (depends on BlobStorage, Logger)
@@ -154,7 +155,7 @@ export async function createCipherAgentServices(config, agentEventBus) {
     if (config.useGranularStorage) {
         // Create granular storage infrastructure
         const keyStorage = new SqliteKeyStorage({
-            storageDir: join(workingDirectory, '.brv', 'blobs'),
+            storageDir: storageBasePath,
         });
         await keyStorage.initialize();
         const messageStorage = new MessageStorageService(keyStorage);
@@ -169,9 +170,9 @@ export async function createCipherAgentServices(config, agentEventBus) {
         const tokenizer = new GeminiTokenizer(config.model ?? 'gemini-3-flash-preview');
         compactionService = new CompactionService(messageStorage, tokenizer, {
             overflowThreshold: 0.85, // 85% triggers compaction check
-            protectedTurns: 2, // Protect first 2 user turns from pruning
-            pruneKeepTokens: 40_000, // Keep 40k tokens in tool outputs
-            pruneMinimumTokens: 20_000, // Only prune if 20k+ tokens can be saved
+            protectedTurns: 2, // Protect last 2 user turns from pruning
+            pruneKeepPercent: 0.2, // Keep 20% of context window in tool outputs
+            pruneMinimumPercent: 0.1, // Only prune if 10%+ of context window can be saved
         });
         logger.info('Granular history storage enabled for new sessions');
     }
@@ -205,7 +206,7 @@ export async function createCipherAgentServices(config, agentEventBus) {
 /**
  * Creates session-specific services for a ChatSession.
  * Generator composition order (innermost to outermost):
- * 1. Base generator (ByteRoverContentGenerator or OpenRouterContentGenerator)
+ * 1. Base generator (created via provider registry)
  * 2. RetryableContentGenerator - handles transient errors with backoff
  * 3. LoggingContentGenerator - debug logging (if verbose enabled)
  *
@@ -220,75 +221,60 @@ export function createSessionServices(sessionId, sharedServices, httpConfig, llm
     const sessionEventBus = new SessionEventBus();
     // 2. Create session-scoped logger
     const sessionLogger = new EventBasedLogger(sharedServices.agentEventBus, 'LLMService', sessionId);
-    // 3. Create LLM service based on configuration
-    // Priority: OpenRouter > ByteRover HTTP
-    let llmService;
-    if (llmConfig.openRouterApiKey) {
-        // Use OpenRouter service when OpenRouter API key is provided
-        llmService = new OpenRouterLLMService(sessionId, {
-            apiKey: llmConfig.openRouterApiKey,
-            httpReferer: llmConfig.httpReferer,
-            maxIterations: llmConfig.maxIterations ?? 50,
-            maxTokens: llmConfig.maxTokens ?? 8192,
-            model: llmConfig.model ?? 'google/gemini-3-flash-preview',
-            siteName: llmConfig.siteName,
-            temperature: llmConfig.temperature ?? 0.7,
-            verbose: llmConfig.verbose ?? false,
-        }, {
-            logger: sessionLogger,
-            memoryManager: sharedServices.memoryManager, // SHARED
-            sessionEventBus,
-            systemPromptManager: sharedServices.systemPromptManager, // SHARED
-            toolManager: sharedServices.toolManager, // SHARED
-        });
-    }
-    else {
-        // Use HTTP backend service (default) with generator pattern
-        // Step 1: Create HTTP service
-        const httpService = new ByteRoverLlmHttpService({
-            apiBaseUrl: httpConfig.apiBaseUrl,
-            projectId: httpConfig.projectId,
-            region: httpConfig.region,
-            sessionKey: httpConfig.sessionKey,
-            spaceId: httpConfig.spaceId,
-            teamId: httpConfig.teamId,
-            timeout: httpConfig.timeout,
-        });
-        // Step 2: Create base content generator
-        let generator = new ByteRoverContentGenerator(httpService, {
-            maxTokens: llmConfig.maxTokens ?? 8192,
-            model: llmConfig.model ?? 'gemini-3-flash-preview',
-            temperature: llmConfig.temperature ?? 0.7,
-        });
-        // Step 3: Wrap with retry decorator
+    // 3. Create LLM service based on provider configuration
+    // Routing priority: explicit provider > openRouterApiKey > byterover (default)
+    const provider = llmConfig.provider ?? (llmConfig.openRouterApiKey ? 'openrouter' : 'byterover');
+    // Helper: wrap a base generator with retry + logging decorators, then create AgentLLMService
+    const createServiceWithGenerator = (baseGenerator) => {
+        let generator = baseGenerator;
+        // Wrap with retry decorator
         generator = new RetryableContentGenerator(generator, {
             eventBus: sessionEventBus,
             policy: DEFAULT_RETRY_POLICY,
         });
-        // Step 4: Wrap with logging decorator (always, for spinner events)
+        // Wrap with logging decorator (always, for spinner events)
         generator = new LoggingContentGenerator(generator, sessionEventBus, {
             logChunks: llmConfig.verbose,
             logRequests: llmConfig.verbose,
             logResponses: llmConfig.verbose,
             verbose: llmConfig.verbose,
         });
-        // Step 5: Create LLM service with composed generator
-        llmService = new ByteRoverLLMService(sessionId, generator, {
+        return new AgentLLMService(sessionId, generator, {
+            maxInputTokens: llmConfig.maxInputTokens,
             maxIterations: llmConfig.maxIterations ?? 50,
             maxTokens: llmConfig.maxTokens ?? 8192,
             model: llmConfig.model ?? 'gemini-3-flash-preview',
+            provider,
             temperature: llmConfig.temperature ?? 0.7,
             verbose: llmConfig.verbose ?? false,
         }, {
-            compactionService: sharedServices.compactionService, // SHARED - for context overflow management
-            historyStorage: sharedServices.historyStorage, // SHARED
+            compactionService: sharedServices.compactionService,
+            historyStorage: sharedServices.historyStorage,
             logger: sessionLogger,
-            memoryManager: sharedServices.memoryManager, // SHARED
+            memoryManager: sharedServices.memoryManager,
+            sandboxService: sharedServices.sandboxService,
             sessionEventBus,
-            systemPromptManager: sharedServices.systemPromptManager, // SHARED
-            toolManager: sharedServices.toolManager, // SHARED
+            systemPromptManager: sharedServices.systemPromptManager,
+            toolManager: sharedServices.toolManager,
         });
-    }
+    };
+    // Create base generator via provider registry
+    const baseGenerator = createGeneratorForProvider(provider, {
+        apiKey: provider === 'openrouter'
+            ? (llmConfig.openRouterApiKey ?? llmConfig.providerApiKey)
+            : llmConfig.providerApiKey,
+        baseUrl: llmConfig.providerBaseUrl,
+        headers: llmConfig.providerHeaders,
+        httpConfig: httpConfig,
+        httpReferer: llmConfig.httpReferer,
+        location: llmConfig.providerLocation,
+        maxTokens: llmConfig.maxTokens ?? 8192,
+        model: llmConfig.model,
+        project: llmConfig.providerProject,
+        siteName: llmConfig.siteName,
+        temperature: llmConfig.temperature ?? 0.7,
+    });
+    const llmService = createServiceWithGenerator(baseGenerator);
     // Event forwarding is handled by ChatSession.setupEventForwarding()
     // to ensure proper cleanup when sessions are disposed
     return {

package/dist/agent/infra/blob/blob-storage-factory.d.ts

@@ -8,6 +8,6 @@ import type { IBlobStorage } from '../../core/interfaces/i-blob-storage.js';
  * @returns SQLite blob storage implementation
  *
  * @example
- * const storage = createBlobStorage({ storageDir: '.brv/blobs' });
+ * const storage = createBlobStorage({ storageDir: '/path/to/xdg/storage' });
  */
 export declare function createBlobStorage(config?: Partial<BlobStorageConfig>): IBlobStorage;

package/dist/agent/infra/blob/blob-storage-factory.js

@@ -7,7 +7,7 @@ import { SqliteBlobStorage } from './sqlite-blob-storage.js';
  * @returns SQLite blob storage implementation
  *
  * @example
- * const storage = createBlobStorage({ storageDir: '.brv/blobs' });
+ * const storage = createBlobStorage({ storageDir: '/path/to/xdg/storage' });
  */
 export function createBlobStorage(config) {
     return new SqliteBlobStorage(config);

package/dist/agent/infra/blob/sqlite-blob-storage.js

@@ -1,6 +1,6 @@
 import Database from 'better-sqlite3';
 import * as fs from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { BlobError } from '../../core/domain/errors/blob-error.js';
 import { runMigrations } from './migrations.js';
 /**
@@ -29,8 +29,11 @@ export class SqliteBlobStorage {
     storageDir;
     constructor(config) {
         this.inMemory = config?.inMemory ?? false;
-        this.storageDir = config?.storageDir || join(process.cwd(), '.brv');
-        this.dbPath = this.inMemory ? ':memory:' : join(this.storageDir, 'storage.db');
+        this.storageDir = config?.storageDir ?? '';
+        if (!this.inMemory && !this.storageDir) {
+            throw new Error('SqliteBlobStorage: storageDir is required when inMemory is false');
+        }
+        this.dbPath = this.inMemory ? ':memory:' : (config?.dbPath ?? join(this.storageDir, 'storage.db'));
         this.maxBlobSize = config?.maxBlobSize ?? 100 * 1024 * 1024; // 100MB default
         this.maxTotalSize = config?.maxTotalSize ?? 1024 * 1024 * 1024; // 1GB default
         this.logger = config?.logger ?? {
@@ -141,9 +144,9 @@ export class SqliteBlobStorage {
             return;
         }
         try {
-            // Ensure storage directory exists (skip for in-memory)
+            // Ensure parent directory of database file exists (skip for in-memory)
             if (!this.inMemory) {
-                await fs.mkdir(this.storageDir, { recursive: true });
+                await fs.mkdir(dirname(this.dbPath), { recursive: true });
             }
             // Open/create database (':memory:' for in-memory mode)
             this.db = new Database(this.dbPath);

package/dist/agent/infra/file-system/file-system-service.js

@@ -206,7 +206,8 @@ export class FileSystemService {
      */
     async globFiles(pattern, options = {}) {
         this.ensureInitialized();
-        const cwd = options.cwd ?? this.config.workingDirectory;
+        const rawCwd = options.cwd ?? this.config.workingDirectory;
+        const cwd = path.isAbsolute(rawCwd) ? rawCwd : path.resolve(this.config.workingDirectory, rawCwd);
         const maxResults = options.maxResults ?? 1000;
         const includeMetadata = options.includeMetadata ?? true;
         const caseSensitive = options.caseSensitive ?? true;
@@ -541,7 +542,8 @@ export class FileSystemService {
      */
     async searchContent(pattern, options = {}) {
         this.ensureInitialized();
-        const cwd = options.cwd ?? this.config.workingDirectory;
+        const rawCwd = options.cwd ?? this.config.workingDirectory;
+        const cwd = path.isAbsolute(rawCwd) ? rawCwd : path.resolve(this.config.workingDirectory, rawCwd);
         const maxResults = options.maxResults ?? 100;
         const contextLines = options.contextLines ?? 0;
         // If context lines requested, use JS fallback directly (native grep context parsing is complex)
@@ -886,7 +888,8 @@ export class FileSystemService {
      */
     async searchContentJS(pattern, options = {}) {
         const globPattern = options.globPattern ?? '**/*';
-        const cwd = options.cwd ?? this.config.workingDirectory;
+        const rawCwd = options.cwd ?? this.config.workingDirectory;
+        const cwd = path.isAbsolute(rawCwd) ? rawCwd : path.resolve(this.config.workingDirectory, rawCwd);
         const maxResults = options.maxResults ?? 100;
         const contextLines = options.contextLines ?? 0;
         const caseInsensitive = options.caseInsensitive ?? false;

package/dist/agent/infra/http/internal-llm-http-service.d.ts

@@ -4,14 +4,18 @@ import type { Content, GenerateContentConfig, GenerateContentResponse } from '@g
 import { GenerateContentChunk } from '../../core/interfaces/i-content-generator.js';
 /**
  * ByteRover HTTP LLM provider configuration.
+ *
+ * projectId, sessionKey, spaceId, teamId accept either a static string or a provider function.
+ * Provider functions are resolved lazily on each HTTP request,
+ * so long-lived agents always get the latest values from the StateServer.
  */
 export interface ByteRoverHttpConfig {
     apiBaseUrl: string;
-    projectId?: string;
+    projectId?: (() => string) | string;
     region?: string;
-    sessionKey: string;
-    spaceId: string;
-    teamId: string;
+    sessionKey: (() => string) | string;
+    spaceId: (() => string) | string;
+    teamId: (() => string) | string;
     timeout?: number;
 }
 /**
@@ -40,7 +44,7 @@ export declare class ByteRoverLlmHttpService {
      * - region defaults to 'us-east1' (can be overridden per request)
      * - timeout defaults to 60 seconds
      *
-     * @param config - HTTP client configuration (accessToken, apiBaseUrl, sessionKey, optional: projectId, region, timeout)
+     * @param config - HTTP client configuration (apiBaseUrl, sessionKey, optional: projectId, region, timeout)
      */
     constructor(config: ByteRoverHttpConfig);
     /**

package/dist/agent/infra/http/internal-llm-http-service.js

@@ -27,7 +27,7 @@ export class ByteRoverLlmHttpService {
      * - region defaults to 'us-east1' (can be overridden per request)
      * - timeout defaults to 60 seconds
      *
-     * @param config - HTTP client configuration (accessToken, apiBaseUrl, sessionKey, optional: projectId, region, timeout)
+     * @param config - HTTP client configuration (apiBaseUrl, sessionKey, optional: projectId, region, timeout)
      */
     constructor(config) {
         this.config = {
@@ -65,11 +65,11 @@ export class ByteRoverLlmHttpService {
                 contents,
                 model,
             },
-            project_id: this.config.projectId,
+            project_id: typeof this.config.projectId === 'function' ? this.config.projectId() : this.config.projectId,
             provider: this.detectProviderFromModel(model),
             region: this.detectRegionFromModel(model),
-            spaceId: this.config.spaceId,
-            teamId: this.config.teamId,
+            spaceId: typeof this.config.spaceId === 'function' ? this.config.spaceId() : this.config.spaceId,
+            teamId: typeof this.config.teamId === 'function' ? this.config.teamId() : this.config.teamId,
         };
         return this.callHttpGenerate(request);
     }
@@ -108,7 +108,8 @@ export class ByteRoverLlmHttpService {
      */
     async callHttpGenerate(request) {
         const url = `${this.config.apiBaseUrl}/api/llm/generate`;
-        const httpClient = new AuthenticatedHttpClient(this.config.sessionKey);
+        const sessionKey = typeof this.config.sessionKey === 'function' ? this.config.sessionKey() : this.config.sessionKey;
+        const httpClient = new AuthenticatedHttpClient(sessionKey);
         const httpResponse = await httpClient.post(url, request, {
             timeout: this.config.timeout,
         });
@@ -180,9 +181,12 @@ export class ByteRoverLlmHttpService {
             if (partRecord.text && typeof partRecord.text === 'string') {
                 textParts.push(partRecord.text);
             }
-            // Collect function calls
+            // Collect function calls (preserve thoughtSignature for Gemini 3+ models)
             if (partRecord.functionCall) {
-                functionCalls.push(partRecord.functionCall);
+                functionCalls.push({
+                    ...partRecord.functionCall,
+                    ...(typeof partRecord.thoughtSignature === 'string' && { thoughtSignature: partRecord.thoughtSignature }),
+                });
             }
         }
         // Yield final content chunk
@@ -197,6 +201,7 @@ export class ByteRoverLlmHttpService {
                         name: fc.name ?? '',
                     },
                     id: `call_${Date.now()}_${index}`,
+                    ...(fc.thoughtSignature && { thoughtSignature: fc.thoughtSignature }),
                     type: 'function',
                 }))
                 : undefined,

package/dist/agent/infra/llm/{internal-llm-service.d.ts → agent-llm-service.d.ts}

@@ -3,6 +3,7 @@ import type { ExecutionContext } from '../../core/interfaces/i-cipher-agent.js';
 import type { IHistoryStorage } from '../../core/interfaces/i-history-storage.js';
 import type { ILLMService } from '../../core/interfaces/i-llm-service.js';
 import type { ILogger } from '../../core/interfaces/i-logger.js';
+import type { ISandboxService } from '../../core/interfaces/i-sandbox-service.js';
 import type { MemoryManager } from '../memory/memory-manager.js';
 import type { SystemPromptManager } from '../system-prompt/system-prompt-manager.js';
 import type { ToolManager } from '../tools/tool-manager.js';
@@ -15,11 +16,17 @@ import { type TruncationConfig } from './tool-output-processor.js';
 /**
  * Configuration for ByteRover LLM service
  */
-export interface ByteRoverLLMServiceConfig {
+export interface AgentLLMServiceConfig {
     maxInputTokens?: number;
     maxIterations?: number;
     maxTokens?: number;
     model: string;
+    /**
+     * Explicit provider ID for formatter/tokenizer selection.
+     * When set, overrides the model-name-based heuristic detection.
+     * Used for direct provider connections (anthropic, openai, google, xai, groq, mistral).
+     */
+    provider?: string;
     temperature?: number;
     /**
      * Thinking configuration for Gemini models (optional).
@@ -61,7 +68,7 @@ export interface LLMServiceConfig {
  * - Format messages for specific providers (handled by generators)
  * - Handle retry logic (handled by RetryableContentGenerator decorator)
  */
-export declare class ByteRoverLLMService implements ILLMService {
+export declare class AgentLLMService implements ILLMService {
     /** Cached base system prompt (everything built by SystemPromptManager) for reuse across iterations */
     private cachedBasePrompt;
     private readonly compactionService?;
@@ -78,7 +85,10 @@ export declare class ByteRoverLLMService implements ILLMService {
     private readonly metadataHandler;
     private readonly mutex;
     private readonly outputProcessor;
+    private readonly providerId;
     private readonly providerType;
+    /** Optional sandbox service for rolling checkpoint variable injection (Pattern 1) */
+    private readonly sandboxService?;
     private readonly sessionEventBus;
     private readonly sessionId;
     private readonly systemPromptManager;
@@ -108,12 +118,15 @@ export declare class ByteRoverLLMService implements ILLMService {
      * @param options.compactionService - Optional compaction service for context overflow management
      * @param options.historyStorage - Optional history storage for persistence
      * @param options.logger - Optional logger for structured logging
+     * @param options.sandboxService - Optional sandbox service for rolling checkpoint variable injection
      */
-    constructor(sessionId: string, generator: IContentGenerator, config: ByteRoverLLMServiceConfig, options: {
+    constructor(sessionId: string, generator: IContentGenerator, config: AgentLLMServiceConfig, options: {
         compactionService?: CompactionService;
         historyStorage?: IHistoryStorage;
         logger?: ILogger;
         memoryManager?: MemoryManager;
+        /** Optional sandbox service for rolling checkpoint variable injection */
+        sandboxService?: ISandboxService;
         sessionEventBus: SessionEventBus;
         systemPromptManager: SystemPromptManager;
         toolManager: ToolManager;
@@ -160,7 +173,7 @@ export declare class ByteRoverLLMService implements ILLMService {
      * Returns metadata about the service including:
      * - Configured and model-specific token limits
      * - Selected LLM model
-     * - Provider name (always 'byterover')
+     * - Provider identity (e.g. 'byterover', 'anthropic', 'openrouter')
      * - Router type (always 'in-built')
      *
      * This is useful for introspecting service capabilities and limits
@@ -211,6 +224,14 @@ export declare class ByteRoverLLMService implements ILLMService {
      * @returns GenerateContentRequest for the generator
      */
     private buildGenerateContentRequest;
+    /**
+     * Build a compact progress summary from current messages.
+     * Used by rolling checkpoint to capture agentic state before clearing history.
+     *
+     * @param messages - Current conversation messages
+     * @returns JSON string summarizing progress
+     */
+    private buildProgressSummary;
     /**
      * Call LLM via generator and process the response.
      *
@@ -248,11 +269,12 @@ export declare class ByteRoverLLMService implements ILLMService {
     /**
      * Detect provider type from model name using the LLM registry.
      *
-     * Uses the centralized registry to determine provider from model name.
-     * Falls back to string prefix matching if model is not in registry.
+     * Uses explicit provider config first, then the centralized registry,
+     * and falls back to string prefix matching if model is not in registry.
      *
      * @param model - Model identifier
-     * @returns Provider type ('claude' or 'gemini')
+     * @param explicitProvider - Optional explicit provider ID from config
+     * @returns Provider type ('claude', 'gemini', or 'openai')
      */
     private detectProviderType;
     /**
@@ -274,6 +296,7 @@ export declare class ByteRoverLLMService implements ILLMService {
      * Execute a single iteration of the agentic loop.
      *
      * @param options - Iteration options
+     * @param options.effectiveMaxIterations - Effective max iterations (per-invocation override or config default)
      * @param options.executionContext - Optional execution context
      * @param options.fileData - Optional file data (only used on first iteration)
      * @param options.imageData - Optional image data (only used on first iteration)
@@ -291,6 +314,7 @@ export declare class ByteRoverLLMService implements ILLMService {
      *
      * @param toolCall - Tool call to execute
      * @param taskId - Task ID from usecase for billing tracking (passed to subagents)
+     * @param executionContext - Optional execution context for context-aware tool behavior
      * @returns Parallel tool result with all execution data
      */
     private executeToolCallParallel;
@@ -350,8 +374,19 @@ export declare class ByteRoverLLMService implements ILLMService {
      *
      * @param lastMessage - Last message containing tool calls
      * @param taskId - Task ID from usecase for billing tracking (passed to subagents)
+     * @param executionContext - Optional execution context for context-aware tool behavior
+     * @returns Early exit result if setFinalResult() was called, undefined otherwise
      */
     private handleToolCalls;
+    /**
+     * Perform a rolling checkpoint: save progress to sandbox variable, clear history, re-inject prompt.
+     * This treats each batch of iterations as a mini-task, preventing unbounded token accumulation.
+     *
+     * @param iterationCount - Current iteration number
+     * @param sessionId - Session ID for sandbox variable injection
+     * @param textInput - Original user input text (for continuation prompt)
+     */
+    private performRollingCheckpoint;
     /**
      * Replace the DateTime section in a cached system prompt with a fresh timestamp.
      * DateTimeContributor wraps its output in <dateTime>...</dateTime> XML tags,
@@ -361,6 +396,16 @@ export declare class ByteRoverLLMService implements ILLMService {
      * @returns Updated prompt with fresh DateTime
      */
     private refreshDateTime;
+    /**
+     * Check if a rolling checkpoint should trigger.
+     * Triggers every N iterations for curate/query commands, or when token utilization is high.
+     *
+     * @param iterationCount - Current iteration number
+     * @param commandType - Command type (only curate/query trigger checkpoints)
+     * @param currentTokens - Current estimated token count for messages
+     * @returns True if checkpoint should trigger
+     */
+    private shouldTriggerCheckpoint;
     /**
      * Validate LLM configuration using Zod schema.
      *