Nsfc Reviewers

# nsfc-reviewers 配置文件
# 版本号管理：本文件是版本信息的唯一来源（Single Source of Truth）

# 技能基本信息
skill_info:
  name: nsfc-reviewers
  version: 1.4.1
  description: "模拟领域专家视角对 NSFC 标书进行多维度评审，输出分级问题与可执行修改建议，并识别受资助额度限制的设计妥协"
  author: "Bensz Conan"
  category: writing

# 阶段性过会判断（默认写入报告）
stage_assessment:
  enabled: true
  include_in_report: true
  # 必须基于“当前版本若直接送审”进行判断，不允许假设后续还能修改
  judge_current_draft_only: true
  # 必须给出二元结论；如不确定，用 confidence 表达把握，不允许只写“边缘/不好说”
  require_binary_verdict: true
  confidence_levels: [高, 中, 低]
  stages:
    letter_review:
      name: 函评
      pass_label: 给过
      fail_label: 不给过
      key_checks:
        - 邻近领域专家能否在独立阅读中快速理解项目价值
        - 创新点、科学问题与技术路线是否能在首次通读时成立
        - 研究基础与申请人能力是否足以支撑“建议资助”判断
    panel_review:
      name: 会评
      pass_label: 给过
      fail_label: 不给过
      stricter_than_letter_review: true
      key_checks:
        - 项目是否具备相对竞争力，能在同场比较中进入前列
        - 核心亮点是否足够鲜明，能支撑专家讨论与投票
        - 现有短板是否会在会评讨论中被放大

# 资助额度约束识别（默认写入相关问题）
funding_context:
  enabled: true
  require_contextualized_judgement: true
  # 若无法识别项目类型/金额，默认保守处理：不硬套额度区间
  unknown_policy: conservative
  project_types:
    youth:
      labels: [青年基金, 青年项目, NSFC_Young, Young]
      typical_budget_wan_range: [30, 40]
      interpretation: 优先支持单一主问题与最小可行验证闭环，不宜按“大课题/平台型项目”标准苛责完整度
    general:
      labels: [面上项目, 面上, NSFC_General, General]
      typical_budget_wan_range: [50, 60]
      interpretation: 可支持较完整研究链条，但通常不足以覆盖大队列、多中心、全机制打通或重资产平台化设计
  report_requirements:
    - 当某项短板明显与资助额度约束有关时，必须显式标注“受资助额度限制”
    - 不得将受限妥协简单归因为申请人能力不足、视野不足或设计偷懒
    - 必须同时说明该受限设计在当前基金框架下的合理性边界
    - 必须补充“若资助不受限时的完整设计”作为对照，提醒用户理想完整版应包含什么

# 评审维度配置
review_dimensions:
  - id: innovation
    name: 创新性评价
    weight: 25
    key_points:
      - 科学问题的原创性和前沿性
      - 是否提出颠覆性假说或新视角
      - 是否存在"新瓶装旧酒"问题
      - 创新点是否明确可验证
    common_issues:
      - 创新性不足，仅是简单的方法移植
      - 科学问题过于简单，缺乏深度
      - 创新点表述模糊，难以评估

  - id: hypothesis
    name: 科学假说与科学问题
    weight: 20
    key_points:
      - 科学假说是否明确可检验
      - 科学问题是否清晰聚焦
      - 研究目标与科学问题是否一致
      - 假说的理论依据是否充分
    common_issues:
      - 科学假说太浅，没有资助价值
      - 科学问题不清晰，让评审专家猜测
      - 研究目标与假说脱节

  - id: methodology
    name: 研究方案与可行性
    weight: 20
    key_points:
      - 技术路线是否合理清晰
      - 研究方法是否先进可行
      - 关键科学问题的解决方案
      - 是否有备选方案应对风险
    common_issues:
      - 技术路线不清晰，逻辑混乱
      - 研究方法过于简单或过于复杂
      - 缺乏可行性分析
      - 没有考虑潜在风险和应对措施

  - id: foundation
    name: 研究基础
    weight: 15
    key_points:
      - 前期工作是否与本项目相关
      - 是否有支撑性的实验结果
      - 发表论文的质量和相关性
      - 申请人在该领域的积累
    common_issues:
      - 研究基础薄弱，没有相关实验结果
      - 前期工作与本项目关联性差
      - 缺乏高质量的相关论文支撑

  - id: team
    name: 研究团队
    weight: 10
    key_points:
      - 申请人的研究经历和能力
      - 团队成员的专业背景和分工
      - 团队协作能力
      - 是否具备完成项目的条件
    common_issues:
      - 团队成员专业背景与项目不匹配
      - 分工不明确
      - 缺乏关键技术人员

  - id: outcomes
    name: 预期成果与科学意义
    weight: 10
    key_points:
      - 预期成果是否明确可量化
      - 科学意义是否重要
      - 应用前景是否合理
      - 成果与投入是否匹配
    common_issues:
      - 预期成果过于宏大或过于保守
      - 科学意义阐述不清
      - 应用前景脱离实际

# 问题严重程度定义
severity_levels:
  P0:
    name: 致命问题
    description: 严重影响资助决策的问题，必须修改
    color: red
  P1:
    name: 重要问题
    description: 需要重点修改的问题
    color: orange
  P2:
    name: 建议改进
    description: 可以改进的细节问题
    color: yellow

# 评审等级定义
review_grades:
  excellent:
    name: 优
    description: 创新性强，科学意义重要，方案可行，基础扎实
    funding_suggestion: 优先资助
  good:
    name: 良
    description: 立意新颖，有一定科学意义，方案较好
    funding_suggestion: 可资助
  fair:
    name: 中
    description: 有一定研究价值，但存在明显不足
    funding_suggestion: 可资助（需重点修改后再评估）
  poor:
    name: 差
    description: 创新性不足或可行性差，不建议资助
    funding_suggestion: 不予资助

# 并行独立评审配置
parallel_review:
  # 是否启用并行评审模式
  enabled: true
  # 默认评审组数量（每组固定 7 位专家；默认取 3 组以平衡成本与共识稳定性）
  default_panel_count: 3
  # 最大评审组数量（超过 5 组通常收益递减、成本显著上升）
  max_panel_count: 5
  # parallel-vibe plan.threads[*].runner.type（评审任务推荐 claude）
  runner: claude
  # parallel-vibe plan.threads[*].runner.profile（default|fast|deep）
  runner_profile: deep
  # 超时时间（秒），0 表示不限时
  timeout_seconds: 0
  # 各组评审输出的文件名
  panel_output_filename: panel_review.md
  # 专家画像定义（仅参数；prompt 内容见 prompt_file 引用）
  reviewer_personas:
    - id: innovation_expert
      name: 学术前沿与创新性专家
      prompt_file: references/expert_01_innovation.md
      primary_dimensions: [innovation, hypothesis]
      secondary_dimensions: [outcomes]

    - id: methodology_expert
      name: 研究方法与可行性专家
      prompt_file: references/expert_02_methodology.md
      primary_dimensions: [methodology, outcomes]
      secondary_dimensions: [hypothesis]

    - id: foundation_expert
      name: 研究基础与团队评估专家
      prompt_file: references/expert_03_foundation.md
      primary_dimensions: [foundation, team]
      secondary_dimensions: [methodology]

    - id: critical_reviewer
      name: 严格综合评审专家
      prompt_file: references/expert_04_critical.md
      primary_dimensions: [innovation, methodology, hypothesis]
      secondary_dimensions: [foundation, team, outcomes]

    - id: constructive_reviewer
      name: 建设性评审专家
      prompt_file: references/expert_05_constructive.md
      primary_dimensions: [methodology, foundation, outcomes]
      secondary_dimensions: [innovation, hypothesis, team]

    - id: significance_reviewer
      name: 科学意义与领域影响专家
      prompt_file: references/expert_06_significance.md
      primary_dimensions: [innovation, outcomes]
      secondary_dimensions: [hypothesis, foundation]

    - id: clarity_reviewer
      name: 可读性与论证清晰度专家
      prompt_file: references/expert_07_clarity.md
      primary_dimensions: [hypothesis, methodology, team]
      secondary_dimensions: [innovation, outcomes, foundation]

  # 聚合策略
  aggregation:
    # 跨组共识阈值（0.0-1.0），默认 60% 以上组一致
    consensus_threshold: 0.6
    # 是否保留各专家原始评审意见作为附录
    keep_individual_reviews: true

# 输出设置
output_settings:
  default_filename: comments-from-nsfc-reviewers.md
  panel_dir: panels
  format: markdown
  # 是否将中间过程文件隐藏到 intermediate_dir（推荐开启，减少根目录噪声）
  hide_intermediate: true
  # 中间过程统一托管目录（相对 review 根目录，放置 parallel-vibe 环境、日志与快照）
  intermediate_dir: .bensz-api/skills/nsfc-reviewers
  # 是否强制执行“输出整理”阶段（强烈建议开启，保证并行环境/计划文件可追溯）
  enforce_output_finalization: true
  # 若检测到多组评审但未生成 intermediate_dir（或缺少 parallel-vibe 环境），是否发出警告
  warn_missing_intermediate: true
  # 校验级别：warn（仅警告）或 error（中断执行）
  validation_level: warn
  include_sections:
    - basic_info
    - stage_assessment
    - overall_evaluation
    - dimension_reviews
    - suggestions_summary
    - expert_comments

# 标书文件识别
proposal_files:
  # 常见的标书章节文件名模式
  patterns:
    - "*.tex"
    - "摘要*.tex"
    - "立项依据*.tex"
    - "研究内容*.tex"
    - "研究方案*.tex"
    - "研究基础*.tex"
    - "工作条件*.tex"
    - "特色与创新*.tex"
    - "研究计划*.tex"
  # 排除的文件
  exclude:
    - "preamble.tex"
    - "*.cls"
    - "*.sty"

# 维护与清理策略（供 scripts/cleanup_intermediate.py 使用）
maintenance:
  cleanup:
    # 仅清理 logs/ 下非 plans 的旧文件；plans 默认保留以便复现
    logs_max_age_days: 14
    keep_plans: true
    # snapshot 默认保留（通常较小且可追溯）
    keep_snapshot: true

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

import yaml


def _read_text(p: Path) -> str:
    return p.read_text(encoding="utf-8")


def _load_yaml(p: Path) -> dict:
    try:
        obj = yaml.safe_load(_read_text(p)) or {}
    except Exception as e:
        raise ValueError(f"failed to read yaml: {p}: {e}") from e
    if not isinstance(obj, dict):
        raise ValueError(f"expected yaml mapping: {p}")
    return obj


def _discover_parallel_vibe_config_path(skill_root: Path) -> Path | None:
    candidates = [
        Path.home() / ".claude" / "skills" / "parallel-vibe" / "config.yaml",
        Path.home() / ".codex" / "skills" / "parallel-vibe" / "config.yaml",
        # In-repo layout: skills/nsfc-reviewers and skills/parallel-vibe are siblings.
        skill_root.parent / "parallel-vibe" / "config.yaml",
    ]
    for p in candidates:
        try:
            if p.exists():
                return p
        except Exception:
            continue
    return None


def _thread_id_width(skill_root: Path) -> int:
    cfg_path = _discover_parallel_vibe_config_path(skill_root)
    if not cfg_path:
        return 3
    try:
        cfg = _load_yaml(cfg_path)
    except Exception:
        return 3
    defaults = cfg.get("defaults") if isinstance(cfg, dict) else None
    if not isinstance(defaults, dict):
        return 3
    w = defaults.get("thread_id_width", 3)
    try:
        w_i = int(w)
    except Exception:
        return 3
    return w_i if 1 <= w_i <= 6 else 3


def main(argv: list[str] | None = None) -> int:
    skill_root = Path(__file__).resolve().parents[1]
    cfg_path = skill_root / "config.yaml"
    if not cfg_path.exists():
        print(f"error: missing config.yaml at {cfg_path}", file=sys.stderr)
        return 2
    cfg = _load_yaml(cfg_path)
    pr = cfg.get("parallel_review") if isinstance(cfg, dict) else None
    if not isinstance(pr, dict):
        print("error: config.yaml missing parallel_review", file=sys.stderr)
        return 2

    p = argparse.ArgumentParser(prog="build_parallel_vibe_plan.py")
    p.add_argument("--panel-count", type=int, required=True, help="评审组数（= threads 数）")
    p.add_argument("--master-prompt-file", required=True, help="包含 master prompt 的文本文件路径（UTF-8）")
    p.add_argument("--out", required=True, help="输出 plan.json 路径")
    p.add_argument("--runner-type", default="", help="覆盖 config.yaml:parallel_review.runner（claude|codex|shell|local）")
    p.add_argument("--runner-profile", default="", help="覆盖 config.yaml:parallel_review.runner_profile（default|fast|deep）")
    p.add_argument("--runner-model", default="", help="显式指定 runner.model（留空表示使用 CLI 默认或 parallel-vibe config 映射）")
    p.add_argument(
        "--shell-cmd-template",
        default="",
        help="当 runner-type=shell 时必填：一条命令模板（必须包含 {prompt} 占位符）",
    )
    args = p.parse_args(argv)

    panel_count = int(args.panel_count)
    max_panels = int(pr.get("max_panel_count", 1) or 1)
    if panel_count < 1:
        print("error: --panel-count must be >= 1", file=sys.stderr)
        return 2
    if panel_count > max_panels:
        print(f"error: --panel-count must be <= {max_panels} (config.yaml:parallel_review.max_panel_count)", file=sys.stderr)
        return 2

    runner_type = str(args.runner_type or pr.get("runner") or "claude").strip().lower()
    if runner_type not in {"claude", "codex", "shell", "local"}:
        print("error: --runner-type must be one of claude|codex|shell|local", file=sys.stderr)
        return 2

    runner_profile = str(args.runner_profile or pr.get("runner_profile") or "default").strip().lower()
    if runner_profile not in {"default", "fast", "deep"}:
        print("error: --runner-profile must be one of default|fast|deep", file=sys.stderr)
        return 2

    panel_output_filename = str(pr.get("panel_output_filename") or "panel_review.md").strip()
    if not panel_output_filename:
        print("error: config.yaml:parallel_review.panel_output_filename is empty", file=sys.stderr)
        return 2

    prompt_path = Path(str(args.master_prompt_file)).expanduser()
    if not prompt_path.exists():
        print(f"error: master prompt file not found: {prompt_path}", file=sys.stderr)
        return 2
    master_prompt = _read_text(prompt_path).strip() + "\n"
    # Best-effort placeholder fill to keep the template/config consistent.
    master_prompt = master_prompt.replace("{panel_output_filename}", panel_output_filename)

    width = _thread_id_width(skill_root)
    threads: list[dict] = []
    for i in range(1, panel_count + 1):
        tid = str(i).zfill(width)
        runner_obj: dict = {
            "type": runner_type,
            "profile": runner_profile,
            "model": str(args.runner_model or "").strip(),
            "args": [],
        }
        if runner_type == "shell":
            tmpl = str(args.shell_cmd_template or "").strip()
            if not tmpl:
                print("error: --shell-cmd-template is required when --runner-type=shell", file=sys.stderr)
                return 2
            if "{prompt}" not in tmpl:
                print("error: --shell-cmd-template must contain a '{prompt}' placeholder", file=sys.stderr)
                return 2
            runner_obj["cmd_template"] = tmpl
        threads.append(
            {
                "thread_id": tid,
                "title": f"Panel G{tid}",
                "runner": runner_obj,
                "prompt": master_prompt,
            }
        )

    plan = {
        "plan_version": 1,
        "prompt": "nsfc-reviewers parallel panels",
        "threads": threads,
        "synthesis": {"enabled": False},
    }

    out_path = Path(str(args.out)).expanduser()
    out_path.parent.mkdir(parents=True, exist_ok=True)
    out_path.write_text(json.dumps(plan, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(str(out_path))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import shutil
import sys
import time
from pathlib import Path

import yaml


def _read_text(p: Path) -> str:
    return p.read_text(encoding="utf-8")


def _load_yaml(p: Path) -> dict:
    try:
        obj = yaml.safe_load(_read_text(p)) or {}
    except Exception as e:
        raise ValueError(f"failed to read yaml: {p}: {e}") from e
    if not isinstance(obj, dict):
        raise ValueError(f"expected yaml mapping: {p}")
    return obj


def _within(base: Path, child: Path) -> bool:
    try:
        child.resolve().relative_to(base.resolve())
        return True
    except Exception:
        return False


def _rm_tree(p: Path, *, apply: bool) -> None:
    if not p.exists():
        return
    if apply:
        shutil.rmtree(p)


def _rm_file(p: Path, *, apply: bool) -> None:
    if not p.exists():
        return
    if apply:
        p.unlink()


def _pr(msg: str) -> None:
    print(msg)


def main(argv: list[str] | None = None) -> int:
    skill_root = Path(__file__).resolve().parents[1]
    cfg_path = skill_root / "config.yaml"
    if not cfg_path.exists():
        print(f"error: missing config.yaml at {cfg_path}", file=sys.stderr)
        return 2
    cfg = _load_yaml(cfg_path)

    p = argparse.ArgumentParser(prog="cleanup_intermediate.py")
    p.add_argument("--review-path", required=True, help="评审会话目录（通常是标书目录或 review session 根目录）")
    p.add_argument(
        "--intermediate-dir",
        default="",
        help="覆盖 config.yaml:output_settings.intermediate_dir（默认 .bensz-api/skills/nsfc-reviewers）",
    )
    p.add_argument(
        "--logs-max-age-days",
        type=int,
        default=0,
        help="覆盖 config.yaml:maintenance.cleanup.logs_max_age_days；仅清理 logs/ 下非 plans 的旧文件",
    )
    p.add_argument(
        "--delete-parallel-vibe",
        action="store_true",
        help="删除 intermediate_dir 下的 parallel-vibe/、.parallel-vibe/ 与 legacy .parallel_vibe/（以及 review 根目录 legacy .parallel_vibe/，若存在）",
    )
    p.add_argument(
        "--delete-snapshot",
        action="store_true",
        help="删除 intermediate_dir 下的 snapshot/（默认保留以便追溯）",
    )
    p.add_argument(
        "--apply",
        action="store_true",
        help="实际执行删除操作（默认仅输出将要执行的动作）",
    )
    args = p.parse_args(argv)

    review_root = Path(str(args.review_path)).expanduser().resolve()
    if not review_root.exists() or not review_root.is_dir():
        print(f"error: review path is not a directory: {review_root}", file=sys.stderr)
        return 2

    os_cfg = cfg.get("output_settings") if isinstance(cfg, dict) else None
    os_cfg = os_cfg if isinstance(os_cfg, dict) else {}
    intermediate_dir_name = str(
        args.intermediate_dir or os_cfg.get("intermediate_dir") or ".bensz-api/skills/nsfc-reviewers"
    ).strip()
    if not intermediate_dir_name:
        print("error: intermediate_dir is empty", file=sys.stderr)
        return 2
    p_intermediate = Path(intermediate_dir_name)
    if p_intermediate.is_absolute() or ".." in p_intermediate.parts:
        print(f"error: intermediate_dir must be a relative name without '..': {intermediate_dir_name!r}", file=sys.stderr)
        return 2
    intermediate_root = (review_root / intermediate_dir_name).resolve()
    if not _within(review_root, intermediate_root):
        print(
            f"error: intermediate_dir escapes review root: review_root={review_root} intermediate_root={intermediate_root}",
            file=sys.stderr,
        )
        return 2

    m_cfg = cfg.get("maintenance") if isinstance(cfg, dict) else None
    m_cfg = m_cfg if isinstance(m_cfg, dict) else {}
    c_cfg = m_cfg.get("cleanup") if isinstance(m_cfg, dict) else None
    c_cfg = c_cfg if isinstance(c_cfg, dict) else {}
    logs_max_age_days = int(args.logs_max_age_days or c_cfg.get("logs_max_age_days") or 14)
    keep_plans = bool(c_cfg.get("keep_plans", True))

    apply = bool(args.apply)
    mode = "APPLY" if apply else "DRY-RUN"
    _pr(f"[cleanup_intermediate] mode={mode}")
    _pr(f"[cleanup_intermediate] review_root={review_root}")
    _pr(f"[cleanup_intermediate] intermediate_root={intermediate_root}")

    if not intermediate_root.exists():
        _pr(f"[cleanup_intermediate] skip: intermediate_root not found: {intermediate_root}")
        return 0

    # 1) parallel-vibe environment cleanup (optional)
    if args.delete_parallel_vibe:
        candidates = [
            intermediate_root / "parallel-vibe",
            intermediate_root / ".parallel-vibe",
            intermediate_root / ".parallel_vibe",
            review_root / ".parallel-vibe",
            review_root / ".parallel_vibe",
        ]
        for d in candidates:
            if not d.exists():
                continue
            if not _within(review_root, d):
                print(f"error: refusing to delete outside review_root: {d}", file=sys.stderr)
                return 2
            _pr(f"[cleanup_intermediate] delete dir: {d}")
            _rm_tree(d, apply=apply)

    # 2) logs cleanup (age-based, keep logs/plans by default)
    logs_dir = intermediate_root / "logs"
    plans_dir = logs_dir / "plans"
    if logs_dir.exists():
        cutoff = time.time() - (max(0, logs_max_age_days) * 86400)
        _pr(f"[cleanup_intermediate] logs_max_age_days={logs_max_age_days} cutoff_epoch={int(cutoff)} keep_plans={keep_plans}")

        to_delete: list[Path] = []
        for f in logs_dir.rglob("*"):
            if not f.is_file():
                continue
            if keep_plans and plans_dir.exists():
                try:
                    f.resolve().relative_to(plans_dir.resolve())
                    continue
                except Exception:
                    pass
            try:
                st = f.stat()
            except Exception:
                continue
            if st.st_mtime < cutoff:
                to_delete.append(f)

        for f in sorted(to_delete):
            if not _within(review_root, f):
                print(f"error: refusing to delete outside review_root: {f}", file=sys.stderr)
                return 2
            _pr(f"[cleanup_intermediate] delete file: {f}")
            _rm_file(f, apply=apply)

    # 3) snapshot cleanup (optional)
    snapshot_dir = intermediate_root / "snapshot"
    if args.delete_snapshot and snapshot_dir.exists():
        if not _within(review_root, snapshot_dir):
            print(f"error: refusing to delete outside review_root: {snapshot_dir}", file=sys.stderr)
            return 2
        _pr(f"[cleanup_intermediate] delete dir: {snapshot_dir}")
        _rm_tree(snapshot_dir, apply=apply)

    _pr("[cleanup_intermediate] done")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import shutil
import sys
from pathlib import Path

import yaml


def _read_text(p: Path) -> str:
    return p.read_text(encoding="utf-8")


def _load_yaml(p: Path) -> dict:
    try:
        obj = yaml.safe_load(_read_text(p)) or {}
    except Exception as e:
        raise ValueError(f"failed to read yaml: {p}: {e}") from e
    if not isinstance(obj, dict):
        raise ValueError(f"expected yaml mapping: {p}")
    return obj


def _within(base: Path, child: Path) -> bool:
    try:
        child.resolve().relative_to(base.resolve())
        return True
    except Exception:
        return False


def _pr(msg: str) -> None:
    print(msg)


def _warn(msg: str) -> None:
    print(f"warning: {msg}", file=sys.stderr)


def _err(msg: str) -> None:
    print(f"error: {msg}", file=sys.stderr)


def _ensure_relative_dir_path(name: str, *, label: str) -> str:
    n = str(name or "").strip()
    if not n:
        raise ValueError(f"{label} is empty")
    p = Path(n)
    if p.is_absolute() or ".." in p.parts:
        raise ValueError(f"{label} must be a relative name without '..': {n!r}")
    return n


def _ensure_dir(p: Path, *, apply: bool) -> None:
    if p.exists():
        return
    _pr(f"[finalize_output] mkdir -p {p}")
    if apply:
        p.mkdir(parents=True, exist_ok=True)


def _move_children(src: Path, dest_dir: Path, *, apply: bool, review_root: Path) -> None:
    if not src.exists() or not src.is_dir():
        return
    if not _within(review_root, src):
        raise ValueError(f"refusing to move from outside review_root: {src}")

    for child in sorted(src.iterdir()):
        dest = dest_dir / child.name
        if dest.exists():
            _warn(f"skip move (dest exists): {child} -> {dest}")
            continue
        if not _within(review_root, dest):
            raise ValueError(f"refusing to move to outside review_root: {dest}")
        _pr(f"[finalize_output] move: {child} -> {dest}")
        if apply:
            shutil.move(str(child), str(dest))

    # Clean up the now-empty directory (best-effort).
    try:
        if apply:
            src.rmdir()
            _pr(f"[finalize_output] rmdir: {src}")
    except Exception:
        pass


def _stage_file(
    src: Path,
    dest: Path,
    *,
    apply: bool,
    review_root: Path,
    mode: str,
) -> None:
    if not src.exists() or not src.is_file():
        return
    if not _within(review_root, src):
        # Allow staging from outside review_root (copy-only), but still keep destination under review_root.
        if mode == "move":
            mode = "copy"
    if not _within(review_root, dest):
        raise ValueError(f"refusing to stage to outside review_root: {dest}")
    if dest.exists():
        _warn(f"skip {mode} (dest exists): {dest}")
        return

    dest.parent.mkdir(parents=True, exist_ok=True) if apply else None
    _pr(f"[finalize_output] {mode}: {src} -> {dest}")
    if not apply:
        return
    if mode == "move":
        shutil.move(str(src), str(dest))
    else:
        shutil.copy2(str(src), str(dest))


def _stage_dir(src: Path, dest_dir: Path, *, apply: bool, review_root: Path) -> None:
    if not src.exists() or not src.is_dir():
        return
    if not _within(review_root, src):
        raise ValueError(f"refusing to move dir from outside review_root: {src}")
    dest = dest_dir / src.name
    if dest.exists():
        _warn(f"skip move dir (dest exists): {src} -> {dest}")
        return
    if not _within(review_root, dest):
        raise ValueError(f"refusing to move dir to outside review_root: {dest}")
    _pr(f"[finalize_output] move dir: {src} -> {dest}")
    if apply:
        shutil.move(str(src), str(dest))


def _discover_parallel_vibe_roots(review_root: Path, intermediate_root: Path, extra: Path | None) -> list[Path]:
    roots: list[Path] = []
    candidates = [
        intermediate_root / ".parallel-vibe",
        intermediate_root / ".parallel_vibe",
        review_root / ".parallel-vibe",
        review_root / ".parallel_vibe",
    ]
    if extra:
        if extra.is_dir() and extra.name in {".parallel-vibe", ".parallel_vibe"}:
            candidates.append(extra)
        elif extra.is_dir() and (extra / ".parallel-vibe").exists():
            candidates.append(extra / ".parallel-vibe")
        elif extra.is_dir() and (extra / ".parallel_vibe").exists():
            candidates.append(extra / ".parallel_vibe")
        else:
            candidates.append(extra)
    for p in candidates:
        try:
            if p.exists() and p.is_dir() and p.name in {".parallel-vibe", ".parallel_vibe"}:
                roots.append(p)
        except Exception:
            continue
    # De-dup (resolve is best-effort; keep stable order).
    seen: set[str] = set()
    out: list[Path] = []
    for p in roots:
        key = str(p.resolve()) if p.exists() else str(p)
        if key in seen:
            continue
        seen.add(key)
        out.append(p)
    return out


def main(argv: list[str] | None = None) -> int:
    skill_root = Path(__file__).resolve().parents[1]
    cfg_path = skill_root / "config.yaml"
    if not cfg_path.exists():
        _err(f"missing config.yaml at {cfg_path}")
        return 2
    try:
        cfg = _load_yaml(cfg_path)
    except Exception as e:
        _err(str(e))
        return 2

    os_cfg = cfg.get("output_settings") if isinstance(cfg, dict) else None
    os_cfg = os_cfg if isinstance(os_cfg, dict) else {}
    default_intermediate = str(os_cfg.get("intermediate_dir") or ".bensz-api/skills/nsfc-reviewers")
    default_panel_dir = str(os_cfg.get("panel_dir") or "panels")
    default_filename = str(os_cfg.get("default_filename") or "comments-from-nsfc-reviewers.md")
    warn_missing_intermediate = bool(os_cfg.get("warn_missing_intermediate", True))
    cfg_validation_level = str(os_cfg.get("validation_level") or "warn").strip().lower()

    p = argparse.ArgumentParser(prog="finalize_output.py")
    p.add_argument("--review-path", required=True, help="标书目录 / 本次评审会话根目录（交付文件所在目录）")
    p.add_argument("--panel-count", type=int, default=1, help="本次评审组数（用于校验并行产物是否齐全）")
    p.add_argument(
        "--intermediate-dir",
        default=default_intermediate,
        help="覆盖 config.yaml:output_settings.intermediate_dir（默认 .bensz-api/skills/nsfc-reviewers）",
    )
    p.add_argument(
        "--master-prompt-file",
        default="",
        help="可选：master prompt 文本文件路径；若提供则会归档到 logs/master_prompt.txt（优先 copy，必要时 move）",
    )
    p.add_argument(
        "--plan-file",
        default="",
        help="可选：plan.json 路径；若提供则会归档到 logs/plans/（优先 copy，必要时 move）",
    )
    p.add_argument(
        "--parallel-vibe-path",
        default="",
        help="可选：额外的 .parallel-vibe/ 或 legacy .parallel_vibe/ 位置；可指向目录本身或其父目录",
    )
    p.add_argument(
        "--validation-level",
        default="",
        help="覆盖 config.yaml:output_settings.validation_level（warn|error）",
    )
    p.add_argument("--apply", action="store_true", help="实际执行移动/复制（默认仅 DRY-RUN）")
    args = p.parse_args(argv)

    apply = bool(args.apply)
    mode = "APPLY" if apply else "DRY-RUN"
    review_root = Path(str(args.review_path)).expanduser().resolve()
    if not review_root.exists() or not review_root.is_dir():
        _err(f"review path is not a directory: {review_root}")
        return 2

    try:
        intermediate_dir_name = _ensure_relative_dir_path(str(args.intermediate_dir), label="--intermediate-dir")
        panel_dir_name = _ensure_relative_dir_path(default_panel_dir, label="config.yaml:output_settings.panel_dir")
    except Exception as e:
        _err(str(e))
        return 2

    validation_level = str(args.validation_level or cfg_validation_level or "warn").strip().lower()
    if validation_level not in {"warn", "error"}:
        _err("--validation-level must be warn|error")
        return 2

    intermediate_root = (review_root / intermediate_dir_name).resolve()
    if not _within(review_root, intermediate_root):
        _err(f"intermediate_dir escapes review root: review_root={review_root} intermediate_root={intermediate_root}")
        return 2

    _pr(f"[finalize_output] mode={mode}")
    _pr(f"[finalize_output] review_root={review_root}")
    _pr(f"[finalize_output] intermediate_root={intermediate_root}")

    # 1) Create the standard intermediate directory structure.
    _ensure_dir(intermediate_root / "parallel-vibe", apply=apply)
    _ensure_dir(intermediate_root / "logs" / "plans", apply=apply)
    _ensure_dir(intermediate_root / "snapshot", apply=apply)

    # 2) Move/collect parallel-vibe environment(s) into intermediate_root/parallel-vibe/
    extra_parallel = Path(str(args.parallel_vibe_path)).expanduser().resolve() if str(args.parallel_vibe_path).strip() else None
    pv_roots = _discover_parallel_vibe_roots(review_root, intermediate_root, extra_parallel)
    for src in pv_roots:
        _pr(f"[finalize_output] collect parallel-vibe env from: {src}")
        _move_children(src, intermediate_root / "parallel-vibe", apply=apply, review_root=review_root)

    # 3) Snapshot (legacy)
    _stage_dir(review_root / "proposal_snapshot", intermediate_root / "snapshot", apply=apply, review_root=review_root)

    # 4) Logs: master prompt + plan files
    # master prompt: prefer explicit, else legacy review_root/master_prompt.txt
    mp_src = Path(str(args.master_prompt_file)).expanduser().resolve() if str(args.master_prompt_file).strip() else None
    if not mp_src:
        mp_src = (review_root / "master_prompt.txt") if (review_root / "master_prompt.txt").exists() else None
    if mp_src:
        _stage_file(
            mp_src,
            intermediate_root / "logs" / "master_prompt.txt",
            apply=apply,
            review_root=review_root,
            mode="move",
        )

    # plan file: explicit single file + auto-discovery of review_root/plan*.json
    plan_src = Path(str(args.plan_file)).expanduser().resolve() if str(args.plan_file).strip() else None
    if plan_src and plan_src.exists():
        _stage_file(
            plan_src,
            intermediate_root / "logs" / "plans" / plan_src.name,
            apply=apply,
            review_root=review_root,
            mode="move",
        )
    for f in sorted(review_root.glob("plan*.json")):
        # Avoid double-staging an explicit plan file.
        if plan_src and f.resolve() == plan_src.resolve():
            continue
        _stage_file(
            f,
            intermediate_root / "logs" / "plans" / f.name,
            apply=apply,
            review_root=review_root,
            mode="move",
        )

    # 5) Validations (warn by default; error if configured).
    warnings: list[str] = []

    panel_count = int(args.panel_count or 1)
    pv_dest = intermediate_root / "parallel-vibe"
    has_parallel_env = pv_dest.exists() and any(pv_dest.iterdir())
    parallel_root_exists = any(
        p.exists()
        for p in (
            review_root / ".parallel-vibe",
            intermediate_root / ".parallel-vibe",
            review_root / ".parallel_vibe",
            intermediate_root / ".parallel_vibe",
        )
    )
    any_parallel_seen = has_parallel_env or parallel_root_exists

    # In DRY-RUN, source parallel-vibe roots are expected to remain; only warn when nothing is found at all.
    if panel_count > 1 and warn_missing_intermediate and (not any_parallel_seen):
        warnings.append(f"panel_count={panel_count} but no parallel-vibe env found (.parallel-vibe missing)")

    if warn_missing_intermediate:
        if not (intermediate_root / "logs").exists() and apply:
            warnings.append(f"missing logs dir after apply: {intermediate_root / 'logs'}")

    final_report = review_root / default_filename
    if not final_report.exists():
        warnings.append(f"final report not found (expected): {final_report}")

    panels_dir = review_root / panel_dir_name
    if panel_count > 1:
        if not panels_dir.exists():
            warnings.append(f"panels dir not found (expected): {panels_dir}")
        else:
            has_panel_files = any(p.name.startswith("G") and p.suffix.lower() == ".md" for p in panels_dir.iterdir() if p.is_file())
            if not has_panel_files:
                warnings.append(f"panels dir has no G*.md files: {panels_dir}")

    for w in warnings:
        _warn(w)

    if warnings and validation_level == "error":
        return 3

    _pr("[finalize_output] done")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import fnmatch
import sys
from pathlib import Path

import yaml


def _read_text(p: Path) -> str:
    return p.read_text(encoding="utf-8")


def _load_yaml(p: Path) -> dict:
    try:
        obj = yaml.safe_load(_read_text(p)) or {}
    except Exception as e:
        raise ValueError(f"failed to read yaml: {p}: {e}") from e
    if not isinstance(obj, dict):
        raise ValueError(f"expected yaml mapping: {p}")
    return obj


def _is_safe_relpath(p: Path) -> bool:
    if p.is_absolute():
        return False
    # Reject any ".." segment to keep path derivations predictable.
    return ".." not in p.parts


def _load_discovery_config(cfg: dict) -> tuple[list[str], list[str], str, str]:
    pf = cfg.get("proposal_files") if isinstance(cfg, dict) else None
    pf = pf if isinstance(pf, dict) else {}
    patterns = pf.get("patterns") or []
    exclude = pf.get("exclude") or []

    if not isinstance(patterns, list) or not all(isinstance(x, str) for x in patterns):
        raise ValueError("config.yaml: proposal_files.patterns must be a list of strings")
    if not isinstance(exclude, list) or not all(isinstance(x, str) for x in exclude):
        raise ValueError("config.yaml: proposal_files.exclude must be a list of strings")

    os_cfg = cfg.get("output_settings") if isinstance(cfg, dict) else None
    os_cfg = os_cfg if isinstance(os_cfg, dict) else {}
    panel_dir = str(os_cfg.get("panel_dir") or "panels").strip()
    intermediate_dir = str(os_cfg.get("intermediate_dir") or ".bensz-api/skills/nsfc-reviewers").strip()
    if not panel_dir or not intermediate_dir:
        raise ValueError("config.yaml: output_settings.panel_dir/intermediate_dir must be non-empty")

    return patterns, exclude, panel_dir, intermediate_dir


def _should_skip_path(
    *,
    rel: Path,
    panel_dir: str,
    intermediate_dir: str,
) -> bool:
    # Skip any file that is under intermediate outputs / final panels / legacy parallel-vibe roots.
    intermediate_parts = tuple(Path(intermediate_dir).parts)
    if intermediate_parts and rel.parts[: len(intermediate_parts)] == intermediate_parts:
        return True

    skip_dir_names = {
        panel_dir,
        intermediate_dir,
        ".bensz-api",
        ".nsfc-reviewers",
        "parallel-vibe",
        ".parallel-vibe",
        ".parallel_vibe",
        ".parallel_vibe".lstrip("."),  # defensive; unlikely
        ".parallel_vibe".strip("/"),
    }
    for part in rel.parts[:-1]:
        if part in skip_dir_names:
            return True
    return False


def _matches_exclude(rel: Path, excludes: list[str]) -> bool:
    rel_posix = rel.as_posix()
    name = rel.name
    for pat in excludes:
        if fnmatch.fnmatch(name, pat) or fnmatch.fnmatch(rel_posix, pat):
            return True
    return False


def main(argv: list[str] | None = None) -> int:
    skill_root = Path(__file__).resolve().parents[1]
    cfg_path = skill_root / "config.yaml"
    if not cfg_path.exists():
        print(f"error: missing config.yaml at {cfg_path}", file=sys.stderr)
        return 2
    cfg = _load_yaml(cfg_path)
    try:
        patterns, excludes, panel_dir, intermediate_dir = _load_discovery_config(cfg)
    except Exception as e:
        print(f"error: {e}", file=sys.stderr)
        return 2

    p = argparse.ArgumentParser(prog="list_proposal_files.py")
    p.add_argument("--proposal-path", required=True, help="标书目录或单个 .tex 文件路径")
    p.add_argument(
        "--max-files",
        type=int,
        default=0,
        help="最多允许输出的文件数（0 表示不限制）；超限则退出码=3 并提示 count",
    )
    p.add_argument("--json", action="store_true", help="以 JSON 数组输出（默认逐行输出）")
    args = p.parse_args(argv)

    proposal_path = Path(str(args.proposal_path)).expanduser().resolve()
    if not proposal_path.exists():
        print(f"error: path not found: {proposal_path}", file=sys.stderr)
        return 2

    files: set[Path] = set()
    if proposal_path.is_file():
        if proposal_path.suffix.lower() != ".tex":
            print(f"error: proposal file must be a .tex file, got: {proposal_path.name}", file=sys.stderr)
            return 2
        files.add(proposal_path)
    else:
        # Recursive discovery (rglob) is more robust than only scanning the root.
        for pat in patterns:
            for f in proposal_path.rglob(pat):
                if not f.is_file():
                    continue
                if f.suffix.lower() != ".tex":
                    continue
                try:
                    rel = f.resolve().relative_to(proposal_path)
                except Exception:
                    continue
                if _should_skip_path(rel=rel, panel_dir=panel_dir, intermediate_dir=intermediate_dir):
                    continue
                if _matches_exclude(rel, excludes):
                    continue
                files.add(f.resolve())

    out = sorted(files)
    if args.max_files and len(out) > int(args.max_files):
        print(f"error: too many tex files: {len(out)} (max={args.max_files})", file=sys.stderr)
        return 3

    if args.json:
        import json

        print(json.dumps([str(p) for p in out], ensure_ascii=False, indent=2))
    else:
        for f in out:
            print(str(f))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
from __future__ import annotations

import re
import sys
from pathlib import Path

import yaml


def _read_text(p: Path) -> str:
    return p.read_text(encoding="utf-8")


def _parse_frontmatter(md_text: str) -> dict:
    if not md_text.startswith("---\n"):
        raise ValueError("SKILL.md must start with YAML frontmatter ('---')")
    m = re.match(r"\A---\n(.*?)\n---\n", md_text, flags=re.DOTALL)
    if not m:
        raise ValueError("SKILL.md YAML frontmatter must be closed by a second '---' line")
    return yaml.safe_load(m.group(1)) or {}


def main() -> int:
    # scripts/*.py -> skill root
    skill_root = Path(__file__).resolve().parents[1]
    config_path = skill_root / "config.yaml"
    skill_md_path = skill_root / "SKILL.md"
    readme_path = skill_root / "README.md"

    errors: list[str] = []

    if not config_path.exists():
        errors.append(f"Missing {config_path}")
        return _finish(errors)
    if not skill_md_path.exists():
        errors.append(f"Missing {skill_md_path}")
        return _finish(errors)

    cfg = yaml.safe_load(_read_text(config_path)) or {}
    cfg_skill = (cfg.get("skill_info") or {}) if isinstance(cfg, dict) else {}
    cfg_name = cfg_skill.get("name")
    cfg_ver = cfg_skill.get("version")

    if cfg_name != "nsfc-reviewers":
        errors.append(f"config.yaml: skill_info.name expected 'nsfc-reviewers', got {cfg_name!r}")
    if not cfg_ver:
        errors.append("config.yaml: missing skill_info.version")

    _validate_skill_info(cfg, errors)

    skill_md_text = _read_text(skill_md_path)
    fm = _parse_frontmatter(skill_md_text)
    fm_name = fm.get("name")
    if fm_name != cfg_name:
        errors.append(
            f"SKILL.md frontmatter: name {fm_name!r} does not match config.yaml skill_info.name {cfg_name!r}"
        )

    kw = ((fm.get("metadata") or {}).get("keywords") or []) if isinstance(fm, dict) else []
    if not isinstance(kw, list):
        errors.append("SKILL.md frontmatter: metadata.keywords must be a list")
    else:
        if not (3 <= len(kw) <= 5):
            errors.append(f"SKILL.md frontmatter: metadata.keywords should be 3-5 items, got {len(kw)}")

    # Generality checks for user-facing docs
    for p in [skill_md_path, readme_path]:
        if not p.exists():
            continue
        t = _read_text(p)
        if "/Users/" in t:
            errors.append(f"{p.name}: contains a personal path '/Users/'")
        if re.search(r"\b20\d{2}-\d{2}-\d{2}\b", t):
            errors.append(f"{p.name}: contains a concrete date (use placeholders like YYYY-MM-DD in examples)")

    # SKILL.md length guardrail
    skill_lines = skill_md_text.count("\n") + 1
    if skill_lines > 500:
        errors.append(f"SKILL.md too long: {skill_lines} lines (> 500)")

    # Version should not be hardcoded in SKILL/README
    if cfg_ver:
        for p in [skill_md_path, readme_path]:
            if p.exists() and str(cfg_ver) in _read_text(p):
                errors.append(f"{p.name}: hardcodes version {cfg_ver} (should only live in config.yaml)")

    _validate_output_settings(cfg, errors)
    _validate_stage_assessment(cfg, errors)
    _validate_funding_context(cfg, errors)
    _validate_parallel_review(cfg, skill_root, errors)
    _validate_scripts(skill_root, errors)
    _validate_references(skill_root, errors)
    _validate_docs_consistency(cfg, skill_md_text, _read_text(readme_path) if readme_path.exists() else "", errors)

    return _finish(errors)


def _validate_skill_info(cfg: dict, errors: list[str]) -> None:
    skill = cfg.get("skill_info") if isinstance(cfg, dict) else None
    if not isinstance(skill, dict):
        errors.append("config.yaml: missing skill_info (dict)")
        return

    category = str(skill.get("category") or "").strip()
    if category not in {"writing", "development", "normal"}:
        errors.append("config.yaml: skill_info.category must be one of writing|development|normal")

    description = str(skill.get("description") or "")
    if not description:
        errors.append("config.yaml: skill_info.description is empty")


def _validate_parallel_review(cfg: dict, skill_root: Path, errors: list[str]) -> None:
    pr = cfg.get("parallel_review") if isinstance(cfg, dict) else None
    if not isinstance(pr, dict):
        errors.append("config.yaml: missing parallel_review (dict)")
        return

    for k in ["default_panel_count", "max_panel_count", "panel_output_filename", "runner", "runner_profile", "timeout_seconds"]:
        if k not in pr:
            errors.append(f"config.yaml: parallel_review missing {k}")

    default_panel_count = pr.get("default_panel_count")
    max_panel_count = pr.get("max_panel_count")
    if not isinstance(default_panel_count, int) or default_panel_count < 1:
        errors.append("config.yaml: parallel_review.default_panel_count must be an integer >= 1")
    if not isinstance(max_panel_count, int) or max_panel_count < 1:
        errors.append("config.yaml: parallel_review.max_panel_count must be an integer >= 1")
    if isinstance(default_panel_count, int) and isinstance(max_panel_count, int) and default_panel_count > max_panel_count:
        errors.append("config.yaml: parallel_review.default_panel_count must be <= max_panel_count")

    if "default_reviewer_count" in pr or "max_reviewer_count" in pr or "thread_output_filename" in pr:
        errors.append("config.yaml: parallel_review still contains old reviewer_count/thread_output_filename fields")

    rp = str(pr.get("runner_profile") or "").strip().lower()
    if rp and rp not in {"default", "fast", "deep"}:
        errors.append("config.yaml: parallel_review.runner_profile must be one of default|fast|deep")

    agg = pr.get("aggregation")
    if not isinstance(agg, dict):
        errors.append("config.yaml: parallel_review.aggregation missing (dict)")
    else:
        ct = agg.get("consensus_threshold")
        if not isinstance(ct, (int, float)) or not (0.0 < float(ct) <= 1.0):
            errors.append("config.yaml: parallel_review.aggregation.consensus_threshold must be in (0, 1]")

    personas = pr.get("reviewer_personas")
    if not isinstance(personas, list) or len(personas) != 7:
        errors.append("config.yaml: parallel_review.reviewer_personas must be a list of 7 personas")
        return

    for i, persona in enumerate(personas):
        if not isinstance(persona, dict):
            errors.append(f"config.yaml: reviewer_personas[{i}] must be a dict")
            continue
        if "style" in persona:
            errors.append(f"config.yaml: reviewer_personas[{i}] must not contain inline prompt field 'style'")
        pf = persona.get("prompt_file")
        if not pf or not isinstance(pf, str):
            errors.append(f"config.yaml: reviewer_personas[{i}] missing prompt_file")
            continue
        p = (skill_root / pf).resolve()
        try:
            p.relative_to(skill_root.resolve())
        except Exception:
            errors.append(f"config.yaml: reviewer_personas[{i}].prompt_file points outside skill root: {pf!r}")
            continue
        if not p.exists():
            errors.append(f"config.yaml: reviewer_personas[{i}].prompt_file not found: {pf!r}")


def _validate_output_settings(cfg: dict, errors: list[str]) -> None:
    os_cfg = cfg.get("output_settings") if isinstance(cfg, dict) else None
    if not isinstance(os_cfg, dict):
        errors.append("config.yaml: missing output_settings (dict)")
        return

    for k in ["default_filename", "panel_dir", "hide_intermediate", "intermediate_dir"]:
        if k not in os_cfg:
            errors.append(f"config.yaml: output_settings missing {k}")
    if not str(os_cfg.get("default_filename") or "").strip():
        errors.append("config.yaml: output_settings.default_filename is empty")
    panel_dir = str(os_cfg.get("panel_dir") or "").strip()
    if not panel_dir:
        errors.append("config.yaml: output_settings.panel_dir is empty")
    intermediate_dir = str(os_cfg.get("intermediate_dir") or "").strip()
    if not intermediate_dir:
        errors.append("config.yaml: output_settings.intermediate_dir is empty")

    # Keep these as simple directory names to avoid path surprises.
    for label, val in [("panel_dir", panel_dir), ("intermediate_dir", intermediate_dir)]:
        if not val:
            continue
        if Path(val).is_absolute():
            errors.append(f"config.yaml: output_settings.{label} must be a relative name, got an absolute path: {val!r}")
            continue
        if ".." in Path(val).parts:
            errors.append(f"config.yaml: output_settings.{label} must not contain '..': {val!r}")
            continue
        if len(Path(val).parts) != 1:
            errors.append(f"config.yaml: output_settings.{label} should be a single directory name (no slashes): {val!r}")

    # Optional-but-recommended validation knobs for deterministic output finalization.
    if "enforce_output_finalization" in os_cfg and not isinstance(os_cfg.get("enforce_output_finalization"), bool):
        errors.append("config.yaml: output_settings.enforce_output_finalization must be a bool")
    if "warn_missing_intermediate" in os_cfg and not isinstance(os_cfg.get("warn_missing_intermediate"), bool):
        errors.append("config.yaml: output_settings.warn_missing_intermediate must be a bool")
    if "validation_level" in os_cfg:
        vl = str(os_cfg.get("validation_level") or "").strip().lower()
        if vl and vl not in {"warn", "error"}:
            errors.append("config.yaml: output_settings.validation_level must be warn|error")


def _validate_stage_assessment(cfg: dict, errors: list[str]) -> None:
    sa = cfg.get("stage_assessment") if isinstance(cfg, dict) else None
    if not isinstance(sa, dict):
        errors.append("config.yaml: missing stage_assessment (dict)")
        return

    for k in ["enabled", "include_in_report", "judge_current_draft_only", "require_binary_verdict", "confidence_levels", "stages"]:
        if k not in sa:
            errors.append(f"config.yaml: stage_assessment missing {k}")

    for k in ["enabled", "include_in_report", "judge_current_draft_only", "require_binary_verdict"]:
        if k in sa and not isinstance(sa.get(k), bool):
            errors.append(f"config.yaml: stage_assessment.{k} must be a bool")

    cls = sa.get("confidence_levels")
    if not isinstance(cls, list) or [str(x) for x in cls] != ["高", "中", "低"]:
        errors.append("config.yaml: stage_assessment.confidence_levels must be ['高', '中', '低']")

    stages = sa.get("stages")
    if not isinstance(stages, dict):
        errors.append("config.yaml: stage_assessment.stages must be a dict")
        return

    for stage_id in ["letter_review", "panel_review"]:
        stage = stages.get(stage_id)
        if not isinstance(stage, dict):
            errors.append(f"config.yaml: stage_assessment.stages.{stage_id} must be a dict")
            continue
        for k in ["name", "pass_label", "fail_label", "key_checks"]:
            if k not in stage:
                errors.append(f"config.yaml: stage_assessment.stages.{stage_id} missing {k}")
        if stage.get("pass_label") != "给过" or stage.get("fail_label") != "不给过":
            errors.append(f"config.yaml: stage_assessment.stages.{stage_id} must use pass_label=给过 and fail_label=不给过")
        kc = stage.get("key_checks")
        if not isinstance(kc, list) or len(kc) < 2:
            errors.append(f"config.yaml: stage_assessment.stages.{stage_id}.key_checks must be a list with at least 2 items")


def _validate_funding_context(cfg: dict, errors: list[str]) -> None:
    fc = cfg.get("funding_context") if isinstance(cfg, dict) else None
    if not isinstance(fc, dict):
        errors.append("config.yaml: missing funding_context (dict)")
        return

    for k in ["enabled", "require_contextualized_judgement", "unknown_policy", "project_types", "report_requirements"]:
        if k not in fc:
            errors.append(f"config.yaml: funding_context missing {k}")

    for k in ["enabled", "require_contextualized_judgement"]:
        if k in fc and not isinstance(fc.get(k), bool):
            errors.append(f"config.yaml: funding_context.{k} must be a bool")

    unknown_policy = str(fc.get("unknown_policy") or "").strip().lower()
    if unknown_policy and unknown_policy not in {"conservative"}:
        errors.append("config.yaml: funding_context.unknown_policy must be conservative")

    project_types = fc.get("project_types")
    if not isinstance(project_types, dict):
        errors.append("config.yaml: funding_context.project_types must be a dict")
        return

    for project_type in ["youth", "general"]:
        item = project_types.get(project_type)
        if not isinstance(item, dict):
            errors.append(f"config.yaml: funding_context.project_types.{project_type} must be a dict")
            continue
        labels = item.get("labels")
        budget_range = item.get("typical_budget_wan_range")
        interpretation = str(item.get("interpretation") or "").strip()
        if not isinstance(labels, list) or not labels:
            errors.append(f"config.yaml: funding_context.project_types.{project_type}.labels must be a non-empty list")
        if not isinstance(budget_range, list) or len(budget_range) != 2:
            errors.append(
                f"config.yaml: funding_context.project_types.{project_type}.typical_budget_wan_range must be a 2-item list"
            )
        elif not all(isinstance(x, (int, float)) for x in budget_range) or float(budget_range[0]) > float(budget_range[1]):
            errors.append(
                f"config.yaml: funding_context.project_types.{project_type}.typical_budget_wan_range must be ascending numbers"
            )
        if not interpretation:
            errors.append(f"config.yaml: funding_context.project_types.{project_type}.interpretation is empty")

    report_requirements = fc.get("report_requirements")
    if not isinstance(report_requirements, list) or len(report_requirements) < 3:
        errors.append("config.yaml: funding_context.report_requirements must be a list with at least 3 items")


def _validate_scripts(skill_root: Path, errors: list[str]) -> None:
    required = [
        "scripts/build_parallel_vibe_plan.py",
        "scripts/cleanup_intermediate.py",
        "scripts/finalize_output.py",
        "scripts/list_proposal_files.py",
        "scripts/validate_skill.py",
    ]
    for rel in required:
        if not (skill_root / rel).exists():
            errors.append(f"Missing {rel}")


def _validate_references(skill_root: Path, errors: list[str]) -> None:
    refs = skill_root / "references"
    required = [
        "expert_01_innovation.md",
        "expert_02_methodology.md",
        "expert_03_foundation.md",
        "expert_04_critical.md",
        "expert_05_constructive.md",
        "expert_06_significance.md",
        "expert_07_clarity.md",
        "master_prompt_template.md",
        "aggregation_rules.md",
    ]
    if not refs.exists():
        errors.append("Missing references/ directory")
        return
    for f in required:
        p = refs / f
        if not p.exists():
            errors.append(f"Missing references/{f}")

    # Ensure master prompt template can stay consistent with config.yaml.
    tmpl = refs / "master_prompt_template.md"
    if tmpl.exists():
        t = _read_text(tmpl)
        if "{panel_output_filename}" not in t:
            errors.append("references/master_prompt_template.md: missing placeholder {panel_output_filename}")


def _extract_doc_number(text: str, pattern: str) -> int | None:
    m = re.search(pattern, text)
    if not m:
        return None
    try:
        return int(m.group(1))
    except Exception:
        return None


def _validate_docs_consistency(cfg: dict, skill_md_text: str, readme_text: str, errors: list[str]) -> None:
    for label, t in [("SKILL.md", skill_md_text), ("README.md", readme_text)]:
        if "reviewer_count" in t:
            errors.append(f"{label}: still mentions old parameter reviewer_count (should use panel_count)")
        if "thread_output_filename" in t:
            errors.append(f"{label}: still mentions old thread_output_filename (should use panel_output_filename)")
        if "--runner" in t:
            errors.append(f"{label}: still mentions old parallel-vibe flag --runner (should use --plan-file)")
        if "--workdir" in t:
            errors.append(f"{label}: mentions parallel-vibe --workdir (prefer --out-dir/--src-dir)")

    # parallel-vibe major updates: ensure SKILL.md documents the plan-file workflow.
    if "--plan-file" not in skill_md_text:
        errors.append("SKILL.md: missing parallel-vibe --plan-file workflow (required for parallel panels)")

    for label, t in [("SKILL.md", skill_md_text), ("README.md", readme_text)]:
        if "## 阶段判断（基于当前版本直接送审）" not in t:
            errors.append(f"{label}: missing default 函评/会评 stage assessment section")
        if "给过 / 不给过" not in t:
            errors.append(f"{label}: missing explicit binary verdict wording '给过 / 不给过'")
        if "资助额度" not in t:
            errors.append(f"{label}: missing funding-constraint guidance")

    pr = cfg.get("parallel_review") if isinstance(cfg, dict) else None
    pr = pr if isinstance(pr, dict) else {}
    expected_reviewer_count = len(pr.get("reviewer_personas") or []) if isinstance(pr.get("reviewer_personas"), list) else None
    expected_default_panels = pr.get("default_panel_count") if isinstance(pr.get("default_panel_count"), int) else None
    expected_max_panels = pr.get("max_panel_count") if isinstance(pr.get("max_panel_count"), int) else None

    readme_checks = [
        (r"每组专家：\s*(\d+)\s*位", expected_reviewer_count, "README.md: 每组专家数量与 config.yaml:parallel_review.reviewer_personas 不一致"),
        (r"总专家人次：N×\s*(\d+)\s*人次", expected_reviewer_count, "README.md: 总专家人次公式与每组专家数不一致"),
        (r"默认组数[^\n]*?(\d+)\s*组", expected_default_panels, "README.md: 默认组数与 config.yaml:parallel_review.default_panel_count 不一致"),
        (r"最大组数[^\n]*?(\d+)\s*组", expected_max_panels, "README.md: 最大组数与 config.yaml:parallel_review.max_panel_count 不一致"),
        (r"最多\s*(\d+)\s*组", expected_max_panels, "README.md: 最多组数与 config.yaml:parallel_review.max_panel_count 不一致"),
    ]
    for pattern, expected, message in readme_checks:
        if expected is None:
            continue
        found = _extract_doc_number(readme_text, pattern)
        if found is not None and found != expected:
            errors.append(f"{message}（文档={found}，配置={expected}）")


def _finish(errors: list[str]) -> int:
    if errors:
        print("FAIL")
        for e in errors:
            print(f"- {e}")
        return 1
    print("PASS")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())