alpiecode 10.5.1__tar.gz → 10.5.2__tar.gz

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

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

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

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

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

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

{alpiecode-10.5.1 → alpiecode-10.5.2}/src/alpiecode.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/alpiecode.egg-info/requires.txt
 src/alpiecode.egg-info/top_level.txt
 src/codeagent/__init__.py
 src/codeagent/agent.py
+src/codeagent/assessment.py
 src/codeagent/cache.py
 src/codeagent/cli.py
 src/codeagent/client.py
@@ -44,4 +45,5 @@ src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
 src/codeagent/extension/alpiecode.vsix
 test/test_context_and_trajectory.py
-test/test_dream_rsi.py
+test/test_dream_rsi.py
+test/test_task_assessment.py

{alpiecode-10.5.1 → alpiecode-10.5.2}/src/codeagent/__init__.py

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

{alpiecode-10.5.1 → alpiecode-10.5.2}/src/codeagent/agent.py

@@ -193,6 +193,18 @@ def _checkpoint(workdir: Path, message: str) -> None:
 
 # ── Main CLI Agent Functions ──────────────────────────────────────────
 
+class AgentRunResult(list):
+    """List of session context messages with execution status."""
+
+    def __init__(self, messages=None, success=True, outcome="success"):
+        super().__init__(messages or [])
+        self.success = success
+        self.outcome = outcome
+
+    def __bool__(self):
+        return self.success
+
+
 def run_agent(
     task: str,
     workdir: Path,
@@ -205,7 +217,7 @@ def run_agent(
     server_url: str = None,
     complexity: str = None,
     debug: bool = False,
-) -> list:
+) -> AgentRunResult:
     """Run non-interactive agent task with Rich presentation."""
     workdir = workdir.resolve()
     _ensure_git(workdir)
@@ -256,6 +268,9 @@ def run_agent(
     last_discovery = {}
     has_streamed_tokens = False
     has_printed_anything = False
+    task_success = True
+    task_outcome = "success"
+    task_failure_message = ""
 
     for event in event_stream:
         if event.type == "token" and verbose:
@@ -470,17 +485,39 @@ def run_agent(
                     f"Cache Hits: {data.get('cache_hits')}"
                 )
 
-        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 == "failed":
+            task_success = False
+            task_outcome = event.data.get("reason", "failed")
+            task_failure_message = event.data.get("message", "Task failed.")
+            if verbose:
+                if HAS_RICH:
+                    console.print(Panel(
+                        f"[bold red]❌ Task Failed[/bold red]\n{task_failure_message}",
+                        border_style="red",
+                        title="Failure Notice"
+                    ))
+                else:
+                    print(f"\n❌ Task Failed: {task_failure_message}")
+
+        elif event.type == "safety_ceiling":
+            task_success = False
+            if task_outcome == "success":
+                task_outcome = "safety_ceiling"
+            if 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":
+            if not event.data.get("success", True):
+                task_success = False
+                if task_outcome == "success":
+                    task_outcome = "failed"
             if has_streamed_tokens:
                 sys.stdout.write("\n\n")
                 sys.stdout.flush()
@@ -490,23 +527,31 @@ def run_agent(
                 has_printed_anything = True
             _checkpoint(workdir, "checkpoint: done")
             if debug and HAS_RICH:
-                console.rule("[bold green]✅ Complete[/bold green]")
+                if task_success:
+                    console.rule("[bold green]✅ Complete[/bold green]")
+                else:
+                    console.rule("[bold red]❌ Failed[/bold red]")
 
-        elif event.type == "max_turns_reached" and verbose:
-            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.")
+        elif event.type == "max_turns_reached":
+            task_success = False
+            if task_outcome == "success":
+                task_outcome = "max_turns_reached"
+            if verbose:
+                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 []
+    msgs = session.context.messages if "session" in locals() else []
+    return AgentRunResult(msgs, success=task_success, outcome=task_outcome)
 
 
 def run_chat(workdir: Path, cfg: Config, verbose: bool = True, debug: bool = False) -> None:

alpiecode-10.5.2/src/codeagent/assessment.py

@@ -0,0 +1,400 @@
+"""
+Task Assessment Engine for AlpieCode.
+
+Replaces brittle heuristic keyword matching with structured, multi-factor analysis:
+  - Intent: (qa, explain, create, modify, debug)
+  - Scope: (local, file, module, system)
+  - Ambiguity: (clear, moderate, ambiguous)
+  - Repository impact: (none, isolated, cross_file, systemic)
+  - Dependency impact: (none, local_imports, external_deps, environment)
+  - Risk: (low, medium, high)
+  - Verification required & methods: (syntax, unit_tests, execution)
+  - Estimated tool calls: (0 to 12+)
+  - Execution Strategy: (fast_path vs reasoning_path)
+
+Deterministic, sub-15ms execution, zero LLM calls, zero network.
+Provides 100% backward compatibility with legacy complexity ('qa', 'low', 'medium', 'high').
+"""
+
+import os
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+
+class TaskIntent(str, Enum):
+    QA = "qa"
+    EXPLAIN = "explain"
+    CREATE = "create"
+    MODIFY = "modify"
+    DEBUG = "debug"
+
+
+class TaskScope(str, Enum):
+    LOCAL = "local"       # Standalone script, simple function, no repository dependencies
+    FILE = "file"         # Single existing file or isolated component
+    MODULE = "module"     # Multiple files within a module/feature
+    SYSTEM = "system"     # Cross-cutting, architecture overhaul, multi-service, full-stack
+
+
+class AmbiguityLevel(str, Enum):
+    CLEAR = "clear"         # Unambiguous requirements, explicit inputs/outputs or targets
+    MODERATE = "moderate"   # Clear goal, but implementation or design details are open
+    AMBIGUOUS = "ambiguous" # Vague, underspecified, or exploratory request
+
+
+class RepositoryImpact(str, Enum):
+    NONE = "none"           # Read-only or purely conceptual (QA, explain)
+    ISOLATED = "isolated"   # Single leaf file, scratch script, or single test
+    CROSS_FILE = "cross_file" # Spans multiple files or impacts inter-module imports
+    SYSTEMIC = "systemic"   # Modifies configs, central architecture, schemas, or root manifests
+
+
+class DependencyImpact(str, Enum):
+    NONE = "none"           # Standard library or existing in-tree code only
+    LOCAL_IMPORTS = "local_imports" # Inter-module project imports
+    EXTERNAL_DEPS = "external_deps" # Introduces or alters 3rd party packages
+    ENVIRONMENT = "environment"   # Modifies docker, containers, env vars, or system packages
+
+
+class RiskLevel(str, Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class ExecutionStrategy(str, Enum):
+    FAST_PATH = "fast_path"           # Direct execution: Execute -> Finish
+    REASONING_PATH = "reasoning_path" # Plan -> Execute -> Verify -> (Pass -> Finish | Fail -> Re-plan/Reason)
+
+
+@dataclass
+class TaskAssessment:
+    """Rigorous, multi-factor intelligence assessing a software task before execution."""
+
+    intent: str
+    scope: str
+    ambiguity: str
+    repo_impact: str
+    dep_impact: str
+    risk: str
+    verification_required: bool
+    verification_methods: List[str] = field(default_factory=list)
+    estimated_tool_calls: int = 1
+    strategy: str = ExecutionStrategy.FAST_PATH.value
+    rationale: str = ""
+
+    @property
+    def legacy_complexity(self) -> str:
+        """Transparent mapping to legacy complexity level for 100% backward compatibility."""
+        if self.intent == TaskIntent.QA.value:
+            return "qa"
+        if self.strategy == ExecutionStrategy.FAST_PATH.value:
+            return "low"
+        # Reasoning path:
+        if (
+            self.scope == TaskScope.SYSTEM.value
+            or self.risk == RiskLevel.HIGH.value
+            or self.repo_impact == RepositoryImpact.SYSTEMIC.value
+        ):
+            return "high"
+        return "medium"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "intent": self.intent,
+            "scope": self.scope,
+            "ambiguity": self.ambiguity,
+            "repo_impact": self.repo_impact,
+            "dep_impact": self.dep_impact,
+            "risk": self.risk,
+            "verification_required": self.verification_required,
+            "verification_methods": list(self.verification_methods),
+            "estimated_tool_calls": self.estimated_tool_calls,
+            "strategy": self.strategy,
+            "rationale": self.rationale,
+            "legacy_complexity": self.legacy_complexity,
+        }
+
+
+# ── Pattern Dictionaries for Sub-15ms Deterministic Analysis ───────────────
+
+_QA_INDICATORS = [
+    r"^\s*(what\s+is|what\s+are|what\'s|what\s+does|what\s+do)\b",
+    r"^\s*(explain|describe|define|compare|contrast)\b",
+    r"^\s*(how\s+does|how\s+do|why\s+does|why\s+do|why\s+is)\b",
+    r"^\s*(can\s+you\s+explain|could\s+you\s+explain|tell\s+me\s+about)\b",
+    r"^\s*(who\s+invented|when\s+was|difference\s+between)\b",
+    r"^\s*(is\s+it\s+possible|is\s+there\s+a\s+way)\b",
+]
+
+_EXPLAIN_INDICATORS = [
+    r"\b(explain\s+this|explain\s+the|walk\s+me\s+through|how\s+does\s+this\s+work)\b",
+    r"\b(what\s+does\s+this\s+do|analyze\s+this|review\s+this|code\s+review)\b",
+    r"\b(read\s+and\s+explain|summarize\s+this\s+code)\b",
+]
+
+_DEBUG_INDICATORS = [
+    r"\b(debug|diagnose|troubleshoot|trace|fix\s+bug|fix\s+the\s+bug)\b",
+    r"\b(find\s+the\s+bug|find\s+the\s+issue|why\s+is\s+this\s+failing)\b",
+    r"\b(traceback|stacktrace|exception|segfault|segmentation\s+fault)\b",
+    r"\b(memory\s+leak|leak\s+during|deadlock|race\s+condition|hangs|hanging)\b",
+    r"\b(failing\s+test|test\s+failure|broken\s+build|syntax\s+error)\b",
+    r"\b(investigate\s+why|investigate\s+error|investigate\s+failure|investigate\s+leak)\b",
+]
+
+_MODIFY_INDICATORS = [
+    r"\b(modify|update|change|refactor|restructure|reorganize)\b",
+    r"\b(add\s+feature|extend|integrate|migrate|upgrade|optimize|improve)\b",
+    r"\b(convert|transform|replace|swap|rename|remove\s+from|delete\s+from)\b",
+    r"\b(add\s+endpoint|add\s+route|add\s+method|add\s+support\s+for)\b",
+]
+
+_STANDALONE_ALGORITHMS = {
+    "palindrome", "fibonacci", "quicksort", "mergesort", "bubblesort", "heapsort",
+    "binary search", "binary_search", "factorial", "hello world", "calculator",
+    "is_palindrome", "check palindrome", "reverse string", "reverse_string",
+    "prime number", "prime_number", "anagram", "todo script", "simple script",
+    "gcd", "lcm", "matrix multiplication", "linked list", "binary tree",
+    "two sum", "fizzbuzz", "fizz buzz", "string reversal",
+}
+
+_SYSTEM_INDICATORS = [
+    r"\b(full\s*stack|fullstack|full-stack)\b",
+    r"\b(microservice|microservices|distributed\s+system)\b",
+    r"\b(docker|kubernetes|k8s|container|docker-compose|dockerfile)\b",
+    r"\b(ci\/cd|pipeline|github\s+actions|jenkins)\b",
+    r"\b(database\s+migration|schema\s+migration|alembic|prisma\s+migrate)\b",
+    r"\b(authentication|oauth|jwt\s+auth|sso|rbac)\b",
+    r"\b(machine\s+learning|deep\s+learning|neural\s+network|training\s+pipeline)\b",
+    r"\b(architectural|architecture\s+overhaul|system-wide|entire\s+repo)\b",
+]
+
+_HIGH_RISK_INDICATORS = [
+    r"\b(delete|drop\s+database|drop\s+table|truncate|rm\s+-rf|destroy)\b",
+    r"\b(migration|schema\s+change|database\s+schema)\b",
+    r"\b(credential|secret|token|password|auth\s+bypass)\b",
+    r"\b(memory\s+leak|deadlock|race\s+condition|concurrency)\b",
+    r"\b(restructure\s+all|rewrite\s+all|refactor\s+entire)\b",
+]
+
+_ENVIRONMENT_INDICATORS = [
+    r"\b(docker|docker-compose|k8s|kubernetes|container|helm)\b",
+    r"\b(ci\/cd|workflow|pipeline|github\s+actions)\b",
+    r"\b(environment\s+variable|\.env|env\s+vars)\b",
+    r"\b(virtualenv|venv|pip\s+install|npm\s+install|cargo\s+add)\b",
+]
+
+_EXTERNAL_DEP_INDICATORS = [
+    r"\b(install|dependency|package|requirements\.txt|package\.json|cargo\.toml)\b",
+    r"\b(pydantic|fastapi|flask|django|react|vue|angular|express|torch|pandas|numpy)\b",
+]
+
+
+def assess_task(
+    task: str,
+    repo_info: Optional[Dict[str, Any]] = None,
+    env_info: Optional[Dict[str, Any]] = None,
+) -> TaskAssessment:
+    """Evaluate task across 8 dimensions and select execution strategy.
+
+    Runs in <15ms. Pure deterministic Python logic, no network or LLM latency.
+    """
+    if not task or not task.strip():
+        return TaskAssessment(
+            intent=TaskIntent.CREATE.value,
+            scope=TaskScope.LOCAL.value,
+            ambiguity=AmbiguityLevel.CLEAR.value,
+            repo_impact=RepositoryImpact.NONE.value,
+            dep_impact=DependencyImpact.NONE.value,
+            risk=RiskLevel.LOW.value,
+            verification_required=False,
+            verification_methods=[],
+            estimated_tool_calls=1,
+            strategy=ExecutionStrategy.FAST_PATH.value,
+            rationale="Empty task string defaulted to fast local execution.",
+        )
+
+    task_clean = task.strip()
+    task_lower = task_clean.lower()
+    repo = repo_info or {}
+    file_count = repo.get("file_count", 0)
+    has_tests = repo.get("has_tests", False)
+    frameworks = repo.get("frameworks", [])
+    project_type = repo.get("project_type", "empty")
+    entry_points = repo.get("entry_points", [])
+
+    # ── 1. Intent Classification ──
+    intent = TaskIntent.CREATE.value
+    if any(re.search(pat, task_lower) for pat in _QA_INDICATORS) and not any(
+        kw in task_lower for kw in ["write", "create", "implement", "build", "fix", "code", "script"]
+    ):
+        intent = TaskIntent.QA.value
+    elif any(re.search(pat, task_lower) for pat in _EXPLAIN_INDICATORS) and not any(
+        kw in task_lower for kw in ["modify", "fix", "implement", "create", "refactor"]
+    ):
+        intent = TaskIntent.EXPLAIN.value
+    elif any(re.search(pat, task_lower) for pat in _DEBUG_INDICATORS):
+        intent = TaskIntent.DEBUG.value
+    elif any(re.search(pat, task_lower) for pat in _MODIFY_INDICATORS):
+        intent = TaskIntent.MODIFY.value
+    elif intent == TaskIntent.CREATE.value and any(re.search(pat, task_lower) for pat in _QA_INDICATORS):
+        # Fallback question check
+        intent = TaskIntent.QA.value
+
+    # ── 2. Scope Evaluation ──
+    # Check if task is a standalone algorithm or single-file script
+    is_standalone_algo = any(algo in task_lower for algo in _STANDALONE_ALGORITHMS)
+    has_project_ref = any(
+        p in task_lower for p in [
+            "this project", "this repo", "our repo", "our project", "existing codebase",
+            "in this codebase", "in the project", "entry point", "route", "database",
+        ]
+    )
+
+    # Check mentioned files
+    mentioned_files: List[str] = []
+    file_pattern = r"\b[a-zA-Z0-9_\-\./]+\.(?:py|js|ts|jsx|tsx|html|css|json|yaml|yml|toml|rs|go|java|sh|md)\b"
+    for match in re.finditer(file_pattern, task):
+        m_str = match.group(0)
+        if not m_str.startswith("http") and "/" in m_str or "." in m_str:
+            mentioned_files.append(m_str)
+
+    is_system_task = any(re.search(pat, task_lower) for pat in _SYSTEM_INDICATORS)
+
+    if intent == TaskIntent.QA.value:
+        scope = TaskScope.LOCAL.value
+    elif is_system_task or (file_count > 50 and intent in (TaskIntent.MODIFY.value, TaskIntent.DEBUG.value) and any(w in task_lower for w in ["all", "across", "entire", "every", "repo"])):
+        scope = TaskScope.SYSTEM.value
+    elif (is_standalone_algo or "simple script" in task_lower or "write a script" in task_lower) and not has_project_ref and (project_type == "empty" or not mentioned_files):
+        scope = TaskScope.LOCAL.value
+    elif len(mentioned_files) == 1 and not is_system_task and intent in (TaskIntent.MODIFY.value, TaskIntent.EXPLAIN.value):
+        scope = TaskScope.FILE.value
+    elif len(mentioned_files) > 1 or file_count > 5 or frameworks or intent in (TaskIntent.MODIFY.value, TaskIntent.DEBUG.value):
+        scope = TaskScope.MODULE.value
+    elif project_type != "empty" and file_count > 0:
+        scope = TaskScope.FILE.value
+    else:
+        scope = TaskScope.LOCAL.value
+
+    # ── 3. Ambiguity Evaluation ──
+    word_count = len(task_clean.split())
+    has_concrete_target = bool(mentioned_files) or is_standalone_algo
+    has_error_message = bool(re.search(r"(error:|exception:|failed with|traceback|syntaxerror|typeerror)", task_lower))
+
+    if word_count < 6 and not has_concrete_target and not has_error_message:
+        ambiguity = AmbiguityLevel.AMBIGUOUS.value
+    elif any(phrase in task_lower for phrase in ["make it better", "improve it", "fix it", "clean it up", "optimize it"]) and not has_concrete_target:
+        ambiguity = AmbiguityLevel.AMBIGUOUS.value
+    elif (has_concrete_target or has_error_message or word_count > 25) and not any(w in task_lower for w in ["maybe", "somehow", "explore"]):
+        ambiguity = AmbiguityLevel.CLEAR.value
+    else:
+        ambiguity = AmbiguityLevel.MODERATE.value
+
+    # ── 4. Repository Impact Evaluation ──
+    if intent in (TaskIntent.QA.value, TaskIntent.EXPLAIN.value):
+        repo_impact = RepositoryImpact.NONE.value
+    elif scope == TaskScope.SYSTEM.value or any(cfg in task_lower for cfg in ["pyproject.toml", "package.json", "cargo.toml", "docker-compose", "alembic"]):
+        repo_impact = RepositoryImpact.SYSTEMIC.value
+    elif scope == TaskScope.MODULE.value or len(mentioned_files) > 1:
+        repo_impact = RepositoryImpact.CROSS_FILE.value
+    elif scope == TaskScope.FILE.value:
+        repo_impact = RepositoryImpact.ISOLATED.value
+    elif scope == TaskScope.LOCAL.value:
+        repo_impact = RepositoryImpact.ISOLATED.value
+    else:
+        repo_impact = RepositoryImpact.CROSS_FILE.value
+
+    # ── 5. Dependency Impact Evaluation ──
+    if any(re.search(pat, task_lower) for pat in _ENVIRONMENT_INDICATORS):
+        dep_impact = DependencyImpact.ENVIRONMENT.value
+    elif any(re.search(pat, task_lower) for pat in _EXTERNAL_DEP_INDICATORS) and any(w in task_lower for w in ["install", "add package", "new lib", "require"]):
+        dep_impact = DependencyImpact.EXTERNAL_DEPS.value
+    elif scope in (TaskScope.MODULE.value, TaskScope.SYSTEM.value) or len(mentioned_files) > 0:
+        dep_impact = DependencyImpact.LOCAL_IMPORTS.value
+    else:
+        dep_impact = DependencyImpact.NONE.value
+
+    # ── 6. Risk Evaluation ──
+    if any(re.search(pat, task_lower) for pat in _HIGH_RISK_INDICATORS) or scope == TaskScope.SYSTEM.value:
+        risk = RiskLevel.HIGH.value
+    elif intent in (TaskIntent.QA.value, TaskIntent.EXPLAIN.value) or (scope == TaskScope.LOCAL.value and ambiguity == AmbiguityLevel.CLEAR.value):
+        risk = RiskLevel.LOW.value
+    elif intent == TaskIntent.DEBUG.value or repo_impact in (RepositoryImpact.CROSS_FILE.value, RepositoryImpact.SYSTEMIC.value):
+        risk = RiskLevel.MEDIUM.value
+    elif intent == TaskIntent.MODIFY.value:
+        risk = RiskLevel.MEDIUM.value
+    else:
+        risk = RiskLevel.LOW.value
+
+    # ── 7. Verification Requirements & Methods ──
+    verification_methods: List[str] = []
+    if intent in (TaskIntent.QA.value, TaskIntent.EXPLAIN.value):
+        verification_required = False
+    else:
+        verification_required = True
+        # Code tasks require verification
+        if project_type == "python" or any(f.endswith(".py") for f in mentioned_files) or "python" in task_lower:
+            verification_methods.append("syntax")
+        elif project_type == "node" or any(f.endswith((".js", ".ts")) for f in mentioned_files) or "javascript" in task_lower:
+            verification_methods.append("syntax")
+
+        if has_tests or "test" in task_lower or "pytest" in frameworks or "jest" in frameworks:
+            verification_methods.append("unit_tests")
+
+        if scope in (TaskScope.LOCAL.value, TaskScope.FILE.value) and not verification_methods:
+            verification_methods.append("execution")
+
+    # ── 8. Estimated Tool Calls ──
+    if intent == TaskIntent.QA.value:
+        estimated_tool_calls = 0
+    elif intent == TaskIntent.EXPLAIN.value:
+        estimated_tool_calls = 1 if mentioned_files else 0
+    elif scope == TaskScope.LOCAL.value and risk == RiskLevel.LOW.value:
+        estimated_tool_calls = 2  # write_file + optional verify run
+    elif scope == TaskScope.FILE.value:
+        estimated_tool_calls = 3  # read_file + edit_file + verify
+    elif scope == TaskScope.MODULE.value:
+        estimated_tool_calls = 6  # multi-file reads, edits, verification runs
+    else:  # SYSTEM
+        estimated_tool_calls = 10
+
+    # ── 9. Strategy Routing (Fast Path vs Reasoning Path) ──
+    # Fast path: standalone algorithms, direct single scripts, direct Q&A / explain
+    # Reasoning path: debugging, refactoring, multi-file modules, systems, or moderate/high risk
+    if intent == TaskIntent.QA.value:
+        strategy = ExecutionStrategy.FAST_PATH.value
+        rationale = "Direct question answering without filesystem modifications."
+    elif intent == TaskIntent.EXPLAIN.value and scope in (TaskScope.LOCAL.value, TaskScope.FILE.value):
+        strategy = ExecutionStrategy.FAST_PATH.value
+        rationale = "Read and explain task with localized read-only scope."
+    elif (
+        scope == TaskScope.LOCAL.value
+        and risk == RiskLevel.LOW.value
+        and ambiguity == AmbiguityLevel.CLEAR.value
+        and intent == TaskIntent.CREATE.value
+    ):
+        strategy = ExecutionStrategy.FAST_PATH.value
+        rationale = "Self-contained local script/algorithm with clear requirements and low risk."
+    else:
+        strategy = ExecutionStrategy.REASONING_PATH.value
+        rationale = (
+            f"Multi-factor assessment indicates {scope} scope with {risk} risk and {intent} intent; "
+            "requires Plan -> Execute -> Verify pipeline."
+        )
+
+    return TaskAssessment(
+        intent=intent,
+        scope=scope,
+        ambiguity=ambiguity,
+        repo_impact=repo_impact,
+        dep_impact=dep_impact,
+        risk=risk,
+        verification_required=verification_required,
+        verification_methods=verification_methods,
+        estimated_tool_calls=estimated_tool_calls,
+        strategy=strategy,
+        rationale=rationale,
+    )

{alpiecode-10.5.1 → alpiecode-10.5.2}/src/codeagent/backends/local_backend.py

@@ -128,6 +128,14 @@ class LocalBackend:
             clean["content"] = content
             sanitized.append(clean)
 
+        if sanitized and sanitized[-1].get("role") == "user" and "[Tool Result" in sanitized[-1].get("content", ""):
+            prompt_hint = (
+                "\n\n[Next Action: Output your next <tool_call> (e.g. write_file or bash) immediately. "
+                "Do NOT output conversational text. When all files are created and verified, output: DONE: <summary>.]"
+            )
+            if prompt_hint not in sanitized[-1]["content"]:
+                sanitized[-1]["content"] += prompt_hint
+
         return sanitized
 
     def chat_completion(

{alpiecode-10.5.1 → alpiecode-10.5.2}/src/codeagent/backends/openai_backend.py

@@ -48,6 +48,9 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
     # 3. Structural repair for streaming cutoffs / trailing commas
     repaired = text
 
+    # Strip any trailing incomplete key without value (e.g. `, "file` from streaming cutoff)
+    repaired = re.sub(r',\s*["\']?[a-zA-Z0-9_-]*\s*$', '', repaired)
+
     # Remove trailing commas like `..., }` or `..., ]`
     repaired = re.sub(r",\s*([\}\]])", r"\1", repaired)
 
@@ -83,15 +86,18 @@ def _repair_and_parse_json_arguments(raw_args: str) -> dict:
     except Exception:
         pass
 
-    # 4. If still failing, attempt regex key-value extraction for simple {"key": "val"} forms
+    # 4. If still failing, attempt regex key-value extraction with proper string escape support
     extracted = {}
-    pattern = r"""['"]([a-zA-Z0-9_-]+)['"]\s*:\s*(?:['"](.*?)['"]|([0-9.]+|true|false|null))"""
+    pattern = r"""['"]([a-zA-Z0-9_-]+)['"]\s*:\s*(?:(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)')|([0-9.]+|true|false|null))"""
     for kv in re.finditer(pattern, text, re.IGNORECASE):
         k = kv.group(1)
-        v_str = kv.group(2)
-        v_lit = kv.group(3)
+        v_str = kv.group(2) if kv.group(2) is not None else kv.group(3)
+        v_lit = kv.group(4)
         if v_str is not None:
-            extracted[k] = v_str
+            try:
+                extracted[k] = json.loads(f'"{v_str}"')
+            except Exception:
+                extracted[k] = v_str
         elif v_lit is not None:
             try:
                 extracted[k] = json.loads(v_lit.lower())