cecli-dev 1.5.1__tar.gz → 1.6.0__tar.gz

{cecli_dev-1.5.1 → cecli_dev-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.1
+Version: 1.6.0
 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-1.5.1 → cecli_dev-1.6.0}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.1'
-__version_tuple__ = version_tuple = (1, 5, 1)
+__version__ = version = '1.6.0'
+__version_tuple__ = version_tuple = (1, 6, 0)
 
-__commit_id__ = commit_id = 'g17d4bc7df'
+__commit_id__ = commit_id = 'gab974c9a6'

{cecli_dev-1.5.1 → cecli_dev-1.6.0}/cecli/coders/agent_coder.py

@@ -652,6 +652,10 @@ class AgentCoder(Coder):
         # Add post-message context blocks (priority 250 - between CUR and REMINDER)
         ConversationService.get_chunks(self).add_post_message_context_blocks()
 
+        # Background command output is debounced independently so it is not
+        # re-dumped every turn as its contents mutate slightly
+        ConversationService.get_chunks(self).add_background_command_output()
+
         # Add sub-agent states context block (same priority as post-message blocks)
         ConversationService.get_chunks(self).add_sub_agent_states()
 
@@ -935,7 +939,11 @@ class AgentCoder(Coder):
             lint_coro = self.lint_edited(edited, show_output=False)
             lint_errors, interrupted = await interruptible(lint_coro, self.interrupt_event)
             if interrupted:
-                raise KeyboardInterrupt("Interrupted during linting")
+                # Abort the turn with CancelledError, which the linear run loop
+                # handles by re-prompting for input. KeyboardInterrupt is a
+                # BaseException that would escape the worker's event loop and
+                # leave it unable to accept further prompts.
+                raise asyncio.CancelledError("Interrupted during linting")
 
             has_errors = False
 
@@ -1074,7 +1082,10 @@ class AgentCoder(Coder):
             sleep_coro = asyncio.sleep(command_timeout / 2)
             _res, interrupted = await interruptible(sleep_coro, self.interrupt_event)
             if interrupted:
-                raise KeyboardInterrupt("Interrupted while waiting for background commands")
+                # Use CancelledError (not KeyboardInterrupt) so the interrupt
+                # stays inside the worker loop and re-prompts, matching the
+                # lint interrupt path above.
+                raise asyncio.CancelledError("Interrupted while waiting for background commands")
             return True
 
         # Check for recently finished commands that need reflection
@@ -1845,25 +1856,44 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
         """
         Get background command output to append after the main message.
 
-        Returns:
-            String containing formatted background command output, or empty string if none
+        Emits a roster of active commands (keeping command keys in context)
+        plus any new incremental output. Output that has been paged to disk is
+        advertised by command key and read on demand through ``ResourceManager``
+        paging.
         """
-        # Get output from all running background commands
-        bg_outputs = BackgroundCommandManager.get_all_command_outputs(clear=True)
+        command_info = BackgroundCommandManager.list_background_commands()
 
-        if not bg_outputs:
+        if not command_info:
             return ""
 
-        # Get command info to show actual command strings
-        command_info = BackgroundCommandManager.list_background_commands()
+        new_outputs = {}
+        for command_key in command_info:
+            output = BackgroundCommandManager.get_new_command_output(command_key)
+            if output.strip():
+                new_outputs[command_key] = output
 
-        # Create formatted output for background commands
         output = "--- Background Commands Output ---\n"
-        for command_key, cmd_output in bg_outputs.items():
-            if cmd_output.strip():  # Only add if there's output
-                # Get the actual command string if available
-                command_str = command_info.get(command_key, {}).get("command", command_key)
-                output += f"\n[bg: {command_str}]\n{cmd_output}\n"
+        output += "Commands:\n"
+
+        paged_keys = []
+        for command_key, info in sorted(command_info.items()):
+            status = "running" if info.get("running", False) else "finished"
+            pages = info.get("pages", 0)
+            page_note = f"pages 1-{pages}" if pages else "no pages yet"
+            output += (
+                f"- {command_key} [{status}] `{info.get('command', command_key)}`"
+                f" — {info.get('total_chars', 0):,} chars, {page_note}\n"
+            )
+            if pages:
+                paged_keys.append(command_key)
+
+        for command_key, cmd_output in new_outputs.items():
+            output += f"\nNew output ({command_key}):\n{cmd_output}\n"
+
+        if paged_keys:
+            output += "\nPaged output is available via `ResourceManager` (up to 3 pages):\n"
+            for command_key in paged_keys:
+                output += f'{{"paging": [{{"target": "{command_key}", "page": 1}}]}}\n'
 
         # Clean up stale (finished) background commands after reading their output
         for command_key, info in command_info.items():
@@ -1872,6 +1902,24 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
 
         return output
 
+    def get_background_command_state(self):
+        """
+        Return a lightweight status snapshot of tracked background commands.
+
+        Maps each command key to its running state and page count so the
+        injection layer can detect finish and page-flush transitions cheaply
+        without consuming any output.
+        """
+        command_info = BackgroundCommandManager.list_background_commands()
+
+        return {
+            key: {
+                "running": bool(info.get("running", False)),
+                "pages": info.get("pages", 0),
+            }
+            for key, info in command_info.items()
+        }
+
     def get_git_status(self):
         """
         Generate a git status context block for repository information.

{cecli_dev-1.5.1 → cecli_dev-1.6.0}/cecli/coders/base_coder.py

@@ -46,6 +46,7 @@ from cecli.helpers.loop_detect import LoopDetectedError, LoopDetector
 from cecli.helpers.memory_control import trim_memory
 from cecli.helpers.observations.service import ObservationService
 from cecli.helpers.profiler import TokenProfiler
+from cecli.helpers.sessions import SessionManager
 from cecli.helpers.threading import ThreadSafeEvent
 from cecli.history import ChatSummary
 from cecli.hooks import HookIntegration
@@ -64,7 +65,6 @@ from cecli.repo import ANY_GIT_ERROR, GitRepoProxy
 from cecli.repomap import RepoMap
 from cecli.report import update_error_prefix
 from cecli.run_cmd import run_cmd_async
-from cecli.sessions import SessionManager
 from cecli.tools.utils.output import print_tool_response
 from cecli.tools.utils.registry import ToolRegistry
 from cecli.utils import copy_tool_call, format_tokens, is_image_file
@@ -1999,7 +1999,13 @@ class Coder(metaclass=UsageMeta):
             if self.commands.is_run_command(inp):
                 self.commands.cmd_running_event.clear()  # Command is running
 
-            return await self.commands.run(inp, coder=self, **run_kwargs)
+            try:
+                return await self.commands.run(inp, coder=self, **run_kwargs)
+            finally:
+                # Dispatch can return early (unknown/ambiguous command) or
+                # raise without ever running a command; the gate must still be
+                # reopened or the input/output loops park forever.
+                self.commands.cmd_running_event.set()
 
         await self.check_for_file_mentions(inp)
         inp = await self.check_for_urls(inp)
@@ -5228,6 +5234,7 @@ class Coder(metaclass=UsageMeta):
                     session_manager.save_session,
                     getattr(self.args, "auto_save_session_name", "auto-save"),
                     False,
+                    True,
                 )
             except Exception:
                 # Don't show errors for auto-save to avoid interrupting the user experience

{cecli_dev-1.5.1 → cecli_dev-1.6.0}/cecli/commands/list_sessions.py

@@ -11,7 +11,7 @@ class ListSessionsCommand(BaseCommand):
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         """Execute the list-sessions command with given parameters."""
-        from cecli import sessions
+        from cecli.helpers import sessions
 
         session_manager = sessions.SessionManager(coder, io)
         sessions_list = session_manager.list_sessions()

{cecli_dev-1.5.1 → cecli_dev-1.6.0}/cecli/commands/load_session.py

@@ -15,7 +15,7 @@ class LoadSessionCommand(BaseCommand):
             io.tool_output("Usage: /load-session <session-name>")
             return format_command_result(io, "load-session", "No session name provided")
 
-        from cecli import sessions
+        from cecli.helpers import sessions
 
         session_manager = sessions.SessionManager(coder, io)
         await session_manager.load_session(args.strip())
@@ -26,7 +26,7 @@ class LoadSessionCommand(BaseCommand):
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for load-session command."""
         # Return available session names for completion
-        from cecli import sessions
+        from cecli.helpers import sessions
 
         session_manager = sessions.SessionManager(coder, io)
         sessions_list = session_manager.list_sessions()
@@ -41,7 +41,10 @@ class LoadSessionCommand(BaseCommand):
         help_text += "\nExamples:\n"
         help_text += "  /load-session my-feature      # Load session 'my-feature'\n"
         help_text += "  /load-session bug-fix         # Load session 'bug-fix'\n"
-        help_text += "\nSessions are loaded from the .cecli/sessions/ directory.\n"
+        help_text += (
+            "\nSessions are loaded from the .cecli/sessions/ directory. Loading a session"
+            " also restores any sub-agents saved with it.\n"
+        )
         help_text += (
             "Use /list-sessions to see saved sessions and /save-session to save a session.\n"
         )

{cecli_dev-1.5.1 → cecli_dev-1.6.0}/cecli/commands/save_session.py

@@ -15,7 +15,7 @@ class SaveSessionCommand(BaseCommand):
             io.tool_error("Please provide a session name to save.")
             return format_command_result(io, "save-session", "No session name provided")
 
-        from cecli import sessions
+        from cecli.helpers import sessions
 
         session_manager = sessions.SessionManager(coder, io)
         session_manager.save_session(args.strip())
@@ -26,7 +26,7 @@ class SaveSessionCommand(BaseCommand):
     def get_completions(cls, io, coder, args) -> List[str]:
         """Get completion options for save-session command."""
         # Return existing session names for completion to prevent accidental overwrites
-        from cecli import sessions
+        from cecli.helpers import sessions
 
         session_manager = sessions.SessionManager(coder, io)
         sessions_list = session_manager.list_sessions()
@@ -42,6 +42,10 @@ class SaveSessionCommand(BaseCommand):
         help_text += "  /save-session my-feature      # Save session as 'my-feature'\n"
         help_text += "  /save-session bug-fix         # Save session as 'bug-fix'\n"
         help_text += "\nSessions are saved in the .cecli/sessions/ directory as JSON files.\n"
+        help_text += (
+            "When the session has sub-agents it is saved as a folder holding the primary"
+            " and each sub-agent payload.\n"
+        )
         help_text += "Use /list-sessions to see saved sessions and /load-session to load them.\n"
         help_text += (
             "\nNote: Existing session names will be shown for tab completion to help prevent"

{cecli_dev-1.5.1 → cecli_dev-1.6.0}/cecli/commands/tokens.py

@@ -1,4 +1,5 @@
-from typing import List
+import json
+from typing import Any, Dict, List, Optional
 
 from cecli.commands.utils.base_command import BaseCommand
 from cecli.commands.utils.helpers import format_command_result
@@ -9,6 +10,140 @@ class TokensCommand(BaseCommand):
     NORM_NAME = "tokens"
     DESCRIPTION = "Report on the number of tokens used by the current chat context"
 
+    @classmethod
+    def _extract_file_name(cls, msg: Dict[str, Any]) -> Optional[str]:
+        """Extract file name from a message dictionary."""
+        if not isinstance(msg, dict):
+            return None
+
+        # Check explicit image_file metadata first
+        fname = msg.get("image_file")
+        if fname:
+            return fname
+
+        content = msg.get("content")
+        if isinstance(content, str):
+            if content.startswith(("Original File Contents For", "Current File Contents For")):
+                lines = content.split("\n", 3)
+                if len(lines) > 1:
+                    return lines[1].strip()
+            elif content.startswith("Image file: "):
+                return content[len("Image file: ") :].strip()
+        elif isinstance(content, list):
+            for part in content:
+                if isinstance(part, dict):
+                    if part.get("image_file"):
+                        return part.get("image_file")
+                    text = part.get("text")
+                    if isinstance(text, str):
+                        if text.startswith(
+                            ("Original File Contents For", "Current File Contents For")
+                        ):
+                            lines = text.split("\n", 3)
+                            if len(lines) > 1:
+                                return lines[1].strip()
+                        elif text.startswith("Image file: "):
+                            return text[len("Image file: ") :].strip()
+                elif isinstance(part, str):
+                    if part.startswith(("Original File Contents For", "Current File Contents For")):
+                        lines = part.split("\n", 3)
+                        if len(lines) > 1:
+                            return lines[1].strip()
+                    elif part.startswith("Image file: "):
+                        return part[len("Image file: ") :].strip()
+
+        return None
+
+    @staticmethod
+    def binary_token_count(data_url: str, bytes_per_pixel: float = 1.0) -> int:
+        """Estimate OpenAI vision tokens for a base64 media data URL.
+
+        Assumes a 4:3 aspect ratio and 1 byte per pixel, which is a reasonable middle
+        ground for binary media when the true dimensions are unknown. The tile cost is
+        inflated by 1.33 and floored to keep the estimate on the pessimistic side.
+        """
+        import math
+
+        b64_data = data_url.split(",", 1)[1] if "," in data_url else data_url
+        padding = b64_data.count("=")
+        rough_bytes = max(0, (len(b64_data) * 3 // 4) - padding)
+        total_pixels = rough_bytes / bytes_per_pixel
+        height = math.sqrt((3 / 4) * total_pixels)
+        width = (4 / 3) * height
+
+        if max(width, height) > 2048:
+            scale = 2048 / max(width, height)
+            width *= scale
+            height *= scale
+
+        if min(width, height) > 768:
+            scale = 768 / min(width, height)
+            width *= scale
+            height *= scale
+
+        tiles = math.ceil(width / 512) * math.ceil(height / 512)
+
+        return math.floor((85 + (170 * tiles)) * 1.33)
+
+    @classmethod
+    def _extract_key_paths(cls, obj: Any, prefix: str = "") -> List[str]:
+        """Return the dot-separated paths of every leaf in a nested structure.
+
+        List indices are included as numeric segments, e.g. "0.image_url.url".
+        """
+        if isinstance(obj, dict):
+            items = obj.items()
+        elif isinstance(obj, list):
+            items = enumerate(obj)
+        else:
+            return [prefix] if prefix else []
+
+        paths = []
+        for key, value in items:
+            path = f"{prefix}.{key}" if prefix else str(key)
+            paths.extend(cls._extract_key_paths(value, path))
+
+        return paths
+
+    @classmethod
+    def _get_path_value(cls, obj: Any, path: str) -> Any:
+        """Resolve a dot-separated path produced by _extract_key_paths."""
+        for part in path.split("."):
+            obj = obj[int(part)] if isinstance(obj, list) else obj[part]
+
+        return obj
+
+    @classmethod
+    def _count_value_tokens(cls, coder, key: str, value: Any) -> int:
+        """Count tokens for an extracted value, estimating data URLs as binary media."""
+        if key == "url" and isinstance(value, str) and value.startswith("data:"):
+            return cls.binary_token_count(value)
+
+        return coder.main_model.token_count(value)
+
+    @classmethod
+    def _count_message_tokens(cls, coder, msg: Dict[str, Any]) -> int:
+        """Count tokens for a message, estimating binary data URLs instead of raw base64."""
+        content = msg.get("content") if isinstance(msg, dict) else None
+
+        if not isinstance(content, (list, dict)):
+            return coder.main_model.token_count([msg])
+
+        total = 0
+
+        for path in cls._extract_key_paths(content):
+            key = path.rsplit(".", 1)[-1]
+
+            if not key.isdigit() and key not in ("text", "content", "url"):
+                continue
+
+            value = cls._get_path_value(content, path)
+
+            if isinstance(value, str):
+                total += cls._count_value_tokens(coder, key, value)
+
+        return total
+
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
         res = []
@@ -55,6 +190,13 @@ class TokensCommand(BaseCommand):
 
         res.append((system_tokens, "system messages", ""))
 
+        # tool definitions
+        tool_list = coder.get_tool_list()
+
+        if tool_list:
+            tokens_tools = coder.main_model.token_count(json.dumps(tool_list))
+            res.append((tokens_tools, "tool schemas", ""))
+
         # chat history
         msgs_done = ConversationService.get_manager(coder).get_messages_dict(tag=MessageTag.DONE)
         msgs_cur = ConversationService.get_manager(coder).get_messages_dict(tag=MessageTag.CUR)
@@ -123,27 +265,10 @@ class TokensCommand(BaseCommand):
             # Group messages by file (each file has user and assistant messages)
             file_tokens = {}
             for msg in readonly_msgs:
-                # Extract file name from message content
-                content = msg.get("content", "")
-                if content.startswith("Original File Contents For"):
-                    # Extract file path from "File Contents {path}:"
-                    lines = content.split("\n", 3)
-                    if lines:
-                        file_line = lines[1]
-                        fname = file_line.strip()
-                        # Calculate tokens for this message
-                        tokens = coder.main_model.token_count([msg])
-                        if fname not in file_tokens:
-                            file_tokens[fname] = 0
-                        file_tokens[fname] += tokens
-                elif "image_file" in msg:
-                    # Handle image files
-                    fname = msg.get("image_file")
-                    if fname:
-                        tokens = coder.main_model.token_count([msg])
-                        if fname not in file_tokens:
-                            file_tokens[fname] = 0
-                        file_tokens[fname] += tokens
+                fname = cls._extract_file_name(msg)
+                if fname:
+                    tokens = cls._count_message_tokens(coder, msg)
+                    file_tokens[fname] = file_tokens.get(fname, 0) + tokens
 
             # Add to results
             for fname, tokens in file_tokens.items():
@@ -158,27 +283,10 @@ class TokensCommand(BaseCommand):
             msgs = ConversationService.get_manager(coder).get_messages_dict(tag=tag)
             if msgs:
                 for msg in msgs:
-                    # Extract file name from message content
-                    content = msg.get("content", "")
-                    if content.startswith("Original File Contents For"):
-                        # Extract file path from "File Contents {path}:"
-                        lines = content.split("\n", 3)
-                        if lines:
-                            file_line = lines[1]
-                            fname = file_line.strip()
-                            # Calculate tokens for this message
-                            tokens = coder.main_model.token_count([msg])
-                            if fname not in editable_file_tokens:
-                                editable_file_tokens[fname] = 0
-                            editable_file_tokens[fname] += tokens
-                    elif "image_file" in msg:
-                        # Handle image files
-                        fname = msg.get("image_file")
-                        if fname:
-                            tokens = coder.main_model.token_count([msg])
-                            if fname not in editable_file_tokens:
-                                editable_file_tokens[fname] = 0
-                            editable_file_tokens[fname] += tokens
+                    fname = cls._extract_file_name(msg)
+                    if fname:
+                        tokens = cls._count_message_tokens(coder, msg)
+                        editable_file_tokens[fname] = editable_file_tokens.get(fname, 0) + tokens
 
         # Add editable files to results
         for fname, tokens in editable_file_tokens.items():

{cecli_dev-1.5.1 → cecli_dev-1.6.0}/cecli/helpers/background_commands.py

@@ -106,6 +106,110 @@ class CircularBuffer:
             return len(self.buffer)
 
 
+class PagedOutputBuffer:
+    """
+    Thread-safe output window that spills full pages to disk.
+
+    Output accumulates in memory until it reaches ``page_size`` characters.
+    Full pages are written to ``pages_dir`` as ``{n}.txt`` and dropped from
+    memory, so the in-memory window never grows beyond ``page_size``. Unlike
+    ``CircularBuffer``, ``total_added`` is a monotonic stream offset that is
+    never reset, so incremental readers can resume after content has been
+    flushed; anything older than the in-memory window lives on disk.
+    """
+
+    def __init__(self, page_size: int = 4096, pages_dir: Optional[str] = None):
+        self.page_size = max(1, int(page_size))
+        self.pages_dir = pages_dir
+        self.buffer = deque()
+        self.lock = threading.Lock()
+        self.total_added = 0
+        self.window_start = 0
+        self.page_count = 0
+
+    def append(self, text: str) -> None:
+        """Append text, spilling full pages to disk once the window fills."""
+        if not text:
+            return
+
+        with self.lock:
+            self.buffer.extend(text)
+            self.total_added += len(text)
+
+            if self.total_added - self.window_start >= self.page_size:
+                self._spill_locked()
+
+    def get_all(self, clear: bool = False) -> str:
+        """Return the in-memory window (content not yet flushed to disk)."""
+        with self.lock:
+            result = "".join(self.buffer)
+
+            if clear:
+                self.buffer.clear()
+                self.window_start = self.total_added
+
+            return result
+
+    def get_new_output(self, last_read_position: int) -> Tuple[str, int]:
+        """Return window content past ``last_read_position`` and the new offset.
+
+        Content older than the window has already been paged to disk, so the
+        read position is clamped forward to the window start rather than
+        replaying bytes that are only available as pages.
+        """
+        with self.lock:
+            if last_read_position >= self.total_added:
+                return "", self.total_added
+
+            start = max(last_read_position, self.window_start)
+            new_output = "".join(self.buffer)[start - self.window_start :]
+
+            return new_output, self.total_added
+
+    def clear(self) -> None:
+        """Drop the in-memory window; flushed pages are unaffected."""
+        with self.lock:
+            self.buffer.clear()
+            self.window_start = self.total_added
+
+    def size(self) -> int:
+        """Get current buffer size in characters."""
+        with self.lock:
+            return len(self.buffer)
+
+    def _spill_locked(self) -> None:
+        content = "".join(self.buffer)
+
+        if not self.pages_dir:
+            # Without a page directory, retain only the newest page in memory.
+            if len(content) > self.page_size:
+                dropped = len(content) - self.page_size
+                content = content[dropped:]
+                self.window_start += dropped
+                self.buffer = deque(content)
+
+            return
+
+        while len(content) >= self.page_size:
+            page = content[: self.page_size]
+            content = content[self.page_size :]
+            self.page_count += 1
+            self._write_page_locked(self.page_count, page)
+            self.window_start += self.page_size
+
+        self.buffer = deque(content)
+
+    def _write_page_locked(self, page_number: int, content: str) -> None:
+        os.makedirs(self.pages_dir, exist_ok=True)
+        abs_path = os.path.join(self.pages_dir, f"{page_number}.txt")
+        tmp_path = f"{abs_path}.tmp"
+
+        with safe_open(tmp_path, "w") as page_file:
+            page_file.write(content)
+
+        os.replace(tmp_path, abs_path)
+
+
 class InputBuffer:
     """
     Thread-safe buffer for queuing input to be sent to a process.
@@ -442,6 +546,9 @@ class BackgroundCommandManager:
         existing_input_buffer: Optional[InputBuffer] = None,
         use_pty: bool = False,
         master_fd: Optional[int] = None,
+        command_key: Optional[str] = None,
+        page_size: Optional[int] = None,
+        pages_dir: Optional[str] = None,
     ) -> str:
         """
         Start a command in background.
@@ -452,15 +559,23 @@ class BackgroundCommandManager:
             cwd: Working directory for command
             max_buffer_size: Maximum buffer size for output
             existing_process: Optional existing subprocess.Popen to register
-            existing_buffer: Optional existing CircularBuffer to use
+            existing_buffer: Optional existing buffer to use (CircularBuffer or PagedOutputBuffer)
             persist: If True, output buffer won't be cleared when read
+            command_key: Optional pre-generated command key; generated when omitted
+            page_size: Characters per page when paging output to disk
+            pages_dir: Directory where full output pages are written
 
         Returns:
             Command key for future reference
         """
         try:
-            # Use existing buffer or create new one
-            buffer = existing_buffer or CircularBuffer(max_size=max_buffer_size)
+            # Use existing buffer or create a paged/circular one
+            if existing_buffer is not None:
+                buffer = existing_buffer
+            elif page_size and pages_dir:
+                buffer = PagedOutputBuffer(page_size=page_size, pages_dir=pages_dir)
+            else:
+                buffer = CircularBuffer(max_size=max_buffer_size)
 
             # Use existing process or start new one
             # Use provided master_fd (e.g., from _execute_with_timeout) or default to None
@@ -523,7 +638,7 @@ class BackgroundCommandManager:
             )
 
             # Generate unique key and store
-            command_key = cls._generate_command_key(command)
+            command_key = command_key or cls._generate_command_key(command)
 
             with cls._lock:
                 cls._background_commands[command_key] = bg_process
@@ -691,6 +806,10 @@ class BackgroundCommandManager:
                     "command": bg_process.command,
                     "running": bg_process.is_alive(),
                     "buffer_size": bg_process.buffer.size(),
+                    "pages": getattr(bg_process.buffer, "page_count", 0),
+                    "total_chars": getattr(
+                        bg_process.buffer, "total_added", bg_process.buffer.size()
+                    ),
                     "start_time": bg_process.start_time,
                     "end_time": bg_process.end_time,
                     "duration": (