V0.99.12

cecli/__init__.py

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

cecli/coders/agent_coder.py

@@ -282,9 +282,7 @@ async def _exec_async():
                             content_parts.append(item.text)
                 return "".join(content_parts)
             except Exception as e:
-                self.io.tool_warning(
-                    (f"Executing {tool_name} on {server.name} failed:\nError: {e}")
-                )
+                self.io.tool_warning(f"Executing {tool_name} on {server.name} failed:\nError: {e}")
                 return f"Error executing tool call {tool_name}: {e}"
 
         result, interrupted = await interruptible(_exec_async(), self.interrupt_event)
@@ -381,7 +379,10 @@ def get_context_symbol_outline(self):
         try:
             result = '<context name="symbol_outline" from="agent">\n'
             result += "## Symbol Outline (Current Context)\n\n"
-            result += "Code definitions (classes, functions, methods, etc.) found in files currently in chat context."
+            result += (
+                "Code definitions (classes, functions, methods, etc.) found in files currently in"
+                " chat context."
+            )
             result += "\n\n"
             files_to_outline = list(self.abs_fnames) + list(self.abs_read_only_fnames)
             if not files_to_outline:
@@ -522,7 +523,10 @@ def get_context_summary(self):
                         )
                 if editable_files:
                     result += "\n".join(editable_files) + "\n\n"
-                    result += f"**Total editable: {len(editable_files)} files, {editable_tokens:,} tokens**\n\n"
+                    result += (
+                        f"**Total editable: {len(editable_files)} files,"
+                        f" {editable_tokens:,} tokens**\n\n"
+                    )
                 else:
                     result += "No editable files in context\n\n"
             if self.abs_read_only_fnames:
@@ -542,7 +546,10 @@ def get_context_summary(self):
                         )
                 if readonly_files:
                     result += "\n".join(readonly_files) + "\n\n"
-                    result += f"**Total read-only: {len(readonly_files)} files, {readonly_tokens:,} tokens**\n\n"
+                    result += (
+                        f"**Total read-only: {len(readonly_files)} files,"
+                        f" {readonly_tokens:,} tokens**\n\n"
+                    )
                 else:
                     result += "No read-only files in context\n\n"
             extra_tokens = sum(self.context_block_tokens.values())
@@ -730,7 +737,7 @@ async def gather_and_await():
                 self.model_kwargs = {}
                 result_message = f"Error executing {tool_name}: {e}"
                 self.io.tool_error(
-                    (f"Error during {tool_name} execution: {e}\n{traceback.format_exc()}")
+                    f"Error during {tool_name} execution: {e}\n{traceback.format_exc()}"
                 )
             tool_responses.append(
                 {"role": "tool", "tool_call_id": tool_call.id, "content": result_message}
@@ -1020,8 +1027,8 @@ def _generate_tool_context(self, repetitive_tools):
             context_parts.append("## File Editing Tools Disabled")
             context_parts.append(
                 "File editing tools are currently disabled. Use `ReadRange` to determine the"
-                " current content hash prefixes needed to perform an edit and activate them when you"
-                " are ready to edit a file."
+                " current content hash prefixes needed to perform an edit and activate them when"
+                " you are ready to edit a file."
             )
 
         context_parts.append("\n\n")

cecli/coders/base_coder.py

@@ -453,7 +453,6 @@ def __init__(
 
         # 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
@@ -1752,7 +1751,7 @@ async def compact_context_if_needed(self, force=False, message=""):
             return
 
         # Trigger background observation/reflection check
-        await self.observation_manager.check_and_trigger()
+        await ObservationManager.get_instance(self).check_and_trigger()
 
         manager = ConversationService.get_manager(self)
         done_messages = manager.get_messages_dict(MessageTag.DONE)
@@ -1789,8 +1788,8 @@ async def summarize_and_update(messages, tag):
                 if not text:
                     raise ValueError(f"Summarization of {tag} messages returned empty.")
 
-                if self.observation_manager.observations:
-                    obs_text = "\n".join(self.observation_manager.observations)
+                if ObservationManager.get_instance(self).observations:
+                    obs_text = "\n".join(ObservationManager.get_instance(self).observations)
                     text = f"HISTORICAL OBSERVATIONS:\n{obs_text}\n\n{text}"
 
                 manager.clear_tag(tag)
@@ -2780,7 +2779,6 @@ async def process_tool_calls(self, tool_call_response):
 
     def _print_tool_call_info(self, server_tool_calls):
         """Print information about an MCP tool call."""
-        self.io.ring_bell()
         # self.io.tool_output("Preparing to run MCP tools", bold=False)
 
         for server, tool_calls in server_tool_calls.items():

cecli/commands/clear.py

@@ -2,6 +2,7 @@
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
+from cecli.helpers.observations.manager import ObservationManager
 
 
 class ClearCommand(BaseCommand):
@@ -19,7 +20,7 @@ async def execute(cls, io, coder, args, **kwargs):
         ConversationService.get_manager(coder).clear_tag(MessageTag.FILE_CONTEXTS)
 
         ConversationService.get_files(coder).reset()
-        coder.observation_manager.reset()
+        ObservationManager.get_instance(coder).reset()
 
         # Clear TUI output if available
         if coder.tui and coder.tui():

cecli/commands/reset.py

@@ -3,6 +3,7 @@
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
 from cecli.helpers.conversation import ConversationService
+from cecli.helpers.observations.manager import ObservationManager
 
 
 class ResetCommand(BaseCommand):
@@ -24,7 +25,7 @@ async def execute(cls, io, coder, args, **kwargs):
             # 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()
+            ObservationManager.get_instance(coder).reset()
 
             # Clear TUI output if available
             if coder.tui and coder.tui():

cecli/helpers/observations/manager.py

@@ -26,17 +26,21 @@ 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)
+        cur_messages = ConversationService.get_manager(self.coder).get_messages_dict(MessageTag.CUR)
 
         # Calculate unobserved tokens
         unobserved = cur_messages[self._last_observed_index :]
+        current_index = len(cur_messages)
+
         if not unobserved:
             return
 
         tokens = self.coder.summarizer.count_tokens(unobserved)
 
-        if tokens >= self.observation_threshold:
+        if (
+            tokens >= self.observation_threshold
+            and (not self._last_observed_index or current_index - self._last_observed_index >= 10)
+        ) or tokens >= 2 * self.observation_threshold:
             asyncio.create_task(self.run_observation(unobserved))
             self._last_observed_index = len(cur_messages)
 
@@ -50,8 +54,7 @@ async def check_and_trigger(self):
     async def run_observation(self, messages):
         self.is_processing = True
         try:
-            manager = ConversationService.get_manager(self.coder)
-            all_messages = manager.get_messages_dict()
+            all_messages = ConversationService.get_manager(self.coder).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

cecli/io.py

@@ -1718,13 +1718,13 @@ def get_default_notification_command(self):
                 "$toastXml = $template.GetXml(); "
                 "$toastXml.GetElementsByTagName('text')[0].AppendChild"
                 "($template.CreateTextNode('cecli')) > $null; "
-                f"$toastXml.GetElementsByTagName('text')[1].AppendChild"
+                "$toastXml.GetElementsByTagName('text')[1].AppendChild"
                 f"($template.CreateTextNode('{NOTIFICATION_MESSAGE}')) > $null; "
                 "$toast = [Windows.UI.Notifications.ToastNotification]::new($toastXml); "
                 "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('cecli')"
                 '.Show($toast)"'
             )
-            return "powershell -command" + ps_command
+            return "powershell -WindowStyle Hidden -Command" + ps_command
 
         return None  # Unknown system
 
@@ -1739,9 +1739,7 @@ def _send_notification(self):
                     "stderr": subprocess.DEVNULL,
                 }
                 if platform.system() == "Windows":
-                    kwargs["creationflags"] = (
-                        subprocess.CREATE_NO_WINDOW | subprocess.DETACHED_PROCESS
-                    )
+                    kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
                 else:
                     # For non-Windows systems, start a new session to detach
                     kwargs["start_new_session"] = True

cecli/main.py

@@ -1194,15 +1194,21 @@ def get_io(pretty):
     if args.exit:
         return await graceful_exit(coder)
     if args.auto_load:
-        try:
-            from cecli.sessions import SessionManager
+        if await pre_init_io.confirm_ask(
+            "Do you want to load your previous session?",
+            acknowledge=True,
+            explicit_yes_required=True,
+        ):
+            try:
+                from cecli.sessions import SessionManager
 
-            session_manager = SessionManager(coder, io)
-            await session_manager.load_session(
-                args.auto_save_session_name if args.auto_save_session_name else "auto-save"
-            )
-        except Exception:
-            pass
+                session_manager = SessionManager(coder, io)
+                await session_manager.load_session(
+                    args.auto_save_session_name if args.auto_save_session_name else "auto-save",
+                    switch=False,
+                )
+            except Exception:
+                pass
 
     if suppress_pre_init:
         await graceful_exit(coder)

cecli/models.py

@@ -1172,6 +1172,26 @@ async def send_completion(
             sorted_tools = sorted(
                 effective_tools, key=lambda x: x.get("function", {}).get("name", "Invalid Name")
             )
+
+            try:
+                # Deep copy to avoid modifying original tool schemas
+                sorted_tools = json.loads(json.dumps(sorted_tools))
+
+                for tool in sorted_tools:
+                    function_schema = tool.get("function")
+                    if function_schema and "description" in function_schema:
+                        desc = function_schema.get("description")
+                        if isinstance(desc, str):
+                            # Escape the description string for JSON, but without the outer quotes.
+                            # This is a workaround for issues with special characters in descriptions.
+                            function_schema["description"] = json.dumps(desc, ensure_ascii=False)[
+                                1:-1
+                            ]
+            except (TypeError, json.JSONDecodeError):
+                # If deep copy fails, proceed with original tools.
+                # This is a safeguard.
+                pass
+
             kwargs["tools"] = sorted_tools
 
         if functions and len(functions) == 1:

cecli/sessions.py

@@ -88,7 +88,7 @@ def list_sessions(self) -> List[Dict]:
 
         return sessions
 
-    async def load_session(self, session_identifier: str) -> bool:
+    async def load_session(self, session_identifier: str, switch=True) -> bool:
         """Load a saved session by name or file path."""
         if not session_identifier:
             self.io.tool_error("Please provide a session name or file path.")
@@ -113,7 +113,7 @@ async def load_session(self, session_identifier: str) -> bool:
 
         # Apply session data
         applied, loaded_edit_format = await self._apply_session_data(session_data, session_file)
-        if applied:
+        if applied and switch:
             from cecli.commands import SwitchCoderSignal
 
             edit_format_to_switch_to = self.coder.edit_format

cecli/tools/context_manager.py

@@ -32,8 +32,7 @@ class Tool(BaseTool):
                         "type": "array",
                         "items": {"type": "string"},
                         "description": (
-                            "List of file paths to add as read-only. "
-                            "Limit to at most 2 at a time."
+                            "List of file paths to add as read-only. Limit to at most 2 at a time."
                         ),
                     },
                     "create": {

cecli/tools/edit_text.py

@@ -37,7 +37,7 @@ class Tool(BaseTool):
                 "Can handle an array of up to 10 edits across multiple files. "
                 "Each edit must include its own file_path and operation type. "
                 "Use content hash ranges with the start_line and end_line parameters with format "
-                '"{4 char hash}" (without the braces). For empty files, use "@000" as the '
+                "`{4 char hash}` (without the braces). For empty files, use `@000` as the "
                 "content hash references."
             ),
             "parameters": {
@@ -71,14 +71,14 @@ class Tool(BaseTool):
                                 "start_line": {
                                     "type": "string",
                                     "description": (
-                                        'Content hash for start line: "{4 char hash}" (without '
+                                        "Content hash for start line: `{4 char hash}` (without "
                                         "the braces)"
                                     ),
                                 },
                                 "end_line": {
                                     "type": "string",
                                     "description": (
-                                        'Content hash for end line: "{4 char hash}" (without the'
+                                        "Content hash for end line: `{4 char hash}` (without the"
                                         " braces)"
                                     ),
                                 },

cecli/tools/load_skill.py

@@ -7,10 +7,7 @@ class Tool(BaseTool):
         "type": "function",
         "function": {
             "name": "LoadSkill",
-            "description": (
-                "Load a skill by name (agent mode only). Adds skill to include list and removes"
-                " from exclude list."
-            ),
+            "description": "Load a skill by name.",
             "parameters": {
                 "type": "object",
                 "properties": {