fix(pipeline): ensure all LLM calls persist inputs/outputs and adjust run ordering

- Persist input/output for async LLM calls in base_agent.ainvoke()
- Ensure compressor LLM calls save inputs and outputs
  - compress_content()
  - _summarize_history()
- Confirm all LLM entry points now persist request/response data
- Change resume run ordering from newest-first to oldest-first
- Update resume UI to label ordering and mark the latest run explicitly

This guarantees that every LLM API invocation is traceable and resumable,
improving debugging, replay, and resume reliability across the pipeline.

Author: lufftw

tools/ai-markmap-agent/src/agents/base_agent.py

@@ -341,8 +341,15 @@ async def ainvoke(self, input_data: dict[str, Any]) -> str:
         )
 
         messages = self._build_messages(formatted_prompt)
+        
+        # Save LLM input if debug enabled
+        self._save_llm_call_input(messages, "invoke")
+        
         response = await self.llm.ainvoke(messages)
 
+        # Save LLM output if debug enabled
+        self._save_llm_call_output(response.content, "invoke")
+        
         return response.content
 
     @abstractmethod

tools/ai-markmap-agent/src/compression/compressor.py

@@ -56,6 +56,56 @@ def __init__(self, config: dict[str, Any] | None = None):
             "max_tokens_before_compress", 8000
         )
 
+    def _save_llm_call(self, agent_id: str, call_type: str, content: Any, is_input: bool = True):
+        """Save LLM call input or output for debugging."""
+        try:
+            from ..debug_output import get_debug_manager
+            debug = get_debug_manager(self.config)
+            
+            if not debug.enabled:
+                return
+            
+            # Get LLM debug config
+            llm_config = self.config.get("debug_output", {}).get("llm_calls", {})
+            if not llm_config.get("enabled", False):
+                return
+            
+            if is_input and not llm_config.get("save_input", False):
+                return
+            if not is_input and not llm_config.get("save_output", False):
+                return
+            
+            # Format content
+            if is_input:
+                # messages list
+                import json
+                if isinstance(content, list):
+                    content_str = json.dumps(
+                        [{"role": msg.type if hasattr(msg, "type") else "unknown", 
+                          "content": msg.content if hasattr(msg, "content") else str(msg)} 
+                         for msg in content],
+                        indent=2,
+                        ensure_ascii=False
+                    )
+                else:
+                    content_str = str(content)
+                filename = f"llm_input_{agent_id}_{call_type}"
+            else:
+                # response string
+                content_str = str(content)
+                filename = f"llm_output_{agent_id}_{call_type}"
+            
+            # Save to debug directory
+            ext = "md"
+            filepath = debug.run_dir / f"{filename}.{ext}"
+            filepath.write_text(content_str, encoding="utf-8")
+            prefix = "📝" if is_input else "📤"
+            print(f"      {prefix} LLM {'input' if is_input else 'output'} saved: {filepath.name}")
+            
+        except Exception as e:
+            # Silently fail if debug output is not available
+            pass
+    
     def _load_prompt(self, prompt_path: str) -> str:
         """Load prompt from file."""
         if not prompt_path:
@@ -134,8 +184,15 @@ def compress(
             HumanMessage(content=prompt),
         ]
 
+        # Save LLM input
+        self._save_llm_call("compressor", "compress_content", messages, is_input=True)
+        
         try:
             response = self.llm.invoke(messages)
+            
+            # Save LLM output
+            self._save_llm_call("compressor", "compress_content", response.content, is_input=False)
+            
             return response.content
         except Exception as e:
             print(f"Warning: Compression failed: {e}")
@@ -202,8 +259,15 @@ def _summarize_history(self, history: list[dict[str, Any]]) -> str:
             HumanMessage(content=prompt),
         ]
 
+        # Save LLM input
+        self._save_llm_call("compressor", "summarize_history", messages, is_input=True)
+        
         try:
             response = self.llm.invoke(messages)
+            
+            # Save LLM output
+            self._save_llm_call("compressor", "summarize_history", response.content, is_input=False)
+            
             return response.content
         except Exception:
             return f"Summary of {len(history)} earlier rounds."

tools/ai-markmap-agent/src/resume.py

@@ -143,7 +143,7 @@ def scan_previous_runs(debug_output_dir: Path) -> list[RunInfo]:
         debug_output_dir: Path to debug outputs directory
         
     Returns:
-        List of RunInfo objects, sorted by timestamp (newest first)
+        List of RunInfo objects, sorted by timestamp (oldest first)
     """
     if not debug_output_dir.exists():
         return []
@@ -154,8 +154,8 @@ def scan_previous_runs(debug_output_dir: Path) -> list[RunInfo]:
             # Skip regeneration runs (they will be handled separately)
             runs.append(RunInfo(item))
 
-    # Sort by timestamp (newest first)
-    runs.sort(key=lambda r: r.timestamp or datetime.min, reverse=True)
+    # Sort by timestamp (oldest first) - so newest prints at the bottom
+    runs.sort(key=lambda r: r.timestamp or datetime.min, reverse=False)
 
     return runs
 
@@ -175,13 +175,15 @@ def select_run_interactive(runs: list[RunInfo]) -> RunInfo | None:
         return None
 
     print("\n" + "=" * 60)
-    print("Available Previous Runs")
+    print("Available Previous Runs (oldest to newest)")
     print("=" * 60)
 
     for i, run in enumerate(runs, 1):
         timestamp_str = run.timestamp.strftime("%Y-%m-%d %H:%M:%S") if run.timestamp else "Unknown"
         file_count = sum(len(files) for files in run.files.values())
-        print(f"\n[{i}] {run.run_id}")
+        is_latest = (i == len(runs))  # Last one is newest
+        marker = " ← Latest" if is_latest else ""
+        print(f"\n[{i}] {run.run_id}{marker}")
         print(f"    Last modified: {timestamp_str}")
         print(f"    Files: {file_count} total")