cecli-dev 0.99.7__tar.gz → 0.99.8__tar.gz

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.7
+Version: 0.99.8
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.7'
-__version_tuple__ = version_tuple = (0, 99, 7)
+__version__ = version = '0.99.8'
+__version_tuple__ = version_tuple = (0, 99, 8)
 
-__commit_id__ = commit_id = 'gf217080c8'
+__commit_id__ = commit_id = 'g2e022d0e6'

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/change_tracker.py

@@ -21,7 +21,7 @@ class ChangeTracker:
 
         Parameters:
         - file_path: Path to the file that was changed
-        - change_type: Type of change (e.g., 'replacetext', 'insertlines')
+        - change_type: Type of change (e.g., 'edittext', 'insertlines')
         - original_content: Original content before the change
         - new_content: New content after the change
         - metadata: Additional information about the change (line numbers, positions, etc.)

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/coders/agent_coder.py

@@ -55,15 +55,15 @@ class AgentCoder(Coder):
             "commandinteractive",
             "explorecode",
             "ls",
+            "getlines",
             "grep",
-            "showcontext",
             "thinking",
             "updatetodolist",
         }
         self.write_tools = {
-            "deletetext",
-            "inserttext",
-            "replacetext",
+            "command",
+            "commandinteractive",
+            "edittext",
             "undochange",
         }
         self.edit_allowed = False
@@ -999,7 +999,7 @@ I will proceed based on the tool results and updated context.""")
             context_parts.append("\n\n")
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
-                "File editing tools are currently disabled.Use `ShowContext` to determine the"
+                "File editing tools are currently disabled.Use `GetLines` to determine the"
                 " current hashline prefixes needed to perform an edit and activate them when you"
                 " are ready to edit a file."
             )

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/main.py

@@ -361,64 +361,12 @@ def register_litellm_models(git_root, model_metadata_fname, io, verbose=False):
 
 def load_model_overrides(git_root, model_overrides_fname, io, verbose=False):
     """Load model tag overrides from a YAML file."""
-    from pathlib import Path
-
-    import yaml
-
-    model_overrides_files = generate_search_path_list(
-        ".cecli.model.overrides.yml", git_root, model_overrides_fname
-    )
-    overrides = {}
-    files_loaded = []
-    for fname in model_overrides_files:
-        try:
-            if Path(fname).exists():
-                with open(fname, "r") as f:
-                    content = yaml.safe_load(f)
-                    if content:
-                        for model_name, tags in content.items():
-                            if model_name not in overrides:
-                                overrides[model_name] = {}
-                            overrides[model_name].update(tags)
-                        files_loaded.append(fname)
-        except Exception as e:
-            io.tool_error(f"Error loading model overrides from {fname}: {e}")
-    if len(files_loaded) > 0 and verbose:
-        io.tool_output("Loaded model overrides from:")
-        for file_loaded in files_loaded:
-            io.tool_output(f"  - {file_loaded}")
-    if (
-        model_overrides_fname
-        and model_overrides_fname not in files_loaded
-        and model_overrides_fname != ".cecli.model.overrides.yml"
-    ):
-        io.tool_warning(f"Model Overrides File Not Found: {model_overrides_fname}")
-    return overrides
+    models.ModelOverrides.load_from_file(git_root, model_overrides_fname, io, verbose=verbose)
 
 
 def load_model_overrides_from_string(model_overrides_str, io):
     """Load model tag overrides from a JSON/YAML string."""
-    import json
-
-    import yaml
-
-    overrides = {}
-    if not model_overrides_str:
-        return overrides
-    try:
-        try:
-            content = json.loads(model_overrides_str)
-        except json.JSONDecodeError:
-            content = yaml.safe_load(model_overrides_str)
-        if content and isinstance(content, dict):
-            for model_name, tags in content.items():
-                if model_name not in overrides:
-                    overrides[model_name] = {}
-                overrides[model_name].update(tags)
-        return overrides
-    except Exception as e:
-        io.tool_error(f"Error parsing model overrides string: {e}")
-        return {}
+    models.ModelOverrides.load_from_string(model_overrides_str, io)
 
 
 async def sanity_check_repo(repo, io):
@@ -847,105 +795,52 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
     if not selected_model_name:
         return await graceful_exit(None, 1)
     args.model = selected_model_name
-    model_overrides = {}
+
+    # Load model tag overrides (stored in ModelOverrides class-level state)
     if args.model_overrides_file:
-        model_overrides = load_model_overrides(
+        models.ModelOverrides.load_from_file(
             git_root, args.model_overrides_file, io, verbose=args.verbose
         )
+
     if args.model_overrides:
-        direct_overrides = load_model_overrides_from_string(args.model_overrides, io)
-        for model_name, tags in direct_overrides.items():
-            if model_name not in model_overrides:
-                model_overrides[model_name] = {}
-            model_overrides[model_name].update(tags)
-    override_index = {}
-    for base_model, suffixes in model_overrides.items():
-        if not isinstance(suffixes, dict):
-            continue
-        for suffix, cfg in suffixes.items():
-            if not isinstance(cfg, dict):
-                continue
-            full_name = f"{base_model}:{suffix}"
-            override_index[full_name] = base_model, cfg
-
-    def apply_model_overrides(model_name):
-        """Return (effective_model_name, override_kwargs) for a given model_name.
-
-        If model_name ends with ":suffix" where suffix is configured for the
-        prefix (everything before the last colon), we switch to the prefix model
-        and apply that override dict. Otherwise we leave the name unchanged
-        and return empty overrides.
-        """
-        if not model_name:
-            return model_name, {}
-        prefix = ""
-        if model_name.startswith(models.COPY_PASTE_PREFIX):
-            prefix = models.COPY_PASTE_PREFIX
-            model_name = model_name[len(prefix) :]
-
-        # Try to find a matching override by checking all possible suffix matches.
-        # We iterate from right to left splitting on colons to handle cases where
-        # the base model name itself contains colons (e.g. "provider/model:tag:alias")
-        parts = model_name.split(":")
-        # We need at least one split to have a base and a suffix
-        for i in range(len(parts) - 1, 0, -1):
-            potential_base = ":".join(parts[:i])
-            potential_suffix = ":".join(parts[i:])
-
-            # Check if this base has the suffix configured
-            if potential_base in model_overrides:
-                suffixes = model_overrides[potential_base]
-                if isinstance(suffixes, dict) and potential_suffix in suffixes:
-                    cfg = suffixes[potential_suffix]
-                    if isinstance(cfg, dict):
-                        model_name = prefix + potential_base
-                        return model_name, cfg.copy()
-
-        # No match found
-        model_name = prefix + model_name
-        return model_name, {}
-
-    main_model_name, main_model_overrides = apply_model_overrides(args.model)
-    weak_model_name, weak_model_overrides = apply_model_overrides(args.weak_model)
-    editor_model_name, editor_model_overrides = apply_model_overrides(args.editor_model)
-    agent_model_name, agent_model_overrides = apply_model_overrides(args.agent_model)
+        models.ModelOverrides.load_from_string(args.model_overrides, io)
+
     weak_model_obj = None
-    if weak_model_name:
+    if args.weak_model:
         weak_model_obj = models.Model(
-            weak_model_name,
+            args.weak_model,
             weak_model=False,
             verbose=args.verbose,
             io=io,
-            override_kwargs=weak_model_overrides,
             retries=args.retries,
             debug=args.debug,
         )
+
     editor_model_obj = None
-    if editor_model_name:
+    if args.editor_model:
         editor_model_obj = models.Model(
-            editor_model_name,
+            args.editor_model,
             editor_model=False,
             verbose=args.verbose,
             io=io,
-            override_kwargs=editor_model_overrides,
             retries=args.retries,
             debug=args.debug,
         )
+
     agent_model_obj = None
-    if agent_model_name:
+    if args.agent_model:
         agent_model_obj = models.Model(
-            agent_model_name,
+            args.agent_model,
             agent_model=False,
             verbose=args.verbose,
             io=io,
-            override_kwargs=agent_model_overrides,
             retries=args.retries,
             debug=args.debug,
         )
 
-    if main_model_name.startswith("openrouter/") and not os.environ.get("OPENROUTER_API_KEY"):
+    if args.model.startswith("openrouter/") and not os.environ.get("OPENROUTER_API_KEY"):
         io.tool_warning(
-            f"The specified model '{main_model_name}' requires an OpenRouter API key, which was not"
+            f"The specified model '{args.model}' requires an OpenRouter API key, which was not"
             " found."
         )
         if await offer_openrouter_oauth(io):
@@ -958,24 +853,25 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
                 return await graceful_exit(None, 1)
         else:
             io.tool_error(
-                f"Unable to proceed without an OpenRouter API key for model '{main_model_name}'."
+                f"Unable to proceed without an OpenRouter API key for model '{args.model}'."
             )
             await io.offer_url(
                 urls.models_and_keys, "Open documentation URL for more info?", acknowledge=True
             )
             return await graceful_exit(None, 1)
+
     main_model = models.Model(
-        main_model_name,
+        args.model,
         weak_model=weak_model_obj,
         editor_model=editor_model_obj,
         agent_model=agent_model_obj,
         editor_edit_format=args.editor_edit_format,
         verbose=args.verbose,
         io=io,
-        override_kwargs=main_model_overrides,
         retries=args.retries,
         debug=args.debug,
     )
+
     if args.copy_paste and main_model.copy_paste_transport == "api":
         main_model.enable_copy_paste_mode()
     if main_model.remove_reasoning is not None:

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/models.py

@@ -20,7 +20,7 @@ from cecli import __version__
 from cecli.dump import dump
 from cecli.exceptions import LiteLLMExceptions
 from cecli.helpers import nested
-from cecli.helpers.file_searcher import handle_core_files
+from cecli.helpers.file_searcher import generate_search_path_list, handle_core_files
 from cecli.helpers.model_providers import ModelProviderManager
 from cecli.helpers.nested import deep_merge
 from cecli.helpers.requests import model_request_parser
@@ -310,6 +310,152 @@ class ModelInfoManager:
 model_info_manager = ModelInfoManager()
 
 
+class ModelOverrides:
+    """Class-level manager for model tag overrides (suffix-based model name resolution).
+
+    Allows users to define model tag overrides like "model:suffix" that map to
+    a base model name with specific configuration overrides.
+
+    State is stored at the class level so it can be loaded once (e.g. from a YAML file
+    in the entry point) and automatically applied when Model is instantiated.
+    """
+
+    _overrides: dict = {}
+    _defaults_overrides: dict = {}
+
+    @classmethod
+    def load_from_file(cls, git_root, model_overrides_fname, io, verbose=False):
+        """Load model tag overrides from a YAML file."""
+        from pathlib import Path
+
+        import yaml
+
+        model_overrides_files = generate_search_path_list(
+            ".cecli.model.overrides.yml", git_root, model_overrides_fname
+        )
+        overrides = {}
+        files_loaded = []
+        for fname in model_overrides_files:
+            try:
+                if Path(fname).exists():
+                    with open(fname, "r") as f:
+                        content = yaml.safe_load(f)
+                        if content:
+                            for model_name, tags in content.items():
+                                if model_name not in overrides:
+                                    overrides[model_name] = {}
+                                overrides[model_name].update(tags)
+                            files_loaded.append(fname)
+            except Exception as e:
+                io.tool_error(f"Error loading model overrides from {fname}: {e}")
+        if len(files_loaded) > 0 and verbose:
+            io.tool_output("Loaded model overrides from:")
+            for file_loaded in files_loaded:
+                io.tool_output(f"  - {file_loaded}")
+        if (
+            model_overrides_fname
+            and model_overrides_fname not in files_loaded
+            and model_overrides_fname != ".cecli.model.overrides.yml"
+        ):
+            io.tool_warning(f"Model Overrides File Not Found: {model_overrides_fname}")
+        cls._from_file_or_string(overrides)
+
+    @classmethod
+    def load_from_string(cls, model_overrides_str, io):
+        """Load model tag overrides from a JSON/YAML string."""
+        import json
+
+        import yaml
+
+        overrides = {}
+        if not model_overrides_str:
+            return
+        try:
+            try:
+                content = json.loads(model_overrides_str)
+            except json.JSONDecodeError:
+                content = yaml.safe_load(model_overrides_str)
+            if content and isinstance(content, dict):
+                for model_name, tags in content.items():
+                    if model_name not in overrides:
+                        overrides[model_name] = {}
+                    overrides[model_name].update(tags)
+        except Exception as e:
+            io.tool_error(f"Error parsing model overrides string: {e}")
+            return
+        cls._from_file_or_string(overrides)
+
+    @classmethod
+    def _from_file_or_string(cls, overrides):
+        """Internal: process raw overrides dict into class-level state."""
+        # Extract 'defaults' key for direct model name matching
+        defaults_overrides = {}
+        if "defaults" in overrides:
+            defaults_overrides = overrides.pop("defaults")
+            if not isinstance(defaults_overrides, dict):
+                defaults_overrides = {}
+
+        # Merge into class-level state
+        for model_name, tags in overrides.items():
+            if model_name not in cls._overrides:
+                cls._overrides[model_name] = {}
+            if isinstance(tags, dict):
+                cls._overrides[model_name].update(tags)
+
+        # Merge defaults
+        for model_name, tags in defaults_overrides.items():
+            if model_name not in cls._defaults_overrides:
+                cls._defaults_overrides[model_name] = {}
+            if isinstance(tags, dict):
+                cls._defaults_overrides[model_name].update(tags)
+
+    @classmethod
+    def apply(cls, model_name):
+        """Return (effective_model_name, override_kwargs) for a given model_name.
+
+        If model_name ends with ":suffix" where suffix is configured for the
+        prefix (everything before the last colon), we return the prefix model
+        and the associated override dict. Otherwise we leave the name unchanged
+        and return empty overrides.
+
+        NOTE: COPY_PASTE_PREFIX handling is done by Model.__init__ before this
+        method is called, so we only work with the clean model name here.
+        """
+        if not model_name:
+            return model_name, {}
+
+        # Try to find a matching override by checking all possible suffix matches.
+        # We iterate from right to left splitting on colons to handle cases where
+        # the base model name itself contains colons (e.g. "provider/model:tag:alias")
+        parts = model_name.split(":")
+        for i in range(len(parts) - 1, 0, -1):
+            potential_base = ":".join(parts[:i])
+            potential_suffix = ":".join(parts[i:])
+
+            # Check if this base has the suffix configured
+            if potential_base in cls._overrides:
+                suffixes = cls._overrides[potential_base]
+                if isinstance(suffixes, dict) and potential_suffix in suffixes:
+                    cfg = suffixes[potential_suffix]
+                    if isinstance(cfg, dict):
+                        return potential_base, cfg.copy()
+
+        # Check for direct match in defaults overrides
+        if model_name in cls._defaults_overrides:
+            cfg = cls._defaults_overrides[model_name]
+            if isinstance(cfg, dict):
+                return model_name, cfg.copy()
+
+        # No match found
+        return model_name, {}
+
+    @classmethod
+    def clear(cls):
+        """Reset all model overrides."""
+        cls._overrides = {}
+        cls._defaults_overrides = {}
+
+
 class Model(ModelSettings):
     def __init__(
         self,
@@ -325,9 +471,7 @@ class Model(ModelSettings):
 
         io = kwargs.get("io", nested.getter(from_model, "io", None))
         verbose = kwargs.get("verbose", nested.getter(from_model, "verbose", False))
-        override_kwargs = kwargs.get(
-            "override_kwargs", nested.getter(from_model, "override_kwargs", None)
-        )
+        override_kwargs = kwargs.get("override_kwargs", None)
         retries = kwargs.get("retries", nested.getter(from_model, "retries", None))
         debug = kwargs.get("debug", nested.getter(from_model, "debug", False))
 
@@ -357,6 +501,20 @@ class Model(ModelSettings):
         else:
             model = provided_model
         model = MODEL_ALIASES.get(model, model)
+
+        # Resolve model tag overrides (suffix-based model name resolution)
+        resolved_model, resolved_overrides = ModelOverrides.apply(model)
+
+        if resolved_overrides:
+            model = resolved_model
+            merged = resolved_overrides.copy()
+
+            if override_kwargs:
+                merged.update(override_kwargs)
+
+            override_kwargs = merged
+            self.override_kwargs = override_kwargs
+
         self.name = model
         self.max_chat_history_tokens = 1024
         self.weak_model = None
@@ -435,7 +593,7 @@ class Model(ModelSettings):
             valid_model_settings_fields = {f.name for f in fields(ModelSettings)}
 
             for key, value in self.override_kwargs.items():
-                if key == "model_settings":
+                if key == "model_settings" or key == "model-settings":
                     if not isinstance(value, dict):
                         raise ValueError(
                             f"override_kwargs 'model_settings' must be a dict, got {type(value)}"
@@ -1005,13 +1163,16 @@ class Model(ModelSettings):
                 override_kwargs.pop("temperature", None)
 
         effective_tools = tools
+
         if effective_tools is None and functions:
             effective_tools = [dict(type="function", function=f) for f in functions]
+
         if effective_tools:
             sorted_tools = sorted(
                 effective_tools, key=lambda x: x.get("function", {}).get("name", "Invalid Name")
             )
             kwargs["tools"] = sorted_tools
+
         if functions and len(functions) == 1:
             function = functions[0]
             if "name" in function:
@@ -1055,9 +1216,17 @@ class Model(ModelSettings):
                 }
 
         if kwargs.get("headers", None):
-            kwargs["headers"].update({"Connection": "close"})
+            kwargs["headers"].update(
+                {
+                    "User-Agent": f"cecli/{__version__}",
+                    "Connection": "close",
+                }
+            )
         else:
-            kwargs["headers"] = {"Connection": "close"}
+            kwargs["headers"] = {
+                "User-Agent": f"cecli/{__version__}",
+                "Connection": "close",
+            }
 
         litellm_ex = LiteLLMExceptions()
         retry_delay = 0.125
@@ -1124,7 +1293,12 @@ class Model(ModelSettings):
                 await asyncio.sleep(retry_delay)
                 continue
 
-    async def simple_send_with_retries(self, messages, max_tokens=None):
+    async def simple_send_with_retries(
+        self,
+        messages,
+        max_tokens=None,
+        override_kwargs={},
+    ):
         from cecli.exceptions import LiteLLMExceptions
 
         litellm_ex = LiteLLMExceptions()
@@ -1134,7 +1308,11 @@ class Model(ModelSettings):
         while True:
             try:
                 _hash, response = await self.send_completion(
-                    messages=messages, functions=None, stream=False, max_tokens=max_tokens
+                    messages=messages,
+                    functions=None,
+                    stream=False,
+                    max_tokens=max_tokens,
+                    override_kwargs=override_kwargs,
                 )
                 if (
                     not response

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/prompts/agent.yml

@@ -19,7 +19,7 @@ main_system: |
   ## Core Directives
   **Act Proactively**: Autonomously use discovery and management tools to fulfill the request. Chain tool calls across multiple turns for continuous exploration.
   **Be Decisive**: Trust your findings. Do not repeat identical searches or ask redundant questions.
-  **Be Efficient**: You may use multiple tools each turn. Batch tool calls when tools allow you to. Respect usage limits while maximizing the utility of each turn.
+  **Be Efficient**: Use multiple tools each turn when possible. Batch tool calls when tools allow you to. Respect usage limits while maximizing the utility of each turn.
   **Be Persistent**: Do not take short cuts. Work through your task until completion. No task takes too long as long as you are making progress towards the goal.
   </context>
 
@@ -46,14 +46,8 @@ main_system: |
 
   ## Todo List Management
   - Use `UpdateTodoList` to keep the state synchronized as you complete subtasks.
-  - Break complex tasks and long edits into granular steps so they remain tractable and context-efficient
+  - Break complex tasks and long edits into smaller steps so they remain tractable and context-efficient
 
-  ### Editing Tool Protocol
-
-  **MANDATORY Two-Phase Safety Protocol**:
-    1. **Phase 1**: Use `ShowContext` to gather the hashline-prefixed content of the section to modify. Capture entire functions, logical blocks and closures.
-    2. **Phase 2**: Execute the edit (`ReplaceText`, `InsertText`, `DeleteText`) using the verified hashlines prefixes from the `ShowContext` tool.
-   
   **Atomic Scope:** Include the **entire function or logical block**. Never return partial syntax or broken closures. Do not attempt to replace just the beginning or end of a closure.
   **Indentation**: Preserve all necessary whitespace (spaces, tabs, and newlines) and stylistic indentation.   
   </context>
@@ -66,7 +60,7 @@ system_reminder: |
   ## Operational Rules
   - **Scope**: No unrequested refactors. Edit files incrementally; avoid full-file rewrites.
   - **Hygiene**: Use `ContextManager`/`RemoveSkill` to evict unneeded files/skills immediately after use.
-  - **Verification**: You MUST use `ShowContext` to verify hashline ranges before every edit.
+  - **Preparation**: Use `GetLines` to verify hashline ranges before every edit. Capture entire functions, logical blocks and closures.
   - **Outputs**: Tool calls trigger turns. Never include tool syntax in final user summaries.
   - **Sandbox**: Perform all verification and temp logic in `.cecli/temp`.
   - **Vibe**: Zero conversational filler. Do not confirm instructions or state "I understand." Provide status updates only when you have new information.

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/repo.py

@@ -428,7 +428,14 @@ class GitRepo:
             if max_tokens and num_tokens > max_tokens:
                 continue
 
-            commit_message = await model.simple_send_with_retries(messages)
+            commit_message = await model.simple_send_with_retries(
+                messages,
+                override_kwargs={
+                    "reasoning_effort": None,
+                    "thinking": None,
+                    "drop_params": True,
+                },
+            )
             if commit_message:
                 break  # Found a model that could generate the message
 

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/tools/__init__.py

@@ -6,9 +6,10 @@ from . import (
     command,
     command_interactive,
     context_manager,
-    delete_text,
+    edit_text,
     explore_code,
     finished,
+    get_lines,
     git_branch,
     git_diff,
     git_log,
@@ -16,12 +17,9 @@ from . import (
     git_show,
     git_status,
     grep,
-    insert_text,
     load_skill,
     ls,
     remove_skill,
-    replace_text,
-    show_context,
     thinking,
     undo_change,
     update_todo_list,
@@ -32,9 +30,10 @@ TOOL_MODULES = [
     command,
     command_interactive,
     context_manager,
-    delete_text,
+    edit_text,
     explore_code,
     finished,
+    get_lines,
     git_branch,
     git_diff,
     git_log,
@@ -42,12 +41,9 @@ TOOL_MODULES = [
     git_show,
     git_status,
     grep,
-    insert_text,
     load_skill,
     ls,
     remove_skill,
-    replace_text,
-    show_context,
     thinking,
     undo_change,
     update_todo_list,

{cecli_dev-0.99.7 → cecli_dev-0.99.8}/cecli/tools/command.py

@@ -255,8 +255,10 @@ class Tool(BaseTool):
                         f"[Large Response ({total_size} characters). "
                         "Output saved to paginated files.]\n"
                         f"File Aliases (for use with ContextManager):\n{alias_list_str}\n"
-                        "Use the `ContextManager` tool to view these files and to remove them "
-                        "when done reading. Do not use standard cli tools to view these files."
+                        "Use the `ContextManager` tool to view these files."
+                        "Do not use standard cli tools to view these files."
+                        "Remove them from context after taking note of the relevant information "
+                        "in the output to prevent overfilling stale context."
                     )
 
                 # Remove from background tracking since it's done
@@ -339,8 +341,10 @@ class Tool(BaseTool):
                 f"[Large Response ({total_size} characters). "
                 "Output saved to paginated files.]\n"
                 f"File Aliases (for use with ContextManager):\n{alias_list_str}\n"
-                "Use the `ContextManager` tool to view these files and to remove them "
-                "when done reading. Do not use standard cli tools to view these files."
+                "Use the `ContextManager` tool to view these files."
+                "Do not use standard cli tools to view these files."
+                "Remove them from context after taking note of the relevant information "
+                "in the output to prevent overfilling stale context."
             )
 
         if tui: