diff --git a/crates/ogar-render-askama/src/artifact_kinds/cells.rs b/crates/ogar-render-askama/src/artifact_kinds/cells.rs
index 67303cc..147b0b1 100644
--- a/crates/ogar-render-askama/src/artifact_kinds/cells.rs
+++ b/crates/ogar-render-askama/src/artifact_kinds/cells.rs
@@ -1,18 +1,21 @@
 //! Per-[`ColumnKind`](crate::ColumnKind) cell renderers — one askama
-//! sub-template per variant. Called from
-//! [`html_list_view`](super::html_list_view) at row-build time to
-//! pre-render each cell's body, so the spine template just emits
-//! `{{ cell.body_html|safe }}` with no runtime polymorphism.
+//! sub-template per variant. Called from the list-view + detail-view
+//! emitters at row-build time to pre-render each cell's body, so the
+//! spine templates just emit `{{ cell.body_html|safe }}` with no
+//! runtime polymorphism.
 //!
-//! Per Northstar §1.6 (mass-mail templates): each cell template is the
-//! smallest bag of variables it needs (the `*Cell` binding-structs
-//! below). Different cell kinds don't share a binding-struct.
+//! [`render_cell_body`] is the shared dispatch entry point T2 / T3 / T4
+//! all call (factored when T4 became the third caller — see Northstar
+//! plan §1.6: "templates are mass-mail simple; the *binding-struct* is
+//! the bag of variables; the dispatch is a Rust `match`").
 //!
 //! The catalog mirrors Redmine `queries_helper::column_value`'s 12-arm
 //! case (see `docs/integration/REDMINE-QUERY-HARVEST.md` §1.4).
 
 use askama::Template;
 
+use super::html_list_view::CellData;
+
 // ── Plain ────────────────────────────────────────────────────────────
 
 #[derive(Template)]
@@ -119,3 +122,66 @@ pub(crate) struct UserEntry<'a> {
     pub name: &'a str,
     pub href: &'a str,
 }
+
+// ── Shared dispatch — one place T2 / T3 / T4 call ─────────────────────
+
+/// Pre-render a [`CellData`] value into its HTML body via the matching
+/// per-kind sub-template. The spine templates (`html_list_view`,
+/// `html_detail_view`, `html_form`'s read-only fallback paths) consume
+/// the resulting string with `|safe` because the sub-templates already
+/// escape their own variables.
+///
+/// Factored from the duplicated `render_cell_body` helpers in T2 and T3
+/// when T4 became the third caller. Northstar plan §1.6: three points
+/// form a line.
+pub(crate) fn render_cell_body(data: &CellData<'_>) -> Result<String, askama::Error> {
+    Ok(match 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()?
+        }
+    })
+}
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
index e13147a..081eb84 100644
--- a/crates/ogar-render-askama/src/artifact_kinds/html_detail_view.rs
+++ b/crates/ogar-render-askama/src/artifact_kinds/html_detail_view.rs
@@ -13,11 +13,6 @@
 
 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};
@@ -116,45 +111,11 @@ pub fn render_detail(
     .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).
+/// Pre-render this cell's body via the shared per-kind dispatch.
+/// See [`super::cells::render_cell_body`]; factored when T4 became the
+/// third caller (T2 list-view, T3 detail-view, T4 form-view fallback).
 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()?
-        }
-    })
+    super::cells::render_cell_body(&src.data)
 }
 
 /// The codebook-only dispatch entry point used by [`for_kind`](super::for_kind).
diff --git a/crates/ogar-render-askama/src/artifact_kinds/html_form.rs b/crates/ogar-render-askama/src/artifact_kinds/html_form.rs
new file mode 100644
index 0000000..e745057
--- /dev/null
+++ b/crates/ogar-render-askama/src/artifact_kinds/html_form.rs
@@ -0,0 +1,273 @@
+//! `HtmlForm` emitter — T4 per Northstar plan §3. The create/edit-page
+//! sibling of T2's list view and T3's detail view.
+//!
+//! Substrate-agnostic — one form spine template + per-[`InputKind`]
+//! sub-templates. Inputs are pre-rendered in Rust (parallel to the
+//! T2/T3 cell pattern) so the spine emits `{{ field.body_html|safe }}`
+//! with no runtime polymorphism on the askama side.
+//!
+//! Mirrors Redmine's `_form.html.erb` shape (one shared partial per
+//! resource), generalised across every canonical concept by the
+//! `InputKind` + `RenderColumn` pair.
+
+use askama::Template;
+
+use super::inputs::{render_input_body, InputData};
+use super::ArtifactEmitter;
+use crate::form_view::{default_input_kind_for, InputKind};
+use crate::list_view::RenderColumn;
+use crate::spec::ArtifactSpec;
+use ogar_vocab::canonical_concept_id;
+
+// ── Spine binding struct ─────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/html_form.askama", escape = "html")]
+struct HtmlFormCtx {
+    class_id_hex: String,
+    canonical_concept: String,
+    method: String,
+    action: String,
+    csrf_token: String,
+    /// Pre-rendered hidden `<input>` for the record id (empty when
+    /// rendering a new-record form).
+    record_id_html: String,
+    legend: String,
+    submit_label: String,
+    cancel_label: String,
+    cancel_href: String,
+    fields: Vec<FormField>,
+}
+
+struct FormField {
+    name: String,
+    label: String,
+    css_classes: String,
+    hint: String,
+    required: bool,
+    /// `true` → emit the body bare (no `<label>`/wrapper); used for
+    /// `InputKind::Hidden` and any frozen/hidden id round-trip.
+    hidden: bool,
+    body_html: String,
+}
+
+// ── Source structs the caller fills ─────────────────────────────────
+
+/// One field's worth of source data the emitter consumes — the form
+/// equivalent of T2's [`CellSource`](super::html_list_view::CellSource).
+#[derive(Debug, Clone)]
+pub struct FormFieldSource<'a> {
+    /// The column this field belongs to (carries name, caption,
+    /// required, frozen, …).
+    pub column: &'a RenderColumn,
+    /// Optional CSS classes added to the field wrapper `<div>`.
+    pub css_classes: &'a str,
+    /// Help text shown under the input (empty for none).
+    pub hint: &'a str,
+    /// Per-kind input payload (current value, required, options, …).
+    pub data: InputData,
+}
+
+/// Full form description — what the caller passes to [`render_form`].
+#[derive(Debug, Clone)]
+pub struct FormSource<'a> {
+    /// HTTP method on the `<form>` element. Typically `"post"` for
+    /// new records and `"patch"` for updates.
+    pub method: &'a str,
+    /// Submit target URL (`/issues`, `/issues/42`, …).
+    pub action: &'a str,
+    /// Authenticity token; empty to skip emission.
+    pub csrf_token: &'a str,
+    /// `Some(id)` when editing an existing record (emits a hidden id
+    /// input so the action can dispatch). `None` for create forms.
+    pub record_id: Option<u64>,
+    /// Optional `<legend>` text on the `<fieldset>`.
+    pub legend: &'a str,
+    /// Label for the submit button.
+    pub submit_label: &'a str,
+    /// Label for the cancel link.
+    pub cancel_label: &'a str,
+    /// Cancel-link href; empty hides the cancel link.
+    pub cancel_href: &'a str,
+    /// One entry per form field, in declaration order.
+    pub fields: Vec<FormFieldSource<'a>>,
+}
+
+// ── Public entry point ──────────────────────────────────────────────
+
+/// Render one create/edit form for a canonical concept.
+///
+/// Returns `askama::Error` on internal template error; caller-supplied
+/// data is validated (no panics on common mistakes — empty fields are
+/// allowed; a malformed `InputData` variant fails the per-input render
+/// loudly).
+pub fn render_form(
+    class_id: u16,
+    canonical_concept: &str,
+    src: &FormSource<'_>,
+) -> Result<String, askama::Error> {
+    use super::inputs::HiddenInput;
+
+    let mut fields = Vec::with_capacity(src.fields.len());
+    for f in &src.fields {
+        let body = render_input_body(&f.column.name, &f.data)?;
+        let hidden = matches!(f.data, InputData::Hidden { .. });
+        fields.push(FormField {
+            name: f.column.name.clone(),
+            label: f.column.caption.clone(),
+            css_classes: f.css_classes.to_string(),
+            hint: f.hint.to_string(),
+            required: required_for(&f.data),
+            hidden,
+            body_html: body,
+        });
+    }
+
+    let record_id_html = if let Some(id) = src.record_id {
+        let id_str = id.to_string();
+        HiddenInput {
+            name: "id",
+            value: id_str.as_str(),
+        }
+        .render()?
+    } else {
+        String::new()
+    };
+
+    HtmlFormCtx {
+        class_id_hex: format!("0x{class_id:04X}"),
+        canonical_concept: canonical_concept.to_string(),
+        method: src.method.to_string(),
+        action: src.action.to_string(),
+        csrf_token: src.csrf_token.to_string(),
+        record_id_html,
+        legend: src.legend.to_string(),
+        submit_label: src.submit_label.to_string(),
+        cancel_label: src.cancel_label.to_string(),
+        cancel_href: src.cancel_href.to_string(),
+        fields,
+    }
+    .render()
+}
+
+fn required_for(data: &InputData) -> bool {
+    match data {
+        InputData::Text { required, .. }
+        | InputData::TextArea { required, .. }
+        | InputData::Number { required, .. }
+        | InputData::Date { required, .. }
+        | InputData::DateTime { required, .. }
+        | InputData::Select { required, .. } => *required,
+        InputData::Range { .. } | InputData::Checkbox { .. } | InputData::Hidden { .. } => false,
+    }
+}
+
+// ── Codebook-only proof-of-shape entry point ────────────────────────
+
+/// The dispatcher entry point used by [`for_kind`](super::for_kind).
+/// Synthesises a new-record form from the class's attributes (proof of
+/// shape); real callers use [`render_form`] with real values.
+pub struct HtmlFormEmitter;
+
+impl ArtifactEmitter for HtmlFormEmitter {
+    fn emit(&self, spec: &ArtifactSpec<'_>) -> Result<String, askama::Error> {
+        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| {
+                use crate::list_view::{default_kind_for, ColumnKind};
+                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();
+
+        // Build placeholder input data per InputKind resolved from the
+        // class's attribute (kept alongside columns so the &str borrows
+        // in InputData::* live as long as the call).
+        let fields: Vec<FormFieldSource<'_>> = columns
+            .iter()
+            .zip(class.attributes.iter())
+            .map(|(col, attr)| {
+                let input_kind = default_input_kind_for(&attr.name, attr.type_name.as_deref());
+                let data = empty_input_for(input_kind);
+                FormFieldSource {
+                    column: col,
+                    css_classes: "",
+                    hint: "",
+                    data,
+                }
+            })
+            .collect();
+
+        let src = FormSource {
+            method: "post",
+            action: "",
+            csrf_token: "",
+            record_id: None,
+            legend: concept,
+            submit_label: "Create",
+            cancel_label: "Cancel",
+            cancel_href: "",
+            fields,
+        };
+        render_form(class_id, concept, &src)
+    }
+}
+
+/// Default empty `InputData` for the given [`InputKind`] — used by the
+/// codebook-only proof-of-shape path and tests that don't supply real
+/// data.
+pub fn empty_input_for(kind: InputKind) -> InputData {
+    match kind {
+        InputKind::Text => InputData::Text {
+            value: String::new(),
+            required: false,
+            placeholder: String::new(),
+        },
+        InputKind::TextArea => InputData::TextArea {
+            value: String::new(),
+            rows: 6,
+            required: false,
+            placeholder: String::new(),
+        },
+        InputKind::Number => InputData::Number {
+            value: String::new(),
+            required: false,
+            step: String::new(),
+        },
+        InputKind::Range => InputData::Range {
+            value: "0".to_string(),
+            min: 0,
+            max: 100,
+            step: 1,
+            suffix: "%".to_string(),
+        },
+        InputKind::Checkbox => InputData::Checkbox { checked: false },
+        InputKind::Date => InputData::Date {
+            value: String::new(),
+            required: false,
+        },
+        InputKind::DateTime => InputData::DateTime {
+            value: String::new(),
+            required: false,
+        },
+        InputKind::Select => InputData::Select {
+            value: String::new(),
+            required: false,
+            options: Vec::new(),
+        },
+        InputKind::Hidden => InputData::Hidden {
+            value: String::new(),
+        },
+    }
+}
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 7342600..1b39c10 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
@@ -17,11 +17,6 @@
 
 use askama::Template;
 
-use super::cells::{
-    AttachmentEntry, AttachmentListCell, HoursCell, IdLinkCell, PlainCell, PrimaryLinkCell,
-    ProgressBarCell, RecordRefCell, RelationEntry, RelationListCell, RichTextCell, UserEntry,
-    UserListCell,
-};
 use super::ArtifactEmitter;
 use crate::list_view::{ColumnKind, RenderColumn};
 use crate::spec::ArtifactSpec;
@@ -237,41 +232,10 @@ pub fn render_list(
 }
 
 fn render_cell(src: &CellSource<'_>) -> Result<RenderedCell, askama::Error> {
-    let body = 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()?
-        }
-    };
+    // Shared dispatch — see `cells::render_cell_body`. T2/T3/T4 all call
+    // the same helper; this function just wraps the body into the
+    // RenderedCell record T2's spine template expects.
+    let body = super::cells::render_cell_body(&src.data)?;
     Ok(RenderedCell {
         name: src.column.name.clone(),
         css_classes: src.css_classes.to_string(),
diff --git a/crates/ogar-render-askama/src/artifact_kinds/inputs.rs b/crates/ogar-render-askama/src/artifact_kinds/inputs.rs
new file mode 100644
index 0000000..a38910c
--- /dev/null
+++ b/crates/ogar-render-askama/src/artifact_kinds/inputs.rs
@@ -0,0 +1,298 @@
+//! Per-[`InputKind`](crate::form_view::InputKind) form-input renderers —
+//! one askama sub-template per variant. Called from
+//! [`html_form`](super::html_form) at field-build time to pre-render
+//! each input's HTML, so the spine template just emits
+//! `{{ field.body_html|safe }}` with no runtime polymorphism (parallel
+//! to T2/T3's cell pattern, factored through
+//! [`render_input_body`](self::render_input_body)).
+//!
+//! Per Northstar §1.6: each input template is the smallest bag of
+//! variables it needs.
+
+use askama::Template;
+
+// ── Text ─────────────────────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/input/text.askama", escape = "html")]
+pub(crate) struct TextInput<'a> {
+    pub name: &'a str,
+    pub value: &'a str,
+    pub required: bool,
+    pub placeholder: &'a str,
+}
+
+// ── TextArea ─────────────────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/input/textarea.askama", escape = "html")]
+pub(crate) struct TextAreaInput<'a> {
+    pub name: &'a str,
+    pub value: &'a str,
+    pub rows: u32,
+    pub required: bool,
+    pub placeholder: &'a str,
+}
+
+// ── Number ───────────────────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/input/number.askama", escape = "html")]
+pub(crate) struct NumberInput<'a> {
+    pub name: &'a str,
+    pub value: &'a str,
+    pub required: bool,
+    /// Step granularity ("1" for integers, "0.01" for currency, etc.).
+    pub step: &'a str,
+}
+
+// ── Range ────────────────────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/input/range.askama", escape = "html")]
+pub(crate) struct RangeInput<'a> {
+    pub name: &'a str,
+    pub value: &'a str,
+    pub min: i64,
+    pub max: i64,
+    pub step: u32,
+    /// e.g. `"%"` for percentage; empty for plain numeric output.
+    pub suffix: &'a str,
+}
+
+// ── Checkbox ─────────────────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/input/checkbox.askama", escape = "html")]
+pub(crate) struct CheckboxInput<'a> {
+    pub name: &'a str,
+    pub checked: bool,
+}
+
+// ── Date / DateTime ─────────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/input/date.askama", escape = "html")]
+pub(crate) struct DateInput<'a> {
+    pub name: &'a str,
+    pub value: &'a str,
+    pub required: bool,
+}
+
+#[derive(Template)]
+#[template(path = "dispatch/input/datetime.askama", escape = "html")]
+pub(crate) struct DateTimeInput<'a> {
+    pub name: &'a str,
+    pub value: &'a str,
+    pub required: bool,
+}
+
+// ── Select ───────────────────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/input/select.askama", escape = "html")]
+pub(crate) struct SelectInput<'a> {
+    pub name: &'a str,
+    pub value: &'a str,
+    pub required: bool,
+    pub options: Vec<SelectOption<'a>>,
+}
+
+pub(crate) struct SelectOption<'a> {
+    pub value: &'a str,
+    pub label: &'a str,
+}
+
+// ── Hidden ──────────────────────────────────────────────────────────
+
+#[derive(Template)]
+#[template(path = "dispatch/input/hidden.askama", escape = "html")]
+pub(crate) struct HiddenInput<'a> {
+    pub name: &'a str,
+    pub value: &'a str,
+}
+
+// ── Owned input-data variant + shared dispatch ──────────────────────
+
+use crate::form_view::InputKind;
+
+/// Per-kind data the caller supplies for a form input. Variants are
+/// keyed by [`InputKind`]; the [`render_input_body`] dispatch picks the
+/// sub-template based on the variant.
+#[derive(Debug, Clone)]
+#[allow(missing_docs)] // self-describing variants; fields documented inline.
+pub enum InputData {
+    Text {
+        value: String,
+        required: bool,
+        placeholder: String,
+    },
+    TextArea {
+        value: String,
+        rows: u32,
+        required: bool,
+        placeholder: String,
+    },
+    Number {
+        value: String,
+        required: bool,
+        /// Step granularity ("1", "0.01", …). Empty for the
+        /// browser-default.
+        step: String,
+    },
+    Range {
+        value: String,
+        min: i64,
+        max: i64,
+        step: u32,
+        suffix: String,
+    },
+    Checkbox {
+        checked: bool,
+    },
+    Date {
+        value: String,
+        required: bool,
+    },
+    DateTime {
+        value: String,
+        required: bool,
+    },
+    Select {
+        value: String,
+        required: bool,
+        options: Vec<SelectOptionOwned>,
+    },
+    Hidden {
+        value: String,
+    },
+}
+
+/// Owned form of one `<option>` for a [`InputData::Select`] dropdown.
+#[derive(Debug, Clone)]
+pub struct SelectOptionOwned {
+    /// `value` attribute (typically a record id as string).
+    pub value: String,
+    /// Human-readable label.
+    pub label: String,
+}
+
+impl InputData {
+    /// The [`InputKind`] this data variant pairs with — useful for
+    /// asserting `(InputKind, InputData)` consistency in tests / call
+    /// sites.
+    pub fn kind(&self) -> InputKind {
+        match self {
+            Self::Text { .. } => InputKind::Text,
+            Self::TextArea { .. } => InputKind::TextArea,
+            Self::Number { .. } => InputKind::Number,
+            Self::Range { .. } => InputKind::Range,
+            Self::Checkbox { .. } => InputKind::Checkbox,
+            Self::Date { .. } => InputKind::Date,
+            Self::DateTime { .. } => InputKind::DateTime,
+            Self::Select { .. } => InputKind::Select,
+            Self::Hidden { .. } => InputKind::Hidden,
+        }
+    }
+}
+
+/// Pre-render an [`InputData`] value into its HTML body via the matching
+/// per-kind sub-template. The spine `html_form.askama` consumes the
+/// result with `|safe` (the sub-templates each escape their own
+/// variables under `escape = "html"`).
+pub(crate) fn render_input_body(name: &str, data: &InputData) -> Result<String, askama::Error> {
+    Ok(match data {
+        InputData::Text {
+            value,
+            required,
+            placeholder,
+        } => TextInput {
+            name,
+            value: value.as_str(),
+            required: *required,
+            placeholder: placeholder.as_str(),
+        }
+        .render()?,
+        InputData::TextArea {
+            value,
+            rows,
+            required,
+            placeholder,
+        } => TextAreaInput {
+            name,
+            value: value.as_str(),
+            rows: *rows,
+            required: *required,
+            placeholder: placeholder.as_str(),
+        }
+        .render()?,
+        InputData::Number {
+            value,
+            required,
+            step,
+        } => NumberInput {
+            name,
+            value: value.as_str(),
+            required: *required,
+            step: step.as_str(),
+        }
+        .render()?,
+        InputData::Range {
+            value,
+            min,
+            max,
+            step,
+            suffix,
+        } => RangeInput {
+            name,
+            value: value.as_str(),
+            min: *min,
+            max: *max,
+            step: *step,
+            suffix: suffix.as_str(),
+        }
+        .render()?,
+        InputData::Checkbox { checked } => CheckboxInput {
+            name,
+            checked: *checked,
+        }
+        .render()?,
+        InputData::Date { value, required } => DateInput {
+            name,
+            value: value.as_str(),
+            required: *required,
+        }
+        .render()?,
+        InputData::DateTime { value, required } => DateTimeInput {
+            name,
+            value: value.as_str(),
+            required: *required,
+        }
+        .render()?,
+        InputData::Select {
+            value,
+            required,
+            options,
+        } => {
+            let mapped: Vec<SelectOption<'_>> = options
+                .iter()
+                .map(|o| SelectOption {
+                    value: o.value.as_str(),
+                    label: o.label.as_str(),
+                })
+                .collect();
+            SelectInput {
+                name,
+                value: value.as_str(),
+                required: *required,
+                options: mapped,
+            }
+            .render()?
+        }
+        InputData::Hidden { value } => HiddenInput {
+            name,
+            value: value.as_str(),
+        }
+        .render()?,
+    })
+}
diff --git a/crates/ogar-render-askama/src/artifact_kinds/mod.rs b/crates/ogar-render-askama/src/artifact_kinds/mod.rs
index 41a5db8..5f9007f 100644
--- a/crates/ogar-render-askama/src/artifact_kinds/mod.rs
+++ b/crates/ogar-render-askama/src/artifact_kinds/mod.rs
@@ -15,25 +15,35 @@
 //! - [`HtmlListView`](html_list_view::HtmlListViewEmitter) — T2, render
 //!   flavour. Mirrors Redmine's `_list.html.erb` shape on our substrate
 //!   (see `docs/integration/REDMINE-QUERY-HARVEST.md`).
+//! - [`HtmlDetailView`](html_detail_view::HtmlDetailViewEmitter) — T3,
+//!   render flavour. Mirror of Redmine `show.html.erb`.
+//! - [`HtmlForm`](html_form::HtmlFormEmitter) — T4, render flavour.
+//!   Mirror of Redmine `_form.html.erb`. Separate
+//!   [`InputKind`](crate::form_view::InputKind) catalog from `ColumnKind`
+//!   because input controls don't map 1:1 to display formatters.
 //!
-//! Remaining kinds use [`Stub`] — placeholder code that compiles and
-//! emits a marker comment so callers can exercise the full pipeline
-//! (lookup + dispatch + return) before T3–T5 land.
+//! Remaining kinds (`SurrealqlTable`, `OpenapiSchema`,
+//! `NodeGuidRoutingArm`) use [`Stub`] — placeholder code so callers can
+//! exercise the full pipeline before T5 lands.
 
 pub(crate) mod cells;
+pub(crate) mod inputs;
 
 use crate::spec::{ArtifactKind, ArtifactSpec};
 
 pub mod html_detail_view;
+pub mod html_form;
 pub mod html_list_view;
 pub mod rust_struct;
 pub mod stub;
 
 pub use html_detail_view::{render_detail, HtmlDetailViewEmitter};
+pub use html_form::{render_form, FormFieldSource, FormSource, HtmlFormEmitter};
 pub use html_list_view::{
     render_list, AttachmentEntryOwned, CellData, CellSource, GroupHeader, HtmlListViewEmitter,
     RelationEntryOwned, RowSource, UserEntryOwned,
 };
+pub use inputs::{InputData, SelectOptionOwned};
 
 /// Contract every kind's emitter implements.
 pub trait ArtifactEmitter {
@@ -50,6 +60,7 @@ pub fn for_kind(kind: ArtifactKind) -> Box<dyn ArtifactEmitter> {
         ArtifactKind::RustStruct => Box::new(rust_struct::RustStructEmitter),
         ArtifactKind::HtmlListView => Box::new(html_list_view::HtmlListViewEmitter),
         ArtifactKind::HtmlDetailView => Box::new(html_detail_view::HtmlDetailViewEmitter),
+        ArtifactKind::HtmlForm => Box::new(html_form::HtmlFormEmitter),
         other => Box::new(stub::Stub { kind: other }),
     }
 }
diff --git a/crates/ogar-render-askama/src/form_view.rs b/crates/ogar-render-askama/src/form_view.rs
new file mode 100644
index 0000000..20f6805
--- /dev/null
+++ b/crates/ogar-render-askama/src/form_view.rs
@@ -0,0 +1,207 @@
+//! Form-input kind enum + resolver — the form-side companion to
+//! [`crate::list_view::ColumnKind`]. While `ColumnKind` says how to
+//! *display* a slot (link / progress bar / etc.), [`InputKind`] says
+//! what HTML `<input>` control collects the user's edit for that slot.
+//!
+//! Used by T4 ([`super::artifact_kinds::html_form`]). Append-only enum
+//! per Northstar §1.6 — variant order is the stable contract.
+
+/// HTML form-control dispatch. One askama sub-template per variant
+/// (`dispatch/input/<name>.askama`). **Append-only** — new variants land
+/// at the end; existing variants never reorder or repurpose.
+///
+/// Maps onto Rails-side type names + canonical-concept slot semantics:
+/// a `name: string` attribute renders as `<input type="text">`; a
+/// `done_ratio: integer` (when the column says it's a percentage)
+/// renders as `<input type="range">`; a `description: text` slot
+/// renders as `<textarea>`; etc.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum InputKind {
+    /// `<input type="text">` — short string (default for `string`-typed
+    /// attributes and any unrecognised type).
+    Text,
+    /// `<textarea>` — long text (Rails `text`, RichText display kind).
+    TextArea,
+    /// `<input type="number">` — integer / decimal.
+    Number,
+    /// `<input type="range" min=0 max=100>` — percentage / `done_ratio`.
+    Range,
+    /// `<input type="checkbox">` — boolean.
+    Checkbox,
+    /// `<input type="date">` — ISO date (Rails `date`).
+    Date,
+    /// `<input type="datetime-local">` — Rails `datetime` / `timestamp`.
+    DateTime,
+    /// `<select>` of related-record options — the form-side companion of
+    /// [`crate::list_view::ColumnKind::RecordRef`].
+    Select,
+    /// `<input type="hidden">` — id-likes and frozen slots that the
+    /// caller wants to round-trip without showing.
+    Hidden,
+}
+
+impl InputKind {
+    /// Short stable name used as the sub-template filename stem
+    /// (`dispatch/input/<name>.askama`). Append-only — never renamed.
+    pub fn template_stem(self) -> &'static str {
+        match self {
+            Self::Text => "text",
+            Self::TextArea => "textarea",
+            Self::Number => "number",
+            Self::Range => "range",
+            Self::Checkbox => "checkbox",
+            Self::Date => "date",
+            Self::DateTime => "datetime",
+            Self::Select => "select",
+            Self::Hidden => "hidden",
+        }
+    }
+
+    /// The `<input type=…>` attribute (for the variants that render a
+    /// single `<input>` element). `None` for variants that render a
+    /// different element (TextArea → `<textarea>`, Select → `<select>`).
+    pub fn html_input_type(self) -> Option<&'static str> {
+        match self {
+            Self::Text => Some("text"),
+            Self::Number => Some("number"),
+            Self::Range => Some("range"),
+            Self::Checkbox => Some("checkbox"),
+            Self::Date => Some("date"),
+            Self::DateTime => Some("datetime-local"),
+            Self::Hidden => Some("hidden"),
+            Self::TextArea | Self::Select => None,
+        }
+    }
+}
+
+/// Resolve a sensible default [`InputKind`] from a field's name + curator
+/// type name. Companion to
+/// [`crate::list_view::default_kind_for`] but for form inputs.
+///
+/// Conventions:
+/// - `id` / `*_id` → [`InputKind::Hidden`] (id round-trips without UI).
+/// - `done_ratio` / `*_ratio` / `*_pct` → [`InputKind::Range`].
+/// - Rails `text` type with prose-shaped name → [`InputKind::TextArea`].
+/// - Rails `integer` / `big_integer` / `bigint` / `float` / `decimal` / `monetary` → [`InputKind::Number`].
+/// - Rails `boolean` → [`InputKind::Checkbox`].
+/// - Rails `date` → [`InputKind::Date`].
+/// - Rails `datetime` / `timestamp` → [`InputKind::DateTime`].
+/// - everything else (default) → [`InputKind::Text`].
+#[must_use]
+pub fn default_input_kind_for(name: &str, type_name: Option<&str>) -> InputKind {
+    let n = name;
+    if n == "id" || n.ends_with("_id") {
+        return InputKind::Hidden;
+    }
+    if n == "done_ratio" || n.ends_with("_ratio") || n.ends_with("_pct") {
+        return InputKind::Range;
+    }
+    if matches!(type_name, Some("text"))
+        && (n.contains("description")
+            || n.contains("notes")
+            || n.contains("comment")
+            || n.contains("body"))
+    {
+        return InputKind::TextArea;
+    }
+    match type_name {
+        Some("text") => InputKind::TextArea,
+        Some("integer") | Some("big_integer") | Some("bigint") | Some("float") | Some("double")
+        | Some("decimal") | Some("monetary") => InputKind::Number,
+        Some("boolean") | Some("bool") => InputKind::Checkbox,
+        Some("date") => InputKind::Date,
+        Some("datetime") | Some("timestamp") => InputKind::DateTime,
+        _ => InputKind::Text,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn input_kind_template_stems_are_stable() {
+        // The stems ARE filenames — must never change once shipped.
+        assert_eq!(InputKind::Text.template_stem(), "text");
+        assert_eq!(InputKind::TextArea.template_stem(), "textarea");
+        assert_eq!(InputKind::Number.template_stem(), "number");
+        assert_eq!(InputKind::Range.template_stem(), "range");
+        assert_eq!(InputKind::Checkbox.template_stem(), "checkbox");
+        assert_eq!(InputKind::Date.template_stem(), "date");
+        assert_eq!(InputKind::DateTime.template_stem(), "datetime");
+        assert_eq!(InputKind::Select.template_stem(), "select");
+        assert_eq!(InputKind::Hidden.template_stem(), "hidden");
+    }
+
+    #[test]
+    fn html_input_type_returns_none_for_non_input_elements() {
+        // TextArea + Select render different tags, not <input>.
+        assert!(InputKind::TextArea.html_input_type().is_none());
+        assert!(InputKind::Select.html_input_type().is_none());
+        // All others render an <input> with a definite type=…
+        for k in [
+            InputKind::Text,
+            InputKind::Number,
+            InputKind::Range,
+            InputKind::Checkbox,
+            InputKind::Date,
+            InputKind::DateTime,
+            InputKind::Hidden,
+        ] {
+            assert!(k.html_input_type().is_some(), "{k:?}");
+        }
+    }
+
+    #[test]
+    fn default_input_kind_hides_ids() {
+        assert_eq!(default_input_kind_for("id", None), InputKind::Hidden);
+        assert_eq!(default_input_kind_for("project_id", None), InputKind::Hidden);
+        assert_eq!(default_input_kind_for("author_id", Some("integer")), InputKind::Hidden);
+    }
+
+    #[test]
+    fn default_input_kind_picks_range_for_ratios() {
+        assert_eq!(default_input_kind_for("done_ratio", None), InputKind::Range);
+        assert_eq!(default_input_kind_for("complete_pct", None), InputKind::Range);
+    }
+
+    #[test]
+    fn default_input_kind_picks_textarea_for_prose() {
+        // Prose-named text fields get a textarea; non-prose text fields
+        // also get a textarea (text is long enough to warrant it).
+        assert_eq!(default_input_kind_for("description", Some("text")), InputKind::TextArea);
+        assert_eq!(default_input_kind_for("body", Some("text")), InputKind::TextArea);
+        assert_eq!(default_input_kind_for("notes", Some("text")), InputKind::TextArea);
+        assert_eq!(default_input_kind_for("status_label", Some("text")), InputKind::TextArea);
+    }
+
+    #[test]
+    fn default_input_kind_picks_numeric_for_numbers() {
+        for t in ["integer", "big_integer", "bigint", "float", "double", "decimal", "monetary"] {
+            assert_eq!(
+                default_input_kind_for("position", Some(t)),
+                InputKind::Number,
+                "type {t}"
+            );
+        }
+    }
+
+    #[test]
+    fn default_input_kind_picks_checkbox_for_boolean() {
+        assert_eq!(default_input_kind_for("active", Some("boolean")), InputKind::Checkbox);
+        assert_eq!(default_input_kind_for("locked", Some("bool")), InputKind::Checkbox);
+    }
+
+    #[test]
+    fn default_input_kind_picks_date_types_for_temporal() {
+        assert_eq!(default_input_kind_for("start_date", Some("date")), InputKind::Date);
+        assert_eq!(default_input_kind_for("created_at", Some("datetime")), InputKind::DateTime);
+        assert_eq!(default_input_kind_for("updated_at", Some("timestamp")), InputKind::DateTime);
+    }
+
+    #[test]
+    fn default_input_kind_falls_back_to_text() {
+        assert_eq!(default_input_kind_for("subject", Some("string")), InputKind::Text);
+        assert_eq!(default_input_kind_for("unknown_field", None), InputKind::Text);
+    }
+}
diff --git a/crates/ogar-render-askama/src/lib.rs b/crates/ogar-render-askama/src/lib.rs
index 6696ba7..06eeda1 100644
--- a/crates/ogar-render-askama/src/lib.rs
+++ b/crates/ogar-render-askama/src/lib.rs
@@ -69,13 +69,16 @@
 #![warn(missing_docs)]
 
 pub mod artifact_kinds;
+pub mod form_view;
 pub mod list_view;
 pub mod spec;
 
 pub use artifact_kinds::{
-    for_kind, render_detail, render_list, ArtifactEmitter, AttachmentEntryOwned, CellData,
-    CellSource, GroupHeader, RelationEntryOwned, RowSource, UserEntryOwned,
+    for_kind, render_detail, render_form, render_list, ArtifactEmitter, AttachmentEntryOwned,
+    CellData, CellSource, FormFieldSource, FormSource, GroupHeader, InputData,
+    RelationEntryOwned, RowSource, SelectOptionOwned, UserEntryOwned,
 };
+pub use form_view::{default_input_kind_for, InputKind};
 pub use list_view::{default_kind_for, ColumnKind, RenderColumn, SortOrder};
 pub use spec::{ArtifactKind, ArtifactSpec};
 
@@ -127,12 +130,13 @@ mod tests {
             all.contains(&ArtifactKind::RustStruct)
                 && all.contains(&ArtifactKind::HtmlListView)
                 && all.contains(&ArtifactKind::HtmlDetailView)
+                && all.contains(&ArtifactKind::HtmlForm)
                 && all.contains(&ArtifactKind::SurrealqlTable)
                 && all.contains(&ArtifactKind::OpenapiSchema)
                 && all.contains(&ArtifactKind::NodeGuidRoutingArm),
             "ArtifactKind::ALL missing a variant"
         );
-        assert_eq!(all.len(), 6);
+        assert_eq!(all.len(), 7);
     }
 
     #[test]
@@ -609,6 +613,256 @@ mod tests {
         assert_eq!(default_kind_for("position", Some("integer")), ColumnKind::Plain);
     }
 
+    // ── T4 (HtmlForm) tests ─────────────────────────────────────────
+
+    #[test]
+    fn html_form_proof_of_shape_renders_inputs_for_class_attributes() {
+        // Codebook-only emit: every typed attribute on project_role lands
+        // as a `<form>` field. Pins data-class-id / data-concept + the
+        // per-attribute form-field wrappers.
+        let class = project_role();
+        let src = render(&class, ArtifactKind::HtmlForm).unwrap();
+        assert!(
+            src.contains("data-class-id=\"0x0117\""),
+            "expected data-class-id=\"0x0117\" in:\n{src}"
+        );
+        assert!(src.contains("data-concept=\"project_role\""), "{src}");
+        assert!(src.contains("<form"), "expected a <form> element:\n{src}");
+        for attr in &class.attributes {
+            assert!(
+                src.contains(&format!("form-field-{}", attr.name)),
+                "missing form-field-{} in:\n{src}",
+                attr.name
+            );
+        }
+        // Default proof-of-shape form uses POST + Create + no cancel.
+        assert!(src.contains("method=\"post\""), "{src}");
+        assert!(src.contains(">Create</button>"), "{src}");
+    }
+
+    #[test]
+    fn html_form_dispatches_input_kinds_to_their_sub_templates() {
+        // Build a form with explicit per-field InputData covering every
+        // kind that maps to a distinct HTML element. Verify each
+        // sub-template fires correctly.
+        let cols = vec![
+            RenderColumn::new("subject", "Subject", ColumnKind::PrimaryLink),
+            RenderColumn::new("description", "Description", ColumnKind::RichText).block(),
+            RenderColumn::new("estimated_hours", "Estimated h", ColumnKind::Hours),
+            RenderColumn::new("done_ratio", "% Done", ColumnKind::ProgressBar),
+            RenderColumn::new("is_private", "Private?", ColumnKind::Plain),
+            RenderColumn::new("start_date", "Start", ColumnKind::Plain),
+            RenderColumn::new("updated_at", "Updated", ColumnKind::Plain),
+            RenderColumn::new("status_id", "Status", ColumnKind::IdLink),
+            RenderColumn::new("id", "ID", ColumnKind::IdLink).frozen(),
+        ];
+        let fields = vec![
+            FormFieldSource {
+                column: &cols[0],
+                css_classes: "",
+                hint: "Short headline",
+                data: InputData::Text {
+                    value: "draft title".to_string(),
+                    required: true,
+                    placeholder: "Enter a subject".to_string(),
+                },
+            },
+            FormFieldSource {
+                column: &cols[1],
+                css_classes: "",
+                hint: "",
+                data: InputData::TextArea {
+                    value: "draft body".to_string(),
+                    rows: 8,
+                    required: false,
+                    placeholder: String::new(),
+                },
+            },
+            FormFieldSource {
+                column: &cols[2],
+                css_classes: "num",
+                hint: "",
+                data: InputData::Number {
+                    value: "3".to_string(),
+                    required: false,
+                    step: "0.25".to_string(),
+                },
+            },
+            FormFieldSource {
+                column: &cols[3],
+                css_classes: "",
+                hint: "",
+                data: InputData::Range {
+                    value: "70".to_string(),
+                    min: 0,
+                    max: 100,
+                    step: 10,
+                    suffix: "%".to_string(),
+                },
+            },
+            FormFieldSource {
+                column: &cols[4],
+                css_classes: "",
+                hint: "",
+                data: InputData::Checkbox { checked: true },
+            },
+            FormFieldSource {
+                column: &cols[5],
+                css_classes: "",
+                hint: "",
+                data: InputData::Date {
+                    value: "2026-01-15".to_string(),
+                    required: false,
+                },
+            },
+            FormFieldSource {
+                column: &cols[6],
+                css_classes: "",
+                hint: "",
+                data: InputData::DateTime {
+                    value: "2026-06-19T10:00".to_string(),
+                    required: false,
+                },
+            },
+            FormFieldSource {
+                column: &cols[7],
+                css_classes: "",
+                hint: "",
+                data: InputData::Select {
+                    value: "2".to_string(),
+                    required: false,
+                    options: vec![
+                        SelectOptionOwned { value: "1".to_string(), label: "New".to_string() },
+                        SelectOptionOwned { value: "2".to_string(), label: "In Progress".to_string() },
+                        SelectOptionOwned { value: "3".to_string(), label: "Closed".to_string() },
+                    ],
+                },
+            },
+            FormFieldSource {
+                column: &cols[8],
+                css_classes: "",
+                hint: "",
+                data: InputData::Hidden {
+                    value: "42".to_string(),
+                },
+            },
+        ];
+
+        let src = render_form(
+            0x0102,
+            "project_work_item",
+            &FormSource {
+                method: "patch",
+                action: "/issues/42",
+                csrf_token: "xyz",
+                record_id: Some(42),
+                legend: "Edit issue",
+                submit_label: "Save",
+                cancel_label: "Cancel",
+                cancel_href: "/issues/42",
+                fields,
+            },
+        )
+        .unwrap();
+
+        // Header attrs
+        assert!(src.contains("method=\"patch\""), "{src}");
+        assert!(src.contains("action=\"/issues/42\""), "{src}");
+        assert!(src.contains("name=\"authenticity_token\" value=\"xyz\""), "{src}");
+        // record_id hidden field for the edit form
+        assert!(src.contains("name=\"id\" value=\"42\""), "expected record-id hidden:\n{src}");
+        assert!(src.contains("<legend>Edit issue</legend>"), "{src}");
+
+        // Each input kind fires its own sub-template:
+        assert!(src.contains("<input type=\"text\" name=\"subject\""), "{src}");
+        assert!(src.contains("placeholder=\"Enter a subject\""), "{src}");
+        assert!(src.contains("<textarea name=\"description\""), "{src}");
+        assert!(src.contains("rows=\"8\""), "{src}");
+        assert!(src.contains("<input type=\"number\" name=\"estimated_hours\""), "{src}");
+        assert!(src.contains("step=\"0.25\""), "{src}");
+        assert!(src.contains("<input type=\"range\" name=\"done_ratio\""), "{src}");
+        assert!(src.contains("max=\"100\""), "{src}");
+        assert!(src.contains("<input type=\"checkbox\" name=\"is_private\""), "{src}");
+        // checkbox carries the hidden 0 sibling per Rails idiom
+        assert!(src.contains("<input type=\"hidden\" name=\"is_private\" value=\"0\""), "{src}");
+        assert!(src.contains("<input type=\"date\" name=\"start_date\""), "{src}");
+        assert!(src.contains("<input type=\"datetime-local\" name=\"updated_at\""), "{src}");
+        assert!(src.contains("<select name=\"status_id\""), "{src}");
+        // selected option pinned
+        assert!(src.contains("<option value=\"2\" selected>In Progress</option>"), "{src}");
+        // hidden field has NO label wrapper; emitted bare
+        assert!(src.contains("<input type=\"hidden\" name=\"id\" value=\"42\""), "{src}");
+        assert!(!src.contains("form-field-id"), "hidden field should not have a wrapper:\n{src}");
+        // The Subject field's hint goes through
+        assert!(src.contains("Short headline"), "{src}");
+        // Cancel + submit buttons
+        assert!(src.contains(">Save</button>"), "{src}");
+        assert!(src.contains("href=\"/issues/42\""), "{src}");
+        assert!(src.contains(">Cancel</a>"), "{src}");
+    }
+
+    #[test]
+    fn html_form_escapes_data_derived_strings_xss_regression() {
+        // Same XSS regression as the spine fixes on PRs #83/#84:
+        // labels, hints, action URL, legend, css_classes all escape.
+        let col = RenderColumn::new(
+            "subject",
+            "<script>alert(1)</script>", // poisoned caption
+            ColumnKind::PrimaryLink,
+        );
+        let fields = vec![FormFieldSource {
+            column: &col,
+            css_classes: "<bad-css>",
+            hint: "<img src=x onerror=alert(2)>",
+            data: InputData::Text {
+                value: "<xss-value>".to_string(),
+                required: false,
+                placeholder: "<xss-placeholder>".to_string(),
+            },
+        }];
+        let src = render_form(
+            0x0102,
+            "project_work_item",
+            &FormSource {
+                method: "post",
+                action: "/<bad-action>",
+                csrf_token: "<xss-csrf>",
+                record_id: None,
+                legend: "<script>alert('legend')</script>",
+                submit_label: "<safe>Save</safe>",
+                cancel_label: "Cancel",
+                cancel_href: "",
+                fields,
+            },
+        )
+        .unwrap();
+        // No raw scripts / images / dangling-tag css survive
+        assert!(!src.contains("<script>alert(1)"), "label raw: {src}");
+        assert!(!src.contains("<img src=x onerror"), "hint raw: {src}");
+        assert!(!src.contains("<bad-css>"), "css raw: {src}");
+        assert!(!src.contains("<xss-value>"), "value raw: {src}");
+        assert!(!src.contains("<xss-placeholder>"), "placeholder raw: {src}");
+        assert!(!src.contains("<script>alert('legend')"), "legend raw: {src}");
+        assert!(!src.contains("<safe>Save</safe>"), "submit raw: {src}");
+        // action attribute gets escaped (the `<` becomes `&lt;`)
+        assert!(!src.contains("action=\"/<bad-action>\""), "action raw: {src}");
+        assert!(src.contains("action=\"/&lt;bad-action&gt;\""), "expected escaped action:\n{src}");
+    }
+
+    #[test]
+    fn input_kind_resolver_is_wired_through_render_kit() {
+        // Smoke: the form-side resolver re-exported from lib.rs is the
+        // one consumers call to pick input controls.
+        assert_eq!(default_input_kind_for("id", None), InputKind::Hidden);
+        assert_eq!(default_input_kind_for("done_ratio", None), InputKind::Range);
+        assert_eq!(default_input_kind_for("description", Some("text")), InputKind::TextArea);
+        assert_eq!(default_input_kind_for("position", Some("integer")), InputKind::Number);
+        assert_eq!(default_input_kind_for("active", Some("boolean")), InputKind::Checkbox);
+        assert_eq!(default_input_kind_for("start_date", Some("date")), InputKind::Date);
+        assert_eq!(default_input_kind_for("updated_at", Some("datetime")), InputKind::DateTime);
+        assert_eq!(default_input_kind_for("subject", Some("string")), InputKind::Text);
+    }
+
     #[test]
     fn rust_struct_escapes_keyword_attribute_names() {
         // Codex P1 on #78: `project_actor()` declares an attribute named
diff --git a/crates/ogar-render-askama/src/spec.rs b/crates/ogar-render-askama/src/spec.rs
index 6750895..1e35449 100644
--- a/crates/ogar-render-askama/src/spec.rs
+++ b/crates/ogar-render-askama/src/spec.rs
@@ -28,6 +28,11 @@ pub enum ArtifactKind {
     /// flavour**; mirror of Redmine's `show.html.erb`. Reuses every
     /// `RenderColumn` / `ColumnKind` / cell sub-template from T2.
     HtmlDetailView,
+    /// Create/edit HTML form rendered server-side via `askama_axum`.
+    /// **Render flavour**; mirror of Redmine's `_form.html.erb`. Same
+    /// `RenderColumn` shape; per-attribute `InputKind` dispatches to one
+    /// of nine `<input>` / `<textarea>` / `<select>` sub-templates.
+    HtmlForm,
     /// SurrealQL `DEFINE TABLE` + per-field `DEFINE FIELD` statements.
     /// **Codegen flavour** — DB engine is the final consumer.
     SurrealqlTable,
@@ -50,6 +55,7 @@ impl ArtifactKind {
         Self::RustStruct,
         Self::HtmlListView,
         Self::HtmlDetailView,
+        Self::HtmlForm,
         Self::SurrealqlTable,
         Self::OpenapiSchema,
         Self::NodeGuidRoutingArm,
@@ -62,6 +68,7 @@ impl ArtifactKind {
             Self::RustStruct => "rust_struct",
             Self::HtmlListView => "html_list_view",
             Self::HtmlDetailView => "html_detail_view",
+            Self::HtmlForm => "html_form",
             Self::SurrealqlTable => "surrealql_table",
             Self::OpenapiSchema => "openapi_schema",
             Self::NodeGuidRoutingArm => "node_guid_routing_arm",
diff --git a/crates/ogar-render-askama/templates/dispatch/html_form.askama b/crates/ogar-render-askama/templates/dispatch/html_form.askama
new file mode 100644
index 0000000..9eba42c
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/html_form.askama
@@ -0,0 +1,36 @@
+{# Form view — create/edit one canonical record. Substrate-agnostic;    #}
+{# driven by `fields` (per-attribute pre-rendered <input>s).            #}
+{# Pre-rendered field bodies are |safe (each sub-template escapes its   #}
+{# own variables); everything else is HTML-escaped by the spine.         #}
+<form class="ogar-form" data-class-id="{{ class_id_hex }}" data-concept="{{ canonical_concept }}" method="{{ method }}" action="{{ action }}">
+  {%- if !csrf_token.is_empty() %}
+  <input type="hidden" name="authenticity_token" value="{{ csrf_token }}">
+  {%- endif %}
+  {%- if !record_id_html.is_empty() %}
+  {{ record_id_html|safe }}
+  {%- endif %}
+  <fieldset class="form-fields">
+    {%- if !legend.is_empty() %}
+    <legend>{{ legend }}</legend>
+    {%- endif %}
+    {%- for field in fields %}
+      {%- if field.hidden %}
+      {{ field.body_html|safe }}
+      {%- else %}
+    <div class="form-field form-field-{{ field.name }}{% if !field.css_classes.is_empty() %} {{ field.css_classes }}{% endif %}">
+      <label for="field-{{ field.name }}">{{ field.label }}{% if field.required %} <span class="required">*</span>{% endif %}</label>
+      {{ field.body_html|safe }}
+      {%- if !field.hint.is_empty() %}
+      <small class="hint">{{ field.hint }}</small>
+      {%- endif %}
+    </div>
+      {%- endif %}
+    {%- endfor %}
+  </fieldset>
+  <div class="form-actions">
+    <button type="submit" class="btn-primary">{{ submit_label }}</button>
+    {%- if !cancel_href.is_empty() %}
+    <a href="{{ cancel_href }}" class="btn-cancel">{{ cancel_label }}</a>
+    {%- endif %}
+  </div>
+</form>
diff --git a/crates/ogar-render-askama/templates/dispatch/input/checkbox.askama b/crates/ogar-render-askama/templates/dispatch/input/checkbox.askama
new file mode 100644
index 0000000..3939a34
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/checkbox.askama
@@ -0,0 +1,4 @@
+{# Boolean checkbox. A hidden 0 field is emitted first so an unchecked #}
+{# box still POSTs `0` for the field (the Rails idiom).                  #}
+<input type="hidden" name="{{ name }}" value="0">
+<input type="checkbox" name="{{ name }}" id="field-{{ name }}" value="1"{% if checked %} checked{% endif %}>
diff --git a/crates/ogar-render-askama/templates/dispatch/input/date.askama b/crates/ogar-render-askama/templates/dispatch/input/date.askama
new file mode 100644
index 0000000..e3c0a9c
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/date.askama
@@ -0,0 +1,2 @@
+{# Date picker (ISO-8601 YYYY-MM-DD). #}
+<input type="date" name="{{ name }}" id="field-{{ name }}" value="{{ value }}"{% if required %} required{% endif %}>
diff --git a/crates/ogar-render-askama/templates/dispatch/input/datetime.askama b/crates/ogar-render-askama/templates/dispatch/input/datetime.askama
new file mode 100644
index 0000000..0abc2ec
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/datetime.askama
@@ -0,0 +1,2 @@
+{# DateTime picker (browser-local; value is ISO-8601 without timezone). #}
+<input type="datetime-local" name="{{ name }}" id="field-{{ name }}" value="{{ value }}"{% if required %} required{% endif %}>
diff --git a/crates/ogar-render-askama/templates/dispatch/input/hidden.askama b/crates/ogar-render-askama/templates/dispatch/input/hidden.askama
new file mode 100644
index 0000000..4e687d8
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/hidden.askama
@@ -0,0 +1,2 @@
+{# Hidden — id / round-trip slot. #}
+<input type="hidden" name="{{ name }}" value="{{ value }}">
diff --git a/crates/ogar-render-askama/templates/dispatch/input/number.askama b/crates/ogar-render-askama/templates/dispatch/input/number.askama
new file mode 100644
index 0000000..faf189c
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/number.askama
@@ -0,0 +1,2 @@
+{# Number input. #}
+<input type="number" name="{{ name }}" id="field-{{ name }}" value="{{ value }}"{% if required %} required{% endif %}{% if !step.is_empty() %} step="{{ step }}"{% endif %}>
diff --git a/crates/ogar-render-askama/templates/dispatch/input/range.askama b/crates/ogar-render-askama/templates/dispatch/input/range.askama
new file mode 100644
index 0000000..5445ac6
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/range.askama
@@ -0,0 +1,3 @@
+{# Range slider — percent / ratio. #}
+<input type="range" name="{{ name }}" id="field-{{ name }}" min="{{ min }}" max="{{ max }}" step="{{ step }}" value="{{ value }}">
+<output for="field-{{ name }}">{{ value }}{% if !suffix.is_empty() %}{{ suffix }}{% endif %}</output>
diff --git a/crates/ogar-render-askama/templates/dispatch/input/select.askama b/crates/ogar-render-askama/templates/dispatch/input/select.askama
new file mode 100644
index 0000000..df14f78
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/select.askama
@@ -0,0 +1,9 @@
+{# Select dropdown — for RecordRef / enumerated targets. #}
+<select name="{{ name }}" id="field-{{ name }}"{% if required %} required{% endif %}>
+  {%- if !required %}
+  <option value=""{% if value.is_empty() %} selected{% endif %}>—</option>
+  {%- endif %}
+  {%- for opt in options %}
+  <option value="{{ opt.value }}"{% if opt.value == value %} selected{% endif %}>{{ opt.label }}</option>
+  {%- endfor %}
+</select>
diff --git a/crates/ogar-render-askama/templates/dispatch/input/text.askama b/crates/ogar-render-askama/templates/dispatch/input/text.askama
new file mode 100644
index 0000000..2a9d5af
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/text.askama
@@ -0,0 +1,2 @@
+{# Text input — single-line string. #}
+<input type="text" name="{{ name }}" id="field-{{ name }}" value="{{ value }}"{% if required %} required{% endif %}{% if !placeholder.is_empty() %} placeholder="{{ placeholder }}"{% endif %}>
diff --git a/crates/ogar-render-askama/templates/dispatch/input/textarea.askama b/crates/ogar-render-askama/templates/dispatch/input/textarea.askama
new file mode 100644
index 0000000..fcee691
--- /dev/null
+++ b/crates/ogar-render-askama/templates/dispatch/input/textarea.askama
@@ -0,0 +1,2 @@
+{# Long-form text. Rows defaults to 6 unless overridden. #}
+<textarea name="{{ name }}" id="field-{{ name }}" rows="{{ rows }}"{% if required %} required{% endif %}{% if !placeholder.is_empty() %} placeholder="{{ placeholder }}"{% endif %}>{{ value }}</textarea>