@@ -12,6 +12,25 @@ pub(crate) fn observe(
     standard: &str,
     source: &[u8],
     deadline: Instant,
+) -> Value {
+    observe_with_cancellation(
+        tool,
+        language,
+        standard,
+        source,
+        deadline,
+        &AtomicBool::new(false),
+    )
+}
+
+/// 对固定标准源码执行共享取消令牌的原生观察；参数与observe一致，额外令牌贯穿两个进程阶段。
+pub(crate) fn observe_with_cancellation(
+    tool: &Path,
+    language: &str,
+    standard: &str,
+    source: &[u8],
+    deadline: Instant,
+    cancelled: &AtomicBool,
 ) -> Value {
     let mut report = json!({"status":"incomplete","reason":"clang_tool_unavailable","version":null,"tool_sha256":null,"diagnostics":[]});
     if Instant::now() >= deadline {
@@ -44,7 +63,6 @@ pub(crate) fn observe(
         report["reason"] = json!("clang_scratch_unavailable");
         return report;
     };
-    let cancelled = AtomicBool::new(false);
     let invoke = |args: Vec<OsString>, stdin| {
         run_process(
             &ProcessSpec {
@@ -56,7 +74,7 @@ pub(crate) fn observe(
                 deadline,
                 output_limit_bytes: 64 * 1024,
             },
-            &cancelled,
+            cancelled,
         )
     };
     let version = invoke(vec![OsString::from("--version")], None);
 
@@ -17,6 +17,10 @@ pub(crate) enum GrammarNativeChecker {
     Go,
     /// 显式固定edition2024的Rustfmt解析；不是Clippy lint或项目编译。
     Rust,
+    /// 固定AppleClang21的C11独立源码观察。
+    C,
+    /// 固定AppleClang21的C++17独立源码观察。
+    Cpp,
 }
 
 impl GrammarNativeChecker {
@@ -32,6 +36,8 @@ impl GrammarNativeChecker {
             "ruby" => Some(Self::Ruby),
             "go" => Some(Self::Go),
             "rust" => Some(Self::Rust),
+            "c" => Some(Self::C),
+            "cpp" => Some(Self::Cpp),
             _ => None,
         }
     }
@@ -44,12 +50,14 @@ impl GrammarNativeChecker {
             Self::Ruby => "ruby 2.6.10p210",
             Self::Go => "go1.23.4",
             Self::Rust => "rustfmt 1.9.0-stable",
+            Self::C | Self::Cpp => "Apple clang version 21.0.0 (clang-2100.3.34.2)",
         }
     }
     /// 返回对应原生制品的有界字节预算；Node 独立预算不扩张其它工具权限。
     pub(crate) fn artifact_budget(self) -> u64 {
         match self {
             Self::Javascript => crate::javascript_syntax_probe::NODE_ARTIFACT_BUDGET,
+            Self::C | Self::Cpp => 256 * 1024 * 1024,
             _ => 64 * 1024 * 1024,
         }
     }
@@ -60,6 +68,32 @@ impl GrammarNativeChecker {
             _ => Ok(None),
         }
     }
+    /// 保留语法与语义的边界；Clang仅明确解析规则可分类为语法无效，警告不是语法错误。
+    pub(crate) fn classify(self, native: &Value) -> Option<bool> {
+        if matches!(self, Self::C | Self::Cpp) {
+            if native["status"] == "completed" {
+                return Some(true);
+            }
+            if native["status"] != "diagnostics_observed" {
+                return None;
+            }
+            let rows = native["diagnostics"].as_array()?;
+            let mut syntax_error = false;
+            for row in rows {
+                match row["level"].as_str()? {
+                    "warning" | "note" => {}
+                    "error" if row["rule_id"] == "clang.err_expected_expression" => {
+                        syntax_error = true
+                    }
+                    // 类型、名称、扩展诊断及未审计解析规则不能被解释为grammar漏报。
+                    _ => return None,
+                }
+            }
+            Some(!syntax_error)
+        } else {
+            crate::grammar_native_differential::classify_native(native)
+        }
+    }
     /// 对冻结源码执行隔离语法观察；工具、源码与预算由差分入口绑定。
     pub(crate) fn observe(
         self,
@@ -77,6 +111,18 @@ impl GrammarNativeChecker {
             Self::Ruby => crate::ruby_syntax_probe::observe(tool, source, deadline, cancelled),
             Self::Go => crate::go_syntax_probe::observe(tool, source, deadline, cancelled),
             Self::Rust => crate::rustfmt_syntax_probe::observe(tool, source, deadline, cancelled),
+            Self::C | Self::Cpp => crate::clang_syntax_probe::observe_with_cancellation(
+                tool,
+                if matches!(self, Self::C) { "c" } else { "cpp" },
+                if matches!(self, Self::C) {
+                    "c11"
+                } else {
+                    "c++17"
+                },
+                source,
+                deadline,
+                cancelled,
+            ),
             Self::Javascript => {
                 crate::javascript_syntax_probe::observe(tool, source, deadline, cancelled)
             }
@@ -98,6 +144,41 @@ mod tests {
         time::{Duration, Instant},
     };
 
+    #[test]
+    fn clang_syntax_labels_preserve_warning_and_semantic_boundaries() {
+        for checker in [GrammarNativeChecker::C, GrammarNativeChecker::Cpp] {
+            for (rows, expected) in [
+                (
+                    serde_json::json!([{"level":"warning","rule_id":"clang.warn_unused_variable"}]),
+                    Some(true),
+                ),
+                (
+                    serde_json::json!([{"level":"error","rule_id":"clang.err_expected_expression"}]),
+                    Some(false),
+                ),
+                (
+                    serde_json::json!([{"level":"error","rule_id":"clang.err_unknown_typename"}]),
+                    None,
+                ),
+                (
+                    serde_json::json!([{"level":"error","rule_id":"clang.err_expected_expression"},{"level":"error","rule_id":"clang.err_unknown_typename"}]),
+                    None,
+                ),
+                (
+                    serde_json::json!([{"rule_id":"clang.err_expected_expression"}]),
+                    None,
+                ),
+            ] {
+                assert_eq!(
+                    checker.classify(
+                        &serde_json::json!({"status":"diagnostics_observed","diagnostics":rows})
+                    ),
+                    expected
+                );
+            }
+        }
+    }
+
     #[test]
     fn every_native_observer_cancels_version_and_scan_in_flight() {
         for language in [
@@ -110,6 +191,8 @@ mod tests {
             "ruby",
             "go",
             "rust",
+            "c",
+            "cpp",
         ] {
             for phase in ["version", "scan"] {
                 let root = std::env::temp_dir().canonicalize().unwrap().join(format!(
@@ -125,6 +208,7 @@ mod tests {
                     "kotlin" => "printf 'info: kotlinc-jvm 2.4.10 (JRE fixture)\\n' >&2",
                     "python" => "printf 'ruff 0.16.8\\n'",
                     "ruby" => "printf 'ruby 2.6.10p210 (fixture) [fixture]\\n'",
+                    "c" | "cpp" => "printf 'Apple clang version 21.0.0 (clang-2100.3.34.2)\\n'",
                     "rust" => "printf 'rustfmt 1.9.0-stable (fixture)\\n'",
                     "go" => {
                         "if [ \"$#\" = 1 ]; then printf 'go version go1.23.4 fixture/fixture\\n'; else printf '%s: go1.23.4\\n' \"$2\"; fi"
@@ -200,6 +284,8 @@ mod tests {
             "ruby",
             "go",
             "rust",
+            "c",
+            "cpp",
         ] {
             for mode in ["alias", "replace"] {
                 let root = std::env::temp_dir().canonicalize().unwrap().join(format!(
@@ -223,6 +309,7 @@ mod tests {
                     "kotlin" => "printf 'info: kotlinc-jvm 2.4.10 (JRE fixture)\\n' >&2",
                     "python" => "printf 'ruff 0.16.8\\n'",
                     "ruby" => "printf 'ruby 2.6.10p210 (fixture) [fixture]\\n'",
+                    "c" | "cpp" => "printf 'Apple clang version 21.0.0 (clang-2100.3.34.2)\\n'",
                     "rust" => "printf 'rustfmt 1.9.0-stable (fixture)\\n'",
                     "go" => {
                         "if [ \"$#\" = 1 ]; then printf 'go version go1.23.4 fixture/fixture\\n'; else printf '%s: go1.23.4\\n' \"$2\"; fi"
 
@@ -69,7 +69,9 @@ pub fn replay_native_corpus(
     let ruby_selected = tools.contains_key("ruby");
     let go_selected = tools.contains_key("go");
     let rust_selected = tools.contains_key("rust");
-    let measure_structure = tools.contains_key("python")
+    let clang_selected = tools.contains_key("c") || tools.contains_key("cpp");
+    let measure_structure = clang_selected
+        || tools.contains_key("python")
         || javascript_selected
         || ruby_selected
         || go_selected
@@ -118,7 +120,7 @@ pub fn replay_native_corpus(
             && checker
                 .companion_identity(&tools[&case.language])
                 .is_ok_and(|current| current == *companion);
-        let native_class = tool_current.then(|| classify_native(&native)).flatten();
+        let native_class = tool_current.then(|| checker.classify(&native)).flatten();
         let wasm_started = Instant::now();
         let observation =
             if !admitted || cancelled.load(Ordering::Relaxed) || Instant::now() >= deadline {
@@ -166,6 +168,10 @@ pub fn replay_native_corpus(
             "native_elapsed_us":native_us,"wasm_classification":name(wasm_class),"wasm_recovery_count":recovery_count,"wasm_reason":wasm_reason,
             "wasm_elapsed_us":elapsed_us(wasm_started),"comparison":comparison(native_class,wasm_class),
             "fixture_native_disagreement":native_class.map(|valid|valid!=case.expected_valid)});
+        if matches!(case.language.as_str(), "c" | "cpp") {
+            row["native_standard"] = json!(if case.language == "c" { "c11" } else { "c++17" });
+            row["native_classification_policy"] = json!("clang-parse-expression-only-v1");
+        }
         if case.language == "javascript" {
             // Node开发观察器固定--input-type=module，不向未知项目模式推断。
             row["javascript_mode"] = json!("module");
@@ -249,7 +255,7 @@ pub fn replay_native_corpus(
             inventory.push(json!({"language":language,"grammar_sha256":asset["sha256"],"native_selected":false,"reason":if checker(language).is_some(){"explicit_native_tool_not_selected"}else{"native_differential_adapter_unavailable"},"grammar_qualified":false}));
         }
     }
-    let mut report = json!({"schema_version":if javascript_selected {"0.10.0"}else if rust_selected {"0.8.0"}else if go_selected {"0.7.0"}else if ruby_selected {"0.5.0"}else if measure_structure {"0.3.0"}else{"0.1.0"},"report_type":"native_grammar_differential","status":"incomplete","delivery_decision":"not_evaluated",
+    let mut report = json!({"schema_version":if clang_selected {"0.11.0"}else if javascript_selected {"0.10.0"}else if rust_selected {"0.8.0"}else if go_selected {"0.7.0"}else if ruby_selected {"0.5.0"}else if measure_structure {"0.3.0"}else{"0.1.0"},"report_type":"native_grammar_differential","status":"incomplete","delivery_decision":"not_evaluated",
         "authority":"development_native_differential_only","native_adapter_reused":!(javascript_selected || ruby_selected || go_selected || rust_selected),"independent_holdout":false,"grammar_qualified_count":0,
         "corpus_sha256":digest(corpus_bytes),"manifest_sha256":corpus.manifest_sha256,"program_sha256":program_sha,"program_stable":program_stable,
         "language_count":inventory.len(),"selected_language_count":frozen.len(),"sample_count":cases.len(),"languages":inventory,"cases":cases});
 
@@ -0,0 +1,119 @@
+#![cfg(all(feature = "wasm-precheck", unix))]
+use codeguard_cli::grammar_native_differential::replay_native_corpus;
+use serde_json::{Value, json};
+use sha2::{Digest, Sha256};
+use std::{
+    collections::BTreeMap,
+    fs,
+    os::unix::fs::PermissionsExt,
+    path::PathBuf,
+    sync::atomic::AtomicBool,
+    time::{Duration, Instant},
+};
+
+fn corpus() -> Vec<u8> {
+    let mut corpus: Value = serde_json::from_slice(include_bytes!(
+        "../../../tests/fixtures/grammar_regression_v0_2.json"
+    ))
+    .unwrap();
+    codeguard_cli::grammar_evaluation::validate_corpus_against_manifest(
+        &serde_json::to_vec(&corpus).unwrap(),
+        include_bytes!("../../../tests/fixtures/grammar_manifests/manifest_2026_10_04.json"),
+    )
+    .unwrap();
+    corpus["manifest_sha256"] = json!(format!(
+        "{:x}",
+        Sha256::digest(include_bytes!("../../../grammars/manifest.json"))
+    ));
+    corpus["cases"]
+        .as_array_mut()
+        .unwrap()
+        .retain(|c| c["language"] != "c" && c["language"] != "cpp");
+    for language in ["c", "cpp"] {
+        for (name, source, valid) in [
+            ("plain", "int x=1;\n", true),
+            ("warning", "int f(void) { int unused; return 0; }\n", true),
+            ("literal", "const char *s=\"#literal\";\n", true),
+            ("syntax", "int x = ;\n", false),
+            ("semantic", "UnknownType x;\n", true),
+            ("context", "%:include \"missing.h\"\n", true),
+        ] {
+            corpus["cases"].as_array_mut().unwrap().push(json!({"id":format!("{language}-replay-{name}"),"language":language,"source":source,"source_sha256":format!("{:x}",Sha256::digest(source)),"expected_valid":valid,"label":"regression","cohort":"repository_regression","origin":"crates/codeguard-cli/tests/c_family_native_replay.rs"}));
+        }
+    }
+    serde_json::to_vec(&corpus).unwrap()
+}
+
+fn replay(tool: PathBuf, budget: u64) -> Value {
+    replay_native_corpus(
+        &PathBuf::from(env!("CARGO_BIN_EXE_codeguard")),
+        &corpus(),
+        &BTreeMap::from([("c".into(), tool.clone()), ("cpp".into(), tool)]),
+        Instant::now() + Duration::from_secs(budget),
+        &AtomicBool::new(false),
+    )
+    .expect("C11/C++17 must use explicit native Clang observers")
+}
+
+#[test]
+fn selected_clang_wrong_version_retains_unknown_cases_and_full_inventory() {
+    let root = std::env::temp_dir().join(format!("cg-clang-replay-control-{}", std::process::id()));
+    fs::create_dir(&root).unwrap();
+    let tool = root.join("clang");
+    fs::write(&tool, "#!/bin/sh\nprintf 'unknown compiler\\n'\n").unwrap();
+    fs::set_permissions(&tool, fs::Permissions::from_mode(0o700)).unwrap();
+    let result = std::panic::catch_unwind(|| replay(tool, 90));
+    fs::remove_dir_all(root).unwrap();
+    let report = result.unwrap();
+    assert_eq!(report["schema_version"], "0.11.0");
+    assert_eq!(report["native_adapter_reused"], true);
+    assert_eq!(report["language_count"], 32);
+    assert_eq!(report["sample_count"], 12);
+    assert_eq!(report["grammar_qualified_count"], 0);
+    assert!(
+        report["cases"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .all(|c| c["native_classification"] == "unknown" && c["comparison"] == "unknown")
+    );
+}
+
+#[test]
+#[ignore = "requires explicit existing Apple Clang21 via CODEGUARD_CLANG_BIN; never installs"]
+fn actual_clang_warnings_semantics_and_context_do_not_fabricate_syntax_labels() {
+    let tool = PathBuf::from(std::env::var_os("CODEGUARD_CLANG_BIN").unwrap());
+    let report = replay(tool, 180);
+    assert_eq!(report["schema_version"], "0.11.0");
+    assert_eq!(report["native_adapter_reused"], true);
+    for row in report["cases"].as_array().unwrap() {
+        let id = row["id"].as_str().unwrap();
+        let expected = if id.ends_with("semantic") || id.ends_with("context") {
+            "unknown"
+        } else if id.ends_with("syntax") {
+            "invalid"
+        } else {
+            "valid"
+        };
+        assert_eq!(row["native_classification"], expected, "{row}");
+        assert_eq!(
+            row["native_standard"],
+            if row["language"] == "c" {
+                "c11"
+            } else {
+                "c++17"
+            }
+        );
+        assert_eq!(
+            row["fixture_native_disagreement"],
+            if expected == "unknown" {
+                Value::Null
+            } else {
+                json!(false)
+            }
+        );
+    }
+    if let Some(path) = std::env::var_os("CODEGUARD_CLANG_REPLAY_EVIDENCE") {
+        fs::write(path, serde_json::to_vec_pretty(&report).unwrap()).unwrap();
+    }
+}
@@ -200,3 +200,6 @@ flowchart LR
     I --> J[Agent feedback and original native verification]
     J --> K[Closure requires accepted native repair evidence]
 ```
+
+
+Uniform development replay now reuses the fixed Clang service for C11/C++17 with shared cancellation. Warnings do not count as syntax errors; only the audited expected-expression parsing rule classifies invalid syntax. Semantic/mixed/context diagnostics remain unknown. Report0.11 records standard and policy, preserves the32-language inventory, and grants no qualification. See [bounded acceptance](../tests/acceptance/c-family-native-replay.md).
@@ -212,3 +212,6 @@ flowchart LR
     I --> J[智能体反馈与原工具复检]
     J --> K[关闭仍需通过原生修复验收]
 ```
+
+
+C11/C++17开发期统一回放现复用固定Clang原生服务与共享取消令牌。警告不算语法错误；仅已审计缺表达式解析规则可分类，语义/混合/预处理上下文保持unknown。新0.11协议记录标准与策略，32库存及零资格保持；见[局部验收](../tests/acceptance/c-family-native-replay.md)。
@@ -969,3 +969,8 @@ Model capture, original task execution and report ownership observation SHALL sh
 - **THEN** CodeGuard SHALL preserve native syntax checking rather than infer missing header/macro context from those literal characters. Real line-start preprocessing directives, including digraph spellings and C11 trigraphs, SHALL remain context-unresolved before native execution. Line splicing and raw-string translation boundaries SHALL not allow header reads or fabricate source findings. This guard SHALL not establish a complete preprocessing model or production qualification.
 
 - **AND** the fixed Clang guard SHALL account for initial UTF-8 BOM and LF, CR, CRLF, LFCR and horizontal-space splices within the 1MiB input budget. Uncertain leading Unicode recovery SHALL remain explicitly context-unresolved without source violations or qualification.
+
+
+#### Scenario: C11 and C++17 uniform native grammar replay keeps semantic diagnostics unknown
+- **WHEN** development corpus replay explicitly selects an existing fixed Apple Clang21 tool for c or cpp
+- **THEN** it SHALL reuse the isolated native service with c11 or c++17, shared deadline/cancellation and frozen original entry/artifact identity. It SHALL retain all 32 inventory rows, selected samples and unknown denominators. Version/tool/context failures SHALL NOT become syntax failures; warnings alone SHALL NOT become invalid syntax. Only independently audited parsing diagnostic rules MAY classify syntax errors, and mixed semantic/unknown errors SHALL remain unknown. Standard and classification policy SHALL be recorded in a new versioned report without changing historical report semantics, granting grammar qualification or claiming independent holdout.