theus-cli-linux-x64 1.2.1 → 1.3.0

package/vendor/theus-arsenal/skills/aprendizaje-continuo-v2/hooks/observe.sh

@@ -1,594 +0,0 @@
-#!/usr/bin/env bash
-# Aprendizaje continuo v2 - Hook de observación
-#
-# Captura los eventos de uso de herramientas para el análisis de patrones.
-# El CLI pasa los datos del hook por stdin como JSON.
-#
-# v2.1: Observaciones con ámbito de proyecto — detecta el contexto del
-#       proyecto actual y escribe las observaciones en su directorio.
-#
-# Registro manual (opt-in) en ~/.theus/settings.json; ver el SKILL.md de la skill.
-
-set -e
-
-# Fase del hook desde el argumento de CLI: "pre" (PreToolUse) o "post" (PostToolUse).
-# Un registro manual en settings.json puede invocar este script sin el argumento
-# posicional de fase, pero el CLI incluye el nombre del evento en el JSON de
-# stdin (campo hook_event_name). Ese campo se usa como fallback más abajo, una
-# vez resuelto el intérprete de Python, para que los hooks PreToolUse
-# registrados a mano se anoten como tool_start en vez de clasificarse en
-# silencio como tool_complete.
-HOOK_PHASE="${1:-}"
-
-# ─────────────────────────────────────────────
-# Leer stdin primero (antes de detectar el proyecto)
-# ─────────────────────────────────────────────
-
-# Leer el JSON de stdin (formato de hook del CLI)
-INPUT_JSON=$(cat)
-
-# Salir si no hay entrada
-if [ -z "$INPUT_JSON" ]; then
-  exit 0
-fi
-
-_is_windows_app_installer_stub() {
-  # Windows 10/11 incluye un stub de "App Execution Alias" en
-  #   %LOCALAPPDATA%\Microsoft\WindowsApps\python.exe
-  #   %LOCALAPPDATA%\Microsoft\WindowsApps\python3.exe
-  # Ambos son symlinks a AppInstallerPythonRedirector.exe que, cuando Python no
-  # está instalado desde la Store, ni lanza Python ni respeta "-c". Las llamadas
-  # se cuelgan o imprimen una línea "Python " pelada, rompiendo en silencio cada
-  # paso de parseo JSON de este hook. Aquí se detectan y omiten esos stubs.
-  local _candidate="$1"
-  [ -z "$_candidate" ] && return 1
-  local _resolved
-  _resolved="$(command -v "$_candidate" 2>/dev/null || true)"
-  [ -z "$_resolved" ] && return 1
-  case "$_resolved" in
-    *AppInstallerPythonRedirector.exe|*AppInstallerPythonRedirector.EXE) return 0 ;;
-  esac
-  # Resolver también un nivel de symlink en shells tipo POSIX (Git Bash, WSL).
-  if command -v readlink >/dev/null 2>&1; then
-    local _target
-    _target="$(readlink -f "$_resolved" 2>/dev/null || readlink "$_resolved" 2>/dev/null || true)"
-    case "$_target" in
-      *AppInstallerPythonRedirector.exe|*AppInstallerPythonRedirector.EXE) return 0 ;;
-    esac
-  fi
-  return 1
-}
-
-resolve_python_cmd() {
-  if [ -n "${ACV2_PYTHON_CMD:-}" ] && command -v "$ACV2_PYTHON_CMD" >/dev/null 2>&1; then
-    printf '%s\n' "$ACV2_PYTHON_CMD"
-    return 0
-  fi
-
-  if command -v python3 >/dev/null 2>&1 && ! _is_windows_app_installer_stub python3; then
-    printf '%s\n' python3
-    return 0
-  fi
-
-  if command -v python >/dev/null 2>&1 && ! _is_windows_app_installer_stub python; then
-    printf '%s\n' python
-    return 0
-  fi
-
-  return 1
-}
-
-PYTHON_CMD="$(resolve_python_cmd 2>/dev/null || true)"
-if [ -z "$PYTHON_CMD" ]; then
-  echo "[observe] No se encontró un intérprete de python; se omite la observación" >&2
-  exit 0
-fi
-
-# Fallback de la fase del hook: leer hook_event_name del JSON de stdin
-if [ -z "$HOOK_PHASE" ]; then
-  _ACV2_EVENT_NAME=$(echo "$INPUT_JSON" | "$PYTHON_CMD" -c "import json,sys; print(json.load(sys.stdin).get('hook_event_name',''))" 2>/dev/null || true)
-  case "$_ACV2_EVENT_NAME" in
-    PreToolUse|pretooluse|pre_tool_use|pre) HOOK_PHASE="pre" ;;
-    *) HOOK_PHASE="post" ;;
-  esac
-fi
-
-# Propagar nuestra selección consciente de stubs para que detect-project.sh
-# (que se carga con source más abajo) no re-resuelva y caiga en silencio en el
-# stub del App Installer. detect-project.sh respeta un ACV2_PYTHON_CMD ya definido.
-export ACV2_PYTHON_CMD="${ACV2_PYTHON_CMD:-$PYTHON_CMD}"
-
-# ─────────────────────────────────────────────
-# Extraer el cwd de stdin para detectar el proyecto
-# ─────────────────────────────────────────────
-
-# Extraer el cwd del JSON del hook para usarlo en la detección de proyecto.
-# Si el cwd es un subdirectorio dentro de un repo git, resolverlo a la raíz del
-# repo para que las observaciones se asocien al proyecto y no a una ruta anidada.
-STDIN_CWD=$(echo "$INPUT_JSON" | "$PYTHON_CMD" -c '
-import json, sys
-try:
-    data = json.load(sys.stdin)
-    cwd = data.get("cwd", "")
-    print(cwd)
-except(KeyError, TypeError, ValueError):
-    print("")
-' 2>/dev/null || echo "")
-
-# Si stdin traía un cwd, usarlo para la detección de proyecto
-if [ -n "$STDIN_CWD" ] && [ -d "$STDIN_CWD" ]; then
-  _GIT_ROOT=$(git -C "$STDIN_CWD" rev-parse --show-toplevel 2>/dev/null || true)
-  if [ -n "$_GIT_ROOT" ]; then
-    export THEUS_PROJECT_DIR="$_GIT_ROOT"
-    unset ACV2_NO_PROJECT
-  else
-    unset THEUS_PROJECT_DIR
-    export ACV2_NO_PROJECT=1
-  fi
-fi
-
-# ─────────────────────────────────────────────
-# Configuración ligera y guardas para sesiones automatizadas
-# ─────────────────────────────────────────────
-#
-# IMPORTANTE: mantener estas guardas por encima de detect-project.sh.
-# Hacer source de detect-project.sh crea directorios por proyecto y actualiza
-# projects.json, así que las sesiones automatizadas deben salir antes de ese punto.
-
-# shellcheck disable=SC1091
-. "$(dirname "$0")/../scripts/lib/arsenal-dir.sh"
-CONFIG_DIR="$(_acv2_resolve_arsenal_dir)"
-
-# Omitir si está deshabilitado (revisar la ubicación por defecto y la derivada de ACV2_CONFIG)
-if [ -f "$CONFIG_DIR/disabled" ]; then
-  exit 0
-fi
-if [ -n "${ACV2_CONFIG:-}" ] && [ -f "$(dirname "$ACV2_CONFIG")/disabled" ]; then
-  exit 0
-fi
-
-# Evitar que observe.sh se dispare en sesiones no humanas para impedir:
-#   - que el observador observe sus propias sesiones de análisis (bucle propio)
-#   - observar sesiones automatizadas de otras herramientas
-#   - que las sesiones automatizadas creen metadatos por proyecto en el arsenal
-
-# Capa 1: punto de entrada. Solo deben continuar las sesiones interactivas de terminal.
-# sdk: las sesiones vía SDK pueden ser interactivas con un humano.
-# La automatización no interactiva vía SDK se sigue filtrando con las capas 2-5
-# (THEUS_HOOK_PROFILE=minimal, THEUS_SKIP_OBSERVE=1, agent_id, exclusiones de ruta).
-case "${THEUS_CODE_ENTRYPOINT:-cli}" in
-  cli|sdk-ts|theus-desktop) ;;
-  *) exit 0 ;;
-esac
-
-# Capa 2: el perfil de hooks mínimo suprime los hooks no esenciales.
-[ "${THEUS_HOOK_PROFILE:-standard}" = "minimal" ] && exit 0
-
-# Capa 3: variable cooperativa de omisión para sesiones automatizadas.
-[ "${THEUS_SKIP_OBSERVE:-0}" = "1" ] && exit 0
-
-# Capa 4: las sesiones de subagentes son automatizadas por definición.
-_ACV2_AGENT_ID=$(echo "$INPUT_JSON" | "$PYTHON_CMD" -c "import json,sys; print(json.load(sys.stdin).get('agent_id',''))" 2>/dev/null || true)
-[ -n "$_ACV2_AGENT_ID" ] && exit 0
-
-# Capa 5: exclusiones de rutas conocidas de sesiones del observador.
-_ACV2_SKIP_PATHS="${THEUS_OBSERVE_SKIP_PATHS:-observer-sessions}"
-if [ -n "$STDIN_CWD" ]; then
-  IFS=',' read -ra _ACV2_SKIP_ARRAY <<< "$_ACV2_SKIP_PATHS"
-  for _pattern in "${_ACV2_SKIP_ARRAY[@]}"; do
-    _pattern="${_pattern#"${_pattern%%[![:space:]]*}"}"
-    _pattern="${_pattern%"${_pattern##*[![:space:]]}"}"
-    [ -z "$_pattern" ] && continue
-    case "$STDIN_CWD" in *"$_pattern"*) exit 0 ;; esac
-  done
-fi
-
-# ─────────────────────────────────────────────
-# Detección de proyecto
-# ─────────────────────────────────────────────
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SKILL_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-
-# Cargar el helper compartido de detección de proyecto.
-# Define: PROJECT_ID, PROJECT_NAME, PROJECT_ROOT, PROJECT_DIR
-source "${SKILL_ROOT}/scripts/detect-project.sh"
-PYTHON_CMD="${ACV2_PYTHON_CMD:-$PYTHON_CMD}"
-
-# ─────────────────────────────────────────────
-# Configuración
-# ─────────────────────────────────────────────
-
-OBSERVATIONS_FILE="${PROJECT_DIR}/observations.jsonl"
-MAX_FILE_SIZE_MB=10
-
-# Autopurgar archivos de observaciones con más de 30 días (corre una vez por sesión)
-PURGE_MARKER="${PROJECT_DIR}/.last-purge"
-if [ ! -f "$PURGE_MARKER" ] || [ "$(find "$PURGE_MARKER" -mtime +1 2>/dev/null)" ]; then
-  find "${PROJECT_DIR}" -name "observations-*.jsonl" -mtime +30 -delete 2>/dev/null || true
-  touch "$PURGE_MARKER" 2>/dev/null || true
-fi
-
-# Parsear con Python vía tubería de stdin (seguro para cualquier payload JSON).
-# HOOK_PHASE se pasa por variable de entorno porque el CLI no incluye el tipo
-# de hook en el JSON de stdin.
-PARSED=$(echo "$INPUT_JSON" | HOOK_PHASE="$HOOK_PHASE" "$PYTHON_CMD" -c '
-import json
-import sys
-import os
-
-try:
-    data = json.load(sys.stdin)
-
-    # Determinar el tipo de evento desde el argumento de CLI pasado por env var.
-    # El CLI NO incluye un campo "hook_type" en el JSON de stdin, por eso
-    # dependemos del argumento del shell ("pre" o "post").
-    hook_phase = os.environ.get("HOOK_PHASE", "post")
-    event = "tool_start" if hook_phase == "pre" else "tool_complete"
-
-    # Extraer campos - formato de hook del CLI
-    tool_name = data.get("tool_name", data.get("tool", "unknown"))
-    tool_input = data.get("tool_input", data.get("input", {}))
-    tool_output = data.get("tool_response")
-    if tool_output is None:
-        tool_output = data.get("tool_output", data.get("output", ""))
-    session_id = data.get("session_id", "unknown")
-    tool_use_id = data.get("tool_use_id", "")
-    cwd = data.get("cwd", "")
-
-    # Truncar entradas/salidas grandes
-    if isinstance(tool_input, dict):
-        tool_input_str = json.dumps(tool_input)[:5000]
-    else:
-        tool_input_str = str(tool_input)[:5000]
-
-    if isinstance(tool_output, dict):
-        tool_response_str = json.dumps(tool_output)[:5000]
-    else:
-        tool_response_str = str(tool_output)[:5000]
-
-    print(json.dumps({
-        "parsed": True,
-        "event": event,
-        "tool": tool_name,
-        "input": tool_input_str if event == "tool_start" else None,
-        "output": tool_response_str if event == "tool_complete" else None,
-        "session": session_id,
-        "tool_use_id": tool_use_id,
-        "cwd": cwd
-    }))
-except Exception as e:
-    print(json.dumps({"parsed": False, "error": str(e)}))
-')
-
-# Comprobar si el parseo tuvo éxito
-PARSED_OK=$(echo "$PARSED" | "$PYTHON_CMD" -c "import json,sys; print(json.load(sys.stdin).get('parsed', False))" 2>/dev/null || echo "False")
-
-if [ "$PARSED_OK" != "True" ]; then
-  # Fallback: registrar la entrada en bruto para depuración (limpiando secretos antes de persistir)
-  timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-  export TIMESTAMP="$timestamp"
-  echo "$INPUT_JSON" | "$PYTHON_CMD" -c '
-import json, sys, os, re
-
-# Detector de secretos en tiempo lineal. Los cuantificadores acotados y un
-# conjunto fijo de esquemas de autenticación (en vez de un [A-Za-z]+\s+
-# genérico que se solapaba con la clase del valor) evitan el backtracking
-# catastrófico que dejaba a python al 100 % de CPU.
-_SECRET_RE = re.compile(
-    r"(?i)(api[_-]?key|token|secret|password|authorization|credentials?|auth)"
-    r"""(["'"'"'\s:=]{1,8})"""
-    r"((?:bearer|basic|token|bot)\s+)?"
-    r"([A-Za-z0-9_\-/.+=]{8,256})"
-)
-
-import signal
-def _acv2_bail(*_):
-    print("[observe] Timeout SIGALRM: la observación de fallback por error de parseo se descartó antes de escribir", file=sys.stderr)
-    sys.exit(0)
-try:
-    signal.signal(signal.SIGALRM, _acv2_bail)
-    signal.alarm(8)  # autoterminarse antes de que el timeout de 10s del hook asíncrono nos deje huérfanos
-except Exception:
-    pass
-
-raw = sys.stdin.read()[:2000]
-raw = _SECRET_RE.sub(lambda m: m.group(1) + m.group(2) + (m.group(3) or "") + "[REDACTED]", raw)
-print(json.dumps({"timestamp": os.environ["TIMESTAMP"], "event": "parse_error", "raw": raw}))
-' >> "$OBSERVATIONS_FILE"
-  exit 0
-fi
-
-# Archivar si el archivo es demasiado grande (atómico: rename con sufijo único para evitar carreras)
-if [ -f "$OBSERVATIONS_FILE" ]; then
-  file_size_mb=$(du -m "$OBSERVATIONS_FILE" 2>/dev/null | cut -f1)
-  if [ "${file_size_mb:-0}" -ge "$MAX_FILE_SIZE_MB" ]; then
-    archive_dir="${PROJECT_DIR}/observations.archive"
-    mkdir -p "$archive_dir"
-    mv "$OBSERVATIONS_FILE" "$archive_dir/observations-$(date +%Y%m%d-%H%M%S)-$$.jsonl" 2>/dev/null || true
-  fi
-fi
-
-# Construir y escribir la observación (ahora incluye el contexto del proyecto).
-# Limpiar patrones comunes de secretos en la E/S de herramientas antes de persistir.
-timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-
-export PROJECT_ID_ENV="$PROJECT_ID"
-export PROJECT_NAME_ENV="$PROJECT_NAME"
-export TIMESTAMP="$timestamp"
-
-echo "$PARSED" | "$PYTHON_CMD" -c '
-import json, sys, os, re
-import signal
-
-def _acv2_bail(*_):
-    print("[observe] Timeout SIGALRM: la observación en curso se descartó antes de escribir", file=sys.stderr)
-    sys.exit(0)
-try:
-    signal.signal(signal.SIGALRM, _acv2_bail)
-    signal.alarm(8)  # autoterminarse antes de que el timeout de 10s del hook asíncrono nos deje huérfanos
-except Exception:
-    pass
-
-parsed = json.load(sys.stdin)
-observation = {
-    "timestamp": os.environ["TIMESTAMP"],
-    "event": parsed["event"],
-    "tool": parsed["tool"],
-    "session": parsed["session"],
-    "project_id": os.environ.get("PROJECT_ID_ENV", "global"),
-    "project_name": os.environ.get("PROJECT_NAME_ENV", "global")
-}
-
-# Limpiar secretos: cubre los patrones comunes clave=valor, clave: valor y clave"valor.
-# Incluye un esquema de autenticación opcional (p. ej. "Bearer", "Basic") antes del token.
-# Detector de secretos en tiempo lineal. Los cuantificadores acotados y un
-# conjunto fijo de esquemas de autenticación (en vez de un [A-Za-z]+\s+
-# genérico que se solapaba con la clase del valor) evitan el backtracking
-# catastrófico que dejaba a python al 100 % de CPU.
-_SECRET_RE = re.compile(
-    r"(?i)(api[_-]?key|token|secret|password|authorization|credentials?|auth)"
-    r"""(["'"'"'\s:=]{1,8})"""
-    r"((?:bearer|basic|token|bot)\s+)?"
-    r"([A-Za-z0-9_\-/.+=]{8,256})"
-)
-
-def scrub(val):
-    if val is None:
-        return None
-    return _SECRET_RE.sub(lambda m: m.group(1) + m.group(2) + (m.group(3) or "") + "[REDACTED]", str(val))
-
-if parsed["input"]:
-    observation["input"] = scrub(parsed["input"])
-if parsed["output"] is not None:
-    observation["output"] = scrub(parsed["output"])
-
-print(json.dumps(observation))
-' >> "$OBSERVATIONS_FILE"
-
-# Arranque perezoso del observador si está habilitado pero no corre (primera configuración).
-# Usa flock para un check-then-act atómico que evita condiciones de carrera.
-# Fallback para macOS (sin flock): usar lockfile o el lock por mkdir.
-LAZY_START_LOCK="${PROJECT_DIR}/.observer-start.lock"
-_REMOVE_FILE_IF_PRESENT() {
-  local target="$1"
-  if [ -n "$target" ] && [ -e "$target" ]; then
-    rm -- "$target" 2>/dev/null || true
-  fi
-}
-
-_START_OBSERVER_LOGGED() {
-  local bootstrap_log="${PROJECT_DIR}/observer-start.log"
-  mkdir -p "$PROJECT_DIR"
-  "${SKILL_ROOT}/agents/start-observer.sh" start >> "$bootstrap_log" 2>&1 || true
-}
-
-_CHECK_OBSERVER_RUNNING() {
-  local pid_file="$1"
-  if [ -f "$pid_file" ]; then
-    local pid
-    pid=$(cat "$pid_file" 2>/dev/null)
-    # Validar que el PID sea un entero positivo (>1) para no señalar objetivos inválidos
-    case "$pid" in
-      ''|*[!0-9]*|0|1)
-        _REMOVE_FILE_IF_PRESENT "$pid_file"
-        return 1
-        ;;
-    esac
-    if kill -0 "$pid" 2>/dev/null; then
-      return 0  # El proceso está vivo
-    fi
-    # Archivo de PID obsoleto - eliminarlo
-    _REMOVE_FILE_IF_PRESENT "$pid_file"
-  fi
-  return 1  # No hay archivo de PID o el proceso murió
-}
-
-if [ -f "${CONFIG_DIR}/disabled" ]; then
-  OBSERVER_ENABLED=false
-else
-  OBSERVER_ENABLED=false
-  if [ -n "${ACV2_CONFIG:-}" ]; then
-    CONFIG_FILE="$ACV2_CONFIG"
-  elif [ -f "${CONFIG_DIR}/config.json" ]; then
-    CONFIG_FILE="${CONFIG_DIR}/config.json"
-  else
-    CONFIG_FILE="${SKILL_ROOT}/config.json"
-  fi
-  # Usar la ruta efectiva de config tanto para comprobar existencia como para leer
-  EFFECTIVE_CONFIG="$CONFIG_FILE"
-  if [ -f "$EFFECTIVE_CONFIG" ] && [ -n "$PYTHON_CMD" ]; then
-    _enabled=$(ACV2_CONFIG_PATH="$EFFECTIVE_CONFIG" "$PYTHON_CMD" -c "
-import json, os
-with open(os.environ['ACV2_CONFIG_PATH']) as f:
-    cfg = json.load(f)
-print(str(cfg.get('observer', {}).get('enabled', False)).lower())
-" 2>/dev/null || echo "false")
-    if [ "$_enabled" = "true" ]; then
-      OBSERVER_ENABLED=true
-    fi
-  fi
-fi
-
-# Revisar los archivos de PID por proyecto Y global (con recuperación de PID obsoletos)
-if [ "$OBSERVER_ENABLED" = "true" ]; then
-  # Limpiar primero los archivos de PID obsoletos
-  _CHECK_OBSERVER_RUNNING "${PROJECT_DIR}/.observer.pid" || true
-  _CHECK_OBSERVER_RUNNING "${CONFIG_DIR}/.observer.pid" || true
-
-  # Comprobar si el observador ya corre después de la limpieza
-  if [ ! -f "${PROJECT_DIR}/.observer.pid" ] && [ ! -f "${CONFIG_DIR}/.observer.pid" ]; then
-    # Usar flock si está disponible (Linux), con fallback para macOS
-    if command -v flock >/dev/null 2>&1; then
-      (
-        flock -n 9 || exit 0
-        # Volver a comprobar los archivos de PID tras adquirir el lock
-        _CHECK_OBSERVER_RUNNING "${PROJECT_DIR}/.observer.pid" || true
-        _CHECK_OBSERVER_RUNNING "${CONFIG_DIR}/.observer.pid" || true
-        if [ ! -f "${PROJECT_DIR}/.observer.pid" ] && [ ! -f "${CONFIG_DIR}/.observer.pid" ]; then
-          _START_OBSERVER_LOGGED
-        fi
-      ) 9>"$LAZY_START_LOCK"
-    else
-      # Fallback macOS: usar lockfile si está disponible; si no, lock basado en mkdir
-      if command -v lockfile >/dev/null 2>&1; then
-        # Subshell para aislar el exit y trap para la limpieza
-        (
-          trap '_REMOVE_FILE_IF_PRESENT "$LAZY_START_LOCK"' EXIT
-          lockfile -r 1 -l 30 "$LAZY_START_LOCK" 2>/dev/null || exit 0
-          _CHECK_OBSERVER_RUNNING "${PROJECT_DIR}/.observer.pid" || true
-          _CHECK_OBSERVER_RUNNING "${CONFIG_DIR}/.observer.pid" || true
-          if [ ! -f "${PROJECT_DIR}/.observer.pid" ] && [ ! -f "${CONFIG_DIR}/.observer.pid" ]; then
-            _START_OBSERVER_LOGGED
-          fi
-          _REMOVE_FILE_IF_PRESENT "$LAZY_START_LOCK"
-        )
-      else
-        # Fallback POSIX: mkdir es atómico -- falla si el directorio ya existe
-        (
-          trap 'rmdir "${LAZY_START_LOCK}.d" 2>/dev/null || true' EXIT
-          mkdir "${LAZY_START_LOCK}.d" 2>/dev/null || exit 0
-          _CHECK_OBSERVER_RUNNING "${PROJECT_DIR}/.observer.pid" || true
-          _CHECK_OBSERVER_RUNNING "${CONFIG_DIR}/.observer.pid" || true
-          if [ ! -f "${PROJECT_DIR}/.observer.pid" ] && [ ! -f "${CONFIG_DIR}/.observer.pid" ]; then
-            _START_OBSERVER_LOGGED
-          fi
-        )
-      fi
-    fi
-  fi
-fi
-
-# Regular SIGUSR1: solo señalar al observador cada N observaciones.
-# Esto evita señalar rápido cuando las llamadas a herramientas se disparan cada
-# segundo, lo que provocaba procesos de análisis paralelos descontrolados.
-SIGNAL_EVERY_N="${THEUS_OBSERVER_SIGNAL_EVERY_N:-20}"
-SIGNAL_COUNTER_FILE="${PROJECT_DIR}/.observer-signal-counter"
-SIGNAL_COUNTER_LOCK="${SIGNAL_COUNTER_FILE}.lock"
-ACTIVITY_FILE="${PROJECT_DIR}/.observer-last-activity"
-
-touch "$ACTIVITY_FILE" 2>/dev/null || true
-
-# Serializar el read-modify-write del contador de regulación. observe.sh corre en
-# cada llamada a herramienta (que puede dispararse cada segundo), así que las
-# invocaciones concurrentes competían por este contador: ambas leían el mismo
-# valor, ambas incrementaban y una escritura se perdía, señalando al observador
-# en intervalos impredecibles.
-# Se prefiere flock (lock consultivo del kernel que el SO libera automáticamente
-# si el hook muere); el fallback es el lock atómico por mkdir que este script ya
-# usa arriba para el arranque perezoso. Ambos envuelven el mismo read-modify-write.
-should_signal=0
-
-_acv2_bump_signal_counter() {
-  if [ -f "$SIGNAL_COUNTER_FILE" ]; then
-    counter=$(cat "$SIGNAL_COUNTER_FILE" 2>/dev/null || echo 0)
-    # Protegerse de un archivo de contador corrupto: un valor no entero abortaría
-    # el hook bajo `set -e` en la aritmética de abajo.
-    case "$counter" in
-      ''|*[!0-9]*) counter=0 ;;
-    esac
-    counter=$((counter + 1))
-    if [ "$counter" -ge "$SIGNAL_EVERY_N" ]; then
-      should_signal=1
-      counter=0
-    fi
-    echo "$counter" > "$SIGNAL_COUNTER_FILE"
-  else
-    echo "1" > "$SIGNAL_COUNTER_FILE"
-  fi
-}
-
-if command -v flock >/dev/null 2>&1 && exec 8>"$SIGNAL_COUNTER_LOCK" 2>/dev/null; then
-  # flock se libera solo cuando el fd 8 se cierra o el proceso muere, así que no
-  # hay lock obsoleto ni incrementos perdidos. Se usa una espera acotada -w para
-  # que el hook nunca se bloquee indefinidamente, y el contador solo se toca con
-  # el lock adquirido -- en un timeout se omite el tick en lugar de hacer un
-  # read-modify-write sin lock.
-  if flock -w 2 8 2>/dev/null; then
-    _acv2_bump_signal_counter
-    flock -u 8 2>/dev/null || true
-  fi
-  exec 8>&- 2>/dev/null || true
-else
-  # Sin flock (p. ej. macOS): lock atómico por mkdir con un spin acotado para que
-  # el hook nunca se bloquee indefinidamente. Un trap libera el lock en toda ruta
-  # de salida -- incluido el SIGTERM del timeout asíncrono -- para que un hook
-  # muerto no deje el directorio bloqueado. Deliberadamente NO se implementa una
-  # recuperación de locks obsoletos basada en PID: re-verificar y luego eliminar
-  # el lock de otro proceso es una carrera y puede borrar el directorio de un
-  # re-adquiridor vivo, reintroduciendo la misma carrera que esto corrige.
-  _signal_lock_held=0
-  _signal_lock_spins=0
-  while [ "$_signal_lock_spins" -lt 100 ]; do
-    if mkdir "$SIGNAL_COUNTER_LOCK" 2>/dev/null; then
-      # EXIT limpia en la terminación normal. INT/TERM deben liberar Y salir:
-      # un trap de señal que solo liberara el lock seguiría de largo y
-      # continuaría el read-modify-write sin ser el dueño.
-      trap 'rmdir "$SIGNAL_COUNTER_LOCK" 2>/dev/null || true' EXIT
-      trap 'rmdir "$SIGNAL_COUNTER_LOCK" 2>/dev/null || true; exit 130' INT
-      trap 'rmdir "$SIGNAL_COUNTER_LOCK" 2>/dev/null || true; exit 143' TERM
-      _signal_lock_held=1
-      break
-    fi
-    _signal_lock_spins=$((_signal_lock_spins + 1))
-    sleep 0.02
-  done
-  if [ "$_signal_lock_held" -eq 1 ]; then
-    # Incrementar solo con el lock adquirido -- nunca un read-modify-write sin lock.
-    _acv2_bump_signal_counter
-    rmdir "$SIGNAL_COUNTER_LOCK" 2>/dev/null || true
-    trap - EXIT INT TERM
-  fi
-  # Si el lock no pudo adquirirse dentro del presupuesto de spins, se omite este
-  # tick en lugar de competir por un contador sin lock. Perder un tick de
-  # regulación bajo contención extrema solo retrasa un poco la siguiente señal
-  # al observador; nunca corrompe el contador ni señala de forma espuria.
-fi
-
-# Señalar al observador si corre y la regulación lo permite (revisar el observador
-# por proyecto y el global, deduplicando)
-if [ "$should_signal" -eq 1 ]; then
-  signaled_pids=" "
-  for pid_file in "${PROJECT_DIR}/.observer.pid" "${CONFIG_DIR}/.observer.pid"; do
-    if [ -f "$pid_file" ]; then
-      observer_pid=$(cat "$pid_file" 2>/dev/null || true)
-      # Validar que el PID sea un entero positivo (>1)
-      case "$observer_pid" in
-        ''|*[!0-9]*|0|1)
-          _REMOVE_FILE_IF_PRESENT "$pid_file"
-          continue
-          ;;
-      esac
-      # Deduplicar: omitir si ya se señaló en esta pasada
-      case "$signaled_pids" in
-        *" $observer_pid "*) continue ;;
-      esac
-      if kill -0 "$observer_pid" 2>/dev/null; then
-        kill -USR1 "$observer_pid" 2>/dev/null || true
-        signaled_pids="${signaled_pids}${observer_pid} "
-      fi
-    fi
-  done
-fi
-
-exit 0