cecli-dev 0.99.2__tar.gz → 0.99.3__tar.gz

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.2
+Version: 0.99.3
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -52,6 +52,7 @@ Requires-Dist: textual>=6.0.0
 Requires-Dist: tomlkit>=0.14.0
 Requires-Dist: truststore
 Requires-Dist: xxhash>=3.6.0
+Requires-Dist: py-cymbal>=0.1.5
 Requires-Dist: rustworkx>=0.15.0
 Requires-Dist: scipy>=1.15.3
 Requires-Dist: importlib-metadata>=7.2.1

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.99.2.dev"
+__version__ = "0.99.3.dev"
 safe_version = __version__
 
 try:

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.2'
-__version_tuple__ = version_tuple = (0, 99, 2)
+__version__ = version = '0.99.3'
+__version_tuple__ = version_tuple = (0, 99, 3)
 
-__commit_id__ = commit_id = 'g7361036c0'
+__commit_id__ = commit_id = 'g2909d229a'

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/args.py

@@ -593,6 +593,12 @@ def get_parser(default_config_files, git_root):
         help="Show token processing and generation speed in usage report (default: False)",
         default=False,
     )
+    group.add_argument(
+        "--use-reminders",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable injecting reminder messages (default: True)",
+    )
     group.add_argument(
         "--completion-menu-color",
         metavar="COLOR",

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/coders/agent_coder.py

@@ -25,6 +25,7 @@ from cecli.helpers.skills import SkillsManager
 from cecli.hooks import HookIntegration
 from cecli.llm import litellm
 from cecli.mcp import LocalServer, McpServerManager
+from cecli.tools.utils.base_tool import BaseTool
 from cecli.tools.utils.registry import ToolRegistry
 from cecli.utils import copy_tool_call, tool_call_to_dict
 
@@ -52,12 +53,9 @@ class AgentCoder(Coder):
         self.read_tools = {
             "command",
             "commandinteractive",
-            "viewfilesatglob",
-            "viewfilesmatching",
+            "exploresymbols",
             "ls",
-            "viewfileswithsymbol",
             "grep",
-            "listchanges",
             "showcontext",
             "thinking",
             "updatetodolist",
@@ -328,7 +326,7 @@ class AgentCoder(Coder):
                 {"role": "tool", "tool_call_id": tool_call.id, "content": result_message}
             )
 
-        if self.auto_lint and used_write_tool and not self.edit_allowed:
+        if self.auto_lint and used_write_tool:
             edited = list(self.files_edited_by_tools)
             lint_errors = self.lint_edited(edited, show_output=False)
             self.lint_outcome = not lint_errors
@@ -1160,7 +1158,7 @@ I will proceed based on the tool results and updated context.""")
 
         Parameters:
         - file_path: Path to the file to add
-        - explicit: Whether this was an explicit view command (vs. implicit through ViewFilesMatching)
+        - explicit: Whether this was an explicit view command (vs. implicit through other tools)
         """
         abs_path = self.abs_root_path(file_path)
         rel_path = self.get_rel_fname(abs_path)
@@ -1205,7 +1203,7 @@ I will proceed based on the tool results and updated context.""")
 
         Override parent's method to disable implicit file mention handling in agent mode.
         Files should only be added via explicit tool commands
-        (`View`, `ViewFilesAtGlob`, `ViewFilesMatching`, `ViewFilesWithSymbol`).
+        (`ContextManager`).
         """
         pass
 
@@ -1217,6 +1215,7 @@ I will proceed based on the tool results and updated context.""")
         inp = await super().preproc_user_input(inp)
         inp = self.wrap_user_input(inp)
 
+        BaseTool.clear_invocation_cache()
         self.agent_finished = False
         self.turn_count = 0
         return inp

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/coders/base_coder.py

@@ -42,6 +42,7 @@ from cecli.commands import Commands, SwitchCoderSignal
 from cecli.exceptions import LiteLLMExceptions
 from cecli.helpers import command_parser, coroutines, nested, responses
 from cecli.helpers.conversation import ConversationService, MessageTag
+from cecli.helpers.observations.manager import ObservationManager
 from cecli.helpers.profiler import TokenProfiler
 from cecli.history import ChatSummary
 from cecli.hooks import HookIntegration
@@ -441,6 +442,7 @@ class Coder:
 
         # Initialize conversation system if enabled
         ConversationService.get_chunks(self).initialize_conversation_system()
+        self.observation_manager = ObservationManager.get_instance(self)
 
         self.commands = commands or Commands(self.io, self, args=args)
         self.commands.coder = self
@@ -921,10 +923,10 @@ class Coder:
                             file_stub = RepoMap.get_file_stub(fname, self.io)
 
                             # Add message about showing definitions instead of full content
-                            self.io.tool_output(
-                                f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
-                                "Use /context-management to toggle truncation off if needed."
-                            )
+                            # self.io.tool_output(
+                            #    f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                            #    "Use /context-management to toggle truncation off if needed."
+                            # )
 
                             # Add a message in the content itself so the model knows it's truncated
                             truncation_note = (
@@ -989,10 +991,10 @@ class Coder:
                         file_stub = RepoMap.get_file_stub(fname, self.io)
 
                         # Add message about showing definitions instead of full content
-                        self.io.tool_output(
-                            f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
-                            "Use /context-management to toggle truncation off if needed."
-                        )
+                        # self.io.tool_output(
+                        #    f"⚠️ '{relative_fname}' is very large ({file_tokens} tokens). "
+                        #    "Use /context-management to toggle truncation off if needed."
+                        # )
 
                         # Add a message in the content itself so the model knows it's truncated
                         truncation_note = (
@@ -1746,11 +1748,14 @@ class Coder:
         if not self.enable_context_compaction:
             return
 
-        # Check if combined messages exceed the token limit,
-        # Get messages from ConversationManager
-        done_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.DONE)
-        cur_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.CUR)
-        diff_messages = ConversationService.get_manager(self).get_messages_dict(MessageTag.DIFFS)
+        # Trigger background observation/reflection check
+        await self.observation_manager.check_and_trigger()
+
+        manager = ConversationService.get_manager(self)
+        done_messages = manager.get_messages_dict(MessageTag.DONE)
+        cur_messages = manager.get_messages_dict(MessageTag.CUR)
+        diff_messages = manager.get_messages_dict(MessageTag.DIFFS)
+
         # Exclude first cur_message since that's the user's initial input
         done_tokens = self.summarizer.count_tokens(done_messages)
         cur_tokens = self.summarizer.count_tokens(cur_messages[1:] if len(cur_messages) > 1 else [])
@@ -1768,129 +1773,97 @@ class Coder:
         self.io.update_spinner("Compacting...")
 
         try:
-            # Check if done_messages alone exceed the limit
-            if done_tokens > self.context_compaction_max_tokens or done_tokens > cur_tokens:
-                # Create a summary of the done_messages
-                # Append custom message to compaction prompt if provided
-                compaction_prompt = self.gpt_prompts.compaction_prompt
-                if message:
-                    compaction_prompt = f"{compaction_prompt}\n\n{message}"
-
-                summary_text = await self.summarizer.summarize_all_as_text(
-                    done_messages,
+            compaction_prompt = self.gpt_prompts.compaction_prompt
+            if message:
+                compaction_prompt = f"{compaction_prompt}\n\n{message}"
+
+            async def summarize_and_update(messages, tag):
+                text = await self.summarizer.summarize_all_as_text(
+                    messages,
                     compaction_prompt,
                     self.context_compaction_summary_tokens,
                 )
+                if not text:
+                    raise ValueError(f"Summarization of {tag} messages returned empty.")
 
-                if not summary_text:
-                    raise ValueError("Summarization returned an empty result.")
+                if self.observation_manager.observations:
+                    obs_text = "\n".join(self.observation_manager.observations)
+                    text = f"HISTORICAL OBSERVATIONS:\n{obs_text}\n\n{text}"
 
-                # Replace old DONE messages with the summary in ConversationManager
-                ConversationService.get_manager(self).clear_tag(MessageTag.DONE)
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "user",
-                        "content": summary_text,
-                    },
-                    tag=MessageTag.DONE,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": (
-                            "Ok, I will use this summary as the context for our conversation going"
-                            " forward."
-                        ),
-                    },
-                    tag=MessageTag.DONE,
-                )
+                manager.clear_tag(tag)
 
-            # Check if cur_messages alone exceed the limit (after potentially compacting done_messages)
-            if cur_tokens > self.context_compaction_max_tokens or cur_tokens > done_tokens:
-                # Create a summary of the cur_messages
-                # Append custom message to compaction prompt if provided
-                compaction_prompt = self.gpt_prompts.compaction_prompt
-                if message:
-                    compaction_prompt = f"{compaction_prompt}\n\n{message}"
-
-                cur_summary_text = await self.summarizer.summarize_all_as_text(
-                    cur_messages,
-                    compaction_prompt,
-                    self.context_compaction_summary_tokens,
-                )
-
-                if not cur_summary_text:
-                    raise ValueError("Summarization of current messages returned an empty result.")
+                if tag == MessageTag.DONE:
+                    manager.add_message({"role": "user", "content": text}, tag=tag)
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": (
+                                "Ok, I will use this summary and the observations as context for"
+                                " our conversation going forward."
+                            ),
+                        },
+                        tag=tag,
+                    )
+                else:
+                    if self.last_user_message:
+                        manager.add_message(
+                            {"role": "user", "content": self.last_user_message}, tag=tag
+                        )
 
-                # Replace current CUR messages with the summary in ConversationManager
-                ConversationService.get_manager(self).clear_tag(MessageTag.CUR)
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": "Ok. I am awaiting your summary of our goals to proceed.",
+                        },
+                        tag=tag,
+                        force=True,
+                    )
 
-                if self.last_user_message:
-                    ConversationService.get_manager(self).add_message(
-                        message_dict={
+                    manager.add_message(
+                        {
                             "role": "user",
-                            "content": self.last_user_message,
+                            "content": (
+                                "Here is a summary of our current goals and historical"
+                                f" context:\n{text}"
+                            ),
                         },
-                        tag=MessageTag.CUR,
+                        tag=tag,
                     )
 
-                # Add the summary conversation
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": "Ok. I am awaiting your summary of our goals to proceed.",
-                    },
-                    tag=MessageTag.CUR,
-                    force=True,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "user",
-                        "content": f"Here is a summary of our current goals:\n{cur_summary_text}",
-                    },
-                    tag=MessageTag.CUR,
-                )
-                ConversationService.get_manager(self).add_message(
-                    message_dict={
-                        "role": "assistant",
-                        "content": (
-                            "Ok, I will use this summary and proceed with our task."
-                            " I will first apply any changes in the summary and then"
-                            " continue exploration as necessary."
-                        ),
-                    },
-                    tag=MessageTag.CUR,
-                    force=True,
-                )
-
-                # Find the last assistant messages in the current conversation
-                latest_messages = []
+                    manager.add_message(
+                        {
+                            "role": "assistant",
+                            "content": (
+                                "Ok, I will use this summary and proceed with our task. I will"
+                                " first apply any changes in the summary and then continue"
+                                " exploration as necessary."
+                            ),
+                        },
+                        tag=tag,
+                        force=True,
+                    )
 
-                # Search from the end to find the most recent assistant messages
-                for msg in reversed(cur_messages):
-                    latest_messages.append(msg)
+                    latest_messages = []
+                    for msg in reversed(messages):
+                        latest_messages.append(msg)
+                        if msg["role"] == "assistant":
+                            break
+                    for msg in reversed(latest_messages):
+                        manager.add_message(msg, tag=tag)
 
-                    if msg["role"] == "assistant":
-                        break
+            if done_tokens > self.context_compaction_max_tokens or done_tokens > cur_tokens:
+                await summarize_and_update(done_messages, MessageTag.DONE)
 
-                for msg in reversed(latest_messages):
-                    ConversationService.get_manager(self).add_message(
-                        message_dict={
-                            "role": msg["role"],
-                            "content": msg["content"],
-                        },
-                        tag=MessageTag.CUR,
-                    )
+            if cur_tokens > self.context_compaction_max_tokens or cur_tokens > done_tokens:
+                await summarize_and_update(cur_messages, MessageTag.CUR)
 
             self.io.tool_output("...chat history compacted.")
             self.io.update_spinner(self.io.last_spinner_text)
 
-            # Clear all diff and file context messages
-            ConversationService.get_manager(self).clear_tag(MessageTag.DIFFS)
-            ConversationService.get_manager(self).clear_tag(MessageTag.FILE_CONTEXTS)
-
-            # Reset ConversationFiles cache entirely
+            manager.clear_tag(MessageTag.DIFFS)
+            manager.clear_tag(MessageTag.FILE_CONTEXTS)
             ConversationService.get_files(self).clear_file_cache()
+
         except Exception as e:
             self.io.tool_warning(f"Context compaction failed: {e}")
             self.io.tool_warning("Proceeding with full history for now.")
@@ -2233,10 +2206,11 @@ class Coder:
 
         self.multi_response_content = ""
         if self.show_pretty():
-            spinner_text = (
-                f"Waiting for {self.get_active_model().name} •"
-                f" ${self.format_cost(self.total_cost)} session"
-            )
+            spinner_text = f"Waiting for {self.get_active_model().name}"
+
+            if not self.tui:
+                spinner_text += f" • ${self.format_cost(self.total_cost)} session"
+
             self.io.start_spinner(spinner_text)
             if self.stream:
                 self.mdstream = True
@@ -3541,13 +3515,18 @@ class Coder:
 
         self.message_tokens_received += completion_tokens
 
-        tokens_report = f"Tokens: {format_tokens(self.message_tokens_sent)} sent"
+        # Build the new streamlined format
+        tokens_parts = [format_tokens(prompt_tokens)]
 
-        if cache_write_tokens:
-            tokens_report += f", {format_tokens(cache_write_tokens)} cache write"
         if cache_hit_tokens:
-            tokens_report += f", {format_tokens(cache_hit_tokens)} cache hit"
-        tokens_report += f", {format_tokens(self.message_tokens_received)} received."
+            tokens_parts.append(f"{format_tokens(cache_hit_tokens)}")
+        if cache_write_tokens:
+            tokens_parts.append(f"{format_tokens(cache_write_tokens)}")
+
+        tokens_str = "/".join(tokens_parts)
+
+        tokens_report = f"{tokens_str} ↑ {format_tokens(completion_tokens)} ↓"
+
         tokens_report = self.token_profiler.add_to_usage_report(
             tokens_report, self.message_tokens_sent, self.message_tokens_received
         )
@@ -3570,9 +3549,12 @@ class Coder:
         self.total_cost += cost
         self.message_cost += cost
 
+        total_combined_tokens = (
+            self.total_tokens_sent + self.total_tokens_received + prompt_tokens + completion_tokens
+        )
         cost_report = (
-            f"Cost: ${self.format_cost(self.message_cost)} message,"
-            f" ${self.format_cost(self.total_cost)} session."
+            f"${self.format_cost(self.message_cost)} • {format_tokens(total_combined_tokens)} ↑↓"
+            f" ${self.format_cost(self.total_cost)}"
         )
 
         if cache_hit_tokens and cache_write_tokens:
@@ -3630,8 +3612,11 @@ class Coder:
         self.total_tokens_sent += self.message_tokens_sent
         self.total_tokens_received += self.message_tokens_received
 
-        self.io.tool_output(self.usage_report)
-        self.io.rule()
+        if self.tui and self.tui():
+            self.tui().update_cost(self.usage_report.replace("\n", " "))
+        else:
+            self.io.tool_output(self.usage_report)
+            self.io.rule()
 
         self.message_cost = 0.0
         self.message_tokens_sent = 0

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/commands/clear.py

@@ -19,6 +19,7 @@ class ClearCommand(BaseCommand):
         ConversationService.get_manager(coder).clear_tag(MessageTag.FILE_CONTEXTS)
 
         ConversationService.get_files(coder).reset()
+        coder.observation_manager.reset()
 
         # Clear TUI output if available
         if coder.tui and coder.tui():

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/commands/reset.py

@@ -22,6 +22,7 @@ class ResetCommand(BaseCommand):
             # Re-initialize Conversation components with current coder
             ConversationService.get_manager(coder).initialize(reformat=True)
             ConversationService.get_files(coder)  # Ensure instance exists/initialized
+            coder.observation_manager.reset()
 
             # Clear TUI output if available
             if coder.tui and coder.tui():

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/helpers/conversation/integration.py

@@ -85,7 +85,12 @@ class ConversationChunks:
                 )
 
         # Add system reminder as a pre-prompt context block
-        if hasattr(coder.gpt_prompts, "system_reminder") and coder.gpt_prompts.system_reminder:
+        use_reminders = getattr(coder.args, "use_reminders", True)
+        if (
+            use_reminders
+            and hasattr(coder.gpt_prompts, "system_reminder")
+            and coder.gpt_prompts.system_reminder
+        ):
             msg = dict(
                 role="user",
                 content=coder.fmt_system_prompt(coder.gpt_prompts.system_reminder),
@@ -235,7 +240,8 @@ class ConversationChunks:
             for f in editable_rel_files:
                 reminder_lines.append(f"  - {f}")
 
-        if len(reminder_lines) > 1:  # Only add reminder if there are files
+        use_reminders = getattr(coder.args, "use_reminders", True)
+        if use_reminders and len(reminder_lines) > 1:  # Only add reminder if there are files
             reminder_lines.append("</context>\n")
             reminder_content = "\n".join(reminder_lines)
             ConversationService.get_manager(coder).add_message(

cecli_dev-0.99.3/cecli/helpers/observations/manager.py

@@ -0,0 +1,98 @@
+import asyncio
+from datetime import datetime
+
+from cecli.helpers.conversation.service import ConversationService
+from cecli.helpers.conversation.tags import MessageTag
+
+
+class ObservationManager:
+    _instances = {}
+
+    @classmethod
+    def get_instance(cls, coder):
+        if coder.uuid not in cls._instances:
+            cls._instances[coder.uuid] = cls(coder)
+        return cls._instances[coder.uuid]
+
+    def __init__(self, coder):
+        self.coder = coder
+        self.observation_threshold = max((coder.context_compaction_max_tokens or 0) / 3, 20000)
+        self.reflection_threshold = self.observation_threshold * 2
+        self.is_processing = False
+        self._last_observed_index = 0
+        self.observations = []  # Internal storage
+
+    async def check_and_trigger(self):
+        if self.is_processing:
+            return
+
+        manager = ConversationService.get_manager(self.coder)
+        cur_messages = manager.get_messages_dict(MessageTag.CUR)
+
+        # Calculate unobserved tokens
+        unobserved = cur_messages[self._last_observed_index :]
+        if not unobserved:
+            return
+
+        tokens = self.coder.summarizer.count_tokens(unobserved)
+
+        if tokens >= self.observation_threshold:
+            asyncio.create_task(self.run_observation(unobserved))
+            self._last_observed_index = len(cur_messages)
+
+        obs_tokens = self.coder.summarizer.count_tokens(
+            [{"role": "user", "content": o} for o in self.observations]
+        )
+
+        if obs_tokens >= self.reflection_threshold:
+            asyncio.create_task(self.run_reflection())
+
+    async def run_observation(self, messages):
+        self.is_processing = True
+        try:
+            manager = ConversationService.get_manager(self.coder)
+            all_messages = manager.get_messages_dict()
+            prompt = self.coder.gpt_prompts.observation_prompt
+            observation = await self.coder.summarizer.summarize_all_as_text(
+                all_messages, prompt, max_tokens=8192
+            )
+            self.observations.append(self.format_observation(observation))
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            self.coder.io.tool_error(f"Error during observation: {e}")
+        finally:
+            self.is_processing = False
+
+    async def run_reflection(self):
+        self.is_processing = True
+        try:
+            # Prepare observations for the reflector
+            obs_text = "\n".join([f"- {o}" for o in self.observations])
+
+            # Use the Reflector to condense and get next steps
+            reflection_prompt = self.coder.gpt_prompts.reflection_prompt
+            reflection = await self.coder.summarizer.summarize_all_as_text(
+                [{"role": "user", "content": obs_text}],
+                reflection_prompt,
+                max_tokens=8192,
+            )
+
+            # 1. Internal State Update: Store the condensed log internally
+            self.observations = [reflection]
+
+            self._last_observed_index = 0
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            self.coder.io.tool_error(f"Error during reflection: {e}")
+        finally:
+            self.is_processing = False
+
+    def reset(self):
+        self.observations = []
+        self._last_observed_index = 0
+
+    def format_observation(self, text):
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+        return f"[{timestamp}] {text}"

{cecli_dev-0.99.2 → cecli_dev-0.99.3}/cecli/prompts/agent.yml

@@ -17,16 +17,16 @@ files_no_full_files_with_repo_map: |
 main_system: |
   <context name="role_and_directives">
   ## Core Directives
-  **Act Proactively**: Autonomously use discovery and management tools (`ViewFilesAtGlob`, `ViewFilesMatching`, `Ls`, `ContextManager`) to fulfill the request. Chain tool calls across multiple turns for continuous exploration.
+  **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**: Batch tool calls when tools allow you to. Respect usage limits while maximizing the utility of each turn.
+  **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 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>
 
   <context name="file_format">
   ### 1. FILE FORMAT
-  Files are provided in "hashline" format. Each line starts with a case-sensitive content hash followed by `::`.
-  Do not attempt to write these content hashes. They are automatically generated, maintained, and subject to change.
+  Files are provided in "hashline" format. Each line starts with a case-sensitive content hash followed by `::`. These are used as identifiers for editing tools.
+  Do not attempt to search for these content hashes. They are automatically generated, maintained, and subject to change.
   
   **Example File Format :**
   il9n::#!/usr/bin/env python3
@@ -39,8 +39,8 @@ main_system: |
   <context name="workflow_and_tool_usage">
   ## Core Workflow
   1. **Plan**: Start by using `UpdateTodoList` to outline the task.
-  2. **Explore**: Use `Grep` for broad searches. If results exceed 50 matches, refine your pattern immediately. Use discovery tools to add files as context.
-  3. **Execute**: Use the appropriate editing tool. Mark files as editable with `ContextManager` when needed. Proactively use skills if they are available.
+  2. **Explore**: Use discovery tools (`ExploreSymbols`, `Grep`, `Ls`) to research and gather understanding for you task. Use `ContextManager` to add files contents as context.
+  3. **Execute**: Use the appropriate editing tool. Mark files as editable with `ContextManager` before attempting edits. Proactively use skills if they are available.
   4. **Verify & Recover**: Review the diff output of every edit. If an edit fails or introduces linting errors, use `UndoChange` immediately.
   5. **Finished**: Use the `Finished` tool only after verifying the solution. Briefly summarize the changes for the user.
 
@@ -65,7 +65,7 @@ system_reminder: |
   <context name="critical_reminders">
   ## Reminders
   **Strict Scope**: Stay on task. Do not alter functionality and syntax that is out of scope or pursue unrequested refactors. Do not attempt to modify large files in one shot. Work step by step.
-  **Context Hygiene**: Remove files and loaded skills from context using `ContextManager` or `RemoveSkill` once they are no longer needed to save tokens and prevent confusion.
+  **Context Hygiene**: Remove files and loaded skills from context using `ContextManager` and/or `RemoveSkill` once they are no longer needed to save tokens and prevent confusion.
   **Turn Management**: Tool calls trigger the next turn. Do not include tool calls in your final summary to the user. You must use `ShowContext` to view the relevant hashline range before each edit.
   **Sandbox**: Use `.cecli/temp` for all verification and temporary logic.
   **Novelty**: Do not repeat phrases in your responses to the user. You do not need to declare you understand the task. Simply proceed. Only give status updates when you have new information.