leynos
diff --git a/‎build.rs‎
Lines changed: 15 additions & 0 deletions b/‎build.rs‎
Lines changed: 15 additions & 0 deletions
diff --git a/‎docs/execplans/3-10-1-guarantee-status-message-ordering.md‎
Lines changed: 3 additions & 6 deletions b/‎docs/execplans/3-10-1-guarantee-status-message-ordering.md‎
Lines changed: 3 additions & 6 deletions
diff --git a/‎docs/execplans/3-12-1-define-design-tokens.md‎
Lines changed: 582 additions & 0 deletions b/‎docs/execplans/3-12-1-define-design-tokens.md‎
Lines changed: 582 additions & 0 deletions
diff --git a/‎locales/en-US/messages.ftl‎
Lines changed: 2 additions & 0 deletions b/‎locales/en-US/messages.ftl‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎locales/es-ES/messages.ftl‎
Lines changed: 2 additions & 0 deletions b/‎locales/es-ES/messages.ftl‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎src/cli/config_merge.rs‎
Lines changed: 177 additions & 0 deletions b/‎src/cli/config_merge.rs‎
Lines changed: 177 additions & 0 deletions
@@ -34,6 +34,12 @@ mod host_pattern;
 #[path = "src/localization/mod.rs"]
 mod localization;
 
+#[path = "src/output_mode.rs"]
+mod output_mode;
+
+#[path = "src/theme.rs"]
+mod theme;
+
 mod build_l10n_audit;
 
 use host_pattern::{HostPattern, HostPatternError};
@@ -43,6 +49,13 @@ type LocalizedParseFn = fn(
     &Arc<dyn ortho_config::Localizer>,
 ) -> Result<(cli::Cli, ArgMatches), clap::Error>;
 
+type ResolveThemeFn = fn(
+    Option<theme::ThemePreference>,
+    Option<bool>,
+    output_mode::OutputMode,
+    fn(&str) -> Option<String>,
+) -> theme::ResolvedTheme;
+
 fn manual_date() -> String {
     let Ok(raw) = env::var("SOURCE_DATE_EPOCH") else {
         return FALLBACK_DATE.into();
@@ -102,6 +115,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     const _: LocalizedParseFn = cli::parse_with_localizer_from;
     const _: fn(&str) -> Result<HostPattern, HostPatternError> = HostPattern::parse;
     const _: fn(&HostPattern, host_pattern::HostCandidate<'_>) -> bool = HostPattern::matches;
+    const _: fn(Option<bool>) -> output_mode::OutputMode = output_mode::resolve;
+    const _: ResolveThemeFn = theme::resolve_theme;
 
     // Regenerate the manual page when the CLI or metadata changes.
     println!("cargo:rerun-if-changed=src/cli/mod.rs");
 
@@ -276,21 +276,18 @@ model provides the necessary ordering guarantees.
    `NINJA_STDERR_MARKER`) to avoid coupling to localized UI strings.
 
 2. **Status messages do not contaminate stdout in standard mode**: Verifies
-   stream
-   routing in non-accessible mode using the same stable markers.
+   stream routing in non-accessible mode using the same stable markers.
 
 3. **Build artifacts can be captured via stdout redirection**: Verifies that
    `netsuke manifest -` output goes to stdout without status contamination.
 
 Supporting infrastructure added:
 
 - `FakeNinjaConfig` struct in `tests/bdd/steps/progress_output.rs` for
-  configurable
-  fixture generation with optional stderr markers.
+  configurable fixture generation with optional stderr markers.
 - `install_fake_ninja_with_config()` function for flexible fixture setup.
 - Updated `fake_ninja_emits_stdout_output` fixture to emit both stdout and
-  stderr
-  markers for comprehensive stream routing verification.
+  stderr markers for comprehensive stream routing verification.
 
 ### Stage E: Documentation (completed)
 
 
@@ -17,6 +17,7 @@ cli.flag.fetch_default_deny.help = Deny all hosts by default; only allow the dec
 cli.flag.accessible.help = Force accessible output mode on or off.
 cli.flag.progress.help = Force standard stage and task progress summaries on or off.
 cli.flag.diag_json.help = Emit machine-readable diagnostics as JSON on stderr.
+cli.flag.theme.help = CLI theme preset (auto, unicode, ascii).
 
 # Subcommand descriptions.
 cli.subcommand.build.about = Build targets defined in the manifest (default).
@@ -43,6 +44,7 @@ cli.validation.scheme.invalid_start = Scheme '{ $scheme }' must start with an AS
 cli.validation.scheme.invalid = Invalid scheme '{ $scheme }'.
 cli.validation.locale.empty = Locale must not be empty.
 cli.validation.locale.invalid = Invalid locale '{ $locale }'.
+cli.validation.theme.invalid = Invalid theme '{ $theme }'. Valid options: auto, unicode, ascii.
 cli.validation.config.expected_object = Expected parsed CLI values to serialize to an object, got { $value }.
 
 # Clap error messages.
 
@@ -17,6 +17,7 @@ cli.flag.fetch_default_deny.help = Denegar todos los hosts por defecto; solo per
 cli.flag.accessible.help = Forzar el modo de salida accesible (activado o desactivado).
 cli.flag.progress.help = Forzar los resúmenes de progreso estándar de etapas y tareas (activados o desactivados).
 cli.flag.diag_json.help = Emitir diagnósticos legibles por máquinas como JSON en stderr.
+cli.flag.theme.help = Tema predefinido de CLI (auto, unicode, ascii).
 
 # Descripciones de subcomandos.
 cli.subcommand.build.about = Compila objetivos definidos en el manifiesto (predeterminado).
@@ -43,6 +44,7 @@ cli.validation.scheme.invalid_start = El esquema '{ $scheme }' debe comenzar con
 cli.validation.scheme.invalid = Esquema no válido '{ $scheme }'.
 cli.validation.locale.empty = La configuración regional no debe estar vacía.
 cli.validation.locale.invalid = Configuración regional no válida '{ $locale }'.
+cli.validation.theme.invalid = Tema no válido '{ $theme }'. Opciones válidas: auto, unicode, ascii.
 cli.validation.config.expected_object = Se esperaba que los valores de la CLI se serializaran como un objeto, se obtuvo { $value }.
 
 # Mensajes de error de Clap.
 
@@ -0,0 +1,177 @@
+//! CLI configuration discovery and merge helpers.
+//!
+//! This module keeps config-layer plumbing out of `cli::mod` so the public CLI
+//! surface stays focused on argument definitions and parsing.
+
+use clap::ArgMatches;
+use clap::parser::ValueSource;
+use ortho_config::declarative::LayerComposition;
+use ortho_config::figment::{Figment, providers::Env};
+use ortho_config::uncased::Uncased;
+use ortho_config::{
+    ConfigDiscovery, LocalizationArgs, MergeComposer, OrthoMergeExt, OrthoResult, sanitize_value,
+};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use crate::localization::{self, keys};
+
+use super::{CONFIG_ENV_VAR, Cli, ENV_PREFIX, validation_message};
+
+/// Return the default manifest filename when none is provided.
+pub(super) fn default_manifest_path() -> PathBuf {
+    PathBuf::from("Netsukefile")
+}
+
+/// Return the prefixed environment provider for CLI configuration.
+fn env_provider() -> Env {
+    Env::prefixed(ENV_PREFIX)
+}
+
+/// Build configuration discovery rooted in the optional working directory.
+fn config_discovery(directory: Option<&Path>) -> ConfigDiscovery {
+    let mut builder = ConfigDiscovery::builder("netsuke").env_var(CONFIG_ENV_VAR);
+    if let Some(dir) = directory {
+        builder = builder.clear_project_roots().add_project_root(dir);
+    }
+    builder.build()
+}
+
+/// Return `true` when no CLI overrides were supplied.
+///
+/// The merge pipeline treats an empty JSON object as "no overrides".
+fn is_empty_value(value: &serde_json::Value) -> bool {
+    matches!(value, serde_json::Value::Object(map) if map.is_empty())
+}
+
+fn diag_json_from_layer(value: &serde_json::Value) -> Option<bool> {
+    value
+        .as_object()
+        .and_then(|map| map.get("diag_json"))
+        .and_then(serde_json::Value::as_bool)
+}
+
+/// Resolve the effective diagnostic JSON preference from the raw config layers.
+///
+/// This is used before full config merging so startup and merge-time failures
+/// can still honour `diag_json` values sourced from config files or the
+/// environment.
+#[must_use]
+pub fn resolve_merged_diag_json(cli: &Cli, matches: &ArgMatches) -> bool {
+    let mut diag_json = Cli::default().diag_json;
+
+    let discovery = config_discovery(cli.directory.as_deref());
+    let file_layers = discovery.compose_layers();
+    for layer in file_layers.value {
+        let layer_value = layer.into_value();
+        if let Some(layer_diag_json) = diag_json_from_layer(&layer_value) {
+            diag_json = layer_diag_json;
+        }
+    }
+
+    let env_provider = env_provider()
+        .map(|key| Uncased::new(key.as_str().to_ascii_uppercase()))
+        .split("__");
+    if let Ok(value) = Figment::from(env_provider).extract::<serde_json::Value>()
+        && let Some(env_diag_json) = diag_json_from_layer(&value)
+    {
+        diag_json = env_diag_json;
+    }
+
+    if matches.value_source("diag_json") == Some(ValueSource::CommandLine) {
+        cli.diag_json
+    } else {
+        diag_json
+    }
+}
+
+fn cli_overrides_from_matches(cli: &Cli, matches: &ArgMatches) -> OrthoResult<serde_json::Value> {
+    let value = sanitize_value(cli)?;
+    let mut map = match value {
+        serde_json::Value::Object(map) => map,
+        other => {
+            let mut args = LocalizationArgs::default();
+            args.insert("value", format!("{other:?}").into());
+            let localizer = localization::localizer();
+            return Err(Arc::new(ortho_config::OrthoError::Validation {
+                key: String::from("cli"),
+                message: validation_message(
+                    localizer.as_ref(),
+                    keys::CLI_CONFIG_EXPECTED_OBJECT,
+                    Some(&args),
+                    &format!("expected parsed CLI values to serialize to an object, got {other:?}"),
+                ),
+            }));
+        }
+    };
+
+    map.remove("command");
+    for field in [
+        "file",
+        "verbose",
+        "fetch_default_deny",
+        "fetch_allow_scheme",
+        "fetch_allow_host",
+        "fetch_block_host",
+        "accessible",
+        "progress",
+        "no_emoji",
+        "theme",
+        "diag_json",
+    ] {
+        if matches.value_source(field) != Some(ValueSource::CommandLine) {
+            map.remove(field);
+        }
+    }
+
+    Ok(serde_json::Value::Object(map))
+}
+
+/// Merge configuration layers over the parsed CLI values.
+///
+/// # Errors
+///
+/// Returns an [`ortho_config::OrthoError`] if layer composition or merging
+/// fails.
+pub fn merge_with_config(cli: &Cli, matches: &ArgMatches) -> OrthoResult<Cli> {
+    let command = cli.command.clone();
+    let mut errors = Vec::new();
+    let mut composer = MergeComposer::with_capacity(4);
+
+    match sanitize_value(&Cli::default()) {
+        Ok(value) => composer.push_defaults(value),
+        Err(err) => errors.push(err),
+    }
+
+    let discovery = config_discovery(cli.directory.as_deref());
+    let mut file_layers = discovery.compose_layers();
+    errors.append(&mut file_layers.required_errors);
+    if file_layers.value.is_empty() {
+        errors.append(&mut file_layers.optional_errors);
+    }
+    for layer in file_layers.value {
+        composer.push_layer(layer);
+    }
+
+    let env_provider = env_provider()
+        .map(|key| Uncased::new(key.as_str().to_ascii_uppercase()))
+        .split("__");
+    match Figment::from(env_provider)
+        .extract::<serde_json::Value>()
+        .into_ortho_merge()
+    {
+        Ok(value) => composer.push_environment(value),
+        Err(err) => errors.push(err),
+    }
+
+    match cli_overrides_from_matches(cli, matches) {
+        Ok(value) if !is_empty_value(&value) => composer.push_cli(value),
+        Ok(_) => {}
+        Err(err) => errors.push(err),
+    }
+
+    let composition = LayerComposition::new(composer.layers(), errors);
+    let mut merged = composition.into_merge_result(Cli::merge_from_layers)?;
+    merged.command = command;
+    Ok(merged)
+}