theus-cli-linux-x64 1.2.2 → 1.4.0

package/vendor/theus-arsenal/skills/aprendizaje-continuo-v2/scripts/instinct-cli.py

@@ -1,1918 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLI de instintos - Gestiona los instintos de Aprendizaje continuo v2
-
-v2.1: Instintos con ámbito de proyecto — cada proyecto tiene sus propios
-      instintos, y los globales aplican universalmente.
-
-Comandos:
-  status   - Muestra todos los instintos (proyecto + global) y su estado
-  import   - Importa instintos desde archivo o URL
-  export   - Exporta instintos a un archivo
-  evolve   - Agrupa instintos en skills/comandos/agentes
-  promote  - Promueve instintos de proyecto al ámbito global
-  projects - Lista los proyectos conocidos y sus recuentos de instintos
-  prune    - Elimina instintos pendientes con más de 30 días (TTL)
-"""
-
-import argparse
-import json
-import hashlib
-import os
-import subprocess
-import sys
-import re
-import shutil
-import ipaddress
-import socket
-import urllib.parse
-import urllib.request
-from contextlib import contextmanager
-from pathlib import Path
-from datetime import datetime, timedelta, timezone
-from collections import defaultdict
-from typing import Optional
-
-if sys.platform == "win32":
-    try:
-        sys.stdout.reconfigure(encoding="utf-8")
-        sys.stderr.reconfigure(encoding="utf-8")
-    except Exception:
-        pass
-
-try:
-    import fcntl
-    _HAS_FCNTL = True
-except ImportError:
-    _HAS_FCNTL = False  # Windows — sin bloqueo de archivos
-
-# ─────────────────────────────────────────────
-# Configuración
-# ─────────────────────────────────────────────
-
-def _resolve_arsenal_dir() -> Path:
-    override = os.environ.get("THEUS_AGENT_DATA_HOME")
-    if override:
-        if Path(override).is_absolute():
-            return Path(override)
-        print(f"[arsenal] THEUS_AGENT_DATA_HOME={override!r} no es una ruta absoluta; se ignora", file=sys.stderr)
-
-    return Path.home() / ".theus" / "arsenal"
-
-
-def _strip_remote_credentials(remote_url: str) -> str:
-    return re.sub(r"://[^@]+@", "://", remote_url or "")
-
-
-def _normalize_remote_url(remote_url: str) -> str:
-    if not remote_url:
-        return ""
-
-    is_network = (
-        not remote_url.startswith("file://")
-        and ("://" in remote_url or re.match(r"^[^@/:]+@[^:/]+:", remote_url) is not None)
-    )
-    normalized = _strip_remote_credentials(remote_url)
-    normalized = re.sub(r"^[A-Za-z][A-Za-z0-9+.-]*://", "", normalized)
-    normalized = re.sub(r"^[^@/:]+@([^:/]+):", r"\1/", normalized)
-    normalized = re.sub(r"\.git/?$", "", normalized)
-    normalized = re.sub(r"/+$", "", normalized)
-
-    return normalized.lower() if is_network else normalized
-
-
-def _stream_can_encode(text: str, stream=None) -> bool:
-    stream = stream or sys.stdout
-    encoding = getattr(stream, "encoding", None) or sys.getdefaultencoding()
-    try:
-        text.encode(encoding)
-    except (LookupError, UnicodeEncodeError):
-        return False
-    return True
-
-
-def _confidence_bar(confidence, stream=None) -> str:
-    try:
-        filled = int(float(confidence) * 10)
-    except (TypeError, ValueError):
-        filled = 5
-    filled = max(0, min(10, filled))
-
-    full, empty = ("\u2588", "\u2591") if _stream_can_encode("\u2588\u2591", stream) else ("#", ".")
-    return full * filled + empty * (10 - filled)
-
-
-def _project_hash(value: str) -> str:
-    return hashlib.sha256(value.encode("utf-8")).hexdigest()[:12]
-
-
-ARSENAL_DIR = _resolve_arsenal_dir()
-PROJECTS_DIR = ARSENAL_DIR / "projects"
-REGISTRY_FILE = ARSENAL_DIR / "projects.json"
-
-# Rutas globales (sin ámbito de proyecto)
-GLOBAL_INSTINCTS_DIR = ARSENAL_DIR / "instincts"
-GLOBAL_PERSONAL_DIR = GLOBAL_INSTINCTS_DIR / "personal"
-GLOBAL_INHERITED_DIR = GLOBAL_INSTINCTS_DIR / "inherited"
-GLOBAL_EVOLVED_DIR = ARSENAL_DIR / "evolved"
-GLOBAL_OBSERVATIONS_FILE = ARSENAL_DIR / "observations.jsonl"
-
-# Umbrales para la autopromoción
-PROMOTE_CONFIDENCE_THRESHOLD = 0.8
-PROMOTE_MIN_PROJECTS = 2
-ALLOWED_INSTINCT_EXTENSIONS = (".yaml", ".yml", ".md")
-
-# TTL por defecto de los instintos pendientes (días)
-PENDING_TTL_DAYS = 30
-# Umbral de aviso: mostrar la alerta de caducidad cuando el instinto caduque dentro de estos días
-PENDING_EXPIRY_WARNING_DAYS = 7
-
-# Asegurar que existan los directorios globales (diferido para evitar efectos al importar)
-def _ensure_global_dirs():
-    for d in [GLOBAL_PERSONAL_DIR, GLOBAL_INHERITED_DIR,
-              GLOBAL_EVOLVED_DIR / "skills", GLOBAL_EVOLVED_DIR / "commands", GLOBAL_EVOLVED_DIR / "agents",
-              PROJECTS_DIR]:
-        d.mkdir(parents=True, exist_ok=True)
-
-
-# ─────────────────────────────────────────────
-# Validación de rutas
-# ─────────────────────────────────────────────
-
-def _validate_file_path(path_str: str, must_exist: bool = False) -> Path:
-    """Valida y resuelve una ruta de archivo, protegiendo contra path traversal.
-
-    Lanza ValueError si la ruta es inválida o sospechosa.
-    """
-    path = Path(path_str).expanduser().resolve()
-
-    # Bloquear rutas que escapan hacia directorios del sistema
-    # Se bloquean rutas de sistema concretas pero se permiten dirs temporales (/var/folders en macOS)
-    blocked_prefixes = [
-        "/etc", "/usr", "/bin", "/sbin", "/proc", "/sys",
-        "/var/log", "/var/run", "/var/lib", "/var/spool",
-            # macOS resuelve /etc → /private/etc
-        "/private/etc",
-        "/private/var/log", "/private/var/run", "/private/var/db",
-    ]
-    path_s = str(path)
-    for prefix in blocked_prefixes:
-        if path_s.startswith(prefix + "/") or path_s == prefix:
-            raise ValueError(f"La ruta '{path}' apunta a un directorio del sistema")
-
-    if must_exist and not path.exists():
-        raise ValueError(f"La ruta no existe: {path}")
-
-    return path
-
-
-def _validate_instinct_id(instinct_id: str) -> bool:
-    """Valida los IDs de instinto antes de usarlos en nombres de archivo."""
-    if not instinct_id or len(instinct_id) > 128:
-        return False
-    if "/" in instinct_id or "\\" in instinct_id:
-        return False
-    if ".." in instinct_id:
-        return False
-    if instinct_id.startswith("."):
-        return False
-    return bool(re.match(r"^[A-Za-z0-9][A-Za-z0-9._-]*$", instinct_id))
-
-
-def _validate_import_url(source: str) -> str:
-    """Valida las importaciones remotas de instintos antes de abrir una conexión de red."""
-    parsed = urllib.parse.urlparse(source)
-    if parsed.scheme != "https":
-        raise ValueError("las importaciones remotas de instintos requieren URLs https")
-    if not parsed.hostname:
-        raise ValueError("la URL de importación remota no tiene hostname")
-
-    try:
-        addr_infos = socket.getaddrinfo(parsed.hostname, parsed.port or 443, type=socket.SOCK_STREAM)
-    except socket.gaierror as exc:
-        raise ValueError(f"no se pudo resolver el host de importación remota: {parsed.hostname}") from exc
-
-    for family, _, _, _, sockaddr in addr_infos:
-        host = sockaddr[0]
-        try:
-            ip = ipaddress.ip_address(host)
-        except ValueError:
-            continue
-        if (
-            ip.is_private
-            or ip.is_loopback
-            or ip.is_link_local
-            or ip.is_multicast
-            or ip.is_reserved
-            or ip.is_unspecified
-        ):
-            raise ValueError(f"el host de importación remota resuelve a una dirección no pública: {host}")
-
-    return urllib.parse.urlunparse(parsed)
-
-
-def _fetch_import_url(source: str, *, max_bytes: int = 2 * 1024 * 1024) -> str:
-    """Descarga un archivo remoto de instintos validado, con tamaño y timeout acotados."""
-    url = _validate_import_url(source)
-    req = urllib.request.Request(url, headers={"User-Agent": "Theus-instinct-import/2"})
-    with urllib.request.urlopen(req, timeout=15) as response:
-        content_type = response.headers.get("Content-Type", "")
-        if content_type and not any(
-            allowed in content_type.lower()
-            for allowed in ("text/", "markdown", "yaml", "json", "octet-stream")
-        ):
-            raise ValueError(f"tipo de contenido remoto no soportado: {content_type}")
-        data = response.read(max_bytes + 1)
-    if len(data) > max_bytes:
-        raise ValueError(f"la importación remota supera {max_bytes} bytes")
-    return data.decode("utf-8")
-
-
-def _yaml_quote(value: str) -> str:
-    """Entrecomilla una cadena para serializarla de forma segura en el frontmatter YAML.
-
-    Usa comillas dobles y escapa las comillas dobles embebidas para evitar
-    YAML malformado cuando el valor contiene comillas.
-    """
-    escaped = value.replace('\\', '\\\\').replace('"', '\\"')
-    return f'"{escaped}"'
-
-
-# ─────────────────────────────────────────────
-# Detección de proyecto (equivalente en Python de detect-project.sh)
-# ─────────────────────────────────────────────
-
-def _git_repo_root(cwd: Optional[str] = None) -> Optional[str]:
-    args = ["git"]
-    if cwd:
-        args.extend(["-C", cwd])
-    args.extend(["rev-parse", "--show-toplevel"])
-    try:
-        result = subprocess.run(args, capture_output=True, text=True, timeout=5)
-        if result.returncode == 0:
-            return result.stdout.strip()
-    except (subprocess.TimeoutExpired, FileNotFoundError):
-        pass
-    return None
-
-
-def _main_worktree_root(project_root: str) -> str:
-    """Devuelve la raíz del worktree principal cuando project_root es un worktree enlazado."""
-    try:
-        result = subprocess.run(
-            ["git", "-C", project_root, "worktree", "list", "--porcelain"],
-            capture_output=True, text=True, timeout=5
-        )
-    except (subprocess.TimeoutExpired, FileNotFoundError):
-        return project_root
-
-    if result.returncode != 0:
-        return project_root
-
-    for line in result.stdout.splitlines():
-        if line.startswith("worktree "):
-            main_root = line.split(" ", 1)[1].strip()
-            return main_root or project_root
-    return project_root
-
-
-def detect_project() -> dict:
-    """Detecta el contexto del proyecto actual. Devuelve un dict con id, name, root, project_dir."""
-    project_root = None
-
-    if os.environ.get("ACV2_NO_PROJECT") == "1":
-        return {
-            "id": "global",
-            "name": "global",
-            "root": "",
-            "project_dir": ARSENAL_DIR,
-            "instincts_personal": GLOBAL_PERSONAL_DIR,
-            "instincts_inherited": GLOBAL_INHERITED_DIR,
-            "evolved_dir": GLOBAL_EVOLVED_DIR,
-            "observations_file": GLOBAL_OBSERVATIONS_FILE,
-        }
-
-    # 1. Variable de entorno THEUS_PROJECT_DIR
-    env_dir = os.environ.get("THEUS_PROJECT_DIR")
-    if env_dir and os.path.isdir(env_dir):
-        project_root = _git_repo_root(env_dir)
-
-    # 2. Raíz del repo git
-    if not project_root:
-        project_root = _git_repo_root()
-
-    # Normalizar: quitar barras finales para mantener estables el basename y el hash
-    if project_root:
-        project_root = project_root.rstrip("/")
-
-    # 3. Sin proyecto — fallback global
-    if not project_root:
-        return {
-            "id": "global",
-            "name": "global",
-            "root": "",
-            "project_dir": ARSENAL_DIR,
-            "instincts_personal": GLOBAL_PERSONAL_DIR,
-            "instincts_inherited": GLOBAL_INHERITED_DIR,
-            "evolved_dir": GLOBAL_EVOLVED_DIR,
-            "observations_file": GLOBAL_OBSERVATIONS_FILE,
-        }
-
-    project_name = os.path.basename(project_root)
-
-    # Derivar el ID del proyecto de la URL del remoto git o de la ruta
-    remote_url = ""
-    try:
-        result = subprocess.run(
-            ["git", "-C", project_root, "remote", "get-url", "origin"],
-            capture_output=True, text=True, timeout=5
-        )
-        if result.returncode == 0:
-            remote_url = result.stdout.strip()
-    except (subprocess.TimeoutExpired, FileNotFoundError):
-        pass
-
-    raw_remote_url = remote_url
-    if remote_url:
-        remote_url = _strip_remote_credentials(remote_url)
-
-    fallback_root = _main_worktree_root(project_root) if not remote_url else project_root
-    legacy_hash_source = remote_url if remote_url else project_root
-    normalized_remote = _normalize_remote_url(remote_url) if remote_url else ""
-    hash_source = normalized_remote if normalized_remote else (remote_url if remote_url else fallback_root)
-    project_id = _project_hash(hash_source)
-
-    project_dir = PROJECTS_DIR / project_id
-
-    if not project_dir.exists():
-        legacy_sources = []
-        if legacy_hash_source and legacy_hash_source != hash_source:
-            legacy_sources.append(legacy_hash_source)
-        if raw_remote_url and raw_remote_url not in {hash_source, legacy_hash_source}:
-            legacy_sources.append(raw_remote_url)
-
-        for legacy_source in legacy_sources:
-            legacy_id = _project_hash(legacy_source)
-            legacy_dir = PROJECTS_DIR / legacy_id
-            if legacy_id != project_id and legacy_dir.exists():
-                try:
-                    legacy_dir.rename(project_dir)
-                except OSError:
-                    project_id = legacy_id
-                    project_dir = legacy_dir
-                break
-
-    # Asegurar la estructura de directorios del proyecto
-    for d in [
-        project_dir / "instincts" / "personal",
-        project_dir / "instincts" / "inherited",
-        project_dir / "observations.archive",
-        project_dir / "evolved" / "skills",
-        project_dir / "evolved" / "commands",
-        project_dir / "evolved" / "agents",
-    ]:
-        d.mkdir(parents=True, exist_ok=True)
-
-    # Actualizar el registro
-    _update_registry(project_id, project_name, project_root, remote_url)
-
-    return {
-        "id": project_id,
-        "name": project_name,
-        "root": project_root,
-        "remote": remote_url,
-        "project_dir": project_dir,
-        "instincts_personal": project_dir / "instincts" / "personal",
-        "instincts_inherited": project_dir / "instincts" / "inherited",
-        "evolved_dir": project_dir / "evolved",
-        "observations_file": project_dir / "observations.jsonl",
-    }
-
-
-@contextmanager
-def _registry_lock():
-    """Serializa el read-modify-write del registro entre sesiones concurrentes.
-
-    Adquiere el mismo lock consultivo para todo escritor del registro
-    (``_update_registry`` y ``_write_registry``) para que ``projects
-    delete/gc/merge`` no pueda intercalarse con una actualización concurrente
-    del hook de observación y corromper ``projects.json``. No hace nada en
-    plataformas sin ``fcntl`` (Windows).
-    """
-    REGISTRY_FILE.parent.mkdir(parents=True, exist_ok=True)
-    lock_path = REGISTRY_FILE.parent / f".{REGISTRY_FILE.name}.lock"
-    lock_fd = None
-    try:
-        if _HAS_FCNTL:
-            lock_fd = open(lock_path, "w")
-            fcntl.flock(lock_fd, fcntl.LOCK_EX)
-        yield
-    finally:
-        if lock_fd is not None:
-            fcntl.flock(lock_fd, fcntl.LOCK_UN)
-            lock_fd.close()
-
-
-def _update_registry(pid: str, pname: str, proot: str, premote: str) -> None:
-    """Actualiza el registro projects.json.
-
-    Usa bloqueo de archivos (donde está disponible) para evitar que sesiones
-    concurrentes pisen las actualizaciones de las demás.
-    """
-    with _registry_lock():
-        try:
-            with open(REGISTRY_FILE, encoding="utf-8") as f:
-                registry = json.load(f)
-        except (FileNotFoundError, json.JSONDecodeError):
-            registry = {}
-        # Un registro que es JSON válido pero no un mapa (p. ej. una lista de un
-        # projects.json corrupto) no debe romper la actualización antes de la
-        # guarda por entrada de abajo: se cae a un dict vacío para sanar el archivo.
-        if not isinstance(registry, dict):
-            registry = {}
-
-        # Espeja al equivalente shell en detect-project.sh: la entrada lleva
-        # "id" y "created_at" junto a los demás campos para que un registro de
-        # projects.json tenga la misma forma sin importar qué vía (CLI Python o
-        # hook shell) lo escribió por última vez. "created_at" se preserva de
-        # cualquier entrada existente; solo "last_seen" avanza al actualizar.
-        now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-        existing = registry.get(pid, {})
-        # Un registro malformado (p. ej. un valor no-dict para este id) no debe
-        # romper la actualización: se cae a un dict vacío para que la reescritura
-        # sane la entrada corrupta, igual que el antiguo sobrescribir incondicional.
-        if not isinstance(existing, dict):
-            existing = {}
-        registry[pid] = {
-            "id": pid,
-            "name": pname,
-            "root": proot,
-            "remote": premote,
-            "created_at": existing.get("created_at", now),
-            "last_seen": now,
-        }
-
-        tmp_file = REGISTRY_FILE.parent / f".{REGISTRY_FILE.name}.tmp.{os.getpid()}"
-        with open(tmp_file, "w", encoding="utf-8") as f:
-            json.dump(registry, f, indent=2)
-            f.flush()
-            os.fsync(f.fileno())
-        os.replace(tmp_file, REGISTRY_FILE)
-
-
-def load_registry() -> dict:
-    """Carga el registro de proyectos."""
-    try:
-        with open(REGISTRY_FILE, encoding="utf-8") as f:
-            return json.load(f)
-    except (FileNotFoundError, json.JSONDecodeError):
-        return {}
-
-
-def _write_registry(registry: dict) -> None:
-    """Escribe el registro de proyectos de forma atómica.
-
-    Mantiene el mismo lock consultivo que ``_update_registry`` para que
-    ``projects delete/gc/merge`` concurrentes y las actualizaciones del hook de
-    observación no puedan corromper el archivo.
-    """
-    with _registry_lock():
-        tmp_file = REGISTRY_FILE.parent / f".{REGISTRY_FILE.name}.tmp.{os.getpid()}"
-        with open(tmp_file, "w", encoding="utf-8") as f:
-            json.dump(registry, f, indent=2)
-            f.write("\n")
-            f.flush()
-            os.fsync(f.fileno())
-        os.replace(tmp_file, REGISTRY_FILE)
-
-
-def _validate_project_id(project_id: str) -> bool:
-    if not project_id or len(project_id) > 128:
-        return False
-    if "/" in project_id or "\\" in project_id or ".." in project_id:
-        return False
-    return bool(re.match(r"^[A-Za-z0-9][A-Za-z0-9._-]*$", project_id))
-
-
-# ─────────────────────────────────────────────
-# Parser de instintos
-# ─────────────────────────────────────────────
-
-def parse_instinct_file(content: str) -> list[dict]:
-    """Parsea el formato de archivo de instintos tipo YAML.
-
-    Cada instinto está delimitado por un par de marcadores ``---`` (frontmatter
-    YAML). Nota: ``---`` siempre se trata como frontera del frontmatter; el
-    cuerpo del instinto debe usar ``***`` o ``___`` para las reglas horizontales
-    y así evitar ambigüedad.
-    """
-    instincts = []
-    current = {}
-    in_frontmatter = False
-    content_lines = []
-
-    for line in content.split('\n'):
-        if line.strip() == '---':
-            if in_frontmatter:
-                # Fin del frontmatter - a continuación viene el contenido
-                in_frontmatter = False
-            else:
-                # Inicio de un nuevo bloque de frontmatter
-                in_frontmatter = True
-                if current:
-                    current['content'] = '\n'.join(content_lines).strip()
-                    instincts.append(current)
-                current = {}
-                content_lines = []
-        elif in_frontmatter:
-            # Parsear el frontmatter tipo YAML
-            if ':' in line:
-                key, value = line.split(':', 1)
-                key = key.strip()
-                value = value.strip()
-                # Des-escapar cadenas YAML entrecomilladas
-                if value.startswith('"') and value.endswith('"'):
-                    value = value[1:-1].replace('\\"', '"').replace('\\\\', '\\')
-                elif value.startswith("'") and value.endswith("'"):
-                    value = value[1:-1].replace("''", "'")
-                if key == 'confidence':
-                    try:
-                        current[key] = float(value)
-                    except ValueError:
-                        current[key] = 0.5  # valor por defecto si la confianza está malformada
-                else:
-                    current[key] = value
-        else:
-            content_lines.append(line)
-
-    # No olvidar el último instinto
-    if current:
-        current['content'] = '\n'.join(content_lines).strip()
-        instincts.append(current)
-
-    return [i for i in instincts if i.get('id')]
-
-
-def _load_instincts_from_dir(directory: Path, source_type: str, scope_label: str) -> list[dict]:
-    """Carga los instintos de un único directorio."""
-    instincts = []
-    if not directory.exists():
-        return instincts
-    files = [
-        file for file in sorted(directory.iterdir())
-        if file.is_file() and file.suffix.lower() in ALLOWED_INSTINCT_EXTENSIONS
-    ]
-    for file in files:
-        try:
-            content = file.read_text(encoding="utf-8")
-            parsed = parse_instinct_file(content)
-            for inst in parsed:
-                inst['_source_file'] = str(file)
-                inst['_source_type'] = source_type
-                inst['_scope_label'] = scope_label
-                # Ámbito por defecto si el frontmatter no lo define
-                if 'scope' not in inst:
-                    inst['scope'] = scope_label
-            instincts.extend(parsed)
-        except Exception as e:
-            print(f"Aviso: no se pudo analizar {file}: {e}", file=sys.stderr)
-    return instincts
-
-
-def _project_counts(project_id: str) -> dict:
-    project_dir = PROJECTS_DIR / project_id
-    personal_dir = project_dir / "instincts" / "personal"
-    inherited_dir = project_dir / "instincts" / "inherited"
-    observations_file = project_dir / "observations.jsonl"
-
-    personal_count = len(_load_instincts_from_dir(personal_dir, "personal", "project"))
-    inherited_count = len(_load_instincts_from_dir(inherited_dir, "inherited", "project"))
-    observations_count = 0
-    if observations_file.exists():
-        try:
-            with open(observations_file, encoding="utf-8") as f:
-                observations_count = sum(1 for _ in f)
-        except OSError:
-            observations_count = 0
-
-    return {
-        "personal": personal_count,
-        "inherited": inherited_count,
-        "observations": observations_count,
-        "total": personal_count + inherited_count + observations_count,
-    }
-
-
-def _remove_project_storage(project_id: str) -> None:
-    # Defensa en profundidad: resolver y confirmar que el objetivo está
-    # contenido en PROJECTS_DIR antes de borrar recursivamente, aunque los
-    # llamadores validen el id del proyecto. Un validador laxo o un llamador
-    # futuro jamás deben poder convertir esto en un borrado de directorios
-    # arbitrarios.
-    projects_root = PROJECTS_DIR.resolve()
-    project_dir = (PROJECTS_DIR / project_id).resolve()
-    if project_dir == projects_root or projects_root not in project_dir.parents:
-        raise ValueError(f"se rechaza eliminar {project_dir}: escapa de {projects_root}")
-    if project_dir.exists():
-        shutil.rmtree(project_dir)
-
-
-def _project_instinct_ids(project_dir: Path, source_type: str) -> set[str]:
-    instinct_dir = project_dir / "instincts" / source_type
-    return {
-        inst.get("id")
-        for inst in _load_instincts_from_dir(instinct_dir, source_type, "project")
-        if inst.get("id")
-    }
-
-
-def _merge_instinct_dir(from_dir: Path, into_dir: Path, existing_ids: set[str]) -> tuple[int, int]:
-    moved = 0
-    skipped = 0
-    if not from_dir.exists():
-        return moved, skipped
-
-    into_dir.mkdir(parents=True, exist_ok=True)
-    for file_path in sorted(from_dir.iterdir()):
-        if not file_path.is_file() or file_path.suffix.lower() not in ALLOWED_INSTINCT_EXTENSIONS:
-            continue
-        try:
-            instincts = parse_instinct_file(file_path.read_text(encoding="utf-8"))
-        except (OSError, UnicodeDecodeError):
-            instincts = []
-        instinct_ids = [inst.get("id") for inst in instincts if inst.get("id")]
-        if any(instinct_id in existing_ids for instinct_id in instinct_ids):
-            skipped += 1
-            continue
-
-        target_path = into_dir / file_path.name
-        if target_path.exists():
-            target_path = into_dir / f"{file_path.stem}-{_project_hash(str(file_path))}{file_path.suffix}"
-        shutil.copy2(file_path, target_path)
-        existing_ids.update(instinct_ids)
-        moved += 1
-
-    return moved, skipped
-
-
-def _append_observations(from_project_dir: Path, into_project_dir: Path) -> int:
-    from_file = from_project_dir / "observations.jsonl"
-    if not from_file.exists():
-        return 0
-
-    into_file = into_project_dir / "observations.jsonl"
-    into_file.parent.mkdir(parents=True, exist_ok=True)
-    try:
-        lines = from_file.read_text(encoding="utf-8").splitlines()
-    except (OSError, UnicodeDecodeError):
-        return 0
-
-    if not lines:
-        return 0
-
-    with open(into_file, "a", encoding="utf-8") as f:
-        for line in lines:
-            if line.strip():
-                f.write(line.rstrip("\n") + "\n")
-    return len([line for line in lines if line.strip()])
-
-
-def load_all_instincts(project: dict, include_global: bool = True) -> list[dict]:
-    """Carga todos los instintos: de proyecto + globales.
-
-    Los instintos de proyecto tienen precedencia sobre los globales cuando los
-    IDs colisionan.
-    """
-    instincts = []
-
-    # 1. Cargar los instintos de proyecto (si no estamos ya en global)
-    if project["id"] != "global":
-        instincts.extend(_load_instincts_from_dir(
-            project["instincts_personal"], "personal", "project"
-        ))
-        instincts.extend(_load_instincts_from_dir(
-            project["instincts_inherited"], "inherited", "project"
-        ))
-
-    # 2. Cargar los instintos globales
-    if include_global:
-        global_instincts = []
-        global_instincts.extend(_load_instincts_from_dir(
-            GLOBAL_PERSONAL_DIR, "personal", "global"
-        ))
-        global_instincts.extend(_load_instincts_from_dir(
-            GLOBAL_INHERITED_DIR, "inherited", "global"
-        ))
-
-        # Deduplicar: el de proyecto gana al global cuando el ID coincide
-        project_ids = {i.get('id') for i in instincts}
-        for gi in global_instincts:
-            if gi.get('id') not in project_ids:
-                instincts.append(gi)
-
-    return instincts
-
-
-def load_project_only_instincts(project: dict) -> list[dict]:
-    """Carga solo los instintos de ámbito de proyecto (sin globales).
-
-    En modo de fallback global (sin proyecto git), devuelve los globales.
-    """
-    if project.get("id") == "global":
-        instincts = _load_instincts_from_dir(GLOBAL_PERSONAL_DIR, "personal", "global")
-        instincts += _load_instincts_from_dir(GLOBAL_INHERITED_DIR, "inherited", "global")
-        return instincts
-    return load_all_instincts(project, include_global=False)
-
-
-# ─────────────────────────────────────────────
-# Comando status
-# ─────────────────────────────────────────────
-
-def cmd_status(args) -> int:
-    """Muestra el estado de todos los instintos (proyecto + global)."""
-    project = detect_project()
-    instincts = load_all_instincts(project)
-
-    if not instincts:
-        print("No se encontraron instintos.")
-        print(f"\nProyecto: {project['name']} ({project['id']})")
-        print(f"  Instintos del proyecto:  {project['instincts_personal']}")
-        print(f"  Instintos globales:      {GLOBAL_PERSONAL_DIR}")
-    else:
-        # Separar por ámbito
-        project_instincts = [i for i in instincts if i.get('_scope_label') == 'project']
-        global_instincts = [i for i in instincts if i.get('_scope_label') == 'global']
-
-        # Imprimir la cabecera
-        print(f"\n{'='*60}")
-        print(f"  ESTADO DE INSTINTOS - {len(instincts)} en total")
-        print(f"{'='*60}\n")
-
-        print(f"  Proyecto: {project['name']} ({project['id']})")
-        print(f"  Instintos del proyecto: {len(project_instincts)}")
-        print(f"  Instintos globales:  {len(global_instincts)}")
-        print()
-
-        # Imprimir los instintos de proyecto
-        if project_instincts:
-            print(f"## ÁMBITO DE PROYECTO ({project['name']})")
-            print()
-            _print_instincts_by_domain(project_instincts)
-
-        # Imprimir los instintos globales
-        if global_instincts:
-            print("## GLOBALES (aplican a todos los proyectos)")
-            print()
-            _print_instincts_by_domain(global_instincts)
-
-        # Estadísticas de observaciones
-        obs_file = project.get("observations_file")
-        if obs_file and Path(obs_file).exists():
-            with open(obs_file, encoding="utf-8") as f:
-                obs_count = sum(1 for _ in f)
-            print(f"-" * 60)
-            print(f"  Observaciones: {obs_count} eventos registrados")
-            print(f"  Archivo: {obs_file}")
-
-    # Estadísticas de instintos pendientes
-    pending = _collect_pending_instincts()
-    if pending:
-        print(f"\n{'-'*60}")
-        print(f"  Instintos pendientes: {len(pending)} a la espera de revisión")
-
-        if len(pending) >= 5:
-            print(f"\n  \u26a0 {len(pending)} instintos pendientes de revisión."
-                  f" Los instintos sin revisar se eliminan automáticamente tras {PENDING_TTL_DAYS} días.")
-
-        # Mostrar los instintos que caducan dentro de PENDING_EXPIRY_WARNING_DAYS
-        expiry_threshold = PENDING_TTL_DAYS - PENDING_EXPIRY_WARNING_DAYS
-        expiring_soon = [p for p in pending
-                         if p["age_days"] >= expiry_threshold and p["age_days"] < PENDING_TTL_DAYS]
-        if expiring_soon:
-            print(f"\n  Caducan en menos de {PENDING_EXPIRY_WARNING_DAYS} días:")
-            for item in expiring_soon:
-                days_left = max(0, PENDING_TTL_DAYS - item["age_days"])
-                print(f"    - {item['name']} ({days_left} días restantes)")
-
-    print(f"\n{'='*60}\n")
-    return 0
-
-
-def _print_instincts_by_domain(instincts: list[dict]) -> None:
-    """Helper para imprimir los instintos agrupados por dominio."""
-    by_domain = defaultdict(list)
-    for inst in instincts:
-        domain = inst.get('domain', 'general')
-        by_domain[domain].append(inst)
-
-    for domain in sorted(by_domain.keys()):
-        domain_instincts = by_domain[domain]
-        print(f"  ### {domain.upper()} ({len(domain_instincts)})")
-        print()
-
-        for inst in sorted(domain_instincts, key=lambda x: -x.get('confidence', 0.5)):
-            conf = inst.get('confidence', 0.5)
-            conf_bar = _confidence_bar(conf)
-            trigger = inst.get('trigger', 'disparador desconocido')
-            scope_tag = f"[{inst.get('scope', '?')}]"
-
-            print(f"    {conf_bar} {int(conf*100):3d}%  {inst.get('id', 'unnamed')} {scope_tag}")
-            print(f"              disparador: {trigger}")
-
-            # Extraer la acción del contenido
-            content = inst.get('content', '')
-            action_match = re.search(r'## Action\s*\n\s*(.+?)(?:\n\n|\n##|$)', content, re.DOTALL)
-            if action_match:
-                action = action_match.group(1).strip().split('\n')[0]
-                print(f"              acción: {action[:60]}{'...' if len(action) > 60 else ''}")
-
-            print()
-
-
-# ─────────────────────────────────────────────
-# Comando import
-# ─────────────────────────────────────────────
-
-def cmd_import(args) -> int:
-    """Importa instintos desde un archivo o URL."""
-    project = detect_project()
-    source = args.source
-
-    # Determinar el ámbito destino
-    target_scope = args.scope or "project"
-    if target_scope == "project" and project["id"] == "global":
-        print("No se detectó proyecto. Se importa con ámbito global.")
-        target_scope = "global"
-
-    # Obtener el contenido
-    if source.startswith('http://') or source.startswith('https://'):
-        print(f"Descargando desde URL: {source}")
-        try:
-            content = _fetch_import_url(source)
-        except Exception as e:
-            print(f"Error al descargar la URL: {e}", file=sys.stderr)
-            return 1
-    else:
-        try:
-            path = _validate_file_path(source, must_exist=True)
-        except ValueError as e:
-            print(f"Ruta inválida: {e}", file=sys.stderr)
-            return 1
-        if not path.is_file():
-            print(f"Error: '{path}' no es un archivo regular.", file=sys.stderr)
-            return 1
-        content = path.read_text(encoding="utf-8")
-
-    # Parsear los instintos
-    new_instincts = parse_instinct_file(content)
-    if not new_instincts:
-        print("No se encontraron instintos válidos en el origen.")
-        return 1
-
-    print(f"\nSe encontraron {len(new_instincts)} instintos para importar.")
-    print(f"Ámbito destino: {target_scope}")
-    if target_scope == "project":
-        print(f"Proyecto destino: {project['name']} ({project['id']})")
-    print()
-
-    # Cargar los instintos existentes para deduplicar, acotado al destino para
-    # evitar sombras entre ámbitos (instintos de proyecto ocultando globales o al revés)
-    if target_scope == "global":
-        existing = _load_instincts_from_dir(GLOBAL_PERSONAL_DIR, "personal", "global")
-        existing += _load_instincts_from_dir(GLOBAL_INHERITED_DIR, "inherited", "global")
-    else:
-        existing = load_project_only_instincts(project)
-    existing_ids = {i.get('id') for i in existing}
-
-    # Deduplicar dentro del origen de importación: conservar la mayor confianza por ID
-    best_by_id = {}
-    for inst in new_instincts:
-        inst_id = inst.get('id')
-        if inst_id not in best_by_id or inst.get('confidence', 0.5) > best_by_id[inst_id].get('confidence', 0.5):
-            best_by_id[inst_id] = inst
-    deduped_instincts = list(best_by_id.values())
-
-    # Clasificar contra los instintos existentes en disco
-    to_add = []
-    duplicates = []
-    to_update = []
-
-    for inst in deduped_instincts:
-        inst_id = inst.get('id')
-        if inst_id in existing_ids:
-            existing_inst = next((e for e in existing if e.get('id') == inst_id), None)
-            if existing_inst:
-                if inst.get('confidence', 0) > existing_inst.get('confidence', 0):
-                    to_update.append(inst)
-                else:
-                    duplicates.append(inst)
-        else:
-            to_add.append(inst)
-
-    # Filtrar por confianza mínima
-    min_conf = args.min_confidence if args.min_confidence is not None else 0.0
-    to_add = [i for i in to_add if i.get('confidence', 0.5) >= min_conf]
-    to_update = [i for i in to_update if i.get('confidence', 0.5) >= min_conf]
-
-    # Mostrar el resumen
-    if to_add:
-        print(f"NUEVOS ({len(to_add)}):")
-        for inst in to_add:
-            print(f"  + {inst.get('id')} (confianza: {inst.get('confidence', 0.5):.2f})")
-
-    if to_update:
-        print(f"\nACTUALIZAR ({len(to_update)}):")
-        for inst in to_update:
-            print(f"  ~ {inst.get('id')} (confianza: {inst.get('confidence', 0.5):.2f})")
-
-    if duplicates:
-        print(f"\nOMITIDOS ({len(duplicates)} - ya existen con confianza igual o superior):")
-        for inst in duplicates[:5]:
-            print(f"  - {inst.get('id')}")
-        if len(duplicates) > 5:
-            print(f"  ... y {len(duplicates) - 5} más")
-
-    if args.dry_run:
-        print("\n[DRY RUN] Sin cambios.")
-        return 0
-
-    if not to_add and not to_update:
-        print("\nNada que importar.")
-        return 0
-
-    # Confirmar
-    if not args.force:
-        response = input(f"\n¿Importar {len(to_add)} nuevos y actualizar {len(to_update)}? [s/N] ")
-        if response.lower() not in ('y', 's'):
-            print("Cancelado.")
-            return 0
-
-    # Determinar el directorio de salida según el ámbito
-    if target_scope == "global":
-        output_dir = GLOBAL_INHERITED_DIR
-    else:
-        output_dir = project["instincts_inherited"]
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Recolectar los archivos obsoletos de los instintos que se actualizan (se
-    # borran después de escribir el archivo nuevo). Se permite borrar de cualquier
-    # subdirectorio (personal/ o inherited/) dentro del ámbito destino para evitar
-    # que el mismo ID exista en ambos sitios. Se protege contra borrados entre
-    # ámbitos restringiendo a la raíz de instintos del ámbito.
-    if target_scope == "global":
-        scope_root = GLOBAL_INSTINCTS_DIR.resolve()
-    else:
-        scope_root = (project["project_dir"] / "instincts").resolve() if project["id"] != "global" else GLOBAL_INSTINCTS_DIR.resolve()
-    stale_paths = []
-    for inst in to_update:
-        inst_id = inst.get('id')
-        stale = next((e for e in existing if e.get('id') == inst_id), None)
-        if stale and stale.get('_source_file'):
-            stale_path = Path(stale['_source_file']).resolve()
-            if stale_path.exists() and str(stale_path).startswith(str(scope_root) + os.sep):
-                stale_paths.append(stale_path)
-
-    # Escribir primero el archivo nuevo (seguro: si falla, los obsoletos se conservan)
-    timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
-    source_name = Path(source).stem if not source.startswith('http') else 'web-import'
-    output_file = output_dir / f"{source_name}-{timestamp}.yaml"
-
-    all_to_write = to_add + to_update
-    output_content = f"# Importado desde {source}\n# Fecha: {datetime.now().isoformat()}\n# Ámbito: {target_scope}\n"
-    if target_scope == "project":
-        output_content += f"# Proyecto: {project['name']} ({project['id']})\n"
-    output_content += "\n"
-
-    for inst in all_to_write:
-        output_content += "---\n"
-        output_content += f"id: {inst.get('id')}\n"
-        output_content += f"trigger: {_yaml_quote(inst.get('trigger', 'unknown'))}\n"
-        output_content += f"confidence: {inst.get('confidence', 0.5)}\n"
-        output_content += f"domain: {inst.get('domain', 'general')}\n"
-        output_content += "source: inherited\n"
-        output_content += f"scope: {target_scope}\n"
-        output_content += f"imported_from: {_yaml_quote(source)}\n"
-        if target_scope == "project":
-            output_content += f"project_id: {project['id']}\n"
-            output_content += f"project_name: {project['name']}\n"
-        if inst.get('source_repo'):
-            output_content += f"source_repo: {inst.get('source_repo')}\n"
-        output_content += "---\n\n"
-        output_content += inst.get('content', '') + "\n\n"
-
-    output_file.write_text(output_content, encoding="utf-8")
-
-    # Eliminar los archivos obsoletos solo tras escribir con éxito el archivo nuevo
-    for stale_path in stale_paths:
-        try:
-            stale_path.unlink()
-        except OSError:
-            pass  # eliminación de mejor esfuerzo
-
-    print(f"\n¡Importación completada!")
-    print(f"   Ámbito: {target_scope}")
-    print(f"   Añadidos: {len(to_add)}")
-    print(f"   Actualizados: {len(to_update)}")
-    print(f"   Guardado en: {output_file}")
-
-    return 0
-
-
-# ─────────────────────────────────────────────
-# Comando export
-# ─────────────────────────────────────────────
-
-def cmd_export(args) -> int:
-    """Exporta los instintos a un archivo."""
-    project = detect_project()
-
-    # Determinar qué exportar según el filtro de ámbito
-    if args.scope == "project":
-        instincts = load_project_only_instincts(project)
-    elif args.scope == "global":
-        instincts = _load_instincts_from_dir(GLOBAL_PERSONAL_DIR, "personal", "global")
-        instincts += _load_instincts_from_dir(GLOBAL_INHERITED_DIR, "inherited", "global")
-    else:
-        instincts = load_all_instincts(project)
-
-    if not instincts:
-        print("No hay instintos para exportar.")
-        return 1
-
-    # Filtrar por dominio si se especifica
-    if args.domain:
-        instincts = [i for i in instincts if i.get('domain') == args.domain]
-
-    # Filtrar por confianza mínima
-    if args.min_confidence:
-        instincts = [i for i in instincts if i.get('confidence', 0.5) >= args.min_confidence]
-
-    if not instincts:
-        print("Ningún instinto cumple los criterios.")
-        return 1
-
-    # Generar la salida
-    output = f"# Exportación de instintos\n# Fecha: {datetime.now().isoformat()}\n# Total: {len(instincts)}\n"
-    if args.scope:
-        output += f"# Ámbito: {args.scope}\n"
-    if project["id"] != "global":
-        output += f"# Proyecto: {project['name']} ({project['id']})\n"
-    output += "\n"
-
-    for inst in instincts:
-        output += "---\n"
-        for key in ['id', 'trigger', 'confidence', 'domain', 'source', 'scope',
-                     'project_id', 'project_name', 'source_repo']:
-            if inst.get(key):
-                value = inst[key]
-                if key == 'trigger':
-                    output += f'{key}: {_yaml_quote(value)}\n'
-                else:
-                    output += f"{key}: {value}\n"
-        output += "---\n\n"
-        output += inst.get('content', '') + "\n\n"
-
-    # Escribir al archivo o a stdout
-    if args.output:
-        try:
-            out_path = _validate_file_path(args.output)
-        except ValueError as e:
-            print(f"Ruta de salida inválida: {e}", file=sys.stderr)
-            return 1
-        if out_path.is_dir():
-            print(f"Error: '{out_path}' es un directorio, no un archivo.", file=sys.stderr)
-            return 1
-        out_path.parent.mkdir(parents=True, exist_ok=True)
-        out_path.write_text(output, encoding="utf-8")
-        print(f"Se exportaron {len(instincts)} instintos a {out_path}")
-    else:
-        print(output)
-
-    return 0
-
-
-# ─────────────────────────────────────────────
-# Comando evolve
-# ─────────────────────────────────────────────
-
-def cmd_evolve(args) -> int:
-    """Analiza los instintos y sugiere evoluciones a skills/comandos/agentes."""
-    project = detect_project()
-    instincts = load_all_instincts(project)
-
-    if len(instincts) < 3:
-        print("Se necesitan al menos 3 instintos para analizar patrones.")
-        print(f"Actualmente hay: {len(instincts)}")
-        return 1
-
-    project_instincts = [i for i in instincts if i.get('_scope_label') == 'project']
-    global_instincts = [i for i in instincts if i.get('_scope_label') == 'global']
-
-    print(f"\n{'='*60}")
-    print(f"  ANÁLISIS DE EVOLUCIÓN - {len(instincts)} instintos")
-    print(f"  Proyecto: {project['name']} ({project['id']})")
-    print(f"  De proyecto: {len(project_instincts)} | Globales: {len(global_instincts)}")
-    print(f"{'='*60}\n")
-
-    # Agrupar por dominio
-    by_domain = defaultdict(list)
-    for inst in instincts:
-        domain = inst.get('domain', 'general')
-        by_domain[domain].append(inst)
-
-    # Instintos de alta confianza por dominio (candidatos a skills)
-    high_conf = [i for i in instincts if i.get('confidence', 0) >= 0.8]
-    print(f"Instintos de alta confianza (>=80%): {len(high_conf)}")
-
-    # Buscar clústeres (instintos con disparadores similares)
-    trigger_clusters = defaultdict(list)
-    for inst in instincts:
-        trigger = inst.get('trigger', '')
-        # Normalizar el disparador
-        trigger_key = trigger.lower()
-        for keyword in ['when', 'creating', 'writing', 'adding', 'implementing', 'testing']:
-            trigger_key = trigger_key.replace(keyword, '').strip()
-        trigger_clusters[trigger_key].append(inst)
-
-    # Buscar clústeres con 2+ instintos (buenos candidatos a skill)
-    skill_candidates = []
-    for trigger, cluster in trigger_clusters.items():
-        if len(cluster) >= 2:
-            avg_conf = sum(i.get('confidence', 0.5) for i in cluster) / len(cluster)
-            skill_candidates.append({
-                'trigger': trigger,
-                'instincts': cluster,
-                'avg_confidence': avg_conf,
-                'domains': list(set(i.get('domain', 'general') for i in cluster)),
-                'scopes': list(set(i.get('scope', 'project') for i in cluster)),
-            })
-
-    # Ordenar por tamaño del clúster y confianza
-    skill_candidates.sort(key=lambda x: (-len(x['instincts']), -x['avg_confidence']))
-
-    print(f"\nClústeres de skill potenciales: {len(skill_candidates)}")
-
-    if skill_candidates:
-        print(f"\n## CANDIDATOS A SKILL\n")
-        for i, cand in enumerate(skill_candidates[:5], 1):
-            scope_info = ', '.join(cand['scopes'])
-            print(f"{i}. Clúster: \"{cand['trigger']}\"")
-            print(f"   Instintos: {len(cand['instincts'])}")
-            print(f"   Confianza media: {cand['avg_confidence']:.0%}")
-            print(f"   Dominios: {', '.join(cand['domains'])}")
-            print(f"   Ámbitos: {scope_info}")
-            print(f"   Instintos:")
-            for inst in cand['instincts'][:3]:
-                print(f"     - {inst.get('id')} [{inst.get('scope', '?')}]")
-            print()
-
-    # Candidatos a comando (instintos de workflow con alta confianza)
-    workflow_instincts = [i for i in instincts if i.get('domain') == 'workflow' and i.get('confidence', 0) >= 0.7]
-    if workflow_instincts:
-        print(f"\n## CANDIDATOS A COMANDO ({len(workflow_instincts)})\n")
-        for inst in workflow_instincts[:5]:
-            trigger = inst.get('trigger', 'unknown')
-            cmd_name = trigger.replace('when ', '').replace('implementing ', '').replace('a ', '')
-            cmd_name = cmd_name.replace(' ', '-')[:20]
-            print(f"  /{cmd_name}")
-            print(f"    Desde: {inst.get('id')} [{inst.get('scope', '?')}]")
-            print(f"    Confianza: {inst.get('confidence', 0.5):.0%}")
-            print()
-
-    # Candidatos a agente (patrones complejos de varios pasos)
-    agent_candidates = [c for c in skill_candidates if len(c['instincts']) >= 3 and c['avg_confidence'] >= 0.75]
-    if agent_candidates:
-        print(f"\n## CANDIDATOS A AGENTE ({len(agent_candidates)})\n")
-        for cand in agent_candidates[:3]:
-            agent_name = cand['trigger'].replace(' ', '-')[:20] + '-agent'
-            print(f"  {agent_name}")
-            print(f"    Abarca {len(cand['instincts'])} instintos")
-            print(f"    Confianza media: {cand['avg_confidence']:.0%}")
-            print()
-
-    # Candidatos a promoción (instintos de proyecto que podrían ser globales)
-    _show_promotion_candidates(project)
-
-    if args.generate:
-        evolved_dir = project["evolved_dir"] if project["id"] != "global" else GLOBAL_EVOLVED_DIR
-        generated = _generate_evolved(skill_candidates, workflow_instincts, agent_candidates, evolved_dir)
-        if generated:
-            print(f"\nSe generaron {len(generated)} estructuras evolucionadas:")
-            for path in generated:
-                print(f"   {path}")
-        else:
-            print("\nNo se generaron estructuras (se necesitan clústeres de mayor confianza).")
-
-    print(f"\n{'='*60}\n")
-    return 0
-
-
-# ─────────────────────────────────────────────
-# Comando promote
-# ─────────────────────────────────────────────
-
-def _find_cross_project_instincts() -> dict:
-    """Encuentra instintos que aparecen en varios proyectos (candidatos a promoción).
-
-    Devuelve un dict que mapea ID de instinto → lista de tuplas (project_id, instinto).
-    """
-    registry = load_registry()
-    cross_project = defaultdict(list)
-
-    for pid, pinfo in registry.items():
-        project_dir = PROJECTS_DIR / pid
-        personal_dir = project_dir / "instincts" / "personal"
-        inherited_dir = project_dir / "instincts" / "inherited"
-
-        # Registrar los IDs de instinto ya vistos en este proyecto para no contar
-        # el mismo instinto dos veces (p. ej. en personal/ y en inherited/)
-        seen_in_project = set()
-        for d, stype in [(personal_dir, "personal"), (inherited_dir, "inherited")]:
-            for inst in _load_instincts_from_dir(d, stype, "project"):
-                iid = inst.get('id')
-                if iid and iid not in seen_in_project:
-                    seen_in_project.add(iid)
-                    cross_project[iid].append((pid, pinfo.get('name', pid), inst))
-
-    # Filtrar solo a los que aparecen en 2+ proyectos distintos
-    return {iid: entries for iid, entries in cross_project.items() if len(entries) >= 2}
-
-
-def _show_promotion_candidates(project: dict) -> None:
-    """Muestra los instintos que podrían promoverse de proyecto a global."""
-    cross = _find_cross_project_instincts()
-
-    if not cross:
-        return
-
-    # Filtrar a los de alta confianza que aún no son globales
-    global_instincts = _load_instincts_from_dir(GLOBAL_PERSONAL_DIR, "personal", "global")
-    global_instincts += _load_instincts_from_dir(GLOBAL_INHERITED_DIR, "inherited", "global")
-    global_ids = {i.get('id') for i in global_instincts}
-
-    candidates = []
-    for iid, entries in cross.items():
-        if iid in global_ids:
-            continue
-        avg_conf = sum(e[2].get('confidence', 0.5) for e in entries) / len(entries)
-        if avg_conf >= PROMOTE_CONFIDENCE_THRESHOLD:
-            candidates.append({
-                'id': iid,
-                'projects': [(pid, pname) for pid, pname, _ in entries],
-                'avg_confidence': avg_conf,
-                'sample': entries[0][2],
-            })
-
-    if candidates:
-        print(f"\n## CANDIDATOS A PROMOCIÓN (proyecto -> global)\n")
-        print(f"  Estos instintos aparecen en {PROMOTE_MIN_PROJECTS}+ proyectos con alta confianza:\n")
-        for cand in candidates[:10]:
-            proj_names = ', '.join(pname for _, pname in cand['projects'])
-            print(f"  * {cand['id']} (avg: {cand['avg_confidence']:.0%})")
-            print(f"    Presente en: {proj_names}")
-            print()
-        print(f"  Ejecuta `instinct-cli.py promote` para promoverlos a ámbito global.\n")
-
-
-def cmd_promote(args) -> int:
-    """Promueve instintos de ámbito de proyecto al ámbito global."""
-    project = detect_project()
-
-    if args.instinct_id:
-        # Promover un instinto concreto
-        return _promote_specific(project, args.instinct_id, args.force, args.dry_run)
-    else:
-        # Autodetectar candidatos a promoción
-        return _promote_auto(project, args.force, args.dry_run)
-
-
-def _promote_specific(project: dict, instinct_id: str, force: bool, dry_run: bool = False) -> int:
-    """Promueve un instinto concreto por ID del proyecto actual al ámbito global."""
-    if not _validate_instinct_id(instinct_id):
-        print(f"ID de instinto inválido: '{instinct_id}'.", file=sys.stderr)
-        return 1
-
-    project_instincts = load_project_only_instincts(project)
-    target = next((i for i in project_instincts if i.get('id') == instinct_id), None)
-
-    if not target:
-        print(f"No se encontró el instinto '{instinct_id}' en el proyecto {project['name']}.")
-        return 1
-
-    # Comprobar si ya es global
-    global_instincts = _load_instincts_from_dir(GLOBAL_PERSONAL_DIR, "personal", "global")
-    global_instincts += _load_instincts_from_dir(GLOBAL_INHERITED_DIR, "inherited", "global")
-    if any(i.get('id') == instinct_id for i in global_instincts):
-        print(f"El instinto '{instinct_id}' ya existe en el ámbito global.")
-        return 1
-
-    print(f"\nPromoviendo: {instinct_id}")
-    print(f"  Desde: proyecto '{project['name']}'")
-    print(f"  Confianza: {target.get('confidence', 0.5):.0%}")
-    print(f"  Dominio: {target.get('domain', 'general')}")
-
-    if dry_run:
-        print("\n[DRY RUN] Sin cambios.")
-        return 0
-
-    if not force:
-        response = input(f"\n¿Promover a global? [s/N] ")
-        if response.lower() not in ('y', 's'):
-            print("Cancelado.")
-            return 0
-
-    # Escribir en el directorio personal global
-    output_file = GLOBAL_PERSONAL_DIR / f"{instinct_id}.yaml"
-    output_content = "---\n"
-    output_content += f"id: {target.get('id')}\n"
-    output_content += f"trigger: {_yaml_quote(target.get('trigger', 'unknown'))}\n"
-    output_content += f"confidence: {target.get('confidence', 0.5)}\n"
-    output_content += f"domain: {target.get('domain', 'general')}\n"
-    output_content += f"source: {target.get('source', 'promoted')}\n"
-    output_content += f"scope: global\n"
-    output_content += f"promoted_from: {project['id']}\n"
-    output_content += f"promoted_date: {datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')}\n"
-    output_content += "---\n\n"
-    output_content += target.get('content', '') + "\n"
-
-    output_file.write_text(output_content, encoding="utf-8")
-    print(f"\nInstinto '{instinct_id}' promovido a ámbito global.")
-    print(f"  Guardado en: {output_file}")
-    return 0
-
-
-def _promote_auto(project: dict, force: bool, dry_run: bool) -> int:
-    """Autopromueve los instintos encontrados en varios proyectos."""
-    cross = _find_cross_project_instincts()
-
-    global_instincts = _load_instincts_from_dir(GLOBAL_PERSONAL_DIR, "personal", "global")
-    global_instincts += _load_instincts_from_dir(GLOBAL_INHERITED_DIR, "inherited", "global")
-    global_ids = {i.get('id') for i in global_instincts}
-
-    candidates = []
-    for iid, entries in cross.items():
-        if iid in global_ids:
-            continue
-        avg_conf = sum(e[2].get('confidence', 0.5) for e in entries) / len(entries)
-        if avg_conf >= PROMOTE_CONFIDENCE_THRESHOLD and len(entries) >= PROMOTE_MIN_PROJECTS:
-            candidates.append({
-                'id': iid,
-                'entries': entries,
-                'avg_confidence': avg_conf,
-            })
-
-    if not candidates:
-        print("Ningún instinto califica para promoción automática.")
-        print(f"  Criterios: aparece en {PROMOTE_MIN_PROJECTS}+ proyectos, confianza media >= {PROMOTE_CONFIDENCE_THRESHOLD:.0%}")
-        return 0
-
-    print(f"\n{'='*60}")
-    print(f"  CANDIDATOS A PROMOCIÓN AUTOMÁTICA - {len(candidates)}")
-    print(f"{'='*60}\n")
-
-    for cand in candidates:
-        proj_names = ', '.join(pname for _, pname, _ in cand['entries'])
-        print(f"  {cand['id']} (avg: {cand['avg_confidence']:.0%})")
-        print(f"    Presente en {len(cand['entries'])} proyectos: {proj_names}")
-
-    if dry_run:
-        print(f"\n[DRY RUN] Sin cambios.")
-        return 0
-
-    if not force:
-        response = input(f"\n¿Promover {len(candidates)} instintos a global? [s/N] ")
-        if response.lower() not in ('y', 's'):
-            print("Cancelado.")
-            return 0
-
-    promoted = 0
-    for cand in candidates:
-        if not _validate_instinct_id(cand['id']):
-            print(f"Se omite un ID de instinto inválido durante la promoción: {cand['id']}", file=sys.stderr)
-            continue
-
-        # Usar la versión de mayor confianza
-        best_entry = max(cand['entries'], key=lambda e: e[2].get('confidence', 0.5))
-        inst = best_entry[2]
-
-        output_file = GLOBAL_PERSONAL_DIR / f"{cand['id']}.yaml"
-        output_content = "---\n"
-        output_content += f"id: {inst.get('id')}\n"
-        output_content += f"trigger: {_yaml_quote(inst.get('trigger', 'unknown'))}\n"
-        output_content += f"confidence: {cand['avg_confidence']}\n"
-        output_content += f"domain: {inst.get('domain', 'general')}\n"
-        output_content += f"source: auto-promoted\n"
-        output_content += f"scope: global\n"
-        output_content += f"promoted_date: {datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')}\n"
-        output_content += f"seen_in_projects: {len(cand['entries'])}\n"
-        output_content += "---\n\n"
-        output_content += inst.get('content', '') + "\n"
-
-        output_file.write_text(output_content, encoding="utf-8")
-        promoted += 1
-
-    print(f"\nSe promovieron {promoted} instintos a ámbito global.")
-    return 0
-
-
-# ─────────────────────────────────────────────
-# Comando projects
-# ─────────────────────────────────────────────
-
-def cmd_projects(args) -> int:
-    """Lista o mantiene los proyectos conocidos y sus recuentos de instintos."""
-    if getattr(args, "project_action", None) == "delete":
-        return _cmd_projects_delete(args)
-    if getattr(args, "project_action", None) == "merge":
-        return _cmd_projects_merge(args)
-    if getattr(args, "project_action", None) == "gc":
-        return _cmd_projects_gc(args)
-
-    registry = load_registry()
-
-    if not registry:
-        print("Aún no hay proyectos registrados.")
-        print("Los proyectos se detectan automáticamente cuando usas el CLI en un repo git.")
-        return 0
-
-    print(f"\n{'='*60}")
-    print(f"  PROYECTOS CONOCIDOS - {len(registry)} en total")
-    print(f"{'='*60}\n")
-
-    for pid, pinfo in sorted(registry.items(), key=lambda x: x[1].get('last_seen', ''), reverse=True):
-        project_dir = PROJECTS_DIR / pid
-        personal_dir = project_dir / "instincts" / "personal"
-        inherited_dir = project_dir / "instincts" / "inherited"
-
-        personal_count = len(_load_instincts_from_dir(personal_dir, "personal", "project"))
-        inherited_count = len(_load_instincts_from_dir(inherited_dir, "inherited", "project"))
-        obs_file = project_dir / "observations.jsonl"
-        if obs_file.exists():
-            with open(obs_file, encoding="utf-8") as f:
-                obs_count = sum(1 for _ in f)
-        else:
-            obs_count = 0
-
-        print(f"  {pinfo.get('name', pid)} [{pid}]")
-        print(f"    Raíz: {pinfo.get('root', 'desconocida')}")
-        if pinfo.get('remote'):
-            print(f"    Remoto: {pinfo['remote']}")
-        print(f"    Instintos: {personal_count} personales, {inherited_count} heredados")
-        print(f"    Observaciones: {obs_count} eventos")
-        print(f"    Visto por última vez: {pinfo.get('last_seen', 'desconocido')}")
-        print()
-
-    # Estadísticas globales
-    global_personal = len(_load_instincts_from_dir(GLOBAL_PERSONAL_DIR, "personal", "global"))
-    global_inherited = len(_load_instincts_from_dir(GLOBAL_INHERITED_DIR, "inherited", "global"))
-    print(f"  GLOBAL")
-    print(f"    Instintos: {global_personal} personales, {global_inherited} heredados")
-
-    print(f"\n{'='*60}\n")
-    return 0
-
-
-def _cmd_projects_delete(args) -> int:
-    registry = load_registry()
-    project_id = args.project_id
-
-    if not _validate_project_id(project_id):
-        print(f"ID de proyecto inválido: {project_id}", file=sys.stderr)
-        return 1
-    if project_id not in registry and not (PROJECTS_DIR / project_id).exists():
-        print(f"No se encontró el proyecto '{project_id}'.", file=sys.stderr)
-        return 1
-
-    counts = _project_counts(project_id)
-    print(f"Proyecto: {project_id}")
-    print(f"  Instintos: {counts['personal']} personales, {counts['inherited']} heredados")
-    print(f"  Observaciones: {counts['observations']} eventos")
-
-    if args.dry_run:
-        print(f"\n[DRY RUN] Se eliminaría el proyecto '{project_id}' del registro y del almacenamiento.")
-        return 0
-
-    if not args.force:
-        if counts["total"] > 0:
-            print("\nAviso: este proyecto tiene instintos u observaciones.")
-        response = input(f"¿Eliminar el proyecto '{project_id}'? [s/N] ")
-        if response.lower() not in ("y", "s"):
-            print("Cancelado.")
-            return 0
-
-    registry.pop(project_id, None)
-    _write_registry(registry)
-    _remove_project_storage(project_id)
-    print(f"\nProyecto '{project_id}' eliminado.")
-    return 0
-
-
-def _cmd_projects_gc(args) -> int:
-    registry = load_registry()
-    candidates = [
-        project_id
-        for project_id in sorted(registry)
-        if _validate_project_id(project_id) and _project_counts(project_id)["total"] == 0
-    ]
-
-    if not candidates:
-        print("No se encontraron entradas de proyecto vacías.")
-        return 0
-
-    print(f"Entradas de proyecto vacías: {len(candidates)}")
-    for project_id in candidates:
-        pinfo = registry.get(project_id, {})
-        print(f"  - {pinfo.get('name', project_id)} [{project_id}]")
-
-    if args.dry_run:
-        print(f"\n[DRY RUN] Se eliminarían {len(candidates)} entrada(s) de proyecto.")
-        return 0
-
-    if not args.force:
-        response = input(f"\n¿Eliminar {len(candidates)} entrada(s) de proyecto vacía(s)? [s/N] ")
-        if response.lower() not in ("y", "s"):
-            print("Cancelado.")
-            return 0
-
-    for project_id in candidates:
-        registry.pop(project_id, None)
-        _remove_project_storage(project_id)
-    _write_registry(registry)
-    print(f"\nSe eliminaron {len(candidates)} entrada(s) de proyecto vacía(s).")
-    return 0
-
-
-def _cmd_projects_merge(args) -> int:
-    from_id = args.from_id
-    into_id = args.into_id
-
-    if not _validate_project_id(from_id) or not _validate_project_id(into_id):
-        print("ID de proyecto inválido.", file=sys.stderr)
-        return 1
-    if from_id == into_id:
-        print("No se puede fusionar un proyecto consigo mismo.", file=sys.stderr)
-        return 1
-
-    registry = load_registry()
-    if from_id not in registry:
-        print(f"No se encontró el proyecto de origen '{from_id}'.", file=sys.stderr)
-        return 1
-    if into_id not in registry:
-        print(f"No se encontró el proyecto de destino '{into_id}'.", file=sys.stderr)
-        return 1
-
-    from_counts = _project_counts(from_id)
-    into_counts = _project_counts(into_id)
-    print(f"Fusión: {from_id} -> {into_id}")
-    print(f"  Origen: {from_counts['personal']} personales, {from_counts['inherited']} heredados, {from_counts['observations']} observaciones")
-    print(f"  Destino antes de la fusión: {into_counts['personal']} personales, {into_counts['inherited']} heredados, {into_counts['observations']} observaciones")
-
-    if args.dry_run:
-        print("\n[DRY RUN] Se fusionaría el proyecto de origen en el destino y se eliminaría el origen.")
-        return 0
-
-    if not args.force:
-        response = input(f"\n¿Fusionar '{from_id}' en '{into_id}' y eliminar el origen? [s/N] ")
-        if response.lower() not in ("y", "s"):
-            print("Cancelado.")
-            return 0
-
-    from_project_dir = PROJECTS_DIR / from_id
-    into_project_dir = PROJECTS_DIR / into_id
-    into_project_dir.mkdir(parents=True, exist_ok=True)
-
-    personal_existing = _project_instinct_ids(into_project_dir, "personal")
-    inherited_existing = _project_instinct_ids(into_project_dir, "inherited")
-    personal_moved, personal_skipped = _merge_instinct_dir(
-        from_project_dir / "instincts" / "personal",
-        into_project_dir / "instincts" / "personal",
-        personal_existing,
-    )
-    inherited_moved, inherited_skipped = _merge_instinct_dir(
-        from_project_dir / "instincts" / "inherited",
-        into_project_dir / "instincts" / "inherited",
-        inherited_existing,
-    )
-    observations_moved = _append_observations(from_project_dir, into_project_dir)
-
-    registry.pop(from_id, None)
-    destination = registry.get(into_id, {})
-    destination["last_seen"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-    registry[into_id] = destination
-    _write_registry(registry)
-    _remove_project_storage(from_id)
-
-    print("\nEntrada de registro del proyecto fusionada.")
-    print(f"  Instintos movidos: {personal_moved + inherited_moved}")
-    print(f"  Instintos duplicados omitidos: {personal_skipped + inherited_skipped}")
-    print(f"  Observaciones añadidas: {observations_moved}")
-    return 0
-
-
-# ─────────────────────────────────────────────
-# Generación de estructuras evolucionadas
-# ─────────────────────────────────────────────
-
-def _generate_evolved(skill_candidates: list, workflow_instincts: list, agent_candidates: list, evolved_dir: Path) -> list[str]:
-    """Genera archivos de skill/comando/agente a partir de los clústeres de instintos analizados."""
-    generated = []
-
-    # Generar skills desde los mejores candidatos
-    for cand in skill_candidates[:5]:
-        trigger = cand['trigger'].strip()
-        if not trigger:
-            continue
-        name = re.sub(r'[^a-z0-9]+', '-', trigger.lower()).strip('-')[:30]
-        if not name:
-            continue
-
-        skill_dir = evolved_dir / "skills" / name
-        skill_dir.mkdir(parents=True, exist_ok=True)
-
-        content = f"# {name}\n\n"
-        content += f"Generado a partir de {len(cand['instincts'])} instintos "
-        content += f"(confianza media: {cand['avg_confidence']:.0%})\n\n"
-        content += f"## Cuándo aplicar\n\n"
-        content += f"Disparador: {trigger}\n\n"
-        content += f"## Acciones\n\n"
-        for inst in cand['instincts']:
-            inst_content = inst.get('content', '')
-            action_match = re.search(r'## Action\s*\n\s*(.+?)(?:\n\n|\n##|$)', inst_content, re.DOTALL)
-            action = action_match.group(1).strip() if action_match else inst.get('id', 'unnamed')
-            content += f"- {action}\n"
-
-        (skill_dir / "SKILL.md").write_text(content, encoding="utf-8")
-        generated.append(str(skill_dir / "SKILL.md"))
-
-    # Generar comandos desde los instintos de workflow
-    for inst in workflow_instincts[:5]:
-        trigger = inst.get('trigger', 'unknown')
-        cmd_name = re.sub(r'[^a-z0-9]+', '-', trigger.lower().replace('when ', '').replace('implementing ', ''))
-        cmd_name = cmd_name.strip('-')[:20]
-        if not cmd_name:
-            continue
-
-        cmd_file = evolved_dir / "commands" / f"{cmd_name}.md"
-        content = f"# {cmd_name}\n\n"
-        content += f"Generado a partir del instinto: {inst.get('id', 'unnamed')}\n"
-        content += f"Confianza: {inst.get('confidence', 0.5):.0%}\n\n"
-        content += inst.get('content', '')
-
-        cmd_file.write_text(content, encoding="utf-8")
-        generated.append(str(cmd_file))
-
-    # Generar agentes desde los clústeres complejos
-    for cand in agent_candidates[:3]:
-        trigger = cand['trigger'].strip()
-        agent_name = re.sub(r'[^a-z0-9]+', '-', trigger.lower()).strip('-')[:20]
-        if not agent_name:
-            continue
-
-        agent_file = evolved_dir / "agents" / f"{agent_name}.md"
-        domains = ', '.join(cand['domains'])
-        instinct_ids = [i.get('id', 'unnamed') for i in cand['instincts']]
-
-        content = f"---\ntools: Read, Grep, Glob\n---\n"
-        content += f"# {agent_name}\n\n"
-        content += f"Generado a partir de {len(cand['instincts'])} instintos "
-        content += f"(confianza media: {cand['avg_confidence']:.0%})\n"
-        content += f"Dominios: {domains}\n\n"
-        content += f"## Instintos de origen\n\n"
-        for iid in instinct_ids:
-            content += f"- {iid}\n"
-
-        agent_file.write_text(content, encoding="utf-8")
-        generated.append(str(agent_file))
-
-    return generated
-
-
-# ─────────────────────────────────────────────
-# Helpers de instintos pendientes
-# ─────────────────────────────────────────────
-
-def _collect_pending_dirs() -> list[Path]:
-    """Devuelve todos los directorios de instintos pendientes (global + por proyecto)."""
-    dirs = []
-    global_pending = GLOBAL_INSTINCTS_DIR / "pending"
-    if global_pending.is_dir():
-        dirs.append(global_pending)
-    if PROJECTS_DIR.is_dir():
-        for project_dir in sorted(PROJECTS_DIR.iterdir()):
-            if project_dir.is_dir():
-                pending = project_dir / "instincts" / "pending"
-                if pending.is_dir():
-                    dirs.append(pending)
-    return dirs
-
-
-def _parse_created_date(file_path: Path) -> Optional[datetime]:
-    """Parsea la fecha 'created' del frontmatter YAML de un archivo de instinto.
-
-    Cae al mtime del archivo si no encuentra el campo 'created'.
-    """
-    try:
-        content = file_path.read_text(encoding="utf-8")
-    except (OSError, UnicodeDecodeError):
-        return None
-
-    in_frontmatter = False
-    for line in content.split('\n'):
-        stripped = line.strip()
-        if stripped == '---':
-            if in_frontmatter:
-                break  # fin del frontmatter sin encontrar created
-            in_frontmatter = True
-            continue
-        if in_frontmatter and ':' in line:
-            key, value = line.split(':', 1)
-            if key.strip() == 'created':
-                date_str = value.strip().strip('"').strip("'")
-                for fmt in (
-                    "%Y-%m-%dT%H:%M:%S%z",
-                    "%Y-%m-%dT%H:%M:%SZ",
-                    "%Y-%m-%dT%H:%M:%S",
-                    "%Y-%m-%d",
-                ):
-                    try:
-                        dt = datetime.strptime(date_str, fmt)
-                        if dt.tzinfo is None:
-                            dt = dt.replace(tzinfo=timezone.utc)
-                        return dt
-                    except ValueError:
-                        continue
-
-    # Fallback: hora de modificación del archivo
-    try:
-        mtime = file_path.stat().st_mtime
-        return datetime.fromtimestamp(mtime, tz=timezone.utc)
-    except OSError:
-        return None
-
-
-def _collect_pending_instincts() -> list[dict]:
-    """Recorre todos los directorios de pendientes y devuelve información de cada instinto pendiente.
-
-    Cada dict contiene: path, created, age_days, name, parent_dir.
-    """
-    now = datetime.now(timezone.utc)
-    results = []
-    for pending_dir in _collect_pending_dirs():
-        files = [
-            f for f in sorted(pending_dir.iterdir())
-            if f.is_file() and f.suffix.lower() in ALLOWED_INSTINCT_EXTENSIONS
-        ]
-        for file_path in files:
-            created = _parse_created_date(file_path)
-            if created is None:
-                print(f"Aviso: no se pudo determinar la antigüedad del instinto pendiente: {file_path.name}", file=sys.stderr)
-                continue
-            age = now - created
-            results.append({
-                "path": file_path,
-                "created": created,
-                "age_days": age.days,
-                "name": file_path.stem,
-                "parent_dir": str(pending_dir),
-            })
-    return results
-
-
-# ─────────────────────────────────────────────
-# Comando prune
-# ─────────────────────────────────────────────
-
-def cmd_prune(args) -> int:
-    """Elimina los instintos pendientes que superan el umbral de TTL."""
-    max_age = args.max_age
-    dry_run = args.dry_run
-    quiet = args.quiet
-
-    pending = _collect_pending_instincts()
-
-    expired = [p for p in pending if p["age_days"] >= max_age]
-    remaining = [p for p in pending if p["age_days"] < max_age]
-
-    if dry_run:
-        if not quiet:
-            if expired:
-                print(f"\n[DRY RUN] Se podarían {len(expired)} instinto(s) pendiente(s) con más de {max_age} días:\n")
-                for item in expired:
-                    print(f"  - {item['name']} (antigüedad: {item['age_days']} días) — {item['path']}")
-            else:
-                print(f"No hay instintos pendientes con más de {max_age} días.")
-            print(f"\nResumen: {len(expired)} se podarían, {len(remaining)} restantes")
-        return 0
-
-    pruned = 0
-    pruned_items = []
-    for item in expired:
-        try:
-            item["path"].unlink()
-            pruned += 1
-            pruned_items.append(item)
-        except OSError as e:
-            if not quiet:
-                print(f"Aviso: no se pudo eliminar {item['path']}: {e}", file=sys.stderr)
-
-    if not quiet:
-        if pruned > 0:
-            print(f"\nSe podaron {pruned} instinto(s) pendiente(s) con más de {max_age} días.")
-            for item in pruned_items:
-                print(f"  - {item['name']} (antigüedad: {item['age_days']} días)")
-        else:
-            print(f"No hay instintos pendientes con más de {max_age} días.")
-        failed = len(expired) - pruned
-        remaining_total = len(remaining) + failed
-        print(f"\nResumen: {pruned} podados, {remaining_total} restantes")
-
-    return 0
-
-
-# ─────────────────────────────────────────────
-# Principal
-# ─────────────────────────────────────────────
-
-def main() -> int:
-    _ensure_global_dirs()
-    parser = argparse.ArgumentParser(description='CLI de instintos para Aprendizaje continuo v2.1 (con ámbito de proyecto)')
-    subparsers = parser.add_subparsers(dest='command', help='Comandos disponibles')
-
-    # Status
-    status_parser = subparsers.add_parser('status', help='Muestra el estado de los instintos (proyecto + global)')
-
-    # Import
-    import_parser = subparsers.add_parser('import', help='Importa instintos')
-    import_parser.add_argument('source', help='Ruta de archivo o URL')
-    import_parser.add_argument('--dry-run', action='store_true', help='Vista previa sin importar')
-    import_parser.add_argument('--force', action='store_true', help='Omite la confirmación')
-    import_parser.add_argument('--min-confidence', type=float, help='Umbral mínimo de confianza')
-    import_parser.add_argument('--scope', choices=['project', 'global'], default='project',
-                               help='Ámbito de importación (por defecto: project)')
-
-    # Export
-    export_parser = subparsers.add_parser('export', help='Exporta instintos')
-    export_parser.add_argument('--output', '-o', help='Archivo de salida')
-    export_parser.add_argument('--domain', help='Filtra por dominio')
-    export_parser.add_argument('--min-confidence', type=float, help='Confianza mínima')
-    export_parser.add_argument('--scope', choices=['project', 'global', 'all'], default='all',
-                               help='Ámbito de exportación (por defecto: all)')
-
-    # Evolve
-    evolve_parser = subparsers.add_parser('evolve', help='Analiza y evoluciona los instintos')
-    evolve_parser.add_argument('--generate', action='store_true', help='Genera las estructuras evolucionadas')
-
-    # Promote (nuevo en v2.1)
-    promote_parser = subparsers.add_parser('promote', help='Promueve instintos de proyecto al ámbito global')
-    promote_parser.add_argument('instinct_id', nargs='?', help='ID del instinto concreto a promover')
-    promote_parser.add_argument('--force', action='store_true', help='Omite la confirmación')
-    promote_parser.add_argument('--dry-run', action='store_true', help='Vista previa sin promover')
-
-    # Projects (nuevo en v2.1)
-    projects_parser = subparsers.add_parser('projects', help='Lista los proyectos conocidos y sus recuentos de instintos')
-    projects_subparsers = projects_parser.add_subparsers(dest='project_action')
-    projects_delete = projects_subparsers.add_parser('delete', help='Elimina una entrada del registro de proyectos')
-    projects_delete.add_argument('project_id', help='ID del proyecto a eliminar')
-    projects_delete.add_argument('--dry-run', action='store_true', help='Vista previa sin eliminar')
-    projects_delete.add_argument('--force', action='store_true', help='Omite la confirmación')
-    projects_merge = projects_subparsers.add_parser('merge', help='Fusiona una entrada del registro de proyectos en otra')
-    projects_merge.add_argument('from_id', help='ID del proyecto de origen')
-    projects_merge.add_argument('into_id', help='ID del proyecto de destino')
-    projects_merge.add_argument('--dry-run', action='store_true', help='Vista previa sin fusionar')
-    projects_merge.add_argument('--force', action='store_true', help='Omite la confirmación')
-    projects_gc = projects_subparsers.add_parser('gc', help='Elimina las entradas de proyecto vacías del registro')
-    projects_gc.add_argument('--dry-run', action='store_true', help='Vista previa sin eliminar')
-    projects_gc.add_argument('--force', action='store_true', help='Omite la confirmación')
-
-    # Prune (TTL de instintos pendientes)
-    prune_parser = subparsers.add_parser('prune', help='Elimina los instintos pendientes que superan el TTL')
-    prune_parser.add_argument('--max-age', type=int, default=PENDING_TTL_DAYS,
-                              help=f'Antigüedad máxima en días antes de podar (por defecto: {PENDING_TTL_DAYS})')
-    prune_parser.add_argument('--dry-run', action='store_true', help='Vista previa sin eliminar')
-    prune_parser.add_argument('--quiet', action='store_true', help='Suprime la salida (para uso automatizado)')
-
-    args = parser.parse_args()
-
-    if args.command == 'status':
-        return cmd_status(args)
-    elif args.command == 'import':
-        return cmd_import(args)
-    elif args.command == 'export':
-        return cmd_export(args)
-    elif args.command == 'evolve':
-        return cmd_evolve(args)
-    elif args.command == 'promote':
-        return cmd_promote(args)
-    elif args.command == 'projects':
-        return cmd_projects(args)
-    elif args.command == 'prune':
-        return cmd_prune(args)
-    else:
-        parser.print_help()
-        return 1
-
-
-if __name__ == '__main__':
-    sys.exit(main())