super-engineer-workflow 0.1.5 → 0.1.7

package/super-engineer-workflow/references/commands/propose.md

@@ -0,0 +1,25 @@
+# `/se:propose <change-name>`
+
+用途：生成或修正当前 OpenSpec change 的规格文档，不改代码，不生成 todo。
+
+## 前置
+
+- `workflow_source=openspec`。
+- 用户必须显式提供 `<change-name>`。
+- 必须读取 `demand_file`，并读取真实存在的 `reference_files` 摘要作为上下文。
+
+## 执行
+
+1. 先执行公共 `route-check`。
+2. 再执行：
+   `python3 scripts/run-workflow.py route-se --command-text "/se:propose <change-name>"`
+3. 根据 `propose-input.json` 更新或生成 `proposal.md`、`design.md`、`tasks.md`、`specs/`。
+4. 停在 `proposed` 阶段。
+
+## 禁止
+
+- 禁止生成或覆盖 `todo.md`。
+- 禁止执行 `/se:bridge`、`/se:plan`、`/se:apply`。
+- 禁止提示“确认后执行 /se:apply”。
+
+最终回复必须表达：代码未修改，下一步只能执行 `/se:bridge`。

package/super-engineer-workflow/references/commands/review.md

@@ -0,0 +1,22 @@
+# `/se:review`
+
+用途：基于标准 session 和真实代码差异生成 review 结果。
+
+## 前置
+
+- 已完成实现和 self-check。
+- 存在标准 `plan.json` / `plan-summary.json`。
+
+## 执行
+
+1. 先执行公共 `route-check`。
+2. 再执行：
+   `python3 scripts/run-workflow.py route-se --command-text "/se:review"`
+3. 优先读取 `plan-summary.json`，输出 compact review。
+
+## 禁止
+
+- 禁止在未实现完成时 review。
+- 禁止跳过 blocking finding 进入 verify。
+
+review 通过时下一步 `/se:verify`；存在 blocking finding 时下一步 `/se:apply` 修复。

package/super-engineer-workflow/references/commands/status.md

@@ -0,0 +1,22 @@
+# `/se:status`
+
+用途：查看当前工作流状态，不修改代码和产物。
+
+## 执行
+
+1. 先执行公共 `route-check`。
+2. 再执行：
+   `python3 scripts/run-workflow.py route-se --command-text "/se:status"`
+
+## 回复
+
+只汇报：
+
+- 当前 workflow_source / mode
+- 当前 phase
+- 当前 session
+- 关键产物路径
+- allowed_next
+- blockers
+
+禁止顺带执行下一阶段命令。

package/super-engineer-workflow/references/commands/verify.md

@@ -0,0 +1,23 @@
+# `/se:verify`
+
+用途：运行验证命令、生成 verify 报告，并由脚本发送通知。
+
+## 前置
+
+- 已完成 review。
+- 存在标准 session。
+
+## 执行
+
+1. 先执行公共 `route-check`。
+2. 再执行：
+   `python3 scripts/run-workflow.py route-se --command-text "/se:verify"`
+3. 验证日志由脚本截断摘要。
+4. 通知只能由 verify 脚本发送，成功证据是 `notification.json`。
+
+## 禁止
+
+- 禁止 AI 直接调用任何 webhook。
+- verify 失败时禁止提示 archive-check。
+
+OpenSpec 模式 verify 通过后，下一步 `/se:archive-check`。

package/super-engineer-workflow/scripts/bootstrap-openspec.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import argparse
 from pathlib import Path
 
-from common import ensure_workflow_inputs, load_workspace_config, todo_path, update_se_state, workflow_source, workspace_root
+from common import ensure_workflow_inputs, load_workspace_config, openspec_tasks_hash, todo_path, update_se_state, workflow_source, workspace_root
 
 
 def main() -> None:
@@ -30,12 +30,14 @@ def main() -> None:
         artifacts={
             "todo": str(todo_path(config)),
             "bridge_source": str(result.get("bridge_source", "")),
+            "tasks_sha256": openspec_tasks_hash(config),
         },
     )
     print(f"workflow_source={result.get('workflow_source', '')}")
     print(f"todo={todo_path(config)}")
     print(f"bridge_generated={'true' if result.get('bridge_generated') else 'false'}")
     print(f"bridge_source={result.get('bridge_source', '')}")
+    print(f"tasks_sha256={openspec_tasks_hash(config)}")
 
 
 if __name__ == "__main__":

package/super-engineer-workflow/scripts/common.py

@@ -23,6 +23,61 @@ def now_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
+def workflow_lock_path(config: dict[str, Any]) -> Path:
+    return artifacts_dir(config) / "workflow.lock"
+
+
+def process_is_running(pid: int) -> bool:
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        return False
+    return True
+
+
+def acquire_workflow_lock(config: dict[str, Any], command: str, stale_seconds: int = 1800) -> Path:
+    ensure_runtime_dirs(config)
+    path = workflow_lock_path(config)
+    payload = {
+        "pid": os.getpid(),
+        "command": command,
+        "created_at": now_iso(),
+    }
+    flags = os.O_CREAT | os.O_EXCL | os.O_WRONLY
+    try:
+        fd = os.open(str(path), flags)
+    except FileExistsError:
+        existing = read_json(path, {})
+        pid = int(existing.get("pid", 0) or 0) if isinstance(existing, dict) else 0
+        created_at = parse_iso_datetime(str(existing.get("created_at", ""))) if isinstance(existing, dict) else None
+        age = (datetime.now(timezone.utc) - created_at).total_seconds() if created_at else stale_seconds + 1
+        if age > stale_seconds or not process_is_running(pid):
+            try:
+                path.unlink()
+            except FileNotFoundError:
+                pass
+            return acquire_workflow_lock(config, command, stale_seconds=stale_seconds)
+        raise RuntimeError(
+            f"检测到工作流正在执行：pid={pid}, command={existing.get('command', '') if isinstance(existing, dict) else ''}。"
+            "请等待当前命令结束后重试。"
+        )
+    with os.fdopen(fd, "w", encoding="utf-8") as handle:
+        json.dump(payload, handle, ensure_ascii=False, indent=2)
+        handle.write("\n")
+    return path
+
+
+def release_workflow_lock(path: Path | None) -> None:
+    if not path:
+        return
+    try:
+        path.unlink()
+    except FileNotFoundError:
+        pass
+
+
 def parse_iso_datetime(value: str) -> datetime | None:
     normalized = str(value).strip()
     if not normalized:
@@ -652,17 +707,13 @@ def create_session(config: dict[str, Any]) -> dict[str, Any]:
         },
     )
     Path(session_meta["data_dir"]).mkdir(parents=True, exist_ok=True)
-    Path(session_meta["report_dir"]).mkdir(parents=True, exist_ok=True)
     write_managed_json(config, current_session_file(config), session_meta)
     return session_meta
 
 
 def current_session_meta(config: dict[str, Any]) -> dict[str, Any]:
     session_meta = read_json(current_session_file(config), {})
-    normalized = _normalize_session_meta(config, session_meta)
-    Path(normalized["data_dir"]).mkdir(parents=True, exist_ok=True)
-    Path(normalized["report_dir"]).mkdir(parents=True, exist_ok=True)
-    return normalized
+    return _normalize_session_meta(config, session_meta)
 
 
 def current_session_status(config: dict[str, Any], session_meta: dict[str, Any] | None = None) -> dict[str, Any]:
@@ -678,16 +729,26 @@ def active_session_for_plan(config: dict[str, Any]) -> dict[str, Any] | None:
         session_meta = current_session_meta(config)
     except FileNotFoundError:
         return None
-    if not data_artifact_path(config, "plan.json", session_meta).exists():
-        return None
+    data_dir = Path(str(session_meta["data_dir"]))
+    has_plan = data_artifact_path(config, "plan.json", session_meta).exists()
     status = current_session_status(config, session_meta)
     status_phase = str(status.get("phase", "") or "").strip()
     if status_phase in ("done", "archived", "blocked"):
         return None
+    if not has_plan and data_dir.exists():
+        return {
+            "session": session_meta,
+            "status": status,
+            "phase": status_phase or "draft",
+            "incomplete": True,
+        }
+    if not has_plan:
+        return None
     return {
         "session": session_meta,
         "status": status,
         "phase": status_phase or "plan",
+        "incomplete": False,
     }
 
 
@@ -697,6 +758,8 @@ def ensure_plan_can_run(config: dict[str, Any]) -> dict[str, Any] | None:
         return None
     phase = str(active.get("phase", "")).strip()
     session = active.get("session", {})
+    if active.get("incomplete"):
+        return active
     if phase in ("plan", "wait_confirm_plan"):
         return active
     raise RuntimeError(
@@ -834,6 +897,71 @@ def update_se_state(
     return state
 
 
+def openspec_tasks_hash(config: dict[str, Any]) -> str:
+    if workflow_source(config) != "openspec":
+        return ""
+    return file_sha256(openspec_tasks_path(config))
+
+
+def openspec_artifact_hashes(config: dict[str, Any]) -> dict[str, Any]:
+    if workflow_source(config) != "openspec":
+        return {}
+    result: dict[str, Any] = {}
+    openspec = config.get("openspec", {})
+    for key in ("proposal_file", "design_file", "tasks_file"):
+        path_text = str(openspec.get(key, "")).strip()
+        if not path_text:
+            continue
+        path = Path(path_text)
+        if path.exists() and path.is_file():
+            result[key.replace("_file", "")] = {
+                "path": str(path.resolve()),
+                "sha256": file_sha256(path),
+            }
+    specs: list[dict[str, str]] = []
+    specs_dir_text = str(openspec.get("specs_dir", "")).strip()
+    if specs_dir_text:
+        specs_dir = Path(specs_dir_text)
+        if specs_dir.exists() and specs_dir.is_dir():
+            for path in sorted(specs_dir.rglob("*.md")):
+                specs.append(
+                    {
+                        "path": str(path.resolve()),
+                        "relative_path": str(path.relative_to(specs_dir)),
+                        "sha256": file_sha256(path),
+                    }
+                )
+    result["specs"] = specs
+    return result
+
+
+def openspec_hash_drift(config: dict[str, Any], baseline: dict[str, Any]) -> list[str]:
+    current = openspec_artifact_hashes(config)
+    drifts: list[str] = []
+    for key in ("proposal", "design", "tasks"):
+        old_item = baseline.get(key, {}) if isinstance(baseline, dict) else {}
+        new_item = current.get(key, {}) if isinstance(current, dict) else {}
+        old_hash = str(old_item.get("sha256", "")).strip() if isinstance(old_item, dict) else ""
+        new_hash = str(new_item.get("sha256", "")).strip() if isinstance(new_item, dict) else ""
+        if old_hash and new_hash and old_hash != new_hash:
+            drifts.append(f"{key}.md 自执行回写后已变化")
+    old_specs = {
+        str(item.get("relative_path", "")): str(item.get("sha256", ""))
+        for item in baseline.get("specs", [])
+        if isinstance(item, dict)
+    } if isinstance(baseline, dict) else {}
+    new_specs = {
+        str(item.get("relative_path", "")): str(item.get("sha256", ""))
+        for item in current.get("specs", [])
+        if isinstance(item, dict)
+    } if isinstance(current, dict) else {}
+    for rel, old_hash in old_specs.items():
+        new_hash = new_specs.get(rel, "")
+        if old_hash and new_hash and old_hash != new_hash:
+            drifts.append(f"specs/{rel} 自执行回写后已变化")
+    return drifts
+
+
 def _se_state_artifact_exists(path_text: str) -> bool:
     return bool(path_text and Path(path_text).exists())
 
@@ -1117,6 +1245,10 @@ def validate_se_state(config: dict[str, Any], run_command: str) -> dict[str, Any
             errors.append("/se:propose 后不能直接进入交付，必须先执行 /se:bridge。")
         if not _se_state_artifact_exists(str(artifacts.get("todo", ""))):
             errors.append("缺少桥接 todo.md，请先执行 /se:bridge。")
+        bridged_hash = str(artifacts.get("tasks_sha256", "")).strip()
+        current_hash = openspec_tasks_hash(config)
+        if bridged_hash and current_hash and bridged_hash != current_hash:
+            errors.append("OpenSpec tasks.md 已变化，请重新执行 /se:bridge 生成待审核 todo.md。")
     elif se_command == "/se:apply":
         if phase not in ("bridged", "planned", "implementing", "reviewed", "blocked") and se_command not in allowed_next:
             errors.append("当前状态不允许进入交付，请先完成 /se:bridge 并人工审核 todo.md。")
@@ -1124,6 +1256,10 @@ def validate_se_state(config: dict[str, Any], run_command: str) -> dict[str, Any
             errors.append("/se:propose 后不能直接进入交付，必须先执行 /se:bridge。")
         if not _se_state_artifact_exists(str(artifacts.get("todo", ""))):
             errors.append("缺少桥接 todo.md，请先执行 /se:bridge。")
+        bridged_hash = str(artifacts.get("tasks_sha256", "")).strip()
+        current_hash = openspec_tasks_hash(config)
+        if bridged_hash and current_hash and bridged_hash != current_hash:
+            errors.append("OpenSpec tasks.md 已变化，请重新执行 /se:bridge 并审核新的 todo.md。")
     elif se_command == "/se:review":
         if phase not in ("self_checked", "reviewed", "blocked"):
             errors.append("当前状态不允许 review，请先完成实现和自查。")

package/super-engineer-workflow/scripts/generate-discovery.py

@@ -107,6 +107,49 @@ def build_discovery_markdown(discovery: dict) -> str:
     return "\n".join(lines)
 
 
+def build_discovery_summary(discovery: dict) -> dict[str, object]:
+    codebase_summaries: list[dict[str, object]] = []
+    evidence: list[dict[str, object]] = []
+    total_matches = 0
+    for codebase in discovery.get("codebases", []):
+        matches = list(codebase.get("matches", []))
+        total_matches += len(matches)
+        codebase_summaries.append(
+            {
+                "name": codebase.get("name", ""),
+                "path": codebase.get("path", ""),
+                "detected_project": codebase.get("detected_project", {}),
+                "match_count": len(matches),
+                "top_files": list(dict.fromkeys(str(item.get("file", "")) for item in matches if item.get("file")))[:12],
+            }
+        )
+        for item in matches[:6]:
+            evidence.append(
+                {
+                    "codebase": codebase.get("name", ""),
+                    "keyword": item.get("keyword", ""),
+                    "file": item.get("file", ""),
+                    "line": item.get("line", 0),
+                    "snippet": item.get("snippet", ""),
+                }
+            )
+            if len(evidence) >= 20:
+                break
+    return {
+        "session_id": discovery.get("session_id", ""),
+        "source": "run-workflow.py discovery-summary",
+        "schema_version": 1,
+        "task_count": len(discovery.get("tasks", [])),
+        "keywords": discovery.get("keywords", [])[:30],
+        "service_resolution": discovery.get("service_resolution", {}),
+        "codebases": codebase_summaries,
+        "total_match_count": total_matches,
+        "evidence": evidence,
+        "planning_hints": discovery.get("planning_hints", [])[:10],
+        "created_at": discovery.get("created_at", ""),
+    }
+
+
 def main() -> None:
     parser = argparse.ArgumentParser(description="根据 todo 关键词定位代码证据，生成 discovery 产物。")
     parser.add_argument("--workspace", help="工作空间路径，默认读取当前目录")
@@ -165,6 +208,7 @@ def main() -> None:
         "created_at": now_iso(),
     }
     write_managed_json(config, data_artifact_path(config, "discovery.json", session_meta), discovery)
+    write_managed_json(config, data_artifact_path(config, "discovery-summary.json", session_meta), build_discovery_summary(discovery))
     write_managed_text(config, report_artifact_path(config, "discovery.md", session_meta), build_discovery_markdown(discovery))
 
     status = ensure_status(config, session_meta, read_json(data_artifact_path(config, "status.json", session_meta), {}))

package/super-engineer-workflow/scripts/generate-smart-plan.py

@@ -122,6 +122,8 @@ def build_acceptance_criteria(task_breakdown: list[dict[str, object]], detected:
 
 
 def discovery_evidence(discovery: dict, limit: int = 16) -> list[dict[str, object]]:
+    if discovery.get("source") == "run-workflow.py discovery-summary":
+        return list(discovery.get("evidence", []))[:limit]
     evidence: list[dict[str, object]] = []
     for codebase in discovery.get("codebases", []):
         for match in codebase.get("matches", [])[:limit]:
@@ -140,7 +142,10 @@ def discovery_evidence(discovery: dict, limit: int = 16) -> list[dict[str, objec
 
 
 def confidence_from_discovery(discovery: dict, impacted_files: list[str]) -> str:
-    match_count = sum(len(codebase.get("matches", [])) for codebase in discovery.get("codebases", []))
+    if discovery.get("source") == "run-workflow.py discovery-summary":
+        match_count = int(discovery.get("total_match_count", 0) or 0)
+    else:
+        match_count = sum(len(codebase.get("matches", [])) for codebase in discovery.get("codebases", []))
     if match_count >= 5 and impacted_files:
         return "high"
     if match_count > 0 or impacted_files:
@@ -317,6 +322,11 @@ def collect_target_plan_data(config: dict, codebases: list[Path]) -> tuple[list[
 
 def merge_discovery_files(discovery: dict, fallback_files: list[str]) -> list[str]:
     files: list[str] = []
+    if discovery.get("source") == "run-workflow.py discovery-summary":
+        for codebase in discovery.get("codebases", []):
+            files.extend(str(item) for item in codebase.get("top_files", []) if item)
+        files.extend(fallback_files)
+        return unique(files)[:24]
     for codebase in discovery.get("codebases", []):
         for match in codebase.get("matches", []):
             file_path = str(match.get("file", "")).strip()
@@ -369,7 +379,7 @@ def main() -> None:
     summary = summarize_todo(todo_text)
     docs = existing_reference_files(config)
     target_codebases, impacted_files, impacted_modules = collect_target_plan_data(config, codebases)
-    discovery = read_json(data_artifact_path(config, "discovery.json", session_meta), {})
+    discovery = read_json(data_artifact_path(config, "discovery-summary.json", session_meta), {}) or read_json(data_artifact_path(config, "discovery.json", session_meta), {})
     bridge_context = read_json(openspec_bridge_context_path(config), {})
     impacted_files = merge_discovery_files(discovery, impacted_files)
     impacted_modules = infer_java_modules(impacted_files) or impacted_modules

package/super-engineer-workflow/scripts/prepare-archive-openspec.py

@@ -12,6 +12,7 @@ from common import (
     is_standard_workflow_notification,
     load_workspace_config,
     openspec_change_dir,
+    openspec_hash_drift,
     openspec_writeback_dir,
     collect_openspec_cli_context,
     read_json,
@@ -133,6 +134,8 @@ def main() -> None:
     acceptance_result = summary.get("acceptance_result", [])
     if any(item.get("status") != "passed" for item in acceptance_result):
         blockers.append("存在未通过的验收项")
+    hash_drifts = openspec_hash_drift(config, summary.get("openspec_hashes", {}))
+    blockers.extend(hash_drifts)
     blockers.extend(notification_blockers(config, summary))
     spec_conflicts = detect_spec_conflicts(summary)
     if spec_conflicts:
@@ -159,6 +162,7 @@ def main() -> None:
         "verify_result": summary.get("verify", {}).get("result", ""),
         "spec_impacts": summary.get("spec_impacts", []),
         "spec_conflicts": spec_conflicts,
+        "openspec_hash_drifts": hash_drifts,
         "merge_mode": merge_mode,
         "acceptance_result": acceptance_result,
         "residual_risks": summary.get("residual_risks", []),

package/super-engineer-workflow/scripts/run-workflow.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import argparse
+import json
 import subprocess
 import sys
 from pathlib import Path
@@ -11,6 +12,7 @@ from common import (
     current_session_is_stale,
     current_session_meta,
     data_artifact_path,
+    acquire_workflow_lock,
     ensure_plan_can_run,
     ensure_status,
     load_workspace_config,
@@ -20,6 +22,7 @@ from common import (
     planned_codebase,
     read_json,
     read_se_state,
+    release_workflow_lock,
     require_se_state,
     report_artifact_path,
     recover_se_state_from_artifacts,
@@ -165,7 +168,7 @@ def command_validate_state(workspace: Path | None, command: str | None) -> None:
         raise SystemExit(1)
 
 
-def command_route_se(workspace: Path | None, command_text: str | None, timeout_seconds: int, force: bool = False) -> None:
+def command_route_se(workspace: Path | None, command_text: str | None, timeout_seconds: int, force: bool = False, output_json: bool = False) -> None:
     if not command_text:
         raise SystemExit("缺少 /se:* 命令文本。")
     parsed = parse_se_command(command_text)
@@ -178,27 +181,88 @@ def command_route_se(workspace: Path | None, command_text: str | None, timeout_s
         print(f"argument={argument}")
     if se_command == "/se:init":
         command_init(workspace)
-    elif se_command == "/se:propose":
-        command_propose_openspec(workspace, argument or None)
-    elif se_command == "/se:bridge":
-        command_bootstrap_openspec(workspace, explicit_se_bridge=True)
-    elif se_command == "/se:plan":
-        command_plan(workspace)
-    elif se_command == "/se:apply":
-        command_apply(workspace, timeout_seconds)
-    elif se_command == "/se:review":
-        command_review(workspace)
-    elif se_command == "/se:verify":
-        command_verify(workspace, timeout_seconds, force)
-    elif se_command == "/se:archive-check":
-        command_prepare_archive_openspec(workspace)
-    elif se_command == "/se:archive":
-        command_archive_openspec(workspace)
-    elif se_command == "/se:status":
-        command_status(workspace)
-    else:
-        raise SystemExit(f"不支持的 /se:* 命令：{se_command}")
+        print_route_reply_constraint(se_command)
+        return
+    config = load_workspace_config(workspace)
+    lock_path = None
+    if se_command != "/se:status":
+        try:
+            lock_path = acquire_workflow_lock(config, se_command)
+            print(f"workflow_lock={lock_path}")
+        except RuntimeError as error:
+            if output_json:
+                print(json.dumps({"se_command": se_command, "run_command": run_command, "result": "blocked", "error": str(error)}, ensure_ascii=False, indent=2))
+            raise SystemExit(str(error))
+    try:
+        if se_command == "/se:propose":
+            command_propose_openspec(workspace, argument or None)
+        elif se_command == "/se:bridge":
+            command_bootstrap_openspec(workspace, explicit_se_bridge=True)
+        elif se_command == "/se:plan":
+            command_plan(workspace)
+        elif se_command == "/se:apply":
+            command_apply(workspace, timeout_seconds)
+        elif se_command == "/se:review":
+            command_review(workspace)
+        elif se_command == "/se:verify":
+            command_verify(workspace, timeout_seconds, force)
+        elif se_command == "/se:archive-check":
+            command_prepare_archive_openspec(workspace)
+        elif se_command == "/se:archive":
+            command_archive_openspec(workspace)
+        elif se_command == "/se:status":
+            command_status(workspace)
+        else:
+            raise SystemExit(f"不支持的 /se:* 命令：{se_command}")
+    finally:
+        release_workflow_lock(lock_path)
     print_route_reply_constraint(se_command)
+    if output_json:
+        state = validate_se_state(load_workspace_config(workspace), run_command)
+        payload = {
+            "se_command": se_command,
+            "run_command": run_command,
+            "argument": argument,
+            "result": "ok",
+            "phase": state.get("phase", ""),
+            "allowed_next": state.get("allowed_next", []),
+        }
+        try:
+            payload["session_id"] = current_session_meta(load_workspace_config(workspace)).get("session_id", "")
+        except FileNotFoundError:
+            payload["session_id"] = ""
+        print("route_result_json_begin")
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        print("route_result_json_end")
+
+
+def command_route_check(workspace: Path | None, command_text: str | None) -> None:
+    if not command_text:
+        raise SystemExit("缺少 /se:* 命令文本。")
+    config = load_workspace_config(workspace)
+    parsed = parse_se_command(command_text)
+    se_command = parsed["se_command"]
+    run_command = parsed["run_command"]
+    result = validate_se_state(config, run_command)
+    payload = {
+        "se_command": se_command,
+        "run_command": run_command,
+        "argument": str(parsed.get("argument", "")).strip(),
+        "workflow_source": workflow_source(config),
+        "allowed": bool(result.get("valid")),
+        "phase": result.get("phase", ""),
+        "allowed_next": result.get("allowed_next", []),
+        "errors": result.get("errors", []),
+        "state_path": result.get("state_path", ""),
+    }
+    try:
+        session = current_session_meta(config)
+        payload["session_id"] = session.get("session_id", "")
+    except FileNotFoundError:
+        payload["session_id"] = ""
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    if not payload["allowed"]:
+        raise SystemExit(1)
 
 
 def print_route_reply_constraint(se_command: str) -> None:
@@ -294,16 +358,24 @@ def command_plan(workspace: Path | None) -> None:
         raise SystemExit(str(error))
     if active:
         session = active.get("session", {})
-        print("session_action=reused")
-        print(f"session_id={session.get('session_id', '')}")
-        print(f"phase={active.get('phase', '')}")
-        print("next_action=当前计划已存在，继续执行 /se:apply。")
-        return
-    command_init(workspace)
-    config = load_workspace_config(workspace)
-    session_meta = create_session(config)
-    print("session_action=created")
-    print(f"session_id={session_meta.get('session_id', '')}")
+        session_meta = session
+        if active.get("incomplete"):
+            print("session_action=reused_incomplete")
+            print(f"session_id={session_meta.get('session_id', '')}")
+            print(f"phase={active.get('phase', '')}")
+            print("next_action=复用未完成计划会话，继续生成 discovery/plan。")
+        else:
+            print("session_action=reused")
+            print(f"session_id={session_meta.get('session_id', '')}")
+            print(f"phase={active.get('phase', '')}")
+            print("next_action=当前计划已存在，继续执行 /se:apply。")
+            return
+    else:
+        command_init(workspace)
+        config = load_workspace_config(workspace)
+        session_meta = create_session(config)
+        print("session_action=created")
+        print(f"session_id={session_meta.get('session_id', '')}")
     command_discover(workspace)
     args = ["--workspace", str(workspace)] if workspace else []
     run_python("generate-smart-plan.py", args)
@@ -465,19 +537,22 @@ def command_apply(workspace: Path | None, timeout_seconds: int) -> None:
 
 def main() -> None:
     parser = argparse.ArgumentParser(description="super-engineer 统一工作流入口。")
-    parser.add_argument("command", choices=["route-se", "init", "propose-openspec", "bootstrap-openspec", "writeback-openspec", "prepare-archive-openspec", "archive-openspec", "discover", "plan", "apply", "start-implement", "finish-implement", "self-check", "review", "verify", "status", "next", "validate-state", "assert-standard-session"])
+    parser.add_argument("command", choices=["route-se", "route-check", "init", "propose-openspec", "bootstrap-openspec", "writeback-openspec", "prepare-archive-openspec", "archive-openspec", "discover", "plan", "apply", "start-implement", "finish-implement", "self-check", "review", "verify", "status", "next", "validate-state", "assert-standard-session"])
     parser.add_argument("change_name", nargs="?", help="配合 propose-openspec 或 validate-state 使用。")
     parser.add_argument("--command-text", help="配合 route-se 使用，传入完整 /se:* 命令文本。")
     parser.add_argument("--workspace", help="工作空间路径，默认读取当前目录")
     parser.add_argument("--timeout-seconds", type=int, default=300)
     parser.add_argument("--force", action="store_true", help="配合 verify 使用，强制重跑验证并覆盖结果。")
+    parser.add_argument("--json", action="store_true", help="输出机器可读摘要。")
     parser.add_argument("--explicit-se-bridge", action="store_true", help="确认本次 bootstrap-openspec 来自用户显式 /se:bridge 命令。")
     args = parser.parse_args()
 
     workspace = Path(args.workspace).expanduser() if args.workspace else None
 
     if args.command == "route-se":
-        command_route_se(workspace, args.command_text or args.change_name, args.timeout_seconds, args.force)
+        command_route_se(workspace, args.command_text or args.change_name, args.timeout_seconds, args.force, args.json)
+    elif args.command == "route-check":
+        command_route_check(workspace, args.command_text or args.change_name)
     elif args.command == "init":
         command_init(workspace)
     elif args.command == "propose-openspec":