@kernaut/kernaut-resources 0.1.17-beta.1 → 0.1.18

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/scripts/get_page.py

@@ -1,178 +0,0 @@
-#!/usr/bin/env python3
-"""Retrieve a single wiki page by its id or path.
-
-Usage:
-    get_page.py kernel-flash-attention-4         # by id
-    get_page.py pr-cutlass-2472                   # by id
-    get_page.py wiki/nvidia/kernels/flash-attention-4.md # by path
-    get_page.py kernel-flash-attention-4 --body-only
-    get_page.py kernel-flash-attention-4 --frontmatter-only
-    get_page.py kernel-flash-attention-4 --follow-sources  # also print first 500 chars of each source
-"""
-
-import argparse
-import sys
-import yaml
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from _wiki_root import WIKI_ROOT  # noqa: E402
-from wiki_page_service import (  # noqa: E402
-    find_page, split_frontmatter, resolve_artifact_dir, ARTIFACT_EXTS,
-)
-try:
-    from source_corpus.registry import resolve_corpus_path  # noqa: E402
-except ImportError:
-    resolve_corpus_path = None
-try:
-    from source_corpus.reader import read_by_anchor  # noqa: E402
-except ImportError:
-    read_by_anchor = None
-
-
-def _extract_excerpt(src_page, anchor=None, max_chars=500):
-    """Extract a text excerpt, using anchor-aware reading if available."""
-    if anchor and read_by_anchor:
-        try:
-            _, _, anchor_text, _ = read_by_anchor(src_page, anchor)
-            return anchor_text[:max_chars].strip()
-        except Exception:
-            pass
-    content = src_page.read_text(encoding="utf-8")
-    _, body = split_frontmatter(content)
-    return ((body or "")[:max_chars]).strip()
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Get a wiki page by id or path")
-    parser.add_argument("lookup", help="Page id (e.g. kernel-flash-attention-4) or relative path")
-    parser.add_argument("--body-only", action="store_true", help="Print only the body (skip frontmatter)")
-    parser.add_argument("--frontmatter-only", action="store_true", help="Print only the frontmatter as YAML")
-    parser.add_argument("--follow-sources", action="store_true", help="Also print 500-char excerpt from each cited source")
-    parser.add_argument("--include-code", action="store_true", help="After the page body, print all files under the page's artifact_dir (Phase 3)")
-    args = parser.parse_args()
-
-    page_path = find_page(args.lookup)
-    if not page_path:
-        print(f"ERROR: No page found for '{args.lookup}'", file=sys.stderr)
-        sys.exit(1)
-
-    content = page_path.read_text(encoding="utf-8")
-    fm, body = split_frontmatter(content)
-
-    if args.frontmatter_only:
-        if fm:
-            print(yaml.dump(fm, allow_unicode=True, sort_keys=False))
-        return
-
-    if args.body_only:
-        print(body)
-        return
-
-    # Default: full page, prefixed with a path header for context
-    print(f"# {page_path.relative_to(WIKI_ROOT)}")
-    print()
-    print(content)
-
-    if args.follow_sources and fm:
-        print()
-        print("---")
-        print("## Cited Sources (excerpts)")
-        print()
-
-        source_entries = []  # (kind, lookup, detail, anchor)
-        for src_id in fm.get("sources", []) or []:
-            source_entries.append(("source-id", src_id, src_id, ""))
-        for src in fm.get("source", []) or []:
-            if isinstance(src, dict) and src.get("path"):
-                source_entries.append(("source-path", src.get("path"), src.get("anchor", ""), src.get("anchor", "")))
-            elif isinstance(src, str):
-                source_entries.append(("source-path", src, "", ""))
-        for src in fm.get("source_refs", []) or []:
-            if isinstance(src, dict) and src.get("source_id"):
-                label = src.get("source_id")
-                corpus_path = label
-                if src.get("path"):
-                    corpus_path = label + "/" + str(src["path"])
-                detail = " / ".join(str(x) for x in (src.get("path"), src.get("anchor")) if x)
-                anchor = src.get("anchor", "")
-                source_entries.append(("source-ref", corpus_path, detail, anchor))
-
-        seen = set()
-        for kind, lookup, detail, anchor in source_entries:
-            key = (kind, lookup, detail)
-            if key in seen:
-                continue
-            seen.add(key)
-            src_page = None
-            if kind == "source-path":
-                p = WIKI_ROOT / str(lookup)
-                if p.is_file():
-                    src_page = p
-            if src_page is None:
-                src_page = find_page(str(lookup))
-            if src_page is None and kind == "source-ref" and resolve_corpus_path:
-                try:
-                    cp = resolve_corpus_path(str(lookup))
-                    if cp.is_file():
-                        src_page = cp
-                except (ValueError, Exception):
-                    pass
-            if src_page:
-                excerpt = _extract_excerpt(src_page, anchor)
-                print(f"### {lookup}")
-                try:
-                    print(f"`{src_page.relative_to(WIKI_ROOT)}`")
-                except ValueError:
-                    print(f"`{src_page}`")
-                if detail and detail != lookup:
-                    print(f"anchor/detail: {detail}")
-                print()
-                print(excerpt)
-                print()
-            else:
-                print(f"### {lookup}")
-                if detail and detail != lookup:
-                    print(f"anchor/detail: {detail}")
-                print("_No local markdown page resolved; use the path/source_ref metadata above._")
-                print()
-
-    if args.include_code:
-        ad, ad_path, is_fallback = resolve_artifact_dir(page_path, fm)
-        if ad_path and ad_path.is_dir():
-            print()
-            print("---")
-            suffix = " (conventional path — artifact_dir not backfilled)" if is_fallback else ""
-            print(f"## Artifact Bundle: `{ad}`{suffix}")
-            print()
-            for f in sorted(ad_path.rglob("*")):
-                if not f.is_file() or f.suffix.lower() not in ARTIFACT_EXTS:
-                    continue
-                rel_to_bundle = f.relative_to(ad_path)
-                print(f"### `{rel_to_bundle}`")
-                print()
-                try:
-                    body_bytes = f.read_bytes()
-                    if f.stat().st_size > 200 * 1024:
-                        print(f"*(file is {f.stat().st_size} bytes; showing first 200 KiB)*")
-                        body_bytes = body_bytes[:200 * 1024]
-                    print("```" + (f.suffix.lstrip(".") or ""))
-                    print(body_bytes.decode("utf-8", errors="replace"))
-                    print("```")
-                    print()
-                except Exception as e:
-                    print(f"*(could not read: {e})*")
-                    print()
-        elif ad is None:
-            # No explicit artifact_dir and no conventional location
-            # resolves to an existing directory — the page simply has no
-            # bundle. Stay silent rather than printing a misleading
-            # "not found on disk" message.
-            pass
-        else:
-            print()
-            print(f"*(artifact_dir '{ad}' not found on disk)*")
-
-
-if __name__ == "__main__":
-    main()

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/scripts/grep_wiki.py

@@ -1,188 +0,0 @@
-#!/usr/bin/env python3
-"""Text search across wiki bodies and source PR descriptions.
-
-Usage:
-    grep_wiki.py "tcgen05.fence"
-    grep_wiki.py "2-CTA backward" --only wiki
-    grep_wiki.py "ping-pong" --context 3
-    grep_wiki.py "nvfp4 block_scale" --any     # match if ANY word appears
-
-Returns matching lines with file path, line number, and N context lines.
-"""
-
-import argparse
-import re
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from _axes import (  # noqa: E402
-    axis_match,
-    infer_vendors_from_terms,
-    read_frontmatter_head,
-    require_vendor,
-)
-from _wiki_root import WIKI_ROOT  # noqa: E402
-
-
-def iter_files(scope, exts=None):
-    """Yield file paths under the given scope.
-
-    Default: markdown files under wiki/sources. If `exts` is provided (a set
-    of lowercase extensions including the leading dot, e.g. {'.cu', '.cuh'}),
-    those extensions are ALSO searched across wiki/sources AND artifacts/.
-
-    R32: when scope=='artifacts' the default search set includes common
-    source-code extensions in addition to `.md`. Artifact bundles rarely
-    contain markdown — the hits users expect live in `.cu` / `.py` /
-    `.ptx` / `.patch` etc. files. Without this default, `--only artifacts`
-    without `--ext` reports `No matches` even when the code bundles
-    contain the pattern.
-    """
-    dirs = {
-        "wiki": ["wiki"],
-        "sources": ["sources"],
-        "all": ["wiki", "sources"],
-        "artifacts": ["artifacts"],
-    }
-    sub_list = dirs.get(scope, ["wiki", "sources"])
-    # When --ext is used, also search artifacts/ unless scope explicitly excludes it
-    if exts and "artifacts" not in sub_list and scope != "wiki" and scope != "sources":
-        sub_list = sub_list + ["artifacts"]
-
-    if scope == "artifacts" and not exts:
-        # R32 default for --only artifacts: match every source-file
-        # extension the Phase 3 emitters actually produce. Keeps `.md`
-        # so MANIFEST/README-style notes are still searchable. `.sh`
-        # added in R33 for shell fences emitted via EXT_MAP
-        # bash/shell/sh -> .sh.
-        search_exts = {
-            ".md",
-            ".cu", ".cuh", ".ptx",
-            ".cpp", ".cxx", ".cc", ".c",
-            ".h", ".hpp", ".hxx", ".inl",
-            ".py", ".pyx",
-            ".patch",
-            ".txt",
-            ".sh",
-            ".yaml", ".yml", ".json",
-        }
-    else:
-        search_exts = {".md"} | (exts or set())
-
-    for sub in sub_list:
-        base = WIKI_ROOT / sub
-        if not base.exists():
-            continue
-        for f in base.rglob("*"):
-            if not f.is_file():
-                continue
-            if f.suffix.lower() in search_exts:
-                yield f
-
-
-def grep_file(path, compiled_patterns, context, any_match):
-    """Search a single file for the pattern(s). Returns list of (line_no, context_text) tuples."""
-    try:
-        lines = path.read_text(encoding="utf-8").splitlines()
-    except Exception:
-        return []
-
-    results = []
-    for i, line in enumerate(lines):
-        if any_match:
-            matched = any(p.search(line) for p in compiled_patterns)
-        else:
-            matched = all(p.search(line) for p in compiled_patterns)
-        if matched:
-            start = max(0, i - context)
-            end = min(len(lines), i + context + 1)
-            snippet = "\n".join(
-                f"{j+1}{'→' if j == i else ':'} {lines[j]}"
-                for j in range(start, end)
-            )
-            results.append((i + 1, snippet))
-    return results
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Text search across Blackwell kernel wiki")
-    parser.add_argument("patterns", nargs="+", help="Search pattern(s) — all must match a line unless --any is used")
-    parser.add_argument("--only", choices=["wiki", "sources", "all", "artifacts"], default="all",
-                        help="Restrict search scope (default: all)")
-    parser.add_argument("--context", type=int, default=1, help="Context lines around each match (default 1)")
-    parser.add_argument("--any", action="store_true", help="Match if ANY pattern matches a line (default: all must match)")
-    parser.add_argument("--limit", type=int, default=20, help="Max files reported (default 20)")
-    parser.add_argument("--files-only", action="store_true", help="Print only matching file paths")
-    parser.add_argument("--ext", default=None, help="Comma-separated extra extensions to search (without dots), e.g. 'cu,cuh,ptx,py'; auto-expands scope to include artifacts/")
-    parser.add_argument("--vendor", help="Filter by vendor (nvidia, ascend, generic, biren, all). Required: an unscoped grep returns every vendor's files. Auto-inferred from --architecture/--language/patterns when omitted")
-    parser.add_argument("--language", help="Filter by language/DSL (ascendc, cuda-cpp, triton-ascend, ptx, ...)")
-    parser.add_argument("--architecture", help="Filter by architecture (ascend910b, sm90, sm100, ...). Names collapse to their family: 910B/910C and the B1-B4 bins are all ascend910b, sm90a is sm90")
-    args = parser.parse_args()
-
-    # Same discipline as query.py: refuse a corpus-wide grep rather than let one
-    # vendor's files leak into another vendor's task. `--vendor all` opts in.
-    if not args.vendor:
-        candidates = infer_vendors_from_terms(
-            [args.architecture, args.language, *args.patterns]
-        )
-        args.vendor = require_vendor(None, candidates, "grep_wiki.py")
-        if not args.files_only:
-            print(f"# Auto-detected vendor: {args.vendor}")
-            print()
-
-    compiled = []
-    for p in args.patterns:
-        try:
-            compiled.append(re.compile(p, re.IGNORECASE))
-        except re.error as e:
-            print(f"ERROR: invalid regex {p!r}: {e}", file=sys.stderr)
-            print("       Hint: escape special chars ([](){}.*+?^$|\\) or quote the pattern.", file=sys.stderr)
-            sys.exit(2)
-
-    ext_set = None
-    if args.ext:
-        ext_set = {"." + e.strip().lstrip(".").lower() for e in args.ext.split(",") if e.strip()}
-
-    matched_files = []
-    filtered_out = 0
-    for path in iter_files(args.only, exts=ext_set):
-        hits = grep_file(path, compiled, args.context, args.any)
-        if not hits:
-            continue
-        relpath = str(path.relative_to(WIKI_ROOT))
-        if not axis_match(relpath, read_frontmatter_head(path),
-                          vendor=args.vendor, language=args.language,
-                          architecture=args.architecture):
-            filtered_out += 1
-            continue
-        matched_files.append((path, hits))
-
-    if filtered_out and not args.files_only:
-        print(f"# {filtered_out} matching file(s) excluded by the vendor/language/"
-              f"architecture filters (use --vendor all to include them)")
-        print()
-
-    matched_files = matched_files[:args.limit]
-
-    if args.files_only:
-        for path, _ in matched_files:
-            print(path.relative_to(WIKI_ROOT))
-        return
-
-    if not matched_files:
-        print("No matches.")
-        return
-
-    print(f"# {len(matched_files)} file(s) match")
-    for path, hits in matched_files:
-        print()
-        print(f"## {path.relative_to(WIKI_ROOT)}  ({len(hits)} match{'es' if len(hits) != 1 else ''})")
-        for line_no, snippet in hits[:5]:  # Cap per-file to 5 hits
-            print(f"```")
-            print(snippet)
-            print(f"```")
-
-
-if __name__ == "__main__":
-    main()

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/scripts/install_precommit_hook.sh

@@ -1,55 +0,0 @@
-#!/usr/bin/env bash
-# Install the conditional Phase 3 pre-commit hook into .git/hooks/
-#
-# The installed hook:
-#   - always runs scripts/validate.py
-#   - runs scripts/repo_size_check.py only if data/phase3-size-budget.yaml exists
-#   - runs scripts/check_dod_fixtures.py only if data/phase3-dod-fixtures.yaml exists
-
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-HOOK_PATH="$REPO_ROOT/.git/hooks/pre-commit"
-
-if [ ! -d "$REPO_ROOT/.git" ]; then
-  echo "ERROR: $REPO_ROOT/.git not a directory (is this a git work tree?)" >&2
-  exit 2
-fi
-
-cat > "$HOOK_PATH" <<'HOOK'
-#!/usr/bin/env bash
-# Auto-generated Phase 3 pre-commit hook
-set -u
-REPO_ROOT="$(git rev-parse --show-toplevel)"
-cd "$REPO_ROOT"
-
-echo "[pre-commit] validate.py"
-python3 scripts/validate.py
-status=$?
-if [ $status -ne 0 ]; then
-  echo "[pre-commit] validate.py failed"; exit $status
-fi
-
-if [ -f "data/phase3-size-budget.yaml" ]; then
-  echo "[pre-commit] repo_size_check.py"
-  python3 scripts/repo_size_check.py
-  status=$?
-  if [ $status -ne 0 ]; then
-    echo "[pre-commit] repo_size_check.py failed"; exit $status
-  fi
-fi
-
-if [ -f "data/phase3-dod-fixtures.yaml" ]; then
-  echo "[pre-commit] check_dod_fixtures.py"
-  python3 scripts/check_dod_fixtures.py
-  status=$?
-  if [ $status -ne 0 ]; then
-    echo "[pre-commit] check_dod_fixtures.py failed"; exit $status
-  fi
-fi
-
-exit 0
-HOOK
-
-chmod +x "$HOOK_PATH"
-echo "Installed pre-commit hook at $HOOK_PATH"

package/resources/kop-2026-10-23-0.1.17-beta.1/product_capabilities/kernel_optflow/skills/KernelWiki-private/scripts/localize.py

@@ -1,257 +0,0 @@
-#!/usr/bin/env python3
-"""Localization tool for the two-tier source corpus.
-
-Manages user-specific configuration for resolving {{PLACEHOLDER}} variables
-in MANIFEST.yaml tier-2 entries.
-
-Usage:
-    python3 scripts/localize.py init-config   # Create localize.yaml from example
-    python3 scripts/localize.py check         # Verify all paths
-    python3 scripts/localize.py link          # Create .external/ symlinks
-    python3 scripts/localize.py resolve-vars  # Show resolved variable values
-    python3 scripts/localize.py doctor        # Full health check
-"""
-
-import argparse
-import os
-import re
-import sys
-import yaml
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).parent.parent
-CORPUS_DIR = REPO_ROOT / "corpus"
-CONFIG_PATH = CORPUS_DIR / "localize.yaml"
-EXAMPLE_PATH = CORPUS_DIR / "localize.yaml.example"
-MANIFEST_PATH = CORPUS_DIR / "MANIFEST.yaml"
-EXTERNAL_DIR = CORPUS_DIR / ".external"
-
-PLACEHOLDER_RE = re.compile(r'\{\{(\w+)\}\}')
-
-
-def load_config():
-    """Load localize.yaml and resolve derived variables."""
-    if not CONFIG_PATH.exists():
-        return None
-    with open(CONFIG_PATH, encoding="utf-8") as f:
-        config = yaml.safe_load(f) or {}
-
-    vars_ = dict(config.get("vars", {}) or {})
-    derived = dict(config.get("derived", {}) or {})
-
-    # Resolve environment variables if inherit is true
-    env_config = config.get("env", {}) or {}
-    if env_config.get("inherit", False):
-        # Scan manifest for placeholder names not already in vars_/derived
-        known_keys = set(vars_) | set(derived)
-        manifest_placeholders = set()
-        if MANIFEST_PATH.exists():
-            try:
-                manifest_text = MANIFEST_PATH.read_text(encoding="utf-8")
-                manifest_placeholders = set(PLACEHOLDER_RE.findall(manifest_text))
-            except Exception:
-                pass
-        for key in manifest_placeholders - known_keys:
-            env_val = os.environ.get(key)
-            if env_val:
-                vars_[key] = env_val
-
-    # Resolve derived variables (may reference vars)
-    resolved = dict(vars_)
-    for key, val in derived.items():
-        if isinstance(val, str):
-            for m in PLACEHOLDER_RE.finditer(val):
-                ref = m.group(1)
-                if ref in resolved:
-                    val = val.replace(f"{{{{{ref}}}}}", str(resolved[ref]))
-        resolved[key] = val
-
-    return resolved
-
-
-def resolve_path(path_str, variables):
-    """Resolve a path string, replacing {{PLACEHOLDER}} with values."""
-    if not variables:
-        return path_str
-    result = path_str
-    for m in PLACEHOLDER_RE.finditer(path_str):
-        var = m.group(1)
-        if var in variables:
-            result = result.replace(f"{{{{{var}}}}}", str(variables[var]))
-    return result
-
-
-def load_manifest():
-    """Load MANIFEST.yaml entries."""
-    if not MANIFEST_PATH.exists():
-        return []
-    with open(MANIFEST_PATH, encoding="utf-8") as f:
-        data = yaml.safe_load(f)
-    return data if isinstance(data, list) else []
-
-
-def cmd_init_config(args):
-    """Create localize.yaml from the example template."""
-    if CONFIG_PATH.exists() and not args.force:
-        print(f"Config already exists: {CONFIG_PATH}")
-        print("Use --force to overwrite.")
-        return 1
-    if not EXAMPLE_PATH.exists():
-        print(f"Example not found: {EXAMPLE_PATH}")
-        return 1
-    import shutil
-    shutil.copy2(EXAMPLE_PATH, CONFIG_PATH)
-    print(f"Created {CONFIG_PATH} from example.")
-    print(f"Edit it to set your local paths, then run: python3 {__file__} check")
-    return 0
-
-
-def cmd_check(args):
-    """Check that all placeholders have values and paths exist."""
-    variables = load_config()
-    manifest = load_manifest()
-    has_config = variables is not None
-
-    if not has_config:
-        print(f"WARN  No localize.yaml found at {CONFIG_PATH}")
-        print(f"      Tier-2 external repos will not be accessible.")
-        print(f"      Run: python3 {__file__} init-config")
-        variables = {}
-
-    ok = 0
-    warn = 0
-    for entry in manifest:
-        sid = entry.get("source_id", "")
-        lpath = entry.get("local_path", "")
-
-        if PLACEHOLDER_RE.search(lpath):
-            # Tier-2: external reference
-            resolved = resolve_path(lpath, variables)
-            if PLACEHOLDER_RE.search(resolved):
-                unresolved = PLACEHOLDER_RE.findall(resolved)
-                print(f"WARN  {sid} → unresolved placeholders: {unresolved}")
-                warn += 1
-            elif Path(resolved).exists():
-                print(f"OK    {sid} → {resolved} (exists)")
-                ok += 1
-            else:
-                print(f"WARN  {sid} → {resolved} (path not found)")
-                warn += 1
-        else:
-            # Tier-1: in-git
-            full_path = CORPUS_DIR / lpath
-            if full_path.exists():
-                print(f"OK    {sid} → {full_path.relative_to(REPO_ROOT)} (in-git)")
-                ok += 1
-            else:
-                print(f"WARN  {sid} → {lpath} (tier-1 path missing)")
-                warn += 1
-
-    print(f"\n{ok} OK, {warn} warnings")
-    return 0 if warn == 0 else 0  # Warnings don't fail
-
-
-def cmd_link(args):
-    """Create symlinks in .external/ for tier-2 repos."""
-    variables = load_config()
-    if not variables:
-        print("No localize.yaml found. Run init-config first.")
-        return 1
-
-    manifest = load_manifest()
-    EXTERNAL_DIR.mkdir(parents=True, exist_ok=True)
-    created = 0
-
-    for entry in manifest:
-        lpath = entry.get("local_path", "")
-        if not PLACEHOLDER_RE.search(lpath):
-            continue
-        sid = entry.get("source_id", "")
-        resolved = resolve_path(lpath, variables)
-        if PLACEHOLDER_RE.search(resolved):
-            continue
-
-        link_name = sid.split("/")[-1]
-        link_path = EXTERNAL_DIR / link_name
-        if link_path.exists() or link_path.is_symlink():
-            link_path.unlink()
-        try:
-            link_path.symlink_to(resolved)
-            print(f"Linked {link_name} → {resolved}")
-            created += 1
-        except OSError as e:
-            print(f"FAIL  {link_name}: {e}")
-
-    print(f"\nCreated {created} symlinks in {EXTERNAL_DIR.relative_to(REPO_ROOT)}")
-    return 0
-
-
-def cmd_resolve_vars(args):
-    """Show all resolved variable values."""
-    variables = load_config()
-    if not variables:
-        print("No localize.yaml found.")
-        return 1
-    for k, v in sorted(variables.items()):
-        exists = Path(v).exists() if not PLACEHOLDER_RE.search(str(v)) else False
-        status = "exists" if exists else "not found"
-        print(f"  {k} = {v}  ({status})")
-    return 0
-
-
-def cmd_doctor(args):
-    """Full health check: placeholders, paths, MANIFEST consistency."""
-    print("=== Localization Doctor ===\n")
-    print("--- Config ---")
-    variables = load_config()
-    if variables:
-        print(f"  Config: {CONFIG_PATH} (loaded)")
-        cmd_resolve_vars(args)
-    else:
-        print(f"  Config: not found (tier-2 unavailable)")
-
-    print("\n--- MANIFEST ---")
-    ret = cmd_check(args)
-
-    print("\n--- Symlinks ---")
-    if EXTERNAL_DIR.exists():
-        for item in sorted(EXTERNAL_DIR.iterdir()):
-            if item.is_symlink():
-                target = item.resolve()
-                exists = target.exists()
-                print(f"  {item.name} → {target} ({'OK' if exists else 'BROKEN'})")
-    else:
-        print("  .external/ not created yet")
-
-    return ret
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Manage source corpus localization")
-    sub = parser.add_subparsers(dest="command")
-
-    p_init = sub.add_parser("init-config", help="Create localize.yaml from example")
-    p_init.add_argument("--force", action="store_true", help="Overwrite existing config")
-
-    sub.add_parser("check", help="Verify placeholder resolution and paths")
-    sub.add_parser("link", help="Create .external/ symlinks")
-    sub.add_parser("resolve-vars", help="Show resolved variables")
-    sub.add_parser("doctor", help="Full health check")
-
-    args = parser.parse_args()
-    if not args.command:
-        parser.print_help()
-        return 1
-
-    cmds = {
-        "init-config": cmd_init_config,
-        "check": cmd_check,
-        "link": cmd_link,
-        "resolve-vars": cmd_resolve_vars,
-        "doctor": cmd_doctor,
-    }
-    return cmds[args.command](args)
-
-
-if __name__ == "__main__":
-    sys.exit(main() or 0)