svharness 0.13.3 → 0.14.1

package/README.md

@@ -119,7 +119,7 @@ Harness 是一个 **项目本地的知识层**，由两大部分组成：
     └── wiki/                       #   架构 wiki
 │
 ├── agent-env/                    # Agent 运行期环境
-│   ├── rules/                    #   编码规则（.mdc，always_on 加载）
+│   ├── rules/                    #   编码规则（.mdc，`alwaysApply: true` 为硬约束）
 │   ├── skills/                   #   运行期技能（SKILL.md + references/ + scripts/）
 │   ├── tools/                    #   项目本地脚本
 │   └── memory/                   #   Agent 长期记忆
@@ -150,7 +150,7 @@ S40/S50                 -> harness-build-skill-spec-builder
 S60                     -> harness-build-skill-references-intake
 S61/S65                 -> harness-build-skill-agent-env-merge
 S70                     -> harness-build-skill-knowledge-builder
-S80/S90                 -> harness-build-skill-orchestrator
+S80/S85/S90             -> harness-build-skill-orchestrator (+ S85 委派 pre-seal-review)
 ```
 
 `.harness-build-state.yaml` 跟踪进度，任何阶段可中断再续。
@@ -192,7 +192,8 @@ harness-build-{skill|rule}-<semantic-name>
 | **S65_customize_agent_env** | agent-env 定制（extra-skills/extra-rules 冲突建议与重命名建议 → 用户确认 → 写入） | `agent-env/rules/` + `agent-env/skills/` |
 | **S70_runtime_assets** | 运行期 Skills & tasks 索引（skill 执行 task） | `agent-env/skills/` + `tasks/templates/` |
 | **S80_seed_memory** | Memory 初始化 | `agent-env/memory/categories/` |
-| **S90_finalize** | 封板 | 版本 bump + CHANGELOG + 终审 |
+| **S85_pre_seal_validation** | 封存前校验 | `svharness doctor` + 全面审查报告 |
+| **S90_finalize** | 封板 | 版本 bump + CHANGELOG + `bootstrap_mode: false` |
 
 > 反复调用 orchestrator 总是从"第一个非 DONE 的阶段"继续。
 > **S10_wiki 仅在有 baseline 时出现；无 baseline 则不构建 wiki，流程从 S20_collect_inputs 开始。**
@@ -222,6 +223,7 @@ svharness wizard
 | `build` | 对应 `svharness build` |
 | `apply` | 对应 `svharness apply` |
 | `convert` | 对应 `svharness convert` |
+| `doctor` | 对应 `svharness doctor` |
 
 `build` 节除路径外，可写人类可读说明（仅写入配置文件，供团队阅读）：
 
@@ -276,7 +278,7 @@ svharness build \
 | `--convert-max-file-mb <n>` | 可选 | build 自动 convert 单文件大小上限（MB） | `50` |
 | `--convert-timeout-sec <n>` | 可选 | build 自动 convert 请求超时秒数 | `120` |
 | `--convert-force` | 可选 flag | build 自动 convert 覆盖同名 `.md`（否则按 `-1/-2` 追加） | `false` |
-| `--force` | 可选 flag | 覆写已存在的 harness 目录；同时覆写项目根 `AGENTS.md` / `CLAUDE.md`（若存在） | `false` |
+| `--force` | 可选 flag | 覆写已存在的 harness 目录；同时允许覆盖已注入的 build skills/rules 与项目根 `AGENTS.md` / `CLAUDE.md`（默认遇到已存在文件会跳过） | `false` |
 | `-y, --yes` | 可选 flag | 跳过所有提示，采用默认值 | `false` |
 | `--verbose` | 可选 flag | 打印每个生成文件 | `false` |
 
@@ -333,8 +335,10 @@ svharness apply --harness ../my-app-harness --target ./to-apply-project --clone
 此外，`apply` 会同步注入运行期资产：
 
 - `<harness>/agent-env/rules/` → `<target>/<adapter.rulesDir>/`（若该 agent 声明了 `rulesDir`）
-- `<harness>/agent-env/skills/` → `<target>/<adapter.skillsDir>/`（全量注入；`harness-apply-skills-main` 由模板写入为薄入口）
-- 目标 `.gitignore` 会追加注入路径（幂等去重）
+- `<harness>/agent-env/skills/` → `<target>/<adapter.skillsDir>/`（默认跳过同名已存在文件；`--force` 才覆盖。`harness-apply-skills-main` 由模板写入为薄入口）
+- `--include-build-assets` 开启时：同步生成 `<target>/build-agent-env/skills` 与 `<target>/build-agent-env/rules`，用于二次 agent 驱动修改
+- `--inject-build-main-bridge` 开启时：在 `<target>/<adapter.skillsDir>/harness-build-skills-bridge/` 写入桥接 skill（仅用于构建流二次改造）
+- 目标 `.gitignore` 会在文件尾部 append 注入路径（幂等去重）
 
 #### references 内容引用 → apply_skill_registry（S60，由 Agent 写入）
 
@@ -348,7 +352,7 @@ S60（`harness-build-skill-references-intake`）属于 **build 阶段**。若某
 #### build / apply 分工
 
 - **build 阶段**：生成 harness 本体资产（`AGENTS_APPLY.md`、`agent-env/skills`、`agent-env/rules`、`specs`、`baseline` 等）
-- **apply 阶段**：复制 harness 到目标项目、注入 skills/rules、生成入口文件、写 `.gitignore`、校验注入文件引用关系
+- **apply 阶段**：复制 harness 到目标项目、注入 skills/rules、（可选）拷贝构建期 assets、生成入口文件、写 `.gitignore`、输出一致性检查报告
 
 #### 全部参数
 
@@ -356,8 +360,11 @@ S60（`harness-build-skill-references-intake`）属于 **build 阶段**。若某
 |------|----------|------|--------|
 | `--harness <path>` | ✅ 必填 | 已构建好的 harness 目录（形如 `./my-app-harness`） | — |
 | `--target <path>` | 可选 | 目标项目根目录 | **当前工作目录（cwd）** |
-| `--agent <agent>` | 可选 | 目标 Agent：`codechat` / `qoder` / `cursor` / `claude-code` / `opencode` / `generic` | **从 `<harness>/.harness-build-state.yaml` 读取**；缺失则报错 |
+| `--agent <agent>` | 可选 | 目标 Agent：`codechat` / `qoder` / `cursor` / `claude-code` / `opencode` / `generic` | `codechat` |
 | `--clone` | 可选 flag | 兼容参数；当前实现下行为与默认一致（都会拷贝 harness） | `false` |
+| `--include-build-assets` | 可选 flag | 显式拷贝构建期 skills/rules 到 `build-agent-env/`（用于二次改造） | `false` |
+| `--inject-build-main-bridge` | 可选 flag | 向运行期 skills 注入 `harness-build-skills-bridge`（需 `--include-build-assets`） | `false` |
+| `--consistency <mode>` | 可选 | 一致性检查级别：`basic` / `strict`（`strict` 当前为预留模式） | `basic` |
 | `--force` | 可选 flag | 覆盖已存在注入目录与入口文件；同时允许重拷贝 harness | `false` |
 | `-y, --yes` | 可选 flag | 跳过交互确认 | `false` |
 | `--verbose` | 可选 flag | 显示详细日志 | `false` |
@@ -371,10 +378,45 @@ S60（`harness-build-skill-references-intake`）属于 **build 阶段**。若某
 ├── <adapter.skillsDir>/<runtime-skill>/SKILL.{md|mdc}  # 运行期 skills 注入
 ├── <adapter.skillsDir>/harness-apply-skills-main/
 │   └── SKILL.{md|mdc}              # 薄入口 skill（仅提示/索引，不做二级调度）
+├── <adapter.skillsDir>/harness-build-skills-bridge/
+│   └── SKILL.{md|mdc}              # 可选：--inject-build-main-bridge（build 流桥接，不是默认入口）
+├── build-agent-env/                # 可选：--include-build-assets 时生成
+│   ├── skills/                     # 构建期 skills 镜像（可二次改造）
+│   └── rules/                      # 构建期 rules 镜像（可二次改造）
 └── <name>-harness/                 # apply 默认复制后的 harness
 ```
 
-> 注入完成后，CLI 会校验入口文件、薄入口 skill、注入 skills/rules 内的路径引用是否可达；失败会报错中止。
+> 注入完成后，CLI 会输出一致性检查摘要（目录/文件存在性、frontmatter 关键字段、引用可达性），发现问题会给出警告或错误明细供修复。
+
+#### 回滚（bridge 最小清理）
+
+- 软回滚：后续 `apply` 不再传 `--inject-build-main-bridge`。
+- 硬回滚：删除 `<adapter.skillsDir>/harness-build-skills-bridge/` 即可；`build-agent-env/` 可保留用于后续构建流改造。
+
+### `doctor` —— harness 健康度与封存前硬检查（S85）
+
+在 Agent 进入 **S85_pre_seal_validation** / 封板前，对 harness 目录执行可重复的硬检查：
+
+```bash
+# 封存前全量（要求 S00–S80 均为 DONE）
+svharness doctor --harness ./my-app-harness --mode pre-seal
+
+# 日常巡检（不强制所有阶段 DONE）
+svharness doctor --harness ./my-app-harness --mode health
+
+# Agent 友好：JSON 报告
+svharness doctor --harness ./my-app-harness --mode pre-seal --format json --report ./my-app-harness/doctor-report.json
+```
+
+| 选项 | 说明 |
+|------|------|
+| `--harness` | harness 根目录（必填；可写在 `svharness.config.yaml` 的 `doctor.harness`） |
+| `--mode` | `pre-seal`（默认）或 `health` |
+| `--format` | `text`（默认）或 `json` |
+| `--report` | JSON 报告路径（默认 `<harness>/doctor-report.json`） |
+| `--strict` | 将 warning 视为 error |
+
+退出码：`0` 通过，`1` 存在 error。通过 doctor 后，由 `harness-build-skill-pre-seal-review` 完成语义层全面审查并经用户确认，方可将 S85 标为 DONE 并进入 S90。
 
 ### `convert` —— 文档 → Markdown 预处理（对接 S20_collect_inputs）
 
@@ -742,11 +784,11 @@ svharness build --harness-name demo-unknown --arch python --agent codechat `
 - [x] `build` —— 骨架 + 元文件 + 状态文件 + skill 注入
 - [x] 多架构模板（`android-compose` / `android-xml` / `cpp` / `web-react` / `python`）
 - [x] `_shared/` + `<arch>/` 两层叠拷合并
-- [x] 每个架构自带 3-5 条规则文件（`.mdc` 格式，`always_on` 加载）
+- [x] 每个架构自带 3-5 条规则文件（`.mdc` 格式，`alwaysApply: true` 默认启用）
 - [x] `apply` —— 把已构建好的 harness 绑定到目标项目（默认复制模式，`--clone` 兼容保留）
 - [x] 构建辅助资源统一命名（`build-skills/harness-build-skill-*`、`build-rules/harness-build-rule-*`）
 - [ ] `detach` —— 从目标项目解绑并清理 dispatcher skill
-- [ ] `doctor` —— 检查既有 harness 的健康度
+- [x] `doctor` —— 检查既有 harness 的健康度（`svharness doctor`）
 - [ ] `phase` —— 从 CLI 直接运行某个构建阶段
 - [ ] `--arch auto` —— 根据 `--baseline` 自动推断架构
 - [ ] 更多架构模板（`ios-swiftui` / `service-kotlin` / `python-fastapi` 等）

package/dist/commands/apply.js

@@ -13,7 +13,9 @@ const apply_project_entry_1 = require("../core/apply-project-entry");
 const validate_args_1 = require("../utils/validate-args");
 const logger_1 = require("../utils/logger");
 const version_1 = require("../utils/version");
+const skill_md_validate_1 = require("../utils/skill-md-validate");
 const DISPATCHER_SKILL_NAME = 'harness-apply-skills-main';
+const BUILD_MAIN_BRIDGE_SKILL_NAME = 'harness-build-skills-bridge';
 const BUILD_SKILL_TEMPLATE_FILES = [
     'harness-build-skills-main.md',
     'harness-build-skill-orchestrator.md',
@@ -22,6 +24,18 @@ const BUILD_SKILL_TEMPLATE_FILES = [
     'harness-build-skill-agent-env-merge.md',
     'harness-build-skill-knowledge-builder.md',
     'harness-build-skill-wiki-writer.md',
+    'harness-build-skill-pre-seal-review.md',
+];
+const BUILD_RULE_TEMPLATE_FILES = [
+    'harness-build-rule-agent-agnostic.md',
+    'harness-build-rule-chinese-only.md',
+    'harness-build-rule-convert-check.md',
+    'harness-build-rule-memory-write.md',
+    'harness-build-rule-orchestrator-flow.md',
+    'harness-build-rule-pre-seal-review.md',
+    'harness-build-rule-skills-tasks-output.md',
+    'harness-build-rule-specs-schema.md',
+    'harness-build-rule-user-interaction.md',
 ];
 const PATH_KEYS = [
     'agent-env/',
@@ -278,6 +292,10 @@ async function copyRuntimeSkills(input) {
         const content = input.adapter.transform
             ? input.adapter.transform(rewritten, node_path_1.default.basename(srcSkillFile))
             : rewritten;
+        const syncResult = syncSkillFrontmatterName(content, skillName);
+        if (syncResult.warning) {
+            logger_1.logger.warn(`运行期 skill frontmatter.name 同步失败（保留原文）：${skillName} - ${syncResult.warning}`);
+        }
         const dstSkillDir = node_path_1.default.join(dstDir, skillName);
         const dstSkillFile = node_path_1.default.join(dstSkillDir, 'SKILL' + input.adapter.skillExt);
         if ((await fs_extra_1.default.pathExists(dstSkillFile)) && !input.force) {
@@ -285,7 +303,7 @@ async function copyRuntimeSkills(input) {
             continue;
         }
         await fs_extra_1.default.ensureDir(dstSkillDir);
-        await fs_extra_1.default.outputFile(dstSkillFile, content, 'utf8');
+        await fs_extra_1.default.outputFile(dstSkillFile, syncResult.content, 'utf8');
         written.push(node_path_1.default.relative(input.targetRoot, dstSkillFile));
     }
     return written;
@@ -314,6 +332,32 @@ async function injectThinMainSkill(input) {
     await fs_extra_1.default.outputFile(dstFile, content, 'utf8');
     return dstFile;
 }
+async function injectBuildMainBridgeSkill(input) {
+    const templatePath = node_path_1.default.join(input.templatesRoot, '_shared', 'apply-skills', `${BUILD_MAIN_BRIDGE_SKILL_NAME}.md`);
+    if (!(await fs_extra_1.default.pathExists(templatePath))) {
+        throw new Error(`build-main bridge 模板缺失：${templatePath}`);
+    }
+    const dstDir = node_path_1.default.join(input.targetRoot, input.adapter.skillsDir, BUILD_MAIN_BRIDGE_SKILL_NAME);
+    const dstFile = node_path_1.default.join(dstDir, 'SKILL' + input.adapter.skillExt);
+    if (await fs_extra_1.default.pathExists(dstDir)) {
+        if (!input.force) {
+            throw new Error(`目标 bridge skill 目录已存在：${dstDir}\n  使用 --force 覆盖，或先清理目标目录。`);
+        }
+        await fs_extra_1.default.remove(dstDir);
+    }
+    const raw = await fs_extra_1.default.readFile(templatePath, 'utf8');
+    const rendered = raw
+        .replace(/__HARNESS_ROOT_REL__/g, `./${input.harnessDirName}`)
+        .replace(/__BUILD_SKILLS_DIR__/g, './build-agent-env/skills')
+        .replace(/__BUILD_RULES_DIR__/g, './build-agent-env/rules')
+        .replace(/__APPLY_MAIN_SKILL__/g, DISPATCHER_SKILL_NAME);
+    const content = input.adapter.transform
+        ? input.adapter.transform(rendered, `${BUILD_MAIN_BRIDGE_SKILL_NAME}.md`)
+        : rendered;
+    await fs_extra_1.default.ensureDir(dstDir);
+    await fs_extra_1.default.outputFile(dstFile, content, 'utf8');
+    return dstFile;
+}
 async function updateGitIgnore(input) {
     const gitignorePath = node_path_1.default.join(input.targetRoot, '.gitignore');
     const raw = (await fs_extra_1.default.pathExists(gitignorePath))
@@ -338,9 +382,10 @@ async function updateGitIgnore(input) {
     }
     if (added.length === 0)
         return [];
-    const appendix = '\n# svharness apply injected assets\n' + added.map((line) => `${line}\n`).join('');
-    const next = raw.endsWith('\n') || raw.length === 0 ? raw + appendix : raw + '\n' + appendix;
-    await fs_extra_1.default.outputFile(gitignorePath, next, 'utf8');
+    const prefix = raw.length === 0 ? '' : raw.endsWith('\n') ? '\n' : '\n\n';
+    const appendix = `${prefix}# svharness apply injected assets\n` + added.map((line) => `${line}\n`).join('');
+    await fs_extra_1.default.ensureDir(node_path_1.default.dirname(gitignorePath));
+    await fs_extra_1.default.appendFile(gitignorePath, appendix, 'utf8');
     return added;
 }
 async function validateInjectedReferences(input) {
@@ -365,6 +410,34 @@ async function validateInjectedReferences(input) {
     }
     return failures;
 }
+function syncSkillFrontmatterName(content, expectedName) {
+    const frontmatter = (0, skill_md_validate_1.extractFrontmatter)(content);
+    if (!frontmatter) {
+        return { content, changed: false, warning: '缺少 frontmatter' };
+    }
+    let parsed;
+    try {
+        parsed = js_yaml_1.default.load(frontmatter.block);
+    }
+    catch (err) {
+        return { content, changed: false, warning: `frontmatter 解析失败：${err.message}` };
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return { content, changed: false, warning: 'frontmatter 解析为空' };
+    }
+    const currentName = typeof parsed.name === 'string' ? parsed.name.trim() : '';
+    if (currentName === expectedName) {
+        return { content, changed: false };
+    }
+    parsed.name = expectedName;
+    const dumped = js_yaml_1.default.dump(parsed, { lineWidth: 120, noRefs: true }).trimEnd();
+    const rewrittenNormalized = `---\n${dumped}\n---\n` + frontmatter.normalized.slice(frontmatter.endIdx + 5);
+    const hasCrlf = content.includes('\r\n');
+    return {
+        content: hasCrlf ? rewrittenNormalized.replace(/\n/g, '\r\n') : rewrittenNormalized,
+        changed: true,
+    };
+}
 async function saveBuildSkillsToBuildAgentEnv(input) {
     const destRoot = node_path_1.default.join(input.targetRoot, 'build-agent-env', 'skills');
     await fs_extra_1.default.ensureDir(destRoot);
@@ -424,19 +497,70 @@ async function saveBuildSkillsToBuildAgentEnv(input) {
     }
     return written;
 }
+async function resolveRuleSourceFile(rulesRoot, ruleName, ruleExt) {
+    const candidates = [
+        node_path_1.default.join(rulesRoot, `${ruleName}${ruleExt}`),
+        node_path_1.default.join(rulesRoot, `${ruleName}.md`),
+        node_path_1.default.join(rulesRoot, `${ruleName}.mdc`),
+    ];
+    for (const candidate of candidates) {
+        if (await fs_extra_1.default.pathExists(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+async function saveBuildRulesToBuildAgentEnv(input) {
+    if (!input.adapter.rulesDir) {
+        logger_1.logger.info(`agent ${input.adapter.name} 未声明 rulesDir，跳过 build-agent-env/rules 生成`);
+        return [];
+    }
+    const destRoot = node_path_1.default.join(input.targetRoot, 'build-agent-env', 'rules');
+    await fs_extra_1.default.ensureDir(destRoot);
+    const sourceRulesRoot = node_path_1.default.join(node_path_1.default.dirname(input.harnessRoot), input.adapter.rulesDir);
+    const ruleExt = input.adapter.ruleExt ?? '.md';
+    const written = [];
+    for (const templateName of BUILD_RULE_TEMPLATE_FILES) {
+        const ruleName = templateName.replace(/\.md$/i, '');
+        const dstRuleFile = node_path_1.default.join(destRoot, `${ruleName}${ruleExt}`);
+        if ((await fs_extra_1.default.pathExists(dstRuleFile)) && !input.force) {
+            logger_1.logger.warn(`build rule 已存在，跳过：${node_path_1.default.relative(input.targetRoot, dstRuleFile)}`);
+            continue;
+        }
+        let raw;
+        if (await fs_extra_1.default.pathExists(sourceRulesRoot)) {
+            const sourceRuleFile = await resolveRuleSourceFile(sourceRulesRoot, ruleName, ruleExt);
+            if (sourceRuleFile) {
+                raw = await fs_extra_1.default.readFile(sourceRuleFile, 'utf8');
+            }
+        }
+        if (!raw) {
+            const templatePath = node_path_1.default.join(input.templatesRoot, '_shared', 'build-rules', templateName);
+            if (!(await fs_extra_1.default.pathExists(templatePath))) {
+                logger_1.logger.warn(`build rule 模板缺失，跳过：${templateName}`);
+                continue;
+            }
+            raw = await fs_extra_1.default.readFile(templatePath, 'utf8');
+        }
+        const rewritten = rewriteHarnessReferences(raw, input.harnessDirName);
+        const content = input.adapter.ruleTransform
+            ? input.adapter.ruleTransform(rewritten, templateName)
+            : rewritten;
+        await fs_extra_1.default.outputFile(dstRuleFile, content, 'utf8');
+        written.push(node_path_1.default.relative(input.targetRoot, dstRuleFile));
+    }
+    return written;
+}
 /**
  * Entry point for `svharnessbuild apply`.
  *
  * Minimum-invasion binding: copies a single dispatcher skill
  * (`harness-apply-skills-main/SKILL.{md|mdc}`) into the target project's
- * agent-native skills directory. The skill carries the harness binding
- * metadata **inlined into its own body** (`## 绑定元数据` section), so any
- * agent can resolve `harness_root` purely from the skill's loaded content
- * without depending on CWD or "same-directory" heuristics (scheme B).
+ * agent-native skills directory as a thin entry. Runtime rules/skills are
+ * copied into adapter directories, and the project-root AI entry file
+ * (`AGENTS.md` / `CLAUDE.md`) is generated from `<harness>/AGENTS_APPLY.md`.
  *
- * `references/binding.yaml` is still written as a redundant copy for
- * `svharnessbuild`'s own tooling (status / detach / re-apply detection) —
- * it is NOT the runtime source of truth.
+ * Runtime behavior is path-rewrite based (`./<name>-harness/...`), not
+ * dispatcher-embedded binding metadata parsing.
  */
 async function runApply(opts) {
     (0, logger_1.setVerbose)(!!opts.verbose);
@@ -479,7 +603,8 @@ async function runApply(opts) {
     else {
         effectiveHarnessRoot = cloneDest;
     }
-    // 3. Resolve agent (explicit > state file).
+    // 3. Resolve agent (explicit > state file > codechat default).
+    const DEFAULT_AGENT = 'codechat';
     let agent = opts.agent;
     if (!agent) {
         agent = await readAgentFromState(harnessRoot);
@@ -488,16 +613,14 @@ async function runApply(opts) {
         }
     }
     if (!agent) {
-        throw new Error('无法推断目标 agent。请显式传入 --agent <' +
-            (0, validate_args_1.listSupportedAgents)().join('|') +
-            '>，或确认 harness 下存在 .harness-build-state.yaml。');
+        agent = DEFAULT_AGENT;
+        logger_1.logger.info(`未指定 agent，使用默认值：${agent}`);
     }
     const adapter = (0, adapters_1.getAdapter)(agent);
     // 4. Compute injection target.
     const skillsBaseDir = node_path_1.default.join(targetRoot, adapter.skillsDir);
     const dispatcherDir = node_path_1.default.join(skillsBaseDir, DISPATCHER_SKILL_NAME);
     const skillFile = node_path_1.default.join(dispatcherDir, 'SKILL' + adapter.skillExt);
-    const bindingFile = node_path_1.default.join(dispatcherDir, 'references', 'binding.yaml');
     // 5. Load dispatcher skill template.
     const templatePath = node_path_1.default.join(resolveTemplatesRoot(), '_shared', 'apply-skills', `${DISPATCHER_SKILL_NAME}.md`);
     if (!(await fs_extra_1.default.pathExists(templatePath))) {
@@ -513,6 +636,10 @@ async function runApply(opts) {
     const harnessRootRel = node_path_1.default.relative(targetRoot, effectiveHarnessRoot).replace(/\\/g, '/') || '.';
     const cliVersion = (0, version_1.getCliVersion)();
     const appliedAt = new Date().toISOString();
+    const includeBuildAssets = !!opts.includeBuildAssets;
+    const requestedBuildBridge = !!opts.injectBuildMainBridge;
+    const injectBuildMainBridge = includeBuildAssets && requestedBuildBridge;
+    const consistencyMode = opts.consistency === 'strict' ? 'strict' : 'basic';
     // 6. Confirm (unless --yes).
     const configRows = [
         { label: 'harness 源路径', value: harnessRoot },
@@ -525,7 +652,7 @@ async function runApply(opts) {
     if (cloneMode && effectiveHarnessRoot !== harnessRoot) {
         configRows.push({ label: '克隆目标', value: effectiveHarnessRoot });
     }
-    configRows.push({ label: '注入 skill', value: node_path_1.default.relative(targetRoot, skillFile) }, { label: '运行期 skills 注入', value: adapter.skillsDir }, { label: '运行期 rules 注入', value: adapter.rulesDir ?? '（agent 未声明 rulesDir）' }, { label: '.gitignore', value: '将追加注入路径（幂等）' }, { label: '项目根 AI 入口', value: `${adapter.projectEntryFile}（由 AGENTS_APPLY.md 重命名）` }, { label: '工具版本', value: `svharness@${cliVersion}` });
+    configRows.push({ label: '注入 skill', value: node_path_1.default.relative(targetRoot, skillFile) }, { label: '运行期 skills 注入', value: adapter.skillsDir }, { label: '运行期 rules 注入', value: adapter.rulesDir ?? '（agent 未声明 rulesDir）' }, { label: '构建期 assets 拷贝', value: includeBuildAssets ? '开启（build-agent-env）' : '关闭' }, { label: 'build-main 桥接', value: injectBuildMainBridge ? '开启' : '关闭' }, { label: '一致性检查级别', value: consistencyMode }, { label: '.gitignore', value: '将追加注入路径（幂等）' }, { label: '项目根 AI 入口', value: `${adapter.projectEntryFile}（由 AGENTS_APPLY.md 重命名）` }, { label: '工具版本', value: `svharness@${cliVersion}` });
     logger_1.logger.configBox('apply 配置确认', configRows);
     if (!opts.yes) {
         const { ok } = await (0, prompts_1.default)({
@@ -539,6 +666,12 @@ async function runApply(opts) {
             return;
         }
     }
+    if (consistencyMode === 'strict') {
+        logger_1.logger.warn('strict 一致性检查尚在规划中，当前先执行 basic 检查。');
+    }
+    if (requestedBuildBridge && !includeBuildAssets) {
+        logger_1.logger.warn('`--inject-build-main-bridge` 依赖 `--include-build-assets`；当前跳过 bridge 注入。');
+    }
     // 7. Guard against overwrite.
     if (await fs_extra_1.default.pathExists(dispatcherDir)) {
         if (!opts.force) {
@@ -549,8 +682,11 @@ async function runApply(opts) {
     }
     // 7b. Clone step — copy the whole harness into the target project first,
     //     so subsequent injections resolve to the local copy.
-    const totalSteps = 5;
+    const totalSteps = includeBuildAssets ? 6 : 5;
     let stepNo = 1;
+    let buildSkills = [];
+    let buildRules = [];
+    let bridgeSkillPath;
     if (cloneMode && effectiveHarnessRoot !== harnessRoot) {
         logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 拷贝 harness 到目标项目`);
         if (await fs_extra_1.default.pathExists(cloneDest)) {
@@ -594,12 +730,53 @@ async function runApply(opts) {
     logger_1.logger.success(`已注入运行期 rules ${runtimeRules.length} 条`);
     logger_1.logger.success(`已注入运行期 skills ${runtimeSkills.length} 条`);
     stepNo++;
+    if (includeBuildAssets) {
+        logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 拷贝构建期 skills/rules`);
+        buildSkills = await saveBuildSkillsToBuildAgentEnv({
+            harnessRoot: effectiveHarnessRoot,
+            targetRoot,
+            adapter,
+            harnessRootRel,
+            harnessName,
+            harnessVersion,
+            harnessArch,
+            agent,
+            force: !!opts.force,
+            cliVersion,
+            generatedAt: appliedAt,
+            templatesRoot,
+        });
+        buildRules = await saveBuildRulesToBuildAgentEnv({
+            harnessRoot: effectiveHarnessRoot,
+            targetRoot,
+            adapter,
+            harnessDirName,
+            force: !!opts.force,
+            templatesRoot,
+        });
+        logger_1.logger.success(`已注入构建期 skills ${buildSkills.length} 条`);
+        logger_1.logger.success(`已注入构建期 rules ${buildRules.length} 条`);
+        if (injectBuildMainBridge) {
+            logger_1.logger.info(`build-main bridge 已启用，目标目录：${adapter.skillsDir}/${BUILD_MAIN_BRIDGE_SKILL_NAME}`);
+            bridgeSkillPath = await injectBuildMainBridgeSkill({
+                templatesRoot,
+                targetRoot,
+                adapter,
+                harnessDirName,
+                force: !!opts.force,
+            });
+            logger_1.logger.success(`已写入 build-main bridge：${node_path_1.default.relative(targetRoot, bridgeSkillPath)}`);
+        }
+        stepNo++;
+    }
     logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 写入项目根 AI 入口`);
     await (0, apply_project_entry_1.writeApplyProjectEntry)({
         projectRoot: targetRoot,
         harnessRoot: effectiveHarnessRoot,
         harnessDirName,
         adapter,
+        includeBuildBridge: injectBuildMainBridge,
+        buildBridgeSkillName: BUILD_MAIN_BRIDGE_SKILL_NAME,
         force: !!opts.force,
     });
     const entryFile = node_path_1.default.join(targetRoot, adapter.projectEntryFile);
@@ -614,25 +791,84 @@ async function runApply(opts) {
         logger_1.logger.info('.gitignore 无新增条目（已是最新）');
     }
     else {
-        logger_1.logger.success(`.gitignore 已新增 ${ignoreAdded.length} 条注入路径`);
+        logger_1.logger.success(`.gitignore 已 append ${ignoreAdded.length} 条注入路径`);
     }
     stepNo++;
     logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 校验注入文件引用关系`);
+    const runtimeRuleFiles = runtimeRules.map((rel) => node_path_1.default.join(targetRoot, rel));
+    const runtimeSkillFiles = runtimeSkills.map((rel) => node_path_1.default.join(targetRoot, rel));
+    const buildRuleFiles = buildRules.map((rel) => node_path_1.default.join(targetRoot, rel));
+    const buildSkillFiles = buildSkills.map((rel) => node_path_1.default.join(targetRoot, rel));
     const filesToCheck = [
         entryFile,
         thinMainPath,
-        ...runtimeRules.map((rel) => node_path_1.default.join(targetRoot, rel)),
-        ...runtimeSkills.map((rel) => node_path_1.default.join(targetRoot, rel)),
+        ...(bridgeSkillPath ? [bridgeSkillPath] : []),
+        ...runtimeRuleFiles,
+        ...runtimeSkillFiles,
+        ...buildRuleFiles,
+        ...buildSkillFiles,
+    ];
+    const consistencyErrors = [];
+    const consistencyWarnings = [];
+    const requiredDirs = [
+        node_path_1.default.join(targetRoot, adapter.skillsDir),
+        ...(adapter.rulesDir ? [node_path_1.default.join(targetRoot, adapter.rulesDir)] : []),
+        ...(includeBuildAssets
+            ? [node_path_1.default.join(targetRoot, 'build-agent-env', 'skills'), node_path_1.default.join(targetRoot, 'build-agent-env', 'rules')]
+            : []),
     ];
+    for (const dir of requiredDirs) {
+        if (!(await fs_extra_1.default.pathExists(dir))) {
+            consistencyErrors.push(`目录缺失：${node_path_1.default.relative(targetRoot, dir)}`);
+        }
+    }
+    for (const file of filesToCheck) {
+        if (!(await fs_extra_1.default.pathExists(file))) {
+            consistencyErrors.push(`文件缺失：${node_path_1.default.relative(targetRoot, file)}`);
+        }
+    }
+    const skillFrontmatterChecks = [...runtimeSkillFiles, ...buildSkillFiles];
+    if (bridgeSkillPath)
+        skillFrontmatterChecks.push(bridgeSkillPath);
+    for (const file of skillFrontmatterChecks) {
+        consistencyWarnings.push(...(await (0, skill_md_validate_1.validateFrontmatterFields)({
+            targetRoot,
+            file,
+            requiredKeys: ['name', 'description'],
+        })));
+        consistencyWarnings.push(...(await (0, skill_md_validate_1.validateSkillNameMatchesDir)({
+            targetRoot,
+            file,
+        })));
+    }
+    const ruleFrontmatterChecks = [...runtimeRuleFiles, ...buildRuleFiles];
+    for (const file of ruleFrontmatterChecks) {
+        consistencyWarnings.push(...(await (0, skill_md_validate_1.validateFrontmatterFields)({
+            targetRoot,
+            file,
+            requiredKeys: ['description'],
+        })));
+    }
     const refFailures = await validateInjectedReferences({
         targetRoot,
         harnessDirName,
         files: filesToCheck,
     });
+    consistencyWarnings.push(...refFailures.map((line) => `引用缺失：${line}`));
+    const okCount = filesToCheck.length + requiredDirs.length - consistencyErrors.length;
+    logger_1.logger.info(`一致性检查（basic）结果：通过 ${Math.max(okCount, 0)} 项，警告 ${consistencyWarnings.length} 项，错误 ${consistencyErrors.length} 项`);
+    if (consistencyErrors.length > 0) {
+        const preview = consistencyErrors.slice(0, 20).join('\n');
+        logger_1.logger.warn(`一致性检查发现 ${consistencyErrors.length} 条错误（请先修复）：\n${preview}\n` +
+            (consistencyErrors.length > 20 ? '...（其余省略）' : ''));
+    }
+    if (consistencyWarnings.length > 0) {
+        const preview = consistencyWarnings.slice(0, 20).join('\n');
+        logger_1.logger.warn(`一致性检查发现 ${consistencyWarnings.length} 条警告：\n${preview}\n` +
+            (consistencyWarnings.length > 20 ? '...（其余省略）' : ''));
+    }
     if (refFailures.length > 0) {
-        const preview = refFailures.slice(0, 20).join('\n');
-        logger_1.logger.warn(`引用校验发现 ${refFailures.length} 条潜在问题（请人工复核）：\n${preview}\n` +
-            (refFailures.length > 20 ? '...（其余省略）' : ''));
+        logger_1.logger.warn(`引用校验发现 ${refFailures.length} 条潜在问题（已并入一致性警告）`);
     }
     else {
         logger_1.logger.success('引用关系校验通过');
@@ -642,8 +878,14 @@ async function runApply(opts) {
     logger_1.logger.plain('✨ harness 已绑定到当前项目');
     logger_1.logger.plain('');
     logger_1.logger.plain('  下一步：在 agent 中输入');
-    logger_1.logger.plain(`    应用 ${DISPATCHER_SKILL_NAME} 完成 <你的功能> 功能开发`);
-    logger_1.logger.plain(`  或阅读 ${adapter.projectEntryFile} 了解完整的 harness 应用工作流`);
+    logger_1.logger.plain(`    应用 ${DISPATCHER_SKILL_NAME} 完成 <你的功能> 功能开发（薄入口）`);
+    logger_1.logger.plain(`  或阅读 ${adapter.projectEntryFile}（项目根入口）了解完整的 harness 应用工作流`);
+    if (includeBuildAssets) {
+        logger_1.logger.plain('  构建期二次改造入口：build-agent-env/skills + build-agent-env/rules');
+        if (injectBuildMainBridge) {
+            logger_1.logger.plain(`  可选桥接入口：${adapter.skillsDir}/${BUILD_MAIN_BRIDGE_SKILL_NAME}/SKILL${adapter.skillExt}`);
+        }
+    }
     logger_1.logger.plain('');
     if (effectiveHarnessRoot !== harnessRoot) {
         logger_1.logger.plain(`  harness 内容已拷贝至：${node_path_1.default.relative(targetRoot, effectiveHarnessRoot)}/（已纳入目标项目）`);

package/dist/commands/doctor/check-bootstrap.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkBootstrap = checkBootstrap;
+const utils_1 = require("./utils");
+async function checkBootstrap(ctx) {
+    const id = 'bootstrap';
+    const findings = [];
+    if (ctx.mode !== 'pre-seal') {
+        return { id, title: 'Bootstrap 模式', findings };
+    }
+    const harness = await (0, utils_1.readHarnessYaml)(ctx.harnessRoot);
+    if (!harness) {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: '缺少或无法解析 harness.yaml',
+            path: 'harness.yaml',
+        });
+        return { id, title: 'Bootstrap 模式', findings };
+    }
+    const specs = harness.specs;
+    const bootstrapMode = specs?.bootstrap_mode;
+    if (bootstrapMode !== true) {
+        findings.push({
+            checkId: id,
+            severity: 'error',
+            message: `封存前 specs.bootstrap_mode 应为 true（当前：${String(bootstrapMode)}）`,
+            path: 'harness.yaml',
+        });
+    }
+    return { id, title: 'Bootstrap 模式', findings };
+}