plan-governance-cli 0.3.2 → 0.3.4

package/README.md

@@ -188,36 +188,14 @@ plan-governance-cli graph code impact --repo modelpad --file Sources/ModelPadCor
 
 `plan impact` 是计划治理的前置只读查询：输入文件声明 `graph_scope`、`change_kind`，默认只查询功能层；API 契约、数据、安全、外部边界或明确代码定位才升级到架构层或代码候选。输出查询层级、升级原因、行动分级、测试映射和未查询层级；失败不伪装成“无影响”，也不会触发 `gitnexus analyze`。
 
-## 自主连续执行（可选）
+## 持续推进
 
-适合目标明确、步骤边界清楚、希望执行者连续推进的计划。用户可以直接说“推进到完成计划”，执行者不必每一步请求继续，但必须逐项执行、记录证据、运行验证，并在失败、阶段门、独立复核或其他治理边界处暂停。
-
-自主模式默认关闭。`plan-governance-cli init` 生成的计划仍按普通计划运行；只有在计划当前阶段明确启用以下结构后，才会进入步骤校验和下一步骤查询：
-
-```markdown
-execution_mode: autonomous-continuous
-execution_policy: serial
-
-### 执行清单
-
-| 步骤 ID | 前置步骤 | 动作 | 证据 | 完成条件 | 状态 | 分支记录 |
-|---|---|---|---|---|---|---|
-| `S1` | `-` | 建立基线 | `tests/baseline.log` | 基线命令通过 | `未开始` | `-` |
-```
-
-启用后建议先运行：
-
-```bash
-plan-governance-cli plan steps validate <plan> --json
-plan-governance-cli plan next <plan> --json
-```
-
-`plan next` 只读返回 `ready`、`blocked`、`phase_gate`、`not_enabled` 或 `complete`。它不会执行 shell、修改计划或状态、自动批准独立复核，也不会把 `complete` 当作验收通过；`blocked`、`phase_gate`、`complete` 和 `not_enabled` 都是停止或等待信号。
+在 Codex 中需要跨轮持续推进时使用 `goal`。`plan-governance` skill 和 CLI 只负责计划、证据、阶段准入与检查，不提供自主连续执行模式或步骤级下一步查询。
 
 也可以不全局安装，直接使用锁定版本：
 
 ```bash
-npx --yes --package plan-governance-cli@0.3.1 plan-governance-cli check . --strict-readiness
+npx --yes --package plan-governance-cli@0.3.3 plan-governance-cli check . --strict-readiness
 ```
 
 npm 包内部仍使用版本化的 Python 检查器，但用户不需要直接调用或复制该脚本。旧项目已有本地脚本时仍可保留作为兼容或回滚路径。

package/bin/plan-governance-cli.mjs

@@ -189,11 +189,11 @@ function main() {
   if (command === "init") return runPython(initializer, args.slice(1));
   if (command === "hook") return runPython(hookRuntime, args.slice(1));
   if (command === "graph") return runNode(graphRuntime, args.slice(1));
-  if (command === "plan" && args[1] === "steps" && args[2] === "validate") {
-    return runPython(checker, ["--validate-steps", ...args.slice(3)]);
-  }
   if (command === "plan" && args[1] === "next") {
-    return runPython(checker, ["--next-plan", args[2], ...args.slice(3)]);
+    return fail("plan next 已移除；在 Codex 中请使用 goal 管理跨轮持续推进。");
+  }
+  if (command === "plan" && args[1] === "steps" && args[2] === "validate") {
+    return fail("自主执行步骤校验已移除；在 Codex 中请使用 goal 管理跨轮持续推进。");
   }
   if (command === "plan") return runNode(graphRuntime, args);
   if (command === "check") return runPython(checker, args.slice(1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plan-governance-cli",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "统一入口的计划治理检查 CLI",
   "private": false,
   "type": "module",
@@ -23,7 +23,8 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node --test tests/npm_cli.test.mjs tests/graph_cli.test.mjs tests/architecture_graph_cli.test.mjs tests/plan_impact_step0.test.mjs tests/plan_impact_cli.test.mjs"
+    "test": "node --test tests/npm_cli.test.mjs tests/graph_cli.test.mjs tests/architecture_graph_cli.test.mjs tests/plan_impact_step0.test.mjs tests/plan_impact_cli.test.mjs",
+    "release:npm": "node scripts/release_npm.mjs"
   },
   "dependencies": {
     "yaml": "^2.9.0"

package/resources/skill/SKILL.md

@@ -7,6 +7,8 @@ description: 轻量计划治理工作流。Use when 用户要求管理路线图
 
 使用这个 skill 管理跨阶段、会漂移、需要证据闭环的工作。普通一次性 bugfix、小范围本地修改、互不依赖的待办列表，不要启用治理，除非用户明确要求。
 
+跨轮持续推进由 Codex 的 `goal` 机制管理；本 skill 不定义自主连续执行模式、执行清单或下一步骤查询。
+
 ## 启用判定
 
 开始前先给任务打分：
@@ -127,24 +129,6 @@ docs/
 
 阶段准入检查命令为 `--strict-readiness`。默认治理检查保持兼容，面向历史文档的准入缺陷先以 `WARNING` 提示；严格模式才将机械准入缺陷提升为 `ERROR`。该检查只判断结构化准入条件，不替代业务验收。
 
-## 自主连续执行
-
-当用户明确说“按计划自主推进至完成”“推进到完成计划”或“自主执行且不跳步”时，将其视为当前计划的持续执行指令：无需逐步请求用户继续，但必须从当前阶段的第一项开始，按计划顺序实际执行并记录每一项的证据。
-
-- 不得跳过、合并或仅凭结果声明 Step 0、实施步骤、样本验证、独立复核、状态同步、完成证据或反向引用检查已经完成。
-- 阶段 N 完成仍不自动准入阶段 N+1。只有阶段 N+1 已完成自己的准入条件，且最新独立准入复核明确通过，才可继续执行该阶段。
-- 计划明确定义“不适用”或失败分支时，必须执行该分支并记录原因和证据；不得静默跳过。
-- 目标、范围、公共契约、兼容策略、失败/回滚边界或计划顺序发生实质变化时，先更新治理文档；需要新的用户取舍、外部授权或超出既定范围的操作时暂停并请求方向。
-- 验证失败时应在既定范围内诊断和修复；无法按计划解决、当前阶段被阻塞或后续阶段尚未准入时暂停，并一次性报告已执行步骤、证据、阻塞原因和推荐下一步。
-- 计划完成后统一报告变更摘要、逐项验证结果、计划地图同步情况、独立验收结论和剩余风险；不需要为了例行步骤逐条汇报。
-
-### 模板与只读查询协同
-
-- 自主模式是计划级可选项。只有计划正文明确写出 `execution_mode: autonomous-continuous`，并提供七列表 `执行清单`，才使用步骤级解析；普通计划保持兼容，不要求迁移。
-- 对已启用计划，开始当前步骤前先运行 `plan-governance-cli plan steps validate <plan> --json` 和 `plan-governance-cli plan next <plan> --json`；只有 `ready_steps` 中的步骤才可推进。
-- 对 `blocked`、`phase_gate`、`complete` 或 `not_enabled`，按输出原因停止当前连续推进；这些状态都不代表自动执行、自动验收或下一阶段已获准入。
-- 模板中的自主示例默认位于代码围栏内，不会自动启用；复制并去掉围栏后，必须补齐真实动作、证据、完成条件、状态和分支记录。
-
 ## 工作流
 
 1. 检查仓库是否已有 `docs/PLAN_MAP.md` 和相关计划。
@@ -193,6 +177,14 @@ docs/
 
 `PLAN_MAP.md` 的计划索引应包含 `最后更新` 列，日期格式为 `YYYY-MM-DD`。
 
+计划索引必须在同一个 `## 计划索引` 章节下，按固定顺序拆成三张六列表格：`### 未完成`、`### 已完成`、`### 已废弃`。状态归类规则如下：
+
+- `未完成`：`候选`、`设计中`、`待实施`、`实施中`。
+- `已完成`：`已完成`。
+- `已废弃`：`已废弃`、`已替代`、`已合并`等不再推进的终态；表格标题不改变行内真实状态。
+
+每个计划只能出现一次；没有对应计划的分类保留表头但不添加占位行。必须使用三级标题，以便治理 CLI 将三张表作为同一个计划索引读取。
+
 推荐表头：
 
 ```markdown

package/resources/skill/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Plan Governance"
   short_description: "用计划、证据和检查管理分阶段工作"
-  default_prompt: "使用 $plan-governance 管理这个跨阶段变更，维护计划文档、Step 0 证据和完成检查；如果用户要求推进到完成，逐项执行计划步骤，不跳步，仅在异常或治理门禁处暂停。"
+  default_prompt: "使用 $plan-governance 管理这个跨阶段变更，维护计划文档、Step 0 证据和完成检查。"

package/resources/skill/assets/PLAN_MAP.template.md

@@ -11,13 +11,26 @@
 - 阶段准入摘要、样本矩阵和独立复核记录只写入专项计划，不复制到本索引。
 - 专项计划可在当前阶段声明阶段证据和追加式实施/验证记录；完成快照默认保持旧 JSON 兼容格式，发布/合规场景再显式使用 purpose 关系。
 - `--drift`/`--pre-commit` 的关闭窗口只在已完成计划自身也发生变更时覆盖该计划自身和显式阶段证据，不复用已完成计划的完整影响范围。
+- 计划索引固定分为 `未完成`、`已完成`、`已废弃` 三张表；`已替代`、`已合并`等不再推进的终态归入 `已废弃` 表，但保留真实状态值。
 
 ## 计划索引
 
+### 未完成
+
 | 计划 | 状态 | 当前阶段 | 最后更新 | 依赖 | 证据 |
 |---|---|---|---|---|---|
 | [example-plan](plans/example-plan.md) | 候选 | 阶段 0 | <YYYY-MM-DD> | - | - |
 
+### 已完成
+
+| 计划 | 状态 | 当前阶段 | 最后更新 | 依赖 | 证据 |
+|---|---|---|---|---|---|
+
+### 已废弃
+
+| 计划 | 状态 | 当前阶段 | 最后更新 | 依赖 | 证据 |
+|---|---|---|---|---|---|
+
 允许状态：`候选`、`设计中`、`待实施`、`实施中`、`已完成`、`已替代`、`已合并`、`已废弃`。
 
 ## 推荐顺序

package/resources/skill/assets/plan.template.md

@@ -12,23 +12,6 @@
 
 - 待补充。
 
-## 自主连续执行（可选）
-
-默认不启用自主连续执行。只有当计划明确选择“推进到完成计划”并且每一步都需要真实执行时，才复制下面的示例到当前阶段，去掉代码围栏并替换所有占位内容。未启用时，旧计划和普通计划继续使用原有流程，不需要补填步骤表。
-
-只读查询入口为 `plan-governance-cli plan steps validate <plan> --json` 和 `plan-governance-cli plan next <plan> --json`；查询不会执行动作、写回状态或替代独立验收。
-
-```markdown
-execution_mode: autonomous-continuous
-execution_policy: serial
-
-### 执行清单
-
-| 步骤 ID | 前置步骤 | 动作 | 证据 | 完成条件 | 状态 | 分支记录 |
-|---|---|---|---|---|---|---|
-| `S1` | `-` | `<动作>` | `<可复现证据定位>` | `<可验证完成条件>` | `未开始` | `-` |
-```
-
 <!-- 仅在触发 grilling 且用户确认结构化结论后保留本节；否则删除本节和本注释。 -->
 ## 需求探索
 

package/scripts/check_plan_governance.py

@@ -1405,170 +1405,6 @@ def print_workset_text(payload, strict=False):
         print(f"{'ERROR' if strict else 'WARNING'}: {warning}")
 
 
-STEP_COLUMNS = ["步骤 ID", "前置步骤", "动作", "证据", "完成条件", "状态", "分支记录"]
-STEP_STATES = {"未开始", "执行中", "已完成", "阻塞", "不适用"}
-CONSTRAINT_COLUMNS = ["约束 ID", "类型", "步骤", "共享目标", "建议顺序", "说明"]
-
-
-def split_prerequisites(value):
-    if not value or value.strip("` -") == "":
-        return []
-    return [item for item in re.split(r"[,，、\s]+", value.strip("` ")) if item and item != "-"]
-
-
-def branch_record_has_value(branch_record, marker):
-    match = re.search(rf"{re.escape(marker)}\s*[：:]\s*([^；;,，\n]+)", branch_record)
-    return bool(match and not is_placeholder(match.group(1).strip()))
-
-
-def find_execution_rows(plan_text):
-    section = markdown_section(plan_text, ["执行清单"])
-    if section is None:
-        return None, []
-    rows = markdown_table_rows(section)
-    header_index = next((index for index, row in enumerate(rows) if row[: len(STEP_COLUMNS)] == STEP_COLUMNS), None)
-    if header_index is None:
-        return [], []
-    return STEP_COLUMNS, rows[header_index + 1 :]
-
-
-def validate_step_plan(root, plan_name, strict=False):
-    errors = []
-    _, _, plans = load_plan_records(root, errors)
-    if errors:
-        payload = {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": "",
-            "enabled": False,
-            "status": "invalid",
-            "steps": [],
-            "errors": errors,
-            "warnings": [],
-        }
-        return payload, 1
-
-    data = plans.get(plan_name)
-    if data is None or not data["path"].exists():
-        payload = {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": data["phase"] if data else "",
-            "enabled": False,
-            "status": "invalid",
-            "steps": [],
-            "errors": [f"{plan_name}: 未登记计划或计划文件不存在"],
-            "warnings": [],
-        }
-        return payload, 1
-
-    plan_errors = []
-    plan_text = read_utf8(data["path"], plan_errors)
-    if plan_errors:
-        return {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": data["phase"],
-            "enabled": False,
-            "status": "invalid",
-            "steps": [],
-            "errors": plan_errors,
-            "warnings": [],
-        }, 1
-    parse_text = mask_fenced_code(plan_text)
-    if not re.search(r"^\s*execution_mode\s*:\s*autonomous-continuous\s*$", parse_text, re.MULTILINE):
-        return {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": data["phase"],
-            "enabled": False,
-            "status": "not_enabled",
-            "steps": [],
-            "errors": [],
-            "warnings": [],
-        }, 0
-
-    errors = []
-    policy_match = re.search(r"^\s*execution_policy\s*:\s*(\S+)\s*$", parse_text, re.MULTILINE)
-    policy = policy_match.group(1).strip("`") if policy_match else "serial"
-    if policy not in {"serial", "parallel"}:
-        errors.append(f"{plan_name}: 字段 execution_policy 值非法：{policy}")
-
-    headers, rows = find_execution_rows(plan_text)
-    if headers is None:
-        errors.append(f"{plan_name}: 缺少 `### 执行清单` 章节")
-        rows = []
-    elif not headers:
-        errors.append(f"{plan_name}: 执行清单缺少固定七列表头")
-    elif not rows:
-        errors.append(f"{plan_name}: 执行清单至少需要一个步骤")
-
-    steps = []
-    ids = set()
-    dependencies = {}
-    for row_index, row in enumerate(rows, start=1):
-        if len(row) < len(STEP_COLUMNS):
-            errors.append(f"{plan_name}: 执行清单第 {row_index} 行字段不足")
-            continue
-        step = dict(zip(STEP_COLUMNS, row[: len(STEP_COLUMNS)]))
-        step_id = step["步骤 ID"].strip("` ")
-        if not step_id:
-            errors.append(f"{plan_name}: 执行清单第 {row_index} 行缺少步骤 ID")
-            continue
-        if step_id in ids:
-            errors.append(f"{plan_name}: 步骤 {step_id} 重复")
-        ids.add(step_id)
-        dependencies[step_id] = split_prerequisites(step["前置步骤"])
-        for field in ["动作", "证据", "完成条件"]:
-            if not step[field].strip("` ") or is_placeholder(step[field]):
-                errors.append(f"{plan_name}: 步骤 {step_id} 缺少字段 {field}")
-        state = step["状态"].strip("` ")
-        if state not in STEP_STATES:
-            errors.append(f"{plan_name}: 步骤 {step_id} 状态非法：{state}")
-        if state == "不适用":
-            branch_record = step["分支记录"].strip("` ")
-            if is_placeholder(branch_record):
-                errors.append(f"{plan_name}: 步骤 {step_id} 为不适用但缺少分支记录")
-            else:
-                for marker in ["触发条件", "理由", "替代证据"]:
-                    if not branch_record_has_value(branch_record, marker):
-                        errors.append(f"{plan_name}: 步骤 {step_id} 的不适用分支记录缺少有效{marker}")
-        if state in {"已完成", "不适用"} and is_placeholder(step["证据"]):
-            errors.append(f"{plan_name}: 步骤 {step_id} 为 {state} 但缺少证据")
-        steps.append(
-            {
-                "id": step_id,
-                "preconditions": dependencies[step_id],
-                "action": step["动作"],
-                "evidence": step["证据"],
-                "completion": step["完成条件"],
-                "state": state,
-                "branch_record": step["分支记录"],
-            }
-        )
-
-    for step_id, prerequisites in dependencies.items():
-        for prerequisite in prerequisites:
-            if prerequisite not in ids:
-                errors.append(f"{plan_name}: 步骤 {step_id} 引用了未知前置步骤 {prerequisite}")
-
-    graph = {step_id: [item for item in prerequisites if item in ids] for step_id, prerequisites in dependencies.items()}
-    errors.extend(f"{plan_name}: 执行清单存在环依赖：{cycle}" for cycle in detect_dependency_cycles(graph))
-    status = "invalid" if errors else "valid"
-    warnings = list(errors) if errors and not strict else []
-    return {
-        "schema_version": 1,
-        "plan": plan_name,
-        "phase": data["phase"],
-        "enabled": True,
-        "status": status,
-        "execution_policy": policy,
-        "steps": steps if not errors else [],
-        "errors": errors,
-        "warnings": warnings,
-    }, 1 if errors and strict else 0
-
-
 def run_workset(root, as_json=False, include_history=False, strict=False):
     payload, status = workset_payload(root, include_history=include_history, strict=strict)
     if as_json:
@@ -1578,337 +1414,13 @@ def run_workset(root, as_json=False, include_history=False, strict=False):
     return status
 
 
-def run_validate_steps(root, plan_name, as_json=False, strict=False):
-    payload, status = validate_step_plan(root, plan_name, strict=strict)
-    if as_json:
-        print(json.dumps(payload, ensure_ascii=False, indent=2))
-    else:
-        print(f"步骤校验：{payload['plan']} | {payload['phase']} | {payload['status']}")
-        for error in payload["errors"]:
-            print(f"{'ERROR' if strict else 'WARNING'}: {error}")
-        for warning in payload["warnings"]:
-            if warning not in payload["errors"]:
-                print(f"WARNING: {warning}")
-    return status
-
-
-def split_constraint_values(value):
-    if not value or value.strip("` -") == "":
-        return []
-    return [
-        item.strip("` ")
-        for item in re.split(r"\s*->\s*|[,，、\s]+", value.strip("` "))
-        if item and item != "-"
-    ]
-
-
-def parse_execution_constraints(plan_text, step_ids):
-    section = markdown_section(plan_text, ["执行约束"])
-    if section is None:
-        return [], []
-    rows = markdown_table_rows(section)
-    header_index = next(
-        (index for index, row in enumerate(rows) if row[: len(CONSTRAINT_COLUMNS)] == CONSTRAINT_COLUMNS),
-        None,
-    )
-    if header_index is None:
-        return [], ["执行约束缺少固定六列表头"]
-
-    constraints = []
-    errors = []
-    seen = set()
-    for row_index, row in enumerate(rows[header_index + 1 :], start=1):
-        if len(row) < len(CONSTRAINT_COLUMNS):
-            errors.append(f"执行约束第 {row_index} 行字段不足")
-            continue
-        constraint = dict(zip(CONSTRAINT_COLUMNS, row[: len(CONSTRAINT_COLUMNS)]))
-        constraint_id = constraint["约束 ID"].strip("` ")
-        kind = constraint["类型"].strip("` ")
-        step_values = split_constraint_values(constraint["步骤"])
-        targets = split_constraint_values(constraint["共享目标"])
-        recommended_order = split_constraint_values(constraint["建议顺序"])
-        if not constraint_id or constraint_id in seen:
-            errors.append(f"执行约束第 {row_index} 行约束 ID 缺失或重复：{constraint_id or '-'}")
-        seen.add(constraint_id)
-        if kind != "shared_write_risk":
-            errors.append(f"执行约束 {constraint_id or row_index} 类型非法：{kind}")
-        if not step_values:
-            errors.append(f"执行约束 {constraint_id or row_index} 缺少步骤")
-        unknown_steps = [item for item in step_values if item not in step_ids]
-        if unknown_steps:
-            errors.append(
-                f"执行约束 {constraint_id or row_index} 引用了未知步骤：{', '.join(unknown_steps)}"
-            )
-        if not targets:
-            errors.append(f"执行约束 {constraint_id or row_index} 缺少共享目标")
-        if recommended_order and any(item not in step_values for item in recommended_order):
-            errors.append(f"执行约束 {constraint_id or row_index} 建议顺序引用了约束外步骤")
-        constraints.append(
-            {
-                "id": constraint_id,
-                "kind": kind,
-                "step_ids": step_values,
-                "targets": targets,
-                "recommended_order": recommended_order,
-                "description": constraint["说明"],
-            }
-        )
-    return constraints, errors
-
-
-def phase_gate_is_blocked(plan_text, current_phase):
-    roadmap = phase_roadmap_rows(plan_text)
-    current_index = next(
-        (index for index, row in enumerate(roadmap) if row and row[0] == current_phase),
-        None,
-    )
-    if current_index is None:
-        return False
-    current_row = roadmap[current_index]
-    current_status = current_row[4].strip() if len(current_row) > 4 else ""
-    if current_status != "已完成":
-        return False
-    following = roadmap[current_index + 1 :]
-    if not following:
-        return False
-    next_status = following[0][4].strip() if len(following[0]) > 4 else ""
-    return next_status not in {"待实施", "实施中", "已完成"}
-
-
-def plan_next_payload(root, plan_name):
-    errors = []
-    _, _, plans = load_plan_records(root, errors)
-    data = plans.get(plan_name)
-    if errors or data is None or not data["path"].exists():
-        return {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": data["phase"] if data else "",
-            "execution_mode": None,
-            "status": "blocked",
-            "ready_steps": [],
-            "blocked_steps": [
-                {
-                    "id": "__plan__",
-                    "reasons": [{"kind": "plan_not_found", "detail": f"未登记计划或计划文件不存在：{plan_name}"}],
-                }
-            ],
-            "constraints": [],
-            "next_action": {"kind": "resolve_blocked", "reason": "plan_not_found"},
-        }, 2
-
-    plan_errors = []
-    plan_text = read_utf8(data["path"], plan_errors)
-    if plan_errors:
-        return {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": data["phase"],
-            "execution_mode": None,
-            "status": "blocked",
-            "ready_steps": [],
-            "blocked_steps": [
-                {"id": "__plan__", "reasons": [{"kind": "invalid_structure", "detail": item} for item in plan_errors]},
-            ],
-            "constraints": [],
-            "next_action": {"kind": "resolve_blocked", "reason": "invalid_structure"},
-        }, 1
-
-    validated, validation_status = validate_step_plan(root, plan_name, strict=True)
-    if validated["status"] == "not_enabled":
-        return {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": data["phase"],
-            "execution_mode": None,
-            "status": "not_enabled",
-            "ready_steps": [],
-            "blocked_steps": [],
-            "constraints": [],
-            "next_action": {"kind": "none", "reason": "plan_not_enabled"},
-        }, 0
-
-    if validated["status"] != "valid":
-        evidence_errors = [
-            error
-            for error in validated.get("errors", [])
-            if "缺少证据" in error or "缺少字段 证据" in error
-        ]
-        other_errors = [
-            error
-            for error in validated.get("errors", [])
-            if "缺少证据" not in error and "缺少字段 证据" not in error
-        ]
-        if evidence_errors and not other_errors:
-            blocked_steps = []
-            for error in evidence_errors:
-                match = re.search(r"步骤\s+([^： ]+)", error)
-                step_id = match.group(1).strip("` ") if match else "__plan__"
-                blocked_steps.append(
-                    {
-                        "id": step_id,
-                        "reasons": [{"kind": "missing_evidence", "detail": error}],
-                    }
-                )
-            return {
-                "schema_version": 1,
-                "plan": plan_name,
-                "phase": data["phase"],
-                "execution_mode": "autonomous-continuous",
-                "execution_policy": validated.get("execution_policy", "serial"),
-                "status": "blocked",
-                "ready_steps": [],
-                "blocked_steps": blocked_steps,
-                "constraints": [],
-                "next_action": {"kind": "resolve_blocked", "reason": "missing_evidence"},
-            }, 0
-        reasons = [
-            {"kind": "invalid_structure", "detail": error}
-            for error in validated.get("errors", [])
-        ] or [{"kind": "invalid_structure", "detail": "步骤表无法安全解析"}]
-        return {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": data["phase"],
-            "execution_mode": "autonomous-continuous",
-            "execution_policy": validated.get("execution_policy", "serial"),
-            "status": "blocked",
-            "ready_steps": [],
-            "blocked_steps": [{"id": "__plan__", "reasons": reasons}],
-            "constraints": [],
-            "next_action": {"kind": "resolve_blocked", "reason": "invalid_structure"},
-        }, 1
-
-    steps = validated["steps"]
-    step_ids = {step["id"] for step in steps}
-    constraints, constraint_errors = parse_execution_constraints(plan_text, step_ids)
-    if constraint_errors:
-        return {
-            "schema_version": 1,
-            "plan": plan_name,
-            "phase": data["phase"],
-            "execution_mode": "autonomous-continuous",
-            "execution_policy": validated.get("execution_policy", "serial"),
-            "status": "blocked",
-            "ready_steps": [],
-            "blocked_steps": [
-                {
-                    "id": "__plan__",
-                    "reasons": [{"kind": "invalid_structure", "detail": error} for error in constraint_errors],
-                }
-            ],
-            "constraints": constraints,
-            "next_action": {"kind": "resolve_blocked", "reason": "invalid_structure"},
-        }, 1
-
-    terminal_states = {"已完成", "不适用"}
-    terminal_ids = {step["id"] for step in steps if step["state"] in terminal_states}
-    ready = []
-    blocked = []
-    for step in steps:
-        if step["state"] in terminal_states:
-            continue
-        if step["state"] == "阻塞":
-            blocked.append(
-                {"id": step["id"], "reasons": [{"kind": "failed_step", "detail": "步骤处于阻塞状态"}]}
-            )
-            continue
-        if step["state"] == "执行中":
-            blocked.append(
-                {"id": step["id"], "reasons": [{"kind": "step_in_progress", "detail": "步骤已处于执行中"}]}
-            )
-            continue
-        missing = [item for item in step["preconditions"] if item not in terminal_ids]
-        if missing:
-            blocked.append(
-                {
-                    "id": step["id"],
-                    "reasons": [
-                        {
-                            "kind": "missing_predecessor",
-                            "step_ids": missing,
-                        }
-                    ],
-                }
-            )
-            continue
-        ready.append(
-            {
-                "id": step["id"],
-                "reason": {"kind": "dependencies_satisfied"},
-            }
-        )
-
-    policy = validated.get("execution_policy", "serial")
-    if policy == "serial" and ready:
-        ready = ready[:1]
-
-    all_terminal = all(step["state"] in terminal_states for step in steps)
-    if ready:
-        status = "ready"
-        action_kind = "review_shared_write_order" if constraints else "run_ready_steps"
-        action_reason = "shared_write_risk_present" if constraints else "steps_ready"
-        exit_status = 0
-    elif all_terminal and phase_gate_is_blocked(plan_text, data["phase"]):
-        status = "phase_gate"
-        action_kind = "await_phase_gate"
-        action_reason = "next_phase_not_admitted"
-        exit_status = 0
-    elif all_terminal:
-        status = "complete"
-        action_kind = "await_independent_acceptance"
-        action_reason = "implementation_complete_acceptance_pending"
-        exit_status = 0
-    else:
-        status = "blocked"
-        action_kind = "resolve_blocked"
-        action_reason = blocked[0]["reasons"][0]["kind"] if blocked else "no_ready_steps"
-        exit_status = 0
-
-    return {
-        "schema_version": 1,
-        "plan": plan_name,
-        "phase": data["phase"],
-        "execution_mode": "autonomous-continuous",
-        "execution_policy": policy,
-        "status": status,
-        "ready_steps": ready,
-        "blocked_steps": blocked,
-        "constraints": constraints,
-        "next_action": {"kind": action_kind, "reason": action_reason},
-    }, exit_status
-
-
-def print_plan_next_text(payload):
-    print(f"下一步骤：{payload['plan']} | {payload['phase']} | {payload['status']}")
-    if payload.get("ready_steps"):
-        print("  ready: " + ", ".join(item["id"] for item in payload["ready_steps"]))
-    if payload.get("blocked_steps"):
-        print("  blocked: " + ", ".join(item["id"] for item in payload["blocked_steps"]))
-    if payload.get("constraints"):
-        print("  constraints: " + ", ".join(item["id"] for item in payload["constraints"]))
-    action = payload["next_action"]
-    print(f"  next: {action['kind']} ({action['reason']})")
-
-
-def run_plan_next(root, plan_name, as_json=False):
-    payload, status = plan_next_payload(root, plan_name)
-    if as_json:
-        print(json.dumps(payload, ensure_ascii=False, indent=2))
-    else:
-        print_plan_next_text(payload)
-    return status
-
-
 def parse_args(argv):
     parser = argparse.ArgumentParser(description="检查计划治理文档的一致性。")
     parser.add_argument("root", nargs="?", default=".", help="仓库根目录，默认当前目录。")
     parser.add_argument("--workset", action="store_true", help="输出只读当前工作集。")
-    parser.add_argument("--validate-steps", action="store_true", help="只读校验指定计划的自主执行步骤表。")
-    parser.add_argument("--next-plan", metavar="PLAN", help="只读查询指定计划的下一步骤集合。")
-    parser.add_argument("--json", action="store_true", help="以 JSON 输出工作集或步骤校验结果。")
+    parser.add_argument("--json", action="store_true", help="以 JSON 输出工作集。")
     parser.add_argument("--include-history", action="store_true", help="工作集包含历史计划。")
-    parser.add_argument("--root", dest="mode_root", help="工作集/步骤校验的仓库根目录。")
+    parser.add_argument("--root", dest="mode_root", help="工作集的仓库根目录。")
     parser.add_argument("--drift", action="store_true", help="检查工作区变更是否被活跃计划影响范围覆盖。")
     parser.add_argument("--pre-commit", action="store_true", help="检查 staged 变更是否被活跃计划影响范围覆盖。")
     parser.add_argument(
@@ -1950,15 +1462,6 @@ def main(argv=None):
             include_history=args.include_history,
             strict=args.strict_readiness,
         )
-    if args.validate_steps:
-        return run_validate_steps(
-            Path(args.mode_root or "."),
-            args.root,
-            as_json=args.json,
-            strict=args.strict_readiness,
-        )
-    if args.next_plan:
-        return run_plan_next(Path(args.mode_root or "."), args.next_plan, as_json=args.json)
     root = Path(args.root)
     docs = root / "docs"
     plan_map = docs / "PLAN_MAP.md"

package/scripts/init_plan_governance.py

@@ -192,6 +192,10 @@ def update_agent_rules(root):
 
 def plan_map_content(plan_slug, title, status, phase):
     today = date.today().isoformat()
+    row = f"| [{title}](plans/{plan_slug}.md) | {status} | {phase} | {today} | - | - |"
+    unfinished_row = row if status in {"候选", "设计中", "待实施", "实施中"} else ""
+    completed_row = row if status == "已完成" else ""
+    deprecated_row = row if status in {"已废弃", "已替代", "已合并"} else ""
     return f"""# PLAN_MAP
 
 ## 治理范围
@@ -208,12 +212,27 @@ def plan_map_content(plan_slug, title, status, phase):
 - `PLAN_MAP.md` 的 `状态` 是计划级生命周期，`当前阶段` 是阶段身份指针；阶段 N 完成后，阶段 N+1 默认保持 `设计中`。
 - 阶段准入摘要、样本矩阵和独立复核记录只写入专项计划，不复制到本索引。
 - 启用治理后，已有草案、历史设计、归档计划和临时分析文档默认只作为背景材料，不再作为规范事实源；后续新规范默认进入 `docs/plans/*.md`、ADR、migration、正式 spec 或 `docs/PLAN_MAP.md`。
+- 计划索引固定分为 `未完成`、`已完成`、`已废弃` 三张表；`已替代`、`已合并`等不再推进的终态归入 `已废弃` 表，但保留真实状态值。
 
 ## 计划索引
 
+### 未完成
+
+| 计划 | 状态 | 当前阶段 | 最后更新 | 依赖 | 证据 |
+|---|---|---|---|---|---|
+{unfinished_row}
+
+### 已完成
+
+| 计划 | 状态 | 当前阶段 | 最后更新 | 依赖 | 证据 |
+|---|---|---|---|---|---|
+{completed_row}
+
+### 已废弃
+
 | 计划 | 状态 | 当前阶段 | 最后更新 | 依赖 | 证据 |
 |---|---|---|---|---|---|
-| [{title}](plans/{plan_slug}.md) | {status} | {phase} | {today} | - | - |
+{deprecated_row}
 
 允许状态：`候选`、`设计中`、`待实施`、`实施中`、`已完成`、`已替代`、`已合并`、`已废弃`。
 

package/scripts/plan_governance_hook.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 import argparse
-import importlib.util
 import re
 import subprocess
 import sys
@@ -135,16 +134,6 @@ def active_plans(root):
     return [plan for plan in plans if plan["status"] in ACTIVE_STATUSES], blockers
 
 
-def load_next_checker():
-    checker_path = Path(__file__).with_name("check_plan_governance.py")
-    spec = importlib.util.spec_from_file_location("plan_governance_next_checker", checker_path)
-    if spec is None or spec.loader is None:
-        return None
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
 def target_matches_path(target, path):
     normalized_target = normalize_scope_path(target)
     normalized_path = normalize_scope_path(path)
@@ -190,24 +179,7 @@ def print_session_start(root):
     else:
         print("[plan-governance] 当前阻塞项：无。")
 
-    checker = load_next_checker()
-    if checker is None:
-        return 0
-    hook_status = 0
-    for plan in active:
-        payload, status = checker.plan_next_payload(root, plan["name"])
-        if payload["status"] == "not_enabled":
-            continue
-        ready = ",".join(item["id"] for item in payload.get("ready_steps", [])) or "-"
-        blocked = ",".join(item["id"] for item in payload.get("blocked_steps", [])) or "-"
-        action = payload["next_action"]
-        print(
-            f"[plan-governance] autonomous next: {plan['name']} | "
-            f"{payload['status']} | ready={ready} | blocked={blocked} | "
-            f"next={action['kind']}:{action['reason']}"
-        )
-        hook_status = max(hook_status, status)
-    return hook_status
+    return 0
 
 
 def print_pre_write(root, paths):