plan-governance-cli 1.1.0 → 1.1.2

package/README.md

@@ -111,7 +111,6 @@ plan-governance-cli init \
 .git/
 docs/PLAN_MAP.md
 docs/plans/api-compat-migration.md
-CLAUDE.md
 AGENTS.md
 ```
 
@@ -119,12 +118,11 @@ AGENTS.md
 
 如果目标目录还不是 Git 仓库，初始化流程会先执行 `git init`；已有 `.git/` 时会跳过，不重复初始化。
 
-`--update-agent-rules` 会创建或更新 `CLAUDE.md` 和 `AGENTS.md` 中带标记的计划治理章节，只写稳定执行规则，不写具体计划内容。具体计划仍以 `docs/PLAN_MAP.md` 和 `docs/plans/*.md` 为准。
+`--update-agent-rules` 会创建或更新 `AGENTS.md` 中带标记的计划治理章节，只写稳定执行规则，不写具体计划内容。具体计划仍以 `docs/PLAN_MAP.md` 和 `docs/plans/*.md` 为准。
 
-如果只需要更新单个入口，也可以使用：
+也可以使用含义更直接的别名：
 
 ```bash
---update-claude-md
 --update-agents-md
 ```
 
@@ -144,7 +142,7 @@ plan-governance-cli init \
   --update-agent-rules-only
 ```
 
-如果只更新单个入口，可以使用 `--update-claude-md-only` 或 `--update-agents-md-only`。
+`--update-agents-md-only` 与上述兼容别名作用相同，也只更新 `AGENTS.md`。
 
 如果要升级已有项目的辅助文件，刷新检查脚本并更新代理规则，但不覆盖 `docs/`，运行：
 
@@ -157,7 +155,7 @@ plan-governance-cli init \
 `--upgrade-existing` 会：
 
 - 按兼容模式覆盖更新项目中的 `scripts/check_plan_governance.py`
-- 创建或更新 `CLAUDE.md` 和 `AGENTS.md` 中带标记的计划治理章节
+- 创建或更新 `AGENTS.md` 中带标记的计划治理章节，既有其他代理入口保持原样
 - 保留已有 `docs/PLAN_MAP.md` 和 `docs/plans/*.md`
 - 提示缺失的治理文档
 
@@ -205,17 +203,24 @@ plan-governance-cli graph code impact --repo modelpad --file Sources/ModelPadCor
 
 ## 持续推进
 
-在已授权的跨轮任务中可使用 `goal`；skill 本身不定义整计划自主执行运行时。普通改动自验，高风险或高影响同范围只独立复核一次，修复后自验；旧计划显式采用新策略，保留历史。
+在已授权的跨轮任务中可使用 `goal`；skill 本身不定义整计划自主执行运行时。普通改动自验，高风险或高影响同范围只独立复核一次，修复后自验；旧策略名和旧记录格式采用相同行为并保留历史，无需逐计划迁移。
 
-[验证规范](resources/skill/references/verification.md)统一维护风险分流、证据复用、修复自验与用户验收；其他会话从同一 skill 读取。需要独立复核且授权明确时自动安排只读 subagent，不为普通小改逐次派发；技术完成待用户验收的适用功能计划仍保持实施中。
+[验证规范](resources/skill/references/verification.md)统一维护单次复核、任务复用、证据复用、修复自验与用户验收；其他会话从同一 skill 读取。需要独立复核且授权明确时自动安排只读 subagent，复用已有同范围任务/结果，等待异常先核准任务 ID 和状态，且复核者不得再委派复核；不为普通小改逐次派发。技术完成待用户验收的适用功能计划仍保持实施中。
 
-1.0.1 起支持可选的最近记录窗口：
+恢复已有计划时可读取派生工作集：
+
+```bash
+plan-governance-cli workset . --json
+plan-governance-cli workset . --json --strict-readiness
+```
+
+工作集返回活跃计划、阶段、阻塞、下一动作、并行提示和最近证据，不写计划或自动执行动作；严格模式让活跃计划的机械准入缺陷返回非零。需要缩小恢复上下文时使用最近记录窗口：
 
 ```bash
 plan-governance-cli workset . --json --evidence-limit 3
 ```
 
-每个计划保留末尾三条记录，并给出省略数量和原文位置；默认完整输出和门禁判断保持。窗口用于恢复阅读，必要时去掉参数回查完整记录，详见 [CLI 参考](resources/skill/references/cli.md#当前工作集)。已发布的 1.0.0 尚不支持此参数。
+每个计划保留末尾三条记录，并给出省略数量和原文位置；默认完整输出和门禁判断保持。窗口用于恢复阅读，必要时去掉参数回查完整记录，详见 [CLI 参考](resources/skill/references/cli.md#当前工作集)。
 
 ## 按需读取规则
 
@@ -230,10 +235,10 @@ plan-governance-cli guide cli             # CLI 操作
 
 SKILL 保留任务边界、自主执行原则和按需入口，三份 references 按需读取并随 manifest/setup/npm 分发。已有项目只刷新受管入口，不迁移旧计划、不改用户块外内容。选择同一版本的规范来源，安装副本与仓库同版本号也可能有不同内容。
 
-也可以不全局安装，直接使用锁定版本：
+也可以不全局安装，直接使用当前公开版本：
 
 ```bash
-npx --yes --package plan-governance-cli@1.0.1 plan-governance-cli check . --strict-readiness
+npx --yes --package plan-governance-cli@latest plan-governance-cli check . --strict-readiness
 ```
 
 npm 包内部仍使用版本化的 Python 检查器，但用户不需要直接调用或复制该脚本。旧项目已有本地脚本时仍可保留作为兼容或回滚路径。
@@ -252,11 +257,10 @@ npm 包内部仍使用版本化的 Python 检查器，但用户不需要直接
 
 ```bash
 plan-governance-cli setup --target codex --dry-run
-plan-governance-cli setup --target claude --dry-run
-plan-governance-cli setup --target all
+plan-governance-cli setup --target codex --force
 ```
 
-`setup` 只同步 npm 包 manifest 指定的 skill、代理元数据和模板文件；默认先用 `--dry-run` 查看差异，目标文件有本地修改时不会静默覆盖。检查器、初始化器和 hook runtime 由 npm 包内部调用，不复制到项目或 skill 目录。当前版本不自动安装 hook 配置。
+`setup` 只向 Codex 同步 npm 包 manifest 指定的 skill、代理元数据和模板文件，必须恰好指定一次 `--target codex`。旧版或重复 target、混合 help、缺失 target 都会在写入前失败；目标之外的用户目录不会被读取、修改或删除。默认先用 `--dry-run` 查看差异，目标文件有本地修改时不会静默覆盖。检查器、初始化器和 hook runtime 由 npm 包内部调用，不复制到项目或 skill 目录；项目初始化器只维护 `AGENTS.md`，当前实现不自动安装 hook 配置。
 
 初始化项目时使用包内初始化器：
 
@@ -268,7 +272,7 @@ plan-governance-cli init --root . --plan api-compat-migration --title "API 兼
 
 ## Hook runtime
 
-本仓库提供只读 hook runtime，供 Codex、Claude Code 或其他 Agent 的项目级 hooks 手动接入。脚本只输出短提示和检查结果，不修改治理文档，不更新 `最后更新`，不安装或修改全局配置。
+本仓库提供只读 hook runtime，供 Codex 项目级 hooks 手动接入。脚本只输出短提示和检查结果，不修改治理文档，不更新 `最后更新`，不安装或修改全局配置。
 
 ```bash
 plan-governance-cli hook --event session-start
@@ -366,7 +370,7 @@ python3 -m pytest
 | `设计中` | 正在明确范围、契约和门禁 |
 | `待实施` | 当前阶段门禁已通过，但尚未开始 |
 | `实施中` | 当前阶段正在修改代码或文档 |
-| `已完成` | 实现、测试、证据和文档已同步 |
+| `已完成` | 实现、测试、证据、文档及适用用户验收均已完成 |
 | `已替代` | 被另一个计划取代 |
 | `已合并` | 并入另一个计划 |
 | `已废弃` | 明确不再推进 |
@@ -375,7 +379,9 @@ python3 -m pytest
 
 状态与当前阶段由 `docs/PLAN_MAP.md` 维护。每阶段必须具备自身 Step 0、验证/完成和失败边界、无有效阻塞及适用复核，不能凭上一阶段完成自动待实施。
 
-旧计划缺省沿用独立准入；新模板使用单次独立复核策略，普通改动自验，高风险或高影响独立检查一次后由实施者修复自验，原发现保留。固定字段、历史保护和严格检查语义以[阶段门规范](resources/skill/references/verification.md#step-0-与阶段门)为准。
+新旧计划统一采用单次复核行为：普通改动自验，高风险或高影响独立检查一次后由实施者修复自验，原发现保留。旧 `风险分流` 标签和缺省六列格式只作为兼容记录形式，不恢复多次独立门禁；固定字段、历史保护和严格检查语义以[阶段门规范](resources/skill/references/verification.md#step-0-与阶段门)为准。
+
+派发独立复核时显式传入推理强度，不依赖全局 subagent 默认值：安全、权限、隐私、资金、数据完整性等高风险复核使用 `high`，其他独立复核使用 `medium`。该分层只影响本次复核的思考强度，不改变是否复核或单次复核规则。
 
 使用 `check --strict-readiness` 做准入/CI/发布机械检查；默认检查兼容告警，机械通过不代替真实风险判断、业务验收或用户接受。
 

package/bin/plan-governance-cli.mjs

@@ -79,11 +79,23 @@ function loadManifest() {
 }
 
 function parseSetupArgs(args) {
+  if (args.length === 1 && ["-h", "--help"].includes(args[0])) {
+    console.log("用法：plan-governance-cli setup --target codex [--destination DIR] [--dry-run] [--force]");
+    return null;
+  }
+
   const options = { target: null, destination: null, dryRun: false, force: false };
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     if (arg === "--target") {
-      options.target = args[++index];
+      if (options.target !== null) {
+        throw new Error("setup 的 --target 只能指定一次");
+      }
+      const value = args[++index];
+      if (!value || value.startsWith("-")) {
+        throw new Error("setup 的 --target 缺少值");
+      }
+      options.target = value;
     } else if (arg === "--destination") {
       options.destination = args[++index];
     } else if (arg === "--dry-run") {
@@ -91,18 +103,14 @@ function parseSetupArgs(args) {
     } else if (arg === "--force") {
       options.force = true;
     } else if (arg === "-h" || arg === "--help") {
-      console.log("用法：plan-governance-cli setup --target codex|claude|all [--destination DIR] [--dry-run] [--force]");
-      return null;
+      throw new Error("setup 的 --help 必须单独使用");
     } else {
       throw new Error(`setup 不支持参数：${arg}`);
     }
   }
 
-  if (!options.target || !["codex", "claude", "all"].includes(options.target)) {
-    throw new Error("setup 必须指定 --target codex、claude 或 all");
-  }
-  if (options.destination && options.target === "all") {
-    throw new Error("--destination 只能与单个 setup target 一起使用");
+  if (options.target !== "codex") {
+    throw new Error("setup 仅支持 --target codex");
   }
   return options;
 }
@@ -112,12 +120,11 @@ function expandTarget(target) {
   return target.replace(/^~(?=\/|$)/, home);
 }
 
-function targetRoots(manifest, options) {
-  const names = options.target === "all" ? ["codex", "claude"] : [options.target];
-  return names.map((name) => ({
-    name,
-    root: resolve(options.destination ? options.destination : expandTarget(manifest.skill.targets[name])),
-  }));
+function targetRoot(manifest, options) {
+  return {
+    name: "codex",
+    root: resolve(options.destination ? options.destination : expandTarget(manifest.skill.targets.codex)),
+  };
 }
 
 function resourceFiles(manifest) {
@@ -148,17 +155,16 @@ function setup(args) {
 
   const plans = [];
   try {
-    for (const target of targetRoots(manifest, options)) {
-      for (const file of files) {
-        accessSync(file.source, constants.R_OK);
-        const destination = resolve(target.root, file.relative);
-        const existing = existsSync(destination) ? readFileSync(destination, "utf8") : null;
-        const sourceContent = readFileSync(file.source, "utf8");
-        if (existing !== null && existing !== sourceContent && !options.force) {
-          throw new Error(`目标文件存在本地差异，未覆盖：${destination}（如确认覆盖请加 --force）`);
-        }
-        plans.push({ target: target.name, destination, existing, sourceContent });
+    const target = targetRoot(manifest, options);
+    for (const file of files) {
+      accessSync(file.source, constants.R_OK);
+      const destination = resolve(target.root, file.relative);
+      const existing = existsSync(destination) ? readFileSync(destination, "utf8") : null;
+      const sourceContent = readFileSync(file.source, "utf8");
+      if (existing !== null && existing !== sourceContent && !options.force) {
+        throw new Error(`目标文件存在本地差异，未覆盖：${destination}（如确认覆盖请加 --force）`);
       }
+      plans.push({ target: target.name, destination, existing, sourceContent });
     }
   } catch (error) {
     return fail(error.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plan-governance-cli",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "统一入口的计划治理检查 CLI",
   "private": false,
   "type": "module",

package/resources/manifest.json

@@ -2,8 +2,7 @@
   "manifestVersion": 1,
   "skill": {
     "targets": {
-      "codex": "~/.agents/skills/plan-governance",
-      "claude": "~/.claude/skills/plan-governance"
+      "codex": "~/.agents/skills/plan-governance"
     },
     "files": [
       "resources/skill/SKILL.md",

package/resources/skill/SKILL.md

@@ -13,7 +13,7 @@ description: 维护已有项目计划，或为需要跨阶段、跨会话协调
 
 首次接手读取地图、当前相关计划及必要契约；恢复只核对当前阶段、实际差异和最近证据。只实施已授权且准入的范围；实质边界变化时调整受影响计划，日常进展随工作同步。事实源与格式见 planning。
 
-先确定当前计划的有效复核策略，再按 verification 验证；单次策略下，高风险或高影响同范围独立检查一次，修复由实施者自验。适用检查通过后完成交付；未解决问题如实保留。交付说明完成结果、必要证据和剩余事项，明确约定的用户体验验收继续有效。
+按 verification 验证：普通改动自验，高风险或高影响的同一交付范围独立检查一次，修复由实施者自验；派发独立复核时显式传入推理强度，高风险用 `high`，其余用 `medium`。旧策略名和旧记录格式不改变此行为。适用检查通过后完成交付；未解决问题如实保留。交付说明完成结果、必要证据和剩余事项，明确约定的用户体验验收继续有效。
 
 ## 按需读取
 

package/resources/skill/references/cli.md

@@ -18,9 +18,9 @@
 
 ## 分发与资源
 
-SKILL、三个 references、agents 元数据与 assets 由同一 npm 包的 manifest 分发。`plan-governance-cli setup --target codex|claude|all --dry-run` 查看同步差异；实际覆盖需既有用户授权并按 setup 冲突提示处理，不自动清理用户目录残留。项目升级不迁移旧计划，受管块外内容必须保持。
+SKILL、三个 references、agents 元数据与 assets 由同一 npm 包的 manifest 分发。`plan-governance-cli setup --target codex --dry-run` 查看 Codex 同步差异；实际覆盖需既有用户授权并按 setup 冲突提示处理，不自动清理目标之外的用户目录。setup 只支持 Codex 单目标同步；项目初始化器只维护 `AGENTS.md`。项目升级不迁移旧计划，受管块外内容必须保持。
 
-仅更新计划格式不等于更新项目入口；更新 AGENTS/CLAUDE 入口也不等于当前阶段已采用新复核策略。已有项目在任务交接、没有进行中的实施或复核时更新受管入口；阶段策略单独按 verification 兼容规则处理，不批量回写历史。安装副本与仓库开发规则有差异时说明本次选用来源，不能因版本号相同就混读正文。
+仅更新计划格式不等于更新项目入口。已有项目在任务交接、没有进行中的实施或复核时更新受管入口；升级不批量回写历史，旧策略名和六列格式按 verification 解释为统一单次行为。安装副本与仓库开发规则有差异时说明本次选用来源，不能因版本号相同就混读正文。
 
 ## 初始化、模板和检查脚本
 
@@ -54,7 +54,7 @@ plan-governance-cli init \
   --update-agent-rules-only
 ```
 
-升级已有项目的辅助文件，刷新 `scripts/check_plan_governance.py`、`CLAUDE.md` 和 `AGENTS.md`，但不覆盖 `docs/`：
+升级已有项目的辅助文件，刷新 `scripts/check_plan_governance.py` 和 `AGENTS.md`，但不覆盖 `docs/` 或其他代理入口：
 
 ```bash
 plan-governance-cli init \

package/resources/skill/references/planning.md

@@ -34,7 +34,7 @@
 
 ## 执行与恢复
 
-沿用当前有效策略和已确认决定，只展开本次差异、证据缺口及直接依赖。跨阶段工作按 [阶段门](verification.md#step-0-与阶段门)判断，每阶段有自身基线与完成条件；上一阶段通过不自动放行下一阶段。未来事项需注明承接范围与依赖，不以未准入的后续工作阻断无关的当前交付。
+沿用已确认决定，只展开本次差异、证据缺口及直接依赖。跨阶段工作按 [阶段门](verification.md#step-0-与阶段门)判断，每阶段有自身基线与完成条件；上一阶段通过不自动放行下一阶段，但同一交付范围的独立检查可按 verification 显式复用而不重审。未来事项需注明承接范围与依赖，不以未准入的后续工作阻断无关的当前交付。
 
 文档变更后做适用链接、结构和引用检查，运行所选版本的 `plan-governance-cli check .`；准入/发布使用 `--strict-readiness`。纯落档不重复代码测试。用户验收与证据真实性按 verification，不以文档格式通过替代。
 

package/resources/skill/references/verification.md

@@ -1,28 +1,28 @@
 # 验证、复核与用户验收
 
-本页维护有效策略、阶段门和交付证据；CLI 入口为 `guide verification`。执行方法按当前策略决定，写入记录时再读格式部分。
+本页维护统一复核行为、阶段门和交付证据；CLI 入口为 `guide verification`。写入记录时再读格式部分。
 
 ## 记录与兼容
 
-先读取当前阶段摘要的 `复核策略`，后续复用，不由新会话或新版 skill 自动改变：
+新旧计划采用同一复核行为；字段只决定记录格式，不决定是否重审或如何恢复：
 
-| 策略 | 行为 |
+| 记录形式 | 解释 |
 |---|---|
-| 单次独立复核 | 新模板默认；普通改动自验，高风险或高影响同范围独立检查一次，修复自验 |
-| 风险分流 | 旧策略；低风险自验，高影响独立，独立失败须独立通过恢复 |
-| 无字段 | 保留旧独立门禁及六列记录，见旧计划兼容 |
+| 单次独立复核 | 当前模板标签 |
+| 风险分流 | 历史标签，按同一单次行为解释，不触发迁移或重审 |
+| 无字段 | 保留六列历史格式，后续自验类型见旧计划兼容 |
 
-空值、未知值和重复声明不能放行。有迁移授权时可显式采用单次策略并保留历史，不为切换先重审，迁移也不解决实际问题。迁移旧格式时替换摘要引用，将适用原检查按真实日期、结论、证据和身份转写成八列基线，说明范围/风险，再追加实际修复自验。旧记录冲突、缺字段或比修复更新的失败保留；不批量改其他项目。CLI 能力不符时说明缺口，更新按授权处理。
+显式字段的空值、未知值和重复声明不能放行。升级不批量改写计划；原检查按真实日期、结论、证据和身份保留，旧失败须由真实修复自验闭环，格式统一本身不解决问题。CLI 能力不符时说明缺口，更新按授权处理。
 
 ## 按风险复核
 
-以下执行方式适用于单次策略；普通无计划任务也按实际风险选择检查，不建立阶段表。
+以下方式适用于所有计划；普通无计划任务也按实际风险选择检查，不建立阶段表。
 
 普通改动由实施者自验。改变权限、安全、隐私、资金、数据完整性、核心契约或产生广泛/难以撤销后果时，按实际高风险或高影响安排独立检查；不按目录、行数或阶段事件触发。风险不清先查事实。
 
-同一交付范围只检查一次，通常在实现和自验收敛后、交付或高影响外部动作前；需要设计准入时将这一次前置，后续实施与完成自验。已审范围内的增量和修复合并处理，确有新增高风险范围才另行判断，不把每个修复拆成新范围。
+同一交付范围只检查一次，通常在实现和自验收敛后、交付或高影响外部动作前；需要设计准入时将这一次前置，后续实施与完成自验。已审范围内的增量和修复合并处理，确有新增高风险范围才另行判断，不把每个修复拆成新范围；后续独立通过不能清除这一次检查留下的发现。
 
-授权明确时自动安排一名未参与实现或测试编写的只读复核者，提供范围、差异、风险和证据入口。冻结受审范围并告知变化。独立者给出发现后，实施者修复并验证原问题及受影响回归，不再送审，未解决则保持未完成。检查不可用/超时直接记录状态，不能伪填已完成结论；业务缺陷描述中的“超时”不代表检查未完成。复核不代替外部授权。
+授权明确时自动安排一名未参与实现或测试编写的只读复核者，提供范围、差异、风险和证据入口，并要求其自行完成、不得再委派复核。创建复核 subagent 时必须显式传入推理强度，不依赖全局默认：涉及安全、权限、隐私、资金、数据完整性或同类高风险后果时用 `high`，其他独立复核用 `medium`；推理强度不改变是否复核、复核次数或完成判定。派发前复用已有同范围任务或结果；等待失败先核对准确任务 ID 与实际状态，只有确认原任务不存在或不可恢复才补发。冻结受审范围并告知变化。独立者给出发现后，实施者修复并验证原问题及受影响回归，不再送审，未解决则保持未完成。检查不可用/超时直接记录状态，不能伪填已完成结论；业务缺陷描述中的“超时”不代表检查未完成。复核不代替外部授权。
 
 ## Step 0 与阶段门
 
@@ -34,9 +34,9 @@ Step 0 可采用缺陷复现、迁移快照/兼容样本、新功能验收 fixtu
 
 验证用户可观察结果和受影响回归，完成项目要求的检查。纯文档做适用文档检查并注明覆盖率不适用。检查通过后，只有新变化、失败或未解疑点才扩大或重复验证。
 
-复用证据须覆盖当前工作树、依赖/配置、环境和验收契约，内容可访问；仅 HEAD/版本相同不足以证明有效。缺口补受影响验证，未解决冲突如实保留。只有状态、证据或链接同步时，不重新跑代码全套；无关任务失败如实报告，不擅自接管。
+复用证据须覆盖当前工作树、依赖/配置、环境和验收契约，内容可访问；仅 HEAD/版本相同不足以证明有效。同一交付范围的前置独立检查可跨阶段复用，但须在当前阶段以 `复核基线复用` 明确关联原记录、来源阶段和范围；未来阶段或未解决基线不可复用，新增范围重新判断风险。缺口补受影响验证，未解决冲突如实保留。只有状态、证据或链接同步时，不重新跑代码全套；无关任务失败如实报告，不擅自接管。
 
-自验失败自主修复/复验。单次策略下保留独立发现，按“发现 → 修复 → 验证”闭环并准确标记自验；旧策略的恢复要求见策略表。机械检查只证明结构，不能证明风险、范围、独立性或证据真实性。可选 attestation 的显式检查见 [CLI](cli.md#初始化模板和检查脚本)。
+自验失败自主修复/复验。保留独立发现，按“发现 → 修复 → 验证”闭环并准确标记自验。机械检查只证明结构，不能证明风险、范围、独立性或证据真实性。可选 attestation 的显式检查见 [CLI](cli.md#初始化模板和检查脚本)。
 
 ## 用户可观察验收与交付
 
@@ -48,24 +48,24 @@ Step 0 可采用缺陷复现、迁移快照/兼容样本、新功能验收 fixtu
 
 ## 格式附录：写入阶段记录时读取
 
-### 新计划风险策略
+### 显式策略格式
 
 显式策略在摘要以 `最新阶段复核` 引用替代旧 `最新独立准入复核`，其余阶段字段保留。最新表采用两列字段/内容：
 
 | 字段 | 要求 |
 |---|---|
 | 日期 / 阶段 | YYYY-MM-DD / 与地图当前阶段一致 |
-| 方式 / 风险 | 自验或独立；低风险、高影响或待判断，单次策略另支持高风险 |
+| 方式 / 风险 | 自验或独立；低风险、高影响、高风险或待判断 |
 | 风险依据 | 当前实际范围、后果与验证依据 |
 | 结论 | 尚未进行或明确结果；待判断风险不能通过，候选、疑问或占位不算通过 |
 | 证据 / 复核者 | 可复验记录或链接 / 真实执行者身份 |
 
 `阶段复核记录` 按 `日期、类型、阶段、方式、风险、结论、证据、复核者` 八列追加，日期顺序和最新表与当前阶段末条一致。完整结果须有有效日期、证据、身份及已判断风险；普通无计划任务无需建表。
 
-单次策略的高风险/高影响自验须有本阶段同范围完整独立基线。独立发现修复后用类型 `修复自验`、方式 `自验` 追加，证据说明原发现与修复回归，不能以普通自验覆盖未修复发现。自验不伪称独立通过。旧风险分流自验仅限低风险；旧独立失败按原策略恢复。上一阶段历史不自动阻断当前阶段。
+高风险/高影响自验须有同范围完整独立基线。本阶段已有基线直接引用；复用前阶段基线时追加类型 `复核基线复用`、方式 `自验` 的当前阶段记录，证据须包含来源阶段并关联原记录和相同范围。独立发现修复后用类型 `修复自验`、方式 `自验` 追加，证据说明原发现与修复回归，不能以普通自验或第二次独立通过覆盖未修复发现。自验不伪称独立通过；上一阶段历史不自动阻断当前阶段。
 
 结论以明确前缀记录：`通过`、`未通过`等；复核入口不可用/超时直接写其状态，实际查出的证据冲突可作为发现。通过说明不能覆盖结构化未解决事项。check 默认对新准入缺陷 WARNING，待实施/实施中在 `--strict-readiness` 下 ERROR。workset 保持 schema 1：待自验 `verify`、待独立 `independent_review`、通过待地图同步 `sync`、失败 `blocked/resolve_blocker`、歧义 `unknown/unknown`；不自动写状态，hook 只提示。
 
 ### 旧计划兼容
 
-没有策略字段时，保留固定标题 `阶段路线图`、`当前阶段`、`阶段准入摘要`、`最新独立准入复核`、`独立复核记录`。摘要字段为准入状态、Step 0、样本矩阵、验证方式、失败/回滚边界、当前阻塞项及最新独立准入复核。最新表含日期、阶段、结论、证据、复核者；历史使用日期、类型、阶段、结论、证据、复核者六列，当前阶段最新结论须独立通过且与历史一致。标题不加阶段编号，阶段身份以地图为准。
+没有策略字段时，保留固定标题 `阶段路线图`、`当前阶段`、`阶段准入摘要`、`最新独立准入复核`、`独立复核记录`，不为统一行为重写历史。摘要字段为准入状态、Step 0、样本矩阵、验证方式、失败/回滚边界、当前阻塞项及最新独立准入复核。最新表含日期、阶段、结论、证据、复核者；历史使用日期、类型、阶段、结论、证据、复核者六列。普通改动写类型 `普通自验`；独立发现后的闭环写 `修复自验`，且不能清除未完成或缺证据的检查；跨阶段复用写 `复核基线复用` 并关联原记录。其他历史类型按独立检查解释，最新表与当前阶段末条适用记录一致。标题不加阶段编号，阶段身份以地图为准。

package/scripts/check_plan_governance.py

@@ -217,8 +217,144 @@ def review_outcome(conclusion):
     return "unknown"
 
 
+def valid_review_date(value):
+    if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", value or ""):
+        return None
+    try:
+        return parse_plan_date(value)
+    except ValueError:
+        return None
+
+
+def legacy_review_method(kind):
+    """六列旧记录用类型显式表达自验；其他历史类型仍按独立事实解释。"""
+    return "自验" if kind == "复核基线复用" or "自验" in kind else "独立"
+
+
+def phase_precedes(plan_text, candidate, current):
+    """只允许路线图中更早的阶段；标准数字阶段可在精简路线图中回退比较。"""
+    roadmap = [row[0] for row in phase_roadmap_rows(plan_text)]
+    if candidate in roadmap and current in roadmap:
+        return roadmap.index(candidate) < roadmap.index(current)
+    candidate_match = re.fullmatch(r"阶段\s*(\d+)", candidate or "")
+    current_match = re.fullmatch(r"阶段\s*(\d+)", current or "")
+    return bool(candidate_match and current_match
+                and int(candidate_match.group(1)) < int(current_match.group(1)))
+
+
+def legacy_review_state(plan_text, phase):
+    """在不改写六列历史的前提下应用统一单次复核闭环。"""
+    result = {"passed": False, "pending_action": None, "issues": [], "blockers": []}
+    issues, blockers = result["issues"], result["blockers"]
+    rows = review_history_rows(plan_text)
+    known_phases = {row[0] for row in phase_roadmap_rows(plan_text)}
+    valid_rows = []
+    previous_dates = {}
+    for row in rows:
+        if len(row) != 6:
+            kind = row[1] if len(row) > 1 else ""
+            row_phase = row[2] if len(row) > 2 else ""
+            if ("准入" in kind or "readiness" in kind.lower() or "自验" in kind
+                    or kind == "复核基线复用") and (not row_phase or row_phase == phase):
+                issues.append("旧独立复核记录必须使用日期、类型、阶段、结论、证据、复核者六列")
+            continue
+        kind, conclusion = row[1], row[3]
+        if not (
+            "准入" in kind
+            or "readiness" in kind.lower()
+            or "自验" in kind
+            or kind == "复核基线复用"
+            or (("完成验收" in kind or "完成复核" in kind) and review_outcome(conclusion) == "passed")
+        ):
+            continue
+        row_phase = row[2]
+        if row_phase != phase and row_phase not in known_phases and not re.fullmatch(r"阶段\s*\d+", row_phase):
+            continue
+        valid_rows.append(row)
+        parsed = valid_review_date(row[0])
+        previous = previous_dates.get(row_phase)
+        if parsed and previous and parsed < previous:
+            issues.append(f"旧独立复核记录 {row_phase} 日期逆序，无法确认最新结果")
+        if parsed:
+            previous_dates[row_phase] = parsed
+
+    def qualified(row):
+        return (len(row) == 6 and not any(is_placeholder(value) for value in row)
+                and valid_review_date(row[0]) is not None)
+
+    def completed_independent(row):
+        conclusion = row[3].strip()
+        return qualified(row) and legacy_review_method(row[1]) == "独立" and (
+            review_outcome(conclusion) == "passed" or
+            conclusion.startswith(("未通过", "不通过", "失败", "不满足", "拒绝", "证据冲突"))
+            and review_outcome(conclusion) == "failed"
+        )
+
+    prior_states = {}
+    for row in valid_rows:
+        if row[2] == phase or not phase_precedes(plan_text, row[2], phase):
+            continue
+        state = prior_states.setdefault(row[2], {"reviewed": False, "unresolved": False})
+        method = legacy_review_method(row[1])
+        outcome = review_outcome(row[3])
+        if method == "独立":
+            state["reviewed"] = completed_independent(row)
+            if outcome == "failed":
+                state["unresolved"] = True
+        elif (row[1] == "修复自验" and state["reviewed"] and outcome == "passed"
+              and qualified(row)):
+            state["unresolved"] = False
+    reusable_prior_phases = {
+        source_phase for source_phase, state in prior_states.items()
+        if state["reviewed"] and not state["unresolved"]
+    }
+
+    current = [row for row in valid_rows if row[2] == phase]
+    reviewed = False
+    unresolved = None
+    for row in current:
+        method = legacy_review_method(row[1])
+        outcome = review_outcome(row[3])
+        if outcome == "unknown":
+            issues.append("旧独立复核记录结论为空或未知")
+        if method == "独立":
+            reviewed = completed_independent(row)
+            if outcome == "failed":
+                unresolved = row[3]
+        elif row[1] == "复核基线复用":
+            referenced = [source for source in reusable_prior_phases if source in row[4]]
+            if not referenced:
+                issues.append("旧格式复核基线复用须在证据中指向已解决的前阶段独立基线")
+            elif outcome == "passed" and qualified(row):
+                reviewed = True
+        elif row[1] == "修复自验":
+            if not reviewed:
+                issues.append("旧格式修复自验缺少已完成的独立复核基线")
+            elif outcome == "passed" and qualified(row):
+                unresolved = None
+        if outcome == "passed" and not qualified(row):
+            issues.append("旧独立复核记录通过缺少有效日期、类型、证据或身份")
+
+    if unresolved:
+        blockers.append("旧独立复核记录存在未修复的独立发现：" + unresolved)
+    if current and review_outcome(current[-1][3]) == "failed":
+        blockers.append("旧独立复核记录最新结果：" + current[-1][3])
+
+    review = key_value_table(fixed_section(plan_text, "最新独立准入复核"))
+    outcome = review_outcome(review.get("结论", ""))
+    latest_matches = bool(current) and all(
+        review.get(field) == current[-1][index]
+        for field, index in [("日期", 0), ("阶段", 2), ("结论", 3), ("证据", 4), ("复核者", 5)]
+    )
+    result["passed"] = outcome == "passed" and latest_matches and not issues and not blockers
+    if outcome == "pending" and not issues and not blockers:
+        method = legacy_review_method(current[-1][1]) if current else "独立"
+        result["pending_action"] = "verify" if method == "自验" else "independent_review"
+    return result
+
+
 def risk_review_state(plan_text, phase):
-    """显式风险策略的共享事实判定；不评估风险真实性或自动检测证据漂移。"""
+    """显式风险策略的共享事实判定；历史策略名不再改变单次复核行为。"""
     summary_section = fixed_section(top_level_section(plan_text, "当前阶段"), "阶段准入摘要")
     policies = [row for row in markdown_table_rows(summary_section) if row[0] == "复核策略"]
     result = {"enabled": bool(policies), "passed": False, "pending_action": None,
@@ -226,13 +362,12 @@ def risk_review_state(plan_text, phase):
     if not policies:
         return result
     issues, blockers = result["issues"], result["blockers"]
-    single_review = len(policies) == 1 and len(policies[0]) == 2 and policies[0][1] == "单次独立复核"
     if len(policies) != 1 or len(policies[0]) != 2 or policies[0][1] not in {"风险分流", "单次独立复核"}:
         issues.append("复核策略必须唯一且为 风险分流/单次独立复核；空值、未知值或重复声明不能准入")
-    risks = {"低风险", "高影响"} | ({"高风险"} if single_review else set())
+    risks = {"低风险", "高影响", "高风险"}
     summary = key_value_table(summary_section)
     if "最新独立准入复核" in summary:
-        issues.append("风险分流的阶段准入摘要应以 最新阶段复核 替代 最新独立准入复核")
+        issues.append("显式复核策略的阶段准入摘要应以 最新阶段复核 替代 最新独立准入复核")
     if is_placeholder(summary.get("最新阶段复核")):
         issues.append("阶段准入摘要缺少有效的 最新阶段复核 链接")
 
@@ -251,8 +386,6 @@ def risk_review_state(plan_text, phase):
         issues.append("最新阶段复核风险必须为 " + "/".join(sorted(risks)) + "/待判断")
     if review.get("风险") == "待判断":
         issues.append("最新阶段复核风险待判断，不能准入")
-    if not single_review and review.get("方式") == "自验" and review.get("风险") != "低风险":
-        issues.append("自验只适用于低风险，不能代替高影响独立复核")
     if is_placeholder(review.get("风险依据")):
         issues.append("最新阶段复核风险依据为空或占位")
     if outcome == "unknown":
@@ -260,13 +393,7 @@ def risk_review_state(plan_text, phase):
     if outcome == "failed" and review.get("阶段") == phase:
         blockers.append("最新阶段复核：" + review["结论"])
 
-    def valid_date(value):
-        if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", value):
-            return None
-        try:
-            return parse_plan_date(value)
-        except ValueError:
-            return None
+    valid_date = valid_review_date
 
     def qualified(row, legacy=False):
         # 独立基线须有完整身份和证据；记录的结论另行判断。
@@ -288,7 +415,7 @@ def risk_review_state(plan_text, phase):
     def known_other_phase(value):
         return value != phase and (value in known_phases or re.fullmatch(r"阶段\s*\d+", value))
 
-    def current_history(title, width):
+    def history_rows(title, width):
         section = fixed_section(plan_text, title)
         rows = markdown_table_rows(section)
         expected = (["日期", "类型", "阶段", "方式", "风险", "结论", "证据", "复核者"]
@@ -297,32 +424,58 @@ def risk_review_state(plan_text, phase):
             issues.append(f"{title} 必须使用固定的 {width} 列表头")
         if rows.count(expected) > 1:
             issues.append(f"{title} 存在重复表头，无法确认记录结构")
-        current = []
-        previous_date = None
+        valid = []
+        previous_dates = {}
         for row in rows:
             if row == expected:
                 continue
             if len(row) > 2 and row[2] != phase:
-                if known_other_phase(row[2]):
+                if not known_other_phase(row[2]):
+                    issues.append(f"{title} 记录阶段为空或未知，不能忽略")
                     continue
-                issues.append(f"{title} 记录阶段为空或未知，不能忽略")
-                continue
-            if len(row) != width or len(row) < 3 or row[2] != phase:
+            if len(row) != width or len(row) < 3 or (row[2] != phase and not known_other_phase(row[2])):
                 issues.append(f"{title} 记录字段不足、列数不符或阶段不明")
                 continue
-            current.append(row)
+            valid.append(row)
             if is_placeholder(row[1]):
                 issues.append(f"{title} 类型为空或占位")
             parsed = valid_date(row[0])
             if not is_placeholder(row[0]) and parsed is None:
                 issues.append(f"{title} 日期不合法：{row[0]}")
+            previous_date = previous_dates.get(row[2])
             if parsed and previous_date and parsed < previous_date:
-                issues.append(f"{title} 当前阶段记录日期逆序，无法确认最新结果")
+                issues.append(f"{title} {row[2]} 记录日期逆序，无法确认最新结果")
             if parsed:
-                previous_date = parsed
-        return current
+                previous_dates[row[2]] = parsed
+        return valid
+
+    all_history = history_rows("阶段复核记录", 8)
+    history = [row for row in all_history if row[2] == phase]
+
+    prior_states = {}
+    for row in all_history:
+        if (row[2] == phase or not phase_precedes(plan_text, row[2], phase)
+                or row[3] not in {"自验", "独立"}):
+            continue
+        state = prior_states.setdefault(row[2], {"reviewed_high": False, "unresolved": False})
+        if row[3] == "独立":
+            if completed(row):
+                state["reviewed_high"] = row[4] in {"高风险", "高影响"}
+            else:
+                state["reviewed_high"] = False
+            row_outcome = review_outcome(row[5])
+            if row_outcome == "failed":
+                state["unresolved"] = True
+        elif (row[1] == "修复自验" and state["reviewed_high"]
+              and review_outcome(row[5]) == "passed"
+              and not any(is_placeholder(value) for value in row)
+              and valid_date(row[0]) is not None):
+            state["unresolved"] = False
+    reusable_prior_phases = {
+        source_phase for source_phase, state in prior_states.items()
+        if state["reviewed_high"] and not state["unresolved"]
+    }
 
-    history = current_history("阶段复核记录", 8)
     reviewed = False
     reviewed_high = False
     repair_date = None
@@ -330,31 +483,36 @@ def risk_review_state(plan_text, phase):
     for row in history:
         if row[3] not in {"自验", "独立"} or row[4] not in risks | {"待判断"}:
             issues.append("阶段复核记录方式或风险未知")
-        if not single_review and row[3] == "自验" and row[4] != "低风险":
-            issues.append("阶段复核记录自验只适用于低风险")
-        if single_review:
-            if row[3] == "独立":
-                if completed(row):
-                    reviewed = True
-                    reviewed_high = row[4] in {"高风险", "高影响"}
-                else:
-                    reviewed = reviewed_high = False
-                if review_outcome(row[5]) == "failed":
-                    unresolved_single = row[5]
-                elif review_outcome(row[5]) == "passed" and completed(row):
+        if row[3] == "独立":
+            if completed(row):
+                reviewed = True
+                reviewed_high = row[4] in {"高风险", "高影响"}
+            else:
+                reviewed = reviewed_high = False
+            if review_outcome(row[5]) == "failed":
+                unresolved_single = row[5]
+            elif review_outcome(row[5]) == "passed" and completed(row):
+                # 后续独立通过可形成新范围基线，但不能清除既有独立发现。
+                pass
+        elif row[3] == "自验":
+            if row[1] == "复核基线复用":
+                referenced = [source for source in reusable_prior_phases if source in row[6]]
+                if row[4] not in {"高风险", "高影响"} or not referenced:
+                    issues.append("复核基线复用须在证据中指向已解决的前阶段高风险/高影响独立基线")
+                elif (review_outcome(row[5]) == "passed"
+                      and not any(is_placeholder(value) for value in row)
+                      and valid_date(row[0]) is not None):
+                    reviewed = reviewed_high = True
+            elif row[4] in {"高风险", "高影响"} and not reviewed_high:
+                issues.append("高风险/高影响自验缺少同范围独立复核基线或明确的跨阶段复用记录")
+            if row[1] == "修复自验":
+                if not reviewed:
+                    issues.append("修复自验缺少已完成的独立复核基线")
+                elif (review_outcome(row[5]) == "passed" and row[4] in risks
+                      and not any(is_placeholder(value) for value in row)
+                      and valid_date(row[0]) is not None):
                     unresolved_single = None
                     repair_date = valid_date(row[0])
-            elif row[3] == "自验":
-                if row[4] in {"高风险", "高影响"} and not reviewed_high:
-                    issues.append("高风险/高影响自验缺少本阶段已完成的独立复核基线")
-                if row[1] == "修复自验":
-                    if not reviewed:
-                        issues.append("修复自验缺少已完成的独立复核基线")
-                    elif (review_outcome(row[5]) == "passed" and row[4] in risks
-                          and not any(is_placeholder(value) for value in row)
-                          and valid_date(row[0]) is not None):
-                        unresolved_single = None
-                        repair_date = valid_date(row[0])
         if review_outcome(row[5]) == "unknown":
             issues.append("阶段复核记录结论为空或未知")
         if review_outcome(row[5]) == "passed" and (
@@ -377,21 +535,11 @@ def risk_review_state(plan_text, phase):
     if (outcome == "passed" or not is_placeholder(review.get("日期"))) and valid_date(review.get("日期", "")) is None:
         issues.append("最新阶段复核日期不合法")
 
-    independent = [row for row in history if row[3] == "独立"] if not single_review else []
-    unresolved = None
-    for row in independent:
-        row_outcome = review_outcome(row[5])
-        if row_outcome == "failed":
-            unresolved = row[5]
-        elif row_outcome == "passed" and qualified(row):
-            unresolved = None
-    if unresolved:
-        blockers.append("阶段复核记录存在未解除的独立失败：" + unresolved)
-    if single_review and unresolved_single:
+    if unresolved_single:
         blockers.append("阶段复核记录存在未修复的独立发现：" + unresolved_single)
 
     # 旧独立记录仍是独立事实源；完成失败也不能被新自验覆盖。
-    legacy_history = current_history("独立复核记录", 6)
+    legacy_history = [row for row in history_rows("独立复核记录", 6) if row[2] == phase]
     legacy_section = fixed_section(plan_text, "最新独立准入复核")
     legacy = key_value_table(legacy_section)
     legacy_current = legacy.get("阶段") == phase
@@ -410,19 +558,19 @@ def risk_review_state(plan_text, phase):
     unresolved = None
     for row in legacy_history:
         row_outcome = review_outcome(row[3])
-        if single_review and not qualified(row, legacy=True):
+        if not qualified(row, legacy=True):
             issues.append("旧独立复核记录缺少有效日期、类型、证据或身份，迁移不能掩盖")
         if row_outcome == "failed":
             unresolved = row[3]
         elif row_outcome == "passed" and qualified(row, legacy=True):
-            unresolved = None
+            pass
         elif row_outcome == "passed":
             issues.append("旧独立通过记录缺少有效日期、类型、证据或身份")
         elif row_outcome == "unknown":
             issues.append("旧独立复核记录结论为空或未知")
     # 显式迁移后保留旧结论；新记录中的有效修复自验可解除旧发现。
     legacy_dates = [valid_date(row[0]) for row in legacy_history]
-    legacy_repaired = (single_review and repair_date is not None and bool(legacy_dates)
+    legacy_repaired = (repair_date is not None and bool(legacy_dates)
                        and all(date is not None and date <= repair_date for date in legacy_dates)
                        and not unresolved_single)
     if unresolved and not legacy_repaired:
@@ -557,10 +705,12 @@ def check_phase_structure(plan_name, data, plan_text, strict, warnings, errors,
     history = [
         row
         for row in review_history_rows(plan_text)
-        if len(row) >= 4
+        if len(row) == 6
         and row[2] == current_phase
         and (
             "准入" in row[1]
+            or "自验" in row[1]
+            or row[1] == "复核基线复用"
             or ("完成验收" in row[1] and row[3].startswith("通过"))
             or ("完成复核" in row[1] and row[3].startswith("通过"))
             or "readiness" in row[1].lower()
@@ -590,6 +740,16 @@ def check_phase_structure(plan_name, data, plan_text, strict, warnings, errors,
                 strict,
                 f"{plan_name}: 最新独立准入复核与历史记录最后一条结论冲突",
             )
+    legacy_state = legacy_review_state(plan_text, current_phase)
+    for issue in legacy_state["issues"] + legacy_state["blockers"]:
+        readiness_issue(warnings, errors, strict, f"{plan_name}: {issue}")
+    if not legacy_state["passed"] and not legacy_state["issues"] and not legacy_state["blockers"]:
+        readiness_issue(
+            warnings,
+            errors,
+            strict,
+            f"{plan_name}: 旧格式当前阶段记录未满足统一单次复核准入",
+        )
 
 
 def markdown_list_items(section):
@@ -1798,6 +1958,8 @@ def phase_gate(plan_map_text, plan_name, data, plan_text):
     if review_state["enabled"]:
         blockers.extend(review_state["blockers"])
     else:
+        legacy_state = legacy_review_state(plan_text, data["phase"])
+        blockers.extend(legacy_state["blockers"])
         review = key_value_table(fixed_section(plan_text, "最新独立准入复核"))
         conclusion = review.get("结论", "").strip()
         if review.get("阶段") == data["phase"] and conclusion.startswith(("未通过", "不通过", "失败", "不满足", "拒绝")):
@@ -1837,8 +1999,7 @@ def current_summary(plan_text):
 
 
 def current_review_passes(plan_text, phase):
-    review = key_value_table(fixed_section(plan_text, "最新独立准入复核"))
-    return review.get("阶段") == phase and review.get("结论", "").startswith("通过")
+    return legacy_review_state(plan_text, phase)["passed"]
 
 
 def structured_next_action(plan_text):
@@ -2202,11 +2363,14 @@ def workset_payload(root, include_history=False, strict=False):
                                "当前阶段复核声明无法确定"),
                 }
             elif not current_review_passes(plan_text, data["phase"]):
+                legacy_state = legacy_review_state(plan_text, data["phase"])
+                kind = legacy_state["pending_action"] or "independent_review"
                 readiness = "design"
                 action = {
                     "state": "known",
-                    "kind": "independent_review",
-                    "reason": "当前阶段尚无通过的最新独立准入复核",
+                    "kind": kind,
+                    "reason": ("当前阶段待自验" if kind == "verify" else
+                               "当前阶段尚无可用的单次独立复核基线"),
                 }
             else:
                 readiness = "design"

package/scripts/init_plan_governance.py

@@ -19,8 +19,6 @@ VALID_STATUSES = {
     "已废弃",
 }
 
-CLAUDE_SECTION_BEGIN = "<!-- plan-governance:start -->"
-CLAUDE_SECTION_END = "<!-- plan-governance:end -->"
 AGENTS_SECTION_BEGIN = "<!-- plan-governance:start -->"
 AGENTS_SECTION_END = "<!-- plan-governance:end -->"
 
@@ -60,7 +58,7 @@ def agent_rules_body():
 
 最小执行边界：
 
-- 普通一次性任务直接处理；已有计划先确定当前有效策略，再按共享 verification 验证。单次策略下高风险或高影响同范围独立复核一次，修复后自验。
+- 普通一次性任务直接处理；已有计划按共享 verification 验证。新旧计划均为普通改动自验，高风险或高影响同范围独立复核一次，修复后自验。
 - 只实施已授权、已准入的当前阶段。每个阶段有自身 Step 0、验证/完成和失败边界；未解决问题不能记为完成，不可用或超时不能冒充已检查。已有授权不重复索取，新增高影响外部动作按实际授权处理。
 - 首次读取 `docs/PLAN_MAP.md`、当前相关 `docs/plans/*.md` 及适用契约/ADR/migration；恢复先核对当前工作集、最近证据和实际 diff，缺失或冲突再展开。
 - 地图维护状态、阶段、关系、阻塞与证据入口；计划记录本次差异及验证，现行契约优先复用 Schema/OpenAPI。新事实不写回历史草案，变化同步地图及相关引用。
@@ -72,10 +70,6 @@ def managed_section(begin, end):
     return f"{begin}\n{agent_rules_body()}{end}\n"
 
 
-def claude_md_section():
-    return managed_section(CLAUDE_SECTION_BEGIN, CLAUDE_SECTION_END)
-
-
 def agents_md_section():
     return managed_section(AGENTS_SECTION_BEGIN, AGENTS_SECTION_END)
 
@@ -105,16 +99,6 @@ def update_managed_file(root, filename, section, begin, end):
     return target
 
 
-def update_claude_md(root):
-    return update_managed_file(
-        root,
-        "CLAUDE.md",
-        claude_md_section(),
-        CLAUDE_SECTION_BEGIN,
-        CLAUDE_SECTION_END,
-    )
-
-
 def update_agents_md(root):
     return update_managed_file(
         root,
@@ -126,7 +110,7 @@ def update_agents_md(root):
 
 
 def update_agent_rules(root):
-    return [update_claude_md(root), update_agents_md(root)]
+    return [update_agents_md(root)]
 
 
 def plan_map_content(plan_slug, title, status, phase):
@@ -303,19 +287,16 @@ def parse_args(argv):
     parser.add_argument("--status", default="设计中", choices=sorted(VALID_STATUSES), help="初始状态。")
     parser.add_argument("--phase", default="阶段 0", help="当前阶段名称。")
     parser.add_argument("--copy-checker", action="store_true", help="复制检查脚本到目标仓库 scripts/。")
-    parser.add_argument("--update-claude-md", action="store_true", help="创建或更新目标仓库 CLAUDE.md 中的计划治理规则。")
     parser.add_argument("--update-agents-md", action="store_true", help="创建或更新目标仓库 AGENTS.md 中的计划治理规则。")
-    parser.add_argument("--update-agent-rules", action="store_true", help="同时创建或更新 CLAUDE.md 和 AGENTS.md 中的计划治理规则。")
-    parser.add_argument("--update-claude-md-only", action="store_true", help="只创建或更新 CLAUDE.md，不初始化或覆盖 docs/。")
+    parser.add_argument("--update-agent-rules", action="store_true", help="创建或更新目标仓库 AGENTS.md 中的计划治理规则。")
     parser.add_argument("--update-agents-md-only", action="store_true", help="只创建或更新 AGENTS.md，不初始化或覆盖 docs/。")
-    parser.add_argument("--update-agent-rules-only", action="store_true", help="只创建或更新 CLAUDE.md 和 AGENTS.md，不初始化或覆盖 docs/。")
+    parser.add_argument("--update-agent-rules-only", action="store_true", help="只创建或更新 AGENTS.md，不初始化或覆盖 docs/。")
     parser.add_argument("--upgrade-existing", action="store_true", help="升级已有项目的辅助文件：刷新检查脚本和代理规则，不覆盖 docs/。")
     parser.add_argument("--migrate-plan-map-last-updated", action="store_true", help="将旧五列表 PLAN_MAP.md 迁移为包含最后更新的六列表。")
     parser.add_argument("--last-updated-date", default=date.today().isoformat(), help="迁移 PLAN_MAP.md 时填入的最后更新日期，默认今天。")
     parser.add_argument("--force", action="store_true", help="允许覆盖已存在的治理文件。")
     args = parser.parse_args(argv)
     only_modes = [
-        args.update_claude_md_only,
         args.update_agents_md_only,
         args.update_agent_rules_only,
         args.upgrade_existing,
@@ -332,12 +313,6 @@ def main(argv=None):
     args = parse_args(argv or sys.argv[1:])
     root = Path(args.root).expanduser().resolve()
 
-    if args.update_claude_md_only:
-        target = update_claude_md(root)
-        print(f"已写入：{target}")
-        print("CLAUDE.md 已更新；未修改 docs/。")
-        return 0
-
     if args.update_agents_md_only:
         target = update_agents_md(root)
         print(f"已写入：{target}")
@@ -390,11 +365,8 @@ def main(argv=None):
         created.append(copy_checker(root, args.force))
     if args.update_agent_rules:
         created.extend(update_agent_rules(root))
-    else:
-        if args.update_claude_md:
-            created.append(update_claude_md(root))
-        if args.update_agents_md:
-            created.append(update_agents_md(root))
+    elif args.update_agents_md:
+        created.append(update_agents_md(root))
 
     for path in created:
         print(f"已写入：{path}")