source-to-skill 0.7.0__py3-none-any.whl

source_to_skill/__init__.py

@@ -0,0 +1,3 @@
+"""source-to-skill: turn videos, podcasts, papers, books, docs, notes and threads into agent skills."""
+
+__version__ = "0.7.0"

source_to_skill/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from source_to_skill.cli import main
+
+sys.exit(main())

source_to_skill/cli.py

@@ -0,0 +1,237 @@
+"""Command-line entry point for the source-to-skill package.
+
+The agent skill itself lives in a self-contained folder (SKILL.md + scripts/
++ tools/). In a wheel it is bundled as ``source_to_skill/skill/``; in a
+source checkout / editable install it is read from ``skills/source-to-skill/``.
+The companion skills (skill-study, skill-eval, skill-library) ship the same
+way, as ``source_to_skill/companions/<name_with_underscores>/`` in a wheel.
+"""
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+from source_to_skill import __version__
+
+SKILL_NAME = "source-to-skill"
+
+# Installed next to source-to-skill unless --only source-to-skill.
+COMPANIONS = ("skill-study", "skill-eval", "skill-library")
+
+# agent -> (user-level skills root relative to $HOME, project-level root
+# relative to cwd), from each agent's skills documentation. Codex, Amp,
+# Goose and most others read the shared .agents/skills folders.
+AGENT_DIRS = {
+    "claude": (Path(".claude/skills"), Path(".claude/skills")),
+    "agents": (Path(".agents/skills"), Path(".agents/skills")),
+    "codex": (Path(".agents/skills"), Path(".agents/skills")),
+    "copilot": (Path(".copilot/skills"), Path(".github/skills")),
+    "gemini": (Path(".gemini/skills"), Path(".gemini/skills")),
+    "cursor": (Path(".cursor/skills"), Path(".cursor/skills")),
+    "opencode": (Path(".config/opencode/skills"), Path(".opencode/skills")),
+    "kiro": (Path(".kiro/skills"), Path(".kiro/skills")),
+    "windsurf": (Path(".codeium/windsurf/skills"), Path(".windsurf/skills")),
+    "factory": (Path(".factory/skills"), Path(".factory/skills")),
+}
+
+IGNORE = shutil.ignore_patterns("__pycache__", "*.pyc", "*.pyo", ".DS_Store")
+
+
+def skill_dir(name: str = SKILL_NAME) -> Path:
+    """Return a bundled skill folder (wheel install or source checkout)."""
+    here = Path(__file__).resolve().parent
+    wheel = (
+        here / "skill" if name == SKILL_NAME
+        else here / "companions" / name.replace("-", "_")
+    )
+    candidates = [
+        wheel,  # installed wheel
+        here.parent.parent / "skills" / name,  # src/ checkout, editable install
+    ]
+    for candidate in candidates:
+        if (candidate / "SKILL.md").is_file():
+            return candidate
+    raise FileNotFoundError(
+        "bundled skill not found; looked in: "
+        + ", ".join(str(c) for c in candidates)
+    )
+
+
+def _load_module(path: Path, name: str):
+    """Import a bundled script by path with its folder on sys.path."""
+    folder = str(path.parent)
+    if folder not in sys.path:
+        sys.path.insert(0, folder)
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def run_extract(argv: list[str]) -> int:
+    module = _load_module(skill_dir() / "scripts" / "extract.py", "_sts_extract")
+    return int(module.main(list(argv)) or 0)
+
+
+def run_validate(argv: list[str]) -> int:
+    module = _load_module(
+        skill_dir() / "tools" / "validate_skill.py", "_sts_validate_skill"
+    )
+    return int(module.main(list(argv)) or 0)
+
+
+def install_target(agent: str, project: bool, dest: str | None) -> Path:
+    if dest:
+        return Path(dest).expanduser().absolute()
+    user_root, project_root = AGENT_DIRS[agent]
+    base = Path.cwd() / project_root if project else Path.home() / user_root
+    return base / SKILL_NAME
+
+
+def _exists(path: Path) -> bool:
+    return path.exists() or path.is_symlink()
+
+
+def _copy_skill(source: Path, target: Path) -> None:
+    """Copy one skill folder to target, replacing whatever is there."""
+    target.parent.mkdir(parents=True, exist_ok=True)
+    # Copy into a sibling temp dir first, then swap: the old copy is moved
+    # aside into the staging dir (a symlink moves as a link, its target is
+    # never touched) and restored if the new one cannot take its place,
+    # so a failure never leaves a half-replaced or missing skill behind.
+    staging = Path(tempfile.mkdtemp(prefix=f".{SKILL_NAME}-", dir=target.parent))
+    try:
+        staged = staging / "new"
+        old = staging / "old"
+        shutil.copytree(source, staged, ignore=IGNORE)
+        if _exists(target):
+            target.rename(old)
+        try:
+            staged.rename(target)
+        except OSError:
+            if _exists(old):
+                old.rename(target)
+            raise
+    finally:
+        # Deletes the old copy; rmtree removes a moved symlink as a link.
+        shutil.rmtree(staging, ignore_errors=True)
+
+
+def run_install(args: argparse.Namespace) -> int:
+    target = install_target(args.agent, args.project, args.dest)
+    # --dest names exactly one folder: installing companions into its
+    # parent could replace (with --force) unrelated folders there.
+    only = args.only or bool(args.dest)
+    # Companions go next to source-to-skill, under their own names.
+    plan = [(skill_dir(), target)]
+    if not only:
+        plan += [
+            (skill_dir(name), target.parent / name) for name in COMPANIONS
+        ]
+    existing = [dest for _, dest in plan if _exists(dest)]
+    if existing and not args.force:
+        print(
+            "ERROR: already exists: "
+            + ", ".join(str(dest) for dest in existing)
+            + ". Re-run with --force to replace "
+            + ("it." if len(existing) == 1 else "them."),
+            file=sys.stderr,
+        )
+        return 1
+    for source, dest in plan:
+        verb = "Replaced" if _exists(dest) else "Installed"
+        _copy_skill(source, dest)
+        print(f"{verb} {dest.name} {__version__} skill at {dest}")
+    print("Next: in your agent, run  /source-to-skill <url-or-file>")
+    if not only:
+        print("Then:  /skill-study <skill>  ·  /skill-eval <skill>  ·  "
+              "/skill-library")
+    print("Optional extractors: pip install 'source-to-skill[all]'  "
+          "(check with: source-to-skill check)")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="source-to-skill",
+        description=(
+            "Turn YouTube videos, playlists & channels, podcasts, meetings, "
+            "papers, books, articles, GitHub repos, docs sites, notes, Office "
+            "files and HN/Reddit threads into AI agent skills."
+        ),
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    sub = parser.add_subparsers(dest="command", metavar="COMMAND")
+
+    install = sub.add_parser(
+        "install",
+        help="copy source-to-skill and its companion skills into a skills folder"
+    )
+    install.add_argument(
+        "--agent",
+        choices=sorted(AGENT_DIRS),
+        default="claude",
+        help="target agent: claude (~/.claude/skills, default); "
+        "agents or codex (~/.agents/skills, also read by Amp, Goose, Cursor, "
+        "Gemini CLI, OpenCode); copilot (~/.copilot/skills); gemini; cursor; "
+        "opencode; kiro; windsurf; factory",
+    )
+    install.add_argument(
+        "--project",
+        action="store_true",
+        help="install into the current project (./.claude/skills, "
+        "./.agents/skills, ./.github/skills, ...) instead of your home dir",
+    )
+    install.add_argument(
+        "--dest",
+        metavar="PATH",
+        help="explicit target directory for source-to-skill; installs "
+        "only source-to-skill (implies --only - companion skills are not "
+        "installed with --dest)",
+    )
+    install.add_argument(
+        "--only",
+        action="store_true",
+        help="install only source-to-skill, without skill-study, "
+        "skill-eval and skill-library",
+    )
+    install.add_argument(
+        "--force", action="store_true", help="replace an existing install"
+    )
+
+    sub.add_parser(
+        "extract",
+        help="run the extractor: extract <source> [--type TYPE] | --check",
+        add_help=False,
+    )
+    sub.add_parser("check", help="report which optional extractors are available")
+    validate = sub.add_parser("validate", help="validate a generated skill folder")
+    validate.add_argument("skill_dir", help="path to the skill directory")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    # `extract` forwards everything verbatim (incl. --check / --type / -h).
+    if argv and argv[0] == "extract":
+        return run_extract(argv[1:])
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.command == "install":
+        return run_install(args)
+    if args.command == "check":
+        return run_extract(["--check"])
+    if args.command == "validate":
+        return run_validate([args.skill_dir])
+    parser.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

source_to_skill/companions/skill_eval/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: skill-eval
+description: Measure how well a generated knowledge skill answers questions about its source - grounded questions drafted from the original source, answered using only the skill, graded expectation by expectation, with a score, the facts the skill is missing, and an optional fix. Writes evals/evals.json in the skill-creator format. Use when the user runs /skill-eval, or asks "is this skill any good", "test / evaluate / benchmark my skill", "what did the skill miss", or wants to check a skill made by source-to-skill before relying on it.
+---
+
+# skill-eval
+
+Check a skill against the source it was made from. The question is not
+"does the skill read well" but "can an agent holding only this skill
+answer what the source answers, and cite it correctly".
+
+Usage: `/skill-eval <skill-dir>` (a path, or a skill name found under
+`~/.claude/skills/`, `~/.agents/skills/`, `~/.copilot/skills/` or the
+project's `.claude/skills/`, `.agents/skills/`, `.github/skills/`).
+
+## Step 1 — Get the questions
+
+If `<skill-dir>/evals/evals.json` exists (source-to-skill writes one while
+the source is still in context), use it. Otherwise draft one:
+
+1. Read `<skill-dir>/source.json` (topic skills: `sources/*.source.json`).
+   Missing → say the skill was not made by source-to-skill and ask for the
+   original source.
+2. Re-extract the source with the source-to-skill extractor into a fresh
+   work dir (`python3 scripts/extract.py "<source>" [options from the
+   manifest] --work-dir <tmp>/skill_eval`, run from the source-to-skill
+   skill folder). Tell the user the `est_tokens` and ask before reading it.
+3. Draft 8 questions from `full_text.txt`, never from the skill, spread
+   across the source's segments: 3 concrete facts or numbers, 2 decision
+   rules or "when should I", 2 that need two segments combined, and for
+   video or audio 1 "where in the source is X" that needs a timestamp.
+   Each gets 1 to 3 expectations: short statements a grader can check
+   against an answer, each naming its segment.
+
+Write it in the skill-creator format so the same file works there:
+
+```json
+{
+  "skill_name": "<slug>",
+  "evals": [
+    {"id": 1, "prompt": "What learning-rate schedule did the paper use?",
+     "expected_output": "Linear warmup for 4000 steps, then inverse square root decay",
+     "files": [],
+     "expectations": ["States warmup_steps = 4000 (segment 5.3 Optimizer)",
+                      "Says the rate then decays proportionally to step^-0.5"]}
+  ]
+}
+```
+
+## Step 2 — Answer with only the skill
+
+The answers must come from someone who has not read the source. If your
+host can run subagents, give one subagent the skill directory path and the
+eight prompts, and tell it to answer from those files only, citing file
+names and deep links. Without subagents, answer them yourself, reading only
+the skill's files, and say in the report that grading was not blind.
+
+## Step 3 — Grade
+
+For each expectation: pass or fail, with one line of evidence quoted from
+the answer. Also fail an answer whose citation points at the wrong file or
+whose timestamp is more than 60 seconds off the moment the source covers
+it. Score = passed expectations / all expectations.
+
+Save `<skill-dir>/evals/last-run.json`:
+`{"date": "...", "score": 0.83, "results": [{"id": 1, "passed": [true, false], "evidence": ["...", "..."]}]}`.
+
+## Step 4 — Report and fix
+
+Report the score, then each failure as one line: what the source says,
+which skill file should have carried it. Separate two causes: the fact is
+missing from the skill, or it is there but the index in `SKILL.md` did
+not lead to it. Offer to fix both — add the missing facts to the right
+support file, sharpen the index line or the description — then re-run only
+the failed questions. Change nothing without the user's yes, and run
+`python3 tools/validate_skill.py <skill-dir>` (from the source-to-skill
+folder) after any edit.

source_to_skill/companions/skill_library/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: skill-library
+description: Your library of skills made by source-to-skill - lists every video, course, podcast, paper, book, article, docs and repo skill installed for Claude Code, Codex, Copilot, Gemini and other agents, finds which one covers a question, flags skills whose playlist, channel, feed or docs has moved on, and refreshes them. Use when the user runs /skill-library, or asks "what skills do I have", "which of my skills covers X", "what did I learn about X", "are any of my skills out of date", "refresh all my skills", or wants to merge overlapping skills.
+---
+
+# skill-library
+
+Run from this skill's directory:
+
+    python3 scripts/library.py
+
+It prints JSON: every skill folder with a `source.json` (or, for topic
+skills, `sources/*.source.json`) under the agents' user and project skills
+folders, with its description, sources, age, and `refresh_due`. It reads
+only; pass `--root <dir>` for another folder and `--stale-days N` to change
+the 30-day refresh threshold.
+
+## List
+
+Show a compact table: name, type, title, extracted (date), tokens, and a
+mark on `refresh_due` skills. Group by source type when there are more than
+ten. No skills found → say where you looked and suggest
+`/source-to-skill <url-or-file>`.
+
+## Find
+
+For "which skill covers X": match X against each skill's description first,
+then open only the matching skills' `SKILL.md` indexes. Answer with the
+skill name, the support file, and the deep link or section where X is
+covered, then answer the question itself from that file. Name every skill
+that covers X when several do; when they disagree, show both positions
+side by side.
+
+## Refresh
+
+`refresh_due` marks playlists, channels, podcast feeds, docs sites, repos,
+threads and notes folders extracted 30 or more days ago. Before refreshing,
+list them with their age and ask which to refresh. For each one the user
+picks, follow the source-to-skill skill's "Refresh an existing skill"
+steps with that skill directory. Run YouTube re-extractions one at a time,
+never in parallel: YouTube rate-limits a machine that asks too often.
+
+## Merge
+
+When two or more skills cover the same topic (overlapping descriptions,
+same author or course), offer to build one topic skill from their
+`source.json` origins with `/source-to-skill <source> <source> ... <slug>`.
+The old skills stay until the user deletes them; never delete a skill
+yourself.

source_to_skill/companions/skill_library/scripts/library.py

@@ -0,0 +1,160 @@
+"""Inventory of the skills source-to-skill made on this machine.
+
+Usage: python3 scripts/library.py [--root PATH ...] [--stale-days N]
+
+Scans the agents' skills folders (user-level and the current project's)
+for skill directories holding a source.json manifest, top-level or under
+sources/ for topic skills, and prints one JSON object with a `skills`
+list: name, path, description, source type, title, origin, extraction
+date, token estimate, and whether the skill is due for a refresh.
+Read-only: it never writes, fetches, or re-extracts anything.
+"""
+import json
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+SKILL_ROOTS = (
+    "~/.claude/skills", "~/.agents/skills", "~/.copilot/skills",
+    "~/.gemini/skills", "~/.cursor/skills", "~/.config/opencode/skills",
+    "~/.kiro/skills", "~/.factory/skills", "~/.codeium/windsurf/skills",
+    ".claude/skills", ".agents/skills", ".github/skills", ".gemini/skills",
+    ".cursor/skills", ".opencode/skills", ".kiro/skills", ".factory/skills",
+    ".windsurf/skills",
+)
+
+# Sources that keep publishing: a skill made from them goes stale.
+GROWING_TYPES = ("playlist", "docs", "thread", "notes", "repo")
+
+DEFAULT_STALE_DAYS = 30
+
+FRONTMATTER_RE = re.compile(r"\A---\n(.*?)\n---\n", re.DOTALL)
+
+
+def _frontmatter(skill_md: Path) -> dict:
+    try:
+        text = skill_md.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return {}
+    match = FRONTMATTER_RE.match(text)
+    fields = {}
+    block = None  # key of a `>` / `|` block scalar being collected
+    for line in (match.group(1) if match else "").splitlines():
+        if block and (line.startswith((" ", "\t")) or not line.strip()):
+            # Folded and literal blocks are joined into one line.
+            if line.strip():
+                fields[block] = f"{fields[block]} {line.strip()}".strip()
+            continue
+        block = None
+        key, _, value = line.partition(":")
+        if not key.strip() or line.startswith(" "):
+            continue
+        if re.fullmatch(r"[>|][+-]?", value.strip()):
+            block = key.strip()
+            fields[block] = ""
+        elif value.strip():
+            fields[key.strip()] = value.strip()
+    return fields
+
+
+def _load(path: Path) -> dict:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _age_days(stamp, now: datetime):
+    try:
+        then = datetime.strptime(stamp, "%Y-%m-%dT%H:%M:%SZ")
+    except (TypeError, ValueError):
+        return None
+    return (now - then.replace(tzinfo=timezone.utc)).days
+
+
+def describe(skill_dir: Path, now: datetime, stale_days: int):
+    """One inventory entry, or None when the folder is not a made skill."""
+    manifests = []
+    if (skill_dir / "source.json").is_file():
+        manifests.append(_load(skill_dir / "source.json"))
+    manifests += [
+        _load(path) for path in sorted(skill_dir.glob("sources/*.source.json"))
+    ]
+    manifests = [m for m in manifests if m.get("source")]
+    if not manifests:
+        return None
+    fields = _frontmatter(skill_dir / "SKILL.md")
+    sources = []
+    for manifest in manifests:
+        age = _age_days(manifest.get("extracted_at"), now)
+        sources.append({
+            "source_type": manifest.get("source_type"),
+            "title": manifest.get("title"),
+            "origin": manifest.get("origin") or manifest.get("source"),
+            "extracted_at": manifest.get("extracted_at"),
+            "age_days": age,
+            "est_tokens": manifest.get("est_tokens"),
+            "segments": len(manifest.get("segments") or []),
+            "refresh_due": (
+                manifest.get("source_type") in GROWING_TYPES
+                and age is not None and age >= stale_days
+            ),
+        })
+    return {
+        "name": fields.get("name") or skill_dir.name,
+        "path": str(skill_dir),
+        "description": fields.get("description", ""),
+        "topic": len(sources) > 1,
+        "sources": sources,
+        "refresh_due": any(s["refresh_due"] for s in sources),
+    }
+
+
+def scan(roots, now=None, stale_days=DEFAULT_STALE_DAYS) -> list:
+    now = now or datetime.now(timezone.utc)
+    seen, skills = set(), []
+    for root in roots:
+        base = Path(root).expanduser()
+        if not base.is_dir():
+            continue
+        for child in sorted(base.iterdir()):
+            if not (child / "SKILL.md").is_file():
+                continue
+            real = child.resolve()
+            if real in seen:
+                continue
+            seen.add(real)
+            entry = describe(child, now, stale_days)
+            if entry:
+                skills.append(entry)
+    return skills
+
+
+def main(argv) -> int:
+    roots, stale_days = [], DEFAULT_STALE_DAYS
+    args = list(argv)
+    while args:
+        flag = args.pop(0)
+        if flag in ("-h", "--help"):
+            print(__doc__)
+            return 0
+        if flag not in ("--root", "--stale-days") or not args:
+            print(__doc__, file=sys.stderr)
+            return 2
+        value = args.pop(0)
+        if flag == "--root":
+            roots.append(value)
+        elif value.isdigit():
+            stale_days = int(value)
+        else:
+            print("--stale-days needs a whole number.", file=sys.stderr)
+            return 2
+    skills = scan(roots or SKILL_ROOTS, stale_days=stale_days)
+    print(json.dumps({"skills": skills}, indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

source_to_skill/companions/skill_study/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: skill-study
+description: Study a skill made by source-to-skill (a video, course, podcast, paper, book, article or docs skill) - quizzes one question at a time with spaced repetition, Feynman-style "explain it back" checks, a study plan over the lessons, and Anki flashcard export. Every answer cites the skill file and, for video and audio, the exact second. Use when the user says /skill-study, "quiz me on", "test me on", "flashcards from", "help me learn / remember", "study plan for", or "make Anki cards" about a source they turned into a skill.
+---
+
+# skill-study
+
+Turn a skill made by source-to-skill into active recall. The skill's files
+are the only ground truth: never quiz on, or correct with, facts that are
+not in them.
+
+Usage:
+
+- `/skill-study <skill>` — quiz (default mode), due cards first.
+- `/skill-study <skill> explain` — the user explains a concept, you check it.
+- `/skill-study <skill> plan` — a study plan over the lessons or chapters.
+- `/skill-study <skill> anki` — export flashcards for Anki.
+
+`<skill>` is a path or a skill name. Find a name under `~/.claude/skills/`,
+`~/.agents/skills/`, `~/.copilot/skills/`, then the project's
+`.claude/skills/`, `.agents/skills/`, `.github/skills/`. Several matches or
+none: list what you found and ask.
+
+## Ground rules
+
+- Read `SKILL.md` first, then only the support files the current question
+  needs (`segments/`, `lessons/`, `chapters/`, `guides/`, `cheatsheet.md`).
+- One question per turn. Wait for the answer before showing anything.
+- Grade honestly: correct, partly correct (say what was missing), or wrong.
+  Then give the answer in two or three sentences with its citation:
+  `segments/03-training.md` plus the `&t=` deep link or `[hh:mm:ss]` when
+  the file has one.
+- Ask for understanding, not trivia: why a rule holds, when a technique
+  applies, what a number implies, how two ideas differ. At most one in four
+  questions may be a bare number or name recall.
+- If the user disputes a grade and the skill file supports them, concede.
+
+## Progress and spaced repetition
+
+Keep progress in `<skill>/.study/progress.json` (create it on first use):
+
+```json
+{
+  "cards": [
+    {"id": "c1", "q": "...", "a": "...", "source": "lessons/02-gradient-descent.md",
+     "link": "https://www.youtube.com/watch?v=IHZwWFHWa-w&t=212s",
+     "box": 1, "due": "2026-10-27", "seen": 1, "correct": 0}
+  ],
+  "sessions": [{"date": "2026-10-26", "asked": 8, "correct": 6}]
+}
+```
+
+Leitner boxes: a correct answer moves the card up one box, a wrong one back
+to box 1. Next due date by box: 1 → tomorrow, 2 → 3 days, 3 → 7 days,
+4 → 14 days, 5 → 30 days. A quiz asks due cards first, then new cards
+from files not yet covered, spreading across the whole skill rather than
+the first file. Default length: 8 questions, or what the user asks for.
+End with the score, the weakest topic, and when the next cards are due.
+
+## Explain mode
+
+Ask the user to explain one core idea from `SKILL.md` in their own words.
+Compare their explanation against the skill: name what was right, what was
+missing, and any misconception, each tied to a file. Then ask one follow-up
+question that probes the gap. Record the concept as a card in box 1 when
+the explanation missed something important.
+
+## Plan mode
+
+From the lesson, chapter or segment index, propose sessions of about 25
+minutes: which files to read (or which timestamps to rewatch), in what
+order, with the quiz focus for each. Respect the course order for
+playlists; for books, start from the chapters the core mental models come
+from. Write it to `<skill>/.study/plan.md` only if the user wants it kept.
+
+## Anki export
+
+Write `<skill>/.study/flashcards.tsv` — one card per line, tab-separated,
+no header: `front<TAB>back<TAB>tags`. The back ends with the citation and,
+when there is one, the deep link as an HTML link
+(`<a href="...">03-training 14:02</a>`). Tags: the skill name plus the
+lesson or chapter slug. 20 to 40 cards across the whole skill unless the
+user asks otherwise; no duplicates of cards already in `progress.json`.
+Tell the user to import it in Anki with File → Import, fields separated by
+Tab, "Allow HTML in fields" on.