thachvd-kit 1.0.15 → 1.0.17

package/scripts/init.py

@@ -1,1047 +0,0 @@
-#!/usr/bin/env python3
-"""
-thachvd-kit — Project Init Wizard
-Generates PROJECT_CONTEXT.md and optional platform config files.
-
-Usage:
-    python scripts/init.py                    # Interactive wizard
-    python scripts/init.py --platform all    # Also generate CLAUDE.md + AGENTS.md
-    python scripts/init.py --platform claude  # Only CLAUDE.md
-    python scripts/init.py --platform codex   # Only AGENTS.md
-"""
-
-import sys
-import os
-import argparse
-import json
-import re
-from pathlib import Path
-from datetime import datetime
-
-# ─── Color helpers ──────────────────────────────────────────────────────────
-
-def c(text, code): return f"\033[{code}m{text}\033[0m" if sys.stdout.isatty() else text
-def bold(t): return c(t, "1")
-def green(t): return c(t, "32")
-def cyan(t): return c(t, "36")
-def yellow(t): return c(t, "33")
-def dim(t): return c(t, "2")
-
-# ─── Input helpers ───────────────────────────────────────────────────────────
-
-def ask(prompt, default="", choices=None):
-    """Prompt user for input with optional default and choices."""
-    display_default = f" [{dim(default)}]" if default else ""
-    if choices:
-        print(f"\n  {cyan('Options:')} {', '.join(choices)}")
-    value = input(f"  {bold('→')} {prompt}{display_default}: ").strip()
-    return value if value else default
-
-def ask_multi(prompt, choices, default=None):
-    """Prompt for comma-separated selection from choices."""
-    display_default = ", ".join(default) if isinstance(default, list) else (default or "none")
-    print(f"\n  {cyan('Available:')} {', '.join(f'{i+1}) {c}' for i, c in enumerate(choices))}")
-    raw = input(f"  {bold('→')} {prompt} (numbers or names, comma-separated) [{dim(display_default)}]: ").strip()
-    if not raw:
-        return default or []
-    selected = []
-    for part in raw.replace(",", " ").split():
-        part = part.strip()
-        if part.isdigit():
-            idx = int(part) - 1
-            if 0 <= idx < len(choices):
-                selected.append(choices[idx])
-        elif part in choices:
-            selected.append(part)
-        else:
-            selected.append(part)  # allow free-text
-    return selected
-
-def ask_bool(prompt, default=True):
-    """Yes/no prompt."""
-    default_str = "Y/n" if default else "y/N"
-    val = input(f"  {bold('→')} {prompt} [{dim(default_str)}]: ").strip().lower()
-    if not val:
-        return default
-    return val.startswith("y")
-
-def ask_select(prompt, choices, default=None):
-    default = default or choices[0]
-    return ask(prompt, default=default, choices=choices)
-
-def section(title):
-    print(f"\n{bold(cyan('━━ ' + title + ' '))}")
-
-# ─── Skill resolver ──────────────────────────────────────────────────────────
-
-LANG_SKILLS = {
-    "typescript": ["nodejs-best-practices", "api-design"],
-    "javascript": ["nodejs-best-practices", "api-design"],
-    "python":     ["python-patterns"],
-    "go":         ["golang-patterns", "golang-testing"],
-    "php":        ["api-design"],
-    "rust":       ["rust-pro"],
-    "java":       ["api-design"],
-    "ruby":       ["api-design"],
-    "swift":      ["mobile-design"],
-    "kotlin":     ["mobile-design"],
-    "csharp":     ["api-design"],
-}
-
-FRAMEWORK_SKILLS = {
-    "vue":           ["frontend-design", "tailwind-patterns"],
-    "react":         ["react-frontend", "frontend-design"],
-    "next":          ["nextjs-react-expert", "frontend-design"],
-    "nuxt":          ["frontend-design"],
-    "svelte":        ["frontend-design"],
-    "angular":       ["frontend-design"],
-    "laravel":       ["laravel-patterns", "laravel-security", "laravel-tdd"],
-    "cakephp":       ["api-design"],
-    "symfony":       ["api-design"],
-    "codeigniter":   ["api-design"],
-    "express":       ["nodejs-best-practices", "api-design"],
-    "fastapi":       ["python-patterns", "api-design"],
-    "django":        ["python-patterns", "api-design"],
-    "flask":         ["python-patterns", "api-design"],
-    "gin":           ["golang-patterns", "golang-testing"],
-    "fiber":         ["golang-patterns", "golang-testing"],
-    "echo":          ["golang-patterns", "golang-testing"],
-    "nestjs":        ["nodejs-best-practices", "api-design"],
-    "tauri":         ["rust-pro", "desktop-design"],
-    "axum":          ["rust-pro", "api-design"],
-    "actix":         ["rust-pro", "api-design"],
-    "rails":         ["api-design"],
-    "spring":        ["api-design"],
-    "aspnet":        ["api-design"],
-    "flutter":       ["mobile-design"],
-    "react-native":  ["mobile-design"],
-}
-
-INFRA_SKILLS = {
-    "docker": ["docker-patterns"],
-    "aws":    ["deployment-procedures", "docker-patterns"],
-    "gcp":    ["deployment-procedures", "docker-patterns"],
-    "azure":  ["deployment-procedures", "docker-patterns"],
-    "vercel": ["deployment-procedures"],
-}
-
-def resolve_skills(data):
-    skills = set()
-    lang = data.get("primary_language", "").lower()
-    if lang in LANG_SKILLS:
-        skills.update(LANG_SKILLS[lang])
-    for fw in data.get("frameworks", []):
-        fw_lower = fw.lower()
-        for key, vals in FRAMEWORK_SKILLS.items():
-            if key in fw_lower:
-                skills.update(vals)
-    for infra in data.get("infrastructure", []):
-        infra_lower = infra.lower()
-        for key, vals in INFRA_SKILLS.items():
-            if key in infra_lower:
-                skills.update(vals)
-    skills.update(["clean-code", "systematic-debugging"])
-    return sorted(skills)
-
-FRAMEWORKS_ALL = ["vue", "react", "next", "nuxt", "svelte", "angular",
-                  "laravel", "cakephp", "symfony", "codeigniter",
-                  "express", "fastapi", "django", "flask", "gin", "fiber", "echo", "nestjs",
-                  "rails", "spring", "aspnet",
-                  "tauri", "axum", "actix", "flutter", "react-native"]
-LANGUAGES_ALL = ["typescript", "javascript", "python", "go", "php", "rust", "java", "ruby", "swift", "kotlin", "csharp", "c", "cpp"]
-PROJECT_TYPES_ALL = ["web-app", "api", "mobile", "desktop", "cli", "library", "fullstack"]
-DATABASES_ALL = ["postgres", "mysql", "sqlite", "mongodb", "redis", "dynamodb", "supabase", "prisma", "none"]
-PACKAGE_MANAGERS_ALL = ["npm", "pnpm", "yarn", "bun", "pip", "uv", "poetry", "go mod", "cargo", "composer", "auto-detect"]
-TEST_FRAMEWORKS_ALL = ["jest", "vitest", "pytest", "go test", "phpunit", "pest", "rspec", "junit", "auto-detect"]
-CLOUDS_ALL = ["aws", "gcp", "azure", "vercel", "fly", "railway", "digitalocean", "none"]
-FRONTEND_FRAMEWORKS = ["vue", "react", "next", "nuxt", "svelte", "angular"]
-BACKEND_FRAMEWORKS = ["laravel", "cakephp", "symfony", "codeigniter", "express", "fastapi", "django", "flask", "gin", "fiber", "echo", "nestjs", "rails", "spring", "aspnet", "axum", "actix"]
-MOBILE_DESKTOP_FRAMEWORKS = ["tauri", "flutter", "react-native"]
-IGNORED_SCAN_DIRS = {".git", "node_modules", "vendor", "dist", "build", "coverage", ".next", ".nuxt", ".turbo", ".cache", "storage", "tmp"}
-
-def read_text_if_exists(*parts):
-    path = Path.cwd().joinpath(*parts)
-    try:
-        return path.read_text(encoding="utf-8") if path.exists() else ""
-    except Exception:
-        return ""
-
-def read_json_if_exists(*parts):
-    path = Path.cwd().joinpath(*parts)
-    try:
-        return json.loads(path.read_text(encoding="utf-8")) if path.exists() else None
-    except Exception:
-        return None
-
-def detect_package_manager(base_dir=None):
-    base_dir = base_dir or Path.cwd()
-    if path_exists(base_dir, "pnpm-lock.yaml"): return "pnpm"
-    if path_exists(base_dir, "yarn.lock"): return "yarn"
-    if path_exists(base_dir, "bun.lockb") or path_exists(base_dir, "bun.lock"): return "bun"
-    if path_exists(base_dir, "package-lock.json"): return "npm"
-    if path_exists(base_dir, "uv.lock"): return "uv"
-    if path_exists(base_dir, "poetry.lock"): return "poetry"
-    if path_exists(base_dir, "requirements.txt") or path_exists(base_dir, "pyproject.toml"): return "pip"
-    if path_exists(base_dir, "go.mod"): return "go mod"
-    if path_exists(base_dir, "Cargo.toml"): return "cargo"
-    if path_exists(base_dir, "composer.json"): return "composer"
-    return "auto-detect"
-
-def uniq(values):
-    return list(dict.fromkeys(v for v in values if v))
-
-def path_exists(base_dir, *parts):
-    return base_dir.joinpath(*parts).exists()
-
-def evidence_if(condition, label, weight=1):
-    return {"label": label, "weight": weight} if condition else None
-
-def build_detection(id, evidence, **meta):
-    hits = [hit for hit in evidence if hit]
-    score = sum(hit["weight"] for hit in hits)
-    return {
-        "id": id,
-        "score": score,
-        "evidence": [hit["label"] for hit in hits],
-        **meta,
-    }
-
-def confidence_label(score):
-    if score >= 6: return "high"
-    if score >= 3: return "medium"
-    return "low"
-
-def has_dependency(dep_names, *names):
-    return any(name in dep_names for name in names)
-
-def has_composer_dependency(composer_dep_names, *names):
-    return any(name in composer_dep_names for name in names)
-
-def text_matches(text, pattern):
-    return bool(text and re.search(pattern, text, re.IGNORECASE | re.MULTILINE))
-
-def detect_app_root(base_dir):
-    candidates = [base_dir]
-    queue = [(base_dir, 0)]
-    while queue:
-        current, depth = queue.pop(0)
-        if depth >= 2:
-            continue
-        try:
-            entries = list(current.iterdir())
-        except Exception:
-            continue
-        for entry in entries:
-            if not entry.is_dir():
-                continue
-            if entry.name in IGNORED_SCAN_DIRS:
-                continue
-            candidates.append(entry)
-            queue.append((entry, depth + 1))
-
-    def score_candidate(path):
-        score = 0
-        if path_exists(path, "composer.json"): score += 5
-        if path_exists(path, "package.json"): score += 4
-        if path_exists(path, "Cargo.toml"): score += 4
-        if path_exists(path, "go.mod"): score += 4
-        if path_exists(path, "pyproject.toml") or path_exists(path, "requirements.txt"): score += 4
-        if path_exists(path, "artisan"): score += 5
-        if path_exists(path, "bin", "cake") or path_exists(path, "app", "Config", "core.php"): score += 5
-        if path_exists(path, "src-tauri", "tauri.conf.json") or path_exists(path, "src-tauri", "tauri.conf.json5"): score += 5
-        if path_exists(path, "manage.py"): score += 4
-        if path_exists(path, "Gemfile"): score += 4
-        if path_exists(path, "pom.xml") or path_exists(path, "build.gradle") or path_exists(path, "build.gradle.kts"): score += 4
-        if path_exists(path, "app", "View") or path_exists(path, "resources", "views") or path_exists(path, "templates") or path_exists(path, "app", "views"): score += 2
-        return score
-
-    ranked = [{"path": path, "score": score_candidate(path)} for path in candidates]
-    ranked = [item for item in ranked if item["score"] > 0]
-    ranked.sort(key=lambda item: (-item["score"], len(str(item["path"]))))
-    return ranked[0]["path"] if ranked else base_dir
-
-def repo_has_any(base_dir, relative_paths, max_depth=3):
-    queue = [(base_dir, 0)]
-    while queue:
-        current, depth = queue.pop(0)
-        for rel_parts in relative_paths:
-            if path_exists(current, *rel_parts):
-                return True
-        if depth >= max_depth:
-            continue
-        try:
-            entries = list(current.iterdir())
-        except Exception:
-            continue
-        for entry in entries:
-            if not entry.is_dir():
-                continue
-            if entry.name in IGNORED_SCAN_DIRS:
-                continue
-            queue.append((entry, depth + 1))
-    return False
-
-def scan_project():
-    repo_root = Path.cwd()
-    app_root = detect_app_root(repo_root)
-    pkg = read_json_if_exists(app_root, "package.json") or {}
-    composer = read_json_if_exists(app_root, "composer.json") or {}
-    root_entries = [p.name for p in app_root.iterdir()] if app_root.exists() else []
-    root_csproj = next((name for name in root_entries if name.endswith(".csproj")), "")
-    deps = {}
-    for key in ("dependencies", "devDependencies", "peerDependencies"):
-        deps.update(pkg.get(key, {}) or {})
-    dep_names = set(deps.keys())
-    composer_deps = {}
-    for key in ("require", "require-dev"):
-        composer_deps.update(composer.get(key, {}) or {})
-    composer_dep_names = set(composer_deps.keys())
-    requirements = read_text_if_exists(app_root, "requirements.txt")
-    pyproject = read_text_if_exists(app_root, "pyproject.toml")
-    go_mod = read_text_if_exists(app_root, "go.mod")
-    pubspec = read_text_if_exists(app_root, "pubspec.yaml")
-    gemfile = read_text_if_exists(app_root, "Gemfile")
-    pom = read_text_if_exists(app_root, "pom.xml")
-    gradle = f"{read_text_if_exists(app_root, 'build.gradle')}\n{read_text_if_exists(app_root, 'build.gradle.kts')}"
-    cargo = f"{read_text_if_exists(app_root, 'Cargo.toml')}\n{read_text_if_exists(app_root, 'src-tauri/Cargo.toml')}"
-    csproj = read_text_if_exists(app_root, root_csproj) if root_csproj else ""
-    program_cs = read_text_if_exists(app_root, "Program.cs")
-
-    language_detections = [
-        build_detection("typescript", [
-            evidence_if(path_exists(app_root, "tsconfig.json"), "found tsconfig.json", 4),
-            evidence_if(has_dependency(dep_names, "typescript", "ts-node", "tsx"), "package.json -> typescript toolchain", 2),
-        ]),
-        build_detection("javascript", [
-            evidence_if(path_exists(app_root, "package.json"), "found package.json", 2),
-            evidence_if(bool(dep_names), "package.json -> JavaScript dependency graph", 1),
-        ]),
-        build_detection("python", [
-            evidence_if(path_exists(app_root, "requirements.txt"), "found requirements.txt", 3),
-            evidence_if(path_exists(app_root, "pyproject.toml"), "found pyproject.toml", 2),
-            evidence_if(text_matches(pyproject, r"\[tool\.(poetry|uv|hatch|pdm)\]"), "pyproject.toml -> Python tool section", 2),
-        ]),
-        build_detection("go", [
-            evidence_if(path_exists(app_root, "go.mod"), "found go.mod", 4),
-        ]),
-        build_detection("php", [
-            evidence_if(path_exists(app_root, "composer.json"), "found composer.json", 4),
-            evidence_if(bool(composer_dep_names), "composer.json -> PHP dependency graph", 1),
-        ]),
-        build_detection("rust", [
-            evidence_if(path_exists(app_root, "Cargo.toml"), "found Cargo.toml", 4),
-            evidence_if(path_exists(app_root, "src-tauri", "Cargo.toml"), "found src-tauri/Cargo.toml", 5),
-        ]),
-        build_detection("java", [
-            evidence_if(path_exists(app_root, "pom.xml"), "found pom.xml", 4),
-            evidence_if(path_exists(app_root, "build.gradle") or path_exists(app_root, "build.gradle.kts"), "found Gradle build file", 3),
-        ]),
-        build_detection("ruby", [
-            evidence_if(path_exists(app_root, "Gemfile"), "found Gemfile", 4),
-            evidence_if(path_exists(app_root, "config.ru"), "found config.ru", 1),
-        ]),
-        build_detection("csharp", [
-            evidence_if(any(name.endswith(".sln") or name.endswith(".csproj") for name in root_entries), "found .sln/.csproj", 4),
-            evidence_if(path_exists(app_root, "Program.cs"), "found Program.cs", 1),
-        ]),
-    ]
-    language_detections = [item for item in language_detections if item["score"] >= 2]
-    language_detections.sort(key=lambda item: item["score"], reverse=True)
-
-    framework_details = [
-        {**build_detection("next", [
-            evidence_if(has_dependency(dep_names, "next"), "package.json -> next", 4),
-            evidence_if(path_exists(app_root, "next.config.js") or path_exists(app_root, "next.config.mjs") or path_exists(app_root, "next.config.ts"), "found next.config.*", 3),
-            evidence_if(path_exists(app_root, "app") or path_exists(app_root, "pages"), "found app/ or pages/", 1),
-        ]), "kind": "frontend", "project_type": "web-app"},
-        {**build_detection("react", [
-            evidence_if(has_dependency(dep_names, "react"), "package.json -> react", 4),
-            evidence_if(has_dependency(dep_names, "react-dom"), "package.json -> react-dom", 2),
-        ]), "kind": "frontend", "project_type": "web-app"},
-        {**build_detection("vue", [
-            evidence_if(has_dependency(dep_names, "vue"), "package.json -> vue", 4),
-        ]), "kind": "frontend", "project_type": "web-app"},
-        {**build_detection("nuxt", [
-            evidence_if(has_dependency(dep_names, "nuxt"), "package.json -> nuxt", 4),
-            evidence_if(path_exists(app_root, "nuxt.config.ts") or path_exists(app_root, "nuxt.config.js"), "found nuxt.config.*", 3),
-        ]), "kind": "frontend", "project_type": "web-app"},
-        {**build_detection("svelte", [
-            evidence_if(has_dependency(dep_names, "svelte", "@sveltejs/kit"), "package.json -> svelte", 4),
-        ]), "kind": "frontend", "project_type": "web-app"},
-        {**build_detection("angular", [
-            evidence_if(has_dependency(dep_names, "@angular/core"), "package.json -> @angular/core", 4),
-            evidence_if(path_exists(app_root, "angular.json"), "found angular.json", 3),
-        ]), "kind": "frontend", "project_type": "web-app"},
-        {**build_detection("express", [
-            evidence_if(has_dependency(dep_names, "express"), "package.json -> express", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "javascript"},
-        {**build_detection("nestjs", [
-            evidence_if(has_dependency(dep_names, "@nestjs/core"), "package.json -> @nestjs/core", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "javascript"},
-        {**build_detection("fastapi", [
-            evidence_if(text_matches(requirements, r"\bfastapi\b") or text_matches(pyproject, r"\bfastapi\b"), "Python deps -> fastapi", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "python"},
-        {**build_detection("django", [
-            evidence_if(text_matches(requirements, r"\bdjango\b") or text_matches(pyproject, r"\bdjango\b"), "Python deps -> django", 4),
-            evidence_if(path_exists(app_root, "manage.py"), "found manage.py", 2),
-            evidence_if(path_exists(app_root, "templates"), "found templates/", 1),
-        ]), "kind": "backend", "project_type": "web-app", "language": "python"},
-        {**build_detection("flask", [
-            evidence_if(text_matches(requirements, r"\bflask\b") or text_matches(pyproject, r"\bflask\b"), "Python deps -> flask", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "python"},
-        {**build_detection("laravel", [
-            evidence_if(has_composer_dependency(composer_dep_names, "laravel/framework"), "composer.json -> laravel/framework", 4),
-            evidence_if(path_exists(app_root, "artisan"), "found artisan", 3),
-            evidence_if(path_exists(app_root, "resources", "views"), "found resources/views", 1),
-        ]), "kind": "backend", "project_type": "web-app", "language": "php"},
-        {**build_detection("cakephp", [
-            evidence_if(has_composer_dependency(composer_dep_names, "cakephp/cakephp"), "composer.json -> cakephp/cakephp", 4),
-            evidence_if(path_exists(app_root, "bin", "cake"), "found bin/cake", 3),
-            evidence_if(path_exists(app_root, "config", "app.php"), "found config/app.php", 2),
-            evidence_if(path_exists(app_root, "app", "Config", "core.php"), "found app/Config/core.php (CakePHP legacy)", 3),
-            evidence_if(path_exists(app_root, "app", "Controller", "AppController.php"), "found app/Controller/AppController.php", 2),
-            evidence_if(path_exists(app_root, "app", "Model", "AppModel.php"), "found app/Model/AppModel.php", 2),
-            evidence_if(path_exists(app_root, "lib", "Cake"), "found lib/Cake", 3),
-            evidence_if(path_exists(app_root, "cake", "console", "cake"), "found cake/console/cake", 3),
-            evidence_if(path_exists(app_root, "app", "View"), "found app/View", 2),
-            evidence_if(any(p.suffix.lower() == ".ctp" for p in app_root.joinpath("app", "View").rglob("*.ctp")) if path_exists(app_root, "app", "View") else False, "found .ctp view templates", 2),
-        ]), "kind": "backend", "project_type": "web-app", "language": "php"},
-        {**build_detection("symfony", [
-            evidence_if(has_composer_dependency(composer_dep_names, "symfony/framework-bundle"), "composer.json -> symfony/framework-bundle", 4),
-            evidence_if(path_exists(app_root, "bin", "console"), "found bin/console", 2),
-            evidence_if(path_exists(app_root, "config", "bundles.php"), "found config/bundles.php", 1),
-            evidence_if(path_exists(app_root, "templates"), "found templates/", 1),
-        ]), "kind": "backend", "project_type": "web-app", "language": "php"},
-        {**build_detection("codeigniter", [
-            evidence_if(has_composer_dependency(composer_dep_names, "codeigniter4/framework"), "composer.json -> codeigniter4/framework", 4),
-            evidence_if(path_exists(app_root, "spark"), "found spark", 2),
-            evidence_if(path_exists(app_root, "app", "Config", "App.php"), "found app/Config/App.php", 1),
-        ]), "kind": "backend", "project_type": "api", "language": "php"},
-        {**build_detection("gin", [
-            evidence_if(text_matches(go_mod, r"\bgithub\.com\/gin-gonic\/gin\b"), "go.mod -> github.com/gin-gonic/gin", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "go"},
-        {**build_detection("fiber", [
-            evidence_if(text_matches(go_mod, r"\bgithub\.com\/gofiber\/fiber\b"), "go.mod -> github.com/gofiber/fiber", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "go"},
-        {**build_detection("echo", [
-            evidence_if(text_matches(go_mod, r"\bgithub\.com\/labstack\/echo\b"), "go.mod -> github.com/labstack/echo", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "go"},
-        {**build_detection("rails", [
-            evidence_if(text_matches(gemfile, r'^\s*gem\s+["\']rails["\']'), "Gemfile -> rails", 4),
-            evidence_if(path_exists(app_root, "bin", "rails"), "found bin/rails", 2),
-            evidence_if(path_exists(app_root, "app", "views"), "found app/views", 1),
-        ]), "kind": "backend", "project_type": "web-app", "language": "ruby"},
-        {**build_detection("spring", [
-            evidence_if(text_matches(pom, r"spring-boot") or text_matches(gradle, r"spring-boot"), "Java build -> spring-boot", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "java"},
-        {**build_detection("aspnet", [
-            evidence_if(text_matches(csproj, r"Microsoft\.NET\.Sdk\.Web"), ".csproj -> Microsoft.NET.Sdk.Web", 4),
-            evidence_if(text_matches(program_cs, r"WebApplication\.CreateBuilder"), "Program.cs -> WebApplication.CreateBuilder", 2),
-        ]), "kind": "backend", "project_type": "api", "language": "csharp"},
-        {**build_detection("tauri", [
-            evidence_if(has_dependency(dep_names, "@tauri-apps/api"), "package.json -> @tauri-apps/api", 4),
-            evidence_if(path_exists(app_root, "src-tauri", "tauri.conf.json") or path_exists(app_root, "src-tauri", "tauri.conf.json5"), "found src-tauri/tauri.conf.*", 4),
-            evidence_if(path_exists(app_root, "src-tauri", "Cargo.toml"), "found src-tauri/Cargo.toml", 2),
-        ]), "kind": "desktop", "project_type": "desktop", "language": "rust"},
-        {**build_detection("axum", [
-            evidence_if(text_matches(cargo, r"\baxum\b"), "Cargo.toml -> axum", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "rust"},
-        {**build_detection("actix", [
-            evidence_if(text_matches(cargo, r"\bactix-web\b"), "Cargo.toml -> actix-web", 4),
-        ]), "kind": "backend", "project_type": "api", "language": "rust"},
-        {**build_detection("flutter", [
-            evidence_if(text_matches(pubspec, r"^\s*flutter\s*:"), "pubspec.yaml -> flutter", 4),
-        ]), "kind": "mobile", "project_type": "mobile"},
-        {**build_detection("react-native", [
-            evidence_if(has_dependency(dep_names, "react-native", "expo"), "package.json -> react-native/expo", 4),
-        ]), "kind": "mobile", "project_type": "mobile"},
-    ]
-    framework_details = [item for item in framework_details if item["score"] >= 3]
-    framework_details.sort(key=lambda item: item["score"], reverse=True)
-    for item in framework_details:
-        item["confidence"] = confidence_label(item["score"])
-
-    framework_language_scores = {}
-    for item in framework_details:
-        if item.get("language"):
-            framework_language_scores[item["language"]] = framework_language_scores.get(item["language"], 0) + item["score"]
-    primary_language = max(framework_language_scores, key=framework_language_scores.get) if framework_language_scores else (language_detections[0]["id"] if language_detections else "typescript")
-    frameworks = [item["id"] for item in framework_details if item["id"] in FRAMEWORKS_ALL]
-    frameworks = uniq(frameworks)
-    infrastructure = []
-    project_type = ""
-    database = "none"
-    test_framework = "auto-detect"
-    cloud = "none"
-    ci_cd = "none"
-
-    if any(item["project_type"] == "desktop" for item in framework_details): project_type = "desktop"
-    elif any(item["project_type"] == "mobile" for item in framework_details): project_type = "mobile"
-    elif any(item["kind"] == "frontend" for item in framework_details) and any(item["kind"] == "backend" for item in framework_details): project_type = "fullstack"
-    elif any(item["project_type"] == "web-app" for item in framework_details): project_type = "web-app"
-    elif any(item["kind"] == "backend" for item in framework_details): project_type = "api"
-    elif any(item["kind"] == "frontend" for item in framework_details): project_type = "web-app"
-    elif path_exists(app_root, "package.json") and pkg.get("bin"): project_type = "cli"
-    elif primary_language in ["php", "python", "go", "java", "ruby", "csharp", "rust"]: project_type = "api"
-
-    if has_dependency(dep_names, "pg", "postgres", "@prisma/client") or "postgres" in json.dumps(pkg).lower(): database = "postgres"
-    elif has_dependency(dep_names, "mysql", "mysql2"): database = "mysql"
-    elif has_dependency(dep_names, "sqlite3", "better-sqlite3", "rusqlite"): database = "sqlite"
-    elif has_dependency(dep_names, "mongodb", "mongoose"): database = "mongodb"
-    elif has_dependency(dep_names, "redis", "ioredis"): database = "redis"
-    elif has_dependency(dep_names, "@aws-sdk/client-dynamodb"): database = "dynamodb"
-
-    if has_dependency(dep_names, "vitest"): test_framework = "vitest"
-    elif has_dependency(dep_names, "jest"): test_framework = "jest"
-    elif has_dependency(dep_names, "pytest") or text_matches(requirements, r"\bpytest\b") or text_matches(pyproject, r"\bpytest\b"): test_framework = "pytest"
-    elif has_composer_dependency(composer_dep_names, "phpunit/phpunit"): test_framework = "phpunit"
-    elif has_composer_dependency(composer_dep_names, "pestphp/pest"): test_framework = "pest"
-    elif path_exists(app_root, "go.mod"): test_framework = "go test"
-    elif text_matches(gemfile, r'^\s*gem\s+["\']rspec["\']'): test_framework = "rspec"
-
-    if repo_has_any(repo_root, [("Dockerfile",), ("docker-compose.yml",), ("docker-compose.yaml",)]):
-        infrastructure.append("docker")
-
-    if repo_has_any(repo_root, [("vercel.json",)]):
-        cloud = "vercel"
-        infrastructure.append("vercel")
-    elif repo_has_any(repo_root, [("fly.toml",)]):
-        cloud = "fly"
-        infrastructure.append("fly")
-    elif repo_has_any(repo_root, [("railway.json",), ("railway.toml",)]):
-        cloud = "railway"
-        infrastructure.append("railway")
-
-    if repo_has_any(repo_root, [(".github", "workflows")], max_depth=2): ci_cd = "github-actions"
-    elif repo_has_any(repo_root, [(".gitlab-ci.yml",)], max_depth=2): ci_cd = "gitlab-ci"
-    elif repo_has_any(repo_root, [(".circleci", "config.yml")], max_depth=2): ci_cd = "circleci"
-    elif repo_has_any(repo_root, [("Jenkinsfile",)], max_depth=2): ci_cd = "jenkins"
-
-    scan_evidence = []
-    if language_detections:
-        scan_evidence.append(f"language:{language_detections[0]['id']} => {'; '.join(language_detections[0]['evidence'])}")
-    scan_evidence.extend(f"{item['id']} [{item['confidence']}] => {'; '.join(item['evidence'])}" for item in framework_details)
-
-    return {
-        "project_name": Path.cwd().name,
-        "app_root": str(app_root.relative_to(repo_root)) if app_root != repo_root else ".",
-        "description": pkg.get("description") or composer.get("description", "A software project"),
-        "project_type": project_type if project_type in PROJECT_TYPES_ALL else "web-app",
-        "primary_language": primary_language if primary_language in LANGUAGES_ALL else "typescript",
-        "frameworks": frameworks,
-        "framework_details": framework_details,
-        "scan_evidence": scan_evidence,
-        "database": database if database in DATABASES_ALL else "none",
-        "package_manager": detect_package_manager(app_root),
-        "uses_docker": "docker" in infrastructure,
-        "cloud": cloud,
-        "infrastructure": uniq(infrastructure),
-        "ci_cd": ci_cd,
-        "test_framework": test_framework if test_framework in TEST_FRAMEWORKS_ALL else "auto-detect",
-        "max_file_lines": "300",
-        "code_style": "project-standard",
-        "architecture_notes": "<!-- Add notes -->",
-        "current_phase": "Initial setup",
-        "next_phase": "—",
-        "known_issues": "<!-- None yet -->",
-    }
-
-def resolve_agent_table(data):
-    rows = []
-    frameworks = [f.lower() for f in data.get("frameworks", [])]
-    lang = data.get("primary_language", "").lower()
-
-    # Determine frontend agent
-    frontend_fws = [f for f in frameworks if f in FRONTEND_FRAMEWORKS]
-    if frontend_fws:
-        fe_skills = []
-        for fw in frontend_fws:
-            fe_skills.extend(FRAMEWORK_SKILLS.get(fw, []))
-        rows.append(("Frontend UI", "frontend-specialist", ", ".join(set(fe_skills[:3]))))
-
-    # Backend
-    be_skills = list(LANG_SKILLS.get(lang, ["api-design"]))
-    backend_fws = [f for f in frameworks if f in BACKEND_FRAMEWORKS]
-    for fw in backend_fws:
-        be_skills.extend(FRAMEWORK_SKILLS.get(fw, []))
-    rows.append(("Backend API", "backend-specialist", ", ".join(set(be_skills[:3]))))
-
-    # Mobile/Desktop
-    mobile_fws = [f for f in frameworks if f in MOBILE_DESKTOP_FRAMEWORKS]
-    if mobile_fws:
-        mobile_skills = []
-        for fw in mobile_fws:
-            mobile_skills.extend(FRAMEWORK_SKILLS.get(fw, []))
-        rows.append(("Mobile / Desktop", "mobile-developer", ", ".join(set(mobile_skills[:3]))))
-
-    # DevOps
-    if data.get("uses_docker") or data.get("cloud"):
-        rows.append(("DevOps / Infra", "devops-engineer", "docker-patterns, deployment-procedures"))
-
-    rows.append(("Debug", "debugger", "systematic-debugging"))
-    rows.append(("Security", "security-auditor", "vulnerability-scanner"))
-    rows.append(("Planning", "project-planner", "brainstorming, plan-writing"))
-    return rows
-
-# ─── Generators ──────────────────────────────────────────────────────────────
-
-def generate_project_context(data):
-    frameworks = data.get("frameworks", [])
-    infrastructure = data.get("infrastructure", [])
-    agent_table = resolve_agent_table(data)
-    auto_skills = resolve_skills(data)
-    scan_evidence = data.get("scan_evidence", [])
-
-    agent_rows = "\n".join(
-        f"| {task} | `{agent}` | {skills} |"
-        for task, agent, skills in agent_table
-    )
-
-    scan_evidence_block = ""
-    if scan_evidence:
-        scan_evidence_block = f"""
----
-
-## Scan Evidence
-
-These detections were inferred from the current codebase during `init --scan`:
-
-```
-{chr(10).join('- ' + line for line in scan_evidence)}
-```
-"""
-
-    return f"""# PROJECT_CONTEXT.md
-# Generated by thachvd-kit init wizard on {datetime.now().strftime('%Y-%m-%d')}
-# Edit freely — this is your project's brain.
-
-## Project
-
-- **Name:** {data['project_name']}
-- **Description:** {data['description']}
-- **Type:** {data['project_type']}
-
----
-
-## Context Status
-
-```yaml
-context:
-  status: {data.get('context_status', 'baseline')}
-  needs_ai_refinement: {'true' if data.get('needs_ai_refinement') else 'false'}
-  last_refined_at: {data.get('last_refined_at', 'not-yet-refined')}
-```
-
----
-
-## Stack
-
-```yaml
-stack:
-  app_root: {data.get('app_root', '.')}
-  primary_language: {data['primary_language']}
-  frameworks: [{', '.join(frameworks)}]
-  database: {data.get('database', 'none')}
-  infrastructure: [{', '.join(infrastructure)}]
-  package_manager: {data.get('package_manager', 'auto-detect')}
-  test_framework: {data.get('test_framework', 'auto-detect')}
-```
-
-{scan_evidence_block}
-
----
-
-## Agent Routing
-
-| Task Type | Agent | Primary Skills |
-|-----------|-------|----------------|
-{agent_rows}
-
----
-
-## Auto-Resolved Skills
-
-Based on your stack, these skills will be loaded automatically:
-
-```
-{chr(10).join('- ' + s for s in auto_skills)}
-```
-
----
-
-## Project Conventions
-
-- **Max file size:** {data.get('max_file_lines', '300')} lines (then modularize)
-- **Code style:** {data.get('code_style', 'project-standard')}
-
----
-
-## Architecture Notes
-
-{data.get('architecture_notes', '<!-- Add architecture notes, key decisions, patterns used -->')}
-
----
-
-## Current Phase
-
-- **Done:** {data.get('done_phases', '—')}
-- **In Progress:** {data.get('current_phase', 'Initial setup')}
-- **Next:** {data.get('next_phase', '—')}
-
----
-
-## Known Issues / Tasks
-
-{data.get('known_issues', '<!-- Add known issues or pending tasks -->')}
-"""
-
-def generate_claude_md(data):
-    """Generate CLAUDE.md for Claude Code."""
-    return f"""# CLAUDE.md — {data['project_name']}
-# Generated by thachvd-kit. See PROJECT_CONTEXT.md for full stack info.
-# Platform: Claude Code
-
-## Project
-{data['description']}
-Stack: {data['primary_language']} | {', '.join(data.get('frameworks', []))}
-
-## Rules
-- Read PROJECT_CONTEXT.md first for stack details and agent routing.
-- If PROJECT_CONTEXT.md is missing or stale, create/update it before major work.
-- Follow skills in .claude/skills/ (or skills/ if using Antigravity).
-- Tests are mandatory. Verify before claiming done.
-- Max {data.get('max_file_lines', '300')} lines per file.
-
-## Key Skills
-- Plan: `plan-writing` → `executing-plans`
-- Review: `requesting-code-review` / `receiving-code-review`
-- Quality: `clean-code`, `verification-before-completion`
-- Workflow: `subagent-driven-development`, `finishing-a-development-branch`
-
-## Commands
-- `/plan` — Create implementation plan
-- `/debug` — Systematic debugging
-- `/test` — Run test suite
-- `/deploy` — Deploy checklist
-
-See PROJECT_CONTEXT.md for full agent routing table.
-"""
-
-def generate_agents_md(data):
-    """Generate AGENTS.md for Codex and AGENTS-compatible editors."""
-    return f"""# AGENTS.md — {data['project_name']}
-# Generated by thachvd-kit. See PROJECT_CONTEXT.md for full stack info.
-# Platform: Codex / AGENTS-compatible editors
-
-## Project
-{data['description']}
-Stack: {data['primary_language']} | {', '.join(data.get('frameworks', [])) or 'no framework'}
-
-## Mandatory First Action
-- Read `PROJECT_CONTEXT.md` before making plans or code changes.
-- If `PROJECT_CONTEXT.md` is missing or stale, create/update it before major work.
-- If `context.needs_ai_refinement: true`, refine `PROJECT_CONTEXT.md` first, then set:
-  - `context.status: refined`
-  - `context.needs_ai_refinement: false`
-  - `context.last_refined_at: <today>`
-
-## Working Rules
-- Use `.agent/agents`, `.agent/skills`, `.agent/rules`, and `.agent/workflows` as the local project kit.
-- Match the task against the Agent Routing table in `PROJECT_CONTEXT.md`.
-- Load relevant skills before editing code.
-- Tests are mandatory. Verify before claiming done.
-- Keep files under {data.get('max_file_lines', '300')} lines when practical, then split into modules.
-- Update dependent files together when a change crosses boundaries.
-
-## Preferred Workflow
-- Plan work from `PROJECT_CONTEXT.md` first.
-- For feature work, use: `plan-writing` -> `executing-plans` -> `verification-before-completion`.
-- For reviews, use: `requesting-code-review` / `receiving-code-review`.
-- For debugging, use: `systematic-debugging`.
-
-## Key Paths
-- Project context: `PROJECT_CONTEXT.md`
-- Agent kit: `.agent/`
-- Skills: `.agent/skills/`
-- Workflows: `.agent/workflows/`
-
-See `PROJECT_CONTEXT.md` for stack details, routing, and auto-resolved skills.
-"""
-
-def generate_ai_context_refinement_prompt(data):
-    scan_evidence = data.get("scan_evidence", [])
-    evidence_block = "\n".join("- " + line for line in scan_evidence) if scan_evidence else "- No scan evidence was captured during init."
-    return f"""# AI Context Refinement
-
-Use this prompt in your AI editor after `thachvd-kit init`.
-
-## Goal
-
-Refine `PROJECT_CONTEXT.md` so it reflects the real project more accurately than the baseline init scan.
-
-## Current Baseline
-
-- Project: {data['project_name']}
-- Type: {data['project_type']}
-- Stack: {data['primary_language']} | {', '.join(data.get('frameworks', [])) or 'no framework'}
-- Database: {data.get('database', 'none')}
-- Infra: {', '.join(data.get('infrastructure', [])) or 'none'}
-
-## Scan Evidence
-
-{evidence_block}
-
-## Instructions For The AI Agent
-
-1. Read `PROJECT_CONTEXT.md` first.
-2. Inspect the project selectively to improve factual accuracy.
-3. Prioritize:
-   - real database/config detection
-   - domain/capability inference
-   - architecture notes
-   - more accurate auto-resolved skills
-   - important project-specific constraints
-4. Update `PROJECT_CONTEXT.md` directly.
-5. Distinguish facts from inferences when uncertain.
-6. Do not implement product code in this pass. Only refine project context.
-
-## Suggested Files To Inspect
-
-- Root manifests: `package.json`, `composer.json`, `Cargo.toml`, `pyproject.toml`
-- Infrastructure/config: Docker, CI, env, framework config files
-- Database config and models
-- Main app entry points, routing, controllers/services
-- README and existing documentation
-
-## Desired Improvements
-
-- Correct the `database` field if config files reveal the real DB.
-- Add architecture notes that explain the actual structure.
-- Infer domain capabilities such as scraping, browser automation, external API integrations, queues, workers, etc.
-- Expand auto-resolved skills when there is clear evidence in the codebase.
-- Add caveats or assumptions if parts of the stack are still uncertain.
-
-## Completion Standard
-
-When done, summarize:
-- what was corrected
-- what is still inferred
-- which files provided the strongest evidence
-"""
-
-def format_scan_preview_lines(scanned):
-    return [
-        ("App root", scanned.get("app_root", ".")),
-        ("Project type", scanned.get("project_type", "unknown")),
-        ("Primary language", scanned.get("primary_language", "unknown")),
-        ("Frameworks", ", ".join(scanned.get("frameworks", [])) or "no framework"),
-        ("Database", scanned.get("database", "none")),
-        ("Package manager", scanned.get("package_manager", "auto-detect")),
-        ("Test framework", scanned.get("test_framework", "auto-detect")),
-        ("Cloud", scanned.get("cloud", "none")),
-        ("Infrastructure", ", ".join(scanned.get("infrastructure", [])) or "none"),
-        ("CI/CD", scanned.get("ci_cd", "none")),
-    ]
-
-# ─── Main wizard ─────────────────────────────────────────────────────────────
-
-def main():
-    parser = argparse.ArgumentParser(description="thachvd-kit project init wizard")
-    parser.add_argument("--platform", choices=["antigravity", "claude", "codex", "all"], default="antigravity",
-                        help="Which platform config to generate (default: antigravity)")
-    parser.add_argument("--yes", "-y", action="store_true", help="Use defaults without prompting")
-    parser.add_argument("--scan", action="store_true", help="Scan the current project to prefill or auto-generate PROJECT_CONTEXT.md")
-    args = parser.parse_args()
-
-    print(f"""
-{bold(cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))}
-  {bold('thachvd-kit')} — Project Init Wizard
-  Generates PROJECT_CONTEXT.md for smart agent routing{' (scan-assisted)' if args.scan else ''}
-{bold(cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'))}
-""")
-
-    # Check if PROJECT_CONTEXT.md already exists
-    output_path = Path("PROJECT_CONTEXT.md")
-    if output_path.exists() and not args.yes:
-        overwrite = ask_bool(f"{yellow('PROJECT_CONTEXT.md already exists. Overwrite?')}", default=False)
-        if not overwrite:
-            print(f"\n  {yellow('Aborted.')} Existing PROJECT_CONTEXT.md unchanged.\n")
-            sys.exit(0)
-
-    use_scan = args.scan
-    if not args.scan and not args.yes:
-        section("Setup Mode")
-        project_setup = ask_select("Project already exists or are you starting fresh",
-            ["existing", "new"], default="existing")
-        if project_setup == "existing":
-            existing_mode = ask_select("How should thachvd-kit build PROJECT_CONTEXT.md",
-                ["scan", "manual"], default="scan")
-            use_scan = existing_mode == "scan"
-
-    scanned = scan_project() if use_scan else None
-    review_scanned_fields = not use_scan
-    if use_scan:
-        print(f"  {dim('Scan mode: detecting stack from current project files...')}")
-        print(f"  {bold('Detected context:')}")
-        for label, value in format_scan_preview_lines(scanned):
-            print(f"    · {label}: {value}")
-        print()
-        if scanned.get("scan_evidence"):
-            print(f"  {bold('Evidence:')}")
-            for line in scanned["scan_evidence"]:
-                print(f"    · {line}")
-            print()
-        if not args.yes:
-            scan_action = ask_select("Use detected context as-is or review fields manually",
-                ["accept", "review"], default="accept")
-            review_scanned_fields = scan_action == "review"
-    elif not args.yes:
-        print(f"  {dim('Manual mode: asking for project context explicitly.')}\n")
-
-    if args.yes and scanned:
-        data = dict(scanned)
-    else:
-        data = {}
-
-    if not args.yes and review_scanned_fields:
-        # ── Project Info ──────────────────────────────────────────────────────
-        section("Project Info")
-        data["project_name"] = ask("Project name", default=(scanned or {}).get("project_name", Path.cwd().name))
-        data["description"]  = ask("Short description", default=(scanned or {}).get("description", "A software project"))
-        data["project_type"] = ask("Project type",
-            default=(scanned or {}).get("project_type", "web-app"),
-            choices=PROJECT_TYPES_ALL)
-
-        # ── Tech Stack ────────────────────────────────────────────────────────
-        section("Tech Stack")
-
-        data["primary_language"] = ask("Primary language",
-            default=(scanned or {}).get("primary_language", "typescript"),
-            choices=LANGUAGES_ALL)
-
-        frameworks = ask_multi("Frameworks (select all that apply)", FRAMEWORKS_ALL, default=(scanned or {}).get("frameworks", None))
-        data["frameworks"] = frameworks or []
-
-        data["database"] = ask("Database / ORM", default=(scanned or {}).get("database", "postgres"), choices=DATABASES_ALL)
-
-        data["package_manager"] = ask("Package manager", default=(scanned or {}).get("package_manager", "auto-detect"), choices=PACKAGE_MANAGERS_ALL)
-
-        # ── Infrastructure ────────────────────────────────────────────────────
-        section("Infrastructure")
-
-        data["uses_docker"] = ask_bool("Uses Docker / Docker Compose?", default=(scanned or {}).get("uses_docker", True))
-        cloud = ask("Cloud provider", default=(scanned or {}).get("cloud", "none"), choices=CLOUDS_ALL)
-        data["cloud"] = cloud
-
-        infrastructure = []
-        if data["uses_docker"]: infrastructure.append("docker")
-        if cloud != "none": infrastructure.append(cloud)
-        data["infrastructure"] = infrastructure
-
-        CI_CD = ["github-actions", "gitlab-ci", "circleci", "jenkins", "none"]
-        data["ci_cd"] = ask("CI/CD", default=(scanned or {}).get("ci_cd", "github-actions"), choices=CI_CD)
-
-        # ── Testing ───────────────────────────────────────────────────────────
-        section("Testing")
-
-        data["test_framework"] = ask("Test framework", default=(scanned or {}).get("test_framework", "auto-detect"), choices=TEST_FRAMEWORKS_ALL)
-
-        # ── Conventions ───────────────────────────────────────────────────────
-        section("Coding Conventions")
-
-        data["max_file_lines"] = ask("Max lines per file before splitting", default=(scanned or {}).get("max_file_lines", "300"))
-        data["code_style"]     = ask("Code style / linter", default=(scanned or {}).get("code_style", "project-standard"),
-            choices=["eslint", "prettier", "ruff", "gofmt", "pint", "standard", "project-standard"])
-
-        # ── Optional fields ───────────────────────────────────────────────────
-        section("Architecture (Optional — press Enter to skip)")
-
-        data["architecture_notes"] = ask("Key architecture notes", default=(scanned or {}).get("architecture_notes", "<!-- Add notes -->"))
-        data["current_phase"]      = ask("Current phase", default=(scanned or {}).get("current_phase", "Initial setup"))
-        data["next_phase"]         = ask("Next planned phase", default=(scanned or {}).get("next_phase", "—"))
-        data["known_issues"]       = ask("Known issues / tasks", default=(scanned or {}).get("known_issues", "<!-- None yet -->"))
-
-    data["project_name"] = data.get("project_name", (scanned or {}).get("project_name", Path.cwd().name))
-    data["description"] = data.get("description", (scanned or {}).get("description", "A software project"))
-    data["project_type"] = data.get("project_type", (scanned or {}).get("project_type", "web-app"))
-    data["primary_language"] = data.get("primary_language", (scanned or {}).get("primary_language", "typescript"))
-    data["frameworks"] = data.get("frameworks", (scanned or {}).get("frameworks", []))
-    data["database"] = data.get("database", (scanned or {}).get("database", "none"))
-    data["package_manager"] = data.get("package_manager", (scanned or {}).get("package_manager", "auto-detect"))
-    data["uses_docker"] = data.get("uses_docker", (scanned or {}).get("uses_docker", True))
-    data["cloud"] = data.get("cloud", (scanned or {}).get("cloud", "none"))
-    data["test_framework"] = data.get("test_framework", (scanned or {}).get("test_framework", "auto-detect"))
-    data["max_file_lines"] = data.get("max_file_lines", (scanned or {}).get("max_file_lines", "300"))
-    data["code_style"] = data.get("code_style", (scanned or {}).get("code_style", "project-standard"))
-    data["framework_details"] = data.get("framework_details", (scanned or {}).get("framework_details", []))
-    data["scan_evidence"] = data.get("scan_evidence", (scanned or {}).get("scan_evidence", []))
-    data["app_root"] = data.get("app_root", (scanned or {}).get("app_root", "."))
-    data["context_status"] = data.get("context_status", "baseline")
-    data["needs_ai_refinement"] = data.get("needs_ai_refinement", False)
-    data["last_refined_at"] = data.get("last_refined_at", "not-yet-refined")
-    data["architecture_notes"] = data.get("architecture_notes", (scanned or {}).get("architecture_notes", "<!-- Add notes -->"))
-    data["current_phase"] = data.get("current_phase", (scanned or {}).get("current_phase", "Initial setup"))
-    data["next_phase"] = data.get("next_phase", (scanned or {}).get("next_phase", "—"))
-    data["known_issues"] = data.get("known_issues", (scanned or {}).get("known_issues", "<!-- None yet -->"))
-    data["infrastructure"] = []
-    if data["uses_docker"]: data["infrastructure"].append("docker")
-    if data["cloud"] != "none": data["infrastructure"].append(data["cloud"])
-
-    if not args.yes:
-        data["needs_ai_refinement"] = ask_bool("Should the agent refine PROJECT_CONTEXT.md on first session start?", default=use_scan)
-
-    # ── Generate files ────────────────────────────────────────────────────
-    section("Generating Files")
-
-    # PROJECT_CONTEXT.md (always)
-    context_content = generate_project_context(data)
-    output_path.write_text(context_content, encoding="utf-8")
-    print(f"  {green('✓')} {bold('PROJECT_CONTEXT.md')} generated")
-
-    # CLAUDE.md (for Claude Code)
-    if args.platform in ("claude", "all"):
-        claude_path = Path("CLAUDE.md")
-        claude_path.write_text(generate_claude_md(data), encoding="utf-8")
-        print(f"  {green('✓')} {bold('CLAUDE.md')} generated (Claude Code)")
-
-    # AGENTS.md (for Codex / AGENTS-compatible editors)
-    if args.platform in ("codex", "all"):
-        agents_path = Path("AGENTS.md")
-        agents_path.write_text(generate_agents_md(data), encoding="utf-8")
-        print(f"  {green('✓')} {bold('AGENTS.md')} generated (Codex)")
-
-    ai_refine_path = None
-    if data.get("needs_ai_refinement"):
-        ai_refine_path = Path("AI_CONTEXT_REFINEMENT.md")
-        ai_refine_path.write_text(generate_ai_context_refinement_prompt(data), encoding="utf-8")
-        print(f"  {green('✓')} {bold('AI_CONTEXT_REFINEMENT.md')} generated")
-
-    # Summary
-    auto_skills = resolve_skills(data)
-    print(f"""
-{bold(green('━━ Done! ━━'))}
-
-  {bold('Project:')} {data['project_name']}
-  {bold('Stack:')}   {data['primary_language']} | {', '.join(data['frameworks']) or 'no framework'}
-  {bold('Infra:')}   {', '.join(data['infrastructure']) or 'none'}
-
-  {bold('Auto-resolved skills:')}
-{chr(10).join(f'    · {s}' for s in auto_skills)}
-
-  {bold('Generated files:')}
-    · {bold(str(output_path.resolve()))}
-    · {bold(str(Path("CLAUDE.md").resolve())) if args.platform in ("claude", "all") else 'CLAUDE.md not generated for this platform'}
-    · {bold(str(Path("AGENTS.md").resolve())) if args.platform in ("codex", "all") else 'AGENTS.md not generated for this platform'}
-    · {bold(str(ai_refine_path.resolve())) if ai_refine_path else 'AI_CONTEXT_REFINEMENT.md not generated'}
-
-  {bold('Next steps:')}
-    1. Review {bold('PROJECT_CONTEXT.md')} first and add architecture notes
-    2. {"Open " + bold("AI_CONTEXT_REFINEMENT.md") + " in your AI editor to refine project context" if ai_refine_path else "Instruct the agent to read/update " + bold("PROJECT_CONTEXT.md") + " before major tasks"}
-    3. Open project in your AI editor (Antigravity / Claude Code / Codex)
-    4. The agent will read PROJECT_CONTEXT.md on session start
-
-{dim('  Tip: Run with --platform all to also generate CLAUDE.md and AGENTS.md')}
-""")
-
-if __name__ == "__main__":
-    main()