diff --git a/docs/STYLEGUIDE.md b/docs/STYLEGUIDE.md
index f0a1512..0d738e8 100644
--- a/docs/STYLEGUIDE.md
+++ b/docs/STYLEGUIDE.md
@@ -68,6 +68,18 @@ rails make "not decided" texturally distinct even in greyscale.
 | `--delta-restored` | `#6B7280` | | `--mode-shadow` | `#667085` |
 | | | | `--mode-enforce` | `#1570EF` |
 
+### Colour — signing posture (ADR-0020; the Admission signing inventory)
+Every image's observed signing posture, always one of these — **never n/a** — each carrying
+colour **+ glyph + word** (meaning never by colour alone). `invalid signature` is the loud channel;
+plain `not signed` is calm (no baseline yet), never green. The "if enforced" cell is always the
+binary would-admit / would-block.
+| Token | Value | Glyph | Word |
+|---|---|---|---|
+| `--sign-signed` (`--cov-present`) | `#067647` | ✓ | signed |
+| `--sign-invalid` (`--posture-breach`) | `#D92D20` | ✕ | invalid signature |
+| `--sign-notsigned` (`--ink-3`) | `#6B7280` | ○ open | not signed |
+| `--sign-checking` (`--posture-awaiting`) | `#9A6B2E` | ◌ dotted | checking… |
+
 ### Space (4px base)
 `--space-1:4 · --space-2:8 · --space-3:12 · --space-4:16 · --space-6:24 · --space-8:32`
 
@@ -97,12 +109,15 @@ Two weights only (400/600). Emphasis via weight + ink value, not a third weight.
 | CVE table | `--font-data` `--text-micro`, right-aligned numerics |
 | Coverage row | `--cov-*` dot + glyph + label; `weakens_decisions` + absent → amber keyline |
 | Reversion log | `--posture-cleared` toned (a self-revert is the system working) |
+| Signing inventory | `--sign-*` chip (glyph + word); `invalid` → `--posture-breach` keyline (loud), `not signed` calm; ref/signer single-line ellipsis (never `break-all`), full value in the `<details>` panel + `title=`; "if enforced" → `--cov-present` would-admit / `--posture-breach` would-block |
 | Empty states | `--ink-2`; posture-coloured only when honestly earned (model judging) |
 
 ## Accessibility gate (test-enforced)
 1. **Contrast:** body/status text ≥ **4.5:1** on its surface; chips/rails/glyphs ≥ **3:1**.
-2. **Meaning not by colour alone:** every posture / severity / Δ / coverage state renders a
-   non-empty **glyph + text label** in addition to colour. (Assert each enum→(glyph,label).)
+2. **Meaning not by colour alone:** every posture / severity / Δ / coverage / **signing posture**
+   state renders a non-empty **glyph + text label** in addition to colour. (Assert each
+   enum→(glyph,label).) The signing posture is always one of signed / invalid signature / not
+   signed / checking — **never n/a** — and its "if enforced" cell is always would-admit / would-block.
 3. **Honest-calm invariant:** the overall green/all-clear resolves to `--posture-cleared`/green
    ONLY when the model has affirmatively cleared everything — `model_judging == true` AND not
    `warming_up` AND **covered** AND **zero breaches AND zero awaiting AND zero uncertain**. If
diff --git a/engine/examples/dashboard_preview.rs b/engine/examples/dashboard_preview.rs
index 61db290..f7967b5 100644
--- a/engine/examples/dashboard_preview.rs
+++ b/engine/examples/dashboard_preview.rs
@@ -334,9 +334,52 @@ fn sample_policy_log() -> Arc<PolicyDecisionLog> {
         )
         .with_would_admit(false),
     );
+    record_signing_inventory(&log);
     Arc::new(log)
 }
 
+/// Seed the signing sweep's per-image observation rows (JEF-261 shape) so the Admission tab's
+/// signing inventory (JEF-262) renders every posture: a GitHub Actions keyless signature, a
+/// human/Google-issued signature, an invalid signature (loud), a plain not-signed (calm), and a
+/// transient checking. Keyed `Image/<ref>` with the posture in the `signature` word + `reason`
+/// prose, exactly as `engine::signing_sweep` records them.
+fn record_signing_inventory(log: &PolicyDecisionLog) {
+    let sweep = |image: &str, status: &str, reason: &str| {
+        log.record(PolicyDecisionRecord::now(
+            "image-signature",
+            "allow",
+            format!("Image/{image}"),
+            image,
+            status,
+            "",
+            "",
+            reason,
+        ));
+    };
+    sweep(
+        "ghcr.io/acme/api-gateway@sha256:1a2b3c4d5e6f70819293a4b5c6d7e8f90112233445566778899aabbccddeeff0",
+        "signed",
+        "signed by https://github.com/acme/api-gateway/.github/workflows/release.yaml@refs/tags/v1.8.2 \
+         via https://token.actions.githubusercontent.com",
+    );
+    sweep(
+        "ghcr.io/acme/export:3.0.0",
+        "signed",
+        "signed by releng@acme.example via https://accounts.google.com",
+    );
+    sweep(
+        "docker.io/library/storefront:latest",
+        "invalid-signature",
+        "signature present but does not verify (untrusted/tampered chain)",
+    );
+    sweep("docker.io/library/postgres:16", "not-signed", "");
+    sweep(
+        "registry.k8s.io/pause:3.9",
+        "checking",
+        "signing posture not yet known (registry/log unreachable)",
+    );
+}
+
 /// A representative bake/coverage summary used by the covered scenarios.
 fn covered_bake() -> BakeStats {
     let mut bake = BakeStats::default();
@@ -826,11 +869,7 @@ fn preview_readiness(state: &DashboardState) -> view_model::props::ReadinessView
 
 /// Build the Admission view props through the public render path.
 fn preview_admission(state: &DashboardState) -> view_model::props::AdmissionViewProps {
-    view_model::build_admission_view(
-        preview_strip(state),
-        state.policy_log.tallies(),
-        &state.policy_log.snapshot(),
-    )
+    view_model::build_admission_view(preview_strip(state), &state.policy_log.snapshot())
 }
 
 /// Render the full page for a tab through the dashboard's PUBLIC render path (all four real).
diff --git a/engine/src/engine/dashboard/admission_tests.rs b/engine/src/engine/dashboard/admission_tests.rs
index 91d6fe6..78c47c8 100644
--- a/engine/src/engine/dashboard/admission_tests.rs
+++ b/engine/src/engine/dashboard/admission_tests.rs
@@ -1,12 +1,13 @@
 //! Render-level tests for the Admission/policy view (the webhook floor, brief §6): the tallies
-//! header (never blank, honest at zero), the deduped decision rows + the "if enforced" what-if, the
-//! honest-empty case, the real fourth nav tab, and escaping of the untrusted image/subject/reason
-//! text. These drive the view_model + component directly (no HTTP, no engine), so they are fast and
-//! pure. Kept in their own file so `tests.rs` stays under the 1,000-line cap (CLAUDE.md).
+//! header (never blank, honest at zero), the per-image signing inventory (JEF-262 — every posture,
+//! the binary if-enforced, honest empty), the deduped decision rows + the "if enforced" what-if, the
+//! real fourth nav tab, and escaping of the untrusted image/subject/reason/identity text. These
+//! drive the view_model + component directly (no HTTP, no engine), so they are fast and pure. Kept
+//! in their own file so `tests.rs` stays under the 1,000-line cap (CLAUDE.md).
 
 use std::time::SystemTime;
 
-use crate::engine::policy_log::{DecisionTallies, PolicyDecisionRecord};
+use crate::engine::policy_log::PolicyDecisionRecord;
 use crate::engine::state::{BakeStats, Finding, ModelHealth, ReadinessConfig, derive_readiness};
 
 use super::page;
@@ -61,12 +62,29 @@ fn admission_rec(
     .with_would_admit(would_admit)
 }
 
+/// A signing-sweep observation row (JEF-261 shape): `Image/<ref>` subject, posture in `signature`.
+fn signing_rec(image: &str, status: &str, reason: &str) -> PolicyDecisionRecord {
+    PolicyDecisionRecord::now(
+        "image-signature",
+        "allow",
+        format!("Image/{image}"),
+        image,
+        status,
+        "",
+        "",
+        reason,
+    )
+}
+
+fn render(rows: &[PolicyDecisionRecord]) -> String {
+    page::admission_page(&build_admission_view(strip_from(&[]), rows)).into_string()
+}
+
 #[test]
 fn admission_nav_tab_is_a_real_fourth_surface() {
     // The four tabs are all reachable; the Admission tab links to its real route. The merged
     // Action tab replaces the former Trust + Activity pair.
-    let v = build_admission_view(strip_from(&[]), DecisionTallies::default(), &[]);
-    let html = page::admission_page(&v).into_string();
+    let html = render(&[]);
     for tab in ["Findings", "Action", "Readiness", "Admission"] {
         assert!(html.contains(tab), "the nav offers the {tab} tab");
     }
@@ -85,64 +103,69 @@ fn admission_nav_tab_is_a_real_fourth_surface() {
 #[test]
 fn admission_tallies_header_is_never_blank_even_at_zero() {
     // The webhook floor's headline: counts honest at zero, so a healthy cluster is never blank.
-    let v = build_admission_view(strip_from(&[]), DecisionTallies::default(), &[]);
-    let html = page::admission_page(&v).into_string();
+    let html = render(&[]);
     assert!(html.contains("admitted"), "the admitted tally is rendered");
     assert!(html.contains("audited"), "the audited tally is rendered");
     assert!(html.contains("denied"), "the denied tally is rendered");
-    // And the honest-empty body, never read as all-clear.
+    // And the honest-empty bodies, never read as all-clear.
     assert!(
         html.contains("no admission decisions recorded yet"),
         "an empty log reads as no-decisions, not all-clear"
     );
+    assert!(
+        html.contains("no images observed yet"),
+        "an empty inventory reads as nothing-inspected, not all-clear"
+    );
     assert!(html.contains("not an all-clear"));
 }
 
 #[test]
 fn admission_renders_deduped_rows_with_the_if_enforced_what_if() {
-    let tallies = DecisionTallies {
-        admitted: 42,
-        audited: 2,
-        denied: 1,
-    };
+    let mut clean = admission_rec(
+        "allow",
+        "Deployment/web",
+        "ghcr.io/org/web:1",
+        "verified",
+        "verified",
+        "default",
+        "",
+        true,
+    );
+    clean.count = 42;
     let rows = vec![
-        // A clean admit — verified on both gates, would admit.
-        admission_rec(
-            "allow",
-            "Deployment/web",
-            "ghcr.io/org/web:1",
-            "verified",
-            "verified",
-            "default",
-            "",
-            true,
-        ),
-        // A would-fail signature gate → the "if enforced" what-if is would-deny.
+        clean,
+        // A would-fail MESH gate → the "if enforced" what-if is would-deny.
         admission_rec(
             "audit",
             "Deployment/legacy",
             "docker.io/legacy:old",
+            "verified",
             "would-fail",
-            "would-pass",
             "payments",
-            "unsigned or untrusted image",
+            "not mesh-injected",
             false,
         ),
     ];
-    let html =
-        page::admission_page(&build_admission_view(strip_from(&[]), tallies, &rows)).into_string();
-    // The counts surface.
+    let html = render(&rows);
+    // The derived admitted count surfaces.
     assert!(html.contains("42"), "the admitted count");
-    // The per-gate shadow status words ride alongside their glyphs (meaning never by colour alone).
+    // The mesh shadow status words ride alongside their glyphs (meaning never by colour alone).
     assert!(html.contains("verified"), "a verified gate");
     assert!(html.contains("would-fail"), "a would-fail gate");
-    assert!(html.contains("would-pass"), "a would-pass gate");
     // The "if enforced" what-if for both directions.
     assert!(html.contains("would admit"), "the admit what-if");
     assert!(html.contains("would deny"), "the would-deny what-if");
     // The subject + image surface (untrusted, escaped by maud).
     assert!(html.contains("Deployment/web"));
     assert!(html.contains("ghcr.io/org/web:1"));
+    // The decision log no longer carries a signature gate column — its thead is decision / workload
+    // / mesh / if enforced (posture now lives in the inventory).
+    let decisions = &html[html.find("admission-rows").unwrap()..];
+    assert!(
+        !decisions.contains(">signature<"),
+        "no signature column header in the decision log"
+    );
+    assert!(decisions.contains(">mesh<"), "the mesh column remains");
 }
 
 #[test]
@@ -151,12 +174,7 @@ fn admission_dedup_count_shows_when_above_one() {
         "allow", "Pod/web", "img:1", "verified", "verified", "ns", "", true,
     );
     r.count = 50;
-    let html = page::admission_page(&build_admission_view(
-        strip_from(&[]),
-        DecisionTallies::default(),
-        &[r],
-    ))
-    .into_string();
+    let html = render(&[r]);
     assert!(
         html.contains("\u{00D7}50"),
         "the replica-churn dedup count (×50) is shown"
@@ -170,18 +188,13 @@ fn admission_untrusted_image_and_reason_are_escaped() {
         "deny",
         format!("Pod/{evil}").as_str(),
         format!("img/{evil}").as_str(),
-        "would-fail",
         "verified",
+        "would-fail",
         evil,
         format!("unsigned {evil}").as_str(),
         false,
     )];
-    let html = page::admission_page(&build_admission_view(
-        strip_from(&[]),
-        DecisionTallies::default(),
-        &rows,
-    ))
-    .into_string();
+    let html = render(&rows);
     assert!(
         !html.contains("<script>alert"),
         "raw script must not reach output"
@@ -191,10 +204,116 @@ fn admission_untrusted_image_and_reason_are_escaped() {
 
 #[test]
 fn admission_fragment_has_no_document_shell() {
-    let v = build_admission_view(strip_from(&[]), DecisionTallies::default(), &[]);
+    let v = build_admission_view(strip_from(&[]), &[]);
     let frag = page::admission_fragment(&v).into_string();
     assert!(!frag.contains("<!DOCTYPE"), "a fragment carries no doctype");
     assert!(!frag.contains("<html"), "nor a document element");
     // It carries the persistent strip (a poll refreshes coverage/freshness on this tab too).
     assert!(frag.contains("strip"));
 }
+
+// ---- signing inventory (JEF-262) render tests -----------------------------------------------
+
+#[test]
+fn signing_inventory_renders_every_posture_with_word_and_no_na() {
+    let rows = vec![
+        signing_rec(
+            "ghcr.io/acme/app@sha256:aa",
+            "signed",
+            "signed by https://github.com/acme/app/.github/workflows/r.yaml@refs/tags/v1 \
+             via https://token.actions.githubusercontent.com",
+        ),
+        signing_rec(
+            "docker.io/library/storefront:latest",
+            "invalid-signature",
+            "signature present but does not verify (untrusted/tampered chain)",
+        ),
+        signing_rec("docker.io/library/postgres:16", "not-signed", ""),
+        signing_rec(
+            "registry.k8s.io/pause:3.9",
+            "checking",
+            "signing posture not yet known (registry/log unreachable)",
+        ),
+    ];
+    let html = render(&rows);
+    // Each posture renders its distinct word (never colour alone, and lexically distinct).
+    assert!(html.contains("signed"), "signed word");
+    assert!(
+        html.contains("invalid signature"),
+        "invalid word — distinct"
+    );
+    assert!(html.contains("not signed"), "not-signed word — distinct");
+    assert!(html.contains("checking"), "the transient checking word");
+    // The binary if-enforced, both directions — never n/a.
+    assert!(html.contains("would admit"), "signed would admit");
+    assert!(html.contains("would block"), "unsigned/invalid would block");
+    // Hard rule: the inventory never shows n/a. Slice the inventory section (the next section is the
+    // decision log — `admission-rows` when populated, `admission-empty` when not).
+    let rest = &html[html.find("signing-inventory").unwrap()..];
+    let end = rest
+        .find("admission-rows")
+        .or_else(|| rest.find("admission-empty"))
+        .unwrap_or(rest.len());
+    let inventory = &rest[..end];
+    assert!(
+        !inventory.contains("n/a"),
+        "the signing inventory never shows n/a"
+    );
+    // Grouped under the repo header.
+    assert!(html.contains("ghcr.io/acme/app"), "the repo group header");
+}
+
+#[test]
+fn signing_inventory_shows_the_short_signer_and_issuer_badge() {
+    let rows = vec![signing_rec(
+        "ghcr.io/acme/app@sha256:aa",
+        "signed",
+        "signed by https://github.com/acme/app/.github/workflows/release.yaml@refs/tags/v1 \
+         via https://token.actions.githubusercontent.com",
+    )];
+    let html = render(&rows);
+    assert!(html.contains("signed by "), "the in-row signer line");
+    assert!(
+        html.contains("acme/app"),
+        "the short org/repo identity label"
+    );
+    assert!(html.contains("github actions"), "the issuer badge");
+    // The full SAN is preserved (expand panel + title=), never dropped.
+    assert!(
+        html.contains("https://github.com/acme/app/.github/workflows/release.yaml@refs/tags/v1"),
+        "the full Fulcio SAN is available"
+    );
+}
+
+#[test]
+fn signing_inventory_escapes_an_attacker_chosen_identity() {
+    // The signer identity is untrusted Fulcio-cert free-text — an attacker-chosen SAN must not
+    // inject markup (maud auto-escape; never PreEscaped).
+    let evil = "<script>alert('pwn')</script>";
+    let rows = vec![signing_rec(
+        "ghcr.io/acme/app@sha256:aa",
+        "signed",
+        &format!("signed by {evil} via https://token.actions.githubusercontent.com"),
+    )];
+    let html = render(&rows);
+    assert!(
+        !html.contains("<script>alert"),
+        "raw script from the identity must not reach output"
+    );
+    assert!(html.contains("&lt;script&gt;"), "the identity is escaped");
+}
+
+#[test]
+fn signing_inventory_honest_empty_when_no_images_observed() {
+    // Decision rows present, but no signing-sweep observation rows → the inventory is honestly
+    // empty, explicitly NOT an all-clear.
+    let rows = vec![admission_rec(
+        "allow", "Pod/web", "img:1", "verified", "verified", "ns", "", true,
+    )];
+    let html = render(&rows);
+    assert!(html.contains("no images observed yet"));
+    assert!(
+        html.contains("not an all-clear"),
+        "the empty inventory disclaims being an all-clear"
+    );
+}
diff --git a/engine/src/engine/dashboard/components/admission_view.rs b/engine/src/engine/dashboard/components/admission_view.rs
index 234f654..9e103a0 100644
--- a/engine/src/engine/dashboard/components/admission_view.rs
+++ b/engine/src/engine/dashboard/components/admission_view.rs
@@ -1,22 +1,26 @@
 //! The Admission/policy view body (brief §6 — the webhook floor): the decision-tallies header
 //! (admitted / audited / denied, so a healthy cluster is never a blank screen — counts honest even
-//! at zero) + the deduped decision rows (subject/image · namespace · signature status · mesh status
-//! · the decision · the "if enforced" what-if). Light-theme, calm by default; meaning never by
-//! colour alone (colour + glyph + word). Honest empty state when no decisions are recorded. Pure
-//! component; no domain types; all free-text auto-escaped.
+//! at zero) + the per-image signing inventory (JEF-262 / ADR-0020) + the deduped decision rows
+//! (subject/image · namespace · mesh status · the decision · the "if enforced" what-if). The
+//! signature posture now lives in the signing inventory, so the decision log no longer carries a
+//! signature gate column. Light-theme, calm by default; meaning never by colour alone (colour +
+//! glyph + word). Honest empty states throughout. Pure component; no domain types; all free-text
+//! auto-escaped.
 
 use maud::{Markup, html};
 
 use crate::engine::dashboard::view_model::props::{
-    AdmissionViewProps, DecisionRowProps, GateStatus,
+    AdmissionViewProps, DecisionRowProps, GateStatus, SigningPosture, SigningRepoProps,
+    SigningRowProps,
 };
 
-/// Render the Admission view: the tallies header, then the deduped decision rows, with an honest
-/// empty state when no decisions have been recorded.
+/// Render the Admission view: the tallies header, then the per-image signing inventory, then the
+/// deduped decision rows — each with its own honest empty state.
 pub fn admission_view(v: &AdmissionViewProps) -> Markup {
     html! {
         main.view.view-admission {
             (tallies_header(v))
+            (signing_inventory(v))
             @if v.rows.is_empty() {
                 (empty_state())
             } @else {
@@ -57,8 +61,161 @@ fn tallies_header(v: &AdmissionViewProps) -> Markup {
     }
 }
 
+/// The per-image signing inventory (JEF-262 / ADR-0020): the observed signing posture of EVERY
+/// image, grouped under its repo, sitting between the tallies header and the decision log. Two hard
+/// rules the operator set: the posture is always signed / invalid signature / not signed (or the
+/// transient checking) — never n/a; and the "if enforced" cell is always the binary would-admit /
+/// would-block. Honest empty ("no images observed yet") — explicitly NOT an all-clear.
+fn signing_inventory(v: &AdmissionViewProps) -> Markup {
+    html! {
+        section.signing-inventory aria-label="signing inventory" {
+            h3.col-h.t-h2 { "signing inventory" }
+            p.section-sub.t-body.muted {
+                "the observed signing posture of every image \u{2014} signed, invalid signature, or \
+                 not signed (or a transient check while a registry is unreachable). This is \
+                 observation, not a gate; the 'if enforced' column is the binary what-if a \
+                 signature gate would apply (only a verifying signature would admit)."
+            }
+            @if v.signing.is_empty() {
+                (signing_empty())
+            } @else {
+                @for repo in &v.signing {
+                    (signing_repo(repo))
+                }
+            }
+        }
+    }
+}
+
+/// One repo group: the registry/repo header + a real `<table>` of the images observed under it (so
+/// the machine columns align — the keyboard/semantics gate).
+fn signing_repo(g: &SigningRepoProps) -> Markup {
+    html! {
+        div.signing-repo {
+            h4.signing-repo-h.t-data-strong { (g.repo) }
+            table.signing {
+                thead {
+                    tr {
+                        th.t-micro { "image" }
+                        th.t-micro { "signature" }
+                        th.t-micro { "if enforced" }
+                    }
+                }
+                tbody {
+                    @for img in &g.images {
+                        (signing_row(img))
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// One image row: the ref (expand-in-place for the full ref + signer/issuer detail) · the signing
+/// posture chip · the binary "if enforced". An invalid signature is the loud attention case (a
+/// breach keyline). The signer identity (untrusted Fulcio SAN) truncates in-row and is auto-escaped;
+/// its full value lives in the expand panel + `title=`.
+fn signing_row(r: &SigningRowProps) -> Markup {
+    let attention = r.posture == SigningPosture::Invalid;
+    let tr_class = if attention {
+        "signing-row signing-row-attention"
+    } else {
+        "signing-row"
+    };
+    html! {
+        tr class=(tr_class) data-posture=(r.posture.token()) {
+            td.cell-image {
+                details.signing-detail {
+                    summary.why-toggle role="button" aria-expanded="false" {
+                        span.signing-ref.t-data-strong title=(r.image) { (r.label) }
+                        @if r.count > 1 {
+                            span.signing-count.t-micro.muted title="distinct image observed this many times" {
+                                "\u{00D7}" (r.count)
+                            }
+                        }
+                        @if let Some(signer) = &r.signer {
+                            span.signing-by.t-micro.muted title=(signer.identity_full) {
+                                "signed by " (signer.identity_short)
+                                @if !signer.issuer_badge.is_empty() {
+                                    " \u{00B7} " span.issuer-badge { (signer.issuer_badge) }
+                                }
+                            }
+                        }
+                    }
+                    div.signing-detail-body {
+                        p.t-data { "image: " span.mono { (r.image) } }
+                        @match &r.signer {
+                            Some(signer) => {
+                                p.t-data { "identity: " span.mono { (signer.identity_full) } }
+                                @match &signer.issuer_full {
+                                    Some(issuer) => p.t-data { "issuer: " span.mono { (issuer) } }
+                                    None => p.t-data.muted { "issuer: none recorded" }
+                                }
+                            }
+                            None => {
+                                @if r.detail.is_empty() {
+                                    p.t-data.muted { "no signature artifact present for this image" }
+                                } @else {
+                                    p.t-data { (r.detail) }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            td.cell-gate { (signing_chip(r.posture)) }
+            td.cell-enforced { (if_enforced_signing(r.posture.would_admit())) }
+        }
+    }
+}
+
+/// A signing-posture chip: colour + glyph + word, never colour alone. Reuses the `gate-chip`
+/// vocabulary with the `sign-*` colour tokens; `invalid` is the loud channel, `not signed` calm.
+fn signing_chip(p: SigningPosture) -> Markup {
+    html! {
+        span class={ "gate-chip sign-" (p.token()) } {
+            span.glyph aria-hidden="true" { (p.glyph()) }
+            span.gate-word { (p.word()) }
+        }
+    }
+}
+
+/// The binary "if enforced" for a signing posture: would admit / would block (never n/a). Colour +
+/// glyph + word; a would-block is the loud channel (a signature gate would reject the image).
+fn if_enforced_signing(would_admit: bool) -> Markup {
+    html! {
+        @if would_admit {
+            span.enforced-chip.enforced-admit {
+                span.glyph aria-hidden="true" { "\u{2713}" }
+                span.enforced-word { "would admit" }
+            }
+        } @else {
+            span.enforced-chip.enforced-block {
+                span.glyph aria-hidden="true" { "\u{2715}" }
+                span.enforced-word { "would block" }
+            }
+        }
+    }
+}
+
+/// The honest empty inventory: no images observed yet — explicitly NOT an all-clear (nothing has
+/// been inspected, not "everything is signed").
+fn signing_empty() -> Markup {
+    html! {
+        div.empty.signing-empty {
+            p.empty-head.t-h2 { "no images observed yet" }
+            p.empty-sub.t-body.muted {
+                "the signing sweep has not recorded any image postures in this window. This is not \
+                 an all-clear \u{2014} it means nothing has been inspected yet, not that every \
+                 image is signed."
+            }
+        }
+    }
+}
+
 /// The deduped decision rows as a real table (keyboard/semantics gate: machine data in a `<table>`
-/// so columns align). One row per distinct `(subject, image, decision)`.
+/// so columns align). One row per distinct `(subject, image, decision)`. The signature posture
+/// lives in the signing inventory above, so this table carries only the mesh gate.
 fn decision_rows(v: &AdmissionViewProps) -> Markup {
     html! {
         section.admission-rows aria-label="admission decisions" {
@@ -68,7 +225,6 @@ fn decision_rows(v: &AdmissionViewProps) -> Markup {
                     tr {
                         th.t-micro { "decision" }
                         th.t-micro { "workload" }
-                        th.t-micro { "signature" }
                         th.t-micro { "mesh" }
                         th.t-micro { "if enforced" }
                     }
@@ -83,9 +239,9 @@ fn decision_rows(v: &AdmissionViewProps) -> Markup {
     }
 }
 
-/// One decision row: the decision chip · the subject/image/namespace · the signature + mesh shadow
-/// status · the "if enforced" what-if. A `would-fail` gate or a `would-deny` what-if is the
-/// attention case (a denied keyline). All free-text (subject/image/namespace/reason) auto-escaped.
+/// One decision row: the decision chip · the subject/image/namespace · the mesh shadow status · the
+/// "if enforced" what-if. A `would-fail` gate or a `would-deny` what-if is the attention case (a
+/// denied keyline). All free-text (subject/image/namespace/reason) auto-escaped.
 fn decision_row(r: &DecisionRowProps) -> Markup {
     // A row the engine would have rejected if enforced is the attention case — keyline it.
     let attention = !r.would_admit;
@@ -123,7 +279,6 @@ fn decision_row(r: &DecisionRowProps) -> Markup {
                     p.decision-reason.t-data { (r.reason) }
                 }
             }
-            td.cell-gate { (gate_chip(r.signature)) }
             td.cell-gate { (gate_chip(r.mesh)) }
             td.cell-enforced { (if_enforced(r.would_admit)) }
         }
diff --git a/engine/src/engine/dashboard/mod.rs b/engine/src/engine/dashboard/mod.rs
index 134061e..151103d 100644
--- a/engine/src/engine/dashboard/mod.rs
+++ b/engine/src/engine/dashboard/mod.rs
@@ -134,11 +134,13 @@ impl DashboardState {
     }
 
     /// Build the Admission/policy (webhook floor) view props: the persistent strip + the decision
-    /// tallies header (so a healthy view is never blank) + the deduped decision rows (newest-first).
+    /// tallies header (so a healthy view is never blank) + the per-image signing inventory + the
+    /// deduped decision rows (newest-first). The tallies are derived from the decision rows (the
+    /// signing sweep's observation rows feed only the inventory), so the view_model shapes the whole
+    /// snapshot on its own.
     fn admission_view(&self) -> AdmissionViewProps {
-        let tallies = self.policy_log.tallies();
         let rows = self.policy_log.snapshot();
-        view_model::build_admission_view(self.status_strip(), tallies, &rows)
+        view_model::build_admission_view(self.status_strip(), &rows)
     }
 }
 
diff --git a/engine/src/engine/dashboard/view_model/admission.rs b/engine/src/engine/dashboard/view_model/admission.rs
index 8e875ed..dfea5cf 100644
--- a/engine/src/engine/dashboard/view_model/admission.rs
+++ b/engine/src/engine/dashboard/view_model/admission.rs
@@ -1,18 +1,21 @@
 //! Map the webhook's admission-decision log into the [`AdmissionViewProps`] the Admission view
-//! renders (brief §6 — the webhook floor): the [`DecisionTallies`] header (admitted/audited/denied,
-//! so a healthy view is never blank) + the deduped decision rows (signature/mesh/decision + the
-//! JEF-246 "if enforced" what-if). The per-gate shadow status (`verified` / `would-pass` /
-//! `would-fail`) is parsed into the presentation enum here so the components never see a raw status
-//! word. Data layer: touches `engine::`; the components never do.
+//! renders (brief §6 — the webhook floor): the tallies header (admitted/audited/denied, so a
+//! healthy view is never blank) + the per-image signing inventory (JEF-262) + the deduped decision
+//! rows (mesh/decision + the JEF-246 "if enforced" what-if). The mesh shadow status
+//! (`verified` / `would-pass` / `would-fail`) is parsed into the presentation enum here so the
+//! components never see a raw status word; the signature posture now lives in the signing inventory
+//! ([`signing_inventory`](super::signing_inventory)). Data layer: touches `engine::`; the
+//! components never do.
 
-use crate::engine::policy_log::{DecisionTallies, PolicyDecisionRecord};
+use crate::engine::policy_log::PolicyDecisionRecord;
 
 use super::props::{
     AdmissionDecision, AdmissionViewProps, DecisionRowProps, GateStatus, StatusStripProps,
 };
+use super::signing_inventory;
 
 /// Project one engine [`PolicyDecisionRecord`] into its presentation row. The coarse decision and
-/// per-gate status words are parsed into the presentation enums; the untrusted free-text fields
+/// mesh status words are parsed into the presentation enums; the untrusted free-text fields
 /// (subject / image / namespace / reason) pass through and are escaped by the component at render.
 fn decision_row(r: &PolicyDecisionRecord) -> DecisionRowProps {
     DecisionRowProps {
@@ -20,7 +23,6 @@ fn decision_row(r: &PolicyDecisionRecord) -> DecisionRowProps {
         subject: r.subject.clone(),
         image: r.image.clone(),
         namespace: r.namespace.clone(),
-        signature: GateStatus::parse(&r.signature),
         mesh: GateStatus::parse(&r.mesh),
         would_admit: r.would_admit,
         reason: r.reason.clone(),
@@ -28,22 +30,39 @@ fn decision_row(r: &PolicyDecisionRecord) -> DecisionRowProps {
     }
 }
 
-/// Build the whole Admission view's props from the webhook's decision tallies + the deduped row
-/// snapshot (newest-first) + the persistent strip the caller supplies. The tallies carry liveness
-/// even when the (deduped) row set is short, so a healthy cluster never renders blank. Pure given
-/// its inputs — driveable in tests with no engine.
-pub(super) fn build(
-    strip: StatusStripProps,
-    tallies: DecisionTallies,
-    rows: &[PolicyDecisionRecord],
-) -> AdmissionViewProps {
+/// Build the whole Admission view's props from the deduped decision-log snapshot (newest-first) +
+/// the persistent strip the caller supplies. The snapshot carries both the webhook's workload
+/// decision rows and the signing sweep's per-image observation rows (`Image/<ref>`); this splits
+/// them — the observation rows feed the signing inventory, the decision rows feed the tallies +
+/// decision log. The tallies are summed from the DECISION rows alone (summing the deduped counts
+/// equals the log's own tallies), so pure observation never inflates the admitted/audited/denied
+/// counts. Pure given its inputs — driveable in tests with no engine.
+pub(super) fn build(strip: StatusStripProps, rows: &[PolicyDecisionRecord]) -> AdmissionViewProps {
+    let signing = signing_inventory::build(rows);
+    let (mut admitted, mut audited, mut denied) = (0u64, 0u64, 0u64);
+    let mut decisions = Vec::new();
+    for r in rows
+        .iter()
+        .filter(|r| !signing_inventory::is_inventory_row(r))
+    {
+        let row = decision_row(r);
+        match row.decision {
+            AdmissionDecision::Allow => admitted += r.count,
+            AdmissionDecision::Audit => audited += r.count,
+            AdmissionDecision::Deny => denied += r.count,
+            AdmissionDecision::Other => {}
+        }
+        decisions.push(row);
+    }
+
     AdmissionViewProps {
         strip,
-        admitted: tallies.admitted,
-        audited: tallies.audited,
-        denied: tallies.denied,
-        total: tallies.total(),
-        rows: rows.iter().map(decision_row).collect(),
+        admitted,
+        audited,
+        denied,
+        total: admitted + audited + denied,
+        signing,
+        rows: decisions,
     }
 }
 
diff --git a/engine/src/engine/dashboard/view_model/admission/tests.rs b/engine/src/engine/dashboard/view_model/admission/tests.rs
index bd3bde9..a425cb6 100644
--- a/engine/src/engine/dashboard/view_model/admission/tests.rs
+++ b/engine/src/engine/dashboard/view_model/admission/tests.rs
@@ -1,6 +1,7 @@
-//! Tests for the Admission view_model mapping: the tallies → header counts, the deduped rows
-//! shaping, the shadow what-if (`verified` / `would-pass` / `would-fail`) parse, and the honest
-//! all-zero / empty-rows case.
+//! Tests for the Admission view_model mapping: the tallies (derived from the DECISION rows, so the
+//! signing sweep's observation rows never inflate them), the deduped rows shaping, the mesh
+//! shadow-status parse, and the honest all-zero / empty-rows case. The per-image signing inventory
+//! mapping is tested in `super::super::signing_inventory`.
 
 use super::*;
 use crate::engine::policy_log::PolicyDecisionRecord;
@@ -48,19 +49,68 @@ fn rec(
 }
 
 #[test]
-fn tallies_drive_the_header_counts() {
-    let tallies = DecisionTallies {
-        admitted: 12,
-        audited: 3,
-        denied: 1,
-    };
-    let v = build(strip(), tallies, &[]);
+fn tallies_are_summed_from_the_decision_rows() {
+    // The header counts are derived from the deduped DECISION rows' counts (summing them equals the
+    // log's own tallies), so a healthy view is never blank and observation rows don't inflate them.
+    let mut admits = rec(
+        "allow", "Pod/web", "img:1", "verified", "verified", "ns", "", true,
+    );
+    admits.count = 12;
+    let mut audits = rec(
+        "audit",
+        "Pod/legacy",
+        "img:2",
+        "would-fail",
+        "verified",
+        "ns",
+        "x",
+        false,
+    );
+    audits.count = 3;
+    let deny = rec(
+        "deny",
+        "Pod/dbg",
+        "img:3",
+        "would-pass",
+        "would-fail",
+        "ns",
+        "y",
+        false,
+    );
+    let v = build(strip(), &[admits, audits, deny]);
     assert_eq!(v.admitted, 12);
     assert_eq!(v.audited, 3);
     assert_eq!(v.denied, 1);
     assert_eq!(v.total, 16, "total sums every outcome");
 }
 
+#[test]
+fn observation_rows_feed_the_inventory_not_the_tallies() {
+    // A signing-sweep observation row (subject `Image/<ref>`, decision `allow`) belongs to the
+    // signing inventory and must NOT be counted as an admission admit.
+    let admit = rec(
+        "allow", "Pod/web", "img:1", "verified", "verified", "ns", "", true,
+    );
+    let observation = PolicyDecisionRecord::now(
+        "image-signature",
+        "allow",
+        "Image/ghcr.io/org/app:1",
+        "ghcr.io/org/app:1",
+        "not-signed",
+        "",
+        "",
+        "",
+    );
+    let v = build(strip(), &[admit, observation]);
+    assert_eq!(v.admitted, 1, "only the real admission decision is counted");
+    assert_eq!(v.rows.len(), 1, "the observation row is not a decision row");
+    assert_eq!(
+        v.signing.len(),
+        1,
+        "the observation row is in the inventory"
+    );
+}
+
 #[test]
 fn rows_carry_the_subject_image_namespace_and_count() {
     let rows = vec![rec(
@@ -73,7 +123,7 @@ fn rows_carry_the_subject_image_namespace_and_count() {
         "",
         true,
     )];
-    let v = build(strip(), DecisionTallies::default(), &rows);
+    let v = build(strip(), &rows);
     assert_eq!(v.rows.len(), 1);
     let row = &v.rows[0];
     assert_eq!(row.subject, "Pod/web");
@@ -84,7 +134,7 @@ fn rows_carry_the_subject_image_namespace_and_count() {
 }
 
 #[test]
-fn the_shadow_what_if_words_map_to_the_gate_states() {
+fn the_mesh_shadow_what_if_words_map_to_the_gate_states() {
     let rows = vec![
         rec(
             "deny",
@@ -93,7 +143,7 @@ fn the_shadow_what_if_words_map_to_the_gate_states() {
             "would-fail",
             "verified",
             "ns",
-            "unsigned image",
+            "r",
             false,
         ),
         rec(
@@ -103,28 +153,15 @@ fn the_shadow_what_if_words_map_to_the_gate_states() {
             "would-pass",
             "would-fail",
             "ns",
-            "not mesh-injected",
+            "r",
             false,
         ),
-        // An empty / unknown legacy status word reads as not-applicable, never a false pass.
+        // An empty / unknown legacy mesh word reads as not-applicable, never a false pass.
         rec("allow", "Pod/c", "img:c", "", "signed", "ns", "", true),
     ];
-    let v = build(strip(), DecisionTallies::default(), &rows);
-    assert_eq!(v.rows[0].signature, GateStatus::WouldFail);
+    let v = build(strip(), &rows);
     assert_eq!(v.rows[0].mesh, GateStatus::Verified);
-    assert!(
-        !v.rows[0].would_admit,
-        "a would-fail gate flips would_admit"
-    );
-
-    assert_eq!(v.rows[1].signature, GateStatus::WouldPass);
     assert_eq!(v.rows[1].mesh, GateStatus::WouldFail);
-
-    assert_eq!(
-        v.rows[2].signature,
-        GateStatus::NotApplicable,
-        "an empty status word is not-applicable"
-    );
     assert_eq!(
         v.rows[2].mesh,
         GateStatus::NotApplicable,
@@ -133,15 +170,15 @@ fn the_shadow_what_if_words_map_to_the_gate_states() {
 }
 
 #[test]
-fn empty_log_renders_zero_tallies_and_no_rows() {
-    // The honest-empty case: no admission decisions recorded. Counts are honest at zero (never
-    // blank) and there are no rows.
-    let v = build(strip(), DecisionTallies::default(), &[]);
+fn empty_log_renders_zero_tallies_no_rows_and_no_inventory() {
+    // The honest-empty case: no decisions recorded. Counts are honest at zero and there are no rows.
+    let v = build(strip(), &[]);
     assert_eq!(v.admitted, 0);
     assert_eq!(v.audited, 0);
     assert_eq!(v.denied, 0);
     assert_eq!(v.total, 0);
     assert!(v.rows.is_empty());
+    assert!(v.signing.is_empty());
 }
 
 #[test]
@@ -150,7 +187,7 @@ fn dedup_count_passes_through() {
         "allow", "Pod/web", "img:1", "verified", "verified", "ns", "", true,
     );
     r.count = 50;
-    let v = build(strip(), DecisionTallies::default(), &[r]);
+    let v = build(strip(), &[r]);
     assert_eq!(
         v.rows[0].count, 50,
         "the replica-churn dedup count is carried"
diff --git a/engine/src/engine/dashboard/view_model/mod.rs b/engine/src/engine/dashboard/view_model/mod.rs
index c025e29..71c416b 100644
--- a/engine/src/engine/dashboard/view_model/mod.rs
+++ b/engine/src/engine/dashboard/view_model/mod.rs
@@ -14,11 +14,12 @@ mod admission;
 mod findings;
 mod posture;
 mod readiness;
+mod signing_inventory;
 mod strip;
 
 use std::time::SystemTime;
 
-use crate::engine::policy_log::{DecisionTallies, PolicyDecisionRecord};
+use crate::engine::policy_log::PolicyDecisionRecord;
 use crate::engine::state::{Finding, Judgement, Readiness, Report, ReversionRecord};
 
 use props::{
@@ -112,12 +113,14 @@ pub fn build_action_view(
 }
 
 /// Build the whole Admission/policy (webhook floor) view's props (brief §6): the persistent strip +
-/// the decision tallies header (so a healthy view is never blank) + the deduped decision rows.
-/// Pure given its inputs.
+/// the decision tallies header (so a healthy view is never blank) + the per-image signing inventory
+/// (JEF-262) + the deduped decision rows. The tallies are derived from the webhook DECISION rows
+/// alone — the signing sweep's observation rows (`Image/<ref>`) feed the inventory, never the
+/// admitted/audited/denied counts — so pure observation can't inflate the decision totals. Pure
+/// given its inputs.
 pub fn build_admission_view(
     strip: StatusStripProps,
-    tallies: DecisionTallies,
     rows: &[PolicyDecisionRecord],
 ) -> AdmissionViewProps {
-    admission::build(strip, tallies, rows)
+    admission::build(strip, rows)
 }
diff --git a/engine/src/engine/dashboard/view_model/props.rs b/engine/src/engine/dashboard/view_model/props.rs
index ff9fb03..c851269 100644
--- a/engine/src/engine/dashboard/view_model/props.rs
+++ b/engine/src/engine/dashboard/view_model/props.rs
@@ -729,9 +729,8 @@ pub struct DecisionRowProps {
     pub image: String,
     /// The request's namespace, untrusted. Empty for a cluster-scoped object.
     pub namespace: String,
-    /// The signature gate's shadow status.
-    pub signature: GateStatus,
-    /// The mesh gate's shadow status.
+    /// The mesh gate's shadow status. (The signature posture now lives in the dedicated signing
+    /// inventory — JEF-262 — so the decision log no longer carries a signature *gate* column.)
     pub mesh: GateStatus,
     /// The "if enforced" net counterfactual (JEF-246): would this be admitted if every gate were
     /// enforced? Display-only — the honest API verdict is [`decision`](Self::decision).
@@ -755,6 +754,139 @@ pub struct AdmissionViewProps {
     pub denied: u64,
     /// Total decisions across all outcomes — drives the honest-empty state when zero.
     pub total: u64,
+    /// The per-image signing inventory (JEF-262 / ADR-0020), grouped under its repo — the
+    /// observed signing posture of every image, sitting between the tallies header and the
+    /// decision log. Empty renders an honest "no images observed yet" (never an all-clear).
+    pub signing: Vec<SigningRepoProps>,
     /// The deduped decision rows, newest-first.
     pub rows: Vec<DecisionRowProps>,
 }
+
+// ---------------------------------------------------------------------------
+// Signing inventory (JEF-262 / ADR-0020 Stage 1 render) — the observed signing
+// posture of EVERY image, as a dedicated inventory section. Two hard operator
+// rules: the posture is ALWAYS signed / invalid signature / not signed (or the
+// transient checking) — never n/a; and the "if enforced" column is ALWAYS the
+// binary would-admit / would-block — never n/a.
+// ---------------------------------------------------------------------------
+
+/// An image's observed signing posture — the presentation mirror of the domain
+/// `signature::posture::SigningPosture` (mapped at the view_model boundary so components never
+/// import the domain type). NEVER n/a: observation always reaches a posture, and a registry blip
+/// is the explicit transient [`Checking`](Self::Checking), not a fabricated clean. Carried as
+/// colour + glyph + word so meaning never rides on colour alone. [`Invalid`](Self::Invalid) is the
+/// LOUD channel — visually and lexically distinct from a calm [`NotSigned`](Self::NotSigned).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SigningPosture {
+    /// A signature is present and verifies (the signer rides [`SigningRowProps::signer`]).
+    Signed,
+    /// A signature artifact is present but does NOT verify — the loud, alarming case. Distinct
+    /// from (and more alarming than) [`NotSigned`](Self::NotSigned).
+    Invalid,
+    /// No signature at all — calm (no baseline yet), never loud, but never a green pass either.
+    NotSigned,
+    /// Transient: the registry / transparency log was unreachable, so the posture is not yet
+    /// known. Never read as clean; resolves into a resting posture on a later pass.
+    Checking,
+}
+
+impl SigningPosture {
+    /// Parse the engine's low-cardinality status word (`SigningPosture::status()`) into the
+    /// presentation enum. An unknown / empty word reads as the transient
+    /// [`Checking`](Self::Checking) rather than a fabricated resting posture — never a false clean.
+    pub fn parse(word: &str) -> SigningPosture {
+        match word {
+            "signed" => SigningPosture::Signed,
+            "invalid-signature" => SigningPosture::Invalid,
+            "not-signed" => SigningPosture::NotSigned,
+            _ => SigningPosture::Checking,
+        }
+    }
+
+    /// The CSS token suffix (`--sign-{kind}`) for this posture.
+    pub fn token(self) -> &'static str {
+        match self {
+            SigningPosture::Signed => "signed",
+            SigningPosture::Invalid => "invalid",
+            SigningPosture::NotSigned => "notsigned",
+            SigningPosture::Checking => "checking",
+        }
+    }
+
+    /// The glyph carrying the posture without colour — each distinct so `invalid` reads apart from
+    /// `not signed` and `signed` even in greyscale.
+    pub fn glyph(self) -> &'static str {
+        match self {
+            SigningPosture::Signed => "\u{2713}",    // ✓ present + verified
+            SigningPosture::Invalid => "\u{2715}",   // ✕ present but broken — the loud channel
+            SigningPosture::NotSigned => "\u{25CB}", // ○ open — nothing there, calm
+            SigningPosture::Checking => "\u{25CC}",  // ◌ dotted — transient
+        }
+    }
+
+    /// The word — always present alongside colour + glyph, and lexically distinct per state.
+    pub fn word(self) -> &'static str {
+        match self {
+            SigningPosture::Signed => "signed",
+            SigningPosture::Invalid => "invalid signature",
+            SigningPosture::NotSigned => "not signed",
+            SigningPosture::Checking => "checking\u{2026}",
+        }
+    }
+
+    /// The binary "if enforced" counterfactual: only a verifying [`Signed`](Self::Signed) image
+    /// would be admitted by a signature gate; every other posture (invalid / not signed / the
+    /// unverifiable transient) would be blocked. Fail-closed — never n/a (operator rule #2).
+    pub fn would_admit(self) -> bool {
+        matches!(self, SigningPosture::Signed)
+    }
+}
+
+/// The signer learned from a verified Fulcio cert (only present when [`SigningPosture::Signed`]).
+/// Both the identity and issuer are UNTRUSTED third-party free-text (an attacker-influenceable cert
+/// subject) — the component escapes them at render (maud auto-escape; NEVER `PreEscaped`).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SignerProps {
+    /// A short, scannable label derived from the Fulcio SAN (a GitHub Actions workflow URI →
+    /// `org/repo`; an email kept as-is; otherwise the raw identity, truncated in-row by CSS). Shown
+    /// in the row.
+    pub identity_short: String,
+    /// The full Fulcio SAN — shown in the expand panel and the `title=`, so the truncated in-row
+    /// label never hides the real signer.
+    pub identity_full: String,
+    /// A short issuer badge derived from the OIDC issuer (`github actions` / `google` / `sigstore`
+    /// / the host), or empty when the cert carried no issuer.
+    pub issuer_badge: String,
+    /// The full OIDC issuer URL for the expand panel, or `None` when the cert carried none.
+    pub issuer_full: Option<String>,
+}
+
+/// One image row in the signing inventory (JEF-262). Plain presentation data only — mapped from the
+/// engine `PolicyDecisionRecord` at the view_model boundary. Every string is UNTRUSTED at render.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SigningRowProps {
+    /// The full image ref (registry/repo + digest/tag), untrusted — shown in the expand panel and
+    /// the `title=`.
+    pub image: String,
+    /// The in-row image label: the digest/tag remainder under the repo group (falls back to the
+    /// full ref when the image carries no tag/digest), untrusted.
+    pub label: String,
+    pub posture: SigningPosture,
+    /// The signer, present only when [`posture`](Self::posture) is [`SigningPosture::Signed`].
+    pub signer: Option<SignerProps>,
+    /// The human-facing posture prose for the expand panel (why invalid / still checking); empty
+    /// for a plain not-signed, which needs no prose. Untrusted.
+    pub detail: String,
+    /// How many times this exact image was observed (the dedup count).
+    pub count: u64,
+}
+
+/// A repo group in the signing inventory: one registry/repo header with the images observed under
+/// it (JEF-262 — the inventory unit is the image, grouped under its repo).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SigningRepoProps {
+    /// The registry/repo the images share (the group header), untrusted.
+    pub repo: String,
+    /// The images observed under this repo.
+    pub images: Vec<SigningRowProps>,
+}
diff --git a/engine/src/engine/dashboard/view_model/signing_inventory.rs b/engine/src/engine/dashboard/view_model/signing_inventory.rs
new file mode 100644
index 0000000..eddfefc
--- /dev/null
+++ b/engine/src/engine/dashboard/view_model/signing_inventory.rs
@@ -0,0 +1,151 @@
+//! Map the signing-sweep rows on the admission-decision log into the per-image signing inventory
+//! the Admission view renders (JEF-262 / ADR-0020 Stage 1 render). The sweep (JEF-261) records
+//! each observed image as an `image-signature` row keyed `Image/<ref>`, with the posture in the
+//! record's `signature` status word (`signed` / `invalid-signature` / `not-signed` / `checking`)
+//! and, for a signed image, the signer prose in `reason` (`signed by <identity>[ via <issuer>]`).
+//!
+//! This layer partitions those observation rows out of the webhook's decision rows, derives a
+//! short scannable signer label + issuer badge from the (untrusted) Fulcio SAN, splits each image
+//! into its repo + digest/tag, and groups the images under their repo. It NEVER changes how the
+//! posture is produced (the producer is JEF-261's sweep); it only shapes it for rendering. Two hard
+//! operator rules are encoded here: the posture is always one of the four states — never n/a — and
+//! the "if enforced" binary is derived from the posture (only a verifying signature would admit).
+//! Data layer: touches `engine::`; the components never do.
+
+use crate::engine::policy_log::PolicyDecisionRecord;
+
+use super::props::{SignerProps, SigningPosture, SigningRepoProps, SigningRowProps};
+
+/// The subject prefix the signing sweep keys its rows under (`Image/<ref>`). A row whose subject
+/// starts with this is an observation row for the inventory, distinct from the webhook's workload
+/// decision rows (`Pod/…`, `Deployment/…`).
+const IMAGE_SUBJECT_PREFIX: &str = "Image/";
+
+/// Whether a decision-log record is a signing-inventory observation row (vs a webhook decision).
+pub(super) fn is_inventory_row(r: &PolicyDecisionRecord) -> bool {
+    r.subject.starts_with(IMAGE_SUBJECT_PREFIX)
+}
+
+/// Split an image ref into `(repo, remainder)`: the digest form `repo@sha256:…` splits at the `@`;
+/// the tag form `repo:tag` splits at the `:` in the LAST path segment (so a registry port —
+/// `registry:5000/org/app` — is never mistaken for a tag). A bare ref with neither has an empty
+/// remainder.
+fn split_ref(image: &str) -> (&str, &str) {
+    if let Some((repo, digest)) = image.split_once('@') {
+        return (repo, digest);
+    }
+    let last_segment = image.rfind('/').map(|i| i + 1).unwrap_or(0);
+    if let Some(colon) = image[last_segment..].find(':') {
+        let at = last_segment + colon;
+        return (&image[..at], &image[at + 1..]);
+    }
+    (image, "")
+}
+
+/// Parse the sweep's signer prose (`signed by <identity>[ via <issuer>]`) into
+/// `(identity, issuer)`. Returns `None` when the prose isn't a signer line (a non-signed posture),
+/// so a malformed / unexpected reason never fabricates a signer.
+fn parse_signer_reason(reason: &str) -> Option<(&str, Option<&str>)> {
+    let rest = reason.strip_prefix("signed by ")?;
+    match rest.split_once(" via ") {
+        Some((identity, issuer)) => Some((identity, Some(issuer))),
+        None => Some((rest, None)),
+    }
+}
+
+/// Derive a short, scannable label from a Fulcio SAN. A GitHub Actions keyless workflow URI
+/// (`https://github.com/org/repo/.github/workflows/…@ref`) collapses to `org/repo`; anything else
+/// (an email, another host) is kept verbatim and truncated in-row by CSS. The full SAN is always
+/// preserved separately for the expand panel + `title=`.
+fn short_identity(identity: &str) -> String {
+    if let Some(rest) = identity.strip_prefix("https://github.com/") {
+        let repo_path = rest.split("/.github/").next().unwrap_or(rest);
+        let mut segments = repo_path.split('/');
+        if let (Some(org), Some(repo)) = (segments.next(), segments.next())
+            && !org.is_empty()
+            && !repo.is_empty()
+        {
+            return format!("{org}/{repo}");
+        }
+    }
+    identity.to_string()
+}
+
+/// Derive a short issuer badge from the OIDC issuer URL — the recognised public-good issuers get a
+/// friendly word; anything else falls back to the bare host (or the raw value). Empty issuer ⇒
+/// empty badge.
+fn issuer_badge(issuer: &str) -> String {
+    let host = issuer
+        .strip_prefix("https://")
+        .or_else(|| issuer.strip_prefix("http://"))
+        .unwrap_or(issuer)
+        .split('/')
+        .next()
+        .unwrap_or(issuer);
+    match host {
+        "token.actions.githubusercontent.com" => "github actions".to_string(),
+        "accounts.google.com" => "google".to_string(),
+        "oauth2.sigstore.dev" => "sigstore".to_string(),
+        "" => String::new(),
+        other => other.to_string(),
+    }
+}
+
+/// Build the signer props for a signed image from the sweep's `reason` prose, or `None` when the
+/// reason carries no signer line.
+fn signer_from_reason(reason: &str) -> Option<SignerProps> {
+    let (identity, issuer) = parse_signer_reason(reason)?;
+    Some(SignerProps {
+        identity_short: short_identity(identity),
+        identity_full: identity.to_string(),
+        issuer_badge: issuer.map(issuer_badge).unwrap_or_default(),
+        issuer_full: issuer.map(|s| s.to_string()),
+    })
+}
+
+/// Project one observation record into its inventory row. The posture always resolves to one of the
+/// four states (never n/a); the signer is attached only for a verifying signature.
+fn signing_row(r: &PolicyDecisionRecord) -> SigningRowProps {
+    let posture = SigningPosture::parse(&r.signature);
+    let (_, remainder) = split_ref(&r.image);
+    let signer = if posture == SigningPosture::Signed {
+        signer_from_reason(&r.reason)
+    } else {
+        None
+    };
+    SigningRowProps {
+        image: r.image.clone(),
+        label: if remainder.is_empty() {
+            r.image.clone()
+        } else {
+            remainder.to_string()
+        },
+        posture,
+        signer,
+        detail: r.reason.clone(),
+        count: r.count,
+    }
+}
+
+/// Build the signing inventory from the admission-decision log's observation rows (those keyed
+/// `Image/<ref>`), grouped under their repo. Repo groups preserve first-seen order (the caller
+/// passes newest-first rows), so a steady inventory renders stably. The webhook's workload decision
+/// rows are ignored here — they drive the decision log, not the inventory.
+pub(super) fn build(rows: &[PolicyDecisionRecord]) -> Vec<SigningRepoProps> {
+    let mut groups: Vec<SigningRepoProps> = Vec::new();
+    for record in rows.iter().filter(|r| is_inventory_row(r)) {
+        let (repo, _) = split_ref(&record.image);
+        let row = signing_row(record);
+        match groups.iter_mut().find(|g| g.repo == repo) {
+            Some(group) => group.images.push(row),
+            None => groups.push(SigningRepoProps {
+                repo: repo.to_string(),
+                images: vec![row],
+            }),
+        }
+    }
+    groups
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/engine/src/engine/dashboard/view_model/signing_inventory/tests.rs b/engine/src/engine/dashboard/view_model/signing_inventory/tests.rs
new file mode 100644
index 0000000..903b809
--- /dev/null
+++ b/engine/src/engine/dashboard/view_model/signing_inventory/tests.rs
@@ -0,0 +1,226 @@
+//! Tests for the signing-inventory mapping (JEF-262): the sweep's `Image/<ref>` rows partitioned
+//! out of the decision log, each posture resolved to one of the four states (never n/a), the signer
+//! label + issuer badge derived from the (untrusted) Fulcio SAN, the image split into repo +
+//! digest/tag, and the images grouped under their repo. Escaping of the untrusted identity is a
+//! render concern, tested in the Admission render tests.
+
+use super::*;
+use crate::engine::policy_log::PolicyDecisionRecord;
+
+/// A signing-sweep observation row, exactly as `engine::signing_sweep` records it: `image-signature`
+/// policy, `Image/<ref>` subject, the posture in the `signature` word + the signer prose in `reason`.
+fn observed(image: &str, status: &str, reason: &str) -> PolicyDecisionRecord {
+    PolicyDecisionRecord::now(
+        "image-signature",
+        "allow",
+        format!("Image/{image}"),
+        image,
+        status,
+        "",
+        "",
+        reason,
+    )
+}
+
+/// A webhook workload decision row (NOT an inventory row) — used to prove partitioning.
+fn workload_decision(subject: &str, image: &str) -> PolicyDecisionRecord {
+    PolicyDecisionRecord::now(
+        "admission",
+        "allow",
+        subject,
+        image,
+        "verified",
+        "verified",
+        "ns",
+        "",
+    )
+}
+
+#[test]
+fn signed_github_actions_identity_collapses_to_org_repo_with_a_badge() {
+    let rows = vec![observed(
+        "ghcr.io/acme/app@sha256:abc",
+        "signed",
+        "signed by https://github.com/acme/app/.github/workflows/release.yaml@refs/tags/v1 \
+         via https://token.actions.githubusercontent.com",
+    )];
+    let groups = build(&rows);
+    let row = &groups[0].images[0];
+    assert_eq!(row.posture, SigningPosture::Signed);
+    let signer = row
+        .signer
+        .as_ref()
+        .expect("a signed image carries a signer");
+    assert_eq!(signer.identity_short, "acme/app", "GitHub SAN → org/repo");
+    assert_eq!(signer.issuer_badge, "github actions");
+    assert_eq!(
+        signer.identity_full,
+        "https://github.com/acme/app/.github/workflows/release.yaml@refs/tags/v1",
+        "the full SAN is preserved for the expand panel + title"
+    );
+    assert_eq!(
+        signer.issuer_full.as_deref(),
+        Some("https://token.actions.githubusercontent.com")
+    );
+}
+
+#[test]
+fn signed_email_identity_is_kept_verbatim_with_the_issuer_badge() {
+    let rows = vec![observed(
+        "ghcr.io/acme/export:3.0.0",
+        "signed",
+        "signed by releng@acme.example via https://accounts.google.com",
+    )];
+    let groups = build(&rows);
+    let signer = groups[0].images[0].signer.as_ref().unwrap();
+    assert_eq!(signer.identity_short, "releng@acme.example");
+    assert_eq!(signer.issuer_badge, "google");
+}
+
+#[test]
+fn signed_without_an_issuer_has_an_empty_badge_and_no_issuer_url() {
+    let rows = vec![observed(
+        "ghcr.io/acme/app:1",
+        "signed",
+        "signed by https://github.com/acme/app/.github/workflows/r.yaml@refs/heads/main",
+    )];
+    let signer = build(&rows)[0].images[0].signer.clone().unwrap();
+    assert_eq!(signer.identity_short, "acme/app");
+    assert!(signer.issuer_badge.is_empty());
+    assert!(signer.issuer_full.is_none());
+}
+
+#[test]
+fn invalid_posture_maps_and_would_block() {
+    let rows = vec![observed(
+        "docker.io/library/storefront:latest",
+        "invalid-signature",
+        "signature present but does not verify (untrusted/tampered chain)",
+    )];
+    let row = &build(&rows)[0].images[0];
+    assert_eq!(row.posture, SigningPosture::Invalid);
+    assert!(
+        row.signer.is_none(),
+        "an invalid signature has no trusted signer"
+    );
+    assert!(
+        !row.posture.would_admit(),
+        "invalid would block if enforced"
+    );
+    assert!(
+        !row.detail.is_empty(),
+        "the invalid prose is carried for the expand panel"
+    );
+}
+
+#[test]
+fn not_signed_posture_maps_is_calm_and_would_block() {
+    let rows = vec![observed("docker.io/library/postgres:16", "not-signed", "")];
+    let row = &build(&rows)[0].images[0];
+    assert_eq!(row.posture, SigningPosture::NotSigned);
+    assert!(row.signer.is_none());
+    assert!(
+        !row.posture.would_admit(),
+        "not signed would block if enforced"
+    );
+    assert!(row.detail.is_empty(), "not-signed needs no prose");
+}
+
+#[test]
+fn checking_is_transient_never_a_resting_clean() {
+    let rows = vec![observed(
+        "registry.k8s.io/pause:3.9",
+        "checking",
+        "signing posture not yet known (registry/log unreachable)",
+    )];
+    let row = &build(&rows)[0].images[0];
+    assert_eq!(row.posture, SigningPosture::Checking);
+    assert!(
+        !row.posture.would_admit(),
+        "an unverifiable posture is fail-closed (would block), never admitted"
+    );
+}
+
+#[test]
+fn an_unknown_status_word_reads_as_checking_never_a_false_clean() {
+    // Defensive: any word that isn't one of the three resting states is the transient checking,
+    // never a fabricated resting posture (and never n/a).
+    let rows = vec![observed("ghcr.io/acme/mystery:1", "n/a", "")];
+    assert_eq!(build(&rows)[0].images[0].posture, SigningPosture::Checking);
+}
+
+#[test]
+fn only_signed_would_admit() {
+    assert!(SigningPosture::Signed.would_admit());
+    assert!(!SigningPosture::Invalid.would_admit());
+    assert!(!SigningPosture::NotSigned.would_admit());
+    assert!(!SigningPosture::Checking.would_admit());
+}
+
+#[test]
+fn images_are_grouped_under_their_repo() {
+    let rows = vec![
+        observed("ghcr.io/acme/app@sha256:aa", "not-signed", ""),
+        observed("ghcr.io/acme/app@sha256:bb", "signed", "signed by x via y"),
+        observed("docker.io/library/postgres:16", "not-signed", ""),
+    ];
+    let groups = build(&rows);
+    assert_eq!(groups.len(), 2, "two distinct repos");
+    let acme = groups
+        .iter()
+        .find(|g| g.repo == "ghcr.io/acme/app")
+        .unwrap();
+    assert_eq!(acme.images.len(), 2, "both digests fold under the one repo");
+    let pg = groups
+        .iter()
+        .find(|g| g.repo == "docker.io/library/postgres")
+        .unwrap();
+    assert_eq!(pg.images.len(), 1);
+}
+
+#[test]
+fn digest_and_tag_and_port_refs_split_correctly() {
+    // digest form: repo@sha256:… → the digest is the in-row label.
+    let digest = build(&[observed("ghcr.io/acme/app@sha256:abc", "not-signed", "")]);
+    assert_eq!(digest[0].repo, "ghcr.io/acme/app");
+    assert_eq!(digest[0].images[0].label, "sha256:abc");
+    // tag form: repo:tag.
+    let tag = build(&[observed("docker.io/library/postgres:16", "not-signed", "")]);
+    assert_eq!(tag[0].repo, "docker.io/library/postgres");
+    assert_eq!(tag[0].images[0].label, "16");
+    // a registry PORT is not a tag — the repo keeps its `:5000`.
+    let port = build(&[observed("registry:5000/team/app:2", "not-signed", "")]);
+    assert_eq!(port[0].repo, "registry:5000/team/app");
+    assert_eq!(port[0].images[0].label, "2");
+    // a bare ref with no tag/digest falls back to the full ref as the label.
+    let bare = build(&[observed("busybox", "not-signed", "")]);
+    assert_eq!(bare[0].repo, "busybox");
+    assert_eq!(bare[0].images[0].label, "busybox");
+}
+
+#[test]
+fn webhook_decision_rows_are_not_in_the_inventory() {
+    let rows = vec![
+        workload_decision("Pod/web", "ghcr.io/acme/app:1"),
+        observed("ghcr.io/acme/app:1", "signed", "signed by x via y"),
+    ];
+    let groups = build(&rows);
+    assert_eq!(
+        groups.len(),
+        1,
+        "only the Image/<ref> observation row is inventoried"
+    );
+    assert_eq!(groups[0].images.len(), 1);
+}
+
+#[test]
+fn empty_input_is_an_empty_inventory() {
+    assert!(build(&[]).is_empty());
+}
+
+#[test]
+fn dedup_count_is_carried() {
+    let mut r = observed("ghcr.io/acme/app:1", "not-signed", "");
+    r.count = 7;
+    assert_eq!(build(&[r])[0].images[0].count, 7);
+}
diff --git a/engine/web/dist/dashboard.css b/engine/web/dist/dashboard.css
index a71baee..a5529af 100644
--- a/engine/web/dist/dashboard.css
+++ b/engine/web/dist/dashboard.css
@@ -811,14 +811,15 @@ summary:focus-visible,
 .tally-denied { color: var(--posture-breach); }
 .tally-total { color: var(--ink-3); }
 
-/* the deduped decision rows, a real table so the machine columns align (keyboard/semantics gate). */
-.decisions {
+/* the deduped decision rows + the signing inventory, real tables so the machine columns align
+   (keyboard/semantics gate). */
+.decisions, .signing {
   width: 100%;
   border-collapse: collapse;
   background: var(--surface);
   border: var(--hairline) solid var(--border);
 }
-.decisions thead th {
+.decisions thead th, .signing thead th {
   text-align: left;
   font-size: var(--fs-micro); line-height: var(--lh-micro);
   font-weight: var(--fw-micro); letter-spacing: var(--track-micro);
@@ -828,7 +829,7 @@ summary:focus-visible,
   border-bottom: var(--hairline) solid var(--border);
   white-space: nowrap;
 }
-.decisions tbody td {
+.decisions tbody td, .signing tbody td {
   padding: var(--space-2) var(--space-3);
   border-bottom: var(--hairline) solid var(--border);
   vertical-align: top;
@@ -875,3 +876,46 @@ summary:focus-visible,
 .gate-na { color: var(--ink-3); }
 .enforced-admit { color: var(--cov-present); }
 .enforced-deny { color: var(--posture-breach); }
+.enforced-block { color: var(--posture-breach); }
+
+/* ---- signing inventory (JEF-262 / ADR-0020): the observed per-image signing posture, grouped
+   under its repo, sitting between the tallies header and the decision log. Posture is always
+   signed / invalid signature / not signed (or the transient checking) — never n/a; the "if
+   enforced" cell is always the binary would-admit / would-block. ---- */
+.view > .signing-inventory { margin-bottom: var(--section-gap); }
+.signing-repo { margin-top: var(--space-4); }
+.signing-repo-h {
+  color: var(--ink-1); font-family: var(--font-data);
+  margin: 0 0 var(--space-1);
+}
+.signing-row:hover { background: var(--surface-hover); }
+/* an invalid signature is the loud attention case — a breach keyline (calm not-signed gets none). */
+.signing-row-attention td.cell-image {
+  border-left: var(--rail-strong) solid var(--posture-breach);
+}
+.cell-image { min-width: 0; }
+/* the ref + signer line truncate to a single line with an ellipsis (never word-break) so the table
+   stays scannable; the full ref/identity lives in the expand panel + title=. */
+.signing-ref {
+  display: inline-block; max-width: 48ch;
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  vertical-align: bottom;
+  color: var(--ink-1); font-family: var(--font-data);
+}
+.signing-by {
+  display: block; max-width: 60ch;
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}
+.issuer-badge { color: var(--ink-2); }
+.signing-count { margin-left: var(--space-1); }
+.signing-detail[open] > .why-toggle::before { content: "\25BE "; }
+.signing-detail-body { padding: var(--space-2) 0; }
+.signing-detail-body p { margin: var(--space-1) 0; color: var(--ink-2); }
+
+/* the signing-posture chip colours: signed is the calm cleared green; invalid is the loud breach
+   channel; not signed is calm/muted (no baseline); checking is the transient ochre. Each pairs with
+   a distinct glyph + word (meaning never by colour alone). */
+.sign-signed { color: var(--cov-present); }
+.sign-invalid { color: var(--posture-breach); }
+.sign-notsigned { color: var(--ink-3); }
+.sign-checking { color: var(--posture-awaiting); }