bone-agent 1.3.2 → 1.3.3

package/src/core/agentic.py

@@ -2,7 +2,6 @@
 
 import json
 import logging
-import time
 from pathlib import Path
 from typing import Optional
 
@@ -172,63 +171,6 @@ class AgenticOrchestrator:
         # Check if we're in a parallel context with suppressed console
         return self._parallel_context.get('console', self.console)
 
-    def _is_memory_file(self, path: str) -> bool:
-        """Check if path targets a memory file (auto-approved).
-
-        Auto-approve scope (restricted to known memory paths):
-        - {repo_root}/.bone/agents.md — project memory
-        - ~/.bone/user_memory.md — global user memory
-        - Any file under {repo_root}/.bone/ — project memory directory
-
-        Args:
-            path: File path from tool arguments.
-
-        Returns:
-            True if the file should be auto-approved as a memory file.
-        """
-        p = Path(path).resolve()
-        repo_root = Path(self.repo_root).resolve()
-        # Known memory paths
-        if p == Path.home() / ".bone" / "user_memory.md":
-            return True
-        # Any file under {repo_root}/.bone/ (future memory files)
-        bone_dir = repo_root / ".bone"
-        if p.is_relative_to(bone_dir):
-            return True
-        return False
-
-    def _execute_memory_edit(self, arguments) -> bool:
-        """Apply a memory file edit synchronously with one retry on failure.
-
-        Args:
-            arguments: Tool arguments dict (path, search, replace, etc.)
-        """
-        from tools.edit import _execute_edit_file
-
-        kwargs = dict(
-            path=arguments.get("path"),
-            search=arguments.get("search"),
-            replace=arguments.get("replace"),
-            repo_root=self.repo_root,
-            console=None,  # silent — no output in chat
-            gitignore_spec=self.gitignore_spec,
-            context_lines=arguments.get("context_lines", 3),
-            vault_root=vault_root_str(),
-        )
-        try:
-            _execute_edit_file(**kwargs)
-            return True
-        except Exception as e:
-            logger.warning("Memory edit failed (retrying in 0.5s): %s", e)
-            time.sleep(0.5)
-            try:
-                _execute_edit_file(**kwargs)
-                logger.info("Memory edit retry succeeded after initial failure.")
-                return True
-            except Exception as e2:
-                logger.error("Memory edit failed after retry: %s", e2)
-                return False
-
     def run(self, user_input, thinking_indicator=None, allowed_tools=None):
         """Main orchestration loop.
 
@@ -908,26 +850,12 @@ class AgenticOrchestrator:
 
                 # Check if tool requires approval
                 if tool.requires_approval:
-                    # For edit_file: check memory file auto-approve first
+                    # For edit_file: validate path then request approval
                     if function_name == "edit_file":
                         edit_path = arguments.get("path", "")
                         if not edit_path:
                             return False, "Error: path is required for edit_file."
 
-                        # Memory file: auto-approve, fire-and-forget
-                        if self._is_memory_file(edit_path):
-                            # Generate preview to validate the edit (reuses existing logic)
-                            result = tool.execute(arguments, context)
-                            preview, is_valid = resolve_edit_preview(result)
-                            if is_valid:
-                                ok = self._execute_memory_edit(arguments)
-                                if self.debug_mode:
-                                    console = self._get_console()
-                                    if console:
-                                        console.print(f"[dim]Memory edit auto-approved: {edit_path}[/dim]")
-                                return False, "Memory saved." if ok else f"Memory edit failed: {edit_path}"
-                            return False, str(result)
-
                         # Normal edit: generate preview and request approval
                         result = tool.execute(arguments, context)
 

package/src/core/chat_manager.py

@@ -15,6 +15,7 @@ from pathlib import Path
 from llm.token_tracker import TokenTracker
 from utils.settings import server_settings, context_settings
 from utils.logger import MarkdownConversationLogger
+from utils.user_message_logger import UserMessageLogger
 from utils.result_parsers import extract_exit_code, extract_metadata_from_result
 
 # Token counting constants
@@ -62,6 +63,9 @@ class ChatManager:
                 conversations_dir=context_settings.conversations_dir
             )
 
+        # User message logging (always on, for dream memory system)
+        self.user_message_logger = UserMessageLogger()
+
         # Compaction lock: prevents compaction during active tool execution
         # Set by agentic.py before executing tools, cleared after all results appended
         self._compaction_locked = False
@@ -119,20 +123,37 @@ class ChatManager:
         self._update_context_tokens()
         self.context_token_estimate = self.token_tracker.current_context_tokens
 
-    def _build_system_prompt(self) -> str:
-        """Build system prompt."""
-        return build_system_prompt()
+    def _build_system_prompt(self, variant: str | None = None) -> str:
+        """Build system prompt.
+
+        Args:
+            variant: Prompt variant name (e.g. 'main', 'micro').
+                     If None, reads from prompt_settings.
+        """
+        if variant is None:
+            from utils.settings import prompt_settings
+            variant = prompt_settings.variant
+        return build_system_prompt(variant)
+
+    def update_system_prompt(self, variant: str | None = None):
+        """Rebuild system prompt in-place (e.g. after hotswap or session reset).
 
-    def update_system_prompt(self):
-        """Rebuild system prompt (e.g. after session reset)."""
+        Args:
+            variant: Prompt variant to use. If None, keeps current variant.
+                     Updates token_tracker.current_variant.
+        """
         if not self.messages:
             raise RuntimeError("Cannot update system prompt: messages array is empty")
 
         if self.messages[0]["role"] != "system":
             raise RuntimeError(f"Cannot update system prompt: messages[0] has role '{self.messages[0]['role']}', expected 'system'")
 
-        # Update the system message with current mode
-        self.messages[0]["content"] = self._build_system_prompt()
+        if variant is None:
+            from utils.settings import prompt_settings
+            variant = prompt_settings.variant
+
+        self.messages[0]["content"] = self._build_system_prompt(variant)
+        self.token_tracker.current_variant = variant
         self._update_context_tokens()
 
     def _load_agents_md(self) -> tuple[str, str]:
@@ -1376,6 +1397,10 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
             server_path,
             "-m", model_path,
             "-ngl", str(server_settings.ngl_layers),
+            "--threads", str(server_settings.threads),
+            "--batch-size", str(server_settings.batch_size),
+            "--ubatch-size", str(server_settings.ubatch_size),
+            "--flash-attn" if server_settings.flash_attn else "--no-flash-attn",
             "--split-mode", "none",
             "--ctx-size", str(server_settings.ctx_size),
             "--n-predict", str(server_settings.n_predict),
@@ -1383,6 +1408,7 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
             "--host", host,
             "--port", str(port),
             "--jinja",
+            "--reasoning", "off",
         ]
 
         # Restrict to RTX 5070 Ti only (GPU 0)
@@ -1459,6 +1485,15 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         if self.markdown_logger:
             self.markdown_logger.log_message(message)
 
+        # Log user messages to JSONL for dream memory processing (only if memory enabled)
+        if message.get("role") == "user" and message.get("content"):
+            from llm.config import MEMORY_SETTINGS
+            if MEMORY_SETTINGS.get("enabled", True):
+                self.user_message_logger.log_user_message(
+                    message["content"],
+                    project_dir=Path.cwd().resolve(),
+                )
+
     def sync_log(self):
         """Rewrite the entire conversation log to match current message state.
 

package/src/core/config_manager.py

@@ -116,9 +116,11 @@ class ConfigManager:
                 'bone': 'BONE_PROXY_MODEL',
                 'openrouter': 'OPENROUTER_MODEL',
                 'glm': 'GLM_MODEL',
+                'glm_plan': 'GLM_PLAN_MODEL',
                 'openai': 'OPENAI_MODEL',
                 'gemini': 'GEMINI_MODEL',
                 'minimax': 'MINIMAX_MODEL',
+                'minimax_plan': 'MINIMAX_PLAN_MODEL',
                 'anthropic': 'ANTHROPIC_MODEL',
                 'kimi': 'KIMI_MODEL'
             }
@@ -144,9 +146,11 @@ class ConfigManager:
             'bone': 'BONE_PROXY_MODEL',
             'openrouter': 'OPENROUTER_MODEL',
             'glm': 'GLM_MODEL',
+            'glm_plan': 'GLM_PLAN_MODEL',
             'openai': 'OPENAI_MODEL',
             'gemini': 'GEMINI_MODEL',
             'minimax': 'MINIMAX_MODEL',
+            'minimax_plan': 'MINIMAX_PLAN_MODEL',
             'anthropic': 'ANTHROPIC_MODEL',
             'kimi': 'KIMI_MODEL'
         }
@@ -172,9 +176,11 @@ class ConfigManager:
             'openrouter': 'OPENROUTER_API_KEY',
             'bone': 'BONE_PROXY_API_KEY',
             'glm': 'GLM_API_KEY',
+            'glm_plan': 'GLM_PLAN_API_KEY',
             'openai': 'OPENAI_API_KEY',
             'gemini': 'GEMINI_API_KEY',
             'minimax': 'MINIMAX_API_KEY',
+            'minimax_plan': 'MINIMAX_PLAN_API_KEY',
             'anthropic': 'ANTHROPIC_API_KEY',
             'kimi': 'KIMI_API_KEY'
         }

package/src/core/cron.py

@@ -273,6 +273,41 @@ def _write_job_log(job: CronJob, output: str, error: bool):
         logger.error("Failed to write cron log: %s", e)
 
 
+# ── Dream job (auto-seeded) ─────────────────────────────────────────────
+
+DREAM_JOB_ID = "dream"
+DREAM_JOB_SCHEDULE = "daily at 4am"
+
+
+def ensure_dream_job(config: CronConfig) -> None:
+    """Sync the dream memory job with the DREAM_SETTINGS.enabled config.
+
+    - Enabled and missing  → seed the job
+    - Enabled and present  → no-op
+    - Disabled and present → remove the job
+    - Disabled and missing → no-op
+    """
+    from utils.settings import dream_settings
+    from llm.config import MEMORY_SETTINGS
+
+    if dream_settings.enabled and MEMORY_SETTINGS.get("enabled", True):
+        if DREAM_JOB_ID in config.jobs:
+            return
+        job = CronJob(
+            id=DREAM_JOB_ID,
+            schedule=DREAM_JOB_SCHEDULE,
+            command="Run the dream memory consolidation process. Read yesterday's user messages from ~/.bone/conversations/, analyze them for preferences and patterns, and consolidate into memory files. Then clean up JSONL files older than 7 days.",
+            enabled=True,
+            description="Dream memory consolidation — scans user messages and updates memories",
+        )
+        config.add_job(job)
+        logger.info("Seeded dream memory cron job (daily at 4am)")
+    else:
+        if DREAM_JOB_ID in config.jobs:
+            config.remove_job(DREAM_JOB_ID)
+            logger.info("Removed dream memory cron job (disabled in config)")
+
+
 def run_single_job(job: CronJob, console=None, interactive=False) -> None:
     """Execute a single cron job without requiring a CronScheduler instance.
 
@@ -321,10 +356,27 @@ def run_single_job(job: CronJob, console=None, interactive=False) -> None:
         # Fresh ChatManager for this job
         chat_manager = ChatManager()
 
-        # Build the prompt — inject context about cron execution
+        # Dream job: auto-approve edits and run cleanup before agent starts
+        if job.id == DREAM_JOB_ID:
+            chat_manager.approve_mode = "accept_edits"
+            from utils.user_message_logger import UserMessageLogger
+            removed = UserMessageLogger.cleanup_old_files()
+            if removed:
+                logger.info("Dream job: removed %d old JSONL files", removed)
+
+        # Build the prompt — load dream.md for dream job, else use command field
+        if job.id == DREAM_JOB_ID:
+            dream_prompt_path = Path(__file__).resolve().parents[2] / "prompts" / "main" / "dream.md"
+            if dream_prompt_path.is_file():
+                command_text = dream_prompt_path.read_text(encoding="utf-8").strip()
+            else:
+                command_text = job.command
+        else:
+            command_text = job.command
+
         prompt = (
             f"[Cron job: {job.id}]\n"
-            f"{job.command}"
+            f"{command_text}"
         )
 
         repo_root = Path.cwd().resolve()
@@ -372,6 +424,9 @@ class CronScheduler:
         self._lock = threading.Lock()
         self._running = False
 
+        # Auto-seed the dream memory job if it doesn't exist
+        ensure_dream_job(self.config)
+
     def start(self):
         """Start the cron scheduler background thread."""
         enabled_jobs = [j for j in self.config.jobs.values() if j.enabled]

package/src/core/memory.py

@@ -4,8 +4,9 @@ Two-layer persistent memory:
 - User memory (global): ~/.bone/user_memory.md
 - Project memory (per-repo): {repo_root}/.bone/agents.md
 
-The agent writes to these files via edit_file (auto-approved, fire-and-forget).
-Memory content is injected into the system prompt on every conversation start.
+Memory files are read-only during conversations — loaded into the system prompt
+for context but never written inline. All writes happen through the dream cron job,
+which consolidates user messages into focused memories nightly.
 """
 
 import logging
@@ -16,8 +17,6 @@ logger = logging.getLogger(__name__)
 
 # Capacity constants (prompt-enforced, no code enforcement)
 CHAR_LIMIT = 1500  # suggested chars per layer (~500 tokens)
-SECTION_LIMIT = 8   # suggested max sections per layer
-ENTRY_LIMIT = 20    # suggested max entries per section
 
 
 class MemoryManager:
@@ -80,17 +79,6 @@ class MemoryManager:
         """Read and return project memory file content. Returns empty string if missing."""
         return self._read_file(self.project_memory_path)
 
-    def load_all(self) -> str:
-        """Load both layers, combined for prompt injection."""
-        parts = []
-        user = self.load_user_memory()
-        project = self.load_project_memory()
-        if user.strip():
-            parts.append(user.strip())
-        if project.strip():
-            parts.append(project.strip())
-        return "\n\n".join(parts)
-
     def get_user_usage(self) -> dict:
         """Return {chars_used, chars_limit} for user memory."""
         content = self.load_user_memory()
@@ -101,81 +89,6 @@ class MemoryManager:
         content = self.load_project_memory()
         return {"chars_used": len(content), "chars_limit": CHAR_LIMIT}
 
-    def get_prompt_section(self) -> str:
-        """Build the full memory system prompt section.
-
-        Includes:
-        - Guidelines text with resolved file paths
-        - Capacity headers and memory content (if files have entries beyond headers)
-
-        Returns:
-            Complete prompt section string. Includes guidelines even when
-            memory files are empty (just headers). Returns guidelines with
-            placeholder paths if no MemoryManager instance exists.
-        """
-        user_path = str(self.user_memory_path)
-        project_path = str(self.project_memory_path)
-
-        lines = [
-            "## Memory System",
-            "",
-            "You have a two-layer memory system that persists across conversations:",
-            f"- User memory (global): {user_path} — preferences, identity, work patterns",
-            f"- Project memory (per-repo): {project_path} — context, conventions, decisions, current work",
-            "",
-            "Both memory layers are loaded into this prompt at conversation start. "
-            "You can already see all memories below.",
-            "",
-            "To save information, use `edit_file` to write directly to the memory files. "
-            "These edits are auto-approved and run silently.",
-            "Add a timestamp in parentheses: `*(YYYY-MM-DD)*`",
-            "",
-            "### Save these (proactively):",
-            "- User preferences: \"I prefer TypeScript over JavaScript\" → user memory",
-            "- Environment facts: \"This project uses Python 3.11 with pytest\" → project memory",
-            "- Corrections: \"Don't use sudo for docker, user is in docker group\" → project memory",
-            "- Conventions: \"Project uses tabs, 120-char line width\" → project memory",
-            "- Completed work: \"Migrated database schema on 2026-04-20\" → project memory",
-            "- Explicit requests: \"Remember that my API key rotation happens monthly\" → user memory",
-            "",
-            "### Skip these:",
-            "- Trivial/obvious info: \"User asked about Python\" — too vague to be useful",
-            "- Easily re-discovered facts: \"Python 3.12 supports f-string nesting\" — can web search this",
-            "- Raw data dumps: Large code blocks, log files, data tables — too big for memory",
-            "- Session-specific ephemera: Temporary file paths, one-off debugging context",
-            "- Information already in agents.md or other context files",
-            "",
-            "Keep memories concise and information-dense. Use the section that best fits the information.",
-            "To update a memory, edit the entry in place with a new timestamp.",
-            "To remove a memory, delete the line.",
-            f"Stay under {CHAR_LIMIT} chars per file (~500 tokens). "
-            f"When above 80% ({int(CHAR_LIMIT * 0.8)} chars), consolidate older entries before adding new ones.",
-        ]
-
-        # Add capacity headers and memory content if files have real content
-        user_content = self.load_user_memory()
-        user_usage = self.get_user_usage()
-        # Only show block if file has more than just the header
-        if self._has_entries(user_content):
-            pct = user_usage["chars_used"] * 100 // user_usage["chars_limit"]
-            lines.extend([
-                "",
-                f"USER MEMORY [{pct}% — {user_usage['chars_used']}/{user_usage['chars_limit']} chars]",
-                user_content.strip(),
-            ])
-
-        project_content = self.load_project_memory()
-        project_usage = self.get_project_usage()
-        if self._has_entries(project_content):
-            pct = project_usage["chars_used"] * 100 // project_usage["chars_limit"]
-            lines.extend([
-                "",
-                f"PROJECT MEMORY [{pct}% — {project_usage['chars_used']}/{project_usage['chars_limit']} chars]",
-                project_content.strip(),
-            ])
-
-        return "\n".join(lines)
-
     # ---- Private helpers ----
 
     @staticmethod

package/src/llm/config.py

@@ -354,7 +354,7 @@ def reload_config():
     
     Note: This is a manual operation - call after config changes.
     """
-    global _CONFIG, _provider_registry_cache, _cached_provider, PROVIDER_REGISTRY, LLM_PROVIDER, STATUS_BAR_SETTINGS
+    global _CONFIG, _provider_registry_cache, _cached_provider, PROVIDER_REGISTRY, LLM_PROVIDER, STATUS_BAR_SETTINGS, MEMORY_SETTINGS
     _CONFIG = _load_config()
     _provider_registry_cache = None
     _cached_provider = None
@@ -363,6 +363,8 @@ def reload_config():
     LLM_PROVIDER = _get_provider()
     # Rebuild status bar settings
     STATUS_BAR_SETTINGS = _build_status_bar_settings()
+    # Rebuild memory settings
+    MEMORY_SETTINGS = _build_memory_settings()
 
 
 def _build_status_bar_settings():
@@ -377,8 +379,27 @@ def _build_status_bar_settings():
     }
 
 
+def _build_memory_settings():
+    """Build MEMORY_SETTINGS dict from current _CONFIG."""
+    ms = _CONFIG.get("MEMORY_SETTINGS", {})
+    return {
+        "enabled": ms.get("enabled", True),
+    }
+
+
+def update_memory_settings(settings_dict):
+    """Update MEMORY_SETTINGS at runtime.
+
+    Returns:
+        Updated MEMORY_SETTINGS dict
+    """
+    global MEMORY_SETTINGS
+    MEMORY_SETTINGS.update(settings_dict)
+    return MEMORY_SETTINGS
+
+
 def update_status_bar_settings(settings_dict):
-    """Update STATUS_BAR_SETTINGS at runtime and persist to config.
+    """Update STATUS_BAR_SETTINGS at runtime.
 
     Args:
         settings_dict: Dict of settings to update (e.g., {"show_cost": False})
@@ -426,6 +447,8 @@ __all__ = [
     "reload_config",
     "STATUS_BAR_SETTINGS",
     "update_status_bar_settings",
+    "MEMORY_SETTINGS",
+    "update_memory_settings",
 ]
 
 
@@ -445,6 +468,9 @@ WEB_SEARCH_REQUIRE_CONFIRMATION = False
 # Status bar configuration
 STATUS_BAR_SETTINGS = _build_status_bar_settings()
 
+# Memory configuration
+MEMORY_SETTINGS = _build_memory_settings()
+
 # Tool approval modes
 APPROVE_MODES = ("safe", "accept_edits", "danger")
 CYCLEABLE_APPROVE_MODES = ("safe", "accept_edits")