alpiecode 6.0.0__tar.gz → 6.2.0__tar.gz

{alpiecode-6.0.0 → alpiecode-6.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 6.0.0
+Version: 6.2.0
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-6.0.0 → alpiecode-6.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "6.0.0"
+version = "6.2.0"
 description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 6.0.0
+Version: 6.2.0
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/alpiecode.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ src/codeagent/local_model.py
 src/codeagent/media.py
 src/codeagent/memory.py
 src/codeagent/orchestrator.py
+src/codeagent/progress.py
 src/codeagent/prompt.py
 src/codeagent/server.py
 src/codeagent/session.py

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/codeagent/__init__.py

@@ -16,7 +16,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "2.0.4"
+__version__ = "6.1.0"
 
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "medium", **kwargs):

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/codeagent/agent.py

@@ -65,45 +65,88 @@ except ImportError:
 def _print_reasoning(reasoning: str):
     if not reasoning or not reasoning.strip():
         return
+    clean = reasoning.strip()
     if HAS_RICH:
-        text = Text(reasoning.strip(), style="dim italic")
-        console.print(Panel(text, title="💭 Thinking", border_style="dim blue", padding=(0, 1)))
+        console.print(Text(f"💭 {clean}", style="dim italic"))
     else:
-        console.print(f"\n💭 Thinking: {reasoning.strip()}")
+        console.print(f"💭 {clean}")
+
+
+def _format_tool_summary(name: str, args: dict) -> str:
+    if not isinstance(args, dict):
+        return ""
+    if name == "bash":
+        cmd = args.get("command", "").strip()
+        return f"$ {cmd[:80]}..." if len(cmd) > 80 else f"$ {cmd}"
+    elif name in ("write_file", "edit_file", "read_file"):
+        path = args.get("path", "")
+        extra = ""
+        if name == "write_file" and "content" in args:
+            lines = len(str(args["content"]).splitlines())
+            extra = f" ({lines} lines)"
+        return f"{path}{extra}"
+    elif name == "list_files":
+        return args.get("path", ".")
+    elif name in ("search", "web_search"):
+        return f"'{args.get('query', '')}'"
+    elif name == "fetch_web_page":
+        return args.get("url", "")
+    else:
+        parts = [f"{k}={repr(v)[:30]}" for k, v in args.items() if k != "content"]
+        return " ".join(parts)
 
 
 def _print_tool_call(turn: int, name: str, args: dict):
-    display_args = {}
-    for k, v in args.items():
-        if isinstance(v, str) and len(v) > 200:
-            display_args[k] = v[:200] + "..."
-        else:
-            display_args[k] = v
+    summary = _format_tool_summary(name, args)
     if HAS_RICH:
-        args_str = json.dumps(display_args, indent=2)
-        console.print(f"\n🔧 [bold cyan]Tool:[/bold cyan] [bold]{name}[/bold]", highlight=False)
-        console.print(Text(f"   {args_str}", style="cyan"))
+        console.print(f"\n⏺ [bold cyan]{name}[/bold cyan] [white]{summary}[/white]")
     else:
-        console.print(f"\n🔧 Tool: {name}({display_args})")
+        console.print(f"\n⏺ {name} {summary}")
 
 
 def _print_tool_result(result: str):
-    truncated = result[:1500] + ("..." if len(result) > 1500 else "")
+    clean = result.strip()
+    if '"exit_code"' in clean:
+        try:
+            data = json.loads(clean.split("\n", 1)[-1] if clean.startswith("⚠️") else clean)
+            out = data.get("stdout", "").strip()
+            err = data.get("stderr", "").strip()
+            code = data.get("exit_code", 0)
+            if code == 0:
+                clean = out if out else "success"
+            else:
+                clean = f"exit {code}: {err}" if err else f"exit {code}"
+        except Exception:
+            pass
+
+    lines = clean.splitlines()
+    if len(lines) > 8:
+        display = "\n".join(lines[:6]) + f"\n  ... ({len(lines)-6} lines omitted)"
+    else:
+        display = clean[:500] + ("..." if len(clean) > 500 else "")
+
     if HAS_RICH:
-        console.print(Text(f"   → {truncated}", style="green"))
+        style = "dim green" if not ("exit 1" in clean or "error:" in clean.lower()[:30]) else "dim red"
+        console.print(Text(f"  └ {display}", style=style))
     else:
-        console.print(f"   → {truncated}")
+        console.print(f"  └ {display}")
 
 
 def _print_assistant_message(content: str):
+    if not content or not content.strip():
+        return
+    text = content.strip()
+    if text.upper().startswith("DONE:"):
+        text = text[5:].strip()
     if HAS_RICH:
         try:
-            md = Markdown(content)
-            console.print(Panel(md, title="🤖 Assistant", border_style="green", padding=(0, 1)))
+            console.print()
+            console.print(Markdown(text))
         except Exception:
-            console.print(Panel(Text(content), title="🤖 Assistant", border_style="green", padding=(0, 1)))
+            console.print()
+            console.print(text)
     else:
-        console.print(f"\n🤖 Assistant: {content}")
+        print(f"\n{text}")
 
 
 # ── Git helpers ───────────────────────────────────────────────────────
@@ -227,9 +270,27 @@ def run_agent(
 
         elif event.type == "start" and verbose:
             data = event.data
-            if HAS_RICH:
-                console.rule("[bold blue]Agent Started[/bold blue]")
-                console.print(Text(f"📋 Task: {task.splitlines()[0]}", style="bold"))
+            if debug:
+                if HAS_RICH:
+                    console.rule("[bold blue]Agent Started (Debug)[/bold blue]")
+                    console.print(Text(f"📋 Task: {task.splitlines()[0]}", style="bold"))
+                    console.print(f"📂 Workdir: {workdir}", style="dim")
+                    mode_str = "[bold green]ONLINE[/bold green]" if not data["is_offline"] else "[bold yellow]OFFLINE[/bold yellow]"
+                    console.print(f"🌐 Mode: {mode_str}", style="dim")
+                    comp = data.get("complexity", "low")
+                    comp_label = {"qa": "Q&A (instant)", "low": "Low (fast)", "medium": "Medium (balanced)", "high": "High (thorough)"}.get(comp, comp)
+                    console.print(f"⚡ Complexity: {comp_label}", style="dim")
+                    if last_discovery:
+                        console.print(f"🔍 Discovery: {last_discovery.get('intent', 'create')} on {last_discovery.get('project_type', 'empty')} project", style="dim")
+                else:
+                    print(f"[Start] task={task.splitlines()[0]}, mode={'offline' if data['is_offline'] else 'online'}")
+            else:
+                # Clean, professional presentation like Claude Code / Codex
+                if data.get("is_offline"):
+                    if HAS_RICH:
+                        console.print("[dim yellow]⚡ Offline mode[/dim yellow]")
+                    else:
+                        print("⚡ Offline mode")
                 if github_repo:
                     console.print(f"🐙 GitHub Repo: {github_repo}", style="cyan")
                 if image_path:
@@ -238,36 +299,17 @@ def run_agent(
                     console.print(f"🎬 Video: {video_path}", style="cyan")
                 if url:
                     console.print(f"📺 URL: {url}", style="cyan")
-                console.print(f"📂 Workdir: {workdir}", style="dim")
-                if not data["is_offline"]:
-                    console.print(f"🌐 Mode: [bold green]ONLINE[/bold green]", style="dim")
-                else:
-                    console.print(f"🧠 Mode: [bold yellow]OFFLINE[/bold yellow]", style="dim")
-                comp = data.get("complexity", "low")
-                comp_label = {"qa": "Q&A (instant)", "low": "Low (fast)", "medium": "Medium (balanced)", "high": "High (thorough)"}.get(comp, comp)
-                comp_color = {"qa": "cyan", "low": "green", "medium": "yellow", "high": "red"}.get(comp, "white")
-                console.print(f"⚡ Complexity: [bold {comp_color}]{comp_label}[/bold {comp_color}]", style="dim")
-                if last_discovery:
-                    intent_str = last_discovery.get('intent', 'create').title()
-                    proj_str = last_discovery.get('project_type', 'empty')
-                    console.print(f"🔍 Discovery: {intent_str} on {proj_str} project ({last_discovery.get('shell', 'bash')})", style="dim")
-                if cfg.enable_thinking:
-                    console.print(f"🧠 Reasoning: [bold green]ON[/bold green]", style="dim")
-            else:
-                console.rule("Agent Started")
-                console.print(f"📋 Task: {task.splitlines()[0]}")
-                console.print(f"📂 Workdir: {workdir}")
 
         elif event.type == "adaptive_mode" and verbose and HAS_RICH:
             console.print("⚡ [dim]Adaptive mode: simple task detected, skipping deep reasoning for speed[/dim]")
 
         elif event.type == "turn_start":
             current_turn = event.data["turn"]
-            if verbose:
+            if debug:
                 if HAS_RICH:
-                    console.rule(f"[bold]Turn {current_turn}[/bold]", style="blue")
+                    console.print(f"[dim]── Step {current_turn} ──[/dim]")
                 else:
-                    console.rule(f"Turn {current_turn}")
+                    print(f"── Step {current_turn} ──")
 
         elif event.type == "compaction" and verbose:
             console.print("🗜️  Compacting context (approaching token limit)...", style="yellow")
@@ -306,17 +348,56 @@ def run_agent(
             else:
                 print(f"\n❌ Model Error: {event.data['error']}")
 
+        elif event.type == "stall_intervention" and verbose:
+            if HAS_RICH:
+                console.print(
+                    f"🔄 [bold yellow]Progress stall detected[/bold yellow] "
+                    f"(turn {event.data['turn']}, {event.data['consecutive_stalls']} stalled turns, "
+                    f"intervention #{event.data['interventions']})",
+                    style="yellow"
+                )
+            else:
+                print(f"🔄 Progress stall detected (turn {event.data['turn']})")
+
+        elif event.type == "turn_progress" and debug:
+            snap = event.data
+            status = "✅" if snap["had_progress"] else "⚠️"
+            if HAS_RICH:
+                console.print(
+                    Text(f"  {status} Progress: created={snap['files_created']}, "
+                    f"modified={snap['files_modified']}, stalls={snap['consecutive_stalls']}"),
+                    style="dim"
+                )
+
+        elif event.type == "safety_ceiling" and verbose:
+            if HAS_RICH:
+                console.print(
+                    f"\n🛑 [bold red]Safety ceiling ({event.data['ceiling']} turns) reached.[/bold red]\n"
+                    "This is an emergency stop — the agent may be stuck in an unrecoverable loop.",
+                    style="bold red"
+                )
+            else:
+                print(f"\n🛑 Safety ceiling ({event.data['ceiling']}) reached.")
+
         elif event.type == "done":
-            summary = event.data["summary"]
+            summary = event.data.get("summary", "")
             _checkpoint(workdir, "checkpoint: done")
-            if verbose and HAS_RICH:
-                if "DONE" in summary.upper():
-                    console.rule("[bold green]✅ Task Complete[/bold green]")
-                else:
-                    console.rule("[bold yellow]💬 Agent Replied[/bold yellow]")
+            if debug and HAS_RICH:
+                console.rule("[bold green]✅ Complete[/bold green]")
 
         elif event.type == "max_turns_reached" and verbose:
-            console.print(f"\n⚠️  Max turns ({event.data['max_turns']}) reached without completion.", style="bold yellow")
+            progress = event.data.get("progress", {})
+            if HAS_RICH:
+                console.print(f"\n⚠️  [bold yellow]Safety ceiling ({event.data['max_turns']}) reached.[/bold yellow]", style="bold yellow")
+                if progress:
+                    console.print(
+                        f"   Progress: {progress.get('progress_turns', 0)}/{progress.get('total_turns', 0)} turns made progress, "
+                        f"{progress.get('files_created', 0)} files created, "
+                        f"{progress.get('stall_interventions', 0)} stall interventions",
+                        style="dim"
+                    )
+            else:
+                print(f"\n⚠️ Safety ceiling ({event.data['max_turns']}) reached.")
 
     return session.context.messages if "session" in locals() else []
 
@@ -368,11 +449,11 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
             break
 
         for event in orchestrator.run_task(session, user_input, cfg):
-            if event.type == "turn_start" and verbose:
+            if event.type == "turn_start" and debug:
                 if HAS_RICH:
-                    console.rule(f"[bold]Turn {event.data['turn']}[/bold]", style="blue")
+                    console.print(f"[dim]── Step {event.data['turn']} ──[/dim]")
                 else:
-                    console.rule(f"Turn {event.data['turn']}")
+                    print(f"── Step {event.data['turn']} ──")
 
             elif event.type == "thinking" and verbose:
                 _print_reasoning(event.data["content"])

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/codeagent/cli.py

@@ -162,8 +162,6 @@ def main():
     if args.command == "run":
         if args.max_turns:
             cfg.max_turns = args.max_turns
-            cfg._explicit_max_turns = True
-        _show_banner()
         from .agent import run_agent
         run_agent(
             args.task, Path(args.workdir), cfg,
@@ -178,13 +176,11 @@ def main():
     elif args.command == "chat":
         if args.max_turns:
             cfg.max_turns = args.max_turns
-            cfg._explicit_max_turns = True
         _show_banner()
         from .agent import run_chat
         run_chat(Path(args.workdir), cfg, verbose=not args.quiet)
 
     elif args.command == "plan":
-        _show_banner()
         plan_task = (
             f"PLANNING ONLY — Do NOT make any file edits. "
             f"Analyze the codebase and create a detailed implementation plan for the following task. "
@@ -208,7 +204,6 @@ def main():
         sys.exit(run_doctor())
 
     elif args.command == "explain":
-        _show_banner()
         target = args.target
         target_path = Path(args.workdir) / target if not Path(target).is_absolute() else Path(target)
         if target_path.exists() and target_path.is_file():

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/codeagent/config.py

@@ -26,7 +26,7 @@ DEFAULTS = {
     "model_repo": "169Pi/Alpie_learn_prototype_GGUF_NEW",
     "api_key": "not-needed",
     "hf_token": None,
-    "max_turns": 20,
+    "max_turns": 200,
     "temperature": 0.1,
     "max_tokens": 8192,
     "enable_thinking": False,  # Reasoning OFF by default
@@ -88,7 +88,7 @@ class Config:
     model_repo: str = "169Pi/Alpie_learn_prototype_GGUF_NEW"  # HuggingFace repo for offline GGUF
     api_key: str = "not-needed"
     hf_token: Optional[str] = None
-    max_turns: int = 20
+    max_turns: int = 200  # Safety ceiling only — agent runs until DONE
     temperature: float = 0.1
     max_tokens: int = 8192
     enable_thinking: bool = False
@@ -117,7 +117,7 @@ def load_config() -> Config:
                 data["enable_thinking"] = False
                 data["temperature"] = 0.1
                 data["max_tokens"] = 8192
-                data["max_turns"] = 20
+                data["max_turns"] = 200
                 data["config_version"] = CONFIG_VERSION
                 needs_save = True
         except Exception:

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/codeagent/discovery.py

@@ -49,7 +49,6 @@ class TaskContext:
     dependencies: List[str] = field(default_factory=list)
 
     # Budget (computed from complexity)
-    max_turns: int = 10
     max_tokens: int = 8192
     tool_set: str = "core"          # none, core, full
     enable_thinking: bool = False
@@ -500,25 +499,21 @@ def compute_complexity(intent: str, repo_info: dict, task: str) -> str:
 
 COMPLEXITY_CONFIG = {
     "qa": {
-        "max_turns": 3,
         "max_tokens": 4096,
         "tool_set": "none",
         "enable_thinking": False,
     },
     "low": {
-        "max_turns": 15,
         "max_tokens": 8192,
         "tool_set": "core",
         "enable_thinking": False,
     },
     "medium": {
-        "max_turns": 40,
         "max_tokens": 16384,
         "tool_set": "full",
         "enable_thinking": True,
     },
     "high": {
-        "max_turns": 60,
         "max_tokens": 16384,
         "tool_set": "full",
         "enable_thinking": True,
@@ -568,7 +563,6 @@ def build_task_context(task: str, workdir: Path) -> TaskContext:
         entry_points=repo["entry_points"],
         dependencies=repo["dependencies"],
         # Budget
-        max_turns=budget["max_turns"],
         max_tokens=budget["max_tokens"],
         tool_set=budget["tool_set"],
         enable_thinking=budget["enable_thinking"],

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/codeagent/guardian.py

@@ -48,6 +48,8 @@ SAFE_PREFIXES = [
     "python -m pytest", "python3 -m pytest", "pytest", "npm test",
     "npm run test", "make test", "cargo test", "go test",
     "python -c", "python3 -c", "node -e",
+    "python3 ", "python ", "node ", "bun ", "deno ", "cargo ", "go ",
+    "make", "cmake", "gcc", "g++", "clang", "clang++", "./",
     "tree", "sort", "uniq", "cut", "awk", "sed -n", "diff",
     "env", "printenv", "set",
     "type", "command -v",
@@ -138,8 +140,9 @@ def gate_command(command: str, auto_approve: bool = False) -> bool:
 
     if risk == RiskLevel.WARNING:
         if auto_approve:
-            if HAS_RICH:
-                console.print(Text(f"   ⚠️  {reason}", style="yellow"))
+            if "Unknown command" not in reason:
+                if HAS_RICH:
+                    console.print(Text(f"   ⚠️  {reason}", style="yellow"))
             return True
         # In interactive mode, show warning but proceed
         if HAS_RICH:

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/codeagent/orchestrator.py

@@ -15,6 +15,7 @@ from .cache import get_cache
 from .config import Config, is_server_reachable
 from .memory import extract_and_save_memories
 from .discovery import build_task_context, COMPLEXITY_CONFIG
+from .progress import ProgressMonitor
 from .prompt import PromptBuilder, classify_task
 from .session import Session, SessionManager
 
@@ -72,13 +73,11 @@ class AgentOrchestrator:
 
         comp_cfg = COMPLEXITY_CONFIG.get(complexity, COMPLEXITY_CONFIG["low"])
 
-        # ── Determine effective max_turns and max_tokens ──
-        effective_max_turns = task_context.max_turns
+        # ── Determine effective max_tokens ──
         effective_max_tokens = task_context.max_tokens
 
-        # User override: if they set --max-turns explicitly, respect it
-        if getattr(cfg, "_explicit_max_turns", False):
-            effective_max_turns = cfg.max_turns
+        # Safety ceiling: hard emergency brake (should never be hit naturally)
+        safety_ceiling = cfg.max_turns if cfg.max_turns != 200 else 200
 
         # ── Response cache check ──
         is_cacheable = not any([image_path, video_path, url, github_repo])
@@ -137,12 +136,7 @@ class AgentOrchestrator:
             "complexity": complexity,
         })
 
-        if complexity in ("medium", "high"):
-            session.context.add_user_message(
-                f"[BUDGET & GOAL] Available turn budget: {effective_max_turns} turns. "
-                "Plan the needed components, create the complete files, verify with bash, "
-                "and finish with DONE: <summary> as soon as verification succeeds."
-            )
+
 
         # ── Adaptive thinking ──
         enable_thinking = cfg.enable_thinking or task_context.enable_thinking
@@ -150,40 +144,43 @@ class AgentOrchestrator:
             enable_thinking = False
             yield AgentEvent("adaptive_mode", {"message": "Simple task detected, skipping deep reasoning."})
 
-        # ── Turn loop ──
-        wrap_up_injected = False
+        # ── Goal-driven turn loop (no fixed limit) ──
+        progress_monitor = ProgressMonitor()
+        turn = 0
+
+        while True:
+            turn += 1
 
-        for turn in range(effective_max_turns):
             if session.cancelled:
-                yield AgentEvent("cancelled", {"turn": turn + 1})
+                yield AgentEvent("cancelled", {"turn": turn})
                 break
 
             # Context compaction
             if session.context.check_and_compact():
-                yield AgentEvent("compaction", {"turn": turn + 1})
-
-            # ── Progressive wrap-up injection ──
-            # Step 1: Gentle verification reminder at 70%
-            if not wrap_up_injected and turn >= int(effective_max_turns * 0.70):
-                wrap_up_injected = True
-                remaining = effective_max_turns - turn
-                session.context.add_user_message(
-                    f"[SYSTEM] Turn budget update: {remaining} turns remaining. "
-                    "Ensure all necessary files are created and run verification tests now. "
-                    "As soon as verification succeeds, output DONE: <summary>."
-                )
-                yield AgentEvent("wrap_up", {"turn": turn + 1, "remaining": remaining})
-
-            # Step 2: Final wrap-up call at 90%
-            if not getattr(self, "_final_wrap_up_injected", False) and turn >= int(effective_max_turns * 0.90):
-                self._final_wrap_up_injected = True
-                remaining = effective_max_turns - turn
-                session.context.add_user_message(
-                    f"[SYSTEM] FINAL TURNS: Only {remaining} turns remaining. "
-                    "Do not start new exploration. Fix any remaining errors and output DONE: <summary>."
-                )
+                yield AgentEvent("compaction", {"turn": turn})
+
+            # ── Stall Detection & Corrective Intervention ──
+            if progress_monitor.is_stalled(threshold=3):
+                advice = progress_monitor.get_stall_advice()
+                session.context.add_user_message(advice)
+                yield AgentEvent("stall_intervention", {
+                    "turn": turn,
+                    "consecutive_stalls": progress_monitor.consecutive_stalls,
+                    "interventions": progress_monitor.stall_interventions,
+                })
+                # After 3 interventions (= 9+ stalled turns), force wrap-up
+                if progress_monitor.stall_interventions >= 3:
+                    session.context.add_user_message(
+                        "[SYSTEM] Multiple stall interventions have not resolved the issue. "
+                        "Finish now with whatever you have. Output DONE: <summary of what was completed>."
+                    )
+
+            # ── Safety ceiling (emergency only) ──
+            if turn > safety_ceiling:
+                yield AgentEvent("safety_ceiling", {"turn": turn, "ceiling": safety_ceiling})
+                break
 
-            yield AgentEvent("turn_start", {"turn": turn + 1})
+            yield AgentEvent("turn_start", {"turn": turn})
 
             try:
                 if enable_thinking:
@@ -235,7 +232,7 @@ class AgentOrchestrator:
                     results = session.executor.execute_tool_calls(tool_calls)
                     for res in results:
                         yield AgentEvent("tool_result", {
-                            "turn": turn + 1,
+                            "turn": turn,
                             "id": res.tool_call_id,
                             "name": res.name,
                             "content": res.content,
@@ -263,7 +260,7 @@ class AgentOrchestrator:
             if tool_calls:
                 for tc in tool_calls:
                     yield AgentEvent("tool_call", {
-                        "turn": turn + 1,
+                        "turn": turn,
                         "id": tc.id,
                         "name": tc.name,
                         "arguments": tc.arguments,
@@ -273,7 +270,7 @@ class AgentOrchestrator:
 
                 for res in results:
                     yield AgentEvent("tool_result", {
-                        "turn": turn + 1,
+                        "turn": turn,
                         "id": res.tool_call_id,
                         "name": res.name,
                         "content": res.content,
@@ -281,6 +278,18 @@ class AgentOrchestrator:
                     })
                     session.context.add_tool_result(res.tool_call_id, res.content)
 
+                # ── Record progress for stall detection ──
+                tc_dicts = [{"name": tc.name, "arguments": tc.arguments} for tc in tool_calls]
+                res_dicts = [{"content": res.content, "name": res.name} for res in results]
+                snap = progress_monitor.record_turn(turn, tc_dicts, res_dicts)
+                yield AgentEvent("turn_progress", {
+                    "turn": turn,
+                    "had_progress": snap.had_progress,
+                    "files_created": list(snap.files_created),
+                    "files_modified": list(snap.files_modified),
+                    "consecutive_stalls": progress_monitor.consecutive_stalls,
+                })
+
                 continue
 
             # Text-only response = done
@@ -302,5 +311,6 @@ class AgentOrchestrator:
             yield AgentEvent("done", {"summary": "Task completed."})
             return
 
-        yield AgentEvent("max_turns_reached", {"max_turns": effective_max_turns})
+        status = progress_monitor.get_status_summary()
+        yield AgentEvent("max_turns_reached", {"max_turns": safety_ceiling, "progress": status})
         extract_and_save_memories(session.workdir, session.context.messages)

alpiecode-6.2.0/src/codeagent/progress.py

@@ -0,0 +1,175 @@
+"""
+Progress Monitor for AlpieCode.
+
+Tracks per-turn agent progress by observing tool calls and results.
+Detects stalls (zero net progress) and thrashing (delete-after-create loops).
+Does NOT kill the agent — only signals the orchestrator to inject corrective prompts.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Set, Optional
+from pathlib import Path
+
+
+@dataclass
+class TurnSnapshot:
+    """Captures what happened in a single turn."""
+    turn: int
+    tools_called: List[str] = field(default_factory=list)
+    files_created: Set[str] = field(default_factory=set)
+    files_modified: Set[str] = field(default_factory=set)
+    files_deleted: Set[str] = field(default_factory=set)
+    bash_exit_codes: List[int] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    had_progress: bool = False
+
+
+class ProgressMonitor:
+    """Tracks agent progress across turns.
+
+    Progress = files created, files modified, successful bash runs,
+    or errors changing (not repeating the same error).
+
+    Stall = 3+ consecutive turns with zero net progress.
+    Thrashing = deleting files the agent itself created.
+    """
+
+    def __init__(self):
+        self.history: List[TurnSnapshot] = []
+        self.all_files_created: Set[str] = set()
+        self.consecutive_stalls: int = 0
+        self.stall_interventions: int = 0
+
+    def record_turn(self, turn: int, tool_calls: list, tool_results: list) -> TurnSnapshot:
+        """Record what happened in a turn and determine if progress was made."""
+        snap = TurnSnapshot(turn=turn)
+
+        for tc in tool_calls:
+            name = tc.get("name", "") if isinstance(tc, dict) else getattr(tc, "name", "")
+            args = tc.get("arguments", {}) if isinstance(tc, dict) else getattr(tc, "arguments", {})
+            if not isinstance(args, dict):
+                args = {}
+            snap.tools_called.append(name)
+
+            if name == "write_file":
+                path = args.get("path", "")
+                snap.files_created.add(path)
+                self.all_files_created.add(path)
+
+            elif name == "edit_file":
+                path = args.get("path", "")
+                snap.files_modified.add(path)
+
+            elif name == "bash":
+                cmd = args.get("command", "")
+                cmd_parts = cmd.strip().split()
+                if cmd_parts and cmd_parts[0] in ("rm", "del", "Remove-Item"):
+                    for part in cmd_parts[1:]:
+                        if not part.startswith("-"):
+                            clean = Path(part.strip("\'\"")).name
+                            snap.files_deleted.add(clean)
+
+        # Parse tool results for exit codes and errors
+        for res in tool_results:
+            content = res.get("content", "") if isinstance(res, dict) else getattr(res, "content", "")
+            if '"exit_code": 0' in content or '"exit_code":0' in content:
+                snap.bash_exit_codes.append(0)
+            elif '"exit_code":' in content:
+                snap.bash_exit_codes.append(1)
+                snap.errors.append(f"command failed: {content[:100]}")
+            if content.lower().startswith("error:") or "error:" in content[:80].lower():
+                snap.errors.append(content[:100])
+
+        # Determine progress
+        snap.had_progress = bool(
+            snap.files_created
+            or snap.files_modified
+            or (snap.bash_exit_codes and 0 in snap.bash_exit_codes)
+        )
+
+        # No tools called at all = not progress (empty turn)
+        if not snap.tools_called:
+            snap.had_progress = True  # text-only response = model is finishing
+
+        # Detect thrashing: deleting a file that was created recently
+        created_names = {Path(f).name for f in self.all_files_created}
+        thrashing = snap.files_deleted & created_names
+        if thrashing:
+            snap.had_progress = False
+
+        # Detect identical consecutive errors (stall)
+        if len(self.history) >= 2 and snap.errors:
+            prev_errors = set(e[:60] for e in self.history[-1].errors)
+            curr_errors = set(e[:60] for e in snap.errors)
+            if curr_errors and curr_errors == prev_errors:
+                snap.had_progress = False
+
+        # Detect pure read-only turns with errors as non-progress
+        if snap.errors and not snap.files_created and not snap.files_modified:
+            if not (snap.bash_exit_codes and 0 in snap.bash_exit_codes):
+                snap.had_progress = False
+
+        # Update stall counter
+        if snap.had_progress:
+            self.consecutive_stalls = 0
+        else:
+            self.consecutive_stalls += 1
+
+        self.history.append(snap)
+        return snap
+
+    def is_stalled(self, threshold: int = 3) -> bool:
+        """Returns True if the agent has made zero net progress for N consecutive turns."""
+        return self.consecutive_stalls >= threshold
+
+    def get_stall_advice(self) -> str:
+        """Generate a corrective prompt for the model when stalled."""
+        self.stall_interventions += 1
+
+        recent = self.history[-3:] if len(self.history) >= 3 else self.history
+        deleted = set()
+        for snap in recent:
+            deleted.update(snap.files_deleted)
+
+        created_names = {Path(f).name for f in self.all_files_created}
+        thrashing = deleted & created_names
+
+        if thrashing:
+            return (
+                f"[SYSTEM - PROGRESS MONITOR] You have been deleting files you previously "
+                f"created ({', '.join(thrashing)}). STOP deleting and rewriting from scratch. "
+                f"Use edit_file to modify specific sections, or overwrite directly with write_file. "
+                f"Take a step back: what is the simplest path to a working solution?"
+            )
+
+        if all(snap.errors or (snap.bash_exit_codes and 0 not in snap.bash_exit_codes) for snap in recent):
+            return (
+                "[SYSTEM - PROGRESS MONITOR] You have encountered errors for 3 consecutive turns. "
+                "STOP retrying the same approach. Instead:\n"
+                "1. Use read_file to examine the FULL current state of the file(s) you\'re editing\n"
+                "2. Identify the root cause of the error (not the symptom)\n"
+                "3. Make ONE comprehensive fix that addresses all issues\n"
+                "If the task approach is fundamentally wrong, start with a simpler design."
+            )
+
+        return (
+            "[SYSTEM - PROGRESS MONITOR] No measurable progress detected for 3 turns. "
+            "You may be stuck in a loop. Either:\n"
+            "1. Complete your current work and output DONE: <summary>\n"
+            "2. Try a completely different approach to the problem\n"
+            "3. If the code is written and working, verify with bash and finish."
+        )
+
+    def get_status_summary(self) -> dict:
+        """Return a summary of overall progress for logging."""
+        total_files = len(self.all_files_created)
+        total_turns = len(self.history)
+        success_turns = sum(1 for s in self.history if s.had_progress)
+        return {
+            "total_turns": total_turns,
+            "progress_turns": success_turns,
+            "stall_turns": total_turns - success_turns,
+            "files_created": total_files,
+            "stall_interventions": self.stall_interventions,
+            "consecutive_stalls": self.consecutive_stalls,
+        }

{alpiecode-6.0.0 → alpiecode-6.2.0}/src/codeagent/prompt.py

@@ -333,25 +333,21 @@ def is_simple_task(task: str) -> bool:
 
 COMPLEXITY_CONFIG = {
     "qa": {
-        "max_turns": 3,
         "max_tokens": 4096,
         "tools": "none",  # No tools for Q&A
         "prompt": "default",
     },
     "low": {
-        "max_turns": 15,
         "max_tokens": 8192,
         "tools": "core",  # 5 core tools
         "prompt": "default",
     },
     "medium": {
-        "max_turns": 40,
         "max_tokens": 16384,
         "tools": "full",  # All 15 tools
         "prompt": "default",
     },
     "high": {
-        "max_turns": 60,
         "max_tokens": 16384,
         "tools": "full",  # All 15 tools
         "prompt": "high",  # Detailed system prompt