diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index d3d233d8d9..67e20e10c1 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -14,6 +14,42 @@ concrete gap and consumer. These author facts are independently reviewed.
 - Observable before → after, with the validation row that proves it:
 - Issue/task and intended base: <!-- Use Closes only for the issue actually completed; otherwise Related to. -->
 
+## Author Declaration
+
+<!--
+Who wrote this change, and what it was implemented against. A reviewer may be a
+different operator's agent, working from a different host and context: this
+section is the only place it can learn both without guessing, and unlike the
+rest of the body it is published attribution rather than a reviewed claim. Keep
+it to one short line plus the spec rows; do not paste runtime identifiers,
+endpoints, credentials or internal routing detail, and never claim a
+verification you did not run.
+-->
+
+- Written by: <!-- model_agent or human_operator; for an agent, the model and provider in ordinary product-family wording; keep it to one line -->
+
+### Implemented against
+
+<!-- The accepted specification this change was built for: an accepted RFC,
+accepted contract/protocol document, the linked issue or task, or a
+maintainer-agreed review frame. Give the exact file path or public link and the
+revision, so a reviewer can open the same text. One row per criterion the
+specification states, using its own section or identifier when it has one.
+Disposition: implemented | deferred | out_of_scope | not_met — a not_met row
+blocks approval and needs its gap and repair. Write "no written specification;
+the request in this PR is the basis" when none exists. Ignore aspirational or
+future properties; they are not obligations.
+-->
+
+- Specification and revision:
+- Criteria:
+
+| Criterion (spec clause) | Disposition | Symbol / path | Test or command |
+| --- | --- | --- | --- |
+|  |  |  |  |
+
+- Self-check before submission: <!-- What you ran, what you read, and what you deliberately left out. Separate what you verified from what you assumed; "none" with a reason is valid. -->
+
 ## Scope And Continuation
 
 <!-- A scoped fix may be complete while the parent program remains open.
diff --git a/loopx/capabilities/pr_review_queue/README.md b/loopx/capabilities/pr_review_queue/README.md
index 57d0a995af..cd2a10c1bf 100644
--- a/loopx/capabilities/pr_review_queue/README.md
+++ b/loopx/capabilities/pr_review_queue/README.md
@@ -442,6 +442,30 @@ them. Queue selection, scheduler and runtime permissions are unchanged. The
 five public sections retain the bounded prose floors documented above; reuse
 evidence and do not pad. Invoking review uses the installed capability policy.
 
+### Reviewer provenance and specification basis
+
+Policy revision 14 makes two publication requirements mandatory for every new
+result; neither changes queue selection, merge authority or how already
+published GitHub reviews are recognized (`check_review_body` is unchanged).
+
+- `result.reviewer` (`reviewer_declaration`) names `actor_kind`
+  (`model_agent` or `human_operator`) and `declaration_source`
+  (`runtime_reported` or `self_reported`); an agent adds `declared_model` and
+  `declared_provider` in product-family wording. The body repeats them on
+  exactly one visible `Reviewer:` line, each value as a whole token. This is
+  provenance, not a credential: it authenticates nothing and adds no weight.
+- `problem_context.spec_basis` (`spec_basis_assessment`) is `mapped`,
+  `no_spec` or `not_yet_proven`. `mapped` gives text `spec_ref`,
+  `spec_revision` (a full commit id for `accepted_rfc` and
+  `accepted_contract_doc`) and one criterion row per material acceptance
+  criterion; `not_met` and `not_yet_proven` block approval. The reference,
+  revision and every `criterion_id` must appear as whole tokens in the
+  visible body, because another operator reads only the published review.
+
+`--check-result` reports a missing or inconsistent declaration or unpublished
+reference as an error, and a spec-basis gap as an approval blocker. Regenerate
+results made under revision 13 rather than adding these fields to them.
+
 ### Semantic alignment and CI constraint recovery
 
 The semantic triage introduced in policy revision 5 replaces universal detailed
diff --git a/loopx/capabilities/pr_review_queue/result_check.py b/loopx/capabilities/pr_review_queue/result_check.py
index 77c1bbff86..4b03ce1f3f 100644
--- a/loopx/capabilities/pr_review_queue/result_check.py
+++ b/loopx/capabilities/pr_review_queue/result_check.py
@@ -1,18 +1,25 @@
 """Check a review's declared evidence for consistency, never its truth."""
 
+import re
 from collections.abc import Mapping
 from typing import Any
 
 from .review_contract import (
     COMPATIBILITY_ASSESSMENT,
     OUTCOME_IMPACT_ASSESSMENT,
+    REVIEWER_DECLARATION,
     SCOPE_COVERAGE_ASSESSMENT,
     SEMANTIC_CANDIDATE_DECISIONS,
+    SPEC_BASIS_ASSESSMENT,
     VALIDATION_FAILURE_ATTRIBUTION,
     build_review_execution_contract,
     build_review_plan,
 )
-from .review_body import check_review_body
+from .review_body import (
+    check_review_body,
+    reviewer_declaration_lines,
+    visible_review_text,
+)
 
 
 def _missing(value: object) -> bool:
@@ -206,6 +213,141 @@ def _check_outcome_impact(blockers: list[str], value: object) -> None:
                             fields=["acceptance_basis", "bounded_cost_and_recovery"])
 
 
+# The declaration names a product family, so the characters that mark a URL,
+# path, host:port, account or ARN have no place in it. This is a shape rule,
+# not a product-name denylist. Known false positive: router- or
+# version-qualified ids such as `vendor/model` or `model@version` are rejected;
+# declare the product-family name instead. A typed runtime-reported identity
+# would replace this text check once a host supplies one.
+_DECLARED_NAME_FORBIDDEN = re.compile(r"[/:@]")
+_PUBLISHED_LINE_FORBIDDEN = re.compile(r"://|@")
+
+
+# Same full-length object ids the packet accepts for an exact head.
+_COMMIT_ID = re.compile(r"[0-9a-f]{40}|[0-9a-f]{64}")
+
+
+def _published_as_token(reference: str, text: str) -> bool:
+    # A whole-token match: EX-1 inside EX-10, or C1 inside a commit id, does not
+    # name the criterion to a reader.
+    pattern = rf"(?<![0-9a-z_-]){re.escape(reference)}(?![0-9a-z_-])"
+    return re.search(pattern, text) is not None
+
+
+def _reviewer_errors(value: object, body: str) -> list[str]:
+    key = "reviewer"
+    contract = REVIEWER_DECLARATION
+    if not isinstance(value, Mapping):
+        return [f"{key}:missing_declaration"]
+    actor_kind = value.get("actor_kind")
+    if actor_kind not in contract["actor_kinds"]:
+        return [f"{key}:invalid_actor_kind"]
+    errors: list[str] = []
+    if value.get("declaration_source") not in contract["declaration_sources"]:
+        errors.append(f"{key}:invalid_declaration_source")
+    declared: list[str] = [str(actor_kind)]
+    if actor_kind == "model_agent":
+        for field in contract["model_agent_fields"]:
+            text = value.get(field)
+            if not isinstance(text, str) or not text.strip():
+                errors.append(f"{key}:missing_field:{field}")
+            elif _DECLARED_NAME_FORBIDDEN.search(text):
+                errors.append(f"{key}:not_a_product_family_name:{field}")
+            else:
+                declared.append(text.strip())
+    lines = reviewer_declaration_lines(body)
+    if len(lines) != 1:
+        errors.append(f"{key}:body_line_missing_or_ambiguous")
+    elif _PUBLISHED_LINE_FORBIDDEN.search(lines[0]):
+        errors.append(f"{key}:body_line_carries_runtime_detail")
+    elif any(not _published_as_token(token.casefold(), lines[0].casefold())
+             for token in declared):
+        errors.append(f"{key}:body_line_disagrees_with_declaration")
+    return errors
+
+
+def _check_spec_basis(blockers: list[str], value: object) -> None:
+    key = "problem_context:spec_basis"
+    contract = SPEC_BASIS_ASSESSMENT
+    _require_fields(blockers, evidence_id=key, value=value, fields=contract["fields"])
+    if not isinstance(value, Mapping):
+        return
+    decision = value.get("decision")
+    if decision not in contract["decision_values"]:
+        blockers.append(f"{key}:invalid_decision")
+        return
+    source = value.get("spec_source")
+    if source not in contract["spec_source_values"]:
+        blockers.append(f"{key}:invalid_spec_source")
+    if decision in contract["blocking_decisions"]:
+        blockers.append(f"{key}:blocking_decision")
+    if decision == "no_spec" and source != "none":
+        blockers.append(f"{key}:no_spec_cannot_cite_a_source")
+    if decision != "mapped":
+        return
+    if source == "none":
+        blockers.append(f"{key}:mapped_without_spec_source")
+    _require_fields(blockers, evidence_id=key, value=value, fields=contract["mapped_fields"])
+    # The reference and revision are published and matched against the body, so
+    # a non-string value would pass the non-empty check and then never be
+    # compared; require text here, as for criterion_id below.
+    for field in contract["published_text_fields"]:
+        text = value.get(field)
+        if not _missing(text) and (not isinstance(text, str) or not text.strip()):
+            blockers.append(f"{key}:invalid_{field}")
+    revision = value.get("spec_revision")
+    if (source in contract["commit_pinned_spec_sources"] and isinstance(revision, str)
+            and revision.strip() and not _COMMIT_ID.fullmatch(revision.strip().lower())):
+        blockers.append(f"{key}:spec_revision_not_a_commit_id")
+    criteria = _require_items(
+        blockers, evidence_id=key, row=value,
+        requirement={"items_field": "criteria", "item_fields": contract["criterion_fields"],
+                     "item_count": {"minimum": 1}},
+    )
+    seen: set[str] = set()
+    for criterion in criteria:
+        # Membership, hashing and publication all assume a public identity.
+        # A bool hashes and is non-empty, and a non-string identity silently
+        # falls out of the published-body check, so validate the type here
+        # rather than letting a later set or dict operation decide.
+        criterion_id = criterion.get("criterion_id")
+        if not isinstance(criterion_id, str) or not criterion_id.strip():
+            blockers.append(f"{key}:invalid_criterion_id")
+            continue
+        if criterion_id in seen:
+            blockers.append(f"{key}:duplicate_criterion:{criterion_id}")
+        seen.add(criterion_id)
+        disposition = criterion.get("disposition")
+        if not isinstance(disposition, str) or disposition not in contract["disposition_fields"]:
+            blockers.append(f"{key}:invalid_disposition:{criterion_id}")
+            continue
+        _require_fields(blockers, evidence_id=f"{key}:{criterion_id}", value=criterion,
+                        fields=contract["disposition_fields"][disposition])
+        if disposition in contract["blocking_dispositions"]:
+            blockers.append(f"{key}:unmet_criterion:{criterion_id}")
+
+
+def _unpublished_spec_references(value: object, body: str) -> list[str]:
+    # The structured result stays local; another operator reads only the body.
+    # A path alone moves with the branch, so the immutable revision the review
+    # judged against has to travel with it for that reader to open the same text.
+    if not isinstance(value, Mapping) or value.get("decision") != "mapped":
+        return []
+    text = visible_review_text(body).casefold()
+    references = [value.get("spec_ref"), value.get("spec_revision")]
+    criteria = value.get("criteria")
+    if isinstance(criteria, list):
+        references += [item.get("criterion_id") for item in criteria if isinstance(item, Mapping)]
+    # Non-text identities are rejected by _check_spec_basis; they are skipped
+    # here only because they have no text to look for in the body.
+    return [
+        f"review_body:spec_reference_not_published:{reference}"
+        for reference in references
+        if isinstance(reference, str) and reference.strip()
+        and not _published_as_token(reference.strip().casefold(), text)
+    ]
+
+
 def _check_scope_coverage(blockers: list[str], value: object) -> None:
     key = "observable_semantics:scope_coverage"
     contract = SCOPE_COVERAGE_ASSESSMENT
@@ -302,6 +444,7 @@ def check_review_result(
             requirement = requirements[key]
             if key == "problem_context":
                 _check_outcome_impact(blockers, row.get("outcome_impact"))
+                _check_spec_basis(blockers, row.get("spec_basis"))
             if key == "code_volume":
                 _check_compatibility_assessment(blockers, row.get("compatibility_assessment"))
             if key == "observable_semantics":
@@ -402,6 +545,13 @@ def check_review_result(
                              head_oid=str(matches[0].get("head_oid") or ""),
                              behavior_bearing=applicability.get("behavior_bearing_change") is True)
     errors.extend(f"review_body:{reason}" for reason in body["invalid_reasons"])
+    body_text = str(result.get("review_body") or "")
+    errors.extend(_reviewer_errors(result.get("reviewer"), body_text))
+    problem_context = evidence.get("problem_context")
+    errors.extend(_unpublished_spec_references(
+        problem_context.get("spec_basis") if isinstance(problem_context, Mapping) else None,
+        body_text,
+    ))
     if body["verdict"] is not None and body["verdict"] != verdict:
         errors.append("review_body:verdict_mismatch")
     if verdict not in {"APPROVE", "REQUEST_CHANGES"}:
diff --git a/loopx/capabilities/pr_review_queue/review_body.py b/loopx/capabilities/pr_review_queue/review_body.py
index afd67a51f0..7351b03ef6 100644
--- a/loopx/capabilities/pr_review_queue/review_body.py
+++ b/loopx/capabilities/pr_review_queue/review_body.py
@@ -67,6 +67,21 @@ def _visible_lines(body: str) -> Iterator[str]:
         yield visible
 
 
+def visible_review_text(body: str) -> str:
+    return "\n".join(_visible_lines(body))
+
+
+def reviewer_declaration_lines(body: str) -> list[str]:
+    # Same visibility rule as the English verdict: a comment or fenced block
+    # cannot carry the declaration a reader is meant to see.
+    lines: list[str] = []
+    for line in _visible_lines(body):
+        match = re.match(r"(?i)^reviewer\s*:\s*(.+)$", line.strip().replace("**", ""))
+        if match:
+            lines.append(match.group(1).strip())
+    return lines
+
+
 def _prose_size(lines: list[str]) -> int:
     prose = "\n".join(dict.fromkeys(lines))
     prose = re.sub(r"!?\[([^\]]*)\]\([^)]*\)", r"\1", prose)
diff --git a/loopx/capabilities/pr_review_queue/review_contract.py b/loopx/capabilities/pr_review_queue/review_contract.py
index e627993a6f..c1143f54da 100644
--- a/loopx/capabilities/pr_review_queue/review_contract.py
+++ b/loopx/capabilities/pr_review_queue/review_contract.py
@@ -8,7 +8,7 @@
 from .approval_closeout import approval_closeout_contract
 
 # Increment when review requirements change without changing the packet shape.
-REVIEW_POLICY_REVISION = 13
+REVIEW_POLICY_REVISION = 14
 
 # A red check is an observation, not evidence that the reviewed PR caused it.
 # This contract belongs to review judgment; merge readiness still owns whether
@@ -138,6 +138,90 @@
     ),
 }
 
+# A published review speaks for an agent or a person, and a reader from another
+# operator has no other way to weigh it. This is provenance carried by the
+# result itself, not review evidence: no reviewer can "verify" its own identity,
+# so a gap here makes the result unpublishable rather than blocking the author.
+REVIEWER_DECLARATION = {
+    "actor_kinds": ["model_agent", "human_operator"],
+    "declaration_sources": ["runtime_reported", "self_reported"],
+    "fields": ["actor_kind", "declaration_source"],
+    "model_agent_fields": ["declared_model", "declared_provider"],
+    "body_marker": "Reviewer:",
+    "rule": (
+        "Every result names who wrote it. actor_kind is model_agent or human_operator. "
+        "A model_agent gives declared_model and declared_provider in ordinary "
+        "product-family wording, and the published body repeats actor_kind, model and "
+        "provider on exactly one visible `Reviewer:` line, so a reader on another host "
+        "or organization can tell a model wrote the review and weigh it without private "
+        "context. declaration_source records whether the host runtime reported the "
+        "identity or the reviewer stated it; a reviewer that cannot observe its exact "
+        "build names the family it knows instead of inventing a version. The declaration "
+        "is provenance, not a credential: it authenticates nothing, authorizes no private "
+        "access and gives the verdict no extra weight. Never put an endpoint, gateway, "
+        "account, credential or router-qualified identifier in it."
+    ),
+}
+
+# Reviewers from different operators share no context or memory; the accepted
+# specification is the one reference both sides can open independently. Map the
+# head onto it criterion by criterion instead of onto the author's narrative.
+SPEC_BASIS_ASSESSMENT = {
+    "decision_values": ["mapped", "no_spec", "not_yet_proven"],
+    "blocking_decisions": ["not_yet_proven"],
+    "fields": ["decision", "spec_source", "reason"],
+    "spec_source_values": [
+        "accepted_rfc",
+        "accepted_contract_doc",
+        "linked_issue_or_task",
+        "review_thread",
+        "none",
+    ],
+    "mapped_fields": ["spec_ref", "spec_revision", "criteria"],
+    "published_text_fields": ["spec_ref", "spec_revision"],
+    # The repository's own documents are pinned by a full commit id; a branch or
+    # tag moves, so it cannot name the text the review judged against.
+    "commit_pinned_spec_sources": ["accepted_rfc", "accepted_contract_doc"],
+    "criterion_fields": ["criterion_id", "requirement", "disposition"],
+    "disposition_fields": {
+        "implemented": ["symbol_or_path", "validation_ref"],
+        "deferred": ["reason", "successor_or_gap"],
+        "out_of_scope": ["reason"],
+        "not_met": ["observed_gap", "minimum_repair"],
+    },
+    "blocking_dispositions": ["not_met"],
+    "rule": (
+        "Read the target repository's own accepted specification for the touched surface "
+        "before the implementation: an accepted RFC, an accepted contract or protocol "
+        "document, the linked issue or task, then a maintainer-agreed frame in the review "
+        "thread. For mapped, give spec_ref as a public path or link and spec_revision as "
+        "the immutable revision judged against, so a reviewer from another operator opens "
+        "the same text, and one criteria row per material acceptance criterion with the "
+        "specification's own identifier when it has one, the requirement as written and "
+        "its disposition at this exact head. implemented names a real symbol or path and "
+        "the validation that exercises it; deferred names the reason and the successor or "
+        "remaining gap; out_of_scope cites the specification or accepted task boundary, "
+        "not author preference; not_met names the observed gap and minimum repair and "
+        "blocks approval. Publish spec_ref, spec_revision and every criterion_id in the "
+        "review body: the body is the only part another operator reads, and a path alone "
+        "moves with the branch while the revision pins the text the review judged against. "
+        "Give spec_ref, spec_revision and criterion_id as non-empty strings: each is "
+        "published and matched against the body as a whole token, so EX-1 inside EX-10 "
+        "or C1 inside a commit id is not publication. For accepted_rfc and "
+        "accepted_contract_doc, spec_revision is the full commit id; a branch or tag "
+        "name moves and cannot pin the text. "
+        "Derive requirements from the "
+        "specification, never from the patch. When the change edits the specification it "
+        "cites, judge the criteria as accepted before this change and treat the edit as a "
+        "finding to justify; a specification rewritten to match its implementation is not "
+        "an independent reference. Do not invent criteria, promote a future or aspirational "
+        "property to a current obligation, or impose this repository's roadmap on another "
+        "repository. With no written specification use no_spec, spec_source none and a "
+        "reason; problem_context remains the delivery judgment. An unread or unavailable "
+        "specification is not_yet_proven."
+    ),
+}
+
 CODE_AREAS = {
     "product_runtime",
     "app_or_ui_surface",
@@ -211,7 +295,7 @@ def build_review_template(item: Mapping[str, Any]) -> dict[str, Any]:
             _section(
                 "动机",
                 floors["动机"],
-                "Use `problem_context`: verified goal basis, old behavior, before/after outcome and delivery verdict. Explain outcome_impact on sustained progress and the user journey, including accepted tradeoffs or scoped inapplicability. Distinguish completing the scoped goal from a justified increment; explain why this is a complete useful slice, not just why the code works.",
+                "Use `problem_context`: verified goal basis, old behavior, before/after outcome and delivery verdict. Cite `spec_basis.spec_ref` and map each criterion_id to implemented/deferred/out_of_scope/not_met at this head, or state that no written specification exists. Explain outcome_impact on sustained progress and the user journey, including accepted tradeoffs or scoped inapplicability. Distinguish completing the scoped goal from a justified increment; explain why this is a complete useful slice, not just why the code works.",
             ),
             _section(
                 "改动思路",
@@ -237,6 +321,8 @@ def build_review_template(item: Mapping[str, Any]) -> dict[str, Any]:
         "review_order": _review_order(key_files),
         "output_hint": (
             "Render the verified structured result using the five sections. "
+            "Open the body with one `Reviewer:` line (reviewer_declaration.body_marker) "
+            "carrying result.reviewer's actor_kind, model and provider. "
             "The capability-owned review_execution_contract is the evidence and completeness authority. Save the exact final Markdown in result.review_body before check-result; publish that checked body and read it back. Section floors reject empty shells, not certify reasoning. Explain concrete paths and counterexamples; do not pad or duplicate evidence to meet a floor."
         ),
     }
@@ -252,6 +338,10 @@ def build_review_execution_contract(*, wait_for_ci: bool = True) -> dict[str, An
             "host skills route this contract but must not reimplement it."
         ),
         "evidence_status_values": ["verified", "unverified", "not_applicable"],
+        # Provenance and spec binding travel with every result, so a host skill
+        # routes them from here instead of inventing its own wording.
+        "reviewer_declaration": deepcopy(REVIEWER_DECLARATION),
+        "spec_basis_assessment": deepcopy(SPEC_BASIS_ASSESSMENT),
         "decision_procedure": {
             "order": [
                 "establish_goal",
@@ -337,6 +427,7 @@ def build_review_execution_contract(*, wait_for_ci: bool = True) -> dict[str, An
                     "smaller_fix_analysis",
                     "observable_outcome",
                     "outcome_impact",
+                    "spec_basis",
                     "non_goals",
                 ],
                 "fields_by_verdict": {
@@ -1278,6 +1369,9 @@ def build_review_plan(item: Mapping[str, Any]) -> dict[str, Any]:
             "findings": [],
             "residual_risk": "",
             "review_body": "",
+            "reviewer": {field: "" for field in (
+                *REVIEWER_DECLARATION["fields"], *REVIEWER_DECLARATION["model_agent_fields"],
+            )},
             "verdict": "unverified",
         },
     }
diff --git a/skills/loopx-pr-review/SKILL.md b/skills/loopx-pr-review/SKILL.md
index 75c6df7ce3..5b5e2b68e6 100644
--- a/skills/loopx-pr-review/SKILL.md
+++ b/skills/loopx-pr-review/SKILL.md
@@ -37,8 +37,7 @@ Save the full first JSON packet before printing a compact projection. Keep all
 paths named by `agent_response_contract.required_packet_fields_to_preserve`:
 
 - `agent_response_contract.review_execution_contract`
-- `result_completeness` and `scheduling_policy`
-- `review_groups`
+- `result_completeness`, `scheduling_policy`, `review_groups`
 - `pull_requests[review_action_kind!=null].review_plan`
 - `pull_requests[review_action_kind!=null].review_template`
 - `pull_requests[review_action_kind!=null].evidence_commands`
@@ -47,11 +46,11 @@ Do not pipe the only copy through `jq`. When an exhaustive queue request has
 `result_completeness.complete=false`, rerun with its `recommended_limit` before
 reviewing; `limit_scope=exact_targets` is already complete for the named targets.
 
-Require the revision the installed capability declares, not a literal this file pins: read
-`review_execution_contract.policy_revision` from the packet and require the result's `review_policy_revision` to equal it.
-A schema name alone is insufficient. If missing or unequal, do not publish APPROVE; a conservative REQUEST_CHANGES
-is allowed only when it names the incompatible-policy gap. Do not retain expired temporary worktree overrides.
-Honor explicit runtime pins, but report incompatible policy rather than silently downgrading the review.
+Read `review_execution_contract.policy_revision` from the packet; require the result's
+`review_policy_revision` to equal it, never a literal this file pins. If missing or unequal,
+do not publish APPROVE; a conservative REQUEST_CHANGES is allowed only when it names the
+incompatible-policy gap. Do not retain expired temporary worktree overrides. Report
+incompatible policy rather than downgrading the review.
 
 ## Read The Review Frame First
 
@@ -59,39 +58,37 @@ Read the PR's existing comments and cited documents first: a maintainer comment
 names the contract the change is judged against.
 
 - Review inside that frame; cite the document and check its rows, gates, or exit criteria one by one at the exact head, attaching each finding to its row.
-- Name unsatisfied rows as missing frame items with their own evidence, and keep the declared boundary (preview versus promotion, milestone entry versus merge).
+- Name unsatisfied rows as missing frame items with their own evidence; keep the declared boundary (preview versus promotion, milestone entry versus merge).
 - Publish the frame-aligned conclusion as a PR comment citing that guidance, since a published review body cannot be edited.
 
 ## Execute One Review Plan
 
 Follow `scheduling_policy` and its ranked actionable `review_sequence`; explicit current-request PR selection may override ordering only, never `pull_requests[].review_action_kind` or exact-head idempotency. Generic `re-review`, `重新review`, and `复审` wording selects the named PR; it is not a force-refresh token. Todo/monitor prose may not select work.
-When `review_action_kind` is null, the row stays in `pull_requests` inventory but must not appear in `review_sequence`; its `review_plan` and `review_template` are null and `evidence_commands` is empty. Do one compact exact-head conclusion readback and report the existing verdict or bounded invalid/missing reason. Run a fresh audit only when the user explicitly requests fresh evidence despite that no-action result, or supplies a concrete new concern/evidence invalidation; regenerate with `--fresh-audit-exact-head NUMBER@HEAD_OID`, then execute the complete current plan and never inherit the earlier approval. For every actionable PR:
-
-1. Record the packet's exact head. Follow `review_execution_contract.decision_procedure`, starting with the current goal
-   and `problem_context` judgment of delivery, sustained progress and user experience, including on re-review;
-   then run `evidence_commands` and relevant repository-native validation.
-2. Fill `review_plan.result_template` from the shared execution contract;
-   preserve missing evidence as `unverified`. Execute its repository-reuse,
-   default-off, authority and real-path counterfactual requirements rather than
-   repeating them as prose. Never infer `verified` from metadata or CI.
+When `review_action_kind` is null, the row stays in `pull_requests` inventory but must not appear in `review_sequence`; its `review_plan` and `review_template` are null and `evidence_commands` is empty. Do one compact exact-head conclusion readback and report the existing verdict or bounded invalid/missing reason. Run a fresh audit only when the user explicitly requests fresh evidence despite that result, or supplies a concrete new concern; regenerate with `--fresh-audit-exact-head NUMBER@HEAD_OID`, then execute the complete current plan and never inherit the earlier approval. For every actionable PR:
+
+1. Record the packet's exact head, then follow `review_execution_contract.decision_procedure`:
+   the current goal and `problem_context` delivery judgment first, including on re-review,
+   then `evidence_commands` and repository-native validation.
+2. Fill `review_plan.result_template`; preserve missing evidence as `unverified` and never
+   infer `verified` from metadata or CI. Execute its repository-reuse, default-off, authority
+   and real-path counterfactuals rather than repeating them as prose. Fill `result.reviewer`
+   per `review_execution_contract.reviewer_declaration`, open the body with its `body_marker`
+   line, and read `problem_context.spec_basis`'s specification before the diff.
 3. Apply `completion_gate` literally: save final Markdown in `review_body`, then check
-   evidence and that exact body. Follow capability-owned floors and scope
-   counterfactuals; prose cannot replace missing execution:
+   evidence and that exact body. Follow capability-owned floors and scope counterfactuals;
+   prose cannot replace missing execution:
 
    ```bash
    loopx --format json pr-review --check-result review-result.json --packet review-packet.json
    ```
 
-   Fix contradictory verdicts, not evidence labels to obtain a pass. This local
-   check cannot verify evidence truth, architecture judgment, remote freshness, or
-   an old result relabeled without executing the current plan. Verified rows fill
-   their declared fields; validation rows bind typed `case_id` coverage, and
-   missing material evidence needs a concrete request-changes reason.
+   Fix contradictory verdicts, not evidence labels. It cannot verify evidence truth,
+   architecture, freshness or a relabeled old result.
 4. Publish the checked `review_body`; recheck after edits. Remote readback uses
    the same body rules. Headings and a verdict alone cannot certify a review.
-5. Re-read the remote head immediately before verdict and publication; restart the evidence pass if it changed.
+5. Re-read the remote head immediately before verdict and publication; restart evidence if it changed.
 
-Each PR needs independent evidence and a standalone card; a queue table is only a preface.
+Each PR needs independent evidence and a standalone card; a queue table is a preface only.
 
 For managed review, pass `--goal-id GOAL` and follow the packet’s resolved `wait_for_ci`: false means never fetch, poll, or wait for CI; true retains CI observation. Apply the packet's `validation_matrix.failure_attribution` before treating a red required check as a PR blocker. An independently verified unchanged baseline failure or external outage can hold merge readiness without forcing `REQUEST_CHANGES` on an unrelated PR; missing attribution or missing affected-invariant coverage still blocks approval. Configure one Goal with `configure-goal --goal-id GOAL --no-pr-review-wait-for-ci --execute`; clear with `--clear-pr-review-configuration --execute`.
 
@@ -108,17 +105,17 @@ requested local-only/dry-run output or the finding is private or security-sensit
 - Merged PR: publish a post-merge audit comment only for a new actionable finding;
   avoid duplicating an equivalent exact-head result.
 
-Build public text from the exact reviewed head; remove local paths, private context,
-raw logs, credentials, and internal-only links. Read the published review back,
-verify state/body and return its URL. After APPROVE (also existing approval), execute
-`review_execution_contract.approval_closeout`; reconcile only verified obsolete
-blockers with owner/GitHub authority, preserving discussion and unresolved reviews.
-Merge routes through `loopx-pr-merge`; an `APPROVE` is not merge authority.
+Build public text from the exact reviewed head; remove local paths, private context, raw
+logs, credentials and internal-only links. Read the published review back, verify state/body
+and return its URL. After APPROVE (incl. existing approval), execute
+`review_execution_contract.approval_closeout`; reconcile only verified obsolete blockers with
+owner/GitHub authority, preserving discussion and unresolved reviews. Merge routes through
+`loopx-pr-merge`; `APPROVE` is not merge authority; a public blocker belongs on the PR.
 
 Immediately before every merge, run `loopx --format json pr-review --goal-id GOAL
---repo OWNER/REPO --check-merge-readiness NUMBER@HEAD_OID`; require `ready=true`.
-Its compact Goal observation suppresses only unchanged requalification; material
-change reopens it, admin bypass never overrides this gate, and author fallback needs user authority.
+--repo OWNER/REPO --check-merge-readiness NUMBER@HEAD_OID`; require `ready=true`. Its compact
+Goal observation suppresses only unchanged requalification; material change reopens it, admin
+bypass never overrides this gate, and author fallback needs user authority.
 
 ## Full PR Review And Bilingual Format
 
@@ -131,7 +128,10 @@ Publish two artifacts:
 1. **详细中文评审** - a standalone Chinese full-PR review with the exact head and five
    sections: `动机`, `改动思路`, `具体改动`, `对主干的风险`, `我的整体评价`. Cover every
    changed surface and key symbols, not only the main finding.
-2. **英文简短结论** - a line starting with exactly `English verdict:` followed by the bare
+2. **审查者来源** - one visible `body_marker` line naming the actor kind and, for an
+   agent, the model and provider. It must agree with `result.reviewer`; a reviewer
+   from another operator reads this body, not your local result.
+3. **英文简短结论** - a line starting with exactly `English verdict:` followed by the bare
    token `APPROVE` or `REQUEST_CHANGES`, then the head, key finding, and validation. The
    parser matches that token as a keyword, so `English verdict: Approved at ...` is invalid
    and leaves the head without a merge-ready approval; write `English verdict: APPROVE - ...`.
diff --git a/tests/capabilities/test_pr_review_contract.py b/tests/capabilities/test_pr_review_contract.py
index c97d87988e..1946487dd7 100644
--- a/tests/capabilities/test_pr_review_contract.py
+++ b/tests/capabilities/test_pr_review_contract.py
@@ -88,6 +88,20 @@ def test_execution_contract_owns_deep_review_requirements() -> None:
         "minimum": 2,
         "maximum": 5,
     }
+    # Every review is bound to the specification it judged, inside the goal
+    # judgment that owns it, rather than to its own narrative.
+    assert "spec_basis" in requirements["problem_context"]["fields"]
+    assert "not_met" in contract["spec_basis_assessment"]["blocking_dispositions"]
+    # Provenance is carried by the result, never scored as review evidence.
+    assert "reviewer" not in requirements
+    assert contract["reviewer_declaration"]["actor_kinds"] == [
+        "model_agent",
+        "human_operator",
+    ]
+    assert contract["reviewer_declaration"]["model_agent_fields"] == [
+        "declared_model",
+        "declared_provider",
+    ]
     assert "caller_evidence" in requirements["symbol_map"]["item_fields"]
     assert "negative_fields" in requirements["walkthroughs"]
     assert "regression_test" in requirements["failure_analysis"]["fields"]
diff --git a/tests/capabilities/test_pr_review_result_check.py b/tests/capabilities/test_pr_review_result_check.py
index 92960fd2cf..6db76ab9e0 100644
--- a/tests/capabilities/test_pr_review_result_check.py
+++ b/tests/capabilities/test_pr_review_result_check.py
@@ -40,6 +40,11 @@ def _review(*, area="product_runtime"):
         if "verdict_values" in requirement:
             row["verdict"] = requirement["verdict_values"][0]
         if key == "problem_context":
+            row["spec_basis"] = {
+                "decision": "no_spec",
+                "spec_source": "none",
+                "reason": "Synthetic formatter fixture has no written specification.",
+            }
             row["outcome_impact"] = {
                 dimension: {"decision": "not_applicable",
                             "reason": "Synthetic internal formatter fixture has no durable work or user journey.",
@@ -90,10 +95,58 @@ def _review(*, area="product_runtime"):
                     for field in fields
                 }
     result["verdict"] = "APPROVE"
-    result["review_body"] = (Path(__file__).parents[2] / "examples/fixtures/pr-review.body.md").read_text().replace("HEAD_OID", "a" * 40).replace("VERDICT", "APPROVE")
+    result["reviewer"] = {
+        "actor_kind": "model_agent",
+        "declaration_source": "self_reported",
+        "declared_model": "Example Model 1",
+        "declared_provider": "Example Provider",
+    }
+    body = (Path(__file__).parents[2] / "examples/fixtures/pr-review.body.md").read_text()
+    result["review_body"] = (
+        f"{REVIEWER_LINE}\n\n"
+        + body.replace("HEAD_OID", "a" * 40).replace("VERDICT", "APPROVE")
+    )
     return {"pull_requests": [item]}, result
 
 
+REVIEWER_LINE = "Reviewer: model_agent · Example Model 1 · Example Provider"
+
+
+def _mapped_spec_basis():
+    return {
+        "decision": "mapped",
+        "spec_source": "accepted_rfc",
+        "reason": "The change implements an accepted RFC section.",
+        "spec_ref": "docs/architecture/rfcs/example-v0.md#acceptance",
+        "spec_revision": "b" * 40,
+        "criteria": [
+            {
+                "criterion_id": "EX-1",
+                "requirement": "Readback reports the persisted value.",
+                "disposition": "implemented",
+                "symbol_or_path": "loopx/example.py::read_back",
+                "validation_ref": "tests/test_example.py::test_read_back",
+            },
+            {
+                "criterion_id": "EX-2",
+                "requirement": "Migration of old rows.",
+                "disposition": "deferred",
+                "reason": "Old rows are retired by the successor task.",
+                "successor_or_gap": "The linked migration task.",
+            },
+        ],
+    }
+
+
+def _publish_spec_references(result):
+    # The published body carries the immutable revision a reader on another host
+    # needs to open the same specification text, not only its moving path.
+    result["review_body"] += (
+        "\n\nSpec basis: docs/architecture/rfcs/example-v0.md#acceptance"
+        " @ revision " + "b" * 40 + " — EX-1 implemented; EX-2 deferred.\n"
+    )
+
+
 def test_result_check_is_not_semantic_or_merge_authority():
     packet, result = _review()
     checked = check_review_result(packet, result)
@@ -471,6 +524,131 @@ def test_nonblocking_suggestion_does_not_force_rejection():
     assert check_review_result(packet, result)["approval_consistent"]
 
 
+def test_review_must_say_which_model_wrote_it_in_the_published_body():
+    packet, result = _review()
+    assert check_review_result(packet, result)["ok"]
+    result["review_body"] = result["review_body"].replace(REVIEWER_LINE + "\n\n", "")
+    assert "reviewer:body_line_missing_or_ambiguous" in check_review_result(packet, result)["errors"]
+    # A declaration hidden from readers is not a declaration.
+    result["review_body"] = f"<!-- {REVIEWER_LINE} -->\n\n" + result["review_body"]
+    assert "reviewer:body_line_missing_or_ambiguous" in check_review_result(packet, result)["errors"]
+
+
+def test_published_reviewer_line_must_match_the_declaration():
+    packet, result = _review()
+    result["reviewer"]["declared_model"] = "Another Model 2"
+    checked = check_review_result(packet, result)
+    assert not checked["ok"]
+    assert "reviewer:body_line_disagrees_with_declaration" in checked["errors"]
+
+
+@pytest.mark.parametrize("field, value, reason", [
+    ("actor_kind", "agent", "reviewer:invalid_actor_kind"),
+    ("declaration_source", "guessed", "reviewer:invalid_declaration_source"),
+    ("declared_model", "", "reviewer:missing_field:declared_model"),
+    ("declared_provider", "  ", "reviewer:missing_field:declared_provider"),
+    ("declared_model", "https://gateway.example/v1", "reviewer:not_a_product_family_name:declared_model"),
+    ("declared_provider", "ops@example", "reviewer:not_a_product_family_name:declared_provider"),
+])
+def test_reviewer_declaration_rejects_unknown_or_infrastructure_values(field, value, reason):
+    packet, result = _review()
+    result["reviewer"][field] = value
+    assert reason in check_review_result(packet, result)["errors"]
+
+
+def test_missing_reviewer_declaration_blocks_publication_of_any_verdict():
+    packet, result = _review()
+    del result["reviewer"]
+    result["verdict"] = "REQUEST_CHANGES"
+    result["review_body"] = result["review_body"].replace(
+        "English verdict: APPROVE", "English verdict: REQUEST_CHANGES")
+    checked = check_review_result(packet, result)
+    assert "reviewer:missing_declaration" in checked["errors"]
+    assert not checked["ok"]
+
+
+def test_human_operator_needs_no_model_or_provider():
+    packet, result = _review()
+    result["reviewer"] = {"actor_kind": "human_operator", "declaration_source": "self_reported"}
+    result["review_body"] = result["review_body"].replace(REVIEWER_LINE, "Reviewer: human_operator")
+    assert check_review_result(packet, result)["ok"]
+
+
+def test_mapped_spec_basis_binds_criteria_to_the_head_and_the_published_body():
+    packet, result = _review()
+    result["evidence"]["problem_context"]["spec_basis"] = _mapped_spec_basis()
+    unpublished = check_review_result(packet, result)
+    assert not unpublished["ok"]
+    assert "review_body:spec_reference_not_published:EX-1" in unpublished["errors"]
+    assert ("review_body:spec_reference_not_published:docs/architecture/rfcs/example-v0.md#acceptance"
+            in unpublished["errors"])
+    _publish_spec_references(result)
+    checked = check_review_result(packet, result)
+    assert checked["ok"] and checked["approval_consistent"]
+
+
+def test_unmet_specification_criterion_cannot_be_approved():
+    packet, result = _review()
+    basis = _mapped_spec_basis()
+    basis["criteria"][1] = {
+        "criterion_id": "EX-2",
+        "requirement": "Migration of old rows.",
+        "disposition": "not_met",
+        "observed_gap": "Old rows keep the previous shape.",
+        "minimum_repair": "Migrate old rows before readback.",
+    }
+    result["evidence"]["problem_context"]["spec_basis"] = basis
+    _publish_spec_references(result)
+    checked = check_review_result(packet, result)
+    assert "problem_context:spec_basis:unmet_criterion:EX-2" in checked["approval_blockers"]
+    assert "approval_contradicts_evidence" in checked["errors"]
+    result["verdict"] = "REQUEST_CHANGES"
+    result["review_body"] = result["review_body"].replace(
+        "English verdict: APPROVE", "English verdict: REQUEST_CHANGES")
+    assert check_review_result(packet, result)["ok"]
+
+
+@pytest.mark.parametrize("mutation, blocker", [
+    ("unknown_disposition", "problem_context:spec_basis:invalid_disposition:EX-1"),
+    ("implemented_without_symbol", "problem_context:spec_basis:EX-1:missing_field:symbol_or_path"),
+    ("deferred_without_successor", "problem_context:spec_basis:EX-2:missing_field:successor_or_gap"),
+    ("duplicate_criterion", "problem_context:spec_basis:duplicate_criterion:EX-1"),
+    ("no_revision", "problem_context:spec_basis:missing_field:spec_revision"),
+    ("mapped_without_source", "problem_context:spec_basis:mapped_without_spec_source"),
+    ("unread_spec", "problem_context:spec_basis:blocking_decision"),
+    ("no_spec_with_source", "problem_context:spec_basis:no_spec_cannot_cite_a_source"),
+    ("missing", "problem_context:spec_basis:value_not_object"),
+])
+def test_spec_basis_cannot_approve_with_incomplete_or_contradictory_mapping(mutation, blocker):
+    packet, result = _review()
+    basis = _mapped_spec_basis()
+    if mutation == "unknown_disposition":
+        basis["criteria"][0]["disposition"] = "mostly_done"
+    elif mutation == "implemented_without_symbol":
+        del basis["criteria"][0]["symbol_or_path"]
+    elif mutation == "deferred_without_successor":
+        del basis["criteria"][1]["successor_or_gap"]
+    elif mutation == "duplicate_criterion":
+        basis["criteria"][1]["criterion_id"] = "EX-1"
+    elif mutation == "no_revision":
+        del basis["spec_revision"]
+    elif mutation == "mapped_without_source":
+        basis["spec_source"] = "none"
+    elif mutation == "unread_spec":
+        basis = {"decision": "not_yet_proven", "spec_source": "accepted_rfc",
+                 "reason": "The cited RFC revision could not be opened."}
+    elif mutation == "no_spec_with_source":
+        basis = {"decision": "no_spec", "spec_source": "accepted_rfc", "reason": "x"}
+    if mutation == "missing":
+        del result["evidence"]["problem_context"]["spec_basis"]
+    else:
+        result["evidence"]["problem_context"]["spec_basis"] = basis
+    _publish_spec_references(result)
+    checked = check_review_result(packet, result)
+    assert blocker in checked["approval_blockers"]
+    assert not checked["ok"]
+
+
 @pytest.mark.parametrize("revision", [None, 0, True, "1", 5, 999])
 def test_old_or_invalid_policy_cannot_certify_current_approval(revision):
     packet, result = _review()
@@ -863,3 +1041,125 @@ def test_projected_compatibility_rules_cannot_mutate_the_checker():
     packet["agent_response_contract"] = {"review_execution_contract": contract}
     result["evidence"]["code_volume"]["compatibility_assessment"] = _compatibility(decision="simplify_now")
     assert not check_review_result(packet, result)["approval_consistent"]
+
+
+@pytest.mark.parametrize("identity", [True, False, ["EX-1"], {"id": "EX-1"}, 1, ""])
+def test_a_criterion_identity_must_be_published_text(identity):
+    """A criterion that cannot be named in the body is not a criterion.
+
+    Bools hash and are non-empty, and non-strings silently fall out of the
+    published-body check, so the type is validated where membership, duplicate
+    detection and publication all assume it — not left to a later set or dict
+    operation that would either pass or fail with a command-level error.
+    """
+    packet, result = _review()
+    basis = _mapped_spec_basis()
+    basis["criteria"][0]["criterion_id"] = identity
+    result["evidence"]["problem_context"]["spec_basis"] = basis
+    _publish_spec_references(result)
+    checked = check_review_result(packet, result)
+    assert "problem_context:spec_basis:invalid_criterion_id" in checked["approval_blockers"]
+    assert not checked["ok"]
+
+
+@pytest.mark.parametrize("field", ["spec_ref", "spec_revision"])
+@pytest.mark.parametrize("value", [True, {"path": "x"}, ["b" * 40], 1, "   "])
+def test_a_mapped_specification_reference_must_be_published_text(field, value):
+    """A reference the body cannot carry cannot pin the reviewed specification.
+
+    Non-string values pass the non-empty field check and then fall out of the
+    published-body comparison, so an approval would cite nothing a reader on
+    another host could open.
+    """
+    packet, result = _review()
+    basis = _mapped_spec_basis()
+    basis[field] = value
+    result["evidence"]["problem_context"]["spec_basis"] = basis
+    _publish_spec_references(result)
+    checked = check_review_result(packet, result)
+    assert f"problem_context:spec_basis:invalid_{field}" in checked["approval_blockers"]
+    assert not checked["ok"] and not checked["approval_consistent"]
+
+
+@pytest.mark.parametrize(("criterion_id", "spec_revision", "line", "unpublished"), [
+    # A criterion named only inside a longer criterion is not published.
+    ("EX-1", "b" * 40, "EX-10 implemented; EX-2 deferred.", "EX-1"),
+    # A short identity hidden inside the pinned commit id is not published.
+    ("bbb", "b" * 40, "EX-2 deferred.", "bbb"),
+])
+def test_a_specification_reference_must_appear_as_a_whole_token(
+    criterion_id, spec_revision, line, unpublished,
+):
+    """Another operator reads the body, so a substring of another word names nothing."""
+    packet, result = _review()
+    basis = _mapped_spec_basis()
+    basis["criteria"][0]["criterion_id"] = criterion_id
+    basis["spec_revision"] = spec_revision
+    result["evidence"]["problem_context"]["spec_basis"] = basis
+    result["review_body"] += (
+        "\n\nSpec basis: docs/architecture/rfcs/example-v0.md#acceptance @ "
+        + spec_revision + " — " + line + "\n"
+    )
+    checked = check_review_result(packet, result)
+    assert f"review_body:spec_reference_not_published:{unpublished}" in checked["errors"]
+    assert not checked["ok"] and not checked["approval_consistent"]
+
+    result["review_body"] += f"{criterion_id} implemented.\n"
+    assert check_review_result(packet, result)["ok"]
+
+
+def test_reviewer_line_must_name_each_declared_value_as_a_whole_token():
+    packet, result = _review()
+    result["reviewer"]["declared_provider"] = "AI"
+    result["review_body"] = result["review_body"].replace(
+        REVIEWER_LINE, "Reviewer: model_agent · Example Model 1 · OpenAI")
+    checked = check_review_result(packet, result)
+    assert "reviewer:body_line_disagrees_with_declaration" in checked["errors"]
+
+    result["review_body"] = result["review_body"].replace(
+        "· OpenAI", "· AI (self-reported family)")
+    assert check_review_result(packet, result)["ok"]
+
+
+@pytest.mark.parametrize("revision", ["main", "v1.2.0", "b" * 12, "B" * 39])
+def test_a_repository_specification_is_pinned_by_a_full_commit_id(revision):
+    """A branch, tag or abbreviated id cannot name the text the review judged."""
+    packet, result = _review()
+    basis = _mapped_spec_basis()
+    basis["spec_revision"] = revision
+    result["evidence"]["problem_context"]["spec_basis"] = basis
+    result["review_body"] += (
+        "\n\nSpec basis: docs/architecture/rfcs/example-v0.md#acceptance @ "
+        + revision + " — EX-1 implemented; EX-2 deferred.\n"
+    )
+    checked = check_review_result(packet, result)
+    assert "problem_context:spec_basis:spec_revision_not_a_commit_id" in checked["approval_blockers"]
+    assert not checked["ok"]
+
+    # A linked task or review thread has no commit; its revision stays free text.
+    basis["spec_source"] = "linked_issue_or_task"
+    assert check_review_result(packet, result)["ok"]
+
+
+def test_a_published_mapping_must_carry_its_immutable_revision():
+    """Another host can only open the same text if the body pins the revision.
+
+    The path moves with the branch, so publishing the path alone lets a reader
+    find a different document than the one the review judged against.
+    """
+    packet, result = _review()
+    result["evidence"]["problem_context"]["spec_basis"] = _mapped_spec_basis()
+    revision = "b" * 40
+    result["review_body"] += (
+        "\n\nSpec basis: docs/architecture/rfcs/example-v0.md#acceptance"
+        " — EX-1 implemented; EX-2 deferred.\n"
+    )
+    assert revision not in result["review_body"]
+    checked = check_review_result(packet, result)
+    # A body-level gap blocks publication rather than scoring the evidence.
+    assert f"review_body:spec_reference_not_published:{revision}" in checked["errors"]
+    assert not checked["ok"] and not checked["approval_consistent"]
+
+    # Publishing the same mapping with its revision closes the gap.
+    result["review_body"] += "Spec revision: " + revision + "\n"
+    assert check_review_result(packet, result)["ok"]