Nsfc Research Content Writer

# ================================
# nsfc-research-content-writer 默认配置
# ================================

skill_info:
  name: nsfc-research-content-writer
  version: 1.0.0
  # template_year: 移除年份限制，使技能适用于不同年份的 NSFC 模板
  description: NSFC 标书正文“（二）研究内容”写作/重构，并同步编排“特色与创新”“三年年度研究计划”，输出 2.1/2.2/2.3 三份 extraTex 文件
  category: writing
  author: "Bensz Conan"

parameters:
  project_root:
    type: string
    required: true
    description: 项目根目录（如 projects/NSFC_Young 或你的标书项目路径）
  output_mode:
    type: string
    required: false
    default: apply
    allowed_values: [preview, apply]

targets:
  research_content_tex: extraTex/2.1.研究内容.tex
  innovation_tex: extraTex/2.2.特色与创新.tex
  yearly_plan_tex: extraTex/2.3.年度研究计划.tex

guardrails:
  allowed_write_files:
    - extraTex/2.1.研究内容.tex
    - extraTex/2.2.特色与创新.tex
    - extraTex/2.3.年度研究计划.tex
  forbidden_write_files:
    - main.tex
    - extraTex/@config.tex
  forbidden_write_globs:
    - "**/*.cls"
    - "**/*.sty"

quality_contract:
  research_content_must_cover:
    - 研究问题与总体目标
    - 3–4 个可检验子目标（指标/对照/数据来源）
    - 研究内容与任务分解（对齐子目标）
    - 技术路线与验证口径（防泄漏/对照/消融/统计）
  innovation_must_be:
    - 可理解（评审能看懂）
    - 可对照（相对坐标系）
    - 可验证（至少有指标或验证实验）
  yearly_plan_must_include:
    - 三年分年任务（不跨年）
    - 里程碑与可交付成果（每年都有）

# scripts/check_project_outputs.py 的轻量自检参数（可选覆盖默认值）
checks:
  # 绝对化措辞：通常建议避免；脚本可扫描并给出 WARN/ERROR（见 --fail-on-risk-phrases）
  risk_phrases:
    - 首次
    - 领先
    - 填补空白
    - 突破性
    - 国际领先
    - 世界领先
  # 研究内容里至少出现多少个子目标标记（默认 3）：S1/S2/S3（可多于 3）
  subgoal_markers_min: 3

from __future__ import annotations

import re
from typing import Iterable


def extract_yaml_value_under_block(lines: Iterable[str], block_key: str, key: str) -> str | None:
    """
    Minimal YAML extractor for a scalar value under a top-level mapping block.

    This skill intentionally avoids external YAML dependencies; keep this helper
    small and predictable, and only support the patterns we generate in config.yaml.
    """
    in_block = False
    block_indent: int | None = None
    key_re = re.compile(rf"^(\s*){re.escape(key)}:\s*(.*?)\s*$")

    for line in lines:
        if not in_block:
            if re.match(rf"^{re.escape(block_key)}:\s*$", line):
                in_block = True
                block_indent = len(line) - len(line.lstrip(" "))
            continue

        if line.strip() == "":
            continue

        indent = len(line) - len(line.lstrip(" "))
        if block_indent is not None and indent <= block_indent and not line.startswith(" " * (block_indent + 1)):
            break

        m = key_re.match(line)
        if m and indent >= (block_indent or 0) + 2:
            return m.group(2).strip().strip('"').strip("'")

    return None


def extract_yaml_list_under_block(lines: Iterable[str], block_key: str, key: str) -> list[str] | None:
    """Extract a simple YAML list under `block_key: { key: [ - item ] }` style."""
    in_block = False
    block_indent: int | None = None
    key_indent: int | None = None
    items: list[str] = []

    for line in lines:
        if not in_block:
            if re.match(rf"^{re.escape(block_key)}:\s*$", line):
                in_block = True
                block_indent = len(line) - len(line.lstrip(" "))
            continue

        if line.strip() == "":
            continue

        indent = len(line) - len(line.lstrip(" "))
        if block_indent is not None and indent <= block_indent and not line.startswith(" " * (block_indent + 1)):
            break

        if key_indent is None:
            if re.match(rf"^\s*{re.escape(key)}:\s*$", line) and indent >= (block_indent or 0) + 2:
                key_indent = indent
            continue

        if indent <= key_indent:
            break

        stripped = line.strip()
        if stripped.startswith("- "):
            items.append(stripped.removeprefix("- ").strip().strip('"').strip("'"))

    return items if items else None

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

import argparse
import re
import sys
from pathlib import Path

from _yaml_utils import extract_yaml_list_under_block, extract_yaml_value_under_block

DEFAULT_RISK_PHRASES = ["首次", "领先", "填补空白", "突破性", "国际领先", "世界领先"]
DEFAULT_SUBGOAL_MARKERS_MIN = 3


def _err(message: str) -> int:
    print(f"ERROR: {message}", file=sys.stderr)
    return 1


def _read_targets_from_config(config_yaml: Path) -> dict[str, str]:
    lines = config_yaml.read_text(encoding="utf-8").splitlines()
    research = extract_yaml_value_under_block(lines, "targets", "research_content_tex")
    innovation = extract_yaml_value_under_block(lines, "targets", "innovation_tex")
    yearly = extract_yaml_value_under_block(lines, "targets", "yearly_plan_tex")
    if not research or not innovation or not yearly:
        raise ValueError("config.yaml missing targets.*_tex")
    return {
        "research_content_tex": research,
        "innovation_tex": innovation,
        "yearly_plan_tex": yearly,
    }


def _read_checks_from_config(config_yaml: Path) -> tuple[list[str], int]:
    lines = config_yaml.read_text(encoding="utf-8").splitlines()

    risk_phrases = extract_yaml_list_under_block(lines, "checks", "risk_phrases") or DEFAULT_RISK_PHRASES
    raw_min = extract_yaml_value_under_block(lines, "checks", "subgoal_markers_min")
    try:
        subgoal_markers_min = int(raw_min) if raw_min is not None else DEFAULT_SUBGOAL_MARKERS_MIN
    except ValueError:
        subgoal_markers_min = DEFAULT_SUBGOAL_MARKERS_MIN

    subgoal_markers_min = max(1, subgoal_markers_min)
    return risk_phrases, subgoal_markers_min


def _check_file_exists(project_root: Path, relpath: str) -> str | None:
    path = project_root / relpath
    if not path.exists():
        return f"missing file: {path}"
    if not path.is_file():
        return f"not a file: {path}"
    return None


def _check_minimal_content(path: Path, *, kind: str, subgoal_markers_min: int) -> list[str]:
    text = path.read_text(encoding="utf-8", errors="replace")
    problems: list[str] = []

    if kind == "research":
        markers = {int(m.group(1)) for m in re.finditer(r"\bS(\d+)\b", text)}
        if len(markers) < subgoal_markers_min:
            problems.append(
                f"{path}: not enough subgoal markers like S1/S2/... (found={len(markers)} min={subgoal_markers_min})"
            )
    elif kind == "innovation":
        if not re.search(r"对应\s*S\d+", text):
            problems.append(f"{path}: missing backreference marker like '对应 S1'")
    elif kind == "yearly":
        year_patterns = {
            "第1年/第一年": [r"第\s*1\s*年", r"第一年"],
            "第2年/第二年": [r"第\s*2\s*年", r"第二年"],
            "第3年/第三年": [r"第\s*3\s*年", r"第三年"],
        }
        for label, patterns in year_patterns.items():
            if not any(re.search(p, text) for p in patterns):
                problems.append(f"{path}: missing yearly header ({label})")
        if not re.search(r"对应\s*S\d+", text) and not re.search(r"\bS\d+\b", text):
            problems.append(f"{path}: missing subgoal backreference like '对应 S1'")
    else:
        problems.append(f"{path}: unknown kind {kind}")

    return problems


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Lightweight checker for nsfc-research-content-writer outputs under a given project_root.",
    )
    parser.add_argument(
        "--project-root",
        required=True,
        help="NSFC LaTeX project root (must contain extraTex/).",
    )
    parser.add_argument(
        "--no-content-check",
        action="store_true",
        help="Only check that target files exist (skip content heuristics).",
    )
    parser.add_argument(
        "--no-risk-scan",
        action="store_true",
        help="Skip scanning for risk phrases like '首次/领先' (default: scan and warn).",
    )
    parser.add_argument(
        "--fail-on-risk-phrases",
        action="store_true",
        help="Treat risk phrases as errors (default: warnings).",
    )
    args = parser.parse_args()

    skill_root = Path(__file__).resolve().parents[1]
    config_yaml = skill_root / "config.yaml"
    if not config_yaml.exists():
        return _err(f"missing config.yaml: {config_yaml}")

    project_root = Path(args.project_root).expanduser().resolve()
    if not project_root.exists() or not project_root.is_dir():
        return _err(f"project_root does not exist or is not a directory: {project_root}")
    if not (project_root / "extraTex").exists():
        return _err(f"project_root missing extraTex/: {project_root}")

    try:
        targets = _read_targets_from_config(config_yaml)
    except ValueError as exc:
        return _err(str(exc))

    risk_phrases, subgoal_markers_min = _read_checks_from_config(config_yaml)

    errors: list[str] = []
    errors.extend(
        e
        for e in [
            _check_file_exists(project_root, targets["research_content_tex"]),
            _check_file_exists(project_root, targets["innovation_tex"]),
            _check_file_exists(project_root, targets["yearly_plan_tex"]),
        ]
        if e
    )
    if errors:
        for e in errors:
            print(f"ERROR: {e}", file=sys.stderr)
        return 1

    if not args.no_content_check:
        checks = [
            (targets["research_content_tex"], "research"),
            (targets["innovation_tex"], "innovation"),
            (targets["yearly_plan_tex"], "yearly"),
        ]
        for relpath, kind in checks:
            errors.extend(
                _check_minimal_content(project_root / relpath, kind=kind, subgoal_markers_min=subgoal_markers_min)
            )

    warnings: list[str] = []
    if not args.no_risk_scan:
        for relpath in [
            targets["research_content_tex"],
            targets["innovation_tex"],
            targets["yearly_plan_tex"],
        ]:
            path = project_root / relpath
            text = path.read_text(encoding="utf-8", errors="replace")
            for phrase in risk_phrases:
                if phrase in text:
                    msg = f"{path}: contains risk phrase '{phrase}'"
                    if args.fail_on_risk_phrases:
                        errors.append(msg)
                    else:
                        warnings.append(msg)

    if errors:
        for e in errors:
            print(f"ERROR: {e}", file=sys.stderr)
        return 1

    for w in warnings:
        print(f"WARN: {w}", file=sys.stderr)

    print("OK: project outputs check passed")
    print(f"- project_root: {project_root}")
    print("- targets:")
    print(f"  - {targets['research_content_tex']}")
    print(f"  - {targets['innovation_tex']}")
    print(f"  - {targets['yearly_plan_tex']}")
    return 0


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

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

import argparse
import datetime as dt
import re
import shutil
import sys
import typing
from pathlib import Path


def _generate_test_id(now: dt.datetime) -> str:
    return f"v{now:%Y%m%d%H%M}"


def _ensure_dir(path: Path) -> None:
    path.mkdir(parents=True, exist_ok=True)


def _safe_write(path: Path, content: str, *, overwrite: bool) -> None:
    if path.exists() and not overwrite:
        raise FileExistsError(f"Refusing to overwrite existing file: {path}")
    path.write_text(content, encoding="utf-8")


def _render_template(template: str, *, values: dict[str, str]) -> str:
    rendered = template
    for key, value in values.items():
        rendered = rendered.replace(f"{{{{{key}}}}}", value)
    return rendered


def _copy_or_template(
    *,
    dst_path: Path,
    src_path: Path | None,
    template_path: Path | None,
    template_values: dict[str, str] | None,
    overwrite: bool,
) -> None:
    if dst_path.exists() and not overwrite:
        return

    if src_path is not None and src_path.exists():
        if dst_path.exists():
            dst_path.unlink()
        shutil.copyfile(src_path, dst_path)
        return

    if template_path is not None and template_path.exists():
        template_text = template_path.read_text(encoding="utf-8")
        if template_values:
            template_text = _render_template(template_text, values=template_values)
        _safe_write(dst_path, template_text, overwrite=overwrite)
        return

    _safe_write(
        dst_path,
        "# TEST_PLAN\n\n（未找到可复制的计划文档或模板，请手动补全）\n",
        overwrite=overwrite,
    )


def _normalize_kind(kind: str) -> str:
    kind = kind.strip().lower()
    if kind in {"a", "a_round", "a-round"}:
        return "a"
    if kind in {"b", "b_round", "b-round"}:
        return "b"
    raise ValueError("kind must be 'a' or 'b'")


def _fail(parser: argparse.ArgumentParser, message: str) -> typing.NoReturn:
    parser.print_usage(sys.stderr)
    print(f"error: {message}", file=sys.stderr)
    raise SystemExit(2)


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Create a nsfc-research-content-writer test session skeleton (A round or B round).",
    )
    parser.add_argument("--kind", default="a", help="Session kind: a (default) or b.")
    parser.add_argument("--id", default="", help="Explicit test id like vYYYYMMDDHHMM (optional).")
    parser.add_argument(
        "--create-plan",
        action="store_true",
        help="Create missing plan doc skeleton under plans/ (optional).",
    )
    parser.add_argument(
        "--seed-test-plan-from-plan",
        action="store_true",
        help="If plan doc exists, seed TEST_PLAN.md from it (optional).",
    )
    parser.add_argument("--overwrite", action="store_true", help="Overwrite existing session files.")
    args = parser.parse_args()

    skill_root = Path(__file__).resolve().parents[1]
    if not (skill_root / "SKILL.md").exists():
        _fail(parser, f"missing SKILL.md at expected skill root: {skill_root}")

    try:
        kind = _normalize_kind(args.kind)
    except ValueError as exc:
        _fail(parser, str(exc))
    test_id = args.id.strip() or _generate_test_id(dt.datetime.now())
    if args.id.strip() and not re.fullmatch(r"v\d{12}", test_id):
        _fail(parser, "explicit test id must match vYYYYMMDDHHMM, e.g. v202602042053")
    if not test_id.startswith("v"):
        _fail(parser, "test id must start with 'v'")

    plans_dir = skill_root / "plans"
    tests_dir = skill_root / "tests"
    templates_dir = skill_root / "templates"

    required_templates = [
        templates_dir / "OPTIMIZATION_PLAN_TEMPLATE.md",
        templates_dir / "B_ROUND_CHECK_TEMPLATE.md",
        templates_dir / "TEST_PLAN_TEMPLATE.md",
        templates_dir / "TEST_REPORT_TEMPLATE.md",
    ]
    missing_templates = [p for p in required_templates if not p.exists()]
    if missing_templates:
        missing_list = "\n".join(f"- {p.relative_to(skill_root)}" for p in missing_templates)
        _fail(
            parser,
            "missing required templates (run validate_skill.py for details):\n" + missing_list,
        )

    _ensure_dir(plans_dir)
    _ensure_dir(tests_dir)

    template_values = {
        "TEST_ID": test_id,
        "TARGET_SKILL_NAME": skill_root.name,
        "TARGET_SKILL_ROOT": str(skill_root),
        "PLAN_TIME": dt.datetime.now().isoformat(timespec="minutes"),
        "CHECK_TIME": dt.datetime.now().isoformat(timespec="minutes"),
        "PLAN_DATE": dt.datetime.now().date().isoformat(),
        "KIND_ARG": kind,
    }

    if kind == "a":
        session_name = test_id
        test_plan_template = templates_dir / "TEST_PLAN_TEMPLATE.md"
        plan_doc_path = plans_dir / f"{test_id}.md"
        plan_template = templates_dir / "OPTIMIZATION_PLAN_TEMPLATE.md"
        round_kind = "A轮"
    else:
        session_name = f"B轮-{test_id}"
        test_plan_template = templates_dir / "TEST_PLAN_TEMPLATE.md"
        plan_doc_path = plans_dir / f"B轮-{test_id}.md"
        plan_template = templates_dir / "B_ROUND_CHECK_TEMPLATE.md"
        round_kind = "B轮"

    template_values["ROUND_KIND"] = round_kind
    template_values["SESSION_NAME"] = session_name
    template_values["PLAN_DOC_PATH"] = str(plan_doc_path.relative_to(skill_root))

    session_dir = tests_dir / session_name
    template_values["SESSION_DIR_REL"] = str(session_dir.relative_to(skill_root))
    template_values["TEST_PLAN_REL"] = str((session_dir / "TEST_PLAN.md").relative_to(skill_root))
    template_values["TEST_REPORT_REL"] = str((session_dir / "TEST_REPORT.md").relative_to(skill_root))

    if args.create_plan and (not plan_doc_path.exists() or args.overwrite):
        if plan_template.exists():
            _safe_write(
                plan_doc_path,
                _render_template(plan_template.read_text(encoding="utf-8"), values=template_values),
                overwrite=args.overwrite,
            )
        else:
            _safe_write(
                plan_doc_path,
                f"# 计划文档（{session_name}）\n\n（未找到模板，请手动补全）\n",
                overwrite=args.overwrite,
            )

    _ensure_dir(session_dir)
    _ensure_dir(session_dir / "_artifacts")
    _ensure_dir(session_dir / "_scripts")

    _copy_or_template(
        dst_path=session_dir / "TEST_PLAN.md",
        src_path=plan_doc_path if (args.seed_test_plan_from_plan and plan_doc_path.exists()) else None,
        template_path=test_plan_template if test_plan_template.exists() else None,
        template_values=template_values,
        overwrite=args.overwrite,
    )

    report_path = session_dir / "TEST_REPORT.md"
    test_report_template = templates_dir / "TEST_REPORT_TEMPLATE.md"
    if not report_path.exists() or args.overwrite:
        if test_report_template.exists():
            _safe_write(
                report_path,
                _render_template(test_report_template.read_text(encoding="utf-8"), values=template_values),
                overwrite=args.overwrite,
            )
        else:
            _safe_write(
                report_path,
                "# 测试报告（TEST_REPORT）\n\n"
                f"**测试会话**: {session_name}\n\n"
                "## 结果\n\n"
                "- 状态：✅ 通过 / ❌ 失败 / ⚠️ 部分通过\n\n"
                "## 证据\n\n"
                "- （填入命令输出、文件路径、对比结果等）\n",
                overwrite=args.overwrite,
            )

    print(str(session_dir))
    return 0


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

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

import argparse
import subprocess
import sys
from pathlib import Path


def _run(cmd: list[str]) -> int:
    print("+ " + " ".join(cmd), flush=True)
    proc = subprocess.run(cmd, text=True)
    return proc.returncode


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Run nsfc-research-content-writer minimal checks (validate skill + optional project output checks).",
    )
    parser.add_argument(
        "--project-root",
        default="",
        help="Optional LaTeX project root to check outputs (must contain extraTex/).",
    )
    parser.add_argument(
        "--no-content-check",
        action="store_true",
        help="Only check that target files exist (skip content heuristics).",
    )
    parser.add_argument(
        "--no-risk-scan",
        action="store_true",
        help="Skip scanning for risk phrases like '首次/领先'.",
    )
    parser.add_argument(
        "--fail-on-risk-phrases",
        action="store_true",
        help="Treat risk phrases as errors (default: warnings).",
    )
    args = parser.parse_args()

    skill_root = Path(__file__).resolve().parents[1]
    validate = skill_root / "scripts" / "validate_skill.py"
    check_outputs = skill_root / "scripts" / "check_project_outputs.py"

    rc = _run([sys.executable, str(validate)])
    if rc != 0:
        return rc

    if args.project_root:
        cmd = [
            sys.executable,
            str(check_outputs),
            "--project-root",
            args.project_root,
        ]
        if args.no_content_check:
            cmd.append("--no-content-check")
        if args.no_risk_scan:
            cmd.append("--no-risk-scan")
        if args.fail_on_risk_phrases:
            cmd.append("--fail-on-risk-phrases")

        rc = _run(cmd)
        if rc != 0:
            return rc

    print("OK: all checks passed", flush=True)
    return 0


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

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

import re
import sys
from pathlib import Path

from _yaml_utils import extract_yaml_list_under_block, extract_yaml_value_under_block


def _err(message: str) -> int:
    print(f"ERROR: {message}", file=sys.stderr)
    return 1


def _extract_frontmatter(text: str) -> str:
    if not text.startswith("---"):
        return ""
    parts = text.split("\n---\n", 1)
    if len(parts) != 2:
        return ""
    return parts[0]


def _extract_frontmatter_field(frontmatter: str, key: str) -> str | None:
    match = re.search(rf"(?m)^{re.escape(key)}:\s*(.+?)\s*$", frontmatter)
    if not match:
        return None
    return match.group(1).strip().strip('"').strip("'")


def main() -> int:
    skill_root = Path(__file__).resolve().parents[1]
    repo_root = skill_root.parents[1]
    skill_md = skill_root / "SKILL.md"
    config_yaml = skill_root / "config.yaml"
    templates_dir = skill_root / "templates"
    plans_dir = skill_root / "plans"
    tests_dir = skill_root / "tests"

    required_files = [
        skill_md,
        config_yaml,
        skill_root / "README.md",
        skill_root / "scripts" / "create_test_session.py",
        skill_root / "scripts" / "check_project_outputs.py",
        skill_root / "scripts" / "run_checks.py",
        skill_root / "scripts" / "_yaml_utils.py",
        skill_root / "references" / "info_form.md",
        skill_root / "references" / "dod_checklist.md",
        templates_dir / "OPTIMIZATION_PLAN_TEMPLATE.md",
        templates_dir / "B_ROUND_CHECK_TEMPLATE.md",
        templates_dir / "TEST_PLAN_TEMPLATE.md",
        templates_dir / "TEST_REPORT_TEMPLATE.md",
    ]
    for path in required_files:
        if not path.exists():
            return _err(f"missing required file: {path}")

    for d in [plans_dir, tests_dir, templates_dir]:
        if not d.exists() or not d.is_dir():
            return _err(f"missing required directory: {d}")

    skill_text = skill_md.read_text(encoding="utf-8")
    frontmatter = _extract_frontmatter(skill_text)
    if not frontmatter:
        return _err("SKILL.md missing YAML frontmatter block")

    fm_name = _extract_frontmatter_field(frontmatter, "name")
    fm_version = _extract_frontmatter_field(frontmatter, "version")
    fm_config = _extract_frontmatter_field(frontmatter, "config")
    fm_references = _extract_frontmatter_field(frontmatter, "references")
    if not fm_name or not fm_version or not fm_config or not fm_references:
        return _err("SKILL.md frontmatter missing required fields: name/version/config/references")

    fm_config_path = Path(fm_config)
    resolved_config_path = (
        (repo_root / fm_config_path) if str(fm_config_path).startswith("skills/") else (skill_root / fm_config_path)
    ).resolve()
    if resolved_config_path != config_yaml.resolve():
        return _err(f"config path mismatch: SKILL.md={resolved_config_path} expected={config_yaml.resolve()}")

    fm_refs_path = Path(fm_references)
    resolved_refs_path = (
        (repo_root / fm_refs_path) if str(fm_refs_path).startswith("skills/") else (skill_root / fm_refs_path)
    ).resolve()
    if not resolved_refs_path.exists() or not resolved_refs_path.is_dir():
        return _err(f"references path invalid: {resolved_refs_path}")

    config_lines = config_yaml.read_text(encoding="utf-8").splitlines()
    cfg_name = extract_yaml_value_under_block(config_lines, "skill_info", "name")
    cfg_version = extract_yaml_value_under_block(config_lines, "skill_info", "version")
    cfg_description = extract_yaml_value_under_block(config_lines, "skill_info", "description")
    cfg_category = extract_yaml_value_under_block(config_lines, "skill_info", "category")
    if not cfg_name or not cfg_version:
        return _err("config.yaml missing skill_info.name or skill_info.version")
    if not cfg_description or not cfg_category:
        return _err("config.yaml missing skill_info.description or skill_info.category")

    if fm_name != cfg_name:
        return _err(f"name mismatch: SKILL.md={fm_name} config.yaml={cfg_name}")
    if fm_version != cfg_version:
        return _err(f"version mismatch: SKILL.md={fm_version} config.yaml={cfg_version}")

    targets = [
        extract_yaml_value_under_block(config_lines, "targets", "research_content_tex"),
        extract_yaml_value_under_block(config_lines, "targets", "innovation_tex"),
        extract_yaml_value_under_block(config_lines, "targets", "yearly_plan_tex"),
    ]
    if any(t is None for t in targets):
        return _err("config.yaml missing one of targets.*_tex")

    allowed = extract_yaml_list_under_block(config_lines, "guardrails", "allowed_write_files")
    if not allowed:
        return _err("config.yaml missing guardrails.allowed_write_files")

    if set(allowed) != set(t for t in targets if t is not None):
        return _err("config.yaml mismatch: guardrails.allowed_write_files must equal targets.*_tex values")

    forbidden = extract_yaml_list_under_block(config_lines, "guardrails", "forbidden_write_files") or []
    for must_forbid in ["main.tex", "extraTex/@config.tex"]:
        if must_forbid not in forbidden:
            return _err(f"config.yaml missing guardrails.forbidden_write_files entry: {must_forbid}")

    forbidden_globs = extract_yaml_list_under_block(config_lines, "guardrails", "forbidden_write_globs") or []
    for must_forbid_glob in ["**/*.cls", "**/*.sty"]:
        if must_forbid_glob not in forbidden_globs:
            return _err(f"config.yaml missing guardrails.forbidden_write_globs entry: {must_forbid_glob}")

    required_skill_snippets = [
        "project_root",
        "output_mode",
        "写入安全约束",
        "references/output_skeletons.md",
        "main.tex",
        "extraTex/@config.tex",
        ".cls",
        ".sty",
    ]
    for snippet in required_skill_snippets:
        if snippet not in skill_text:
            return _err(f"SKILL.md missing required snippet: {snippet}")

    for t in targets:
        if t and t not in skill_text:
            return _err(f"SKILL.md missing target path from config.yaml: {t}")

    link_paths = re.findall(r"\((references/[^)]+)\)", skill_text)
    missing_links = []
    for rel in link_paths:
        if not (skill_root / rel).exists():
            missing_links.append(rel)
    if missing_links:
        missing = "\n".join(f"- {p}" for p in missing_links)
        return _err(f"SKILL.md contains missing references links:\n{missing}")

    stray = "（ 二）"
    readme_path = skill_root / "README.md"
    md_files = [skill_md, readme_path, *sorted((skill_root / "references").glob("*.md"))]
    for md in md_files:
        txt = md.read_text(encoding="utf-8")
        if stray in txt:
            return _err(f"found stray title variant '{stray}' in {md}")

    readme_text = readme_path.read_text(encoding="utf-8")
    for required_snippet in [
        "project_root",
        "output_mode",
        "禁止改动",
        "check_project_outputs.py",
        "run_checks.py",
        "--fail-on-risk-phrases",
    ]:
        if required_snippet not in readme_text:
            return _err(f"README.md missing required snippet: {required_snippet}")

    for required_path in [
        "skills/nsfc-research-content-writer/references/info_form.md",
        "skills/nsfc-research-content-writer/references/dod_checklist.md",
        "skills/nsfc-research-content-writer/references/output_skeletons.md",
    ]:
        if required_path not in readme_text:
            return _err(f"README.md missing required reference path: {required_path}")

    print("OK: validate-skill passed")
    print(f"- skill: {fm_name}")
    print(f"- version: {fm_version}")
    print(f"- referenced files: {len(link_paths)}")
    return 0


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