@trac3er/oh-my-god 2.0.0 → 2.0.2

package/OMG-setup.sh

@@ -3,6 +3,19 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 CLAUDE_DIR="${CLAUDE_CONFIG_DIR:-$HOME/.claude}"
+BACKUP_TS="$(date +%Y%m%d_%H%M%S)"
+BACKUP_DIR="$CLAUDE_DIR/.omg-backup-$BACKUP_TS"
+VERSION="2.0.2"
+
+PLUGIN_NAME="omg"
+PLUGIN_MARKETPLACE="omg"
+LEGACY_PLUGIN_MARKETPLACE="oh-advanced-layer"
+PLUGIN_REF="${PLUGIN_NAME}@${PLUGIN_MARKETPLACE}"
+LEGACY_PLUGIN_REF="${PLUGIN_NAME}@${LEGACY_PLUGIN_MARKETPLACE}"
+PLUGIN_CACHE_DIR="$CLAUDE_DIR/plugins/cache/$PLUGIN_MARKETPLACE/$PLUGIN_NAME"
+LEGACY_PLUGIN_CACHE_DIR="$CLAUDE_DIR/plugins/cache/$LEGACY_PLUGIN_MARKETPLACE/$PLUGIN_NAME"
+PLUGIN_BUNDLE_MARKER_FILE=".omg-plugin-bundle"
+
 ACTION="install"
 ACTION_EXPLICIT=false
 DRY_RUN=false
@@ -11,421 +24,1254 @@ MERGE_POLICY="ask"
 FRESH_INSTALL=false
 INSTALL_AS_PLUGIN=false
 USE_SYMLINK=false
-SKIP_CODEX_SKILLS=false
-MANIFEST_PATH="$CLAUDE_DIR/.omg-manifest"
-PLUGIN_CACHE_DIR="$CLAUDE_DIR/plugins/cache/oh-advanced-layer/omg"
-PLUGIN_MARKER="$PLUGIN_CACHE_DIR/.omg-plugin-bundle"
-VERSION=""
-TMP_MANIFEST=()
+ADOPTION_MODE="omg-only"
+ADOPT_MODE="auto"
+OMG_PRESET="safe"
+ERRORS=0
+OMG_MANIFEST="$CLAUDE_DIR/.omg-manifest"
+NEW_MANIFEST_ENTRIES=()
+
+V3_RULES=(
+    "00-truth-evidence.md" "01-enforcement-map.md" "02-doc-check.md"
+    "03-working-memory.md" "04-quality-gate.md" "05-structured-reports.md"
+    "06-infra-safety.md" "07-cross-model.md" "08-big-picture.md"
+    "09-surgical-changes.md" "10-code-simplifier.md" "11-dependency-safety.md"
+    "12-circuit-breaker.md" "13-planning-checklist.md" "14-auto-commands.md"
+    "15-context-management.md" "16-honest-testing.md" "17-ensemble-collaboration.md"
+    "18-collaborative-solving.md" "19-outside-in.md" "20-project-identity.md"
+    "21-verified-claims.md" "22-auto-plugin-mcp.md"
+)
+V3_AGENTS_REMOVE=(cross-validator.md dependency-guardian.md infra-guardian.md perf-analyst.md ui-reviewer.md)
+OLD_OMG_AGENTS=(architect.md critic.md executor.md qa-tester.md escalation-router.md)
+V3_COMMANDS_REMOVE=(cross-review.md simplify.md)
+V4_COMMANDS_REMOVE=(
+    code-review.md deep-plan.md domain-init.md escalate.md handoff.md
+    health-check.md learn.md project-init.md security-review.md
+)
+
+# Dynamic hook discovery — no hardcoded list.
+# Used by remove_omg_files() as fallback when manifest is absent.
+build_omg_hooks_list() {
+    OMG_HOOKS=()
+    for f in "$SCRIPT_DIR"/hooks/*.py; do
+        [ -f "$f" ] && OMG_HOOKS+=("$(basename "$f")")
+    done
+}
 
 usage() {
-  cat <<'EOF'
+    cat <<EOF
 OMG Setup Manager
 
 Usage:
-  ./OMG-setup.sh <action> [options]
-  ./OMG-setup.sh [options]
+  ./OMG-setup.sh <action> [OPTIONS]
+  ./OMG-setup.sh [OPTIONS]             # defaults to install
+  ./OMG-setup.sh                       # interactive menu in terminal mode
 
 Actions:
-  install      Install or update OMG
-  update       Alias of install
-  reinstall    Uninstall then install
-  uninstall    Remove OMG-managed files
+  install      Install or upgrade OMG components
+  update       Alias of install (explicit update mode)
+  reinstall    Clean reinstall (remove OMG files, then install)
+  uninstall    Remove OMG-managed files from ~/.claude
 
 Options:
-  --fresh
-  --symlink
+  --fresh            For install/update: clean reinstall before install
+  --symlink          Use symlinks instead of copies (dev mode - live updates)
   --install-as-plugin
-  --skip-codex-skills
-  --dry-run
-  --non-interactive
-  --merge-policy=ask|apply|skip
-  -h, --help
+                     Install plugin bundle (plugin.json + MCP + HUD) together
+  --dry-run          Show what would happen without writing files
+  --non-interactive  Skip prompts (CI/automation mode)
+  --merge-policy=X   Settings merge: ask (default), apply, skip
+  --mode=omg-only|coexist
+                     Native OMG adoption mode for overlapping ecosystems
+  --adopt=auto       Detect OMG-adjacent ecosystems during install/update
+  --preset=safe|balanced|interop|labs
+                     User-facing preset for managed OMG features
+  -h, --help         Show this help
+
+Examples:
+  ./OMG-setup.sh install
+  ./OMG-setup.sh install --symlink              # Dev mode: live updates from repo
+  ./OMG-setup.sh install --install-as-plugin
+  ./OMG-setup.sh install --mode=coexist --preset=interop
+  ./OMG-setup.sh update --non-interactive --merge-policy=apply
+  ./OMG-setup.sh reinstall --dry-run
+  ./OMG-setup.sh uninstall --dry-run
 EOF
 }
 
-say() {
-  printf '%s\n' "$*"
+is_standalone_installed() {
+    [ -f "$CLAUDE_DIR/hooks/.omg-version" ] || [ -d "$CLAUDE_DIR/omg-runtime" ]
 }
 
-record_manifest() {
-  TMP_MANIFEST+=("$1")
+is_plugin_installed() {
+    local marker_new="$PLUGIN_CACHE_DIR/$PLUGIN_BUNDLE_MARKER_FILE"
+    local marker_legacy="$LEGACY_PLUGIN_CACHE_DIR/$PLUGIN_BUNDLE_MARKER_FILE"
+    if [ -f "$marker_new" ] || [ -f "$marker_legacy" ]; then
+        return 0
+    fi
+    local installed_plugins="$CLAUDE_DIR/plugins/installed_plugins.json"
+    if [ -f "$installed_plugins" ] && grep -Eq "\"$PLUGIN_REF\"|\"$LEGACY_PLUGIN_REF\"" "$installed_plugins" 2>/dev/null; then
+        return 0
+    fi
+    return 1
 }
 
-run_or_echo() {
-  if $DRY_RUN; then
-    say "DRY RUN: $*"
-    return 0
-  fi
-  "$@"
-}
+prompt_start_action() {
+    if $ACTION_EXPLICIT || $NON_INTERACTIVE || $DRY_RUN; then
+        return 0
+    fi
 
-copy_file() {
-  local src="$1"
-  local dst="$2"
-  local mode="${3:-644}"
-  if $DRY_RUN; then
-    say "DRY RUN: install $src -> $dst"
-    record_manifest "$dst"
-    return 0
-  fi
-  mkdir -p "$(dirname "$dst")"
-  if $USE_SYMLINK; then
-    ln -sfn "$src" "$dst"
-  else
-    cp "$src" "$dst"
-  fi
-  chmod "$mode" "$dst"
-  record_manifest "$dst"
-}
+    local standalone_installed=false
+    local plugin_installed=false
+    is_standalone_installed && standalone_installed=true
+    is_plugin_installed && plugin_installed=true
+
+    echo ""
+    echo "Select OMG setup action:"
+    echo "  1. Install standalone"
+    if $standalone_installed; then
+        echo "  2. Update standalone"
+    fi
+    echo "  3. Install as plugin"
+    if $plugin_installed; then
+        echo "  4. Update plugin install"
+    fi
+    echo "  5. Uninstall"
+    echo "  0. Cancel"
+    echo ""
 
-copy_dir_glob() {
-  local src_dir="$1"
-  local pattern="$2"
-  local dst_dir="$3"
-  local mode="${4:-644}"
-  shopt -s nullglob
-  for src in "$src_dir"/$pattern; do
-    [ -e "$src" ] || continue
-    copy_file "$src" "$dst_dir/$(basename "$src")" "$mode"
-  done
-  shopt -u nullglob
+    read -p "Choose [1/2/3/4/5/0]: " -r
+    case "${REPLY:-}" in
+        1)
+            ACTION="install"
+            INSTALL_AS_PLUGIN=false
+            ;;
+        2)
+            if $standalone_installed; then
+                ACTION="update"
+                INSTALL_AS_PLUGIN=false
+            else
+                echo "Standalone update unavailable (not installed)."
+                exit 1
+            fi
+            ;;
+        3)
+            ACTION="install"
+            INSTALL_AS_PLUGIN=true
+            ;;
+        4)
+            if $plugin_installed; then
+                ACTION="update"
+                INSTALL_AS_PLUGIN=true
+            else
+                echo "Plugin update unavailable (plugin install not detected)."
+                exit 1
+            fi
+            ;;
+        5)
+            ACTION="uninstall"
+            ;;
+        0)
+            echo "Cancelled by user."
+            exit 0
+            ;;
+        *)
+            echo "Invalid selection."
+            exit 1
+            ;;
+    esac
 }
 
-copy_tree() {
-  local src_dir="$1"
-  local dst_dir="$2"
-  local selector="${3:-all}"
-  while IFS= read -r src; do
-    case "$selector" in
-      markdown)
-        [[ "$src" == *.md ]] || continue
-        ;;
-      ts-only)
-        [[ "$src" == *.ts ]] || continue
-        ;;
-      runtime)
-        [[ "$src" == *.ts || "$src" == *.json || "$src" == *.sh ]] || continue
-        ;;
-      all)
-        ;;
-      *)
-        ;;
+parse_args() {
+    if [ $# -gt 0 ]; then
+        case "$1" in
+            install|update|reinstall|uninstall)
+                ACTION="$1"
+                ACTION_EXPLICIT=true
+                shift
+                ;;
+            help|-h|--help)
+                usage
+                exit 0
+                ;;
+        esac
+    fi
+
+    for arg in "$@"; do
+        case "$arg" in
+            --dry-run) DRY_RUN=true ;;
+            --symlink) USE_SYMLINK=true ;;
+            --non-interactive) NON_INTERACTIVE=true ;;
+            --fresh) FRESH_INSTALL=true ;;
+            --install-as-plugin) INSTALL_AS_PLUGIN=true ;;
+            --merge-policy=*) MERGE_POLICY="${arg#*=}" ;;
+            --mode=*) ADOPTION_MODE="${arg#*=}" ;;
+            --adopt=*) ADOPT_MODE="${arg#*=}" ;;
+            --preset=*) OMG_PRESET="${arg#*=}" ;;
+            --help|-h)
+                usage
+                exit 0
+                ;;
+            *)
+                echo "Unknown option: $arg"
+                echo ""
+                usage
+                exit 1
+                ;;
+        esac
+    done
+
+    if [ "$ACTION" = "reinstall" ]; then
+        FRESH_INSTALL=true
+    fi
+
+    if [ ! -t 0 ] || [ -n "${npm_lifecycle_event:-}" ] || [ -n "${npm_execpath:-}" ]; then
+        NON_INTERACTIVE=true
+    fi
+
+    # Auto-enable plugin mode for npm installs
+    if [ -n "${npm_execpath:-}" ] || [ -n "${npm_lifecycle_event:-}" ]; then
+        INSTALL_AS_PLUGIN=true
+    fi
+
+    case "$ADOPTION_MODE" in
+        omg-only|coexist) ;;
+        *)
+            echo "Unknown adoption mode: $ADOPTION_MODE"
+            exit 1
+            ;;
+    esac
+
+    case "$ADOPT_MODE" in
+        auto) ;;
+        *)
+            echo "Unknown adoption detector mode: $ADOPT_MODE"
+            exit 1
+            ;;
     esac
-    local rel="${src#$src_dir/}"
-    local mode=644
-    case "$src" in
-      *.sh|*.ts|*.mjs) mode=755 ;;
+
+    case "$OMG_PRESET" in
+        safe|balanced|interop|labs) ;;
+        *)
+            echo "Unknown OMG preset: $OMG_PRESET"
+            exit 1
+            ;;
     esac
-    copy_file "$src" "$dst_dir/$rel" "$mode"
-  done < <(find "$src_dir" -type f | sort)
 }
 
-is_standalone_installed() {
-  [ -f "$MANIFEST_PATH" ] || [ -d "$CLAUDE_DIR/omg-runtime" ]
+preflight() {
+    echo "Pre-flight checks..."
+    if ! command -v python3 &>/dev/null; then
+        echo "  ❌ python3 not found. Install: https://www.python.org/downloads/"
+        exit 1
+    fi
+    local py_ver py_maj py_min
+    py_ver=$(python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
+    py_maj=$(echo "$py_ver" | cut -d. -f1)
+    py_min=$(echo "$py_ver" | cut -d. -f2)
+    if [ "$py_maj" -lt 3 ] || { [ "$py_maj" -eq 3 ] && [ "$py_min" -lt 8 ]; }; then
+        echo "  ❌ Python $py_ver found, 3.8+ required"
+        exit 1
+    fi
+    echo "  ✓ Python $py_ver"
 }
 
-is_plugin_installed() {
-  [ -f "$PLUGIN_MARKER" ]
+ensure_backup() {
+    if ! $DRY_RUN; then
+        mkdir -p "$BACKUP_DIR"
+        for dir in rules hooks agents commands; do
+            [ -d "$CLAUDE_DIR/$dir" ] && cp -r "$CLAUDE_DIR/$dir" "$BACKUP_DIR/$dir" 2>/dev/null || true
+        done
+        [ -f "$CLAUDE_DIR/settings.json" ] && cp "$CLAUDE_DIR/settings.json" "$BACKUP_DIR/"
+        prune_old_backups
+    fi
 }
 
-prompt_start_action() {
-  if $ACTION_EXPLICIT || $NON_INTERACTIVE || $DRY_RUN; then
-    return 0
-  fi
-
-  local standalone_installed=false
-  local plugin_installed=false
-  is_standalone_installed && standalone_installed=true
-  is_plugin_installed && plugin_installed=true
-
-  say ""
-  say "Select OMG setup action:"
-  say "  1. Install standalone"
-  if $standalone_installed; then
-    say "  2. Update standalone"
-  fi
-  say "  3. Install as plugin"
-  if $plugin_installed; then
-    say "  4. Update plugin install"
-  fi
-  say "  5. Uninstall"
-  say "  0. Cancel"
-  say ""
-  read -r -p "Choose [1/2/3/4/5/0]: " choice
-  case "${choice:-}" in
-    1) ACTION="install"; INSTALL_AS_PLUGIN=false ;;
-    2) ACTION="update"; INSTALL_AS_PLUGIN=false ;;
-    3) ACTION="install"; INSTALL_AS_PLUGIN=true ;;
-    4) ACTION="update"; INSTALL_AS_PLUGIN=true ;;
-    5) ACTION="uninstall" ;;
-    0) say "Cancelled by user."; exit 0 ;;
-    *) say "Invalid selection."; exit 1 ;;
-  esac
+prune_old_backups() {
+    local backups=()
+    while IFS= read -r path; do
+        backups+=("$path")
+    done < <(find "$CLAUDE_DIR" -maxdepth 1 -type d -name ".omg-backup-*" | sort)
+
+    local total=${#backups[@]}
+    if [ "$total" -le 2 ]; then
+        return 0
+    fi
+
+    local remove_count=$((total - 2))
+    for old in "${backups[@]:0:$remove_count}"; do
+        [[ "$old" == "$CLAUDE_DIR"/* ]] || {
+            echo "ERROR: backup prune target outside expected directory: $old" >&2
+            exit 1
+        }
+        rm -rf "$old"
+    done
 }
 
-parse_args() {
-  if [ $# -gt 0 ]; then
-    case "$1" in
-      install|update|reinstall|uninstall)
-        ACTION="$1"
-        ACTION_EXPLICIT=true
-        shift
-        ;;
-      -h|--help|help)
-        usage
-        exit 0
-        ;;
-    esac
-  fi
-
-  for arg in "$@"; do
-    case "$arg" in
-      --dry-run) DRY_RUN=true ;;
-      --symlink) USE_SYMLINK=true ;;
-      --non-interactive) NON_INTERACTIVE=true ;;
-      --fresh) FRESH_INSTALL=true ;;
-      --install-as-plugin) INSTALL_AS_PLUGIN=true ;;
-      --skip-codex-skills) SKIP_CODEX_SKILLS=true ;;
-      --merge-policy=*) MERGE_POLICY="${arg#*=}" ;;
-      -h|--help)
-        usage
-        exit 0
-        ;;
-      *)
-        say "Unknown option: $arg"
-        usage
-        exit 1
-        ;;
-    esac
-  done
+is_omg_managed_command_file() {
+    local file="$1"
+    if [ ! -f "$file" ]; then
+        return 1
+    fi
 
-  if [ "$ACTION" = "reinstall" ]; then
-    FRESH_INSTALL=true
-    ACTION="install"
-  fi
+    if grep -q "OMG-AUTO-COMPAT-ALIAS" "$file" 2>/dev/null; then
+        return 0
+    fi
+    if grep -q "OMG-MANAGED-COMMAND" "$file" 2>/dev/null; then
+        return 0
+    fi
 
-  if [ ! -t 0 ] || [ -n "${npm_execpath:-}" ] || [ -n "${npm_lifecycle_event:-}" ]; then
-    NON_INTERACTIVE=true
-  fi
+    local base
+    base="$(basename "$file")"
+    if [[ "$base" == OMG:* ]] && grep -q "/OMG:" "$file" 2>/dev/null; then
+        return 0
+    fi
+    return 1
+}
 
-  if [ -n "${npm_execpath:-}" ] || [ -n "${npm_lifecycle_event:-}" ]; then
-    INSTALL_AS_PLUGIN=true
-  fi
+mark_omg_managed_command_file() {
+    local file="$1"
+    if [ ! -f "$file" ]; then
+        return 0
+    fi
+    if ! grep -q "OMG-MANAGED-COMMAND" "$file" 2>/dev/null; then
+        printf "\n<!-- OMG-MANAGED-COMMAND -->\n" >> "$file"
+    fi
 }
 
-preflight() {
-  say "═══════════════════════════════════════════════════════════════"
-  say "  OMG Setup Manager — $ACTION"
-  say "═══════════════════════════════════════════════════════════════"
-  say ""
-  say "Pre-flight checks..."
-  if ! command -v bun >/dev/null 2>&1; then
-    say "  ✗ bun not found. Install Bun first: https://bun.sh"
-    exit 1
-  fi
-  VERSION="$(bun -e 'import { readFileSync } from "node:fs"; console.log(JSON.parse(readFileSync(process.argv[1], "utf8")).version);' "$SCRIPT_DIR/package.json")"
-  say "  ✓ Bun $(bun --version)"
+# Install a file or directory - either copy or symlink based on USE_SYMLINK
+# Usage: install_file <source> <target> [type: file|dir]
+install_file() {
+    local src="$1"
+    local target="$2"
+    local type="${3:-file}"
+    
+    if $USE_SYMLINK; then
+        # In symlink mode, create symlink from target -> source
+        # First remove existing file/dir if present
+        if [ -e "$target" ] || [ -L "$target" ]; then
+            rm -rf "$target"
+        fi
+        ln -s "$src" "$target"
+    else
+        # In copy mode, do regular copy
+        if [ "$type" = "dir" ]; then
+            cp -R "$src" "$target"
+        else
+            cp "$src" "$target"
+        fi
+    fi
 }
 
-backup_existing() {
-  local backup_dir="$CLAUDE_DIR/.omg-backup-$(date +%Y%m%d_%H%M%S)"
-  if $DRY_RUN; then
-    say "  DRY RUN: backup -> $backup_dir"
-    return 0
-  fi
-  mkdir -p "$backup_dir"
-  for path in settings.json commands agents hooks omg-runtime rules templates; do
-    if [ -e "$CLAUDE_DIR/$path" ]; then
-      cp -R "$CLAUDE_DIR/$path" "$backup_dir/" 2>/dev/null || true
-    fi
-  done
-  say "  ✓ Backup: $backup_dir"
+track_file() {
+    NEW_MANIFEST_ENTRIES+=("$1")
 }
 
-remove_manifest_paths() {
-  if [ ! -f "$MANIFEST_PATH" ]; then
-    return 0
-  fi
-  while IFS= read -r path; do
-    [ -n "$path" ] || continue
-    if $DRY_RUN; then
-      say "DRY RUN: remove $path"
+reconcile_stale_files() {
+    if [ ! -f "$OMG_MANIFEST" ]; then
+        echo "  (no previous manifest — first install, skipping reconciliation)"
+        return 0
+    fi
+    local stale=0
+    while IFS= read -r old_entry; do
+        [ -n "$old_entry" ] || continue
+        [[ "$old_entry" == "#"* ]] && continue
+        local found=false
+        for new_entry in "${NEW_MANIFEST_ENTRIES[@]}"; do
+            if [ "$old_entry" = "$new_entry" ]; then
+                found=true
+                break
+            fi
+        done
+        if ! $found; then
+            local target="$CLAUDE_DIR/$old_entry"
+            if [ -f "$target" ]; then
+                if ! $DRY_RUN; then
+                    rm -f "$target"
+                fi
+                echo "  - $old_entry (removed from source)"
+                stale=$((stale + 1))
+            fi
+        fi
+    done < "$OMG_MANIFEST"
+    if [ $stale -eq 0 ]; then
+        echo "  (no stale files)"
+    elif $DRY_RUN; then
+        echo "  (dry-run: would remove $stale stale file(s))"
     else
-      rm -rf "$path"
+        echo "  ✓ Cleaned $stale stale file(s)"
     fi
-  done < "$MANIFEST_PATH"
-  if ! $DRY_RUN; then
-    rm -f "$MANIFEST_PATH"
-  fi
 }
 
-remove_legacy_runtime_files() {
-  local legacy_ext="py"
-  local dirs=(
-    "$CLAUDE_DIR/hooks"
-    "$CLAUDE_DIR/omg-runtime/scripts"
-    "$CLAUDE_DIR/omg-runtime/runtime"
-    "$CLAUDE_DIR/omg-runtime/tools"
-    "$CLAUDE_DIR/omg-runtime/control_plane"
-    "$CLAUDE_DIR/omg-runtime/lab"
-    "$CLAUDE_DIR/omg-runtime/omg_natives"
-    "$CLAUDE_DIR/omg-runtime/registry"
-  )
-  local dir
-  local file
-  for dir in "${dirs[@]}"; do
-    [ -d "$dir" ] || continue
-    while IFS= read -r file; do
-      if $DRY_RUN; then
-        say "DRY RUN: remove legacy $file"
-      else
-        rm -f "$file"
-      fi
-    done < <(find "$dir" -maxdepth 1 -type f -name "*.${legacy_ext}" | sort)
-  done
+write_omg_manifest() {
+    if ! $DRY_RUN; then
+        printf '%s\n' "${NEW_MANIFEST_ENTRIES[@]}" | sort > "$OMG_MANIFEST"
+    fi
 }
 
-merge_settings() {
-  local source="$SCRIPT_DIR/settings.json"
-  local target="$CLAUDE_DIR/settings.json"
-
-  if [ ! -f "$target" ]; then
-    copy_file "$source" "$target" 644
-    return 0
-  fi
-
-  case "$MERGE_POLICY" in
-    skip)
-      say "  ~ Settings merge skipped"
-      return 0
-      ;;
-    apply)
-      ;;
-    ask)
-      if $NON_INTERACTIVE; then
-        :
-      else
-        read -r -p "Apply settings merge? [Y/n]: " reply
-        case "${reply:-Y}" in
-          n|N) say "  ~ Settings merge skipped"; return 0 ;;
-        esac
-      fi
-      ;;
-    *)
-      say "Invalid merge policy: $MERGE_POLICY"
-      exit 1
-      ;;
-  esac
-
-  if $DRY_RUN; then
-    say "DRY RUN: merge settings $target <= $source"
-  else
-    bun "$SCRIPT_DIR/scripts/settings-merge.ts" "$target" "$source"
-    say "  ✓ Settings merged (auto)"
-  fi
-  record_manifest "$target"
+prune_plugin_mcp_from_settings() {
+    local mcp_path="$CLAUDE_DIR/.mcp.json"
+    if [ ! -f "$mcp_path" ]; then
+        return 0
+    fi
+    python3 - "$mcp_path" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+path = Path(sys.argv[1])
+try:
+    data = json.loads(path.read_text(encoding="utf-8"))
+except Exception:
+    print("0")
+    raise SystemExit(0)
+
+servers = data.get("mcpServers")
+if not isinstance(servers, dict):
+    print("0")
+    raise SystemExit(0)
+
+removed = 0
+for key in ("context7", "filesystem", "websearch", "chrome-devtools"):
+    if key in servers:
+        servers.pop(key, None)
+        removed += 1
+
+if removed:
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+
+print(str(removed))
+PY
+}
+
+merge_plugin_mcp_into_settings() {
+    local mcp_path="$CLAUDE_DIR/.mcp.json"
+    local source_mcp_path="$SCRIPT_DIR/.mcp.json"
+    python3 - "$mcp_path" "$source_mcp_path" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+mcp_path = Path(sys.argv[1])
+source_mcp_path = Path(sys.argv[2])
+
+mcp_config = {}
+if mcp_path.exists():
+    try:
+        mcp_config = json.loads(mcp_path.read_text(encoding="utf-8"))
+    except Exception:
+        mcp_config = {}
+if not isinstance(mcp_config, dict):
+    mcp_config = {}
+
+try:
+    source_mcp = json.loads(source_mcp_path.read_text(encoding="utf-8"))
+except Exception:
+    source_mcp = {}
+
+incoming = source_mcp.get("mcpServers") if isinstance(source_mcp, dict) else {}
+if not isinstance(incoming, dict):
+    incoming = {}
+
+servers = mcp_config.get("mcpServers")
+if not isinstance(servers, dict):
+    servers = {}
+for key, value in incoming.items():
+    servers[key] = value
+mcp_config["mcpServers"] = servers
+
+mcp_path.parent.mkdir(parents=True, exist_ok=True)
+mcp_path.write_text(json.dumps(mcp_config, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+print(str(len(incoming)))
+PY
+}
+
+write_plugin_mcp_file() {
+    local target_path="$1"
+    local source_mcp_path="$SCRIPT_DIR/.mcp.json"
+    python3 - "$target_path" "$source_mcp_path" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+target_path = Path(sys.argv[1])
+source_mcp_path = Path(sys.argv[2])
+
+try:
+    source_mcp = json.loads(source_mcp_path.read_text(encoding="utf-8"))
+except Exception:
+    source_mcp = {}
+
+mcp_servers = source_mcp.get("mcpServers") if isinstance(source_mcp, dict) else {}
+if not isinstance(mcp_servers, dict):
+    mcp_servers = {}
+
+payload = {"mcpServers": mcp_servers}
+target_path.parent.mkdir(parents=True, exist_ok=True)
+target_path.write_text(json.dumps(payload, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+print(str(len(mcp_servers)))
+PY
+}
+
+register_plugin_in_registry() {
+    local plugin_ref="$1"
+    local install_path="$2"
+    local version="$3"
+    local settings_path="$CLAUDE_DIR/settings.json"
+    local installed_plugins_path="$CLAUDE_DIR/plugins/installed_plugins.json"
+
+    python3 - "$settings_path" "$installed_plugins_path" "$plugin_ref" "$install_path" "$version" <<'PY'
+import json
+import sys
+from pathlib import Path
+from datetime import datetime, timezone
+
+settings_path = Path(sys.argv[1])
+installed_plugins_path = Path(sys.argv[2])
+plugin_ref = sys.argv[3]
+install_path = sys.argv[4]
+version = sys.argv[5]
+now = datetime.now(timezone.utc).isoformat()
+
+settings = {}
+if settings_path.exists():
+    try:
+        settings = json.loads(settings_path.read_text(encoding="utf-8"))
+    except Exception:
+        settings = {}
+if not isinstance(settings, dict):
+    settings = {}
+enabled = settings.get("enabledPlugins")
+if not isinstance(enabled, dict):
+    enabled = {}
+enabled[plugin_ref] = True
+settings["enabledPlugins"] = enabled
+settings_path.parent.mkdir(parents=True, exist_ok=True)
+settings_path.write_text(json.dumps(settings, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+
+installed = {}
+if installed_plugins_path.exists():
+    try:
+        installed = json.loads(installed_plugins_path.read_text(encoding="utf-8"))
+    except Exception:
+        installed = {}
+if not isinstance(installed, dict):
+    installed = {}
+installed["version"] = 2
+plugins = installed.get("plugins")
+if not isinstance(plugins, dict):
+    plugins = {}
+plugins[plugin_ref] = [{
+    "scope": "user",
+    "installPath": install_path,
+    "version": version,
+    "installedAt": now,
+    "lastUpdated": now,
+}]
+installed["plugins"] = plugins
+installed_plugins_path.parent.mkdir(parents=True, exist_ok=True)
+installed_plugins_path.write_text(json.dumps(installed, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+PY
+}
+
+unregister_plugin_from_registry() {
+    local plugin_ref="$1"
+    local settings_path="$CLAUDE_DIR/settings.json"
+    local installed_plugins_path="$CLAUDE_DIR/plugins/installed_plugins.json"
+
+    python3 - "$settings_path" "$installed_plugins_path" "$plugin_ref" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+settings_path = Path(sys.argv[1])
+installed_plugins_path = Path(sys.argv[2])
+plugin_ref = sys.argv[3]
+
+if settings_path.exists():
+    try:
+        settings = json.loads(settings_path.read_text(encoding="utf-8"))
+    except Exception:
+        settings = {}
+    if isinstance(settings, dict):
+        enabled = settings.get("enabledPlugins")
+        if isinstance(enabled, dict) and plugin_ref in enabled:
+            enabled.pop(plugin_ref, None)
+            settings["enabledPlugins"] = enabled
+            settings_path.write_text(json.dumps(settings, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+
+if installed_plugins_path.exists():
+    try:
+        installed = json.loads(installed_plugins_path.read_text(encoding="utf-8"))
+    except Exception:
+        installed = {}
+    if isinstance(installed, dict):
+        plugins = installed.get("plugins")
+        if isinstance(plugins, dict) and plugin_ref in plugins:
+            plugins.pop(plugin_ref, None)
+            installed["plugins"] = plugins
+            installed_plugins_path.write_text(json.dumps(installed, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+PY
+}
+
+apply_omg_preset_to_settings() {
+    local settings_path="$1"
+    local preset="$2"
+
+    if [ ! -f "$settings_path" ]; then
+        return 0
+    fi
+
+    python3 - "$SCRIPT_DIR" "$settings_path" "$preset" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+root = Path(sys.argv[1])
+settings_path = Path(sys.argv[2])
+preset = sys.argv[3]
+
+sys.path.insert(0, str(root))
+
+from runtime.adoption import CANONICAL_VERSION, get_preset_features, resolve_preset
+
+try:
+    settings = json.loads(settings_path.read_text(encoding="utf-8"))
+except Exception:
+    settings = {}
+
+if not isinstance(settings, dict):
+    settings = {}
+
+omg = settings.get("_omg")
+if not isinstance(omg, dict):
+    omg = {}
+
+features = omg.get("features")
+if not isinstance(features, dict):
+    features = {}
+
+features.update(get_preset_features(resolve_preset(preset)))
+omg["features"] = features
+omg["preset"] = resolve_preset(preset)
+omg["_version"] = CANONICAL_VERSION
+settings["_omg"] = omg
+
+settings_path.parent.mkdir(parents=True, exist_ok=True)
+settings_path.write_text(json.dumps(settings, indent=2, ensure_ascii=True) + "\n", encoding="utf-8")
+PY
 }
 
-write_manifest() {
-  if $DRY_RUN; then
-    return 0
-  fi
-  printf '%s\n' "${TMP_MANIFEST[@]}" | awk 'NF' | sort -u > "$MANIFEST_PATH"
+write_native_adoption_report() {
+    python3 - "$SCRIPT_DIR" "$CLAUDE_DIR" "$ADOPTION_MODE" "$ADOPT_MODE" "$OMG_PRESET" <<'PY'
+import sys
+from pathlib import Path
+
+root = Path(sys.argv[1])
+project_dir = Path(sys.argv[2])
+mode = sys.argv[3]
+adopt = sys.argv[4]
+preset = sys.argv[5]
+
+sys.path.insert(0, str(root))
+
+from runtime.adoption import build_adoption_report, write_adoption_report
+
+report = build_adoption_report(project_dir, requested_mode=mode, preset=preset, adopt=adopt)
+path = write_adoption_report(project_dir, report)
+print(path)
+PY
+}
+
+apply_adoption_mode_marker() {
+    if [ "$ADOPTION_MODE" = "coexist" ]; then
+        if ! $DRY_RUN; then
+            mkdir -p "$CLAUDE_DIR/hooks"
+            printf '%s\n' "coexist" > "$CLAUDE_DIR/hooks/.omg-coexist"
+        fi
+        track_file "hooks/.omg-coexist"
+    else
+        if ! $DRY_RUN; then
+            rm -f "$CLAUDE_DIR/hooks/.omg-coexist"
+        fi
+    fi
+}
+
+remove_omg_files() {
+    if ! $DRY_RUN; then
+        local plugin_bundle_marker="$PLUGIN_CACHE_DIR/$PLUGIN_BUNDLE_MARKER_FILE"
+        local plugin_bundle_marker_legacy="$LEGACY_PLUGIN_CACHE_DIR/$PLUGIN_BUNDLE_MARKER_FILE"
+        local remove_plugin_managed_mcp=false
+        if [ -f "$plugin_bundle_marker" ] || [ -f "$plugin_bundle_marker_legacy" ]; then
+            remove_plugin_managed_mcp=true
+        fi
+
+        # Use manifest for precise removal if available.
+        if [ -f "$OMG_MANIFEST" ]; then
+            while IFS= read -r entry; do
+                [ -n "$entry" ] || continue
+                [[ "$entry" == "#"* ]] && continue
+                rm -f "$CLAUDE_DIR/$entry"
+            done < "$OMG_MANIFEST"
+            rm -f "$OMG_MANIFEST"
+        fi
+
+        # Also remove by pattern (covers pre-manifest installs + compat aliases).
+        build_omg_hooks_list
+        for h in "${OMG_HOOKS[@]}"; do
+            rm -f "$CLAUDE_DIR/hooks/$h"
+        done
+        rm -f "$CLAUDE_DIR/hooks/.omg-version" "$CLAUDE_DIR/hooks/.omg-coexist"
+
+        # Remove OMG rules and old v3 rule set.
+        for r in "$CLAUDE_DIR"/rules/0[0-4]-*.md; do
+            [ -f "$r" ] && rm "$r"
+        done
+        for rule in "${V3_RULES[@]}"; do
+            rm -f "$CLAUDE_DIR/rules/$rule"
+        done
+
+        # Remove OMG agents, commands, templates.
+        rm -f "$CLAUDE_DIR"/agents/omg-*.md
+        if [ -d "$CLAUDE_DIR/commands" ]; then
+            while IFS= read -r cmd_path; do
+                if [ -n "$cmd_path" ] && is_omg_managed_command_file "$cmd_path"; then
+                    rm -f "$cmd_path"
+                fi
+            done < <(find "$CLAUDE_DIR/commands" -maxdepth 1 -type f -name "*.md" 2>/dev/null | sort)
+        fi
+        [[ "$CLAUDE_DIR/templates/omg" == "$CLAUDE_DIR"* ]] || { echo "ERROR: rm -rf target outside expected directory: $CLAUDE_DIR/templates/omg" >&2; exit 1; }
+        rm -rf "$CLAUDE_DIR/templates/omg"
+        [[ "$CLAUDE_DIR/omg-runtime" == "$CLAUDE_DIR"* ]] || { echo "ERROR: rm -rf target outside expected directory: $CLAUDE_DIR/omg-runtime" >&2; exit 1; }
+        rm -rf "$CLAUDE_DIR/omg-runtime"
+
+        [[ "$PLUGIN_CACHE_DIR" == "$CLAUDE_DIR"* ]] || { echo "ERROR: rm -rf target outside expected directory: $PLUGIN_CACHE_DIR" >&2; exit 1; }
+        rm -rf "$PLUGIN_CACHE_DIR"
+        [[ "$LEGACY_PLUGIN_CACHE_DIR" == "$CLAUDE_DIR"* ]] || { echo "ERROR: rm -rf target outside expected directory: $LEGACY_PLUGIN_CACHE_DIR" >&2; exit 1; }
+        rm -rf "$LEGACY_PLUGIN_CACHE_DIR"
+        rm -f "$CLAUDE_DIR/hud/omg-hud.mjs"
+        unregister_plugin_from_registry "$PLUGIN_REF"
+        unregister_plugin_from_registry "$LEGACY_PLUGIN_REF"
+
+        if $remove_plugin_managed_mcp; then
+            local pruned_mcp=0
+            pruned_mcp=$(prune_plugin_mcp_from_settings)
+            if [ "${pruned_mcp:-0}" -gt 0 ]; then
+                echo "  ✓ Plugin-managed MCP servers removed from .mcp.json ($pruned_mcp)"
+            fi
+        fi
+    fi
 }
 
 install_plugin_bundle() {
-  say "  Plugin bundle mode enabled: install plugin + MCP + HUD together"
-  if ! $DRY_RUN; then
-    mkdir -p "$PLUGIN_CACHE_DIR"
-  fi
-  copy_tree "$SCRIPT_DIR/.claude-plugin" "$PLUGIN_CACHE_DIR/.claude-plugin" ""
-  copy_file "$SCRIPT_DIR/.mcp.json" "$PLUGIN_CACHE_DIR/.mcp.json" 644
-  copy_tree "$SCRIPT_DIR/hud" "$PLUGIN_CACHE_DIR/hud" ""
-  if $DRY_RUN; then
-    say "DRY RUN: write $PLUGIN_MARKER"
-  else
-    printf '%s\n' "omg-plugin-bundle-v2" > "$PLUGIN_MARKER"
-  fi
-  record_manifest "$PLUGIN_CACHE_DIR"
+    local plugin_ref="$PLUGIN_REF"
+    local plugin_root="$PLUGIN_CACHE_DIR/$VERSION"
+    local plugin_manifest_src="$SCRIPT_DIR/.claude-plugin/plugin.json"
+    local plugin_manifest_target="$plugin_root/.claude-plugin/plugin.json"
+    local plugin_mcp_target="$plugin_root/.mcp.json"
+    local hud_src="$SCRIPT_DIR/hud/omg-hud.mjs"
+    local hud_target="$CLAUDE_DIR/hud/omg-hud.mjs"
+
+    echo "  Plugin bundle mode enabled: install plugin + MCP + HUD together"
+    if $DRY_RUN; then
+        echo "  (would install plugin bundle under $plugin_root and deploy HUD to $hud_target)"
+        echo "  (would register plugin in ~/.claude/plugins/installed_plugins.json and enable it in settings.json)"
+        echo "  (would merge plugin MCP servers into .mcp.json)"
+        return 0
+    fi
+
+    mkdir -p "$plugin_root/.claude-plugin"
+    mkdir -p "$CLAUDE_DIR/hud"
+    cp "$plugin_manifest_src" "$plugin_manifest_target"
+    
+    # Provide a fallback .mcp.json if not shipped in npm package
+    if [ ! -f "$SCRIPT_DIR/.mcp.json" ]; then
+        local _fallback_mcp_dir
+        _fallback_mcp_dir=$(mktemp -d)
+        cat > "$_fallback_mcp_dir/.mcp.json" <<'FALLBACK_MCP'
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["@upstash/context7-mcp@2.1.3"]
+    },
+    "filesystem": {
+      "command": "npx",
+      "args": ["@modelcontextprotocol/server-filesystem@2026.1.14", "."]
+    },
+    "websearch": {
+      "command": "npx",
+      "args": ["@zhafron/mcp-web-search@1.2.2"]
+    },
+    "chrome-devtools": {
+      "command": "npx",
+      "args": ["chrome-devtools-mcp@0.19.0"]
+    }
+  }
 }
+FALLBACK_MCP
+        SCRIPT_DIR="$_fallback_mcp_dir" write_plugin_mcp_file "$plugin_mcp_target" >/dev/null
+        rm -rf "$_fallback_mcp_dir"
+    else
+        write_plugin_mcp_file "$plugin_mcp_target" >/dev/null
+    fi
+    
+    cp "$hud_src" "$hud_target"
+    mkdir -p "$PLUGIN_CACHE_DIR"
+    printf '%s\n' "omg-plugin-bundle-v1" > "$PLUGIN_CACHE_DIR/$PLUGIN_BUNDLE_MARKER_FILE"
+
+    unregister_plugin_from_registry "$LEGACY_PLUGIN_REF"
+    register_plugin_in_registry "$plugin_ref" "$plugin_root" "$VERSION"
+    merge_plugin_mcp_into_settings >/dev/null
 
-install_runtime() {
-  say "Step 1/4: Install core runtime..."
-  copy_tree "$SCRIPT_DIR/commands" "$CLAUDE_DIR/commands" "markdown"
-  copy_tree "$SCRIPT_DIR/agents" "$CLAUDE_DIR/agents" "markdown"
-  copy_tree "$SCRIPT_DIR/rules" "$CLAUDE_DIR/rules" "markdown"
-  copy_tree "$SCRIPT_DIR/templates" "$CLAUDE_DIR/templates/omg" "all"
-  copy_tree "$SCRIPT_DIR/hooks" "$CLAUDE_DIR/hooks" "ts-only"
-  copy_tree "$SCRIPT_DIR/runtime" "$CLAUDE_DIR/omg-runtime/runtime" "runtime"
-  copy_tree "$SCRIPT_DIR/scripts" "$CLAUDE_DIR/omg-runtime/scripts" "runtime"
-  copy_tree "$SCRIPT_DIR/tools" "$CLAUDE_DIR/omg-runtime/tools" "runtime"
-  copy_tree "$SCRIPT_DIR/control_plane" "$CLAUDE_DIR/omg-runtime/control_plane" "runtime"
-  copy_tree "$SCRIPT_DIR/lab" "$CLAUDE_DIR/omg-runtime/lab" "runtime"
-  copy_tree "$SCRIPT_DIR/registry" "$CLAUDE_DIR/omg-runtime/registry" "runtime"
-  copy_tree "$SCRIPT_DIR/omg_natives" "$CLAUDE_DIR/omg-runtime/omg_natives" "runtime"
-  copy_tree "$SCRIPT_DIR/hud" "$CLAUDE_DIR/omg-runtime/hud" "all"
-  copy_file "$SCRIPT_DIR/.mcp.json" "$CLAUDE_DIR/omg-runtime/.mcp.json" 644
-  copy_file "$SCRIPT_DIR/package.json" "$CLAUDE_DIR/omg-runtime/package.json" 644
-  copy_file "$SCRIPT_DIR/tsconfig.json" "$CLAUDE_DIR/omg-runtime/tsconfig.json" 644
-  copy_file "$SCRIPT_DIR/bunfig.toml" "$CLAUDE_DIR/omg-runtime/bunfig.toml" 644
+    track_file "plugins/cache/$PLUGIN_MARKETPLACE/$PLUGIN_NAME/$VERSION/.claude-plugin/plugin.json"
+    track_file "plugins/cache/$PLUGIN_MARKETPLACE/$PLUGIN_NAME/$VERSION/.mcp.json"
+    track_file "plugins/cache/$PLUGIN_MARKETPLACE/$PLUGIN_NAME/$PLUGIN_BUNDLE_MARKER_FILE"
+    track_file "hud/omg-hud.mjs"
+    echo "  ✓ Plugin bundle installed and registered in Claude plugin settings"
 }
 
-install_action() {
-  if $FRESH_INSTALL; then
-    uninstall_action
-  fi
-  backup_existing
-  remove_legacy_runtime_files
-  install_runtime
-  say "Step 2/4: Merge settings and templates..."
-  merge_settings
-  say "Step 3/4: Install portable runtime metadata..."
-  if ! $DRY_RUN; then
-    mkdir -p "$CLAUDE_DIR/hooks" "$CLAUDE_DIR/omg-runtime"
-    mkdir -p "$CLAUDE_DIR/omg-runtime"
-    printf '%s\n' "omg-v2-$VERSION" > "$CLAUDE_DIR/hooks/.omg-version"
-  fi
-  record_manifest "$CLAUDE_DIR/omg-runtime"
-  record_manifest "$CLAUDE_DIR/hooks/.omg-version"
-  if $INSTALL_AS_PLUGIN; then
-    say "Step 4/4: Install plugin bundle..."
-    install_plugin_bundle
-  else
-    say "Step 4/4: Plugin bundle skipped"
-  fi
-  write_manifest
-  say ""
-  say "═══════════════════════════════════════════════════════════════"
-  say "  ✅ OMG Bun install completed successfully"
-  say "═══════════════════════════════════════════════════════════════"
+run_uninstall() {
+    echo "═══════════════════════════════════════════════════════════════"
+    echo "  OMG Setup Manager — uninstall"
+    echo "═══════════════════════════════════════════════════════════════"
+    echo ""
+
+    if $DRY_RUN; then
+        echo "  *** DRY RUN — no files will be changed ***"
+        echo ""
+    fi
+
+    preflight
+
+    local existing_ver=""
+    if [ -f "$CLAUDE_DIR/hooks/.omg-version" ]; then
+        existing_ver=$(cat "$CLAUDE_DIR/hooks/.omg-version" 2>/dev/null || echo "")
+    fi
+    if [ -n "$existing_ver" ]; then
+        echo "  ✓ Existing OMG install: $existing_ver"
+    else
+        echo "  ~ No .omg-version marker found; uninstall will still remove known OMG files."
+    fi
+
+    if ! $NON_INTERACTIVE && ! $DRY_RUN; then
+        read -p "Proceed with uninstall? [y/N] " -n 1 -r
+        echo ""
+        if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+            echo "Cancelled."
+            exit 0
+        fi
+    fi
+
+    echo ""
+    echo "Uninstall: removing OMG-managed files from $CLAUDE_DIR"
+    ensure_backup
+    if ! $DRY_RUN; then
+        echo "  ✓ Backup: $BACKUP_DIR"
+    else
+        echo "  (would backup to $BACKUP_DIR)"
+    fi
+    remove_omg_files
+    if $DRY_RUN; then
+        echo "  (would remove OMG hooks/rules/agents/commands/templates)"
+    else
+        echo "  ✓ Removed OMG hooks/rules/agents/commands/templates"
+    fi
+
+    echo ""
+    echo "Uninstall complete."
+    echo "  ✓ If plugin bundle was installed, plugin + MCP + HUD were removed together"
+    echo "Preserved:"
+    echo "  - $CLAUDE_DIR/settings.json"
+    echo "  - project .omg/ data"
+    echo "  - non-OMG custom files"
 }
 
-uninstall_action() {
-  say "Uninstalling OMG Bun runtime..."
-  remove_manifest_paths
-  if $DRY_RUN; then
-    say "DRY RUN: remove $PLUGIN_CACHE_DIR"
-  else
-    rm -rf "$PLUGIN_CACHE_DIR"
-    rm -rf "$CLAUDE_DIR/omg-runtime"
-    rm -f "$CLAUDE_DIR/hooks/.omg-version"
-  fi
-  say "  ✓ Uninstall complete"
+run_install_like() {
+    local existing_ver=""
+    local removed=0
+    local installed_rules=0
+    local installed_hooks=0
+    local hook_errors=0
+    local installed_agents=0
+    local installed_cmds=0
+
+    echo "═══════════════════════════════════════════════════════════════"
+    echo "  OMG Setup Manager — $ACTION"
+    echo "═══════════════════════════════════════════════════════════════"
+    echo ""
+
+    if $DRY_RUN; then
+        echo "  *** DRY RUN — no files will be changed ***"
+        echo ""
+    fi
+
+    preflight
+
+    if [ -f "$CLAUDE_DIR/hooks/.omg-version" ]; then
+        existing_ver=$(cat "$CLAUDE_DIR/hooks/.omg-version" 2>/dev/null || echo "")
+    fi
+
+    if [ "$ACTION" = "update" ] && [ -z "$existing_ver" ]; then
+        echo "  ~ No existing OMG install detected. update will proceed as install."
+    fi
+
+    if [ -n "$existing_ver" ]; then
+        echo "  ✓ Existing: $existing_ver → target $VERSION"
+    else
+        echo "  ✓ Fresh install"
+    fi
+    echo "  ✓ Command surface: /OMG:setup and /OMG:crazy are the primary native front door"
+    echo "  ✓ Adoption mode: $ADOPTION_MODE"
+    echo "  ✓ Preset: $OMG_PRESET"
+
+    if $FRESH_INSTALL; then
+        echo ""
+        echo "Fresh/reinstall mode: remove OMG files before install."
+        if ! $NON_INTERACTIVE && ! $DRY_RUN; then
+            read -p "Proceed with fresh cleanup? [y/N] " -n 1 -r
+            echo ""
+            if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+                echo "Cancelled."
+                exit 0
+            fi
+        fi
+
+        ensure_backup
+        if ! $DRY_RUN; then
+            echo "  ✓ Backup: $BACKUP_DIR"
+        else
+            echo "  (would backup to $BACKUP_DIR)"
+        fi
+        remove_omg_files
+        if $DRY_RUN; then
+            echo "  (would remove OMG hooks/rules/agents/commands/templates)"
+        else
+            echo "  ✓ Clean slate ready"
+        fi
+        existing_ver=""
+    fi
+
+    if [ -n "$existing_ver" ] && ! $FRESH_INSTALL; then
+        echo ""
+        echo "Step 0/7: Backup existing installation..."
+        ensure_backup
+        if ! $DRY_RUN; then
+            echo "  ✓ Backup: $BACKUP_DIR"
+        else
+            echo "  (would backup to $BACKUP_DIR)"
+        fi
+    fi
+
+    echo ""
+    echo "Step 1/7: Remove deprecated files..."
+
+    for rule in "${V3_RULES[@]}"; do
+        target="$CLAUDE_DIR/rules/$rule"
+        if [ -f "$target" ]; then
+            ! $DRY_RUN && rm "$target"
+            echo "  - rules/$rule"
+            removed=$((removed + 1))
+        fi
+    done
+
+    for agent in "${V3_AGENTS_REMOVE[@]}"; do
+        target="$CLAUDE_DIR/agents/$agent"
+        if [ -f "$target" ]; then
+            ! $DRY_RUN && rm "$target"
+            echo "  - agents/$agent (v3 deprecated)"
+            removed=$((removed + 1))
+        fi
+    done
+
+    for agent in "${OLD_OMG_AGENTS[@]}"; do
+        target="$CLAUDE_DIR/agents/$agent"
+        if [ -f "$target" ]; then
+            if grep -q "OMG\|omg\|circuit.breaker\|escalat" "$target" 2>/dev/null; then
+                ! $DRY_RUN && rm "$target"
+                echo "  - agents/$agent (renamed to omg-$agent)"
+                removed=$((removed + 1))
+            else
+                echo "  ~ agents/$agent (kept — appears to be non-OMG/custom)"
+            fi
+        fi
+    done
+
+    for cmd in "${V3_COMMANDS_REMOVE[@]}" "${V4_COMMANDS_REMOVE[@]}"; do
+        target="$CLAUDE_DIR/commands/$cmd"
+        if [ -f "$target" ]; then
+            if is_omg_managed_command_file "$target"; then
+                ! $DRY_RUN && rm "$target"
+                echo "  - commands/$cmd (v4 → OMG:$cmd)"
+                removed=$((removed + 1))
+            else
+                echo "  ~ commands/$cmd (kept — appears to be non-OMG/custom)"
+            fi
+        fi
+    done
+
+    if compgen -G "$CLAUDE_DIR/commands/*omc*.md" > /dev/null; then
+        for cmd in "$CLAUDE_DIR"/commands/*omc*.md; do
+            [ -f "$cmd" ] || continue
+            if is_omg_managed_command_file "$cmd"; then
+                ! $DRY_RUN && rm "$cmd"
+                echo "  - commands/$(basename "$cmd") (removed legacy command)"
+                removed=$((removed + 1))
+            fi
+        done
+    fi
+
+    if [ -d "$CLAUDE_DIR/hooks/__pycache__" ]; then
+        ! $DRY_RUN && rm -rf "$CLAUDE_DIR/hooks/__pycache__"
+        removed=$((removed + 1))
+    fi
+    ! $DRY_RUN && find "$CLAUDE_DIR/hooks/" -name "*.pyc" -delete 2>/dev/null || true
+    [ $removed -eq 0 ] && echo "  (nothing to remove)" || echo "  ✓ Removed $removed deprecated files"
+
+    echo ""
+    echo "Step 2/7: Core Rules → $CLAUDE_DIR/rules/"
+    ! $DRY_RUN && mkdir -p "$CLAUDE_DIR/rules"
+    for f in "$SCRIPT_DIR"/rules/core/*.md; do
+        name=$(basename "$f")
+        target="$CLAUDE_DIR/rules/$name"
+        ! $DRY_RUN && cp "$f" "$target"
+        installed_rules=$((installed_rules + 1))
+        track_file "rules/$name"
+    done
+    echo "  ✓ $installed_rules core rules"
+
+    echo ""
+    echo "Step 3/7: Hooks → $CLAUDE_DIR/hooks/"
+    ! $DRY_RUN && mkdir -p "$CLAUDE_DIR/hooks"
+    for f in "$SCRIPT_DIR"/hooks/*.py; do
+        name=$(basename "$f")
+        target="$CLAUDE_DIR/hooks/$name"
+        if ! $DRY_RUN; then
+            install_file "$f" "$target"
+            if ! $USE_SYMLINK; then
+                chmod +x "$target"
+            fi
+        fi
+        if python3 -c "import py_compile; py_compile.compile('$f', doraise=True)" 2>/dev/null; then
+            echo "  ✓ $name"
+        else
+            echo "  ❌ $name (SYNTAX ERROR)"
+            hook_errors=$((hook_errors + 1))
+            ERRORS=$((ERRORS + 1))
+        fi
+        installed_hooks=$((installed_hooks + 1))
+        track_file "hooks/$name"
+    done
+    ! $DRY_RUN && echo "$VERSION" > "$CLAUDE_DIR/hooks/.omg-version"
+    apply_adoption_mode_marker
+    echo "  ✓ $installed_hooks hooks ($hook_errors errors)"
+
+    echo ""
+    echo "Step 4/7: Agents → $CLAUDE_DIR/agents/"
+    ! $DRY_RUN && mkdir -p "$CLAUDE_DIR/agents"
+    for f in "$SCRIPT_DIR"/agents/*.md; do
+        name=$(basename "$f")
+        target="$CLAUDE_DIR/agents/$name"
+        if ! $DRY_RUN; then
+            [ -f "$target" ] && [ -z "$existing_ver" ] && cp "$target" "$target.bak.$BACKUP_TS"
+            install_file "$f" "$target"
+        fi
+        echo "  ✓ $name"
+        installed_agents=$((installed_agents + 1))
+        track_file "agents/$name"
+    done
+    echo "  ✓ $installed_agents agents"
+
+    echo ""
+    echo "Step 5/7: Commands → $CLAUDE_DIR/commands/"
+    ! $DRY_RUN && mkdir -p "$CLAUDE_DIR/commands"
+    for f in "$SCRIPT_DIR"/commands/*.md; do
+        name=$(basename "$f")
+        if [[ "$name" == *omc* ]]; then
+            echo "  - /$(basename "$name" .md) (skipped: legacy alias commands are unsupported)"
+            continue
+        fi
+        target="$CLAUDE_DIR/commands/$name"
+        if [ -f "$target" ] && ! is_omg_managed_command_file "$target"; then
+            echo "  ~ /$(basename "$name" .md) (kept existing custom command)"
+            continue
+        fi
+        if ! $DRY_RUN; then
+            install_file "$f" "$target"
+            if ! $USE_SYMLINK; then
+                mark_omg_managed_command_file "$target"
+            fi
+        fi
+        echo "  ✓ /$(basename "$name" .md)"
+        installed_cmds=$((installed_cmds + 1))
+        track_file "commands/$name"
+    done
+    echo ""
+    echo "Step 6/7: Settings + Templates..."
+    MERGE="$SCRIPT_DIR/scripts/settings-merge.py"
+    TARGET="$CLAUDE_DIR/settings.json"
+    SOURCE="$SCRIPT_DIR/settings.json"
+    if ! $DRY_RUN; then
+        if [ ! -f "$TARGET" ]; then
+            cp "$SOURCE" "$TARGET"
+            apply_omg_preset_to_settings "$TARGET" "$OMG_PRESET"
+            echo "  ✓ Created settings.json"
+        else
+            if [ "$MERGE_POLICY" = "skip" ]; then
+                apply_omg_preset_to_settings "$TARGET" "$OMG_PRESET"
+                echo "  ⊘ Skipped settings merge (--merge-policy=skip)"
+            elif [ "$MERGE_POLICY" = "apply" ] || $NON_INTERACTIVE; then
+                python3 "$MERGE" "$TARGET" "$SOURCE"
+                apply_omg_preset_to_settings "$TARGET" "$OMG_PRESET"
+                echo "  ✓ Settings merged (auto)"
+            else
+                echo "  Merging settings.json..."
+                dry_run_preview="$(python3 "$MERGE" "$TARGET" "$SOURCE" --dry-run 2>&1)"
+                printf '%s\n' "$dry_run_preview" | sed -n '1,5p' | sed 's/^/      /'
+                echo ""
+                if read -p "  Apply merge? [Y/n] " -n 1 -r 2>/dev/null; then
+                    echo ""
+                    if [[ ! $REPLY =~ ^[Nn]$ ]]; then
+                        python3 "$MERGE" "$TARGET" "$SOURCE"
+                        apply_omg_preset_to_settings "$TARGET" "$OMG_PRESET"
+                        echo "  ✓ Settings merged"
+                    else
+                        echo "  ⊘ Skipped (manual merge needed)"
+                    fi
+                else
+                    # read failed — only auto-apply if we can confirm non-interactive context
+                    # non-interactive fallback: check for clear non-interactive indicators
+                    if [ ! -t 0 ] || [ -n "${npm_lifecycle_event:-}" ] || [ -n "${npm_execpath:-}" ]; then
+                        python3 "$MERGE" "$TARGET" "$SOURCE"
+                        apply_omg_preset_to_settings "$TARGET" "$OMG_PRESET"
+                        echo "  ✓ Settings merged (auto — non-interactive fallback)"
+                    else
+                        echo "  ⚠ Could not read input. Skipping merge to be safe."
+                        echo "    Run manually: ./OMG-setup.sh update --merge-policy=apply"
+                    fi
+                fi
+            fi
+        fi
+
+        if $USE_SYMLINK; then
+            # In symlink mode, link entire directories for templates
+            if [ -e "$CLAUDE_DIR/templates/omg" ] || [ -L "$CLAUDE_DIR/templates/omg" ]; then
+                rm -rf "$CLAUDE_DIR/templates/omg"
+            fi
+            ln -s "$SCRIPT_DIR/templates" "$CLAUDE_DIR/templates/omg"
+            # Also link contextual rules
+            mkdir -p "$CLAUDE_DIR/templates/omg/contextual-rules"
+            for cr in "$SCRIPT_DIR"/rules/contextual/*.md; do
+                [ -f "$cr" ] && track_file "templates/omg/contextual-rules/$(basename "$cr")"
+            done
+        else
+            mkdir -p "$CLAUDE_DIR/templates/omg"
+            cp "$SCRIPT_DIR"/templates/* "$CLAUDE_DIR/templates/omg/" 2>/dev/null || true
+            for t in "$SCRIPT_DIR"/templates/*; do
+                [ -f "$t" ] && track_file "templates/omg/$(basename "$t")"
+            done
+            mkdir -p "$CLAUDE_DIR/templates/omg/contextual-rules"
+            cp "$SCRIPT_DIR"/rules/contextual/*.md "$CLAUDE_DIR/templates/omg/contextual-rules/" 2>/dev/null || true
+            for cr in "$SCRIPT_DIR"/rules/contextual/*.md; do
+                [ -f "$cr" ] && track_file "templates/omg/contextual-rules/$(basename "$cr")"
+            done
+        fi
+        mkdir -p "$CLAUDE_DIR/templates/omg/state/memory"
+        mkdir -p "$CLAUDE_DIR/templates/omg/state/learnings"
+        mkdir -p "$CLAUDE_DIR/templates/omg/state/ledger"
+        echo "  \u2713 State directory templates (memory, learnings, ledger)"
+        echo "  \u2713 Templates + contextual rules"
+
+        if $USE_SYMLINK; then
+            # In symlink mode, link runtime directories instead of copying
+            mkdir -p "$CLAUDE_DIR/omg-runtime/scripts"
+            install_file "$SCRIPT_DIR/scripts/omg.py" "$CLAUDE_DIR/omg-runtime/scripts/omg.py"
+            
+            [[ "$CLAUDE_DIR/omg-runtime/runtime" == "$CLAUDE_DIR"* ]] || { echo "ERROR: symlink target outside expected directory: $CLAUDE_DIR/omg-runtime/runtime" >&2; exit 1; }
+            [[ "$CLAUDE_DIR/omg-runtime/hooks" == "$CLAUDE_DIR"* ]] || { echo "ERROR: symlink target outside expected directory: $CLAUDE_DIR/omg-runtime/hooks" >&2; exit 1; }
+            [[ "$CLAUDE_DIR/omg-runtime/lab" == "$CLAUDE_DIR"* ]] || { echo "ERROR: symlink target outside expected directory: $CLAUDE_DIR/omg-runtime/lab" >&2; exit 1; }
+            
+            rm -rf "$CLAUDE_DIR/omg-runtime/runtime" "$CLAUDE_DIR/omg-runtime/hooks" "$CLAUDE_DIR/omg-runtime/lab"
+            ln -s "$SCRIPT_DIR/runtime" "$CLAUDE_DIR/omg-runtime/runtime"
+            ln -s "$SCRIPT_DIR/hooks" "$CLAUDE_DIR/omg-runtime/hooks"
+            ln -s "$SCRIPT_DIR/lab" "$CLAUDE_DIR/omg-runtime/lab"
+            
+            [[ "$CLAUDE_DIR/omg-runtime" == "$CLAUDE_DIR"* ]] || { echo "ERROR: rm -rf target outside expected directory: $CLAUDE_DIR/omg-runtime" >&2; exit 1; }
+            find "$CLAUDE_DIR/omg-runtime" -name "__pycache__" -type d -exec rm -rf {} + 2>/dev/null || true
+            find "$CLAUDE_DIR/omg-runtime" -name "*.pyc" -delete 2>/dev/null || true
+            echo "  ✓ Portable runtime → $CLAUDE_DIR/omg-runtime (symlinked to $SCRIPT_DIR)"
+        else
+            mkdir -p "$CLAUDE_DIR/omg-runtime/scripts"
+            cp "$SCRIPT_DIR/scripts/omg.py" "$CLAUDE_DIR/omg-runtime/scripts/omg.py"
+            [[ "$CLAUDE_DIR/omg-runtime/runtime" == "$CLAUDE_DIR"* ]] || { echo "ERROR: rm -rf target outside expected directory: $CLAUDE_DIR/omg-runtime/runtime" >&2; exit 1; }
+            rm -rf "$CLAUDE_DIR/omg-runtime/runtime" "$CLAUDE_DIR/omg-runtime/hooks" "$CLAUDE_DIR/omg-runtime/lab"
+            cp -R "$SCRIPT_DIR/runtime" "$CLAUDE_DIR/omg-runtime/"
+            cp -R "$SCRIPT_DIR/hooks" "$CLAUDE_DIR/omg-runtime/"
+            cp -R "$SCRIPT_DIR/lab" "$CLAUDE_DIR/omg-runtime/"
+            [[ "$CLAUDE_DIR/omg-runtime" == "$CLAUDE_DIR"* ]] || { echo "ERROR: rm -rf target outside expected directory: $CLAUDE_DIR/omg-runtime" >&2; exit 1; }
+            find "$CLAUDE_DIR/omg-runtime" -name "__pycache__" -type d -exec rm -rf {} + 2>/dev/null || true
+            find "$CLAUDE_DIR/omg-runtime" -name "*.pyc" -delete 2>/dev/null || true
+            echo "  ✓ Portable runtime → $CLAUDE_DIR/omg-runtime"
+        fi
+        if $INSTALL_AS_PLUGIN; then
+            install_plugin_bundle
+        fi
+
+        local adoption_report_path=""
+        adoption_report_path=$(write_native_adoption_report)
+        echo "  ✓ Adoption report → $adoption_report_path"
+    else
+        echo "  (would merge settings.json + copy templates + provision portable runtime)"
+        if $INSTALL_AS_PLUGIN; then
+            install_plugin_bundle
+        fi
+        echo "  (would write adoption report and apply preset/mode markers)"
+    fi
+
+
+    echo ""
+    echo "Step 7/7: Reconcile stale files..."
+    reconcile_stale_files
+    write_omg_manifest
+
+    echo ""
+    echo "═══════════════════════════════════════════════════════════════"
+    if [ $ERRORS -eq 0 ]; then
+        echo "  ✅ OMG ${VERSION} ${ACTION} completed successfully"
+    else
+        echo "  ⚠  OMG ${VERSION} ${ACTION} completed with $ERRORS error(s)"
+    fi
+    echo "═══════════════════════════════════════════════════════════════"
+    echo ""
+    echo "  Files: $installed_rules rules, $installed_hooks hooks, $installed_agents agents, $installed_cmds commands"
+    echo "  Version: $VERSION"
+    if $USE_SYMLINK; then
+        echo "  Mode: Symlink (live updates from $SCRIPT_DIR)"
+        echo "  Source: $SCRIPT_DIR"
+    elif $FRESH_INSTALL; then
+        echo "  Mode: Fresh reinstall"
+    elif [ -n "$existing_ver" ]; then
+        echo "  Upgraded: $existing_ver → $VERSION"
+        echo "  Backup: $BACKUP_DIR"
+    fi
+    echo ""
+    if $DRY_RUN; then
+        echo "  *** DRY RUN — no files were changed ***"
+        echo "  Run without --dry-run to apply changes."
+    fi
 }
 
 main() {
-  parse_args "$@"
-  prompt_start_action
-  preflight
-  case "$ACTION" in
-    install|update) install_action ;;
-    uninstall) uninstall_action ;;
-    *)
-      usage
-      exit 1
-      ;;
-  esac
+    parse_args "$@"
+    prompt_start_action
+    case "$ACTION" in
+        uninstall) run_uninstall ;;
+        install|update|reinstall) run_install_like ;;
+        *)
+            usage
+            exit 1
+            ;;
+    esac
 }
 
 main "$@"