rsscript: registry-level review-risk badges

Surfaces the existing risk classification + capability summary as a compact,
machine-readable badge set a registry can render per package — the §20.1-F item.

- PackageReview gains `badges: Vec<String>` derived from `risk` + the review
  summary: `risk:<level>`, plus `native`, `unsafe`, `async`, `parallel`,
  `unknown-capability`, `has-errors`. Pure restatement of existing review
  evidence (no new analysis), so badges never disagree with risk/summary.
- The registry index entry (rss.registry.index.v1) carries the subset derivable
  from its own authoritative fields (`risk:<level>`, `native`, `unsafe`), kept
  consistent with the entry's risk/native/unsafe_apis.
- Risk-label formatting shared via package_risk_label (no duplication).

Tested on the s3-iam native package (risk:unknown + native + unknown-capability).
Documented in package-manager §18.3 and spec §20.1-F. Remaining (out of repo):
rendering badges in a registry UI.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/package/publish.rs

@@ -178,6 +178,22 @@ fn publish_check(
     }
 }
 
+/// Registry-index review-risk badges, derived from the entry's own authoritative
+/// fields (its aggregate publish `risk` plus the native/unsafe boundary signals),
+/// so the badges never disagree with the rest of the index entry. The richer
+/// capability badge set lives on `PackageReview::badges` (which has the full
+/// review summary).
+fn registry_index_badges(risk: PackageRisk, native: bool, unsafe_boundary: bool) -> Vec<String> {
+    let mut badges = vec![format!("risk:{}", super::package_risk_label(risk))];
+    if native {
+        badges.push("native".to_string());
+    }
+    if unsafe_boundary {
+        badges.push("unsafe".to_string());
+    }
+    badges
+}
+
 fn package_registry_index_entry(
     package: &LoadedPackage,
     lock_entry: &PackageLockPackage,
@@ -193,6 +209,8 @@ fn package_registry_index_entry(
         .as_ref()
         .and_then(|native| native.rust.as_ref())
         .is_some_and(|native| native.enabled);
+    let unsafe_boundary = package_index_unsafe_boundary(&package.manifest, native_check);
+    let badges = registry_index_badges(risk, native, unsafe_boundary);
     PackageRegistryIndexEntry {
         schema: "rss.registry.index.v1".to_string(),
         name: package.manifest.package.name.clone(),
@@ -213,7 +231,8 @@ fn package_registry_index_entry(
                 has_default: virtual_package.has_default,
                 provider: virtual_package.provider.clone(),
             }),
-        unsafe_boundary: package_index_unsafe_boundary(&package.manifest, native_check),
+        unsafe_boundary,
+        badges,
         dependencies: package_index_dependencies(&package.manifest.dependencies),
         features: package_index_features(&package.manifest, root_features),
         footprint_default: package_index_footprint(native, tree_summary),

crates/rsscript/src/package/review.rs

@@ -264,13 +264,16 @@ pub(super) fn review_package_dir_with_features(
             .then_with(|| left.name.cmp(&right.name))
     });
 
+    let badges = package_review_badges(risk, &summary);
+
     Ok(PackageReview {
         schema: super::types::PACKAGE_REVIEW_SCHEMA.to_string(),
         producer: super::types::ArtifactProducer::current(),
         package: super::package_identity(manifest),
         manifest_path: package.manifest_path.display().to_string(),
         risk,
         reasons,
+        badges,
         features,
         virtual_package,
         implements,
@@ -1859,6 +1862,33 @@ fn package_unknown_api_count(
         .count()
 }
 
+/// Derive the compact review-risk badge set from the classified `risk` and the
+/// capability `summary`. Badges are stable, lowercase, machine-readable labels a
+/// registry can render per package; they restate signals already in the review
+/// (no new analysis), so they never disagree with `risk`/`summary`.
+fn package_review_badges(risk: PackageRisk, summary: &PackageReviewSummary) -> Vec<String> {
+    let mut badges = vec![format!("risk:{}", super::package_risk_label(risk))];
+    if summary.native_apis > 0 {
+        badges.push("native".to_string());
+    }
+    if summary.unsafe_apis > 0 {
+        badges.push("unsafe".to_string());
+    }
+    if summary.async_apis > 0 {
+        badges.push("async".to_string());
+    }
+    if summary.parallel_apis > 0 {
+        badges.push("parallel".to_string());
+    }
+    if summary.unknown_apis > 0 {
+        badges.push("unknown-capability".to_string());
+    }
+    if summary.errors > 0 {
+        badges.push("has-errors".to_string());
+    }
+    badges
+}
+
 fn package_risk(
     manifest: &Manifest,
     native: Option<&PackageNativeRustReview>,

crates/rsscript/src/package/types.rs

@@ -35,6 +35,11 @@ pub struct PackageReview {
     pub manifest_path: String,
     pub risk: PackageRisk,
     pub reasons: Vec<String>,
+    /// Compact, machine-readable review-risk badges derived from `risk` and the
+    /// capability `summary` (e.g. `risk:elevated`, `native`, `unsafe`, `async`,
+    /// `unknown-capability`). A registry surfaces these as per-package badges.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub badges: Vec<String>,
     pub features: Vec<String>,
     pub virtual_package: Option<PackageVirtual>,
     pub implements: Vec<PackageProviderImplementation>,
@@ -209,6 +214,10 @@ pub struct PackageRegistryIndexEntry {
     pub virtual_package: Option<PackageVirtual>,
     #[serde(rename = "unsafe_apis")]
     pub unsafe_boundary: bool,
+    /// Review-risk badges (same set as `PackageReview::badges`) carried into the
+    /// registry index so a registry can render them without re-deriving.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub badges: Vec<String>,
     pub dependencies: BTreeMap<String, String>,
     pub features: BTreeMap<String, Vec<String>>,
     pub footprint_default: PackageRegistryFootprint,

crates/rsscript/tests/s3_iam_reir_demo_e2e.rs

@@ -340,6 +340,15 @@ fn s3_iam_reir_demo_missing_capability_binding_is_unknown_not_safe() {
 
     assert_eq!(review.risk, rsscript::PackageRisk::Unknown);
     assert_eq!(review.summary.unknown_apis, 1);
+    // Review-risk badges restate the classified risk + capability signals as a
+    // compact, registry-renderable set; they must agree with risk/summary.
+    assert!(
+        review.badges.contains(&"risk:unknown".to_string()),
+        "badges: {:?}",
+        review.badges
+    );
+    assert!(review.badges.contains(&"native".to_string()));
+    assert!(review.badges.contains(&"unknown-capability".to_string()));
     assert!(
         review
             .reasons

docs/RSScript_Package_Manager_Design_v0.6.md

@@ -2778,6 +2778,7 @@ Implemented v1 schema shape:
   },
   "risk": "elevated",
   "reasons": ["native Rust wrapper enabled", "returns Result"],
+  "badges": ["risk:elevated", "native"],
   "features": [],
   "implements": [],
   "dependencies": [],
@@ -2849,6 +2850,15 @@ Implemented v1 schema shape:
 }
 ```
 
+`badges` is a compact, machine-readable set of review-risk badges derived from
+`risk` and the capability `summary` (`risk:<level>`, plus `native`, `unsafe`,
+`async`, `parallel`, `unknown-capability`, `has-errors` as applicable). They
+restate signals already in the review — never new analysis — so a registry can
+render per-package badges without re-deriving them. The registry index entry
+(`rss.registry.index.v1`) carries the subset derivable from its own authoritative
+fields (`risk:<level>`, `native`, `unsafe`), kept consistent with the entry's
+`risk`/`native`/`unsafe_apis`.
+
 `exports` records the normalized public contract surface, not only callable
 functions. Current package review metadata uses `kind` values such as
 `type`, `sum_type`, `type_alias`, `const`, `function`, `protocol`, and

docs/RSScript_v0.7_Spec.md

@@ -5301,15 +5301,18 @@ E. Sum type hardening
      implicit variant coercion.
 
 F. Registry-level review-risk badges
-   - the package registry should surface review-risk signals as first-class
-     quality badges: native, unsafe, unknown, mutating/retaining ratios.
-   - this reuses the package review metadata already produced by package tooling
-     (section 18.3) rather than inventing a separate scoring system.
-   - package-manager registry previews expose these signals through
-     `rss.registry.index.v1` fields such as `review_schema`, `unsafe_apis`,
-     selected feature sets, and default graph footprint. The language spec does
-     not define registry scoring beyond requiring those signals to derive from
-     compiler/package review evidence.
+   - the package registry surfaces review-risk signals as first-class quality
+     badges: a `badges` field on the package review (`rss.review.package.v1`) and
+     the registry index (`rss.registry.index.v1`) carries compact labels —
+     `risk:<level>`, `native`, `unsafe`, `async`, `parallel`,
+     `unknown-capability`, `has-errors` — derived from the classified `risk` and
+     capability `summary` (package-manager §18.3).
+   - badges restate review evidence already produced by package tooling; they
+     invent no separate scoring system and never disagree with `risk`/`summary`.
+   - remaining (registry-side, out of this repo): rendering the badges in a
+     registry UI / preview. The language + package tooling now emit the badge data;
+     the language spec does not define registry scoring beyond requiring those
+     signals to derive from compiler/package review evidence.
 
 G. Capability objects (explicit dynamic dispatch)
    - RSScript does not adopt Rust-style `dyn Trait` with vtable coercion.