fix: match requirement identity case-insensitively

src/spec/apply.rs

@@ -58,7 +58,9 @@ fn apply_renamed(
                 ),
             });
         };
-        if canonical.requirement_index(to).is_some() {
+        if let Some(target_index) = canonical.requirement_index(to)
+            && target_index != source_index
+        {
             return Err(ParseIssue {
                 line: Some(*line),
                 message: format!(

src/spec/apply/tests.rs

@@ -1,5 +1,5 @@
 use super::*;
-use crate::spec::model::Requirement;
+use crate::spec::model::{CanonicalSpec, Requirement};
 
 fn requirement(name: &str, scenarios: &[&str]) -> Requirement {
     Requirement {
@@ -10,6 +10,54 @@ fn requirement(name: &str, scenarios: &[&str]) -> Requirement {
     }
 }
 
+fn empty_result() -> ApplyResult {
+    ApplyResult {
+        summary: MergeSummary::default(),
+        warnings: Vec::new(),
+    }
+}
+
+#[test]
+fn added_requirement_with_case_variant_name_is_rejected() {
+    let mut canonical = CanonicalSpec::new("Cap", "chg");
+    canonical.add_requirement(requirement("Temporary review state", &[]));
+    let incoming = requirement("Temporary Review State", &[]);
+    let mut result = empty_result();
+
+    let issue = apply_added(
+        &mut canonical,
+        &[DeltaOperation::Added(incoming)],
+        "Cap",
+        &mut result,
+    )
+    .unwrap_err();
+
+    assert!(issue.message.contains("cannot add existing requirement"));
+    assert_eq!(canonical.requirement_count(), 1);
+}
+
+#[test]
+fn added_requirement_identical_up_to_case_is_skipped() {
+    let mut canonical = CanonicalSpec::new("Cap", "chg");
+    let mut existing = requirement("Temporary review state", &[]);
+    existing.content = "shared content".to_string();
+    canonical.add_requirement(existing);
+    let mut incoming = requirement("Temporary Review State", &[]);
+    incoming.content = "shared content".to_string();
+    let mut result = empty_result();
+
+    apply_added(
+        &mut canonical,
+        &[DeltaOperation::Added(incoming)],
+        "Cap",
+        &mut result,
+    )
+    .unwrap();
+
+    assert_eq!(result.summary.added, 0);
+    assert_eq!(canonical.requirement_count(), 1);
+}
+
 #[test]
 fn scenario_preservation_compares_occurrence_multiplicity() {
     let current = requirement("Repeated", &["Retry", "Retry"]);

src/spec/model.rs

@@ -119,8 +119,10 @@ impl CanonicalSpec {
     }
 
     pub(super) fn requirement_index(&self, name: &str) -> Option<usize> {
+        let identity = requirement_identity(name);
         self.body.iter().position(|element| {
-            matches!(element, BodyElement::Requirement(requirement) if requirement.name == name)
+            matches!(element, BodyElement::Requirement(requirement)
+                if requirement_identity(&requirement.name) == identity)
         })
     }
 
@@ -134,7 +136,7 @@ impl CanonicalSpec {
         requirement: &Requirement,
     ) -> bool {
         self.requirement(element_index).is_some_and(|existing| {
-            existing.name == requirement.name
+            requirement_identity(&existing.name) == requirement_identity(&requirement.name)
                 && existing.content
                     == normalize_line_endings(&requirement.content, &self.line_ending)
         })
@@ -254,6 +256,18 @@ pub(super) struct ParseIssue {
     pub(super) message: String,
 }
 
+/// Requirement identity for lookups: case- and whitespace-insensitive,
+/// so a Title Case delta finds its sentence-case canonical twin instead
+/// of appending a duplicate. Equality checks that decide whether an
+/// edit applies keep exact comparison, so a case-only rename still
+/// lands.
+fn requirement_identity(name: &str) -> String {
+    name.split_whitespace()
+        .collect::<Vec<_>>()
+        .join(" ")
+        .to_ascii_lowercase()
+}
+
 fn normalize_line_endings(content: &str, line_ending: &str) -> String {
     content
         .replace("\r\n", "\n")