open-code-review-toolkit 0.8.2__tar.gz → 0.8.4__tar.gz

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-code-review-toolkit
-Version: 0.8.2
+Version: 0.8.4
 Summary: Unofficial GitLab CI integration layer for Open Code Review
 Project-URL: Homepage, https://github.com/xeonvs/open-code-review-toolkit
 Project-URL: Repository, https://github.com/xeonvs/open-code-review-toolkit
@@ -249,7 +249,7 @@ ocr-ci --help
 The exact recommended OCR release and its verified asset checksums live in the [versioned compatibility manifest](compatibility/ocr-support.json). CI should pin that release and checksum before execution.
 The [versioned compatibility policy](docs/compatibility.md) records tested assets and evidence and describes the conservative Dependabot-like qualification workflow for later upstream releases.
 Review output defaults to English. `OCR_REVIEW_LANGUAGE` accepts another explicit language name when a project needs localized review output; for example, `OCR_REVIEW_LANGUAGE=Russian`.
-The current OCR 1.10.0 integration defaults `OCR_REVIEW_EFFORT` to `medium` for two review rounds. `low` and `high` are explicit one- and three-round alternatives; see the [configuration reference](docs/configuration.md#review-effort) for cost, budget, and precedence boundaries.
+The current OCR 1.10.1 integration defaults `OCR_REVIEW_EFFORT` to `medium` for two review rounds. `low` and `high` are explicit one- and three-round alternatives; see the [configuration reference](docs/configuration.md#review-effort) for cost, budget, and precedence boundaries.
 
 Stable distributions are published to [PyPI](https://pypi.org/project/open-code-review-toolkit/) and mirrored as checksum-listed, provenance-attested assets in the corresponding [GitHub Release](https://github.com/xeonvs/open-code-review-toolkit/releases). Development snapshots are published only to TestPyPI.
 

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/README.md

@@ -22,7 +22,7 @@ ocr-ci --help
 The exact recommended OCR release and its verified asset checksums live in the [versioned compatibility manifest](compatibility/ocr-support.json). CI should pin that release and checksum before execution.
 The [versioned compatibility policy](docs/compatibility.md) records tested assets and evidence and describes the conservative Dependabot-like qualification workflow for later upstream releases.
 Review output defaults to English. `OCR_REVIEW_LANGUAGE` accepts another explicit language name when a project needs localized review output; for example, `OCR_REVIEW_LANGUAGE=Russian`.
-The current OCR 1.10.0 integration defaults `OCR_REVIEW_EFFORT` to `medium` for two review rounds. `low` and `high` are explicit one- and three-round alternatives; see the [configuration reference](docs/configuration.md#review-effort) for cost, budget, and precedence boundaries.
+The current OCR 1.10.1 integration defaults `OCR_REVIEW_EFFORT` to `medium` for two review rounds. `low` and `high` are explicit one- and three-round alternatives; see the [configuration reference](docs/configuration.md#review-effort) for cost, budget, and precedence boundaries.
 
 Stable distributions are published to [PyPI](https://pypi.org/project/open-code-review-toolkit/) and mirrored as checksum-listed, provenance-attested assets in the corresponding [GitHub Release](https://github.com/xeonvs/open-code-review-toolkit/releases). Development snapshots are published only to TestPyPI.
 

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/src/ocr_toolkit/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.8.2'
-__version_tuple__ = version_tuple = (0, 8, 2)
+__version__ = version = '0.8.4'
+__version_tuple__ = version_tuple = (0, 8, 4)
 
 __commit_id__ = commit_id = None

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/src/ocr_toolkit/context/dlp.py

@@ -109,7 +109,7 @@ class ForbiddenMatcher:
         exact: list[str] = []
         seen: set[str] = set()
         for value in values:
-            candidate = normalize_text(value)
+            candidate = normalize_text(value, allow_horizontal_tabs=True)
             if not candidate:
                 continue
             for representation in (_display_normalize(candidate), _source_normalize(candidate)):
@@ -157,14 +157,16 @@ class ForbiddenMatcher:
         return self.match_reason(value) is not None
 
 
-def normalize_text(value: object) -> str | None:
+def normalize_text(value: object, *, allow_horizontal_tabs: bool = False) -> str | None:
     """Normalize NFC/newlines and reject unsupported controls."""
 
     if not isinstance(value, str):
         return None
     normalized = unicodedata.normalize("NFC", value.replace("\r\n", "\n").replace("\r", "\n"))
+    allowed_controls = "\n\t" if allow_horizontal_tabs else "\n"
     if any(
-        unicodedata.category(character) in {"Cc", "Cf", "Cs", "Zl", "Zp"} and character != "\n"
+        unicodedata.category(character) in {"Cc", "Cf", "Cs", "Zl", "Zp"}
+        and character not in allowed_controls
         for character in normalized
     ):
         return None
@@ -178,10 +180,11 @@ def check_text(
     publication: bool = False,
     forbidden: tuple[str, ...] = (),
     forbidden_matcher: ForbiddenMatcher | None = None,
+    allow_horizontal_tabs: bool = False,
 ) -> DLPResult:
     """Apply independent units, redaction, PII, and optional publication checks."""
 
-    normalized = normalize_text(value)
+    normalized = normalize_text(value, allow_horizontal_tabs=allow_horizontal_tabs)
     if normalized is None:
         return DLPResult(False, None, "invalid_text", "type_or_control")
     normalized_bytes = normalized.encode("utf-8")

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/src/ocr_toolkit/ocr_result.py

@@ -9,6 +9,7 @@ import secrets
 import stat
 import sys
 from collections.abc import Callable, Mapping
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
@@ -20,6 +21,11 @@ MAX_RESULT_BYTES_HARD_LIMIT = 20_000_000
 TOOLKIT_RESULT_KEY = "_ocr_toolkit"
 TOOLKIT_RESULT_SCHEMA_VERSION = 5
 SUPPORTED_TOOLKIT_RESULT_SCHEMA_VERSIONS = frozenset({TOOLKIT_RESULT_SCHEMA_VERSION})
+TOOLKIT_ADVISORY_KEY = "_ocr_toolkit_advisory"
+TOOLKIT_ADVISORY_SCHEMA_VERSION = "ocr.toolkit-advisory/v1"
+TOOLKIT_ADVISORY_KIND = "background_recommended_limit"
+TOOLKIT_ADVISORY_UNIT = "characters"
+MAX_TOOLKIT_ADVISORY_VALUE = 999_999_999_999
 # The receipt can name the 16 configured external servers plus the mandatory built-in.
 MAX_TOOLKIT_MCP_USAGE_SERVERS = 17
 MAX_TOOLKIT_MCP_TOOLS_PER_SERVER = 128
@@ -27,6 +33,23 @@ MAX_TOOLKIT_MCP_TOOL_NAME_CHARS = 4_096
 MAX_TOOLKIT_MCP_USAGE_COUNT = 1_000_000_000
 TOOLKIT_MCP_SERVER_NAME_RE = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
 
+# Closed names whose numeric call counts may appear in the public review summary.
+# Dynamic external MCP tools remain represented by the receipt's verified
+# per-server aggregate so provider-controlled names do not cross into GitLab.
+PUBLIC_REVIEW_TOOL_CALL_NAMES = frozenset(
+    {
+        "code_comment",
+        "code_search",
+        "context_get",
+        "context_list",
+        "file_find",
+        "file_read",
+        "file_read_diff",
+        "ocr_toolkit_evidence",
+        "task_done",
+    }
+)
+
 
 class OcrResultMissing(Exception):
     """The OCR result artifact is missing or unreadable on disk."""
@@ -40,6 +63,69 @@ class OcrResultTooLarge(Exception):
     """The OCR result artifact exceeds the configured safety limit."""
 
 
+@dataclass(frozen=True, slots=True)
+class OcrToolkitAdvisory:
+    """Carry one validated toolkit-authored numeric OCR advisory."""
+
+    actual: int
+    recommended: int
+
+
+def parse_toolkit_advisory(value: Any) -> OcrToolkitAdvisory:
+    """Parse the exact private toolkit advisory without accepting extensions."""
+
+    if not isinstance(value, dict) or set(value) != {
+        "schema_version",
+        "kind",
+        "actual",
+        "recommended",
+        "unit",
+    }:
+        raise OcrResultMalformed("OCR toolkit advisory has an unsupported schema")
+    actual = value.get("actual")
+    recommended = value.get("recommended")
+    if (
+        value.get("schema_version") != TOOLKIT_ADVISORY_SCHEMA_VERSION
+        or value.get("kind") != TOOLKIT_ADVISORY_KIND
+        or value.get("unit") != TOOLKIT_ADVISORY_UNIT
+        or not isinstance(actual, int)
+        or isinstance(actual, bool)
+        or not isinstance(recommended, int)
+        or isinstance(recommended, bool)
+        or not 0 < recommended < actual <= MAX_TOOLKIT_ADVISORY_VALUE
+    ):
+        raise OcrResultMalformed("OCR toolkit advisory has invalid closed values")
+    return OcrToolkitAdvisory(actual=actual, recommended=recommended)
+
+
+def background_recommended_advisory(*, actual: int, recommended: int) -> OcrToolkitAdvisory:
+    """Construct one validated background recommendation advisory."""
+
+    return parse_toolkit_advisory(
+        {
+            "schema_version": TOOLKIT_ADVISORY_SCHEMA_VERSION,
+            "kind": TOOLKIT_ADVISORY_KIND,
+            "actual": actual,
+            "recommended": recommended,
+            "unit": TOOLKIT_ADVISORY_UNIT,
+        }
+    )
+
+
+def toolkit_advisory_payload(advisory: OcrToolkitAdvisory) -> dict[str, object]:
+    """Serialize a validated advisory into its exact private result shape."""
+
+    payload: dict[str, object] = {
+        "schema_version": TOOLKIT_ADVISORY_SCHEMA_VERSION,
+        "kind": TOOLKIT_ADVISORY_KIND,
+        "actual": advisory.actual,
+        "recommended": advisory.recommended,
+        "unit": TOOLKIT_ADVISORY_UNIT,
+    }
+    parse_toolkit_advisory(payload)
+    return payload
+
+
 def max_result_bytes() -> int:
     """Return the maximum OCR JSON artifact size to read into memory."""
 
@@ -217,7 +303,16 @@ def _decode_result(data: bytes) -> Any:
     except UnicodeDecodeError as exc:
         raise OcrResultMalformed(str(exc)) from exc
     try:
-        return json.loads(text)
+
+        def reject_duplicate_advisory(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+            result: dict[str, Any] = {}
+            for key, value in pairs:
+                if key == TOOLKIT_ADVISORY_KEY and key in result:
+                    raise OcrResultMalformed("OCR result repeats the reserved toolkit advisory")
+                result[key] = value
+            return result
+
+        return json.loads(text, object_pairs_hook=reject_duplicate_advisory)
     except (json.JSONDecodeError, RecursionError) as exc:
         raise OcrResultMalformed(str(exc)) from exc
 

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/src/ocr_toolkit/posting/approval.py

@@ -14,10 +14,11 @@ from ocr_toolkit.ocr_result import (
     TOOLKIT_MCP_SERVER_NAME_RE,
 )
 from ocr_toolkit.posting.settings import BooleanSetting
-from ocr_toolkit.result_contract import ReviewOutcome
+from ocr_toolkit.result_contract import OcrResultContractError, ReviewOutcome
 
 ALLOWED_CATEGORIES = frozenset({"style", "documentation", "maintainability"})
 MAX_APPROVABLE_FINDINGS = 3
+INVALID_APPROVAL_RECEIPT_REASON = "the review-time approval receipt is missing or invalid"
 
 
 class ApprovalStatus(str, Enum):
@@ -218,6 +219,23 @@ def publication_dlp_state(value: Any) -> str | None:
         )
     ):
         return None
+    selected = original["selected"]
+    completed = original["completed"]
+    reused = original["reused"]
+    failed = original["failed"]
+    waived = original["waived"]
+    outcome = original["outcome"]
+    derived_outcomes = {"failed"} | (
+        {"skipped"}
+        if selected == 0
+        else {"clean", "warning"}
+        if failed == 0
+        else {"failed"}
+        if failed == selected
+        else {"partial"}
+    )
+    if selected != completed + reused + failed + waived or outcome not in derived_outcomes:
+        return None
     return "publication-filtered"
 
 
@@ -237,7 +255,7 @@ def _valid_dlp_reason_counts(value: Any) -> bool:
 def automatic_approval_metadata_reason(toolkit_metadata: Any) -> str:
     """Return the closed review-time receipt blocker for automatic approval."""
 
-    invalid = "the review-time approval receipt is missing or invalid"
+    invalid = INVALID_APPROVAL_RECEIPT_REASON
     if not isinstance(toolkit_metadata, dict):
         return invalid
     if toolkit_metadata.get("schema_version") != 5 or set(toolkit_metadata) != {
@@ -433,6 +451,51 @@ def automatic_approval_metadata_reason(toolkit_metadata: Any) -> str:
     return ""
 
 
+def toolkit_receipt_is_valid(toolkit_metadata: Any) -> bool:
+    """Return whether metadata is an exact receipt v5, including valid blockers."""
+
+    return automatic_approval_metadata_reason(toolkit_metadata) != INVALID_APPROVAL_RECEIPT_REASON
+
+
+def publication_outcome_for_summary(outcome: ReviewOutcome, publication: Any) -> ReviewOutcome:
+    """Recover only validated original coverage facts from a filtered receipt."""
+
+    if publication_dlp_state(publication) != "publication-filtered":
+        return outcome
+    if outcome.kind != "partial" or outcome.manifest_present:
+        raise OcrResultContractError(
+            "publication-filtered receipt is not bound to a safe result projection"
+        )
+    original = publication["original"]
+    kind = original["outcome"]
+    if outcome.budget_exceeded and kind != "partial":
+        raise OcrResultContractError(
+            "publication-filtered receipt contradicts the result budget state"
+        )
+    counts = {
+        field: original[field] for field in ("selected", "completed", "reused", "failed", "waived")
+    }
+    manifest_present = any(counts.values())
+    status = {
+        "clean": "complete" if manifest_present else "success",
+        "warning": "completed_with_warnings",
+        "partial": "budget_exceeded" if outcome.budget_exceeded else "completed_with_errors",
+        "failed": "failed",
+        "skipped": "skipped",
+    }[kind]
+    return ReviewOutcome(
+        status=status,
+        kind=kind,
+        budget_exceeded=outcome.budget_exceeded and kind == "partial",
+        manifest_present=manifest_present,
+        selected_count=counts["selected"],
+        completed_count=counts["completed"],
+        reused_count=counts["reused"],
+        failed_count=counts["failed"],
+        waived_count=counts["waived"],
+    )
+
+
 def _valid_evidence_actions(value: Any, evidence_calls: Any) -> bool:
     """Validate verified counts or an explicit unavailable attribution state."""
 

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/src/ocr_toolkit/posting/formatting.py

@@ -20,8 +20,10 @@ from ocr_toolkit.common.redaction import redact_sensitive
 from ocr_toolkit.ocr_result import (
     MAX_TOOLKIT_MCP_USAGE_COUNT,
     MAX_TOOLKIT_MCP_USAGE_SERVERS,
+    PUBLIC_REVIEW_TOOL_CALL_NAMES,
     SUPPORTED_TOOLKIT_RESULT_SCHEMA_VERSIONS,
     TOOLKIT_MCP_SERVER_NAME_RE,
+    OcrToolkitAdvisory,
 )
 from ocr_toolkit.posting.approval import (
     ApprovalResult,
@@ -45,8 +47,6 @@ from ocr_toolkit.posting.settings import (
     MAX_REVIEWER_GUIDE_LABEL_CHARS,
     MAX_REVIEWER_GUIDE_LOCATION_CHARS,
     MAX_REVIEWER_GUIDE_TEXT_CHARS,
-    MAX_TOOL_CALL_NAME_CHARS,
-    MAX_TOOL_CALL_SUMMARY_TOOLS,
     SUGGESTION_HEADER,
     post_badges,
     post_emoji,
@@ -374,32 +374,25 @@ def nonnegative_int(value: Any) -> int | None:
     return None
 
 
-def truncate_tool_call_name(name: str) -> str:
-    """Return a compact tool name for one-line MR summaries."""
-
-    if len(name) <= MAX_TOOL_CALL_NAME_CHARS:
-        return name
-
-    return name[: MAX_TOOL_CALL_NAME_CHARS - 3].rstrip() + "..."
-
-
 def tool_call_name(value: Any) -> str:
-    """Extract a displayable tool name from common OCR tool-call shapes."""
+    """Extract one closed public tool name from common OCR call shapes."""
 
     if isinstance(value, str):
-        return clean_text(value)
+        name = clean_text(value)
+        return name if name in PUBLIC_REVIEW_TOOL_CALL_NAMES else ""
 
     if not isinstance(value, dict):
         return ""
 
     for key in ("name", "tool", "tool_name"):
         name = clean_text(value.get(key))
-        if name:
+        if name in PUBLIC_REVIEW_TOOL_CALL_NAMES:
             return name
 
     function_value = value.get("function")
     if isinstance(function_value, dict):
-        return clean_text(function_value.get("name"))
+        name = clean_text(function_value.get("name"))
+        return name if name in PUBLIC_REVIEW_TOOL_CALL_NAMES else ""
 
     return ""
 
@@ -407,14 +400,17 @@ def tool_call_name(value: Any) -> str:
 def tool_call_counts_from_items(
     items: list[Any],
 ) -> tuple[int | None, list[tuple[str, int]]]:
-    """Summarize a list-style OCR tool_calls payload."""
+    """Summarize admitted calls from a legacy list-style OCR payload."""
 
     counts: dict[str, int] = {}
     for item in items:
         name = tool_call_name(item)
         if not name:
             continue
-        counts[name] = counts.get(name, 0) + 1
+        count = counts.get(name, 0) + 1
+        if count > MAX_TOOLKIT_MCP_USAGE_COUNT:
+            return None, []
+        counts[name] = count
 
     total = sum(counts.values())
     if total == 0 and items:
@@ -424,51 +420,52 @@ def tool_call_counts_from_items(
 
 
 def format_tool_calls_summary(tool_calls: Any) -> str:
-    """Return one bounded MR summary line for OCR tool-call statistics."""
+    """Return one bounded MR line for admitted non-zero OCR tool counts."""
 
     entries: list[tuple[str, int]]
     total: int | None
-    scalar_total = nonnegative_int(tool_calls)
-    if scalar_total is not None:
-        total = scalar_total
-        entries = []
-    elif isinstance(tool_calls, list):
+    if isinstance(tool_calls, list):
         total, entries = tool_call_counts_from_items(tool_calls)
     elif isinstance(tool_calls, dict):
         by_tool_value = tool_calls.get("by_tool")
         entries = []
-        by_tool_total = 0
-        valid_by_tool_count = False
+        admitted_total = 0
 
         if isinstance(by_tool_value, dict):
             for raw_name, raw_count in by_tool_value.items():
-                count = nonnegative_int(raw_count)
-                if count is None:
+                if not isinstance(raw_name, str) or raw_name not in PUBLIC_REVIEW_TOOL_CALL_NAMES:
                     continue
-                name = clean_text(raw_name)
-                if not name:
+                if (
+                    not isinstance(raw_count, int)
+                    or isinstance(raw_count, bool)
+                    or not 0 < raw_count <= MAX_TOOLKIT_MCP_USAGE_COUNT
+                ):
                     continue
-                valid_by_tool_count = True
-                by_tool_total += count
-                if count > 0:
-                    entries.append((name, count))
+                admitted_total += raw_count
+                if admitted_total > MAX_TOOLKIT_MCP_USAGE_COUNT:
+                    return ""
+                entries.append((raw_name, raw_count))
 
         calls_value = tool_calls.get("calls")
-        if valid_by_tool_count:
-            list_total = None
-        elif isinstance(calls_value, list):
+        if not by_tool_value and isinstance(calls_value, list):
             list_total, entries = tool_call_counts_from_items(calls_value)
         else:
             list_total = None
 
-        total = nonnegative_int(tool_calls.get("total"))
-        if total is None:
-            if valid_by_tool_count:
-                total = by_tool_total
-            elif list_total is not None:
+        if "total" in tool_calls:
+            raw_total = tool_calls["total"]
+            if (
+                not isinstance(raw_total, int)
+                or isinstance(raw_total, bool)
+                or not 0 < raw_total <= MAX_TOOLKIT_MCP_USAGE_COUNT
+            ):
+                return ""
+            total = raw_total
+        else:
+            if list_total is not None:
                 total = list_total
-            elif by_tool_value == {}:
-                total = 0
+            elif entries:
+                total = admitted_total
             else:
                 return ""
     else:
@@ -476,21 +473,14 @@ def format_tool_calls_summary(tool_calls: Any) -> str:
 
     if total is None:
         return ""
-    if total == 0:
+    if total == 0 or not entries:
+        return ""
+    if sum(count for _name, count in entries) > total:
         return ""
 
     line = f"- all OCR tool calls: {total} total"
-    if not entries:
-        return line
-
     entries.sort(key=lambda item: (-item[1], item[0]))
-    shown_entries = entries[:MAX_TOOL_CALL_SUMMARY_TOOLS]
-    detail_parts = [
-        f"{inline_code(truncate_tool_call_name(name))}: {count}" for name, count in shown_entries
-    ]
-    omitted_entries = len(entries) - len(shown_entries)
-    if omitted_entries > 0:
-        detail_parts.append(f"+{omitted_entries} more")
+    detail_parts = [f"{inline_code(name)}: {count}" for name, count in entries]
 
     return f"{line} ({', '.join(detail_parts)})"
 
@@ -610,10 +600,10 @@ def format_publication_dlp_details(signal: dict[str, Any] | None) -> str:
     omitted = signal["omitted"]
     carried = signal["carried_forward_comments"]
     completeness = (
-        "One or more publication units were omitted, so this review is partial and cannot "
-        "authorize automatic approval."
+        "One or more public projection units were omitted. OCR coverage is reported "
+        "separately, and automatic approval remains unavailable."
         if omitted["comments"] or omitted["warnings"]
-        else "The canonical publication or approval projection changed, so automatic approval remains unavailable."
+        else "The public projection changed, so automatic approval remains unavailable."
     )
     return "\n".join(
         [
@@ -841,7 +831,11 @@ def format_reviewer_guide(
         enumerate(comments),
         key=lambda item: _guide_comment_rank(item[1], item[0]),
     )
-    guide_comments = [comment for _, comment in ranked_comments[:MAX_REVIEWER_GUIDE_COMMENTS]]
+    guide_comments = (
+        [comment for _, comment in ranked_comments[:MAX_REVIEWER_GUIDE_COMMENTS]]
+        if len(comments) >= 2
+        else []
+    )
     if guide_comments:
         lines.append("")
         lines.append("### Recommended focus areas")
@@ -890,6 +884,8 @@ def _review_outcome_line(
             marker, status_text = "⚠️", "Review stopped at token budget"
         elif partial_result:
             marker, status_text = "⚠️", "Review incomplete"
+        elif outcome_status == "publication-filtered":
+            marker, status_text = "⚠️", "Review complete with publication filtering"
         elif outcome_status in {"warning", "completed_with_warnings"} or warning_count:
             marker, status_text = "⚠️", "Review complete with warnings"
         elif has_finding_state:
@@ -933,6 +929,17 @@ def _review_outcome_line(
     return f"{prefix}**{status_text} — {result_text}**"
 
 
+def format_ocr_core_advisory(advisory: OcrToolkitAdvisory | None) -> str:
+    """Render one validated numeric OCR advisory for Technical details only."""
+
+    if advisory is None:
+        return ""
+    return (
+        f"- OCR core advisory: background {advisory.actual} characters; recommended "
+        f"{advisory.recommended} characters; accepted by OCR core"
+    )
+
+
 def summarize_result(
     total: int,
     inline_count: int,
@@ -944,6 +951,7 @@ def summarize_result(
     tool_calls_summary: str = "",
     mcp_usage_summary: str = "",
     token_usage_summary: str = "",
+    ocr_core_advisory_summary: str = "",
     publication_dlp_details: str = "",
     reviewer_guide: str = "",
     fallback_reasons: Mapping[str, int] | None = None,
@@ -1055,7 +1063,12 @@ def summarize_result(
         )
         if reasons:
             technical.append(f"- Fallback reasons: {reasons}")
-    for summary in (mcp_usage_summary, tool_calls_summary, token_usage_summary):
+    for summary in (
+        mcp_usage_summary,
+        tool_calls_summary,
+        token_usage_summary,
+        ocr_core_advisory_summary,
+    ):
         if summary:
             technical.append(summary)
     technical.append(f"- Review mode: `{post_mode()}`")

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/src/ocr_toolkit/posting/result.py

@@ -122,7 +122,10 @@ def _safe_detail(value: object, reason: str) -> str:
 
 
 def normalize_coverage_diagnostics(
-    outcome: ReviewOutcome, warnings: Sequence[Any]
+    outcome: ReviewOutcome,
+    warnings: Sequence[Any],
+    *,
+    legacy_warning_fallback: bool = True,
 ) -> CoverageDiagnostics:
     """Normalize manifest failures or legacy warnings once at the posting boundary."""
 
@@ -136,7 +139,7 @@ def normalize_coverage_diagnostics(
             )
             for item in outcome.failed_items
         )
-    elif outcome.kind == "partial":
+    elif outcome.kind == "partial" and legacy_warning_fallback:
         for warning in warnings:
             path = warning.get("file") or warning.get("path") if isinstance(warning, dict) else None
             candidates.append((path, _legacy_reason(warning), ocr_warning_text(warning)))

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.4}/src/ocr_toolkit/posting/settings.py

@@ -53,12 +53,6 @@ DEFAULT_MAX_POST_COMMENTS = 50
 MAX_POST_COMMENTS_HARD_LIMIT = 200
 
 
-MAX_TOOL_CALL_SUMMARY_TOOLS = 6
-
-
-MAX_TOOL_CALL_NAME_CHARS = 48
-
-
 MAX_REVIEWER_GUIDE_COMMENTS = 6