From f46de3650465962766cbea0de129d2abc3feb114 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 30 Jun 2026 19:42:58 +0000
Subject: [PATCH 1/5] feat(rm-handlers): home overview page + "New issue" CTA
 on /issues
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The two deferred POC-polish items that make the demo navigable
end-to-end without hand-typing URLs.

- home: new cross-resource overview at `/` (rm_handlers::home). Lists
  every seeded concept (Issues, Projects, Time entries, News, Wiki,
  Users, Roles, Repositories, Issue statuses, Trackers, Priorities,
  Custom queries, Relations) with its live row count and a link to the
  resource's list route, plus a "New issue" quick action. Pure
  render_home() is split from the handler so the markup is unit-tested
  without booting a store; counts come from each Store::list_*().len()
  (becomes COUNT(*) when a SQL backend lands — handler shape unchanged).
- list_chrome: generic render_action_bar(&[(label, href)]) — Redmine's
  top-right `.contextual` action strip. HTML-escapes label + href; an
  empty slice yields no stray <nav>. W2/W3/detail pages reuse it.
- issues: wire the action bar into the list with a "New issue" link to
  the D1 create form (/issues/new).
- rm-server: mount home::router at `/` in build_router_with, replacing
  the storeless proof-of-shape index (which stays on the scaffolding
  build_router()).

CI gate green locally on toolchain 1.95: cargo fmt --all --check,
clippy --all-targets --workspace -D warnings, test --workspace
(6 new tests, all green).
---
 crates/rm-handlers/src/home.rs        | 230 ++++++++++++++++++++++++++
 crates/rm-handlers/src/issues.rs      |  28 +++-
 crates/rm-handlers/src/lib.rs         |   1 +
 crates/rm-handlers/src/list_chrome.rs |  57 +++++++
 crates/rm-server/src/router.rs        |   6 +-
 5 files changed, 314 insertions(+), 8 deletions(-)
 create mode 100644 crates/rm-handlers/src/home.rs

diff --git a/crates/rm-handlers/src/home.rs b/crates/rm-handlers/src/home.rs
new file mode 100644
index 0000000..ceffc8b
--- /dev/null
+++ b/crates/rm-handlers/src/home.rs
@@ -0,0 +1,230 @@
+//! Home / overview page (`GET /`).
+//!
+//! Redmine's landing page is a jumping-off point: a heading plus links
+//! into every resource. This is the rm-* equivalent — a single overview
+//! that lists each seeded concept with its live row count and links to
+//! that resource's list route. It's the first thing a demo visitor sees,
+//! so it doubles as the site map until G1's master template lands a
+//! persistent top nav.
+//!
+//! Unlike the W1..W8 resource modules this one is **cross-cutting**: it
+//! reads a count from every store table. On the in-memory store that's a
+//! cheap `list_*().len()`; when a SQL backend lands these become
+//! `COUNT(*)` and the handler shape doesn't change.
+//!
+//! Per Plan §8 file ownership it still owns exactly one file + one route
+//! (`/`), so it merges into `rm-server` the same way every W* track does.
+
+use std::fmt::Write as _;
+
+use axum::extract::State;
+use axum::response::Html;
+use axum::routing::get;
+use axum::Router;
+
+use crate::common::{html_escape, wrap_in_doc, AppState, HandlerError};
+
+/// One row of the overview index: a human label, the list route, and the
+/// live count of records behind it. Labels + hrefs are static (the route
+/// table is fixed); only `count` is read from the store.
+struct ResourceEntry {
+    label: &'static str,
+    href: &'static str,
+    count: usize,
+}
+
+/// `GET /` — the overview / landing page.
+///
+/// Reads one count per seeded resource and renders the index. Any store
+/// error short-circuits to a 500 via `?` — a dead store means nothing
+/// renders anyway, so there's no partial-page to salvage.
+pub async fn home(State(state): State<AppState>) -> Result<Html<String>, HandlerError> {
+    let s = &state.store;
+    // Counts in Redmine's sidebar grouping: work first, then taxonomy,
+    // then people, then SCM / meta. Each `?` bubbles a store failure.
+    let entries = [
+        ResourceEntry {
+            label: "Issues",
+            href: "/issues",
+            count: s.list_issues().await?.len(),
+        },
+        ResourceEntry {
+            label: "Projects",
+            href: "/projects",
+            count: s.list_projects().await?.len(),
+        },
+        ResourceEntry {
+            label: "Time entries",
+            href: "/time_entries",
+            count: s.list_time_entries().await?.len(),
+        },
+        ResourceEntry {
+            label: "News",
+            href: "/news",
+            count: s.list_news().await?.len(),
+        },
+        ResourceEntry {
+            label: "Wiki pages",
+            href: "/wiki",
+            count: s.list_wiki_pages().await?.len(),
+        },
+        ResourceEntry {
+            label: "Users",
+            href: "/users",
+            count: s.list_users().await?.len(),
+        },
+        ResourceEntry {
+            label: "Roles",
+            href: "/roles",
+            count: s.list_roles().await?.len(),
+        },
+        ResourceEntry {
+            label: "Repositories",
+            href: "/repositories",
+            count: s.list_repositories().await?.len(),
+        },
+        ResourceEntry {
+            label: "Issue statuses",
+            href: "/issue_statuses",
+            count: s.list_issue_statuses().await?.len(),
+        },
+        ResourceEntry {
+            label: "Trackers",
+            href: "/trackers",
+            count: s.list_trackers().await?.len(),
+        },
+        ResourceEntry {
+            label: "Priorities",
+            href: "/enumerations/issue_priorities",
+            count: s.list_issue_priorities().await?.len(),
+        },
+        ResourceEntry {
+            label: "Custom queries",
+            href: "/queries",
+            count: s.list_queries().await?.len(),
+        },
+        ResourceEntry {
+            label: "Relations",
+            href: "/relations",
+            count: s.list_relations().await?.len(),
+        },
+    ];
+    let body = render_home(&entries);
+    Ok(Html(wrap_in_doc("Home", &body)))
+}
+
+/// Pure render of the overview page from the resource counts. Split from
+/// [`home`] so the markup is unit-testable without booting a store. All
+/// labels + hrefs are HTML-escaped (uniform with the rest of the chrome,
+/// even though today's values are static).
+fn render_home(entries: &[ResourceEntry]) -> String {
+    let mut out = String::with_capacity(512 + 96 * entries.len());
+    out.push_str(r#"<main class="home">"#);
+    out.push_str("<h1>Redmine RS</h1>");
+    out.push_str(
+        r#"<p class="tagline">A faithful Redmine port on the OGAR canonical-vocabulary render kit.</p>"#,
+    );
+    // Quick-action row mirrors Redmine's home "+ New issue" jump.
+    out.push_str(r#"<nav class="contextual" aria-label="Quick actions">"#);
+    out.push_str(r#"<a class="action" href="/issues/new">New issue</a>"#);
+    out.push_str("</nav>");
+    out.push_str(r#"<section class="overview"><h2>Overview</h2><ul class="resource-index">"#);
+    for e in entries {
+        let _ = write!(
+            &mut out,
+            r#"<li class="resource"><a href="{href}">{label}</a> <span class="count">{count}</span></li>"#,
+            href = html_escape(e.href),
+            label = html_escape(e.label),
+            count = e.count,
+        );
+    }
+    out.push_str("</ul></section></main>");
+    out
+}
+
+/// Build the home router. `rm-server` merges this at `/` — it's the one
+/// route that owns the document root, so it sorts first in the merge
+/// block.
+pub fn router(state: AppState) -> Router {
+    Router::new().route("/", get(home)).with_state(state)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::body::Body;
+    use axum::http::{Request, StatusCode};
+    use http_body_util::BodyExt;
+    use rm_store::{NewIssue, Store};
+    use tower::ServiceExt;
+
+    #[test]
+    fn render_home_lists_entries_with_counts_and_links() {
+        let entries = [
+            ResourceEntry {
+                label: "Issues",
+                href: "/issues",
+                count: 27,
+            },
+            ResourceEntry {
+                label: "Projects",
+                href: "/projects",
+                count: 3,
+            },
+        ];
+        let html = render_home(&entries);
+        assert!(html.contains(r#"href="/issues""#), "{html}");
+        assert!(html.contains(">Issues</a>"), "{html}");
+        assert!(
+            html.contains(r#"<span class="count">27</span>"#),
+            "issue count missing:\n{html}"
+        );
+        assert!(html.contains(r#"href="/projects""#), "{html}");
+        assert!(
+            html.contains(r#"<span class="count">3</span>"#),
+            "project count missing:\n{html}"
+        );
+        // The New issue quick-action is always present (it doesn't depend
+        // on the counts).
+        assert!(
+            html.contains(r#"href="/issues/new""#),
+            "new-issue quick action missing:\n{html}"
+        );
+    }
+
+    #[tokio::test]
+    async fn home_route_renders_overview_with_live_counts() {
+        let store = Store::open().await.expect("store boots");
+        // Seed three issues so the issues row count is observable end-to-end.
+        for subject in ["one", "two", "three"] {
+            store
+                .create_issue(NewIssue {
+                    subject: subject.to_string(),
+                    description: None,
+                })
+                .await
+                .expect("seed insert");
+        }
+        let app = router(AppState { store });
+        let res = app
+            .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        let bytes = res.into_body().collect().await.unwrap().to_bytes();
+        let s = String::from_utf8(bytes.to_vec()).unwrap();
+        assert!(s.contains("Redmine RS"), "title heading missing:\n{s}");
+        assert!(s.contains(r#"href="/issues""#), "issues link missing:\n{s}");
+        // 3 seeded issues → the issues row shows count 3.
+        assert!(
+            s.contains(r#"<span class="count">3</span>"#),
+            "expected issue count 3:\n{s}"
+        );
+        // Cross-resource: the projects link renders even with 0 projects,
+        // proving the overview spans every table, not just the seeded one.
+        assert!(
+            s.contains(r#"href="/projects""#),
+            "projects link missing:\n{s}"
+        );
+    }
+}
diff --git a/crates/rm-handlers/src/issues.rs b/crates/rm-handlers/src/issues.rs
index 55e4fef..2357369 100644
--- a/crates/rm-handlers/src/issues.rs
+++ b/crates/rm-handlers/src/issues.rs
@@ -49,7 +49,7 @@ use rm_store::IssueRow;
 use surrealdb_types::{RecordId, ToSql};
 
 use crate::common::{html_escape, record_id_to_u64, wrap_in_doc, AppState, HandlerError};
-use crate::list_chrome::{ListQuery, SortDir};
+use crate::list_chrome::{render_action_bar, ListQuery, SortDir};
 
 /// The list URL — used by the chrome to build self-referential links
 /// (filter form action, sort headers, pagination Prev/Next).
@@ -117,14 +117,16 @@ pub async fn list(
     let table = render_list("Issues", 0x0102, "project_work_item", &cols, &[], &rows)
         .map_err(|e| HandlerError::Render(e.to_string()))?;
 
-    // Chrome composes around the table: filter bar above (with search +
-    // clear), clickable sort headers (column-by-column links over the
-    // existing table rows — emitted as a small nav block above the
-    // table), and pagination strip below.
+    // Chrome composes around the table: the contextual action bar at the
+    // very top (Redmine's "+ New issue" jump), filter bar below it (search
+    // + clear), clickable sort headers (column-by-column links over the
+    // existing table rows — emitted as a small nav block above the table),
+    // and pagination strip below.
+    let action_bar = render_action_bar(&[("New issue", "/issues/new")]);
     let filter_bar = q.render_filter_bar(LIST_PATH, "Filter by subject");
     let sort_nav = render_sort_nav(&q);
     let pagination = q.render_pagination(LIST_PATH, total);
-    let body = format!("{filter_bar}\n{sort_nav}\n{table}\n{pagination}");
+    let body = format!("{action_bar}\n{filter_bar}\n{sort_nav}\n{table}\n{pagination}");
     Ok(Html(wrap_in_doc("Issues", &body)))
 }
 
@@ -321,6 +323,20 @@ mod tests {
         assert!(s.contains("list-filter"), "filter bar always renders:\n{s}");
     }
 
+    #[tokio::test]
+    async fn list_shows_new_issue_action_link() {
+        // The Redmine "+ New issue" CTA must sit on the list page and point
+        // at the D1 create form — present even on an empty list (that's the
+        // whole point of the empty state: a place to start adding).
+        let app = app_with_issues(&[]).await;
+        let (status, s) = body_of(app, "/issues").await;
+        assert_eq!(status, StatusCode::OK);
+        assert!(
+            s.contains(r#"href="/issues/new""#) && s.contains("New issue"),
+            "expected a New issue CTA linking to the create form:\n{s}"
+        );
+    }
+
     #[tokio::test]
     async fn list_renders_seeded_issues() {
         let app =
diff --git a/crates/rm-handlers/src/lib.rs b/crates/rm-handlers/src/lib.rs
index 91beb6b..22c3dfc 100644
--- a/crates/rm-handlers/src/lib.rs
+++ b/crates/rm-handlers/src/lib.rs
@@ -46,6 +46,7 @@
 #![warn(missing_docs)]
 
 mod common;
+pub mod home;
 pub mod issues;
 pub mod issues_form;
 pub mod list_chrome;
diff --git a/crates/rm-handlers/src/list_chrome.rs b/crates/rm-handlers/src/list_chrome.rs
index 57f27c8..3a3061b 100644
--- a/crates/rm-handlers/src/list_chrome.rs
+++ b/crates/rm-handlers/src/list_chrome.rs
@@ -294,6 +294,38 @@ impl ListQuery {
     }
 }
 
+/// Render a Redmine-style **contextual action bar** — the strip of
+/// action links (e.g. "New issue") Redmine renders top-right of a list
+/// or detail page, in the `#content`'s `.contextual` slot.
+///
+/// Each entry is `(label, href)`. Both are HTML-escaped: the label is
+/// user-facing text and the href lands in an attribute, so even though
+/// today's callers pass static strings, escaping keeps the contract
+/// uniform with the rest of the chrome. An empty slice yields an empty
+/// string — no stray `<nav>` in the document.
+///
+/// Generic on purpose: W2 ("New project"), W3 ("Log time"), and the
+/// issue detail page ("Edit" / "Delete") reuse this strip instead of
+/// each hand-rolling its own link row.
+#[must_use]
+pub fn render_action_bar(actions: &[(&str, &str)]) -> String {
+    if actions.is_empty() {
+        return String::new();
+    }
+    let mut out = String::with_capacity(48 + 40 * actions.len());
+    out.push_str(r#"<nav class="contextual" aria-label="Actions">"#);
+    for (label, href) in actions {
+        let _ = write!(
+            &mut out,
+            r#"<a class="action" href="{}">{}</a>"#,
+            html_escape(href),
+            html_escape(label)
+        );
+    }
+    out.push_str("</nav>");
+    out
+}
+
 /// Percent-encode a single query-string value. Conservative: anything
 /// outside the URL-unreserved set (`A-Z a-z 0-9 - . _ ~`) is `%HH`-escaped.
 fn percent_encode(s: &str) -> String {
@@ -554,4 +586,29 @@ mod tests {
         assert_eq!(percent_encode("a b"), "a%20b");
         assert_eq!(percent_encode("&=?#"), "%26%3D%3F%23");
     }
+
+    #[test]
+    fn action_bar_renders_each_link_in_a_contextual_nav() {
+        let bar = render_action_bar(&[("New issue", "/issues/new")]);
+        assert!(bar.contains(r#"class="contextual""#), "{bar}");
+        assert!(bar.contains(r#"href="/issues/new""#), "{bar}");
+        assert!(bar.contains(">New issue</a>"), "{bar}");
+    }
+
+    #[test]
+    fn action_bar_is_empty_for_no_actions() {
+        // No empty `<nav>` clutters the page when a resource has no actions.
+        assert!(render_action_bar(&[]).is_empty());
+    }
+
+    #[test]
+    fn action_bar_escapes_label_and_href() {
+        let bar = render_action_bar(&[("<x>", "/a?b=c&d=e")]);
+        assert!(!bar.contains("<x>"), "label not escaped: {bar}");
+        assert!(bar.contains("&lt;x&gt;"), "{bar}");
+        assert!(
+            bar.contains("/a?b=c&amp;d=e"),
+            "href ampersand not escaped: {bar}"
+        );
+    }
 }
diff --git a/crates/rm-server/src/router.rs b/crates/rm-server/src/router.rs
index 2797377..8e97498 100644
--- a/crates/rm-server/src/router.rs
+++ b/crates/rm-server/src/router.rs
@@ -72,15 +72,17 @@ pub fn build_router() -> Router {
 /// conflict.
 ///
 /// Today's mounts:
+/// - `rm_handlers::home::router(state)` — `/` (cross-resource overview)
 /// - `rm_auth::router(auth_cfg)` — `/login`, `/logout`, `/me`
 /// - `rm_handlers::issues::router(state)` — `/issues`, `/issues/:id` (W1)
 pub fn build_router_with(store: Store, auth_cfg: AuthConfig) -> Router {
     let state = AppState { store };
     Router::new()
-        .route("/", get(index))
         .route("/healthz", get(healthz))
         // ── W* width tracks — keep merge calls alphabetised on the URL
-        //    path so parallel branches don't conflict on this file. ──
+        //    path so parallel branches don't conflict on this file. The
+        //    home overview owns `/`, so it sorts first. ──
+        .merge(rm_handlers::home::router(state.clone())) // Home: / (overview)
         .merge(rm_handlers::issues::router(state.clone())) // W1: /issues
         .merge(rm_handlers::issues_form::router(state.clone())) // D1: /issues/new + POST /issues
         .merge(rm_handlers::news::router(state.clone())) // W6a: /news

From 152dc6301a878b415734eafa166ac454759868aa Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 30 Jun 2026 20:15:12 +0000
Subject: [PATCH 2/5] feat(rm-handlers): Redmine-shaped master layout (global
 top menu)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

wrap_in_doc now emits the master-layout skeleton every page shares:

- #top-menu — persistent global nav (Home, Projects, Issues, Spent
  time, News, Wiki) as a const, spliced verbatim (no per-request alloc
  beyond the outer format!).
- #header — app title linking home.
- #main > #content — the fragment wrapper.
- viewport meta for the eventual responsive stylesheet.

The id/class hooks mirror Redmine's own markup so G1's base.askama
template + stylesheet drop in cosmetically over this shell. Title stays
HTML-escaped (XSS guard, codex P1 on PR #10). All existing page-body
assertions are substring checks, so the added chrome doesn't break them.

CI gate green on toolchain 1.95: fmt --all --check, clippy --all-targets
--workspace -D warnings, test --workspace.
---
 crates/rm-handlers/src/common.rs | 65 +++++++++++++++++++++++++++++---
 1 file changed, 59 insertions(+), 6 deletions(-)

diff --git a/crates/rm-handlers/src/common.rs b/crates/rm-handlers/src/common.rs
index 8f1a7b8..818b3b3 100644
--- a/crates/rm-handlers/src/common.rs
+++ b/crates/rm-handlers/src/common.rs
@@ -96,10 +96,29 @@ fn hex_nibble(n: u8) -> char {
     }
 }
 
-/// Wrap a fragment in a minimal HTML5 document. G1 (Plan §5 GUI
-/// chrome) will replace this with the master `base.askama` template
-/// — at that point this fn deletes and every handler uses
-/// `askama_axum::Template` directly.
+/// Redmine's global `#top-menu` — the persistent bar of cross-app links
+/// rendered on every page. The link set is fixed, so it's a `const` the
+/// formatter splices in verbatim (no per-request allocation beyond the
+/// outer `format!`). Mirrors Redmine's top menu shape (Home + the global
+/// resource lists); the `id`/`class` hooks match Redmine so G1's
+/// stylesheet drops straight in over this skeleton.
+const TOP_MENU: &str = concat!(
+    r#"<div id="top-menu"><ul class="menu">"#,
+    r#"<li><a class="home" href="/">Home</a></li>"#,
+    r#"<li><a href="/projects">Projects</a></li>"#,
+    r#"<li><a href="/issues">Issues</a></li>"#,
+    r#"<li><a href="/time_entries">Spent time</a></li>"#,
+    r#"<li><a href="/news">News</a></li>"#,
+    r#"<li><a href="/wiki">Wiki</a></li>"#,
+    r#"</ul></div>"#,
+);
+
+/// Wrap a fragment in the **master-layout skeleton** — an HTML5 document
+/// carrying Redmine's persistent chrome: the global `#top-menu` nav, the
+/// `#header` app title, and a `#main` > `#content` wrapper the fragment
+/// lands in. G1 (Plan §5 GUI chrome) swaps this Rust-built shell for the
+/// real `base.askama` master template + a stylesheet; the markup shape
+/// (ids/classes) is already Redmine-compatible so that swap is cosmetic.
 ///
 /// The `title` parameter is **HTML-escaped** — handlers pass
 /// user-controlled strings (issue subjects, project names) and the
@@ -109,15 +128,21 @@ fn hex_nibble(n: u8) -> char {
 ///
 /// `body` is treated as already-rendered HTML — askama-emitted by
 /// the kit's `render_list` / `render_detail`, which run their own
-/// `escape = "html"` on data-derived strings.
+/// `escape = "html"` on data-derived strings — and the handler-built
+/// chrome (`render_action_bar`, the filter/sort/pagination strips),
+/// which escape their own user-derived inputs.
 #[must_use]
 pub fn wrap_in_doc(title: &str, body: &str) -> String {
     let escaped_title = html_escape(title);
     format!(
         "<!doctype html>\n<html lang=\"en\">\n<head>\
          <meta charset=\"utf-8\">\
+         <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\
          <title>{escaped_title} · Redmine RS</title>\
-         </head><body>{body}</body></html>"
+         </head><body>{TOP_MENU}\
+         <div id=\"header\"><h1><a href=\"/\">Redmine RS</a></h1></div>\
+         <div id=\"main\"><div id=\"content\">{body}</div></div>\
+         </body></html>"
     )
 }
 
@@ -209,6 +234,34 @@ mod tests {
         );
     }
 
+    #[test]
+    fn wrap_in_doc_renders_global_top_menu_and_content_wrapper() {
+        // Every page carries Redmine's persistent chrome: the global
+        // top menu, the app header, and a #content wrapper the fragment
+        // lands inside.
+        let html = wrap_in_doc("Issues", "<p>body</p>");
+        assert!(
+            html.contains(r#"id="top-menu""#),
+            "top menu missing:\n{html}"
+        );
+        assert!(
+            html.contains(r#"<a class="home" href="/">Home</a>"#),
+            "Home link missing:\n{html}"
+        );
+        assert!(
+            html.contains(r#"href="/projects""#) && html.contains(r#"href="/issues""#),
+            "global resource links missing:\n{html}"
+        );
+        assert!(
+            html.contains(r#"id="content""#),
+            "content wrapper missing:\n{html}"
+        );
+        // The fragment still renders inside the shell.
+        assert!(html.contains("<p>body</p>"), "body not wrapped:\n{html}");
+        // Viewport meta for the eventual responsive stylesheet.
+        assert!(html.contains("viewport"), "viewport meta missing:\n{html}");
+    }
+
     #[test]
     fn html_escape_covers_the_five_chars() {
         assert_eq!(html_escape("&<>\"'"), "&amp;&lt;&gt;&quot;&#39;");

From 56e6d8426a756e3f2e6ab9e6505dc2153d319957 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 30 Jun 2026 20:16:41 +0000
Subject: [PATCH 3/5] feat(rm-handlers): Project create form + "New project"
 CTA
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

D1 create flow for Project, mirroring issues_form one resource over.

- projects_form: GET /projects/new + POST /projects. Name (required,
  <=255) + Identifier (required, <=100, Redmine slug rule: starts with a
  lowercase letter, then [a-z0-9_-]). 303 to /projects/<identifier> on
  success (POST-redirect-GET); 200 re-render with inline errors on
  failure, input preserved. Pure validate() + is_valid_identifier() are
  fully unit-tested.
- projects: "+ New project" contextual action on the list -> /projects/new.
- rm-server: merge projects_form::router. The static /projects/new
  coexists with /projects/:identifier — matchit gives the static segment
  priority, same proven shape as /issues/new vs /issues/:id.

CI gate green on toolchain 1.95: fmt --all --check, clippy --all-targets
--workspace -D warnings, test --workspace.
---
 crates/rm-handlers/src/lib.rs           |   1 +
 crates/rm-handlers/src/projects.rs      |  29 +-
 crates/rm-handlers/src/projects_form.rs | 411 ++++++++++++++++++++++++
 crates/rm-server/src/router.rs          |   1 +
 4 files changed, 441 insertions(+), 1 deletion(-)
 create mode 100644 crates/rm-handlers/src/projects_form.rs

diff --git a/crates/rm-handlers/src/lib.rs b/crates/rm-handlers/src/lib.rs
index 22c3dfc..6f70bf1 100644
--- a/crates/rm-handlers/src/lib.rs
+++ b/crates/rm-handlers/src/lib.rs
@@ -52,6 +52,7 @@ pub mod issues_form;
 pub mod list_chrome;
 pub mod news;
 pub mod projects;
+pub mod projects_form;
 pub mod queries;
 pub mod relations;
 pub mod roles;
diff --git a/crates/rm-handlers/src/projects.rs b/crates/rm-handlers/src/projects.rs
index 04e157f..a69be93 100644
--- a/crates/rm-handlers/src/projects.rs
+++ b/crates/rm-handlers/src/projects.rs
@@ -23,6 +23,7 @@ use rm_store::ProjectRow;
 use crate::common::{
     encode_path_segment, html_escape, identifier_to_u64, wrap_in_doc, AppState, HandlerError,
 };
+use crate::list_chrome::render_action_bar;
 
 /// `GET /projects` — render the project list.
 pub async fn list(State(state): State<AppState>) -> Result<Html<String>, HandlerError> {
@@ -63,8 +64,11 @@ pub async fn list(State(state): State<AppState>) -> Result<Html<String>, Handler
             block: Vec::new(),
         })
         .collect();
-    let body = render_list("Projects", 0x0101, "project", &cols, &[], &rows)
+    let table = render_list("Projects", 0x0101, "project", &cols, &[], &rows)
         .map_err(|e| HandlerError::Render(e.to_string()))?;
+    // Redmine's "+ New project" contextual action, top-right of the list.
+    let action_bar = render_action_bar(&[("New project", "/projects/new")]);
+    let body = format!("{action_bar}\n{table}");
     Ok(Html(wrap_in_doc("Projects", &body)))
 }
 
@@ -212,6 +216,29 @@ mod tests {
         assert!(s.contains("href=\"/projects/beta-proj\""), "{s}");
     }
 
+    #[tokio::test]
+    async fn list_shows_new_project_action_link() {
+        // The "+ New project" CTA links the list to the D1 create form,
+        // present even on an empty list.
+        let app = app_with_projects(&[]).await;
+        let res = app
+            .oneshot(
+                Request::builder()
+                    .uri("/projects")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        let body = res.into_body().collect().await.unwrap().to_bytes();
+        let s = std::str::from_utf8(&body).unwrap();
+        assert!(
+            s.contains(r#"href="/projects/new""#) && s.contains("New project"),
+            "expected a New project CTA linking to the create form:\n{s}"
+        );
+    }
+
     #[tokio::test]
     async fn detail_renders_by_identifier() {
         let app = app_with_projects(&[("My Project", "my-proj")]).await;
diff --git a/crates/rm-handlers/src/projects_form.rs b/crates/rm-handlers/src/projects_form.rs
new file mode 100644
index 0000000..6b7cb13
--- /dev/null
+++ b/crates/rm-handlers/src/projects_form.rs
@@ -0,0 +1,411 @@
+//! **D1** — Project (`project`) create form.
+//!
+//! The depth follow-on to the W2 `/projects` list/detail on the same
+//! surface, mirroring [`crate::issues_form`] exactly one resource over.
+//! Redmine's project-creation flow: list page → "New project" → form with
+//! Name (required) + Identifier (required, URL slug) → submit → land on the
+//! new project's detail page (`/projects/<identifier>`).
+//!
+//! - `GET /projects/new` — render an empty form
+//! - `POST /projects` — validate, create, **303 See Other** to
+//!   `/projects/<identifier>` on success; re-render with inline errors on
+//!   validation failure.
+//!
+//! # Today's scope
+//!
+//! - **Create only** — edit (`PATCH`) is a follow-on, same as issues.
+//! - **Name required**, trimmed, **max 255** (Redmine's column cap).
+//! - **Identifier required**, trimmed, **max 100**, and constrained to
+//!   Redmine's slug rule: starts with a lowercase letter, then lowercase
+//!   letters / digits / `-` / `_`. Rejecting at the form boundary surfaces
+//!   the rule as a Redmine-shaped validation error instead of a DB failure
+//!   (and keeps the redirect target URL-safe).
+//! - **No CSRF token yet** (`csrf_token: ""`) — rm-auth's concern, opted
+//!   into when that infra is shared (same seam as issues_form).
+//! - **No description / homepage / parent / module fields** — those
+//!   columns land on `ProjectRow` later; the form grows one field per
+//!   column with no chrome change.
+
+use axum::extract::State;
+use axum::http::StatusCode;
+use axum::response::{Html, IntoResponse, Redirect, Response};
+use axum::routing::{get, post};
+use axum::{Form, Router};
+use ogar_render_askama::{
+    render_form, ColumnKind, FormFieldSource, FormSource, InputData, RenderColumn,
+};
+use rm_store::NewProject;
+use serde::Deserialize;
+
+use crate::common::{encode_path_segment, wrap_in_doc, AppState, HandlerError};
+
+/// The submit URL — also the action the GET form points to.
+const SUBMIT_PATH: &str = "/projects";
+
+/// Max project name length — Redmine's `projects.name` column cap.
+const NAME_MAX_LEN: usize = 255;
+
+/// Max identifier length — Redmine's `projects.identifier` cap.
+const IDENT_MAX_LEN: usize = 100;
+
+/// Form submission shape — Axum's `Form<T>` deserializes the
+/// `application/x-www-form-urlencoded` body into this.
+#[derive(Debug, Clone, Default, Deserialize)]
+pub struct ProjectForm {
+    /// Submitted display name. Required at validation time (after trimming).
+    #[serde(default)]
+    pub name: String,
+    /// Submitted URL slug. Required + slug-constrained (see [`validate`]).
+    #[serde(default)]
+    pub identifier: String,
+}
+
+/// `GET /projects/new` — render an empty create form.
+pub async fn new_form(State(_state): State<AppState>) -> Result<Html<String>, HandlerError> {
+    render(&ProjectForm::default(), &[])
+}
+
+/// `POST /projects` — accept submission, validate, persist, redirect.
+///
+/// `303 See Other` → `/projects/<identifier>` on success (POST-redirect-GET
+/// so a refresh doesn't re-submit); `200 OK` re-rendering the form with
+/// inline errors on validation failure, preserving the user's input.
+pub async fn create(
+    State(state): State<AppState>,
+    Form(form): Form<ProjectForm>,
+) -> Result<Response, HandlerError> {
+    let errors = validate(&form);
+    if !errors.is_empty() {
+        let html = render(&form, &errors)?;
+        return Ok((StatusCode::OK, html).into_response());
+    }
+    let new = NewProject {
+        name: form.name.trim().to_string(),
+        identifier: form.identifier.trim().to_string(),
+    };
+    let project = state.store.create_project(new).await?;
+    // `identifier` is validated URL-safe; `encode_path_segment` is a no-op
+    // for the slug charset but keeps the redirect defensive by contract.
+    Ok(Redirect::to(&format!(
+        "/projects/{}",
+        encode_path_segment(&project.identifier)
+    ))
+    .into_response())
+}
+
+/// Validate the form. Returns human-readable error strings — empty when
+/// acceptable. Pure so the unit tests hit every branch without axum.
+fn validate(form: &ProjectForm) -> Vec<&'static str> {
+    let mut errs: Vec<&'static str> = Vec::new();
+
+    let name = form.name.trim();
+    if name.is_empty() {
+        errs.push("Name is required.");
+    }
+    if name.chars().count() > NAME_MAX_LEN {
+        errs.push("Name must be 255 characters or fewer.");
+    }
+
+    // Flat checks (no nested-if) so clippy's collapsible lints stay quiet;
+    // the `!is_empty()` guards stop a blank identifier from also tripping
+    // the length / charset messages on top of "required".
+    let ident = form.identifier.trim();
+    if ident.is_empty() {
+        errs.push("Identifier is required.");
+    }
+    if !ident.is_empty() && ident.chars().count() > IDENT_MAX_LEN {
+        errs.push("Identifier must be 100 characters or fewer.");
+    }
+    if !ident.is_empty() && !is_valid_identifier(ident) {
+        errs.push(
+            "Identifier may contain only lowercase letters, numbers, hyphens and underscores, \
+             and must start with a letter.",
+        );
+    }
+    errs
+}
+
+/// Redmine's project-identifier slug rule: first char a lowercase ASCII
+/// letter, the rest lowercase letters / digits / `-` / `_`. Pure +
+/// allocation-free so it's cheap to call and trivially testable.
+fn is_valid_identifier(s: &str) -> bool {
+    let mut chars = s.chars();
+    match chars.next() {
+        Some(c) if c.is_ascii_lowercase() => {}
+        _ => return false,
+    }
+    chars.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-' || c == '_')
+}
+
+/// Render the create form, optionally with validation errors above the
+/// fields. Pure helper around the kit — used by both `GET /projects/new`
+/// and the POST validation-failure branch.
+fn render(form: &ProjectForm, errors: &[&str]) -> Result<Html<String>, HandlerError> {
+    let cols = form_columns();
+    let fields = vec![
+        FormFieldSource {
+            column: &cols[0],
+            css_classes: "",
+            hint: "Display name shown in lists and navigation. Required.",
+            data: InputData::Text {
+                value: form.name.clone(),
+                required: true,
+                placeholder: String::new(),
+            },
+        },
+        FormFieldSource {
+            column: &cols[1],
+            css_classes: "",
+            hint: "URL slug: lowercase letters, numbers, hyphens, underscores; \
+                   starts with a letter. Required and unique.",
+            data: InputData::Text {
+                value: form.identifier.clone(),
+                required: true,
+                placeholder: String::from("my-project"),
+            },
+        },
+    ];
+    let src = FormSource {
+        method: "post",
+        action: SUBMIT_PATH,
+        csrf_token: "", // rm-auth integration is its own follow-on
+        record_id: None,
+        legend: "New project",
+        submit_label: "Create",
+        cancel_label: "Cancel",
+        cancel_href: SUBMIT_PATH,
+        fields,
+    };
+    let form_html =
+        render_form(0x0101, "project", &src).map_err(|e| HandlerError::Render(e.to_string()))?;
+    let errors_html = render_errors(errors);
+    let body = format!("{errors_html}{form_html}");
+    Ok(Html(wrap_in_doc("New project", &body)))
+}
+
+/// Render the validation-error block above the form. Empty string when
+/// there are no errors. Errors are `&'static str` literals from
+/// [`validate`] — no user-controlled content reaches the HTML here.
+///
+/// Duplicated from [`crate::issues_form`] by the project's "factor on the
+/// third caller" rule (Plan §1.6); the third form module (TimeEntry /
+/// News) triggers the lift into `common`.
+fn render_errors(errors: &[&str]) -> String {
+    if errors.is_empty() {
+        return String::new();
+    }
+    let mut out = String::with_capacity(64 + errors.len() * 32);
+    out.push_str(r#"<div class="form-errors" role="alert"><ul>"#);
+    for e in errors {
+        out.push_str("<li>");
+        out.push_str(e);
+        out.push_str("</li>");
+    }
+    out.push_str("</ul></div>");
+    out
+}
+
+/// Form columns: Name (primary) + Identifier (plain). The kit reads
+/// `required` from each field's `InputData`, not the column.
+fn form_columns() -> [RenderColumn; 2] {
+    [
+        RenderColumn::new("name", "Name", ColumnKind::PrimaryLink),
+        RenderColumn::new("identifier", "Identifier", ColumnKind::Plain),
+    ]
+}
+
+/// Build the D1 form router (`GET /projects/new` + `POST /projects`) that
+/// `rm-server` merges alongside `projects::router`.
+pub fn router(state: AppState) -> Router {
+    Router::new()
+        .route("/projects/new", get(new_form))
+        .route("/projects", post(create))
+        .with_state(state)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::body::Body;
+    use axum::http::{header, Method, Request, StatusCode};
+    use http_body_util::BodyExt;
+    use rm_store::Store;
+    use tower::ServiceExt;
+
+    async fn app() -> Router {
+        let store = Store::open().await.expect("store boots");
+        router(AppState { store })
+    }
+
+    async fn submit(app: Router, body: &str) -> (StatusCode, Option<String>, String) {
+        let res = app
+            .oneshot(
+                Request::builder()
+                    .method(Method::POST)
+                    .uri(SUBMIT_PATH)
+                    .header(header::CONTENT_TYPE, "application/x-www-form-urlencoded")
+                    .body(Body::from(body.to_string()))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        let status = res.status();
+        let location = res
+            .headers()
+            .get(header::LOCATION)
+            .map(|v| v.to_str().unwrap().to_string());
+        let bytes = res.into_body().collect().await.unwrap().to_bytes();
+        let s = String::from_utf8(bytes.to_vec()).unwrap();
+        (status, location, s)
+    }
+
+    // ── GET /projects/new ───────────────────────────────────────────
+
+    #[tokio::test]
+    async fn get_new_renders_empty_form_with_name_and_identifier_fields() {
+        let res = app()
+            .await
+            .oneshot(
+                Request::builder()
+                    .uri("/projects/new")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        let body = res.into_body().collect().await.unwrap().to_bytes();
+        let s = String::from_utf8(body.to_vec()).unwrap();
+        assert!(s.contains(r#"action="/projects""#), "form action:\n{s}");
+        assert!(s.contains(r#"method="post""#), "form method:\n{s}");
+        assert!(s.contains(r#"name="name""#), "name field:\n{s}");
+        assert!(s.contains(r#"name="identifier""#), "identifier field:\n{s}");
+        assert!(
+            s.contains(r#"data-class-id="0x0101""#),
+            "class id stamped:\n{s}"
+        );
+        assert!(!s.contains("form-errors"), "no errors on empty form:\n{s}");
+    }
+
+    // ── POST /projects — success path ───────────────────────────────
+
+    #[tokio::test]
+    async fn post_with_valid_fields_creates_and_redirects_to_identifier() {
+        let app = app().await;
+        let (status, location, _) = submit(app, "name=My+Project&identifier=my-project").await;
+        assert_eq!(status, StatusCode::SEE_OTHER, "must 303 on success");
+        assert_eq!(
+            location.as_deref(),
+            Some("/projects/my-project"),
+            "redirect must target the new project's slug"
+        );
+    }
+
+    #[tokio::test]
+    async fn post_trims_whitespace_before_persisting() {
+        let app = app().await;
+        let (status, location, _) = submit(app, "name=++Spaced++&identifier=++spaced++").await;
+        assert_eq!(status, StatusCode::SEE_OTHER);
+        // Trimmed identifier in the redirect proves the trim happened.
+        assert_eq!(location.as_deref(), Some("/projects/spaced"));
+    }
+
+    // ── POST /projects — validation-failure paths ───────────────────
+
+    #[tokio::test]
+    async fn post_with_empty_name_re_renders_with_error() {
+        let app = app().await;
+        let (status, _, s) = submit(app, "name=&identifier=ok").await;
+        assert_eq!(
+            status,
+            StatusCode::OK,
+            "validation failure must not redirect"
+        );
+        assert!(s.contains("Name is required"), "name error:\n{s}");
+        assert!(s.contains("form-errors"), "error block:\n{s}");
+        assert!(
+            s.contains(r#"action="/projects""#),
+            "form re-rendered:\n{s}"
+        );
+    }
+
+    #[tokio::test]
+    async fn post_with_empty_identifier_re_renders_with_error() {
+        let app = app().await;
+        let (status, _, s) = submit(app, "name=Has+name&identifier=").await;
+        assert_eq!(status, StatusCode::OK);
+        assert!(s.contains("Identifier is required"), "ident error:\n{s}");
+    }
+
+    #[tokio::test]
+    async fn post_with_invalid_identifier_charset_is_rejected() {
+        let app = app().await;
+        // Uppercase + space + slash are all outside Redmine's slug rule.
+        let (status, _, s) = submit(app, "name=Ok&identifier=Bad+Slug%2Fx").await;
+        assert_eq!(status, StatusCode::OK);
+        assert!(
+            s.contains("lowercase letters"),
+            "charset error must show:\n{s}"
+        );
+    }
+
+    // ── pure validate() + is_valid_identifier() units ───────────────
+
+    #[test]
+    fn validate_accepts_a_normal_project() {
+        let f = ProjectForm {
+            name: "My Project".into(),
+            identifier: "my-project".into(),
+        };
+        assert!(validate(&f).is_empty());
+    }
+
+    #[test]
+    fn validate_rejects_blank_name_and_identifier_together() {
+        let f = ProjectForm {
+            name: "   ".into(),
+            identifier: "".into(),
+        };
+        let errs = validate(&f);
+        assert!(errs.contains(&"Name is required."));
+        assert!(errs.contains(&"Identifier is required."));
+    }
+
+    #[test]
+    fn validate_rejects_overlong_name_and_identifier() {
+        let f = ProjectForm {
+            name: "a".repeat(NAME_MAX_LEN + 1),
+            identifier: "a".repeat(IDENT_MAX_LEN + 1),
+        };
+        let errs = validate(&f);
+        assert!(errs.contains(&"Name must be 255 characters or fewer."));
+        assert!(errs.contains(&"Identifier must be 100 characters or fewer."));
+    }
+
+    #[test]
+    fn blank_identifier_does_not_also_trip_charset_or_length() {
+        // The `!is_empty()` guards mean a blank identifier yields exactly
+        // one identifier error ("required"), not three.
+        let f = ProjectForm {
+            name: "Ok".into(),
+            identifier: "   ".into(),
+        };
+        let ident_errs: Vec<_> = validate(&f)
+            .into_iter()
+            .filter(|e| e.starts_with("Identifier"))
+            .collect();
+        assert_eq!(ident_errs, vec!["Identifier is required."]);
+    }
+
+    #[test]
+    fn identifier_rule_matches_redmine_slug_shape() {
+        // Valid: starts with a letter, then lowercase/digits/-/_.
+        for ok in ["a", "my-project", "proj_2", "x1-y2_z3"] {
+            assert!(is_valid_identifier(ok), "{ok} should be valid");
+        }
+        // Invalid: leading digit/hyphen, uppercase, spaces, punctuation.
+        for bad in ["1abc", "-abc", "Abc", "a b", "a/b", "a.b", ""] {
+            assert!(!is_valid_identifier(bad), "{bad} should be invalid");
+        }
+    }
+}
diff --git a/crates/rm-server/src/router.rs b/crates/rm-server/src/router.rs
index 8e97498..47d981a 100644
--- a/crates/rm-server/src/router.rs
+++ b/crates/rm-server/src/router.rs
@@ -87,6 +87,7 @@ pub fn build_router_with(store: Store, auth_cfg: AuthConfig) -> Router {
         .merge(rm_handlers::issues_form::router(state.clone())) // D1: /issues/new + POST /issues
         .merge(rm_handlers::news::router(state.clone())) // W6a: /news
         .merge(rm_handlers::projects::router(state.clone())) // W2: /projects
+        .merge(rm_handlers::projects_form::router(state.clone())) // D1: /projects/new + POST /projects
         .merge(rm_handlers::queries::router(state.clone())) // W8a: /queries
         .merge(rm_handlers::relations::router(state.clone())) // W8b: /relations
         .merge(rm_handlers::roles::router(state.clone())) // W4b: /roles

From bec7653f1b072b6e01550110de946212bee89e16 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 30 Jun 2026 20:29:42 +0000
Subject: [PATCH 4/5] feat(rm-handlers): News create form + factor
 render_errors to common
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

News is the third form module, so per the codebase's "factor on the
third caller" rule (Plan §1.6) the duplicated form-error block lifts into
common::render_errors (now pub(crate)); issues_form + projects_form drop
their copies and import it.

- news_form: GET /news/new + POST /news. Title (required, <=255) +
  Summary (optional, <=255) + Description (required), mirroring Redmine's
  News validations. 303 to /news/<id> on success (record-keyed like
  Issue); 200 re-render with inline errors on failure. Pure validate()
  unit-tested.
- news: "Add news" contextual action on the list -> /news/new.
- common: render_errors moved here + directly unit-tested.
- rm-server: merge news_form::router.

CI gate green on toolchain 1.95: fmt --all --check, clippy --all-targets
--workspace -D warnings, test --workspace.
---
 crates/rm-handlers/src/common.rs        |  35 +++
 crates/rm-handlers/src/issues_form.rs   |  22 +-
 crates/rm-handlers/src/lib.rs           |   1 +
 crates/rm-handlers/src/news.rs          |  23 +-
 crates/rm-handlers/src/news_form.rs     | 320 ++++++++++++++++++++++++
 crates/rm-handlers/src/projects_form.rs |  24 +-
 crates/rm-server/src/router.rs          |   1 +
 7 files changed, 381 insertions(+), 45 deletions(-)
 create mode 100644 crates/rm-handlers/src/news_form.rs

diff --git a/crates/rm-handlers/src/common.rs b/crates/rm-handlers/src/common.rs
index 818b3b3..07b5b93 100644
--- a/crates/rm-handlers/src/common.rs
+++ b/crates/rm-handlers/src/common.rs
@@ -146,6 +146,31 @@ pub fn wrap_in_doc(title: &str, body: &str) -> String {
     )
 }
 
+/// Render the validation-error block shown above a create/edit form — a
+/// `role="alert"` list of messages. Empty string when there are no errors
+/// (so a clean form renders no stray block).
+///
+/// Factored here once a **third** form module (News) joined Issue +
+/// Project as a caller — the project's "three points form a line" rule
+/// (Plan §1.6). Callers pass `&'static str` literals from their own
+/// `validate`, so no user-controlled content reaches this HTML; the
+/// messages are spliced verbatim.
+#[must_use]
+pub(crate) fn render_errors(errors: &[&str]) -> String {
+    if errors.is_empty() {
+        return String::new();
+    }
+    let mut out = String::with_capacity(64 + errors.len() * 32);
+    out.push_str(r#"<div class="form-errors" role="alert"><ul>"#);
+    for e in errors {
+        out.push_str("<li>");
+        out.push_str(e);
+        out.push_str("</li>");
+    }
+    out.push_str("</ul></div>");
+    out
+}
+
 /// Hash a SurrealDB `RecordId` to a `u64` — the render kit's
 /// `render_detail(record_id: u64, ...)` parameter takes an integer
 /// for display + the `data-record-id` HTML attribute. SurrealDB
@@ -262,6 +287,16 @@ mod tests {
         assert!(html.contains("viewport"), "viewport meta missing:\n{html}");
     }
 
+    #[test]
+    fn render_errors_is_empty_without_errors_and_lists_them_otherwise() {
+        assert!(render_errors(&[]).is_empty(), "no block when no errors");
+        let html = render_errors(&["Subject is required.", "Too long."]);
+        assert!(html.contains(r#"class="form-errors""#), "{html}");
+        assert!(html.contains(r#"role="alert""#), "{html}");
+        assert!(html.contains("<li>Subject is required.</li>"), "{html}");
+        assert!(html.contains("<li>Too long.</li>"), "{html}");
+    }
+
     #[test]
     fn html_escape_covers_the_five_chars() {
         assert_eq!(html_escape("&<>\"'"), "&amp;&lt;&gt;&quot;&#39;");
diff --git a/crates/rm-handlers/src/issues_form.rs b/crates/rm-handlers/src/issues_form.rs
index 6651708..2c3cb7e 100644
--- a/crates/rm-handlers/src/issues_form.rs
+++ b/crates/rm-handlers/src/issues_form.rs
@@ -50,7 +50,7 @@ use rm_store::NewIssue;
 use serde::Deserialize;
 use surrealdb_types::ToSql;
 
-use crate::common::{wrap_in_doc, AppState, HandlerError};
+use crate::common::{render_errors, wrap_in_doc, AppState, HandlerError};
 
 /// The submit URL — also the action the GET form points to.
 const SUBMIT_PATH: &str = "/issues";
@@ -172,26 +172,6 @@ fn render(form: &IssueForm, errors: &[&str]) -> Result<Html<String>, HandlerErro
     Ok(Html(wrap_in_doc("New issue", &body)))
 }
 
-/// Render the validation-error block above the form. Empty string when
-/// there are no errors. Errors are static `&'static str` literals from
-/// [`validate`] — no user-controlled content reaches the HTML here, so
-/// the literal strings are safe.
-fn render_errors(errors: &[&str]) -> String {
-    if errors.is_empty() {
-        return String::new();
-    }
-    let mut out = String::with_capacity(64 + errors.len() * 32);
-    out.push_str(r#"<div class="form-errors" role="alert"><ul>"#);
-    for e in errors {
-        // Static literals only; no untrusted data here.
-        out.push_str("<li>");
-        out.push_str(e);
-        out.push_str("</li>");
-    }
-    out.push_str("</ul></div>");
-    out
-}
-
 /// Form columns: Subject (the kit pulls `required` from the field's
 /// `InputData::Text { required: true }` — `RenderColumn` is just
 /// name+caption+kind), Description (optional TextArea).
diff --git a/crates/rm-handlers/src/lib.rs b/crates/rm-handlers/src/lib.rs
index 6f70bf1..95de712 100644
--- a/crates/rm-handlers/src/lib.rs
+++ b/crates/rm-handlers/src/lib.rs
@@ -51,6 +51,7 @@ pub mod issues;
 pub mod issues_form;
 pub mod list_chrome;
 pub mod news;
+pub mod news_form;
 pub mod projects;
 pub mod projects_form;
 pub mod queries;
diff --git a/crates/rm-handlers/src/news.rs b/crates/rm-handlers/src/news.rs
index 0a52e50..5e54adc 100644
--- a/crates/rm-handlers/src/news.rs
+++ b/crates/rm-handlers/src/news.rs
@@ -17,6 +17,7 @@ use rm_store::NewsRow;
 use surrealdb_types::{RecordId, ToSql};
 
 use crate::common::{html_escape, record_id_to_u64, wrap_in_doc, AppState, HandlerError};
+use crate::list_chrome::render_action_bar;
 
 /// `GET /news` — render the news list.
 pub async fn list(State(state): State<AppState>) -> Result<Html<String>, HandlerError> {
@@ -59,8 +60,11 @@ pub async fn list(State(state): State<AppState>) -> Result<Html<String>, Handler
             block: Vec::new(),
         })
         .collect();
-    let body = render_list("News", 0x0114, "project_news", &cols, &[], &rows)
+    let table = render_list("News", 0x0114, "project_news", &cols, &[], &rows)
         .map_err(|e| HandlerError::Render(e.to_string()))?;
+    // Redmine's "Add news" contextual action, top-right of the list.
+    let action_bar = render_action_bar(&[("Add news", "/news/new")]);
+    let body = format!("{action_bar}\n{table}");
     Ok(Html(wrap_in_doc("News", &body)))
 }
 
@@ -187,6 +191,23 @@ mod tests {
         assert!(s.contains("href=\"/news/"));
     }
 
+    #[tokio::test]
+    async fn list_shows_add_news_action_link() {
+        let store = Store::open().await.unwrap();
+        let app = router(AppState { store });
+        let res = app
+            .oneshot(Request::builder().uri("/news").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        let body = res.into_body().collect().await.unwrap().to_bytes();
+        let s = std::str::from_utf8(&body).unwrap();
+        assert!(
+            s.contains(r#"href="/news/new""#) && s.contains("Add news"),
+            "expected an Add news CTA linking to the create form:\n{s}"
+        );
+    }
+
     #[tokio::test]
     async fn detail_renders_by_record_key() {
         let store = Store::open().await.unwrap();
diff --git a/crates/rm-handlers/src/news_form.rs b/crates/rm-handlers/src/news_form.rs
new file mode 100644
index 0000000..c23e137
--- /dev/null
+++ b/crates/rm-handlers/src/news_form.rs
@@ -0,0 +1,320 @@
+//! **W6a D1** — News (`project_news`) create form.
+//!
+//! Third form module after [`crate::issues_form`] + [`crate::projects_form`]
+//! — the one that triggered lifting the shared `render_errors` block into
+//! [`crate::common`] (Plan §1.6 "three points form a line").
+//!
+//! - `GET /news/new` — render an empty form
+//! - `POST /news` — validate, create, **303 See Other** to `/news/<id>` on
+//!   success (News is record-keyed like Issue — Redmine's `/news/:id` uses
+//!   the numeric primary key, no slug); re-render with inline errors on
+//!   failure, input preserved.
+//!
+//! # Today's scope
+//!
+//! Mirrors Redmine's `News` validations: **title required** (trimmed,
+//! ≤255) and **description required**; **summary optional** (≤255). No
+//! markdown preview / attachments (separate D-tracks), no CSRF token yet
+//! (`csrf_token: ""`, same seam as the sibling forms).
+
+use axum::extract::State;
+use axum::http::StatusCode;
+use axum::response::{Html, IntoResponse, Redirect, Response};
+use axum::routing::{get, post};
+use axum::{Form, Router};
+use ogar_render_askama::{
+    render_form, ColumnKind, FormFieldSource, FormSource, InputData, RenderColumn,
+};
+use rm_store::NewNews;
+use serde::Deserialize;
+use surrealdb_types::ToSql;
+
+use crate::common::{render_errors, wrap_in_doc, AppState, HandlerError};
+
+/// The submit URL — also the action the GET form points to.
+const SUBMIT_PATH: &str = "/news";
+
+/// Max title length — Redmine's `news.title` column cap.
+const TITLE_MAX_LEN: usize = 255;
+
+/// Max summary length — Redmine's `news.summary` column cap.
+const SUMMARY_MAX_LEN: usize = 255;
+
+/// Form submission shape — Axum's `Form<T>` deserializes the
+/// `application/x-www-form-urlencoded` body into this.
+#[derive(Debug, Clone, Default, Deserialize)]
+pub struct NewsForm {
+    /// Submitted headline. Required (after trimming), ≤255.
+    #[serde(default)]
+    pub title: String,
+    /// Submitted one-line summary. Optional, ≤255.
+    #[serde(default)]
+    pub summary: String,
+    /// Submitted long-form body. Required (after trimming).
+    #[serde(default)]
+    pub description: String,
+}
+
+/// `GET /news/new` — render an empty create form.
+pub async fn new_form(State(_state): State<AppState>) -> Result<Html<String>, HandlerError> {
+    render(&NewsForm::default(), &[])
+}
+
+/// `POST /news` — accept submission, validate, persist, redirect.
+///
+/// `303 See Other` → `/news/<id>` on success (POST-redirect-GET); `200 OK`
+/// re-rendering the form with inline errors on validation failure,
+/// preserving the user's input.
+pub async fn create(
+    State(state): State<AppState>,
+    Form(form): Form<NewsForm>,
+) -> Result<Response, HandlerError> {
+    let errors = validate(&form);
+    if !errors.is_empty() {
+        let html = render(&form, &errors)?;
+        return Ok((StatusCode::OK, html).into_response());
+    }
+    let new = NewNews {
+        title: form.title.trim().to_string(),
+        summary: form.summary.trim().to_string(),
+        description: form.description.trim().to_string(),
+    };
+    let entry = state.store.create_news(new).await?;
+    let rid = entry
+        .id
+        .ok_or(HandlerError::Store(rm_store::StoreError::NotFound))?;
+    Ok(Redirect::to(&format!("/news/{}", rid.key.to_sql())).into_response())
+}
+
+/// Validate the form. Returns human-readable error strings — empty when
+/// acceptable. Pure so the unit tests hit every branch without axum.
+fn validate(form: &NewsForm) -> Vec<&'static str> {
+    let mut errs: Vec<&'static str> = Vec::new();
+
+    let title = form.title.trim();
+    if title.is_empty() {
+        errs.push("Title is required.");
+    }
+    if title.chars().count() > TITLE_MAX_LEN {
+        errs.push("Title must be 255 characters or fewer.");
+    }
+
+    // Summary is optional; only length-cap it when present.
+    if form.summary.trim().chars().count() > SUMMARY_MAX_LEN {
+        errs.push("Summary must be 255 characters or fewer.");
+    }
+
+    if form.description.trim().is_empty() {
+        errs.push("Description is required.");
+    }
+    errs
+}
+
+/// Render the create form, optionally with validation errors above the
+/// fields. Pure helper around the kit.
+fn render(form: &NewsForm, errors: &[&str]) -> Result<Html<String>, HandlerError> {
+    let cols = form_columns();
+    let fields = vec![
+        FormFieldSource {
+            column: &cols[0],
+            css_classes: "",
+            hint: "Headline shown on the news list. Required.",
+            data: InputData::Text {
+                value: form.title.clone(),
+                required: true,
+                placeholder: String::new(),
+            },
+        },
+        FormFieldSource {
+            column: &cols[1],
+            css_classes: "",
+            hint: "One-line teaser shown next to the title. Optional.",
+            data: InputData::Text {
+                value: form.summary.clone(),
+                required: false,
+                placeholder: String::new(),
+            },
+        },
+        FormFieldSource {
+            column: &cols[2],
+            css_classes: "",
+            hint: "Long-form announcement body. Required.",
+            data: InputData::TextArea {
+                value: form.description.clone(),
+                required: true,
+                rows: 8,
+                placeholder: String::new(),
+            },
+        },
+    ];
+    let src = FormSource {
+        method: "post",
+        action: SUBMIT_PATH,
+        csrf_token: "", // rm-auth integration is its own follow-on
+        record_id: None,
+        legend: "Add news",
+        submit_label: "Create",
+        cancel_label: "Cancel",
+        cancel_href: SUBMIT_PATH,
+        fields,
+    };
+    let form_html = render_form(0x0114, "project_news", &src)
+        .map_err(|e| HandlerError::Render(e.to_string()))?;
+    let errors_html = render_errors(errors);
+    let body = format!("{errors_html}{form_html}");
+    Ok(Html(wrap_in_doc("Add news", &body)))
+}
+
+/// Form columns: Title (primary) + Summary (plain) + Description
+/// (long-form). The kit reads `required` from each field's `InputData`.
+fn form_columns() -> [RenderColumn; 3] {
+    [
+        RenderColumn::new("title", "Title", ColumnKind::PrimaryLink),
+        RenderColumn::new("summary", "Summary", ColumnKind::Plain),
+        RenderColumn::new("description", "Description", ColumnKind::Plain),
+    ]
+}
+
+/// Build the D1 form router (`GET /news/new` + `POST /news`) that
+/// `rm-server` merges alongside `news::router`.
+pub fn router(state: AppState) -> Router {
+    Router::new()
+        .route("/news/new", get(new_form))
+        .route("/news", post(create))
+        .with_state(state)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::body::Body;
+    use axum::http::{header, Method, Request, StatusCode};
+    use http_body_util::BodyExt;
+    use rm_store::Store;
+    use tower::ServiceExt;
+
+    async fn app() -> Router {
+        let store = Store::open().await.expect("store boots");
+        router(AppState { store })
+    }
+
+    async fn submit(app: Router, body: &str) -> (StatusCode, Option<String>, String) {
+        let res = app
+            .oneshot(
+                Request::builder()
+                    .method(Method::POST)
+                    .uri(SUBMIT_PATH)
+                    .header(header::CONTENT_TYPE, "application/x-www-form-urlencoded")
+                    .body(Body::from(body.to_string()))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        let status = res.status();
+        let location = res
+            .headers()
+            .get(header::LOCATION)
+            .map(|v| v.to_str().unwrap().to_string());
+        let bytes = res.into_body().collect().await.unwrap().to_bytes();
+        let s = String::from_utf8(bytes.to_vec()).unwrap();
+        (status, location, s)
+    }
+
+    #[tokio::test]
+    async fn get_new_renders_empty_form_with_all_three_fields() {
+        let res = app()
+            .await
+            .oneshot(
+                Request::builder()
+                    .uri("/news/new")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        let body = res.into_body().collect().await.unwrap().to_bytes();
+        let s = String::from_utf8(body.to_vec()).unwrap();
+        assert!(s.contains(r#"action="/news""#), "form action:\n{s}");
+        assert!(s.contains(r#"method="post""#), "form method:\n{s}");
+        assert!(s.contains(r#"name="title""#), "title field:\n{s}");
+        assert!(s.contains(r#"name="summary""#), "summary field:\n{s}");
+        assert!(
+            s.contains(r#"name="description""#),
+            "description field:\n{s}"
+        );
+        assert!(
+            s.contains(r#"data-class-id="0x0114""#),
+            "class id stamped:\n{s}"
+        );
+        assert!(!s.contains("form-errors"), "no errors on empty form:\n{s}");
+    }
+
+    #[tokio::test]
+    async fn post_with_valid_fields_creates_and_redirects() {
+        let app = app().await;
+        let (status, location, _) = submit(
+            app,
+            "title=Release+0.1&summary=MVP+ships&description=Browse+create+auth",
+        )
+        .await;
+        assert_eq!(status, StatusCode::SEE_OTHER, "must 303 on success");
+        let loc = location.expect("Location header");
+        assert!(loc.starts_with("/news/"), "expected /news/<key>, got {loc}");
+    }
+
+    #[tokio::test]
+    async fn post_missing_title_re_renders_with_error() {
+        let app = app().await;
+        let (status, _, s) = submit(app, "title=&summary=&description=Body").await;
+        assert_eq!(
+            status,
+            StatusCode::OK,
+            "validation failure must not redirect"
+        );
+        assert!(s.contains("Title is required"), "title error:\n{s}");
+        assert!(s.contains("form-errors"), "error block:\n{s}");
+    }
+
+    #[tokio::test]
+    async fn post_missing_description_re_renders_with_error() {
+        let app = app().await;
+        let (status, _, s) = submit(app, "title=Has+title&summary=&description=").await;
+        assert_eq!(status, StatusCode::OK);
+        assert!(s.contains("Description is required"), "desc error:\n{s}");
+    }
+
+    #[test]
+    fn validate_accepts_title_and_description_with_optional_summary() {
+        let f = NewsForm {
+            title: "Release 0.1".into(),
+            summary: String::new(), // optional — empty is fine
+            description: "Body".into(),
+        };
+        assert!(validate(&f).is_empty());
+    }
+
+    #[test]
+    fn validate_requires_title_and_description() {
+        let f = NewsForm {
+            title: "  ".into(),
+            summary: String::new(),
+            description: "   ".into(),
+        };
+        let errs = validate(&f);
+        assert!(errs.contains(&"Title is required."));
+        assert!(errs.contains(&"Description is required."));
+    }
+
+    #[test]
+    fn validate_caps_title_and_summary_lengths() {
+        let f = NewsForm {
+            title: "a".repeat(TITLE_MAX_LEN + 1),
+            summary: "b".repeat(SUMMARY_MAX_LEN + 1),
+            description: "ok".into(),
+        };
+        let errs = validate(&f);
+        assert!(errs.contains(&"Title must be 255 characters or fewer."));
+        assert!(errs.contains(&"Summary must be 255 characters or fewer."));
+    }
+}
diff --git a/crates/rm-handlers/src/projects_form.rs b/crates/rm-handlers/src/projects_form.rs
index 6b7cb13..85bc3d2 100644
--- a/crates/rm-handlers/src/projects_form.rs
+++ b/crates/rm-handlers/src/projects_form.rs
@@ -37,7 +37,7 @@ use ogar_render_askama::{
 use rm_store::NewProject;
 use serde::Deserialize;
 
-use crate::common::{encode_path_segment, wrap_in_doc, AppState, HandlerError};
+use crate::common::{encode_path_segment, render_errors, wrap_in_doc, AppState, HandlerError};
 
 /// The submit URL — also the action the GET form points to.
 const SUBMIT_PATH: &str = "/projects";
@@ -183,28 +183,6 @@ fn render(form: &ProjectForm, errors: &[&str]) -> Result<Html<String>, HandlerEr
     Ok(Html(wrap_in_doc("New project", &body)))
 }
 
-/// Render the validation-error block above the form. Empty string when
-/// there are no errors. Errors are `&'static str` literals from
-/// [`validate`] — no user-controlled content reaches the HTML here.
-///
-/// Duplicated from [`crate::issues_form`] by the project's "factor on the
-/// third caller" rule (Plan §1.6); the third form module (TimeEntry /
-/// News) triggers the lift into `common`.
-fn render_errors(errors: &[&str]) -> String {
-    if errors.is_empty() {
-        return String::new();
-    }
-    let mut out = String::with_capacity(64 + errors.len() * 32);
-    out.push_str(r#"<div class="form-errors" role="alert"><ul>"#);
-    for e in errors {
-        out.push_str("<li>");
-        out.push_str(e);
-        out.push_str("</li>");
-    }
-    out.push_str("</ul></div>");
-    out
-}
-
 /// Form columns: Name (primary) + Identifier (plain). The kit reads
 /// `required` from each field's `InputData`, not the column.
 fn form_columns() -> [RenderColumn; 2] {
diff --git a/crates/rm-server/src/router.rs b/crates/rm-server/src/router.rs
index 47d981a..caaf16b 100644
--- a/crates/rm-server/src/router.rs
+++ b/crates/rm-server/src/router.rs
@@ -86,6 +86,7 @@ pub fn build_router_with(store: Store, auth_cfg: AuthConfig) -> Router {
         .merge(rm_handlers::issues::router(state.clone())) // W1: /issues
         .merge(rm_handlers::issues_form::router(state.clone())) // D1: /issues/new + POST /issues
         .merge(rm_handlers::news::router(state.clone())) // W6a: /news
+        .merge(rm_handlers::news_form::router(state.clone())) // D1: /news/new + POST /news
         .merge(rm_handlers::projects::router(state.clone())) // W2: /projects
         .merge(rm_handlers::projects_form::router(state.clone())) // D1: /projects/new + POST /projects
         .merge(rm_handlers::queries::router(state.clone())) // W8a: /queries

From cd2b270cefac8429ae63e2854838f3f852babffc Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 30 Jun 2026 20:32:18 +0000
Subject: [PATCH 5/5] feat(rm-handlers): Wiki create form + "New wiki page" CTA
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fourth create form, completing the "create any core resource" set
(Issue, Project, News, Wiki) on the shared form chrome.

- wiki_form: GET /wiki/new + POST /wiki. Title (required, <=255 — it's
  the URL slug) + Body (optional — a stub page is valid). 303 to
  /wiki/<title> on success (title URL-encoded via encode_path_segment,
  so spaces work); 200 re-render with inline errors on failure.
- wiki_pages: "New wiki page" contextual action on the list -> /wiki/new.
- rm-server: merge wiki_form::router.

Documented MVP routing caveat: /wiki/new shadows a page literally titled
"new" (static beats /wiki/:title); nested /projects/:id/wiki/new lands
with the project sidebar follow-up.

CI gate green on toolchain 1.95: fmt --all --check, clippy --all-targets
--workspace -D warnings, test --workspace.
---
 crates/rm-handlers/src/lib.rs        |   1 +
 crates/rm-handlers/src/wiki_form.rs  | 278 +++++++++++++++++++++++++++
 crates/rm-handlers/src/wiki_pages.rs |  23 ++-
 crates/rm-server/src/router.rs       |   1 +
 4 files changed, 302 insertions(+), 1 deletion(-)
 create mode 100644 crates/rm-handlers/src/wiki_form.rs

diff --git a/crates/rm-handlers/src/lib.rs b/crates/rm-handlers/src/lib.rs
index 95de712..fdf0327 100644
--- a/crates/rm-handlers/src/lib.rs
+++ b/crates/rm-handlers/src/lib.rs
@@ -61,6 +61,7 @@ pub mod scm;
 pub mod taxonomy;
 pub mod time_entries;
 pub mod users;
+pub mod wiki_form;
 pub mod wiki_pages;
 
 pub use common::{
diff --git a/crates/rm-handlers/src/wiki_form.rs b/crates/rm-handlers/src/wiki_form.rs
new file mode 100644
index 0000000..6c4d537
--- /dev/null
+++ b/crates/rm-handlers/src/wiki_form.rs
@@ -0,0 +1,278 @@
+//! **W6b D1** — WikiPage (`project_wiki_page`) create form.
+//!
+//! Fourth form module — the create flow for the title-keyed wiki page,
+//! mirroring [`crate::projects_form`]'s slug-keyed shape (title doubles as
+//! the URL slug, like Redmine's wiki).
+//!
+//! - `GET /wiki/new` — render an empty form
+//! - `POST /wiki` — validate, create, **303 See Other** to
+//!   `/wiki/<title>` on success; re-render with inline errors on failure.
+//!
+//! # Today's scope
+//!
+//! - **Title required**, trimmed, **≤255** — it's the URL slug, so it
+//!   must be present; `encode_path_segment` makes the redirect URL-safe
+//!   (Redmine wiki titles allow spaces, which percent-encode fine).
+//! - **Body optional** — creating a stub page then filling it in is a
+//!   real wiki workflow; an empty page is valid.
+//! - **Routing caveat**: `/wiki/new` (this form) shadows a page literally
+//!   titled `new` (static route beats `/wiki/:title`). Acceptable for the
+//!   flattened MVP routing; nested `/projects/:id/wiki/new` lands with the
+//!   project-scoped sidebar (the same W2 follow-up that nests wiki under a
+//!   project).
+//! - **No versioning / preview / attachments** — separate D-tracks.
+//! - **No CSRF token yet** (`csrf_token: ""`, same seam as siblings).
+
+use axum::extract::State;
+use axum::http::StatusCode;
+use axum::response::{Html, IntoResponse, Redirect, Response};
+use axum::routing::{get, post};
+use axum::{Form, Router};
+use ogar_render_askama::{
+    render_form, ColumnKind, FormFieldSource, FormSource, InputData, RenderColumn,
+};
+use rm_store::NewWikiPage;
+use serde::Deserialize;
+
+use crate::common::{encode_path_segment, render_errors, wrap_in_doc, AppState, HandlerError};
+
+/// The submit URL — also the action the GET form points to.
+const SUBMIT_PATH: &str = "/wiki";
+
+/// Max title length — the title is the URL slug; cap it at Redmine's 255.
+const TITLE_MAX_LEN: usize = 255;
+
+/// Form submission shape.
+#[derive(Debug, Clone, Default, Deserialize)]
+pub struct WikiForm {
+    /// Submitted page title (doubles as the URL slug). Required, ≤255.
+    #[serde(default)]
+    pub title: String,
+    /// Submitted page body. Optional — a stub page is valid.
+    #[serde(default)]
+    pub body: String,
+}
+
+/// `GET /wiki/new` — render an empty create form.
+pub async fn new_form(State(_state): State<AppState>) -> Result<Html<String>, HandlerError> {
+    render(&WikiForm::default(), &[])
+}
+
+/// `POST /wiki` — accept submission, validate, persist, redirect.
+///
+/// `303 See Other` → `/wiki/<title>` on success (POST-redirect-GET); `200
+/// OK` re-rendering with inline errors on validation failure, input
+/// preserved.
+pub async fn create(
+    State(state): State<AppState>,
+    Form(form): Form<WikiForm>,
+) -> Result<Response, HandlerError> {
+    let errors = validate(&form);
+    if !errors.is_empty() {
+        let html = render(&form, &errors)?;
+        return Ok((StatusCode::OK, html).into_response());
+    }
+    let new = NewWikiPage {
+        title: form.title.trim().to_string(),
+        body: form.body.trim().to_string(),
+    };
+    let page = state.store.create_wiki_page(new).await?;
+    Ok(Redirect::to(&format!("/wiki/{}", encode_path_segment(&page.title))).into_response())
+}
+
+/// Validate the form. Pure so the unit tests hit every branch without axum.
+fn validate(form: &WikiForm) -> Vec<&'static str> {
+    let mut errs: Vec<&'static str> = Vec::new();
+    let title = form.title.trim();
+    if title.is_empty() {
+        errs.push("Title is required.");
+    }
+    if title.chars().count() > TITLE_MAX_LEN {
+        errs.push("Title must be 255 characters or fewer.");
+    }
+    errs
+}
+
+/// Render the create form, optionally with validation errors above the
+/// fields. Pure helper around the kit.
+fn render(form: &WikiForm, errors: &[&str]) -> Result<Html<String>, HandlerError> {
+    let cols = form_columns();
+    let fields = vec![
+        FormFieldSource {
+            column: &cols[0],
+            css_classes: "",
+            hint: "Page title — also the URL slug. Required.",
+            data: InputData::Text {
+                value: form.title.clone(),
+                required: true,
+                placeholder: String::new(),
+            },
+        },
+        FormFieldSource {
+            column: &cols[1],
+            css_classes: "",
+            hint: "Page content (wiki markup). Optional — you can fill it in later.",
+            data: InputData::TextArea {
+                value: form.body.clone(),
+                required: false,
+                rows: 12,
+                placeholder: String::new(),
+            },
+        },
+    ];
+    let src = FormSource {
+        method: "post",
+        action: SUBMIT_PATH,
+        csrf_token: "", // rm-auth integration is its own follow-on
+        record_id: None,
+        legend: "New wiki page",
+        submit_label: "Create",
+        cancel_label: "Cancel",
+        cancel_href: SUBMIT_PATH,
+        fields,
+    };
+    let form_html = render_form(0x010C, "project_wiki_page", &src)
+        .map_err(|e| HandlerError::Render(e.to_string()))?;
+    let errors_html = render_errors(errors);
+    let body = format!("{errors_html}{form_html}");
+    Ok(Html(wrap_in_doc("New wiki page", &body)))
+}
+
+/// Form columns: Title (primary) + Body (long-form). The kit reads
+/// `required` from each field's `InputData`.
+fn form_columns() -> [RenderColumn; 2] {
+    [
+        RenderColumn::new("title", "Title", ColumnKind::PrimaryLink),
+        RenderColumn::new("body", "Body", ColumnKind::Plain),
+    ]
+}
+
+/// Build the D1 form router (`GET /wiki/new` + `POST /wiki`) that
+/// `rm-server` merges alongside `wiki_pages::router`.
+pub fn router(state: AppState) -> Router {
+    Router::new()
+        .route("/wiki/new", get(new_form))
+        .route("/wiki", post(create))
+        .with_state(state)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::body::Body;
+    use axum::http::{header, Method, Request, StatusCode};
+    use http_body_util::BodyExt;
+    use rm_store::Store;
+    use tower::ServiceExt;
+
+    async fn app() -> Router {
+        let store = Store::open().await.expect("store boots");
+        router(AppState { store })
+    }
+
+    async fn submit(app: Router, body: &str) -> (StatusCode, Option<String>, String) {
+        let res = app
+            .oneshot(
+                Request::builder()
+                    .method(Method::POST)
+                    .uri(SUBMIT_PATH)
+                    .header(header::CONTENT_TYPE, "application/x-www-form-urlencoded")
+                    .body(Body::from(body.to_string()))
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        let status = res.status();
+        let location = res
+            .headers()
+            .get(header::LOCATION)
+            .map(|v| v.to_str().unwrap().to_string());
+        let bytes = res.into_body().collect().await.unwrap().to_bytes();
+        let s = String::from_utf8(bytes.to_vec()).unwrap();
+        (status, location, s)
+    }
+
+    #[tokio::test]
+    async fn get_new_renders_empty_form_with_title_and_body() {
+        let res = app()
+            .await
+            .oneshot(
+                Request::builder()
+                    .uri("/wiki/new")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        let body = res.into_body().collect().await.unwrap().to_bytes();
+        let s = String::from_utf8(body.to_vec()).unwrap();
+        assert!(s.contains(r#"action="/wiki""#), "form action:\n{s}");
+        assert!(s.contains(r#"name="title""#), "title field:\n{s}");
+        assert!(s.contains(r#"name="body""#), "body field:\n{s}");
+        assert!(
+            s.contains(r#"data-class-id="0x010C""#),
+            "class id stamped:\n{s}"
+        );
+        assert!(!s.contains("form-errors"), "no errors on empty form:\n{s}");
+    }
+
+    #[tokio::test]
+    async fn post_with_title_creates_and_redirects_to_slug() {
+        let app = app().await;
+        // Title with a space exercises the URL-encoding of the redirect.
+        let (status, location, _) = submit(app, "title=Getting+Started&body=Hello").await;
+        assert_eq!(status, StatusCode::SEE_OTHER, "must 303 on success");
+        assert_eq!(
+            location.as_deref(),
+            Some("/wiki/Getting%20Started"),
+            "redirect must URL-encode the title slug"
+        );
+    }
+
+    #[tokio::test]
+    async fn post_allows_empty_body_stub_page() {
+        let app = app().await;
+        let (status, location, _) = submit(app, "title=Stub&body=").await;
+        assert_eq!(status, StatusCode::SEE_OTHER, "empty body is a valid stub");
+        assert_eq!(location.as_deref(), Some("/wiki/Stub"));
+    }
+
+    #[tokio::test]
+    async fn post_missing_title_re_renders_with_error() {
+        let app = app().await;
+        let (status, _, s) = submit(app, "title=&body=Body").await;
+        assert_eq!(
+            status,
+            StatusCode::OK,
+            "validation failure must not redirect"
+        );
+        assert!(s.contains("Title is required"), "title error:\n{s}");
+        assert!(s.contains("form-errors"), "error block:\n{s}");
+    }
+
+    #[test]
+    fn validate_requires_title_only() {
+        assert!(validate(&WikiForm {
+            title: "Home".into(),
+            body: String::new(),
+        })
+        .is_empty());
+        assert_eq!(
+            validate(&WikiForm {
+                title: "   ".into(),
+                body: "x".into(),
+            }),
+            vec!["Title is required."]
+        );
+    }
+
+    #[test]
+    fn validate_caps_title_length() {
+        let errs = validate(&WikiForm {
+            title: "a".repeat(TITLE_MAX_LEN + 1),
+            body: String::new(),
+        });
+        assert!(errs.contains(&"Title must be 255 characters or fewer."));
+    }
+}
diff --git a/crates/rm-handlers/src/wiki_pages.rs b/crates/rm-handlers/src/wiki_pages.rs
index c27efce..66141f5 100644
--- a/crates/rm-handlers/src/wiki_pages.rs
+++ b/crates/rm-handlers/src/wiki_pages.rs
@@ -19,6 +19,7 @@ use rm_store::WikiPageRow;
 use crate::common::{
     encode_path_segment, html_escape, identifier_to_u64, wrap_in_doc, AppState, HandlerError,
 };
+use crate::list_chrome::render_action_bar;
 
 /// `GET /wiki` — render the wiki-page list.
 pub async fn list(State(state): State<AppState>) -> Result<Html<String>, HandlerError> {
@@ -47,8 +48,11 @@ pub async fn list(State(state): State<AppState>) -> Result<Html<String>, Handler
             block: Vec::new(),
         })
         .collect();
-    let body = render_list("Wiki", 0x010C, "project_wiki_page", &cols, &[], &rows)
+    let table = render_list("Wiki", 0x010C, "project_wiki_page", &cols, &[], &rows)
         .map_err(|e| HandlerError::Render(e.to_string()))?;
+    // Redmine's "New wiki page" contextual action, top-right of the list.
+    let action_bar = render_action_bar(&[("New wiki page", "/wiki/new")]);
+    let body = format!("{action_bar}\n{table}");
     Ok(Html(wrap_in_doc("Wiki", &body)))
 }
 
@@ -138,6 +142,23 @@ mod tests {
         assert!(s.contains("No data."));
     }
 
+    #[tokio::test]
+    async fn list_shows_new_wiki_page_action_link() {
+        let store = Store::open().await.unwrap();
+        let app = router(AppState { store });
+        let res = app
+            .oneshot(Request::builder().uri("/wiki").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+        assert_eq!(res.status(), StatusCode::OK);
+        let body = res.into_body().collect().await.unwrap().to_bytes();
+        let s = std::str::from_utf8(&body).unwrap();
+        assert!(
+            s.contains(r#"href="/wiki/new""#) && s.contains("New wiki page"),
+            "expected a New wiki page CTA linking to the create form:\n{s}"
+        );
+    }
+
     #[tokio::test]
     async fn detail_by_title_renders() {
         let store = Store::open().await.unwrap();
diff --git a/crates/rm-server/src/router.rs b/crates/rm-server/src/router.rs
index caaf16b..a2b477b 100644
--- a/crates/rm-server/src/router.rs
+++ b/crates/rm-server/src/router.rs
@@ -97,6 +97,7 @@ pub fn build_router_with(store: Store, auth_cfg: AuthConfig) -> Router {
         .merge(rm_handlers::time_entries::router(state.clone())) // W3: /time_entries
         .merge(rm_handlers::users::router(state.clone())) // W4a: /users
         .merge(rm_handlers::wiki_pages::router(state.clone())) // W6b: /wiki
+        .merge(rm_handlers::wiki_form::router(state.clone())) // D1: /wiki/new + POST /wiki
         // ── Phase-0 auxiliary surfaces ──
         .merge(rm_auth::router(auth_cfg)) //               /login, /logout, /me
         .layer(CookieManagerLayer::new())