feat(ai-markmap-agent): simplify writer prompt and fix resume functionality

Writer prompt simplification:
- Remove URL format instructions from writer_behavior.md
- Compress problem data to ID list only (reduces tokens)
- Add _convert_plain_leetcode_to_links() to post_processing.py
- Post-processing handles plain text "LeetCode XXX" -> full link

Resume functionality fixes:
- Fix load_expert_responses_from_run to scan correct file categories
- Add parse_suggestions_from_response() standalone function
- Add parse_adoption_list_from_response() standalone function
- Fix run_expert_review resume to load expert_suggestions into state
- Fix run_full_discussion resume to load adoption_lists into state

Author: lufftw

docs/pages/mindmaps/neetcode_ontology_agent_evolved_en.html

@@ -29,6 +29,10 @@ urls:
   github:
     base: "https://github.com/lufftw/neetcode"
     solution_template: "https://github.com/lufftw/neetcode/blob/main/{solution_file}"
+  
+  leetcode:
+    base: "https://leetcode.com"
+    problem_template: "https://leetcode.com/problems/{slug}/"
 
 # -----------------------------------------------------------------------------
 # Data Sources Configuration

docs/pages/mindmaps/neetcode_ontology_agent_evolved_zh-TW.html

@@ -7,7 +7,7 @@ You are the **Markmap Writer** operating in **refinement mode**. Your task is to
 1. **Apply ONLY the adopted improvements** - Do not add your own ideas or "fix" things not mentioned
 2. **Preserve baseline quality** - The baseline was carefully crafted; maintain its strengths
 3. **Match existing style** - New content should be indistinguishable from original content
-4. **Verify all links** - Use the reference data to ensure URLs are correct
+4. **Normalize problem references** - Follow the link format rules below
 
 ---
 
@@ -39,28 +39,24 @@ For context, here are the full descriptions and rationales:
 
 ## Reference Data
 
-Use this data to verify problem information and generate correct links:
-
-### Problem Metadata
+### Problems With Solutions (auto-linked)
 {problem_data}
 
-### URL Templates
+### Link Format Rules
 
-**CRITICAL: Link Generation Rules**
+**For problems in the list above:**
+- Write ONLY: `LeetCode {id} - {title}` (NO URL needed)
+- Links will be generated automatically in post-processing
+- If baseline has URLs for these problems, REMOVE them
+- Example: `LeetCode 11 - Container With Most Water`
 
-1. **If problem has `solution_file` (Has Solution = "Yes"):**
-   - Use GitHub project link: `{github_template}`
-   - Replace `{solution_file}` with the actual solution file path from problem metadata
-   - Example: `https://github.com/lufftw/neetcode/blob/main/solutions/0905_sort_array_by_parity.py`
-   - This takes priority over LeetCode links
+**For problems NOT in the list:**
+- Include the LeetCode link: `[LeetCode {id} - {title}](https://leetcode.com/problems/{slug}/description/)`
+- Example: `[LeetCode 999 - Some Problem](https://leetcode.com/problems/some-problem/description/)`
 
-2. **If problem has NO `solution_file` (Has Solution = "No"):**
-   - Use LeetCode problem link with CORRECT format
-   - Format: `https://leetcode.com/problems/{slug}/description/`
-   - The `slug` is provided in the problem metadata table
-   - **IMPORTANT**: Use the slug as-is from metadata (e.g., `container-with-most-water`), NOT the problem ID format (e.g., NOT `0011_container_with_most_water`)
-   - You know the correct LeetCode URL format - use it correctly
-   - Example: `https://leetcode.com/problems/container-with-most-water/description/`
+**Important:**
+- Do NOT add GitHub solution links (added automatically where available)
+- Use full "LeetCode" not "LC"
 
 ### Ontology Reference
 {ontology_summary}
@@ -72,7 +68,7 @@ Use this data to verify problem information and generate correct links:
 1. **Read the baseline carefully** - Understand its structure and style
 2. **Apply each improvement one by one** - Be surgical and precise
 3. **Maintain consistency** - New content should match existing style
-4. **Verify links** - All URLs must be correct per the templates
+4. **Normalize problem references** - Follow the link format rules above
 5. **Output the complete refined Markmap**
 
 ---
@@ -97,24 +93,11 @@ Use this data to verify problem information and generate correct links:
 - Match code formatting with baseline
 - Match emoji usage with baseline (if any)
 
-### Link Format
-
-**Priority Order:**
-1. **If solution exists (Has Solution = "Yes"):** Use GitHub project link
-   - Format: `[Problem Title](https://github.com/lufftw/neetcode/blob/main/solutions/XXXX_problem_name.py)`
-   - Example: `[LeetCode 905 - Sort Array By Parity](https://github.com/lufftw/neetcode/blob/main/solutions/0905_sort_array_by_parity.py)`
-
-2. **If no solution (Has Solution = "No"):** Use LeetCode problem link
-   - Format: `[Problem Title](https://leetcode.com/problems/{slug}/description/)`
-   - Use the `slug` from problem metadata (e.g., `container-with-most-water`)
-   - **DO NOT** use problem ID format like `0011_container_with_most_water`
-   - **DO** use the correct slug format: `container-with-most-water`
-   - Example: `[LeetCode 11 - Container With Most Water](https://leetcode.com/problems/container-with-most-water/description/)`
-
-**General Rules:**
-- Always use full "LeetCode" not "LC" in link text
-- Format: `[Problem Title](url)`
-- Verify all links are correct before outputting 
+### Problem References
+- Use full "LeetCode" not "LC"
+- For problems in our list: `LeetCode {id} - {title}` (no URL)
+- For other problems: `[LeetCode {id} - {title}](leetcode_url)`
+- Do NOT add GitHub solution links
 
 ### Markmap Features
 - Use `<!-- markmap: fold -->` for collapsible sections
@@ -133,15 +116,15 @@ You would find those problems in the baseline and add the marker:
 
 Before:
 ```markdown
-- [x] [LeetCode 3: Longest Substring Without Repeating Characters](url)
+- [x] [LeetCode 3 - Longest Substring Without Repeating Characters](https://leetcode.com/...)
 ```
 
-After:
+After (assuming LeetCode 3 is in our solutions list):
 ```markdown
-- [x] 🔥 [LeetCode 3: Longest Substring Without Repeating Characters](url)
+- [x] 🔥 LeetCode 3 - Longest Substring Without Repeating Characters
 ```
 
-The rest of the line remains unchanged.
+Note: The URL is removed because LeetCode 3 is in our solutions list. Post-processing will add the correct links automatically.
 
 ---
 

tools/ai-markmap-agent/config/config.yaml

@@ -59,6 +59,88 @@ def to_dict(self) -> dict[str, Any]:
         }
 
 
+def parse_suggestions_from_response(response: str, expert_id: str) -> list[Suggestion]:
+    """
+    Parse suggestions from LLM response (standalone function for resume).
+    
+    Args:
+        response: Raw LLM response text
+        expert_id: Expert identifier (e.g., "architect", "professor")
+        
+    Returns:
+        List of parsed Suggestion objects
+    """
+    suggestions = []
+    
+    # Pattern to match suggestion blocks
+    # Looking for patterns like: ### A1: Title or ## A1 - Title
+    suggestion_pattern = r'#{2,3}\s*([A-Z]\d+)[:\s-]+(.+?)(?=#{2,3}\s*[A-Z]\d+|$)'
+    matches = re.findall(suggestion_pattern, response, re.DOTALL)
+    
+    for match in matches:
+        suggestion_id = match[0]
+        content = match[1].strip()
+        
+        # Extract fields
+        type_match = re.search(r'\*\*Type\*\*:\s*(\w+)', content, re.IGNORECASE)
+        location_match = re.search(r'\*\*Location\*\*:\s*(.+?)(?=\n\*\*|\n-|\n#|$)', content, re.IGNORECASE | re.DOTALL)
+        what_match = re.search(r'\*\*What\*\*:\s*(.+?)(?=\n\*\*|\n-|\n#|$)', content, re.IGNORECASE | re.DOTALL)
+        why_match = re.search(r'\*\*Why\*\*:\s*(.+?)(?=\n\*\*|\n-|\n#|$)', content, re.IGNORECASE | re.DOTALL)
+        
+        suggestions.append(Suggestion(
+            id=suggestion_id,
+            expert_id=expert_id,
+            type=type_match.group(1).strip().lower() if type_match else "modify",
+            location=location_match.group(1).strip() if location_match else "",
+            what=what_match.group(1).strip() if what_match else content[:200],
+            why=why_match.group(1).strip() if why_match else "",
+            raw_text=content,
+        ))
+    
+    return suggestions
+
+
+def parse_adoption_list_from_response(response: str) -> list[str]:
+    """
+    Parse adoption list from discussion response (standalone function for resume).
+    
+    Args:
+        response: Raw LLM discussion response text
+        
+    Returns:
+        List of adopted suggestion IDs (e.g., ["A1", "P2", "E3"])
+    """
+    adopted_ids = []
+    
+    # Strategy 1: Look for explicit adoption section
+    adoption_patterns = [
+        r'(?:^|\n)#+\s*(?:My\s+)?Final\s+Adoption\s+List.*',
+        r'I\s+recommend\s+adopting\s+(?:these\s+)?suggestions?:?\s*\n.*',
+        r'(?:^|\n)#+\s*Part\s*2\s*:?\s*Final\s+Adoption.*',
+    ]
+    
+    section_text = ""
+    for pattern in adoption_patterns:
+        match = re.search(pattern, response, re.IGNORECASE | re.DOTALL)
+        if match:
+            section_text = response[match.start():]
+            break
+    
+    # Strategy 2: If no explicit section found, look for all ✅ Agree votes
+    if not section_text:
+        agree_pattern = r'\*\*Vote\*\*:\s*✅\s*Agree.*?(?:^|\n)#+\s*([APE]\d+)'
+        agrees = re.findall(agree_pattern, response, re.IGNORECASE | re.DOTALL | re.MULTILINE)
+        if agrees:
+            adopted_ids = list(dict.fromkeys(agrees))
+    
+    # Extract IDs from section text
+    if section_text:
+        ids = re.findall(r'\b([APE]\d+)\b', section_text)
+        adopted_ids = list(dict.fromkeys(ids))
+    
+    return adopted_ids
+
+
 class ExpertAgent(BaseAgent):
     """
     Base class for Expert agents.

tools/ai-markmap-agent/outputs/versions/v1/neetcode_ontology_agent_evolved_en.html

@@ -48,13 +48,6 @@ def __init__(self, config: dict[str, Any] | None = None):
 
         # Load format guide
         self.format_guide = self._load_format_guide(model_config)
-        
-        # URL templates
-        urls_config = config.get("urls", {})
-        self.github_template = urls_config.get("github", {}).get(
-            "solution_template",
-            "https://github.com/lufftw/neetcode/blob/main/{solution_file}"
-        )
 
     def _load_format_guide(self, model_config: dict) -> str:
         """Load the Markmap format guide."""
@@ -91,24 +84,33 @@ def _format_problems_for_prompt(
         self,
         problems_lookup: dict[str, dict],
     ) -> str:
-        """Format problems for the writer prompt."""
+        """Format problems for the writer prompt - compressed ID list only."""
         if not problems_lookup:
-            return "No problem data available."
-        
-        lines = ["| ID | Title | Slug | Has Solution |", "|---|---|---|---|"]
+            return "None"
 
+        # Collect problem IDs that have solution files
+        solution_ids = []
         seen = set()
-        for pid, problem in list(problems_lookup.items())[:100]:
+        
+        for pid, problem in problems_lookup.items():
             if pid in seen:
                 continue
-            seen.add(pid)
-            
-            title = problem.get("title", "Unknown")[:50]
-            slug = problem.get("slug", "")
-            has_solution = "Yes" if problem.get("solution_file") else "No"
-            lines.append(f"| {pid} | {title} | {slug} | {has_solution} |")
+            try:
+                pid_int = int(pid)
+                seen.add(pid)
+                # Check for solution file in files.solution
+                files = problem.get("files", {})
+                if files.get("solution"):
+                    solution_ids.append(pid_int)
+            except (ValueError, TypeError):
+                continue
 
-        return "\n".join(lines)
+        if not solution_ids:
+            return "None"
+        
+        # Sort and format as compact list: "1,2,3,11,15,..."
+        solution_ids.sort()
+        return ",".join(str(pid) for pid in solution_ids)
 
     def _format_ontology(self, ontology: dict[str, Any]) -> str:
         """Format ontology for prompt."""
@@ -159,13 +161,12 @@ def process(self, state: dict[str, Any]) -> dict[str, Any]:
         # Get ontology
         ontology = state.get("ontology", {})
 
-        # Build the prompt
+        # Build the prompt (no longer pass github_template or leetcode_template)
         prompt = self.behavior_prompt.format(
             baseline_markmap=baseline_markmap,
             adopted_improvements=brief_list,
             improvement_details=detailed_descriptions,
             problem_data=self._format_problems_for_prompt(problems_lookup),
-            github_template=self.github_template,
             ontology_summary=self._format_ontology(ontology),
         )