open-code-review-toolkit 0.8.6__tar.gz → 0.9.0__tar.gz

{open_code_review_toolkit-0.8.6 → open_code_review_toolkit-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-code-review-toolkit
-Version: 0.8.6
+Version: 0.9.0
 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
@@ -227,6 +227,9 @@ Description-Content-Type: text/markdown
 
 # Open Code Review Toolkit
 
+[![Version](https://img.shields.io/pypi/v/open-code-review-toolkit?label=version&color=0A66C2)](https://pypi.org/project/open-code-review-toolkit/)
+[![Python](https://img.shields.io/pypi/pyversions/open-code-review-toolkit?logo=python&logoColor=white&label=python)](https://pypi.org/project/open-code-review-toolkit/)
+[![License](https://img.shields.io/pypi/l/open-code-review-toolkit?color=0A66C2)](https://github.com/xeonvs/open-code-review-toolkit/blob/main/LICENSE)
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/13906/badge)](https://www.bestpractices.dev/projects/13906)
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/xeonvs/open-code-review-toolkit/badge)](https://securityscorecards.dev/viewer/?uri=github.com/xeonvs/open-code-review-toolkit)
 [![CodeQL](https://github.com/xeonvs/open-code-review-toolkit/actions/workflows/codeql.yml/badge.svg?branch=main)](https://github.com/xeonvs/open-code-review-toolkit/actions/workflows/codeql.yml)
@@ -255,11 +258,11 @@ python -m pip install open-code-review-toolkit
 ```
 
 The toolkit does not bundle OCR. Download the platform asset for exact
-[Open Code Review 1.11.0](https://github.com/alibaba/open-code-review/releases/tag/v1.11.0),
+[Open Code Review 1.11.3](https://github.com/alibaba/open-code-review/releases/tag/v1.11.3),
 verify it before installation against the [compatibility manifest](compatibility/ocr-support.json),
 and place the verified binary on `PATH`. The current Linux amd64 digest is
-`13f68cc2eca1a36d42140e9d37797b68fea5cbbf4b6345ec01ec1b06910fab60`; Darwin arm64 is
-`ac8bf5a0fcd176bb9dcc15b169e90f4b52bf32787adef17a850489dbed97fb78`. The manifest owns
+`9726204ac81baee153fd65b1ff357c380f73e9d8091c4a73c3c9fb541b5164cb`; Darwin arm64 is
+`515cd92ce300b62dea2bcaf53e910cdf57b681e1d58bbd0a9e8e49617bca52fa`. The manifest owns
 the other platform hashes.
 
 Verify the installation without contacting an LLM provider:
@@ -269,14 +272,14 @@ ocr --version
 ocr-ci --help
 ```
 
-`ocr --version` must report `open-code-review v1.11.0`; `ocr-ci --help` must exit
+`ocr --version` must report `open-code-review v1.11.3`; `ocr-ci --help` must exit
 successfully. `ocr-ci preflight` is an operational configuration check, not the installation
 smoke test.
 
 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.11.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.11.3 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.
 
@@ -286,16 +289,16 @@ On a successful rerun, the toolkit replaces untouched OCR-only notes instead of
 
 Suppression uses both the GitLab diff position and a stable finding fingerprint, so ordinary line shifts do not normally bring the same bug back. A materially changed finding can still receive a new discussion. See [GitLab review operations](docs/operations.md) for the complete lifecycle, posting modes, permissions, failure behavior, and Mermaid state diagram.
 
-After every current review note publishes, the GitLab adapter can add a conservative approval bound to receipt v5's exact reviewed source SHA and merge-request author. This write is enabled by default; set `OCR_AUTO_APPROVE=false` when the bot must remain comment-only. DLP-clean metadata, generic discussions, and adapter records do not independently block approval, while degraded metadata, DLP rejection, required context degradation, admitted remediation history, legacy receipts, publication filtering, any direct external MCP, author movement, or bot self-authorship prevents an approval write. GitLab approval rules and protected-branch policy remain authoritative. The toolkit only adds an eligible approval; it never removes an existing approval when a later review is ineligible or disabled.
+After every current review note publishes, the GitLab adapter can add a conservative approval bound to receipt v8's exact reviewed source SHA, target SHA/protection state, and merge-request author. This write is enabled by default; set `OCR_AUTO_APPROVE=false` when the bot must remain comment-only. DLP-clean metadata, generic discussions, protected same-revision CI outcomes, and adapter records do not independently block approval, while an unprotected target, degraded metadata, DLP rejection, required context degradation, admitted remediation history, legacy receipts, publication filtering, any direct external MCP, author movement, or bot self-authorship prevents an approval write. A CI status is review context, never approval authority. GitLab approval rules, Code Owners, and protected-branch policy remain authoritative merge policy. They are not prerequisites for OCR execution. The toolkit only adds an eligible approval; it never removes an existing approval when a later review is ineligible or disabled.
 
 Accepted tradeoffs can be recorded in `.opencodereview/accepted-decisions.md`; the evidence collector supplies only applicable target-ref decisions and never lets a source change self-authorize its review. Root and nested target `AGENTS.md`/`CLAUDE.md` guidance is similarly exposed through the existing evidence MCP with deterministic scope and precedence, while any guidance touched by the merge request is excluded. See [Accepted project decisions](docs/configuration.md#accepted-project-decisions) and [Target project guidance](docs/configuration.md#target-project-guidance) for formats and trust boundaries.
 
 ## Project architecture
 
-The shipped Repository Evidence Engine reads immutable base/head Git objects, stores bounded typed facts and deltas, creates the compact bootstrap used by OCR, and exposes detailed facts, scoped completeness, and base/head changes through the mandatory built-in read-only MCP server. Protected-policy enriched reviews can acquire stable GitLab discussions, verified remediation history, and authorized external issue/document records before OCR. Forge-specific acquisition and posting stay at provider edges; the broker, DLP, store, MCP, receipts, and tests use common contracts so a future GitHub adapter can reuse them without inheriting GitLab API semantics. The same built-in MCP exposes only opaque committed `context_list`/`context_get` handles; it has no provider network or arbitrary identifier path. Direct external MCP remains a separate privileged, comment-only operator boundary.
+The shipped Repository Evidence Engine reads immutable base/head Git objects, stores bounded typed facts and deltas, creates the compact bootstrap used by OCR, and exposes detailed facts, literal search, scoped absence checks, and base/head changes through three fixed tools in the mandatory built-in read-only MCP server. Protected-policy enriched reviews can acquire stable GitLab discussions, verified remediation history, protected same-revision CI outcomes, and authorized external issue/document records before OCR. Forge-specific acquisition and posting stay at provider edges; the broker, DLP, store, MCP, receipts, and tests use common contracts so a future GitHub adapter can reuse them without inheriting GitLab API semantics. The same built-in MCP exposes only opaque committed `context_list`/`context_get` handles; it has no provider network or arbitrary identifier path. Direct external MCP remains a separate privileged, comment-only operator boundary.
 
 - [Toolkit strategy](docs/engineering/toolkit_strategy.md) - durable product boundaries, architecture, invariants, and non-goals.
-- [Bounded review context](docs/review-context.md) - protected policy, adapter protocol, GitLab discussions, opaque handles, DLP, receipt, and cleanup contracts.
+- [Bounded review context](docs/review-context.md) - protected policy, GitLab discussions and same-revision CI outcomes, adapter protocol, opaque handles, DLP, receipt, and cleanup contracts.
 - [Roadmap](ROADMAP.md) - milestone status, dependencies, outcomes, and completion signals.
 - [Backlog](docs/codex/TASKS_BACKLOG.md) - inactive implementation-ready work; active execution remains in `PLANS.md`.
 
@@ -303,8 +306,10 @@ The shipped Repository Evidence Engine reads immutable base/head Git objects, st
 
 1. Configure protected/masked `GITLAB_API_TOKEN` and LLM variables in GitLab.
 2. Pin and checksum the OCR binary.
-3. Install this package.
-4. Run the four public helper stages around `ocr review`:
+3. Keep `OCR_GITLAB_TARGET_PROTECTION_MODE=required` unless the project deliberately permits an unprotected target in limited, comment-only mode.
+4. Merge repository review configuration, including the Rules path, into the target branch.
+5. Enable the CI review job in a later merge request and install this package.
+6. Run the four public helper stages around `ocr review`:
 
 ```console
 ocr-ci preflight
@@ -315,6 +320,8 @@ ocr-ci post --result /tmp/ocr-result.json --stderr /tmp/ocr-stderr.log
 
 See the [GitLab mode matrix](examples/gitlab/README.md), the complete [`ocr-review.gitlab-ci.yml`](examples/gitlab/ocr-review.gitlab-ci.yml) pipeline, the [GitLab setup guide](docs/gitlab.md), and [GitLab review operations](docs/operations.md).
 
+The two-merge-request setup is recommended because repository Rules are loaded only from the captured target commit. On the default protected-target path, a supported one-merge-request alternative may add the Rules and CI job together when that integration merge request does not need review: its first run stops before OCR with a setup-pending note, retrying the same merge request cannot change the captured target Rules, and later merge requests work after it merges. An actually unprotected target with missing target Rules fails closed without promoting the source copy or promising setup-pending status. If the status identity is missing or mismatched, the toolkit likewise uses the generic fail-closed failure note. A green advisory job or pipeline does not prove that OCR or its model executed.
+
 ## Configuration and safety
 
 Configuration is environment-driven. The [configuration reference](docs/configuration.md) documents supported `OCR_*`, `CI_*`, `GITLAB_*`, and MCP inputs. Posting requires `GITLAB_API_TOKEN`; job tokens and legacy aliases are deliberately unsupported.

{open_code_review_toolkit-0.8.6 → open_code_review_toolkit-0.9.0}/README.md

@@ -1,5 +1,8 @@
 # Open Code Review Toolkit
 
+[![Version](https://img.shields.io/pypi/v/open-code-review-toolkit?label=version&color=0A66C2)](https://pypi.org/project/open-code-review-toolkit/)
+[![Python](https://img.shields.io/pypi/pyversions/open-code-review-toolkit?logo=python&logoColor=white&label=python)](https://pypi.org/project/open-code-review-toolkit/)
+[![License](https://img.shields.io/pypi/l/open-code-review-toolkit?color=0A66C2)](https://github.com/xeonvs/open-code-review-toolkit/blob/main/LICENSE)
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/13906/badge)](https://www.bestpractices.dev/projects/13906)
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/xeonvs/open-code-review-toolkit/badge)](https://securityscorecards.dev/viewer/?uri=github.com/xeonvs/open-code-review-toolkit)
 [![CodeQL](https://github.com/xeonvs/open-code-review-toolkit/actions/workflows/codeql.yml/badge.svg?branch=main)](https://github.com/xeonvs/open-code-review-toolkit/actions/workflows/codeql.yml)
@@ -28,11 +31,11 @@ python -m pip install open-code-review-toolkit
 ```
 
 The toolkit does not bundle OCR. Download the platform asset for exact
-[Open Code Review 1.11.0](https://github.com/alibaba/open-code-review/releases/tag/v1.11.0),
+[Open Code Review 1.11.3](https://github.com/alibaba/open-code-review/releases/tag/v1.11.3),
 verify it before installation against the [compatibility manifest](compatibility/ocr-support.json),
 and place the verified binary on `PATH`. The current Linux amd64 digest is
-`13f68cc2eca1a36d42140e9d37797b68fea5cbbf4b6345ec01ec1b06910fab60`; Darwin arm64 is
-`ac8bf5a0fcd176bb9dcc15b169e90f4b52bf32787adef17a850489dbed97fb78`. The manifest owns
+`9726204ac81baee153fd65b1ff357c380f73e9d8091c4a73c3c9fb541b5164cb`; Darwin arm64 is
+`515cd92ce300b62dea2bcaf53e910cdf57b681e1d58bbd0a9e8e49617bca52fa`. The manifest owns
 the other platform hashes.
 
 Verify the installation without contacting an LLM provider:
@@ -42,14 +45,14 @@ ocr --version
 ocr-ci --help
 ```
 
-`ocr --version` must report `open-code-review v1.11.0`; `ocr-ci --help` must exit
+`ocr --version` must report `open-code-review v1.11.3`; `ocr-ci --help` must exit
 successfully. `ocr-ci preflight` is an operational configuration check, not the installation
 smoke test.
 
 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.11.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.11.3 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.
 
@@ -59,16 +62,16 @@ On a successful rerun, the toolkit replaces untouched OCR-only notes instead of
 
 Suppression uses both the GitLab diff position and a stable finding fingerprint, so ordinary line shifts do not normally bring the same bug back. A materially changed finding can still receive a new discussion. See [GitLab review operations](docs/operations.md) for the complete lifecycle, posting modes, permissions, failure behavior, and Mermaid state diagram.
 
-After every current review note publishes, the GitLab adapter can add a conservative approval bound to receipt v5's exact reviewed source SHA and merge-request author. This write is enabled by default; set `OCR_AUTO_APPROVE=false` when the bot must remain comment-only. DLP-clean metadata, generic discussions, and adapter records do not independently block approval, while degraded metadata, DLP rejection, required context degradation, admitted remediation history, legacy receipts, publication filtering, any direct external MCP, author movement, or bot self-authorship prevents an approval write. GitLab approval rules and protected-branch policy remain authoritative. The toolkit only adds an eligible approval; it never removes an existing approval when a later review is ineligible or disabled.
+After every current review note publishes, the GitLab adapter can add a conservative approval bound to receipt v8's exact reviewed source SHA, target SHA/protection state, and merge-request author. This write is enabled by default; set `OCR_AUTO_APPROVE=false` when the bot must remain comment-only. DLP-clean metadata, generic discussions, protected same-revision CI outcomes, and adapter records do not independently block approval, while an unprotected target, degraded metadata, DLP rejection, required context degradation, admitted remediation history, legacy receipts, publication filtering, any direct external MCP, author movement, or bot self-authorship prevents an approval write. A CI status is review context, never approval authority. GitLab approval rules, Code Owners, and protected-branch policy remain authoritative merge policy. They are not prerequisites for OCR execution. The toolkit only adds an eligible approval; it never removes an existing approval when a later review is ineligible or disabled.
 
 Accepted tradeoffs can be recorded in `.opencodereview/accepted-decisions.md`; the evidence collector supplies only applicable target-ref decisions and never lets a source change self-authorize its review. Root and nested target `AGENTS.md`/`CLAUDE.md` guidance is similarly exposed through the existing evidence MCP with deterministic scope and precedence, while any guidance touched by the merge request is excluded. See [Accepted project decisions](docs/configuration.md#accepted-project-decisions) and [Target project guidance](docs/configuration.md#target-project-guidance) for formats and trust boundaries.
 
 ## Project architecture
 
-The shipped Repository Evidence Engine reads immutable base/head Git objects, stores bounded typed facts and deltas, creates the compact bootstrap used by OCR, and exposes detailed facts, scoped completeness, and base/head changes through the mandatory built-in read-only MCP server. Protected-policy enriched reviews can acquire stable GitLab discussions, verified remediation history, and authorized external issue/document records before OCR. Forge-specific acquisition and posting stay at provider edges; the broker, DLP, store, MCP, receipts, and tests use common contracts so a future GitHub adapter can reuse them without inheriting GitLab API semantics. The same built-in MCP exposes only opaque committed `context_list`/`context_get` handles; it has no provider network or arbitrary identifier path. Direct external MCP remains a separate privileged, comment-only operator boundary.
+The shipped Repository Evidence Engine reads immutable base/head Git objects, stores bounded typed facts and deltas, creates the compact bootstrap used by OCR, and exposes detailed facts, literal search, scoped absence checks, and base/head changes through three fixed tools in the mandatory built-in read-only MCP server. Protected-policy enriched reviews can acquire stable GitLab discussions, verified remediation history, protected same-revision CI outcomes, and authorized external issue/document records before OCR. Forge-specific acquisition and posting stay at provider edges; the broker, DLP, store, MCP, receipts, and tests use common contracts so a future GitHub adapter can reuse them without inheriting GitLab API semantics. The same built-in MCP exposes only opaque committed `context_list`/`context_get` handles; it has no provider network or arbitrary identifier path. Direct external MCP remains a separate privileged, comment-only operator boundary.
 
 - [Toolkit strategy](docs/engineering/toolkit_strategy.md) - durable product boundaries, architecture, invariants, and non-goals.
-- [Bounded review context](docs/review-context.md) - protected policy, adapter protocol, GitLab discussions, opaque handles, DLP, receipt, and cleanup contracts.
+- [Bounded review context](docs/review-context.md) - protected policy, GitLab discussions and same-revision CI outcomes, adapter protocol, opaque handles, DLP, receipt, and cleanup contracts.
 - [Roadmap](ROADMAP.md) - milestone status, dependencies, outcomes, and completion signals.
 - [Backlog](docs/codex/TASKS_BACKLOG.md) - inactive implementation-ready work; active execution remains in `PLANS.md`.
 
@@ -76,8 +79,10 @@ The shipped Repository Evidence Engine reads immutable base/head Git objects, st
 
 1. Configure protected/masked `GITLAB_API_TOKEN` and LLM variables in GitLab.
 2. Pin and checksum the OCR binary.
-3. Install this package.
-4. Run the four public helper stages around `ocr review`:
+3. Keep `OCR_GITLAB_TARGET_PROTECTION_MODE=required` unless the project deliberately permits an unprotected target in limited, comment-only mode.
+4. Merge repository review configuration, including the Rules path, into the target branch.
+5. Enable the CI review job in a later merge request and install this package.
+6. Run the four public helper stages around `ocr review`:
 
 ```console
 ocr-ci preflight
@@ -88,6 +93,8 @@ ocr-ci post --result /tmp/ocr-result.json --stderr /tmp/ocr-stderr.log
 
 See the [GitLab mode matrix](examples/gitlab/README.md), the complete [`ocr-review.gitlab-ci.yml`](examples/gitlab/ocr-review.gitlab-ci.yml) pipeline, the [GitLab setup guide](docs/gitlab.md), and [GitLab review operations](docs/operations.md).
 
+The two-merge-request setup is recommended because repository Rules are loaded only from the captured target commit. On the default protected-target path, a supported one-merge-request alternative may add the Rules and CI job together when that integration merge request does not need review: its first run stops before OCR with a setup-pending note, retrying the same merge request cannot change the captured target Rules, and later merge requests work after it merges. An actually unprotected target with missing target Rules fails closed without promoting the source copy or promising setup-pending status. If the status identity is missing or mismatched, the toolkit likewise uses the generic fail-closed failure note. A green advisory job or pipeline does not prove that OCR or its model executed.
+
 ## Configuration and safety
 
 Configuration is environment-driven. The [configuration reference](docs/configuration.md) documents supported `OCR_*`, `CI_*`, `GITLAB_*`, and MCP inputs. Posting requires `GITLAB_API_TOKEN`; job tokens and legacy aliases are deliberately unsupported.

{open_code_review_toolkit-0.8.6 → open_code_review_toolkit-0.9.0}/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.6'
-__version_tuple__ = version_tuple = (0, 8, 6)
+__version__ = version = '0.9.0'
+__version_tuple__ = version_tuple = (0, 9, 0)
 
 __commit_id__ = commit_id = None

open_code_review_toolkit-0.9.0/src/ocr_toolkit/context/ci_outcomes.py

@@ -0,0 +1,141 @@
+"""Project provider-neutral same-revision CI outcomes into private context."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+
+from ocr_toolkit.context.contracts import CIOutcomePolicy, TextBudgets
+from ocr_toolkit.context.dlp import check_text
+from ocr_toolkit.context.store import PendingContextRecord
+
+CI_OUTCOME_STATUSES = frozenset({"passed", "failed", "skipped", "canceled", "unknown"})
+CI_OUTCOME_REQUIREMENTS = frozenset({"required", "advisory"})
+CI_OUTCOME_ORIGINS = frozenset({"current_pipeline", "same_revision_pipeline"})
+CI_IDENTITY_BUDGETS = TextBudgets(max_chars=256, max_bytes=1_024, max_lines=1)
+
+
+@dataclass(frozen=True, slots=True)
+class CIOutcome:
+    """Carry one normalized provider outcome without raw forge identities."""
+
+    check: str
+    status: str
+    requirement: str
+    path_prefixes: tuple[str, ...]
+    origin: str
+    completed_at: int
+    version: str
+    digest: str
+
+
+@dataclass(frozen=True, slots=True)
+class CIOutcomeSnapshot:
+    """Carry a stable provider snapshot and its closed completeness state."""
+
+    state: str
+    records: tuple[CIOutcome, ...]
+    omitted: int
+    invalid: int
+
+
+def prepare_ci_outcome_records(
+    snapshot: CIOutcomeSnapshot,
+    *,
+    policy: CIOutcomePolicy,
+    now: int,
+    forbidden: tuple[str, ...] = (),
+) -> tuple[PendingContextRecord, ...]:
+    """DLP-check one closed snapshot and build exact immutable store records."""
+
+    if (
+        snapshot.state not in {"complete", "partial", "mutated"}
+        or not isinstance(snapshot.omitted, int)
+        or isinstance(snapshot.omitted, bool)
+        or snapshot.omitted < 0
+        or not isinstance(snapshot.invalid, int)
+        or isinstance(snapshot.invalid, bool)
+        or snapshot.invalid < 0
+        or (snapshot.state == "complete" and (snapshot.omitted or snapshot.invalid))
+        or (snapshot.state == "mutated" and snapshot.records)
+    ):
+        return ()
+    if snapshot.state == "mutated":
+        return ()
+    authorized = {check.name: check.path_prefixes for check in policy.checks}
+    pending: list[PendingContextRecord] = []
+    for record in snapshot.records:
+        normalized_identity = {
+            "check": record.check,
+            "status": record.status,
+            "requirement": record.requirement,
+            "path_prefixes": list(record.path_prefixes),
+            "origin": record.origin,
+            "completed_at": record.completed_at,
+        }
+        expected_digest = hashlib.sha256(
+            json.dumps(normalized_identity, sort_keys=True, separators=(",", ":")).encode()
+        ).hexdigest()
+        if (
+            record.check not in authorized
+            or record.path_prefixes != authorized[record.check]
+            or record.status not in CI_OUTCOME_STATUSES
+            or record.requirement not in CI_OUTCOME_REQUIREMENTS
+            or record.origin not in CI_OUTCOME_ORIGINS
+            or not isinstance(record.completed_at, int)
+            or isinstance(record.completed_at, bool)
+            or record.completed_at < 0
+            or record.completed_at > now + 300
+            or now - record.completed_at > policy.max_age_seconds
+            or record.version != str(record.completed_at)
+            or len(record.digest) != 64
+            or any(character not in "0123456789abcdef" for character in record.digest)
+            or record.digest != expected_digest
+        ):
+            continue
+        values = (record.check, *record.path_prefixes)
+        checked = [
+            check_text(value, budgets=CI_IDENTITY_BUDGETS, forbidden=forbidden) for value in values
+        ]
+        if any(
+            not value.admitted or value.text != original for value, original in zip(checked, values)
+        ):
+            continue
+        model = {
+            "check": record.check,
+            "revision": "reviewed_head",
+            "status": record.status,
+            "requirement": record.requirement,
+            "scope": {"mode": "declared", "path_prefixes": list(record.path_prefixes)},
+            "origin": record.origin,
+            "completed_at": record.completed_at,
+        }
+        canonical = json.dumps(model, sort_keys=True, separators=(",", ":"))
+        pending.append(
+            PendingContextRecord(
+                source="forge:ci_outcomes",
+                adapter="gitlab",
+                tenant="project",
+                canonical_object=hashlib.sha256(
+                    f"ci-outcome:{record.check}:{record.digest}".encode()
+                ).hexdigest(),
+                resource_class="ci_outcome",
+                descriptor="ci_outcome",
+                projections={
+                    "model": {"descriptor": "ci_outcome", "ci_outcome": model},
+                    "publish": {"descriptor": "ci_outcome"},
+                    "retain": {
+                        "state": record.status,
+                        "digest": hashlib.sha256(canonical.encode()).hexdigest(),
+                        "version": record.version,
+                        "expiry": now + 3_600,
+                    },
+                },
+                version=record.version,
+                digest=hashlib.sha256(canonical.encode()).hexdigest(),
+                mutable=False,
+                expiry=now + 3_600,
+            )
+        )
+    return tuple(pending)

{open_code_review_toolkit-0.8.6 → open_code_review_toolkit-0.9.0}/src/ocr_toolkit/context/contracts.py

@@ -6,14 +6,17 @@ from dataclasses import dataclass
 
 POLICY_SCHEMA_V1 = "ocr.review-context-policy/v1"
 POLICY_SCHEMA_V2 = "ocr.review-context-policy/v2"
-POLICY_SCHEMAS = frozenset({POLICY_SCHEMA_V1, POLICY_SCHEMA_V2})
-POLICY_SCHEMA = POLICY_SCHEMA_V2
+POLICY_SCHEMA_V3 = "ocr.review-context-policy/v3"
+POLICY_SCHEMAS = frozenset({POLICY_SCHEMA_V1, POLICY_SCHEMA_V2, POLICY_SCHEMA_V3})
+POLICY_SCHEMA = POLICY_SCHEMA_V3
 STORE_SCHEMA = "ocr.context-store/v2"
 REQUEST_SCHEMA = "ocr.context-adapter-request/v1"
 RESPONSE_SCHEMA = "ocr.context-adapter-response/v1"
 ACCOUNT_CLASSES = frozenset({"user", "automation", "system", "toolkit_bot"})
 REFERENCE_RESOURCE_CLASSES = frozenset({"issue", "document"})
-STORE_RESOURCE_CLASSES = frozenset({*REFERENCE_RESOURCE_CLASSES, "remediation_thread"})
+STORE_RESOURCE_CLASSES = frozenset(
+    {*REFERENCE_RESOURCE_CLASSES, "remediation_thread", "ci_outcome"}
+)
 PROJECTION_FIELDS = frozenset(
     {
         "descriptor",
@@ -33,7 +36,10 @@ PROJECTION_FIELDS = frozenset(
     }
 )
 REMEDIATION_MODEL_FIELD = "remediation_thread"
-STORE_PROJECTION_FIELDS = frozenset({*PROJECTION_FIELDS, REMEDIATION_MODEL_FIELD})
+CI_OUTCOME_MODEL_FIELD = "ci_outcome"
+STORE_PROJECTION_FIELDS = frozenset(
+    {*PROJECTION_FIELDS, REMEDIATION_MODEL_FIELD, CI_OUTCOME_MODEL_FIELD}
+)
 RETENTION_FIELDS = frozenset({"state", "count", "digest", "version", "expiry"})
 
 
@@ -99,6 +105,23 @@ class RemediationThreadPolicy:
     budgets: TextBudgets
 
 
+@dataclass(frozen=True, slots=True)
+class CIOutcomeCheckPolicy:
+    """Authorize one exact forge check and its protected path scope."""
+
+    name: str
+    path_prefixes: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class CIOutcomePolicy:
+    """Select bounded same-revision forge outcomes under protected policy."""
+
+    required: bool
+    max_age_seconds: int
+    checks: tuple[CIOutcomeCheckPolicy, ...]
+
+
 @dataclass(frozen=True, slots=True)
 class RecognizerPolicy:
     """Hold one fixed toolkit-authored candidate grammar."""
@@ -132,5 +155,6 @@ class ContextPolicy:
     budgets: AggregateBudgets
     forge_discussions: DiscussionPolicy | None
     remediation_threads: RemediationThreadPolicy | None
+    ci_outcomes: CIOutcomePolicy | None
     references: tuple[ReferencePolicy, ...]
     digest: str

{open_code_review_toolkit-0.8.6 → open_code_review_toolkit-0.9.0}/src/ocr_toolkit/context/policy.py

@@ -5,18 +5,23 @@ from __future__ import annotations
 import hashlib
 import json
 import re
+import unicodedata
 from collections.abc import Callable, Mapping
+from pathlib import PurePosixPath
 from typing import Any
 from urllib.parse import urlsplit
 
 from ocr_toolkit.context.contracts import (
     ACCOUNT_CLASSES,
     POLICY_SCHEMA_V1,
+    POLICY_SCHEMA_V2,
     POLICY_SCHEMAS,
     PROJECTION_FIELDS,
     REFERENCE_RESOURCE_CLASSES,
     RETENTION_FIELDS,
     AggregateBudgets,
+    CIOutcomeCheckPolicy,
+    CIOutcomePolicy,
     ContextContractError,
     ContextPolicy,
     ContextProjections,
@@ -32,6 +37,7 @@ MAX_POLICY_BYTES = 64 * 1024
 MAX_REFERENCES = 16
 NAME_RE = re.compile(r"[a-z][a-z0-9_-]{0,63}\Z")
 ISSUE_PREFIX_RE = re.compile(r"[A-Z][A-Z0-9]{0,15}\Z")
+MAX_CI_CHECKS = 32
 
 
 def _pairs(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
@@ -208,6 +214,79 @@ def _remediation_threads(value: object) -> RemediationThreadPolicy:
     )
 
 
+def normalize_ci_path_prefix(value: object) -> str:
+    """Validate one protected repository-relative POSIX path prefix."""
+
+    if (
+        not isinstance(value, str)
+        or not 1 <= len(value) <= 256
+        or "\\" in value
+        or "://" in value
+        or any(unicodedata.category(character) in {"Cc", "Cf", "Cs"} for character in value)
+        or len(value.encode("utf-8")) > 1_024
+    ):
+        raise ContextContractError("ci_outcomes path prefix is invalid")
+    trailing = value.endswith("/")
+    path = PurePosixPath(value)
+    parts = value.rstrip("/").split("/")
+    if path.is_absolute() or any(part in {"", ".", ".."} for part in parts):
+        raise ContextContractError("ci_outcomes path prefix is invalid")
+    normalized = path.as_posix()
+    return f"{normalized}/" if trailing else normalized
+
+
+def _ci_outcomes(value: object) -> CIOutcomePolicy:
+    """Parse exact check names and path scopes from protected policy v3."""
+
+    item = _object(
+        value,
+        keys=frozenset({"required", "max_age_seconds", "checks"}),
+        label="ci_outcomes",
+    )
+    checks = item.get("checks")
+    if not isinstance(checks, list) or not checks or len(checks) > MAX_CI_CHECKS:
+        raise ContextContractError("ci_outcomes.checks is invalid")
+    parsed: list[CIOutcomeCheckPolicy] = []
+    for raw in checks:
+        check = _object(
+            raw,
+            keys=frozenset({"name", "path_prefixes"}),
+            label="ci_outcomes check",
+        )
+        name = check.get("name")
+        prefixes = check.get("path_prefixes")
+        if (
+            not isinstance(name, str)
+            or not 1 <= len(name) <= 128
+            or "://" in name
+            or any(unicodedata.category(character) in {"Cc", "Cf", "Cs"} for character in name)
+            or len(name.encode("utf-8")) > 512
+            or not isinstance(prefixes, list)
+            or not prefixes
+            or len(prefixes) > 32
+        ):
+            raise ContextContractError("ci_outcomes check is invalid")
+        normalized = tuple(normalize_ci_path_prefix(prefix) for prefix in prefixes)
+        if list(normalized) != sorted(set(normalized)):
+            raise ContextContractError("ci_outcomes path prefixes must be sorted and unique")
+        parsed.append(CIOutcomeCheckPolicy(name=name, path_prefixes=normalized))
+    names = [check.name for check in parsed]
+    if names != sorted(set(names)):
+        raise ContextContractError("ci_outcomes check names must be sorted and unique")
+    required = item.get("required", False)
+    max_age_seconds = item.get("max_age_seconds", 86_400)
+    return CIOutcomePolicy(
+        required=_boolean(required, label="ci_outcomes.required"),
+        max_age_seconds=_integer(
+            max_age_seconds,
+            minimum=60,
+            maximum=604_800,
+            label="ci_outcomes.max_age_seconds",
+        ),
+        checks=tuple(parsed),
+    )
+
+
 def _recognizer(value: object, *, resource_class: str) -> RecognizerPolicy:
     item = _object(
         value,
@@ -328,6 +407,7 @@ def parse_policy(raw: bytes) -> ContextPolicy:
                 "budgets",
                 "forge_discussions",
                 "remediation_threads",
+                "ci_outcomes",
                 "references",
             }
         ),
@@ -338,6 +418,8 @@ def parse_policy(raw: bytes) -> ContextPolicy:
         raise ContextContractError("context policy schema version is unsupported")
     if schema_version == POLICY_SCHEMA_V1 and "remediation_threads" in root:
         raise ContextContractError("context policy v1 cannot select remediation threads")
+    if schema_version in {POLICY_SCHEMA_V1, POLICY_SCHEMA_V2} and "ci_outcomes" in root:
+        raise ContextContractError("context policy v1/v2 cannot select CI outcomes")
     budgets_value = _object(
         root.get("budgets"),
         keys=frozenset({"max_records", "max_chars", "max_bytes", "max_lines", "timeout_ms"}),
@@ -364,6 +446,7 @@ def parse_policy(raw: bytes) -> ContextPolicy:
     remediation = (
         _remediation_threads(root["remediation_threads"]) if "remediation_threads" in root else None
     )
+    ci_outcomes = _ci_outcomes(root["ci_outcomes"]) if "ci_outcomes" in root else None
     references_value = root.get("references", [])
     if (
         not isinstance(references_value, list)
@@ -375,7 +458,7 @@ def parse_policy(raw: bytes) -> ContextPolicy:
     identities = [(item.adapter, item.tenant, item.resource_class) for item in references]
     if len(identities) != len(set(identities)):
         raise ContextContractError("context policy references collide")
-    if discussion is None and remediation is None and not references:
+    if discussion is None and remediation is None and ci_outcomes is None and not references:
         raise ContextContractError("context policy must select at least one source")
     canonical = json.dumps(
         payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False
@@ -385,6 +468,7 @@ def parse_policy(raw: bytes) -> ContextPolicy:
         budgets=budgets,
         forge_discussions=discussion,
         remediation_threads=remediation,
+        ci_outcomes=ci_outcomes,
         references=references,
         digest=hashlib.sha256(canonical).hexdigest(),
     )