code-finder 0.1.0__py3-none-any.whl

claude_context/synthesis/multi_review_pipeline.py

@@ -0,0 +1,717 @@
+"""
+Multi-Review Documentation Pipeline
+
+Orchestrates a writer agent with 3 sequential reviewer agents to produce
+high-quality documentation through iterative refinement with regression checks.
+
+Design:
+- Writer: Applies feedback and maintains citations
+- Reviewer A: Deep technical accuracy check (establishes baseline)
+- Reviewer B: Progressive disclosure focus + critical technical regression checks
+- Reviewer C: Consistency/formatting focus + final safety checks for any regressions
+
+Each reviewer sees only the current draft (fresh eyes, no previous feedback).
+Later reviewers flag CRITICAL issues outside their domain to catch regressions.
+"""
+
+import json
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+
+from .providers import create_generator, TextGenerator
+
+logger = logging.getLogger(__name__)
+
+
+class ReviewerRole(Enum):
+    """Reviewer types with distinct focus areas."""
+    TECHNICAL_ACCURACY = "reviewer_a"
+    PROGRESSIVE_DISCLOSURE = "reviewer_b"
+    CONSISTENCY = "reviewer_c"
+
+
+@dataclass
+class ReviewFeedback:
+    """Structured feedback from a reviewer pass."""
+    reviewer: str
+    overall_assessment: str
+    issues: List[Dict[str, str]] = field(default_factory=list)
+    strengths: List[str] = field(default_factory=list)
+    questions: List[str] = field(default_factory=list)
+    raw_response: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "reviewer": self.reviewer,
+            "overall_assessment": self.overall_assessment,
+            "issues": self.issues,
+            "strengths": self.strengths,
+            "questions": self.questions
+        }
+
+
+# Role definitions with regression check instructions
+REVIEWER_A_ROLE = """You are Reviewer A: Technical Accuracy & Architecture Specialist
+
+**PRIMARY FOCUS (Your Main Responsibility):**
+1. **Technical Correctness**
+   - Code examples match actual implementation
+   - API signatures are accurate (parameters, return types, exceptions)
+   - Dependencies and versions are correct
+   - Error handling is properly documented
+   - Command-line examples work as shown
+
+2. **Architecture & Terminology**
+   - Architectural diagrams match code structure
+   - Terminology is consistent and precise
+   - Component relationships are accurate
+   - Design patterns are correctly identified
+   - File paths and module names match actual codebase
+
+**SECONDARY FOCUS:** None (you're establishing the technical baseline)
+
+**Output Format (JSON):**
+Return ONLY valid JSON. No markdown code blocks, no commentary before or after.
+Start your response with `{` and end with `}`.
+
+```json
+{
+  "overall_assessment": "Brief verdict (2-3 sentences)",
+  "issues": [
+    {
+      "location": "Section name or line reference",
+      "severity": "critical|major|minor",
+      "category": "accuracy|architecture|terminology",
+      "description": "What's wrong and why it matters",
+      "suggested_fix": "Concrete suggestion with correct information"
+    }
+  ],
+  "strengths": ["What works well technically"],
+  "questions": ["Unclear items needing human review"]
+}
+```
+
+CRITICAL: Ensure all strings are properly closed with quotes. Keep descriptions concise to avoid JSON parsing errors.
+
+**Review Criteria:**
+- Does the code actually work this way?
+- Are API signatures exactly correct?
+- Is terminology aligned with codebase naming?
+- Would a developer be misled by any technical claims?
+"""
+
+REVIEWER_B_ROLE = """You are Reviewer B: Progressive Disclosure & Conceptual Layering Specialist
+
+**PRIMARY FOCUS (Your Main Responsibility):**
+1. **Progressive Disclosure**
+   - Start with essentials (install, quickstart, basic usage)
+   - Build complexity gradually
+   - Avoid overwhelming beginners with advanced topics too early
+   - Clear path from "first steps" to "advanced usage"
+
+2. **Conceptual Coherence**
+   - Clear mental models before implementation details
+   - Analogies and examples aid understanding
+   - Concepts build on each other logically
+   - Appropriate detail level for target audience
+
+3. **Boilerplate Repetition Check (CRITICAL)**
+   - ONLY "Getting Started" should have full Installation + Quickstart + Citation blocks
+   - ALL other documents should replace these with a cross-reference like:
+     "For installation instructions, see [Getting Started](getting-started.md)"
+   - Flag ANY document (except Getting Started) that duplicates Installation/Quickstart/Citation sections
+   - This is a MAJOR disclosure issue: readers must scroll past 15-20 lines of boilerplate on every page
+
+**SECONDARY FOCUS (Regression Check):**
+- Quick scan for CRITICAL technical errors introduced during revision
+- Only flag if obvious/critical (e.g., broken code example, wrong command syntax)
+- NOT a full technical re-review, just a safety net
+- Examples to flag: `pip install wrong-package`, incorrect function signature in code block
+
+**Output Format (JSON):**
+Return ONLY valid JSON. No markdown code blocks, no commentary before or after.
+Start your response with `{` and end with `}`.
+
+```json
+{
+  "overall_assessment": "Brief verdict on information flow and any critical regressions",
+  "issues": [
+    {
+      "location": "Section or paragraph",
+      "severity": "critical|major|minor",
+      "category": "disclosure|layering|clarity|regression_technical|boilerplate",
+      "description": "What disrupts learning flow OR critical technical error introduced",
+      "suggested_fix": "How to restructure/simplify OR correct the technical error"
+    }
+  ],
+  "strengths": ["Well-structured explanations"],
+  "questions": ["Ambiguous ordering decisions"]
+}
+```
+
+CRITICAL: Ensure all strings are properly closed with quotes. Keep descriptions concise to avoid JSON parsing errors.
+
+**Review Criteria:**
+- Can a newcomer follow this?
+- Do advanced topics appear too early?
+- Are concepts properly scaffolded?
+- **REGRESSION CHECK:** Are there obvious broken code examples or commands?
+"""
+
+REVIEWER_C_ROLE = """You are Reviewer C: Consistency, Formatting & Cross-Reference Specialist
+
+**PRIMARY FOCUS (Your Main Responsibility):**
+1. **Consistency & Naming**
+   - Variable/function names match codebase exactly
+   - Consistent terminology across sections
+   - Cross-references are accurate
+   - Examples use real file paths from the repository
+
+2. **Formatting & Patterns**
+   - Code blocks are properly formatted
+   - Citations follow [CITE:source] convention
+   - Headings follow proper hierarchy
+   - Lists and tables are well-structured
+   - Links work and point to correct locations
+
+3. **Boilerplate Duplication Check (CRITICAL)**
+   - ONLY "Getting Started" should contain full Installation + Quickstart + Citation blocks
+   - ALL other documents must use cross-references instead:
+     "For installation, see [Getting Started](getting-started.md)"
+   - Flag ANY document (except Getting Started) that duplicates these sections
+   - This is a consistency violation: same boilerplate repeated across multiple files
+
+**SECONDARY FOCUS (Final Safety Check):**
+- Quick scan for CRITICAL regressions (technical OR disclosure)
+- Last chance to catch obvious errors before final draft
+- Only flag if severe (e.g., completely broken example, major inconsistency introduced)
+- Examples to flag: duplicate boilerplate text, contradictory instructions, broken citations
+
+**Output Format (JSON):**
+Return ONLY valid JSON. No markdown code blocks, no commentary before or after.
+Start your response with `{` and end with `}`.
+
+```json
+{
+  "overall_assessment": "Brief verdict on polish, consistency, and any critical regressions",
+  "issues": [
+    {
+      "location": "Specific location",
+      "severity": "critical|major|minor",
+      "category": "consistency|formatting|naming|citations|boilerplate|regression_technical|regression_disclosure",
+      "description": "What's inconsistent/malformed OR critical regression",
+      "suggested_fix": "Correction"
+    }
+  ],
+  "strengths": ["Well-formatted sections"],
+  "questions": ["Questionable naming choices"]
+}
+```
+
+CRITICAL: Ensure all strings are properly closed with quotes. Keep descriptions concise to avoid JSON parsing errors.
+
+**Review Criteria:**
+- Is naming consistent with the repo?
+- Are citations properly formatted?
+- Do cross-references work?
+- **REGRESSION CHECK:** Any obvious technical or disclosure errors introduced?
+- **CONSISTENCY CHECK:** Is same boilerplate text repeated across multiple sections?
+"""
+
+WRITER_ROLE = """You are a technical documentation writer with deep codebase expertise.
+
+**Your Responsibilities:**
+- Apply reviewer feedback systematically and accurately
+- Verify all changes against the codebase
+- Preserve ALL existing [CITE:...] citations
+- Maintain document structure and formatting
+
+**Feedback Application Process:**
+1. Read reviewer feedback carefully
+2. For each issue:
+   - Assess validity against codebase
+   - Apply fix if valid
+   - Preserve or add appropriate citations
+   - Document any feedback you cannot apply
+3. Maintain consistency across all sections
+
+**Critical Rules:**
+- NEVER remove existing [CITE:...] citations
+- If you move text, keep its citation attached
+- If you add new factual claims, add appropriate citations
+- Be conservative: if unsure about a fix, keep the original with a note
+- When fixing technical errors, verify against actual code
+
+**Boilerplate Content Rules:**
+- ONLY "Getting Started" should have full Installation + Quickstart + Citation blocks
+- ALL other documents should replace these sections with cross-references like:
+  "For installation instructions, see [Getting Started](getting-started.md)"
+- Remove duplicate Installation/Quickstart/Citation blocks from non-Getting-Started documents
+
+**Style Guidelines:**
+- Progressive disclosure (simple → complex)
+- Technical accuracy over brevity
+- Concrete examples with citations
+- Clear architecture explanations
+
+**CRITICAL OUTPUT FORMAT:**
+You MUST return ONLY the revised document content.
+DO NOT include explanations, commentary, analysis, or acknowledgments.
+DO NOT wrap content in markdown code blocks.
+ONLY output documents in this exact delimiter format:
+
+=== FILENAME ===
+[full revised content]
+
+=== NEXT_FILENAME ===
+[full revised content]
+"""
+
+
+class MultiReviewPipeline:
+    """
+    Orchestrate writer + 3 reviewers for iterative documentation refinement.
+
+    Each reviewer has:
+    - Primary focus (their specialty)
+    - Secondary focus (regression checks for later reviewers)
+    - Isolated context (fresh eyes, no previous feedback)
+    """
+
+    def __init__(self, searcher=None, repo_path: str = "."):
+        """
+        Initialize the multi-review pipeline.
+
+        Args:
+            searcher: Optional hybrid searcher for evidence grounding
+            repo_path: Path to repository root
+        """
+        self.searcher = searcher
+        self.repo_path = Path(repo_path)
+        self.generator = create_generator()
+
+    def run(
+        self,
+        drafts: Dict[str, str],
+        output_dir: Path
+    ) -> Dict[str, str]:
+        """
+        Run the complete multi-review pipeline.
+
+        Args:
+            drafts: Dictionary of {filename: content} for documentation
+            output_dir: Where to save final outputs
+
+        Returns:
+            Dictionary of final revised documentation
+        """
+        logger.info("Starting multi-review pipeline (Writer + 3 Reviewers)")
+
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Track all feedback for audit trail
+        review_log = {}
+
+        # Current working drafts
+        current_drafts = drafts.copy()
+
+        # Cycle 1: Reviewer A (Technical Accuracy)
+        logger.info("Cycle 1: Reviewer A (Technical Accuracy)")
+        feedback_a = self._spawn_reviewer_agent(
+            role=ReviewerRole.TECHNICAL_ACCURACY,
+            drafts=current_drafts
+        )
+        review_log["reviewer_a"] = feedback_a.to_dict()
+
+        current_drafts = self._spawn_writer_agent(
+            drafts=current_drafts,
+            feedback=feedback_a
+        )
+
+        # Cycle 2: Reviewer B (Progressive Disclosure + Regression Check)
+        logger.info("Cycle 2: Reviewer B (Progressive Disclosure + Regression Check)")
+        feedback_b = self._spawn_reviewer_agent(
+            role=ReviewerRole.PROGRESSIVE_DISCLOSURE,
+            drafts=current_drafts
+        )
+        review_log["reviewer_b"] = feedback_b.to_dict()
+
+        current_drafts = self._spawn_writer_agent(
+            drafts=current_drafts,
+            feedback=feedback_b
+        )
+
+        # Cycle 3: Reviewer C (Consistency + Final Safety Check)
+        logger.info("Cycle 3: Reviewer C (Consistency + Final Safety Check)")
+        feedback_c = self._spawn_reviewer_agent(
+            role=ReviewerRole.CONSISTENCY,
+            drafts=current_drafts
+        )
+        review_log["reviewer_c"] = feedback_c.to_dict()
+
+        final_drafts = self._spawn_writer_agent(
+            drafts=current_drafts,
+            feedback=feedback_c
+        )
+
+        # Save final drafts
+        logger.info("Saving final documentation...")
+        for filename, content in final_drafts.items():
+            output_file = output_dir / filename
+            output_file.write_text(content)
+            logger.info(f"  ✓ {output_file}")
+
+        # Save review log
+        review_log_file = output_dir / "REVIEW_LOG.json"
+        review_log_file.write_text(json.dumps(review_log, indent=2))
+        logger.info(f"Review log saved: {review_log_file}")
+
+        logger.info("Multi-review pipeline complete!")
+        return final_drafts
+
+    def _spawn_reviewer_agent(
+        self,
+        role: ReviewerRole,
+        drafts: Dict[str, str]
+    ) -> ReviewFeedback:
+        """
+        Spawn isolated reviewer agent with fresh context.
+
+        Reviews documents in batches to avoid API timeouts.
+
+        Args:
+            role: Which reviewer type to spawn
+            drafts: Current documentation drafts
+
+        Returns:
+            Structured feedback from the reviewer (merged from all batches)
+        """
+        BATCH_SIZE = 5  # Review 5 documents at a time
+
+        draft_items = list(drafts.items())
+        total_batches = (len(draft_items) + BATCH_SIZE - 1) // BATCH_SIZE
+        all_issues = []
+        all_strengths = []
+        all_questions = []
+        overall_assessments = []
+
+        role_prompt = self._get_role_prompt(role)
+
+        logger.info(f"  Spawning {role.value} with isolated context ({total_batches} batches)...")
+
+        for batch_idx in range(0, len(draft_items), BATCH_SIZE):
+            batch = dict(draft_items[batch_idx:batch_idx + BATCH_SIZE])
+            batch_num = (batch_idx // BATCH_SIZE) + 1
+
+            logger.info(f"    Reviewing batch {batch_num}/{total_batches} ({len(batch)} documents)...")
+
+            # Build review prompt for this batch
+            user_prompt = f"""Review the following documentation drafts against the codebase.
+
+IMPORTANT: You are seeing these drafts with fresh eyes. You have no knowledge of previous reviews.
+
+Batch {batch_num}/{total_batches}:
+{self._format_drafts(batch)}
+
+Provide your feedback as JSON following the format specified in your role description.
+Focus on your PRIMARY responsibilities, but also note any CRITICAL issues in your SECONDARY focus area if applicable.
+"""
+
+            # Generate review for this batch
+            response = self.generator.generate(
+                system_prompt=role_prompt,
+                user_prompt=user_prompt,
+                temperature=0.15,  # Deterministic reviews
+                max_tokens=3000
+            )
+
+            # Parse and accumulate feedback from this batch
+            batch_feedback = self._parse_feedback(response, role.value)
+            all_issues.extend(batch_feedback.issues)
+            all_strengths.extend(batch_feedback.strengths)
+            all_questions.extend(batch_feedback.questions)
+            overall_assessments.append(batch_feedback.overall_assessment)
+
+        # Merge all batch feedback into single ReviewFeedback
+        merged_assessment = " | ".join(overall_assessments) if overall_assessments else "No issues found"
+
+        logger.info(f"  {role.value} completed all {total_batches} batches ({len(all_issues)} total issues)")
+
+        return ReviewFeedback(
+            reviewer=role.value,
+            overall_assessment=merged_assessment,
+            issues=all_issues,
+            strengths=all_strengths,
+            questions=all_questions
+        )
+
+    def _spawn_writer_agent(
+        self,
+        drafts: Dict[str, str],
+        feedback: ReviewFeedback
+    ) -> Dict[str, str]:
+        """
+        Spawn writer agent to apply reviewer feedback.
+
+        Processes documents in batches to avoid API timeouts.
+
+        Args:
+            drafts: Current documentation drafts
+            feedback: Reviewer feedback to apply
+
+        Returns:
+            Revised documentation drafts
+        """
+        BATCH_SIZE = 4  # Process 4 documents at a time
+
+        draft_items = list(drafts.items())
+        revised_drafts = {}
+        total_batches = (len(draft_items) + BATCH_SIZE - 1) // BATCH_SIZE
+
+        logger.info(f"  Writer applying {feedback.reviewer} feedback in {total_batches} batches...")
+
+        for batch_idx in range(0, len(draft_items), BATCH_SIZE):
+            batch = dict(draft_items[batch_idx:batch_idx + BATCH_SIZE])
+            batch_num = (batch_idx // BATCH_SIZE) + 1
+
+            logger.info(f"    Processing batch {batch_num}/{total_batches} ({len(batch)} documents)...")
+
+            # Filter feedback to only issues relevant to this batch
+            batch_feedback = self._filter_feedback_for_batch(feedback, batch.keys())
+
+            user_prompt = f"""Apply the following reviewer feedback to the documentation drafts.
+
+Current Drafts (Batch {batch_num}/{total_batches}):
+{self._format_drafts(batch)}
+
+Reviewer Feedback:
+{json.dumps(batch_feedback.to_dict(), indent=2)}
+
+For each issue:
+1. Verify the concern against the codebase
+2. Apply the fix if valid
+3. Preserve ALL [CITE:...] citations
+4. Make precise, targeted edits
+
+CRITICAL OUTPUT REQUIREMENTS:
+- Return ONLY the revised document content
+- NO explanations, commentary, or analysis
+- NO markdown code blocks (```markdown, etc.)
+- Use EXACTLY this format for each file:
+
+=== FILENAME ===
+[complete revised content of the file]
+
+=== NEXT_FILENAME ===
+[complete revised content of next file]
+
+EXAMPLES OF CORRECT FORMAT:
+
+Example 1 (correct):
+=== SYNTHESIZED_GETTING_STARTED.md ===
+# Getting Started
+
+Speculators is a library for speculative decoding...
+
+## Installation
+...
+
+=== SYNTHESIZED_CONCEPTS.md ===
+# Concepts
+
+For installation instructions, see [Getting Started](getting-started.md).
+
+## Overview
+...
+
+Example 2 (INCORRECT - do NOT do this):
+I've reviewed the feedback and applied the following changes:
+- Removed duplicate Installation section from Concepts
+- Fixed the boilerplate issue
+Here are the revised documents:
+=== SYNTHESIZED_CONCEPTS.md ===
+...
+
+CRITICAL: Your response must START with "=== " (the first three characters).
+Do not write ANYTHING before the first "=== " delimiter.
+"""
+
+            response = self.generator.generate(
+                system_prompt=WRITER_ROLE,
+                user_prompt=user_prompt,
+                temperature=0.2,
+                max_tokens=8000  # Reduced from 16000 since processing fewer docs
+            )
+
+            # Parse and merge batch results
+            batch_revised = self._parse_revised_drafts(response, batch)
+            revised_drafts.update(batch_revised)
+
+        logger.info(f"  Writer completed all {total_batches} batches")
+        return revised_drafts
+
+    def _filter_feedback_for_batch(
+        self,
+        feedback: ReviewFeedback,
+        batch_filenames: set
+    ) -> ReviewFeedback:
+        """Filter feedback to only include issues relevant to the current batch."""
+        # Filter issues that mention files in this batch
+        relevant_issues = []
+        for issue in feedback.issues:
+            location = issue.get("location", "")
+            # Check if location mentions any file in the batch
+            if any(filename in location for filename in batch_filenames):
+                relevant_issues.append(issue)
+            # Also include general issues without specific locations
+            elif not any(f".md:" in location for f in ["SYNTHESIZED_"]):
+                relevant_issues.append(issue)
+
+        # Create filtered feedback
+        return ReviewFeedback(
+            reviewer=feedback.reviewer,
+            overall_assessment=feedback.overall_assessment,
+            issues=relevant_issues,
+            strengths=feedback.strengths,
+            questions=feedback.questions
+        )
+
+    def _get_role_prompt(self, role: ReviewerRole) -> str:
+        """Get the system prompt for a reviewer role."""
+        role_map = {
+            ReviewerRole.TECHNICAL_ACCURACY: REVIEWER_A_ROLE,
+            ReviewerRole.PROGRESSIVE_DISCLOSURE: REVIEWER_B_ROLE,
+            ReviewerRole.CONSISTENCY: REVIEWER_C_ROLE,
+        }
+        return role_map[role]
+
+    def _format_drafts(self, drafts: Dict[str, str]) -> str:
+        """Format drafts for inclusion in prompts."""
+        formatted = []
+        for filename, content in drafts.items():
+            # Truncate very long content to stay within token limits
+            truncated_content = content[:15000] if len(content) > 15000 else content
+            truncation_note = "\n[... content truncated for review ...]" if len(content) > 15000 else ""
+
+            formatted.append(f"""=== {filename} ===
+{truncated_content}{truncation_note}
+""")
+        return "\n\n".join(formatted)
+
+    def _parse_feedback(self, response: str, reviewer_name: str) -> ReviewFeedback:
+        """
+        Parse reviewer response into structured feedback.
+
+        Args:
+            response: Raw LLM response
+            reviewer_name: Name of the reviewer
+
+        Returns:
+            Structured ReviewFeedback object
+        """
+        # Try to extract JSON from response
+        try:
+            # Look for JSON in markdown code blocks
+            if "```json" in response:
+                json_start = response.find("```json") + 7
+                json_end = response.find("```", json_start)
+                json_str = response[json_start:json_end].strip()
+            elif "```" in response:
+                json_start = response.find("```") + 3
+                json_end = response.find("```", json_start)
+                json_str = response[json_start:json_end].strip()
+            else:
+                json_str = response.strip()
+
+            data = json.loads(json_str)
+
+            return ReviewFeedback(
+                reviewer=reviewer_name,
+                overall_assessment=data.get("overall_assessment", "No assessment provided"),
+                issues=data.get("issues", []),
+                strengths=data.get("strengths", []),
+                questions=data.get("questions", []),
+                raw_response=response
+            )
+        except (json.JSONDecodeError, KeyError, IndexError) as e:
+            logger.warning(f"Failed to parse {reviewer_name} feedback as JSON: {e}")
+            # Fallback: treat as plain text issues
+            return ReviewFeedback(
+                reviewer=reviewer_name,
+                overall_assessment="Could not parse structured feedback",
+                issues=[{
+                    "location": "general",
+                    "severity": "minor",
+                    "category": "parsing_error",
+                    "description": f"Reviewer response: {response[:500]}",
+                    "suggested_fix": "Manual review required"
+                }],
+                raw_response=response
+            )
+
+    def _parse_revised_drafts(
+        self,
+        response: str,
+        original_drafts: Dict[str, str]
+    ) -> Dict[str, str]:
+        """
+        Parse writer's revised drafts from response.
+
+        Args:
+            response: Raw LLM response with revised drafts
+            original_drafts: Original drafts (fallback if parsing fails)
+
+        Returns:
+            Dictionary of revised drafts
+        """
+        revised = {}
+
+        # Check if response starts with delimiter
+        if not response.strip().startswith("==="):
+            logger.warning(
+                f"Writer response does not start with '===' delimiter. "
+                f"First 200 chars: {response[:200]}"
+            )
+
+        # Try to parse delimited format
+        try:
+            sections = response.split("=== ")
+            for section in sections[1:]:  # Skip first empty split
+                if " ===" not in section:
+                    continue
+
+                filename_end = section.find(" ===")
+                filename = section[:filename_end].strip()
+                content = section[filename_end + 4:].strip()
+
+                # Clean up markdown code blocks if present
+                if content.startswith("```"):
+                    content = content.split("```", 2)[-1].strip()
+                if content.endswith("```"):
+                    content = content.rsplit("```", 1)[0].strip()
+
+                revised[filename] = content
+                logger.info(f"  Successfully parsed revision for {filename} ({len(content)} chars)")
+        except Exception as e:
+            logger.warning(f"Failed to parse revised drafts: {e}")
+            logger.warning(f"Response preview: {response[:500]}")
+            return original_drafts
+
+        # If no files were parsed, return originals
+        if not revised:
+            logger.warning("No revised drafts found in response, keeping originals")
+            logger.warning(f"Response length: {len(response)} chars")
+            logger.warning(f"Response preview: {response[:500]}")
+            return original_drafts
+
+        # Fill in any missing files from originals
+        for filename in original_drafts:
+            if filename not in revised:
+                logger.warning(f"File {filename} not in revision, keeping original")
+                revised[filename] = original_drafts[filename]
+
+        return revised