agent-project-sdlc 0.1.19 → 0.1.21

package/assets/tools/impact_analyzer.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+import json
+import re
+from pathlib import Path
+
+from harness_utils import ROOT, make_arg_parser, repo_path, require, run_main
+
+
+def tokens(text: str) -> set[str]:
+    raw = re.findall(r"[A-Za-z0-9_./-]{3,}|[\u4e00-\u9fff]{2,}", text)
+    stop = {"the", "and", "for", "with", "status", "draft", "added", "changed", "removed"}
+    return {item.lower() for item in raw if item.lower() not in stop}
+
+
+def score_file(path: Path, query_tokens: set[str]) -> int:
+    try:
+        content = path.read_text(encoding="utf-8", errors="ignore").lower()
+    except Exception:
+        return 0
+    return sum(1 for token in query_tokens if token in content)
+
+
+def main() -> None:
+    parser = make_arg_parser("Generate candidate impact scope for an RFC")
+    parser.add_argument("--rfc", required=True, help="RFC path relative to repository root")
+    parser.add_argument("--top", type=int, default=30, help="Maximum candidates to print")
+    args = parser.parse_args()
+
+    rfc_path = repo_path(args.rfc)
+    require(rfc_path.exists(), f"RFC file not found: {args.rfc}")
+    query_tokens = tokens(rfc_path.read_text(encoding="utf-8"))
+    require(query_tokens, "RFC does not contain enough analyzable terms")
+
+    candidates = []
+    roots = [".docs", "src", "tests"]
+    for root in roots:
+        base = repo_path(root)
+        if not base.exists():
+            continue
+        for path in base.rglob("*"):
+            if path.is_file() and path.name != ".gitkeep":
+                score = score_file(path, query_tokens)
+                if score:
+                    candidates.append({"path": str(path.relative_to(ROOT)), "score": score})
+
+    candidates.sort(key=lambda item: (-item["score"], item["path"]))
+    print(json.dumps({"rfc": args.rfc, "candidates": candidates[: args.top]}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/run_current_gate.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+import subprocess
+
+from harness_utils import load_lifecycle, load_phase_contracts, load_plan, require, run_main, ROOT, validate_plan_contract
+
+
+def main() -> None:
+    lifecycle = load_lifecycle()
+    phases = load_phase_contracts()
+    phase_name = lifecycle.get("current_phase")
+    require(phase_name in phases, f"Current phase not found in phase contracts: {phase_name}")
+    gates = phases[phase_name].get("gates") or []
+    if not gates:
+        print(f"No gate configured for phase {phase_name}")
+        return
+
+    for gate in gates:
+        print(f"Running {gate}")
+        proc = subprocess.run(gate, cwd=ROOT, shell=True)
+        result = "PASS" if proc.returncode == 0 else "FAIL"
+        print(f"{gate}: {result}")
+        require(proc.returncode == 0, f"Gate failed for {phase_name}: {gate}")
+
+    validate_plan_contract(load_plan(), allow_open=False)
+    print("Phase exit plan OK: no open tasks")
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/status.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+from harness_utils import load_lifecycle, load_plan, run_main
+
+
+def main() -> None:
+    lifecycle = load_lifecycle()
+    tasks_data = load_plan()
+    tasks = tasks_data.get("tasks", [])
+    current_task_id = tasks_data.get("current_task_id") or ""
+    current_task = next((task for task in tasks if task.get("id") == current_task_id), None)
+    active_count = len(tasks)
+
+    print(f"Current phase: {lifecycle.get('current_phase')}")
+    print(f"Active role: {lifecycle.get('active_role')}")
+    print(f"Active skill: {lifecycle.get('active_skill')}")
+    print(f"Milestone: {lifecycle.get('current_milestone')}")
+    print(f"Allowed next phases: {', '.join(lifecycle.get('allowed_next_phases') or []) or 'none'}")
+    print(f"Plan tasks: {active_count} active/future")
+    print(f"Next task sequence: {tasks_data.get('next_task_sequence') or 'unset'}")
+    if current_task:
+        print(f"Current task: {current_task.get('id')} {current_task.get('title')} [{current_task.get('status')}]")
+    else:
+        print("Current task: none")
+    if lifecycle.get("blocked_reason"):
+        print(f"Blocked reason: {lifecycle.get('blocked_reason')}")
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/transition.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+from harness_utils import dump_yaml, load_lifecycle, load_phase_contracts, make_arg_parser, require, run_main
+
+
+RFC_INTERRUPT_SOURCES = {"SPRINTING", "REVIEWING", "TESTING", "RELEASING"}
+
+
+def phase_targets(phase: dict) -> list[str]:
+    targets: list[str] = []
+    next_phase = phase.get("next")
+    if next_phase:
+        targets.append(str(next_phase))
+    for return_phase in phase.get("returns") or []:
+        if return_phase:
+            targets.append(str(return_phase))
+    return list(dict.fromkeys(targets))
+
+
+def main() -> None:
+    parser = make_arg_parser("Transition AI SDLC Harness lifecycle phase")
+    parser.add_argument("--to", required=True, help="Target lifecycle phase")
+    parser.add_argument("--reason", default="", help="Short compatibility note; not persisted in active state")
+    parser.add_argument("--force", action="store_true", help="Allow transition outside configured next phases")
+    args = parser.parse_args()
+
+    lifecycle = load_lifecycle()
+    phases = load_phase_contracts()
+    target = args.to
+    current = lifecycle.get("current_phase")
+    require(target in phases, f"Unknown target phase: {target}")
+    require(current in phases, f"Current phase is not declared in phase_contracts.yaml: {current}")
+
+    legal = set(lifecycle.get("allowed_next_phases") or [])
+    legal.update(phase_targets(phases[current]))
+    if target == "RFC_RECALIBRATION" and current in RFC_INTERRUPT_SOURCES:
+        legal.add(target)
+    if target == "BLOCKED":
+        legal.add(target)
+    suspended = lifecycle.get("suspended_phase")
+    if current == "BLOCKED" and suspended:
+        legal.add(suspended)
+
+    require(args.force or target in legal, f"Illegal transition {current} -> {target}. Legal: {sorted(legal)}")
+
+    if target in {"RFC_RECALIBRATION", "BLOCKED"} and current not in {"RFC_RECALIBRATION", "BLOCKED"}:
+        lifecycle["suspended_phase"] = current
+    elif current == "RFC_RECALIBRATION" and target == "SPRINTING":
+        lifecycle["suspended_phase"] = ""
+    elif suspended and target == suspended:
+        lifecycle["suspended_phase"] = ""
+
+    phase = phases[target]
+    lifecycle["current_phase"] = target
+    lifecycle["active_role"] = phase.get("role", "")
+    lifecycle["active_skill"] = phase.get("skill", "")
+
+    lifecycle["allowed_next_phases"] = phase_targets(phase)
+    if target == "BLOCKED" and lifecycle.get("suspended_phase"):
+        lifecycle["allowed_next_phases"] = [lifecycle["suspended_phase"]]
+
+    dump_yaml(lifecycle, ".codex/state/lifecycle.yaml")
+    print(f"Transitioned {current} -> {target}")
+    if args.reason:
+        print(f"Note: {args.reason}")
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/validate_allowed_paths.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+from harness_utils import (
+    OPEN_TASK_STATUSES,
+    changed_files,
+    expand_harness_root,
+    load_lifecycle,
+    load_plan,
+    load_yaml,
+    matches_any,
+    require,
+    run_main,
+    task_by_id,
+)
+
+
+def main() -> None:
+    data = load_plan()
+    tasks = [task for task in data.get("tasks", []) if isinstance(task, dict)]
+    open_tasks = [task for task in tasks if task.get("status") in OPEN_TASK_STATUSES]
+
+    policies = load_yaml(".codex/pjsdlc_managed/policies/allowed_paths.yaml")
+    lifecycle = load_lifecycle()
+    current_phase = lifecycle.get("current_phase") or "SPRINTING"
+    phase_policy = ((policies.get("phases") or {}).get(current_phase) or {})
+    always_allow = expand_harness_root(phase_policy.get("always_allow") or [])
+
+    if open_tasks:
+        current_task_id = data.get("current_task_id") or ""
+        task = task_by_id(data, current_task_id) if current_task_id else None
+        require(task, "current_task_id must point to the task being validated")
+        require(task.get("status") in OPEN_TASK_STATUSES, "current_task_id must point to an open task for path validation")
+        allowed = list(task.get("allowed_paths") or []) + list(always_allow)
+    else:
+        print("Allowed paths skipped: no open task")
+        return
+
+    changed = [path for path in changed_files() if not path.startswith(".git/")]
+    blocked = [path for path in changed if not matches_any(path, allowed)]
+    require(not blocked, "Changed files outside current task allowed_paths: " + ", ".join(blocked))
+    print(f"Allowed paths OK: {len(changed)} changed file(s) checked")
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/validate_design.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+import re
+from harness_utils import (
+    combined_text,
+    contains_any,
+    load_lifecycle,
+    load_plan,
+    markdown_deliverables,
+    repo_path,
+    run_main,
+    require,
+    validate_plan_contract,
+    validate_task_shape,
+)
+
+CROSS_CUTTING_CATEGORIES = [
+    {
+        "name": "ai",
+        "label": "AI copilot/provider",
+        "trigger_terms": ["ai provider", "ai output", "aioutput", "llm", "copilot", "副驾驶"],
+        "architecture_terms": ["ai provider", "ai output", "llm", "copilot", "副驾驶", "模型", "智能", "prompt"],
+    },
+    {
+        "name": "external",
+        "label": "external system boundary",
+        "trigger_terms": ["external system", "external integration", "webhook", "外部系统", "第三方", "微信", "工商", "税务", "社保", "公积金", "金蝶", "对象存储"],
+        "architecture_terms": ["external system", "external integration", "webhook", "adapter", "适配", "边界", "外部系统", "第三方", "微信", "工商", "税务", "社保", "公积金", "金蝶", "对象存储"],
+    },
+    {
+        "name": "compliance",
+        "label": "compliance/permission/audit",
+        "trigger_terms": ["compliance", "authorization", "audit log", "audit trail", "合规", "授权", "客户确认", "回执归档", "权限模型", "权限控制", "权限架构", "审计架构", "审计日志"],
+        "architecture_terms": ["compliance", "permission", "authorization", "audit", "合规", "权限", "审计", "授权", "客户确认", "回执归档"],
+    },
+]
+
+
+def main() -> None:
+    lifecycle = load_lifecycle()
+    plan = load_plan()
+    validate_plan_contract(plan, allow_open=lifecycle.get("current_phase") != "ARCHITECTING")
+
+    architecture_docs = markdown_deliverables(".docs/02_architecture")
+    tech_plan_docs = markdown_deliverables(".docs/03_tech_plan")
+    product_docs = markdown_deliverables(".docs/01_product")
+    require(architecture_docs, "No architecture deliverables found in .docs/02_architecture/")
+    require(tech_plan_docs, "No technical plan deliverables found in .docs/03_tech_plan/")
+
+    text = combined_text(architecture_docs + tech_plan_docs)
+    require(contains_any(text, ["prd", "requirement", "需求"]), "Design must cite product requirements")
+    require(contains_any(text, ["api", "interface", "接口", "contract", "契约"]), "Design must describe interfaces or contracts")
+    require(contains_any(text, ["task", "任务", "breakdown"]), "Design must include task breakdown")
+    draft_tasks = validate_draft_task_tech_plan_refs(tech_plan_docs)
+    validate_cross_cutting_architecture(product_docs, tech_plan_docs, architecture_docs, draft_tasks)
+    print(f"Design artifacts OK: {len(architecture_docs)} architecture, {len(tech_plan_docs)} tech plan")
+
+
+def validate_draft_task_tech_plan_refs(tech_plan_docs: list) -> list[dict]:
+    draft = load_plan(".codex/state/plan.draft.yaml")
+    require("current_phase" not in draft, "plan.draft.yaml must not define current_phase; lifecycle.yaml is the single source for current_phase")
+    require("current_task_id" not in draft, "plan.draft.yaml must not define current_task_id because drafts are not active task state")
+    tasks = draft.get("tasks", [])
+    require(tasks, "plan.draft.yaml must contain at least one task before leaving ARCHITECTING")
+
+    available_tech_plans = {repo_relative(path) for path in tech_plan_docs}
+    development_tasks: list[dict] = []
+    primary_refs: list[str] = []
+    for index, task in enumerate(tasks):
+        require(isinstance(task, dict), f"Task draft #{index + 1} must be a mapping")
+        validate_task_shape(task, index)
+        require(task.get("status") == "pending", f"Draft task {task.get('id')} should start as pending")
+        if not is_development_draft(task):
+            continue
+        development_tasks.append(task)
+        docs = task.get("docs")
+        require(isinstance(docs, dict), f"Draft task {task.get('id')} docs must be a mapping")
+        tech_refs = as_list(docs.get("tech_plan"))
+        require(tech_refs, f"Draft task {task.get('id')} must reference at least one tech plan slice in docs.tech_plan")
+        normalized_refs = [normalize_doc_ref(ref) for ref in tech_refs]
+        for ref in normalized_refs:
+            require(ref.startswith(".docs/03_tech_plan/"), f"Draft task {task.get('id')} docs.tech_plan must point into .docs/03_tech_plan/: {ref}")
+            require(ref in available_tech_plans, f"Draft task {task.get('id')} references missing or generated tech plan slice: {ref}")
+        validate_self_test_contract_tech_plan_binding(task, normalized_refs)
+        primary_refs.append(normalized_refs[0])
+
+    require(development_tasks, "plan.draft.yaml must contain at least one development task with implementation_doc")
+    if len(development_tasks) > 1:
+        require(
+            len(set(primary_refs)) == len(primary_refs),
+            "Draft development tasks must reference distinct primary tech plan slices in docs.tech_plan",
+        )
+    return tasks
+
+
+def validate_cross_cutting_architecture(product_docs: list, tech_plan_docs: list, architecture_docs: list, draft_tasks: list[dict]) -> None:
+    source_text = "\n".join(
+        [
+            combined_text(product_docs),
+            combined_text(tech_plan_docs),
+            "\n".join(task_text(task) for task in draft_tasks),
+        ]
+    )
+    triggered = [category for category in CROSS_CUTTING_CATEGORIES if contains_any(source_text, category["trigger_terms"])]
+    assigned_docs: set[str] = set()
+    for category in triggered:
+        matches = [
+            doc
+            for doc in architecture_docs
+            if repo_relative(doc) not in assigned_docs and contains_any(doc.read_text(encoding="utf-8"), category["architecture_terms"])
+        ]
+        require(matches, f"Design requires a dedicated {category['label']} architecture slice")
+        assigned_docs.add(repo_relative(matches[0]))
+
+
+def validate_self_test_contract_tech_plan_binding(task: dict, normalized_tech_refs: list[str]) -> None:
+    contract = task.get("self_test_contract")
+    if not isinstance(contract, dict) or contract.get("status") != "required":
+        return
+    source = normalize_doc_ref(str(contract.get("source") or ""))
+    task_id = task.get("id")
+    require(source in normalized_tech_refs, f"Draft task {task_id} self_test_contract.source must be listed in docs.tech_plan: {source}")
+    source_path = repo_path(source)
+    if not source_path.exists():
+        return
+    text = source_path.read_text(encoding="utf-8")
+    section = markdown_section(text, ["development self-test contract", "开发自测合同"])
+    require(section, f"Draft task {task_id} self_test_contract.source must contain a Development Self-Test Contract section: {source}")
+    require(
+        contains_any(section, ["module key test path", "模块关键测试路径"]),
+        f"Draft task {task_id} tech plan Development Self-Test Contract must include Module key test path: {source}",
+    )
+    for scenario in contract.get("scenarios") or []:
+        if not isinstance(scenario, dict):
+            continue
+        scenario_id = str(scenario.get("id") or "").strip()
+        if scenario_id:
+            require(scenario_id in section, f"Draft task {task_id} tech plan Development Self-Test Contract must include scenario {scenario_id}: {source}")
+
+
+def markdown_section(text: str, header_terms: list[str]) -> str:
+    lines = text.splitlines()
+    start = -1
+    level = 0
+    for index, line in enumerate(lines):
+        match = re.match(r"^(#{1,6})\s+(.+)$", line)
+        if not match:
+            continue
+        title = match.group(2).lower()
+        if any(term.lower() in title for term in header_terms):
+            start = index
+            level = len(match.group(1))
+            break
+    if start == -1:
+        return ""
+    end = len(lines)
+    for index in range(start + 1, len(lines)):
+        match = re.match(r"^(#{1,6})\s+", lines[index])
+        if match and len(match.group(1)) <= level:
+            end = index
+            break
+    return "\n".join(lines[start:end])
+
+
+def is_development_draft(task: dict) -> bool:
+    task_id = str(task.get("id") or "")
+    return bool(task.get("implementation_doc")) or task.get("phase") == "SPRINTING" or task_id.startswith("DEV-")
+
+
+def as_list(value) -> list[str]:
+    if isinstance(value, list):
+        return [str(item).strip() for item in value if str(item).strip()]
+    if isinstance(value, str) and value.strip():
+        return [value.strip()]
+    return []
+
+
+def normalize_doc_ref(value: str) -> str:
+    ref = value.replace("\\", "/")
+    return ref[2:] if ref.startswith("./") else ref
+
+
+def repo_relative(path) -> str:
+    return path.resolve().relative_to(repo_path(".").resolve()).as_posix()
+
+
+def task_text(task: dict) -> str:
+    parts = []
+    for key in ["id", "title", "summary", "phase"]:
+        if task.get(key):
+            parts.append(str(task[key]))
+    docs = task.get("docs")
+    if isinstance(docs, dict):
+        for value in docs.values():
+            parts.extend(as_list(value))
+    return "\n".join(parts)
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/validate_dev_state.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+from harness_utils import load_plan, require, run_main
+
+
+def main() -> None:
+    draft = load_plan(".codex/state/plan.draft.yaml")
+    require("current_phase" not in draft, "plan.draft.yaml must not define current_phase; lifecycle.yaml is the single source for current_phase")
+    require("current_task_id" not in draft, "plan.draft.yaml must not define current_task_id because drafts are not active task state")
+    tasks = [task for task in draft.get("tasks", []) if isinstance(task, dict)]
+    require(
+        not tasks,
+        "Unconsumed draft tasks remain in plan.draft.yaml: "
+        + ", ".join(str(task.get("id") or "<missing id>") for task in tasks)
+        + ". Promote the next draft into plan.yaml or remove already-consumed drafts before validate-dev.",
+    )
+    print("Dev state OK: 0 unconsumed draft task(s)")
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/validate_harness.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+from harness_utils import load_lifecycle, load_phase_contracts, load_yaml, repo_path, require, require_paths, run_main
+
+
+def main() -> None:
+    required_files = [
+        "AGENTS.md",
+        "Makefile",
+        ".docs/INDEX.md",
+        ".codex/state/lifecycle.yaml",
+        ".codex/state/plan.yaml",
+        ".codex/state/plan.draft.yaml",
+        ".codex/state/memory.md",
+        ".codex/pjsdlc_managed/templates/PLAN_TEMPLATE.yaml",
+        ".codex/pjsdlc_managed/policies/phase_contracts.yaml",
+        ".codex/pjsdlc_managed/policies/gates.yaml",
+        ".codex/pjsdlc_managed/policies/allowed_paths.yaml",
+        ".codex/pjsdlc_managed/policies/risk_matrix.yaml",
+        "tools/build_doc_overviews.py",
+        "tools/validate_plan.py",
+    ]
+    required_dirs = [
+        ".docs/00_raw",
+        ".docs/01_product",
+        ".docs/02_architecture",
+        ".docs/03_tech_plan",
+        ".docs/04_implementation",
+        ".docs/05_decisions",
+        ".docs/06_review",
+        ".docs/07_test",
+        ".docs/08_release",
+        ".docs/rfc",
+        ".codex/skills",
+        "tools",
+    ]
+    require_paths(required_files + required_dirs)
+
+    lifecycle = load_lifecycle()
+    phases = load_phase_contracts()
+    load_yaml(".codex/pjsdlc_managed/policies/gates.yaml")
+    load_yaml(".codex/pjsdlc_managed/policies/allowed_paths.yaml")
+    load_yaml(".codex/pjsdlc_managed/policies/risk_matrix.yaml")
+
+    current_phase = lifecycle.get("current_phase")
+    require(current_phase in phases, f"Lifecycle current_phase is not declared: {current_phase}")
+
+    for phase_name, contract in phases.items():
+        skill = contract.get("skill")
+        require(skill, f"{phase_name} missing skill")
+        skill_file = repo_path(f".codex/skills/{skill}/SKILL.md")
+        require(skill_file.exists(), f"Missing skill file for {phase_name}: {skill_file.relative_to(repo_path('.'))}")
+        require("inputs" in contract, f"{phase_name} missing inputs")
+        require("outputs" in contract, f"{phase_name} missing outputs")
+        require("gates" in contract, f"{phase_name} missing gates")
+
+    print("Harness scaffold OK")
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/validate_plan.py

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+from harness_utils import (
+    make_arg_parser,
+    load_plan,
+    run_main,
+    validate_plan_contract,
+)
+
+
+def main() -> None:
+    parser = make_arg_parser("Validate plan.yaml shape and active task contract")
+    parser.add_argument("--allow-open", action="store_true", help="Allow open tasks while validating an in-progress workflow task")
+    args = parser.parse_args()
+
+    data = load_plan()
+    tasks = data.get("tasks", [])
+    validate_plan_contract(data, allow_open=args.allow_open)
+
+    suffix = "open tasks allowed" if args.allow_open else "none open"
+    print(f"Plan OK: {len(tasks)} active/future task(s), {suffix}")
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/validate_plan_draft.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+from harness_utils import load_plan, require, run_main, validate_task_shape
+
+
+def main() -> None:
+    data = load_plan(".codex/state/plan.draft.yaml")
+    require("current_phase" not in data, "plan.draft.yaml must not define current_phase; lifecycle.yaml is the single source for current_phase")
+    require("current_task_id" not in data, "plan.draft.yaml must not define current_task_id because drafts are not active task state")
+    tasks = data.get("tasks", [])
+    require(tasks, "plan.draft.yaml must contain at least one task before leaving ARCHITECTING")
+    for index, task in enumerate(tasks):
+        require(isinstance(task, dict), f"Task draft #{index + 1} must be a mapping")
+        validate_task_shape(task, index)
+        require(task.get("status") == "pending", f"Draft task {task.get('id')} should start as pending")
+    print(f"Task draft OK: {len(tasks)} task(s)")
+
+
+if __name__ == "__main__":
+    run_main(main)

package/assets/tools/validate_prd.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+from harness_utils import (
+    combined_text,
+    contains_any,
+    load_plan,
+    markdown_deliverables,
+    require,
+    run_main,
+    validate_plan_contract,
+)
+
+
+def main() -> None:
+    plan = load_plan()
+    validate_plan_contract(plan, allow_open=False)
+
+    docs = markdown_deliverables(".docs/01_product")
+    require(docs, "No PRD deliverables found in .docs/01_product/")
+    text = combined_text(docs)
+    require(contains_any(text, ["acceptance", "验收"]), "PRD must include acceptance criteria")
+    require(contains_any(text, ["out of scope", "out of scope", "不做", "边界"]), "PRD must include out-of-scope boundaries")
+    require(contains_any(text, ["open questions", "未决", "待确认"]), "PRD must include open questions")
+    print(f"PRD artifacts OK: {len(docs)} file(s)")
+
+
+if __name__ == "__main__":
+    run_main(main)