byterover-cli 0.2.1 → 0.3.0

package/dist/infra/parsers/raw/raw-parser-service-factory.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Raw Parser Service Factory
+ * Routes IDE-based parsing requests to the appropriate parser service
+ * Supports: Claude Code, Cursor, GitHub Copilot, Codex
+ */
+import { Agent } from '../../../core/domain/entities/agent.js';
+import { IRawParserService } from '../../../core/interfaces/parser/i-raw-parser-service.js';
+/**
+ * Raw Parser Service Factory
+ * Creates and returns appropriate parser service for the given IDE
+ */
+export declare class RawParserServiceFactory {
+    private static readonly SUPPORTED_IDES;
+    /**
+     * Create a raw parser service for the specified IDE
+     *
+     * Factory method that instantiates the appropriate raw parser service
+     * based on the provided IDE type. Routes to specialized service classes.
+     *
+     * @param ide - The IDE type: 'Claude Code', 'Cursor', 'Github Copilot', or 'Codex'
+     * @returns The appropriate raw parser service instance
+     * @throws Error if IDE is not supported
+     */
+    static createRawParserService(ide: Agent): IRawParserService;
+    /**
+     * Get list of supported IDEs
+     *
+     * Returns array of all IDE types that have corresponding raw parser services.
+     *
+     * @returns Array of supported IDE type strings
+     */
+    static getSupportedIDEs(): Agent[];
+    /**
+     * Check if IDE is supported
+     *
+     * Validates whether the provided IDE string corresponds to a supported IDE.
+     *
+     * @param ide - IDE name to validate
+     * @returns True if IDE is in supported list, false otherwise
+     */
+    static isSupported(ide: Agent): boolean;
+    /**
+     * Parse conversations for the specified IDE
+     *
+     * Creates appropriate service and delegates to its parse method to extract
+     * and transform raw conversation data from IDE storage.
+     *
+     * @param ide - The IDE type (Claude Code, Cursor, Github Copilot, Codex)
+     * @param customDir - Path to custom directory containing IDE session data
+     * @param outputDir - Optional output directory (defaults to process.cwd()/.brv/logs/{ide}/raw)
+     * @returns Promise resolving to true if parsing succeeded, false otherwise
+     */
+    static parseConversations(ide: Agent, customDir: string, outputDir?: string): Promise<boolean>;
+}

package/dist/infra/parsers/raw/raw-parser-service-factory.js

@@ -0,0 +1,81 @@
+/**
+ * Raw Parser Service Factory
+ * Routes IDE-based parsing requests to the appropriate parser service
+ * Supports: Claude Code, Cursor, GitHub Copilot, Codex
+ */
+import { ClaudeRawService } from './raw-claude-service.js';
+import { CodexRawService } from './raw-codex-service.js';
+import { CopilotRawService } from './raw-copilot-service.js';
+import { CursorRawService } from './raw-cursor-service.js';
+/**
+ * Raw Parser Service Factory
+ * Creates and returns appropriate parser service for the given IDE
+ */
+export class RawParserServiceFactory {
+    static SUPPORTED_IDES = ['Claude Code', 'Cursor', 'Github Copilot', 'Codex'];
+    /**
+     * Create a raw parser service for the specified IDE
+     *
+     * Factory method that instantiates the appropriate raw parser service
+     * based on the provided IDE type. Routes to specialized service classes.
+     *
+     * @param ide - The IDE type: 'Claude Code', 'Cursor', 'Github Copilot', or 'Codex'
+     * @returns The appropriate raw parser service instance
+     * @throws Error if IDE is not supported
+     */
+    static createRawParserService(ide) {
+        switch (ide) {
+            case 'Claude Code': {
+                return new ClaudeRawService(ide);
+            }
+            case 'Codex': {
+                return new CodexRawService(ide);
+            }
+            case 'Cursor': {
+                return new CursorRawService(ide);
+            }
+            case 'Github Copilot': {
+                return new CopilotRawService(ide);
+            }
+            default: {
+                throw new Error(`Unsupported IDE: ${ide}. Supported IDEs are: claude, cursor, copilot, codex`);
+            }
+        }
+    }
+    /**
+     * Get list of supported IDEs
+     *
+     * Returns array of all IDE types that have corresponding raw parser services.
+     *
+     * @returns Array of supported IDE type strings
+     */
+    static getSupportedIDEs() {
+        return [...this.SUPPORTED_IDES];
+    }
+    /**
+     * Check if IDE is supported
+     *
+     * Validates whether the provided IDE string corresponds to a supported IDE.
+     *
+     * @param ide - IDE name to validate
+     * @returns True if IDE is in supported list, false otherwise
+     */
+    static isSupported(ide) {
+        return this.getSupportedIDEs().includes(ide);
+    }
+    /**
+     * Parse conversations for the specified IDE
+     *
+     * Creates appropriate service and delegates to its parse method to extract
+     * and transform raw conversation data from IDE storage.
+     *
+     * @param ide - The IDE type (Claude Code, Cursor, Github Copilot, Codex)
+     * @param customDir - Path to custom directory containing IDE session data
+     * @param outputDir - Optional output directory (defaults to process.cwd()/.brv/logs/{ide}/raw)
+     * @returns Promise resolving to true if parsing succeeded, false otherwise
+     */
+    static async parseConversations(ide, customDir, outputDir) {
+        const service = this.createRawParserService(ide);
+        return service.parse(customDir, outputDir);
+    }
+}

package/dist/infra/space/http-space-service.js

@@ -1,4 +1,5 @@
 import { Space } from '../../core/domain/entities/space.js';
+import { getErrorMessage } from '../../utils/error-helpers.js';
 import { AuthenticatedHttpClient } from '../http/authenticated-http-client.js';
 export class HttpSpaceService {
     config;
@@ -34,7 +35,7 @@ export class HttpSpaceService {
             };
         }
         catch (error) {
-            throw new Error(`Failed to fetch spaces: ${error.message}`);
+            throw new Error(`Failed to fetch spaces: ${getErrorMessage(error)}`);
         }
     }
     async fetchAllSpaces(httpClient, teamId) {

package/dist/infra/team/http-team-service.js

@@ -1,4 +1,5 @@
 import { Team } from '../../core/domain/entities/team.js';
+import { getErrorMessage } from '../../utils/error-helpers.js';
 import { AuthenticatedHttpClient } from '../http/authenticated-http-client.js';
 export class HttpTeamService {
     config;
@@ -36,7 +37,7 @@ export class HttpTeamService {
             };
         }
         catch (error) {
-            throw new Error(`Failed to fetch teams: ${error.message}`);
+            throw new Error(`Failed to fetch teams: ${getErrorMessage(error)}`);
         }
     }
     async fetchAllTeams(httpClient, isActive) {

package/dist/infra/user/http-user-service.js

@@ -1,4 +1,5 @@
 import { User } from '../../core/domain/entities/user.js';
+import { getErrorMessage } from '../../utils/error-helpers.js';
 import { AuthenticatedHttpClient } from '../http/authenticated-http-client.js';
 export class HttpUserService {
     config;
@@ -17,7 +18,7 @@ export class HttpUserService {
             return this.mapToUser(response.data);
         }
         catch (error) {
-            throw new Error(`Failed to fetch user information: ${error.message}`);
+            throw new Error(`Failed to fetch user information: ${getErrorMessage(error)}`);
         }
     }
     mapToUser(userData) {

package/dist/infra/watcher/file-watcher-service.d.ts

@@ -0,0 +1,10 @@
+import type { FileEvent, IFileWatcherService } from '../../core/interfaces/i-file-watcher-service.js';
+export declare class FileWatcherService implements IFileWatcherService {
+    private eventHandler;
+    private watcher;
+    constructor();
+    setFileEventHandler(handler: (event: FileEvent) => Promise<void>): void;
+    start(paths: string[]): Promise<void>;
+    stop(): Promise<void>;
+    private invokeHandler;
+}

package/dist/infra/watcher/file-watcher-service.js

@@ -0,0 +1,81 @@
+import { watch } from 'chokidar';
+export class FileWatcherService {
+    eventHandler;
+    watcher;
+    constructor() {
+        this.eventHandler = undefined;
+        this.watcher = undefined;
+    }
+    setFileEventHandler(handler) {
+        this.eventHandler = handler;
+    }
+    async start(paths) {
+        this.watcher = watch(paths, {
+            // `false` means the `add` events will be emitted for files already existing when the watcher starts.
+            // May need to change to `true` in the future because:
+            //   - We only care about NEW LOGS that agents write AFTER we start watching.
+            //   - We don't want to process old/existing log files that were already there.
+            //   - Cleaner output - no flood of events when watcher starts.
+            ignoreInitial: true,
+            // Keep watching indefinitely (we want a long-running watcher)
+            persistent: true,
+        });
+        // Register event LISTENERS for all file system events
+        // Note: invokeHandler is async and handles errors internally
+        this.watcher.on('add', async (path) => {
+            await this.invokeHandler('add', path);
+        });
+        this.watcher.on('addDir', async (path) => {
+            await this.invokeHandler('addDir', path);
+        });
+        this.watcher.on('change', async (path) => {
+            await this.invokeHandler('change', path);
+        });
+        this.watcher.on('unlink', async (path) => {
+            await this.invokeHandler('unlink', path);
+        });
+        this.watcher.on('unlinkDir', async (path) => {
+            await this.invokeHandler('unlinkDir', path);
+        });
+        // Wait for watcher to be ready.
+        // The 'ready' event fires when
+        // chokidar has completed its initial scan of the directories (regardless of ignoreInitial setting)
+        // With ignoreInitial: false, the timeline is:
+        // 1. chokidar.watch() called
+        // 2. Scans directories
+        // 3. Emits 'add' events for 100 existing files
+        // 4. 'ready' event fires ← "Done with initial scan"
+        // 5. Now watching for new changes
+        //
+        // With ignoreInitial: true, timeline is:
+        // 1. chokidar.watch() called
+        // 2. Scans directories (still happens!)
+        // 3. Doesn't emit 'add' events for existing files
+        // 4. 'ready' event fires ← "Done with initial scan"
+        // 5. Now watching for new changes
+        // 'ready' is still useful for ignoreInitial: true.
+        await new Promise((resolve) => {
+            this.watcher?.on('ready', () => {
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (this.watcher !== undefined) {
+            await this.watcher.close();
+            this.watcher = undefined;
+        }
+        this.eventHandler = undefined;
+    }
+    async invokeHandler(type, path) {
+        if (this.eventHandler !== undefined) {
+            const event = { path, type };
+            try {
+                await this.eventHandler(event);
+            }
+            catch (error) {
+                console.error(`[FileWatcherService] Error in event handler for ${type} ${path}:`, error);
+            }
+        }
+    }
+}

package/dist/infra/workspace/workspace-detector-service.d.ts

@@ -0,0 +1,60 @@
+import { Agent } from '../../core/domain/entities/agent.js';
+export type WorkspaceInfo = {
+    chatLogPath: string;
+    cwd: string;
+};
+/**
+ * Service to detect IDE workspaces that contain the current working directory
+ * Supports: VS Code (Github Copilot), Cursor, Claude, and Codex
+ */
+export declare class WorkspaceDetectorService {
+    private readonly claudeUserPath;
+    private readonly codexUserPath;
+    private readonly cursorUserPath;
+    private readonly cwd;
+    private readonly vscodeUserPath;
+    constructor(cwd?: string);
+    /**
+     * Detect workspaces for the given IDE
+     *
+     * Supports: Github Copilot (VSCode), Cursor, Claude Code, Codex
+     *
+     * chatLogPath:
+     *   - For Cursor/VSCode: Path to workspace storage folder if workspace.json matches cwd
+     *   - For Claude Code: Path to claude project folder matching cwd (with special naming pattern)
+     *   - For Codex: Direct path to codex sessions folder
+     */
+    detectWorkspaces(agent: Agent): WorkspaceInfo;
+    /**
+     * Convert current working directory to Claude Code folder name format
+     * Example: /Users/datpham/dpmemories/byterover-cli -> -Users-datpham-dpmemories-byterover-cli
+     */
+    private cwdToClaudeFolderName;
+    /**
+     * Detect Claude Code workspaces
+     * Claude Code stores projects in ~/.claude/projects with folder names like "-Users-datpham-dpmemories-byterover-cli"
+     * These folder names are derived from the project path with slashes replaced by dashes
+     */
+    private detectClaudeWorkspaces;
+    /**
+     * Detect Codex workspaces
+     * Codex uses a single sessions folder
+     */
+    private detectCodexWorkspaces;
+    /**
+     * Detect Cursor workspaces
+     */
+    private detectCursorWorkspaces;
+    /**
+     * Detect VSCode workspaces (Github Copilot)
+     */
+    private detectVSCodeWorkspaces;
+    /**
+     * Detect workspaces using workspace.json file (VSCode, Cursor)
+     */
+    private detectWorkspacesByFile;
+    /**
+     * Check if current working directory is within the given workspace folder
+     */
+    private isCurrentDirInWorkspace;
+}

package/dist/infra/workspace/workspace-detector-service.js

@@ -0,0 +1,165 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * Service to detect IDE workspaces that contain the current working directory
+ * Supports: VS Code (Github Copilot), Cursor, Claude, and Codex
+ */
+export class WorkspaceDetectorService {
+    claudeUserPath;
+    codexUserPath;
+    cursorUserPath;
+    cwd;
+    vscodeUserPath;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+        this.vscodeUserPath = join(homedir(), 'Library/Application Support/Code/User/workspaceStorage');
+        this.cursorUserPath = join(homedir(), 'Library/Application Support/Cursor/User/workspaceStorage');
+        this.claudeUserPath = join(homedir(), '.claude/projects');
+        this.codexUserPath = join(homedir(), '.codex/sessions');
+    }
+    /**
+     * Detect workspaces for the given IDE
+     *
+     * Supports: Github Copilot (VSCode), Cursor, Claude Code, Codex
+     *
+     * chatLogPath:
+     *   - For Cursor/VSCode: Path to workspace storage folder if workspace.json matches cwd
+     *   - For Claude Code: Path to claude project folder matching cwd (with special naming pattern)
+     *   - For Codex: Direct path to codex sessions folder
+     */
+    detectWorkspaces(agent) {
+        const chatLogPath = '';
+        switch (agent) {
+            case 'Claude Code': {
+                return this.detectClaudeWorkspaces(chatLogPath);
+            }
+            case 'Codex': {
+                return this.detectCodexWorkspaces(chatLogPath);
+            }
+            case 'Cursor': {
+                return this.detectCursorWorkspaces(chatLogPath);
+            }
+            case 'Github Copilot': {
+                return this.detectVSCodeWorkspaces(chatLogPath);
+            }
+            default: {
+                return { chatLogPath, cwd: this.cwd };
+            }
+        }
+    }
+    /**
+     * Convert current working directory to Claude Code folder name format
+     * Example: /Users/datpham/dpmemories/byterover-cli -> -Users-datpham-dpmemories-byterover-cli
+     */
+    cwdToClaudeFolderName(cwd) {
+        // Remove leading slash and replace all slashes with dashes, then prepend dash
+        return '-' + cwd.slice(1).replaceAll('/', '-');
+    }
+    /**
+     * Detect Claude Code workspaces
+     * Claude Code stores projects in ~/.claude/projects with folder names like "-Users-datpham-dpmemories-byterover-cli"
+     * These folder names are derived from the project path with slashes replaced by dashes
+     */
+    detectClaudeWorkspaces(chatLogPath) {
+        try {
+            if (!existsSync(this.claudeUserPath)) {
+                return { chatLogPath, cwd: this.cwd };
+            }
+            // Convert cwd to Claude folder name format: /Users/datpham/dpmemories/byterover-cli -> -Users-datpham-dpmemories-byterover-cli
+            const claudeFolderName = this.cwdToClaudeFolderName(this.cwd);
+            const projectFolders = readdirSync(this.claudeUserPath);
+            for (const folderName of projectFolders) {
+                const folderPath = join(this.claudeUserPath, folderName);
+                // Check if this folder matches the current working directory
+                if (folderName === claudeFolderName) {
+                    chatLogPath = folderPath;
+                    break;
+                }
+            }
+        }
+        catch {
+            // Ignore directory read errors
+        }
+        return { chatLogPath, cwd: this.cwd };
+    }
+    /**
+     * Detect Codex workspaces
+     * Codex uses a single sessions folder
+     */
+    detectCodexWorkspaces(chatLogPath) {
+        try {
+            if (existsSync(this.codexUserPath)) {
+                chatLogPath = this.codexUserPath;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return { chatLogPath, cwd: this.cwd };
+    }
+    /**
+     * Detect Cursor workspaces
+     */
+    detectCursorWorkspaces(chatLogPath) {
+        return this.detectWorkspacesByFile(this.cursorUserPath, chatLogPath);
+    }
+    /**
+     * Detect VSCode workspaces (Github Copilot)
+     */
+    detectVSCodeWorkspaces(chatLogPath) {
+        return this.detectWorkspacesByFile(this.vscodeUserPath, chatLogPath);
+    }
+    /**
+     * Detect workspaces using workspace.json file (VSCode, Cursor)
+     */
+    detectWorkspacesByFile(userPath, chatLogPath) {
+        try {
+            if (!existsSync(userPath)) {
+                return { chatLogPath, cwd: this.cwd };
+            }
+            const workspaceIds = readdirSync(userPath);
+            for (const wsId of workspaceIds) {
+                const wsPath = join(userPath, wsId);
+                const workspaceFile = join(wsPath, 'workspace.json');
+                if (!existsSync(workspaceFile)) {
+                    continue;
+                }
+                try {
+                    const content = readFileSync(workspaceFile, 'utf8');
+                    const data = JSON.parse(content);
+                    // Only handle single folder windows (workspace files are ignored)
+                    if (!data.folder) {
+                        continue;
+                    }
+                    const folderPath = decodeURIComponent(data.folder.replace('file://', ''));
+                    // Set chatLogPath ONLY if folder exactly matches cwd
+                    if (folderPath === this.cwd) {
+                        chatLogPath = wsPath;
+                    }
+                }
+                catch {
+                    // Ignore JSON parse errors
+                }
+            }
+        }
+        catch {
+            // Ignore directory read errors
+        }
+        return { chatLogPath, cwd: this.cwd };
+    }
+    /**
+     * Check if current working directory is within the given workspace folder
+     */
+    isCurrentDirInWorkspace(folderPath) {
+        // Exact match
+        if (this.cwd === folderPath) {
+            return true;
+        }
+        // Check if current dir is a subdirectory
+        if (this.cwd.startsWith(folderPath + '/')) {
+            return true;
+        }
+        return false;
+    }
+}

package/dist/resources/prompts/curate-context-tree-curation.yml

@@ -0,0 +1,48 @@
+description: "context tree curation instructions"
+prompt: |
+
+  Your task is to assemble relevant high-level information (context) from the input data which will be saved to the context tree in the following steps.
+
+  The information should be sufficient to understand what the user has provided to the coding assistant as the important context so that the coding assistant can use it to complete the task at hand. When organizing the context, keep in mind the hierarchical structure with a maximum of 2 levels: domain → topic → subtopic. If subtopics contain complex information, break them into separate topics rather than creating deeper nesting.
+
+  The context tree captures:
+  - the domains of the context
+  - the topics of the context
+  - the subtopics of the context (maximum one level under topics)
+  - the code snippets of the context
+  - the content of the context
+
+  For doing that, you will need to acquire information from the chat history with the corresponding tools. Use the `detect_domains` tool to get the overview of the domains and the related segments of text that are relevant to the domain in the current user's inputs.
+
+  After collecting all the information, follow these steps to understand and update the context tree:
+
+  1. **Explore existing context**: Use `glob_files` and `grep_content` to understand the current related context in the context tree. You may use bash commands (e.g., `ls`, `find`) to list directories if necessary to navigate the context tree structure.
+
+  2. **Find existing knowledge**: Use `find_knowledge_topics` to retrieve concise information about existing knowledge topics in the context tree that relate to the current domain and text segments.
+
+  3. **Create or update knowledge**: Once you have gathered all information about:
+     - The current domain and text segments from the user's input data
+     - The existing context in the context tree
+     Use the `create_knowledge_topic` tool to create new knowledge topics or update existing ones. Ensure that:
+     - The context is well-structured and MUST meet **Context quality requirements**
+     - There is no duplication with existing context
+     - The information is clear and easy to understand
+     
+  4. **Context quality requirements**: Each context in the `contexts` array must:
+       - Important: Minimum 2-4 sentences per context. Otherwise, DO NOT add that context.
+       - A developer should understand the concept without reading source code
+       - Include names of functions, classes, patterns, or key concepts
+
+       AVOID vague contexts like:
+       - "Hook system" 
+       - "Error handling" 
+
+       WRITE detailed contexts like:
+       - "The hook system allows registering callbacks for lifecycle events. Register hooks using 
+        `HookRegistry.register(hookName, callback)` and trigger them with `HookRegistry.trigger(hookName, context)`. Hooks are used to: 
+        support async callbacks and are commonly used for: pre/post tool execution, agent lifecycle events, and custom 
+        integrations." 
+
+       - "Error handling follows a custom error class pattern. All custom errors extend `BaseError` and include: error 
+        code, message, context object, and optional cause. Use `ErrorHandler.wrap(fn)` for consistent error boundaries across 
+        async operations." 

package/dist/resources/prompts/modes/autonomous.yml

@@ -0,0 +1,9 @@
+description: "autonomous execution instructions"
+prompt: |
+
+  CRITICAL: Autonomous Execution Required
+
+  You are currently in autonomous mode. You can use all tools to process the input data and perform the CREATE, READ, UPDATE and DELETE operations on the context tree without any human intervention.
+
+excluded_tools: []
+

package/dist/resources/prompts/query-context-tree-retrieval.yml

@@ -0,0 +1,49 @@
+description: "context tree retrieval instructions for query command"
+prompt: |
+
+  Your task is to search and retrieve relevant information from the context tree to answer the user's query. 
+  Prioritize tool call efficiency for tools that can be run in parallel.
+  ONLY give up on search in the last iteration.
+
+  Follow these steps to provide comprehensive answers:
+
+  1. **Understand the query**: Analyze what the user is asking for - which domains, topics, or specific information they need.
+
+  2. **Search strategically**:
+     - Use `find_knowledge_topics` to locate relevant topics across domains with pattern matching
+     - Use `read_file` to read the full content of relevant context.md files
+     - Use `grep_content` to search for specific terms, code snippets, or patterns within context files
+     - Use `glob_files` to find files by path patterns if needed
+     - For multi-part queries (queries that include words like "and"), use tools in parallel:
+      - Use `find_knowledge_topics` and `read_file` multiple times to get all relevant topics and their full content.
+      - If ANY of these tools don't depend on each other, try to run them in the same iteration.
+
+     - Consider the context tree structure: `.brv/context-tree/{domain}/{topic}/context.md`
+
+  3. **Read relevant content**:
+     - Use `read_file` to read the full content of relevant context.md files
+     - Read multiple files if the query spans multiple domains or topics
+
+  4. **Synthesize and present**:
+     - Organize findings by domain and topic
+     - Important: Even if you don't have the answer, provide the best answer you can with the information gathered.
+     - Include relevant content excerpts with their source paths (e.g., "From code_style/best_practices:")
+     - Provide clear, structured answers with citations. 
+     - If multiple topics are relevant, group them logically
+
+  5. **Be thorough but efficient**:
+     - Search progressively - start broad, then narrow down based on findings
+     - Use pattern matching to avoid reading entire tree
+     - If initial search returns too many results, refine with more specific patterns
+     - If search returns no results, try broader patterns or alternative terms
+
+  Available domains in the context tree:
+  - `code_style` - Coding standards, style guidelines, quality standards
+  - `design` - UI/UX design, component libraries, themes, design systems
+  - `structure` - Project structure, architecture, component organization
+  - `compliance` - Security policies, compliance requirements, best practices
+  - `testing` - Testing strategies, test implementation, quality assurance
+  - `bug_fixes` - Bug fixing procedures, common issues, troubleshooting guides
+
+excluded_tools: []
+

package/dist/resources/prompts/reflection.yml

@@ -0,0 +1,27 @@
+# Reflection prompts for task completion checking
+# These prompts help the agent assess progress and determine when tasks are complete
+description: Reflection prompts for task completion self-assessment
+prompt: "Reflection prompts for task completion"
+
+prompts:
+  completion_check: |
+    For every iteration, consider whether you have gathered sufficient information to answer the users' question.
+
+  mid_point_check: |
+    You've used {{current_iteration}} iterations ({{remaining_iterations}} remaining). Review your progress:
+    - Do you have enough information to answer all parts of the question?
+    -   If yes, provide your answer now. If it is a multi-part question, provide your answer for each part. Stop exploring or running more tools.
+    -   If no, please continue exploring or running more tools for missing parts of the question.
+    - However, DO NOT declare you can't answer the question and keep searching if you have at least one iteration left.
+
+  near_max_iterations: |
+    NOTICE: You are approaching the iteration limit ({{current_iteration}}/{{max_iterations}}).
+    To ensure task completion: 
+    - If this is the last iteration, don't running any more tools. Try to answer all parts of the question using the information you already have.
+    - Answer the question immediately if possible. Run tools ONLY IF you still have at least one iteration left.
+    - However, DO NOT declare you can't answer the question and keep searching if you have at least one iteration left.
+
+  final_iteration: |
+    FINAL ITERATION: This is your last opportunity to respond.
+    Review what you've learned from your previous tool calls and provide your answer now.
+    Summarize your findings and give the best answer you can with the information gathered.