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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.577
+Version: 0.0.579
 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.577 → code_puppy-0.0.579}/code_puppy/cli_runner.py

@@ -27,7 +27,7 @@ from code_puppy.config import (
     COMMAND_HISTORY_FILE,
     ensure_config_exists,
     finalize_autosave_session,
-    get_current_autosave_session_name,
+    get_current_session_name,
     initialize_command_history_file,
     record_terminal_session,
     save_command_to_history,
@@ -82,57 +82,6 @@ def _render_turn_exception(exc: Exception) -> None:
     get_queue_console().print_exception()
 
 
-def _resume_session_from_path(raw_path: str) -> None:
-    """Restore agent message history from a saved .pkl session file.
-
-    Accepts any path (autosaves, contexts, somewhere weird on disk). We don't
-    care where it lives — we just decompose into (parent_dir, stem) and reuse
-    ``session_storage.load_session`` so we stay DRY.
-    """
-    from code_puppy.agents.agent_manager import get_current_agent
-    from code_puppy.messaging import emit_error, emit_success
-    from code_puppy.session_storage import load_session
-
-    session_path = Path(raw_path).expanduser().resolve()
-
-    if not session_path.exists():
-        emit_error(f"--resume: session file not found: {session_path}")
-        sys.exit(1)
-
-    if session_path.suffix != ".pkl":
-        emit_error(
-            f"--resume: expected a .pkl session file, got '{session_path.suffix}': {session_path}"
-        )
-        sys.exit(1)
-
-    try:
-        history = load_session(session_path.stem, session_path.parent)
-    except Exception as exc:
-        emit_error(f"--resume: failed to load session: {exc}")
-        sys.exit(1)
-
-    try:
-        agent = get_current_agent()
-        agent.set_message_history(history)
-    except Exception as exc:
-        emit_error(f"--resume: failed to attach history to agent: {exc}")
-        sys.exit(1)
-
-    # Rotate autosave id so we don't clobber the original file we just resumed.
-    try:
-        from code_puppy.config import rotate_autosave_id
-
-        rotate_autosave_id()
-    except Exception:
-        pass  # autosave rotation is best-effort
-
-    total_tokens = sum(agent.estimate_tokens_for_message(m) for m in history)
-    emit_success(
-        f"✅ Resumed session: {len(history)} messages ({total_tokens} tokens)\n"
-        f"📁 From: {session_path}"
-    )
-
-
 def apply_quick_resume(args) -> bool:
     """Resolve ``--quick-resume [PATH]`` into ``args.resume`` so the existing
     resume machinery loads it.
@@ -447,14 +396,98 @@ async def main():
         else:
             default_version_mismatch_behavior(current_version)
 
+    # One-shot sweep of legacy ~/.code_puppy/contexts/ into the unified
+    # autosaves/ store. Idempotent via a sentinel; safe to call every
+    # startup. MUST run before any plugin startup callback can read
+    # AUTOSAVE_DIR (otherwise a plugin could miss freshly-swept files)
+    # and before the resume block below resolves -r NAME.
+    try:
+        from code_puppy.session_migration import sweep_contexts_to_autosaves
+
+        sweep_contexts_to_autosaves()
+    except Exception:
+        # Sweep failure must never block startup -- it logs internally.
+        pass
+
     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)
 
+    # Holds the resolved (normalised) session name when -r/--resume is in
+    # effect, so save-back paths can persist into the same file the resolver
+    # opened — not the raw user input (which might be ``foo.pkl`` or an
+    # absolute path that the resolver normalised to a bare slug).
+    resolved_resume_session: str | None = None
+
     if args.resume:
-        _resume_session_from_path(args.resume)
+        from code_puppy.agents.agent_manager import get_current_agent
+        from code_puppy.config import AUTOSAVE_DIR, pin_current_session_name
+        from code_puppy.messaging import emit_error, emit_info, emit_success
+        from code_puppy.session_lifecycle import (
+            ResumeTargetError,
+            resolve_or_create_resume_target,
+        )
+        from code_puppy.session_storage import list_sessions, load_session
+
+        resume_target = args.resume
+        sessions_dir = Path(AUTOSAVE_DIR)
+
+        # Lazy-create is symmetric across modes: both headless and
+        # interactive accept ``-r missing-name`` and materialise an
+        # empty session. The typo-guard concern is preserved by the
+        # visible ``Created new session: NAME`` info line plus the
+        # empty ``message_count: 0`` initial state.
+        try:
+            session_name, session_dir, lazy_created = resolve_or_create_resume_target(
+                resume_target,
+                sessions_dir=sessions_dir,
+                allow_lazy_create=True,
+            )
+        except ResumeTargetError as resolve_exc:
+            emit_error(resolve_exc.message)
+            if resolve_exc.hint:
+                emit_info(resolve_exc.hint)
+            available = list_sessions(sessions_dir)
+            if available:
+                emit_info(f"Available sessions: {', '.join(available[:10])}")
+            sys.exit(1)
+
+        # When lazy-create fired, announce it so scripts and users can
+        # distinguish first-run creation from a normal resume.
+        if lazy_created:
+            emit_info(f"Created new session: {session_name}")
+
+        try:
+            history = load_session(session_name, session_dir)
+            agent = get_current_agent()
+            agent.set_message_history(history)
+            total_tokens = sum(agent.estimate_tokens_for_message(m) for m in history)
+
+            # Pin the singleton so periodic autosave AND headless save-back
+            # both update this named file in place. Replaces the old
+            # rotate_autosave_id() call, which under unification would
+            # actively undo the named-session wiring we want.
+            #
+            # Note: even when the user resumed via an absolute path
+            # (resolver branches 1 or 3), we pin the *stem* and let
+            # subsequent writes land in AUTOSAVE_DIR. That keeps cross-mode
+            # resume by name consistent; users who passed a one-off path
+            # can copy the resulting AUTOSAVE_DIR file back if they care.
+            pin_current_session_name(session_name)
+
+            # Record the resolved name for the headless save-back path below.
+            resolved_resume_session = session_name
+
+            if not lazy_created:
+                emit_success(
+                    f"Resumed: {len(history)} messages "
+                    f"({total_tokens} tokens) from {session_name}"
+                )
+        except Exception as e:
+            emit_error(f"Failed to resume from {resume_target}: {e}")
+            sys.exit(1)
 
     global shutdown_flag
     shutdown_flag = False
@@ -470,7 +503,11 @@ async def main():
             prompt_only_mode = False
 
         if prompt_only_mode:
-            await execute_single_prompt(initial_command, message_renderer)
+            await execute_single_prompt(
+                initial_command,
+                message_renderer,
+                session_name=resolved_resume_session,
+            )
         else:
             # Default to interactive mode (no args = same as -i)
             await interactive_mode(message_renderer, initial_command=initial_command)
@@ -652,55 +689,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
     # Autosave loading is now manual - use /autosave_load command
 
-    # Track this terminal's active session for /switch-agent auto-resume
-    record_terminal_session(get_current_autosave_session_name(), overwrite=False)
-
-    # Auto-run tutorial on first startup
-    try:
-        from code_puppy.command_line.onboarding_wizard import should_show_onboarding
-
-        if should_show_onboarding():
-            import concurrent.futures
-
-            from code_puppy.command_line.onboarding_wizard import run_onboarding_wizard
-            from code_puppy.config import set_model_name
-            from code_puppy.messaging import emit_info
-
-            from code_puppy.command_line.onboarding_wizard import (
-                require_model_setup_if_needed,
-            )
-
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(lambda: asyncio.run(run_onboarding_wizard()))
-                result = future.result(timeout=300)
-
-            if result == "chatgpt":
-                emit_info("🔐 Starting ChatGPT OAuth flow...")
-                from code_puppy.plugins.chatgpt_oauth.oauth_flow import run_oauth_flow
-
-                run_oauth_flow()
-                set_model_name("chatgpt-gpt-5.4")
-            elif result == "claude":
-                emit_info("🔐 Starting Claude Code OAuth flow...")
-                from code_puppy.plugins.claude_code_oauth.register_callbacks import (
-                    _perform_authentication,
-                )
-
-                _perform_authentication()
-                set_model_name("claude-code-claude-opus-4-7")
-            elif result == "completed":
-                emit_info("🎉 Tutorial complete! Happy coding!")
-            elif result == "skipped":
-                emit_info("⏭️ Tutorial skipped. Run /tutorial anytime!")
-
-            # No bundled default model anymore: if the user skipped OAuth they
-            # must add a model explicitly.
-            require_model_setup_if_needed(result)
-    except Exception as e:
-        from code_puppy.messaging import emit_warning
-
-        emit_warning(f"Tutorial auto-start failed: {e}")
-
+    record_terminal_session(get_current_session_name(), overwrite=False)
     # Track the current agent task for cancellation on quit
     current_agent_task = None
 
@@ -856,7 +845,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                                 interactive_autosave_picker,
                             )
                             from code_puppy.config import (
-                                set_current_autosave_from_session_name,
+                                pin_current_session_name,
                             )
                             from code_puppy.messaging import (
                                 emit_error,
@@ -882,7 +871,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                             agent.set_message_history(history)
 
                             # Set current autosave session
-                            set_current_autosave_from_session_name(chosen_session)
+                            pin_current_session_name(chosen_session)
 
                             total_tokens = sum(
                                 agent.estimate_tokens_for_message(msg)
@@ -1196,8 +1185,28 @@ async def run_prompt_with_attachments(
             return None, agent_task
 
 
-async def execute_single_prompt(prompt: str, message_renderer) -> None:
-    """Execute a single prompt and exit (for -p flag)."""
+async def execute_single_prompt(
+    prompt: str,
+    message_renderer,
+    *,
+    session_name: str | None = None,
+) -> None:
+    """Execute a single prompt and exit (for -p flag).
+
+    When ``session_name`` is supplied (i.e. the user passed ``-r NAME``),
+    history is persisted back to that named session in a ``finally`` block
+    so partial state still lands on cancel / error paths. The runtime
+    prunes interrupted tool calls before returning so the saved history is
+    coherent (see ``agents/_runtime.py`` -- the two ``_message_history``
+    commit/prune sites around lines 446 and 498).
+
+    Edge case worth knowing: when the agent returns ``(None, None)`` for an
+    empty-prompt scenario, the response emit is skipped but the ``finally``
+    still fires, producing a no-op idempotent rewrite of an existing
+    session (and a phantom ``post_autosave`` event for plugin authors who
+    count saves). Acceptable trade-off versus the complexity of a
+    'something-actually-ran' tracking flag.
+    """
     # Shell pass-through: !<cmd> bypasses the agent even in -p mode
     from code_puppy.command_line.shell_passthrough import (
         execute_shell_passthrough,
@@ -1206,9 +1215,26 @@ async def execute_single_prompt(prompt: str, message_renderer) -> None:
 
     if is_shell_passthrough(prompt):
         execute_shell_passthrough(prompt)
+        # Agent never ran — do NOT touch the named session, otherwise
+        # `-r mywork -p '!ls'` would clobber existing history with an empty
+        # save-back. Return before the try/finally so the save path is
+        # genuinely unreachable, not just guarded.
         return
 
-    from code_puppy.messaging import emit_info
+    from code_puppy.messaging import (
+        emit_error,
+        emit_info,
+        emit_warning,
+        get_message_bus,
+    )
+    from code_puppy.messaging.messages import AgentResponseMessage
+
+    # Hoist save-back imports here rather than into the ``finally`` block --
+    # if the user passed ``-r`` we will exercise these on every code path,
+    # and lazy-importing inside ``finally`` just hides the dependency without
+    # buying any actual startup savings (the module is already loaded).
+    from code_puppy.config import AUTOSAVE_DIR
+    from code_puppy.session_lifecycle import persist_named_session
 
     emit_info(f"Executing prompt: {prompt}")
 
@@ -1220,29 +1246,47 @@ async def execute_single_prompt(prompt: str, message_renderer) -> None:
             prompt,
             spinner_console=message_renderer.console,
         )
-        if result is None:
-            return
-
-        agent_response = result.output
-
-        # Emit structured message for proper markdown rendering
-        from code_puppy.messaging import get_message_bus
-        from code_puppy.messaging.messages import AgentResponseMessage
-
-        response_msg = AgentResponseMessage(
-            content=agent_response,
-            is_markdown=True,
-        )
-        get_message_bus().emit(response_msg)
+        if result is not None:
+            response_msg = AgentResponseMessage(
+                content=result.output,
+                is_markdown=True,
+            )
+            get_message_bus().emit(response_msg)
+
+            # Commit the completed turn (user prompt + assistant response)
+            # into the agent's history BEFORE the finally-block save-back.
+            # Without this, headless -r save-back persists only user prompts
+            # (the normal _do_run path never writes result.all_messages()
+            # back to agent._message_history), so resumed sessions feed the
+            # model a pile of unanswered prompts and it re-answers them all.
+            # Mirrors interactive_mode's post-run set_message_history call.
+            if hasattr(result, "all_messages"):
+                agent.set_message_history(list(result.all_messages()))
 
     except asyncio.CancelledError:
-        from code_puppy.messaging import emit_warning
-
         emit_warning("Execution cancelled by user")
     except Exception as e:
-        from code_puppy.messaging import emit_error
-
         emit_error(f"Error executing prompt: {str(e)}")
+    finally:
+        if session_name:
+            try:
+                persist_named_session(
+                    get_current_agent(),
+                    session_name,
+                    base_dir=Path(AUTOSAVE_DIR),
+                    # Headless -r save-back is automated (user passed a
+                    # flag and walked away) rather than an explicit
+                    # /dump_context-style intent, so it carries the same
+                    # auto_saved=True bit as autosave proper. Plugins
+                    # that filter on `metadata.auto_saved` get the right
+                    # signal.
+                    auto_saved=True,
+                )
+            except Exception as save_exc:
+                # The user's primary deliverable (the agent response) has
+                # already been emitted. Report the save failure but do not
+                # re-raise -- a save bug shouldn't mask a successful turn.
+                emit_error(f"Failed to save session {session_name}: {save_exc}")
 
 
 def _force_utf8_stdio():

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

@@ -48,8 +48,26 @@ def _get_session_metadata(base_dir: Path, session_name: str) -> dict:
         return {}
 
 
+def _is_auto_flavored(session_name: str) -> bool:
+    """Return True for system-generated session names.
+
+    Matches the ``auto_session_`` prefix reserved by
+    ``code_puppy.session_lifecycle.is_valid_session_name``. Pre-unification,
+    all autosaves carried this prefix; the unified-autosave migration introduces user-named
+    entries (from ``-r NAME``, ``/dump_context``, ``/load_context``) into
+    the same store, hence the need to distinguish.
+    """
+    return session_name.startswith("auto_session_")
+
+
 def _get_session_entries(base_dir: Path) -> List[Tuple[str, dict]]:
-    """Get all sessions with their metadata, sorted by timestamp."""
+    """Get all sessions with their metadata.
+
+    Returns entries grouped "named first, auto-flavored second", each group
+    sorted mtime-descending. Section headers (if any) are inserted at
+    render time -- see ``_render_menu_panel`` -- to keep this function's
+    return shape stable and pagination math straightforward.
+    """
     try:
         sessions = list_sessions(base_dir)
     except (FileNotFoundError, PermissionError):
@@ -75,8 +93,11 @@ def _get_session_entries(base_dir: Path) -> List[Tuple[str, dict]]:
                 return datetime.min
         return datetime.min
 
-    entries.sort(key=sort_key, reverse=True)
-    return entries
+    named = [e for e in entries if not _is_auto_flavored(e[0])]
+    auto = [e for e in entries if _is_auto_flavored(e[0])]
+    named.sort(key=sort_key, reverse=True)
+    auto.sort(key=sort_key, reverse=True)
+    return named + auto
 
 
 def _extract_last_user_message(history: list) -> str:
@@ -216,10 +237,24 @@ def _render_menu_panel(
         lines.append(("", "Cancel"))
         return lines
 
-    # Show sessions for current page
+    # Show sessions for current page. We inject visual section headers
+    # at named->auto boundaries within the visible page (and at the very
+    # top if the page starts in either section). Section headers do NOT
+    # consume entry indices -- they're cosmetic only -- so selection and
+    # pagination math stay untouched.
+    prev_section = None
     for i in range(start_idx, end_idx):
         session_name, metadata = entries[i]
         is_selected = i == selected_idx
+        section = "auto" if _is_auto_flavored(session_name) else "named"
+
+        if section != prev_section:
+            header = "Named sessions" if section == "named" else "Auto-saved sessions"
+            # Blank line between sections (skip for the very first one).
+            if prev_section is not None:
+                lines.append(("", "\n"))
+            lines.append(("fg:ansibrightcyan bold", f"  {header}\n"))
+            prev_section = section
 
         # Format timestamp
         timestamp = metadata.get("timestamp", "unknown")
@@ -232,11 +267,19 @@ def _render_menu_panel(
         # Format message count
         msg_count = metadata.get("message_count", "?")
 
+        # For named sessions, include the name so users can tell them
+        # apart at a glance. Auto-flavored sessions keep the existing
+        # timestamp+count summary -- the auto_session_* names are noise.
+        if section == "named":
+            label = f"{time_str} \u2022 {msg_count} msgs ({session_name})"
+        else:
+            label = f"{time_str} \u2022 {msg_count} msgs"
+
         # Highlight selected item
         if is_selected:
-            lines.append(("fg:ansibrightblack", f" > {time_str} • {msg_count} msgs"))
+            lines.append(("fg:ansibrightblack", f" > {label}"))
         else:
-            lines.append(("fg:ansibrightblack", f"   {time_str} • {msg_count} msgs"))
+            lines.append(("fg:ansibrightblack", f"   {label}"))
 
         lines.append(("", "\n"))
 

{code_puppy-0.0.577 → code_puppy-0.0.579}/code_puppy/command_line/session_commands.py

@@ -4,13 +4,12 @@ This module contains @register_command decorated handlers that are automatically
 discovered by the command registry system.
 """
 
-from datetime import datetime
 import logging
 from pathlib import Path
 
 from code_puppy.command_line.command_registry import register_command
-from code_puppy.config import CONTEXTS_DIR
-from code_puppy.session_storage import list_sessions, load_session, save_session
+from code_puppy.config import AUTOSAVE_DIR
+from code_puppy.session_storage import list_sessions, load_session
 
 logger = logging.getLogger(__name__)
 
@@ -64,25 +63,23 @@ def get_commands_help():
 def handle_session_command(command: str) -> bool:
     """Handle /session command."""
     from code_puppy.config import (
-        AUTOSAVE_DIR,
-        get_current_autosave_id,
-        get_current_autosave_session_name,
-        rotate_autosave_id,
+        get_current_session_name,
+        rotate_session_name,
     )
     from code_puppy.messaging import emit_info, emit_success, emit_warning
 
     tokens = command.split()
 
     if len(tokens) == 1 or tokens[1] == "id":
-        sid = get_current_autosave_id()
+        session_name = get_current_session_name()
         emit_info(
-            f"[bold magenta]Autosave Session[/bold magenta]: {sid}\n"
-            f"Files prefix: {Path(AUTOSAVE_DIR) / get_current_autosave_session_name()}"
+            f"[bold magenta]Autosave Session[/bold magenta]: {session_name}\n"
+            f"Files prefix: {Path(AUTOSAVE_DIR) / session_name}"
         )
         return True
     if tokens[1] == "new":
-        new_sid = rotate_autosave_id()
-        emit_success(f"New autosave session id: {new_sid}")
+        new_name = rotate_session_name()
+        emit_success(f"New autosave session: {new_name}")
         return True
     emit_warning("Usage: /session [id|new]")
     return True
@@ -350,7 +347,11 @@ def handle_quick_resume_command(command: str) -> bool:
 def handle_dump_context_command(command: str) -> bool:
     """Dump message history to a file."""
     from code_puppy.agents.agent_manager import get_current_agent
-    from code_puppy.messaging import emit_error, emit_success, emit_warning
+    from code_puppy.messaging import emit_error, emit_warning
+    from code_puppy.session_lifecycle import (
+        is_valid_session_name,
+        persist_named_session,
+    )
 
     tokens = command.split()
     if len(tokens) != 2:
@@ -358,24 +359,38 @@ def handle_dump_context_command(command: str) -> bool:
         return True
 
     session_name = tokens[1]
-    agent = get_current_agent()
-    history = agent.get_message_history()
+    # Enforce reserved-prefix + slug rules at every user-input write site
+    # (the resolver enforces them for ``-r NAME``; this is the parallel
+    # gate for ``/dump_context``). Without it, /dump_context bypasses
+    # the validator that ``-r`` runs and lets a user squat the
+    # ``auto_session_`` namespace or smuggle in a path-traversal name.
+    if not is_valid_session_name(session_name, allow_reserved_prefix=False):
+        emit_error(
+            f"Invalid session name: {session_name!r}. "
+            "Session names must be 1-128 chars of [A-Za-z0-9._-] "
+            "and may not start with 'auto_session_' (reserved)."
+        )
+        return True
 
-    if not history:
+    agent = get_current_agent()
+    if not agent.get_message_history():
         emit_warning("No message history to dump!")
         return True
 
     try:
-        metadata = save_session(
-            history=history,
-            session_name=session_name,
-            base_dir=Path(CONTEXTS_DIR),
-            timestamp=datetime.now().isoformat(),
-            token_estimator=agent.estimate_tokens_for_message,
-        )
-        emit_success(
-            f"✅ Context saved: {metadata.message_count} messages ({metadata.total_tokens} tokens)\n"
-            f"📁 Files: {metadata.pickle_path}, {metadata.metadata_path}"
+        # The user-facing success line is preserved verbatim via
+        # ``success_message_template`` so /dump_context UX doesn't
+        # regress. The silent save-back paths (``-r``, periodic
+        # autosave) omit the template and stay quiet.
+        persist_named_session(
+            agent,
+            session_name,
+            base_dir=Path(AUTOSAVE_DIR),
+            success_message_template=(
+                "\u2705 Context saved: {message_count} messages "
+                "({total_tokens} tokens)\n"
+                "\U0001f4c1 Files: {pickle_path}, {metadata_path}"
+            ),
         )
         return True
 
@@ -392,10 +407,8 @@ def handle_dump_context_command(command: str) -> bool:
 )
 def handle_load_context_command(command: str) -> bool:
     """Load message history from a file."""
-    from rich.text import Text
-
     from code_puppy.agents.agent_manager import get_current_agent
-    from code_puppy.config import rotate_autosave_id
+    from code_puppy.config import rotate_session_name
     from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
 
     tokens = command.split()
@@ -404,14 +417,14 @@ def handle_load_context_command(command: str) -> bool:
         return True
 
     session_name = tokens[1]
-    contexts_dir = Path(CONTEXTS_DIR)
-    session_path = contexts_dir / f"{session_name}.pkl"
+    sessions_dir = Path(AUTOSAVE_DIR)
+    session_path = sessions_dir / f"{session_name}.pkl"
 
     try:
-        history = load_session(session_name, contexts_dir)
+        history = load_session(session_name, sessions_dir)
     except FileNotFoundError:
         emit_error(f"Context file not found: {session_path}")
-        available = list_sessions(contexts_dir)
+        available = list_sessions(sessions_dir)
         if available:
             emit_info(f"Available contexts: {', '.join(available)}")
         return True
@@ -423,22 +436,41 @@ def handle_load_context_command(command: str) -> bool:
     agent.set_message_history(history)
     total_tokens = sum(agent.estimate_tokens_for_message(m) for m in history)
 
-    # Rotate autosave id to avoid overwriting any existing autosave
-    try:
-        new_id = rotate_autosave_id()
-        autosave_info = Text.from_markup(
-            f"\n[dim]Autosave session rotated to: {new_id}[/dim]"
-        )
-    except Exception:
-        autosave_info = Text("")
+    # Rotate the singleton to a fresh ``auto_session_<TS>`` so subsequent
+    # autosaves do NOT overwrite the loaded snapshot. This asymmetry with
+    # ``-r NAME`` (which pins and saves back in place) is INTENTIONAL --
+    # the two verbs encode two different intents:
+    #
+    #   * ``/dump_context NAME`` + ``/load_context NAME`` are a snapshot
+    #     pair (think ``pg_dump`` / ``pg_restore``, save games, git
+    #     stash). The named file is a stable reference point; loading
+    #     it lets you inspect / branch from it without dirtying the
+    #     original.
+    #   * ``-r NAME`` / ``--resume NAME`` is a continuation verb (pick
+    #     up where you left off). That path pins and saves back.
+    #
+    # Origin: commit ``cc04629b`` (Mike Pfaffenberger, 2025-10-11)
+    # introduced this rotate-on-load behavior as a deliberate design
+    # choice; the commit message explicitly says "Automatically rotate
+    # session ID when loading saved context to prevent overwrites." The
+    # ``-r`` flag was added 4 months later (commit ``92bb0f90``) and
+    # the asymmetry was preserved -- on purpose. Do NOT "unify" these
+    # two paths in the name of symmetry; you'd be deleting the encoded
+    # distinction between snapshot-load and continuation-resume.
+    #
+    # If a user wants to continue working on the loaded snapshot in
+    # place, the explicit move is ``/load_context NAME`` followed by
+    # ``/dump_context NAME`` later -- or relaunch via ``-r NAME``.
+    new_autosave_id = rotate_session_name()
 
-    # Build the success message with proper Text concatenation
-    success_msg = Text(
-        f"✅ Context loaded: {len(history)} messages ({total_tokens} tokens)\n"
-        f"📁 From: {session_path}"
+    emit_success(
+        f"\u2705 Context loaded: {len(history)} messages "
+        f"({total_tokens} tokens)\n"
+        f"\U0001f4c1 From: {session_path}\n"
+        f"\U0001f504 Autosave rotated to: {new_autosave_id} "
+        f"(snapshot at {session_path.name} is preserved; further "
+        f"autosaves land in the new session)"
     )
-    success_msg.append_text(autosave_info)
-    emit_success(success_msg)
 
     # Display recent message history for context
     from code_puppy.command_line.autosave_menu import display_resumed_history