diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index f07b475..6201f10 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -190,6 +190,11 @@ additions (violations are `kind: contentPolicy`). Content policy is on by defaul
    against code logic, an identifier, or structured data is not itself validated, but
    the prompt instructs against it and it is expected to be rare and low-confidence.
 7. Forge summaries do not duplicate inline findings or expose model/provider details.
+   GitHub inline counts require observed comment IDs: the create-review body makes no
+   inline-delivery claim, then an idempotent summary update adds the reconciled count.
+   Exhausted update retries leave that claim absent without invalidating the receipt.
+   Oversized summaries degrade to a bounded marker-bearing body instead of preventing
+   valid inline comments from being published.
    Operational-only failures skip the PR review and use generic linked check text.
 8. `humanEscalation` blocks by kind at confidence 0.30 or above. It represents an
    irreducible owner decision, not uncertainty about a concrete defect. Admin overrides
diff --git a/docs/automation.md b/docs/automation.md
index d496f36..b6c06a6 100644
--- a/docs/automation.md
+++ b/docs/automation.md
@@ -47,4 +47,4 @@ Pass comment text through `POSTIL_COMMENT` in automation because command-line ar
 
 Hosted workers can set `POSTIL_USAGE_RECEIPT_PATH` to a worker-owned path. A successful response writes a mode-`0600` version 2 JSON receipt before forge delivery. Every provider attempt includes its role, phase, operation-wide call ordinal, transport attempt, token counts, accounting-completeness flag, cost source, canonical provider-reported decimal cost when present, and rounded micro-dollar display value. The caller owns receipt deletion. Receipt consumers must accept the additional `costProviderDecimal` field before deploying this CLI.
 
-Hosted reviews can set `POSTIL_PUBLICATION_RECEIPT_PATH` to a worker-owned path. Review publication writes a mode-`0600` version 1 JSON receipt atomically. Each entry carries the stable finding ID when present, marks legacy fallback identities, and records its initial publication outcome. GitHub receipts include review and inline-comment identities when available and record rejected inline placement before the summary-only fallback. Reconciled retries return the existing review identities without posting a duplicate. The caller owns receipt deletion.
+Hosted reviews can set `POSTIL_PUBLICATION_RECEIPT_PATH` to a worker-owned path. Review publication writes a mode-`0600` version 1 JSON receipt atomically. Each entry carries the stable finding ID when present, marks legacy fallback identities, and records its initial publication outcome. GitHub receipts include review and inline-comment identities when available and record rejected inline placement before the summary-only fallback. The GitHub create-review body makes no inline-delivery claim; an idempotent review-summary update adds only the count backed by observed comment IDs, while exhausted update retries leave the claim absent and preserve the receipt. Reconciled retries return the existing review identities without posting a duplicate. The caller owns receipt deletion.
diff --git a/src/forge/github.rs b/src/forge/github.rs
index 09ed46d..0ce4212 100644
--- a/src/forge/github.rs
+++ b/src/forge/github.rs
@@ -110,6 +110,51 @@ impl GitHub {
         )
     }
 
+    async fn finalize_review_summary(
+        &self,
+        envelope: &Envelope,
+        receipt: &ReviewPublicationReceipt,
+        marker: &str,
+    ) -> Result<()> {
+        let review_id = receipt
+            .review_id
+            .as_deref()
+            .context("GitHub published review omitted its review id")?
+            .parse::<u64>()
+            .context("GitHub published review returned an invalid review id")?;
+        let summary = self.review_summary_for_receipt(envelope, receipt);
+        let body = bounded_review_body(&summary, marker, self.details_url.as_deref());
+        let response = self
+            .send_write_retryable(
+                self.request(
+                    reqwest::Method::PUT,
+                    self.url(&format!("/pulls/{}/reviews/{review_id}", self.pr)),
+                )
+                .json(&json!({ "body": body })),
+                "review summary update",
+            )
+            .await?;
+        Self::check_ok(response, "review summary update").await?;
+        Ok(())
+    }
+
+    async fn finalize_review_summary_if_possible(
+        &self,
+        envelope: &Envelope,
+        receipt: &ReviewPublicationReceipt,
+        marker: &str,
+    ) {
+        if self
+            .finalize_review_summary(envelope, receipt, marker)
+            .await
+            .is_err()
+        {
+            eprintln!(
+                "postil: github operation=review-summary-update status=incomplete recovery=truthful-initial-summary"
+            );
+        }
+    }
+
     fn check_external_id(&self, name: &str, head_sha: &str) -> String {
         let run_id = self.details_url.as_deref().and_then(|details_url| {
             reqwest::Url::parse(details_url)
@@ -1254,7 +1299,11 @@ impl Forge for GitHub {
             return Ok(planned_receipt);
         }
         let marker = review_marker(&planned_receipt.receipt_id);
-        let marked_summary = append_marker(&summary, &marker);
+        let marked_summary = bounded_review_body(&summary, &marker, self.details_url.as_deref());
+        let has_planned_inline = planned_receipt
+            .findings
+            .iter()
+            .any(|finding| finding.initial_outcome == FindingPublicationOutcome::Inline);
         let body = json!({
             "commit_id": head_sha,
             "event": "COMMENT",
@@ -1266,18 +1315,28 @@ impl Forge for GitHub {
             .await?;
         let resp = match delivery {
             ReviewDelivery::Reconciled(review) => {
-                return self
+                let receipt = self
                     .materialize_review_receipt(planned_receipt, review)
-                    .await;
+                    .await?;
+                if has_planned_inline {
+                    self.finalize_review_summary_if_possible(envelope, &receipt, &marker)
+                        .await;
+                }
+                return Ok(receipt);
             }
             ReviewDelivery::Response(response) => response,
         };
         if resp.status().is_success() {
             let review: PublishedReview =
                 super::bounded_response_json(resp, "GitHub published review").await?;
-            return self
+            let receipt = self
                 .materialize_review_receipt(planned_receipt, review)
-                .await;
+                .await?;
+            if has_planned_inline {
+                self.finalize_review_summary_if_possible(envelope, &receipt, &marker)
+                    .await;
+            }
+            return Ok(receipt);
         }
         let status = resp.status();
         let request_id = github_request_id(resp.headers()).unwrap_or_else(|| "none".to_string());
@@ -1296,11 +1355,15 @@ impl Forge for GitHub {
         let summary_only = json!({
             "commit_id": head_sha,
             "event": "COMMENT",
-            "body": append_marker(if fallback_summary.is_empty() {
-                "Postil completed the review, but GitHub could not attach its inline comments."
-            } else {
-                &fallback_summary
-            }, &marker),
+            "body": bounded_review_body(
+                if fallback_summary.is_empty() {
+                    "Postil completed the review, but GitHub could not attach its inline comments."
+                } else {
+                    &fallback_summary
+                },
+                &marker,
+                self.details_url.as_deref(),
+            ),
         });
         let fallback = self
             .send_review_reconciled(&summary_only, &marker, head_sha, "summary-only review post")
@@ -1619,7 +1682,10 @@ fn publication_summary(receipt: &ReviewPublicationReceipt) -> ReviewPublicationS
     let mut summary = ReviewPublicationSummary::default();
     for finding in &receipt.findings {
         match finding.initial_outcome {
-            FindingPublicationOutcome::Inline => summary.active_inline += 1,
+            FindingPublicationOutcome::Inline if finding.comment_id.is_some() => {
+                summary.active_inline += 1;
+            }
+            FindingPublicationOutcome::Inline => {}
             FindingPublicationOutcome::SummaryOnly => summary.summary_only += 1,
             FindingPublicationOutcome::Carried => summary.carried += 1,
             FindingPublicationOutcome::Resolved
@@ -1670,6 +1736,27 @@ fn append_marker(body: &str, marker: &str) -> String {
     }
 }
 
+const MAX_REVIEW_BODY_BYTES: usize = 60_000;
+const OVERSIZED_REVIEW_MESSAGE: &str =
+    "Review summary omitted because it exceeds GitHub's size limit.";
+
+fn bounded_review_body(body: &str, marker: &str, details_url: Option<&str>) -> String {
+    let marked = append_marker(body, marker);
+    if marked.len() <= MAX_REVIEW_BODY_BYTES {
+        return marked;
+    }
+    if let Some(details_url) = details_url {
+        let linked = append_marker(
+            &format!("{OVERSIZED_REVIEW_MESSAGE}\n\n<sub>[Review details]({details_url})</sub>"),
+            marker,
+        );
+        if linked.len() <= MAX_REVIEW_BODY_BYTES {
+            return linked;
+        }
+    }
+    append_marker(OVERSIZED_REVIEW_MESSAGE, marker)
+}
+
 fn comment_marker(number: u64, body: &str) -> String {
     let mut digest = Sha256::new();
     digest.update(number.to_be_bytes());
@@ -1774,6 +1861,33 @@ mod tests {
         assert_eq!(EXPECTED_REPOSITORY_ID_ENV, "POSTIL_EXPECTED_GITHUB_REPO_ID");
     }
 
+    #[test]
+    fn review_summary_body_is_bounded_before_github_publication() {
+        let marker = "<!-- postil-review:test -->";
+        assert_eq!(
+            super::bounded_review_body("summary", marker, None),
+            format!("summary\n\n{marker}")
+        );
+        let fallback = super::bounded_review_body(
+            &"x".repeat(super::MAX_REVIEW_BODY_BYTES),
+            marker,
+            Some("https://postil.dev/runs/1"),
+        );
+        assert!(fallback.contains(super::OVERSIZED_REVIEW_MESSAGE));
+        assert!(fallback.contains("[Review details](https://postil.dev/runs/1)"));
+        assert!(fallback.ends_with(marker));
+        assert!(fallback.len() <= super::MAX_REVIEW_BODY_BYTES);
+
+        let oversized_url = format!("https://postil.dev/{}", "x".repeat(60_000));
+        let without_link = super::bounded_review_body(
+            &"x".repeat(super::MAX_REVIEW_BODY_BYTES),
+            marker,
+            Some(&oversized_url),
+        );
+        assert!(!without_link.contains("Review details"));
+        assert!(without_link.len() <= super::MAX_REVIEW_BODY_BYTES);
+    }
+
     fn delivery_snapshot(head_sha: &str, target_sha: &str, merge_base_sha: &str) -> PrMeta {
         PrMeta {
             title: "t".into(),
@@ -2019,6 +2133,12 @@ mod tests {
             .expect(1)
             .mount(&server)
             .await;
+        Mock::given(method("PUT"))
+            .and(path("/repos/owner/repo/pulls/1/reviews/77"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({})))
+            .expect(1)
+            .mount(&server)
+            .await;
 
         let receipt = test_github(&server)
             .post_review(
@@ -2069,10 +2189,137 @@ mod tests {
                 .body,
         )
         .unwrap();
-        let summary = review["body"].as_str().unwrap();
-        assert!(summary.contains("1 inline finding"));
-        assert!(summary.contains("1 finding in summary"));
-        assert!(!summary.contains("3 inline"));
+        let initial_summary = review["body"].as_str().unwrap();
+        assert!(!initial_summary.contains("posted inline"));
+        let update: serde_json::Value = serde_json::from_slice(
+            &requests
+                .iter()
+                .find(|request| request.method == reqwest::Method::PUT)
+                .unwrap()
+                .body,
+        )
+        .unwrap();
+        let final_summary = update["body"].as_str().unwrap();
+        assert!(final_summary.contains("1 finding posted inline"));
+        assert!(final_summary.contains("1 finding in review details"));
+        assert!(final_summary.contains("3 advisory findings"));
+        assert!(final_summary.contains("1 resolved finding"));
+    }
+
+    #[tokio::test]
+    async fn github_summary_update_failure_preserves_truthful_review_and_receipt() {
+        let server = MockServer::start().await;
+        mount_current_delivery_snapshot(&server).await;
+        let envelope = delivery_envelope_with_findings(
+            "aaaaaaaaaaaa",
+            "cccccccccccc",
+            vec![publication_finding(
+                "inline-1",
+                "src/lib.rs",
+                "A concrete issue.",
+            )],
+        );
+        Mock::given(method("POST"))
+            .and(path("/repos/owner/repo/pulls/1/reviews"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+                "id": 79,
+                "commit_id": "aaaaaaaaaaaa",
+                "comments": [{
+                    "id": 502,
+                    "body": format!("finding\n\n{}", super::finding_marker("inline-1"))
+                }]
+            })))
+            .expect(1)
+            .mount(&server)
+            .await;
+        Mock::given(method("PUT"))
+            .and(path("/repos/owner/repo/pulls/1/reviews/79"))
+            .respond_with(ResponseTemplate::new(422))
+            .expect(1)
+            .mount(&server)
+            .await;
+
+        let receipt = test_github(&server)
+            .post_review(
+                &envelope,
+                &delivery_snapshot("aaaaaaaaaaaa", "bbbbbbbbbbbb", "cccccccccccc"),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(receipt.review_id.as_deref(), Some("79"));
+        assert_eq!(receipt.findings[0].comment_id.as_deref(), Some("502"));
+        let requests = server.received_requests().await.unwrap();
+        let initial: serde_json::Value = serde_json::from_slice(
+            &requests
+                .iter()
+                .find(|request| request.method == reqwest::Method::POST)
+                .unwrap()
+                .body,
+        )
+        .unwrap();
+        assert!(!initial["body"].as_str().unwrap().contains("posted inline"));
+    }
+
+    #[tokio::test]
+    async fn github_oversized_summary_falls_back_without_losing_inline_publication() {
+        let server = MockServer::start().await;
+        mount_current_delivery_snapshot(&server).await;
+        let envelope = delivery_envelope_with_findings(
+            "aaaaaaaaaaaa",
+            "cccccccccccc",
+            vec![publication_finding(
+                "inline-1",
+                "src/lib.rs",
+                "A concrete issue.",
+            )],
+        );
+        Mock::given(method("POST"))
+            .and(path("/repos/owner/repo/pulls/1/reviews"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+                "id": 80,
+                "commit_id": "aaaaaaaaaaaa",
+                "comments": [{
+                    "id": 503,
+                    "body": format!("finding\n\n{}", super::finding_marker("inline-1"))
+                }]
+            })))
+            .expect(1)
+            .mount(&server)
+            .await;
+        Mock::given(method("PUT"))
+            .and(path("/repos/owner/repo/pulls/1/reviews/80"))
+            .respond_with(ResponseTemplate::new(200))
+            .expect(1)
+            .mount(&server)
+            .await;
+        let mut github = test_github(&server);
+        github.details_url = Some(format!("https://postil.dev/{}", "x".repeat(60_000)));
+
+        let receipt = github
+            .post_review(
+                &envelope,
+                &delivery_snapshot("aaaaaaaaaaaa", "bbbbbbbbbbbb", "cccccccccccc"),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(receipt.findings[0].comment_id.as_deref(), Some("503"));
+        let requests = server.received_requests().await.unwrap();
+        let initial: serde_json::Value = serde_json::from_slice(
+            &requests
+                .iter()
+                .find(|request| request.method == reqwest::Method::POST)
+                .unwrap()
+                .body,
+        )
+        .unwrap();
+        assert_eq!(initial["comments"].as_array().unwrap().len(), 1);
+        let body = initial["body"].as_str().unwrap();
+        assert!(body.contains(super::OVERSIZED_REVIEW_MESSAGE));
+        assert!(!body.contains("Review details"));
+        assert!(body.contains("<!-- postil-review:v1:"));
+        assert!(body.len() <= super::MAX_REVIEW_BODY_BYTES);
     }
 
     #[tokio::test]
@@ -2168,6 +2415,12 @@ mod tests {
             .expect(1)
             .mount(&server)
             .await;
+        Mock::given(method("PUT"))
+            .and(path("/repos/owner/repo/pulls/1/reviews/88"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({})))
+            .expect(1)
+            .mount(&server)
+            .await;
         Mock::given(method("GET"))
             .and(path("/repos/owner/repo/pulls/1/reviews/88/comments"))
             .respond_with(
@@ -2224,6 +2477,8 @@ mod tests {
             receipt.findings[0].initial_outcome,
             FindingPublicationOutcome::Unknown
         );
+        let summary = test_github(&server).review_summary_for_receipt(&envelope, &receipt);
+        assert!(!summary.contains("posted inline"));
     }
 
     #[tokio::test]
@@ -2850,6 +3105,19 @@ mod tests {
             .await;
         Mock::given(method("POST"))
             .and(path("/repos/owner/repo/pulls/1/reviews"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+                "id": 99,
+                "comments": []
+            })))
+            .mount(&server)
+            .await;
+        Mock::given(method("GET"))
+            .and(path("/repos/owner/repo/pulls/1/reviews/99/comments"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!([])))
+            .mount(&server)
+            .await;
+        Mock::given(method("PUT"))
+            .and(path("/repos/owner/repo/pulls/1/reviews/99"))
             .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({})))
             .mount(&server)
             .await;
diff --git a/src/forge/mod.rs b/src/forge/mod.rs
index 8627114..35ee9e0 100644
--- a/src/forge/mod.rs
+++ b/src/forge/mod.rs
@@ -894,7 +894,17 @@ pub fn check_summary(envelope: &Envelope, rich: bool, context: SummaryContext) -
         }
         s.push('\n');
     } else if envelope.silent {
-        s.push_str(&clean_review_message(envelope));
+        if envelope.resolved.is_empty() {
+            s.push_str(&clean_review_message(envelope));
+        } else {
+            s.push_str(&summary_count(
+                rich,
+                "pass",
+                envelope.resolved.len(),
+                "resolved finding",
+                "resolved findings",
+            ));
+        }
         s.push('\n');
     } else {
         let open_visible = envelope
@@ -902,17 +912,6 @@ pub fn check_summary(envelope: &Envelope, rich: bool, context: SummaryContext) -
             .iter()
             .filter(|finding| !is_operational_path(&finding.path))
             .count();
-        let new_visible = context.publication.map_or_else(
-            || {
-                envelope
-                    .findings
-                    .iter()
-                    .filter(|finding| !is_operational_path(&finding.path))
-                    .filter(|finding| !crate::filter::is_carried(finding))
-                    .count()
-            },
-            |publication| publication.active_inline + publication.summary_only,
-        );
         let open_blocking = envelope
             .findings
             .iter()
@@ -926,104 +925,70 @@ pub fn check_summary(envelope: &Envelope, rich: bool, context: SummaryContext) -
                 )
             })
             .count();
-        if context
-            .publication
-            .is_some_and(|publication| publication.rejected_inline > 0)
-        {
-            let rejected = context
-                .publication
-                .expect("publication summary is present")
-                .rejected_inline;
-            s.push_str(&summary_count(
+        let open_advisory = open_visible.saturating_sub(open_blocking);
+        let mut counts = Vec::new();
+        if has_operational {
+            counts.push(if rich {
+                format!("{} **review incomplete**", icon_md("warn"))
+            } else {
+                "warn: **review incomplete**".to_string()
+            });
+        }
+        if open_blocking > 0 {
+            counts.push(summary_count(
+                rich,
+                "error",
+                open_blocking,
+                "blocking finding open",
+                "blocking findings open",
+            ));
+        }
+        if open_advisory > 0 {
+            counts.push(summary_count(
                 rich,
                 "info",
-                rejected,
-                "finding in review details",
-                "findings in review details",
+                open_advisory,
+                "advisory finding open",
+                "advisory findings open",
             ));
-            s.push_str(" · inline placement unavailable");
-            if open_blocking > 0 {
-                s.push_str(" · ");
-                s.push_str(&summary_count(
-                    rich,
-                    "error",
-                    open_blocking,
-                    "blocking finding open",
-                    "blocking findings open",
-                ));
-            }
+        }
+        if !envelope.resolved.is_empty() {
+            counts.push(summary_count(
+                rich,
+                "pass",
+                envelope.resolved.len(),
+                "resolved finding",
+                "resolved findings",
+            ));
+        }
+        if !counts.is_empty() {
+            s.push_str(&counts.join(" · "));
             s.push('\n');
-        } else if let Some(publication) = context.publication
-            && (publication.active_inline > 0 || publication.summary_only > 0)
-        {
+        }
+
+        if let Some(publication) = context.publication {
+            let mut delivery = Vec::new();
             if publication.active_inline > 0 {
-                s.push_str(&summary_count(
-                    rich,
-                    "info",
+                delivery.push(format!(
+                    "{} {} posted inline",
                     publication.active_inline,
-                    "inline finding",
-                    "inline findings",
+                    plural(publication.active_inline, "finding", "findings"),
                 ));
             }
             if publication.summary_only > 0 {
-                if publication.active_inline > 0 {
-                    s.push_str(" · ");
-                }
-                s.push_str(&summary_count(
-                    rich,
-                    "info",
+                delivery.push(format!(
+                    "{} {} in review details",
                     publication.summary_only,
-                    "finding in summary",
-                    "findings in summary",
+                    plural(publication.summary_only, "finding", "findings"),
                 ));
             }
-            s.push('\n');
-        } else if has_operational && new_visible > 0 {
-            s.push_str(&summary_count(
-                rich,
-                "warn",
-                new_visible,
-                "new finding; review incomplete",
-                "new findings; review incomplete",
-            ));
-            s.push('\n');
-        } else if open_blocking > 0 {
-            if new_visible > 0 {
-                s.push_str(&summary_count(
-                    rich,
-                    "warn",
-                    new_visible,
-                    "new finding",
-                    "new findings",
-                ));
-                s.push_str(" · ");
+            if publication.rejected_inline > 0 {
+                delivery.push("inline placement unavailable".to_string());
+            }
+            if !delivery.is_empty() {
+                s.push_str(&delivery.join(" · "));
+                s.push('\n');
             }
-            s.push_str(&summary_count(
-                rich,
-                "error",
-                open_blocking,
-                "blocking finding open",
-                "blocking findings open",
-            ));
-            s.push('\n');
-        } else if new_visible > 0 {
-            s.push_str(&summary_count(
-                rich,
-                "info",
-                new_visible,
-                "new advisory finding",
-                "new advisory findings",
-            ));
-            s.push('\n');
-        } else if open_visible > 0 {
-            s.push_str(&summary_count(
-                rich,
-                "info",
-                open_visible,
-                "advisory finding open",
-                "advisory findings open",
-            ));
-            s.push('\n');
         }
     }
 
@@ -1070,17 +1035,6 @@ pub fn check_summary(envelope: &Envelope, rich: bool, context: SummaryContext) -
             ));
         }
     }
-    if !envelope.resolved.is_empty() {
-        s.push_str(&summary_count(
-            rich,
-            "pass",
-            envelope.resolved.len(),
-            "resolved finding",
-            "resolved findings",
-        ));
-        s.push('\n');
-    }
-
     let eligible: Vec<_> = envelope
         .suppressed_findings
         .iter()
@@ -1138,7 +1092,7 @@ pub fn check_summary(envelope: &Envelope, rich: bool, context: SummaryContext) -
         } else {
             s.push_str("\nBefore the next push:\n");
         }
-        s.push_str("Run `postil review --staged`, or install it with `postil hook install`.\n");
+        s.push_str("Run `postil review --staged`.\n");
         if rich {
             s.push_str("\n</details>\n");
         }
@@ -1557,7 +1511,7 @@ mod tests {
             },
         );
 
-        assert!(summary.starts_with(&format!("{} **1 new advisory finding**", icon_md("info"))));
+        assert!(summary.starts_with(&format!("{} **1 advisory finding open**", icon_md("info"))));
         assert!(!summary.contains("does not block"));
         assert!(!summary.contains("Unsanitized input reaches query"));
         assert!(!summary.contains("src/auth.rs:41"));
@@ -1572,8 +1526,7 @@ mod tests {
         assert!(summary.contains("Evidence from the changed branch"));
         assert!(!summary.contains("Ignored generated file"));
         assert!(summary.contains("postil review --staged"));
-        assert!(summary.contains("postil hook install"));
-        assert!(!summary.contains("cargo test --lib"));
+        assert!(!summary.contains("postil hook install"));
         assert!(
             summary
                 .contains("<sub>[Review details](https://postil.dev/orgs/acme/runs/run-1)</sub>")
@@ -1589,15 +1542,13 @@ mod tests {
         let blocking = envelope_with_findings(vec![finding()]);
         let blocking_summary = check_summary(&blocking, true, Default::default());
         assert!(blocking_summary.starts_with(&format!(
-            "{} **1 new finding** · {} **1 blocking finding open**\n",
-            icon_md("warn"),
+            "{} **1 blocking finding open**\n",
             icon_md("error"),
         )));
         let blocking_plural = envelope_with_findings(vec![finding(), finding()]);
         assert!(
             check_summary(&blocking_plural, true, Default::default()).starts_with(&format!(
-                "{} **2 new findings** · {} **2 blocking findings open**\n",
-                icon_md("warn"),
+                "{} **2 blocking findings open**\n",
                 icon_md("error"),
             ))
         );
@@ -1610,7 +1561,7 @@ mod tests {
         advisory.gate.failing = false;
         let advisory_summary = check_summary(&advisory, true, Default::default());
         assert!(advisory_summary.starts_with(&format!(
-            "{} **2 new advisory findings**\n",
+            "{} **2 advisory findings open**\n",
             icon_md("info")
         )));
 
@@ -1625,10 +1576,10 @@ mod tests {
             Default::default(),
         );
         assert!(carried_summary.starts_with(&format!(
-            "{} **1 blocking finding open**\n",
+            "{} **review incomplete** · {} **1 blocking finding open**\n",
+            icon_md("warn"),
             icon_md("error")
         )));
-        assert!(!carried_summary.contains("new finding"));
 
         let mut resolved_singular = envelope_with_findings(vec![finding()]);
         resolved_singular.resolved = vec![finding()];
@@ -1637,6 +1588,14 @@ mod tests {
                 .contains(&format!("{} **1 resolved finding**\n", icon_md("pass")))
         );
 
+        let mut resolution_only = envelope_with_findings(vec![]);
+        resolution_only.resolved = vec![finding(), finding()];
+        let resolution_only_summary = check_summary(&resolution_only, true, Default::default());
+        assert_eq!(
+            resolution_only_summary,
+            format!("{} **2 resolved findings**\n", icon_md("pass"))
+        );
+
         let mut detail_counts = envelope_with_findings(vec![finding()]);
         detail_counts.resolved = vec![finding(), finding()];
         detail_counts.suppressed_findings = vec![crate::envelope::SuppressedFinding {
@@ -1727,7 +1686,7 @@ mod tests {
     }
 
     #[test]
-    fn prevention_commands_are_bounded_and_markdown_safe() {
+    fn prevention_commands_remain_bounded_and_markdown_safe() {
         let parsed = parse_prevention_commands(
             r#"["cargo test --lib","bun test","bad`command","line\nbreak","","one","two","three","four"]"#,
         );
diff --git a/tests/e2e.rs b/tests/e2e.rs
index b046e3b..8919c4a 100644
--- a/tests/e2e.rs
+++ b/tests/e2e.rs
@@ -300,6 +300,9 @@ struct ReconciledReviewListResponder {
     published_body: Arc<Mutex<Option<String>>>,
 }
 
+#[derive(Clone)]
+struct PublishedReviewResponder;
+
 struct OutputBudgetResponder;
 
 #[derive(Clone)]
@@ -492,6 +495,31 @@ impl Respond for ReconciledReviewListResponder {
     }
 }
 
+impl Respond for PublishedReviewResponder {
+    fn respond(&self, request: &Request) -> ResponseTemplate {
+        let request_body = request
+            .body_json::<Value>()
+            .expect("published review request must be valid JSON");
+        let comments = request_body["comments"]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .enumerate()
+            .map(|(index, comment)| {
+                json!({
+                    "id": 500 + index,
+                    "body": comment["body"],
+                })
+            })
+            .collect::<Vec<_>>();
+        ResponseTemplate::new(200).set_body_json(json!({
+            "id": 77,
+            "commit_id": request_body["commit_id"],
+            "comments": comments,
+        }))
+    }
+}
+
 async fn mount_github_complete_diff(server: &MockServer, pr: u64) {
     Mock::given(method("GET"))
         .and(path_regex(r"^/repos/acme/api/compare/b+\.\.\.a+$"))
@@ -7996,6 +8024,11 @@ async fn github_flow_posts_review_and_completes_both_checks() {
         .await;
     Mock::given(method("POST"))
         .and(path("/repos/acme/api/pulls/7/reviews"))
+        .respond_with(PublishedReviewResponder)
+        .mount(&server)
+        .await;
+    Mock::given(method("PUT"))
+        .and(path("/repos/acme/api/pulls/7/reviews/77"))
         .respond_with(ResponseTemplate::new(200).set_body_json(json!({})))
         .mount(&server)
         .await;
@@ -8085,11 +8118,22 @@ async fn github_flow_posts_review_and_completes_both_checks() {
     let body: Value = review.body_json().unwrap();
     assert_eq!(body["comments"][0]["path"], "src/auth.rs");
     assert_eq!(body["comments"][0]["line"], 41);
-    let summary = body["body"].as_str().unwrap();
+    let initial_summary = body["body"].as_str().unwrap();
+    assert!(!initial_summary.contains("posted inline"));
+    let update = reqs
+        .iter()
+        .find(|r| {
+            r.method == wiremock::http::Method::PUT
+                && r.url.path() == "/repos/acme/api/pulls/7/reviews/77"
+        })
+        .expect("review summary updated");
+    let update_body: Value = update.body_json().unwrap();
+    let summary = update_body["body"].as_str().unwrap();
     assert!(summary.starts_with(&format!(
-        "{} **1 inline finding**\n",
-        postil_cli::forge::icon_md("info"),
+        "{} **1 blocking finding open**\n",
+        postil_cli::forge::icon_md("error"),
     )));
+    assert!(summary.contains("1 finding posted inline"));
     assert!(!summary.contains("Unsanitized input reaches query"));
     assert!(!summary.contains("`src/auth.rs:41`"));
     assert!(!summary.contains("Review metadata"));
@@ -8226,7 +8270,7 @@ async fn content_policy_pr_server(llm: Value) -> MockServer {
         .and(path("/repos/acme/api/pulls/7"))
         .respond_with(ResponseTemplate::new(200).set_body_json(json!({
             "title": "Add login",
-            "body": "This file is untracked and was written by Claude.",
+            "body": "This change updates review retention behavior.",
             "state": "open", "merged": false,
             "head": {"sha": "aaaaaaaaaaaa"}, "base": {"sha": "bbbbbbbbbbbb"}, "changed_files": 1
         })))
@@ -8256,14 +8300,14 @@ async fn content_policy_pr_body_finding_survives_grounding() {
     // `.postil/pr-description` path instead of being dropped as ungrounded (which
     // would have spuriously fail-closed a run whose only finding was here).
     let cp_finding = json!([{
-        "path": ".postil/pr-description", "line": 1, "severity": "warn",
+        "path": ".postil/pr-description", "line": 2, "severity": "warn",
         "kind": "contentPolicy", "confidence": 0.9,
-        "title": "AI-authorship residue in PR description",
-        "body": "Rule 3: the description contains model-authorship residue.",
-        "evidence": "Add login"
+        "title": "Retention scope missing from PR description",
+        "body": "State the supported retention scope in the description.",
+        "evidence": "This change updates review retention behavior."
     }]);
     let server = content_policy_pr_server(llm_with_summary(
-        "PR description contains model-authorship residue.",
+        "PR description omits the supported retention scope.",
         cp_finding,
     ))
     .await;
@@ -8303,6 +8347,7 @@ async fn content_policy_pr_body_finding_survives_grounding() {
     let user_msg = sent["messages"][1]["content"].as_str().unwrap();
     assert!(user_msg.contains(".postil/pr-description"));
     assert!(user_msg.contains("     1   Add login"));
+    assert!(user_msg.contains("     2   This change updates review retention behavior."));
 
     // The reserved-path finding has no real line, so its bounded detail appears
     // in the PR summary instead of an inline comment.
@@ -8318,12 +8363,13 @@ async fn content_policy_pr_body_finding_survives_grounding() {
     );
     let summary = body["body"].as_str().unwrap();
     assert!(summary.contains(&format!(
-        "{} **1 finding in summary**",
+        "{} **1 advisory finding open**",
         postil_cli::forge::icon_md("info")
     )));
-    assert!(summary.contains("AI-authorship residue in PR description"));
+    assert!(summary.contains("1 finding in review details"));
+    assert!(summary.contains("Retention scope missing from PR description"));
     assert!(summary.contains("in pull request description"));
-    assert!(summary.contains("Rule 3: the description contains model-authorship residue."));
+    assert!(summary.contains("State the supported retention scope in the description."));
 }
 
 #[tokio::test]