Updates to agent

Author: shuds13

ensemble_agent/agent.py

@@ -32,8 +32,11 @@ async def run_agent(config: AgentConfig):
     # Set up archive manager
     archive = ArchiveManager(config.output_dir)
 
-    # Load skills
-    skills = load_skills(config.skills, config, archive)
+    # Load skills — drop generator when using existing scripts
+    skill_names = config.skills
+    if config.scripts_dir and "generator" in skill_names:
+        skill_names = ",".join(s for s in skill_names.split(",") if s.strip() != "generator")
+    skills = load_skills(skill_names, config, archive)
     has_generator = any(isinstance(s, GeneratorSkill) for s in skills)
 
     # MCP setup for generator skill

ensemble_agent/skills/file_ops.py

@@ -1,5 +1,6 @@
 """File operations skill — read, write, list files in the work directory."""
 
+import difflib
 from pathlib import Path
 
 from pydantic import BaseModel, Field
@@ -36,10 +37,24 @@ async def read_file_tool(filepath: str) -> str:
 
         async def write_file_tool(filepath: str, content: str) -> str:
             try:
-                (work_dir / filepath).write_text(content)
+                file_path = work_dir / filepath
+                # Diff against old content for summary
+                old_lines = file_path.read_text().splitlines() if file_path.exists() else []
+                new_lines = content.splitlines()
+                changes = list(difflib.unified_diff(old_lines, new_lines, n=0))
+                changed = [l for l in changes if l.startswith('+') and not l.startswith('+++')]
+
+                file_path.write_text(content)
                 archive.start("fix")
                 archive.archive_scripts()
-                print(f"- Saved: {work_dir / filepath}", flush=True)
+
+                if changed and len(changed) <= 3:
+                    summary = "; ".join(l[1:].strip() for l in changed)
+                    print(f"- Fixed: {filepath} ({summary})", flush=True)
+                elif changed:
+                    print(f"- Fixed: {filepath} ({len(changed)} lines changed)", flush=True)
+                else:
+                    print(f"- Saved: {filepath}", flush=True)
                 return f"SUCCESS: Wrote {filepath}"
             except Exception as e:
                 return f"ERROR: {e}"

ensemble_agent/skills/runner.py

@@ -6,7 +6,6 @@
 from langchain_core.tools import StructuredTool
 
 from .base import Skill
-from ..config import MAX_RETRIES
 
 
 class RunScriptInput(BaseModel):
@@ -19,7 +18,8 @@ class RunnerSkill(Skill):
     def __init__(self, config, archive):
         super().__init__(config, archive)
         self._run_count = 0
-        self._max_runs = config.max_retries + 1  # initial run + retries
+        self._max_runs = config.max_retries + 1
+        self._succeeded = False
 
     def get_tools(self):
         work_dir = self.archive.work_dir
@@ -28,17 +28,17 @@ def get_tools(self):
         skill = self
 
         async def run_script_tool(script_name: str) -> str:
+            if skill._succeeded:
+                return "Script already ran successfully. Do not run again."
             skill._run_count += 1
             if skill._run_count > skill._max_runs:
-                msg = f"RUN LIMIT REACHED ({skill._max_runs} runs). Stop and report the current status to the user."
-                print(f"\n{msg}", flush=True)
-                return msg
+                return "Run limit reached. Stop and report current status."
 
             script_path = work_dir / script_name
             if not script_path.exists():
                 return f"ERROR: Script '{script_name}' not found"
 
-            print(f"\nRunning {script_name}... (run {skill._run_count}/{skill._max_runs})", flush=True)
+            print(f"\nRunning {script_name}...", flush=True)
             try:
                 result = subprocess.run(
                     ["python", script_name],
@@ -48,6 +48,7 @@ async def run_script_tool(script_name: str) -> str:
                     timeout=timeout,
                 )
                 if result.returncode == 0:
+                    skill._succeeded = True
                     print("Script ran successfully", flush=True)
                     return f"SUCCESS\nOutput:\n{result.stdout[:500]}"
                 else:
@@ -57,13 +58,13 @@ async def run_script_tool(script_name: str) -> str:
                         f"Stdout: {result.stdout}"
                     )
                     print(f"Failed (code {result.returncode})", flush=True)
+                    if result.stderr:
+                        print(f"Error output:\n{result.stderr[:500]}", flush=True)
                     archive.archive_run_output(error_msg)
-                    remaining = skill._max_runs - skill._run_count
                     return (
                         f"FAILED (code {result.returncode})\n"
                         f"Stderr:\n{result.stderr}\n"
-                        f"Stdout:\n{result.stdout[:500]}\n"
-                        f"\nYou have {remaining} run(s) remaining."
+                        f"Stdout:\n{result.stdout[:500]}"
                     )
             except subprocess.TimeoutExpired:
                 return f"ERROR: Script timed out ({timeout}s)"