klaude-code 1.2.19__py3-none-any.whl → 1.2.21__py3-none-any.whl

klaude_code/core/executor.py

@@ -8,10 +8,12 @@ handling operations submitted from the CLI and coordinating with agents.
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Callable
+import subprocess
+from collections.abc import Callable
 from dataclasses import dataclass
+from pathlib import Path
 
-from klaude_code.command import InputAction, InputActionType, dispatch_command
+from klaude_code.command import dispatch_command
 from klaude_code.config import load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
@@ -20,6 +22,7 @@ from klaude_code.llm.registry import create_llm_client
 from klaude_code.protocol import commands, events, model, op
 from klaude_code.protocol.op_handler import OperationHandler
 from klaude_code.protocol.sub_agent import SubAgentResult
+from klaude_code.session.export import build_export_html, get_default_export_path
 from klaude_code.session.session import Session
 from klaude_code.trace import DebugType, log_debug
 
@@ -76,174 +79,6 @@ class TaskManager:
         self._tasks.clear()
 
 
-class InputActionExecutor:
-    """Execute input actions returned by the command dispatcher.
-
-    This helper encapsulates the logic for running the main agent task,
-    applying model changes, and clearing conversations so that
-    :class:`ExecutorContext` stays focused on operation dispatch.
-    """
-
-    def __init__(
-        self,
-        task_manager: TaskManager,
-        sub_agent_manager: SubAgentManager,
-        model_profile_provider: ModelProfileProvider,
-        emit_event: Callable[[events.Event], Awaitable[None]],
-        on_model_change: Callable[[str], None] | None = None,
-    ) -> None:
-        self._task_manager = task_manager
-        self._sub_agent_manager = sub_agent_manager
-        self._model_profile_provider = model_profile_provider
-        self._emit_event = emit_event
-        self._on_model_change = on_model_change
-
-    async def run(self, action: InputAction, operation: op.UserInputOperation, agent: Agent) -> None:
-        """Dispatch and execute a single input action."""
-
-        if operation.session_id is None:
-            raise ValueError("session_id cannot be None for input actions")
-
-        session_id = operation.session_id
-
-        if action.type == InputActionType.RUN_AGENT:
-            await self._run_agent_action(action, operation, agent, session_id)
-            return
-
-        if action.type == InputActionType.CHANGE_MODEL:
-            if not action.model_name:
-                raise ValueError("ChangeModel action requires model_name")
-
-            await self._apply_model_change(agent, action.model_name)
-            return
-
-        if action.type == InputActionType.CLEAR:
-            await self._apply_clear(agent)
-            return
-
-        raise ValueError(f"Unsupported input action type: {action.type}")
-
-    async def _run_agent_action(
-        self,
-        action: InputAction,
-        operation: op.UserInputOperation,
-        agent: Agent,
-        session_id: str,
-    ) -> None:
-        task_input = model.UserInputPayload(text=action.text, images=operation.input.images)
-
-        existing_active = self._task_manager.get(operation.id)
-        if existing_active is not None and not existing_active.task.done():
-            raise RuntimeError(f"Active task already registered for operation {operation.id}")
-
-        task: asyncio.Task[None] = asyncio.create_task(
-            self._run_agent_task(agent, task_input, operation.id, session_id)
-        )
-        self._task_manager.register(operation.id, task, session_id)
-
-    async def _run_agent_task(
-        self,
-        agent: Agent,
-        user_input: model.UserInputPayload,
-        task_id: str,
-        session_id: str,
-    ) -> None:
-        """Run the main agent task and forward events to the UI."""
-
-        try:
-            log_debug(
-                f"Starting agent task {task_id} for session {session_id}",
-                style="green",
-                debug_type=DebugType.EXECUTION,
-            )
-
-            async def _runner(state: model.SubAgentState) -> SubAgentResult:
-                return await self._sub_agent_manager.run_sub_agent(agent, state)
-
-            token = current_run_subtask_callback.set(_runner)
-            try:
-                async for event in agent.run_task(user_input):
-                    await self._emit_event(event)
-            finally:
-                current_run_subtask_callback.reset(token)
-
-        except asyncio.CancelledError:
-            log_debug(
-                f"Agent task {task_id} was cancelled",
-                style="yellow",
-                debug_type=DebugType.EXECUTION,
-            )
-            await self._emit_event(events.TaskFinishEvent(session_id=session_id, task_result="task cancelled"))
-
-        except Exception as e:
-            import traceback
-
-            log_debug(
-                f"Agent task {task_id} failed: {e!s}",
-                style="red",
-                debug_type=DebugType.EXECUTION,
-            )
-            log_debug(traceback.format_exc(), style="red", debug_type=DebugType.EXECUTION)
-            await self._emit_event(
-                events.ErrorEvent(
-                    error_message=f"Agent task failed: [{e.__class__.__name__}] {e!s}",
-                    can_retry=False,
-                )
-            )
-
-        finally:
-            self._task_manager.remove(task_id)
-            log_debug(
-                f"Cleaned up agent task {task_id}",
-                style="cyan",
-                debug_type=DebugType.EXECUTION,
-            )
-
-    async def _apply_model_change(self, agent: Agent, model_name: str) -> None:
-        """Change the model used by the active agent and notify the UI."""
-
-        config = load_config()
-        if config is None:
-            raise ValueError("Configuration must be initialized before changing model")
-
-        llm_config = config.get_model_config(model_name)
-        llm_client = create_llm_client(llm_config)
-        agent.set_model_profile(self._model_profile_provider.build_profile(llm_client))
-
-        agent.session.model_config_name = model_name
-        agent.session.model_thinking = llm_config.thinking
-
-        developer_item = model.DeveloperMessageItem(
-            content=f"switched to model: {model_name}",
-            command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
-        )
-        agent.session.append_history([developer_item])
-
-        await self._emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-        await self._emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
-
-        if self._on_model_change is not None:
-            self._on_model_change(llm_client.model_name)
-
-    async def _apply_clear(self, agent: Agent) -> None:
-        """Start a new conversation for the agent and notify the UI."""
-
-        new_session = Session(work_dir=agent.session.work_dir)
-        new_session.model_name = agent.session.model_name
-        new_session.model_config_name = agent.session.model_config_name
-        new_session.model_thinking = agent.session.model_thinking
-
-        agent.session = new_session
-        agent.session.save()
-
-        developer_item = model.DeveloperMessageItem(
-            content="started new conversation",
-            command_output=model.CommandOutput(command_name=commands.CommandName.CLEAR),
-        )
-
-        await self._emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
-
-
 class ExecutorContext:
     """
     Context object providing shared state and operations for the executor.
@@ -269,13 +104,7 @@ class ExecutorContext:
 
         self.task_manager = TaskManager()
         self.sub_agent_manager = SubAgentManager(event_queue, llm_clients, resolved_profile_provider)
-        self._action_executor = InputActionExecutor(
-            task_manager=self.task_manager,
-            sub_agent_manager=self.sub_agent_manager,
-            model_profile_provider=resolved_profile_provider,
-            emit_event=self.emit_event,
-            on_model_change=on_model_change,
-        )
+        self._on_model_change = on_model_change
         self._agent: Agent | None = None
 
     async def emit_event(self, event: events.Event) -> None:
@@ -347,7 +176,7 @@ class ExecutorContext:
         await self._ensure_agent(operation.session_id)
 
     async def handle_user_input(self, operation: op.UserInputOperation) -> None:
-        """Handle a user input operation by running it through an agent."""
+        """Handle a user input operation by dispatching it into operations."""
 
         if operation.session_id is None:
             raise ValueError("session_id cannot be None")
@@ -356,29 +185,187 @@ class ExecutorContext:
         agent = await self._ensure_agent(session_id)
         user_input = operation.input
 
-        # emit user input event
+        # Emit the original user input to UI (even if the persisted text differs).
         await self.emit_event(
             events.UserMessageEvent(content=user_input.text, session_id=session_id, images=user_input.images)
         )
 
-        result = await dispatch_command(user_input.text, agent)
+        result = await dispatch_command(user_input, agent, submission_id=operation.id)
+        ops: list[op.Operation] = list(result.operations or [])
 
-        actions: list[InputAction] = list(result.actions or [])
+        run_ops = [candidate for candidate in ops if isinstance(candidate, op.RunAgentOperation)]
+        if len(run_ops) > 1:
+            raise ValueError("Multiple RunAgentOperation results are not supported")
 
-        has_run_agent_action = any(action.type is InputActionType.RUN_AGENT for action in actions)
-        if not has_run_agent_action:
-            # No async agent task will run, append user message directly
-            agent.session.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
+        persisted_user_input = run_ops[0].input if run_ops else user_input
+        agent.session.append_history(
+            [model.UserMessageItem(content=persisted_user_input.text, images=persisted_user_input.images)]
+        )
 
         if result.events:
-            agent.session.append_history(
-                [evt.item for evt in result.events if isinstance(evt, events.DeveloperMessageEvent)]
-            )
             for evt in result.events:
+                if isinstance(evt, events.DeveloperMessageEvent):
+                    agent.session.append_history([evt.item])
                 await self.emit_event(evt)
 
-        for action in actions:
-            await self._action_executor.run(action, operation, agent)
+        for operation_item in ops:
+            await operation_item.execute(handler=self)
+
+    async def handle_run_agent(self, operation: op.RunAgentOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        existing_active = self.task_manager.get(operation.id)
+        if existing_active is not None and not existing_active.task.done():
+            raise RuntimeError(f"Active task already registered for operation {operation.id}")
+        task: asyncio.Task[None] = asyncio.create_task(
+            self._run_agent_task(agent, operation.input, operation.id, operation.session_id)
+        )
+        self.task_manager.register(operation.id, task, operation.session_id)
+
+    async def handle_change_model(self, operation: op.ChangeModelOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        config = load_config()
+        if config is None:
+            raise ValueError("Configuration must be initialized before changing model")
+
+        llm_config = config.get_model_config(operation.model_name)
+        llm_client = create_llm_client(llm_config)
+        agent.set_model_profile(self.model_profile_provider.build_profile(llm_client))
+
+        agent.session.model_config_name = operation.model_name
+        agent.session.model_thinking = llm_config.thinking
+
+        developer_item = model.DeveloperMessageItem(
+            content=f"switched to model: {operation.model_name}",
+            command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
+        )
+        agent.session.append_history([developer_item])
+
+        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
+
+        if self._on_model_change is not None:
+            self._on_model_change(llm_client.model_name)
+
+    async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        new_session = Session.create(work_dir=agent.session.work_dir)
+        new_session.model_name = agent.session.model_name
+        new_session.model_config_name = agent.session.model_config_name
+        new_session.model_thinking = agent.session.model_thinking
+        agent.session = new_session
+
+        developer_item = model.DeveloperMessageItem(
+            content="started new conversation",
+            command_output=model.CommandOutput(command_name=commands.CommandName.CLEAR),
+        )
+        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+
+    async def handle_export_session(self, operation: op.ExportSessionOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        try:
+            output_path = self._resolve_export_output_path(operation.output_path, agent.session)
+            html_doc = self._build_export_html(agent)
+            await asyncio.to_thread(output_path.parent.mkdir, parents=True, exist_ok=True)
+            await asyncio.to_thread(output_path.write_text, html_doc, "utf-8")
+            await asyncio.to_thread(self._open_file, output_path)
+            developer_item = model.DeveloperMessageItem(
+                content=f"Session exported and opened: {output_path}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        except Exception as exc:  # pragma: no cover
+            import traceback
+
+            developer_item = model.DeveloperMessageItem(
+                content=f"Failed to export session: {exc}\n{traceback.format_exc()}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT, is_error=True),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+
+    async def _run_agent_task(
+        self,
+        agent: Agent,
+        user_input: model.UserInputPayload,
+        task_id: str,
+        session_id: str,
+    ) -> None:
+        try:
+            log_debug(
+                f"Starting agent task {task_id} for session {session_id}",
+                style="green",
+                debug_type=DebugType.EXECUTION,
+            )
+
+            async def _runner(state: model.SubAgentState) -> SubAgentResult:
+                return await self.sub_agent_manager.run_sub_agent(agent, state)
+
+            token = current_run_subtask_callback.set(_runner)
+            try:
+                async for event in agent.run_task(user_input):
+                    await self.emit_event(event)
+            finally:
+                current_run_subtask_callback.reset(token)
+
+        except asyncio.CancelledError:
+            log_debug(
+                f"Agent task {task_id} was cancelled",
+                style="yellow",
+                debug_type=DebugType.EXECUTION,
+            )
+            await self.emit_event(events.TaskFinishEvent(session_id=session_id, task_result="task cancelled"))
+
+        except Exception as e:
+            import traceback
+
+            log_debug(
+                f"Agent task {task_id} failed: {e!s}",
+                style="red",
+                debug_type=DebugType.EXECUTION,
+            )
+            log_debug(traceback.format_exc(), style="red", debug_type=DebugType.EXECUTION)
+            await self.emit_event(
+                events.ErrorEvent(
+                    error_message=f"Agent task failed: [{e.__class__.__name__}] {e!s}",
+                    can_retry=False,
+                )
+            )
+        finally:
+            self.task_manager.remove(task_id)
+            log_debug(
+                f"Cleaned up agent task {task_id}",
+                style="cyan",
+                debug_type=DebugType.EXECUTION,
+            )
+
+    def _resolve_export_output_path(self, raw: str | None, session: Session) -> Path:
+        trimmed = (raw or "").strip()
+        if trimmed:
+            candidate = Path(trimmed).expanduser()
+            if not candidate.is_absolute():
+                candidate = Path(session.work_dir) / candidate
+            if candidate.suffix.lower() != ".html":
+                candidate = candidate.with_suffix(".html")
+            return candidate
+        return get_default_export_path(session)
+
+    def _build_export_html(self, agent: Agent) -> str:
+        profile = agent.profile
+        system_prompt = (profile.system_prompt if profile else "") or ""
+        tool_schemas = profile.tools if profile else []
+        model_name = profile.llm_client.model_name if profile else "unknown"
+        return build_export_html(agent.session, system_prompt, tool_schemas, model_name)
+
+    def _open_file(self, path: Path) -> None:
+        try:
+            subprocess.run(["open", str(path)], check=True)
+        except FileNotFoundError as exc:  # pragma: no cover
+            msg = "`open` command not found; please open the HTML manually."
+            raise RuntimeError(msg) from exc
+        except subprocess.CalledProcessError as exc:  # pragma: no cover
+            msg = f"Failed to open HTML with `open`: {exc}"
+            raise RuntimeError(msg) from exc
 
     async def handle_interrupt(self, operation: op.InterruptOperation) -> None:
         """Handle an interrupt by invoking agent.cancel() and cancelling tasks."""

klaude_code/core/manager/sub_agent_manager.py

@@ -80,6 +80,9 @@ Only the content passed to `report_back` will be returned to user.\
             result: str = ""
             task_metadata: model.TaskMetadata | None = None
             sub_agent_input = model.UserInputPayload(text=state.sub_agent_prompt, images=None)
+            child_session.append_history(
+                [model.UserMessageItem(content=sub_agent_input.text, images=sub_agent_input.images)]
+            )
             async for event in child_agent.run_task(sub_agent_input):
                 # Capture TaskFinishEvent content for return
                 if isinstance(event, events.TaskFinishEvent):

klaude_code/core/prompt.py

@@ -12,6 +12,7 @@ COMMAND_DESCRIPTIONS: dict[str, str] = {
     "fd": "simple and fast alternative to find",
     "tree": "directory listing as a tree",
     "sg": "ast-grep - AST-aware code search",
+    "jj": "jujutsu - Git-compatible version control system",
 }
 
 # Mapping from logical prompt keys to resource file paths under the core/prompt directory.
@@ -57,18 +58,20 @@ def _build_env_info(model_name: str) -> str:
     cwd = Path.cwd()
     today = datetime.datetime.now().strftime("%Y-%m-%d")
     is_git_repo = (cwd / ".git").exists()
+    is_empty_dir = not any(cwd.iterdir())
 
     available_tools: list[str] = []
     for command, desc in COMMAND_DESCRIPTIONS.items():
         if shutil.which(command) is not None:
             available_tools.append(f"{command}: {desc}")
 
+    cwd_display = f"{cwd} (empty)" if is_empty_dir else str(cwd)
     env_lines: list[str] = [
         "",
         "",
         "Here is useful information about the environment you are running in:",
         "<env>",
-        f"Working directory: {cwd}",
+        f"Working directory: {cwd_display}",
         f"Today's Date: {today}",
         f"Is directory a git repo: {is_git_repo}",
         f"You are powered by the model: {model_name}",

klaude_code/core/prompts/prompt-sub-agent-web.md

@@ -1,4 +1,4 @@
-You are a web research agent that searches and fetches web content to provide up-to-date information.
+You are a web research subagent that searches and fetches web content to provide up-to-date information as part of team.
 
 ## Available Tools
 
@@ -28,7 +28,7 @@ Balance efficiency with thoroughness. For open-ended questions (e.g., "recommend
 - Avoid repeating similar queries - they won't yield new results
 - NEVER use '-', 'site:', or quotes unless explicitly asked
 - Include year/date for time-sensitive queries (check "Today's date" in <env>), don't limit yourself to your knowledge cutoff date
-- Use WebFetch to get full content - search snippets are often insufficient
+- Always use WebFetch to get the complete contents of websites - search snippets are often insufficient
 - Follow relevant links on pages with WebFetch
 - If truncated results are saved to local files, use grep/read to explore
 
@@ -48,4 +48,4 @@ You MUST end every response with a "Sources:" section listing all URLs with thei
 
 Sources:
 - [Source Title](https://example.com) -> /tmp/klaude/web/example_com-123456.md
-- [Another Source](https://example.com/page) -> /tmp/klaude/web/example_com_page-123456.md
+- [Another Source](https://example.com/page) -> /tmp/klaude/web/example_com_page-123456.md

klaude_code/core/reminders.py

@@ -1,6 +1,7 @@
 import re
 import shlex
 from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
 from pathlib import Path
 
 from pydantic import BaseModel
@@ -31,6 +32,45 @@ def get_last_new_user_input(session: Session) -> str | None:
     return "\n\n".join(result)
 
 
+@dataclass
+class AtPatternSource:
+    """Represents an @ pattern with its source file (if from a memory file)."""
+
+    pattern: str
+    mentioned_in: str | None = None
+
+
+def get_at_patterns_with_source(session: Session) -> list[AtPatternSource]:
+    """Get @ patterns from last user input and developer messages, preserving source info."""
+    patterns: list[AtPatternSource] = []
+
+    for item in reversed(session.conversation_history):
+        if isinstance(item, model.ToolResultItem):
+            break
+
+        if isinstance(item, model.UserMessageItem):
+            content = item.content or ""
+            if "@" in content:
+                for match in AT_FILE_PATTERN.finditer(content):
+                    path_str = match.group("quoted") or match.group("plain")
+                    if path_str:
+                        patterns.append(AtPatternSource(pattern=path_str, mentioned_in=None))
+            break
+
+        if isinstance(item, model.DeveloperMessageItem):
+            content = item.content or ""
+            if "@" not in content:
+                continue
+            # Use first memory_path as the source if available
+            source = item.memory_paths[0] if item.memory_paths else None
+            for match in AT_FILE_PATTERN.finditer(content):
+                path_str = match.group("quoted") or match.group("plain")
+                if path_str:
+                    patterns.append(AtPatternSource(pattern=path_str, mentioned_in=source))
+
+    return patterns
+
+
 async def _load_at_file_recursive(
     session: Session,
     pattern: str,
@@ -99,33 +139,22 @@ async def at_file_reader_reminder(
     session: Session,
 ) -> model.DeveloperMessageItem | None:
     """Parse @foo/bar to read, with recursive loading of nested @ references"""
-    last_user_input = get_last_new_user_input(session)
-    if not last_user_input or "@" not in last_user_input:
-        return None
-
-    at_patterns: list[str] = []
-
-    for match in AT_FILE_PATTERN.finditer(last_user_input):
-        quoted = match.group("quoted")
-        plain = match.group("plain")
-        path_str = quoted if quoted is not None else plain
-        if path_str:
-            at_patterns.append(path_str)
-
-    if len(at_patterns) == 0:
+    at_pattern_sources = get_at_patterns_with_source(session)
+    if not at_pattern_sources:
         return None
 
     at_files: dict[str, model.AtPatternParseResult] = {}  # path -> content
     collected_images: list[model.ImageURLPart] = []
     visited: set[str] = set()
 
-    for pattern in at_patterns:
+    for source in at_pattern_sources:
         await _load_at_file_recursive(
             session,
-            pattern,
+            source.pattern,
             at_files,
             collected_images,
             visited,
+            mentioned_in=source.mentioned_in,
         )
 
     if len(at_files) == 0:
@@ -231,9 +260,9 @@ async def file_changed_externally_reminder(
     changed_files: list[tuple[str, str, list[model.ImageURLPart] | None]] = []
     collected_images: list[model.ImageURLPart] = []
     if session.file_tracker and len(session.file_tracker) > 0:
-        for path, mtime in session.file_tracker.items():
+        for path, status in session.file_tracker.items():
             try:
-                if Path(path).stat().st_mtime > mtime:
+                if Path(path).stat().st_mtime > status.mtime:
                     context_token = set_tool_context_from_session(session)
                     try:
                         tool_result = await ReadTool.call_with_args(
@@ -282,6 +311,7 @@ def get_memory_paths() -> list[tuple[Path, str]]:
         ),
         (Path.cwd() / "AGENTS.md", "project instructions, checked into the codebase"),
         (Path.cwd() / "CLAUDE.md", "project instructions, checked into the codebase"),
+        (Path.cwd() / ".claude" / "CLAUDE.md", "project instructions, checked into the codebase"),
     ]
 
 
@@ -313,16 +343,32 @@ async def image_reminder(session: Session) -> model.DeveloperMessageItem | None:
     )
 
 
+def _is_memory_loaded(session: Session, path: str) -> bool:
+    """Check if a memory file has already been loaded (tracked with is_memory=True)."""
+    status = session.file_tracker.get(path)
+    return status is not None and status.is_memory
+
+
+def _mark_memory_loaded(session: Session, path: str) -> None:
+    """Mark a file as loaded memory in file_tracker."""
+    try:
+        mtime = Path(path).stat().st_mtime
+    except (OSError, FileNotFoundError):
+        mtime = 0.0
+    session.file_tracker[path] = model.FileStatus(mtime=mtime, is_memory=True)
+
+
 async def memory_reminder(session: Session) -> model.DeveloperMessageItem | None:
     """CLAUDE.md AGENTS.md"""
     memory_paths = get_memory_paths()
     memories: list[Memory] = []
     for memory_path, instruction in memory_paths:
-        if memory_path.exists() and memory_path.is_file() and str(memory_path) not in session.loaded_memory:
+        path_str = str(memory_path)
+        if memory_path.exists() and memory_path.is_file() and not _is_memory_loaded(session, path_str):
             try:
                 text = memory_path.read_text()
-                session.loaded_memory.append(str(memory_path))
-                memories.append(Memory(path=str(memory_path), instruction=instruction, content=text))
+                _mark_memory_loaded(session, path_str)
+                memories.append(Memory(path=path_str, instruction=instruction, content=text))
             except (PermissionError, UnicodeDecodeError, OSError):
                 continue
     if len(memories) > 0:
@@ -358,7 +404,7 @@ async def last_path_memory_reminder(
     """Load CLAUDE.md/AGENTS.md from directories containing files in file_tracker.
 
     Uses session.file_tracker to detect accessed paths (works for both tool calls
-    and @ file references). Uses session.loaded_memory to avoid duplicate loading.
+    and @ file references). Checks is_memory flag to avoid duplicate loading.
     """
     if not session.file_tracker:
         return None
@@ -367,7 +413,6 @@ async def last_path_memory_reminder(
     memories: list[Memory] = []
 
     cwd = Path.cwd().resolve()
-    loaded_set: set[str] = set(session.loaded_memory)
     seen_memory_files: set[str] = set()
 
     for p_str in paths:
@@ -395,15 +440,14 @@ async def last_path_memory_reminder(
             for fname in MEMORY_FILE_NAMES:
                 mem_path = current_dir / fname
                 mem_path_str = str(mem_path)
-                if mem_path_str in seen_memory_files or mem_path_str in loaded_set:
+                if mem_path_str in seen_memory_files or _is_memory_loaded(session, mem_path_str):
                     continue
                 if mem_path.exists() and mem_path.is_file():
                     try:
                         text = mem_path.read_text()
                     except (PermissionError, UnicodeDecodeError, OSError):
                         continue
-                    session.loaded_memory.append(mem_path_str)
-                    loaded_set.add(mem_path_str)
+                    _mark_memory_loaded(session, mem_path_str)
                     seen_memory_files.add(mem_path_str)
                     memories.append(
                         Memory(