super-engineer-workflow 0.1.6 → 0.1.7

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:
@@ -842,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())
 
@@ -1125,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。")
@@ -1132,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:
@@ -473,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":

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

@@ -10,6 +10,7 @@ from common import (
     format_duration,
     load_workspace_config,
     now_iso,
+    openspec_artifact_hashes,
     openspec_bridge_context_path,
     openspec_change_dir,
     openspec_writeback_dir,
@@ -265,6 +266,7 @@ def main() -> None:
     if str(status.get("phase", "")).strip() != "done":
         archive_blockers.append(f"当前状态不是 done：{status.get('phase', '')}")
 
+    mapping = task_mapping(plan, verify, todo_text)
     payload = {
         "change_name": str(config.get("openspec", {}).get("change_name", "")),
         "change_dir": str(openspec_change_dir(config)),
@@ -295,7 +297,8 @@ def main() -> None:
             "sections": verify.get("sections", []),
         },
         "acceptance_result": summarize_acceptance(plan, verify),
-        "task_mapping": task_mapping(plan, verify, todo_text),
+        "task_mapping": mapping,
+        "openspec_hashes": openspec_artifact_hashes(config),
         "spec_impacts": infer_spec_impacts(plan, plan_bridge_context),
         "residual_risks": residual_risks(plan, review, verify),
         "manual_decisions": [],
@@ -310,6 +313,7 @@ def main() -> None:
 
     output_dir = openspec_writeback_dir(config)
     write_managed_json(config, output_dir / "execution-summary.json", payload)
+    write_managed_json(config, output_dir / "task-mapping.json", {"source": "run-workflow.py writeback-openspec", "items": mapping})
     write_managed_text(config, output_dir / "execution-summary.md", build_markdown(payload))
     print(f"writeback_dir={output_dir}")
     print(f"change_dir={openspec_change_dir(config)}")