feat(pipeline): add interactive resume/replay with stage reuse and regeneration

- Introduce resume module to replay previous pipeline runs
- Support interactive run selection and per-stage output reuse
- Enable resuming from a specific stage (e.g. writer)
- Load consensus and writer outputs from existing files when reused
- Generate new regen run directories without overwriting original data
- Integrate resume flow into main entrypoint with --resume and --from-stage
- Update graph execution to skip reused stages and continue from checkpoints
- Improve debug output handling to support resumed and regenerated runs

Author: lufftw

docs/pages/mindmaps/neetcode_ontology_agent_evolved_zh-TW.html

@@ -59,7 +59,7 @@
         document.addEventListener('DOMContentLoaded', function() {
             const { Transformer, Markmap } = window.markmap;
             const transformer = new Transformer();
-            const markdown = `I'm sorry, but it seems that the content to be translated is missing. Could you please provide the specific Markmap content that needs to be translated into Traditional Chinese (Taiwan)?`;
+            const markdown = `I'm sorry, but it seems like the content to translate was not provided. Could you please provide the content that needs to be translated?`;
             const { root } = transformer.transform(markdown);
             const svg = d3.select('.markmap').append('svg');
             const mm = Markmap.create(svg.node(), { color: (node) => node.payload?.color || '#f59e0b' }, root);

tools/ai-markmap-agent/RESUME_MODE.md

@@ -0,0 +1,104 @@
+# Resume / Replay Mode Usage Guide
+
+## Overview
+
+Resume mode allows you to continue execution from a previous pipeline run, supporting:
+- Reusing completed stage outputs (saves tokens and time)
+- Re-running from a specific stage (debug-friendly)
+- Not overwriting original run data (generates new regen run)
+
+## Usage
+
+### Method 1: Interactive Resume Mode
+
+```bash
+python main.py --resume
+```
+
+After startup, it will:
+1. Scan all previous runs under `outputs/debug/`
+2. Display them sorted by time (newest first)
+3. Let you select the run to resume
+4. Ask whether to reuse each stage's output one by one
+
+### Method 2: Start from a Specific Stage
+
+```bash
+python main.py --resume --from-stage writer
+```
+
+This will automatically:
+- Select the latest run
+- Reuse outputs from `expert_review`, `full_discussion`, `consensus`
+- Re-run from the `writer` stage
+
+Supported stages:
+- `expert_review`
+- `full_discussion`
+- `consensus`
+- `writer`
+- `translate`
+- `post_process`
+
+## Example Workflows
+
+### Scenario 1: Writer has no output, want to re-run
+
+```bash
+# 1. List available runs
+python main.py --resume
+
+# 2. Select the latest run (e.g., run_20251215_111303)
+
+# 3. Ask whether to reuse each stage:
+#    - expert_review: [y] (reuse)
+#    - full_discussion: [y] (reuse)
+#    - consensus: [y] (reuse)
+#    - writer: [n] (regenerate)
+
+# 4. Pipeline will:
+#    - Skip expert_review, full_discussion, consensus
+#    - Re-run writer
+#    - Save output to run_20251215_111303_regen_1/
+```
+
+### Scenario 2: Only want to re-run writer
+
+```bash
+python main.py --resume --from-stage writer
+```
+
+Automatically reuses outputs from all previous stages, only re-runs writer.
+
+## Run Naming Rules
+
+- **Original run**: `run_YYYYMMDD_HHMMSS/`
+- **Resume from original run**: `run_YYYYMMDD_HHMMSS_regen_1/`
+- **Resume again**: `run_YYYYMMDD_HHMMSS_regen_2/`
+
+**Important**: Original run data is never overwritten, all new outputs are in regen directories.
+
+## State Loading
+
+The system automatically loads:
+- ✅ **Consensus data**: Loaded from JSON file (if reusing consensus stage)
+- ✅ **Writer output**: Loaded from writer output file (if reusing writer stage)
+- ⚠️ **Expert responses**: Currently only marked as reused, incomplete recovery (needs improvement)
+
+## Debug Output
+
+All intermediate outputs (including reused and regenerated ones) are saved in the new regen run directory for easy comparison and debugging.
+
+## Notes
+
+1. **Ensure debug_output.enabled = true**: Resume mode depends on debug output
+2. **API Keys**: Still need to provide API keys (even when reusing stages)
+3. **Configuration consistency**: Resume uses current config, which may differ from original run
+4. **Partial state recovery**: Currently only partial state recovery is supported, some stages may need to be re-run
+
+## Future Improvements
+
+- [ ] Complete state serialization/deserialization
+- [ ] Support resuming from any intermediate state
+- [ ] Automatically detect failed stages and suggest resume
+- [ ] Support comparing outputs from different runs

tools/ai-markmap-agent/main.py

@@ -32,6 +32,12 @@
 )
 from src.data_sources import DataSourcesLoader
 from src.graph import run_pipeline, load_baseline_markmap, handle_versioning_mode
+from src.resume import (
+    scan_previous_runs,
+    select_run_interactive,
+    ask_reuse_stage,
+    RunInfo,
+)
 
 
 def print_banner() -> None:
@@ -151,6 +157,17 @@ def main() -> int:
         action="store_true",
         help="Enable verbose output"
     )
+    parser.add_argument(
+        "--resume",
+        action="store_true",
+        help="Resume from a previous run (interactive mode)"
+    )
+    parser.add_argument(
+        "--from-stage",
+        type=str,
+        choices=["expert_review", "full_discussion", "consensus", "writer", "translate", "post_process"],
+        help="Start from a specific stage (requires --resume)"
+    )
 
     args = parser.parse_args()
 
@@ -163,6 +180,60 @@ def main() -> int:
         config = load_config(args.config)
         print("  ✓ Configuration loaded\n")
 
+        # Step 1.5: Resume mode selection
+        resume_config = None
+        if args.resume or args.from_stage:
+            print("\n" + "=" * 60)
+            print("Resume Mode")
+            print("=" * 60)
+            
+            # Scan for previous runs
+            debug_config = config.get("debug_output", {})
+            debug_output_dir = Path(debug_config.get("output_dir", "outputs/debug"))
+            runs = scan_previous_runs(debug_output_dir)
+            
+            if not runs:
+                print("\n  ⚠ No previous runs found")
+                if args.resume:
+                    print("  Starting fresh run instead...\n")
+                else:
+                    return 1
+            else:
+                # Let user select a run
+                selected_run = select_run_interactive(runs)
+                if not selected_run:
+                    print("\n  ⚠ Cancelled")
+                    return 0
+                
+                print(f"\n  ✓ Selected: {selected_run.run_id}")
+                
+                # Determine which stages to reuse
+                reuse_stages = {}
+                stages = ["expert_review", "full_discussion", "consensus", "writer"]
+                
+                # If --from-stage is specified, reuse everything before that stage
+                if args.from_stage:
+                    stage_idx = stages.index(args.from_stage) if args.from_stage in stages else -1
+                    if stage_idx >= 0:
+                        for i in range(stage_idx):
+                            if selected_run.has_stage_output(stages[i]):
+                                reuse_stages[stages[i]] = True
+                        print(f"  → Will start from stage: {args.from_stage}")
+                        if reuse_stages:
+                            print(f"  → Will reuse stages: {', '.join(reuse_stages.keys())}")
+                else:
+                    # Interactive: ask for each stage
+                    print("\n  Select which stages to reuse:")
+                    for stage in stages:
+                        if selected_run.has_stage_output(stage):
+                            should_reuse = ask_reuse_stage(stage, selected_run)
+                            reuse_stages[stage] = should_reuse
+                
+                resume_config = {
+                    "run_dir": str(selected_run.run_dir),
+                    "reuse_stages": reuse_stages,
+                }
+        
         # Print workflow summary
         print_workflow_summary(config)
 
@@ -215,6 +286,10 @@ def main() -> int:
         # Add baseline to data
         data["baseline_markmap"] = baseline_markmap
 
+        # Add resume config if available
+        if resume_config:
+            data["_resume_config"] = resume_config
+        
         # Print summary
         print_data_summary(loader.get_summary())
 

tools/ai-markmap-agent/outputs/versions/v1/neetcode_ontology_agent_evolved_zh-TW.html

@@ -59,7 +59,7 @@
         document.addEventListener('DOMContentLoaded', function() {
             const { Transformer, Markmap } = window.markmap;
             const transformer = new Transformer();
-            const markdown = `I'm sorry, but it seems that the content to be translated is missing. Could you please provide the specific Markmap content that needs to be translated into Traditional Chinese (Taiwan)?`;
+            const markdown = `I'm sorry, but it seems like the content to translate was not provided. Could you please provide the content that needs to be translated?`;
             const { root } = transformer.transform(markdown);
             const svg = d3.select('.markmap').append('svg');
             const mm = Markmap.create(svg.node(), { color: (node) => node.payload?.color || '#f59e0b' }, root);

tools/ai-markmap-agent/outputs/versions/v1/neetcode_ontology_agent_evolved_zh-TW.md

@@ -1 +1 @@
-I'm sorry, but it seems that the content to be translated is missing. Could you please provide the specific Markmap content that needs to be translated into Traditional Chinese (Taiwan)?
+I'm sorry, but it seems like the content to translate was not provided. Could you please provide the content that needs to be translated?

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

@@ -19,12 +19,14 @@ class DebugOutputManager:
     Saves intermediate outputs to help with debugging and verification.
     """
 
-    def __init__(self, config: dict[str, Any] | None = None):
+    def __init__(self, config: dict[str, Any] | None = None, run_dir: Path | str | None = None):
         """
         Initialize the debug output manager.
         
         Args:
             config: Configuration dictionary
+            run_dir: Optional run directory path (for resume mode).
+                     If provided, uses this directory instead of creating new one.
         """
         from .config_loader import ConfigLoader
 
@@ -40,11 +42,18 @@ def __init__(self, config: dict[str, Any] | None = None):
         if self.enabled:
             self.output_dir.mkdir(parents=True, exist_ok=True)
 
-            # Create run-specific directory with timestamp
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            self.run_dir = self.output_dir / f"run_{timestamp}"
-            self.run_dir.mkdir(parents=True, exist_ok=True)
-            print(f"  📁 Debug outputs: {self.run_dir}")
+            if run_dir:
+                # Resume mode: use existing run directory
+                self.run_dir = Path(run_dir)
+                if not self.run_dir.exists():
+                    self.run_dir.mkdir(parents=True, exist_ok=True)
+                print(f"  📁 Debug outputs (resume): {self.run_dir}")
+            else:
+                # New run: create run-specific directory with timestamp
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                self.run_dir = self.output_dir / f"run_{timestamp}"
+                self.run_dir.mkdir(parents=True, exist_ok=True)
+                print(f"  📁 Debug outputs: {self.run_dir}")
 
     def _get_filename(
         self,
@@ -314,11 +323,11 @@ def save_post_processing(
 _debug_manager: DebugOutputManager | None = None
 
 
-def get_debug_manager(config: dict[str, Any] | None = None) -> DebugOutputManager:
+def get_debug_manager(config: dict[str, Any] | None = None, run_dir: Path | str | None = None) -> DebugOutputManager:
     """Get or create the global debug output manager."""
     global _debug_manager
     if _debug_manager is None:
-        _debug_manager = DebugOutputManager(config)
+        _debug_manager = DebugOutputManager(config, run_dir=run_dir)
     return _debug_manager