feat: inject winning algorithm code as few-shot examples across sessions

The PromptRefiner now queries the best-performing code for each agent's
file (main.py, Alpha.py, Universe.py, Risk.py) from the SQLite learning
database and injects it as a reference example into the prompt. This means
iteration 1 of a new session starts with the best code from all previous
sessions, not from scratch.

https://claude.ai/code/session_01G7z6nZKeChXhvrkz1bRvJf

Author: claude

quantcoder/autonomous/database.py

@@ -289,6 +289,60 @@ def get_top_strategies(self, limit: int = 10) -> List[Dict]:
             strategies.append(strategy)
         return strategies
 
+    def get_best_code_for_file(
+        self,
+        filename: str,
+        category: Optional[str] = None,
+        limit: int = 1,
+    ) -> List[Dict]:
+        """
+        Get the best-performing code for a specific file (e.g., main.py, Alpha.py).
+
+        Returns strategies that contain the requested file, ordered by Sharpe.
+        Each result includes 'code' (the file content) and strategy metadata.
+        """
+        cursor = self.conn.cursor()
+
+        if category:
+            cursor.execute("""
+                SELECT name, category, sharpe_ratio, max_drawdown, code_files
+                FROM generated_strategies
+                WHERE success = 1 AND sharpe_ratio IS NOT NULL AND category = ?
+                ORDER BY sharpe_ratio DESC
+                LIMIT ?
+            """, (category, limit * 3))
+        else:
+            cursor.execute("""
+                SELECT name, category, sharpe_ratio, max_drawdown, code_files
+                FROM generated_strategies
+                WHERE success = 1 AND sharpe_ratio IS NOT NULL
+                ORDER BY sharpe_ratio DESC
+                LIMIT ?
+            """, (limit * 3,))
+
+        results = []
+        for row in cursor.fetchall():
+            d = dict(row)
+            files = json.loads(d['code_files'])
+            # Match filename case-insensitively
+            code = None
+            for fname, content in files.items():
+                if fname.lower() == filename.lower():
+                    code = content
+                    break
+            if code:
+                results.append({
+                    'name': d['name'],
+                    'category': d['category'],
+                    'sharpe': d['sharpe_ratio'],
+                    'drawdown': d['max_drawdown'],
+                    'code': code,
+                })
+                if len(results) >= limit:
+                    break
+
+        return results
+
     def get_library_stats(self) -> Dict:
         """Get overall library statistics."""
         cursor = self.conn.cursor()

quantcoder/autonomous/prompt_refiner.py

@@ -10,14 +10,24 @@ class PromptRefiner:
     def __init__(self, db: LearningDatabase):
         self.db = db
 
+    # Map agent types to the files they generate
+    AGENT_FILE_MAP = {
+        'strategy': 'main.py',
+        'alpha': 'Alpha.py',
+        'universe': 'Universe.py',
+        'risk': 'Risk.py',
+        'coordinator': 'main.py',
+    }
+
     def inject_learnings(
         self,
         base_prompt: str,
         strategy_type: str = None,
         max_errors: int = 5,
-        max_successes: int = 5
+        max_successes: int = 5,
+        agent_type: str = None,
     ) -> str:
-        """Enhance base prompt with learned error patterns and success strategies."""
+        """Enhance base prompt with learned error patterns, success strategies, and winning code."""
         # Get common errors to avoid
         common_errors = self.db.get_common_error_types(limit=max_errors)
 
@@ -50,6 +60,14 @@ def inject_learnings(
             perf_section = self._build_performance_section(perf_stats, strategy_type)
             enhancements.append(perf_section)
 
+        # Best code example for this agent's file
+        code_section = self._build_code_example_section(
+            agent_type=agent_type,
+            strategy_type=strategy_type,
+        )
+        if code_section:
+            enhancements.append(code_section)
+
         # Combine everything
         if enhancements:
             enhanced_prompt = f"""{base_prompt}
@@ -153,6 +171,46 @@ def _find_fix_for_error(
 
         return generic_fixes.get(error_type, 'Review code carefully')
 
+    def _build_code_example_section(
+        self,
+        agent_type: str = None,
+        strategy_type: str = None,
+        max_lines: int = 150,
+    ) -> str:
+        """Build a section with the best-performing code as a reference example."""
+        if agent_type is None:
+            return ""
+
+        filename = self.AGENT_FILE_MAP.get(agent_type)
+        if not filename:
+            return ""
+
+        examples = self.db.get_best_code_for_file(
+            filename=filename,
+            category=strategy_type,
+            limit=1,
+        )
+
+        if not examples:
+            return ""
+
+        best = examples[0]
+        code = best['code']
+
+        # Truncate very long code to keep the prompt manageable
+        lines = code.splitlines()
+        if len(lines) > max_lines:
+            code = "\n".join(lines[:max_lines]) + f"\n# ... ({len(lines) - max_lines} more lines)"
+
+        section = (
+            f"CODE REFERENCE - Best {filename} from previous runs "
+            f"(Sharpe {best['sharpe']:.2f}, {best['category']}):\n"
+            f"Use this as a structural reference. Adapt the logic to the new strategy.\n\n"
+            f"```python\n{code}\n```\n"
+        )
+
+        return section
+
     def _extract_common_patterns(self, strategies: List[Dict]) -> List[Dict]:
         """Extract common patterns from successful strategies."""
         patterns = []
@@ -241,7 +299,8 @@ def get_enhanced_prompts_for_agents(
         for agent_type, base_prompt in base_prompts.items():
             enhanced[agent_type] = self.inject_learnings(
                 base_prompt,
-                strategy_type=strategy_type
+                strategy_type=strategy_type,
+                agent_type=agent_type,
             )
 
         return enhanced