feat(scaffold): 模板可以拒绝自依赖,因为有一个模板必须拒绝

⚠️ **`mcpp new k --template riscv-virt-rt:nolibc` 之后 `mcpp run` 直接失败**,
而那个模板的全部意义就是不依赖任何东西。

自依赖注入的存在是为了让模板不与它所属的库脱节,这对几乎所有模板都对。它对
「主题就是不依赖任何东西」的模板是错的:板级包自己的模块 `#include <stdio.h>`,
于是在一个**清单里没有任何依赖**的工程上,报错是

    riscv_virt_rt.cppm:9: fatal error: 'stdio.h' file not found

⇒ `[template.inject] self = false`。布尔形式拒绝注入,既有的表形式(携带 features)
不受影响,默认仍然是开 —— 三个单测分别钉住这三种情形,其中「默认为开」那条是防止
将来悄悄翻转:每个没有声明的模板都依赖它。

## 生态侧同批修复(riscv-virt-rt 0.4.1)

板级包此前把「没有 C 库」当成错误。它不是:处在零 libc 档的工程没有在向这块板子要
任何东西。现在该路径不再报错。

⚠️ 但**模拟器照常发** —— 哪个模拟器能启动这台机器是板级事实,与哪份 C 库编出的镜像
无关。我第一版把它和其余部分一起早退掉了,那会让这类工程没有 runner。

实测:生成后 **362 字节**,qemu 中打印 `k: running with no C library` / `answer 42`。

## ⚠️ 这是本轮唯一一次发布之后才发现的缺陷

0.4.0 的模板在索引里可见、可生成,而生成出来的工程跑不起来。发现它的方式是**用发布后
的包从零走一遍新用户流程** —— 与上一轮 `.3` 那次同一个方法,也同一个教训:
**「我这儿能跑」用的从来不是新用户的路径。**

Author: speak-agent

.agents/docs/2026-08-20-freestanding-ecosystem-implementation-plan.md

@@ -135,7 +135,13 @@ capability 作仲裁,实现在别的包。
 
 | `nolibc` 也应做成 `std-freestanding` 的 feature(默认关),与 `alloc-*` 一致 | ⚠️ **我判断它「状态不可达」,而那个判断建立在一次测错的探针上**;正确测量后它**可达,但代价是一个独立项目**。见 §3.1 | 本轮不加;记为后续项 |
 
-⇒ 十四条里有十三条**若不实测就会写进文档**。
+| 零 libc 模板发布即可用 | ⚠️ **生成出来就是坏的。** `mcpp new --template` 强制注入自依赖,而板级包自己的模块 `#include <stdio.h>` ⇒ 那个从未被请求的依赖在工程本身之前就编不过 | 引擎加 `[template.inject] self = false`;板级包在零 libc 档改为**不贡献而非报错**,但**照常发 runner** |
+
+⇒ 十五条里有十四条**若不实测就会写进文档**。
+
+⚠️ 最后这条是唯一一次**发布之后**才发现的:0.4.0 的模板在索引里可见、可生成,
+而生成出来的工程跑不起来。发现它的方式是**用发布后的包从零走一遍新用户流程** ——
+和上一轮 `.3` 那次同一个方法,也同一个教训:**「我这儿能跑」用的从来不是新用户的路径。**
 
 ⭐ 上面这条值得单独记:提法本身是对的(默认关的 feature 与主动加依赖等价,且能让包的
 表面一致),**我原来反对它的理由也确实站不住**(中间库无论经 feature 还是经直接依赖

src/scaffold/create.cppm

@@ -256,11 +256,15 @@ export int new_from_package_template(
         mcpp::ui::error(instantiated.error());
         return 1;
     }
-    auto injected = mcpp::scaffold::inject_self_dependency(
-        root / "mcpp.toml", vars, chosen->meta.injectSelfFeatures);
-    if (!injected) {
-        mcpp::ui::error(injected.error());
-        return 1;
+    // A template may decline the self-dependency — see TemplateMeta::injectSelf
+    // for the case that requires it.
+    if (chosen->meta.injectSelf) {
+        auto injected = mcpp::scaffold::inject_self_dependency(
+            root / "mcpp.toml", vars, chosen->meta.injectSelfFeatures);
+        if (!injected) {
+            mcpp::ui::error(injected.error());
+            return 1;
+        }
     }
 
     // Parsing the completed manifest is the final semantic gate. Nothing is

src/scaffold/template.cppm

@@ -118,6 +118,21 @@ struct TemplateMeta {
     std::string postMessage;
     // [template.inject] self = { features = [...] }
     std::vector<std::string> injectSelfFeatures;
+    // [template.inject] self = false
+    //
+    // ⚠️ A TEMPLATE THAT MUST NOT DEPEND ON ITS OWN PACKAGE IS NOT HYPOTHETICAL.
+    //
+    // The self-dependency exists so a template cannot drift from the library
+    // that ships it, and for almost every template that is right. It is wrong
+    // for one whose whole subject is depending on NOTHING: a bare-metal package
+    // may ship a kernel starting point for a target with no C library, and its
+    // own module includes <stdio.h> — so injecting it makes the generated
+    // project fail to compile the dependency it never asked for.
+    //
+    // Measured: `mcpp new k --template riscv-virt-rt:nolibc` then `mcpp run`
+    // failed on the board package's own module, in a project whose manifest
+    // declares no dependencies at all.
+    bool injectSelf = true;
 };
 
 std::expected<TemplateMeta, std::string>
@@ -142,6 +157,12 @@ load_meta(const std::filesystem::path& templateDir) {
             meta.isDefault = it->second.as_bool();
         if (auto it = t->find("inject"); it != t->end() && it->second.is_table()) {
             auto& inj = it->second.as_table();
+            // The bool form declines the injection outright; the table form
+            // keeps it and carries features.
+            if (auto self = inj.find("self");
+                self != inj.end() && self->second.is_bool()) {
+                meta.injectSelf = self->second.as_bool();
+            }
             if (auto self = inj.find("self");
                 self != inj.end() && self->second.is_table()) {
                 auto& st = self->second.as_table();

tests/unit/test_scaffold.cpp

@@ -388,3 +388,63 @@ widget = "1.0.0"
 }
 
 } // namespace
+
+// ── [template.inject] self = false ───────────────────────────────────────────
+//
+// ⚠️ A TEMPLATE THAT MUST NOT DEPEND ON ITS OWN PACKAGE IS NOT HYPOTHETICAL.
+//
+// The self-dependency keeps a template from drifting from the library that
+// ships it, and for almost every template that is right. It is wrong for one
+// whose subject is depending on NOTHING: a bare-metal package may ship a kernel
+// starting point for a target with no C library, while the package's own module
+// includes <stdio.h>. Measured: the injected dependency failed to compile
+// before the generated project was reached, in a project whose manifest
+// declares no dependencies at all.
+TEST(ScaffoldTemplate, InjectSelfCanBeDeclined) {
+    auto dir = std::filesystem::temp_directory_path() / "mcpp_tmpl_noself";
+    std::filesystem::remove_all(dir);
+    std::filesystem::create_directories(dir);
+    {
+        std::ofstream f(dir / "template.toml");
+        f << "[template]\ndescription = \"d\"\n[template.inject]\nself = false\n";
+    }
+    auto meta = mcpp::scaffold::load_meta(dir);
+    ASSERT_TRUE(meta.has_value()) << (meta ? "" : meta.error());
+    EXPECT_FALSE(meta->injectSelf);
+    std::filesystem::remove_all(dir);
+}
+
+// The default must stay ON: every template that does not say otherwise relies
+// on the injection, and a silent flip would leave them all without their own
+// package.
+TEST(ScaffoldTemplate, InjectSelfDefaultsToOn) {
+    auto dir = std::filesystem::temp_directory_path() / "mcpp_tmpl_self_default";
+    std::filesystem::remove_all(dir);
+    std::filesystem::create_directories(dir);
+    {
+        std::ofstream f(dir / "template.toml");
+        f << "[template]\ndescription = \"d\"\n";
+    }
+    auto meta = mcpp::scaffold::load_meta(dir);
+    ASSERT_TRUE(meta.has_value()) << (meta ? "" : meta.error());
+    EXPECT_TRUE(meta->injectSelf);
+    std::filesystem::remove_all(dir);
+}
+
+// The table form still carries features, and must not be read as "declined".
+TEST(ScaffoldTemplate, InjectSelfTableFormStillInjects) {
+    auto dir = std::filesystem::temp_directory_path() / "mcpp_tmpl_self_table";
+    std::filesystem::remove_all(dir);
+    std::filesystem::create_directories(dir);
+    {
+        std::ofstream f(dir / "template.toml");
+        f << "[template]\ndescription = \"d\"\n"
+             "[template.inject]\nself = { features = [\"x\"] }\n";
+    }
+    auto meta = mcpp::scaffold::load_meta(dir);
+    ASSERT_TRUE(meta.has_value()) << (meta ? "" : meta.error());
+    EXPECT_TRUE(meta->injectSelf);
+    ASSERT_EQ(meta->injectSelfFeatures.size(), 1u);
+    EXPECT_EQ(meta->injectSelfFeatures[0], "x");
+    std::filesystem::remove_all(dir);
+}