A channel's message slots are named from the client, on every backend

The IR called them react-message and django-message, so a FastAPI channel had
to declare a DjangoMessage. They are client-message and server-message now,
and the direction words hold wherever a channel is declared: Params /
ClientMessage / ServerMessage, with mizan-core deriving <Pascal>Params and
friends so no backend names a type itself. Django's ReactChannel and
FastAPI's ReactChannel are both Channel.

mizan-fastapi never registered a channels extension, so build_ir() emitted no
channel at all and every payload type was invisible to codegen. It registers
one now. RegistryExtension is an ABC requiring all(), which is what the IR
reads — an extension that cannot enumerate its registrations no longer exists.

The gate that should have caught the rename could not: tests/afi registered no
channel because mizan-rust had no channel registry to register one in, so a
five-package rename of the wire contract passed byte-parity without a channel
byte crossing it. mizan-rust grows ChannelSlotKind, a CHANNELS slice, a
#[mizan::channel] macro, and KDL emission whose wire_to_pascal matches Python's
split; the AFI fixture now carries a channel with every slot and one with a
single slot, so all three backends prove the contract byte for byte.

MizanChannel held three Option<String> beside three has_*() predicates and
unwrapped them with defaults; it holds an ordered slot vector, so an absent
slot is absent rather than defaulted. The channels target emitted a React
hooks file that a stage1-only consumer could not compile — react emits that
now. The codegen's parity tests byte-compared emitted source against baselines
without ever compiling it: they compile the generated crate and run its tests,
import the generated Python package and call every method, and typecheck each
TypeScript target against a consumer.

Also fixed at source: app_visitor printed its import diagnostic to stdout, the
stream export_mizan_ir writes KDL to, so a failed import silently corrupted the
IR; the apps root was hardcoded to "apps"; _default_literal crashed build_ir on
any non-JSON-serializable field default; Django and mizan-core derived Pascal
names two different ways, disagreeing on every dotted channel name.

ir.py builds a document and renders templates/ir/document.kdl.j2 rather than
appending KDL strings with hand-tracked indentation, and named types resolve to
a fixed point — a model reachable only through a union branch was referenced by
a ref that no type block ever defined.

The rest is the write-gate's own classifiers run over the standing tree:
relative imports, silent swallows, Protocol contracts that should be ABCs,
emitters hand-rendering target source, catch-all arms over closed enums, and
comments narrating the project rather than the code.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

protocol/mizan-codegen/src/config.rs

@@ -1,5 +1,5 @@
 //! Codegen configuration — deserialized from `mizan.toml` at the consumer
-//! project root. Replaces the JS substrate's `mizan.config.mjs`.
+//! project root.
 //!
 //! Example:
 //!
@@ -20,38 +20,82 @@
 use std::collections::BTreeMap;
 use std::path::PathBuf;
 
-use serde::Deserialize;
+use serde::{Deserialize, Deserializer};
 
 
+/// Every field carries a value once deserialization returns — a key absent
+/// from the TOML takes the corresponding field of `Config::default()`.
 #[derive(Debug, Deserialize)]
+#[serde(default)]
 pub struct Config {
-    #[serde(default)]
     pub project_id: Option<String>,
 
-    #[serde(default = "default_output")]
     pub output: PathBuf,
 
-    #[serde(default = "default_targets")]
     pub targets: Vec<String>,
 
-    #[serde(default)]
     pub source: SourceConfig,
 
-    #[serde(default)]
     pub rust_kernel: Option<RustKernelSpec>,
 
-    #[serde(default)]
-    pub rust_crate_name: Option<String>,
+    pub rust_crate_name: String,
 }
 
 
-fn default_output() -> PathBuf {
-    PathBuf::from("src/api")
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            project_id: None,
+            output: PathBuf::from("src/api"),
+            targets: vec!["react".to_string()],
+            source: SourceConfig::default(),
+            rust_kernel: None,
+            rust_crate_name: "mizan_client".to_string(),
+        }
+    }
 }
 
 
-fn default_targets() -> Vec<String> {
-    vec!["react".to_string()]
+fn default_python() -> String {
+    "python".to_string()
+}
+
+
+/// A subprocess invocation split into the program and its argv. The
+/// deserializer rejects an empty array, so every `CommandLine` in hand names
+/// a program.
+#[derive(Debug, Clone)]
+pub struct CommandLine {
+    program: String,
+    args: Vec<String>,
+}
+
+
+impl CommandLine {
+    pub fn program_only(program: &str) -> Self {
+        Self { program: program.to_string(), args: Vec::new() }
+    }
+
+    pub fn program(&self) -> &str {
+        &self.program
+    }
+
+    pub fn args(&self) -> &[String] {
+        &self.args
+    }
+}
+
+
+impl<'de> Deserialize<'de> for CommandLine {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let mut parts = Vec::<String>::deserialize(deserializer)?.into_iter();
+        match parts.next() {
+            Some(program) => Ok(CommandLine { program, args: parts.collect() }),
+            None => Err(serde::de::Error::custom(
+                "command must be a non-empty array naming the program first",
+            )),
+        }
+    }
 }
 
 
@@ -63,20 +107,11 @@ pub struct SourceConfig {
     #[serde(default)]
     pub django: Option<DjangoSource>,
 
-    /// Canonical "Pydantic + Rust" DX path. The Rust crate is the IR
-    /// authority; an optional `pydantic` sub-block invokes decoru as a
-    /// pre-step to author Rust types from Pydantic models. Pure-Rust
-    /// usage (no Pydantic) just omits the sub-block.
     #[serde(default)]
     pub rust: Option<RustSource>,
 
-    /// `[source.script]` — generic source. Spawn an arbitrary command and
-    /// read its stdout as KDL IR. Use when none of the language-specific
-    /// sources fit — e.g. a Python module that walks `mizan_core.registry`
-    /// for a non-Django/non-FastAPI consumer, or a custom IR emitter.
-    /// Keeps mizan-codegen out of the business of knowing every possible
-    /// backend language while preserving the "subprocess emits KDL"
-    /// contract every other source already follows.
+    /// `[source.script]` — spawn an arbitrary command and read its stdout
+    /// as KDL IR.
     #[serde(default)]
     pub script: Option<ScriptSource>,
 }
@@ -89,11 +124,11 @@ pub struct FastapiSource {
     #[serde(default)]
     pub cwd: Option<PathBuf>,
 
-    #[serde(default)]
-    pub python: Option<String>,
+    #[serde(default = "default_python")]
+    pub python: String,
 
     #[serde(default)]
-    pub command: Option<Vec<String>>,
+    pub command: Option<CommandLine>,
 
     #[serde(default)]
     pub env: BTreeMap<String, String>,
@@ -104,11 +139,11 @@ pub struct FastapiSource {
 pub struct DjangoSource {
     pub manage_path: PathBuf,
 
-    #[serde(default)]
-    pub python: Option<String>,
+    #[serde(default = "default_python")]
+    pub python: String,
 
     #[serde(default)]
-    pub command: Option<Vec<String>>,
+    pub command: Option<CommandLine>,
 
     #[serde(default)]
     pub env: BTreeMap<String, String>,
@@ -122,12 +157,11 @@ pub struct DjangoSource {
 #[derive(Debug, Deserialize)]
 pub struct RustSource {
     /// Path to the consumer's Cargo.toml, relative to the codegen config
-    /// directory. Defaults to `Cargo.toml` (i.e. config_dir/Cargo.toml).
-    #[serde(default)]
-    pub manifest_path: Option<PathBuf>,
+    /// directory.
+    #[serde(default = "default_manifest_path")]
+    pub manifest_path: PathBuf,
 
-    /// Name of the binary under `[[bin]]` that exports the IR. Defaults
-    /// to `emit-mizan-ir` — the convention this substrate documents.
+    /// Name of the binary under `[[bin]]` that exports the IR.
     #[serde(default = "default_rust_bin")]
     pub bin: String,
 
@@ -135,8 +169,7 @@ pub struct RustSource {
     #[serde(default)]
     pub features: Vec<String>,
 
-    /// Build in release mode. Defaults to false (dev mode is faster for
-    /// codegen, and the binary is throwaway).
+    /// Build in release mode.
     #[serde(default)]
     pub release: bool,
 
@@ -144,25 +177,26 @@ pub struct RustSource {
     #[serde(default)]
     pub env: BTreeMap<String, String>,
 
-    /// Optional pre-step — invoke decoru on a Pydantic source module
-    /// before running the Cargo bin. When present, the pipeline becomes:
-    ///   1. python + decoru → write Rust types to `pydantic.output`
-    ///   2. cargo run --bin <bin> → emit IR to stdout
-    /// Omit for pure-Rust usage (hand-authored or otherwise-generated
-    /// Rust types with `#[derive(Mizan)]`).
+    /// Pre-step run before the Cargo bin: decoru writes Rust types from a
+    /// Pydantic source module to `pydantic.output`.
     #[serde(default)]
     pub pydantic: Option<PydanticPreStep>,
 }
 
 
+fn default_manifest_path() -> PathBuf {
+    PathBuf::from("Cargo.toml")
+}
+
+
 fn default_rust_bin() -> String {
     "emit-mizan-ir".to_string()
 }
 
 
-/// Pydantic → Rust pre-step. Runs an embedded Python helper that walks
-/// the named module for `BaseModel` subclasses and invokes decoru's
-/// `walk_pydantic_model` + `emit_rust_struct` to produce a Rust file.
+/// Pydantic → Rust pre-step. Runs an embedded Python helper that reports
+/// the module's `BaseModel` and `Enum` declarations, then writes the Rust
+/// file those shapes render to.
 #[derive(Debug, Deserialize)]
 pub struct PydanticPreStep {
     /// Python module name to import (e.g. `claude_manage.schema`).
@@ -178,26 +212,24 @@ pub struct PydanticPreStep {
     #[serde(default)]
     pub cwd: Option<PathBuf>,
 
-    /// Python executable. Defaults to `python`.
-    #[serde(default)]
-    pub python: Option<String>,
+    /// Python executable.
+    #[serde(default = "default_python")]
+    pub python: String,
 
     /// Full command override (e.g. `["uv", "run", "python"]`). Wins over
     /// `python` when present.
     #[serde(default)]
-    pub command: Option<Vec<String>>,
+    pub command: Option<CommandLine>,
 
-    /// Derive macros to apply to every generated struct. The default
-    /// matches the Mizan-canonical set used in `cores/rust/blazr/session`
-    /// — serde + mizan_core::Mizan for end-to-end RPC participation.
+    /// Derive macros applied to every generated struct.
     #[serde(default = "default_pydantic_derives")]
     pub derives: Vec<String>,
 
-    /// Optional prelude inserted at the top of the generated file
-    /// (typically a "// AUTO-GENERATED" warning + `use` statements for
-    /// referenced types not produced by decoru itself).
+    /// Prelude inserted at the top of the generated file — the leading
+    /// comment plus `use` statements for referenced types decoru does not
+    /// itself produce.
     #[serde(default)]
-    pub header: Option<String>,
+    pub header: String,
 
     /// Environment overrides for the python subprocess.
     #[serde(default)]
@@ -216,11 +248,8 @@ fn default_pydantic_derives() -> Vec<String> {
 }
 
 
-/// `[source.script]` — generic stdout-of-arbitrary-command source.
-///
-/// Spawns `command` with `args`, reads its stdout, and parses it as KDL
-/// Mizan IR. The same contract every other source follows; this one just
-/// doesn't bake in any language-specific assumptions.
+/// `[source.script]` — spawns `command`, reads its stdout, and parses it as
+/// KDL Mizan IR.
 ///
 /// Example:
 ///
@@ -230,9 +259,8 @@ fn default_pydantic_derives() -> Vec<String> {
 /// ```
 #[derive(Debug, Deserialize)]
 pub struct ScriptSource {
-    /// Full command vector. First entry is the program; rest are argv.
-    /// Must be non-empty.
-    pub command: Vec<String>,
+    /// Program plus argv.
+    pub command: CommandLine,
 
     /// Working directory for the subprocess, relative to the codegen
     /// config directory. Defaults to the config directory itself.