super-engineer-workflow 0.1.0

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

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from common import (
+    constraint_items,
+    current_session_meta,
+    data_artifact_path,
+    detect_project,
+    ensure_status,
+    existing_reference_files,
+    infer_java_modules,
+    is_todo_template_placeholder,
+    load_workspace_config,
+    now_iso,
+    parse_task_blocks,
+    parse_task_modules,
+    phase_after,
+    openspec_bridge_context_path,
+    report_artifact_path,
+    read_json,
+    read_text,
+    resolve_target_codebases,
+    scan_java_files,
+    service_hints,
+    summarize_detected_projects,
+    summarize_todo,
+    todo_path,
+    todo_progress,
+    unique,
+    workspace_root,
+    write_managed_json,
+    write_managed_text,
+)
+
+
+def build_change_steps(summary: str, detected: dict[str, str], impacted_files: list[str], task_breakdown: list[dict[str, object]]) -> list[dict[str, str]]:
+    steps: list[dict[str, str]] = [
+        {
+            "id": "step-1",
+            "title": "分析当前实现",
+            "details": "结合 todo、参考文件和代码结构确认真实修改范围。",
+            "status": "pending",
+        },
+        {
+            "id": "step-2",
+            "title": "按计划实施修改",
+            "details": "严格围绕计划影响文件和业务规则推进实现，必要时先修订计划。",
+            "status": "pending",
+        },
+        {
+            "id": "step-3",
+            "title": "自查并整理差异",
+            "details": "在进入正式审查前，先确认改动与需求、风险和测试计划一致。",
+            "status": "pending",
+        },
+    ]
+
+    task_text = " ".join(
+        [summary]
+        + [str(task.get("title", "")) for task in task_breakdown]
+        + [str(detail) for task in task_breakdown for detail in task.get("details", [])]
+    )
+    if any(path.endswith("Test.java") for path in impacted_files) or "测试" in task_text or "校验" in task_text:
+        steps.append(
+            {
+                "id": "step-4",
+                "title": "补齐自动化测试",
+                "details": "覆盖正常路径、非法输入和回归风险场景。",
+                "status": "pending",
+            }
+        )
+
+    verify_command = detected.get("verify_command") or "请根据项目实际情况补充验证命令。"
+    if verify_command == "multiple":
+        verify_command = "按各目标仓库分别执行验证命令。"
+    steps.append(
+        {
+            "id": f"step-{len(steps) + 1}",
+            "title": "执行验证",
+            "details": f"执行验证命令并记录结论：{verify_command}",
+            "status": "pending",
+        }
+    )
+    return steps
+
+
+def build_acceptance_criteria(task_breakdown: list[dict[str, object]], detected: dict[str, str]) -> list[dict[str, object]]:
+    criteria: list[dict[str, object]] = []
+    for task in task_breakdown:
+        title = str(task.get("title", "")).strip()
+        details = [str(item) for item in task.get("details", []) if str(item).strip()]
+        checks = [f"需求项已实现：{title}"]
+        checks.extend(f"子要求已覆盖：{item}" for item in details[:5])
+        checks.append("相关边界场景已通过自查或测试覆盖。")
+        criteria.append(
+            {
+                "task_id": str(task.get("id", "")),
+                "task_title": title,
+                "checks": checks,
+            }
+        )
+    if not criteria:
+        criteria.append(
+            {
+                "task_id": "workflow",
+                "task_title": "本轮工作流",
+                "checks": ["todo 中的未完成任务已逐项核对。"],
+            }
+        )
+    if detected.get("verify_command"):
+        criteria.append(
+            {
+                "task_id": "verify",
+                "task_title": "自动化验证",
+                "checks": [f"验证命令可执行并通过：{detected['verify_command']}"],
+            }
+        )
+    return criteria
+
+
+def discovery_evidence(discovery: dict, limit: int = 16) -> list[dict[str, object]]:
+    evidence: list[dict[str, object]] = []
+    for codebase in discovery.get("codebases", []):
+        for match in codebase.get("matches", [])[:limit]:
+            evidence.append(
+                {
+                    "codebase": codebase.get("name", ""),
+                    "keyword": match.get("keyword", ""),
+                    "file": match.get("file", ""),
+                    "line": match.get("line", 0),
+                    "snippet": match.get("snippet", ""),
+                }
+            )
+            if len(evidence) >= limit:
+                return evidence
+    return evidence
+
+
+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 match_count >= 5 and impacted_files:
+        return "high"
+    if match_count > 0 or impacted_files:
+        return "medium"
+    return "low"
+
+
+def build_plan_markdown(plan: dict) -> str:
+    detected_project = plan["detected_project"]
+    test_command = detected_project["test_command"] if detected_project["test_command"] != "multiple" else "按各仓库分别执行"
+    start_command = detected_project["start_command"] if detected_project["start_command"] != "multiple" else "按各仓库实际需要执行"
+    verify_command = detected_project["verify_command"] if detected_project["verify_command"] != "multiple" else "按各仓库分别执行"
+    build_tool = detected_project["build_tool"] if detected_project["build_tool"] != "multiple" else "多种构建方式"
+    lines = [
+        "# 变更计划",
+        "",
+        "## 限制条件",
+    ]
+    lines.extend(f"- {item}" for item in plan.get("constraints", [])) if plan.get("constraints") else lines.append("- 暂无")
+    lines.extend([
+        "",
+        "## Todo 进度",
+        f"- 未完成任务：{plan.get('todo_progress', {}).get('pending_task_count', 0)}",
+        f"- 已完成任务：{plan.get('todo_progress', {}).get('completed_task_count', 0)}",
+        f"- 总任务数：{plan.get('todo_progress', {}).get('total_task_count', 0)}",
+        "",
+        "## 需求摘要",
+        plan["requirement_summary"],
+        "",
+        "## 任务拆解",
+    ])
+    task_modules = plan.get("task_modules", [])
+    if task_modules:
+        for module in task_modules:
+            lines.append(f"- 模块：{module.get('title') or '未命名模块'}")
+            for task in module.get("tasks", []):
+                lines.append(f"  - 任务：{task.get('title') or '未命名任务'}")
+                details = task.get("details", [])
+                if details:
+                    lines.extend(f"    - {item}" for item in details)
+    else:
+        lines.append("- 暂无")
+    lines.extend([
+        "",
+        "## 工作区",
+        plan["workspace"],
+        "",
+        "## 目标代码目录",
+        f"- 配置目录：{plan.get('configured_code_path') or '未知'}",
+        f"- 实际目录：{plan.get('resolved_code_path') or '未知'}",
+        f"- 解析说明：{plan.get('service_resolution', {}).get('selection_reason') or '未提供'}",
+        "",
+        "## 目标仓库",
+    ])
+    targets = plan.get("target_codebases", [])
+    if targets:
+        for target in targets:
+            lines.extend(
+                [
+                    f"- {target.get('name') or '未知仓库'}",
+                    f"  - 路径：{target.get('path') or '未知'}",
+                    f"  - 语言：{target.get('detected_project', {}).get('language') or '未知'}",
+                    f"  - 构建工具：{target.get('detected_project', {}).get('build_tool') or '未知'}",
+                    f"  - 验证命令：{target.get('detected_project', {}).get('verify_command') or '未识别'}",
+                ]
+            )
+    else:
+        lines.append("- 暂无")
+    lines.extend([
+        "",
+        "## 使用的参考文件",
+    ])
+    lines.extend(f"- {item}" for item in plan["reference_files_used"]) if plan["reference_files_used"] else lines.append("- 暂无")
+    lines.extend(["", "## 检测到的项目信息"])
+    lines.extend(
+        [
+            f"- 语言：{detected_project['language'] or '未知'}",
+            f"- 构建工具：{build_tool or '未知'}",
+            f"- 测试命令：{test_command or '未识别'}",
+            f"- 启动命令：{start_command or '未识别'}",
+            f"- 验证命令：{verify_command or '未识别'}",
+            "",
+            "## 影响模块",
+        ]
+    )
+    lines.extend(f"- {item}" for item in plan["impacted_modules"]) if plan["impacted_modules"] else lines.append("- 暂无识别结果")
+    lines.extend(["", "## 影响文件"])
+    lines.extend(f"- `{item}`" for item in plan["impacted_files"]) if plan["impacted_files"] else lines.append("- 暂无识别结果")
+    lines.extend(["", "## 计划置信度", f"- {plan.get('confidence', 'unknown')}"])
+    if plan.get("bridge_context"):
+        lines.extend(["", "## Bridge Context"])
+        bridge_context = plan.get("bridge_context", {})
+        lines.extend(f"- {item}" for item in bridge_context.get("business_constraints", [])) if bridge_context.get("business_constraints") else lines.append("- 暂无")
+        if bridge_context.get("compatibility_notes"):
+            lines.append("- 兼容/发布提示：")
+            lines.extend(f"  - {item}" for item in bridge_context.get("compatibility_notes", []))
+    lines.extend(["", "## 定位证据"])
+    evidence = plan.get("evidence", [])
+    if evidence:
+        for item in evidence:
+            lines.append(
+                f"- `{item.get('file')}`:{item.get('line')} 命中 `{item.get('keyword')}`：{item.get('snippet')}"
+            )
+    else:
+        lines.append("- 暂无，实施前需要继续定位代码入口")
+    lines.extend(["", "## 验收标准"])
+    for criterion in plan.get("acceptance_criteria", []):
+        lines.append(f"- {criterion.get('task_title')}")
+        for check in criterion.get("checks", []):
+            lines.append(f"  - {check}")
+    lines.extend(["", "## 实施切片"])
+    for item in plan.get("implementation_slices", []):
+        lines.append(f"- {item.get('title')}：{item.get('goal')}")
+    lines.extend(["", "## 修改步骤"])
+    lines.extend(f"- {item['title']}：{item['details']}" for item in plan["change_steps"])
+    lines.extend(["", "## 测试计划"])
+    lines.extend(f"- {item}" for item in plan["test_plan"]) if plan["test_plan"] else lines.append("- 暂无")
+    lines.extend(["", "## 风险"])
+    lines.extend(f"- {item}" for item in plan["risks"]) if plan["risks"] else lines.append("- 暂无")
+    lines.extend(["", "## 未知项"])
+    lines.extend(f"- {item}" for item in plan["unknowns"]) if plan["unknowns"] else lines.append("- 暂无")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def collect_target_plan_data(config: dict, codebases: list[Path]) -> tuple[list[dict], list[str], list[str]]:
+    targets: list[dict] = []
+    all_impacted_files: list[str] = []
+    all_impacted_modules: list[str] = []
+    for codebase in codebases:
+        detected = detect_project(codebase, config)
+        impacted_files: list[str] = []
+        impacted_modules: list[str] = []
+        if detected["language"] == "java":
+            java_files = scan_java_files(codebase)
+            impacted_files = java_files[:8]
+            impacted_modules = infer_java_modules(impacted_files)
+        targets.append(
+            {
+                "name": codebase.name,
+                "path": str(codebase),
+                "detected_project": detected,
+                "impacted_modules": impacted_modules,
+                "impacted_files": impacted_files,
+            }
+        )
+        all_impacted_files.extend(impacted_files)
+        all_impacted_modules.extend(impacted_modules)
+    return targets, unique(all_impacted_files), unique(all_impacted_modules)
+
+
+def merge_discovery_files(discovery: dict, fallback_files: list[str]) -> list[str]:
+    files: list[str] = []
+    for codebase in discovery.get("codebases", []):
+        for match in codebase.get("matches", []):
+            file_path = str(match.get("file", "")).strip()
+            if file_path:
+                files.append(file_path)
+    files.extend(fallback_files)
+    return unique(files)[:24]
+
+
+def build_implementation_slices(task_breakdown: list[dict[str, object]], impacted_files: list[str]) -> list[dict[str, object]]:
+    slices: list[dict[str, object]] = []
+    for index, task in enumerate(task_breakdown, start=1):
+        slices.append(
+            {
+                "id": f"slice-{index}",
+                "title": str(task.get("title", "")).strip() or f"任务 {index}",
+                "goal": "完成该任务的最小可验证实现，并同步更新相关测试或人工验证项。",
+                "candidate_files": impacted_files[:8],
+                "status": "pending",
+            }
+        )
+    return slices
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="根据工作区 todo 和仓库上下文生成智能计划。")
+    parser.add_argument("--workspace", help="工作空间路径，默认读取当前目录")
+    args = parser.parse_args()
+
+    workspace = workspace_root(Path(args.workspace).expanduser() if args.workspace else None)
+    config = load_workspace_config(workspace)
+    session_meta = current_session_meta(config)
+    todo_file = todo_path(config)
+    if not todo_file.exists():
+        raise SystemExit(f"未找到 todo 文件：{todo_file}")
+
+    todo_text = read_text(todo_file)
+    if is_todo_template_placeholder(todo_text):
+        raise SystemExit(
+            f"已自动创建或检测到示例 todo 模板：{todo_file}。"
+            "请先完善真实需求内容后，再重新执行 plan。"
+        )
+    codebases, resolution = resolve_target_codebases(config, todo_text)
+    constraints = constraint_items(todo_text)
+    task_breakdown = parse_task_blocks(todo_text)
+    task_modules = parse_task_modules(todo_text)
+    progress = todo_progress(todo_text)
+    if not task_breakdown:
+        raise SystemExit("todo.md 中没有未完成任务，请检查是否已经全部标记完成。")
+    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), {})
+    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
+    detected = summarize_detected_projects([item["detected_project"] for item in target_codebases])
+    primary_codebase = codebases[0]
+    test_plan = []
+    for target in target_codebases:
+        verify_command = target["detected_project"].get("verify_command", "")
+        if verify_command:
+            test_plan.append(f"{target['name']}：{verify_command}")
+    if not test_plan:
+        test_plan.append("请根据项目实际情况补充测试命令。")
+    test_plan.append("覆盖本轮需求涉及的正常路径、边界场景和回归风险。")
+
+    plan = {
+        "session_id": session_meta["session_id"],
+        "source": "run-workflow.py plan",
+        "schema_version": 1,
+        "constraints": constraints,
+        "todo_progress": progress,
+        "task_modules": task_modules,
+        "task_breakdown": task_breakdown,
+        "requirement_summary": summary,
+        "assumptions": [
+            "优先以 todo 和已配置参考文件作为需求边界判断依据。",
+            "如果实现过程中发现计划范围不准确，应先更新计划再继续修改代码。",
+        ],
+        "workspace": str(workspace),
+        "configured_code_path": str(config["code_path"]),
+        "resolved_code_path": str(primary_codebase),
+        "resolved_code_paths": [str(item) for item in codebases],
+        "service_hints": resolution.get("service_hints") or service_hints(todo_text),
+        "service_resolution": resolution,
+        "target_codebases": target_codebases,
+        "reference_files_used": docs,
+        "detected_project": detected,
+        "impacted_modules": impacted_modules,
+        "impacted_files": impacted_files,
+        "change_steps": build_change_steps(summary, detected, impacted_files, task_breakdown),
+        "confidence": confidence_from_discovery(discovery, impacted_files),
+        "evidence": discovery_evidence(discovery),
+        "bridge_context": bridge_context,
+        "acceptance_criteria": build_acceptance_criteria(task_breakdown, detected),
+        "implementation_slices": build_implementation_slices(task_breakdown, impacted_files),
+        "test_plan": test_plan,
+        "risks": [
+            "如果参考文件过时，计划可能低估真实影响范围。",
+            "如果当前仓库缺少测试覆盖，回归风险需要靠人工复核兜底。",
+            "如果 todo 中服务名描述不准确，可能会选错目标仓库，需要在计划阶段先确认。",
+            "如果本轮需求涉及多个独立仓库，需要逐仓校验计划、改动和验证结果是否一致。",
+        ],
+        "unknowns": [
+            "需要确认 todo 中未写明但代码行为依赖的隐含业务规则。",
+        ],
+    }
+
+    write_managed_json(config, data_artifact_path(config, "plan.json", session_meta), plan)
+    write_managed_text(config, report_artifact_path(config, "plan.md", session_meta), build_plan_markdown(plan) + "\n")
+
+    status = ensure_status(config, session_meta, read_json(data_artifact_path(config, "status.json", session_meta), {}))
+    phase, awaiting_confirmation, pending_for, next_action = phase_after("plan", config["mode"])
+    status.update(
+        {
+            "phase": phase,
+            "current_task": "已生成变更计划。",
+            "progress": 25,
+            "awaiting_confirmation": awaiting_confirmation,
+            "pending_confirmation_for": pending_for,
+            "next_action": next_action,
+            "completed_tasks": list(dict.fromkeys(status.get("completed_tasks", []) + ["已生成变更计划"])),
+            "blocked_tasks": status.get("blocked_tasks", []),
+            "started_at": status.get("started_at") or session_meta.get("started_at", ""),
+            "updated_at": now_iso(),
+        }
+    )
+    write_managed_json(config, data_artifact_path(config, "status.json", session_meta), status)
+
+
+if __name__ == "__main__":
+    main()

package/super-engineer-workflow/scripts/init-workspace.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from common import (
+    ensure_runtime_dirs,
+    ensure_workflow_inputs,
+    load_workspace_config,
+    read_text,
+    todo_path,
+    code_root,
+    output_dir,
+    workflow_source,
+    workspace_root,
+)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="初始化 super-engineer 工作区基础目录。")
+    parser.add_argument("--workspace", help="工作空间路径，默认读取当前目录")
+    args = parser.parse_args()
+
+    workspace = workspace_root(Path(args.workspace).expanduser() if args.workspace else None)
+    config = load_workspace_config(workspace)
+    if not workspace.exists():
+        raise SystemExit(f"工作区不存在：{workspace}")
+    if not code_root(config).exists():
+        raise SystemExit(f"代码目录不存在：{code_root(config)}")
+
+    ensure_runtime_dirs(config)
+
+    try:
+        input_result = ensure_workflow_inputs(config)
+    except (FileNotFoundError, ValueError) as error:
+        raise SystemExit(str(error))
+    todo_file = todo_path(config)
+    print(f"workflow_source={workflow_source(config)}")
+    print(f"todo_created={'true' if input_result.get('todo_created') else 'false'}")
+    print(f"bridge_generated={'true' if input_result.get('bridge_generated') else 'false'}")
+    if input_result.get("bridge_source"):
+        print(f"bridge_source={input_result.get('bridge_source')}")
+    todo_text = read_text(todo_file)
+    print(f"todo_needs_edit={'true' if input_result.get('todo_needs_edit') else 'false'}")
+
+    print(f"workspace={workspace}")
+    print(f"todo={todo_file}")
+    print(f"code_path={code_root(config)}")
+    print(f"data_root={workspace / '.super-engineer'}")
+    print(f"output_dir={output_dir(config)}")
+    print(f"skill_config={config.get('__skill_config_path', '')}")
+    if todo_text.strip():
+        print("todo_status=ready")
+
+    if bool(config.get("__skill_config_created", False)):
+        print("skill_config_created=true")
+        raise SystemExit(
+            "已自动生成 Skill 配置文件："
+            f"{config.get('__skill_config_path', '')}。"
+            "当前工作流已暂停。"
+            "请先完善配置后再继续。"
+        )
+    print("skill_config_created=false")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from common import (
+    current_session_meta,
+    data_artifact_path,
+    ensure_status,
+    file_sha256,
+    is_standard_workflow_notification,
+    load_workspace_config,
+    openspec_change_dir,
+    openspec_writeback_dir,
+    collect_openspec_cli_context,
+    read_json,
+    update_se_state,
+    workflow_source,
+    workspace_root,
+    write_managed_json,
+    write_managed_text,
+)
+
+
+def detect_spec_conflicts(summary: dict) -> list[dict[str, object]]:
+    bridge_context = summary.get("bridge_context", {})
+    conflicts: list[dict[str, object]] = []
+    for item in bridge_context.get("spec_merge_targets", []):
+        target = Path(str(item.get("target", "")))
+        baseline = str(item.get("target_sha256", ""))
+        current = file_sha256(target)
+        target_exists = bool(item.get("target_exists", False))
+        if not target_exists and target.exists():
+            conflicts.append(
+                {
+                    "relative_path": str(item.get("relative_path", "")),
+                    "reason": "计划阶段目标 spec 不存在，但归档前已出现同路径文件",
+                    "target": str(target),
+                }
+            )
+        elif target_exists and baseline and current and baseline != current:
+            conflicts.append(
+                {
+                    "relative_path": str(item.get("relative_path", "")),
+                    "reason": "目标 spec 自计划阶段以来已发生变化",
+                    "target": str(target),
+                }
+            )
+    return conflicts
+
+
+def notification_blockers(config: dict, summary: dict) -> list[str]:
+    session_meta = current_session_meta(config)
+    status = ensure_status(config, session_meta, read_json(data_artifact_path(config, "status.json", session_meta), {}))
+    verify = read_json(data_artifact_path(config, "verify.json", session_meta), {})
+    notification = read_json(data_artifact_path(config, "notification.json", session_meta), {})
+    overall_result = str(verify.get("result") or summary.get("verify", {}).get("result", "")).strip()
+    if overall_result != "通过":
+        return ["verify 未通过，不能归档"]
+    if not is_standard_workflow_notification(config, session_meta, status, overall_result, notification):
+        return ["缺少标准 notification.json，或通知不是由 run-workflow.py verify 发送"]
+    return []
+
+
+def build_markdown(payload: dict) -> str:
+    blockers = payload.get("blockers", [])
+    lines = [
+        "# Archive Input",
+        "",
+        "## Summary",
+        f"- change: {payload.get('change_name', '')}",
+        f"- archive_ready: {payload.get('archive_ready', False)}",
+        "",
+        "## Blockers",
+    ]
+    if blockers:
+        lines.extend(f"- {item}" for item in blockers)
+    else:
+        lines.append("- 暂无")
+    lines.extend([
+        "",
+        "## Spec Impacts",
+    ])
+    impacts = payload.get("spec_impacts", [])
+    if impacts:
+        lines.extend(f"- {item}" for item in impacts)
+    else:
+        lines.append("- 暂无")
+    lines.extend([
+        "",
+        "## Acceptance",
+    ])
+    acceptance = payload.get("acceptance_result", [])
+    if acceptance:
+        lines.extend(f"- {item.get('task_title', '')}: {item.get('status', '')}" for item in acceptance)
+    else:
+        lines.append("- 暂无")
+    lines.extend([
+        "",
+        "## Merge Mode",
+        f"- {payload.get('merge_mode', '')}",
+        "",
+        "## Conflicts",
+    ])
+    conflicts = payload.get("spec_conflicts", [])
+    if conflicts:
+        lines.extend(f"- {item.get('relative_path', '')}: {item.get('reason', '')}" for item in conflicts)
+    else:
+        lines.append("- 暂无")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="根据 OpenSpec 回写结果生成 archive 输入。")
+    parser.add_argument("--workspace", help="工作空间路径，默认读取当前目录")
+    args = parser.parse_args()
+
+    workspace = workspace_root(Path(args.workspace).expanduser() if args.workspace else None)
+    config = load_workspace_config(workspace)
+    if workflow_source(config) != "openspec":
+        raise SystemExit("当前 workspace.yml 未启用 OpenSpec 模式，无需执行 prepare-archive-openspec。")
+
+    writeback_dir = openspec_writeback_dir(config)
+    summary = read_json(writeback_dir / "execution-summary.json", {})
+    if not summary:
+        raise SystemExit(f"未找到 execution-summary.json：{writeback_dir / 'execution-summary.json'}")
+
+    blockers = list(summary.get("archive_blockers", []))
+    if not summary.get("task_mapping"):
+        blockers.append("缺少 OpenSpec task -> todo -> evidence 映射")
+    acceptance_result = summary.get("acceptance_result", [])
+    if any(item.get("status") != "passed" for item in acceptance_result):
+        blockers.append("存在未通过的验收项")
+    blockers.extend(notification_blockers(config, summary))
+    spec_conflicts = detect_spec_conflicts(summary)
+    if spec_conflicts:
+        blockers.append("存在 spec merge 冲突，请先人工处理")
+    merge_mode = "safe_merge" if not spec_conflicts else "manual_merge_required"
+    openspec_cli = collect_openspec_cli_context(config, include_archive=True)
+    status_json = ((openspec_cli.get("status") or {}).get("json") or {})
+    artifacts = status_json.get("artifacts", []) if isinstance(status_json, dict) else []
+    incomplete_artifacts = []
+    for item in artifacts:
+        status = str(item.get("status", "")).strip()
+        artifact_id = str(item.get("id") or item.get("artifact") or item.get("name") or "").strip()
+        if status and status != "done":
+            incomplete_artifacts.append({"id": artifact_id, "status": status})
+    if incomplete_artifacts:
+        blockers.append("OpenSpec status 存在未完成 artifact")
+
+    payload = {
+        "change_name": summary.get("change_name", ""),
+        "change_dir": str(openspec_change_dir(config)),
+        "archive_ready": not blockers and bool(summary.get("archive_ready")),
+        "blockers": blockers,
+        "review_result": summary.get("review", {}).get("result", ""),
+        "verify_result": summary.get("verify", {}).get("result", ""),
+        "spec_impacts": summary.get("spec_impacts", []),
+        "spec_conflicts": spec_conflicts,
+        "merge_mode": merge_mode,
+        "acceptance_result": acceptance_result,
+        "residual_risks": summary.get("residual_risks", []),
+        "reports": summary.get("reports", {}),
+        "openspec_cli": openspec_cli,
+        "openspec_incomplete_artifacts": incomplete_artifacts,
+    }
+    write_managed_json(config, writeback_dir / "archive-input.json", payload)
+    write_managed_text(config, writeback_dir / "merge-preview.md", build_markdown(payload))
+    update_se_state(
+        config,
+        phase="archive_ready" if payload["archive_ready"] and merge_mode == "safe_merge" else "blocked",
+        last_command="/se:archive-check",
+        artifacts={
+            "archive_input": str(writeback_dir / "archive-input.json"),
+            "merge_preview": str(writeback_dir / "merge-preview.md"),
+        },
+        blocked_reason="; ".join(blockers),
+    )
+    print(f"archive_ready={str(payload['archive_ready']).lower()}")
+    print(f"writeback_dir={writeback_dir}")
+
+
+if __name__ == "__main__":
+    main()