alpiecode 10.0.3__tar.gz → 10.5.0__tar.gz

{alpiecode-10.0.3 → alpiecode-10.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.0.3
+Version: 10.5.0
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.0.3 → alpiecode-10.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.0.3"
+version = "10.5.0"
 description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.0.3
+Version: 10.5.0
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/alpiecode.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ src/codeagent/config.py
 src/codeagent/context.py
 src/codeagent/discovery.py
 src/codeagent/doctor.py
+src/codeagent/dream_rsi.py
 src/codeagent/executor.py
 src/codeagent/git_ops.py
 src/codeagent/github.py
@@ -41,19 +42,4 @@ src/codeagent/backends/__init__.py
 src/codeagent/backends/base.py
 src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
-src/codeagent/extension/alpiecode.vsix
-test/test_audit_fixes.py
-test/test_benchmark_system1.py
-test/test_cache_reads.py
-test/test_chat_mode.py
-test/test_claude_codex_capabilities.py
-test/test_context_filter.py
-test/test_math_tools.py
-test/test_metrics.py
-test/test_offline_mode.py
-test/test_offline_opt.py
-test/test_palindrome_check.py
-test/test_phase1.py
-test/test_phase2.py
-test/test_phase3.py
-test/test_system1.py
+src/codeagent/extension/alpiecode.vsix

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/codeagent/__init__.py

@@ -17,7 +17,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "10.0.3"
+__version__ = "10.5.0"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/codeagent/agent.py

@@ -340,7 +340,8 @@ def run_agent(
                     console.print(f"📺 URL: {url}", style="cyan")
 
         elif event.type == "adaptive_mode" and verbose and HAS_RICH:
-            console.print("⚡ [dim]Adaptive mode: simple task detected, skipping deep reasoning for speed[/dim]")
+            msg = event.data.get("message") or "Adaptive mode: reasoning trace adjusted."
+            console.print(f"⚡ [dim]{msg}[/dim]")
 
         elif event.type == "status":
             phase = event.data.get("phase")

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/codeagent/backends/local_backend.py

@@ -99,8 +99,17 @@ class LocalBackend:
                         fn = tc.get("function", {})
                         name = fn.get("name", "unknown")
                         args = fn.get("arguments", "{}")
+                        # Do not duplicate full file content in context history
+                        if name in ("write_file", "edit_file"):
+                            try:
+                                import json as _json
+                                a_dict = _json.loads(args) if isinstance(args, str) else args
+                                p = a_dict.get("path") or a_dict.get("filename") or ""
+                                args = f'{"path": "{p}"}'
+                            except Exception:
+                                args = "{...}"
                         tc_descriptions.append(f"[Called tool: {name}({args})]")
-                if tc_descriptions:
+                if tc_descriptions and "<tool_call>" not in content:
                     content = (content + "\n" + "\n".join(tc_descriptions)).strip()
                 # Do NOT include tool_calls key — GGUF template will crash on it
 
@@ -247,7 +256,9 @@ class LocalBackend:
                         inside_suppressed_think = True
                         text = text.replace("<think>", "")
                     if inside_suppressed_think:
-                        if "</think>" in text:
+                        if "<tool_call>" in text or "DONE:" in text or "<function=" in text:
+                            inside_suppressed_think = False
+                        elif "</think>" in text:
                             _, after = text.split("</think>", 1)
                             inside_suppressed_think = False
                             text = after

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/codeagent/backends/openai_backend.py

@@ -57,11 +57,15 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
     # Check unclosed quotes: count non-escaped double quotes
     quote_count = len(re.findall(r'(?<!\\)"', repaired))
     if quote_count % 2 != 0:
+        dangling_bs = len(repaired) - len(repaired.rstrip('\\'))
+        if dangling_bs % 2 != 0:
+            repaired = repaired[:-1]
         repaired += '"'
 
-    # Balance unclosed brackets and braces
-    open_curly = repaired.count("{") - repaired.count("}")
-    open_square = repaired.count("[") - repaired.count("]")
+    # Balance unclosed brackets and braces outside string literals
+    stripped = re.sub(r'"(?:\\.|[^"\\])*"', '""', repaired)
+    open_curly = stripped.count("{") - stripped.count("}")
+    open_square = stripped.count("[") - stripped.count("]")
 
     if open_square > 0:
         repaired += "]" * open_square
@@ -91,6 +95,9 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
                 extracted[k] = v_lit
 
     if extracted:
+        if "name" in extracted and "arguments" not in extracted:
+            args = {k: v for k, v in extracted.items() if k not in ("name", "id", "type")}
+            return {"name": extracted["name"], "arguments": args}
         return extracted
 
     logger.warning("Failed to parse tool call arguments: %s", raw_args[:200])

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/codeagent/cli.py

@@ -29,7 +29,7 @@ def _show_banner():
 
 
 def _normalize_args():
-    known_commands = {"init", "serve", "run", "chat", "plan", "diff", "undo", "doctor", "explain", "version", "-h", "--help", "-v", "--version"}
+    known_commands = {"init", "serve", "run", "chat", "plan", "diff", "undo", "doctor", "explain", "dream", "version", "-h", "--help", "-v", "--version"}
     subcommand = None
     
     # Check if a subcommand is present
@@ -131,6 +131,12 @@ def main():
     explain_p = sub.add_parser("explain", help="Explain a file, function, or codebase concept", parents=[common])
     explain_p.add_argument("target", help="File path or concept to explain")
 
+    # ?? dream ??
+    dream_p = sub.add_parser('dream', help='Dream-RSI: offline recursive self-improvement simulation')
+    dream_p.add_argument('--optimize', action='store_true', help='Run offline dreaming simulation to synthesize optimal search policy')
+    dream_p.add_argument('--stats', action='store_true', help='Show trajectory replay metrics and active policy status')
+    dream_p.add_argument('--clear', action='store_true', help='Clear historical trajectory replay pool')
+
     args = parser.parse_args()
 
     if not args.command:
@@ -145,6 +151,52 @@ def main():
         interactive_init()
         return
 
+    if args.command == 'dream':
+        import time
+        from .dream_rsi import TrajectoryStore, DreamOptimizer, load_active_dream_profile
+        store = TrajectoryStore()
+        optimizer = DreamOptimizer(store)
+        if getattr(args, 'clear', False):
+            count = store.clear_trajectories()
+            print(f'?? Cleared {count} historical trajectories from replay pool.')
+            return
+        if getattr(args, 'optimize', False):
+            print('?? Running Dream-RSI offline recursive self-improvement simulation...')
+            profile, res = optimizer.optimize()
+            if res.get('status') == 'no_trajectories':
+                print('??  No historical trajectories recorded yet. Run tasks with alpiecode run to populate the replay buffer.')
+                return
+            metrics = res.get('metrics', {})
+            print('\n? Dream-RSI Optimization Complete!')
+            print(f'   ?? Trajectories Replayed: {metrics.get("total_trajectories", 0)}')
+            print(f'   ??  Total Turns Saved:     {metrics.get("total_turns_saved", 0)}')
+            print(f'   ?? Loops Prevented:       {metrics.get("total_loops_prevented", 0)}')
+            print(f'   ?? Stalls Averted:         {metrics.get("total_stalls_averted", 0)}')
+            print(f'   ? Simulation Fitness:     {metrics.get("average_score", 0.0)}')
+            print('\n?? Active Policy Updated:')
+            print(f'   ? Syntax Loop Threshold:   {profile.syntax_loop_threshold}')
+            print(f'   ? General Loop Threshold:  {profile.general_loop_threshold}')
+            print(f'   ? Stall Trigger:           {profile.stall_threshold}')
+            print(f'   ? Single-File Enforcement: {profile.single_file_enforcement}')
+            return
+        trajectories = store.list_trajectories()
+        profile = load_active_dream_profile()
+        successes = sum(1 for t in trajectories if t.outcome == 'success')
+        failures = sum(1 for t in trajectories if t.outcome != 'success')
+        print('\n?? Dream-RSI Status & Replay Pool')
+        print(f'   ?? Replay Buffer:          {len(trajectories)} trajectories stored')
+        print(f'   ? Successful Runs:        {successes}')
+        print(f'   ??  Failed/Stalled Runs:    {failures}')
+        print('\n?? Active Policy Profile:')
+        print(f'   ? Syntax Loop Threshold:   {profile.syntax_loop_threshold}')
+        print(f'   ? General Loop Threshold:  {profile.general_loop_threshold}')
+        print(f'   ? Stall Trigger:           {profile.stall_threshold}')
+        print(f'   ? Single-File Enforcement: {profile.single_file_enforcement}')
+        opt_time = time.ctime(profile.last_optimized_at) if profile.last_optimized_at else 'Never'
+        print(f'   ? Last Optimized:          {opt_time}')
+        print('\n?? Tip: Run alpiecode dream --optimize to run offline self-improvement.')
+        return
+
     if args.command == "doctor":
         from .doctor import run_doctor
         sys.exit(run_doctor())

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/codeagent/discovery.py

@@ -565,6 +565,11 @@ def gather_relevant_context(
         return None
 
     task_lower = task.lower().strip()
+
+    # Skip pre-reading repo files for standalone algorithms or scripts (e.g. palindrome, calculator)
+    standalone_kws = ["palindrome", "fibonacci", "quicksort", "bubblesort", "factorial", "hello world", "calculator", "reverse string", "reverse_string"]
+    if any(kw in task_lower for kw in standalone_kws):
+        return None
     sections: List[str] = []
     chars_used = 0
 

alpiecode-10.5.0/src/codeagent/dream_rsi.py

@@ -0,0 +1,373 @@
+"""
+Dream-RSI: Recursive Self-Improvement through Evolving Worlds for AlpieCode.
+Reference: DeepMind / UMD / UVA (arXiv:2609.14858).
+
+Decouples agent exploration/intervention policies from LLM weights:
+  1. TrajectoryRecorder: Logs complete discovery trees to ~/.alpiecode/trajectories/
+  2. ReplaySimulator: Fast offline world model evaluating counterfactual search policies
+  3. DreamOptimizer: Simulates candidate policies over replay trees at near-zero compute cost
+  4. DreamStrategyProfile: Distilled high-performance policy used by System 1 (< 1ms runtime)
+"""
+
+import hashlib
+import json
+import logging
+import os
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+TRAJECTORY_DIR = Path.home() / ".alpiecode" / "trajectories"
+POLICY_PATH = Path.home() / ".alpiecode" / "dream_policy.json"
+
+
+# ?? 1. Trajectory Data Models ??????????????????????????????????????????
+
+@dataclass
+class TurnSnapshot:
+    turn: int
+    tool_calls: List[Dict[str, Any]] = field(default_factory=list)
+    tool_results: List[Dict[str, Any]] = field(default_factory=list)
+    error_types: List[str] = field(default_factory=list)
+    had_error: bool = False
+    system1_action: Optional[str] = None
+    system1_directive: Optional[str] = None
+    duration_ms: float = 0.0
+    tokens_estimated: int = 0
+
+
+@dataclass
+class TrajectoryRecord:
+    session_id: str
+    task: str
+    complexity: str = "low"
+    is_offline: bool = False
+    created_at: float = field(default_factory=time.time)
+    turns: List[TurnSnapshot] = field(default_factory=list)
+    outcome: str = "in_progress"  # "success", "failed", "stalled", "cancelled"
+    total_duration_ms: float = 0.0
+    total_turns: int = 0
+    total_tokens: int = 0
+    files_touched: List[str] = field(default_factory=list)
+    error_summary: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TrajectoryRecord":
+        turns_data = data.pop("turns", [])
+        turns = [TurnSnapshot(**t) for t in turns_data]
+        return cls(turns=turns, **data)
+
+
+# ?? 2. Trajectory Persistence Store ?????????????????????????????????????
+
+class TrajectoryStore:
+    """Local persistent repository of discovery trajectories."""
+
+    def __init__(self, storage_dir: Optional[Path] = None):
+        self.storage_dir = storage_dir or TRAJECTORY_DIR
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+
+    def save_trajectory(self, record: TrajectoryRecord) -> Path:
+        """Save a completed trajectory atomically to disk."""
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+        file_path = self.storage_dir / f"{record.session_id}.json"
+        temp_path = self.storage_dir / f"{record.session_id}.json.tmp"
+
+        try:
+            with open(temp_path, "w", encoding="utf-8") as f:
+                json.dump(record.to_dict(), f, indent=2)
+            os.replace(temp_path, file_path)
+        except Exception as e:
+            if temp_path.exists():
+                temp_path.unlink()
+            logger.warning("Failed to save trajectory %s: %s", record.session_id, e)
+
+        return file_path
+
+    def load_trajectory(self, session_id: str) -> Optional[TrajectoryRecord]:
+        """Load a specific trajectory record by session ID."""
+        path = self.storage_dir / f"{session_id}.json"
+        if not path.exists():
+            return None
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return TrajectoryRecord.from_dict(data)
+        except Exception as e:
+            logger.warning("Failed to load trajectory %s: %s", session_id, e)
+            return None
+
+    def list_trajectories(self, limit: int = 100) -> List[TrajectoryRecord]:
+        """List recent discovery trajectories, sorted newest first."""
+        if not self.storage_dir.exists():
+            return []
+
+        records = []
+        files = sorted(self.storage_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+        for p in files[:limit]:
+            try:
+                with open(p, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                records.append(TrajectoryRecord.from_dict(data))
+            except Exception:
+                continue
+        return records
+
+    def clear_trajectories(self) -> int:
+        """Remove all historical trajectories. Returns count removed."""
+        if not self.storage_dir.exists():
+            return 0
+        count = 0
+        for p in self.storage_dir.glob("*.json"):
+            try:
+                p.unlink()
+                count += 1
+            except Exception:
+                pass
+        return count
+
+
+# ?? 3. Distilled Strategy Profile ??????????????????????????????????????
+
+@dataclass
+class DreamStrategyProfile:
+    """
+    Distilled exploration and intervention policy synthesized by Dream-RSI.
+    Directly consumed by System 1 and Orchestrator in < 1ms.
+    """
+    syntax_loop_threshold: int = 1       # Intervene on syntax errors at turn 1
+    general_loop_threshold: int = 2      # Intervene on general repeated errors at turn 2
+    stall_threshold: int = 3             # Consecutive turns without file progress before intervention
+    single_file_enforcement: bool = True # For multi-file offline tasks, write 1 file per turn
+    prefer_surgical_edits: bool = True   # Favor edit_file over full write_file on error recovery
+    nudge_missing_tools: bool = True     # Nudge when model speaks text without tools on early turns
+    max_offline_tokens: int = 2048       # Maximum token headroom ceiling for offline generation
+    version: int = 1
+    last_optimized_at: float = field(default_factory=time.time)
+    trajectories_evaluated: int = 0
+    estimated_turns_saved: int = 0
+    loop_prevention_score: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "DreamStrategyProfile":
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+
+def load_active_dream_profile(path: Optional[Path] = None) -> DreamStrategyProfile:
+    """Load the current active dream policy profile."""
+    target = path or POLICY_PATH
+    if not target.exists():
+        return DreamStrategyProfile()
+    try:
+        with open(target, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return DreamStrategyProfile.from_dict(data)
+    except Exception:
+        return DreamStrategyProfile()
+
+
+def save_active_dream_profile(profile: DreamStrategyProfile, path: Optional[Path] = None) -> None:
+    """Save a synthesized dream policy profile."""
+    target = path or POLICY_PATH
+    target.parent.mkdir(parents=True, exist_ok=True)
+    tmp = target.with_suffix(".tmp")
+    try:
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(profile.to_dict(), f, indent=2)
+        os.replace(tmp, target)
+    except Exception as e:
+        if tmp.exists():
+            tmp.unlink()
+        logger.warning("Failed to save dream policy: %s", e)
+
+
+# ?? 4. Replay Simulator (The Dream Engine) ?????????????????????????????
+
+class ReplaySimulator:
+    """
+    Offline simulator that replays recorded discovery trajectories under
+    counterfactual policy rules at near-zero execution cost.
+    """
+
+    def evaluate_trajectory(
+        self,
+        trajectory: TrajectoryRecord,
+        profile: DreamStrategyProfile,
+    ) -> Dict[str, Any]:
+        """
+        Simulate how a given policy profile would have handled this trajectory.
+        Computes counterfactual turns saved, loop prevention, and recovery efficiency.
+        """
+        turns_saved = 0
+        loops_prevented = 0
+        stalls_averted = 0
+        early_nudges = 0
+
+        action_counts: Dict[str, int] = {}
+
+        for turn in trajectory.turns:
+            for tc in turn.tool_calls:
+                name = tc.get("name", "")
+                path = tc.get("arguments", {}).get("path") or tc.get("arguments", {}).get("command") or ""
+                sig = f"{name}:{path}"
+                action_counts[sig] = action_counts.get(sig, 0) + 1
+
+                # Counterfactual Loop Evaluation
+                has_syntax = "syntax" in turn.error_types
+                threshold = profile.syntax_loop_threshold if has_syntax else profile.general_loop_threshold
+                if action_counts[sig] >= threshold and turn.had_error:
+                    loops_prevented += 1
+                    # If this loop occurred at a higher threshold historically, we save turns
+                    if action_counts[sig] > threshold:
+                        turns_saved += (action_counts[sig] - threshold)
+
+            # Counterfactual Multi-File Token Budget Check
+            if profile.single_file_enforcement and trajectory.is_offline:
+                write_calls = [tc for tc in turn.tool_calls if tc.get("name") == "write_file"]
+                if len(write_calls) > 1:
+                    # In historical run, bundling multiple writes caused truncation/error
+                    turns_saved += 1
+                    stalls_averted += 1
+
+            # Counterfactual Conversational Nudge Check
+            if profile.nudge_missing_tools and not turn.tool_calls and turn.turn < 5:
+                if trajectory.outcome != "success":
+                    early_nudges += 1
+                    turns_saved += 1
+
+        # Net effectiveness score
+        base_score = 100.0 if trajectory.outcome == "success" else 20.0
+        policy_gain = (turns_saved * 15.0) + (loops_prevented * 20.0) + (stalls_averted * 25.0)
+        final_score = base_score + policy_gain
+
+        return {
+            "session_id": trajectory.session_id,
+            "turns_saved": turns_saved,
+            "loops_prevented": loops_prevented,
+            "stalls_averted": stalls_averted,
+            "score": final_score,
+        }
+
+    def evaluate_policy(
+        self,
+        profile: DreamStrategyProfile,
+        trajectories: List[TrajectoryRecord],
+    ) -> Dict[str, Any]:
+        """Evaluate candidate profile across the entire replay buffer."""
+        if not trajectories:
+            return {
+                "total_trajectories": 0,
+                "total_turns_saved": 0,
+                "total_loops_prevented": 0,
+                "average_score": 0.0,
+            }
+
+        total_turns_saved = 0
+        total_loops_prevented = 0
+        total_stalls_averted = 0
+        total_score = 0.0
+
+        for traj in trajectories:
+            res = self.evaluate_trajectory(traj, profile)
+            total_turns_saved += res["turns_saved"]
+            total_loops_prevented += res["loops_prevented"]
+            total_stalls_averted += res["stalls_averted"]
+            total_score += res["score"]
+
+        count = len(trajectories)
+        return {
+            "total_trajectories": count,
+            "total_turns_saved": total_turns_saved,
+            "total_loops_prevented": total_loops_prevented,
+            "total_stalls_averted": total_stalls_averted,
+            "average_score": round(total_score / count, 2),
+        }
+
+
+# ?? 5. Dream Optimizer (Offline Self-Improvement Loop) ??????????????????
+
+class DreamOptimizer:
+    """
+    Recursive Self-Improvement (RSI) optimizer that searches parameter space
+    across recorded trajectory trees to find the optimal search harness.
+    """
+
+    def __init__(self, store: Optional[TrajectoryStore] = None):
+        self.store = store or TrajectoryStore()
+        self.simulator = ReplaySimulator()
+
+    def optimize(
+        self,
+        trajectories: Optional[List[TrajectoryRecord]] = None,
+    ) -> Tuple[DreamStrategyProfile, Dict[str, Any]]:
+        """
+        Run the dream optimization cycle over available discovery trees.
+        Returns the winning profile and its performance metrics.
+        """
+        traj_pool = trajectories if trajectories is not None else self.store.list_trajectories(limit=250)
+
+        best_profile = DreamStrategyProfile(
+            trajectories_evaluated=len(traj_pool),
+            last_optimized_at=time.time(),
+        )
+
+        if not traj_pool:
+            # No replay data yet; return baseline defaults
+            return best_profile, {"status": "no_trajectories", "message": "No historical trajectories to replay yet."}
+
+        best_score = -1.0
+        best_stats = {}
+
+        # Exploration Policy Search Grid (Dream Simulation Space)
+        syntax_thresholds = [1, 2]
+        general_thresholds = [1, 2, 3]
+        stall_thresholds = [2, 3, 4]
+        single_file_options = [True, False]
+        nudge_options = [True, False]
+
+        for st in syntax_thresholds:
+            for gt in general_thresholds:
+                for stall in stall_thresholds:
+                    for sfo in single_file_options:
+                        for no in nudge_options:
+                            candidate = DreamStrategyProfile(
+                                syntax_loop_threshold=st,
+                                general_loop_threshold=gt,
+                                stall_threshold=stall,
+                                single_file_enforcement=sfo,
+                                nudge_missing_tools=no,
+                                prefer_surgical_edits=True,
+                                max_offline_tokens=2048,
+                                trajectories_evaluated=len(traj_pool),
+                                last_optimized_at=time.time(),
+                            )
+
+                            metrics = self.simulator.evaluate_policy(candidate, traj_pool)
+                            score = metrics["average_score"]
+
+                            if score > best_score:
+                                best_score = score
+                                candidate.estimated_turns_saved = metrics["total_turns_saved"]
+                                candidate.loop_prevention_score = round(
+                                    metrics["total_loops_prevented"] / max(1, len(traj_pool)), 2
+                                )
+                                best_profile = candidate
+                                best_stats = metrics
+
+        # Persist winning policy
+        save_active_dream_profile(best_profile)
+
+        return best_profile, {
+            "status": "optimized",
+            "winning_profile": best_profile.to_dict(),
+            "metrics": best_stats,
+        }

{alpiecode-10.0.3 → alpiecode-10.5.0}/src/codeagent/executor.py

@@ -49,9 +49,16 @@ def parse_text_tool_calls(text: str) -> List[dict]:
         try:
             data = _repair_and_parse_json_arguments(raw)
             if isinstance(data, dict) and "name" in data:
+                args = data.get("arguments")
+                if not isinstance(args, dict) or not args:
+                    fallback_args = {k: v for k, v in data.items() if k not in ("name", "id", "type", "_raw_arguments", "_parse_error")}
+                    if fallback_args:
+                        args = fallback_args
+                    elif not isinstance(args, dict):
+                        args = {}
                 tool_calls.append({
                     "name": data["name"],
-                    "arguments": data.get("arguments", {})
+                    "arguments": args
                 })
         except Exception:
             pass