Merge branch 'main' into 3-16-revert-changes

[autofix.ci] apply automated fixes
chore: bring back monaco-editor-react, revert #32966
2026-03-17 05:17:08 +00:00 · 2026-03-16 19:57:42 +08:00 · 2026-03-16 10:57:04 +00:00 · 2026-03-16 18:53:20 +08:00
27 changed files with 758 additions and 1223 deletions
--- a/.github/workflows/web-tests.yml
+++ b/.github/workflows/web-tests.yml
@@ -89,24 +89,14 @@ jobs:
      - name: Merge reports
        run: vp test --merge-reports --reporter=json --reporter=agent --coverage

-      - name: Report app/components baseline coverage
-        run: node ./scripts/report-components-coverage-baseline.mjs
-
-      - name: Report app/components test touch
-        env:
-          BASE_SHA: ${{ inputs.base_sha }}
-          DIFF_RANGE_MODE: ${{ inputs.diff_range_mode }}
-          HEAD_SHA: ${{ inputs.head_sha }}
-        run: node ./scripts/report-components-test-touch.mjs
-
-      - name: Check app/components pure diff coverage
+      - name: Check app/components diff coverage
        env:
          BASE_SHA: ${{ inputs.base_sha }}
          DIFF_RANGE_MODE: ${{ inputs.diff_range_mode }}
          HEAD_SHA: ${{ inputs.head_sha }}
        run: node ./scripts/check-components-diff-coverage.mjs

-      - name: Check Coverage Summary
+      - name: Coverage Summary
        if: always()
        id: coverage-summary
        run: |
@@ -115,15 +105,313 @@ jobs:
          COVERAGE_FILE="coverage/coverage-final.json"
          COVERAGE_SUMMARY_FILE="coverage/coverage-summary.json"

-          if [ -f "$COVERAGE_FILE" ] || [ -f "$COVERAGE_SUMMARY_FILE" ]; then
-            echo "has_coverage=true" >> "$GITHUB_OUTPUT"
+          if [ ! -f "$COVERAGE_FILE" ] && [ ! -f "$COVERAGE_SUMMARY_FILE" ]; then
+            echo "has_coverage=false" >> "$GITHUB_OUTPUT"
+            echo "### 🚨 Test Coverage Report :test_tube:" >> "$GITHUB_STEP_SUMMARY"
+            echo "Coverage data not found. Ensure Vitest runs with coverage enabled." >> "$GITHUB_STEP_SUMMARY"
            exit 0
          fi

-          echo "has_coverage=false" >> "$GITHUB_OUTPUT"
-          echo "### 🚨 app/components Diff Coverage" >> "$GITHUB_STEP_SUMMARY"
-          echo "" >> "$GITHUB_STEP_SUMMARY"
-          echo "Coverage artifacts not found. Ensure Vitest merge reports ran with coverage enabled." >> "$GITHUB_STEP_SUMMARY"
+          echo "has_coverage=true" >> "$GITHUB_OUTPUT"
+
+          node <<'NODE' >> "$GITHUB_STEP_SUMMARY"
+          const fs = require('fs');
+          const path = require('path');
+          let libCoverage = null;
+
+          try {
+            libCoverage = require('istanbul-lib-coverage');
+          } catch (error) {
+            libCoverage = null;
+          }
+
+          const summaryPath = path.join('coverage', 'coverage-summary.json');
+          const finalPath = path.join('coverage', 'coverage-final.json');
+
+          const hasSummary = fs.existsSync(summaryPath);
+          const hasFinal = fs.existsSync(finalPath);
+
+          if (!hasSummary && !hasFinal) {
+            console.log('### Test Coverage Summary :test_tube:');
+            console.log('');
+            console.log('No coverage data found.');
+            process.exit(0);
+          }
+
+          const summary = hasSummary
+            ? JSON.parse(fs.readFileSync(summaryPath, 'utf8'))
+            : null;
+          const coverage = hasFinal
+            ? JSON.parse(fs.readFileSync(finalPath, 'utf8'))
+            : null;
+
+          const getLineCoverageFromStatements = (statementMap, statementHits) => {
+            const lineHits = {};
+
+            if (!statementMap || !statementHits) {
+              return lineHits;
+            }
+
+            Object.entries(statementMap).forEach(([key, statement]) => {
+              const line = statement?.start?.line;
+              if (!line) {
+                return;
+              }
+              const hits = statementHits[key] ?? 0;
+              const previous = lineHits[line];
+              lineHits[line] = previous === undefined ? hits : Math.max(previous, hits);
+            });
+
+            return lineHits;
+          };
+
+          const getFileCoverage = (entry) => (
+            libCoverage ? libCoverage.createFileCoverage(entry) : null
+          );
+
+          const getLineHits = (entry, fileCoverage) => {
+            const lineHits = entry.l ?? {};
+            if (Object.keys(lineHits).length > 0) {
+              return lineHits;
+            }
+            if (fileCoverage) {
+              return fileCoverage.getLineCoverage();
+            }
+            return getLineCoverageFromStatements(entry.statementMap ?? {}, entry.s ?? {});
+          };
+
+          const getUncoveredLines = (entry, fileCoverage, lineHits) => {
+            if (lineHits && Object.keys(lineHits).length > 0) {
+              return Object.entries(lineHits)
+                .filter(([, count]) => count === 0)
+                .map(([line]) => Number(line))
+                .sort((a, b) => a - b);
+            }
+            if (fileCoverage) {
+              return fileCoverage.getUncoveredLines();
+            }
+            return [];
+          };
+
+          const totals = {
+            lines: { covered: 0, total: 0 },
+            statements: { covered: 0, total: 0 },
+            branches: { covered: 0, total: 0 },
+            functions: { covered: 0, total: 0 },
+          };
+          const fileSummaries = [];
+
+          if (summary) {
+            const totalEntry = summary.total ?? {};
+            ['lines', 'statements', 'branches', 'functions'].forEach((key) => {
+              if (totalEntry[key]) {
+                totals[key].covered = totalEntry[key].covered ?? 0;
+                totals[key].total = totalEntry[key].total ?? 0;
+              }
+            });
+
+            Object.entries(summary)
+              .filter(([file]) => file !== 'total')
+              .forEach(([file, data]) => {
+                fileSummaries.push({
+                  file,
+                  pct: data.lines?.pct ?? data.statements?.pct ?? 0,
+                  lines: {
+                    covered: data.lines?.covered ?? 0,
+                    total: data.lines?.total ?? 0,
+                  },
+                });
+              });
+          } else if (coverage) {
+            Object.entries(coverage).forEach(([file, entry]) => {
+              const fileCoverage = getFileCoverage(entry);
+              const lineHits = getLineHits(entry, fileCoverage);
+              const statementHits = entry.s ?? {};
+              const branchHits = entry.b ?? {};
+              const functionHits = entry.f ?? {};
+
+              const lineTotal = Object.keys(lineHits).length;
+              const lineCovered = Object.values(lineHits).filter((n) => n > 0).length;
+
+              const statementTotal = Object.keys(statementHits).length;
+              const statementCovered = Object.values(statementHits).filter((n) => n > 0).length;
+
+              const branchTotal = Object.values(branchHits).reduce((acc, branches) => acc + branches.length, 0);
+              const branchCovered = Object.values(branchHits).reduce(
+                (acc, branches) => acc + branches.filter((n) => n > 0).length,
+                0,
+              );
+
+              const functionTotal = Object.keys(functionHits).length;
+              const functionCovered = Object.values(functionHits).filter((n) => n > 0).length;
+
+              totals.lines.total += lineTotal;
+              totals.lines.covered += lineCovered;
+              totals.statements.total += statementTotal;
+              totals.statements.covered += statementCovered;
+              totals.branches.total += branchTotal;
+              totals.branches.covered += branchCovered;
+              totals.functions.total += functionTotal;
+              totals.functions.covered += functionCovered;
+
+              const pct = (covered, tot) => (tot > 0 ? (covered / tot) * 100 : 0);
+
+              fileSummaries.push({
+                file,
+                pct: pct(lineCovered || statementCovered, lineTotal || statementTotal),
+                lines: {
+                  covered: lineCovered || statementCovered,
+                  total: lineTotal || statementTotal,
+                },
+              });
+            });
+          }
+
+          const pct = (covered, tot) => (tot > 0 ? ((covered / tot) * 100).toFixed(2) : '0.00');
+
+          console.log('### Test Coverage Summary :test_tube:');
+          console.log('');
+          console.log('| Metric | Coverage | Covered / Total |');
+          console.log('|--------|----------|-----------------|');
+          console.log(`| Lines | ${pct(totals.lines.covered, totals.lines.total)}% | ${totals.lines.covered} / ${totals.lines.total} |`);
+          console.log(`| Statements | ${pct(totals.statements.covered, totals.statements.total)}% | ${totals.statements.covered} / ${totals.statements.total} |`);
+          console.log(`| Branches | ${pct(totals.branches.covered, totals.branches.total)}% | ${totals.branches.covered} / ${totals.branches.total} |`);
+          console.log(`| Functions | ${pct(totals.functions.covered, totals.functions.total)}% | ${totals.functions.covered} / ${totals.functions.total} |`);
+
+          console.log('');
+          console.log('<details><summary>File coverage (lowest lines first)</summary>');
+          console.log('');
+          console.log('```');
+          fileSummaries
+            .sort((a, b) => (a.pct - b.pct) || (b.lines.total - a.lines.total))
+            .slice(0, 25)
+            .forEach(({ file, pct, lines }) => {
+              console.log(`${pct.toFixed(2)}%\t${lines.covered}/${lines.total}\t${file}`);
+            });
+          console.log('```');
+          console.log('</details>');
+
+          if (coverage) {
+            const pctValue = (covered, tot) => {
+              if (tot === 0) {
+                return '0';
+              }
+              return ((covered / tot) * 100)
+                .toFixed(2)
+                .replace(/\.?0+$/, '');
+            };
+
+            const formatLineRanges = (lines) => {
+              if (lines.length === 0) {
+                return '';
+              }
+              const ranges = [];
+              let start = lines[0];
+              let end = lines[0];
+
+              for (let i = 1; i < lines.length; i += 1) {
+                const current = lines[i];
+                if (current === end + 1) {
+                  end = current;
+                  continue;
+                }
+                ranges.push(start === end ? `${start}` : `${start}-${end}`);
+                start = current;
+                end = current;
+              }
+              ranges.push(start === end ? `${start}` : `${start}-${end}`);
+              return ranges.join(',');
+            };
+
+            const tableTotals = {
+              statements: { covered: 0, total: 0 },
+              branches: { covered: 0, total: 0 },
+              functions: { covered: 0, total: 0 },
+              lines: { covered: 0, total: 0 },
+            };
+            const tableRows = Object.entries(coverage)
+              .map(([file, entry]) => {
+                const fileCoverage = getFileCoverage(entry);
+                const lineHits = getLineHits(entry, fileCoverage);
+                const statementHits = entry.s ?? {};
+                const branchHits = entry.b ?? {};
+                const functionHits = entry.f ?? {};
+
+                const lineTotal = Object.keys(lineHits).length;
+                const lineCovered = Object.values(lineHits).filter((n) => n > 0).length;
+                const statementTotal = Object.keys(statementHits).length;
+                const statementCovered = Object.values(statementHits).filter((n) => n > 0).length;
+                const branchTotal = Object.values(branchHits).reduce((acc, branches) => acc + branches.length, 0);
+                const branchCovered = Object.values(branchHits).reduce(
+                  (acc, branches) => acc + branches.filter((n) => n > 0).length,
+                  0,
+                );
+                const functionTotal = Object.keys(functionHits).length;
+                const functionCovered = Object.values(functionHits).filter((n) => n > 0).length;
+
+                tableTotals.lines.total += lineTotal;
+                tableTotals.lines.covered += lineCovered;
+                tableTotals.statements.total += statementTotal;
+                tableTotals.statements.covered += statementCovered;
+                tableTotals.branches.total += branchTotal;
+                tableTotals.branches.covered += branchCovered;
+                tableTotals.functions.total += functionTotal;
+                tableTotals.functions.covered += functionCovered;
+
+                const uncoveredLines = getUncoveredLines(entry, fileCoverage, lineHits);
+
+                const filePath = entry.path ?? file;
+                const relativePath = path.isAbsolute(filePath)
+                  ? path.relative(process.cwd(), filePath)
+                  : filePath;
+
+                return {
+                  file: relativePath || file,
+                  statements: pctValue(statementCovered, statementTotal),
+                  branches: pctValue(branchCovered, branchTotal),
+                  functions: pctValue(functionCovered, functionTotal),
+                  lines: pctValue(lineCovered, lineTotal),
+                  uncovered: formatLineRanges(uncoveredLines),
+                };
+              })
+              .sort((a, b) => a.file.localeCompare(b.file));
+
+            const columns = [
+              { key: 'file', header: 'File', align: 'left' },
+              { key: 'statements', header: '% Stmts', align: 'right' },
+              { key: 'branches', header: '% Branch', align: 'right' },
+              { key: 'functions', header: '% Funcs', align: 'right' },
+              { key: 'lines', header: '% Lines', align: 'right' },
+              { key: 'uncovered', header: 'Uncovered Line #s', align: 'left' },
+            ];
+
+            const allFilesRow = {
+              file: 'All files',
+              statements: pctValue(tableTotals.statements.covered, tableTotals.statements.total),
+              branches: pctValue(tableTotals.branches.covered, tableTotals.branches.total),
+              functions: pctValue(tableTotals.functions.covered, tableTotals.functions.total),
+              lines: pctValue(tableTotals.lines.covered, tableTotals.lines.total),
+              uncovered: '',
+            };
+
+            const rowsForOutput = [allFilesRow, ...tableRows];
+            const formatRow = (row) => `| ${columns
+              .map(({ key }) => String(row[key] ?? ''))
+              .join(' | ')} |`;
+            const headerRow = `| ${columns.map(({ header }) => header).join(' | ')} |`;
+            const dividerRow = `| ${columns
+              .map(({ align }) => (align === 'right' ? '---:' : ':---'))
+              .join(' | ')} |`;
+
+            console.log('');
+            console.log('<details><summary>Vitest coverage table</summary>');
+            console.log('');
+            console.log(headerRow);
+            console.log(dividerRow);
+            rowsForOutput.forEach((row) => console.log(formatRow(row)));
+            console.log('</details>');
+          }
+          NODE

      - name: Upload Coverage Artifact
        if: steps.coverage-summary.outputs.has_coverage == 'true'
--- a/api/core/indexing_runner.py
+++ b/api/core/indexing_runner.py
@@ -5,7 +5,6 @@ import re
 import threading
 import time
 import uuid
-from collections.abc import Mapping
 from typing import Any

 from flask import Flask, current_app
@@ -38,7 +37,7 @@ from extensions.ext_storage import storage
 from libs import helper
 from libs.datetime_utils import naive_utc_now
 from models import Account
-from models.dataset import AutomaticRulesConfig, ChildChunk, Dataset, DatasetProcessRule, DocumentSegment
+from models.dataset import ChildChunk, Dataset, DatasetProcessRule, DocumentSegment
 from models.dataset import Document as DatasetDocument
 from models.model import UploadFile
 from services.feature_service import FeatureService
@@ -266,7 +265,7 @@ class IndexingRunner:
        self,
        tenant_id: str,
        extract_settings: list[ExtractSetting],
-        tmp_processing_rule: Mapping[str, Any],
+        tmp_processing_rule: dict,
        doc_form: str | None = None,
        doc_language: str = "English",
        dataset_id: str | None = None,
@@ -377,7 +376,7 @@ class IndexingRunner:
        return IndexingEstimate(total_segments=total_segments, preview=preview_texts)

    def _extract(
-        self, index_processor: BaseIndexProcessor, dataset_document: DatasetDocument, process_rule: Mapping[str, Any]
+        self, index_processor: BaseIndexProcessor, dataset_document: DatasetDocument, process_rule: dict
    ) -> list[Document]:
        data_source_info = dataset_document.data_source_info_dict
        text_docs = []
@@ -544,7 +543,6 @@ class IndexingRunner:
        """
        Clean the document text according to the processing rules.
        """
-        rules: AutomaticRulesConfig | dict[str, Any]
        if processing_rule.mode == "automatic":
            rules = DatasetProcessRule.AUTOMATIC_RULES
        else:
@@ -758,7 +756,7 @@ class IndexingRunner:
        dataset: Dataset,
        text_docs: list[Document],
        doc_language: str,
-        process_rule: Mapping[str, Any],
+        process_rule: dict,
        current_user: Account | None = None,
    ) -> list[Document]:
        # get embedding model instance
--- a/api/dify_graph/graph_engine/response_coordinator/init.py
+++ b/api/dify_graph/graph_engine/response_coordinator/init.py
@@ -6,5 +6,6 @@ of responses based on upstream node outputs and constants.
 """

 from .coordinator import ResponseStreamCoordinator
+from .session import RESPONSE_SESSION_NODE_TYPES

-__all__ = ["ResponseStreamCoordinator"]
+__all__ = ["RESPONSE_SESSION_NODE_TYPES", "ResponseStreamCoordinator"]
--- a/api/dify_graph/graph_engine/response_coordinator/session.py
+++ b/api/dify_graph/graph_engine/response_coordinator/session.py
@@ -3,6 +3,10 @@ Internal response session management for response coordinator.

 This module contains the private ResponseSession class used internally
 by ResponseStreamCoordinator to manage streaming sessions.
+
+`RESPONSE_SESSION_NODE_TYPES` is intentionally mutable so downstream applications
+can opt additional response-capable node types into session creation without
+patching the coordinator.
 """

 from __future__ import annotations
@@ -10,6 +14,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Protocol, cast

+from dify_graph.enums import BuiltinNodeTypes, NodeType
 from dify_graph.nodes.base.template import Template
 from dify_graph.runtime.graph_runtime_state import NodeProtocol

@@ -20,6 +25,12 @@ class _ResponseSessionNodeProtocol(NodeProtocol, Protocol):
    def get_streaming_template(self) -> Template: ...


+RESPONSE_SESSION_NODE_TYPES: list[NodeType] = [
+    BuiltinNodeTypes.ANSWER,
+    BuiltinNodeTypes.END,
+]
+
+
@dataclass
 class ResponseSession:
    """
@@ -38,8 +49,8 @@ class ResponseSession:
        Create a ResponseSession from a response-capable node.

        The parameter is typed as `NodeProtocol` because the graph is exposed behind a protocol at the runtime layer.
-        At runtime this must be a node that implements `get_streaming_template()`. The coordinator decides which
-        graph nodes should be treated as response-capable before they reach this factory.
+        At runtime this must be a node whose `node_type` is listed in `RESPONSE_SESSION_NODE_TYPES`
+        and which implements `get_streaming_template()`.

        Args:
            node: Node from the materialized workflow graph.
@@ -48,8 +59,15 @@ class ResponseSession:
            ResponseSession configured with the node's streaming template

        Raises:
-            TypeError: If node does not implement the response-session streaming contract.
+            TypeError: If node is not a supported response node type.
        """
+        if node.node_type not in RESPONSE_SESSION_NODE_TYPES:
+            supported_node_types = ", ".join(RESPONSE_SESSION_NODE_TYPES)
+            raise TypeError(
+                "ResponseSession.from_node only supports node types in "
+                f"RESPONSE_SESSION_NODE_TYPES: {supported_node_types}"
+            )
+
        response_node = cast(_ResponseSessionNodeProtocol, node)
        try:
            template = response_node.get_streaming_template()
--- a/api/models/dataset.py
+++ b/api/models/dataset.py
@@ -10,7 +10,7 @@ import re
 import time
 from datetime import datetime
 from json import JSONDecodeError
-from typing import Any, TypedDict, cast
+from typing import Any, cast
 from uuid import uuid4

 import sqlalchemy as sa
@@ -37,61 +37,6 @@ from .types import AdjustedJSON, BinaryData, EnumText, LongText, StringUUID, adj
 logger = logging.getLogger(__name__)


-class PreProcessingRuleItem(TypedDict):
-    id: str
-    enabled: bool
-
-
-class SegmentationConfig(TypedDict):
-    delimiter: str
-    max_tokens: int
-    chunk_overlap: int
-
-
-class AutomaticRulesConfig(TypedDict):
-    pre_processing_rules: list[PreProcessingRuleItem]
-    segmentation: SegmentationConfig
-
-
-class ProcessRuleDict(TypedDict):
-    id: str
-    dataset_id: str
-    mode: str
-    rules: dict[str, Any] | None
-
-
-class DocMetadataDetailItem(TypedDict):
-    id: str
-    name: str
-    type: str
-    value: Any
-
-
-class AttachmentItem(TypedDict):
-    id: str
-    name: str
-    size: int
-    extension: str
-    mime_type: str
-    source_url: str
-
-
-class DatasetBindingItem(TypedDict):
-    id: str
-    name: str
-
-
-class ExternalKnowledgeApiDict(TypedDict):
-    id: str
-    tenant_id: str
-    name: str
-    description: str
-    settings: dict[str, Any] | None
-    dataset_bindings: list[DatasetBindingItem]
-    created_by: str
-    created_at: str
-
-
 class DatasetPermissionEnum(enum.StrEnum):
    ONLY_ME = "only_me"
    ALL_TEAM = "all_team_members"
@@ -389,7 +334,7 @@ class DatasetProcessRule(Base):  # bug

    MODES = ["automatic", "custom", "hierarchical"]
    PRE_PROCESSING_RULES = ["remove_stopwords", "remove_extra_spaces", "remove_urls_emails"]
-    AUTOMATIC_RULES: AutomaticRulesConfig = {
+    AUTOMATIC_RULES: dict[str, Any] = {
        "pre_processing_rules": [
            {"id": "remove_extra_spaces", "enabled": True},
            {"id": "remove_urls_emails", "enabled": False},
@@ -397,7 +342,7 @@ class DatasetProcessRule(Base):  # bug
        "segmentation": {"delimiter": "\n", "max_tokens": 500, "chunk_overlap": 50},
    }

-    def to_dict(self) -> ProcessRuleDict:
+    def to_dict(self) -> dict[str, Any]:
        return {
            "id": self.id,
            "dataset_id": self.dataset_id,
@@ -586,7 +531,7 @@ class Document(Base):
        return self.updated_at

    @property
-    def doc_metadata_details(self) -> list[DocMetadataDetailItem] | None:
+    def doc_metadata_details(self) -> list[dict[str, Any]] | None:
        if self.doc_metadata:
            document_metadatas = (
                db.session.query(DatasetMetadata)
@@ -596,9 +541,9 @@ class Document(Base):
                )
                .all()
            )
-            metadata_list: list[DocMetadataDetailItem] = []
+            metadata_list: list[dict[str, Any]] = []
            for metadata in document_metadatas:
-                metadata_dict: DocMetadataDetailItem = {
+                metadata_dict: dict[str, Any] = {
                    "id": metadata.id,
                    "name": metadata.name,
                    "type": metadata.type,
@@ -612,13 +557,13 @@ class Document(Base):
        return None

    @property
-    def process_rule_dict(self) -> ProcessRuleDict | None:
+    def process_rule_dict(self) -> dict[str, Any] | None:
        if self.dataset_process_rule_id and self.dataset_process_rule:
            return self.dataset_process_rule.to_dict()
        return None

-    def get_built_in_fields(self) -> list[DocMetadataDetailItem]:
-        built_in_fields: list[DocMetadataDetailItem] = []
+    def get_built_in_fields(self) -> list[dict[str, Any]]:
+        built_in_fields: list[dict[str, Any]] = []
        built_in_fields.append(
            {
                "id": "built-in",
@@ -932,7 +877,7 @@ class DocumentSegment(Base):
        return text

    @property
-    def attachments(self) -> list[AttachmentItem]:
+    def attachments(self) -> list[dict[str, Any]]:
        # Use JOIN to fetch attachments in a single query instead of two separate queries
        attachments_with_bindings = db.session.execute(
            select(SegmentAttachmentBinding, UploadFile)
@@ -946,7 +891,7 @@ class DocumentSegment(Base):
        ).all()
        if not attachments_with_bindings:
            return []
-        attachment_list: list[AttachmentItem] = []
+        attachment_list = []
        for _, attachment in attachments_with_bindings:
            upload_file_id = attachment.id
            nonce = os.urandom(16).hex()
@@ -1316,7 +1261,7 @@ class ExternalKnowledgeApis(TypeBase):
        DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
    )

-    def to_dict(self) -> ExternalKnowledgeApiDict:
+    def to_dict(self) -> dict[str, Any]:
        return {
            "id": self.id,
            "tenant_id": self.tenant_id,
@@ -1336,13 +1281,13 @@ class ExternalKnowledgeApis(TypeBase):
            return None

    @property
-    def dataset_bindings(self) -> list[DatasetBindingItem]:
+    def dataset_bindings(self) -> list[dict[str, Any]]:
        external_knowledge_bindings = db.session.scalars(
            select(ExternalKnowledgeBindings).where(ExternalKnowledgeBindings.external_knowledge_api_id == self.id)
        ).all()
        dataset_ids = [binding.dataset_id for binding in external_knowledge_bindings]
        datasets = db.session.scalars(select(Dataset).where(Dataset.id.in_(dataset_ids))).all()
-        dataset_bindings: list[DatasetBindingItem] = []
+        dataset_bindings: list[dict[str, Any]] = []
        for dataset in datasets:
            dataset_bindings.append({"id": dataset.id, "name": dataset.name})

--- a/api/models/trigger.py
+++ b/api/models/trigger.py
@@ -3,7 +3,7 @@ import time
 from collections.abc import Mapping
 from datetime import datetime
 from functools import cached_property
-from typing import Any, TypedDict, cast
+from typing import Any, cast
 from uuid import uuid4

 import sqlalchemy as sa
@@ -24,44 +24,6 @@ from .model import Account
 from .types import EnumText, LongText, StringUUID


-class WorkflowTriggerLogDict(TypedDict):
-    id: str
-    tenant_id: str
-    app_id: str
-    workflow_id: str
-    workflow_run_id: str | None
-    root_node_id: str | None
-    trigger_metadata: Any
-    trigger_type: str
-    trigger_data: Any
-    inputs: Any
-    outputs: Any
-    status: str
-    error: str | None
-    queue_name: str
-    celery_task_id: str | None
-    retry_count: int
-    elapsed_time: float | None
-    total_tokens: int | None
-    created_by_role: str
-    created_by: str
-    created_at: str | None
-    triggered_at: str | None
-    finished_at: str | None
-
-
-class WorkflowSchedulePlanDict(TypedDict):
-    id: str
-    app_id: str
-    node_id: str
-    tenant_id: str
-    cron_expression: str
-    timezone: str
-    next_run_at: str | None
-    created_at: str
-    updated_at: str
-
-
 class TriggerSubscription(TypeBase):
    """
    Trigger provider model for managing credentials
@@ -288,7 +250,7 @@ class WorkflowTriggerLog(TypeBase):
        created_by_role = CreatorUserRole(self.created_by_role)
        return db.session.get(EndUser, self.created_by) if created_by_role == CreatorUserRole.END_USER else None

-    def to_dict(self) -> WorkflowTriggerLogDict:
+    def to_dict(self) -> dict[str, Any]:
        """Convert to dictionary for API responses"""
        return {
            "id": self.id,
@@ -519,7 +481,7 @@ class WorkflowSchedulePlan(TypeBase):
        DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
    )

-    def to_dict(self) -> WorkflowSchedulePlanDict:
+    def to_dict(self) -> dict[str, Any]:
        """Convert to dictionary representation"""
        return {
            "id": self.id,
--- a/api/models/workflow.py
+++ b/api/models/workflow.py
@@ -3,7 +3,7 @@ import logging
 from collections.abc import Generator, Mapping, Sequence
 from datetime import datetime
 from enum import StrEnum
-from typing import TYPE_CHECKING, Any, Optional, TypedDict, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 from uuid import uuid4

 import sqlalchemy as sa
@@ -60,22 +60,6 @@ from .types import EnumText, LongText, StringUUID
 logger = logging.getLogger(__name__)


-class WorkflowContentDict(TypedDict):
-    graph: Mapping[str, Any]
-    features: dict[str, Any]
-    environment_variables: list[dict[str, Any]]
-    conversation_variables: list[dict[str, Any]]
-    rag_pipeline_variables: list[dict[str, Any]]
-
-
-class WorkflowRunSummaryDict(TypedDict):
-    id: str
-    status: str
-    triggered_from: str
-    elapsed_time: float
-    total_tokens: int
-
-
 class WorkflowType(StrEnum):
    """
    Workflow Type Enum
@@ -518,14 +502,14 @@ class Workflow(Base):  # bug
        )
        self._environment_variables = environment_variables_json

-    def to_dict(self, *, include_secret: bool = False) -> WorkflowContentDict:
+    def to_dict(self, *, include_secret: bool = False) -> Mapping[str, Any]:
        environment_variables = list(self.environment_variables)
        environment_variables = [
            v if not isinstance(v, SecretVariable) or include_secret else v.model_copy(update={"value": ""})
            for v in environment_variables
        ]

-        result: WorkflowContentDict = {
+        result = {
            "graph": self.graph_dict,
            "features": self.features_dict,
            "environment_variables": [var.model_dump(mode="json") for var in environment_variables],
@@ -1247,7 +1231,7 @@ class WorkflowArchiveLog(TypeBase):
    )

    @property
-    def workflow_run_summary(self) -> WorkflowRunSummaryDict:
+    def workflow_run_summary(self) -> dict[str, Any]:
        return {
            "id": self.workflow_run_id,
            "status": self.run_status,
--- a/api/services/async_workflow_service.py
+++ b/api/services/async_workflow_service.py
@@ -18,7 +18,7 @@ from extensions.ext_database import db
 from models.account import Account
 from models.enums import CreatorUserRole, WorkflowTriggerStatus
 from models.model import App, EndUser
-from models.trigger import WorkflowTriggerLog, WorkflowTriggerLogDict
+from models.trigger import WorkflowTriggerLog
 from models.workflow import Workflow
 from repositories.sqlalchemy_workflow_trigger_log_repository import SQLAlchemyWorkflowTriggerLogRepository
 from services.errors.app import QuotaExceededError, WorkflowNotFoundError, WorkflowQuotaLimitError
@@ -224,9 +224,7 @@ class AsyncWorkflowService:
        return cls.trigger_workflow_async(session, user, trigger_data)

    @classmethod
-    def get_trigger_log(
-        cls, workflow_trigger_log_id: str, tenant_id: str | None = None
-    ) -> WorkflowTriggerLogDict | None:
+    def get_trigger_log(cls, workflow_trigger_log_id: str, tenant_id: str | None = None) -> dict[str, Any] | None:
        """
        Get trigger log by ID

@@ -249,7 +247,7 @@ class AsyncWorkflowService:
    @classmethod
    def get_recent_logs(
        cls, tenant_id: str, app_id: str, hours: int = 24, limit: int = 100, offset: int = 0
-    ) -> list[WorkflowTriggerLogDict]:
+    ) -> list[dict[str, Any]]:
        """
        Get recent trigger logs

@@ -274,7 +272,7 @@ class AsyncWorkflowService:
    @classmethod
    def get_failed_logs_for_retry(
        cls, tenant_id: str, max_retry_count: int = 3, limit: int = 100
-    ) -> list[WorkflowTriggerLogDict]:
+    ) -> list[dict[str, Any]]:
        """
        Get failed logs eligible for retry

--- a/api/services/vector_service.py
+++ b/api/services/vector_service.py
@@ -156,8 +156,7 @@ class VectorService:
        )
        # use full doc mode to generate segment's child chunk
        processing_rule_dict = processing_rule.to_dict()
-        if processing_rule_dict["rules"] is not None:
-            processing_rule_dict["rules"]["parent_mode"] = ParentMode.FULL_DOC
+        processing_rule_dict["rules"]["parent_mode"] = ParentMode.FULL_DOC
        documents = index_processor.transform(
            [document],
            embedding_model_instance=embedding_model_instance,
--- a/api/tests/unit_tests/core/workflow/graph_engine/test_response_session.py
+++ b/api/tests/unit_tests/core/workflow/graph_engine/test_response_session.py
@@ -4,7 +4,9 @@ from __future__ import annotations

 import pytest

+import dify_graph.graph_engine.response_coordinator.session as response_session_module
 from dify_graph.enums import BuiltinNodeTypes, NodeExecutionType, NodeState, NodeType
+from dify_graph.graph_engine.response_coordinator import RESPONSE_SESSION_NODE_TYPES
 from dify_graph.graph_engine.response_coordinator.session import ResponseSession
 from dify_graph.nodes.base.template import Template, TextSegment

@@ -33,14 +35,28 @@ class DummyNodeWithoutStreamingTemplate:
        self.state = NodeState.UNKNOWN


-def test_response_session_from_node_accepts_nodes_outside_previous_allowlist() -> None:
-    """Session creation depends on the streaming-template contract rather than node type."""
+def test_response_session_from_node_rejects_node_types_outside_allowlist() -> None:
+    """Unsupported node types are rejected even if they expose a template."""
    node = DummyResponseNode(
        node_id="llm-node",
        node_type=BuiltinNodeTypes.LLM,
        template=Template(segments=[TextSegment(text="hello")]),
    )

+    with pytest.raises(TypeError, match="RESPONSE_SESSION_NODE_TYPES"):
+        ResponseSession.from_node(node)
+
+
+def test_response_session_from_node_supports_downstream_allowlist_extension(monkeypatch) -> None:
+    """Downstream applications can extend the supported node-type list."""
+    node = DummyResponseNode(
+        node_id="llm-node",
+        node_type=BuiltinNodeTypes.LLM,
+        template=Template(segments=[TextSegment(text="hello")]),
+    )
+    extended_node_types = [*RESPONSE_SESSION_NODE_TYPES, BuiltinNodeTypes.LLM]
+    monkeypatch.setattr(response_session_module, "RESPONSE_SESSION_NODE_TYPES", extended_node_types)
+
    session = ResponseSession.from_node(node)

    assert session.node_id == "llm-node"
--- a/api/uv.lock
+++ b/api/uv.lock
@@ -457,14 +457,14 @@ wheels = [

 [[package]]
 name = "authlib"
-version = "1.6.9"
+version = "1.6.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "cryptography" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/af/98/00d3dd826d46959ad8e32af2dbb2398868fd9fd0683c26e56d0789bd0e68/authlib-1.6.9.tar.gz", hash = "sha256:d8f2421e7e5980cc1ddb4e32d3f5fa659cfaf60d8eaf3281ebed192e4ab74f04", size = 165134, upload-time = "2026-03-02T07:44:01.998Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/dc/ed1681bf1339dd6ea1ce56136bad4baabc6f7ad466e375810702b0237047/authlib-1.6.7.tar.gz", hash = "sha256:dbf10100011d1e1b34048c9d120e83f13b35d69a826ae762b93d2fb5aafc337b", size = 164950, upload-time = "2026-02-06T14:04:14.171Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/23/b65f568ed0c22f1efacb744d2db1a33c8068f384b8c9b482b52ebdbc3ef6/authlib-1.6.9-py2.py3-none-any.whl", hash = "sha256:f08b4c14e08f0861dc18a32357b33fbcfd2ea86cfe3fe149484b4d764c4a0ac3", size = 244197, upload-time = "2026-03-02T07:44:00.307Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/00/3ed12264094ec91f534fae429945efbaa9f8c666f3aa7061cc3b2a26a0cd/authlib-1.6.7-py2.py3-none-any.whl", hash = "sha256:c637340d9a02789d2efa1d003a7437d10d3e565237bcb5fcbc6c134c7b95bab0", size = 244115, upload-time = "2026-02-06T14:04:12.141Z" },
 ]

 [[package]]
--- a/web/tests/check-components-diff-coverage.test.ts
+++ b/web/tests/check-components-diff-coverage.test.ts
@@ -161,40 +161,11 @@ describe('check-components-diff-coverage helpers', () => {

    const coverage = getChangedBranchCoverage(entry, new Set([33]))

-    expect(coverage).toEqual({
-      covered: 0,
-      total: 1,
-      uncoveredBranches: [
-        { armIndex: 0, line: 33 },
-      ],
-    })
-  })
-
-  it('should require all branch arms when the branch condition changes', () => {
-    const entry = {
-      b: {
-        0: [0, 0],
-      },
-      branchMap: {
-        0: {
-          line: 30,
-          loc: { start: { line: 30 }, end: { line: 35 } },
-          locations: [
-            { start: { line: 31 }, end: { line: 34 } },
-            { start: { line: 35 }, end: { line: 38 } },
-          ],
-          type: 'if',
-        },
-      },
-    }
-
-    const coverage = getChangedBranchCoverage(entry, new Set([30]))
-
    expect(coverage).toEqual({
      covered: 0,
      total: 2,
      uncoveredBranches: [
-        { armIndex: 0, line: 31 },
+        { armIndex: 0, line: 33 },
        { armIndex: 1, line: 35 },
      ],
    })
--- a/web/tests/components-coverage-common.test.ts
+++ b/web/tests/components-coverage-common.test.ts
@@ -1,72 +0,0 @@
-import {
-  getCoverageStats,
-  isRelevantTestFile,
-  isTrackedComponentSourceFile,
-  loadTrackedCoverageEntries,
-} from '../scripts/components-coverage-common.mjs'
-
-describe('components coverage common helpers', () => {
-  it('should identify tracked component source files and relevant tests', () => {
-    const excludedComponentCoverageFiles = new Set([
-      'web/app/components/share/types.ts',
-    ])
-
-    expect(isTrackedComponentSourceFile('web/app/components/share/index.tsx', excludedComponentCoverageFiles)).toBe(true)
-    expect(isTrackedComponentSourceFile('web/app/components/share/types.ts', excludedComponentCoverageFiles)).toBe(false)
-    expect(isTrackedComponentSourceFile('web/app/components/provider/index.tsx', excludedComponentCoverageFiles)).toBe(false)
-
-    expect(isRelevantTestFile('web/__tests__/share/text-generation-run-once-flow.test.tsx')).toBe(true)
-    expect(isRelevantTestFile('web/app/components/share/__tests__/index.spec.tsx')).toBe(true)
-    expect(isRelevantTestFile('web/utils/format.spec.ts')).toBe(false)
-  })
-
-  it('should load only tracked coverage entries from mixed coverage paths', () => {
-    const context = {
-      excludedComponentCoverageFiles: new Set([
-        'web/app/components/share/types.ts',
-      ]),
-      repoRoot: '/repo',
-      webRoot: '/repo/web',
-    }
-    const coverage = {
-      '/repo/web/app/components/provider/index.tsx': {
-        path: '/repo/web/app/components/provider/index.tsx',
-        statementMap: { 0: { start: { line: 1 }, end: { line: 1 } } },
-        s: { 0: 1 },
-      },
-      'app/components/share/index.tsx': {
-        path: 'app/components/share/index.tsx',
-        statementMap: { 0: { start: { line: 2 }, end: { line: 2 } } },
-        s: { 0: 1 },
-      },
-      'app/components/share/types.ts': {
-        path: 'app/components/share/types.ts',
-        statementMap: { 0: { start: { line: 3 }, end: { line: 3 } } },
-        s: { 0: 1 },
-      },
-    }
-
-    expect([...loadTrackedCoverageEntries(coverage, context).keys()]).toEqual([
-      'web/app/components/share/index.tsx',
-    ])
-  })
-
-  it('should calculate coverage stats using statement-derived line hits', () => {
-    const entry = {
-      b: { 0: [1, 0] },
-      f: { 0: 1, 1: 0 },
-      s: { 0: 1, 1: 0 },
-      statementMap: {
-        0: { start: { line: 10 }, end: { line: 10 } },
-        1: { start: { line: 12 }, end: { line: 13 } },
-      },
-    }
-
-    expect(getCoverageStats(entry)).toEqual({
-      branches: { covered: 1, total: 2 },
-      functions: { covered: 1, total: 2 },
-      lines: { covered: 1, total: 2 },
-      statements: { covered: 1, total: 2 },
-    })
-  })
-})
--- a/web/app/components/app/configuration/dataset-config/select-dataset/index.spec.tsx
+++ b/web/app/components/app/configuration/dataset-config/select-dataset/index.spec.tsx
@@ -137,31 +137,4 @@ describe('SelectDataSet', () => {
    expect(screen.getByRole('link', { name: 'appDebug.feature.dataSet.toCreate' })).toHaveAttribute('href', '/datasets/create')
    expect(screen.getByRole('button', { name: 'common.operation.add' })).toBeDisabled()
  })
-
-  it('uses selectedIds as the initial modal selection', async () => {
-    const datasetOne = makeDataset({
-      id: 'set-1',
-      name: 'Dataset One',
-    })
-    mockUseInfiniteDatasets.mockReturnValue({
-      data: { pages: [{ data: [datasetOne] }] },
-      isLoading: false,
-      isFetchingNextPage: false,
-      fetchNextPage: vi.fn(),
-      hasNextPage: false,
-    })
-
-    const onSelect = vi.fn()
-    await act(async () => {
-      render(<SelectDataSet {...baseProps} onSelect={onSelect} selectedIds={['set-1']} />)
-    })
-
-    expect(screen.getByText('1 appDebug.feature.dataSet.selected')).toBeInTheDocument()
-
-    await act(async () => {
-      fireEvent.click(screen.getByRole('button', { name: 'common.operation.add' }))
-    })
-
-    expect(onSelect).toHaveBeenCalledWith([datasetOne])
-  })
 })
--- a/web/app/components/app/configuration/dataset-config/select-dataset/index.tsx
+++ b/web/app/components/app/configuration/dataset-config/select-dataset/index.tsx
@@ -4,7 +4,7 @@ import type { DataSet } from '@/models/datasets'
 import { useInfiniteScroll } from 'ahooks'
 import Link from 'next/link'
 import * as React from 'react'
-import { useMemo, useRef, useState } from 'react'
+import { useEffect, useMemo, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import AppIcon from '@/app/components/base/app-icon'
 import Badge from '@/app/components/base/badge'
@@ -31,21 +31,17 @@ const SelectDataSet: FC<ISelectDataSetProps> = ({
  onSelect,
 }) => {
  const { t } = useTranslation()
-  const [selectedIdsInModal, setSelectedIdsInModal] = useState(() => selectedIds)
+  const [selected, setSelected] = useState<DataSet[]>([])
  const canSelectMulti = true
  const { formatIndexingTechniqueAndMethod } = useKnowledge()
  const { data, isLoading, isFetchingNextPage, fetchNextPage, hasNextPage } = useInfiniteDatasets(
    { page: 1 },
    { enabled: isShow, staleTime: 0, refetchOnMount: 'always' },
  )
+  const pages = data?.pages || []
  const datasets = useMemo(() => {
-    const pages = data?.pages || []
    return pages.flatMap(page => page.data.filter(item => item.indexing_technique || item.provider === 'external'))
-  }, [data])
-  const datasetMap = useMemo(() => new Map(datasets.map(item => [item.id, item])), [datasets])
-  const selected = useMemo(() => {
-    return selectedIdsInModal.map(id => datasetMap.get(id) || ({ id } as DataSet))
-  }, [datasetMap, selectedIdsInModal])
+  }, [pages])
  const hasNoData = !isLoading && datasets.length === 0

  const listRef = useRef<HTMLDivElement>(null)
@@ -65,14 +61,50 @@ const SelectDataSet: FC<ISelectDataSetProps> = ({
    },
  )

-  const toggleSelect = (dataSet: DataSet) => {
-    setSelectedIdsInModal((prev) => {
-      const isSelected = prev.includes(dataSet.id)
-      if (isSelected)
-        return prev.filter(id => id !== dataSet.id)
+  const prevSelectedIdsRef = useRef<string[]>([])
+  const hasUserModifiedSelectionRef = useRef(false)
+  useEffect(() => {
+    if (isShow)
+      hasUserModifiedSelectionRef.current = false
+  }, [isShow])
+  useEffect(() => {
+    const prevSelectedIds = prevSelectedIdsRef.current
+    const idsChanged = selectedIds.length !== prevSelectedIds.length
+      || selectedIds.some((id, idx) => id !== prevSelectedIds[idx])

-      return canSelectMulti ? [...prev, dataSet.id] : [dataSet.id]
+    if (!selectedIds.length && (!hasUserModifiedSelectionRef.current || idsChanged)) {
+      setSelected([])
+      prevSelectedIdsRef.current = selectedIds
+      hasUserModifiedSelectionRef.current = false
+      return
+    }
+
+    if (!idsChanged && hasUserModifiedSelectionRef.current)
+      return
+
+    setSelected((prev) => {
+      const prevMap = new Map(prev.map(item => [item.id, item]))
+      const nextSelected = selectedIds
+        .map(id => datasets.find(item => item.id === id) || prevMap.get(id))
+        .filter(Boolean) as DataSet[]
+      return nextSelected
    })
+    prevSelectedIdsRef.current = selectedIds
+    hasUserModifiedSelectionRef.current = false
+  }, [datasets, selectedIds])
+
+  const toggleSelect = (dataSet: DataSet) => {
+    hasUserModifiedSelectionRef.current = true
+    const isSelected = selected.some(item => item.id === dataSet.id)
+    if (isSelected) {
+      setSelected(selected.filter(item => item.id !== dataSet.id))
+    }
+    else {
+      if (canSelectMulti)
+        setSelected([...selected, dataSet])
+      else
+        setSelected([dataSet])
+    }
  }

  const handleSelect = () => {
@@ -94,7 +126,7 @@ const SelectDataSet: FC<ISelectDataSetProps> = ({

      {hasNoData && (
        <div
-          className="mt-6 flex h-[128px] items-center justify-center space-x-1 rounded-lg border text-[13px]"
+          className="mt-6 flex h-[128px] items-center justify-center space-x-1  rounded-lg border text-[13px]"
          style={{
            background: 'rgba(0, 0, 0, 0.02)',
            borderColor: 'rgba(0, 0, 0, 0.02',
@@ -113,7 +145,7 @@ const SelectDataSet: FC<ISelectDataSetProps> = ({
                key={item.id}
                className={cn(
                  'flex h-10 cursor-pointer items-center rounded-lg border-[0.5px] border-components-panel-border-subtle bg-components-panel-on-panel-item-bg px-2 shadow-xs hover:border-components-panel-border hover:bg-components-panel-on-panel-item-bg-hover hover:shadow-sm',
-                  selectedIdsInModal.includes(item.id) && 'border-[1.5px] border-components-option-card-option-selected-border bg-state-accent-hover shadow-xs hover:border-components-option-card-option-selected-border hover:bg-state-accent-hover hover:shadow-xs',
+                  selected.some(i => i.id === item.id) && 'border-[1.5px] border-components-option-card-option-selected-border bg-state-accent-hover shadow-xs hover:border-components-option-card-option-selected-border hover:bg-state-accent-hover hover:shadow-xs',
                  !item.embedding_available && 'hover:border-components-panel-border-subtle hover:bg-components-panel-on-panel-item-bg hover:shadow-xs',
                )}
                onClick={() => {
@@ -163,7 +195,7 @@ const SelectDataSet: FC<ISelectDataSetProps> = ({
      )}
      {!isLoading && (
        <div className="mt-8 flex items-center justify-between">
-          <div className="text-sm font-medium text-text-secondary">
+          <div className="text-sm  font-medium text-text-secondary">
            {selected.length > 0 && `${selected.length} ${t('feature.dataSet.selected', { ns: 'appDebug' })}`}
          </div>
          <div className="flex space-x-2">
--- a/web/app/components/base/param-item/tests/score-threshold-item.spec.tsx
+++ b/web/app/components/base/param-item/tests/score-threshold-item.spec.tsx
@@ -137,11 +137,5 @@ describe('ScoreThresholdItem', () => {
      const input = screen.getByRole('textbox')
      expect(input).toHaveValue('1')
    })
-
-    it('should fall back to default value when value is undefined', () => {
-      render(<ScoreThresholdItem {...defaultProps} value={undefined} />)
-      const input = screen.getByRole('textbox')
-      expect(input).toHaveValue('0.7')
-    })
  })
 })
--- a/web/app/components/base/param-item/score-threshold-item.tsx
+++ b/web/app/components/base/param-item/score-threshold-item.tsx
@@ -6,7 +6,7 @@ import ParamItem from '.'

 type Props = {
  className?: string
-  value?: number
+  value: number
  onChange: (key: string, value: number) => void
  enable: boolean
  hasSwitch?: boolean
@@ -20,18 +20,6 @@ const VALUE_LIMIT = {
  max: 1,
 }

-const normalizeScoreThreshold = (value?: number): number => {
-  const normalizedValue = typeof value === 'number' && Number.isFinite(value)
-    ? value
-    : VALUE_LIMIT.default
-  const roundedValue = Number.parseFloat(normalizedValue.toFixed(2))
-
-  return Math.min(
-    VALUE_LIMIT.max,
-    Math.max(VALUE_LIMIT.min, roundedValue),
-  )
-}
-
 const ScoreThresholdItem: FC<Props> = ({
  className,
  value,
@@ -41,10 +29,16 @@ const ScoreThresholdItem: FC<Props> = ({
  onSwitchChange,
 }) => {
  const { t } = useTranslation()
-  const handleParamChange = (key: string, nextValue: number) => {
-    onChange(key, normalizeScoreThreshold(nextValue))
+  const handleParamChange = (key: string, value: number) => {
+    let notOutRangeValue = Number.parseFloat(value.toFixed(2))
+    notOutRangeValue = Math.max(VALUE_LIMIT.min, notOutRangeValue)
+    notOutRangeValue = Math.min(VALUE_LIMIT.max, notOutRangeValue)
+    onChange(key, notOutRangeValue)
  }
-  const safeValue = normalizeScoreThreshold(value)
+  const safeValue = Math.min(
+    VALUE_LIMIT.max,
+    Math.max(VALUE_LIMIT.min, Number.parseFloat(value.toFixed(2))),
+  )

  return (
    <ParamItem
--- a/web/app/components/workflow/block-selector/main.tsx
+++ b/web/app/components/workflow/block-selector/main.tsx
@@ -203,7 +203,7 @@ const NodeSelector: FC<NodeSelectorProps> = ({
              )
        }
      </PortalToFollowElemTrigger>
-      <PortalToFollowElemContent className="z-[1002]">
+      <PortalToFollowElemContent className="z-[1000]">
        <div className={`rounded-lg border-[0.5px] border-components-panel-border bg-components-panel-bg shadow-lg ${popupClassName}`}>
          <Tabs
            tabs={tabs}
--- a/web/app/components/workflow/block-selector/tool-picker.tsx
+++ b/web/app/components/workflow/block-selector/tool-picker.tsx
@@ -169,7 +169,7 @@ const ToolPicker: FC<Props> = ({
        {trigger}
      </PortalToFollowElemTrigger>

-      <PortalToFollowElemContent className="z-[1002]">
+      <PortalToFollowElemContent className="z-[1000]">
        <div className={cn('relative min-h-20 rounded-xl border-[0.5px] border-components-panel-border bg-components-panel-bg-blur shadow-lg backdrop-blur-sm', panelClassName)}>
          <div className="p-2 pb-1">
            <SearchBox
--- a/web/app/components/workflow/nodes/llm/components/json-schema-config-modal/code-editor.tsx
+++ b/web/app/components/workflow/nodes/llm/components/json-schema-config-modal/code-editor.tsx
@@ -117,7 +117,7 @@ const CodeEditor: FC<CodeEditorProps> = ({
    <div className={cn('flex h-full flex-col overflow-hidden bg-components-input-bg-normal', hideTopMenu && 'pt-2', className)}>
      {!hideTopMenu && (
        <div className="flex items-center justify-between pl-2 pr-1 pt-1">
-          <div className="system-xs-semibold-uppercase py-0.5 text-text-secondary">
+          <div className="py-0.5 text-text-secondary system-xs-semibold-uppercase">
            <span className="px-1 py-0.5">JSON</span>
          </div>
          <div className="flex items-center gap-x-0.5">
--- a/web/eslint-suppressions.json
+++ b/web/eslint-suppressions.json
@@ -928,6 +928,12 @@
  "app/components/app/configuration/dataset-config/select-dataset/index.tsx": {
    "no-restricted-imports": {
      "count": 1
+    },
+    "react-hooks-extra/no-direct-set-state-in-use-effect": {
+      "count": 2
+    },
+    "tailwindcss/no-unnecessary-whitespace": {
+      "count": 2
    }
  },
  "app/components/app/configuration/dataset-config/settings-modal/index.tsx": {
@@ -7875,9 +7881,6 @@
    "no-restricted-imports": {
      "count": 1
    },
-    "tailwindcss/enforce-consistent-class-order": {
-      "count": 1
-    },
    "ts/no-explicit-any": {
      "count": 4
    }
--- a/web/scripts/check-components-diff-coverage-lib.mjs
+++ b/web/scripts/check-components-diff-coverage-lib.mjs
@@ -2,11 +2,6 @@ import fs from 'node:fs'
 import path from 'node:path'

 const DIFF_COVERAGE_IGNORE_LINE_TOKEN = 'diff-coverage-ignore-line:'
-const DEFAULT_BRANCH_REF_CANDIDATES = ['origin/main', 'main']
-
-export function normalizeDiffRangeMode(mode) {
-  return mode === 'exact' ? 'exact' : 'merge-base'
-}

 export function buildGitDiffRevisionArgs(base, head, mode = 'merge-base') {
  return mode === 'exact'
@@ -14,46 +9,6 @@ export function buildGitDiffRevisionArgs(base, head, mode = 'merge-base') {
    : [`${base}...${head}`]
 }

-export function resolveGitDiffContext({
-  base,
-  head,
-  mode = 'merge-base',
-  execGit,
-}) {
-  const requestedMode = normalizeDiffRangeMode(mode)
-  const context = {
-    base,
-    head,
-    mode: requestedMode,
-    requestedMode,
-    reason: null,
-    useCombinedMergeDiff: false,
-  }
-
-  if (requestedMode !== 'exact' || !base || !head || !execGit)
-    return context
-
-  const baseCommit = resolveCommitSha(base, execGit) ?? base
-  const headCommit = resolveCommitSha(head, execGit) ?? head
-  const parents = getCommitParents(headCommit, execGit)
-  if (parents.length < 2)
-    return context
-
-  const [firstParent, secondParent] = parents
-  if (firstParent !== baseCommit)
-    return context
-
-  const defaultBranchRef = resolveDefaultBranchRef(execGit)
-  if (!defaultBranchRef || !isAncestor(secondParent, defaultBranchRef, execGit))
-    return context
-
-  return {
-    ...context,
-    reason: `ignored merge from ${defaultBranchRef}`,
-    useCombinedMergeDiff: true,
-  }
-}
-
 export function parseChangedLineMap(diff, isTrackedComponentSourceFile) {
  const lineMap = new Map()
  let currentFile = null
@@ -67,7 +22,7 @@ export function parseChangedLineMap(diff, isTrackedComponentSourceFile) {
    if (!currentFile || !isTrackedComponentSourceFile(currentFile))
      continue

-    const match = line.match(/^@{2,}(?: -\d+(?:,\d+)?)+ \+(\d+)(?:,(\d+))? @{2,}/)
+    const match = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/)
    if (!match)
      continue

@@ -176,15 +131,14 @@ export function getChangedBranchCoverage(entry, changedLines) {
  let total = 0

  for (const [branchId, branch] of Object.entries(entry.branchMap ?? {})) {
+    if (!branchIntersectsChangedLines(branch, changedLines))
+      continue
+
    const hits = Array.isArray(entry.b?.[branchId]) ? entry.b[branchId] : []
    const locations = getBranchLocations(branch)
    const armCount = Math.max(locations.length, hits.length)
-    const impactedArmIndexes = getImpactedBranchArmIndexes(branch, changedLines, armCount)

-    if (impactedArmIndexes.length === 0)
-      continue
-
-    for (const armIndex of impactedArmIndexes) {
+    for (let armIndex = 0; armIndex < armCount; armIndex += 1) {
      total += 1
      if ((hits[armIndex] ?? 0) > 0) {
        covered += 1
@@ -265,99 +219,24 @@ function emptyIgnoreResult(changedLines = []) {
  }
 }

-function getCommitParents(ref, execGit) {
-  const output = tryExecGit(execGit, ['rev-list', '--parents', '-n', '1', ref])
-  if (!output)
-    return []
-
-  return output
-    .trim()
-    .split(/\s+/)
-    .slice(1)
-}
-
-function resolveCommitSha(ref, execGit) {
-  return tryExecGit(execGit, ['rev-parse', '--verify', ref])?.trim() ?? null
-}
-
-function resolveDefaultBranchRef(execGit) {
-  const originHeadRef = tryExecGit(execGit, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'])?.trim()
-  if (originHeadRef)
-    return originHeadRef
-
-  for (const ref of DEFAULT_BRANCH_REF_CANDIDATES) {
-    if (tryExecGit(execGit, ['rev-parse', '--verify', '-q', ref]))
-      return ref
-  }
-
-  return null
-}
-
-function isAncestor(ancestorRef, descendantRef, execGit) {
-  try {
-    execGit(['merge-base', '--is-ancestor', ancestorRef, descendantRef])
-    return true
-  }
-  catch {
+function branchIntersectsChangedLines(branch, changedLines) {
+  if (!changedLines || changedLines.size === 0)
    return false
-  }
-}

-function tryExecGit(execGit, args) {
-  try {
-    return execGit(args)
-  }
-  catch {
-    return null
-  }
+  if (rangeIntersectsChangedLines(branch.loc, changedLines))
+    return true
+
+  const locations = getBranchLocations(branch)
+  if (locations.some(location => rangeIntersectsChangedLines(location, changedLines)))
+    return true
+
+  return branch.line ? changedLines.has(branch.line) : false
 }

 function getBranchLocations(branch) {
  return Array.isArray(branch?.locations) ? branch.locations.filter(Boolean) : []
 }

-function getImpactedBranchArmIndexes(branch, changedLines, armCount) {
-  if (!changedLines || changedLines.size === 0 || armCount === 0)
-    return []
-
-  const locations = getBranchLocations(branch)
-  if (isWholeBranchTouched(branch, changedLines, locations, armCount))
-    return Array.from({ length: armCount }, (_, armIndex) => armIndex)
-
-  const impactedArmIndexes = []
-  for (let armIndex = 0; armIndex < armCount; armIndex += 1) {
-    const location = locations[armIndex]
-    if (rangeIntersectsChangedLines(location, changedLines))
-      impactedArmIndexes.push(armIndex)
-  }
-
-  return impactedArmIndexes
-}
-
-function isWholeBranchTouched(branch, changedLines, locations, armCount) {
-  if (!changedLines || changedLines.size === 0)
-    return false
-
-  if (branch.line && changedLines.has(branch.line))
-    return true
-
-  const branchRange = branch.loc ?? branch
-  if (!rangeIntersectsChangedLines(branchRange, changedLines))
-    return false
-
-  if (locations.length === 0 || locations.length < armCount)
-    return true
-
-  for (const lineNumber of changedLines) {
-    if (!lineTouchesLocation(lineNumber, branchRange))
-      continue
-    if (!locations.some(location => lineTouchesLocation(lineNumber, location)))
-      return true
-  }
-
-  return false
-}
-
 function rangeIntersectsChangedLines(location, changedLines) {
  if (!location || !changedLines || changedLines.size === 0)
    return false
@@ -389,15 +268,6 @@ function getFirstChangedLineInRange(location, changedLines, fallbackLine = 1) {
  return startLine ?? fallbackLine
 }

-function lineTouchesLocation(lineNumber, location) {
-  const startLine = getLocationStartLine(location)
-  const endLine = getLocationEndLine(location) ?? startLine
-  if (!startLine || !endLine)
-    return false
-
-  return lineNumber >= startLine && lineNumber <= endLine
-}
-
 function getLocationStartLine(location) {
  return location?.start?.line ?? location?.line ?? null
 }
--- a/web/scripts/check-components-diff-coverage-lib.spec.ts
+++ b/web/scripts/check-components-diff-coverage-lib.spec.ts
@@ -1,118 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { parseChangedLineMap, resolveGitDiffContext } from './check-components-diff-coverage-lib.mjs'
-
-function createExecGitMock(responses: Record<string, string | Error>) {
-  return vi.fn((args: string[]) => {
-    const key = args.join(' ')
-    const response = responses[key]
-
-    if (response instanceof Error)
-      throw response
-
-    if (response === undefined)
-      throw new Error(`Unexpected git args: ${key}`)
-
-    return response
-  })
-}
-
-describe('resolveGitDiffContext', () => {
-  it('switches exact diff to combined merge diff when head merges origin/main into the branch', () => {
-    const execGit = createExecGitMock({
-      'rev-parse --verify feature-parent-sha': 'feature-parent-sha\n',
-      'rev-parse --verify merge-sha': 'merge-sha\n',
-      'rev-list --parents -n 1 merge-sha': 'merge-sha feature-parent-sha main-parent-sha\n',
-      'symbolic-ref --quiet --short refs/remotes/origin/HEAD': 'origin/main\n',
-      'merge-base --is-ancestor main-parent-sha origin/main': '',
-    })
-
-    expect(resolveGitDiffContext({
-      base: 'feature-parent-sha',
-      head: 'merge-sha',
-      mode: 'exact',
-      execGit,
-    })).toEqual({
-      base: 'feature-parent-sha',
-      head: 'merge-sha',
-      mode: 'exact',
-      requestedMode: 'exact',
-      reason: 'ignored merge from origin/main',
-      useCombinedMergeDiff: true,
-    })
-  })
-
-  it('falls back to origin/main when origin/HEAD is unavailable', () => {
-    const execGit = createExecGitMock({
-      'rev-parse --verify feature-parent-sha': 'feature-parent-sha\n',
-      'rev-parse --verify merge-sha': 'merge-sha\n',
-      'rev-list --parents -n 1 merge-sha': 'merge-sha feature-parent-sha main-parent-sha\n',
-      'symbolic-ref --quiet --short refs/remotes/origin/HEAD': new Error('missing origin/HEAD'),
-      'rev-parse --verify -q origin/main': 'main-tip-sha\n',
-      'merge-base --is-ancestor main-parent-sha origin/main': '',
-    })
-
-    expect(resolveGitDiffContext({
-      base: 'feature-parent-sha',
-      head: 'merge-sha',
-      mode: 'exact',
-      execGit,
-    })).toEqual({
-      base: 'feature-parent-sha',
-      head: 'merge-sha',
-      mode: 'exact',
-      requestedMode: 'exact',
-      reason: 'ignored merge from origin/main',
-      useCombinedMergeDiff: true,
-    })
-  })
-
-  it('keeps exact diff when the second parent is not the default branch', () => {
-    const execGit = createExecGitMock({
-      'rev-parse --verify feature-parent-sha': 'feature-parent-sha\n',
-      'rev-parse --verify merge-sha': 'merge-sha\n',
-      'rev-list --parents -n 1 merge-sha': 'merge-sha feature-parent-sha topic-parent-sha\n',
-      'symbolic-ref --quiet --short refs/remotes/origin/HEAD': 'origin/main\n',
-      'merge-base --is-ancestor topic-parent-sha origin/main': new Error('not ancestor'),
-    })
-
-    expect(resolveGitDiffContext({
-      base: 'feature-parent-sha',
-      head: 'merge-sha',
-      mode: 'exact',
-      execGit,
-    })).toEqual({
-      base: 'feature-parent-sha',
-      head: 'merge-sha',
-      mode: 'exact',
-      requestedMode: 'exact',
-      reason: null,
-      useCombinedMergeDiff: false,
-    })
-  })
-})
-
-describe('parseChangedLineMap', () => {
-  it('parses regular diff hunks', () => {
-    const diff = [
-      'diff --git a/web/app/components/example.tsx b/web/app/components/example.tsx',
-      '+++ b/web/app/components/example.tsx',
-      '@@ -10,0 +11,2 @@',
-    ].join('\n')
-
-    const changedLineMap = parseChangedLineMap(diff, () => true)
-
-    expect([...changedLineMap.get('web/app/components/example.tsx') ?? []]).toEqual([11, 12])
-  })
-
-  it('parses combined merge diff hunks', () => {
-    const diff = [
-      'diff --cc web/app/components/example.tsx',
-      '+++ b/web/app/components/example.tsx',
-      '@@@ -10,0 -10,0 +11,3 @@@',
-    ].join('\n')
-
-    const changedLineMap = parseChangedLineMap(diff, () => true)
-
-    expect([...changedLineMap.get('web/app/components/example.tsx') ?? []]).toEqual([11, 12, 13])
-  })
-})
--- a/web/scripts/check-components-diff-coverage.mjs
+++ b/web/scripts/check-components-diff-coverage.mjs
@@ -6,36 +6,41 @@ import {
  getChangedBranchCoverage,
  getChangedStatementCoverage,
  getIgnoredChangedLinesFromFile,
-  normalizeDiffRangeMode,
+  getLineHits,
+  normalizeToRepoRelative,
  parseChangedLineMap,
-  resolveGitDiffContext,
 } from './check-components-diff-coverage-lib.mjs'
-import { COMPONENT_COVERAGE_EXCLUDE_LABEL } from './component-coverage-filters.mjs'
 import {
-  APP_COMPONENTS_PREFIX,
-  createComponentCoverageContext,
-  getModuleName,
-  isAnyComponentSourceFile,
-  isExcludedComponentSourceFile,
-  isTrackedComponentSourceFile,
-  loadTrackedCoverageEntries,
-} from './components-coverage-common.mjs'
-import { EXCLUDED_COMPONENT_MODULES } from './components-coverage-thresholds.mjs'
+  collectComponentCoverageExcludedFiles,
+  COMPONENT_COVERAGE_EXCLUDE_LABEL,
+} from './component-coverage-filters.mjs'
+import {
+  COMPONENTS_GLOBAL_THRESHOLDS,
+  EXCLUDED_COMPONENT_MODULES,
+  getComponentModuleThreshold,
+} from './components-coverage-thresholds.mjs'

-const REQUESTED_DIFF_RANGE_MODE = normalizeDiffRangeMode(process.env.DIFF_RANGE_MODE)
+const APP_COMPONENTS_PREFIX = 'web/app/components/'
+const APP_COMPONENTS_COVERAGE_PREFIX = 'app/components/'
+const SHARED_TEST_PREFIX = 'web/__tests__/'
+const STRICT_TEST_FILE_TOUCH = process.env.STRICT_COMPONENT_TEST_TOUCH === 'true'
 const EXCLUDED_MODULES_LABEL = [...EXCLUDED_COMPONENT_MODULES].sort().join(', ')
+const DIFF_RANGE_MODE = process.env.DIFF_RANGE_MODE === 'exact' ? 'exact' : 'merge-base'

 const repoRoot = repoRootFromCwd()
-const context = createComponentCoverageContext(repoRoot)
+const webRoot = path.join(repoRoot, 'web')
+const excludedComponentCoverageFiles = new Set(
+  collectComponentCoverageExcludedFiles(path.join(webRoot, 'app/components'), { pathPrefix: 'web/app/components' }),
+)
 const baseSha = process.env.BASE_SHA?.trim()
 const headSha = process.env.HEAD_SHA?.trim() || 'HEAD'
-const coverageFinalPath = path.join(context.webRoot, 'coverage', 'coverage-final.json')
+const coverageFinalPath = path.join(webRoot, 'coverage', 'coverage-final.json')

 if (!baseSha || /^0+$/.test(baseSha)) {
  appendSummary([
-    '### app/components Pure Diff Coverage',
+    '### app/components Diff Coverage',
    '',
-    'Skipped pure diff coverage check because `BASE_SHA` was not available.',
+    'Skipped diff coverage check because `BASE_SHA` was not available.',
  ])
  process.exit(0)
 }
@@ -45,36 +50,55 @@ if (!fs.existsSync(coverageFinalPath)) {
  process.exit(1)
 }

-const diffContext = resolveGitDiffContext({
-  base: baseSha,
-  head: headSha,
-  mode: REQUESTED_DIFF_RANGE_MODE,
-  execGit,
-})
 const coverage = JSON.parse(fs.readFileSync(coverageFinalPath, 'utf8'))
-const changedFiles = getChangedFiles(diffContext)
+const changedFiles = getChangedFiles(baseSha, headSha)
 const changedComponentSourceFiles = changedFiles.filter(isAnyComponentSourceFile)
-const changedSourceFiles = changedComponentSourceFiles.filter(filePath => isTrackedComponentSourceFile(filePath, context.excludedComponentCoverageFiles))
-const changedExcludedSourceFiles = changedComponentSourceFiles.filter(filePath => isExcludedComponentSourceFile(filePath, context.excludedComponentCoverageFiles))
+const changedSourceFiles = changedComponentSourceFiles.filter(isTrackedComponentSourceFile)
+const changedExcludedSourceFiles = changedComponentSourceFiles.filter(isExcludedComponentSourceFile)
+const changedTestFiles = changedFiles.filter(isRelevantTestFile)

 if (changedSourceFiles.length === 0) {
  appendSummary(buildSkipSummary(changedExcludedSourceFiles))
  process.exit(0)
 }

-const coverageEntries = loadTrackedCoverageEntries(coverage, context)
-const diffChanges = getChangedLineMap(diffContext)
+const coverageEntries = new Map()
+for (const [file, entry] of Object.entries(coverage)) {
+  const repoRelativePath = normalizeToRepoRelative(entry.path ?? file, {
+    appComponentsCoveragePrefix: APP_COMPONENTS_COVERAGE_PREFIX,
+    appComponentsPrefix: APP_COMPONENTS_PREFIX,
+    repoRoot,
+    sharedTestPrefix: SHARED_TEST_PREFIX,
+    webRoot,
+  })
+  if (!isTrackedComponentSourceFile(repoRelativePath))
+    continue
+
+  coverageEntries.set(repoRelativePath, entry)
+}
+
+const fileCoverageRows = []
+const moduleCoverageMap = new Map()
+
+for (const [file, entry] of coverageEntries.entries()) {
+  const stats = getCoverageStats(entry)
+  const moduleName = getModuleName(file)
+  fileCoverageRows.push({ file, moduleName, ...stats })
+  mergeCoverageStats(moduleCoverageMap, moduleName, stats)
+}
+
+const overallCoverage = sumCoverageStats(fileCoverageRows)
+const diffChanges = getChangedLineMap(baseSha, headSha)
 const diffRows = []
 const ignoredDiffLines = []
 const invalidIgnorePragmas = []

 for (const [file, changedLines] of diffChanges.entries()) {
-  if (!isTrackedComponentSourceFile(file, context.excludedComponentCoverageFiles))
+  if (!isTrackedComponentSourceFile(file))
    continue

  const entry = coverageEntries.get(file)
  const ignoreInfo = getIgnoredChangedLinesFromFile(path.join(repoRoot, file), changedLines)
-
  for (const [line, reason] of ignoreInfo.ignoredLines.entries()) {
    ignoredDiffLines.push({
      file,
@@ -82,7 +106,6 @@ for (const [file, changedLines] of diffChanges.entries()) {
      reason,
    })
  }
-
  for (const invalidPragma of ignoreInfo.invalidPragmas) {
    invalidIgnorePragmas.push({
      file,
@@ -114,16 +137,40 @@ const diffTotals = diffRows.reduce((acc, row) => {

 const diffStatementFailures = diffRows.filter(row => row.statements.uncoveredLines.length > 0)
 const diffBranchFailures = diffRows.filter(row => row.branches.uncoveredBranches.length > 0)
+const overallThresholdFailures = getThresholdFailures(overallCoverage, COMPONENTS_GLOBAL_THRESHOLDS)
+const moduleCoverageRows = [...moduleCoverageMap.entries()]
+  .map(([moduleName, stats]) => ({
+    moduleName,
+    stats,
+    thresholds: getComponentModuleThreshold(moduleName),
+  }))
+  .map(row => ({
+    ...row,
+    failures: row.thresholds ? getThresholdFailures(row.stats, row.thresholds) : [],
+  }))
+const moduleThresholdFailures = moduleCoverageRows
+  .filter(row => row.failures.length > 0)
+  .flatMap(row => row.failures.map(failure => ({
+    moduleName: row.moduleName,
+    ...failure,
+  })))
+const hasRelevantTestChanges = changedTestFiles.length > 0
+const missingTestTouch = !hasRelevantTestChanges

 appendSummary(buildSummary({
-  changedSourceFiles,
-  diffContext,
+  overallCoverage,
+  overallThresholdFailures,
+  moduleCoverageRows,
+  moduleThresholdFailures,
  diffBranchFailures,
  diffRows,
  diffStatementFailures,
  diffTotals,
+  changedSourceFiles,
+  changedTestFiles,
  ignoredDiffLines,
  invalidIgnorePragmas,
+  missingTestTouch,
 }))

 if (process.env.CI) {
@@ -131,51 +178,107 @@ if (process.env.CI) {
    const firstLine = failure.statements.uncoveredLines[0] ?? 1
    console.log(`::error file=${failure.file},line=${firstLine}::Uncovered changed statements: ${formatLineRanges(failure.statements.uncoveredLines)}`)
  }
-
  for (const failure of diffBranchFailures.slice(0, 20)) {
    const firstBranch = failure.branches.uncoveredBranches[0]
    const line = firstBranch?.line ?? 1
    console.log(`::error file=${failure.file},line=${line}::Uncovered changed branches: ${formatBranchRefs(failure.branches.uncoveredBranches)}`)
  }
-
  for (const invalidPragma of invalidIgnorePragmas.slice(0, 20)) {
    console.log(`::error file=${invalidPragma.file},line=${invalidPragma.line}::Invalid diff coverage ignore pragma: ${invalidPragma.reason}`)
  }
 }

 if (
-  diffStatementFailures.length > 0
+  overallThresholdFailures.length > 0
+  || moduleThresholdFailures.length > 0
+  || diffStatementFailures.length > 0
  || diffBranchFailures.length > 0
  || invalidIgnorePragmas.length > 0
+  || (STRICT_TEST_FILE_TOUCH && missingTestTouch)
 ) {
  process.exit(1)
 }

 function buildSummary({
-  changedSourceFiles,
-  diffContext,
+  overallCoverage,
+  overallThresholdFailures,
+  moduleCoverageRows,
+  moduleThresholdFailures,
  diffBranchFailures,
  diffRows,
  diffStatementFailures,
  diffTotals,
+  changedSourceFiles,
+  changedTestFiles,
  ignoredDiffLines,
  invalidIgnorePragmas,
+  missingTestTouch,
 }) {
  const lines = [
-    '### app/components Pure Diff Coverage',
+    '### app/components Diff Coverage',
    '',
-    ...buildDiffContextSummary(diffContext),
+    `Compared \`${baseSha.slice(0, 12)}\` -> \`${headSha.slice(0, 12)}\``,
+    `Diff range mode: \`${DIFF_RANGE_MODE}\``,
    '',
    `Excluded modules: \`${EXCLUDED_MODULES_LABEL}\``,
    `Excluded file kinds: \`${COMPONENT_COVERAGE_EXCLUDE_LABEL}\``,
    '',
    '| Check | Result | Details |',
    '|---|---:|---|',
+    `| Overall tracked lines | ${formatPercent(overallCoverage.lines)} | ${overallCoverage.lines.covered}/${overallCoverage.lines.total}; threshold ${COMPONENTS_GLOBAL_THRESHOLDS.lines}% |`,
+    `| Overall tracked statements | ${formatPercent(overallCoverage.statements)} | ${overallCoverage.statements.covered}/${overallCoverage.statements.total}; threshold ${COMPONENTS_GLOBAL_THRESHOLDS.statements}% |`,
+    `| Overall tracked functions | ${formatPercent(overallCoverage.functions)} | ${overallCoverage.functions.covered}/${overallCoverage.functions.total}; threshold ${COMPONENTS_GLOBAL_THRESHOLDS.functions}% |`,
+    `| Overall tracked branches | ${formatPercent(overallCoverage.branches)} | ${overallCoverage.branches.covered}/${overallCoverage.branches.total}; threshold ${COMPONENTS_GLOBAL_THRESHOLDS.branches}% |`,
    `| Changed statements | ${formatDiffPercent(diffTotals.statements)} | ${diffTotals.statements.covered}/${diffTotals.statements.total} |`,
    `| Changed branches | ${formatDiffPercent(diffTotals.branches)} | ${diffTotals.branches.covered}/${diffTotals.branches.total} |`,
    '',
  ]

+  if (overallThresholdFailures.length > 0) {
+    lines.push('Overall thresholds failed:')
+    for (const failure of overallThresholdFailures)
+      lines.push(`- ${failure.metric}: ${failure.actual.toFixed(2)}% < ${failure.expected}%`)
+    lines.push('')
+  }
+
+  if (moduleThresholdFailures.length > 0) {
+    lines.push('Module thresholds failed:')
+    for (const failure of moduleThresholdFailures)
+      lines.push(`- ${failure.moduleName} ${failure.metric}: ${failure.actual.toFixed(2)}% < ${failure.expected}%`)
+    lines.push('')
+  }
+
+  const moduleRows = moduleCoverageRows
+    .map(({ moduleName, stats, thresholds, failures }) => ({
+      moduleName,
+      lines: percentage(stats.lines.covered, stats.lines.total),
+      statements: percentage(stats.statements.covered, stats.statements.total),
+      functions: percentage(stats.functions.covered, stats.functions.total),
+      branches: percentage(stats.branches.covered, stats.branches.total),
+      thresholds,
+      failures,
+    }))
+    .sort((a, b) => {
+      if (a.failures.length !== b.failures.length)
+        return b.failures.length - a.failures.length
+
+      return a.lines - b.lines || a.moduleName.localeCompare(b.moduleName)
+    })
+
+  lines.push('<details><summary>Module coverage</summary>')
+  lines.push('')
+  lines.push('| Module | Lines | Statements | Functions | Branches | Thresholds | Status |')
+  lines.push('|---|---:|---:|---:|---:|---|---|')
+  for (const row of moduleRows) {
+    const thresholdLabel = row.thresholds
+      ? `L${row.thresholds.lines}/S${row.thresholds.statements}/F${row.thresholds.functions}/B${row.thresholds.branches}`
+      : 'n/a'
+    const status = row.thresholds ? (row.failures.length > 0 ? 'fail' : 'pass') : 'info'
+    lines.push(`| ${row.moduleName} | ${row.lines.toFixed(2)}% | ${row.statements.toFixed(2)}% | ${row.functions.toFixed(2)}% | ${row.branches.toFixed(2)}% | ${thresholdLabel} | ${status} |`)
+  }
+  lines.push('</details>')
+  lines.push('')
+
  const changedRows = diffRows
    .filter(row => row.statements.total > 0 || row.branches.total > 0)
    .sort((a, b) => {
@@ -194,45 +297,59 @@ function buildSummary({
  lines.push('</details>')
  lines.push('')

+  if (missingTestTouch) {
+    lines.push(`Warning: tracked source files changed under \`web/app/components/\`, but no test files changed under \`web/app/components/**\` or \`web/__tests__/\`.`)
+    if (STRICT_TEST_FILE_TOUCH)
+      lines.push('`STRICT_COMPONENT_TEST_TOUCH=true` is enabled, so this warning fails the check.')
+    lines.push('')
+  }
+  else {
+    lines.push(`Relevant test files changed: ${changedTestFiles.length}`)
+    lines.push('')
+  }
+
  if (diffStatementFailures.length > 0) {
    lines.push('Uncovered changed statements:')
-    for (const row of diffStatementFailures)
+    for (const row of diffStatementFailures) {
      lines.push(`- ${row.file.replace('web/', '')}: ${formatLineRanges(row.statements.uncoveredLines)}`)
+    }
    lines.push('')
  }

  if (diffBranchFailures.length > 0) {
    lines.push('Uncovered changed branches:')
-    for (const row of diffBranchFailures)
+    for (const row of diffBranchFailures) {
      lines.push(`- ${row.file.replace('web/', '')}: ${formatBranchRefs(row.branches.uncoveredBranches)}`)
+    }
    lines.push('')
  }

  if (ignoredDiffLines.length > 0) {
    lines.push('Ignored changed lines via pragma:')
-    for (const ignoredLine of ignoredDiffLines)
+    for (const ignoredLine of ignoredDiffLines) {
      lines.push(`- ${ignoredLine.file.replace('web/', '')}:${ignoredLine.line} - ${ignoredLine.reason}`)
+    }
    lines.push('')
  }

  if (invalidIgnorePragmas.length > 0) {
    lines.push('Invalid diff coverage ignore pragmas:')
-    for (const invalidPragma of invalidIgnorePragmas)
+    for (const invalidPragma of invalidIgnorePragmas) {
      lines.push(`- ${invalidPragma.file.replace('web/', '')}:${invalidPragma.line} - ${invalidPragma.reason}`)
+    }
    lines.push('')
  }

  lines.push(`Changed source files checked: ${changedSourceFiles.length}`)
-  lines.push('Blocking rules: uncovered changed statements, uncovered changed branches, invalid ignore pragmas.')
+  lines.push(`Changed statement coverage: ${formatDiffPercent(diffTotals.statements)}`)
+  lines.push(`Changed branch coverage: ${formatDiffPercent(diffTotals.branches)}`)

  return lines
 }

 function buildSkipSummary(changedExcludedSourceFiles) {
  const lines = [
-    '### app/components Pure Diff Coverage',
-    '',
-    ...buildDiffContextSummary(diffContext),
+    '### app/components Diff Coverage',
    '',
    `Excluded modules: \`${EXCLUDED_MODULES_LABEL}\``,
    `Excluded file kinds: \`${COMPONENT_COVERAGE_EXCLUDE_LABEL}\``,
@@ -240,60 +357,146 @@ function buildSkipSummary(changedExcludedSourceFiles) {
  ]

  if (changedExcludedSourceFiles.length > 0) {
-    lines.push('Only excluded component modules or type-only files changed, so pure diff coverage was skipped.')
+    lines.push('Only excluded component modules or type-only files changed, so diff coverage check was skipped.')
    lines.push(`Skipped files: ${changedExcludedSourceFiles.length}`)
  }
  else {
-    lines.push('No tracked source changes under `web/app/components/`. Pure diff coverage skipped.')
+    lines.push('No source changes under tracked `web/app/components/`. Diff coverage check skipped.')
  }

  return lines
 }

-function buildDiffContextSummary(diffContext) {
-  const lines = [
-    `Compared \`${diffContext.base.slice(0, 12)}\` -> \`${diffContext.head.slice(0, 12)}\``,
-  ]
-
-  if (diffContext.useCombinedMergeDiff) {
-    lines.push(`Requested diff range mode: \`${diffContext.requestedMode}\``)
-    lines.push(`Effective diff strategy: \`combined-merge\` (${diffContext.reason})`)
-  }
-  else if (diffContext.reason) {
-    lines.push(`Requested diff range mode: \`${diffContext.requestedMode}\``)
-    lines.push(`Effective diff range mode: \`${diffContext.mode}\` (${diffContext.reason})`)
-  }
-  else {
-    lines.push(`Diff range mode: \`${diffContext.mode}\``)
-  }
-
-  return lines
-}
-
-function getChangedFiles(diffContext) {
-  if (diffContext.useCombinedMergeDiff) {
-    const output = execGit(['diff-tree', '--cc', '--no-commit-id', '--name-only', '-r', diffContext.head, '--', APP_COMPONENTS_PREFIX])
-    return output
-      .split('\n')
-      .map(line => line.trim())
-      .filter(Boolean)
-  }
-
-  const output = execGit(['diff', '--name-only', '--diff-filter=ACMR', ...buildGitDiffRevisionArgs(diffContext.base, diffContext.head, diffContext.mode), '--', APP_COMPONENTS_PREFIX])
+function getChangedFiles(base, head) {
+  const output = execGit(['diff', '--name-only', '--diff-filter=ACMR', ...buildGitDiffRevisionArgs(base, head, DIFF_RANGE_MODE), '--', 'web/app/components', 'web/__tests__'])
  return output
    .split('\n')
    .map(line => line.trim())
    .filter(Boolean)
 }

-function getChangedLineMap(diffContext) {
-  if (diffContext.useCombinedMergeDiff) {
-    const diff = execGit(['diff-tree', '--cc', '--no-commit-id', '-r', '--unified=0', diffContext.head, '--', APP_COMPONENTS_PREFIX])
-    return parseChangedLineMap(diff, filePath => isTrackedComponentSourceFile(filePath, context.excludedComponentCoverageFiles))
-  }
+function getChangedLineMap(base, head) {
+  const diff = execGit(['diff', '--unified=0', '--no-color', '--diff-filter=ACMR', ...buildGitDiffRevisionArgs(base, head, DIFF_RANGE_MODE), '--', 'web/app/components'])
+  return parseChangedLineMap(diff, isTrackedComponentSourceFile)
+}

-  const diff = execGit(['diff', '--unified=0', '--no-color', '--diff-filter=ACMR', ...buildGitDiffRevisionArgs(diffContext.base, diffContext.head, diffContext.mode), '--', APP_COMPONENTS_PREFIX])
-  return parseChangedLineMap(diff, filePath => isTrackedComponentSourceFile(filePath, context.excludedComponentCoverageFiles))
+function isAnyComponentSourceFile(filePath) {
+  return filePath.startsWith(APP_COMPONENTS_PREFIX)
+    && /\.(?:ts|tsx)$/.test(filePath)
+    && !isTestLikePath(filePath)
+}
+
+function isTrackedComponentSourceFile(filePath) {
+  return isAnyComponentSourceFile(filePath)
+    && !isExcludedComponentSourceFile(filePath)
+}
+
+function isExcludedComponentSourceFile(filePath) {
+  return isAnyComponentSourceFile(filePath)
+    && (
+      EXCLUDED_COMPONENT_MODULES.has(getModuleName(filePath))
+      || excludedComponentCoverageFiles.has(filePath)
+    )
+}
+
+function isRelevantTestFile(filePath) {
+  return filePath.startsWith(SHARED_TEST_PREFIX)
+    || (filePath.startsWith(APP_COMPONENTS_PREFIX) && isTestLikePath(filePath) && !isExcludedComponentTestFile(filePath))
+}
+
+function isExcludedComponentTestFile(filePath) {
+  if (!filePath.startsWith(APP_COMPONENTS_PREFIX))
+    return false
+
+  return EXCLUDED_COMPONENT_MODULES.has(getModuleName(filePath))
+}
+
+function isTestLikePath(filePath) {
+  return /(?:^|\/)__tests__\//.test(filePath)
+    || /(?:^|\/)__mocks__\//.test(filePath)
+    || /\.(?:spec|test)\.(?:ts|tsx)$/.test(filePath)
+    || /\.stories\.(?:ts|tsx)$/.test(filePath)
+    || /\.d\.ts$/.test(filePath)
+}
+
+function getCoverageStats(entry) {
+  const lineHits = getLineHits(entry)
+  const statementHits = Object.values(entry.s ?? {})
+  const functionHits = Object.values(entry.f ?? {})
+  const branchHits = Object.values(entry.b ?? {}).flat()
+
+  return {
+    lines: {
+      covered: Object.values(lineHits).filter(count => count > 0).length,
+      total: Object.keys(lineHits).length,
+    },
+    statements: {
+      covered: statementHits.filter(count => count > 0).length,
+      total: statementHits.length,
+    },
+    functions: {
+      covered: functionHits.filter(count => count > 0).length,
+      total: functionHits.length,
+    },
+    branches: {
+      covered: branchHits.filter(count => count > 0).length,
+      total: branchHits.length,
+    },
+  }
+}
+
+function sumCoverageStats(rows) {
+  const total = createEmptyCoverageStats()
+  for (const row of rows)
+    addCoverageStats(total, row)
+  return total
+}
+
+function mergeCoverageStats(map, moduleName, stats) {
+  const existing = map.get(moduleName) ?? createEmptyCoverageStats()
+  addCoverageStats(existing, stats)
+  map.set(moduleName, existing)
+}
+
+function addCoverageStats(target, source) {
+  for (const metric of ['lines', 'statements', 'functions', 'branches']) {
+    target[metric].covered += source[metric].covered
+    target[metric].total += source[metric].total
+  }
+}
+
+function createEmptyCoverageStats() {
+  return {
+    lines: { covered: 0, total: 0 },
+    statements: { covered: 0, total: 0 },
+    functions: { covered: 0, total: 0 },
+    branches: { covered: 0, total: 0 },
+  }
+}
+
+function getThresholdFailures(stats, thresholds) {
+  const failures = []
+  for (const metric of ['lines', 'statements', 'functions', 'branches']) {
+    const actual = percentage(stats[metric].covered, stats[metric].total)
+    const expected = thresholds[metric]
+    if (actual < expected) {
+      failures.push({
+        metric,
+        actual,
+        expected,
+      })
+    }
+  }
+  return failures
+}
+
+function getModuleName(filePath) {
+  const relativePath = filePath.slice(APP_COMPONENTS_PREFIX.length)
+  if (!relativePath)
+    return '(root)'
+
+  const segments = relativePath.split('/')
+  return segments.length === 1 ? '(root)' : segments[0]
 }

 function formatLineRanges(lines) {
@@ -333,6 +536,10 @@ function percentage(covered, total) {
  return (covered / total) * 100
 }

+function formatPercent(metric) {
+  return `${percentage(metric.covered, metric.total).toFixed(2)}%`
+}
+
 function formatDiffPercent(metric) {
  if (metric.total === 0)
    return 'n/a'
--- a/web/scripts/components-coverage-common.mjs
+++ b/web/scripts/components-coverage-common.mjs
@@ -1,195 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getLineHits, normalizeToRepoRelative } from './check-components-diff-coverage-lib.mjs'
-import { collectComponentCoverageExcludedFiles } from './component-coverage-filters.mjs'
-import { EXCLUDED_COMPONENT_MODULES } from './components-coverage-thresholds.mjs'
-
-export const APP_COMPONENTS_ROOT = 'web/app/components'
-export const APP_COMPONENTS_PREFIX = `${APP_COMPONENTS_ROOT}/`
-export const APP_COMPONENTS_COVERAGE_PREFIX = 'app/components/'
-export const SHARED_TEST_PREFIX = 'web/__tests__/'
-
-export function createComponentCoverageContext(repoRoot) {
-  const webRoot = path.join(repoRoot, 'web')
-  const excludedComponentCoverageFiles = new Set(
-    collectComponentCoverageExcludedFiles(path.join(webRoot, 'app/components'), { pathPrefix: APP_COMPONENTS_ROOT }),
-  )
-
-  return {
-    excludedComponentCoverageFiles,
-    repoRoot,
-    webRoot,
-  }
-}
-
-export function loadTrackedCoverageEntries(coverage, context) {
-  const coverageEntries = new Map()
-
-  for (const [file, entry] of Object.entries(coverage)) {
-    const repoRelativePath = normalizeToRepoRelative(entry.path ?? file, {
-      appComponentsCoveragePrefix: APP_COMPONENTS_COVERAGE_PREFIX,
-      appComponentsPrefix: APP_COMPONENTS_PREFIX,
-      repoRoot: context.repoRoot,
-      sharedTestPrefix: SHARED_TEST_PREFIX,
-      webRoot: context.webRoot,
-    })
-
-    if (!isTrackedComponentSourceFile(repoRelativePath, context.excludedComponentCoverageFiles))
-      continue
-
-    coverageEntries.set(repoRelativePath, entry)
-  }
-
-  return coverageEntries
-}
-
-export function collectTrackedComponentSourceFiles(context) {
-  const trackedFiles = []
-
-  walkComponentSourceFiles(path.join(context.webRoot, 'app/components'), (absolutePath) => {
-    const repoRelativePath = path.relative(context.repoRoot, absolutePath).split(path.sep).join('/')
-    if (isTrackedComponentSourceFile(repoRelativePath, context.excludedComponentCoverageFiles))
-      trackedFiles.push(repoRelativePath)
-  })
-
-  trackedFiles.sort((a, b) => a.localeCompare(b))
-  return trackedFiles
-}
-
-export function isTestLikePath(filePath) {
-  return /(?:^|\/)__tests__\//.test(filePath)
-    || /(?:^|\/)__mocks__\//.test(filePath)
-    || /\.(?:spec|test)\.(?:ts|tsx)$/.test(filePath)
-    || /\.stories\.(?:ts|tsx)$/.test(filePath)
-    || /\.d\.ts$/.test(filePath)
-}
-
-export function getModuleName(filePath) {
-  const relativePath = filePath.slice(APP_COMPONENTS_PREFIX.length)
-  if (!relativePath)
-    return '(root)'
-
-  const segments = relativePath.split('/')
-  return segments.length === 1 ? '(root)' : segments[0]
-}
-
-export function isAnyComponentSourceFile(filePath) {
-  return filePath.startsWith(APP_COMPONENTS_PREFIX)
-    && /\.(?:ts|tsx)$/.test(filePath)
-    && !isTestLikePath(filePath)
-}
-
-export function isExcludedComponentSourceFile(filePath, excludedComponentCoverageFiles) {
-  return isAnyComponentSourceFile(filePath)
-    && (
-      EXCLUDED_COMPONENT_MODULES.has(getModuleName(filePath))
-      || excludedComponentCoverageFiles.has(filePath)
-    )
-}
-
-export function isTrackedComponentSourceFile(filePath, excludedComponentCoverageFiles) {
-  return isAnyComponentSourceFile(filePath)
-    && !isExcludedComponentSourceFile(filePath, excludedComponentCoverageFiles)
-}
-
-export function isTrackedComponentTestFile(filePath) {
-  return filePath.startsWith(APP_COMPONENTS_PREFIX)
-    && isTestLikePath(filePath)
-    && !EXCLUDED_COMPONENT_MODULES.has(getModuleName(filePath))
-}
-
-export function isRelevantTestFile(filePath) {
-  return filePath.startsWith(SHARED_TEST_PREFIX)
-    || isTrackedComponentTestFile(filePath)
-}
-
-export function isAnyWebTestFile(filePath) {
-  return filePath.startsWith('web/')
-    && isTestLikePath(filePath)
-}
-
-export function getCoverageStats(entry) {
-  const lineHits = getLineHits(entry)
-  const statementHits = Object.values(entry.s ?? {})
-  const functionHits = Object.values(entry.f ?? {})
-  const branchHits = Object.values(entry.b ?? {}).flat()
-
-  return {
-    lines: {
-      covered: Object.values(lineHits).filter(count => count > 0).length,
-      total: Object.keys(lineHits).length,
-    },
-    statements: {
-      covered: statementHits.filter(count => count > 0).length,
-      total: statementHits.length,
-    },
-    functions: {
-      covered: functionHits.filter(count => count > 0).length,
-      total: functionHits.length,
-    },
-    branches: {
-      covered: branchHits.filter(count => count > 0).length,
-      total: branchHits.length,
-    },
-  }
-}
-
-export function sumCoverageStats(rows) {
-  const total = createEmptyCoverageStats()
-  for (const row of rows)
-    addCoverageStats(total, row)
-  return total
-}
-
-export function mergeCoverageStats(map, moduleName, stats) {
-  const existing = map.get(moduleName) ?? createEmptyCoverageStats()
-  addCoverageStats(existing, stats)
-  map.set(moduleName, existing)
-}
-
-export function percentage(covered, total) {
-  if (total === 0)
-    return 100
-  return (covered / total) * 100
-}
-
-export function formatPercent(metric) {
-  return `${percentage(metric.covered, metric.total).toFixed(2)}%`
-}
-
-function createEmptyCoverageStats() {
-  return {
-    lines: { covered: 0, total: 0 },
-    statements: { covered: 0, total: 0 },
-    functions: { covered: 0, total: 0 },
-    branches: { covered: 0, total: 0 },
-  }
-}
-
-function addCoverageStats(target, source) {
-  for (const metric of ['lines', 'statements', 'functions', 'branches']) {
-    target[metric].covered += source[metric].covered
-    target[metric].total += source[metric].total
-  }
-}
-
-function walkComponentSourceFiles(currentDir, onFile) {
-  if (!fs.existsSync(currentDir))
-    return
-
-  const entries = fs.readdirSync(currentDir, { withFileTypes: true })
-  for (const entry of entries) {
-    const entryPath = path.join(currentDir, entry.name)
-    if (entry.isDirectory()) {
-      if (entry.name === '__tests__' || entry.name === '__mocks__')
-        continue
-      walkComponentSourceFiles(entryPath, onFile)
-      continue
-    }
-
-    if (!/\.(?:ts|tsx)$/.test(entry.name) || isTestLikePath(entry.name))
-      continue
-
-    onFile(entryPath)
-  }
-}
--- a/web/scripts/report-components-coverage-baseline.mjs
+++ b/web/scripts/report-components-coverage-baseline.mjs
@@ -1,165 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-import { COMPONENT_COVERAGE_EXCLUDE_LABEL } from './component-coverage-filters.mjs'
-import {
-  collectTrackedComponentSourceFiles,
-  createComponentCoverageContext,
-  formatPercent,
-  getCoverageStats,
-  getModuleName,
-  loadTrackedCoverageEntries,
-  mergeCoverageStats,
-  percentage,
-  sumCoverageStats,
-} from './components-coverage-common.mjs'
-import {
-  COMPONENTS_GLOBAL_THRESHOLDS,
-  EXCLUDED_COMPONENT_MODULES,
-  getComponentModuleThreshold,
-} from './components-coverage-thresholds.mjs'
-
-const EXCLUDED_MODULES_LABEL = [...EXCLUDED_COMPONENT_MODULES].sort().join(', ')
-
-const repoRoot = repoRootFromCwd()
-const context = createComponentCoverageContext(repoRoot)
-const coverageFinalPath = path.join(context.webRoot, 'coverage', 'coverage-final.json')
-
-if (!fs.existsSync(coverageFinalPath)) {
-  console.error(`Coverage report not found at ${coverageFinalPath}`)
-  process.exit(1)
-}
-
-const coverage = JSON.parse(fs.readFileSync(coverageFinalPath, 'utf8'))
-const trackedSourceFiles = collectTrackedComponentSourceFiles(context)
-const coverageEntries = loadTrackedCoverageEntries(coverage, context)
-const fileCoverageRows = []
-const moduleCoverageMap = new Map()
-
-for (const [file, entry] of coverageEntries.entries()) {
-  const stats = getCoverageStats(entry)
-  const moduleName = getModuleName(file)
-  fileCoverageRows.push({ file, moduleName, ...stats })
-  mergeCoverageStats(moduleCoverageMap, moduleName, stats)
-}
-
-const overallCoverage = sumCoverageStats(fileCoverageRows)
-const overallTargetGaps = getTargetGaps(overallCoverage, COMPONENTS_GLOBAL_THRESHOLDS)
-const moduleCoverageRows = [...moduleCoverageMap.entries()]
-  .map(([moduleName, stats]) => ({
-    moduleName,
-    stats,
-    targets: getComponentModuleThreshold(moduleName),
-  }))
-  .map(row => ({
-    ...row,
-    targetGaps: row.targets ? getTargetGaps(row.stats, row.targets) : [],
-  }))
-  .sort((a, b) => {
-    const aWorst = Math.min(...a.targetGaps.map(gap => gap.delta), Number.POSITIVE_INFINITY)
-    const bWorst = Math.min(...b.targetGaps.map(gap => gap.delta), Number.POSITIVE_INFINITY)
-    return aWorst - bWorst || a.moduleName.localeCompare(b.moduleName)
-  })
-
-appendSummary(buildSummary({
-  coverageEntriesCount: coverageEntries.size,
-  moduleCoverageRows,
-  overallCoverage,
-  overallTargetGaps,
-  trackedSourceFilesCount: trackedSourceFiles.length,
-}))
-
-function buildSummary({
-  coverageEntriesCount,
-  moduleCoverageRows,
-  overallCoverage,
-  overallTargetGaps,
-  trackedSourceFilesCount,
-}) {
-  const lines = [
-    '### app/components Baseline Coverage',
-    '',
-    `Excluded modules: \`${EXCLUDED_MODULES_LABEL}\``,
-    `Excluded file kinds: \`${COMPONENT_COVERAGE_EXCLUDE_LABEL}\``,
-    '',
-    `Coverage entries: ${coverageEntriesCount}/${trackedSourceFilesCount} tracked source files`,
-    '',
-    '| Metric | Current | Target | Delta |',
-    '|---|---:|---:|---:|',
-    `| Lines | ${formatPercent(overallCoverage.lines)} | ${COMPONENTS_GLOBAL_THRESHOLDS.lines}% | ${formatDelta(overallCoverage.lines, COMPONENTS_GLOBAL_THRESHOLDS.lines)} |`,
-    `| Statements | ${formatPercent(overallCoverage.statements)} | ${COMPONENTS_GLOBAL_THRESHOLDS.statements}% | ${formatDelta(overallCoverage.statements, COMPONENTS_GLOBAL_THRESHOLDS.statements)} |`,
-    `| Functions | ${formatPercent(overallCoverage.functions)} | ${COMPONENTS_GLOBAL_THRESHOLDS.functions}% | ${formatDelta(overallCoverage.functions, COMPONENTS_GLOBAL_THRESHOLDS.functions)} |`,
-    `| Branches | ${formatPercent(overallCoverage.branches)} | ${COMPONENTS_GLOBAL_THRESHOLDS.branches}% | ${formatDelta(overallCoverage.branches, COMPONENTS_GLOBAL_THRESHOLDS.branches)} |`,
-    '',
-  ]
-
-  if (coverageEntriesCount !== trackedSourceFilesCount) {
-    lines.push('Warning: coverage report did not include every tracked component source file. CI should set `VITEST_COVERAGE_SCOPE=app-components` before collecting coverage.')
-    lines.push('')
-  }
-
-  if (overallTargetGaps.length > 0) {
-    lines.push('Below baseline targets:')
-    for (const gap of overallTargetGaps)
-      lines.push(`- overall ${gap.metric}: ${gap.actual.toFixed(2)}% < ${gap.target}%`)
-    lines.push('')
-  }
-
-  lines.push('<details><summary>Module baseline coverage</summary>')
-  lines.push('')
-  lines.push('| Module | Lines | Statements | Functions | Branches | Targets | Status |')
-  lines.push('|---|---:|---:|---:|---:|---|---|')
-  for (const row of moduleCoverageRows) {
-    const targetsLabel = row.targets
-      ? `L${row.targets.lines}/S${row.targets.statements}/F${row.targets.functions}/B${row.targets.branches}`
-      : 'n/a'
-    const status = row.targets
-      ? (row.targetGaps.length > 0 ? 'below-target' : 'at-target')
-      : 'unconfigured'
-    lines.push(`| ${row.moduleName} | ${percentage(row.stats.lines.covered, row.stats.lines.total).toFixed(2)}% | ${percentage(row.stats.statements.covered, row.stats.statements.total).toFixed(2)}% | ${percentage(row.stats.functions.covered, row.stats.functions.total).toFixed(2)}% | ${percentage(row.stats.branches.covered, row.stats.branches.total).toFixed(2)}% | ${targetsLabel} | ${status} |`)
-  }
-  lines.push('</details>')
-  lines.push('')
-  lines.push('Report only: baseline targets no longer gate CI. The blocking rule is the pure diff coverage step.')
-
-  return lines
-}
-
-function getTargetGaps(stats, targets) {
-  const gaps = []
-  for (const metric of ['lines', 'statements', 'functions', 'branches']) {
-    const actual = percentage(stats[metric].covered, stats[metric].total)
-    const target = targets[metric]
-    const delta = actual - target
-    if (delta < 0) {
-      gaps.push({
-        actual,
-        delta,
-        metric,
-        target,
-      })
-    }
-  }
-  return gaps
-}
-
-function formatDelta(metric, target) {
-  const actual = percentage(metric.covered, metric.total)
-  const delta = actual - target
-  const sign = delta >= 0 ? '+' : ''
-  return `${sign}${delta.toFixed(2)}%`
-}
-
-function appendSummary(lines) {
-  const content = `${lines.join('\n')}\n`
-  if (process.env.GITHUB_STEP_SUMMARY)
-    fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, content)
-  console.log(content)
-}
-
-function repoRootFromCwd() {
-  return execFileSync('git', ['rev-parse', '--show-toplevel'], {
-    cwd: process.cwd(),
-    encoding: 'utf8',
-  }).trim()
-}
--- a/web/scripts/report-components-test-touch.mjs
+++ b/web/scripts/report-components-test-touch.mjs
@@ -1,168 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import fs from 'node:fs'
-import {
-  buildGitDiffRevisionArgs,
-  normalizeDiffRangeMode,
-  resolveGitDiffContext,
-} from './check-components-diff-coverage-lib.mjs'
-import {
-  createComponentCoverageContext,
-  isAnyWebTestFile,
-  isRelevantTestFile,
-  isTrackedComponentSourceFile,
-} from './components-coverage-common.mjs'
-
-const REQUESTED_DIFF_RANGE_MODE = normalizeDiffRangeMode(process.env.DIFF_RANGE_MODE)
-
-const repoRoot = repoRootFromCwd()
-const context = createComponentCoverageContext(repoRoot)
-const baseSha = process.env.BASE_SHA?.trim()
-const headSha = process.env.HEAD_SHA?.trim() || 'HEAD'
-
-if (!baseSha || /^0+$/.test(baseSha)) {
-  appendSummary([
-    '### app/components Test Touch',
-    '',
-    'Skipped test-touch report because `BASE_SHA` was not available.',
-  ])
-  process.exit(0)
-}
-
-const diffContext = resolveGitDiffContext({
-  base: baseSha,
-  head: headSha,
-  mode: REQUESTED_DIFF_RANGE_MODE,
-  execGit,
-})
-const changedFiles = getChangedFiles(diffContext)
-const changedSourceFiles = changedFiles.filter(filePath => isTrackedComponentSourceFile(filePath, context.excludedComponentCoverageFiles))
-
-if (changedSourceFiles.length === 0) {
-  appendSummary([
-    '### app/components Test Touch',
-    '',
-    ...buildDiffContextSummary(diffContext),
-    '',
-    'No tracked source changes under `web/app/components/`. Test-touch report skipped.',
-  ])
-  process.exit(0)
-}
-
-const changedRelevantTestFiles = changedFiles.filter(isRelevantTestFile)
-const changedOtherWebTestFiles = changedFiles.filter(filePath => isAnyWebTestFile(filePath) && !isRelevantTestFile(filePath))
-const totalChangedWebTests = [...new Set([...changedRelevantTestFiles, ...changedOtherWebTestFiles])]
-
-appendSummary(buildSummary({
-  changedOtherWebTestFiles,
-  changedRelevantTestFiles,
-  diffContext,
-  changedSourceFiles,
-  totalChangedWebTests,
-}))
-
-function buildSummary({
-  changedOtherWebTestFiles,
-  changedRelevantTestFiles,
-  diffContext,
-  changedSourceFiles,
-  totalChangedWebTests,
-}) {
-  const lines = [
-    '### app/components Test Touch',
-    '',
-    ...buildDiffContextSummary(diffContext),
-    '',
-    `Tracked source files changed: ${changedSourceFiles.length}`,
-    `Component-local or shared integration tests changed: ${changedRelevantTestFiles.length}`,
-    `Other web tests changed: ${changedOtherWebTestFiles.length}`,
-    `Total changed web tests: ${totalChangedWebTests.length}`,
-    '',
-  ]
-
-  if (totalChangedWebTests.length === 0) {
-    lines.push('Warning: no frontend test files changed alongside tracked component source changes.')
-    lines.push('')
-  }
-
-  if (changedRelevantTestFiles.length > 0) {
-    lines.push('<details><summary>Changed component-local or shared tests</summary>')
-    lines.push('')
-    for (const filePath of changedRelevantTestFiles.slice(0, 40))
-      lines.push(`- ${filePath.replace('web/', '')}`)
-    if (changedRelevantTestFiles.length > 40)
-      lines.push(`- ... ${changedRelevantTestFiles.length - 40} more`)
-    lines.push('</details>')
-    lines.push('')
-  }
-
-  if (changedOtherWebTestFiles.length > 0) {
-    lines.push('<details><summary>Changed other web tests</summary>')
-    lines.push('')
-    for (const filePath of changedOtherWebTestFiles.slice(0, 40))
-      lines.push(`- ${filePath.replace('web/', '')}`)
-    if (changedOtherWebTestFiles.length > 40)
-      lines.push(`- ... ${changedOtherWebTestFiles.length - 40} more`)
-    lines.push('</details>')
-    lines.push('')
-  }
-
-  lines.push('Report only: test-touch is now advisory and no longer blocks the diff coverage gate.')
-  return lines
-}
-
-function buildDiffContextSummary(diffContext) {
-  const lines = [
-    `Compared \`${diffContext.base.slice(0, 12)}\` -> \`${diffContext.head.slice(0, 12)}\``,
-  ]
-
-  if (diffContext.useCombinedMergeDiff) {
-    lines.push(`Requested diff range mode: \`${diffContext.requestedMode}\``)
-    lines.push(`Effective diff strategy: \`combined-merge\` (${diffContext.reason})`)
-  }
-  else if (diffContext.reason) {
-    lines.push(`Requested diff range mode: \`${diffContext.requestedMode}\``)
-    lines.push(`Effective diff range mode: \`${diffContext.mode}\` (${diffContext.reason})`)
-  }
-  else {
-    lines.push(`Diff range mode: \`${diffContext.mode}\``)
-  }
-
-  return lines
-}
-
-function getChangedFiles(diffContext) {
-  if (diffContext.useCombinedMergeDiff) {
-    const output = execGit(['diff-tree', '--cc', '--no-commit-id', '--name-only', '-r', diffContext.head, '--', 'web'])
-    return output
-      .split('\n')
-      .map(line => line.trim())
-      .filter(Boolean)
-  }
-
-  const output = execGit(['diff', '--name-only', '--diff-filter=ACMR', ...buildGitDiffRevisionArgs(diffContext.base, diffContext.head, diffContext.mode), '--', 'web'])
-  return output
-    .split('\n')
-    .map(line => line.trim())
-    .filter(Boolean)
-}
-
-function appendSummary(lines) {
-  const content = `${lines.join('\n')}\n`
-  if (process.env.GITHUB_STEP_SUMMARY)
-    fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, content)
-  console.log(content)
-}
-
-function execGit(args) {
-  return execFileSync('git', args, {
-    cwd: repoRoot,
-    encoding: 'utf8',
-  })
-}
-
-function repoRootFromCwd() {
-  return execFileSync('git', ['rev-parse', '--show-toplevel'], {
-    cwd: process.cwd(),
-    encoding: 'utf8',
-  }).trim()
-}
Author	SHA1	Message	Date
yyh	c1e834742b	Merge branch 'main' into 3-16-revert-changes	2026-03-16 19:57:42 +08:00
autofix-ci[bot]	9d2755eb85	[autofix.ci] apply automated fixes	2026-03-16 10:57:04 +00:00
Stephen Zhou	b80b0bd7a3	chore: bring back monaco-editor-react, revert #32966	2026-03-16 18:53:20 +08:00