@reftrixmcp/mcp-server 0.1.7

package/src/services/page/section-postprocessor.service.ts

@@ -0,0 +1,874 @@
+// SPDX-FileCopyrightText: 2025-2026 Reftrix Contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
+/**
+ * Section Merge Post-Processor
+ *
+ * JSDOM ベースのセクション検出で発生する過剰分割を、ルールベースのポストプロセッサで修正する。
+ * Phase 1 (Layout Analysis) 内、mergeVisionDetectedSections() 後、DB保存前に実行される。
+ *
+ * Fixes over-segmentation from JSDOM-based section detection via rule-based post-processing.
+ * Runs in Phase 1 (Layout Analysis) after mergeVisionDetectedSections(), before DB save.
+ *
+ * ルール（実行順序） / Rules (execution order):
+ * - Rule 4: 巨大セクション再分割（height > 10,000px → 3戦略で再分割）
+ *           Large section split (height > 10,000px → split via 3 strategies)
+ * - Rule 1: 同一タイプ連続マージ（3+連続の同一タイプセクション → 1つに統合）
+ *           Consecutive same-type merge (3+ consecutive same-type sections → 1)
+ * - Rule 3: 同名隣接マージ（同一タイプ+同名の2+連続セクション → 1つに統合）
+ *           Same-heading adjacent merge (same type + same heading, 2+ consecutive → 1)
+ * - Rule 2: コンテンツ空セクション吸収（heading無し+textContent<20文字 → 隣接に吸収）
+ *           Empty-content section absorption (no heading + textContent<20 chars → absorb into neighbor)
+ *
+ * PII: PII分類はPhase 5で実施。このフェーズではPIIフィルタリング不要。
+ * PII: PII classification is performed in Phase 5. No PII filtering needed in this phase.
+ *
+ * @module services/page/section-postprocessor
+ */
+
+import { isDevelopment, logger } from "../../utils/logger";
+
+// =====================================================
+// 定数 / Constants
+// =====================================================
+
+/**
+ * 同一タイプ連続マージの最小連続数
+ * Minimum consecutive count for same-type merge
+ */
+const MIN_CONSECUTIVE_COUNT = 3;
+
+/**
+ * マージ対象のセクションタイプ（構造的に繰り返しが多いタイプ）
+ * navigation/hero/footer は個別に意味があるためマージ対象外
+ * cta はv0.1.8でマージ対象に変更（3+連続CTAの過剰分割が実データで確認されたため）
+ *
+ * Section types eligible for merge (types that commonly repeat structurally).
+ * navigation/hero/footer are excluded as they have individual significance.
+ * cta was added in v0.1.8 (3+ consecutive CTA over-segmentation confirmed in production data).
+ */
+const MERGEABLE_TYPES = new Set([
+  "unknown",
+  "feature",
+  "testimonial",
+  "gallery",
+  "partners",
+  "portfolio",
+  "team",
+  "stories",
+  "stats",
+  "faq",
+  "cta",
+]);
+
+/**
+ * 同名隣接マージの最小連続数（Rule 3用）
+ * Minimum consecutive count for same-heading adjacent merge (Rule 3)
+ */
+const MIN_SAME_HEADING_COUNT = 2;
+
+/**
+ * textContent空判定の閾値（文字数）
+ * Threshold for textContent empty detection (character count)
+ */
+const TEXT_CONTENT_EMPTY_THRESHOLD = 20;
+
+/**
+ * 入力セクション数の安全上限
+ * Maximum input section count safety limit
+ */
+const MAX_INPUT_SECTIONS = 500;
+
+/**
+ * 巨大セクション再分割閾値（px）
+ * Large section split threshold (px)
+ *
+ * TDA MEDIUM-4: 10,000px は DINOv2 ViT-B/14 の入力解像度 224x224 に対して
+ * アスペクト比が極端になり visual embedding 品質が劣化する閾値。
+ * 一般的なビューポート高さ（900px）の約11倍に相当し、
+ * 実データ（supabase.com等）で 10,000px 超セクションの embedding 類似度低下が確認されたため設定。
+ *
+ * TDA MEDIUM-4: 10,000px is the threshold where aspect ratio becomes extreme
+ * relative to DINOv2 ViT-B/14 input resolution (224x224), degrading visual embedding quality.
+ * Equals ~11x typical viewport height (900px). Confirmed embedding similarity degradation
+ * for sections exceeding 10,000px in production data (e.g., supabase.com).
+ */
+const MAX_SECTION_HEIGHT = 10_000;
+
+/**
+ * 分割後の最小高さ（px）
+ * Minimum height after split (px)
+ */
+const MIN_SPLIT_SECTION_HEIGHT = 1_000;
+
+/**
+ * 1セクションからの最大分割数
+ * Maximum splits per section
+ */
+const MAX_SPLIT_COUNT = 20;
+
+/**
+ * 巨大セクション再分割の Feature flag（ランタイム評価）
+ * Feature flag for large section split (runtime evaluation)
+ */
+function isSectionSplitEnabled(): boolean {
+  return process.env["ENABLE_SECTION_SPLIT_POSTPROCESSOR"] !== "false";
+}
+
+// =====================================================
+// 型定義 / Types
+// =====================================================
+
+/**
+ * ポストプロセッサが処理するセクションの最小型
+ * Minimum section type processed by the post-processor
+ */
+export interface PostProcessableSection {
+  id: string;
+  type: string;
+  positionIndex: number;
+  heading?: string;
+  confidence: number;
+  htmlSnippet?: string;
+  position?: { startY: number; endY: number; height: number };
+}
+
+/**
+ * ポストプロセッサの結果統計
+ * Post-processor result statistics
+ */
+export interface PostProcessResult {
+  sections: PostProcessableSection[];
+  stats: {
+    inputCount: number;
+    outputCount: number;
+    mergedGroups: number;
+    sameHeadingMergedCount: number;
+    absorbedCount: number;
+    /** Rule 4 で再分割された元セクション数 / Number of original sections split by Rule 4 */
+    splitCount: number;
+    /** Rule 4 で生成された分割セクション数 / Number of split sections generated by Rule 4 */
+    splitSectionsGenerated: number;
+  };
+}
+
+// =====================================================
+// Rule 4: 巨大セクション再分割 / Large Section Split
+// =====================================================
+
+/**
+ * HTML子セクションの分割点を検出する正規表現
+ * Regex to detect split points from HTML child elements
+ *
+ * SEC-07: この正規表現は分割点検出のみに使用。出力・サニタイズには使用しない。
+ * SEC-07: This regex is used for split point detection only. Not used for output or sanitization.
+ */
+const SPLIT_POINT_REGEX = /<(?:section|article|h[1-3])[\s>]/gi;
+
+/**
+ * 巨大セクション（height > MAX_SECTION_HEIGHT）を再分割する
+ * Splits oversized sections (height > MAX_SECTION_HEIGHT) into smaller ones
+ *
+ * 3戦略 / 3 strategies:
+ * - 戦略A: HTML子セクション検出（section/article/h1-h3 タグ） / Strategy A: HTML child detection
+ * - 戦略B: 等分割フォールバック / Strategy B: Equal division fallback
+ * - 戦略C: 分割しない（Graceful Degradation） / Strategy C: No split (Graceful Degradation)
+ *
+ * @param sections - 入力セクション配列 / Input section array
+ * @returns 分割後のセクション配列、分割統計、分割されたセクションIDのSet
+ *          Split sections, split statistics, and Set of split section IDs
+ */
+function splitOversizedSections(sections: PostProcessableSection[]): {
+  sections: PostProcessableSection[];
+  splitCount: number;
+  splitSectionsGenerated: number;
+  splitSectionIds: Set<string>;
+} {
+  if (!isSectionSplitEnabled()) {
+    return { sections, splitCount: 0, splitSectionsGenerated: 0, splitSectionIds: new Set() };
+  }
+
+  const result: PostProcessableSection[] = [];
+  let splitCount = 0;
+  let splitSectionsGenerated = 0;
+  const splitSectionIds = new Set<string>();
+
+  for (const section of sections) {
+    const height = section.position?.height;
+
+    // 分割不要: position無し、高さ未超過、または NaN/Infinity
+    // No split needed: no position, height within limit, or NaN/Infinity
+    if (!section.position || !height || height <= MAX_SECTION_HEIGHT || !Number.isFinite(height)) {
+      result.push(section);
+      continue;
+    }
+
+    // 戦略A: HTML子セクション検出 / Strategy A: HTML child detection
+    const strategySplits = trySplitByHtml(section);
+    if (strategySplits) {
+      for (const s of strategySplits) {
+        splitSectionIds.add(s.id);
+      }
+      result.push(...strategySplits);
+      splitCount++;
+      splitSectionsGenerated += strategySplits.length;
+      continue;
+    }
+
+    // 戦略B: 等分割フォールバック / Strategy B: Equal division fallback
+    const equalSplits = trySplitEqually(section);
+    if (equalSplits) {
+      for (const s of equalSplits) {
+        splitSectionIds.add(s.id);
+      }
+      result.push(...equalSplits);
+      splitCount++;
+      splitSectionsGenerated += equalSplits.length;
+      continue;
+    }
+
+    // 戦略C: 分割しない（Graceful Degradation） / Strategy C: No split
+    result.push(section);
+  }
+
+  return { sections: result, splitCount, splitSectionsGenerated, splitSectionIds };
+}
+
+/**
+ * 戦略A: HTML子セクション（section/article/h1-h3）を分割点として使用
+ * Strategy A: Use HTML child sections (section/article/h1-h3) as split points
+ *
+ * SEC-07: HTML解析は分割点検出のみに使用。出力・サニタイズには使用しない。
+ * SEC-07: HTML parsing is used for split point detection only. Not used for output or sanitization.
+ *
+ * @returns 分割セクション配列、または分割不可能な場合はnull / Split sections or null if not splittable
+ */
+function trySplitByHtml(section: PostProcessableSection): PostProcessableSection[] | null {
+  if (!section.htmlSnippet || !section.position) {
+    return null;
+  }
+
+  // SEC-07: HTML解析は分割点検出のみに使用。出力には使用しない。
+  // SEC-07: HTML parsing for split point detection only. Not used for output.
+  const matches: number[] = [];
+  let match: RegExpExecArray | null;
+  const regex = new RegExp(SPLIT_POINT_REGEX.source, "gi");
+  while ((match = regex.exec(section.htmlSnippet)) !== null) {
+    matches.push(match.index);
+  }
+
+  // 2つ以上の分割点が必要（最初の1つはセクション自体の開始点と重なる可能性）
+  // Need 2+ split points (first one may overlap with section start)
+  if (matches.length < 2) {
+    return null;
+  }
+
+  // 分割数の制限 / Limit split count
+  const splitCount = Math.min(matches.length, MAX_SPLIT_COUNT);
+
+  // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
+  if (!Number.isFinite(splitCount) || splitCount <= 0) {
+    return null;
+  }
+
+  // 各分割点を元にセクションの高さを按分
+  // Distribute section height proportionally based on split points
+  const totalLength = section.htmlSnippet.length;
+  const splitPositions = matches.slice(0, splitCount);
+  const { startY, height } = section.position;
+
+  const splits: PostProcessableSection[] = [];
+  for (let i = 0; i < splitPositions.length; i++) {
+    const ratioStart = splitPositions[i]! / totalLength;
+    const ratioEnd = i + 1 < splitPositions.length ? splitPositions[i + 1]! / totalLength : 1;
+
+    const splitStartY = startY + height * ratioStart;
+    const splitEndY = startY + height * ratioEnd;
+    const splitHeight = splitEndY - splitStartY;
+
+    // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
+    if (
+      !Number.isFinite(splitStartY) ||
+      !Number.isFinite(splitEndY) ||
+      !Number.isFinite(splitHeight)
+    ) {
+      continue;
+    }
+
+    // 最小高さチェック / Minimum height check
+    if (splitHeight < MIN_SPLIT_SECTION_HEIGHT) {
+      continue;
+    }
+
+    splits.push({
+      ...section,
+      id: `${section.id}-split-${i}`,
+      positionIndex: section.positionIndex + i,
+      position: {
+        startY: splitStartY,
+        endY: splitEndY,
+        height: splitHeight,
+      },
+    });
+  }
+
+  // 分割結果が2つ未満なら戦略Aは失敗 / Strategy A fails if less than 2 splits
+  if (splits.length < 2) {
+    return null;
+  }
+
+  return splits;
+}
+
+/**
+ * 戦略B: 等分割フォールバック
+ * Strategy B: Equal division fallback
+ *
+ * @returns 分割セクション配列、または分割不可能な場合はnull / Split sections or null if not splittable
+ */
+function trySplitEqually(section: PostProcessableSection): PostProcessableSection[] | null {
+  if (!section.position) {
+    return null;
+  }
+
+  const { startY, height } = section.position;
+
+  // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
+  const rawSplitCount = Math.ceil(height / MAX_SECTION_HEIGHT);
+  if (!Number.isFinite(rawSplitCount) || rawSplitCount <= 0) {
+    return null;
+  }
+
+  const splitCount = Math.min(rawSplitCount, MAX_SPLIT_COUNT);
+  const splitHeight = height / splitCount;
+
+  // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
+  if (!Number.isFinite(splitHeight) || splitHeight <= 0) {
+    return null;
+  }
+
+  // 分割後が最小高さ未満なら戦略Cへ / Fall through to Strategy C if below minimum height
+  if (splitHeight < MIN_SPLIT_SECTION_HEIGHT) {
+    return null;
+  }
+
+  const splits: PostProcessableSection[] = [];
+  for (let i = 0; i < splitCount; i++) {
+    const splitStartY = startY + splitHeight * i;
+    const splitEndY =
+      i === splitCount - 1
+        ? startY + height // 最後の分割は元の endY を使用 / Last split uses original endY
+        : startY + splitHeight * (i + 1);
+    const actualHeight = splitEndY - splitStartY;
+
+    // SEC-08: NaN/Infinity防御 / SEC-08: NaN/Infinity defense
+    if (
+      !Number.isFinite(splitStartY) ||
+      !Number.isFinite(splitEndY) ||
+      !Number.isFinite(actualHeight)
+    ) {
+      continue;
+    }
+
+    splits.push({
+      ...section,
+      id: `${section.id}-split-${i}`,
+      positionIndex: section.positionIndex + i,
+      position: {
+        startY: splitStartY,
+        endY: splitEndY,
+        height: actualHeight,
+      },
+    });
+  }
+
+  if (splits.length < 2) {
+    return null;
+  }
+
+  return splits;
+}
+
+// =====================================================
+// Rule 1: 同一タイプ連続マージ / Consecutive Same-Type Merge
+// =====================================================
+
+/**
+ * 同一タイプが3つ以上連続するセクションを1つにマージする
+ * Merges 3+ consecutive sections of the same type into one
+ *
+ * TDA MEDIUM-5: excludeIds に含まれるセクションIDはマージ対象から除外する。
+ * Rule 4 で分割されたセクションが Rule 1 で再マージされることを防止する。
+ *
+ * TDA MEDIUM-5: Section IDs in excludeIds are excluded from merge candidates.
+ * Prevents Rule 4 split sections from being re-merged by Rule 1.
+ *
+ * @param sections - 入力セクション配列 / Input section array
+ * @param excludeIds - マージ対象外のセクションIDセット / Section IDs excluded from merging
+ * @returns マージ後のセクション配列とマージ数 / Merged sections and merge count
+ */
+function mergeConsecutiveSameType(
+  sections: PostProcessableSection[],
+  excludeIds: Set<string> = new Set()
+): { sections: PostProcessableSection[]; mergedGroups: number } {
+  if (sections.length < MIN_CONSECUTIVE_COUNT) {
+    return { sections, mergedGroups: 0 };
+  }
+
+  const result: PostProcessableSection[] = [];
+  let mergedGroups = 0;
+  let i = 0;
+
+  while (i < sections.length) {
+    const current = sections[i]!;
+
+    // マージ対象外タイプはそのまま保持
+    // Non-mergeable types are kept as-is
+    if (!MERGEABLE_TYPES.has(current.type)) {
+      result.push(current);
+      i++;
+      continue;
+    }
+
+    // TDA MEDIUM-5: Rule 4分割セクションはマージ対象外
+    // TDA MEDIUM-5: Rule 4 split sections are excluded from merging
+    if (excludeIds.has(current.id)) {
+      result.push(current);
+      i++;
+      continue;
+    }
+
+    // 同一タイプの連続セクションを収集（excludeIds除外）
+    // Collect consecutive sections of the same type (excluding excludeIds)
+    const group: PostProcessableSection[] = [current];
+    let j = i + 1;
+    while (
+      j < sections.length &&
+      sections[j]!.type === current.type &&
+      !excludeIds.has(sections[j]!.id)
+    ) {
+      group.push(sections[j]!);
+      j++;
+    }
+
+    if (group.length >= MIN_CONSECUTIVE_COUNT) {
+      // マージ: 先頭セクションをベースに統合
+      // Merge: use first section as base
+      const merged = mergeGroup(group);
+      result.push(merged);
+      mergedGroups++;
+    } else {
+      // 閾値未満はそのまま保持
+      // Below threshold: keep as-is
+      result.push(...group);
+    }
+
+    i = j;
+  }
+
+  return { sections: result, mergedGroups };
+}
+
+/**
+ * セクショングループを1つに統合
+ * Merge a group of sections into one
+ *
+ * @param group - マージ対象のセクション群（3+件） / Sections to merge (3+)
+ * @returns マージ後のセクション / Merged section
+ */
+function mergeGroup(group: PostProcessableSection[]): PostProcessableSection {
+  const first = group[0]!;
+
+  // position再計算（NaN/Infinity防御付き）
+  // Recalculate position with NaN/Infinity defense
+  let mergedPosition = first.position;
+  if (group.some((s) => s.position)) {
+    const positions = group.filter((s) => s.position).map((s) => s.position!);
+    const newStartY = Math.min(...positions.map((p) => p.startY));
+    const newEndY = Math.max(...positions.map((p) => p.endY));
+    const newHeight = newEndY - newStartY;
+
+    if (Number.isFinite(newStartY) && Number.isFinite(newEndY) && Number.isFinite(newHeight)) {
+      mergedPosition = { startY: newStartY, endY: newEndY, height: newHeight };
+    } else {
+      logger.warn(
+        "[section-postprocessor] Invalid position after merge, using first section position",
+        {
+          groupSize: group.length,
+        }
+      );
+      mergedPosition = first.position;
+    }
+  }
+
+  // heading: 最初の非nullなheadingを使用
+  // heading: use first non-null heading
+  const headingSection = group.find((s) => s.heading);
+
+  // confidence: グループ内の最大値
+  // confidence: max in group
+  const confidence = Math.max(...group.map((s) => s.confidence));
+
+  // 先頭セクションをベースにマージ結果を構築（追加プロパティ保持のためスプレッド）
+  // Build merged result from first section as base (spread to preserve additional properties)
+  // htmlSnippet: 先頭セクションのみ保持（SEC監査: XSSリスク回避のため単純結合しない）
+  // htmlSnippet: keep only first section's snippet (SEC audit: avoid XSS risk from concatenation)
+  // スプレッドベースでマージ結果を構築
+  // Build via spread, then conditionally set optional fields
+  const merged: PostProcessableSection = {
+    ...first,
+    confidence: Number.isFinite(confidence) ? confidence : first.confidence,
+  };
+
+  if (mergedPosition) {
+    merged.position = mergedPosition;
+  }
+
+  if (headingSection?.heading) {
+    merged.heading = headingSection.heading;
+  }
+
+  return merged;
+}
+
+// =====================================================
+// Rule 3: 同名隣接マージ / Same-Heading Adjacent Merge
+// =====================================================
+
+/**
+ * 同一タイプかつ同名の2+連続セクションを1つにマージする
+ * Merges 2+ consecutive sections with same type and same heading
+ *
+ * SEC: heading=null/undefined/空文字列同士はマージ対象外
+ * SEC: null/undefined/empty string headings are NOT treated as matching
+ *
+ * @param sections - 入力セクション配列 / Input section array
+ * @returns マージ後のセクション配列とマージ数 / Merged sections and merge count
+ */
+function mergeConsecutiveSameHeading(
+  sections: PostProcessableSection[],
+  excludeIds: Set<string> = new Set()
+): { sections: PostProcessableSection[]; sameHeadingMergedCount: number } {
+  if (sections.length < MIN_SAME_HEADING_COUNT) {
+    return { sections, sameHeadingMergedCount: 0 };
+  }
+
+  const result: PostProcessableSection[] = [];
+  let sameHeadingMergedCount = 0;
+  let i = 0;
+
+  while (i < sections.length) {
+    const current = sections[i]!;
+
+    // heading無し、またはMERGEABLE_TYPES外はスキップ
+    // Skip if no heading or non-mergeable type
+    if (!current.heading || !MERGEABLE_TYPES.has(current.type)) {
+      result.push(current);
+      i++;
+      continue;
+    }
+
+    // Rule 4分割セクションはマージ対象外
+    // Rule 4 split sections are excluded from merging
+    if (excludeIds.has(current.id)) {
+      result.push(current);
+      i++;
+      continue;
+    }
+
+    // 同一タイプ+同名の連続セクションを収集（excludeIds除外）
+    // Collect consecutive sections with same type and same heading (excluding excludeIds)
+    const group: PostProcessableSection[] = [current];
+    let j = i + 1;
+    while (
+      j < sections.length &&
+      sections[j]!.type === current.type &&
+      sections[j]!.heading === current.heading &&
+      !excludeIds.has(sections[j]!.id)
+    ) {
+      group.push(sections[j]!);
+      j++;
+    }
+
+    if (group.length >= MIN_SAME_HEADING_COUNT) {
+      const merged = mergeGroup(group);
+      result.push(merged);
+      sameHeadingMergedCount++;
+    } else {
+      result.push(...group);
+    }
+
+    i = j;
+  }
+
+  return { sections: result, sameHeadingMergedCount };
+}
+
+// =====================================================
+// Rule 2: コンテンツ空セクション吸収 / Empty Content Absorption
+// =====================================================
+
+/**
+ * コンテンツが空のセクションを隣接セクションに吸収する
+ * Absorbs empty-content sections into neighboring sections
+ *
+ * 空の判定: heading無し、htmlSnippetが無いか極小（<50文字）
+ * Empty criteria: no heading, no htmlSnippet or very small (<50 chars)
+ *
+ * @param sections - 入力セクション配列 / Input section array
+ * @returns 吸収後のセクション配列と吸収数 / Absorbed sections and count
+ */
+function absorbEmptyContentSections(sections: PostProcessableSection[]): {
+  sections: PostProcessableSection[];
+  absorbedCount: number;
+} {
+  if (sections.length <= 1) {
+    return { sections, absorbedCount: 0 };
+  }
+
+  const keep: boolean[] = new Array(sections.length).fill(true);
+  let absorbedCount = 0;
+
+  for (let i = 0; i < sections.length; i++) {
+    const section = sections[i]!;
+
+    // 空でないセクションは保持
+    // Keep non-empty sections
+    if (!isEmptyContent(section)) {
+      continue;
+    }
+
+    // 明確なタイプを持つセクションは保持（unknownのみ吸収対象）
+    // Keep sections with definite types (only unknown is eligible for absorption)
+    if (section.type !== "unknown") {
+      continue;
+    }
+
+    // 前のセクションに吸収（前がなければ次に吸収）
+    // Absorb into previous section (or next if no previous)
+    const prevIdx = findPrevKept(keep, i);
+    const nextIdx = findNextKept(keep, i, sections.length);
+
+    if (prevIdx !== -1) {
+      const prev = sections[prevIdx]!;
+      if (prev.position && section.position) {
+        // 前のセクションの範囲を拡張
+        // Extend previous section's range
+        const newEndY = Math.max(prev.position.endY, section.position.endY);
+        const newHeight = newEndY - prev.position.startY;
+
+        if (Number.isFinite(newEndY) && Number.isFinite(newHeight)) {
+          prev.position = {
+            startY: prev.position.startY,
+            endY: newEndY,
+            height: newHeight,
+          };
+        }
+
+        keep[i] = false;
+        absorbedCount++;
+      }
+    } else if (nextIdx !== -1) {
+      const next = sections[nextIdx]!;
+      if (next.position && section.position) {
+        // 次のセクションの範囲を拡張
+        // Extend next section's range
+        const newStartY = Math.min(next.position.startY, section.position.startY);
+        const newHeight = next.position.endY - newStartY;
+
+        if (Number.isFinite(newStartY) && Number.isFinite(newHeight)) {
+          next.position = {
+            startY: newStartY,
+            endY: next.position.endY,
+            height: newHeight,
+          };
+        }
+
+        keep[i] = false;
+        absorbedCount++;
+      }
+    }
+    // 前後とも無い場合はそのまま保持
+    // Keep if no neighbors available
+  }
+
+  const result = sections.filter((_, i) => keep[i]);
+  return { sections: result, absorbedCount };
+}
+
+/**
+ * セクションのコンテンツが空かどうかを判定
+ * Determines if a section has empty content
+ *
+ * SEC: この正規表現は空判定のみに使用。出力・サニタイズには使用しない。
+ * SEC: This regex is used for empty-content detection only. Not used for output or sanitization.
+ */
+function isEmptyContent(section: PostProcessableSection): boolean {
+  // headingがあれば非空
+  if (section.heading) {
+    return false;
+  }
+
+  // htmlSnippetが無いなら空
+  if (!section.htmlSnippet) {
+    return true;
+  }
+
+  // HTMLタグ除去後のtextContentで判定（SEC: 判定のみ、出力には使用しない）
+  // Determine by textContent after HTML tag removal (SEC: detection only, not used for output)
+  const textContent = section.htmlSnippet.replace(/<[^>]*>/g, "").trim();
+  if (textContent.length < TEXT_CONTENT_EMPTY_THRESHOLD) {
+    return true;
+  }
+
+  return false;
+}
+
+/** 前方で保持されているセクションのインデックスを探す */
+function findPrevKept(keep: boolean[], current: number): number {
+  for (let i = current - 1; i >= 0; i--) {
+    if (keep[i]) return i;
+  }
+  return -1;
+}
+
+/** 後方で保持されているセクションのインデックスを探す */
+function findNextKept(keep: boolean[], current: number, length: number): number {
+  for (let i = current + 1; i < length; i++) {
+    if (keep[i]) return i;
+  }
+  return -1;
+}
+
+// =====================================================
+// メインエントリポイント / Main Entry Point
+// =====================================================
+
+/**
+ * セクション配列をポストプロセスして過剰分割を修正する
+ * Post-processes section array to fix over-segmentation
+ *
+ * Feature flag: ENABLE_SECTION_MERGE_POSTPROCESSOR (default: true, opt-out)
+ *
+ * 実行順序 / Execution order: Rule 4 → Rule 1 → Rule 3 → Rule 2
+ * Rule 4 を最初に実行する理由: 分割により新たな連続同一タイプが発生する可能性があり、
+ * Rule 1 で処理できるため。ただし TDA MEDIUM-5 により、Rule 4 で分割されたセクション間の
+ * マージは excludeIds で防止される。
+ *
+ * Rule 4 runs first because splits may create new consecutive same-type sequences
+ * processable by Rule 1. However, TDA MEDIUM-5 prevents re-merging of Rule 4 split
+ * sections via excludeIds.
+ *
+ * @param sections - 入力セクション配列 / Input section array
+ * @returns ポストプロセス結果 / Post-process result
+ */
+export function postProcessSections(sections: PostProcessableSection[]): PostProcessResult {
+  const inputCount = sections.length;
+  const emptyStats = {
+    inputCount,
+    outputCount: inputCount,
+    mergedGroups: 0,
+    sameHeadingMergedCount: 0,
+    absorbedCount: 0,
+    splitCount: 0,
+    splitSectionsGenerated: 0,
+  };
+
+  // Feature flag チェック / Feature flag check
+  if (process.env["ENABLE_SECTION_MERGE_POSTPROCESSOR"] === "false") {
+    if (isDevelopment()) {
+      logger.debug("[section-postprocessor] Disabled via feature flag");
+    }
+    return { sections, stats: emptyStats };
+  }
+
+  // 空配列のearly return / Early return for empty array
+  if (sections.length === 0) {
+    return {
+      sections: [],
+      stats: { ...emptyStats, inputCount: 0, outputCount: 0 },
+    };
+  }
+
+  // 安全上限チェック / Safety limit check
+  if (sections.length > MAX_INPUT_SECTIONS) {
+    logger.warn("[section-postprocessor] Input exceeds safety limit, skipping post-processing", {
+      sectionCount: sections.length,
+      limit: MAX_INPUT_SECTIONS,
+    });
+    return { sections, stats: emptyStats };
+  }
+
+  try {
+    // Rule 4: 巨大セクション再分割 / Large section split
+    const rule4Result = splitOversizedSections(sections);
+
+    // SEC-09: Rule 4出力後の安全上限チェック / SEC-09: Safety limit check after Rule 4 output
+    if (rule4Result.sections.length > MAX_INPUT_SECTIONS) {
+      logger.warn(
+        "[section-postprocessor] Post-Rule 4 output exceeds safety limit, returning Rule 4 result only",
+        {
+          sectionCount: rule4Result.sections.length,
+          limit: MAX_INPUT_SECTIONS,
+        }
+      );
+      // positionIndex を再採番 / Re-number positionIndex
+      for (let i = 0; i < rule4Result.sections.length; i++) {
+        rule4Result.sections[i]!.positionIndex = i;
+      }
+      return {
+        sections: rule4Result.sections,
+        stats: {
+          ...emptyStats,
+          outputCount: rule4Result.sections.length,
+          splitCount: rule4Result.splitCount,
+          splitSectionsGenerated: rule4Result.splitSectionsGenerated,
+        },
+      };
+    }
+
+    // Rule 1: 同一タイプ連続マージ（TDA MEDIUM-5: Rule 4分割セクション除外）
+    // Rule 1: Consecutive same-type merge (TDA MEDIUM-5: exclude Rule 4 split sections)
+    const rule1Result = mergeConsecutiveSameType(rule4Result.sections, rule4Result.splitSectionIds);
+
+    // Rule 3: 同名隣接マージ（Rule 4分割セクション除外）
+    // Rule 3: Same-heading adjacent merge (exclude Rule 4 split sections)
+    const rule3Result = mergeConsecutiveSameHeading(
+      rule1Result.sections,
+      rule4Result.splitSectionIds
+    );
+
+    // Rule 2: コンテンツ空セクション吸収 / Empty content absorption
+    const rule2Result = absorbEmptyContentSections(rule3Result.sections);
+
+    // positionIndex を再採番 / Re-number positionIndex
+    const processed = rule2Result.sections;
+    for (let i = 0; i < processed.length; i++) {
+      processed[i]!.positionIndex = i;
+    }
+
+    const stats = {
+      inputCount,
+      outputCount: processed.length,
+      mergedGroups: rule1Result.mergedGroups,
+      sameHeadingMergedCount: rule3Result.sameHeadingMergedCount,
+      absorbedCount: rule2Result.absorbedCount,
+      splitCount: rule4Result.splitCount,
+      splitSectionsGenerated: rule4Result.splitSectionsGenerated,
+    };
+
+    if (isDevelopment()) {
+      logger.info("[section-postprocessor] Post-processing complete", stats);
+    }
+
+    return { sections: processed, stats };
+  } catch (error) {
+    // Graceful Degradation: 失敗時は元のセクション配列をそのまま返す
+    // Graceful Degradation: return original sections on failure
+    logger.warn("[section-postprocessor] Post-processing failed, returning original sections", {
+      error: (error as Error).message,
+      sectionCount: sections.length,
+    });
+    return { sections, stats: emptyStats };
+  }
+}