Add Organization aggregate (client-as-status), wired but inert

Prospect -> Client -> PastClient (Prospect -> PastClient allowed
directly too - a prospect that never converted). "Client" is a status
on Organization, not a separate aggregate, per the event-sourcing
plan's design decision. Wired into the same dispatch points as the
other three aggregates (content.rs's bucket map, answers.rs's
create/transition dispatch) so it's ready the moment content
references an "organizations" bucket - nothing does yet, so this lands
compiled and tested but with zero production surface.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

src/aggregates/mod.rs

@@ -9,6 +9,7 @@
 #![cfg(feature = "ssr")]
 
 pub mod applicant;
+pub mod organization;
 pub mod project;
 pub mod subscriber;
 

src/aggregates/organization.rs

@@ -0,0 +1,45 @@
+//! Organizations (companies). "Client" is a *status* this aggregate can
+//! be in, not a separate aggregate type - `Prospect -> Client ->
+//! PastClient`, with `Prospect -> PastClient` also allowed directly
+//! (a prospect that never converted, archived without ever having been
+//! a client). Greenfield: no content or KV bucket references this yet
+//! (see the event-sourcing plan's Deferred section) - this lands
+//! compiled and ready, not wired into any live content.
+use super::AggregateKind;
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum State {
+    Prospect,
+    Client,
+    PastClient,
+}
+
+impl AggregateKind for State {
+    const AGGREGATE_TYPE: &'static str = "organization";
+    const INITIAL_STATE: Self = State::Prospect;
+
+    fn from_event_type(event_type: &str) -> Option<Self> {
+        match event_type {
+            "identified" => Some(State::Prospect),
+            "became_client" => Some(State::Client),
+            "churned" => Some(State::PastClient),
+            _ => None,
+        }
+    }
+
+    fn event_type(self) -> &'static str {
+        match self {
+            State::Prospect => "identified",
+            State::Client => "became_client",
+            State::PastClient => "churned",
+        }
+    }
+
+    fn allowed(self) -> &'static [Self] {
+        match self {
+            State::Prospect => &[State::Client, State::PastClient],
+            State::Client => &[State::PastClient],
+            State::PastClient => &[],
+        }
+    }
+}

src/answers.rs

@@ -78,7 +78,7 @@ pub async fn store_answer(
     // fail a submission the NATS notification event has already
     // recorded" policy as the KV write above.
     if let Some(agg_type) = crate::content::aggregate_type_for_bucket(bucket) {
-        use crate::aggregates::{applicant, create, project, subscriber};
+        use crate::aggregates::{applicant, create, organization, project, subscriber};
         let seed = match agg_type {
             "applicant" => create::<applicant::State>(js, &id, responses.clone(), submitted_ms)
                 .await
@@ -89,6 +89,9 @@ pub async fn store_answer(
             "project" => create::<project::State>(js, &id, responses.clone(), submitted_ms)
                 .await
                 .map(|_| ()),
+            "organization" => create::<organization::State>(js, &id, responses.clone(), submitted_ms)
+                .await
+                .map(|_| ()),
             _ => Ok(()),
         };
         if let Err(e) = seed {
@@ -242,7 +245,7 @@ async fn transition_by_aggregate(
     payload: serde_json::Value,
     occurred_at_ms: i64,
 ) -> Result<(), crate::aggregates::TransitionError> {
-    use crate::aggregates::{applicant, project, subscriber, transition, AggregateKind, TransitionError};
+    use crate::aggregates::{applicant, organization, project, subscriber, transition, AggregateKind, TransitionError};
 
     macro_rules! dispatch {
         ($state:ty) => {{
@@ -260,6 +263,7 @@ async fn transition_by_aggregate(
         "applicant" => dispatch!(applicant::State),
         "subscriber" => dispatch!(subscriber::State),
         "project" => dispatch!(project::State),
+        "organization" => dispatch!(organization::State),
         _ => return Err(TransitionError::UnknownAggregate),
     }
     Ok(())

src/content.rs

@@ -345,6 +345,7 @@ pub fn aggregate_type_for_bucket(bucket: &str) -> Option<&'static str> {
         "applicants" => Some("applicant"),
         "subscribers" => Some("subscriber"),
         "projects" => Some("project"),
+        "organizations" => Some("organization"),
         _ => None,
     }
 }
@@ -359,6 +360,7 @@ fn is_valid_transition_target(aggregate_type: &str, to: &str) -> bool {
         "applicant" => check::<crate::aggregates::applicant::State>(to),
         "subscriber" => check::<crate::aggregates::subscriber::State>(to),
         "project" => check::<crate::aggregates::project::State>(to),
+        "organization" => check::<crate::aggregates::organization::State>(to),
         _ => false,
     }
 }