bone-agent 1.3.3 → 1.4.0

package/README.md

@@ -130,8 +130,25 @@ bone
 - `/account` - View your bone-agent account and plan details
 - `/plan` - View available plans and pricing
 - `/upgrade` - Upgrade your subscription
+- `/skills list [query]` - List saved skills, optionally filtered by name or content
+- `/skills show <name>` - Display a saved skill
+- `/skills add <name>` - Create a reusable prompt skill in your editor
+- `/skills edit <name>` - Open a saved skill in your editor
+- `/skills modify <name> [prompt]` - Update an existing saved skill inline or in your editor
+- `/skills load <name>` - Load a saved skill into the current chat
+- `/skills use <name>` - Alias for `/skills load`
+- `/skills remove <name>` - Delete a saved skill
+- `/skills dir` - Print the skills directory path
 - `/help` - Display all available commands
 
+Example:
+
+```text
+/skills add frontend_design
+/skills modify frontend_design Use restrained, production-quality UI patterns.
+/skills use frontend_design
+```
+
 /help Menu:
 <img width="1843" height="1349" alt="image" src="https://github.com/user-attachments/assets/631ab805-f012-4bb6-a031-c82a339e94c5" />
 

package/config.yaml.example

@@ -104,8 +104,11 @@ CONTEXT_SETTINGS:
 # -- Sub-Agent Settings -------------------------------------------------------
 
 SUB_AGENT_SETTINGS:
-  soft_limit_tokens: 300000
-  hard_limit_tokens: 500000
+  soft_limit_tokens: 100000
+  hard_limit_tokens: 150000
+  billed_warning_tokens: 200000
+  billed_hard_limit_tokens: 500000
+  compact_trigger_tokens: 50000
   enable_compaction: false
   dump_context_on_hard_limit: true
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bone-agent",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "description": "A terminal-based AI coding assistant powered by OpenAI-style function calling",
   "main": "src/ui/main.py",
   "bin": {

package/prompts/main/communication_style.md

@@ -3,7 +3,7 @@
 **Important:** Default to concise explanations
 
 - Show only changed code snippets when making edits via tools, never in explanations
-- Use bullet points instead of prose when possible
+- Use bullet points where necessary, not as default
 - Target: 3-5 sentences max for explanations, 10-15 lines max for plans
 - Explain the "why" and "what", skip the "how" unless requested
 

package/prompts/main/dream.md

@@ -10,13 +10,26 @@ You are the dream agent — a background process that consolidates user messages
    b. If the project directory is found, read its project memory at `{project_dir}/.bone/agents.md`
    c. If the project directory cannot be resolved, treat those messages as user-level only
 3. Read the current user memory at `~/.bone/user_memory.md`
-4. Analyze the messages for:
-   - Preferences (tools, languages, workflows, coding style)
-   - Corrections or feedback the user gave
-   - Patterns in how the user works
-   - Decisions made about architecture or approach
-   - Explicit requests to remember something
-5. Consolidate findings into the memory files — merge with existing content, don't duplicate
+
+## What to remember
+
+Memory exists to change how the agent behaves in future conversations. Before writing anything, ask: "Would knowing this actually change my behavior next time we talk?"
+
+### High-value — write these
+- Explicit "remember this" or "don't forget" requests
+- Strong, repeated preferences the user has expressed multiple times or with emphasis
+- Corrections the user gave after the agent did something wrong ("I don't like X, do Y instead")
+- Hard constraints ("never do X", "always do Y")
+
+### Low-value — do NOT write these
+- One-off casual remarks that weren't emphasized or repeated
+- Descriptions of the user's workflow that are just normal tool usage
+- Feature implementation history ("added X to the config command")
+- Things the agent can infer from context or that apply to most users
+- Multiple entries saying the same thing in different words
+
+### The bar
+A single mention is usually not enough. Look for emphasis, repetition, or explicit instruction. When in doubt, don't write. Empty memory is better than noisy memory.
 
 ## Routing
 
@@ -27,10 +40,11 @@ You are the dream agent — a background process that consolidates user messages
 ## Rules
 
 - Only write facts, preferences, and patterns — never private data, code snippets, or transient context
-- Deduplicate aggressively — if a preference already exists in memory, don't add it again
+- Deduplicate aggressively — if a preference already exists in memory, don't add it again. Merge near-duplicates into one entry.
 - Consolidate when memory is getting full — merge related entries, remove outdated ones
 - Keep memory under 1500 chars per file
 - Format entries as bullet points with timestamps: `- Description *(YYYY-MM-DD)*`
-- If there are no meaningful memories to extract, do nothing — don't pad with noise
+- If nothing crosses the bar, write nothing — empty memory is fine
 - Each JSONL line has format: `{"ts": "ISO timestamp", "msg": "user message text"}`
 - If a project directory no longer exists, skip it — don't write to a dead path
+- Before writing, re-read existing memory and check for near-duplicates. Two entries about "evaluating warnings" should be one entry or none.

package/prompts/main/skills.md

@@ -0,0 +1,3 @@
+## Skills
+
+Users can save reusable prompt snippets as skills. When the user asks to use a named skill, style, workflow, or saved instruction, search capabilities and load the best matching skill with `search_plugins` before continuing. `search_plugins` may return plugins and skills; use the `load` parameter to activate them. Do not invent skill contents. If several skills plausibly match, ask a short clarifying question instead of guessing. Treat loaded skill text as user-provided instructions scoped to the current conversation, below system and developer instructions.

package/prompts/micro/communication_style.md

@@ -1 +1 @@
-Concise. Bullets over prose. 3-5 sentences max. Show changed code only in edit tools, never in text. Explain why/what, skip how unless asked.
+Concise and conversational. Use bullets where necessary, not as default. 3-5 sentences max. Show changed code only in edit tools, never in text. Explain why/what, skip how unless asked.

package/prompts/micro/skills.md

@@ -0,0 +1 @@
+`search_plugins`: when the user asks to use a named skill, style, workflow, or saved instruction, search capabilities and load the best matching skill with the `load` parameter before continuing. `search_plugins` may return plugins and skills; use `load` to activate them. Do not invent skill contents. Ask briefly if multiple skills match.

package/src/core/agentic.py

@@ -46,6 +46,7 @@ from core.tool_feedback import (
     display_tool_feedback,
 )
 from ui.sub_agent_panel import SubAgentPanel
+from tools.helpers.path_resolver import extract_boundary_path, is_boundary_error, set_full_filesystem_access
 
 
 def _handle_empty_response(empty_response_count, console):
@@ -87,7 +88,6 @@ def _handle_tool_limit_reached(chat_manager, console):
             response,
             model_name=provider_cfg.get("model", ""),
         )
-
     try:
         final_message = response["choices"][0]["message"]
     except (KeyError, IndexError):
@@ -105,8 +105,6 @@ def _handle_tool_limit_reached(chat_manager, console):
     console.print("[red]Error: model returned empty response after tool limit reached.[/red]")
     return False
 
-
-
 class AgenticOrchestrator:
     """Orchestrates the agentic tool-calling loop.
 
@@ -171,21 +169,42 @@ class AgenticOrchestrator:
         # Check if we're in a parallel context with suppressed console
         return self._parallel_context.get('console', self.console)
 
-    def run(self, user_input, thinking_indicator=None, allowed_tools=None):
+    def _get_effective_tools(self, allowed_tools=None, allow_active_plugins=False):
+        """Return tool schemas allowed for the current run."""
+        from tools.helpers.base import ToolRegistry
+
+        tools = TOOLS()
+        if allowed_tools is None:
+            return tools
+
+        effective_names = set(allowed_tools)
+        if allow_active_plugins:
+            effective_names.update(ToolRegistry.active_plugin_names())
+
+        if not effective_names:
+            return []
+
+        return [tool for tool in tools if tool["function"]["name"] in effective_names]
+
+    def run(self, user_input, thinking_indicator=None, allowed_tools=None, allow_active_plugins=False):
         """Main orchestration loop.
 
         Args:
             user_input: User's input message
             thinking_indicator: Optional ThinkingIndicator instance
             allowed_tools: Optional list of allowed tool names (for research)
+            allow_active_plugins: Whether to include active plugin tools in restricted runs
         """
+        self._current_allowed_tools = allowed_tools
+        self._current_allow_active_plugins = allow_active_plugins
+
         # Append user message
         self.chat_manager.messages.append({"role": "user", "content": user_input})
 
         # Log user message
         self.chat_manager.log_message({"role": "user", "content": user_input})
 
-        from tools.base import ToolRegistry
+        from tools.helpers.base import ToolRegistry
 
         while True:
             # Decrement plugin TTLs after previous iteration's tool execution.
@@ -195,7 +214,10 @@ class AgenticOrchestrator:
                 self.console.print(f"[dim]Plugins evicted (TTL expired): {evicted}[/dim]")
 
             # Get response from LLM
-            response = self._get_llm_response(allowed_tools=allowed_tools)
+            response = self._get_llm_response(
+                allowed_tools=allowed_tools,
+                allow_active_plugins=allow_active_plugins,
+            )
             if response is None:
                 return
 
@@ -209,11 +231,16 @@ class AgenticOrchestrator:
                 if self._handle_final_response(response, thinking_indicator):
                     return
             else:
-                should_exit = self._handle_tool_calls(response, thinking_indicator, allowed_tools)
+                should_exit = self._handle_tool_calls(
+                    response,
+                    thinking_indicator,
+                    allowed_tools,
+                    allow_active_plugins=allow_active_plugins,
+                )
                 if should_exit:
                     return
 
-    def _get_llm_response(self, allowed_tools=None):
+    def _get_llm_response(self, allowed_tools=None, allow_active_plugins=False):
         """Get next LLM response with tool definitions.
 
         Includes automatic retry with live countdown for timeout/connection errors.
@@ -221,6 +248,7 @@ class AgenticOrchestrator:
 
         Args:
             allowed_tools: Optional list of allowed tool names (overrides mode-based filtering)
+            allow_active_plugins: Whether to include active plugin tools in restricted runs
 
         Returns:
             Response dict from LLM, or None if error occurred
@@ -229,19 +257,17 @@ class AgenticOrchestrator:
         self.chat_manager.ensure_context_fits(console=self.console)
 
         # Use allowed_tools if provided, otherwise use mode-based filtering
-        if allowed_tools is not None:
-            # Validate that allowed_tools is not empty
-            if not allowed_tools:
-                self.console.print("[red]Error: allowed_tools is empty[/red]")
-                return None
-            # TOOLS is a function, call it to get the list
-            tools = [tool for tool in TOOLS() if tool["function"]["name"] in allowed_tools]
-            # Log filtered tools for debugging
-            if self.debug_mode:
-                tool_names = [t["function"]["name"] for t in tools]
-                self.console.print(f"[dim]Available tools: {tool_names}[/dim]")
-        else:
-            tools = TOOLS()
+        if allowed_tools is not None and not allowed_tools and not allow_active_plugins:
+            self.console.print("[red]Error: allowed_tools is empty[/red]")
+            return None
+
+        tools = self._get_effective_tools(
+            allowed_tools=allowed_tools,
+            allow_active_plugins=allow_active_plugins,
+        )
+        if allowed_tools is not None and self.debug_mode:
+            tool_names = [t["function"]["name"] for t in tools]
+            self.console.print(f"[dim]Available tools: {tool_names}[/dim]")
 
         # Retry loop for timeout/connection errors
         last_error = None
@@ -262,7 +288,21 @@ class AgenticOrchestrator:
                     continue
                 else:
                     # Non-retryable error or final attempt exhausted
+                    detail_lines = []
+                    for key, value in getattr(e, "details", {}).items():
+                        value_str = str(value)
+                        if "\n" in value_str or key == "original_error":
+                            detail_lines.append(f"{key}: {value_str}")
+                    detailed_error = str(e)
+                    if detail_lines:
+                        detailed_error += "\n\n" + "\n\n".join(detail_lines)
+
+                    if self.is_sub_agent:
+                        raise LLMError(detailed_error, details=getattr(e, "details", {}))
+
                     self.console.print(f"[red]LLM Error: {e}[/red]")
+                    if detail_lines:
+                        self.console.print(f"[dim]{detail_lines[0]}[/dim]", markup=False)
                     return None
 
             # Successful response — parse and return
@@ -324,8 +364,11 @@ class AgenticOrchestrator:
             # NEW: Compact tool results after final answer (per-message compaction)
             self.chat_manager.compact_tool_results(skip_token_update=True)
 
-            # Update context tokens with current mode's tools
-            tools_for_mode = TOOLS()
+            # Update context tokens with current run's effective tools
+            tools_for_mode = self._get_effective_tools(
+                allowed_tools=getattr(self, "_current_allowed_tools", None),
+                allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
+            )
             self.chat_manager._update_context_tokens(tools_for_mode)
 
             self.console.print()
@@ -337,13 +380,14 @@ class AgenticOrchestrator:
         )
         return not should_continue
 
-    def _handle_tool_calls(self, response, thinking_indicator, allowed_tools=None):
+    def _handle_tool_calls(self, response, thinking_indicator, allowed_tools=None, allow_active_plugins=False):
         """Process tool calls and display accompanying content.
 
         Args:
             response: Full message dict from LLM (includes content and tool_calls)
             thinking_indicator: Optional ThinkingIndicator instance
             allowed_tools: Optional list of allowed tool names
+            allow_active_plugins: Whether to allow active plugin tools in restricted runs
 
         Returns:
             True if should exit the orchestration loop
@@ -357,6 +401,8 @@ class AgenticOrchestrator:
         # This must happen BEFORE filtering so the LLM sees its original intent
         content = (response.get("content") or "").strip()
         assistant_msg = {"role": "assistant", "tool_calls": tool_calls}
+        if response.get("_responses_output"):
+            assistant_msg["_responses_output"] = response["_responses_output"]
         if content:
             assistant_msg["content"] = content
         self.chat_manager.messages.append(assistant_msg)
@@ -367,7 +413,7 @@ class AgenticOrchestrator:
         # This silently removes unknown tools or tools not in the allowed whitelist
         # to prevent error messages from reaching the user while allowing the agent
         # to continue with alternative tools.
-        from tools.base import ToolRegistry
+        from tools.helpers.base import ToolRegistry
 
         filtered_calls = []
         filtered_tool_ids = []  # Track filtered tool IDs to provide feedback
@@ -384,10 +430,14 @@ class AgenticOrchestrator:
                 filtered_tool_ids.append(tool_call.get("id"))
                 continue
 
-            # Check if tool is in allowed_tools whitelist (if provided)
-            # Plugin-tier tools bypass the whitelist — they are already vetted
-            # by the manifest and activated on-demand via search_plugins.
-            if allowed_tools and function_name not in allowed_tools and not ToolRegistry.is_plugin_active(function_name):
+            # Check if tool is in the effective allowlist for this run.
+            effective_allowed_tools = None
+            if allowed_tools is not None:
+                effective_allowed_tools = set(allowed_tools)
+                if allow_active_plugins:
+                    effective_allowed_tools.update(ToolRegistry.active_plugin_names())
+
+            if effective_allowed_tools is not None and function_name not in effective_allowed_tools:
                 # Silent fail - skip this tool
                 if self.debug_mode:
                     self.console.print(f"[dim]Silently filtered non-allowed tool: {function_name}[/dim]")
@@ -542,8 +592,11 @@ class AgenticOrchestrator:
         # Compact completed tool blocks once after all tools complete
         self.chat_manager.compact_tool_results(skip_token_update=True)
 
-        # Update context tokens with current mode's tools
-        tools_for_mode = TOOLS()
+        # Update context tokens with current run's effective tools
+        tools_for_mode = self._get_effective_tools(
+            allowed_tools=getattr(self, "_current_allowed_tools", None),
+            allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
+        )
         self.chat_manager._update_context_tokens(tools_for_mode)
 
         # Pre-send guard: ensure context fits before next LLM call
@@ -563,7 +616,7 @@ class AgenticOrchestrator:
         """
         if not tool_calls:
             return False
-        from tools.parallel_executor import ParallelToolExecutor, ToolCall
+        from tools.helpers.parallel_executor import ParallelToolExecutor, ToolCall
 
         # Suppress console output in handlers during parallel execution
         # We'll display results ourselves in order below
@@ -783,8 +836,11 @@ class AgenticOrchestrator:
             # after all parallel results are appended (safe — only compacts completed blocks)
             self.chat_manager.compact_tool_results(skip_token_update=True)
 
-            # Update context tokens with current mode's tools
-            tools_for_mode = TOOLS()
+            # Update context tokens with current run's effective tools
+            tools_for_mode = self._get_effective_tools(
+                allowed_tools=getattr(self, "_current_allowed_tools", None),
+                allow_active_plugins=getattr(self, "_current_allow_active_plugins", False),
+            )
             self.chat_manager._update_context_tokens(tools_for_mode)
 
             # Pre-send guard: ensure context fits before next LLM call
@@ -795,6 +851,38 @@ class AgenticOrchestrator:
             # Restore console output
             self._parallel_context['console'] = self.console
 
+    def _boundary_prompt(self, path_str):
+        """Prompt the user to grant filesystem access for a path outside boundaries.
+
+        Called after a tool returns a boundary error. If the user grants access,
+        the caller retries the tool with the boundary lifted.
+
+        Args:
+            path_str: The path that triggered the boundary violation.
+
+        Returns:
+            True if user granted access, False if denied.
+        """
+        if self.is_sub_agent:
+            return False
+
+        console = self._get_console()
+        if console is None:
+            return False
+
+        from ui.tool_confirmation import ToolConfirmationPanel
+        panel = ToolConfirmationPanel(
+            'Grant filesystem access',
+            reason=f'Agent requested access outside project boundary: {path_str}',
+            is_edit_tool=False
+        )
+        action, _ = panel.run()
+
+        if action == "accept":
+            console.print("[yellow]Full filesystem access granted[/yellow]\n")
+            return True
+        return False
+
     def _process_single_tool_call(self, tool_call, thinking_indicator):
         """Process a single tool call.
 
@@ -826,7 +914,7 @@ class AgenticOrchestrator:
             panel_to_use = SubAgentPanel(query, self.console)
 
         # Execute via tool registry
-        from tools.base import ToolRegistry, build_context
+        from tools.helpers.base import ToolRegistry, build_context
 
         tool = ToolRegistry.get(function_name)
         if tool:
@@ -916,6 +1004,20 @@ class AgenticOrchestrator:
                     if policy == TERMINAL_YIELD and thinking_indicator:
                         thinking_indicator.resume()
 
+                # Boundary escalation: if the tool result is a path boundary
+                # violation, prompt the user to grant session-wide access.
+                result_str = str(result)
+                if is_boundary_error(result_str):
+                    path_arg = arguments.get("path", arguments.get("path_str", ""))
+                    if not path_arg:
+                        path_arg = extract_boundary_path(result_str)
+                    granted = self._boundary_prompt(path_arg)
+                    if granted:
+                        set_full_filesystem_access(True)
+                        # Retry with the boundary now lifted
+                        result = tool.execute(arguments, context)
+                        result_str = str(result)
+
                 # Display result for registry tools
                 # Skip display for tools that take over the terminal (they handle their own display)
                 if policy != TERMINAL_YIELD:
@@ -948,7 +1050,7 @@ class AgenticOrchestrator:
                             # Then display feedback
                             display_tool_feedback(label, result, console, indent=self.is_sub_agent, panel_updater=self.panel_updater)
 
-                return False, str(result)
+                return False, result_str
             except Exception as e:
                 # If thinking_indicator was paused (TERMINAL_YIELD) and tool
                 # raised, resume it so the spinner reappears for the next iteration
@@ -981,5 +1083,3 @@ def agentic_answer(chat_manager, user_input, console, repo_root, rg_exe_path, de
         debug_mode=debug_mode,
     )
     orchestrator.run(user_input, thinking_indicator)
-
-

package/src/core/chat_manager.py

@@ -9,8 +9,9 @@ import requests
 from typing import Optional, IO
 
 from llm.client import LLMClient
-from llm.config import get_providers, get_provider_config, reload_config
+from llm.config import get_providers, get_provider_config, get_provider_display_name, reload_config
 from llm.prompts import build_system_prompt
+from core.skills import render_active_skills_section
 from pathlib import Path
 from llm.token_tracker import TokenTracker
 from utils.settings import server_settings, context_settings
@@ -45,6 +46,10 @@ class ChatManager:
         self.task_list = []
         self.task_list_title = None
 
+        # In-session active skill tracking. These skills are rendered into the
+        # system prompt for the current chat.
+        self.loaded_skills = set()
+
         # .gitignore filtering state
         self._gitignore_spec = None
         self._gitignore_mtime = None
@@ -94,6 +99,9 @@ class ChatManager:
         if self.markdown_logger:
             self.markdown_logger.start_session()
 
+        # Active skills are scoped to the current message history/session.
+        self.loaded_skills = set()
+
         # Start with system prompt only
         self.messages = [{"role": "system", "content": self._build_system_prompt()}]
 
@@ -133,7 +141,8 @@ class ChatManager:
         if variant is None:
             from utils.settings import prompt_settings
             variant = prompt_settings.variant
-        return build_system_prompt(variant)
+        active_skills_section = render_active_skills_section(self.loaded_skills)
+        return build_system_prompt(variant, active_skills_section=active_skills_section)
 
     def update_system_prompt(self, variant: str | None = None):
         """Rebuild system prompt in-place (e.g. after hotswap or session reset).
@@ -1326,7 +1335,8 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         """
         providers = get_providers()
         if provider_name not in providers:
-            return f"Invalid provider. Use /provider to list. Available: {', '.join(providers)}"
+            available = ', '.join(get_provider_display_name(provider) for provider in providers)
+            return f"Invalid provider. Use /provider to list. Available: {available}"
 
         previous_provider = self.client.provider
 
@@ -1342,10 +1352,13 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
                     # Failed to start server - revert
                     self.client.switch_provider(previous_provider)
                     self._init_messages(reset_costs=True)
-                    return f"Failed to start local server. Reverted to {previous_provider} provider."
+                    previous_label = get_provider_display_name(previous_provider)
+                    return f"Failed to start local server. Reverted to {previous_label} provider."
                 self.server_process = server
-                return f"Switched to {provider_name} provider (server ready)."
-            return f"Switched to {provider_name} provider."
+                provider_label = get_provider_display_name(provider_name)
+                return f"Switched to {provider_label} provider (server ready)."
+            provider_label = get_provider_display_name(provider_name)
+            return f"Switched to {provider_label} provider."
         return "Provider switch failed."
 
     def reload_config(self):

package/src/core/config_manager.py

@@ -36,12 +36,16 @@ class ConfigManager:
             with open(self.config_path, 'r', encoding='utf-8-sig') as f:
                 self._cached_data = yaml.safe_load(f) or {}
 
-            # Migrate: rename old provider IDs -> bone (provider ID rename)
+            # Migrate legacy provider IDs to current names.
             old_provider = self._cached_data.get('LAST_PROVIDER')
             if old_provider in ('vmcode_proxy', 'vmcode_free', 'vmcode'):
                 logger.info("Migrating provider name '%s' -> 'bone'", old_provider)
                 self._cached_data['LAST_PROVIDER'] = 'bone'
                 self.save(self._cached_data, create_backup=True)
+            elif old_provider == 'codex_plan':
+                logger.info("Migrating provider name '%s' -> 'codex'", old_provider)
+                self._cached_data['LAST_PROVIDER'] = 'codex'
+                self.save(self._cached_data, create_backup=True)
 
             return self._cached_data
         except yaml.YAMLError as e:
@@ -114,6 +118,7 @@ class ConfigManager:
         if model is None:
             provider_model_map = {
                 'bone': 'BONE_PROXY_MODEL',
+                'codex': 'CODEX_PLAN_MODEL',
                 'openrouter': 'OPENROUTER_MODEL',
                 'glm': 'GLM_MODEL',
                 'glm_plan': 'GLM_PLAN_MODEL',
@@ -144,6 +149,7 @@ class ConfigManager:
         provider_keys = {
             'local': 'LOCAL_MODEL_PATH',
             'bone': 'BONE_PROXY_MODEL',
+            'codex': 'CODEX_PLAN_MODEL',
             'openrouter': 'OPENROUTER_MODEL',
             'glm': 'GLM_MODEL',
             'glm_plan': 'GLM_PLAN_MODEL',
@@ -175,6 +181,7 @@ class ConfigManager:
         provider_keys = {
             'openrouter': 'OPENROUTER_API_KEY',
             'bone': 'BONE_PROXY_API_KEY',
+            'codex': 'CODEX_PLAN_API_KEY',
             'glm': 'GLM_API_KEY',
             'glm_plan': 'GLM_PLAN_API_KEY',
             'openai': 'OPENAI_API_KEY',

package/src/core/cron.py

@@ -344,15 +344,11 @@ def run_single_job(job: CronJob, console=None, interactive=False) -> None:
         from core.chat_manager import ChatManager
         from core.agentic import AgenticOrchestrator
         from utils.paths import RG_EXE_PATH
-        from tools.loader import load_all_tools
         from llm.config import TOOLS_ENABLED
 
         if not TOOLS_ENABLED:
             raise RuntimeError("Cron requires tools to be enabled")
 
-        # Ensure tools are loaded
-        load_all_tools()
-
         # Fresh ChatManager for this job
         chat_manager = ChatManager()