cecli-dev 0.96.3__tar.gz → 0.96.5__tar.gz

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.96.3
+Version: 0.96.5
 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.96.3 → cecli_dev-0.96.5}/cecli/__init__.py

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

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.96.3'
-__version_tuple__ = version_tuple = (0, 96, 3)
+__version__ = version = '0.96.5'
+__version_tuple__ = version_tuple = (0, 96, 5)
 
-__commit_id__ = commit_id = 'gc5417d2f9'
+__commit_id__ = commit_id = 'g495cbfd20'

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/coders/agent_coder.py

@@ -724,6 +724,7 @@ class AgentCoder(Coder):
         ) = await self._process_tool_commands(content)
         if self.agent_finished:
             self.tool_usage_history = []
+            self.reflected_message = None
             if self.files_edited_by_tools:
                 _ = await self.auto_commit(self.files_edited_by_tools)
             return False

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/coders/architect_coder.py

@@ -42,68 +42,54 @@ class ArchitectCoder(AskCoder):
         kwargs["cache_prompts"] = False
         kwargs["num_cache_warming_pings"] = 0
         kwargs["summarize_from_coder"] = False
+        kwargs["done_messages"] = []
+        kwargs["cur_messages"] = []
 
         new_kwargs = dict(io=self.io, from_coder=self)
         new_kwargs.update(kwargs)
 
         # Save current conversation state
-        original_all_messages = ConversationManager.get_messages()
         original_coder = self
 
         editor_coder = await Coder.create(**new_kwargs)
 
         # Re-initialize ConversationManager with editor coder
-        ConversationManager.initialize(editor_coder, reset=True, reformat=True)
+        ConversationManager.initialize(
+            editor_coder, reset=True, reformat=True, preserve_tags=[MessageTag.DONE, MessageTag.CUR]
+        )
 
         if self.verbose:
             editor_coder.show_announcements()
 
+        postamble = """
+        The above changes are proposed changes.
+        You must repeat SEARCH/REPLACE blocks in order to apply edits.
+        Shell commands must also be duplicated in order to run them.
+        """
+
+        content = f"Please implement all requested changes from:\n{content}\n{postamble}"
+
         try:
             await editor_coder.generate(user_message=content, preproc=False)
 
-            # Save editor's ALL messages
-            editor_all_messages = ConversationManager.get_messages()
-
             # Clear manager and restore original state
-            ConversationManager.initialize(original_coder or self, reset=True, reformat=True)
-
-            # Restore original messages with all metadata
-            for msg in original_all_messages:
-                if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                    ConversationManager.add_message(
-                        message_dict=msg.message_dict,
-                        tag=MessageTag(msg.tag),
-                        priority=msg.priority,
-                        mark_for_delete=msg.mark_for_delete,
-                        force=True,
-                    )
-
-            # Append editor's DONE and CUR messages (but not other tags like SYSTEM)
-            for msg in editor_all_messages:
-                if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                    ConversationManager.add_message(
-                        message_dict=msg.message_dict,
-                        tag=MessageTag(msg.tag),
-                        priority=msg.priority,
-                        mark_for_delete=msg.mark_for_delete,
-                        force=True,
-                    )
+            ConversationManager.initialize(
+                original_coder or self,
+                reset=True,
+                reformat=True,
+                preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+            )
 
             self.total_cost = editor_coder.total_cost
             self.coder_commit_hashes = editor_coder.coder_commit_hashes
         except Exception as e:
             self.io.tool_error(e)
             # Restore original state on error
-            ConversationManager.initialize(original_coder or self, reset=True, reformat=True)
-
-            for msg in original_all_messages:
-                if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                    ConversationManager.add_message(
-                        message_dict=msg.message_dict,
-                        tag=MessageTag(msg.tag),
-                        priority=msg.priority,
-                        mark_for_delete=msg.mark_for_delete,
-                        force=True,
-                    )
+            ConversationManager.initialize(
+                original_coder or self,
+                reset=True,
+                reformat=True,
+                preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+            )
 
         raise SwitchCoderSignal(main_model=self.main_model, edit_format="architect")

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/coders/base_coder.py

@@ -1584,6 +1584,7 @@ class Coder:
                 pass
 
             if not self.reflected_message:
+                await self.auto_save_session(force=True)
                 break
 
             if self.num_reflections >= self.max_reflections:
@@ -1603,6 +1604,8 @@ class Coder:
             if self.enable_context_compaction:
                 await self.compact_context_if_needed()
 
+            await self.auto_save_session(force=True)
+
     async def check_and_open_urls(self, exc, friendly_msg=None):
         """Check exception for URLs, offer to open in a browser, with user-friendly error msgs."""
         text = str(exc)
@@ -2096,7 +2099,7 @@ class Coder:
             ConversationManager.add_message(
                 message_dict=dict(role="user", content=inp),
                 tag=MessageTag.CUR,
-                hash_key=("user_message", inp, str(time.time_ns())),
+                hash_key=("user_message", inp, str(time.monotonic_ns())),
             )
 
         loop = asyncio.get_running_loop()
@@ -3776,7 +3779,7 @@ class Coder:
     def apply_edits_dry_run(self, edits):
         return edits
 
-    async def auto_save_session(self):
+    async def auto_save_session(self, force=False):
         """Automatically save the current session to {auto-save-session-name}.json."""
         if not getattr(self.args, "auto_save", False):
             return
@@ -3789,11 +3792,17 @@ class Coder:
             self._autosave_future = None
 
         if self._autosave_future and not self._autosave_future.done():
-            return
+            if force:
+                try:
+                    await self._autosave_future
+                except Exception:
+                    pass
+            else:
+                return
 
         # Throttle autosave to run at most once every 15 seconds
         current_time = time.time()
-        if current_time - self._last_autosave_time >= 15.0:
+        if current_time - self._last_autosave_time >= 15.0 or force:
             try:
                 self._last_autosave_time = current_time
                 session_manager = SessionManager(self, self.io)

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/commands/editor_model.py

@@ -52,18 +52,24 @@ class EditorModelCommand(BaseCommand):
             kwargs["total_cost"] = coder.total_cost
             kwargs["num_cache_warming_pings"] = 0
             kwargs["summarize_from_coder"] = False
+            kwargs["done_messages"] = []
+            kwargs["cur_messages"] = []
 
             new_kwargs = dict(io=io, from_coder=coder)
             new_kwargs.update(kwargs)
 
             # Save current conversation state
-            original_all_messages = ConversationManager.get_messages()
             original_coder = coder
 
             temp_coder = await Coder.create(**new_kwargs)
 
             # Re-initialize ConversationManager with temp coder
-            ConversationManager.initialize(temp_coder, reset=True, reformat=True)
+            ConversationManager.initialize(
+                temp_coder,
+                reset=True,
+                reformat=True,
+                preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+            )
 
             verbose = kwargs.get("verbose", False)
             if verbose:
@@ -74,33 +80,13 @@ class EditorModelCommand(BaseCommand):
                 coder.total_cost = temp_coder.total_cost
                 coder.coder_commit_hashes = temp_coder.coder_commit_hashes
 
-                # Save temp coder's ALL messages
-                temp_all_messages = ConversationManager.get_messages()
-
                 # Clear manager and restore original state
-                ConversationManager.initialize(original_coder, reset=True, reformat=True)
-
-                # Restore original messages with all metadata
-                for msg in original_all_messages:
-                    if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                        ConversationManager.add_message(
-                            message_dict=msg.message_dict,
-                            tag=MessageTag(msg.tag),
-                            priority=msg.priority,
-                            mark_for_delete=msg.mark_for_delete,
-                            force=True,
-                        )
-
-                # Append temp coder's DONE and CUR messages (but not other tags like SYSTEM)
-                for msg in temp_all_messages:
-                    if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                        ConversationManager.add_message(
-                            message_dict=msg.message_dict,
-                            tag=MessageTag(msg.tag),
-                            priority=msg.priority,
-                            mark_for_delete=msg.mark_for_delete,
-                            force=True,
-                        )
+                ConversationManager.initialize(
+                    original_coder,
+                    reset=True,
+                    reformat=True,
+                    preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+                )
 
                 # Restore the original model configuration
                 from cecli.commands import SwitchCoderSignal

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/commands/model.py

@@ -57,18 +57,24 @@ class ModelCommand(BaseCommand):
             kwargs["total_cost"] = coder.total_cost
             kwargs["num_cache_warming_pings"] = 0
             kwargs["summarize_from_coder"] = False
+            kwargs["done_messages"] = []
+            kwargs["cur_messages"] = []
 
             new_kwargs = dict(io=io, from_coder=coder)
             new_kwargs.update(kwargs)
 
             # Save current conversation state
-            original_all_messages = ConversationManager.get_messages()
             original_coder = coder
 
             temp_coder = await Coder.create(**new_kwargs)
 
             # Re-initialize ConversationManager with temp coder
-            ConversationManager.initialize(temp_coder, reset=True, reformat=True)
+            ConversationManager.initialize(
+                temp_coder,
+                reset=True,
+                reformat=True,
+                preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+            )
 
             verbose = kwargs.get("verbose", False)
             if verbose:
@@ -79,33 +85,13 @@ class ModelCommand(BaseCommand):
                 coder.total_cost = temp_coder.total_cost
                 coder.coder_commit_hashes = temp_coder.coder_commit_hashes
 
-                # Save temp coder's ALL messages
-                temp_all_messages = ConversationManager.get_messages()
-
                 # Clear manager and restore original state
-                ConversationManager.initialize(original_coder, reset=True, reformat=True)
-
-                # Restore original messages with all metadata
-                for msg in original_all_messages:
-                    if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                        ConversationManager.add_message(
-                            message_dict=msg.message_dict,
-                            tag=MessageTag(msg.tag),
-                            priority=msg.priority,
-                            mark_for_delete=msg.mark_for_delete,
-                            force=True,
-                        )
-
-                # Append temp coder's DONE and CUR messages (but not other tags like SYSTEM)
-                for msg in temp_all_messages:
-                    if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                        ConversationManager.add_message(
-                            message_dict=msg.message_dict,
-                            tag=MessageTag(msg.tag),
-                            priority=msg.priority,
-                            mark_for_delete=msg.mark_for_delete,
-                            force=True,
-                        )
+                ConversationManager.initialize(
+                    original_coder,
+                    reset=True,
+                    reformat=True,
+                    preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+                )
 
                 # Restore the original model configuration
                 from cecli.commands import SwitchCoderSignal

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/commands/utils/base_command.py

@@ -142,47 +142,30 @@ class BaseCommand(ABC, metaclass=CommandMeta):
             "num_cache_warming_pings": 0,
             "coder_commit_hashes": coder.coder_commit_hashes,
             "args": coder.args,
+            "done_messages": [],
+            "cur_messages": [],
         }
 
         # Save current conversation state
-        original_all_messages = ConversationManager.get_messages()
         original_coder = coder
 
         new_coder = await Coder.create(**kwargs)
 
         # Re-initialize ConversationManager with new coder
-        ConversationManager.initialize(new_coder, reset=True, reformat=True)
+        ConversationManager.initialize(
+            new_coder, reset=True, reformat=True, preserve_tags=[MessageTag.DONE, MessageTag.CUR]
+        )
 
         await new_coder.generate(user_message=user_msg, preproc=False)
         coder.coder_commit_hashes = new_coder.coder_commit_hashes
 
-        # Save new coder's ALL messages
-        new_all_messages = ConversationManager.get_messages()
-
         # Clear manager and restore original state
-        ConversationManager.initialize(original_coder, reset=True, reformat=True)
-
-        # Restore original messages with all metadata
-        for msg in original_all_messages:
-            if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                ConversationManager.add_message(
-                    message_dict=msg.message_dict,
-                    tag=MessageTag(msg.tag),
-                    priority=msg.priority,
-                    mark_for_delete=msg.mark_for_delete,
-                    force=True,
-                )
-
-        # Append new coder's DONE and CUR messages (but not other tags like SYSTEM)
-        for msg in new_all_messages:
-            if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                ConversationManager.add_message(
-                    message_dict=msg.message_dict,
-                    tag=MessageTag(msg.tag),
-                    priority=msg.priority,
-                    mark_for_delete=msg.mark_for_delete,
-                    force=True,
-                )
+        ConversationManager.initialize(
+            original_coder,
+            reset=True,
+            reformat=True,
+            preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+        )
 
         from cecli.commands import SwitchCoderSignal
 

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/commands/weak_model.py

@@ -52,18 +52,24 @@ class WeakModelCommand(BaseCommand):
             kwargs["total_cost"] = coder.total_cost
             kwargs["num_cache_warming_pings"] = 0
             kwargs["summarize_from_coder"] = False
+            kwargs["done_messages"] = []
+            kwargs["cur_messages"] = []
 
             new_kwargs = dict(io=io, from_coder=coder)
             new_kwargs.update(kwargs)
 
             # Save current conversation state
-            original_all_messages = ConversationManager.get_messages()
             original_coder = coder
 
             temp_coder = await Coder.create(**new_kwargs)
 
             # Re-initialize ConversationManager with temp coder
-            ConversationManager.initialize(temp_coder, reset=True, reformat=True)
+            ConversationManager.initialize(
+                temp_coder,
+                reset=True,
+                reformat=True,
+                preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+            )
 
             verbose = kwargs.get("verbose", False)
             if verbose:
@@ -74,33 +80,13 @@ class WeakModelCommand(BaseCommand):
                 coder.total_cost = temp_coder.total_cost
                 coder.coder_commit_hashes = temp_coder.coder_commit_hashes
 
-                # Save temp coder's ALL messages
-                temp_all_messages = ConversationManager.get_messages()
-
                 # Clear manager and restore original state
-                ConversationManager.initialize(original_coder, reset=True, reformat=True)
-
-                # Restore original messages with all metadata
-                for msg in original_all_messages:
-                    if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                        ConversationManager.add_message(
-                            message_dict=msg.message_dict,
-                            tag=MessageTag(msg.tag),
-                            priority=msg.priority,
-                            mark_for_delete=msg.mark_for_delete,
-                            force=True,
-                        )
-
-                # Append temp coder's DONE and CUR messages (but not other tags like SYSTEM)
-                for msg in temp_all_messages:
-                    if msg.tag in [MessageTag.DONE.value, MessageTag.CUR.value]:
-                        ConversationManager.add_message(
-                            message_dict=msg.message_dict,
-                            tag=MessageTag(msg.tag),
-                            priority=msg.priority,
-                            mark_for_delete=msg.mark_for_delete,
-                            force=True,
-                        )
+                ConversationManager.initialize(
+                    original_coder,
+                    reset=True,
+                    reformat=True,
+                    preserve_tags=[MessageTag.DONE, MessageTag.CUR],
+                )
 
                 # Restore the original model configuration
                 from cecli.commands import SwitchCoderSignal

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/helpers/conversation/base_message.py

@@ -26,7 +26,7 @@ class BaseMessage:
     message_dict: Dict[str, Any]
     tag: str
     priority: int = field(default=0)
-    timestamp: int = field(default_factory=lambda: time.time_ns())
+    timestamp: int = field(default_factory=lambda: time.monotonic_ns())
     mark_for_delete: Optional[int] = field(default=None)
     hash_key: Optional[Tuple[str, ...]] = field(default=None)
     message_id: str = field(init=False)
@@ -136,6 +136,6 @@ class BaseMessage:
         content_preview = str(self.message_dict.get("content", ""))[:50]
         return (
             f"BaseMessage(id={self.message_id[:8]}..., "
-            f"tag={self.tag}, priority={self.priority}, "
-            f"role={role}, content='{content_preview}...')"
+            f"tag={self.tag}, priority={self.priority}, timestamp={self.timestamp}, "
+            f"role={role}, content='{content_preview}...', )"
         )

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/helpers/conversation/manager.py

@@ -33,7 +33,13 @@ class ConversationManager:
     _ALL_MESSAGES_CACHE_KEY = "__all__"  # Special key for caching all messages (tag=None)
 
     @classmethod
-    def initialize(cls, coder, reset: bool = False, reformat: bool = False) -> None:
+    def initialize(
+        cls,
+        coder,
+        reset: bool = False,
+        reformat: bool = False,
+        preserve_tags: Optional[List[str]] = None,
+    ) -> None:
         """
         Set up singleton with weak reference to coder.
 
@@ -42,17 +48,49 @@ class ConversationManager:
             reset: Whether to re-initialize the conversation history itself
             reformat: Whether to format chat history
                       (useful for initialization outside of coder class)
+            preserve_tags: Optional list of tag strings to preserve during reset.
+                          If provided, messages with these tags will be preserved
+                          when reset=True and re-added AFTER the reformat block.
         """
         cls._coder_ref = weakref.ref(coder)
         cls._initialized = True
 
-        if reset:
+        preserved_messages = []
+        if reset and preserve_tags:
+            # New approach: loop over every single tag type and only clear tags NOT in preserve_tags
+            # Get all MessageTag values
+            all_tag_types = list(MessageTag)
+
+            # Clear tags that are NOT in preserve_tags
+            for tag_type in all_tag_types:
+                if tag_type.value not in preserve_tags:
+                    cls.clear_tag(tag_type)
+
+            # Get all remaining messages left over after preservation
+            preserved_messages = cls.get_messages()
+        elif reset:
+            # Original behavior: clear everything
             cls.reset()
 
         if reformat:
             if hasattr(coder, "format_chat_chunks"):
                 coder.format_chat_chunks()
 
+        # If preserve_tags is truthy, re-add preserved messages with updated timestamps after reformat block
+        if preserve_tags and preserved_messages:
+            for tag_type in preserve_tags:
+                cls.clear_tag(tag_type)
+
+            for msg in preserved_messages:
+                cls.add_message(
+                    message_dict=msg.message_dict,
+                    tag=MessageTag(msg.tag),
+                    priority=msg.priority,
+                    timestamp=time.monotonic_ns(),  # Updated timestamp
+                    mark_for_delete=msg.mark_for_delete,
+                    force=True,
+                )
+
         # Enable debug mode if coder has verbose attribute and it's True
         if hasattr(coder, "verbose") and coder.verbose:
             cls._debug_enabled = True
@@ -110,7 +148,7 @@ class ConversationManager:
             priority = get_default_priority(tag)
 
         if timestamp is None:
-            timestamp = time.time_ns() + get_default_timestamp_offset(tag)
+            timestamp = time.monotonic_ns() + get_default_timestamp_offset(tag)
 
         # Create message instance
         message = BaseMessage(
@@ -152,7 +190,7 @@ class ConversationManager:
     @classmethod
     def get_messages(cls) -> List[BaseMessage]:
         """
-        Returns messages sorted by priority (lowest first), then timestamp (earliest first).
+        Returns messages sorted by priority (lowest first), then raw order in list.
 
         Returns:
             List of BaseMessage instances in sorted order

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/io.py

@@ -213,22 +213,48 @@ class AutoCompleter(Completer):
 
     def get_command_completions(self, document, complete_event, text, words):
         if len(words) == 1 and not text[-1].isspace():
+            # Handle command completion (e.g., typing "/ad" should complete to "/add")
             partial = words[0].lower()
-            candidates = [cmd for cmd in self.command_names if cmd.startswith(partial)]
+            # Strip leading '/' if present for comparison with command names
+            if partial.startswith("/"):
+                partial = partial[1:]
+            # Compare with command names without leading '/'
+            candidates = [cmd for cmd in self.command_names if cmd[1:].startswith(partial)]
             for candidate in sorted(candidates):
+                # Add back the leading '/' for the completion
                 yield Completion(candidate, start_position=-len(words[-1]))
             return
 
-        if len(words) <= 1 or text[-1].isspace():
-            return
+        # Handle command followed by space: trigger auto-completion with empty partial
+        if text[-1].isspace():
+            # We have a command followed by space, trigger auto-completion with empty string
+            if len(words) == 1:
+                # Command with no arguments yet, just a trailing space
+                partial = ""
+                # We need to get the command name without the trailing space
+                # The command is words[0] but might have leading '/'
+                cmd_text = words[0]
+            else:
+                # Command with arguments and trailing space
+                partial = ""
+                cmd_text = text.rstrip()  # Remove trailing space for matching
+        else:
+            # No trailing space
+            if len(words) <= 1:
+                return
+            partial = words[-1].lower()
+            cmd_text = text
 
-        cmd = words[0]
-        partial = words[-1].lower()
+        # Pass the text (without trailing space if present) to matching_commands
+        matches, matched_cmd, _ = self.commands.matching_commands(cmd_text.rstrip())
+        if not matches:
+            return
 
-        matches, _, _ = self.commands.matching_commands(cmd)
         if len(matches) == 1:
             cmd = matches[0]
-        elif cmd not in matches:
+        elif matched_cmd in matches:
+            cmd = matched_cmd
+        else:
             return
 
         raw_completer = self.commands.get_raw_completions(cmd)
@@ -240,8 +266,15 @@ class AutoCompleter(Completer):
 
         if candidates is None:
             return
+
+        candidates = [word for word in candidates if partial in word.lower()]
+
         for candidate in sorted(candidates):
-            yield Completion(candidate, start_position=-len(words[-1]))
+            # Calculate start position based on partial, not words[-1]
+            # When partial is empty (trailing space), start_position should be 0
+            # When partial is not empty, replace that many characters
+            start_position = -len(partial) if partial else 0
+            yield Completion(candidate, start_position=start_position)
 
     def get_completions(self, document, complete_event):
         self.tokenize()
@@ -251,8 +284,9 @@ class AutoCompleter(Completer):
         if not words:
             return
 
-        if text and text[-1].isspace():
-            # don't keep completing after a space
+        if text and text[-1].isspace() and not text.startswith("/"):
+            # don't keep completing after a space for non-commands
+            # For commands, we want to allow completion with empty string partial
             return
 
         if text[0] == "/":

{cecli_dev-0.96.3 → cecli_dev-0.96.5}/cecli/main.py

@@ -1202,6 +1202,7 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
             return await graceful_exit(coder)
         except SwitchCoderSignal as switch:
             coder.ok_to_warm_cache = False
+            await coder.auto_save_session(force=True)
 
             if hasattr(switch, "placeholder") and switch.placeholder is not None:
                 io.placeholder = switch.placeholder
@@ -1229,6 +1230,7 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
 
         except SystemExit:
             sys.settrace(None)
+            await coder.auto_save_session(force=True)
             return await graceful_exit(coder)