coreinsight-cli 0.3.1__tar.gz → 0.3.3__tar.gz

{coreinsight_cli-0.3.1/coreinsight_cli.egg-info → coreinsight_cli-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coreinsight-cli
-Version: 0.3.1
+Version: 0.3.3
 Summary: Local-first AI performance profiler that mathematically verifies optimizations for Python, C++, and CUDA
 Author: Varun Jani
 License: GPL-3.0-or-later
@@ -20,20 +20,30 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: rich>=13.0
+Requires-Dist: textual>=0.60.0
+Requires-Dist: psutil>=5.9
+Requires-Dist: pydantic>=2.0
 Requires-Dist: docker>=6.0
-Requires-Dist: tree-sitter==0.21.3
-Requires-Dist: tree-sitter-languages
-Requires-Dist: langchain>=0.2.0
 Requires-Dist: langchain-core>=0.2.0
+Requires-Dist: langchain>=0.2.0
 Requires-Dist: langchain-ollama>=0.1.0
-Requires-Dist: langchain-google-genai>=1.0.0
 Requires-Dist: langchain-openai>=0.1.0
-Requires-Dist: langchain-anthropic>=0.1.0
-Requires-Dist: pydantic>=2.0
-Requires-Dist: chromadb>=0.5.0
-Requires-Dist: sentence-transformers>=3.0.0
-Requires-Dist: textual>=0.60.0
-Requires-Dist: psutil>=5.9
+Requires-Dist: tree-sitter==0.21.3
+Requires-Dist: tree-sitter-languages
+Provides-Extra: openai
+Provides-Extra: google
+Requires-Dist: langchain-google-genai>=1.0.0; extra == "google"
+Provides-Extra: anthropic
+Requires-Dist: langchain-anthropic>=0.1.0; extra == "anthropic"
+Provides-Extra: memory
+Requires-Dist: chromadb>=0.5.0; extra == "memory"
+Requires-Dist: sentence-transformers>=3.0.0; extra == "memory"
+Provides-Extra: cloud
+Requires-Dist: langchain-openai>=0.1.0; extra == "cloud"
+Requires-Dist: langchain-google-genai>=1.0.0; extra == "cloud"
+Requires-Dist: langchain-anthropic>=0.1.0; extra == "cloud"
+Provides-Extra: all
+Requires-Dist: coreinsight-cli[cloud,memory]; extra == "all"
 Provides-Extra: compat
 Requires-Dist: pysqlite3-binary>=0.5.0; extra == "compat"
 Dynamic: license-file
@@ -49,7 +59,23 @@ CoreInsight finds hardware bottlenecks in your code, generates optimized replace
 ## Install
 
 ```bash
+# OpenAI key - quick install
+pip install coreinsight-cli[openai]
+
+# Gemini key - quick install
+pip install coreinsight-cli[google]
+
+# Claude key - quick install
+pip install coreinsight-cli[anthropic]
+
+# Local Ollama install
 pip install coreinsight-cli
+
+# Memory and additional usage install
+pip install coreinsight-cli[openai,memory]
+
+# Install everything
+pip install coreinsight-cli[all]
 ```
 
 **Requirements:** Python 3.9+ · Docker Desktop · [Ollama](https://ollama.com/download) (for local inference)

{coreinsight_cli-0.3.1 → coreinsight_cli-0.3.3}/README.md

@@ -9,7 +9,23 @@ CoreInsight finds hardware bottlenecks in your code, generates optimized replace
 ## Install
 
 ```bash
+# OpenAI key - quick install
+pip install coreinsight-cli[openai]
+
+# Gemini key - quick install
+pip install coreinsight-cli[google]
+
+# Claude key - quick install
+pip install coreinsight-cli[anthropic]
+
+# Local Ollama install
 pip install coreinsight-cli
+
+# Memory and additional usage install
+pip install coreinsight-cli[openai,memory]
+
+# Install everything
+pip install coreinsight-cli[all]
 ```
 
 **Requirements:** Python 3.9+ · Docker Desktop · [Ollama](https://ollama.com/download) (for local inference)

{coreinsight_cli-0.3.1 → coreinsight_cli-0.3.3}/coreinsight/analyzer.py

@@ -8,11 +8,11 @@ from langchain_core.prompts import PromptTemplate
 from langchain_core.exceptions import OutputParserException
 
 from langchain_ollama import ChatOllama
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_openai import ChatOpenAI
-from langchain_anthropic import ChatAnthropic
 
-from coreinsight.prompts import SYSTEM_PROMPT, ANALYSIS_TEMPLATE, HARNESS_ADDENDUM
+from coreinsight.prompts import (
+    SYSTEM_PROMPT, ANALYSIS_TEMPLATE, HARNESS_ADDENDUM,
+    _HARNESS_TEMPLATE, _FIX_TEMPLATE, _TEST_CASES_TEMPLATE,
+)
 
 # Phrases that appear at the start of a truncated LLM response
 _TRUNCATION_HINTS = (
@@ -99,117 +99,6 @@ class AuditResult(BaseModel):
     optimized_code: Optional[str] = Field(description="The entirely rewritten optimized code, ready to drop in", default=None)
 
 
-_HARNESS_TEMPLATE = """
-You are a strict QA engineer writing a standalone asymptotic scaling benchmark script in {language}.
-
-ORIGINAL FUNCTION (Name: {func_name}):
-{original}
-
-OPTIMIZED FUNCTION:
-{optimized}
-
-GLOBAL DEPENDENCIES (Helper functions/structs required to run the code):
-{context}
-
-Write the complete executable script (e.g., `int main()` or `if __name__ == "__main__":`) that:
-1. Includes necessary imports/headers.
-2. Includes ALL required helper functions or structs from GLOBAL DEPENDENCIES so the script is fully standalone.
-3. Defines BOTH the original and optimized functions exactly as provided above.
-4. Tests multiple data sizes (e.g., N=10, 100, 1000, 5000).
-5. Target Hardware: {hardware_target}. The largest N MUST cross cache boundaries but MUST NOT exceed 20% of available RAM to prevent OOM crashes.
-6. Initializes realistic dummy data for each size N.
-7. Times execution of original vs optimized using high-resolution timers.
-
-CRITICAL TIMING:
-- Python: use `time.perf_counter()`. C++: use `std::chrono::high_resolution_clock`.
-- Clamp: `orig_time = max(end - start, 1e-9)` to prevent zero-division.
-- Speedup: `speedup = orig_time / opt_time`.
-
-ISOLATION RULES (CRITICAL):
-- This runs in an empty Docker container. NO local files exist.
-- DO NOT use local imports. Define everything inline.
-- DO NOT rename the original function — call it exactly `{func_name}`.
-
-OUTPUT FORMAT (CRITICAL):
-Print ONLY this exact CSV to stdout, no other text:
-N,Original_Time,Optimized_Time,Speedup
-10,0.002,0.001,2.00
-
-[PYTHON ONLY]: Also import matplotlib, plot results, and save as `benchmark_plot.png`.
-
-FORMATTING RULE: Wrap your ENTIRE script in a single markdown code block. No text before or after.
-"""
-
-_FIX_TEMPLATE = """
-You are an expert {language} developer. Your previous benchmark script FAILED in an isolated sandbox.
-
-ORIGINAL FUNCTION (Name: {func_name}):
-{original}
-
-GLOBAL DEPENDENCIES:
-{context}
-
-YOUR FAILED SCRIPT:
-{bad_harness}
-
-EXECUTION ERROR LOGS:
-{error_logs}
-
-ISOLATION CONSTRAINTS (CRITICAL):
-- Empty Docker container. No local files. NO local imports.
-- Define `{func_name}` and all GLOBAL DEPENDENCIES inline.
-
-FIX INSTRUCTIONS:
-1. Diagnose the failure from the error logs above.
-2. Fix imports, NameErrors, type mismatches, infinite loops, or OOM issues.
-3. Maintain the CSV stdout format exactly: N,Original_Time,Optimized_Time,Speedup
-4. Use high-resolution timers and clamp with `max(t, 1e-9)`.
-5. [PYTHON ONLY]: Save benchmark plot as `benchmark_plot.png`.
-
-FORMATTING RULE: Wrap your ENTIRE fixed script in a single markdown code block. No text before or after.
-"""
-
-_TEST_CASES_TEMPLATE = """
-You are a QA engineer writing correctness test cases for a function.
-
-FUNCTION NAME: {func_name}
-LANGUAGE: {language}
-
-FUNCTION SIGNATURE AND BODY:
-{original}
-
-GLOBAL DEPENDENCIES (helper functions / structs this function relies on):
-{context}
-
-Your task: generate {num_cases} diverse test cases that call `{func_name}` with different
-arguments. The cases must cover:
-  - Small inputs (N ~ 10)
-  - Medium inputs (N ~ 100-500)
-  - Edge cases: empty collections, single-element, all-zeros, negative values (where applicable)
-  - Boundary conditions specific to this function's logic
-
-OUTPUT FORMAT — respond with ONLY a valid JSON array, nothing else. No markdown fences,
-no explanation. Each element must be a JSON object with exactly two keys:
-  "args"  : a JSON array of positional arguments (use only JSON-serialisable types:
-            numbers, strings, booleans, arrays, objects — NO numpy, NO bytes)
-  "kwargs": a JSON object of keyword arguments (may be empty {{}})
-
-Example (do NOT copy this — generate cases specific to {func_name}):
-[
-  {{"args": [[1, 2, 3]], "kwargs": {{}}}},
-  {{"args": [[]], "kwargs": {{}}}},
-  {{"args": [[9, -1, 4, 0, 7]], "kwargs": {{"reverse": true}}}}
-]
-
-CONSTRAINTS:
-- All values must be plain JSON types — no numpy arrays, no custom objects.
-- If the function operates on a matrix, represent it as a list-of-lists.
-- If the function takes a size integer N, generate concrete data of that size inline.
-- Do NOT include function calls or expressions — only literal values.
-- Produce exactly {num_cases} test cases.
-"""
-
-
 class AnalyzerAgent:
     def __init__(self, provider="ollama", model_name="llama3.2", api_keys=None, model_tier="large"):
         self.model_tier = model_tier
@@ -217,70 +106,15 @@ class AnalyzerAgent:
         self.provider = provider
         api_keys = api_keys or {}
 
-        if provider == "openai":
-            if not api_keys.get("openai"):
-                raise ValueError("OpenAI API Key required.")
-            self.base_llm = ChatOpenAI(
-                model=model_name,
-                api_key=api_keys["openai"],
-                temperature=0.1,
-                model_kwargs={"response_format": {"type": "json_object"}},
-            )
-            self.json_llm = self.base_llm
-
+        # Reuse shared LLM factory — handles lazy imports and provider validation
+        from coreinsight.prompts import ModelTier
+        if provider == "ollama":
+            api_keys["_ctx"]     = 4096 if model_tier == ModelTier.SMALL else 8192
+            api_keys["_predict"] = 2048 if model_tier == ModelTier.SMALL else 4096
         elif provider == "local_server":
-            from coreinsight.prompts import ModelTier
-            base_url   = api_keys.get("local_url", "http://localhost:1234/v1")
-            _max_tokens = 2048 if model_tier == ModelTier.SMALL else 4096
-            self.base_llm = ChatOpenAI(
-                model=model_name,
-                api_key="not-needed",
-                base_url=base_url,
-                temperature=0.1,
-                max_tokens=_max_tokens,
-                model_kwargs={"response_format": {"type": "json_object"}},
-            )
-            self.json_llm = self.base_llm
-
-        elif provider == "anthropic":
-            if not api_keys.get("anthropic"):
-                raise ValueError("Anthropic API Key required.")
-            self.base_llm = ChatAnthropic(
-                model=model_name,
-                api_key=api_keys["anthropic"],
-                temperature=0.1,
-            )
-            # Anthropic doesn't support response_format; JSON is enforced via prompt only
-            self.json_llm = self.base_llm
-
-        elif provider == "google":
-            if not api_keys.get("google"):
-                raise ValueError("Google Gemini API Key required.")
-            self.base_llm = ChatGoogleGenerativeAI(
-                model=model_name,
-                google_api_key=api_keys["google"],
-                temperature=0.1,
-                convert_system_message_to_human=True,
-            )
-            self.json_llm = self.base_llm
-
-        else:  # Ollama default
-            from coreinsight.prompts import ModelTier
-            # Small models (7B) typically have 4096 native context.
-            # Asking for more causes silent degradation or OOM on the host.
-            # Medium/large local models can handle 8192 comfortably.
-            _ctx = 4096 if model_tier == ModelTier.SMALL else 8192
-            # num_predict: small models need room for JSON + code in one shot.
-            # Capping at 2048 for small prevents runaway generation that hits
-            # the limit mid-JSON and returns truncated garbage.
-            _predict = 2048 if model_tier == ModelTier.SMALL else 4096
-            self.base_llm = ChatOllama(
-                model=model_name,
-                temperature=0.1,
-                num_predict=_predict,
-                num_ctx=_ctx,
-            )
-            self.json_llm = self.base_llm.bind(format="json")
+            api_keys["_predict"] = 2048 if model_tier == ModelTier.SMALL else 4096
+            
+        self.base_llm, self.json_llm = _build_llm(provider, model_name, api_keys)
 
         self.prompt = PromptTemplate(
             template=ANALYSIS_TEMPLATE + "\n\n{format_instructions}",
@@ -556,16 +390,17 @@ class AnalyzerAgent:
 # ---------------------------------------------------------------------------
 
 def _build_llm(provider: str, model_name: str, api_keys: dict):
-    """
-    Shared LLM factory for all multi-agent classes.
-    Returns (base_llm, json_llm) — same pattern as AnalyzerAgent.__init__.
-    Raises ValueError on missing credentials.
-    """
     api_keys = api_keys or {}
 
     if provider == "openai":
         if not api_keys.get("openai"):
             raise ValueError("OpenAI API key required.")
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(
+                "OpenAI provider requires: pip install coreinsight-cli[openai]"
+            )
         llm = ChatOpenAI(
             model=model_name,
             api_key=api_keys["openai"],
@@ -575,8 +410,14 @@ def _build_llm(provider: str, model_name: str, api_keys: dict):
         return llm, llm
 
     if provider == "local_server":
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise ImportError(
+                "local_server provider requires: pip install coreinsight-cli[openai]"
+            )
         base_url    = api_keys.get("local_url", "http://localhost:1234/v1")
-        _max_tokens = api_keys.pop("_predict", 4096)  # reuse same key as Ollama path
+        _max_tokens = api_keys.pop("_predict", 4096)
         llm = ChatOpenAI(
             model=model_name,
             api_key="not-needed",
@@ -590,6 +431,12 @@ def _build_llm(provider: str, model_name: str, api_keys: dict):
     if provider == "anthropic":
         if not api_keys.get("anthropic"):
             raise ValueError("Anthropic API key required.")
+        try:
+            from langchain_anthropic import ChatAnthropic
+        except ImportError:
+            raise ImportError(
+                "Anthropic provider requires: pip install coreinsight-cli[anthropic]"
+            )
         llm = ChatAnthropic(
             model=model_name,
             api_key=api_keys["anthropic"],
@@ -600,6 +447,12 @@ def _build_llm(provider: str, model_name: str, api_keys: dict):
     if provider == "google":
         if not api_keys.get("google"):
             raise ValueError("Google Gemini API key required.")
+        try:
+            from langchain_google_genai import ChatGoogleGenerativeAI
+        except ImportError:
+            raise ImportError(
+                "Google provider requires: pip install coreinsight-cli[google]"
+            )
         llm = ChatGoogleGenerativeAI(
             model=model_name,
             google_api_key=api_keys["google"],
@@ -608,9 +461,7 @@ def _build_llm(provider: str, model_name: str, api_keys: dict):
         )
         return llm, llm
 
-    # Ollama default — context and predict budget are passed in from the
-    # calling agent which knows its own model_tier.
-    # Default to medium-safe values; callers override via kwargs if needed.
+    # Ollama default
     _ctx     = api_keys.pop("_ctx",     8192)
     _predict = api_keys.pop("_predict", 4096)
     base = ChatOllama(
@@ -650,13 +501,13 @@ class BottleneckAgent:
         api_keys:   dict,
         model_tier: str,
     ) -> None:
-        from coreinsight.prompts import BOTTLENECK_TEMPLATE, SYSTEM_PROMPT
+        from coreinsight.prompts import BOTTLENECK_TEMPLATES, SYSTEM_PROMPT
         self.model_tier = model_tier
         self.parser     = JsonOutputParser(pydantic_object=AuditResult)
         self._base_llm, self._json_llm = _build_llm_tiered(provider, model_name, api_keys, model_tier)
 
         self._prompt = PromptTemplate(
-            template=BOTTLENECK_TEMPLATE,
+            template=BOTTLENECK_TEMPLATES[model_tier],
             input_variables=[
                 "language", "code_content", "context", "hardware_target",
             ],
@@ -736,10 +587,10 @@ class OptimizerAgent:
         api_keys:   dict,
         model_tier: str,
     ) -> None:
-        from coreinsight.prompts import OPTIMIZER_TEMPLATE
+        from coreinsight.prompts import OPTIMIZER_TEMPLATES
         self.model_tier = model_tier
         self._base_llm, _ = _build_llm_tiered(provider, model_name, api_keys, model_tier)
-        self._template = OPTIMIZER_TEMPLATE
+        self._template = OPTIMIZER_TEMPLATES[model_tier]
 
     def _extract_code(self, raw: str) -> str:
         """Reuse the same extraction logic as AnalyzerAgent."""
@@ -898,7 +749,13 @@ class HarnessAgent:
         except Exception as e:
             return False, f"Harness generation failed: {e}", None, 0
 
-        success, logs, plot_data = sandbox.execute_benchmark(harness, language)
+        # Catch missing int main() before hitting the sandbox
+        if language in ("cpp", "c++") and "int main(" not in harness and "int main (" not in harness:
+            logs     = "Missing CSV output (exit 1).\nFull output:\nundefined reference to `main'"
+            success  = False
+            plot_data = None
+        else:
+            success, logs, plot_data = sandbox.execute_benchmark(harness, language)
         is_valid  = self._check_speedup(success, logs)
         retries   = 0
 
@@ -921,7 +778,12 @@ class HarnessAgent:
                 logs += f"\nFix generation failed: {e}"
                 break
 
-            success, logs, plot_data = sandbox.execute_benchmark(harness, language)
+            if language in ("cpp", "c++") and "int main(" not in harness and "int main (" not in harness:
+                logs      = "Missing CSV output (exit 1).\nFull output:\nundefined reference to `main'"
+                success   = False
+                plot_data = None
+            else:
+                success, logs, plot_data = sandbox.execute_benchmark(harness, language)
             is_valid = self._check_speedup(success, logs)
             retries += 1
 

{coreinsight_cli-0.3.1 → coreinsight_cli-0.3.3}/coreinsight/main.py

@@ -161,7 +161,6 @@ def _run_multi_agent(
     optimized_code = multi_agents["optimizer"].generate(
         func_name, original_code, result,
         language, context, hardware_target,
-        stream_callback=stream_callback,  # readable code, stream it
     )
     if not optimized_code or optimized_code == original_code:
         return result, None, False, "", None, False
@@ -205,21 +204,78 @@ def process_function(func: dict, language: str, agent: AnalyzerAgent, sandbox: C
         _log(func_name, "Fetching RAG context...")
         context = indexer.get_context_for_code(original_code) if indexer else ""
 
-        # 0b. Memory lookup — skip LLM entirely if we've seen this pattern before
+        # 0b. Memory lookup — skip LLM if we've seen this pattern before,
+        # but validate the stored result before trusting it:
+        #   Gate A: no optimized code stored  → previous run was incomplete, re-run LLM
+        #   Gate B: correctness < 50% last run → keep analysis, re-run correctness only
+        #   Gate C: result is good             → return as-is
         if memory:
             memory_hit = memory.lookup(original_code, language)
             if memory_hit:
                 label = "exact match" if memory_hit.is_exact else f"similarity {memory_hit.similarity:.1%}"
-                _log(func_name, f"⚡ Recalled from memory ({label}) — skipping LLM", style="bold cyan")
-                recalled_result = {
-                    "severity":       memory_hit.severity,
-                    "issue":          memory_hit.issue,
-                    "reasoning":      memory_hit.reasoning,
-                    "optimized_code": memory_hit.optimized_code,
-                    "suggestion":     "",
-                    "bottlenecks":    [],
-                }
-                return func_name, recalled_result, None, None, None, None, memory_hit, False
+
+                # Gate A: stored result has no optimized code — not useful, fall through to LLM
+                if not memory_hit.optimized_code:
+                    _log(func_name, f"Memory hit ({label}) — no optimized code stored, re-running LLM", style="yellow")
+                    memory_hit = None   # fall through; LLM path runs below as normal
+
+                # Gate B: correctness was poor last time — re-run the correctness check only
+                elif memory_hit.total_cases > 0 and memory_hit.correctness_cases / memory_hit.total_cases < 0.5:
+                    _log(
+                        func_name,
+                        f"Memory hit ({label}) — correctness was "
+                        f"{memory_hit.correctness_cases}/{memory_hit.total_cases} last run, re-checking",
+                        style="yellow",
+                    )
+                    recalled_result = {
+                        "severity":       memory_hit.severity,
+                        "issue":          memory_hit.issue,
+                        "reasoning":      memory_hit.reasoning,
+                        "optimized_code": memory_hit.optimized_code,
+                        "suggestion":     "",
+                        "bottlenecks":    [],
+                    }
+                    new_verification = None
+                    if not getattr(sandbox, "disabled", False):
+                        stored_cases = memory.lookup_test_cases(original_code)
+                        if stored_cases:
+                            _log(func_name, "Re-running correctness sandbox with stored test cases...", style="dim")
+                            correctness = sandbox.verify_correctness_only(
+                                original_code=original_code,
+                                optimized_code=memory_hit.optimized_code,
+                                original_func_name=func_name,
+                                optimized_func_name=func_name,
+                                test_cases=stored_cases,
+                                language=language,
+                                context=context,
+                            )
+                            _log(func_name, f"Re-verification: {correctness.passed_cases}/{correctness.total_cases} passed", style="dim")
+                            try:
+                                from coreinsight.sandbox import VerificationResult, SpeedupVerification
+                                new_verification = VerificationResult(
+                                    speedup=SpeedupVerification(
+                                        verified=True,
+                                        computed_speedups=[memory_hit.avg_speedup] if memory_hit.avg_speedup else [],
+                                        details=f"Speedup recalled from memory: {memory_hit.avg_speedup:.2f}x",
+                                    ),
+                                    correctness=correctness,
+                                )
+                            except Exception:
+                                pass   # verification display is non-critical
+                    return func_name, recalled_result, None, None, new_verification, None, memory_hit, False
+
+                # Gate C: stored result is complete and correctness is acceptable
+                else:
+                    _log(func_name, f"⚡ Recalled from memory ({label}) — skipping LLM", style="bold cyan")
+                    recalled_result = {
+                        "severity":       memory_hit.severity,
+                        "issue":          memory_hit.issue,
+                        "reasoning":      memory_hit.reasoning,
+                        "optimized_code": memory_hit.optimized_code,
+                        "suggestion":     "",
+                        "bottlenecks":    [],
+                    }
+                    return func_name, recalled_result, None, None, None, None, memory_hit, False
 
         # ── Route: single-agent vs multi-agent ──────────────────────────
         if agent_mode == "multi" and multi_agents:
@@ -240,8 +296,37 @@ def process_function(func: dict, language: str, agent: AnalyzerAgent, sandbox: C
         if result is None:
             return func_name, None, None, f"❌ Analysis error: {logs}", None, None, None, False
 
+        # Retry gate: Low severity or missing optimized code often means the model
+        # defaulted to "looks fine" rather than truly auditing.
+        # Retry up to 2 times before accepting the conclusion.
+        _MAX_ANALYSIS_RETRIES = 2
+        _retry = 0
+        while (result.get("severity") == "Low" or not optimized_code) and _retry < _MAX_ANALYSIS_RETRIES:
+            _retry += 1
+            _log(func_name, f"Low/missing result — retrying analysis ({_retry}/{_MAX_ANALYSIS_RETRIES})...", style="yellow")
+            if agent_mode == "multi" and multi_agents:
+                result, optimized_code, success, logs, plot_data, is_valid_optimization = \
+                    _run_multi_agent(
+                        func_name, original_code, language, context,
+                        hardware_target, sandbox, multi_agents, tier_limits,
+                        stream_callback=stream_callback,
+                    )
+            else:
+                result, optimized_code, success, logs, plot_data, is_valid_optimization = \
+                    _run_single_agent(
+                        func_name, original_code, language, context,
+                        hardware_target, sandbox, agent, tier_limits,
+                        stream_callback=stream_callback,
+                    )
+            if result is None:
+                break
+
+        if result is None:
+            return func_name, None, None, f"❌ Analysis error after {_retry} retries: {logs}", None, None, None, False
+
         if result.get("severity") == "Low" or not optimized_code:
-            return func_name, None, None, "✅ No critical bottlenecks detected. Code is optimal.", None, None, None, False
+            confirmed = f" (confirmed after {_retry} retries)" if _retry > 0 else ""
+            return func_name, None, None, f"✅ No significant bottlenecks found{confirmed}.", None, None, None, False
 
         # 3. Verification + AI-free hardware profiling
         verification    = None
@@ -288,11 +373,29 @@ def process_function(func: dict, language: str, agent: AnalyzerAgent, sandbox: C
 
     except Exception as e:
         err_str = str(e)
-        if "context" in err_str.lower() and "limit" in err_str.lower():
-            _log(func_name, f"Context limit hit: {e}", style="bold yellow")
+        err_low  = err_str.lower()
+        if "context" in err_low and "limit" in err_low:
+            _log(func_name, "Context limit hit", style="bold yellow")
+            return func_name, None, None, (
+                "⚠️  Context limit — try a model with a larger context window, "
+                "or split the function into smaller pieces."
+            ), None, None, None, False
+        if any(k in err_low for k in ("cannot connect", "connection refused", "docker")):
+            _log(func_name, "Docker unavailable", style="bold yellow")
+            return func_name, None, None, (
+                "⚠️  Docker is not running — start Docker Desktop and try again.\n"
+                "    Skip the sandbox with: coreinsight analyze --no-docker <file>"
+            ), None, None, None, False
+        if "timeout" in err_low or "timed out" in err_low:
+            _log(func_name, "Sandbox timed out", style="bold yellow")
+            return func_name, None, None, (
+                "⚠️  Sandbox timed out — the benchmark likely contains an infinite loop.\n"
+                "    The LLM analysis result above is still valid."
+            ), None, None, None, False
+        if "out of memory" in err_low or "oom" in err_low:
+            _log(func_name, "Sandbox OOM", style="bold yellow")
             return func_name, None, None, (
-                f"⚠️  Context limit: {err_str}\n"
-                f"Try a model with a larger context window, or split the function."
+                "⚠️  Sandbox ran out of memory. Try --no-docker or reduce the file size."
             ), None, None, None, False
         _log(func_name, f"Failed: {e}", style="bold red")
         return func_name, None, None, f"❌ Analysis failed: {err_str}", None, None, None, False
@@ -763,7 +866,16 @@ def run_analysis(file_path: str, no_docker: bool = False, tui_console=None, stre
                     
                 except Exception as exc:
                     with print_lock:
-                        console.print(f"[bold red]❌ Critical failure in thread processing {func['name']}:[/bold red] {exc}")
+                        exc_low = str(exc).lower()
+                        if any(k in exc_low for k in ("docker", "cannot connect", "connection refused")):
+                            console.print(f"[bold yellow]⚠️  {func['name']}: Docker unavailable — start Docker Desktop and retry.[/bold yellow]")
+                        elif "timeout" in exc_low or "timed out" in exc_low:
+                            console.print(f"[bold yellow]⚠️  {func['name']}: Sandbox timed out.[/bold yellow]")
+                        elif "out of memory" in exc_low or "oom" in exc_low:
+                            console.print(f"[bold yellow]⚠️  {func['name']}: Sandbox ran out of memory.[/bold yellow]")
+                        else:
+                            from rich.markup import escape
+                            console.print(f"[bold red]❌ {func['name']}: Unexpected error — {escape(str(exc))}[/bold red]")
 
         console.print(Panel.fit(f"✅ [bold green]Analysis Complete![/bold green] Final report saved to:\n{report_path.absolute()}"))
 
@@ -917,7 +1029,8 @@ def _run_test_cmd(func_name: str, no_docker: bool = False):
                 num_cases=tier_limits["num_test_cases"],
             )
         except Exception as exc:
-            console.print(f"[red]LLM error generating test cases: {exc}[/red]")
+            from rich.markup import escape
+            console.print(f"[red]LLM error generating test cases: {escape(str(exc))}[/red]")
             return
 
         if not test_cases:
@@ -1034,7 +1147,8 @@ def _run_memory_cmd(clear: bool, export_path: str = None, export_fmt: str = "csv
         metadatas   = all_records.get("metadatas", []) or []
         ids         = all_records.get("ids",       []) or []
     except Exception as exc:
-        console.print(f"[red]Failed to read memory store: {exc}[/red]")
+        from rich.markup import escape
+        console.print(f"[red]Failed to read memory store: {escape(str(exc))}[/red]")
         return
 
     # Build the detail table