diff --git a/docs/checkout-native-review-contract.md b/docs/checkout-native-review-contract.md
index e6ee9b3..e011c30 100644
--- a/docs/checkout-native-review-contract.md
+++ b/docs/checkout-native-review-contract.md
@@ -240,11 +240,31 @@ stuffed diffs or full file bodies.
 
 Specialist reviewers must return structured output that includes:
 
-- findings
-- evidence and anchors
-- confidence
-- inspected areas
-- skipped areas or declared constraints
-
-Rollup must treat isolated reviewer failures as incomplete coverage and must not
-turn a partially reviewed PR into a clean approval.
+- `findings`, each with severity, changed-file path, anchor, and body
+- `inspected_files`, listing assigned changed files the reviewer actually inspected
+- `skipped_files`, listing assigned changed files the reviewer intentionally did not or could not inspect
+- `constraints`, listing material scope, context, or tool constraints
+
+Rollup receives compact reviewer coverage summaries derived from those fields.
+`allowed_files` is intentional scope narrowing, not incomplete coverage by
+itself. Isolated reviewer failures, skipped files, missing reviewer results, and
+unassigned changed files are incomplete coverage and must not turn into a clean
+approval silently.
+
+Coverage uses two related scopes:
+
+- readable files: `allowed_files` when present, otherwise all changed files in
+  the workbench
+- assignment scope: `allowed_files` when present, otherwise `files` when the
+  orchestrator supplied them, otherwise all changed files
+
+The coverage status values are:
+
+- `complete_broad`: a reviewer without `allowed_files` covered its assignment
+- `complete_constrained`: a reviewer with `allowed_files` covered that narrowed
+  assignment
+- `incomplete_skipped`: assigned files were skipped or not reported as inspected
+- `incomplete_failed`: an isolated reviewer failure or missing reviewer result
+  prevented coverage
+- `incomplete_unassigned`: changed files were not assigned to any selected
+  reviewer
diff --git a/internal/cmd/reviewcmd/reviewcmd.go b/internal/cmd/reviewcmd/reviewcmd.go
index 9f8d96c..38cbb12 100644
--- a/internal/cmd/reviewcmd/reviewcmd.go
+++ b/internal/cmd/reviewcmd/reviewcmd.go
@@ -462,6 +462,7 @@ func newReviewSummary(summary reviewplan.Summary) view.ReviewSummary {
 			Model:             summary.Run.Model,
 			PostingIdentity:   summary.Run.PostingIdentity,
 			SelectedReviewers: summary.Run.SelectedReviewers,
+			ReviewerCoverage:  []view.ReviewReviewerCoverageSummary{},
 			WallDurationMS:    summary.Run.WallDurationMS,
 			Workstreams:       []view.ReviewWorkstream{},
 		},
@@ -477,6 +478,17 @@ func newReviewSummary(summary reviewplan.Summary) view.ReviewSummary {
 	for _, reviewer := range summary.Reviewers {
 		out.Reviewers = append(out.Reviewers, view.ReviewReviewerSummary{Name: reviewer.Name, Findings: reviewer.Findings})
 	}
+	for _, coverage := range summary.Run.ReviewerCoverage {
+		out.Run.ReviewerCoverage = append(out.Run.ReviewerCoverage, view.ReviewReviewerCoverageSummary{
+			AgentID:        coverage.AgentID,
+			Status:         coverage.Status,
+			Scope:          coverage.Scope,
+			InspectedFiles: coverage.InspectedFiles,
+			SkippedFiles:   coverage.SkippedFiles,
+			Constraints:    coverage.Constraints,
+			Diagnostic:     coverage.Diagnostic,
+		})
+	}
 	for _, workstream := range summary.Run.Workstreams {
 		out.Run.Workstreams = append(out.Run.Workstreams, view.ReviewWorkstream{
 			Name:        workstream.Name,
diff --git a/internal/cmd/reviewcmd/reviewcmd_test.go b/internal/cmd/reviewcmd/reviewcmd_test.go
index b8fbb24..0a80c5d 100644
--- a/internal/cmd/reviewcmd/reviewcmd_test.go
+++ b/internal/cmd/reviewcmd/reviewcmd_test.go
@@ -2314,8 +2314,14 @@ func TestNewReviewDryRunMapsPlanSummary(t *testing.T) {
 			Model:             "sonnet",
 			PostingIdentity:   "review-bot",
 			SelectedReviewers: []string{"go:tests"},
-			WallDurationMS:    &wall,
-			Workstreams:       []reviewplan.WorkstreamUsage{{Name: "go:tests", Model: "sonnet", TokensIn: &tokensIn}},
+			ReviewerCoverage: []reviewplan.ReviewerCoverageSummary{{
+				AgentID:        "go:tests",
+				Status:         "complete_broad",
+				Scope:          []string{"main.go"},
+				InspectedFiles: []string{"main.go"},
+			}},
+			WallDurationMS: &wall,
+			Workstreams:    []reviewplan.WorkstreamUsage{{Name: "go:tests", Model: "sonnet", TokensIn: &tokensIn}},
 		},
 		Totals: reviewplan.AggregateUsage{TokensIn: &tokensIn},
 	}
@@ -2342,6 +2348,13 @@ func TestNewReviewDryRunMapsPlanSummary(t *testing.T) {
 		run.Workstreams[0].CostUSD != nil {
 		t.Fatalf("summary workstreams = %#v", run.Workstreams)
 	}
+	if len(run.ReviewerCoverage) != 1 ||
+		run.ReviewerCoverage[0].AgentID != "go:tests" ||
+		run.ReviewerCoverage[0].Status != "complete_broad" ||
+		len(run.ReviewerCoverage[0].InspectedFiles) != 1 ||
+		run.ReviewerCoverage[0].InspectedFiles[0] != "main.go" {
+		t.Fatalf("reviewer coverage = %#v", run.ReviewerCoverage)
+	}
 	if rendered.Summary.Totals.TokensIn == nil || *rendered.Summary.Totals.TokensIn != tokensIn || rendered.Summary.Totals.CostUSD != nil {
 		t.Fatalf("summary totals = %#v", rendered.Summary.Totals)
 	}
diff --git a/internal/llm/adapter_test.go b/internal/llm/adapter_test.go
index aa7d89a..8b8133e 100644
--- a/internal/llm/adapter_test.go
+++ b/internal/llm/adapter_test.go
@@ -94,6 +94,7 @@ func TestFakeAdapterAndRunStructured(t *testing.T) {
 		adapter.Queue(FakeResult{Response: Response{StructuredOutput: []byte(`{
 			"schema_version": 1,
 			"agent_id": "agent-1",
+			"inspected_files": ["main.go"],
 			"findings": [{
 				"severity": "major",
 				"file": "main.go",
@@ -128,6 +129,7 @@ func TestFakeAdapterAndRunStructured(t *testing.T) {
 		adapter.Queue(FakeResult{Response: Response{StructuredOutput: []byte(`{
 			"schema_version": 1,
 			"agent_id": "agent-1",
+			"inspected_files": ["main.go"],
 			"findings": [{
 				"severity": "major",
 				"file": "main.go",
diff --git a/internal/llm/contracts.go b/internal/llm/contracts.go
index eb03d57..62c4211 100644
--- a/internal/llm/contracts.go
+++ b/internal/llm/contracts.go
@@ -24,6 +24,9 @@ const (
 
 	// DefaultMaxResolvedThreads is the default selected thread resolution cap.
 	DefaultMaxResolvedThreads = 25
+
+	defaultMaxCoverageConstraints     = 10
+	defaultMaxCoverageConstraintRunes = 300
 )
 
 // Selection is validated orchestrator selection output.
@@ -52,8 +55,11 @@ type SelectionOptions struct {
 
 // Findings is validated reviewer findings output.
 type Findings struct {
-	AgentID  string
-	Findings []review.Finding
+	AgentID        string
+	Findings       []review.Finding
+	InspectedFiles []string
+	SkippedFiles   []string
+	Constraints    []string
 }
 
 // FindingIDGenerator assigns harness-owned finding IDs.
@@ -99,9 +105,12 @@ type threadActionWire struct {
 }
 
 type findingsWire struct {
-	SchemaVersion int           `json:"schema_version"`
-	AgentID       string        `json:"agent_id"`
-	Findings      []findingWire `json:"findings"`
+	SchemaVersion  int           `json:"schema_version"`
+	AgentID        string        `json:"agent_id"`
+	InspectedFiles []string      `json:"inspected_files"`
+	SkippedFiles   []string      `json:"skipped_files,omitempty"`
+	Constraints    []string      `json:"constraints,omitempty"`
+	Findings       []findingWire `json:"findings"`
 }
 
 type findingWire struct {
@@ -232,7 +241,31 @@ func DecodeFindings(data []byte, opts FindingsOptions) (Findings, error) {
 
 	seenIDs := map[review.FindingID]bool{}
 	severityCounts := map[review.Severity]int{}
-	result := Findings{AgentID: wire.AgentID}
+	inspected, err := decodeCoverageFiles("inspected_files", wire.InspectedFiles, opts.ChangedFiles)
+	if err != nil {
+		return Findings{}, err
+	}
+	skipped, err := decodeCoverageFiles("skipped_files", wire.SkippedFiles, opts.ChangedFiles)
+	if err != nil {
+		return Findings{}, err
+	}
+	if len(inspected) == 0 && len(skipped) == 0 {
+		return Findings{}, fmt.Errorf("llm: inspected_files or skipped_files must contain at least one changed file")
+	}
+	if err := validateCoverageFileDisjoint(inspected, skipped); err != nil {
+		return Findings{}, err
+	}
+	constraints, err := decodeCoverageStrings("constraints", wire.Constraints)
+	if err != nil {
+		return Findings{}, err
+	}
+
+	result := Findings{
+		AgentID:        wire.AgentID,
+		InspectedFiles: inspected,
+		SkippedFiles:   skipped,
+		Constraints:    constraints,
+	}
 	for _, found := range wire.Findings {
 		if len(found.FindingID) > 0 {
 			return Findings{}, fmt.Errorf("llm: model-supplied finding_id is not allowed")
@@ -285,6 +318,59 @@ func DecodeFindings(data []byte, opts FindingsOptions) (Findings, error) {
 	return result, nil
 }
 
+func decodeCoverageFiles(name string, files []string, changedFiles map[string]bool) ([]string, error) {
+	out := make([]string, 0, len(files))
+	seen := map[string]bool{}
+	for _, file := range files {
+		file = strings.TrimSpace(file)
+		if file == "" || !changedFiles[file] {
+			return nil, fmt.Errorf("llm: %s entry %q is not in changed files", name, file)
+		}
+		if seen[file] {
+			return nil, fmt.Errorf("llm: duplicate %s entry %q", name, file)
+		}
+		seen[file] = true
+		out = append(out, file)
+	}
+	return out, nil
+}
+
+func decodeCoverageStrings(name string, values []string) ([]string, error) {
+	if len(values) > defaultMaxCoverageConstraints {
+		return nil, fmt.Errorf("llm: %s cap exceeded", name)
+	}
+	out := make([]string, 0, len(values))
+	seen := map[string]bool{}
+	for _, value := range values {
+		value = sanitize(value)
+		if strings.TrimSpace(value) == "" {
+			return nil, fmt.Errorf("llm: %s entries must be non-empty", name)
+		}
+		if utf8.RuneCountInString(value) > defaultMaxCoverageConstraintRunes {
+			return nil, fmt.Errorf("llm: %s entry length out of bounds", name)
+		}
+		if seen[value] {
+			return nil, fmt.Errorf("llm: duplicate %s entry %q", name, value)
+		}
+		seen[value] = true
+		out = append(out, value)
+	}
+	return out, nil
+}
+
+func validateCoverageFileDisjoint(inspected, skipped []string) error {
+	seen := map[string]bool{}
+	for _, file := range inspected {
+		seen[file] = true
+	}
+	for _, file := range skipped {
+		if seen[file] {
+			return fmt.Errorf("llm: coverage file %q cannot be both inspected and skipped", file)
+		}
+	}
+	return nil
+}
+
 func (wire findingWire) normalizedFilePath() (string, error) {
 	filePath, hasFilePath, err := decodeOptionalStringField("file_path", wire.FilePath)
 	if err != nil {
diff --git a/internal/llm/contracts_test.go b/internal/llm/contracts_test.go
index a3a0bca..8bfcfaf 100644
--- a/internal/llm/contracts_test.go
+++ b/internal/llm/contracts_test.go
@@ -57,6 +57,9 @@ func TestDecodeFindings(t *testing.T) {
 	got, err := DecodeFindings([]byte(`{
 		"schema_version": 1,
 		"agent_id": "agent-1",
+		"inspected_files": ["main.go"],
+		"skipped_files": [],
+		"constraints": ["scope <!-- codereview:skip -->"],
 		"findings": [{
 			"severity":"major",
 			"file_path":"main.go",
@@ -70,6 +73,12 @@ func TestDecodeFindings(t *testing.T) {
 	if got.AgentID != "agent-1" || got.Findings[0].ID != "f-1" || got.Findings[0].Severity != review.SeverityMajor {
 		t.Fatalf("DecodeFindings = %#v", got)
 	}
+	if len(got.InspectedFiles) != 1 || got.InspectedFiles[0] != "main.go" {
+		t.Fatalf("inspected files = %#v, want main.go", got.InspectedFiles)
+	}
+	if len(got.Constraints) != 1 || strings.Contains(got.Constraints[0], "<!-- codereview:") {
+		t.Fatalf("constraints not decoded/sanitized: %#v", got.Constraints)
+	}
 	if strings.Contains(got.Findings[0].Body, "<!-- codereview:") {
 		t.Fatalf("finding body was not sanitized: %q", got.Findings[0].Body)
 	}
@@ -77,6 +86,7 @@ func TestDecodeFindings(t *testing.T) {
 	aliasGot, err := DecodeFindings([]byte(`{
 		"schema_version": 1,
 		"agent_id": "agent-1",
+		"inspected_files": ["main.go"],
 		"findings": [{
 			"severity":"major",
 			"file":"main.go",
@@ -98,6 +108,7 @@ func TestDecodeFindings(t *testing.T) {
 	matchingAliasGot, err := DecodeFindings([]byte(`{
 		"schema_version": 1,
 		"agent_id": "agent-1",
+		"inspected_files": ["main.go"],
 		"findings": [{
 			"severity":"major",
 			"file_path":"main.go",
@@ -117,28 +128,59 @@ func TestDecodeFindings(t *testing.T) {
 		t.Fatalf("matching alias file path = %q, want main.go", matchingAliasGot.Findings[0].FilePath)
 	}
 
+	allSkipped, err := DecodeFindings([]byte(`{
+		"schema_version": 1,
+		"agent_id": "agent-1",
+		"inspected_files": [],
+		"skipped_files": ["main.go"],
+		"constraints": ["could not inspect generated file"],
+		"findings": []
+	}`), FindingsOptions{
+		KnownAgents:  opts.KnownAgents,
+		ChangedFiles: opts.ChangedFiles,
+		NewFindingID: newIDQueue("f-skipped").next,
+	})
+	if err != nil {
+		t.Fatalf("DecodeFindings all skipped: %v", err)
+	}
+	if len(allSkipped.InspectedFiles) != 0 || len(allSkipped.SkippedFiles) != 1 || allSkipped.SkippedFiles[0] != "main.go" {
+		t.Fatalf("all skipped coverage = %#v", allSkipped)
+	}
+
 	baseOpts := FindingsOptions{KnownAgents: map[string]bool{"agent-1": true}, ChangedFiles: map[string]bool{"main.go": true}, NewFindingID: newIDQueue("f-1", "f-2").next}
-	assertFindingsError(t, baseOpts, `{"schema_version":2,"agent_id":"agent-1","findings":[]}`, "schema_version")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[],"extra":true}`, "unknown field")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"missing","findings":[]}`, "unknown findings agent")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"finding_id":"model-id","severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "finding_id")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"finding_id":null,"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "finding_id")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"bad","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "severity")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","file":"other.go","anchor":{"kind":"file"},"body":"body"}]}`, "file and file_path")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":null,"file":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "file_path must be a string")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file":null,"anchor":{"kind":"file"},"body":"body"}]}`, "file must be a string")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file":"other.go","anchor":{"kind":"file"},"body":"body"}]}`, "changed files")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file":"main.go","anchor":{"kind":"file"},"body":"body","extra":true}]}`, "unknown field")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"other.go","anchor":{"kind":"file"},"body":"body"}]}`, "changed files")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"line","side":"RIGHT"},"body":"body"}]}`, "line anchor requires a positive line")
-	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"  "}]}`, "finding body length out of bounds")
-	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("f-1").next, MaxBodyLength: 3}, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"toolong"}]}`, "finding body length out of bounds")
-	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("f-1", "f-2").next, MaxFindingsPerAgent: 1}, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"},{"severity":"minor","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "findings cap exceeded")
-	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("f-1").next, SeverityCaps: map[review.Severity]int{review.SeverityMajor: 0}}, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "major severity cap exceeded")
-	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: nil}, `{"schema_version":1,"agent_id":"agent-1","findings":[]}`, "generator")
-	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: func() (review.FindingID, error) { return "", errors.New("id failed") }}, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "id failed")
-	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("").next}, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "blank")
-	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("dup", "dup").next}, `{"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"},{"severity":"minor","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]}`, "duplicate")
+	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","inspected_files":[],"findings":[]}`, "inspected_files or skipped_files")
+	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","inspected_files":["other.go"],"findings":[]}`, "inspected_files entry")
+	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","inspected_files":["main.go","main.go"],"findings":[]}`, "duplicate inspected_files")
+	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","inspected_files":["main.go"],"skipped_files":["other.go"],"findings":[]}`, "skipped_files entry")
+	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","inspected_files":["main.go"],"skipped_files":["main.go"],"findings":[]}`, "both inspected and skipped")
+	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","inspected_files":["main.go"],"constraints":["  "],"findings":[]}`, "constraints")
+	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","inspected_files":["main.go"],"constraints":["one","two","three","four","five","six","seven","eight","nine","ten","eleven"],"findings":[]}`, "constraints cap exceeded")
+	assertFindingsError(t, baseOpts, `{"schema_version":1,"agent_id":"agent-1","inspected_files":["main.go"],"constraints":["`+strings.Repeat("x", defaultMaxCoverageConstraintRunes+1)+`"],"findings":[]}`, "constraints entry length")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":2,"agent_id":"agent-1","findings":[]`), "schema_version")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[],"extra":true`), "unknown field")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"missing","findings":[]`), "unknown findings agent")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"finding_id":"model-id","severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "finding_id")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"finding_id":null,"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "finding_id")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"bad","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "severity")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","file":"other.go","anchor":{"kind":"file"},"body":"body"}]`), "file and file_path")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":null,"file":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "file_path must be a string")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file":null,"anchor":{"kind":"file"},"body":"body"}]`), "file must be a string")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file":"other.go","anchor":{"kind":"file"},"body":"body"}]`), "changed files")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file":"main.go","anchor":{"kind":"file"},"body":"body","extra":true}]`), "unknown field")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"other.go","anchor":{"kind":"file"},"body":"body"}]`), "changed files")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"line","side":"RIGHT"},"body":"body"}]`), "line anchor requires a positive line")
+	assertFindingsError(t, baseOpts, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"  "}]`), "finding body length out of bounds")
+	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("f-1").next, MaxBodyLength: 3}, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"toolong"}]`), "finding body length out of bounds")
+	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("f-1", "f-2").next, MaxFindingsPerAgent: 1}, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"},{"severity":"minor","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "findings cap exceeded")
+	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("f-1").next, SeverityCaps: map[review.Severity]int{review.SeverityMajor: 0}}, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "major severity cap exceeded")
+	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: nil}, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[]`), "generator")
+	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: func() (review.FindingID, error) { return "", errors.New("id failed") }}, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "id failed")
+	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("").next}, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "blank")
+	assertFindingsError(t, FindingsOptions{KnownAgents: baseOpts.KnownAgents, ChangedFiles: baseOpts.ChangedFiles, NewFindingID: newIDQueue("dup", "dup").next}, findingsFixture(`"schema_version":1,"agent_id":"agent-1","findings":[{"severity":"major","file_path":"main.go","anchor":{"kind":"file"},"body":"body"},{"severity":"minor","file_path":"main.go","anchor":{"kind":"file"},"body":"body"}]`), "duplicate")
+}
+
+func findingsFixture(fields string) string {
+	return `{"inspected_files":["main.go"],` + fields + `}`
 }
 
 func TestDecodeRollup(t *testing.T) {
diff --git a/internal/pipeline/pipeline.go b/internal/pipeline/pipeline.go
index e9c5060..5cd7f51 100644
--- a/internal/pipeline/pipeline.go
+++ b/internal/pipeline/pipeline.go
@@ -396,6 +396,7 @@ type Result struct {
 	ReviewBaseSHA         string
 	ReviewHeadSHA         string
 	ReviewerFailures      []ReviewerFailure
+	ReviewerCoverage      []reviewplan.ReviewerCoverageSummary
 }
 
 // ReviewerFailure records an isolated reviewer LLM task failure that should not
@@ -406,6 +407,14 @@ type ReviewerFailure struct {
 	Error   string `json:"error"`
 }
 
+const (
+	reviewerCoverageCompleteBroad        = "complete_broad"
+	reviewerCoverageCompleteConstrained  = "complete_constrained"
+	reviewerCoverageIncompleteSkipped    = "incomplete_skipped"
+	reviewerCoverageIncompleteFailed     = "incomplete_failed"
+	reviewerCoverageIncompleteUnassigned = "incomplete_unassigned"
+)
+
 // SelectionSession describes the single LLM turn used for selection-only execution.
 type SelectionSession struct {
 	ProviderReportedSessionID string
@@ -783,7 +792,7 @@ func execute(ctx context.Context, opts Options, req Request, mode executionMode)
 		namedSession.recordSessionID(selectionSession)
 
 		selectionTaskIDs := []string{orchestratorSelectionStage}
-		findings, reviewerSessions, reviewerLedgerSessions, reviewerFindingSessions, reviewerFailures, err := runReviewers(ctx, opts, req, run.RunID, prepared.reviewPR, prepared.catalog, prepared.parsed, prepared.artifacts, selection, selectionTaskIDs, maxConcurrency)
+		findings, reviewerResults, reviewerSessions, reviewerLedgerSessions, reviewerFindingSessions, reviewerFailures, err := runReviewers(ctx, opts, req, run.RunID, prepared.reviewPR, prepared.catalog, prepared.parsed, prepared.artifacts, selection, selectionTaskIDs, maxConcurrency)
 		if err != nil {
 			if errors.Is(err, errLLMTaskFailedBlocking) {
 				failureOutcome = ledger.OutcomeIncomplete
@@ -792,6 +801,8 @@ func execute(ctx context.Context, opts Options, req Request, mode executionMode)
 		}
 		result.Findings = findings
 		result.ReviewerFailures = reviewerFailures
+		reviewerCoverage := buildReviewerCoverage(selection.SelectedAgents, reviewerResults, reviewerFailures, prepared.changedFiles)
+		result.ReviewerCoverage = reviewerCoverage
 		result.Sessions = appendSessionsIfPresent(result.Sessions, reviewerLedgerSessions...)
 		for id, rowID := range reviewerFindingSessions {
 			findingSession[id] = rowID
@@ -803,7 +814,7 @@ func execute(ctx context.Context, opts Options, req Request, mode executionMode)
 		}
 		rollupModel, rollupEffort := rollupRuntimeConfig.model, rollupRuntimeConfig.effort
 
-		rollupPrompt, err := buildRollupPrompt(prepared.reviewPR, findings, reviewerFailures)
+		rollupPrompt, err := buildRollupPrompt(prepared.reviewPR, findings, reviewerFailures, reviewerCoverage)
 		if err != nil {
 			return Result{}, err
 		}
@@ -857,6 +868,7 @@ func execute(ctx context.Context, opts Options, req Request, mode executionMode)
 			selectedAgents:   selection.SelectedAgents,
 			findingSessions:  findingSession,
 			reviewerFailures: reviewerFailures,
+			reviewerCoverage: reviewerCoverage,
 			startedAt:        now,
 		})
 		if err != nil {
@@ -1200,7 +1212,7 @@ func appendSessionsIfPresent(sessions []ledger.Session, more ...ledger.Session)
 	return sessions
 }
 
-func runReviewers(ctx context.Context, opts Options, req Request, runID string, pr gitprovider.PR, catalog agents.Catalog, parsed ParsedDiff, artifacts ArtifactPaths, selection llm.Selection, dependencyTaskIDs []string, maxConcurrency int) ([]review.Finding, []sessionDraft, []ledger.Session, map[review.FindingID]string, []ReviewerFailure, error) {
+func runReviewers(ctx context.Context, opts Options, req Request, runID string, pr gitprovider.PR, catalog agents.Catalog, parsed ParsedDiff, artifacts ArtifactPaths, selection llm.Selection, dependencyTaskIDs []string, maxConcurrency int) ([]review.Finding, []llm.Findings, []sessionDraft, []ledger.Session, map[review.FindingID]string, []ReviewerFailure, error) {
 	type job struct {
 		selected llm.SelectedAgent
 		agent    agents.Agent
@@ -1209,12 +1221,12 @@ func runReviewers(ctx context.Context, opts Options, req Request, runID string,
 	for _, selected := range selection.SelectedAgents {
 		agent, ok := catalog.Find(selected.AgentID)
 		if !ok {
-			return nil, nil, nil, nil, nil, fmt.Errorf("pipeline: selected agent %q not found", selected.AgentID)
+			return nil, nil, nil, nil, nil, nil, fmt.Errorf("pipeline: selected agent %q not found", selected.AgentID)
 		}
 		jobs = append(jobs, job{selected: selected, agent: agent})
 	}
 	if len(jobs) == 0 {
-		return nil, nil, nil, nil, nil, nil
+		return nil, nil, nil, nil, nil, nil, nil
 	}
 	sort.Slice(jobs, func(i, j int) bool { return jobs[i].agent.ID < jobs[j].agent.ID })
 
@@ -1223,6 +1235,7 @@ func runReviewers(ctx context.Context, opts Options, req Request, runID string,
 	sem := make(chan struct{}, maxConcurrency)
 	var mu sync.Mutex
 	var allFindings []review.Finding
+	var reviewerResults []llm.Findings
 	var sessions []sessionDraft
 	var ledgerSessions []ledger.Session
 	findingSessions := map[review.FindingID]string{}
@@ -1240,7 +1253,7 @@ func runReviewers(ctx context.Context, opts Options, req Request, runID string,
 				return
 			}
 			defer func() { <-sem }()
-			findings, session, ledgerSession, failure, err := runReviewer(reviewCtx, opts, req, runID, pr, parsed, artifacts, current.selected, current.agent, dependencyTaskIDs)
+			result, session, ledgerSession, failure, err := runReviewer(reviewCtx, opts, req, runID, pr, parsed, artifacts, current.selected, current.agent, dependencyTaskIDs)
 			mu.Lock()
 			defer mu.Unlock()
 			if failure != nil {
@@ -1258,7 +1271,8 @@ func runReviewers(ctx context.Context, opts Options, req Request, runID string,
 			}
 			sessions = append(sessions, session)
 			ledgerSessions = appendSessionIfPresent(ledgerSessions, ledgerSession)
-			for _, finding := range findings {
+			reviewerResults = append(reviewerResults, result)
+			for _, finding := range result.Findings {
 				allFindings = append(allFindings, finding)
 				findingSessions[finding.ID] = session.rowID
 			}
@@ -1266,35 +1280,38 @@ func runReviewers(ctx context.Context, opts Options, req Request, runID string,
 	}
 	wg.Wait()
 	if firstErr != nil {
-		return nil, nil, nil, nil, nil, firstErr
+		return nil, nil, nil, nil, nil, nil, firstErr
 	}
 	sort.Slice(allFindings, func(i, j int) bool { return allFindings[i].ID < allFindings[j].ID })
+	sort.Slice(reviewerResults, func(i, j int) bool { return reviewerResults[i].AgentID < reviewerResults[j].AgentID })
 	sort.Slice(failures, func(i, j int) bool { return failures[i].AgentID < failures[j].AgentID })
-	return allFindings, sessions, ledgerSessions, findingSessions, failures, nil
+	return allFindings, reviewerResults, sessions, ledgerSessions, findingSessions, failures, nil
 }
 
-func runReviewer(ctx context.Context, opts Options, req Request, runID string, pr gitprovider.PR, parsed ParsedDiff, artifacts ArtifactPaths, selected llm.SelectedAgent, agent agents.Agent, dependencyTaskIDs []string) ([]review.Finding, sessionDraft, ledger.Session, *ReviewerFailure, error) {
+func runReviewer(ctx context.Context, opts Options, req Request, runID string, pr gitprovider.PR, parsed ParsedDiff, artifacts ArtifactPaths, selected llm.SelectedAgent, agent agents.Agent, dependencyTaskIDs []string) (llm.Findings, sessionDraft, ledger.Session, *ReviewerFailure, error) {
 	runtimeConfig, err := resolveReviewerRuntimeConfig(req, agent)
 	if err != nil {
-		return nil, sessionDraft{}, ledger.Session{}, nil, err
+		return llm.Findings{}, sessionDraft{}, ledger.Session{}, nil, err
 	}
 	model, effort := runtimeConfig.model, runtimeConfig.effort
-	prompt, promptDeps, err := buildReviewerPrompt(artifacts, pr, selected, agent)
+	changedFilePaths := patchPaths(parsed.Patches)
+	reviewerScope := reviewerReadableFiles(selected, changedFilePaths)
+	prompt, promptDeps, err := buildReviewerPrompt(artifacts, pr, selected, agent, changedFilePaths)
 	if err != nil {
-		return nil, sessionDraft{}, ledger.Session{}, nil, err
+		return llm.Findings{}, sessionDraft{}, ledger.Session{}, nil, err
 	}
 	if err := opts.checkPromptBudget("reviewer", agent.ID, model, strings.Join(selected.Files, ","), prompt); err != nil {
-		return nil, sessionDraft{}, ledger.Session{}, nil, err
+		return llm.Findings{}, sessionDraft{}, ledger.Session{}, nil, err
 	}
 	logPath, err := artifacts.AgentLog(agent.ID)
 	if err != nil {
-		return nil, sessionDraft{}, ledger.Session{}, nil, err
+		return llm.Findings{}, sessionDraft{}, ledger.Session{}, nil, err
 	}
 	agentID := agent.ID
 	taskID := reviewerTaskID(agent.ID)
 	request, err := buildCheckoutReadonlyRequest(opts, artifacts, agent.ID, selected.AllowedFiles, model, effort, prompt, logPath)
 	if err != nil {
-		return nil, sessionDraft{}, ledger.Session{}, nil, err
+		return llm.Findings{}, sessionDraft{}, ledger.Session{}, nil, err
 	}
 	fingerprintDeps := append(append([]string(nil), dependencyTaskIDs...), promptDeps...)
 	findings, session, ledgerSession, err := runStructuredTask(ctx, opts, llmTaskSpec{
@@ -1315,22 +1332,22 @@ func runReviewer(ctx context.Context, opts Options, req Request, runID string, p
 	}, func(data []byte) (llm.Findings, error) {
 		return llm.DecodeFindings(data, llm.FindingsOptions{
 			KnownAgents:  map[string]bool{agent.ID: true},
-			ChangedFiles: changedFiles(parsed.Patches),
+			ChangedFiles: stringSet(reviewerScope),
 			NewFindingID: opts.newFindingID,
 		})
 	})
 	if err != nil {
 		var taskErr *llmTaskError
 		if errors.As(err, &taskErr) && taskErr.status == llmTaskStatusFailedIsolated {
-			return nil, session, ledgerSession, &ReviewerFailure{
+			return llm.Findings{}, session, ledgerSession, &ReviewerFailure{
 				TaskID:  taskID,
 				AgentID: agent.ID,
 				Error:   sanitizeTaskErrorForMarkdown(err),
 			}, nil
 		}
-		return nil, sessionDraft{}, ledger.Session{}, nil, err
+		return llm.Findings{}, sessionDraft{}, ledger.Session{}, nil, err
 	}
-	return findings.Findings, session, ledgerSession, nil, nil
+	return findings, session, ledgerSession, nil, nil
 }
 
 func reviewerTaskID(agentID string) string {
@@ -2044,6 +2061,7 @@ type planRunInputs struct {
 	selectedAgents   []llm.SelectedAgent
 	findingSessions  map[review.FindingID]string
 	reviewerFailures []ReviewerFailure
+	reviewerCoverage []reviewplan.ReviewerCoverageSummary
 	startedAt        time.Time
 }
 
@@ -2079,6 +2097,7 @@ func (opts Options) buildRunSummary(req Request, inputs planRunInputs) (reviewpl
 		PostingIdentity:   postingKey(req.PostingIdentity),
 		SelectedReviewers: selectedIDs,
 		ReviewerFailures:  reviewerFailureSummaries(inputs.reviewerFailures),
+		ReviewerCoverage:  inputs.reviewerCoverage,
 		WallDurationMS:    &wallMS,
 		Workstreams:       workstreams,
 	}
@@ -2103,6 +2122,136 @@ func reviewerFailureSummaries(failures []ReviewerFailure) []reviewplan.ReviewerF
 	return out
 }
 
+func buildReviewerCoverage(selected []llm.SelectedAgent, results []llm.Findings, failures []ReviewerFailure, changedFiles []string) []reviewplan.ReviewerCoverageSummary {
+	if len(selected) == 0 {
+		return nil
+	}
+	resultByAgent := make(map[string]llm.Findings, len(results))
+	for _, result := range results {
+		resultByAgent[result.AgentID] = result
+	}
+	failureByAgent := make(map[string]ReviewerFailure, len(failures))
+	for _, failure := range failures {
+		failureByAgent[failure.AgentID] = failure
+	}
+	assigned := map[string]bool{}
+	out := make([]reviewplan.ReviewerCoverageSummary, 0, len(selected)+1)
+	for _, agent := range selected {
+		scope := reviewerAssignmentScope(agent, changedFiles)
+		for _, file := range scope {
+			assigned[file] = true
+		}
+		entry := reviewplan.ReviewerCoverageSummary{
+			AgentID: agent.AgentID,
+			Scope:   scope,
+		}
+		if failure, ok := failureByAgent[agent.AgentID]; ok {
+			entry.Status = reviewerCoverageIncompleteFailed
+			entry.Diagnostic = failure.Error
+			out = append(out, entry)
+			continue
+		}
+		result, ok := resultByAgent[agent.AgentID]
+		if !ok {
+			entry.Status = reviewerCoverageIncompleteFailed
+			entry.Diagnostic = "reviewer result was not recorded"
+			out = append(out, entry)
+			continue
+		}
+		entry.InspectedFiles = copySortedStrings(result.InspectedFiles)
+		entry.SkippedFiles = sortedIntersection(result.SkippedFiles, scope)
+		entry.Constraints = copySortedStrings(result.Constraints)
+		missing := coverageMissingFiles(scope, entry.InspectedFiles, entry.SkippedFiles)
+		switch {
+		case len(entry.SkippedFiles) > 0 || len(missing) > 0:
+			entry.Status = reviewerCoverageIncompleteSkipped
+			if len(missing) > 0 {
+				entry.Diagnostic = "assigned files were neither inspected nor skipped: " + strings.Join(missing, ", ")
+			}
+		case len(agent.AllowedFiles) > 0:
+			entry.Status = reviewerCoverageCompleteConstrained
+		default:
+			entry.Status = reviewerCoverageCompleteBroad
+		}
+		out = append(out, entry)
+	}
+	var unassigned []string
+	for _, file := range changedFiles {
+		if !assigned[file] {
+			unassigned = append(unassigned, file)
+		}
+	}
+	if len(unassigned) > 0 {
+		out = append(out, reviewplan.ReviewerCoverageSummary{
+			AgentID:      "unassigned",
+			Status:       reviewerCoverageIncompleteUnassigned,
+			SkippedFiles: copySortedStrings(unassigned),
+			Diagnostic:   "changed files were not assigned to a selected reviewer",
+		})
+	}
+	return out
+}
+
+// reviewerReadableFiles is the schema/decoder scope: broad reviewers may read
+// every changed file, while allowed_files narrows highly specialized reviewers.
+func reviewerReadableFiles(agent llm.SelectedAgent, changedFiles []string) []string {
+	if len(agent.AllowedFiles) > 0 {
+		return copySortedStrings(agent.AllowedFiles)
+	}
+	return copySortedStrings(changedFiles)
+}
+
+// reviewerAssignmentScope is the coverage expectation: broad reviewers may read
+// the whole checkout, but selected files define the work they were asked to cover.
+func reviewerAssignmentScope(agent llm.SelectedAgent, changedFiles []string) []string {
+	if len(agent.AllowedFiles) > 0 {
+		return copySortedStrings(agent.AllowedFiles)
+	}
+	if len(agent.Files) > 0 {
+		return copySortedStrings(agent.Files)
+	}
+	return copySortedStrings(changedFiles)
+}
+
+func coverageMissingFiles(scope, inspected, skipped []string) []string {
+	covered := stringSet(inspected)
+	for _, file := range skipped {
+		covered[file] = true
+	}
+	var missing []string
+	for _, file := range scope {
+		if !covered[file] {
+			missing = append(missing, file)
+		}
+	}
+	return copySortedStrings(missing)
+}
+
+func sortedIntersection(values, scope []string) []string {
+	inScope := stringSet(scope)
+	var out []string
+	for _, value := range values {
+		if inScope[value] {
+			out = append(out, value)
+		}
+	}
+	return copySortedStrings(out)
+}
+
+func stringSet(values []string) map[string]bool {
+	out := make(map[string]bool, len(values))
+	for _, value := range values {
+		out[value] = true
+	}
+	return out
+}
+
+func copySortedStrings(values []string) []string {
+	out := append([]string(nil), values...)
+	sort.Strings(out)
+	return out
+}
+
 // Orchestrator stage names share a stable prefix so the headline model filter
 // can exclude them; deriving the stage names from the prefix keeps the filter
 // and the names from diverging.
@@ -2237,14 +2386,15 @@ func pruneRetention(ctx context.Context, layout statepaths.Layout, store datalif
 	return nil
 }
 
-func buildReviewerPrompt(paths ArtifactPaths, pr gitprovider.PR, selected llm.SelectedAgent, agent agents.Agent) (string, []string, error) {
+func buildReviewerPrompt(paths ArtifactPaths, pr gitprovider.PR, selected llm.SelectedAgent, agent agents.Agent, changedFiles []string) (string, []string, error) {
 	input, deps, err := reviewerPromptInputFromArtifacts(paths, pr, selected, agent)
 	if err != nil {
 		return "", nil, err
 	}
+	reviewerScope := reviewerReadableFiles(selected, changedFiles)
 	payload := map[string]any{
 		"task":            "review files and return findings JSON only",
-		"output_contract": findingsOutputContract(agent.ID, append([]string(nil), input.Assignment.Files...)),
+		"output_contract": findingsOutputContract(agent.ID, reviewerScope),
 		"agent":           reviewerAgentPromptFromAgent(agent),
 		"assignment":      input.Assignment,
 		"dossier":         input.Dossier,
@@ -2603,7 +2753,7 @@ func selectionThreadPrompts(threads []gitprovider.InlineThread, summary dossierD
 	return out
 }
 
-func buildRollupPrompt(pr gitprovider.PR, findings []review.Finding, reviewerFailures []ReviewerFailure) (string, error) {
+func buildRollupPrompt(pr gitprovider.PR, findings []review.Finding, reviewerFailures []ReviewerFailure, reviewerCoverage []reviewplan.ReviewerCoverageSummary) (string, error) {
 	payload := map[string]any{
 		"task":              "dedupe findings and return rollup JSON only",
 		"output_contract":   rollupOutputContract(findings),
@@ -2611,6 +2761,7 @@ func buildRollupPrompt(pr gitprovider.PR, findings []review.Finding, reviewerFai
 		"pr":                promptPRFromPR(pr),
 		"findings":          rollupFindingsPrompt(findings),
 		"reviewer_failures": reviewerFailures,
+		"reviewer_coverage": rollupCoveragePrompt(reviewerCoverage),
 	}
 	body, err := json.MarshalIndent(payload, "", "  ")
 	if err != nil {
@@ -2619,6 +2770,32 @@ func buildRollupPrompt(pr gitprovider.PR, findings []review.Finding, reviewerFai
 	return string(body), nil
 }
 
+type rollupCoveragePromptEntry struct {
+	AgentID        string   `json:"agent_id"`
+	Status         string   `json:"status"`
+	Scope          []string `json:"scope,omitempty"`
+	InspectedFiles []string `json:"inspected_files,omitempty"`
+	SkippedFiles   []string `json:"skipped_files,omitempty"`
+	Constraints    []string `json:"constraints,omitempty"`
+	Diagnostic     string   `json:"diagnostic,omitempty"`
+}
+
+func rollupCoveragePrompt(coverage []reviewplan.ReviewerCoverageSummary) []rollupCoveragePromptEntry {
+	out := make([]rollupCoveragePromptEntry, 0, len(coverage))
+	for _, entry := range coverage {
+		out = append(out, rollupCoveragePromptEntry{
+			AgentID:        entry.AgentID,
+			Status:         entry.Status,
+			Scope:          append([]string(nil), entry.Scope...),
+			InspectedFiles: append([]string(nil), entry.InspectedFiles...),
+			SkippedFiles:   append([]string(nil), entry.SkippedFiles...),
+			Constraints:    append([]string(nil), entry.Constraints...),
+			Diagnostic:     entry.Diagnostic,
+		})
+	}
+	return out
+}
+
 type rollupFindingPrompt struct {
 	ID       string                      `json:"id"`
 	Severity string                      `json:"severity"`
@@ -2741,22 +2918,32 @@ func findingsOutputContract(agentID string, changedFiles []string) outputContrac
 			"allowed_values is context only; do not include allowed_values keys in the response.",
 			"schema_version must be 1.",
 			"agent_id must match the provided agent id.",
+			"inspected_files must list assigned changed files you actually inspected, even when findings is empty.",
+			"skipped_files must list assigned changed files you intentionally did not inspect or could not inspect.",
+			"At least one of inspected_files or skipped_files must be non-empty.",
+			"constraints must list any material review constraints, such as intentionally narrow scope, missing context, or tool limitations.",
 			"findings must be an empty array when there are no actionable findings.",
 			"file_path must be one of changed_files.",
 			"Do not provide finding_id; the harness assigns IDs.",
 		},
 		ResponseSchema: map[string]any{
-			"schema_version": "number, required, must be 1",
-			"agent_id":       "string, required",
-			"findings":       "array of {severity: string, file_path: string, anchor: {kind: 'file'} or {kind: 'line', side: 'RIGHT'|'LEFT', line: positive number}, body: string}",
+			"schema_version":  "number, required, must be 1",
+			"agent_id":        "string, required",
+			"inspected_files": "string[], assigned changed files inspected by this reviewer",
+			"skipped_files":   "string[], assigned changed files intentionally not inspected or not inspectable",
+			"constraints":     "string[], material scope/tool/context constraints",
+			"findings":        "array of {severity: string, file_path: string, anchor: {kind: 'file'} or {kind: 'line', side: 'RIGHT'|'LEFT', line: positive number}, body: string}",
 		},
 		AllowedValues: map[string]any{
 			"severities":    []string{"blocking", "major", "minor", "nits"},
 			"changed_files": changedFiles,
 		},
 		Example: map[string]any{
-			"schema_version": 1,
-			"agent_id":       agentID,
+			"schema_version":  1,
+			"agent_id":        agentID,
+			"inspected_files": firstNOrPlaceholder(changedFiles, "path/to/changed-file.ext", 1),
+			"skipped_files":   []string{},
+			"constraints":     []string{},
 			"findings": []map[string]any{{
 				"severity":  "major",
 				"file_path": firstOrPlaceholder(changedFiles, "path/to/changed-file.ext"),
diff --git a/internal/pipeline/pipeline_test.go b/internal/pipeline/pipeline_test.go
index 635b836..dc26c90 100644
--- a/internal/pipeline/pipeline_test.go
+++ b/internal/pipeline/pipeline_test.go
@@ -209,6 +209,47 @@ func TestDryRunPlansAndPersistsWithoutProviderWrites(t *testing.T) {
 	}
 }
 
+func TestDryRunIncompleteReviewerCoverageForcesCommentOutcome(t *testing.T) {
+	ctx := context.Background()
+	store := openPipelineStore(t)
+	defer closeStore(t, store)
+	provider, req := dryRunHarness(t)
+	adapter := &llm.FakeAdapter{NameValue: "fake-llm"}
+	adapter.Queue(fakeLLMResult("dossier-summary-session", discussionSummaryJSON(nil, nil), 1, 1))
+	adapter.Queue(fakeLLMResult("selection-session", selectionJSON("harness:reviewer", "main.go"), 1, 1))
+	adapter.Queue(fakeLLMResult("reviewer-session", coverageOnlyJSON("harness:reviewer", nil, []string{"main.go"}, "could not inspect assigned file"), 1, 1))
+	adapter.Queue(fakeLLMResult("rollup-session", rollupJSON("approve", nil), 1, 1))
+
+	result, err := dryRunForTest(ctx, Options{
+		Provider:        provider,
+		Adapter:         adapter,
+		Store:           store,
+		Layout:          statepaths.NewLayout(t.TempDir(), t.TempDir()),
+		Now:             fixedNow,
+		NewRunID:        func() string { return "run-incomplete-coverage" },
+		NewSessionRowID: sequence("session"),
+		NewFindingID:    findingSequence("finding"),
+		NewActionID:     actionSequence(),
+		MaxConcurrency:  1,
+	}, req)
+	if err != nil {
+		t.Fatalf("DryRun: %v", err)
+	}
+	if result.Plan.Outcome != reviewplan.OutcomeComment {
+		t.Fatalf("outcome = %q, want comment despite approve rollup", result.Plan.Outcome)
+	}
+	coverage := result.Plan.Summary.Run.ReviewerCoverage
+	if len(coverage) != 1 ||
+		coverage[0].AgentID != "harness:reviewer" ||
+		coverage[0].Status != reviewerCoverageIncompleteSkipped ||
+		!reflect.DeepEqual(coverage[0].SkippedFiles, []string{"main.go"}) {
+		t.Fatalf("coverage = %#v, want incomplete skipped reviewer coverage", coverage)
+	}
+	if !strings.Contains(result.Plan.RollupMarkdown, "### Reviewer Coverage") {
+		t.Fatalf("rollup markdown missing reviewer coverage:\n%s", result.Plan.RollupMarkdown)
+	}
+}
+
 func TestDryRunNormalizesReviewerFindingsFileAlias(t *testing.T) {
 	ctx := context.Background()
 	store := openPipelineStore(t)
@@ -3825,6 +3866,8 @@ func TestDryRunMultiAgentSessionsMapFindingsToReviewerSessions(t *testing.T) {
 				t.Fatalf("reviewer prompt missing checkout-native context: %s", request.Prompt)
 			}
 			if !strings.Contains(request.Prompt, `"file_path"`) ||
+				!strings.Contains(request.Prompt, `"inspected_files"`) ||
+				!strings.Contains(request.Prompt, `"skipped_files"`) ||
 				!strings.Contains(request.Prompt, `"anchor"`) ||
 				!strings.Contains(request.Prompt, `"Do not provide finding_id`) {
 				t.Fatalf("reviewer prompt missing output schema fields: %s", request.Prompt)
@@ -4514,7 +4557,7 @@ func TestRunReviewerRejectsStaleWorkbenchMetadata(t *testing.T) {
 	if err != nil {
 		t.Fatalf("resolveReviewerRuntimeConfig: %v", err)
 	}
-	prompt, promptDeps, err := buildReviewerPrompt(prepared.artifacts, prepared.reviewPR, selection.SelectedAgents[0], agent)
+	prompt, promptDeps, err := buildReviewerPrompt(prepared.artifacts, prepared.reviewPR, selection.SelectedAgents[0], agent, patchPaths(prepared.parsed.Patches))
 	if err != nil {
 		t.Fatalf("buildReviewerPrompt: %v", err)
 	}
@@ -4540,7 +4583,7 @@ func TestRunReviewerRejectsStaleWorkbenchMetadata(t *testing.T) {
 	}, func(data []byte) (llm.Findings, error) {
 		return llm.DecodeFindings(data, llm.FindingsOptions{
 			KnownAgents:  map[string]bool{agent.ID: true},
-			ChangedFiles: changedFiles(prepared.parsed.Patches),
+			ChangedFiles: stringSet(reviewerReadableFiles(selection.SelectedAgents[0], patchPaths(prepared.parsed.Patches))),
 			NewFindingID: findingSequence("reload"),
 		})
 	})
@@ -4571,13 +4614,19 @@ func TestRollupPromptPreservesLocationForDedupeWithoutRawAnchors(t *testing.T) {
 			Anchor:   review.Anchor{Kind: review.AnchorKindLine, Side: review.DiffSideRight, Line: 20},
 			Body:     "same issue text",
 		},
-	}, nil)
+	}, nil, []reviewplan.ReviewerCoverageSummary{{
+		AgentID:        "harness:reviewer",
+		Status:         reviewerCoverageCompleteBroad,
+		Scope:          []string{"main.go"},
+		InspectedFiles: []string{"main.go"},
+	}})
 	if err != nil {
 		t.Fatalf("buildRollupPrompt: %v", err)
 	}
 
 	var payload struct {
-		Findings []rollupFindingPrompt `json:"findings"`
+		Findings         []rollupFindingPrompt       `json:"findings"`
+		ReviewerCoverage []rollupCoveragePromptEntry `json:"reviewer_coverage"`
 	}
 	if err := json.Unmarshal([]byte(prompt), &payload); err != nil {
 		t.Fatalf("unmarshal rollup prompt: %v", err)
@@ -4585,6 +4634,11 @@ func TestRollupPromptPreservesLocationForDedupeWithoutRawAnchors(t *testing.T) {
 	if len(payload.Findings) != 2 {
 		t.Fatalf("rollup findings = %d, want 2", len(payload.Findings))
 	}
+	if len(payload.ReviewerCoverage) != 1 ||
+		payload.ReviewerCoverage[0].Status != reviewerCoverageCompleteBroad ||
+		!reflect.DeepEqual(payload.ReviewerCoverage[0].InspectedFiles, []string{"main.go"}) {
+		t.Fatalf("reviewer coverage = %#v, want compact broad coverage", payload.ReviewerCoverage)
+	}
 	if payload.Findings[0].Location.Line != 10 || payload.Findings[1].Location.Line != 20 {
 		t.Fatalf("rollup finding locations = %#v", payload.Findings)
 	}
@@ -4594,6 +4648,164 @@ func TestRollupPromptPreservesLocationForDedupeWithoutRawAnchors(t *testing.T) {
 	if strings.Contains(prompt, "Rollup prompt body should stay out of prompt payloads.") {
 		t.Fatalf("rollup prompt leaked PR body: %s", prompt)
 	}
+	for _, forbidden := range []string{`"diff"`, `"base_content"`, `"head_content"`, "@@", "+changed implementation body"} {
+		if strings.Contains(prompt, forbidden) {
+			t.Fatalf("rollup prompt leaked stuffed code context %q: %s", forbidden, prompt)
+		}
+	}
+}
+
+func TestBuildReviewerCoverageStatuses(t *testing.T) {
+	broad := buildReviewerCoverage(
+		[]llm.SelectedAgent{{AgentID: "harness:broad", Files: []string{"main.go", "other.go"}}},
+		[]llm.Findings{{AgentID: "harness:broad", InspectedFiles: []string{"main.go", "other.go"}}},
+		nil,
+		[]string{"main.go", "other.go"},
+	)
+	if len(broad) != 1 || broad[0].Status != reviewerCoverageCompleteBroad {
+		t.Fatalf("broad coverage = %#v, want complete broad", broad)
+	}
+
+	selected := []llm.SelectedAgent{
+		{AgentID: "harness:scoped", Files: []string{"db.sql"}, AllowedFiles: []string{"db.sql"}},
+		{AgentID: "harness:skipped", Files: []string{"api.go"}, AllowedFiles: []string{"api.go"}},
+		{AgentID: "harness:failed", Files: []string{"worker.go"}, AllowedFiles: []string{"worker.go"}},
+	}
+	results := []llm.Findings{
+		{AgentID: "harness:scoped", InspectedFiles: []string{"db.sql"}, Constraints: []string{"SQL-only review"}},
+		{AgentID: "harness:skipped", InspectedFiles: []string{"api.go"}, SkippedFiles: []string{"api.go"}},
+	}
+	failures := []ReviewerFailure{{AgentID: "harness:failed", Error: "model failed"}}
+
+	got := buildReviewerCoverage(selected, results, failures, []string{"api.go", "db.sql", "unassigned.go", "worker.go"})
+	byAgent := map[string]reviewplan.ReviewerCoverageSummary{}
+	for _, entry := range got {
+		byAgent[entry.AgentID] = entry
+	}
+
+	if byAgent["harness:scoped"].Status != reviewerCoverageCompleteConstrained {
+		t.Fatalf("scoped coverage = %#v", byAgent["harness:scoped"])
+	}
+	if byAgent["harness:skipped"].Status != reviewerCoverageIncompleteSkipped {
+		t.Fatalf("skipped coverage = %#v", byAgent["harness:skipped"])
+	}
+	if byAgent["harness:failed"].Status != reviewerCoverageIncompleteFailed || byAgent["harness:failed"].Diagnostic != "model failed" {
+		t.Fatalf("failed coverage = %#v", byAgent["harness:failed"])
+	}
+	if byAgent["unassigned"].Status != reviewerCoverageIncompleteUnassigned ||
+		!reflect.DeepEqual(byAgent["unassigned"].SkippedFiles, []string{"unassigned.go"}) {
+		t.Fatalf("unassigned coverage = %#v", byAgent["unassigned"])
+	}
+}
+
+func TestBuildReviewerCoverageMarksAssignedScopeMissing(t *testing.T) {
+	got := buildReviewerCoverage(
+		[]llm.SelectedAgent{{AgentID: "harness:reviewer", AllowedFiles: []string{"main.go", "other.go"}}},
+		[]llm.Findings{{AgentID: "harness:reviewer", InspectedFiles: []string{"main.go"}}},
+		nil,
+		[]string{"main.go", "other.go"},
+	)
+	if len(got) != 1 {
+		t.Fatalf("coverage entries = %#v", got)
+	}
+	if got[0].Status != reviewerCoverageIncompleteSkipped ||
+		!strings.Contains(got[0].Diagnostic, "other.go") {
+		t.Fatalf("coverage = %#v, want incomplete missing other.go", got[0])
+	}
+}
+
+func TestReviewerScopesSeparateReadAccessFromExpectedCoverage(t *testing.T) {
+	changed := []string{"api.go", "main.go", "schema.sql"}
+	if got := reviewerReadableFiles(llm.SelectedAgent{
+		Files:        []string{"main.go"},
+		AllowedFiles: []string{"schema.sql"},
+	}, changed); !reflect.DeepEqual(got, []string{"schema.sql"}) {
+		t.Fatalf("constrained reviewable scope = %#v, want allowed_files", got)
+	}
+	if got := reviewerReadableFiles(llm.SelectedAgent{Files: []string{"main.go"}}, changed); !reflect.DeepEqual(got, []string{"api.go", "main.go", "schema.sql"}) {
+		t.Fatalf("broad reviewable scope = %#v, want all changed files", got)
+	}
+	if got := reviewerAssignmentScope(llm.SelectedAgent{Files: []string{"main.go"}}, changed); !reflect.DeepEqual(got, []string{"main.go"}) {
+		t.Fatalf("broad coverage scope = %#v, want selected files", got)
+	}
+}
+
+func TestBuildReviewerCoverageAllowsBroadReviewerSplitAssignments(t *testing.T) {
+	got := buildReviewerCoverage(
+		[]llm.SelectedAgent{
+			{AgentID: "harness:alpha", Files: []string{"main.go"}},
+			{AgentID: "harness:beta", Files: []string{"other.go"}},
+		},
+		[]llm.Findings{
+			{AgentID: "harness:alpha", InspectedFiles: []string{"main.go"}},
+			{AgentID: "harness:beta", InspectedFiles: []string{"other.go"}},
+		},
+		nil,
+		[]string{"main.go", "other.go"},
+	)
+	if len(got) != 2 {
+		t.Fatalf("coverage entries = %#v, want two reviewer entries", got)
+	}
+	for _, entry := range got {
+		if entry.Status != reviewerCoverageCompleteBroad {
+			t.Fatalf("coverage entry = %#v, want complete broad", entry)
+		}
+	}
+}
+
+func TestBuildReviewerCoverageIgnoresSkippedFilesOutsideAssignmentScope(t *testing.T) {
+	got := buildReviewerCoverage(
+		[]llm.SelectedAgent{{AgentID: "harness:reviewer", Files: []string{"main.go"}}},
+		[]llm.Findings{{AgentID: "harness:reviewer", InspectedFiles: []string{"main.go"}, SkippedFiles: []string{"other.go"}}},
+		nil,
+		[]string{"main.go", "other.go"},
+	)
+	if len(got) != 2 {
+		t.Fatalf("coverage entries = %#v, want reviewer plus unassigned other.go", got)
+	}
+	if got[0].AgentID != "harness:reviewer" || got[0].Status != reviewerCoverageCompleteBroad {
+		t.Fatalf("reviewer coverage = %#v, want complete broad for assigned scope", got[0])
+	}
+	if len(got[0].SkippedFiles) != 0 {
+		t.Fatalf("reviewer skipped files = %#v, want outside-assignment skipped file filtered", got[0].SkippedFiles)
+	}
+	if got[1].AgentID != "unassigned" || got[1].Status != reviewerCoverageIncompleteUnassigned {
+		t.Fatalf("unassigned coverage = %#v, want other.go unassigned", got[1])
+	}
+}
+
+func TestRollupPromptAndFingerprintChangeWhenReviewerCoverageChanges(t *testing.T) {
+	findings := largeRollupFindings(1, "main.go", "body")
+	baseCoverage := []reviewplan.ReviewerCoverageSummary{{
+		AgentID:        "harness:reviewer",
+		Status:         reviewerCoverageCompleteBroad,
+		Scope:          []string{"main.go"},
+		InspectedFiles: []string{"main.go"},
+	}}
+	skippedCoverage := []reviewplan.ReviewerCoverageSummary{{
+		AgentID:        "harness:reviewer",
+		Status:         reviewerCoverageIncompleteSkipped,
+		Scope:          []string{"main.go"},
+		InspectedFiles: []string{"main.go"},
+		SkippedFiles:   []string{"main.go"},
+	}}
+	basePrompt, err := buildRollupPrompt(gitprovider.PR{}, findings, nil, baseCoverage)
+	if err != nil {
+		t.Fatalf("buildRollupPrompt base: %v", err)
+	}
+	skippedPrompt, err := buildRollupPrompt(gitprovider.PR{}, findings, nil, skippedCoverage)
+	if err != nil {
+		t.Fatalf("buildRollupPrompt skipped: %v", err)
+	}
+	if basePrompt == skippedPrompt {
+		t.Fatal("rollup prompts are equal, want coverage changes to affect prompt")
+	}
+	deps := []string{orchestratorSelectionStage, reviewerTaskID("harness:reviewer")}
+	baseFingerprint := llmTaskFingerprint("fake", orchestratorRollupStage, "rollup", "model", "effort", basePrompt, deps)
+	skippedFingerprint := llmTaskFingerprint("fake", orchestratorRollupStage, "rollup", "model", "effort", skippedPrompt, deps)
+	if baseFingerprint == skippedFingerprint {
+		t.Fatal("rollup fingerprints are equal, want coverage changes to invalidate cached rollup input")
+	}
 }
 
 func TestDryRunContextBudgetFailures(t *testing.T) {
@@ -4761,7 +4973,7 @@ func TestRollupPromptBudgetUsesSynthesisModel(t *testing.T) {
 	if err != nil {
 		t.Fatalf("resolveSynthesisRuntimeConfig: %v", err)
 	}
-	prompt, err := buildRollupPrompt(provider.pr, largeRollupFindings(4, "main.go", strings.Repeat("body ", 4000)), nil)
+	prompt, err := buildRollupPrompt(provider.pr, largeRollupFindings(4, "main.go", strings.Repeat("body ", 4000)), nil, nil)
 	if err != nil {
 		t.Fatalf("buildRollupPrompt: %v", err)
 	}
@@ -4778,7 +4990,7 @@ func TestRollupPromptBudgetIgnoresSelectionModelOverride(t *testing.T) {
 	if err != nil {
 		t.Fatalf("resolveSynthesisRuntimeConfig: %v", err)
 	}
-	prompt, err := buildRollupPrompt(provider.pr, largeRollupFindings(4, "main.go", strings.Repeat("body ", 4000)), nil)
+	prompt, err := buildRollupPrompt(provider.pr, largeRollupFindings(4, "main.go", strings.Repeat("body ", 4000)), nil, nil)
 	if err != nil {
 		t.Fatalf("buildRollupPrompt: %v", err)
 	}
@@ -4876,12 +5088,12 @@ func (a *promptAwareAdapter) Start(_ context.Context, req llm.Request) (llm.Stre
 			"thread_actions": [],
 			"reasoning": "two agents"
 		}`}, nil
+	case strings.Contains(req.Prompt, `"schema": "rollup"`):
+		return staticStream{sessionID: "rollup-session", output: rollupJSON("comment", findingIDsFromPrompt(req.Prompt))}, nil
 	case strings.Contains(req.Prompt, "harness:alpha"):
 		return staticStream{sessionID: "alpha-session", output: findingsJSON("harness:alpha", "main.go", "major", 2, "Alpha finding")}, nil
 	case strings.Contains(req.Prompt, "harness:beta"):
 		return staticStream{sessionID: "beta-session", output: findingsJSON("harness:beta", "other.go", "major", 2, "Beta finding")}, nil
-	case strings.Contains(req.Prompt, `"schema": "rollup"`):
-		return staticStream{sessionID: "rollup-session", output: rollupJSON("comment", findingIDsFromPrompt(req.Prompt))}, nil
 	default:
 		return nil, fmt.Errorf("unexpected prompt: %s", req.Prompt)
 	}
@@ -5650,8 +5862,11 @@ func selectionJSONForAgents(file string, agentIDs ...string) string {
 
 func findingsJSON(agentID, file, severity string, line int, body string) string {
 	payload := map[string]any{
-		"schema_version": 1,
-		"agent_id":       agentID,
+		"schema_version":  1,
+		"agent_id":        agentID,
+		"inspected_files": []string{file},
+		"skipped_files":   []string{},
+		"constraints":     []string{},
 		"findings": []map[string]any{{
 			"severity":  severity,
 			"file_path": file,
@@ -5670,6 +5885,22 @@ func findingsJSON(agentID, file, severity string, line int, body string) string
 	return string(data)
 }
 
+func coverageOnlyJSON(agentID string, inspected, skipped []string, constraints ...string) string {
+	payload := map[string]any{
+		"schema_version":  1,
+		"agent_id":        agentID,
+		"inspected_files": inspected,
+		"skipped_files":   skipped,
+		"constraints":     constraints,
+		"findings":        []map[string]any{},
+	}
+	data, err := json.Marshal(payload)
+	if err != nil {
+		panic(err)
+	}
+	return string(data)
+}
+
 func largeRollupFindings(count int, filePath, body string) []review.Finding {
 	out := make([]review.Finding, 0, count)
 	for i := 0; i < count; i++ {
@@ -5690,8 +5921,11 @@ func largeRollupFindings(count int, filePath, body string) []review.Finding {
 
 func findingsFileAliasJSON(agentID, file, severity string, line int, body string) string {
 	payload := map[string]any{
-		"schema_version": 1,
-		"agent_id":       agentID,
+		"schema_version":  1,
+		"agent_id":        agentID,
+		"inspected_files": []string{file},
+		"skipped_files":   []string{},
+		"constraints":     []string{},
 		"findings": []map[string]any{{
 			"severity": severity,
 			"file":     file,
diff --git a/internal/reviewplan/reviewplan.go b/internal/reviewplan/reviewplan.go
index 2f1837e..2097442 100644
--- a/internal/reviewplan/reviewplan.go
+++ b/internal/reviewplan/reviewplan.go
@@ -319,6 +319,22 @@ func applySelfApprovalPolicy(event review.ReviewEvent, opts EventOptions) review
 	return event
 }
 
+func hasIncompleteReviewerCoverage(coverage []ReviewerCoverageSummary) bool {
+	for _, entry := range coverage {
+		switch entry.Status {
+		case "", "complete_broad", "complete_constrained":
+			continue
+		case "incomplete_skipped", "incomplete_failed", "incomplete_unassigned":
+			return true
+		default:
+			// Unknown coverage statuses are treated conservatively so a new
+			// incomplete state cannot silently bypass approval coercion.
+			return true
+		}
+	}
+	return false
+}
+
 func newBuilder(req Request) (*builder, error) {
 	if !req.PostMode.Valid() {
 		return nil, fmt.Errorf("reviewplan: invalid post mode %q", req.PostMode)
@@ -394,6 +410,9 @@ func (b *builder) buildReview() (Plan, error) {
 	if len(b.req.RunSummary.ReviewerFailures) > 0 && event == review.ReviewEventApprove {
 		event = review.ReviewEventComment
 	}
+	if hasIncompleteReviewerCoverage(b.req.RunSummary.ReviewerCoverage) && event == review.ReviewEventApprove {
+		event = review.ReviewEventComment
+	}
 	outcome, err := OutcomeFromReviewEvent(event)
 	if err != nil {
 		return Plan{}, err
@@ -748,6 +767,7 @@ func (b *builder) renderRollup(ordered []review.Finding, anchored []AnchoredFind
 	if len(summary.Reviewers) > 0 {
 		writeReviewerTable(&out, summary.Reviewers)
 		b.writeReviewerSections(&out, anchored, summary.Reviewers)
+		writeReviewerCoverageDiagnostics(&out, summary.Run.ReviewerCoverage)
 		writeReviewerFailureDiagnostics(&out, summary.Run.ReviewerFailures)
 	} else {
 		counts := severityCounts(ordered)
@@ -772,6 +792,7 @@ func (b *builder) renderRollup(ordered []review.Finding, anchored []AnchoredFind
 		}
 	}
 	if len(summary.Reviewers) == 0 {
+		writeReviewerCoverageDiagnostics(&out, summary.Run.ReviewerCoverage)
 		writeReviewerFailureDiagnostics(&out, summary.Run.ReviewerFailures)
 	}
 	fmt.Fprintf(&out, "*%d PR discussion threads considered. %d summarized; %d resolved.*\n", summary.Threads.Considered, summary.Threads.Summarized, summary.Threads.Resolved)
diff --git a/internal/reviewplan/summary.go b/internal/reviewplan/summary.go
index 910b594..2abdce2 100644
--- a/internal/reviewplan/summary.go
+++ b/internal/reviewplan/summary.go
@@ -32,6 +32,19 @@ type ReviewerSummary struct {
 	Findings int
 }
 
+// ReviewerCoverageSummary describes whether a selected reviewer actually
+// covered its assignment. It is compact by design so rollups can include it
+// without pulling diff or file content into context.
+type ReviewerCoverageSummary struct {
+	AgentID        string
+	Status         string
+	Scope          []string
+	InspectedFiles []string
+	SkippedFiles   []string
+	Constraints    []string
+	Diagnostic     string
+}
+
 // ThreadCounts summarizes PR discussion thread handling.
 type ThreadCounts struct {
 	Considered int
@@ -50,6 +63,7 @@ type RunSummary struct {
 	PostingIdentity   string
 	SelectedReviewers []string
 	ReviewerFailures  []ReviewerFailureSummary
+	ReviewerCoverage  []ReviewerCoverageSummary
 	WallDurationMS    *int64
 	Workstreams       []WorkstreamUsage
 }
@@ -92,7 +106,7 @@ type AggregateUsage struct {
 func (r RunSummary) hasData() bool {
 	return r.ToolVersion != "" || r.Adapter != "" || r.Model != "" ||
 		r.PostingIdentity != "" || len(r.SelectedReviewers) > 0 ||
-		len(r.ReviewerFailures) > 0 || r.WallDurationMS != nil ||
+		len(r.ReviewerFailures) > 0 || len(r.ReviewerCoverage) > 0 || r.WallDurationMS != nil ||
 		len(r.Workstreams) > 0
 }
 
@@ -237,6 +251,33 @@ func writeReviewerFailureDiagnostics(out *strings.Builder, failures []ReviewerFa
 	out.WriteString("\n")
 }
 
+func writeReviewerCoverageDiagnostics(out *strings.Builder, coverage []ReviewerCoverageSummary) {
+	if len(coverage) == 0 {
+		return
+	}
+	out.WriteString("### Reviewer Coverage\n\n")
+	out.WriteString("| Reviewer | Status | Inspected | Skipped | Constraints |\n")
+	out.WriteString("|----------|--------|-----------|---------|-------------|\n")
+	for _, entry := range coverage {
+		fmt.Fprintf(out, "| %s | %s | %s | %s | %s |\n",
+			escapeCell(entry.AgentID),
+			escapeCell(entry.Status),
+			escapeCell(orUnavailable(strings.Join(entry.InspectedFiles, ", "))),
+			escapeCell(orUnavailable(strings.Join(entry.SkippedFiles, ", "))),
+			escapeCell(coverageAnnotationCell(entry)),
+		)
+	}
+	out.WriteString("\n")
+}
+
+func coverageAnnotationCell(entry ReviewerCoverageSummary) string {
+	parts := append([]string(nil), entry.Constraints...)
+	if strings.TrimSpace(entry.Diagnostic) != "" {
+		parts = append(parts, entry.Diagnostic)
+	}
+	return orUnavailable(strings.Join(parts, "; "))
+}
+
 func writeRunFooter(out *strings.Builder, run RunSummary, totals AggregateUsage) {
 	if !run.hasData() {
 		return
diff --git a/internal/reviewplan/summary_test.go b/internal/reviewplan/summary_test.go
index 388c51e..80f4c62 100644
--- a/internal/reviewplan/summary_test.go
+++ b/internal/reviewplan/summary_test.go
@@ -338,6 +338,66 @@ func TestRollupSummaryRendering(t *testing.T) {
 		}
 	})
 
+	t.Run("incomplete reviewer coverage renders diagnostics and force comment", func(t *testing.T) {
+		req := baseRequest()
+		req.Findings = nil
+		req.Rollup = review.Rollup{
+			ReviewEvent:          review.ReviewEventApprove,
+			ReviewEventRationale: "no findings",
+			OrderedFindings:      nil,
+		}
+		req.RunSummary = RunSummary{
+			SelectedReviewers: []string{"go:implementation-tests"},
+			ReviewerCoverage: []ReviewerCoverageSummary{{
+				AgentID:        "go:implementation-tests",
+				Status:         "incomplete_skipped",
+				Scope:          []string{"main.go"},
+				InspectedFiles: []string{"main.go"},
+				SkippedFiles:   []string{"schema.sql"},
+				Constraints:    []string{"read-only tools"},
+			}},
+		}
+		plan, err := Build(req)
+		if err != nil {
+			t.Fatalf("Build: %v", err)
+		}
+		if plan.Outcome != OutcomeComment {
+			t.Fatalf("outcome = %q, want comment", plan.Outcome)
+		}
+		md := plan.RollupMarkdown
+		for _, want := range []string{
+			"### Reviewer Coverage",
+			"| go:implementation-tests | incomplete_skipped | main.go | schema.sql | read-only tools |",
+		} {
+			if !strings.Contains(md, want) {
+				t.Fatalf("rollup missing %q:\n%s", want, md)
+			}
+		}
+	})
+
+	t.Run("unknown reviewer coverage status force comment", func(t *testing.T) {
+		req := baseRequest()
+		req.Findings = nil
+		req.Rollup = review.Rollup{
+			ReviewEvent:          review.ReviewEventApprove,
+			ReviewEventRationale: "no findings",
+			OrderedFindings:      nil,
+		}
+		req.RunSummary = RunSummary{
+			ReviewerCoverage: []ReviewerCoverageSummary{{
+				AgentID: "go:implementation-tests",
+				Status:  "partial_coverage",
+			}},
+		}
+		plan, err := Build(req)
+		if err != nil {
+			t.Fatalf("Build: %v", err)
+		}
+		if plan.Outcome != OutcomeComment {
+			t.Fatalf("outcome = %q, want comment for unknown coverage status", plan.Outcome)
+		}
+	})
+
 	t.Run("rollup marker placement unchanged with run summary", func(t *testing.T) {
 		for _, mode := range []PostMode{PostModeLive, PostModeDryRun} {
 			req := summaryRequest()
diff --git a/internal/view/review.go b/internal/view/review.go
index e133239..2c54690 100644
--- a/internal/view/review.go
+++ b/internal/view/review.go
@@ -33,6 +33,18 @@ type ReviewReviewerSummary struct {
 	Findings int    `json:"findings"`
 }
 
+// ReviewReviewerCoverageSummary describes reviewer coverage rendered in the
+// rollup summary.
+type ReviewReviewerCoverageSummary struct {
+	AgentID        string   `json:"agent_id"`
+	Status         string   `json:"status"`
+	Scope          []string `json:"scope,omitempty"`
+	InspectedFiles []string `json:"inspected_files,omitempty"`
+	SkippedFiles   []string `json:"skipped_files,omitempty"`
+	Constraints    []string `json:"constraints,omitempty"`
+	Diagnostic     string   `json:"diagnostic,omitempty"`
+}
+
 // ReviewThreadCounts summarizes PR discussion thread handling.
 type ReviewThreadCounts struct {
 	Considered int `json:"considered"`
@@ -42,13 +54,14 @@ type ReviewThreadCounts struct {
 
 // ReviewRunSummary is the execution metadata rendered in the rollup footer.
 type ReviewRunSummary struct {
-	ToolVersion       string             `json:"tool_version,omitempty"`
-	Adapter           string             `json:"adapter,omitempty"`
-	Model             string             `json:"model,omitempty"`
-	PostingIdentity   string             `json:"posting_identity,omitempty"`
-	SelectedReviewers []string           `json:"selected_reviewers,omitempty"`
-	WallDurationMS    *int64             `json:"wall_duration_ms"`
-	Workstreams       []ReviewWorkstream `json:"workstreams"`
+	ToolVersion       string                          `json:"tool_version,omitempty"`
+	Adapter           string                          `json:"adapter,omitempty"`
+	Model             string                          `json:"model,omitempty"`
+	PostingIdentity   string                          `json:"posting_identity,omitempty"`
+	SelectedReviewers []string                        `json:"selected_reviewers,omitempty"`
+	ReviewerCoverage  []ReviewReviewerCoverageSummary `json:"reviewer_coverage,omitempty"`
+	WallDurationMS    *int64                          `json:"wall_duration_ms"`
+	Workstreams       []ReviewWorkstream              `json:"workstreams"`
 }
 
 // ReviewWorkstream is adapter-reported usage for one workstream.