bone-agent 1.3.1 → 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.
 
@@ -380,7 +322,7 @@ class AgenticOrchestrator:
             self.chat_manager.log_message(response)
 
             # NEW: Compact tool results after final answer (per-message compaction)
-            self.chat_manager.compact_tool_results()
+            self.chat_manager.compact_tool_results(skip_token_update=True)
 
             # Update context tokens with current mode's tools
             tools_for_mode = TOOLS()
@@ -597,9 +539,8 @@ class AgenticOrchestrator:
                 # Log tool result
                 self.chat_manager.log_message(tool_msg)
 
-                # Mid-loop compaction: compact older completed tool blocks
-                # after each tool result is appended (safe — only compacts completed blocks)
-                self.chat_manager.compact_tool_results()
+        # 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()
@@ -840,7 +781,7 @@ class AgenticOrchestrator:
 
             # Mid-loop compaction: compact older completed tool blocks
             # after all parallel results are appended (safe — only compacts completed blocks)
-            self.chat_manager.compact_tool_results()
+            self.chat_manager.compact_tool_results(skip_token_update=True)
 
             # Update context tokens with current mode's tools
             tools_for_mode = TOOLS()
@@ -909,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)
 
@@ -1023,6 +950,10 @@ class AgenticOrchestrator:
 
                 return False, str(result)
             except Exception as e:
+                # If thinking_indicator was paused (TERMINAL_YIELD) and tool
+                # raised, resume it so the spinner reappears for the next iteration
+                if policy == TERMINAL_YIELD and thinking_indicator:
+                    thinking_indicator.resume()
                 return False, f"Error executing tool '{function_name}': {str(e)}"
 
         return False, f"Error: Unknown tool '{function_name}'."

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]:
@@ -383,7 +404,7 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
 
     # ===== Tool Result Compaction =====
 
-    def _find_tool_blocks(self):
+    def _find_tool_blocks(self, include_in_flight=False):
         """Find all tool-result blocks in message history.
 
         Handles both single-turn and multi-turn tool chains:
@@ -394,6 +415,12 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         a single block spanning from the first assistant(tool_calls) to the
         final assistant(answer).
 
+        Args:
+            include_in_flight: If True, also return blocks that lack a final
+                assistant answer (in-flight tool chains). The 'end' field points
+                to the index after the last message in the chain (or the breaking
+                message index if the chain was interrupted).
+
         Returns:
             list: List of block dicts with keys: user_idx, start, end, tool_calls, tool_results
         """
@@ -441,14 +468,25 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
                         # Non-tool, non-assistant message breaks the chain
                         break
 
-                if found_end and all_tool_calls:
-                    blocks.append({
-                        'user_idx': user_idx,
-                        'start': block_start,
-                        'end': j,
-                        'tool_calls': all_tool_calls,
-                        'tool_results': all_tool_results
-                    })
+                if include_in_flight:
+                    if all_tool_calls:
+                        blocks.append({
+                            'user_idx': user_idx,
+                            'start': block_start,
+                            'end': j,
+                            'tool_calls': all_tool_calls,
+                            'tool_results': all_tool_results,
+                            'in_flight': not found_end,
+                        })
+                else:
+                    if found_end and all_tool_calls:
+                        blocks.append({
+                            'user_idx': user_idx,
+                            'start': block_start,
+                            'end': j,
+                            'tool_calls': all_tool_calls,
+                            'tool_results': all_tool_results,
+                        })
 
                 # Continue scanning from after the final answer (or after the chain)
                 # Guard: always advance at least one position to prevent infinite loops
@@ -635,68 +673,21 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
     def _find_in_flight_boundary(self):
         """Find the index where in-flight tool blocks begin.
 
-        Scans from the end of messages for any assistant message with tool_calls
-        that does NOT have a corresponding final assistant answer after it.
+        Delegates to _find_tool_blocks(include_in_flight=True) to find all
+        blocks, then returns the earliest start of any in-flight block.
         These messages must never be included in the compactable region.
 
         Returns:
             int: Index of the first in-flight message, or len(messages) if none.
         """
-        n = len(self.messages)
-        i = n - 1
-
-        # Walk backward looking for the pattern: ...assistant(tool_calls) tool_results...
-        # without a final assistant(answer) after the tool results.
-        while i >= 0:
-            msg = self.messages[i]
-            if msg.get('role') == 'assistant' and msg.get('tool_calls'):
-                # Found an assistant with tool_calls. Check if there's a final
-                # answer (assistant without tool_calls) after it.
-                has_final_answer = False
-                j = i + 1
-                while j < n:
-                    if self.messages[j].get('role') == 'assistant' and not self.messages[j].get('tool_calls'):
-                        has_final_answer = True
-                        break
-                    elif self.messages[j].get('role') == 'assistant' and self.messages[j].get('tool_calls'):
-                        # Another tool-calling assistant — skip over its tool results
-                        j += 1
-                        while j < n and self.messages[j].get('role') == 'tool':
-                            j += 1
-                        continue
-                    elif self.messages[j].get('role') == 'tool':
-                        j += 1
-                        continue
-                    else:
-                        break
-
-                if not has_final_answer:
-                    # This is an in-flight tool block. Find its user question.
-                    user_idx = i - 1
-                    while user_idx >= 0 and self.messages[user_idx].get('role') != 'user':
-                        user_idx -= 1
-                    return max(0, user_idx)
-                else:
-                    # Completed block — continue scanning backward
-                    # Skip past all the tool messages associated with this block
-                    j = i + 1
-                    while j < n:
-                        if self.messages[j].get('role') == 'tool':
-                            j += 1
-                        elif self.messages[j].get('role') == 'assistant' and self.messages[j].get('tool_calls'):
-                            j += 1
-                            while j < n and self.messages[j].get('role') == 'tool':
-                                j += 1
-                            continue
-                        else:
-                            break
-                    i = j - 1
-            else:
-                i -= 1
-
-        return n
-
-    def _compute_split_boundary(self, blocks, in_flight_start):
+        all_blocks = self._find_tool_blocks(include_in_flight=True)
+        in_flight = [b for b in all_blocks if b.get('in_flight')]
+        if in_flight:
+            return min(b['user_idx'] for b in in_flight)
+        return len(self.messages)
+
+    def _compute_split_boundary(self, blocks, in_flight_start,
+                                uncompacted_tail_tokens=None, min_tool_blocks=None):
         """Compute the message index where the uncompacted tail begins.
 
         Three constraints determine the boundary (take the most conservative /
@@ -709,19 +700,23 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         Args:
             blocks: List of tool block dicts from _find_tool_blocks()
             in_flight_start: Index of first in-flight message (from _find_in_flight_boundary)
+            uncompacted_tail_tokens: Override for the token budget (None = use settings)
+            min_tool_blocks: Override for minimum tool blocks to preserve (None = use settings)
 
         Returns:
             int: Message index where the uncompacted tail starts
         """
         tc = context_settings.tool_compaction
-        token_budget = tc.uncompacted_tail_tokens
-        min_blocks = tc.min_tool_blocks
+        token_budget = uncompacted_tail_tokens if uncompacted_tail_tokens is not None else tc.uncompacted_tail_tokens
+        min_blocks = min_tool_blocks if min_tool_blocks is not None else tc.min_tool_blocks
         n = len(self.messages)
 
         # The verbatim region ends at the first in-flight message (exclusive)
         verbatim_end = min(in_flight_start, n)
 
-        # Constraint 1: Token budget — walk from verbatim_end backward
+        # Constraint 1: Token budget — walk from verbatim_end backward.
+        # Note: range stops at 1 (not 0) so the system prompt is never counted
+        # toward the budget — it is always preserved uncompacted.
         tokens_accumulated = 0
         token_boundary = 0
         for i in range(verbatim_end - 1, 0, -1):
@@ -734,25 +729,16 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
             token_boundary = 1
 
         # Constraint 2: Minimum tool blocks — ensure at least min_blocks completed
-        # blocks are within the verbatim tail
+        # blocks are within the uncompacted tail. Take the min_blocks most recent
+        # completed blocks and set the boundary so they all fall at or after it.
         min_block_boundary = 1
-        completed_blocks_in_tail = []
-        for block in blocks:
-            # A block is in the tail if its end is within the verbatim region
-            if block['end'] < verbatim_end:
-                completed_blocks_in_tail.append(block)
-
-        if len(completed_blocks_in_tail) < min_blocks and len(completed_blocks_in_tail) < len(blocks):
-            # Need to extend backward to include more blocks
-            blocks_needed = min_blocks - len(completed_blocks_in_tail)
-            # Take the blocks immediately before the current tail
-            # Find blocks whose end < token_boundary (not already in tail)
-            earlier_blocks = [b for b in blocks if b['end'] < token_boundary]
-            # Sort by end index descending (most recent first)
-            earlier_blocks.sort(key=lambda b: b['end'], reverse=True)
-            # Extend boundary to include the earliest user_idx of the blocks we need
-            for b in earlier_blocks[:blocks_needed]:
-                min_block_boundary = min(min_block_boundary, b['user_idx'])
+        if min_blocks > 0 and len(blocks) >= min_blocks:
+            # Sort by end index descending (most recent first), take top min_blocks
+            sorted_blocks = sorted(blocks, key=lambda b: b['end'], reverse=True)
+            recent_blocks = sorted_blocks[:min_blocks]
+            # The boundary must be at or before the earliest user_idx of these blocks
+            # so that all of them satisfy user_idx >= boundary (i.e. block is fully in the tail)
+            min_block_boundary = min(b['user_idx'] for b in recent_blocks)
 
         # Constraint 3: Tool-call integrity — if token_boundary lands inside a
         # tool block, extend backward to include the complete block
@@ -763,13 +749,15 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
                 integrity_boundary = min(integrity_boundary, block['user_idx'])
 
         # Take the most conservative (earliest) boundary
-        boundary = min(token_boundary, integrity_boundary)
+        # integrity_boundary <= token_boundary always (starts equal, only decreases)
+        boundary = integrity_boundary
         if min_block_boundary < boundary:
             boundary = min_block_boundary
 
         return boundary
 
-    def compact_tool_results(self):
+    def compact_tool_results(self, skip_token_update=False,
+                              uncompacted_tail_tokens=None, min_tool_blocks=None):
         """Replace completed tool-result blocks with summaries using token-budget tail.
 
         Walks messages from the end, accumulating tokens until ~40k tokens are
@@ -779,6 +767,15 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
 
         Safe to call mid-loop (during tool execution) because it only compacts
         completed tool blocks — in-flight blocks are never touched.
+
+        Args:
+            skip_token_update: If True, skip the internal _update_context_tokens()
+                call. Use when the caller will update tokens with mode-specific
+                tools immediately after.
+            uncompacted_tail_tokens: Override for the token budget (None = use settings).
+                Use for aggressive compaction with a smaller tail.
+            min_tool_blocks: Override for minimum tool blocks to preserve (None = use settings).
+                Use for aggressive compaction with fewer preserved blocks.
         """
         # Skip if disabled (e.g. sub-agents preserving findings)
         if self._compaction_disabled:
@@ -801,7 +798,11 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         in_flight_start = self._find_in_flight_boundary()
 
         # Compute the split boundary using token budget + constraints
-        split_boundary = self._compute_split_boundary(blocks, in_flight_start)
+        split_boundary = self._compute_split_boundary(
+            blocks, in_flight_start,
+            uncompacted_tail_tokens=uncompacted_tail_tokens,
+            min_tool_blocks=min_tool_blocks,
+        )
 
         # Determine which blocks fall entirely before the split boundary
         # (those are the ones to compact)
@@ -864,7 +865,8 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
                 new_messages.append(msg)
 
         self.messages = new_messages
-        self._update_context_tokens()
+        if not skip_token_update:
+            self._update_context_tokens()
 
     # ===== AI-Based History Compaction =====
 
@@ -1101,16 +1103,12 @@ Provide a concise summary (2-4 paragraphs) that captures all essential context f
         # If compaction is NOT locked, try layers 1 and 2
         if not self._compaction_locked:
             # Layer 1: Aggressive tool result compaction (non-LLM, fast)
-            # Temporarily use very small token budget and min blocks for aggressive compaction
-            original_tail_tokens = context_settings.tool_compaction.uncompacted_tail_tokens
-            original_min_blocks = context_settings.tool_compaction.min_tool_blocks
-            try:
-                context_settings.tool_compaction.uncompacted_tail_tokens = 10_000
-                context_settings.tool_compaction.min_tool_blocks = 1
-                self.compact_tool_results()
-            finally:
-                context_settings.tool_compaction.uncompacted_tail_tokens = original_tail_tokens
-                context_settings.tool_compaction.min_tool_blocks = original_min_blocks
+            # Use very small token budget and min blocks for aggressive compaction
+            self.compact_tool_results(
+                skip_token_update=True,
+                uncompacted_tail_tokens=10_000,
+                min_tool_blocks=1,
+            )
 
             self._update_context_tokens()
             current_tokens = self.token_tracker.current_context_tokens
@@ -1399,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),
@@ -1406,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)
@@ -1482,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]