diff --git a/crates/ogar-render-askama/src/artifact_kinds/html_detail_view.rs b/crates/ogar-render-askama/src/artifact_kinds/html_detail_view.rs
new file mode 100644
index 0000000..e13147a
--- /dev/null
+++ b/crates/ogar-render-askama/src/artifact_kinds/html_detail_view.rs
@@ -0,0 +1,210 @@
+//! `HtmlDetailView` emitter — T3 per Northstar plan §3, the detail-page
+//! sibling of T2's [`html_list_view`](super::html_list_view).
+//!
+//! Reuses every piece T2 built (`RenderColumn`, `ColumnKind`, the cell
+//! sub-templates from [`super::cells`], the two-stage cells-pre-rendered-
+//! in-Rust pattern). The difference is the spine: a `<dl>` of inline
+//! fields + `<section>` blocks for prose / family-edge collections,
+//! instead of a `<table>` of rows.
+//!
+//! Mirror of Redmine's `app/views/issues/show.html.erb` shape — same
+//! field-by-field laydown, with the family-edge sections (subtasks,
+//! relations, attachments, watchers, journals) as sibling `<section>`s.
+
+use askama::Template;
+
+use super::cells::{
+    AttachmentEntry, AttachmentListCell, HoursCell, IdLinkCell, PlainCell, PrimaryLinkCell,
+    ProgressBarCell, RecordRefCell, RelationEntry, RelationListCell, RichTextCell, UserEntry,
+    UserListCell,
+};
+use super::html_list_view::{CellData, CellSource};
+use super::ArtifactEmitter;
+use crate::list_view::{ColumnKind, RenderColumn};
+use crate::spec::ArtifactSpec;
+use ogar_vocab::canonical_concept_id;
+
+// ── Spine binding struct ─────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/html_detail_view.askama", escape = "html")]
+struct HtmlDetailViewCtx {
+    class_id_hex: String,
+    canonical_concept: String,
+    record_id: u64,
+    /// Pre-rendered headline (typically the primary-link or plain-text
+    /// for the record's primary attribute). Empty means no headline.
+    headline_html: String,
+    /// Optional subtitle line (e.g. status + priority badges); empty
+    /// for none.
+    subtitle: String,
+    inline_cells: Vec<DetailField>,
+    block_sections: Vec<DetailSection>,
+}
+
+struct DetailField {
+    name: String,
+    label: String,
+    css_classes: String,
+    body_html: String,
+}
+
+struct DetailSection {
+    name: String,
+    label: String,
+    css_classes: String,
+    body_html: String,
+}
+
+// ── Public entry point ──────────────────────────────────────────────
+
+/// Render one canonical record as a detail page (definition-list inline
+/// fields + section blocks for prose + family-edge collections).
+///
+/// `columns` carries both `inline=true` (laid out as `<dt>/<dd>`) and
+/// `inline=false` (rendered as full-width `<section>`s). The classifier
+/// is done at render time from `column.inline`.
+///
+/// `cells` is one entry per column in the same order — paired by index.
+/// `headline_html` is the (already-rendered) primary-link / plain text
+/// the page header shows; empty string for none.
+#[allow(clippy::too_many_arguments)]
+pub fn render_detail(
+    class_id: u16,
+    canonical_concept: &str,
+    record_id: u64,
+    headline_html: &str,
+    subtitle: &str,
+    columns: &[RenderColumn],
+    cells: &[CellSource<'_>],
+) -> Result<String, askama::Error> {
+    if columns.len() != cells.len() {
+        // Hard caller-side bug; surface it loudly. Tests pin this contract.
+        return Err(askama::Error::from(std::fmt::Error));
+    }
+
+    let mut inline_cells = Vec::new();
+    let mut block_sections = Vec::new();
+    for (col, src) in columns.iter().zip(cells.iter()) {
+        let body = render_cell_body(src)?;
+        if col.inline {
+            inline_cells.push(DetailField {
+                name: col.name.clone(),
+                label: col.caption.clone(),
+                css_classes: src.css_classes.to_string(),
+                body_html: body,
+            });
+        } else {
+            block_sections.push(DetailSection {
+                name: col.name.clone(),
+                label: col.caption.clone(),
+                css_classes: src.css_classes.to_string(),
+                body_html: body,
+            });
+        }
+    }
+
+    HtmlDetailViewCtx {
+        class_id_hex: format!("0x{class_id:04X}"),
+        canonical_concept: canonical_concept.to_string(),
+        record_id,
+        headline_html: headline_html.to_string(),
+        subtitle: subtitle.to_string(),
+        inline_cells,
+        block_sections,
+    }
+    .render()
+}
+
+/// Same per-kind dispatch as the list view (kept duplicated here rather
+/// than re-exported because the list-view side has crate-internal naming;
+/// once T3 + T4 stabilise we factor the dispatch into one helper).
+fn render_cell_body(src: &CellSource<'_>) -> Result<String, askama::Error> {
+    Ok(match &src.data {
+        CellData::Plain { value } => PlainCell { value }.render()?,
+        CellData::IdLink { id, href } => IdLinkCell { id: *id, href }.render()?,
+        CellData::PrimaryLink { label, href } => PrimaryLinkCell { label, href }.render()?,
+        CellData::RecordRef { label, href, target_concept } => RecordRefCell {
+            label,
+            href,
+            target_concept,
+        }
+        .render()?,
+        CellData::RichText { body } => RichTextCell { body }.render()?,
+        CellData::ProgressBar { pct } => ProgressBarCell { pct: *pct }.render()?,
+        CellData::RelationList { relations } => {
+            let mapped: Vec<RelationEntry<'_>> = relations
+                .iter()
+                .map(|r| RelationEntry { id: r.id, kind: r.kind.as_str(), href: r.href.as_str() })
+                .collect();
+            RelationListCell { relations: mapped }.render()?
+        }
+        CellData::Hours { hours, href } => HoursCell { hours, href }.render()?,
+        CellData::AttachmentList { attachments } => {
+            let mapped: Vec<AttachmentEntry<'_>> = attachments
+                .iter()
+                .map(|a| AttachmentEntry { filename: a.filename.as_str(), href: a.href.as_str() })
+                .collect();
+            AttachmentListCell { attachments: mapped }.render()?
+        }
+        CellData::UserList { users } => {
+            let mapped: Vec<UserEntry<'_>> = users
+                .iter()
+                .map(|u| UserEntry { name: u.name.as_str(), href: u.href.as_str() })
+                .collect();
+            UserListCell { users: mapped }.render()?
+        }
+    })
+}
+
+/// The codebook-only dispatch entry point used by [`for_kind`](super::for_kind).
+/// Synthesises a no-data detail page from the class's attributes (proof
+/// of shape); real callers use [`render_detail`] with real cell data.
+pub struct HtmlDetailViewEmitter;
+
+impl ArtifactEmitter for HtmlDetailViewEmitter {
+    fn emit(&self, spec: &ArtifactSpec<'_>) -> Result<String, askama::Error> {
+        use crate::list_view::default_kind_for;
+        let class = spec.class;
+        let concept = class.canonical_concept.as_deref().unwrap_or("");
+        let class_id = canonical_concept_id(concept).unwrap_or(0);
+
+        // Synthesise columns from the class's attributes.
+        let columns: Vec<RenderColumn> = class
+            .attributes
+            .iter()
+            .map(|attr| {
+                let kind = default_kind_for(&attr.name, attr.type_name.as_deref());
+                let col = RenderColumn::new(&attr.name, &attr.name, kind);
+                if matches!(kind, ColumnKind::RichText) {
+                    col.block()
+                } else {
+                    col
+                }
+            })
+            .collect();
+
+        // Placeholder values, kept alive across the render. One per column.
+        let placeholders: Vec<String> = columns.iter().map(|_| "—".to_string()).collect();
+
+        // Pair columns with placeholder cells.
+        let cells: Vec<CellSource<'_>> = columns
+            .iter()
+            .zip(placeholders.iter())
+            .map(|(col, p)| {
+                let data = if matches!(col.kind, ColumnKind::RichText) {
+                    CellData::RichText { body: p.as_str() }
+                } else {
+                    CellData::Plain { value: p.as_str() }
+                };
+                CellSource {
+                    column: col,
+                    css_classes: "muted",
+                    data,
+                }
+            })
+            .collect();
+
+        render_detail(class_id, concept, 0, "", "", &columns, &cells)
+    }
+}
diff --git a/crates/ogar-render-askama/src/artifact_kinds/html_list_view.rs b/crates/ogar-render-askama/src/artifact_kinds/html_list_view.rs
index e4b6d9f..7342600 100644
--- a/crates/ogar-render-askama/src/artifact_kinds/html_list_view.rs
+++ b/crates/ogar-render-askama/src/artifact_kinds/html_list_view.rs
@@ -30,7 +30,7 @@ use ogar_vocab::canonical_concept_id;
 // ── Spine binding struct ─────────────────────────────────────────────
 
 #[derive(Template)]
-#[template(path = "dispatch/html_list_view.askama", escape = "none")]
+#[template(path = "dispatch/html_list_view.askama", escape = "html")]
 struct HtmlListViewCtx {
     title: String,
     class_id_hex: String,
diff --git a/crates/ogar-render-askama/src/artifact_kinds/mod.rs b/crates/ogar-render-askama/src/artifact_kinds/mod.rs
index f9739cb..41a5db8 100644
--- a/crates/ogar-render-askama/src/artifact_kinds/mod.rs
+++ b/crates/ogar-render-askama/src/artifact_kinds/mod.rs
@@ -24,10 +24,12 @@ pub(crate) mod cells;
 
 use crate::spec::{ArtifactKind, ArtifactSpec};
 
+pub mod html_detail_view;
 pub mod html_list_view;
 pub mod rust_struct;
 pub mod stub;
 
+pub use html_detail_view::{render_detail, HtmlDetailViewEmitter};
 pub use html_list_view::{
     render_list, AttachmentEntryOwned, CellData, CellSource, GroupHeader, HtmlListViewEmitter,
     RelationEntryOwned, RowSource, UserEntryOwned,
@@ -47,6 +49,7 @@ pub fn for_kind(kind: ArtifactKind) -> Box<dyn ArtifactEmitter> {
     match kind {
         ArtifactKind::RustStruct => Box::new(rust_struct::RustStructEmitter),
         ArtifactKind::HtmlListView => Box::new(html_list_view::HtmlListViewEmitter),
+        ArtifactKind::HtmlDetailView => Box::new(html_detail_view::HtmlDetailViewEmitter),
         other => Box::new(stub::Stub { kind: other }),
     }
 }
diff --git a/crates/ogar-render-askama/src/lib.rs b/crates/ogar-render-askama/src/lib.rs
index c1a6fb7..6696ba7 100644
--- a/crates/ogar-render-askama/src/lib.rs
+++ b/crates/ogar-render-askama/src/lib.rs
@@ -73,8 +73,8 @@ pub mod list_view;
 pub mod spec;
 
 pub use artifact_kinds::{
-    for_kind, render_list, ArtifactEmitter, AttachmentEntryOwned, CellData, CellSource,
-    GroupHeader, RelationEntryOwned, RowSource, UserEntryOwned,
+    for_kind, render_detail, render_list, ArtifactEmitter, AttachmentEntryOwned, CellData,
+    CellSource, GroupHeader, RelationEntryOwned, RowSource, UserEntryOwned,
 };
 pub use list_view::{default_kind_for, ColumnKind, RenderColumn, SortOrder};
 pub use spec::{ArtifactKind, ArtifactSpec};
@@ -126,12 +126,13 @@ mod tests {
         assert!(
             all.contains(&ArtifactKind::RustStruct)
                 && all.contains(&ArtifactKind::HtmlListView)
+                && all.contains(&ArtifactKind::HtmlDetailView)
                 && all.contains(&ArtifactKind::SurrealqlTable)
                 && all.contains(&ArtifactKind::OpenapiSchema)
                 && all.contains(&ArtifactKind::NodeGuidRoutingArm),
             "ArtifactKind::ALL missing a variant"
         );
-        assert_eq!(all.len(), 5);
+        assert_eq!(all.len(), 6);
     }
 
     #[test]
@@ -332,6 +333,267 @@ mod tests {
         assert!(src.contains("<span class=\"badge\">5</span>"), "{src}");
     }
 
+    // ── XSS regression — codex P1 on #83 + #84 ──────────────────────
+
+    #[test]
+    fn html_list_view_escapes_data_derived_strings_xss_regression() {
+        // Codex P1 on PR #83: the spine template was compiled with
+        // `escape = "none"`, so every interpolation was raw — a malicious
+        // group-header label, title, caption, or css_class would inject
+        // raw HTML into the page. The fix is `escape = "html"` on the
+        // spine binding + `|safe` only on the intentionally-pre-rendered
+        // `cell.body_html`. This test pins the contract: untrusted
+        // strings get escaped; only cell bodies are raw.
+        let col = RenderColumn::new(
+            "subject",
+            "<script>alert(1)</script>", // poisoned caption
+            ColumnKind::PrimaryLink,
+        );
+        let row = RowSource {
+            record_id: 1,
+            css_classes: "<malicious-class>",
+            group: Some(GroupHeader {
+                label: "<img src=x onerror=alert(2)>",
+                count: 0,
+            }),
+            inline: vec![CellSource {
+                column: &col,
+                css_classes: "<bad-cell-class>",
+                data: CellData::PrimaryLink {
+                    label: "<safe>label</safe>",
+                    href: "/i/1",
+                },
+            }],
+            block: vec![],
+        };
+        let src = render_list(
+            "<title-xss>x</title-xss>",
+            0x0102,
+            "project_work_item",
+            std::slice::from_ref(&col),
+            &[],
+            std::slice::from_ref(&row),
+        )
+        .unwrap();
+
+        // Untrusted strings MUST be escaped — no raw `<script>` etc.
+        assert!(
+            !src.contains("<script>alert(1)"),
+            "caption was rendered raw — XSS hazard:\n{src}"
+        );
+        assert!(
+            src.contains("&lt;script&gt;alert(1)"),
+            "caption should be HTML-escaped:\n{src}"
+        );
+        assert!(
+            !src.contains("<img src=x onerror"),
+            "group label was rendered raw — XSS hazard:\n{src}"
+        );
+        assert!(
+            !src.contains("<malicious-class>"),
+            "row css_classes was rendered raw — XSS hazard:\n{src}"
+        );
+        assert!(
+            !src.contains("<title-xss>"),
+            "title was rendered raw — XSS hazard:\n{src}"
+        );
+        // The pre-rendered cell body comes from the PrimaryLink cell
+        // sub-template, which DOES escape its `label` field — the
+        // `<safe>` markers in the label become `&lt;safe&gt;` inside the
+        // already-escaped `<a>...</a>` HTML, which is then `|safe`-passed
+        // through the spine. Both layers escape: the spine doesn't
+        // re-escape, the sub-template escapes once.
+        assert!(
+            src.contains("&lt;safe&gt;label&lt;/safe&gt;"),
+            "primary_link cell should escape its label:\n{src}"
+        );
+        // The intentional HTML — the `<a>` element wrapping the label —
+        // DOES make it through (cell body is pre-rendered + `|safe`).
+        assert!(src.contains("<a href=\"/i/1\""), "cell body lost:\n{src}");
+    }
+
+    #[test]
+    fn html_detail_view_escapes_data_derived_strings_xss_regression() {
+        // Codex P1 on PR #84 (sibling of the list-view P1). Same
+        // contract: subtitle / labels / css_classes get escaped;
+        // only headline_html + cell.body_html + section.body_html
+        // are pre-rendered and marked safe.
+        let col = RenderColumn::new(
+            "status",
+            "<script>alert('label')</script>",
+            ColumnKind::PrimaryLink,
+        );
+        let block = RenderColumn::new(
+            "description",
+            "<script>alert('block-label')</script>",
+            ColumnKind::RichText,
+        )
+        .block();
+        let columns = vec![col, block];
+        let cells = vec![
+            CellSource {
+                column: &columns[0],
+                css_classes: "<inline-css>",
+                data: CellData::PrimaryLink {
+                    label: "<safe>x</safe>",
+                    href: "/s/1",
+                },
+            },
+            CellSource {
+                column: &columns[1],
+                css_classes: "<block-css>",
+                data: CellData::RichText {
+                    body: "<p>Trusted prose.</p>", // intentional HTML
+                },
+            },
+        ];
+
+        let src = render_detail(
+            0x0102,
+            "project_work_item",
+            42,
+            // headline_html — intentional HTML, gets through
+            "<a href=\"/issues/42\">Headline</a>",
+            // subtitle — data-derived, MUST be escaped
+            "<img src=x onerror=alert(3)>",
+            &columns,
+            &cells,
+        )
+        .unwrap();
+
+        // Subtitle XSS attempt must not survive.
+        assert!(
+            !src.contains("<img src=x onerror"),
+            "subtitle was rendered raw — XSS hazard:\n{src}"
+        );
+        // Section labels (block labels) must be escaped.
+        assert!(
+            !src.contains("<script>alert('block-label')"),
+            "block section label was rendered raw — XSS hazard:\n{src}"
+        );
+        // Inline field labels must be escaped.
+        assert!(
+            !src.contains("<script>alert('label')"),
+            "inline field label was rendered raw — XSS hazard:\n{src}"
+        );
+        // CSS classes must be escaped.
+        assert!(
+            !src.contains("<inline-css>"),
+            "cell css_classes was rendered raw — XSS hazard:\n{src}"
+        );
+        assert!(
+            !src.contains("<block-css>"),
+            "section css_classes was rendered raw — XSS hazard:\n{src}"
+        );
+        // Pre-rendered intentional HTML DOES get through.
+        assert!(
+            src.contains("<a href=\"/issues/42\">Headline</a>"),
+            "headline_html should be marked safe and pass through:\n{src}"
+        );
+        assert!(
+            src.contains("<p>Trusted prose.</p>"),
+            "rich-text section body should pass through (cell|safe):\n{src}"
+        );
+    }
+
+    // ── T3 (HtmlDetailView) tests ───────────────────────────────────
+
+    #[test]
+    fn html_detail_view_proof_of_shape_renders_dl_with_class_meta() {
+        // Codebook-only emit: synthesised dl from class attributes, "—"
+        // placeholders, no headline. Pins data-class-id + data-concept.
+        let class = project_work_item();
+        let src = render(&class, ArtifactKind::HtmlDetailView).unwrap();
+        assert!(
+            src.contains("data-class-id=\"0x0102\""),
+            "expected data-class-id in:\n{src}"
+        );
+        assert!(src.contains("data-concept=\"project_work_item\""));
+        assert!(src.contains("<dl class=\"detail-fields\">"), "{src}");
+        // Every typed attribute should land as a detail-field-<name>.
+        for attr in &class.attributes {
+            assert!(
+                src.contains(&format!("detail-field-{}", attr.name)),
+                "missing detail-field-{} in:\n{src}",
+                attr.name
+            );
+        }
+    }
+
+    #[test]
+    fn html_detail_view_renders_inline_dl_and_block_sections() {
+        let inline = RenderColumn::new("status", "Status", ColumnKind::PrimaryLink);
+        let pct = RenderColumn::new("done_ratio", "% Done", ColumnKind::ProgressBar);
+        let block_desc =
+            RenderColumn::new("description", "Description", ColumnKind::RichText).block();
+
+        let columns = vec![inline.clone(), pct.clone(), block_desc.clone()];
+        let cells = vec![
+            CellSource {
+                column: &columns[0],
+                css_classes: "",
+                data: CellData::PrimaryLink {
+                    label: "Open",
+                    href: "/statuses/1",
+                },
+            },
+            CellSource {
+                column: &columns[1],
+                css_classes: "num",
+                data: CellData::ProgressBar { pct: 60 },
+            },
+            CellSource {
+                column: &columns[2],
+                css_classes: "",
+                data: CellData::RichText {
+                    body: "<p>Detailed body here.</p>",
+                },
+            },
+        ];
+
+        let src = render_detail(
+            0x0102,
+            "project_work_item",
+            42,
+            "<a href=\"/issues/42\" class=\"primary-link\">Fix the foo</a>",
+            "Open · High",
+            &columns,
+            &cells,
+        )
+        .unwrap();
+
+        // Header
+        assert!(src.contains("data-record-id=\"42\""), "{src}");
+        assert!(src.contains("class=\"detail-id\">#42"), "{src}");
+        assert!(src.contains("Fix the foo"), "headline missing in:\n{src}");
+        assert!(src.contains("Open · High"), "subtitle missing in:\n{src}");
+        // Inline dl entries
+        assert!(src.contains("detail-field-status"), "{src}");
+        assert!(src.contains("detail-field-done_ratio"), "{src}");
+        // Inline cells render through the per-kind sub-templates.
+        assert!(src.contains("href=\"/statuses/1\""), "{src}");
+        assert!(src.contains("aria-valuenow=\"60\""), "{src}");
+        // Block section for description
+        assert!(src.contains("detail-section-description"), "{src}");
+        assert!(src.contains("<section class=\"detail-section"), "{src}");
+        assert!(src.contains("Detailed body here."), "{src}");
+        // Block content should NOT appear inside the inline `<dl>`.
+        // (Negative pin: detail-field-description should not exist.)
+        assert!(
+            !src.contains("detail-field-description"),
+            "block field leaked into inline dl in:\n{src}"
+        );
+    }
+
+    #[test]
+    fn html_detail_view_column_cell_arity_mismatch_returns_error() {
+        let col = RenderColumn::new("subject", "Subject", ColumnKind::PrimaryLink);
+        let columns = vec![col];
+        let cells: Vec<CellSource<'_>> = vec![]; // intentional mismatch
+        let r = render_detail(0x0102, "project_work_item", 1, "", "", &columns, &cells);
+        assert!(r.is_err(), "expected mismatch to error, got Ok:\n{r:?}");
+    }
+
     #[test]
     fn default_kind_resolver_is_wired_through_render_kit() {
         // Smoke: the resolver lib.rs re-exports is the one consumers
diff --git a/crates/ogar-render-askama/src/spec.rs b/crates/ogar-render-askama/src/spec.rs
index 4e93cf9..6750895 100644
--- a/crates/ogar-render-askama/src/spec.rs
+++ b/crates/ogar-render-askama/src/spec.rs
@@ -23,6 +23,11 @@ pub enum ArtifactKind {
     /// `ClassView` substrate. Spec: `docs/integration/REDMINE-QUERY-
     /// HARVEST.md` §3.
     HtmlListView,
+    /// Single-record HTML detail view: definition-list inline fields +
+    /// `<section>` blocks for prose / family-edge collections. **Render
+    /// flavour**; mirror of Redmine's `show.html.erb`. Reuses every
+    /// `RenderColumn` / `ColumnKind` / cell sub-template from T2.
+    HtmlDetailView,
     /// SurrealQL `DEFINE TABLE` + per-field `DEFINE FIELD` statements.
     /// **Codegen flavour** — DB engine is the final consumer.
     SurrealqlTable,
@@ -44,6 +49,7 @@ impl ArtifactKind {
     pub const ALL: &'static [Self] = &[
         Self::RustStruct,
         Self::HtmlListView,
+        Self::HtmlDetailView,
         Self::SurrealqlTable,
         Self::OpenapiSchema,
         Self::NodeGuidRoutingArm,
@@ -55,6 +61,7 @@ impl ArtifactKind {
         match self {
             Self::RustStruct => "rust_struct",
             Self::HtmlListView => "html_list_view",
+            Self::HtmlDetailView => "html_detail_view",
             Self::SurrealqlTable => "surrealql_table",
             Self::OpenapiSchema => "openapi_schema",
             Self::NodeGuidRoutingArm => "node_guid_routing_arm",
diff --git a/crates/ogar-render-askama/templates/dispatch/html_detail_view.askama b/crates/ogar-render-askama/templates/dispatch/html_detail_view.askama
new file mode 100644
index 0000000..b0807ff
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/html_detail_view.askama
@@ -0,0 +1,34 @@
+{# Detail view for a single canonical record. Same `RenderColumn` shape #}
+{# as the list view, just laid out as a definition list (dt/dd) for     #}
+{# inline fields + full-width sections for block fields and family-edge #}
+{# collections. Substrate-agnostic — driven by the binding-struct, no   #}
+{# class name hardcoded.                                                 #}
+<article class="ogar-detail" data-class-id="{{ class_id_hex }}" data-concept="{{ canonical_concept }}" data-record-id="{{ record_id }}">
+  <header class="detail-header">
+    <h2 class="detail-headline">
+      <span class="detail-id">#{{ record_id }}</span>
+      <span class="detail-primary">{{ headline_html|safe }}</span>
+    </h2>
+    {%- if !subtitle.is_empty() %}
+    <p class="detail-subtitle">{{ subtitle }}</p>
+    {%- endif %}
+  </header>
+
+  <dl class="detail-fields">
+  {%- for cell in inline_cells %}
+    <div class="detail-field detail-field-{{ cell.name }}{% if !cell.css_classes.is_empty() %} {{ cell.css_classes }}{% endif %}">
+      <dt class="detail-label">{{ cell.label }}</dt>
+      <dd class="detail-value">{{ cell.body_html|safe }}</dd>
+    </div>
+  {%- endfor %}
+  </dl>
+
+  {%- for section in block_sections %}
+  <section class="detail-section detail-section-{{ section.name }}">
+    <h3 class="detail-section-title">{{ section.label }}</h3>
+    <div class="detail-section-body{% if !section.css_classes.is_empty() %} {{ section.css_classes }}{% endif %}">
+      {{ section.body_html|safe }}
+    </div>
+  </section>
+  {%- endfor %}
+</article>