codegraph-cli 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

codegraph_cli/cli_workflows.py

@@ -0,0 +1,255 @@
+"""Combined workflow commands for CodeGraph CLI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from . import config
+from .diff_engine import DiffEngine
+from .storage import GraphStore, ProjectManager
+
+console = Console()
+
+workflows_app = typer.Typer(help="🔄 Combined workflow commands")
+
+
+def _ensure_project() -> tuple[ProjectManager, str]:
+    """Ensure a project is loaded and return (pm, project_name)."""
+    pm = ProjectManager()
+    project = pm.get_current_project()
+    if not project:
+        console.print("[red]✗[/red] No project loaded. Use 'cg load-project <name>' or run 'cg index <path>'.")
+        raise typer.Exit(1)
+    return pm, project
+
+
+@workflows_app.command("review-and-fix")
+def review_and_fix(
+    path: str = typer.Argument(..., help="File to review and fix"),
+    auto_apply: bool = typer.Option(False, "--apply", "-y", help="Auto-apply fixes without confirmation"),
+    check: str = typer.Option("all", help="Check type: bugs, security, performance, all"),
+    use_llm: bool = typer.Option(False, "--llm", help="Use LLM for deeper analysis"),
+):
+    """🔍 Complete code review → diagnose → fix workflow.
+
+    Runs a full code review, diagnoses issues, and optionally applies fixes.
+
+    Example:
+      cg review-and-fix src/auth.py
+      cg review-and-fix src/auth.py --apply
+      cg review-and-fix src/auth.py --llm --apply
+    """
+    from .bug_detector import BugDetector
+    from .security_scanner import SecurityScanner
+    from .performance_analyzer import PerformanceAnalyzer
+    from .llm import LocalLLM
+    from .validation_engine import ValidationEngine
+    from .models_v2 import CodeProposal
+
+    pm, project = _ensure_project()
+
+    file_path = Path(path)
+    if not file_path.exists():
+        console.print(f"[red]✗[/red] File not found: {path}")
+        raise typer.Exit(1)
+
+    project_dir = pm.project_dir(project)
+    store = GraphStore(project_dir)
+    llm = LocalLLM(
+        model=config.LLM_MODEL,
+        provider=config.LLM_PROVIDER,
+        api_key=config.LLM_API_KEY,
+    ) if use_llm else None
+
+    # ── Step 1: Code Review ──────────────────────────────────
+    console.print(f"\n[bold cyan]Step 1/3:[/bold cyan] Running code review on [bold]{path}[/bold]\n")
+
+    all_issues = []
+
+    if check in ("bugs", "all"):
+        detector = BugDetector(store, llm)
+        bug_issues = detector.analyze_file(str(file_path), use_llm=use_llm)
+        all_issues.extend(bug_issues)
+        console.print(f"  [dim]Bug detection:[/dim] {len(bug_issues)} issue(s)")
+
+    if check in ("security", "all"):
+        scanner = SecurityScanner(store)
+        security_issues = scanner.scan_file(str(file_path))
+        all_issues.extend(security_issues)
+        console.print(f"  [dim]Security scan:[/dim] {len(security_issues)} issue(s)")
+
+    if check in ("performance", "all"):
+        analyzer = PerformanceAnalyzer(store)
+        perf_issues = analyzer.analyze_file(str(file_path))
+        all_issues.extend(perf_issues)
+        console.print(f"  [dim]Performance:[/dim] {len(perf_issues)} issue(s)")
+
+    if not all_issues:
+        console.print("\n[green]✓ No issues found! Code looks good.[/green]")
+        store.close()
+        return
+
+    # Show summary
+    by_severity = {"critical": 0, "high": 0, "medium": 0, "low": 0}
+    for issue in all_issues:
+        sev = issue.get("severity", "low")
+        by_severity[sev] = by_severity.get(sev, 0) + 1
+
+    console.print(f"\n  Found [bold]{len(all_issues)}[/bold] total issues:")
+    for sev, count in by_severity.items():
+        if count:
+            icon = {"critical": "🚨", "high": "🔴", "medium": "⚠️", "low": "ℹ️"}.get(sev, "•")
+            console.print(f"    {icon} {sev}: {count}")
+
+    # ── Step 2: Diagnose ─────────────────────────────────────
+    console.print(f"\n[bold cyan]Step 2/3:[/bold cyan] Diagnosing fixable issues\n")
+
+    validator = ValidationEngine()
+    errors = validator.diagnose_project(file_path.parent if file_path.is_file() else file_path)
+
+    if errors:
+        console.print(f"  Found [bold]{len(errors)}[/bold] syntax error(s)")
+    else:
+        console.print("  [green]✓[/green] No syntax errors")
+
+    # ── Step 3: Fix ──────────────────────────────────────────
+    fixable = [e for e in errors if True]  # all errors are potentially fixable
+    if not fixable:
+        console.print(f"\n[bold cyan]Step 3/3:[/bold cyan] No auto-fixable issues found")
+        console.print("\n[yellow]Review the issues above and fix manually.[/yellow]")
+
+        # Show issues for manual review
+        for issue in all_issues[:10]:
+            line = issue.get("line", "?")
+            msg = issue.get("message", issue.get("error", "Unknown"))
+            sev = issue.get("severity", "low")
+            console.print(f"  [dim]L{line}[/dim] [{sev}] {msg}")
+            if "suggestion" in issue:
+                console.print(f"        💡 {issue['suggestion']}")
+
+        store.close()
+        return
+
+    console.print(f"\n[bold cyan]Step 3/3:[/bold cyan] Proposing fixes\n")
+
+    changes = []
+    for error in fixable:
+        file_p = Path(error["file"])
+        fix = validator.fix_common_errors(file_p)
+        if fix:
+            changes.append(fix)
+
+    if not changes:
+        console.print("[yellow]No automatic fixes available — manual fixes required.[/yellow]")
+        store.close()
+        return
+
+    diff_engine = DiffEngine()
+    proposal = CodeProposal(
+        id="review-and-fix",
+        description=f"Review & fix: {len(changes)} issue(s) in {path}",
+        changes=changes,
+    )
+    preview = diff_engine.preview_changes(proposal)
+    console.print(preview)
+
+    if auto_apply:
+        result = diff_engine.apply_changes(proposal, backup=True)
+        if result.success:
+            console.print(f"\n[green]✓ Fixed {len(result.files_changed)} file(s)[/green]")
+            if result.backup_id:
+                console.print(f"[dim]Backup: {result.backup_id} — rollback with: cg v2 rollback {result.backup_id}[/dim]")
+        else:
+            console.print(f"\n[red]✗ Failed to apply fixes: {result.error}[/red]")
+    else:
+        if typer.confirm("\nApply these fixes?", default=False):
+            result = diff_engine.apply_changes(proposal, backup=True)
+            if result.success:
+                console.print(f"\n[green]✓ Fixed {len(result.files_changed)} file(s)[/green]")
+                if result.backup_id:
+                    console.print(f"[dim]Backup: {result.backup_id}[/dim]")
+            else:
+                console.print(f"\n[red]✗ Failed: {result.error}[/red]")
+        else:
+            console.print("[yellow]Fixes not applied.[/yellow]")
+
+    store.close()
+
+
+@workflows_app.command("full-analysis")
+def full_analysis(
+    symbol: str = typer.Argument(..., help="Symbol to analyze"),
+    hops: int = typer.Option(2, min=1, max=6, help="Dependency traversal depth."),
+    export: bool = typer.Option(False, "--export", "-e", help="Export graph to HTML"),
+):
+    """📊 Complete analysis: impact + graph + RAG context for a symbol.
+
+    Example:
+      cg full-analysis "UserService.login"
+      cg full-analysis "process_payment" --export
+      cg full-analysis "main" --hops 3
+    """
+    from .orchestrator import MCPOrchestrator
+    from .graph_export import export_html
+
+    pm, project = _ensure_project()
+    project_dir = pm.project_dir(project)
+    store = GraphStore(project_dir)
+    orchestrator = MCPOrchestrator(store)
+
+    console.print(f"\n[bold]Analyzing: [cyan]{symbol}[/cyan][/bold]\n")
+
+    # 1. Impact analysis
+    console.print("[cyan]1/3 Impact analysis...[/cyan]")
+    report = orchestrator.impact(symbol, hops=hops)
+
+    if "not found" in report.explanation.lower() and not report.impacted:
+        console.print(f"[red]✗[/red] Symbol '{symbol}' not found in current project.")
+        search_results = orchestrator.search(symbol, top_k=3)
+        if search_results:
+            console.print("\n[yellow]Did you mean:[/yellow]")
+            for r in search_results:
+                console.print(f"  • {r.qualname} ({r.node_type})")
+        store.close()
+        raise typer.Exit(1)
+
+    console.print(f"  Root: {report.root}")
+    console.print(f"  Impacted: {len(report.impacted)} symbol(s)")
+    if report.impacted:
+        for imp in report.impacted[:10]:
+            console.print(f"    • {imp}")
+        if len(report.impacted) > 10:
+            console.print(f"    [dim]... and {len(report.impacted) - 10} more[/dim]")
+
+    # 2. Dependency graph
+    console.print("\n[cyan]2/3 Dependency graph...[/cyan]")
+    graph_text = orchestrator.graph(symbol, depth=hops)
+    console.print(graph_text)
+
+    # 3. RAG context
+    console.print("\n[cyan]3/3 RAG context...[/cyan]")
+    rag_text = orchestrator.rag_context(symbol, top_k=6)
+    # Count snippets (rough heuristic)
+    snippet_count = rag_text.count("──") if rag_text else 0
+    console.print(f"  Retrieved {max(snippet_count, 1)} context snippet(s)")
+
+    # Summary
+    console.print(f"\n[bold green]━━━ Summary ━━━[/bold green]")
+    console.print(f"  Symbol:         {report.root}")
+    console.print(f"  Impacted:       {len(report.impacted)} symbol(s)")
+    console.print(f"  Traversal:      {hops} hop(s)")
+
+    console.print(f"\n[bold]Explanation:[/bold]")
+    console.print(report.explanation)
+
+    if export:
+        output_path = Path.cwd() / f"{symbol.replace('.', '_')}_graph.html"
+        export_html(store, output_path, focus=symbol)
+        console.print(f"\n[green]✓ Graph exported to {output_path}[/green]")
+
+    store.close()

codegraph_cli/codegen_agent.py

@@ -135,7 +135,21 @@ class CodeGenAgent:
         Returns:
             Result of applying changes
         """
-        return self.diff_engine.apply_changes(proposal, backup=backup)
+        result = self.diff_engine.apply_changes(proposal, backup=backup)
+
+        # Incrementally reindex changed files so the code graph stays current
+        if result.success and self.project_context is not None:
+            for change in proposal.changes:
+                try:
+                    rel_path = change.file_path
+                    if change.change_type == "delete":
+                        self.project_context.remove_from_index(rel_path)
+                    else:
+                        self.project_context._incremental_reindex(rel_path)
+                except Exception:
+                    pass  # never break apply on index failure
+
+        return result
     
     def _gather_context(
         self,

codegraph_cli/config.py

@@ -11,6 +11,14 @@ STATE_FILE = BASE_DIR / "state.json"
 DEFAULT_EMBEDDING_DIM = 256
 SUPPORTED_EXTENSIONS = {".py"}
 
+# Smart defaults — work without any configuration
+DEFAULT_CONFIG = {
+    "llm_provider": "ollama",
+    "llm_model": "qwen2.5-coder:7b",
+    "embedding_model": "hash",
+    "auto_setup": True,
+}
+
 # Load configuration from TOML file (if available)
 try:
     from .config_manager import load_config, load_embedding_config
@@ -20,14 +28,19 @@ except ImportError:
     _toml_config = {}
     _emb_config = {}
 
-# LLM Provider Configuration — loaded from ~/.codegraph/config.toml (set via `cg setup` or `cg set-llm`)
-LLM_PROVIDER = _toml_config.get("provider", "ollama")
+# LLM Provider Configuration — loaded from ~/.codegraph/config.toml (set via `cg config setup` or `cg config set-llm`)
+LLM_PROVIDER = _toml_config.get("provider", DEFAULT_CONFIG["llm_provider"])
 LLM_API_KEY = _toml_config.get("api_key", "")
-LLM_MODEL = _toml_config.get("model", "qwen2.5-coder:7b")
+LLM_MODEL = _toml_config.get("model", DEFAULT_CONFIG["llm_model"])
 LLM_ENDPOINT = _toml_config.get("endpoint", "http://127.0.0.1:11434/api/generate")
 
-# Embedding model — set via `cg set-embedding` (default: "hash" = no download)
-EMBEDDING_MODEL = _emb_config.get("model", "hash")
+# Embedding model — set via `cg config set-embedding` (default: "hash" = no download)
+EMBEDDING_MODEL = _emb_config.get("model", DEFAULT_CONFIG["embedding_model"])
+
+
+def config_file_exists() -> bool:
+    """Check whether a user config file has been created."""
+    return (BASE_DIR / "config.toml").exists()
 
 
 def ensure_base_dirs() -> None:

codegraph_cli/context_manager.py

@@ -5,6 +5,8 @@ Includes:
   symbols) designed to fit inside an LLM context window for agentic planning
   *before* deep retrieval.
 - **ConversationMemory**: sliding-window compression for chat history.
+- **SymbolMemory**: tracks recently discussed symbols, files, and proposals
+  so the chat agent can avoid redundant RAG queries.
 - Intent detection and query extraction utilities.
 """
 
@@ -250,6 +252,63 @@ class ConversationMemory:
         return " | ".join(summary_parts[-5:])
 
 
+class SymbolMemory:
+    """Tracks recently discussed symbols, files, and active proposals.
+
+    The chat agent consults this memory *before* hitting RAG so that
+    consecutive questions about the same symbol don't trigger redundant
+    vector searches.
+    """
+
+    def __init__(self, max_symbols: int = 20, max_files: int = 10) -> None:
+        self.max_symbols = max_symbols
+        self.max_files = max_files
+
+        # Recently discussed symbols (qualname → last SearchResult)
+        self.recent_symbols: Dict[str, Any] = {}
+        # Recently touched files
+        self.recent_files: List[str] = []
+        # Active proposal (if any)
+        self.active_proposal: Optional[CodeProposal] = None
+
+    def record_symbols(self, results: List[Any]) -> None:
+        """Record search results as recently discussed symbols."""
+        for r in results:
+            self.recent_symbols[r.qualname] = r
+        # Trim to limit
+        while len(self.recent_symbols) > self.max_symbols:
+            # Remove oldest (first inserted)
+            oldest_key = next(iter(self.recent_symbols))
+            del self.recent_symbols[oldest_key]
+
+    def record_file(self, file_path: str) -> None:
+        """Track a file that was recently discussed or modified."""
+        if file_path in self.recent_files:
+            self.recent_files.remove(file_path)
+        self.recent_files.insert(0, file_path)
+        self.recent_files = self.recent_files[: self.max_files]
+
+    def get_context_summary(self) -> str:
+        """Return a compact summary of tracked state for LLM context."""
+        parts: List[str] = []
+        if self.recent_symbols:
+            names = list(self.recent_symbols.keys())[-8:]
+            parts.append(f"Recent symbols: {', '.join(names)}")
+        if self.recent_files:
+            parts.append(f"Recent files: {', '.join(self.recent_files[:5])}")
+        if self.active_proposal:
+            parts.append(f"Active proposal: {self.active_proposal.description}")
+        return "\n".join(parts)
+
+    def find_cached_symbol(self, query: str) -> Optional[Any]:
+        """Check if *query* matches a recently discussed symbol."""
+        query_lower = query.lower()
+        for qualname, result in self.recent_symbols.items():
+            if query_lower in qualname.lower() or qualname.lower() in query_lower:
+                return result
+        return None
+
+
 def detect_intent(message: str) -> str:
     """Detect user intent from message.
     
@@ -343,11 +402,24 @@ def extract_queries_from_message(message: str, intent: str) -> List[str]:
             queries.append(f"{target} service")
     
     elif intent in ["impact", "explain"]:
-        # Extract symbol names
-        # Look for function/class names (CamelCase or snake_case)
-        symbols = re.findall(r'\b[A-Z][a-zA-Z0-9_]*\b|\b[a-z_][a-z0-9_]*\b', message)
-        if symbols:
-            queries.append(symbols[0])  # Use first symbol
+        # Extract symbol names — prefer CamelCase and snake_case
+        # identifiers that look like real code symbols, not common
+        # English words.
+        camel_case = re.findall(r'\b[A-Z][a-zA-Z0-9_]+\b', message)
+        snake_case = re.findall(r'\b[a-z_][a-z0-9_]*(?:_[a-z0-9]+)+\b', message)
+        code_symbols = camel_case + snake_case
+        if code_symbols:
+            queries.append(code_symbols[0])
+        else:
+            # Fallback: extract all identifier-like tokens, skip
+            # very short common English words.
+            _SKIP = {"how", "does", "what", "why", "the", "is", "in", "a", "an", "to", "for", "it", "of", "on"}
+            symbols = [
+                s for s in re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', message)
+                if s.lower() not in _SKIP and len(s) > 2
+            ]
+            if symbols:
+                queries.append(symbols[0])
     
     # Fallback: use entire message
     if not queries:
@@ -374,7 +446,8 @@ def assemble_context_for_llm(
     session: ChatSession,
     rag_retriever: RAGRetriever,
     system_prompt: str,
-    max_tokens: int = 8000
+    max_tokens: int = 8000,
+    symbol_memory: Optional[SymbolMemory] = None,
 ) -> List[Dict[str, str]]:
     """Assemble optimized context for LLM within token budget.
     
@@ -384,6 +457,7 @@ def assemble_context_for_llm(
         rag_retriever: RAG retriever for code search
         system_prompt: System prompt
         max_tokens: Maximum total tokens
+        symbol_memory: Optional SymbolMemory for tracking context
         
     Returns:
         List of message dicts for LLM
@@ -398,7 +472,12 @@ def assemble_context_for_llm(
     # 2. Detect intent
     intent = detect_intent(user_message)
     
-    # 3. Extract queries and retrieve code
+    # 3. Check symbol memory first (avoid redundant RAG)
+    memory_hit = None
+    if symbol_memory is not None:
+        memory_hit = symbol_memory.find_cached_symbol(user_message)
+    
+    # 4. Extract queries and retrieve code
     queries = extract_queries_from_message(user_message, intent)
     code_snippets = []
     
@@ -419,7 +498,25 @@ def assemble_context_for_llm(
     # Limit to top 10
     unique_snippets = unique_snippets[:10]
     
-    # 4. Add RAG context (high priority)
+    # Record in symbol memory
+    if symbol_memory is not None and unique_snippets:
+        symbol_memory.record_symbols(unique_snippets)
+        for s in unique_snippets:
+            symbol_memory.record_file(s.file_path)
+    
+    # 5. Add symbol memory summary (compact, low cost)
+    if symbol_memory is not None:
+        mem_summary = symbol_memory.get_context_summary()
+        if mem_summary:
+            mem_tokens = count_tokens(mem_summary)
+            if token_count + mem_tokens < max_tokens - 3000:
+                context.append({
+                    "role": "system",
+                    "content": f"Session context:\n{mem_summary}",
+                })
+                token_count += mem_tokens
+    
+    # 6. Add RAG context (high priority)
     if unique_snippets:
         rag_context = format_code_snippets(unique_snippets)
         rag_tokens = count_tokens(rag_context)
@@ -431,7 +528,7 @@ def assemble_context_for_llm(
             })
             token_count += rag_tokens
     
-    # 5. Add pending proposals if exist
+    # 7. Add pending proposals if exist
     if session.pending_proposals:
         proposal_text = format_proposals(session.pending_proposals)
         proposal_tokens = count_tokens(proposal_text)
@@ -443,7 +540,7 @@ def assemble_context_for_llm(
             })
             token_count += proposal_tokens
     
-    # 6. Add conversation history (compressed)
+    # 8. Add conversation history (compressed)
     conv_memory = ConversationMemory(max_recent=3)
     conv_context = conv_memory.get_context_for_llm(
         session,
@@ -451,14 +548,16 @@ def assemble_context_for_llm(
     )
     context.extend(conv_context)
     
-    # 7. Add current user message
+    # 9. Add current user message
     context.append({"role": "user", "content": user_message})
     
     return context
 
 
 def format_code_snippets(snippets: List) -> str:
-    """Format code snippets for LLM context.
+    """Format code snippets for LLM context with compression.
+    
+    Strips import lines, trims long code, and adds structured metadata.
     
     Args:
         snippets: List of SearchResult objects
@@ -466,14 +565,17 @@ def format_code_snippets(snippets: List) -> str:
     Returns:
         Formatted string
     """
+    from .rag import _compress_snippet
+
     blocks = []
     
     for snippet in snippets:
+        compressed = _compress_snippet(snippet.snippet, max_chars=800)
         blocks.append(
             f"[{snippet.node_type}] {snippet.qualname}\n"
-            f"Location: {snippet.file_path}:{snippet.start_line}\n"
-            f"Relevance: {snippet.score:.2f}\n"
-            f"```python\n{snippet.snippet[:800]}\n```"
+            f"file: {snippet.file_path}:{snippet.start_line}\n"
+            f"score: {snippet.score:.2f}\n"
+            f"```python\n{compressed}\n```"
         )
     
     return "\n\n".join(blocks)

codegraph_cli/crew_agents.py

@@ -4,7 +4,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, List
 
-from crewai import Agent
+try:
+    from crewai import Agent
+    CREWAI_AVAILABLE = True
+except ImportError:
+    Agent = None  # type: ignore
+    CREWAI_AVAILABLE = False
 
 if TYPE_CHECKING:
     from .crew_tools import create_tools
@@ -32,6 +37,7 @@ def create_file_ops_agent(tools: list, llm, project_context: str = "") -> Agent:
         verbose=False,
         allow_delegation=False,
         max_iter=15,
+        max_tokens=4096,
     )
 
 
@@ -54,13 +60,17 @@ def create_code_gen_agent(tools: list, llm, project_context: str = "") -> Agent:
             "4. Include proper error handling, type hints, and docstrings\n"
             "5. Use search_code and grep_in_project to understand how code is used before changing it\n"
             "6. When asked to improve/refactor, explain what you changed and why\n"
-            f"7. Generate complete, runnable code — never leave TODO placeholders{ctx}"
+            "7. Generate complete, runnable code — never leave TODO placeholders\n"
+            "8. When applying previously suggested improvements, check the PREVIOUS CONVERSATION "
+            "section in the task description for the exact changes that were recommended, then "
+            f"implement each one using the appropriate tools{ctx}"
         ),
         tools=tools,
         llm=llm,
         verbose=False,
         allow_delegation=False,
         max_iter=20,
+        max_tokens=4096,
     )
 
 
@@ -89,10 +99,11 @@ def create_code_analysis_agent(tools: list, llm, project_context: str = "") -> A
         verbose=False,
         allow_delegation=False,
         max_iter=15,
+        max_tokens=4096,
     )
 
 
-def create_coordinator_agent(llm, project_context: str = "") -> Agent:
+def create_coordinator_agent(llm, project_context: str = "", tools: list = None) -> Agent:
     """Coordinator agent — routes tasks to the right specialist."""
     ctx = f" Current Project: {project_context}." if project_context else ""
     return Agent(
@@ -100,7 +111,8 @@ def create_coordinator_agent(llm, project_context: str = "") -> Agent:
         goal=(
             "Understand user requests and coordinate specialist agents. Route file operations "
             "to File System Engineer, code changes to Senior Software Developer, and analysis "
-            "to Code Intelligence Analyst."
+            "to Code Intelligence Analyst. When users reference previous conversation, use the "
+            "provided history to fulfil follow-up requests."
         ),
         backstory=(
             f"You are a project coordinator managing a team of AI specialists.{ctx}\n\n"
@@ -109,15 +121,27 @@ def create_coordinator_agent(llm, project_context: str = "") -> Agent:
             "• Senior Software Developer — generates code, implements features, refactors\n"
             "• Code Intelligence Analyst — searches code, analyzes dependencies, explains logic\n\n"
             "RULES:\n"
-            "1. ALWAYS delegate to the right specialist — never try to do tasks yourself\n"
-            "2. For 'what is in this project' / 'show files' → delegate to File System Engineer\n"
+            "1. ALWAYS use tools directly to gather information BEFORE responding. "
+            "Call read_file, file_tree, search_code, get_project_summary, etc. "
+            "Never say 'I need to examine files' without actually doing it in the same step.\n"
+            "2. For complex file operations or code generation, delegate to the appropriate specialist\n"
             "3. For 'write code' / 'add feature' / 'fix bug' / 'refactor' → delegate to Senior Software Developer\n"
             "4. For 'find' / 'search' / 'explain' / 'how does X work' → delegate to Code Intelligence Analyst\n"
             "5. For complex tasks, break them into steps and delegate each step\n"
-            "6. Always return concrete answers based on actual project data from tools"
+            "6. Always return concrete answers based on actual project data from tools\n"
+            "7. CRITICAL — CONVERSATION CONTINUITY: When the user says things like "
+            "'apply those', 'implement that', 'do what you said', 'make those changes', or "
+            "references previous suggestions, look at the PREVIOUS CONVERSATION section in the "
+            "task description. It contains the full history of what was discussed. Extract the "
+            "specific suggestions/improvements from your earlier response and delegate to the "
+            "Senior Software Developer to ACTUALLY implement them using write_file/patch_file tools. "
+            "Never say you don't remember or can't access previous context — it's right there "
+            "in the task description."
         ),
+        tools=tools,
         llm=llm,
         verbose=False,
         allow_delegation=True,
-        max_iter=10,
+        max_iter=25,
+        max_tokens=4096,
     )