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

klaude_code/core/executor.py

@@ -8,15 +8,19 @@ handling operations submitted from the CLI and coordinating with agents.
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 
 from klaude_code.command import InputAction, InputActionType, dispatch_command
+from klaude_code.config import load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
-from klaude_code.core.manager import AgentManager, LLMClients, SubAgentManager
+from klaude_code.core.manager import LLMClients, SubAgentManager
 from klaude_code.core.tool import current_run_subtask_callback
-from klaude_code.protocol import events, model, op
+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.session import Session
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -72,6 +76,174 @@ 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.
@@ -87,34 +259,92 @@ class ExecutorContext:
         event_queue: asyncio.Queue[events.Event],
         llm_clients: LLMClients,
         model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
     ):
         self.event_queue: asyncio.Queue[events.Event] = event_queue
+        self.llm_clients: LLMClients = llm_clients
 
         resolved_profile_provider = model_profile_provider or DefaultModelProfileProvider()
         self.model_profile_provider: ModelProfileProvider = resolved_profile_provider
 
-        # Delegate responsibilities to helper components
-        self.agent_manager = AgentManager(event_queue, llm_clients, resolved_profile_provider)
         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._agent: Agent | None = None
 
     async def emit_event(self, event: events.Event) -> None:
         """Emit an event to the UI display system."""
         await self.event_queue.put(event)
 
+    def current_session_id(self) -> str | None:
+        """Return the primary active session id, if any.
+
+        This is a convenience wrapper used by the CLI, which conceptually
+        operates on a single interactive session per process.
+        """
+
+        agent = self._agent
+        if agent is None:
+            return None
+        return agent.session.id
+
     @property
-    def active_agents(self) -> dict[str, Agent]:
-        """Expose currently active agents keyed by session id.
+    def current_agent(self) -> Agent | None:
+        """Return the currently active agent, if any."""
 
-        This property preserves the previous public attribute used by the
-        CLI status provider while delegating storage to :class:`AgentManager`.
+        return self._agent
+
+    async def _ensure_agent(self, session_id: str | None = None) -> Agent:
+        """Return the active agent, creating or loading a session as needed.
+
+        If ``session_id`` is ``None``, a new session is created with an
+        auto-generated ID. If provided, the executor attempts to resume the
+        session from disk or creates a new one if not found.
         """
 
-        return self.agent_manager.all_active_agents()
+        # Fast-path: reuse current agent when the session id already matches.
+        if session_id is not None and self._agent is not None and self._agent.session.id == session_id:
+            return self._agent
+
+        session = Session.create() if session_id is None else Session.load(session_id)
+
+        if (
+            session.model_thinking is not None
+            and session.model_name
+            and session.model_name == self.llm_clients.main.model_name
+        ):
+            self.llm_clients.main.get_llm_config().thinking = session.model_thinking
+
+        profile = self.model_profile_provider.build_profile(self.llm_clients.main)
+        agent = Agent(session=session, profile=profile)
+
+        async for evt in agent.replay_history():
+            await self.emit_event(evt)
+
+        await self.emit_event(
+            events.WelcomeEvent(
+                work_dir=str(session.work_dir),
+                llm_config=self.llm_clients.main.get_llm_config(),
+            )
+        )
+
+        self._agent = agent
+        log_debug(
+            f"Initialized agent for session: {session.id}",
+            style="cyan",
+            debug_type=DebugType.EXECUTION,
+        )
+        return agent
 
     async def handle_init_agent(self, operation: op.InitAgentOperation) -> None:
         """Initialize an agent for a session and replay history to UI."""
-        await self.agent_manager.ensure_agent(operation.session_id)
+        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."""
@@ -123,7 +353,7 @@ class ExecutorContext:
             raise ValueError("session_id cannot be None")
 
         session_id = operation.session_id
-        agent = await self.agent_manager.ensure_agent(session_id)
+        agent = await self._ensure_agent(session_id)
         user_input = operation.input
 
         # emit user input event
@@ -148,39 +378,7 @@ class ExecutorContext:
                 await self.emit_event(evt)
 
         for action in actions:
-            await self._run_input_action(action, operation, agent)
-
-    async def _run_input_action(self, action: InputAction, operation: op.UserInputOperation, agent: Agent) -> None:
-        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:
-            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)
-            return
-
-        if action.type == InputActionType.CHANGE_MODEL:
-            if not action.model_name:
-                raise ValueError("ChangeModel action requires model_name")
-
-            await self.agent_manager.apply_model_change(agent, action.model_name)
-            return
-
-        if action.type == InputActionType.CLEAR:
-            await self.agent_manager.apply_clear(agent)
-            return
-
-        raise ValueError(f"Unsupported input action type: {action.type}")
+            await self._action_executor.run(action, operation, agent)
 
     async def handle_interrupt(self, operation: op.InterruptOperation) -> None:
         """Handle an interrupt by invoking agent.cancel() and cancelling tasks."""
@@ -189,11 +387,12 @@ class ExecutorContext:
         if operation.target_session_id is not None:
             session_ids: list[str] = [operation.target_session_id]
         else:
-            session_ids = self.agent_manager.active_session_ids()
+            agent = self._agent
+            session_ids = [agent.session.id] if agent is not None else []
 
         # Call cancel() on each affected agent to persist an interrupt marker
         for sid in session_ids:
-            agent = self.agent_manager.get_active_agent(sid)
+            agent = self._get_active_agent(sid)
             if agent is not None:
                 for evt in agent.cancel():
                     await self.emit_event(evt)
@@ -222,69 +421,6 @@ class ExecutorContext:
             # Remove from active tasks immediately
             self.task_manager.remove(task_id)
 
-    async def _run_agent_task(
-        self, agent: Agent, user_input: model.UserInputPayload, task_id: str, session_id: str
-    ) -> None:
-        """
-        Run an agent task and forward all events to the UI.
-
-        This method wraps the agent's run_task method and handles any exceptions
-        that might occur during execution.
-        """
-        try:
-            log_debug(
-                f"Starting agent task {task_id} for session {session_id}",
-                style="green",
-                debug_type=DebugType.EXECUTION,
-            )
-
-            # Inject subtask runner into tool context for nested Task tool usage
-            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:
-                # Forward all events from the agent to the UI
-                async for event in agent.run_task(user_input):
-                    await self.emit_event(event)
-            finally:
-                current_run_subtask_callback.reset(token)
-
-        except asyncio.CancelledError:
-            # Task was cancelled (likely due to interrupt)
-            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:
-            # Handle any other exceptions
-            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:
-            # Clean up the task from active tasks
-            self.task_manager.remove(task_id)
-            log_debug(
-                f"Cleaned up agent task {task_id}",
-                style="cyan",
-                debug_type=DebugType.EXECUTION,
-            )
-
     def get_active_task(self, submission_id: str) -> asyncio.Task[None] | None:
         """Return the asyncio.Task for a submission id if one is registered."""
 
@@ -298,6 +434,16 @@ class ExecutorContext:
 
         return self.task_manager.get(submission_id) is not None
 
+    def _get_active_agent(self, session_id: str) -> Agent | None:
+        """Return the active agent if its session id matches ``session_id``."""
+
+        agent = self._agent
+        if agent is None:
+            return None
+        if agent.session.id != session_id:
+            return None
+        return agent
+
 
 class Executor:
     """
@@ -312,8 +458,9 @@ class Executor:
         event_queue: asyncio.Queue[events.Event],
         llm_clients: LLMClients,
         model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
     ):
-        self.context = ExecutorContext(event_queue, llm_clients, model_profile_provider)
+        self.context = ExecutorContext(event_queue, llm_clients, model_profile_provider, on_model_change)
         self.submission_queue: asyncio.Queue[op.Submission] = asyncio.Queue()
         # Track completion events for all submissions (not just those with ActiveTask)
         self._completion_events: dict[str, asyncio.Event] = {}

klaude_code/core/manager/__init__.py

@@ -1,18 +1,16 @@
 """Core runtime and state management components.
 
 Expose the manager layer via package imports to reduce module churn in
-callers. This keeps long-lived runtime state helpers (agents, tasks,
-LLM clients, sub-agents) distinct from per-session execution logic in
+callers. This keeps long-lived runtime state helpers (LLM clients and
+sub-agents) distinct from per-session execution logic in
 ``klaude_code.core``.
 """
 
-from klaude_code.core.manager.agent_manager import AgentManager
 from klaude_code.core.manager.llm_clients import LLMClients
 from klaude_code.core.manager.llm_clients_builder import build_llm_clients
 from klaude_code.core.manager.sub_agent_manager import SubAgentManager
 
 __all__ = [
-    "AgentManager",
     "LLMClients",
     "SubAgentManager",
     "build_llm_clients",

klaude_code/core/prompts/prompt-claude-code.md

@@ -7,7 +7,7 @@ You are an interactive CLI tool that helps users with software engineering tasks
 - NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one. This includes markdown files.
 
 ## Professional objectivity
-Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without any unnecessary superlatives, praise, or emotional validation. It is best for the user if Claude honestly applies the same rigorous standards to all ideas and disagrees when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs. Avoid using over-the-top validation or excessive praise when responding to users such as "You're absolutely right" or similar phrases.
+Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without any unnecessary superlatives, praise, or emotional validation. It is best for the user if you honestly applies the same rigorous standards to all ideas and disagrees when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs. Avoid using over-the-top validation or excessive praise when responding to users such as "You're absolutely right" or similar phrases.
 
 ## Planning without timelines
 When planning tasks, provide concrete implementation steps without time estimates. Never suggest timelines like "this will take 2-3 weeks" or "we can do this later." Focus on what needs to be done, not when. Break work into actionable steps and let users decide scheduling.

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

@@ -1,6 +1,14 @@
 You are a powerful code search agent.
 
-CRITICAL: This is a READ-ONLY exploration task. You MUST NOT create, write, or modify any files under any circumstances. Your role is strictly to search and analyze existing code.
+=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
+This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:
+- Creating new files (no Write, touch, or file creation of any kind)
+- Modifying existing files (no Edit operations)
+- Deleting files (no rm or deletion)
+- Moving or copying files (no mv or cp)
+- Creating temporary files anywhere, including /tmp
+- Using redirect operators (>, >>, |) or heredocs to write to files
+- Running ANY commands that change system state
 
 Your strengths:
 - Rapidly finding files using glob patterns
@@ -14,12 +22,16 @@ Guidelines:
 - Use Bash ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail). NEVER use it for file creation, modification, or commands that change system state (mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install). NEVER use redirect operators (>, >>, |) or heredocs to create files
 - Adapt your search approach based on the thoroughness level specified by the caller
 - quick = scan obvious targets; medium = cover all related modules; very thorough = exhaustive sweep with validation
-- For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
 - Only your last message is surfaced back to the agent as the final answer.
 - Return file paths as absolute paths in your final response
 - For clear communication, avoid using emojis
 - Do not create any files, or run bash commands that modify the user's system state in any way (This includes temporary files in the /tmp folder. Never create these files, instead communicate your final report directly as a regular message)
 
+NOTE: You are meant to be a fast agent that returns output as quickly as possible. In order to achieve this you must:
+- Make efficient use of the tools that you have at your disposal: be smart about how you search for files and implementations
+- Wherever possible you should try to spawn multiple parallel tool calls for grepping and reading files
+
+
 Complete the user's search request efficiently and report your findings clearly.
 
 Notes:

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

@@ -11,6 +11,7 @@ You are a web research agent that searches and fetches web content to provide up
 - HTML pages are automatically converted to Markdown
 - JSON responses are auto-formatted with indentation
 - Other text content returned as-is
+- **Content is always saved to a local file** - check `<file_saved>` tag for the path
 
 ## Tool Usage Strategy
 
@@ -26,7 +27,7 @@ Balance efficiency with thoroughness. For open-ended questions (e.g., "recommend
 - Keep queries concise (1-6 words). Start broad, then narrow if needed
 - 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>)
+- 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
 - Follow relevant links on pages with WebFetch
 - If truncated results are saved to local files, use grep/read to explore
@@ -34,15 +35,17 @@ Balance efficiency with thoroughness. For open-ended questions (e.g., "recommend
 ## Response Guidelines
 
 - Only your last message is returned to the main agent
-- Be succinct - include only relevant information
+- **DO NOT copy full web page content** - the main agent can read the saved files directly
+- Provide a concise summary/analysis of key findings
+- Include the file path from `<file_saved>` so the main agent can access full content if needed
 - Lead with the most recent info for evolving topics
 - Favor original sources (company blogs, papers, gov sites) over aggregators
 - Note conflicting sources when they exist
 
 ## Sources (REQUIRED)
 
-You MUST end every response with a "Sources:" section listing all URLs as markdown links:
+You MUST end every response with a "Sources:" section listing all URLs with their saved file paths:
 
 Sources:
-- [Source Title](https://example.com)
-- [Another Source](https://example.com/page) (saved: /path/to/file)
+- [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

klaude_code/core/reminders.py

@@ -1,4 +1,3 @@
-import json
 import re
 import shlex
 from collections.abc import Awaitable, Callable
@@ -282,7 +281,6 @@ def get_memory_paths() -> list[tuple[Path, str]]:
             "user's private global instructions for all projects",
         ),
         (Path.cwd() / "AGENTS.md", "project instructions, checked into the codebase"),
-        (Path.cwd() / "AGENT.md", "project instructions, checked into the codebase"),
         (Path.cwd() / "CLAUDE.md", "project instructions, checked into the codebase"),
     ]
 
@@ -351,46 +349,22 @@ IMPORTANT: this context may or may not be relevant to your tasks. You should not
     return None
 
 
-def get_last_turn_tool_call(session: Session) -> list[model.ToolCallItem]:
-    tool_calls: list[model.ToolCallItem] = []
-    for item in reversed(session.conversation_history):
-        if isinstance(item, model.ToolCallItem):
-            tool_calls.append(item)
-        if isinstance(
-            item,
-            (
-                model.ReasoningEncryptedItem,
-                model.ReasoningTextItem,
-                model.AssistantMessageItem,
-            ),
-        ):
-            break
-    return tool_calls
-
-
 MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md", "AGENT.md"]
 
 
 async def last_path_memory_reminder(
     session: Session,
 ) -> model.DeveloperMessageItem | None:
-    """When last turn tool call entered a directory (or parent directory) with CLAUDE.md AGENTS.md"""
-    tool_calls = get_last_turn_tool_call(session)
-    if len(tool_calls) == 0:
+    """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.
+    """
+    if not session.file_tracker:
         return None
-    paths: list[str] = []
-    for tool_call in tool_calls:
-        if tool_call.name in (tools.READ, tools.EDIT, tools.MULTI_EDIT, tools.WRITE):
-            try:
-                json_dict = json.loads(tool_call.arguments)
-                if path := json_dict.get("file_path", ""):
-                    paths.append(path)
-            except json.JSONDecodeError:
-                continue
-    paths = list(set(paths))
+
+    paths = list(session.file_tracker.keys())
     memories: list[Memory] = []
-    if len(paths) == 0:
-        return None
 
     cwd = Path.cwd().resolve()
     loaded_set: set[str] = set(session.loaded_memory)
@@ -484,8 +458,8 @@ def load_agent_reminders(
     reminders.extend(
         [
             memory_reminder,
-            last_path_memory_reminder,
             at_file_reader_reminder,
+            last_path_memory_reminder,
             file_changed_externally_reminder,
             image_reminder,
         ]

klaude_code/core/task.py

@@ -29,6 +29,8 @@ class MetadataAccumulator:
         self._sub_agent_metadata: list[model.TaskMetadata] = []
         self._throughput_weighted_sum: float = 0.0
         self._throughput_tracked_tokens: int = 0
+        self._first_token_latency_sum: float = 0.0
+        self._first_token_latency_count: int = 0
         self._turn_count: int = 0
 
     def add(self, turn_metadata: model.ResponseMetadataItem) -> None:
@@ -51,13 +53,8 @@ class MetadataAccumulator:
                 acc_usage.context_limit = usage.context_limit
 
             if usage.first_token_latency_ms is not None:
-                if acc_usage.first_token_latency_ms is None:
-                    acc_usage.first_token_latency_ms = usage.first_token_latency_ms
-                else:
-                    acc_usage.first_token_latency_ms = min(
-                        acc_usage.first_token_latency_ms,
-                        usage.first_token_latency_ms,
-                    )
+                self._first_token_latency_sum += usage.first_token_latency_ms
+                self._first_token_latency_count += 1
 
             if usage.throughput_tps is not None:
                 current_output = usage.output_tokens
@@ -83,6 +80,11 @@ class MetadataAccumulator:
             else:
                 main.usage.throughput_tps = None
 
+            if self._first_token_latency_count > 0:
+                main.usage.first_token_latency_ms = self._first_token_latency_sum / self._first_token_latency_count
+            else:
+                main.usage.first_token_latency_ms = None
+
         main.task_duration_s = task_duration_s
         main.turn_count = self._turn_count
         return model.TaskMetadataItem(main=main, sub_agent_task_metadata=self._sub_agent_metadata)