alpiecode 10.0.3__tar.gz → 10.5.1__tar.gz

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

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

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

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

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

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

{alpiecode-10.0.3 → alpiecode-10.5.1}/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
@@ -42,18 +43,5 @@ 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
+test/test_context_and_trajectory.py
+test/test_dream_rsi.py

{alpiecode-10.0.3 → alpiecode-10.5.1}/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.1"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.0.3 → alpiecode-10.5.1}/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.1}/src/codeagent/backends/local_backend.py

@@ -91,17 +91,38 @@ class LocalBackend:
             elif not isinstance(content, str):
                 content = str(content)
 
-            # For assistant messages with tool_calls, embed tool call info in content text
+            # For assistant messages, condense bulky write_file / edit_file payloads from content
+            if role == "assistant":
+                from ..compaction import compact_text_tool_calls
+                content = compact_text_tool_calls(content)
+
+            # For assistant messages with tool_calls, embed tool call info in content text ONLY if not already marked
             if role == "assistant" and msg.get("tool_calls"):
-                tc_descriptions = []
-                for tc in msg["tool_calls"]:
-                    if isinstance(tc, dict):
-                        fn = tc.get("function", {})
-                        name = fn.get("name", "unknown")
-                        args = fn.get("arguments", "{}")
-                        tc_descriptions.append(f"[Called tool: {name}({args})]")
-                if tc_descriptions:
-                    content = (content + "\n" + "\n".join(tc_descriptions)).strip()
+                already_marked = (
+                    "[Completed " in content
+                    or "[Incomplete" in content
+                    or "[Called tool:" in content
+                    or "<tool_call>" in content
+                )
+                if not already_marked:
+                    tc_descriptions = []
+                    for tc in msg["tool_calls"]:
+                        if isinstance(tc, dict):
+                            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", "apply_patch"):
+                                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 a_dict.get("file") or ""
+                                    args = f'{{"path": "{p}"}}'
+                                except Exception:
+                                    args = "{...}"
+                            tc_descriptions.append(f"[Called tool: {name}({args})]")
+                    if tc_descriptions:
+                        content = (content + "\n" + "\n".join(tc_descriptions)).strip()
                 # Do NOT include tool_calls key — GGUF template will crash on it
 
             clean["content"] = content
@@ -247,7 +268,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.1}/src/codeagent/backends/openai_backend.py

@@ -54,14 +54,20 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
     # If trailing comma at end: `{"a": 1,` -> `{"a": 1`
     repaired = re.sub(r",\s*$", "", repaired)
 
+    was_truncated = False
     # Check unclosed quotes: count non-escaped double quotes
     quote_count = len(re.findall(r'(?<!\\)"', repaired))
     if quote_count % 2 != 0:
+        was_truncated = True
+        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
@@ -71,6 +77,8 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
     try:
         parsed = json.loads(repaired)
         if isinstance(parsed, dict):
+            if was_truncated:
+                parsed["_was_truncated"] = True
             return parsed
     except Exception:
         pass
@@ -91,6 +99,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.1}/src/codeagent/cli.py

@@ -29,18 +29,30 @@ 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
-    
+
+    # Normalize common flag typos / aliases before parsing
+    for idx, arg in enumerate(sys.argv):
+        if arg in ("--offlie", "-offline"):
+            sys.argv[idx] = "--offline"
+
     # Check if a subcommand is present
     for arg in sys.argv[1:]:
         if arg in known_commands:
             subcommand = arg
             break
-            
+
     if not subcommand and len(sys.argv) > 1:
-        subcommand = "run"
-        sys.argv.insert(1, "run")
+        # Determine if any positional non-flag argument was provided
+        positional_args = [a for a in sys.argv[1:] if not a.startswith("-")]
+        if not positional_args:
+            # Flags like --offline or --thinking given without a subcommand or task -> launch chat mode
+            subcommand = "chat"
+            sys.argv.insert(1, "chat")
+        else:
+            subcommand = "run"
+            sys.argv.insert(1, "run")
     elif subcommand and subcommand not in ("-h", "--help", "-v", "--version") and sys.argv[1] != subcommand:
         # Move subcommand to index 1 so subparsers parse arguments correctly without default override
         sys.argv.remove(subcommand)
@@ -49,11 +61,11 @@ def _normalize_args():
     if subcommand in ("run", "plan", "explain") and len(sys.argv) > 2:
         cmd_idx = sys.argv.index(subcommand)
         sub_args = sys.argv[cmd_idx + 1:]
-        
+
         flags = []
         positionals = []
-        value_flags = {"--workdir", "--image", "--video", "--url", "--github", "--max-turns", "--host", "--port"}
-        
+        value_flags = {"--workdir", "--image", "--video", "--url", "--github", "--max-turns", "--host", "--port", "--ctx-size"}
+
         i = 0
         while i < len(sub_args):
             arg = sub_args[i]
@@ -67,7 +79,7 @@ def _normalize_args():
             else:
                 positionals.append(arg)
             i += 1
-            
+
         sys.argv = sys.argv[:cmd_idx + 1] + flags + positionals
 
 
@@ -87,7 +99,7 @@ def main():
     common.add_argument("--quiet", action="store_true", help="Suppress per-turn logging")
     common.add_argument("--debug", action="store_true", help="Show autonomous discovery and debug diagnostics")
     common.add_argument("--offline", "--local", dest="offline", action="store_true", help="Run using local offline GGUF model on GPU without internet")
-    common.add_argument("--ctx-size", type=int, default=None, help="Context size in tokens (default: 4096 offline, 262144 online)")
+    common.add_argument("--ctx-size", type=int, default=None, help="Context size in tokens (default: 8192 offline, 262144 online)")
 
     from . import __version__
     parser = argparse.ArgumentParser(
@@ -103,7 +115,7 @@ def main():
     sub.add_parser("init", help="Configure your VLM/OpenAI-compatible endpoint")
 
     # ── serve ──
-    serve_p = sub.add_parser("serve", help="Start the AlpieCode API server")
+    serve_p = sub.add_parser("serve", help="Start the AlpieCode API server", parents=[common])
     serve_p.add_argument("--host", default="127.0.0.1", help="Host address to bind to (default: 127.0.0.1)")
     serve_p.add_argument("--port", type=int, default=7169, help="Port to listen on (default: 7169)")
 
@@ -125,12 +137,18 @@ def main():
     undo_p = sub.add_parser("undo", help="Revert file changes made by the last AlpieCode session", parents=[common])
 
     # ── doctor ──
-    sub.add_parser("doctor", help="Run system health checks (CUDA, Python, network, dev tools)")
+    sub.add_parser("doctor", help="Run system health checks (CUDA, Python, network, dev tools)", parents=[common])
 
     # ── explain ──
     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', parents=[common])
+    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 +163,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())
@@ -175,9 +239,9 @@ def main():
 
     if getattr(args, "offline", False):
         cfg.base_url = "offline"
-        # 4096 default fits 4.4GB model + KV cache 100% in 6GB VRAM with zero host-paging
+        # 8192 default fits 4.4GB model + KV cache 100% in 6GB VRAM (4.75GB / 6GB) with zero host-paging
         import os
-        cfg.n_ctx = int(os.environ.get("ALPIECODE_CTX_SIZE", 4096))
+        cfg.n_ctx = int(os.environ.get("ALPIECODE_CTX_SIZE", 8192))
         os.environ["ALPIECODE_BASE_URL"] = "offline"
 
     if getattr(args, "ctx_size", None):

{alpiecode-10.0.3 → alpiecode-10.5.1}/src/codeagent/compaction.py

@@ -15,6 +15,7 @@ Strategy:
 """
 
 import json
+import re
 from typing import Any, Dict, List, Optional
 
 # Our model's context window
@@ -219,27 +220,120 @@ def select_relevant_history(
     return "### Relevant Historical Anchors:\n" + "\n".join(reversed(high_value_notes))
 
 
-def compact_messages(messages: List[dict]) -> List[dict]:
+def compact_text_tool_calls(text: str) -> str:
+    """Condense bulky file content in text-based tool calls."""
+    if not text or ("write_file" not in text and "edit_file" not in text and "apply_patch" not in text):
+        return text
+
+    def _replace_block(m):
+        raw = m.group(1).strip()
+        try:
+            from .backends.openai_backend import _repair_and_parse_json_arguments
+            data = _repair_and_parse_json_arguments(raw)
+            if isinstance(data, dict) and data.get("name") in ("write_file", "edit_file", "apply_patch"):
+                args = data.get("arguments", {})
+                if isinstance(args, dict):
+                    p = args.get("path") or args.get("filename") or args.get("file") or "file"
+                    return f"[Completed {data['name']} for '{p}']"
+        except Exception:
+            pass
+        return m.group(0)
+
+    # 1. First condense complete/closed <tool_call>...</tool_call> blocks
+    text = re.sub(r"<tool_call>\s*(.*?)\s*</tool_call>", _replace_block, text, flags=re.DOTALL)
+
+    # 2. Also condense unclosed/truncated <tool_call> blocks (e.g. from token cutoff before </tool_call>)
+    if "<tool_call>" in text:
+        def _replace_unclosed(m):
+            raw = m.group(0)
+            t_name = "write_file"
+            p = "file"
+            name_m = re.search(r'"name":\s*"([^"]+)"', raw)
+            if name_m:
+                t_name = name_m.group(1)
+            path_m = re.search(r'"(?:path|filename|file)":\s*"([^"]+)"', raw)
+            if path_m:
+                p = path_m.group(1)
+            return f"[Incomplete/truncated {t_name} for '{p}']"
+
+        text = re.sub(r"<tool_call>(?:(?!</tool_call>).)*$", _replace_unclosed, text, flags=re.DOTALL)
+
+    return text
+
+
+def compact_tool_calls(tool_calls: List[Any]) -> List[Any]:
+    """Condense bulky file content in historical tool calls to conserve context tokens."""
+    if not tool_calls:
+        return []
+    compacted = []
+    for tc in tool_calls:
+        if not isinstance(tc, dict):
+            compacted.append(tc)
+            continue
+        fn = tc.get("function", {})
+        if not isinstance(fn, dict):
+            compacted.append(tc)
+            continue
+        name = fn.get("name", "")
+        raw_args = fn.get("arguments", "")
+        if name in ("write_file", "edit_file", "apply_patch"):
+            try:
+                args = json.loads(raw_args) if isinstance(raw_args, str) else dict(raw_args)
+                content = args.get("content") or args.get("patch") or ""
+                path = args.get("path") or args.get("filename") or "file"
+                if isinstance(content, str) and len(content) > 150:
+                    lines = content.splitlines()
+                    args["content"] = f"[Content saved to {path} ({len(lines)} lines, {len(content)} bytes)]"
+                    compact_tc = dict(tc)
+                    compact_tc["function"] = dict(fn)
+                    compact_tc["function"]["arguments"] = json.dumps(args) if isinstance(raw_args, str) else args
+                    compacted.append(compact_tc)
+                    continue
+            except Exception:
+                pass
+        compacted.append(tc)
+    return compacted
+
+
+def compact_messages(messages: List[dict], keep_recent: int = KEEP_RECENT_TURNS) -> List[dict]:
     """
     Compact a message list by summarizing older turns.
 
     Preserves:
       - System prompt (index 0)
       - All user messages (verbatim)
-      - Last KEEP_RECENT_TURNS messages (verbatim)
+      - Last keep_recent messages (verbatim, with older tool arguments trimmed if bulky)
 
     Summarizes:
       - Older tool results (truncated)
       - Older assistant reasoning (removed)
+      - Older write_file/edit_file payload content (condensed)
     """
-    if len(messages) <= KEEP_RECENT_TURNS + 2:
-        return messages
+    if len(messages) <= keep_recent + 2:
+        # Even if short, condense older bulky assistant tool calls while keeping latest intact
+        result = []
+        last_asst_idx = -1
+        for i in range(len(messages) - 1, -1, -1):
+            if messages[i].get("role") == "assistant":
+                last_asst_idx = i
+                break
+        for i, m in enumerate(messages):
+            if i != last_asst_idx and m.get("role") == "assistant":
+                cm = dict(m)
+                if cm.get("tool_calls"):
+                    cm["tool_calls"] = compact_tool_calls(m["tool_calls"])
+                if cm.get("content"):
+                    cm["content"] = compact_text_tool_calls(cm["content"])
+                result.append(cm)
+            else:
+                result.append(m)
+        return result
 
     # Always keep system prompt
     system = messages[0] if messages and messages[0].get("role") == "system" else None
 
     # Split into old and recent
-    cutoff = len(messages) - KEEP_RECENT_TURNS
+    cutoff = len(messages) - keep_recent
 
     # ── Tool-Call Pairing Guard ──
     # If cutoff lands on a 'tool' message, move it backwards to include
@@ -263,11 +357,11 @@ def compact_messages(messages: List[dict]) -> List[dict]:
             compacted_old.append(msg)
 
         elif role == "assistant":
-            # Compact assistant messages: keep tool calls but remove reasoning
+            # Compact assistant messages: keep tool calls (condensed) but remove reasoning
             compact_msg = {"role": "assistant"}
             if msg.get("content"):
                 # Truncate long assistant content
-                content = msg["content"]
+                content = compact_text_tool_calls(msg["content"])
                 if len(content) > 200:
                     compact_msg["content"] = content[:200] + "..."
                 else:
@@ -276,7 +370,7 @@ def compact_messages(messages: List[dict]) -> List[dict]:
                 compact_msg["content"] = None
 
             if msg.get("tool_calls"):
-                compact_msg["tool_calls"] = msg["tool_calls"]
+                compact_msg["tool_calls"] = compact_tool_calls(msg["tool_calls"])
             compacted_old.append(compact_msg)
 
         elif role == "tool":
@@ -301,11 +395,29 @@ def compact_messages(messages: List[dict]) -> List[dict]:
                 "content": _summarize_tool_result(tool_name, content),
             })
 
+    # In recent messages, also condense older assistant tool calls (except the immediate last one)
+    last_asst_idx = -1
+    for i in range(len(recent_messages) - 1, -1, -1):
+        if recent_messages[i].get("role") == "assistant":
+            last_asst_idx = i
+            break
+
+    cleaned_recent = []
+    for i, m in enumerate(recent_messages):
+        if i != last_asst_idx and m.get("role") == "assistant":
+            cm = dict(m)
+            if cm.get("tool_calls"):
+                cm["tool_calls"] = compact_tool_calls(m["tool_calls"])
+            if cm.get("content"):
+                cm["content"] = compact_text_tool_calls(cm["content"])
+            cleaned_recent.append(cm)
+        else:
+            cleaned_recent.append(m)
+
     # Rebuild message list
     result = []
     if system:
         result.append(system)
     result.extend(compacted_old)
-    result.extend(recent_messages)
-
+    result.extend(cleaned_recent)
     return result

{alpiecode-10.0.3 → alpiecode-10.5.1}/src/codeagent/config.py

@@ -158,8 +158,8 @@ def load_config() -> Config:
     # For offline mode, set high-performance 16k context (16384 tokens) for big multi-file projects
     # Fits completely in 6GB VRAM on RTX 3050 with zero paging
     if data.get("base_url") == "offline" and not any(os.environ.get(v) for v in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE")):
-        if data.get("n_ctx") in (32768, 4096):
-            data["n_ctx"] = 16384
+        if data.get("n_ctx") in (32768, 4096, 16384):
+            data["n_ctx"] = 8192
         if data.get("max_tokens", 8192) > 4096:
             data["max_tokens"] = 4096
 

{alpiecode-10.0.3 → alpiecode-10.5.1}/src/codeagent/context.py

@@ -14,6 +14,8 @@ from typing import Any, Dict, List, Optional
 
 from .backends.base import ChatResponse, ToolCall
 from .compaction import (
+    compact_tool_calls,
+    compact_text_tool_calls,
     CHARS_PER_TOKEN,
     compact_messages,
     estimate_tokens,
@@ -350,25 +352,42 @@ class ContextManager:
                         context_blocks.append(dict(m))
                         break
 
+        # ── Budget Verification & Headroom Limits ──
+        effective_limit = max_tokens or self.max_tokens
+
         # ── Layer 4 & 5: Recent Messages and Current Request ──
-        if len(recent_messages) > 6:
-            for i in range(len(recent_messages) - 4):
-                m = recent_messages[i]
-                if m.get("role") == "tool":
-                    c = str(m.get("content") or "")
-                    if len(c) > 400 and "[Plan updated]" not in c and "Plan Status:" not in c:
-                        lines = c.splitlines()
-                        if len(lines) > 8:
-                            m["content"] = f"[Output: {len(lines)} lines truncated]\n" + "\n".join(lines[:3]) + "\n...\n" + "\n".join(lines[-2:])
-                        else:
-                            m["content"] = c[:200] + "... [truncated]"
+        # Condense bulky file write payloads in older assistant messages
+        last_asst_idx = -1
+        for i in range(len(recent_messages) - 1, -1, -1):
+            if recent_messages[i].get("role") == "assistant":
+                last_asst_idx = i
+                break
+
+        for i, m in enumerate(recent_messages):
+            if i != last_asst_idx and m.get("role") == "assistant":
+                if m.get("tool_calls"):
+                    m["tool_calls"] = compact_tool_calls(m["tool_calls"])
+                if m.get("content"):
+                    m["content"] = compact_text_tool_calls(m["content"])
+            elif m.get("role") == "tool":
+                c = str(m.get("content") or "")
+                if len(c) > 300 and "[Plan updated]" not in c and "Plan Status:" not in c:
+                    lines = c.splitlines()
+                    if len(lines) > 8:
+                        top = "\n".join(lines[:3])
+                        bot = "\n".join(lines[-2:])
+                        m["content"] = f"[Output: {len(lines)} lines condensed]\n{top}\n...\n{bot}"
+                    else:
+                        m["content"] = c[:180] + "... [condensed]"
 
         context_blocks.extend(recent_messages)
 
         # ── Budget Verification ──
-        effective_limit = max_tokens or self.max_tokens
-        if estimate_tokens(context_blocks) > effective_limit:
-            context_blocks = compact_messages(context_blocks)
+        reserved_headroom = 2048 if effective_limit <= 8192 else 4096
+        prompt_budget = max(1024, effective_limit - reserved_headroom)
+
+        if estimate_tokens(context_blocks) > prompt_budget:
+            context_blocks = compact_messages(context_blocks, keep_recent=4 if effective_limit <= 8192 else 8)
 
         if is_default_params:
             self._cached_context = [dict(m) for m in context_blocks]
@@ -403,6 +422,16 @@ class ContextManager:
         """Returns parallel metadata list for all messages."""
         return list(self._metadata)
 
+    def compact_for_headroom(self, target_headroom: int = 1536, n_ctx: int = 8192, tools_overhead: int = 800) -> int:
+        """
+        Actively compact context to ensure at least target_headroom tokens are available for generation.
+        Returns the new estimated token count.
+        """
+        self.invalidate_cache(reset_summary=True)
+        self._cached_summary = extract_conversation_summary(self._messages, self._metadata)
+        self._messages = compact_messages(self._messages, keep_recent=4)
+        return self.estimate_tokens()
+
     def estimate_tokens(self) -> int:
         """Estimate tokens of the active built context."""
         return estimate_tokens(self.build_context())

{alpiecode-10.0.3 → alpiecode-10.5.1}/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