code-puppy 0.0.575__tar.gz → 0.0.577__tar.gz

{code_puppy-0.0.575 → code_puppy-0.0.577}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.575
+Version: 0.0.577
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.575 → code_puppy-0.0.577}/code_puppy/cli_runner.py

@@ -133,6 +133,48 @@ def _resume_session_from_path(raw_path: str) -> None:
     )
 
 
+def apply_quick_resume(args) -> bool:
+    """Resolve ``--quick-resume [PATH]`` into ``args.resume`` so the existing
+    resume machinery loads it.
+
+    Looks up the most recent autosave for PATH (defaulting to cwd), scoped to
+    the nearest git worktree root + branch when available, with a no-git
+    fallback. No-op when ``--quick-resume`` was not requested or ``--resume`` is
+    already set (explicit ``--resume`` always wins). Returns True when a target
+    was resolved.
+    """
+    existing_resume = getattr(args, "resume", None)
+    quick_resume_target = getattr(args, "quick_resume", None)
+    if quick_resume_target is None or (
+        existing_resume and str(existing_resume).strip()
+    ):
+        return False
+
+    from code_puppy.config import (
+        format_quick_resume_scope,
+        get_quick_resume_location,
+        resolve_quick_resume_pickle,
+    )
+    from code_puppy.messaging import emit_info
+
+    target_path = str(quick_resume_target).strip() or "."
+
+    # Diagnostic identifies the lookup scope without leaking full local paths.
+    cwd, branch = get_quick_resume_location(target_path)
+    emit_info(
+        "\U0001f50d Quick Resume selected - finding latest session for "
+        f"{format_quick_resume_scope(cwd, branch)}"
+    )
+
+    quick_resume_pickle = resolve_quick_resume_pickle(target_path)
+    if quick_resume_pickle:
+        args.resume = quick_resume_pickle
+        return True
+
+    emit_info("No previous session found for this scope; starting fresh.")
+    return False
+
+
 async def main():
     """Main async entry point for Code Puppy CLI."""
     parser = argparse.ArgumentParser(description="Code Puppy - A code generation agent")
@@ -174,6 +216,18 @@ async def main():
         metavar="PATH",
         help="Resume a saved session from a .pkl file (e.g. ~/.code_puppy/contexts/foo.pkl)",
     )
+    parser.add_argument(
+        "--quick-resume",
+        "-qr",
+        nargs="?",
+        const=".",
+        default=None,
+        metavar="PATH",
+        help=(
+            "Resume the most recent session for PATH (defaults to the current "
+            "directory; scopes to git root + branch when available)"
+        ),
+    )
     parser.add_argument(
         "command", nargs="*", help="Run a single command (deprecated, use -p instead)"
     )
@@ -395,6 +449,10 @@ async def main():
 
     await callbacks.on_startup()
 
+    # Resolve --quick-resume [PATH] into --resume so the resume machinery below
+    # loads the most recent session for that canonical (git-root + branch) scope.
+    apply_quick_resume(args)
+
     if args.resume:
         _resume_session_from_path(args.resume)
 

{code_puppy-0.0.575 → code_puppy-0.0.577}/code_puppy/command_line/autosave_menu.py

@@ -20,9 +20,15 @@ from prompt_toolkit.widgets import Frame
 from rich.console import Console
 from rich.markdown import Markdown
 
+from code_puppy.command_line.autosave_search import (
+    SessionContentIndex,
+    entry_matches,
+    iter_alphabet_bindings,
+)
 from code_puppy.command_line.pagination import (
     ensure_visible_page,
     get_page_bounds,
+    get_page_for_index,
     get_total_pages,
 )
 from code_puppy.config import AUTOSAVE_DIR
@@ -163,17 +169,40 @@ def _render_menu_panel(
     page: int,
     selected_idx: int,
     browse_mode: bool = False,
+    search_text: str = "",
+    in_search_mode: bool = False,
+    search_buffer: str = "",
+    status_line: Optional[Tuple[str, str]] = None,
 ) -> List:
-    """Render the left menu panel with pagination."""
+    """Render the left menu panel with pagination.
+
+    ``status_line`` is an optional ``(style, text)`` pair that, when
+    provided, replaces the normal search/filter indicator. The picker
+    uses it to surface transient states like ``Filtering...`` (right
+    after the user commits a search) and ``Indexing N/M...`` (while the
+    background pre-warm task is still chewing through sessions).
+    """
     lines = []
     total_pages = get_total_pages(len(entries), PAGE_SIZE)
     start_idx, end_idx = get_page_bounds(page, len(entries), PAGE_SIZE)
 
     lines.append(("", f" Session Page(s): ({page + 1}/{total_pages})"))
+    if status_line is not None:
+        lines.append(("", "\n"))
+        lines.append(status_line)
+    elif in_search_mode:
+        lines.append(("", "\n"))
+        lines.append(("fg:ansiyellow", f"  Searching: '{search_buffer}'"))
+    elif search_text:
+        lines.append(("", "\n"))
+        lines.append(("fg:ansiyellow", f"  Filter: '{search_text}'"))
     lines.append(("", "\n\n"))
 
     if not entries:
-        lines.append(("fg:yellow", "  No autosave sessions found."))
+        if search_text or in_search_mode:
+            lines.append(("fg:yellow", "  No sessions match your search."))
+        else:
+            lines.append(("fg:yellow", "  No autosave sessions found."))
         lines.append(("", "\n\n"))
         # Navigation hints (always show)
         lines.append(("", "\n"))
@@ -225,6 +254,8 @@ def _render_menu_panel(
         lines.append(("", "Page\n"))
         lines.append(("fg:ansicyan", "  e   "))
         lines.append(("", "Browse msgs\n"))
+        lines.append(("fg:ansibrightblack", "  /   "))
+        lines.append(("", "Search content\n"))
     lines.append(("fg:green", "  Enter  "))
     lines.append(("", "Load\n"))
     lines.append(("fg:ansibrightred", "  Ctrl+C "))
@@ -515,7 +546,7 @@ async def interactive_autosave_picker() -> Optional[str]:
         return None
 
     # State
-    selected_idx = [0]  # Current selection (global index)
+    selected_idx = [0]  # Current selection (index into visible_entries)
     current_page = [0]  # Current page
     result = [None]  # Selected session name
 
@@ -524,21 +555,90 @@ async def interactive_autosave_picker() -> Optional[str]:
     message_idx = [0]  # Current message index (0 = most recent)
     cached_history = [None]  # Cached history for current session in browse mode
 
-    total_pages = get_total_pages(len(entries), PAGE_SIZE)
+    # Search/filter state (mirrors set_menu.py's `/`-search UX)
+    search_text = [""]  # Committed filter (drives visible_entries)
+    in_search_mode = [False]  # Currently typing into the search buffer?
+    search_buffer = [""]  # Live keystrokes before Enter commits them
+    visible_entries: List[List[Tuple[str, dict]]] = [list(entries)]
+    content_index = SessionContentIndex()  # Lazy content cache for THIS picker
+    is_filtering = [False]  # True while the Enter-handler is doing the work
+    total_to_index = len(entries)  # Denominator for the prewarm progress hint
 
     def get_current_entry() -> Optional[Tuple[str, dict]]:
-        if 0 <= selected_idx[0] < len(entries):
-            return entries[selected_idx[0]]
+        visible = visible_entries[0]
+        if 0 <= selected_idx[0] < len(visible):
+            return visible[selected_idx[0]]
         return None
 
+    def _filter_entries(needle: str) -> List[Tuple[str, dict]]:
+        """Pure filter: needle in, filtered list out. Safe to run off-thread.
+
+        Reads ``entries``, ``content_index``, and ``base_dir`` from the
+        enclosing closure -- ``entries`` is built once and never mutated,
+        and ``content_index`` is protected by its own internal lock, so
+        this is safe to invoke from an ``asyncio.to_thread`` worker.
+        """
+        if not needle:
+            return list(entries)
+        return [e for e in entries if entry_matches(e, needle, content_index, base_dir)]
+
+    def _apply_filter_result(filtered: List[Tuple[str, dict]]) -> None:
+        """Apply a filter result to picker state. Must run on the main thread."""
+        visible_entries[0] = filtered
+        if not filtered:
+            selected_idx[0] = 0
+            current_page[0] = 0
+            return
+        selected_idx[0] = min(selected_idx[0], len(filtered) - 1)
+        current_page[0] = get_page_for_index(selected_idx[0], PAGE_SIZE)
+
+    def update_visible_entries() -> None:
+        """Synchronous re-filter -- only safe when the cache is warm or empty.
+
+        Used for the picker's initial setup (no filter active -> trivial)
+        and as a fallback. The post-Enter path goes through
+        :func:`asyncio.to_thread` instead so a cold-cache filter does not
+        freeze the event loop.
+        """
+        _apply_filter_result(_filter_entries(search_text[0]))
+
     # Build UI
     menu_control = FormattedTextControl(text="")
     preview_control = FormattedTextControl(text="")
 
+    def _compute_status_line() -> Optional[Tuple[str, str]]:
+        """Resolve which transient indicator (if any) takes the header slot.
+
+        Priority order:
+          1. ``Filtering...`` -- user just hit Enter, filter is running.
+          2. ``Searching: '...'`` / ``Filter: '...'`` -- normal search UX,
+             handled by the renderer's own branches when this returns None.
+          3. ``Indexing N/M...`` -- background pre-warm in progress and no
+             other search activity to crowd out.
+        """
+        if is_filtering[0]:
+            return ("fg:ansicyan bold", "  Filtering...")
+        if in_search_mode[0] or search_text[0]:
+            return None  # Let the renderer show the search/filter line.
+        cached = content_index.count()
+        if 0 < cached < total_to_index:
+            return (
+                "fg:ansibrightblack",
+                f"  Indexing {cached}/{total_to_index}...",
+            )
+        return None
+
     def update_display():
         """Update both panels."""
         menu_control.text = _render_menu_panel(
-            entries, current_page[0], selected_idx[0], browse_mode[0]
+            visible_entries[0],
+            current_page[0],
+            selected_idx[0],
+            browse_mode[0],
+            search_text=search_text[0],
+            in_search_mode=in_search_mode[0],
+            search_buffer=search_buffer[0],
+            status_line=_compute_status_line(),
         )
         # Show message browser if in browse mode, otherwise show preview
         if browse_mode[0] and cached_history[0] is not None:
@@ -574,6 +674,8 @@ async def interactive_autosave_picker() -> Optional[str]:
     @kb.add("up")
     @kb.add("c-p")  # Ctrl+P = previous (Emacs-style)
     def _(event):
+        if in_search_mode[0]:
+            return  # While typing the search buffer, arrows do nothing.
         if browse_mode[0]:
             # In browse mode: go to older message
             if cached_history[0] and message_idx[0] < len(cached_history[0]) - 1:
@@ -586,7 +688,7 @@ async def interactive_autosave_picker() -> Optional[str]:
                 current_page[0] = ensure_visible_page(
                     selected_idx[0],
                     current_page[0],
-                    len(entries),
+                    len(visible_entries[0]),
                     PAGE_SIZE,
                 )
                 update_display()
@@ -594,6 +696,8 @@ async def interactive_autosave_picker() -> Optional[str]:
     @kb.add("down")
     @kb.add("c-n")  # Ctrl+N = next (Emacs-style)
     def _(event):
+        if in_search_mode[0]:
+            return
         if browse_mode[0]:
             # In browse mode: go to newer message
             if message_idx[0] > 0:
@@ -601,18 +705,20 @@ async def interactive_autosave_picker() -> Optional[str]:
                 update_display()
         else:
             # Normal mode: navigate sessions
-            if selected_idx[0] < len(entries) - 1:
+            if selected_idx[0] < len(visible_entries[0]) - 1:
                 selected_idx[0] += 1
                 current_page[0] = ensure_visible_page(
                     selected_idx[0],
                     current_page[0],
-                    len(entries),
+                    len(visible_entries[0]),
                     PAGE_SIZE,
                 )
                 update_display()
 
     @kb.add("left")
     def _(event):
+        if in_search_mode[0]:
+            return
         if current_page[0] > 0:
             current_page[0] -= 1
             selected_idx[0] = current_page[0] * PAGE_SIZE
@@ -620,14 +726,25 @@ async def interactive_autosave_picker() -> Optional[str]:
 
     @kb.add("right")
     def _(event):
+        if in_search_mode[0]:
+            return
+        # Recompute total_pages from visible_entries every call -- filtering
+        # changes the list length and a stale captured value would let users
+        # page past the end of a filtered result.
+        total_pages = get_total_pages(len(visible_entries[0]), PAGE_SIZE)
         if current_page[0] < total_pages - 1:
             current_page[0] += 1
             selected_idx[0] = current_page[0] * PAGE_SIZE
             update_display()
 
     @kb.add("e")
+    @kb.add("E")
     def _(event):
-        """Enter message browse mode."""
+        """Enter message browse mode (or feed the search buffer)."""
+        if in_search_mode[0]:
+            search_buffer[0] += "e"
+            update_display()
+            return
         if browse_mode[0]:
             return  # Already in browse mode
         entry = get_current_entry()
@@ -643,20 +760,30 @@ async def interactive_autosave_picker() -> Optional[str]:
 
     @kb.add("escape")
     def _(event):
-        """Exit browse mode or cancel."""
+        """Exit search mode, browse mode, or cancel -- in that priority."""
+        if in_search_mode[0]:
+            in_search_mode[0] = False
+            search_buffer[0] = ""
+            update_display()
+            return
         if browse_mode[0]:
             browse_mode[0] = False
             cached_history[0] = None
             message_idx[0] = 0
             update_display()
         else:
-            # Not in browse mode - treat as cancel
+            # Not in any sub-mode - treat as cancel
             result[0] = None
             event.app.exit()
 
     @kb.add("q")
+    @kb.add("Q")
     def _(event):
-        """Exit browse mode (only when in browse mode)."""
+        """Feed the search buffer, or exit browse mode if not searching."""
+        if in_search_mode[0]:
+            search_buffer[0] += "q"
+            update_display()
+            return
         if browse_mode[0]:
             browse_mode[0] = False
             cached_history[0] = None
@@ -664,12 +791,57 @@ async def interactive_autosave_picker() -> Optional[str]:
             update_display()
 
     @kb.add("enter")
-    def _(event):
+    async def _(event):
+        if in_search_mode[0]:
+            # Commit the buffer as the active filter. Repaint "Filtering..."
+            # BEFORE doing the work so users get feedback even when the
+            # content index is cold and the lookup has to read pickles.
+            search_text[0] = search_buffer[0]
+            in_search_mode[0] = False
+            search_buffer[0] = ""
+            is_filtering[0] = True
+            update_display()
+            event.app.invalidate()
+            # Run the (potentially blocking) filter on a worker thread
+            # so the event loop stays responsive. ``await`` yields here,
+            # which also gives prompt_toolkit the tick it needs to paint
+            # the "Filtering..." indicator before the worker starts.
+            try:
+                filtered = await asyncio.to_thread(_filter_entries, search_text[0])
+                _apply_filter_result(filtered)
+            finally:
+                is_filtering[0] = False
+            update_display()
+            event.app.invalidate()
+            return
         entry = get_current_entry()
         if entry:
             result[0] = entry[0]  # Store session name
         event.app.exit()
 
+    @kb.add("/")
+    def _(event):
+        """Enter search mode. Disabled inside browse mode (focus is on msgs)."""
+        if browse_mode[0]:
+            return
+        in_search_mode[0] = True
+        search_buffer[0] = ""
+        update_display()
+
+    @kb.add("backspace")
+    def _(event):
+        if in_search_mode[0]:
+            search_buffer[0] = search_buffer[0][:-1]
+            update_display()
+
+    for _key, _append in iter_alphabet_bindings():
+
+        @kb.add(_key)
+        def _alpha(event, _c=_append):
+            if in_search_mode[0]:
+                search_buffer[0] += _c
+                update_display()
+
     @kb.add("c-c")
     def _(event):
         result[0] = None
@@ -683,6 +855,32 @@ async def interactive_autosave_picker() -> Optional[str]:
         mouse_support=False,
     )
 
+    async def _prewarm_index() -> None:
+        """Eagerly populate the content index in the background.
+
+        Without this, the first content-search blocks the UI on N pickle
+        reads. Running the loads on a worker thread keeps the event loop
+        responsive; ``app.invalidate()`` after each one drives the
+        ``Indexing N/M...`` progress hint in the menu header.
+        """
+        for name, _meta in entries:
+            if name in content_index:
+                continue
+            try:
+                await asyncio.to_thread(content_index.lookup, name, base_dir)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                # SessionContentIndex.lookup already swallows + caches
+                # load errors; we should never get here, but be paranoid.
+                pass
+            try:
+                app.invalidate()
+            except Exception:
+                # If the app is tearing down, invalidate may explode --
+                # not our problem, just stop pre-warming gracefully.
+                return
+
     set_awaiting_user_input(True)
 
     # Enter alternate screen buffer once for entire session
@@ -691,6 +889,8 @@ async def interactive_autosave_picker() -> Optional[str]:
     sys.stdout.flush()
     await asyncio.sleep(0.05)
 
+    prewarm_task = asyncio.create_task(_prewarm_index())
+
     try:
         # Initial display
         update_display()
@@ -703,6 +903,13 @@ async def interactive_autosave_picker() -> Optional[str]:
         await app.run_async()
 
     finally:
+        # Cancel the background pre-warm if it hasn't finished; suppress
+        # the resulting CancelledError so the picker exits cleanly.
+        prewarm_task.cancel()
+        try:
+            await prewarm_task
+        except (asyncio.CancelledError, Exception):
+            pass
         # Exit alternate screen buffer once at end
         sys.stdout.write("\033[?1049l")  # Exit alternate buffer
         sys.stdout.flush()

code_puppy-0.0.577/code_puppy/command_line/autosave_search.py

@@ -0,0 +1,184 @@
+"""Search/filter helpers for the ``/resume`` (autosave_load) session picker.
+
+Lives separately from :mod:`code_puppy.command_line.autosave_menu` so that
+file (already overweight at ~700+ lines) does not grow further. Everything
+in here is pure / IO-tolerant so it is unit-testable without spinning up
+a prompt_toolkit ``Application``.
+
+The picker UX mirrors ``/set``: pressing ``/`` enters search mode, alphabet
+chars append to a buffer, ``Enter`` commits the buffer, ``Esc`` cancels the
+search. The novel bit is that this picker filters on *session content* --
+the concatenated text of every message in each session -- rather than just
+the timestamp/metadata visible in the left menu. Content is loaded lazily
+and cached for the picker's lifetime so we do not re-unpickle session
+files on every keystroke.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from threading import Lock
+from typing import Callable, Dict, Iterator, Optional, Tuple
+
+from code_puppy.session_storage import load_session
+
+# Alphabet bound to the search buffer while ``in_search_mode`` is True.
+# Lowercase ASCII letters (except ``e`` and ``q``), digits, underscore,
+# hyphen, and space. ``e`` and ``q`` are deliberately excluded because
+# autosave_menu.py already binds them to nav actions (browse-msgs and
+# exit-browse respectively); those existing handlers are dual-mode --
+# they append to the search buffer when ``in_search_mode`` is True and
+# fire their nav action otherwise. Same trick set_menu uses for ``r``.
+SEARCH_ALPHABET = "abcdfghijklmnoprstuvwxyz0123456789_- "
+
+
+def iter_alphabet_bindings() -> Iterator[Tuple[str, str]]:
+    """Yield ``(key_to_bind, char_to_append)`` pairs for the alphabet.
+
+    For each lowercase character in :data:`SEARCH_ALPHABET` we yield both
+    the lowercase and (when distinct) the uppercase form. Both forms
+    append the *lowercase* character so the buffer stays case-folded --
+    search match is already case-insensitive, and folding on input means
+    the rendered ``Searching: '...'`` line is stable regardless of
+    Shift/Caps Lock state.
+
+    Yields lowercase before uppercase so prompt_toolkit's keybinding
+    registration order is deterministic and easy to reason about.
+    """
+    for ch in SEARCH_ALPHABET:
+        yield ch, ch
+        upper = ch.upper()
+        if upper != ch:
+            yield upper, ch
+
+
+def _session_text(history: list) -> str:
+    """Concatenate the raw text content of every message part.
+
+    Deliberately uses raw ``part.content`` (only when it is a non-empty
+    ``str``) instead of going through
+    :func:`code_puppy.command_line.autosave_menu._extract_message_content`.
+    That helper decorates tool messages with ``"Tool Call: <name>"`` and
+    ``"Tool Result: <name>"`` prefixes -- if we indexed the decorated
+    form, typing ``tool call`` would match every session that ever
+    called a tool. Noise, not signal.
+    """
+    chunks: list = []
+    for msg in history:
+        for part in getattr(msg, "parts", ()) or ():
+            content = getattr(part, "content", None)
+            if isinstance(content, str) and content:
+                chunks.append(content)
+    return "\n".join(chunks)
+
+
+class SessionContentIndex:
+    """Lazy, per-picker cache of ``{session_name -> lowercased text}``.
+
+    Loading a session unpickles the whole file, so we only do it on
+    demand and cache the result for the lifetime of one picker
+    invocation. Errors are tolerated and cached as empty strings so we
+    do not re-hit broken files on every keystroke.
+
+    The ``loader`` injection point exists for testing -- production code
+    always uses :func:`code_puppy.session_storage.load_session`.
+    """
+
+    def __init__(
+        self,
+        loader: Optional[Callable[[str, Path], list]] = None,
+    ) -> None:
+        self._loader = loader or load_session
+        self._cache: Dict[str, str] = {}
+        # The pre-warm task runs on an ``asyncio.to_thread`` worker while
+        # the picker's render path reads cache state on the event loop;
+        # the post-Enter filter (PR review accept #2) also runs on a
+        # worker. CPython's GIL makes individual dict ops atomic, but
+        # the ``check-then-load-then-store`` sequence in ``lookup`` is
+        # not -- the lock keeps the invariant tidy and survives a future
+        # free-threaded build where GIL atomicity disappears.
+        self._lock = Lock()
+
+    def lookup(self, session_name: str, base_dir: Path) -> str:
+        with self._lock:
+            cached = self._cache.get(session_name)
+            if cached is not None or session_name in self._cache:
+                # ``cached is not None`` short-circuits the common case;
+                # the explicit ``in`` check picks up cached-empty-string
+                # entries (failed loads) without re-running the loader.
+                return cached or ""
+        # Loader runs OUTSIDE the lock so a slow pickle read does not
+        # block other threads from checking the cache for unrelated keys.
+        try:
+            history = self._loader(session_name, base_dir)
+            text = _session_text(history).lower()
+        except Exception:
+            # Cache the failure so a broken pickle does not slow every keystroke.
+            text = ""
+        with self._lock:
+            # Last-writer-wins. If a concurrent ``lookup`` for the same
+            # key beat us here that is fine -- the value is identical.
+            self._cache[session_name] = text
+        return text
+
+    def count(self) -> int:
+        """Number of sessions cached so far (success or failure).
+
+        The picker uses this to render an ``Indexing N/M…`` progress hint
+        while the background pre-warm task is still running.
+        """
+        with self._lock:
+            return len(self._cache)
+
+    def __contains__(self, session_name: object) -> bool:
+        """Membership check so callers don't have to peek at ``_cache``.
+
+        Used by the picker's pre-warm loop to skip sessions that were
+        already loaded on demand by an earlier ``lookup``.
+        """
+        with self._lock:
+            return session_name in self._cache
+
+
+def _formatted_timestamp(metadata: dict) -> str:
+    """Mirror the ``YYYY-MM-DD HH:MM`` format the left menu shows.
+
+    Search must hit what the user *sees*, so the formatting has to
+    match :func:`autosave_menu._render_menu_panel`.
+    """
+    timestamp = metadata.get("timestamp", "")
+    try:
+        dt = datetime.fromisoformat(timestamp)
+        return dt.strftime("%Y-%m-%d %H:%M")
+    except (ValueError, TypeError):
+        return str(timestamp)
+
+
+def entry_matches(
+    entry: Tuple[str, dict],
+    needle: str,
+    index: SessionContentIndex,
+    base_dir: Path,
+) -> bool:
+    """Return True if ``needle`` is a substring of the session.
+
+    Empty needle matches everything (the picker shows the full list).
+    Cheap metadata checks (session name, formatted timestamp, message
+    count) run first; the full session content is only loaded via
+    ``index`` if the cheap checks miss. Typing ``2026-06`` therefore
+    never triggers a single pickle read.
+    """
+    if not needle:
+        return True
+    needle_lower = needle.lower()
+    session_name, metadata = entry
+
+    if needle_lower in session_name.lower():
+        return True
+    if needle_lower in _formatted_timestamp(metadata).lower():
+        return True
+    if needle_lower in str(metadata.get("message_count", "")).lower():
+        return True
+
+    return needle_lower in index.lookup(session_name, base_dir)