mcp-sequential-research 1.0.0

package/src/compilers.ts

@@ -0,0 +1,1113 @@
+/**
+ * Research Report Compilation
+ *
+ * Deterministic compiler that transforms research plan + raw results
+ * into a structured markdown report with citations.
+ */
+
+import type {
+  CompileInput,
+  CompileOutput,
+  Citation,
+  RawResult,
+  ReportSection,
+  PlanOutput,
+  PriorArtCluster,
+  ClaimRiskFlag,
+  NoveltyGap,
+} from "./schema.js";
+import {
+  generateId,
+  isoNow,
+  formatSourcesList,
+  countWords,
+  deduplicateCitations,
+  renumberCitations,
+  applyCitationMapping,
+  formatBulletList,
+  formatCallout,
+} from "./format.js";
+
+/**
+ * Section templates by query type
+ */
+const SECTION_TEMPLATES: Record<string, {
+  heading: string;
+  level: number;
+  formatter: (data: Record<string, unknown>, citations: Citation[]) => string;
+}> = {
+  definition: {
+    heading: "Overview",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (data.definition) {
+        parts.push(String(data.definition));
+        if (citations.length > 0) {
+          parts[parts.length - 1] += ` ${formatInlineCitations(citations)}`;
+        }
+      }
+
+      if (Array.isArray(data.characteristics) && data.characteristics.length > 0) {
+        parts.push("\n**Key Characteristics:**");
+        parts.push(formatBulletList(data.characteristics.map(String)));
+      }
+
+      if (Array.isArray(data.examples) && data.examples.length > 0) {
+        parts.push("\n**Examples:**");
+        parts.push(formatBulletList(data.examples.map(String)));
+      }
+
+      return parts.join("\n");
+    },
+  },
+  comparison: {
+    heading: "Comparison",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.similarities) && data.similarities.length > 0) {
+        parts.push("**Similarities:**");
+        parts.push(formatBulletList(data.similarities.map(String)));
+      }
+
+      if (Array.isArray(data.differences) && data.differences.length > 0) {
+        parts.push("\n**Differences:**");
+        parts.push(formatBulletList(data.differences.map(String)));
+      }
+
+      if (data.recommendation) {
+        parts.push(`\n**Recommendation:** ${data.recommendation}`);
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  enumeration: {
+    heading: "Types and Categories",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.items) && data.items.length > 0) {
+        parts.push(formatBulletList(data.items.map(String)));
+      }
+
+      if (data.categories && typeof data.categories === "object") {
+        for (const [category, items] of Object.entries(data.categories as Record<string, unknown[]>)) {
+          parts.push(`\n**${category}:**`);
+          if (Array.isArray(items)) {
+            parts.push(formatBulletList(items.map(String)));
+          }
+        }
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  procedure: {
+    heading: "Process",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.prerequisites) && data.prerequisites.length > 0) {
+        parts.push("**Prerequisites:**");
+        parts.push(formatBulletList(data.prerequisites.map(String)));
+      }
+
+      if (Array.isArray(data.steps) && data.steps.length > 0) {
+        parts.push("\n**Steps:**");
+        data.steps.forEach((step, i) => {
+          parts.push(`${i + 1}. ${step}`);
+        });
+      }
+
+      if (Array.isArray(data.warnings) && data.warnings.length > 0) {
+        parts.push("\n" + formatCallout(data.warnings.join("\n"), "warning"));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  causation: {
+    heading: "Causes and Factors",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.primary_causes) && data.primary_causes.length > 0) {
+        parts.push("**Primary Causes:**");
+        parts.push(formatBulletList(data.primary_causes.map(String)));
+      }
+
+      if (Array.isArray(data.contributing_factors) && data.contributing_factors.length > 0) {
+        parts.push("\n**Contributing Factors:**");
+        parts.push(formatBulletList(data.contributing_factors.map(String)));
+      }
+
+      if (data.evidence_quality) {
+        parts.push(`\n*Evidence Quality: ${data.evidence_quality}*`);
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  evidence: {
+    heading: "Evidence",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.supporting_evidence) && data.supporting_evidence.length > 0) {
+        parts.push("**Supporting Evidence:**");
+        parts.push(formatBulletList(data.supporting_evidence.map(String)));
+      }
+
+      if (Array.isArray(data.contrary_evidence) && data.contrary_evidence.length > 0) {
+        parts.push("\n**Contrary Evidence:**");
+        parts.push(formatBulletList(data.contrary_evidence.map(String)));
+      }
+
+      if (data.consensus) {
+        parts.push(`\n**Consensus:** ${data.consensus}`);
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  current_state: {
+    heading: "Current State",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (data.current_status) {
+        parts.push(String(data.current_status));
+      }
+
+      if (Array.isArray(data.recent_developments) && data.recent_developments.length > 0) {
+        parts.push("\n**Recent Developments:**");
+        parts.push(formatBulletList(data.recent_developments.map(String)));
+      }
+
+      if (Array.isArray(data.key_players) && data.key_players.length > 0) {
+        parts.push("\n**Key Players:**");
+        parts.push(formatBulletList(data.key_players.map(String)));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  historical: {
+    heading: "Historical Context",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.timeline) && data.timeline.length > 0) {
+        parts.push("**Timeline:**");
+        parts.push(formatBulletList(data.timeline.map(String)));
+      }
+
+      if (Array.isArray(data.milestones) && data.milestones.length > 0) {
+        parts.push("\n**Key Milestones:**");
+        parts.push(formatBulletList(data.milestones.map(String)));
+      }
+
+      if (Array.isArray(data.key_figures) && data.key_figures.length > 0) {
+        parts.push("\n**Key Figures:**");
+        parts.push(formatBulletList(data.key_figures.map(String)));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  prediction: {
+    heading: "Future Outlook",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.short_term) && data.short_term.length > 0) {
+        parts.push("**Short-term Outlook:**");
+        parts.push(formatBulletList(data.short_term.map(String)));
+      }
+
+      if (Array.isArray(data.long_term) && data.long_term.length > 0) {
+        parts.push("\n**Long-term Outlook:**");
+        parts.push(formatBulletList(data.long_term.map(String)));
+      }
+
+      if (Array.isArray(data.uncertainties) && data.uncertainties.length > 0) {
+        parts.push("\n**Key Uncertainties:**");
+        parts.push(formatBulletList(data.uncertainties.map(String)));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  opinion: {
+    heading: "Expert Perspectives",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (data.majority_view) {
+        parts.push(`**Majority View:** ${data.majority_view}`);
+      }
+
+      if (Array.isArray(data.alternative_views) && data.alternative_views.length > 0) {
+        parts.push("\n**Alternative Views:**");
+        parts.push(formatBulletList(data.alternative_views.map(String)));
+      }
+
+      if (Array.isArray(data.key_debates) && data.key_debates.length > 0) {
+        parts.push("\n**Key Debates:**");
+        parts.push(formatBulletList(data.key_debates.map(String)));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+
+  // Patent-grade section templates
+  patent_broad: {
+    heading: "Patent Landscape",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.patents) && data.patents.length > 0) {
+        parts.push("**Relevant Patents:**");
+        parts.push(formatBulletList(data.patents.map(String)));
+      }
+
+      if (Array.isArray(data.key_claims) && data.key_claims.length > 0) {
+        parts.push("\n**Key Claim Language:**");
+        parts.push(formatBulletList(data.key_claims.map(String)));
+      }
+
+      if (Array.isArray(data.classifications) && data.classifications.length > 0) {
+        parts.push("\n**Technology Classifications:** " + data.classifications.join(", "));
+      }
+
+      if (Array.isArray(data.assignees) && data.assignees.length > 0) {
+        parts.push("\n**Major Assignees:** " + data.assignees.join(", "));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  patent_synonyms: {
+    heading: "Terminology Analysis",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.synonyms) && data.synonyms.length > 0) {
+        parts.push("**Alternative Terms:**");
+        parts.push(formatBulletList(data.synonyms.map(String)));
+      }
+
+      if (Array.isArray(data.patent_language) && data.patent_language.length > 0) {
+        parts.push("\n**Patent Language:**");
+        parts.push(formatBulletList(data.patent_language.map(String)));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  patent_problem_benefit: {
+    heading: "Problem-Solution Analysis",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.problems) && data.problems.length > 0) {
+        parts.push("**Problems Addressed:**");
+        parts.push(formatBulletList(data.problems.map(String)));
+      }
+
+      if (Array.isArray(data.benefits) && data.benefits.length > 0) {
+        parts.push("\n**Claimed Benefits:**");
+        parts.push(formatBulletList(data.benefits.map(String)));
+      }
+
+      if (Array.isArray(data.technical_effects) && data.technical_effects.length > 0) {
+        parts.push("\n**Technical Effects:**");
+        parts.push(formatBulletList(data.technical_effects.map(String)));
+      }
+
+      if (data.prior_art_gap) {
+        parts.push(`\n**Gap in Prior Art:** ${data.prior_art_gap}`);
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  patent_competitor: {
+    heading: "Competitor Analysis",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.assignees) && data.assignees.length > 0) {
+        parts.push("**Key Patent Holders:**");
+        parts.push(formatBulletList(data.assignees.map(String)));
+      }
+
+      if (Array.isArray(data.recent_filings) && data.recent_filings.length > 0) {
+        parts.push("\n**Recent Filing Activity:**");
+        parts.push(formatBulletList(data.recent_filings.map(String)));
+      }
+
+      if (Array.isArray(data.key_patents) && data.key_patents.length > 0) {
+        parts.push("\n**Most Cited Patents:**");
+        parts.push(formatBulletList(data.key_patents.map(String)));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  patent_limitation: {
+    heading: "Claim Limitations",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.claim_elements) && data.claim_elements.length > 0) {
+        parts.push("**Claim Elements:**");
+        parts.push(formatBulletList(data.claim_elements.map(String)));
+      }
+
+      if (Array.isArray(data.limitations) && data.limitations.length > 0) {
+        parts.push("\n**Technical Limitations:**");
+        parts.push(formatBulletList(data.limitations.map(String)));
+      }
+
+      if (data.parameters && typeof data.parameters === "object") {
+        parts.push("\n**Parameter Ranges:**");
+        for (const [param, value] of Object.entries(data.parameters as Record<string, unknown>)) {
+          parts.push(`- ${param}: ${value}`);
+        }
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+
+  // Web query section templates
+  web_academic: {
+    heading: "Academic Research",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.papers) && data.papers.length > 0) {
+        parts.push("**Academic Publications:**");
+        parts.push(formatBulletList(data.papers.map(String)));
+      }
+
+      if (Array.isArray(data.authors) && data.authors.length > 0) {
+        parts.push("\n**Key Researchers:** " + data.authors.join(", "));
+      }
+
+      if (Array.isArray(data.institutions) && data.institutions.length > 0) {
+        parts.push("\n**Research Institutions:** " + data.institutions.join(", "));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  web_vendor: {
+    heading: "Commercial Implementations",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.products) && data.products.length > 0) {
+        parts.push("**Commercial Products:**");
+        parts.push(formatBulletList(data.products.map(String)));
+      }
+
+      if (Array.isArray(data.vendors) && data.vendors.length > 0) {
+        parts.push("\n**Vendors:** " + data.vendors.join(", "));
+      }
+
+      if (data.availability) {
+        parts.push(`\n**Market Availability:** ${data.availability}`);
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  web_opensource: {
+    heading: "Open Source Implementations",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.repositories) && data.repositories.length > 0) {
+        parts.push("**Repositories:**");
+        parts.push(formatBulletList(data.repositories.map(String)));
+      }
+
+      if (Array.isArray(data.implementations) && data.implementations.length > 0) {
+        parts.push("\n**Implementations:**");
+        parts.push(formatBulletList(data.implementations.map(String)));
+      }
+
+      if (Array.isArray(data.licenses) && data.licenses.length > 0) {
+        parts.push("\n**Licenses:** " + data.licenses.join(", "));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+  web_conference: {
+    heading: "Conference Papers",
+    level: 2,
+    formatter: (data, citations) => {
+      const parts: string[] = [];
+
+      if (Array.isArray(data.papers) && data.papers.length > 0) {
+        parts.push("**Papers:**");
+        parts.push(formatBulletList(data.papers.map(String)));
+      }
+
+      if (Array.isArray(data.conferences) && data.conferences.length > 0) {
+        parts.push("\n**Conferences:** " + data.conferences.join(", "));
+      }
+
+      if (Array.isArray(data.preprints) && data.preprints.length > 0) {
+        parts.push("\n**Preprints:**");
+        parts.push(formatBulletList(data.preprints.map(String)));
+      }
+
+      if (citations.length > 0) {
+        parts.push(`\n${formatInlineCitations(citations)}`);
+      }
+
+      return parts.join("\n");
+    },
+  },
+};
+
+/**
+ * Format inline citation references
+ */
+function formatInlineCitations(citations: Citation[]): string {
+  if (citations.length === 0) return "";
+  return citations.map((c) => `[${c.id}]`).join(", ");
+}
+
+/**
+ * Build a report section from a query result
+ */
+function buildSection(
+  plan: PlanOutput,
+  result: RawResult
+): ReportSection | null {
+  // Find the query in the plan
+  const query = plan.queries.find((q) => q.query_id === result.query_id);
+  if (!query) return null;
+
+  // Skip failed queries
+  if (!result.success || !result.data) return null;
+
+  // Get template for query type
+  const template = SECTION_TEMPLATES[query.query_type];
+  if (!template) {
+    // Fallback for unknown types
+    return {
+      heading: query.query_text,
+      level: 2,
+      content: JSON.stringify(result.data, null, 2),
+      citations_used: result.sources?.map((s) => s.id) ?? [],
+    };
+  }
+
+  const content = template.formatter(
+    result.data as Record<string, unknown>,
+    result.sources ?? []
+  );
+
+  return {
+    heading: template.heading,
+    level: template.level,
+    content,
+    citations_used: result.sources?.map((s) => s.id) ?? [],
+  };
+}
+
+/**
+ * Generate executive summary from sections
+ */
+function generateExecutiveSummary(
+  topic: string,
+  sections: ReportSection[],
+  stats: { succeeded: number; failed: number }
+): string {
+  const parts: string[] = [];
+
+  parts.push(`This report presents research findings on **${topic}**.`);
+
+  if (stats.succeeded > 0) {
+    parts.push(`The analysis covers ${stats.succeeded} research queries across ${sections.length} sections.`);
+  }
+
+  if (stats.failed > 0) {
+    parts.push(`Note: ${stats.failed} queries could not be completed.`);
+  }
+
+  // Add brief description of each section
+  const sectionNames = sections.map((s) => s.heading).slice(0, 5);
+  if (sectionNames.length > 0) {
+    parts.push(`Key topics include: ${sectionNames.join(", ")}.`);
+  }
+
+  return parts.join(" ");
+}
+
+/**
+ * Build the full markdown report
+ */
+function buildMarkdownReport(
+  title: string,
+  summary: string,
+  sections: ReportSection[],
+  sources: Citation[],
+  includeSources: boolean,
+  includeMethodology: boolean,
+  citationStyle: "inline" | "footnote" | "endnote"
+): string {
+  const parts: string[] = [];
+
+  // Title
+  parts.push(`# ${title}`);
+  parts.push("");
+
+  // Executive Summary
+  parts.push("## Executive Summary");
+  parts.push("");
+  parts.push(summary);
+  parts.push("");
+
+  // Methodology (optional)
+  if (includeMethodology) {
+    parts.push("## Methodology");
+    parts.push("");
+    parts.push("This report was compiled using a sequential research approach:");
+    parts.push("1. Research queries were generated based on the topic and focus areas");
+    parts.push("2. Each query was executed to gather relevant information");
+    parts.push("3. Results were compiled and organized into thematic sections");
+    parts.push("4. Sources were consolidated and citations were verified");
+    parts.push("");
+  }
+
+  // Content sections
+  for (const section of sections) {
+    parts.push("#".repeat(section.level) + " " + section.heading);
+    parts.push("");
+    parts.push(section.content);
+    parts.push("");
+  }
+
+  // Sources
+  if (includeSources && sources.length > 0) {
+    parts.push(formatSourcesList(sources, citationStyle));
+  }
+
+  return parts.join("\n");
+}
+
+/**
+ * Check if this is a patent-focused research plan
+ */
+function isPatentFocused(plan: PlanOutput): boolean {
+  return plan.queries.some((q) =>
+    q.query_type.startsWith("patent_") || q.query_type.startsWith("web_")
+  );
+}
+
+/**
+ * Generate prior art clusters from sources
+ */
+function generatePriorArtClusters(
+  sources: Citation[],
+  _results: RawResult[],
+  _plan: PlanOutput
+): PriorArtCluster[] {
+  const clusters: PriorArtCluster[] = [];
+
+  // Group by source type
+  const patentSources = sources.filter((s) => s.source_type === "patent" || s.source_type === "document");
+  const webSources = sources.filter((s) => s.source_type === "web");
+  const academicSources = sources.filter((s) =>
+    s.url?.includes(".edu") || s.url?.includes("arxiv") || s.url?.includes("ieee")
+  );
+
+  if (patentSources.length > 0) {
+    clusters.push({
+      cluster_id: generateId("cluster"),
+      theme: "Patent Prior Art",
+      source_ids: patentSources.map((s) => s.id),
+      relevance: "high",
+      overlap_notes: `${patentSources.length} patent documents identified as potential prior art`,
+    });
+  }
+
+  if (academicSources.length > 0) {
+    clusters.push({
+      cluster_id: generateId("cluster"),
+      theme: "Academic Publications",
+      source_ids: academicSources.map((s) => s.id),
+      relevance: "medium",
+      overlap_notes: `${academicSources.length} academic sources may establish prior knowledge`,
+    });
+  }
+
+  const commercialSources = webSources.filter((s) =>
+    !s.url?.includes(".edu") && !s.url?.includes("arxiv") && !s.url?.includes("github")
+  );
+  if (commercialSources.length > 0) {
+    clusters.push({
+      cluster_id: generateId("cluster"),
+      theme: "Commercial Prior Art",
+      source_ids: commercialSources.map((s) => s.id),
+      relevance: "medium",
+      overlap_notes: `${commercialSources.length} commercial sources showing market implementation`,
+    });
+  }
+
+  const ossSources = webSources.filter((s) =>
+    s.url?.includes("github") || s.url?.includes("gitlab")
+  );
+  if (ossSources.length > 0) {
+    clusters.push({
+      cluster_id: generateId("cluster"),
+      theme: "Open Source Prior Art",
+      source_ids: ossSources.map((s) => s.id),
+      relevance: "low",
+      overlap_notes: `${ossSources.length} open source implementations may affect novelty`,
+    });
+  }
+
+  return clusters;
+}
+
+/**
+ * Generate claim risk flags based on results
+ */
+function generateClaimRiskFlags(
+  sources: Citation[],
+  results: RawResult[],
+  plan: PlanOutput
+): ClaimRiskFlag[] {
+  const risks: ClaimRiskFlag[] = [];
+
+  // Check for potential anticipation
+  const patentResults = results.filter((r) => {
+    const query = plan.queries.find((q) => q.query_id === r.query_id);
+    return query?.query_type.startsWith("patent_");
+  });
+
+  if (patentResults.length > 0) {
+    const patentCount = sources.filter((s) =>
+      s.source_type === "patent" || s.source_type === "document"
+    ).length;
+
+    if (patentCount > 5) {
+      risks.push({
+        risk_id: generateId("risk"),
+        severity: "high",
+        category: "anticipation",
+        description: `${patentCount} potentially relevant patents identified. Review each for anticipation of core claims.`,
+        blocking_sources: sources
+          .filter((s) => s.source_type === "patent" || s.source_type === "document")
+          .slice(0, 5)
+          .map((s) => s.id),
+        mitigation: "Conduct detailed claim-by-claim analysis against top 5 most relevant patents",
+      });
+    }
+  }
+
+  // Check for obviousness risk
+  const problemBenefitResults = results.filter((r) => {
+    const query = plan.queries.find((q) => q.query_id === r.query_id);
+    return query?.query_type === "patent_problem_benefit";
+  });
+
+  if (problemBenefitResults.length > 0 && sources.length > 3) {
+    risks.push({
+      risk_id: generateId("risk"),
+      severity: "medium",
+      category: "obviousness",
+      description: "Multiple sources address similar problems. Combination of references may render claims obvious.",
+      mitigation: "Identify unexpected results or synergistic effects to overcome obviousness",
+    });
+  }
+
+  // Check for academic prior art
+  const academicCount = sources.filter((s) =>
+    s.url?.includes(".edu") || s.url?.includes("arxiv") || s.url?.includes("ieee")
+  ).length;
+
+  if (academicCount > 3) {
+    risks.push({
+      risk_id: generateId("risk"),
+      severity: "medium",
+      category: "anticipation",
+      description: `${academicCount} academic publications found. Academic literature often predates patent filings.`,
+      blocking_sources: sources
+        .filter((s) => s.url?.includes(".edu") || s.url?.includes("arxiv"))
+        .slice(0, 3)
+        .map((s) => s.id),
+      mitigation: "Check publication dates against priority date; identify implementation-specific claims",
+    });
+  }
+
+  return risks;
+}
+
+/**
+ * Generate novelty gap suggestions
+ */
+function generateNoveltyGaps(
+  sources: Citation[],
+  results: RawResult[],
+  plan: PlanOutput
+): NoveltyGap[] {
+  const gaps: NoveltyGap[] = [];
+
+  // Look for limitation results
+  const limitationResults = results.filter((r) => {
+    const query = plan.queries.find((q) => q.query_id === r.query_id);
+    return query?.query_type === "patent_limitation";
+  });
+
+  if (limitationResults.length > 0) {
+    for (const result of limitationResults) {
+      if (!result.success || !result.data) continue;
+
+      const data = result.data as Record<string, unknown>;
+
+      // Suggest parameter-based differentiation
+      if (data.parameters && typeof data.parameters === "object") {
+        const params = Object.keys(data.parameters as Record<string, unknown>);
+        if (params.length > 0) {
+          gaps.push({
+            gap_id: generateId("gap"),
+            limitation_type: "parameter",
+            description: `Consider novel parameter ranges for: ${params.join(", ")}`,
+            confidence: "medium",
+            claim_language_suggestion: `wherein the ${params[0]} is in a range of [X] to [Y]`,
+          });
+        }
+      }
+
+      // Suggest structural differentiation
+      if (Array.isArray(data.claim_elements) && data.claim_elements.length > 0) {
+        gaps.push({
+          gap_id: generateId("gap"),
+          limitation_type: "structural",
+          description: "Consider adding structural limitations not found in prior art",
+          confidence: "medium",
+          claim_language_suggestion: "comprising a [novel component] configured to [novel function]",
+        });
+      }
+    }
+  }
+
+  // Look for problem-benefit gaps
+  const problemResults = results.filter((r) => {
+    const query = plan.queries.find((q) => q.query_id === r.query_id);
+    return query?.query_type === "patent_problem_benefit";
+  });
+
+  if (problemResults.length > 0) {
+    for (const result of problemResults) {
+      if (!result.success || !result.data) continue;
+
+      const data = result.data as Record<string, unknown>;
+
+      if (data.prior_art_gap) {
+        gaps.push({
+          gap_id: generateId("gap"),
+          limitation_type: "functional",
+          description: String(data.prior_art_gap),
+          confidence: "high",
+          claim_language_suggestion: "wherein [component] is configured to [address identified gap]",
+        });
+      }
+    }
+  }
+
+  // Suggest combination novelty if multiple sources
+  if (sources.length > 5) {
+    gaps.push({
+      gap_id: generateId("gap"),
+      limitation_type: "combination",
+      description: "Consider claiming novel combination of known elements that produces unexpected result",
+      confidence: "low",
+      claim_language_suggestion: "A system comprising [element A] and [element B] configured to cooperatively [produce unexpected result]",
+    });
+  }
+
+  return gaps;
+}
+
+/**
+ * Build patent analysis section for markdown report
+ */
+function buildPatentAnalysisSection(
+  clusters: PriorArtCluster[],
+  risks: ClaimRiskFlag[],
+  gaps: NoveltyGap[]
+): string {
+  const parts: string[] = [];
+
+  if (clusters.length > 0 || risks.length > 0 || gaps.length > 0) {
+    parts.push("## Patent Analysis");
+    parts.push("");
+  }
+
+  if (clusters.length > 0) {
+    parts.push("### Prior Art Clusters");
+    parts.push("");
+    for (const cluster of clusters) {
+      parts.push(`**${cluster.theme}** (${cluster.relevance} relevance)`);
+      parts.push(`- Sources: ${cluster.source_ids.join(", ")}`);
+      if (cluster.overlap_notes) {
+        parts.push(`- ${cluster.overlap_notes}`);
+      }
+      parts.push("");
+    }
+  }
+
+  if (risks.length > 0) {
+    parts.push("### Claim Risk Flags");
+    parts.push("");
+    for (const risk of risks) {
+      const severityIcon = risk.severity === "critical" ? "!!!" :
+                          risk.severity === "high" ? "!!" : "!";
+      parts.push(`**${severityIcon} ${risk.category.toUpperCase()}** (${risk.severity})`);
+      parts.push(`- ${risk.description}`);
+      if (risk.blocking_sources && risk.blocking_sources.length > 0) {
+        parts.push(`- Blocking sources: ${risk.blocking_sources.join(", ")}`);
+      }
+      if (risk.mitigation) {
+        parts.push(`- Mitigation: ${risk.mitigation}`);
+      }
+      parts.push("");
+    }
+  }
+
+  if (gaps.length > 0) {
+    parts.push("### Novelty Gap Suggestions");
+    parts.push("");
+    for (const gap of gaps) {
+      parts.push(`**${gap.limitation_type.toUpperCase()}** (${gap.confidence} confidence)`);
+      parts.push(`- ${gap.description}`);
+      if (gap.claim_language_suggestion) {
+        parts.push(`- Suggested claim language: \`${gap.claim_language_suggestion}\``);
+      }
+      parts.push("");
+    }
+  }
+
+  return parts.join("\n");
+}
+
+/**
+ * Main compile function
+ */
+export function compileReport(input: CompileInput): CompileOutput {
+  const reportId = generateId("report");
+  const warnings: string[] = [];
+  const patentFocused = isPatentFocused(input.plan);
+
+  // Collect all sources
+  const allSources: Citation[] = [];
+  for (const result of input.raw_results) {
+    if (result.sources) {
+      allSources.push(...result.sources);
+    }
+  }
+
+  // Deduplicate and optionally renumber
+  const dedupedSources = deduplicateCitations(allSources);
+  const { citations: finalSources, mapping } = renumberCitations(dedupedSources);
+
+  // Build sections
+  const sections: ReportSection[] = [];
+  let queriesSucceeded = 0;
+  let queriesFailed = 0;
+
+  for (const result of input.raw_results) {
+    if (result.success) {
+      queriesSucceeded++;
+      const section = buildSection(input.plan, result);
+      if (section) {
+        // Apply citation renumbering
+        section.content = applyCitationMapping(section.content, mapping);
+        section.citations_used = section.citations_used.map((id) => mapping.get(id) ?? id);
+        sections.push(section);
+      }
+    } else {
+      queriesFailed++;
+      if (result.error) {
+        warnings.push(`Query ${result.query_id} failed: ${result.error}`);
+      }
+    }
+  }
+
+  // Generate patent analysis if patent-focused
+  let priorArtClusters: PriorArtCluster[] | undefined;
+  let claimRiskFlags: ClaimRiskFlag[] | undefined;
+  let noveltyGaps: NoveltyGap[] | undefined;
+  let patentAnalysisSection = "";
+
+  if (patentFocused) {
+    priorArtClusters = generatePriorArtClusters(finalSources, input.raw_results, input.plan);
+    claimRiskFlags = generateClaimRiskFlags(finalSources, input.raw_results, input.plan);
+    noveltyGaps = generateNoveltyGaps(finalSources, input.raw_results, input.plan);
+    patentAnalysisSection = buildPatentAnalysisSection(priorArtClusters, claimRiskFlags, noveltyGaps);
+  }
+
+  // Generate title
+  const title = `Research Report: ${input.plan.topic}`;
+
+  // Generate executive summary
+  const executiveSummary = generateExecutiveSummary(
+    input.plan.topic,
+    sections,
+    { succeeded: queriesSucceeded, failed: queriesFailed }
+  );
+
+  // Build full markdown report
+  let markdownReport = buildMarkdownReport(
+    title,
+    executiveSummary,
+    sections,
+    finalSources,
+    input.include_sources ?? true,
+    input.include_methodology ?? false,
+    input.citation_style ?? "inline"
+  );
+
+  // Append patent analysis section if present
+  if (patentAnalysisSection) {
+    // Insert before sources section
+    const sourcesIndex = markdownReport.lastIndexOf("---\n\n### References");
+    if (sourcesIndex > 0) {
+      markdownReport = markdownReport.slice(0, sourcesIndex) +
+        patentAnalysisSection + "\n" +
+        markdownReport.slice(sourcesIndex);
+    } else {
+      markdownReport += "\n" + patentAnalysisSection;
+    }
+  }
+
+  // Calculate statistics
+  const wordCount = countWords(markdownReport);
+  const patentSourceCount = finalSources.filter((s) =>
+    s.source_type === "patent" || s.source_type === "document"
+  ).length;
+  const webSourceCount = finalSources.filter((s) => s.source_type === "web").length;
+
+  return {
+    report_id: reportId,
+    plan_id: input.plan.plan_id,
+    title,
+    compiled_at: isoNow(),
+    executive_summary: executiveSummary,
+    sections,
+    markdown_report: markdownReport,
+    sources: finalSources,
+    statistics: {
+      queries_executed: input.raw_results.length,
+      queries_succeeded: queriesSucceeded,
+      queries_failed: queriesFailed,
+      total_sources: finalSources.length,
+      word_count: wordCount,
+      patent_sources: patentSourceCount > 0 ? patentSourceCount : undefined,
+      web_sources: webSourceCount > 0 ? webSourceCount : undefined,
+    },
+    prior_art_clusters: priorArtClusters && priorArtClusters.length > 0 ? priorArtClusters : undefined,
+    claim_risk_flags: claimRiskFlags && claimRiskFlags.length > 0 ? claimRiskFlags : undefined,
+    novelty_gaps: noveltyGaps && noveltyGaps.length > 0 ? noveltyGaps : undefined,
+    warnings: warnings.length > 0 ? warnings : undefined,
+  };
+}