alpiecode 8.0.7__tar.gz → 8.0.8__tar.gz

{alpiecode-8.0.7 → alpiecode-8.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 8.0.7
+Version: 8.0.8
 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-8.0.7 → alpiecode-8.0.8}/pyproject.toml

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

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 8.0.7
+Version: 8.0.8
 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-8.0.7 → alpiecode-8.0.8}/src/alpiecode.egg-info/SOURCES.txt

@@ -39,4 +39,5 @@ 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
+src/codeagent/extension/alpiecode.vsix
+test/test_phase1.py

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/codeagent/__init__.py

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

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/codeagent/agent.py

@@ -11,6 +11,7 @@ Delegates agent orchestration to AgentOrchestrator and handles Rich terminal UI
 
 import json
 import subprocess
+import sys
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -249,9 +250,43 @@ def run_agent(
 
     current_turn = 0
     last_discovery = {}
+    has_streamed_tokens = False
+    has_printed_anything = False
 
     for event in event_stream:
-        if event.type == "discovery" and verbose:
+        if event.type == "token" and verbose:
+            delta = event.data.get("delta", "")
+            if delta:
+                if not has_streamed_tokens:
+                    sys.stdout.write("\n")
+                    has_streamed_tokens = True
+                sys.stdout.write(delta)
+                sys.stdout.flush()
+                has_printed_anything = True
+
+        elif event.type == "thinking_start" and verbose:
+            if debug:
+                if HAS_RICH:
+                    console.print("\n[dim italic]Thinking...[/dim italic]", style="dim")
+                else:
+                    sys.stdout.write("\nThinking...\n")
+                    sys.stdout.flush()
+
+        elif event.type == "thinking_delta" and verbose and debug:
+            delta = event.data.get("delta", "")
+            if delta:
+                sys.stdout.write(delta)
+                sys.stdout.flush()
+
+        elif event.type == "thinking_end" and verbose and debug:
+            duration = event.data.get("duration", 0)
+            if HAS_RICH:
+                console.print(f" [dim]({duration}s)[/dim]\n")
+            else:
+                sys.stdout.write(f" ({duration}s)\n")
+                sys.stdout.flush()
+
+        elif event.type == "discovery" and verbose:
             last_discovery = event.data
             if debug and HAS_RICH:
                 console.print(Panel(
@@ -335,7 +370,12 @@ def run_agent(
             _print_reasoning(event.data["content"])
 
         elif event.type == "tool_call" and verbose:
+            if has_streamed_tokens:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+                has_streamed_tokens = False
             _print_tool_call(event.data["turn"], event.data["name"], event.data["arguments"])
+            has_printed_anything = True
 
         elif event.type == "tool_result":
             if verbose:
@@ -343,7 +383,13 @@ def run_agent(
             _checkpoint(workdir, f"checkpoint: turn {event.data['turn']}")
 
         elif event.type == "message" and verbose:
-            _print_assistant_message(event.data["content"])
+            if has_streamed_tokens:
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+                has_streamed_tokens = False
+            else:
+                _print_assistant_message(event.data["content"])
+            has_printed_anything = True
             _checkpoint(workdir, "checkpoint: response")
 
         elif event.type == "fallback" and verbose:
@@ -393,7 +439,13 @@ def run_agent(
                 print(f"\n🛑 Safety ceiling ({event.data['ceiling']}) reached.")
 
         elif event.type == "done":
-            summary = event.data.get("summary", "")
+            if has_streamed_tokens:
+                sys.stdout.write("\n\n")
+                sys.stdout.flush()
+                has_streamed_tokens = False
+            elif not has_printed_anything and event.data.get("summary"):
+                _print_assistant_message(event.data["summary"])
+                has_printed_anything = True
             _checkpoint(workdir, "checkpoint: done")
             if debug and HAS_RICH:
                 console.rule("[bold green]✅ Complete[/bold green]")
@@ -461,8 +513,16 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
             console.print("Goodbye! 👋")
             break
 
+        has_streamed_chat = False
         for event in orchestrator.run_task(session, user_input, cfg):
-            if event.type == "turn_start" and debug:
+            if event.type == "token":
+                delta = event.data.get("delta", "")
+                if delta:
+                    sys.stdout.write(delta)
+                    sys.stdout.flush()
+                    has_streamed_chat = True
+
+            elif event.type == "turn_start" and debug:
                 if HAS_RICH:
                     console.print(f"[dim]── Step {event.data['turn']} ──[/dim]")
                 else:
@@ -480,7 +540,11 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 _checkpoint(workdir, f"checkpoint: chat turn {event.data['turn']}")
 
             elif event.type == "message":
-                _print_assistant_message(event.data["content"])
+                if has_streamed_chat:
+                    sys.stdout.write("\n")
+                    has_streamed_chat = False
+                else:
+                    _print_assistant_message(event.data["content"])
                 _checkpoint(workdir, "checkpoint: done")
 
             elif event.type == "error":
@@ -490,4 +554,9 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                     print(f"❌ Model error: {event.data['error']}")
 
             elif event.type == "done":
+                if has_streamed_chat:
+                    sys.stdout.write("\n")
+                    has_streamed_chat = False
+                elif event.data.get("summary"):
+                    _print_assistant_message(event.data["summary"])
                 break

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/codeagent/cli.py

@@ -219,10 +219,6 @@ def main():
         undo_last_session(Path(args.workdir).resolve())
         return
 
-    elif args.command == "doctor":
-        from .doctor import run_doctor
-        sys.exit(run_doctor())
-
     elif args.command == "explain":
         target = args.target
         target_path = Path(args.workdir) / target if not Path(target).is_absolute() else Path(target)
@@ -254,51 +250,6 @@ def main():
             debug=getattr(args, "debug", False),
         )
 
-    elif args.command == "diff":
-        workdir = Path(args.workdir).resolve()
-        # Show git diff since the first checkpoint
-        result = subprocess.run(
-            ["git", "log", "--oneline", "--all"],
-            cwd=workdir, capture_output=True, text=True
-        )
-        if result.returncode != 0:
-            print("Not a git repository or no commits found.")
-            return
-
-        # Find the start checkpoint
-        log_lines = result.stdout.strip().splitlines()
-        start_sha = None
-        for line in reversed(log_lines):
-            if "checkpoint: start" in line:
-                start_sha = line.split()[0]
-                break
-
-        if not start_sha:
-            print("No AlpieCode checkpoint found. Run a task first.")
-            return
-
-        diff_result = subprocess.run(
-            ["git", "diff", start_sha, "HEAD", "--stat"],
-            cwd=workdir, capture_output=True, text=True
-        )
-        print(f"Changes since AlpieCode started (from {start_sha}):\n")
-        print(diff_result.stdout)
-
-        # Also show the full diff
-        full_diff = subprocess.run(
-            ["git", "diff", start_sha, "HEAD"],
-            cwd=workdir, capture_output=True, text=True
-        )
-        if full_diff.stdout:
-            try:
-                from rich.console import Console
-                from rich.syntax import Syntax
-                console = Console()
-                syntax = Syntax(full_diff.stdout, "diff", theme="monokai")
-                console.print(syntax)
-            except ImportError:
-                print(full_diff.stdout)
-
 
 if __name__ == "__main__":
     main()

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/codeagent/compaction.py

@@ -240,6 +240,15 @@ def compact_messages(messages: List[dict]) -> List[dict]:
 
     # Split into old and recent
     cutoff = len(messages) - KEEP_RECENT_TURNS
+
+    # ── Tool-Call Pairing Guard ──
+    # If cutoff lands on a 'tool' message, move it backwards to include
+    # the preceding 'assistant' message that owns the tool_call_id.
+    # This prevents OpenAI API 400 errors ("missing tool result for tool_call_id").
+    min_cutoff = 1 if system else 0
+    while cutoff > min_cutoff and messages[cutoff].get("role") == "tool":
+        cutoff -= 1
+
     old_messages = messages[1:cutoff] if system else messages[:cutoff]
     recent_messages = messages[cutoff:]
 

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/codeagent/context.py

@@ -297,6 +297,14 @@ class ContextManager:
                     "content": "\n\n".join(supplemental_parts),
                 })
 
+            # Ensure user query anchor: endpoint requires at least one 'user' message
+            has_user_in_recent = any(m.get("role") == "user" for m in recent_messages)
+            if not has_user_in_recent:
+                for m in distant_messages:
+                    if m.get("role") == "user":
+                        context_blocks.append(dict(m))
+                        break
+
         # ── Layer 4 & 5: Recent Messages and Current Request ──
         if len(recent_messages) > 6:
             for i in range(len(recent_messages) - 4):

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/codeagent/executor.py

@@ -346,62 +346,3 @@ class ToolExecutor:
                 )
 
         return [results_map[tc.id] for tc in tool_calls if tc.id in results_map]
-
-        # Sequential execution
-        for tc in tool_calls:
-            if on_tool_start:
-                on_tool_start(tc.name, tc.arguments)
-            t0 = time.monotonic()
-            # Defensive: ensure arguments is always a dict
-            safe_args = tc.arguments if isinstance(tc.arguments, dict) else {}
-            fn = self.dispatch.get(tc.name)
-            if fn:
-                try:
-                    res_str = str(fn(safe_args))
-                except Exception as e:
-                    res_str = f"error: {e}"
-            else:
-                res_str = f"error: Unknown tool '{tc.name}'"
-            elapsed = (time.monotonic() - t0) * 1000
-
-            # Tool loop detection guard
-            call_sig = (tc.name, json.dumps(tc.arguments, sort_keys=True))
-            self.tool_call_history.append(call_sig)
-            repeat_count = sum(1 for item in self.tool_call_history[-5:] if item == call_sig)
-
-            if repeat_count >= 3:
-                res_str += (
-                    f"\n\n🛑 REPEATED TOOL CALL LOOP DETECTED (attempt #{repeat_count}). "
-                    f"You have already executed '{tc.name}' with these exact parameters {repeat_count} times in a row. "
-                    "All checks have passed. Do NOT run this tool again. Output your final summary starting with: DONE: <summary>."
-                )
-
-            # Compilation failure recovery hint
-            if tc.name == "bash":
-                cmd = tc.arguments.get("command", "")
-                is_compile = any(kw in cmd for kw in ["g++", "gcc", "clang", "make", "cmake", "cargo build", "rustc"])
-                if is_compile and "exit_code" in str(res_str):
-                    try:
-                        result_data = json.loads(res_str.split("\n", 1)[-1] if res_str.startswith("⚠️") else res_str)
-                        if result_data.get("exit_code", 0) != 0:
-                            compile_key = cmd.strip()
-                            self.compile_fail_counts[compile_key] = self.compile_fail_counts.get(compile_key, 0) + 1
-                            if self.compile_fail_counts[compile_key] >= 3:
-                                res_str += (
-                                    "\n\n🛑 REPEATED COMPILATION FAILURE (attempt "
-                                    f"#{self.compile_fail_counts[compile_key]}). "
-                                    "STOP making blind edits. Re-read the ENTIRE source file with "
-                                    "read_file to understand its full structure, then fix ALL errors "
-                                    "comprehensively in one edit."
-                                )
-                        else:
-                            self.compile_fail_counts.pop(cmd.strip(), None)
-                    except (json.JSONDecodeError, ValueError):
-                        pass
-
-            if on_tool_end:
-                on_tool_end(tc.name, res_str)
-
-            results.append(ToolResult(tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed))
-
-        return results

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/codeagent/orchestrator.py

@@ -118,6 +118,7 @@ class AgentOrchestrator:
         # Track touched files and executed commands for Antigravity Walkthrough
         session_touched_files = set()
         session_executed_commands = []
+        verification_nudged = False  # Per-task local flag (prevents cross-session state leak)
 
         # ── Response cache check ──
         is_cacheable = not any([image_path, video_path, url, github_repo])
@@ -142,11 +143,12 @@ class AgentOrchestrator:
                 yield AgentEvent("done", {"summary": cached["response"]})
                 return
 
-        # ── Dynamic backend re-check ──
-        if isinstance(self.backend, LocalBackend) and is_server_reachable(cfg.base_url, timeout=1.5):
-            self.backend = OpenAIBackend(cfg)
+        # ── Dynamic backend re-check (thread-safe: use task-local backend) ──
+        task_backend = self.backend
+        if isinstance(task_backend, LocalBackend) and is_server_reachable(cfg.base_url, timeout=1.5):
+            task_backend = OpenAIBackend(cfg)
 
-        is_offline = not self.backend.is_available or isinstance(self.backend, LocalBackend)
+        is_offline = not task_backend.is_available or isinstance(task_backend, LocalBackend)
         session.is_offline = is_offline
 
         # ── Configure tools & system prompt based on complexity ──
@@ -164,7 +166,7 @@ class AgentOrchestrator:
         })
         rephrased_task = task
         try:
-            rephrased_task = self.rephraser.rephrase(task, self.backend, task_context)
+            rephrased_task = self.rephraser.rephrase(task, task_backend, task_context)
         except Exception:
             rephrased_task = task
 
@@ -199,7 +201,7 @@ class AgentOrchestrator:
         yield AgentEvent("start", {
             "task": task,
             "workdir": str(session.workdir),
-            "backend": self.backend.name,
+            "backend": task_backend.name,
             "is_offline": is_offline,
             "tool_count": len(active_tools),
             "complexity": complexity,
@@ -261,9 +263,9 @@ class AgentOrchestrator:
                 else:
                     max_tokens = 2048 if is_offline else effective_max_tokens
 
-                if hasattr(self.backend, "chat_completion_stream") and not is_offline:
+                if hasattr(task_backend, "chat_completion_stream") and not is_offline:
                     resp = None
-                    for event_type, data in self.backend.chat_completion_stream(
+                    for event_type, data in task_backend.chat_completion_stream(
                         messages=session.context.messages,
                         tools=active_tools if active_tools else None,
                         temperature=cfg.temperature,
@@ -275,7 +277,7 @@ class AgentOrchestrator:
                         else:
                             yield AgentEvent(event_type, data)
                 else:
-                    resp = self.backend.chat_completion(
+                    resp = task_backend.chat_completion(
                         messages=session.context.messages,
                         tools=active_tools if active_tools else None,
                         temperature=cfg.temperature,
@@ -284,14 +286,14 @@ class AgentOrchestrator:
                     )
             except Exception as e:
                 # Online error -> fallback to local
-                if not is_offline and isinstance(self.backend, OpenAIBackend):
+                if not is_offline and isinstance(task_backend, OpenAIBackend):
                     yield AgentEvent("fallback", {"error": str(e), "message": "Falling back to local engine"})
-                    self.backend = LocalBackend(cfg)
+                    task_backend = LocalBackend(cfg)
                     session.is_offline = True
                     is_offline = True
                     active_tools = self.prompt_builder.get_tools(is_offline=True, complexity=complexity)
                     try:
-                        resp = self.backend.chat_completion(
+                        resp = task_backend.chat_completion(
                             messages=session.context.messages,
                             tools=active_tools if active_tools else None,
                             temperature=cfg.temperature,
@@ -305,7 +307,11 @@ class AgentOrchestrator:
                     yield AgentEvent("error", {"error": str(e)})
                     return
 
-            if resp.reasoning and not (hasattr(self.backend, "chat_completion_stream") and not is_offline):
+            if resp is None:
+                yield AgentEvent("error", {"error": "Backend returned no response"})
+                return
+
+            if resp.reasoning and not (hasattr(task_backend, "chat_completion_stream") and not is_offline):
                 yield AgentEvent("thinking", {"content": resp.reasoning})
 
             session.context.add_assistant_response(resp)
@@ -349,7 +355,7 @@ class AgentOrchestrator:
                             resp.content = parts[0] + "DONE: " + parts[1].strip()
 
                 # Only yield 'message' if tokens were NOT already streamed chunk-by-chunk
-                if not (hasattr(self.backend, "chat_completion_stream") and not is_offline):
+                if not (hasattr(task_backend, "chat_completion_stream") and not is_offline):
                     yield AgentEvent("message", {"content": resp.content})
 
                 extract_and_save_memories(session.workdir, getattr(session.context, 'all_messages', session.context.messages))
@@ -385,8 +391,8 @@ class AgentOrchestrator:
                 has_successful_verify = any(
                     c.get("exit_code", -1) == 0 for c in session_executed_commands
                 )
-                if has_code_files and not has_successful_verify and not getattr(self, "_verification_nudge", False):
-                    self._verification_nudge = True
+                if has_code_files and not has_successful_verify and not verification_nudged:
+                    verification_nudged = True
                     session.context.add_user_message(
                         "[SYSTEM - VERIFICATION] You created/modified code files but did not run "
                         "any verification command. Please run a quick syntax check or test before finishing. "
@@ -475,7 +481,7 @@ class AgentOrchestrator:
                             resp.content = parts[0] + "DONE: " + parts[1].strip()
 
                 # Only yield 'message' if tokens were NOT already streamed chunk-by-chunk
-                if not (hasattr(self.backend, "chat_completion_stream") and not is_offline):
+                if not (hasattr(task_backend, "chat_completion_stream") and not is_offline):
                     yield AgentEvent("message", {"content": resp.content})
 
                 extract_and_save_memories(session.workdir, getattr(session.context, 'all_messages', session.context.messages))

{alpiecode-8.0.7 → alpiecode-8.0.8}/src/codeagent/tools.py

@@ -496,7 +496,7 @@ def _bash(workdir: Path, command: str) -> str:
 
         return output
     except subprocess.TimeoutExpired:
-        return json.dumps({"stdout": "", "stderr": "Command timed out after 300s", "exit_code": -1})
+        return json.dumps({"stdout": "", "stderr": "Command timed out after 120s", "exit_code": -1})
 
 
 def _read_file(workdir: Path, path: str, start_line: int = None, end_line: int = None) -> str:

alpiecode-8.0.8/test/test_phase1.py

@@ -0,0 +1,205 @@
+"""
+Unit tests verifying Phase 1 stability fixes:
+- BUG-01: executor.py dead code removal
+- BUG-02: cli.py duplicate command handler removal
+- BUG-04: orchestrator.py verification nudge state leak prevention
+- BUG-06: orchestrator.py backend immutability / thread safety
+- BUG-09: tools.py bash timeout error message alignment
+- BUG-11: compaction.py tool-call pairing integrity
+"""
+import ast
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+import json
+import pytest
+
+from codeagent.executor import ToolExecutor, ToolCall, ToolResult
+from codeagent.compaction import compact_messages, KEEP_RECENT_TURNS
+from codeagent.orchestrator import AgentOrchestrator
+from codeagent.session import SessionManager
+from codeagent.config import Config
+from codeagent.backends.base import ChatResponse
+from codeagent.backends.openai_backend import OpenAIBackend
+from codeagent.backends.local_backend import LocalBackend
+
+
+def test_bug01_executor_dead_code_removed():
+    """Verify executor.py no longer contains the unreachable sequential execution block."""
+    executor_path = Path(__file__).resolve().parent.parent / "src" / "codeagent" / "executor.py"
+    content = executor_path.read_text(encoding="utf-8")
+    assert "# Sequential execution" not in content
+    assert content.count("return results") == 0
+
+
+def test_bug01_executor_execution():
+    """Verify ToolExecutor correctly executes tool calls via the DAG pipeline."""
+    workdir = Path("/tmp")
+    executor = ToolExecutor(workdir)
+
+    def dummy_tool(args):
+        return f"result: {args.get('x', 0)}"
+
+    executor.dispatch["dummy_tool"] = dummy_tool
+
+    calls = [
+        ToolCall(id="c1", name="dummy_tool", arguments={"x": 42}),
+        ToolCall(id="c2", name="dummy_tool", arguments={"x": 99}),
+    ]
+
+    results = executor.execute_tool_calls(calls)
+    assert len(results) == 2
+    assert results[0].tool_call_id == "c1"
+    assert "result: 42" in results[0].content
+    assert results[1].tool_call_id == "c2"
+    assert "result: 99" in results[1].content
+
+
+def test_bug02_cli_no_duplicate_handlers():
+    """Verify cli.py has exactly one diff and one doctor handler."""
+    cli_path = Path(__file__).resolve().parent.parent / "src" / "codeagent" / "cli.py"
+    content = cli_path.read_text(encoding="utf-8")
+    
+    assert content.count('args.command == "diff"') == 1
+    assert content.count('args.command == "doctor"') == 1
+
+
+def test_bug04_and_06_orchestrator_state_isolation(tmp_path):
+    """Verify orchestrator does not leak verification_nudge on self and does not mutate self.backend."""
+    mock_backend = MagicMock(spec=["name", "is_available", "chat_completion"])
+    mock_backend.name = "MockOpenAI"
+    mock_backend.is_available = True
+    mock_backend.chat_completion.return_value = ChatResponse(
+        content="DONE: Task is finished",
+        reasoning=None,
+        tool_calls=[],
+    )
+
+    orchestrator = AgentOrchestrator(backend=mock_backend)
+    session_mgr = SessionManager()
+    session = session_mgr.create_session(workdir=tmp_path, max_tokens=8192)
+    cfg = Config()
+
+    # Before run
+    assert not hasattr(orchestrator, "_verification_nudge")
+    original_backend = orchestrator.backend
+
+    events = list(orchestrator.run_task(session=session, task="Simple test task", cfg=cfg))
+
+    # After run: verify _verification_nudge is NOT set on orchestrator instance
+    assert not hasattr(orchestrator, "_verification_nudge")
+    # Verify backend on orchestrator was NOT mutated
+    assert orchestrator.backend is original_backend
+
+    done_events = [e for e in events if e.type == "done"]
+    assert len(done_events) == 1
+
+
+def test_bug06_fallback_preserves_orchestrator_backend(tmp_path):
+    """Verify that when online backend fails and falls back to local, self.backend is NOT mutated."""
+    mock_openai = MagicMock(spec=OpenAIBackend)
+    mock_openai.name = "OpenAI"
+    mock_openai.is_available = True
+    mock_openai.chat_completion.side_effect = ConnectionError("Online service unreachable")
+    # Disallow stream so it hits chat_completion directly
+    del mock_openai.chat_completion_stream
+
+    orchestrator = AgentOrchestrator(backend=mock_openai)
+    session_mgr = SessionManager()
+    session = session_mgr.create_session(workdir=tmp_path, max_tokens=8192)
+    cfg = Config()
+
+    fallback_resp = ChatResponse(
+        content="DONE: Handled by local fallback",
+        reasoning=None,
+        tool_calls=[],
+    )
+
+    with patch.object(LocalBackend, "__init__", return_value=None), \
+         patch.object(LocalBackend, "chat_completion", return_value=fallback_resp):
+        events = list(orchestrator.run_task(session=session, task="Fallback test", cfg=cfg))
+
+    event_types = [e.type for e in events]
+    assert "fallback" in event_types
+    assert "done" in event_types
+
+    # Critical check: orchestrator.backend must still be the original OpenAI backend!
+    assert orchestrator.backend is mock_openai
+
+
+def test_orchestrator_streaming(tmp_path):
+    """Verify orchestrator handles streaming backends properly."""
+    mock_backend = MagicMock(spec=["name", "is_available", "chat_completion", "chat_completion_stream"])
+    mock_backend.name = "MockStreamBackend"
+    mock_backend.is_available = True
+    
+    chat_resp = ChatResponse(
+        content="DONE: Stream completed",
+        reasoning="thinking about stream",
+        tool_calls=[],
+    )
+    mock_backend.chat_completion_stream.return_value = iter([
+        ("token", {"delta": "DONE: "}),
+        ("token", {"delta": "Stream completed"}),
+        ("done", chat_resp),
+    ])
+
+    orchestrator = AgentOrchestrator(backend=mock_backend)
+    session_mgr = SessionManager()
+    session = session_mgr.create_session(workdir=tmp_path, max_tokens=8192)
+    cfg = Config()
+
+    events = list(orchestrator.run_task(session=session, task="Streaming test", cfg=cfg))
+    event_types = [e.type for e in events]
+    assert "token" in event_types
+    assert "done" in event_types
+
+
+def test_bug09_bash_timeout_message(tmp_path):
+    """Verify tools.py _bash returns 120s timeout in error message."""
+    import subprocess
+    from codeagent.tools import _bash
+
+    with patch("subprocess.run", side_effect=subprocess.TimeoutExpired(cmd="sleep 200", timeout=120)):
+        res = _bash(tmp_path, "sleep 200")
+        data = json.loads(res)
+        assert data["exit_code"] == -1
+        assert "120s" in data["stderr"]
+        assert "300s" not in data["stderr"]
+
+
+def test_bug11_compaction_tool_pairing_guard():
+    """Verify compact_messages does not split an assistant tool-call from its tool results."""
+    # Build a message list where KEEP_RECENT_TURNS would land right on a tool message
+    messages = [
+        {"role": "system", "content": "You are AlpieCode."},
+        {"role": "user", "content": "Initial prompt"},
+        {"role": "assistant", "content": "Thinking about step 1..."},
+        {"role": "user", "content": "Continue"},
+    ]
+
+    # Add several turns of assistant + tool calls
+    for i in range(10):
+        call_id = f"call_{i}"
+        messages.append({
+            "role": "assistant",
+            "content": f"Running tool {i}",
+            "tool_calls": [{"id": call_id, "function": {"name": "read_file", "arguments": "{}"}}]
+        })
+        messages.append({
+            "role": "tool",
+            "tool_call_id": call_id,
+            "content": f"file content {i}"
+        })
+
+    compacted = compact_messages(messages)
+    assert len(compacted) > 0
+    assert compacted[0]["role"] == "system"
+
+    # In compacted messages, every 'tool' message must be immediately preceded by
+    # an 'assistant' message that contains its tool_call_id or another 'tool' from the same assistant
+    for idx, msg in enumerate(compacted):
+        if msg.get("role") == "tool":
+            prev_msg = compacted[idx - 1]
+            assert prev_msg.get("role") in ("assistant", "tool"), (
+                f"Tool message at index {idx} was preceded by role '{prev_msg.get('role')}'"
+            )