plan-governance-cli 0.3.2 → 0.3.3

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.3",
   "description": "统一入口的计划治理检查 CLI",
   "private": false,
   "type": "module",

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` 和相关计划。

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.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/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):