@sparkleideas/claude-flow-patch 3.1.0-alpha.44.patch.10

package/check-patches.sh

@@ -0,0 +1,195 @@
+#!/bin/bash
+# check-patches.sh — Dynamic sentinel checker
+# Reads patch/*/sentinel files to verify patches are still applied.
+# On session start: detects wipes, auto-reapplies, warns user.
+#
+# Usage:
+#   bash check-patches.sh [--global] [--target <dir>]
+#
+# If neither flag is given, --global is assumed.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# ── Parse arguments ──
+DO_GLOBAL=0
+TARGET_DIR=""
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --global) DO_GLOBAL=1; shift ;;
+    --target) TARGET_DIR="${2:-}"; shift 2 ;;
+    *) shift ;;  # ignore unknown (e.g. filter env handled by caller)
+  esac
+done
+
+if [[ $DO_GLOBAL -eq 0 && -z "$TARGET_DIR" ]]; then
+  DO_GLOBAL=1
+fi
+
+# ── Shared discovery ──
+. "$SCRIPT_DIR/lib/discover.sh"
+
+# ── Collect installs ──
+INSTALLS=()
+
+if [[ $DO_GLOBAL -eq 1 ]]; then
+  while IFS= read -r line; do
+    [ -n "$line" ] && INSTALLS+=("$line")
+  done < <(discover_all_cf_installs)
+fi
+
+if [[ -n "$TARGET_DIR" && -d "$TARGET_DIR" ]]; then
+  while IFS= read -r line; do
+    [ -n "$line" ] && INSTALLS+=("$line")
+  done < <(discover_target_installs "$TARGET_DIR")
+fi
+
+if [[ ${#INSTALLS[@]} -eq 0 ]]; then
+  echo "[PATCHES] WARN: Cannot find claude-flow CLI files"
+  exit 0
+fi
+
+# ── Path resolver ──
+
+resolve_path() {
+  local base="$1"
+  local rv_base="$2"
+  local rs_base="$3"
+  local pkg="$4"
+  local relpath="$5"
+  case "$pkg" in
+    ruvector)  echo "$rv_base/$relpath" ;;
+    ruv-swarm) echo "$rs_base/$relpath" ;;
+    *)         echo "$base/$relpath" ;;
+  esac
+}
+
+# ── Check sentinels for a single install ──
+# Returns 0 if all OK, 1 if any failed.
+
+check_sentinels_for_install() {
+  local base="$1"
+  local rv_cli="$2"
+  local rs_root="$3"
+
+  # Derive ruvector base from cli path
+  local rv_base=""
+  if [ -n "$rv_cli" ]; then
+    rv_base="$(cd "$(dirname "$rv_cli")/.." 2>/dev/null && pwd)"
+  fi
+
+  local all_ok=true
+
+  for sentinel_file in "$SCRIPT_DIR"/patch/*/sentinel; do
+    [ -f "$sentinel_file" ] || continue
+
+    # PATCH_INCLUDE / PATCH_EXCLUDE env vars filter by directory name regex
+    local dirname
+    dirname=$(basename "$(dirname "$sentinel_file")")
+    local matchname="${dirname#[0-9][0-9][0-9]-}"   # strip NNN- prefix for pattern matching
+    if [ -n "${PATCH_INCLUDE:-}" ] && ! echo "$matchname" | grep -qE "$PATCH_INCLUDE"; then
+      continue
+    fi
+    if [ -n "${PATCH_EXCLUDE:-}" ] && echo "$matchname" | grep -qE "$PATCH_EXCLUDE"; then
+      continue
+    fi
+
+    # Read package line (default: claude-flow)
+    local pkg="claude-flow"
+    local pkg_line
+    pkg_line=$(grep -m1 '^package:' "$sentinel_file" 2>/dev/null || true)
+    if [ -n "$pkg_line" ]; then
+      pkg="${pkg_line#package:}"
+      pkg="${pkg#"${pkg%%[![:space:]]*}"}"  # trim leading whitespace
+      pkg="${pkg%%[[:space:]]*}"            # trim trailing whitespace
+    fi
+
+    # Skip if required package not installed
+    case "$pkg" in
+      ruvector)  [ -z "$rv_cli" ] && continue ;;
+      ruv-swarm) [ -z "$rs_root" ] && continue ;;
+    esac
+
+    # Process each line
+    while IFS= read -r line; do
+      line="${line#"${line%%[![:space:]]*}"}"  # trim leading whitespace
+      [[ -z "$line" ]] && continue
+      [[ "$line" == package:* ]] && continue
+
+      if [[ "$line" == "none" ]]; then
+        continue
+
+      elif [[ "$line" =~ ^absent\ \"(.+)\"\ (.+)$ ]]; then
+        local pattern="${BASH_REMATCH[1]}"
+        local filepath
+        filepath=$(resolve_path "$base" "$rv_base" "$rs_root" "$pkg" "${BASH_REMATCH[2]}")
+        if grep -q "$pattern" "$filepath" 2>/dev/null; then
+          all_ok=false
+        fi
+
+      elif [[ "$line" =~ ^grep\ \"(.+)\"\ (.+)$ ]]; then
+        local pattern="${BASH_REMATCH[1]}"
+        local filepath
+        filepath=$(resolve_path "$base" "$rv_base" "$rs_root" "$pkg" "${BASH_REMATCH[2]}")
+        if ! grep -q "$pattern" "$filepath" 2>/dev/null; then
+          all_ok=false
+        fi
+      fi
+    done < "$sentinel_file"
+  done
+
+  $all_ok
+}
+
+# ── Check all installs ──
+
+any_failed=false
+first_version=""
+
+for entry in "${INSTALLS[@]}"; do
+  IFS=$'\t' read -r dist_src version rv_cli rs_root writable <<< "$entry"
+  # "-" is the placeholder for empty fields (bash IFS collapses consecutive tabs)
+  [ "$rv_cli" = "-" ] && rv_cli=""
+  [ "$rs_root" = "-" ] && rs_root=""
+  [ -z "$first_version" ] && first_version="$version"
+
+  if ! check_sentinels_for_install "$dist_src" "$rv_cli" "$rs_root"; then
+    any_failed=true
+    break  # One failure is enough to trigger reapply
+  fi
+done
+
+VERSION="${first_version:-unknown}"
+
+if ! $any_failed; then
+  echo "[PATCHES] OK: All patches verified (v$VERSION)"
+  exit 0
+fi
+
+# ── Patches wiped — auto-reapply and warn ──
+
+echo ""
+echo "============================================"
+echo "  WARNING: claude-flow patches were wiped!"
+echo "  Likely cause: npx cache update (v$VERSION)"
+echo "============================================"
+echo ""
+
+if [ -x "$SCRIPT_DIR/patch-all.sh" ]; then
+  REAPPLY_ARGS=()
+  if [[ $DO_GLOBAL -eq 1 ]]; then REAPPLY_ARGS+=(--global); fi
+  if [[ -n "$TARGET_DIR" ]]; then REAPPLY_ARGS+=(--target "$TARGET_DIR"); fi
+  bash "$SCRIPT_DIR/patch-all.sh" "${REAPPLY_ARGS[@]}"
+  echo ""
+  echo "[PATCHES] Auto-reapplied. Stopping existing daemons..."
+  npx @claude-flow/cli@latest daemon stop 2>/dev/null
+  # Fallback: kill by PID file if daemon stop missed an orphan (project-scoped, not global)
+  _pid=$(cat .claude-flow/daemon.pid 2>/dev/null)
+  if [ -n "$_pid" ]; then kill "$_pid" 2>/dev/null || true; rm -f .claude-flow/daemon.pid; fi
+  sleep 1
+  npx @claude-flow/cli@latest daemon start 2>/dev/null
+  echo "[PATCHES] Daemon restarted in background (PID: $(cat .claude-flow/daemon.pid 2>/dev/null || echo 'unknown'))"
+  echo ""
+else
+  echo "[PATCHES] ERROR: patch-all.sh not found at $SCRIPT_DIR"
+  echo "[PATCHES] Run manually: bash ~/src/claude-flow-patch/patch-all.sh"
+fi

package/lib/categories.json

@@ -0,0 +1,15 @@
+{
+  "HW": "Headless Worker",
+  "DM": "Daemon & Workers",
+  "CF": "Config & Doctor",
+  "EM": "Embeddings & HNSW",
+  "UI": "Display & Cosmetic",
+  "NS": "Memory Namespace",
+  "GV": "Ghost Vectors",
+  "IN": "Intelligence",
+  "SG": "Settings Generator",
+  "MM": "Memory Management",
+  "HK": "Hooks",
+  "RV": "RuVector Intelligence",
+  "RS": "ruv-swarm"
+}

package/lib/common.py

@@ -0,0 +1,97 @@
+# common.py — shared patch infrastructure
+# Extracted from apply-patches.sh. Provides patch()/patch_all() + path variables.
+
+import sys, os, re
+
+base = os.environ.get("BASE", "")
+if not base or base == "/dev/null":
+    base = ""  # No claude-flow/cli, paths will be invalid (patch() will skip gracefully)
+services = base + "/services" if base else ""
+commands = base + "/commands" if base else ""
+memory = base + "/memory" if base else ""
+
+applied = 0
+skipped = 0
+
+def patch(label, filepath, old, new):
+    global applied, skipped
+    if not filepath:
+        return  # Skip if path is empty (package not found)
+    try:
+        with open(filepath, 'r') as f:
+            code = f.read()
+        if new in code:
+            skipped += 1
+            return
+        if old not in code:
+            print(f"  WARN: {label} — pattern not found (code may have changed)")
+            return
+        code = code.replace(old, new, 1)
+        with open(filepath, 'w') as f:
+            f.write(code)
+        print(f"  Applied: {label}")
+        applied += 1
+    except FileNotFoundError:
+        pass  # Silently skip if file doesn't exist (package not installed)
+    except Exception as e:
+        print(f"  ERROR: {label} — {e}")
+
+def patch_all(label, filepath, old, new):
+    """Replace ALL occurrences"""
+    global applied, skipped
+    if not filepath:
+        return  # Skip if path is empty (package not found)
+    try:
+        with open(filepath, 'r') as f:
+            code = f.read()
+        if new in code and old not in code:
+            skipped += 1
+            return
+        if old not in code:
+            print(f"  WARN: {label} — pattern not found")
+            return
+        code = code.replace(old, new)
+        with open(filepath, 'w') as f:
+            f.write(code)
+        print(f"  Applied: {label}")
+        applied += 1
+    except FileNotFoundError:
+        pass  # Silently skip if file doesn't exist (package not installed)
+    except Exception as e:
+        print(f"  ERROR: {label} — {e}")
+
+# ── Target file paths ──
+# These may be empty strings if base is not set (no claude-flow/cli found)
+HWE = services + "/headless-worker-executor.js" if services else ""
+WD = services + "/worker-daemon.js" if services else ""
+DJ = commands + "/daemon.js" if commands else ""
+DOC = commands + "/doctor.js" if commands else ""
+MI = memory + "/memory-initializer.js" if memory else ""
+
+MCP_MEMORY = base + "/mcp-tools/memory-tools.js" if base else ""
+MCP_HOOKS = base + "/mcp-tools/hooks-tools.js" if base else ""
+CLI_MEMORY = commands + "/memory.js" if commands else ""
+CONF = commands + "/config.js" if commands else ""
+HOOKS_CMD = commands + "/hooks.js" if commands else ""
+NEURAL = commands + "/neural.js" if commands else ""
+EMB_TOOLS = base + "/mcp-tools/embeddings-tools.js" if base else ""
+
+# Init module
+init = base + "/init" if base else ""
+SETTINGS_GEN = init + "/settings-generator.js" if init else ""
+HELPERS_GEN = init + "/helpers-generator.js" if init else ""
+EXECUTOR = init + "/executor.js" if init else ""
+TYPES = init + "/types.js" if init else ""
+INIT_CMD = commands + "/init.js" if commands else ""
+START_CMD = commands + "/start.js" if commands else ""
+CMDS_INDEX = commands + "/index.js" if commands else ""
+
+# Source helpers (shipped with package, copied by writeHelpers when source dir found)
+_pkg_root = os.path.dirname(os.path.dirname(base)) if base else ""
+SRC_HOOK_HANDLER = os.path.join(_pkg_root, ".claude", "helpers", "hook-handler.cjs") if _pkg_root else ""
+
+# RuVector (separate package, path set by patch-all.sh)
+ruvector_cli = os.environ.get("RUVECTOR_CLI", "")
+
+# ruv-swarm root (separate package, path set by patch-all.sh via discover.sh)
+ruv_swarm_root = os.environ.get("RUV_SWARM_ROOT", "")

package/lib/discover.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// lib/discover.mjs — Dynamic patch discovery
+// Scans patch/*/ directories, parses README.md + fix.py headers for metadata.
+// Single source of truth for scripts, sentinel checks, and documentation.
+
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+const PATCH_DIR = resolve(ROOT, 'patch');
+
+// Category labels from lib/categories.json
+const CATEGORY_MAP = JSON.parse(
+  readFileSync(resolve(__dirname, 'categories.json'), 'utf-8')
+);
+
+/**
+ * Parse a patch README.md for doc metadata.
+ * Expected format:
+ *   # {ID}: {title}
+ *   **Severity**: {severity}
+ *   **GitHub**: [{label}]({url})
+ *   ## Files Patched
+ *   - {file}
+ *   ## Ops
+ *   {N} op(s) in fix.py
+ */
+function parseReadme(readmePath, dirName) {
+  const text = readFileSync(readmePath, 'utf-8');
+  const lines = text.split('\n');
+
+  const titleMatch = lines[0]?.match(/^#\s+(\S+):\s+(.+)/);
+  const stripped = dirName.replace(/^\d+-/, '');
+  const id = titleMatch?.[1] ?? stripped.split('-').slice(0, 2).join('-');
+  const title = titleMatch?.[2]?.trim() ?? '';
+
+  const sevLine = lines.find(l => l.startsWith('**Severity**'));
+  const severity = sevLine?.match(/\*\*Severity\*\*:\s*(\S+)/)?.[1] ?? 'Unknown';
+
+  const ghLine = lines.find(l => l.startsWith('**GitHub**'));
+  const ghMatch = ghLine?.match(/\[([^\]]+)\]\(([^)]+)\)/);
+  const github = ghMatch?.[1] ?? '';
+  const githubUrl = ghMatch?.[2] ?? '';
+
+  const filesIdx = lines.findIndex(l => /^##\s+Files Patched/i.test(l));
+  const files = [];
+  if (filesIdx >= 0) {
+    for (let i = filesIdx + 1; i < lines.length; i++) {
+      const m = lines[i].match(/^-\s+`?([^`\n]+)`?\s*$/);
+      if (m) files.push(m[1].trim());
+      else if (lines[i].startsWith('#') || (lines[i].trim() === '' && files.length > 0)) break;
+    }
+  }
+
+  const opsLine = lines.find(l => /^\d+\s+ops?\b/i.test(l));
+  const ops = opsLine ? parseInt(opsLine, 10) : 0;
+
+  return { id, title, severity, github, githubUrl, files, ops };
+}
+
+/**
+ * Parse a sentinel file for verification metadata.
+ * Each line is one of:
+ *   package: <name>          — target package (default: @claude-flow/cli)
+ *   grep "<pattern>" <file>  — pass if pattern found
+ *   absent "<pattern>" <file> — pass if pattern NOT found
+ *   none                     — skip verification
+ */
+function parseSentinels(sentinelPath) {
+  const text = readFileSync(sentinelPath, 'utf-8');
+  const lines = text.split('\n');
+
+  let pkg = null;
+  const sentinels = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    if (trimmed.startsWith('package:')) {
+      pkg = trimmed.replace('package:', '').trim();
+    } else if (trimmed === 'none') {
+      sentinels.push({ type: 'none' });
+    } else {
+      const absentMatch = trimmed.match(/^absent\s+"(.+)"\s+(.+)$/);
+      if (absentMatch) {
+        sentinels.push({ type: 'absent', pattern: absentMatch[1], file: absentMatch[2] });
+        continue;
+      }
+      const grepMatch = trimmed.match(/^grep\s+"(.+)"\s+(.+)$/);
+      if (grepMatch) {
+        sentinels.push({ type: 'grep', pattern: grepMatch[1], file: grepMatch[2] });
+      }
+    }
+  }
+
+  return { package: pkg, sentinels };
+}
+
+/**
+ * Discover all patches. Returns structured JSON with everything needed
+ * by scripts, sentinel checks, and documentation.
+ */
+export function discover() {
+  let dirs;
+  try {
+    dirs = readdirSync(PATCH_DIR, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .sort();
+  } catch {
+    return { patches: [], categories: {}, stats: { total: 0, categories: 0 } };
+  }
+
+  const patches = [];
+  const categorySet = new Set();
+
+  for (const dirName of dirs) {
+    const readmePath = resolve(PATCH_DIR, dirName, 'README.md');
+    if (!existsSync(readmePath)) continue;
+
+    const meta = parseReadme(readmePath, dirName);
+    const prefix = meta.id.split('-')[0];
+    const stripped = dirName.replace(/^\d+-/, '');
+    const slug = stripped.replace(/^[A-Z]+-\d+-/, '');
+    const orderMatch = dirName.match(/^(\d+)-/);
+    const order = orderMatch ? parseInt(orderMatch[1], 10) : null;
+    const hasPy = existsSync(resolve(PATCH_DIR, dirName, 'fix.py'));
+    const hasSh = existsSync(resolve(PATCH_DIR, dirName, 'fix.sh'));
+    const fixType = hasPy ? 'python' : hasSh ? 'shell' : 'unknown';
+    const category = CATEGORY_MAP[prefix] ?? prefix;
+    categorySet.add(category);
+
+    // Parse sentinel metadata from dedicated sentinel file
+    const sentinelPath = resolve(PATCH_DIR, dirName, 'sentinel');
+    const sentinel = existsSync(sentinelPath) ? parseSentinels(sentinelPath) : { package: null, sentinels: [] };
+
+    patches.push({
+      id: meta.id,
+      order,
+      slug,
+      dir: dirName,
+      title: meta.title,
+      severity: meta.severity,
+      github: meta.github,
+      githubUrl: meta.githubUrl,
+      category,
+      prefix,
+      type: fixType,
+      files: meta.files,
+      ops: meta.ops,
+      package: sentinel.package,
+      sentinels: sentinel.sentinels,
+    });
+  }
+
+  // Build categories object: { prefix: label } for active categories
+  const categories = {};
+  for (const p of patches) {
+    if (!categories[p.prefix]) {
+      categories[p.prefix] = CATEGORY_MAP[p.prefix] ?? p.prefix;
+    }
+  }
+
+  return {
+    patches,
+    categories,
+    stats: {
+      total: patches.length,
+      categories: categorySet.size,
+    },
+  };
+}
+
+// CLI: `node lib/discover.mjs` prints JSON to stdout
+const thisFile = resolve(__dirname, 'discover.mjs');
+if (process.argv[1] && resolve(process.argv[1]) === thisFile) {
+  console.log(JSON.stringify(discover(), null, 2));
+}

package/lib/discover.sh

@@ -0,0 +1,160 @@
+#!/bin/bash
+# lib/discover.sh — Shared install discovery for patch-all.sh, check-patches.sh, repair-post-init.sh
+#
+# Finds ALL @claude-flow/cli installations across three patterns:
+#   1. Direct npx:   {npx_cache}/{hash}/node_modules/@claude-flow/cli/dist/src/
+#   2. Umbrella npx: {npx_cache}/{hash}/node_modules/claude-flow/v3/@claude-flow/cli/dist/src/
+#   3. Umbrella global: {npm_prefix}/lib/node_modules/claude-flow/v3/@claude-flow/cli/dist/src/
+#
+# Output: tab-separated lines:
+#   dist_src \t version \t ruvector_cli \t ruv_swarm_root \t writable(yes|no)
+
+# ── npx cache roots ──
+
+_cfp_npx_cache_roots() {
+  # Linux / macOS
+  local home_npx="$HOME/.npm/_npx"
+  [ -d "$home_npx" ] && echo "$home_npx"
+
+  # Windows (Git Bash / MSYS2): $LOCALAPPDATA/npm-cache/_npx
+  if [ -n "${LOCALAPPDATA:-}" ]; then
+    local win_npx
+    if command -v cygpath >/dev/null 2>&1; then
+      win_npx="$(cygpath "$LOCALAPPDATA")/npm-cache/_npx"
+    else
+      win_npx="$LOCALAPPDATA/npm-cache/_npx"
+    fi
+    [ -d "$win_npx" ] && echo "$win_npx"
+  fi
+}
+
+# ── Probe a single node_modules directory ──
+# Args: <node_modules_dir>
+# Outputs tab-separated lines for each valid install found.
+
+_cfp_probe_node_modules() {
+  local nm_dir="$1"
+  [ -d "$nm_dir" ] || return 0
+
+  local layouts=(
+    "@claude-flow/cli/dist/src"
+    "claude-flow/v3/@claude-flow/cli/dist/src"
+  )
+
+  local _seen_real=()
+
+  for layout in "${layouts[@]}"; do
+    local dist_src="$nm_dir/$layout"
+    [ -f "$dist_src/memory/memory-initializer.js" ] || continue
+
+    # Deduplicate by realpath
+    local real
+    real="$(realpath "$dist_src" 2>/dev/null || echo "$dist_src")"
+    local dup=0
+    for s in "${_seen_real[@]}"; do
+      [ "$s" = "$real" ] && { dup=1; break; }
+    done
+    [ "$dup" -eq 1 ] && continue
+    _seen_real+=("$real")
+
+    # Version
+    local pkg_json="$dist_src/../../package.json"
+    local version
+    version=$(grep -o '"version": *"[^"]*"' "$pkg_json" 2>/dev/null | head -1 | cut -d'"' -f4)
+    [ -z "$version" ] && version="unknown"
+
+    # Companion: ruvector — search sibling node_modules and umbrella's v3/node_modules
+    local rv_cli="-"
+    local search_dirs=("$nm_dir")
+    # If umbrella layout, also search inside v3/node_modules
+    if [[ "$layout" == claude-flow/* ]]; then
+      local v3_nm="$nm_dir/claude-flow/v3/node_modules"
+      [ -d "$v3_nm" ] && search_dirs+=("$v3_nm")
+    fi
+    for sd in "${search_dirs[@]}"; do
+      if [ -f "$sd/ruvector/bin/cli.js" ]; then
+        rv_cli="$(cd "$sd/ruvector/bin" 2>/dev/null && pwd)/cli.js"
+        break
+      fi
+    done
+
+    # Companion: ruv-swarm root
+    local rs_root="-"
+    for sd in "${search_dirs[@]}"; do
+      if [ -f "$sd/ruv-swarm/package.json" ]; then
+        rs_root="$(cd "$sd/ruv-swarm" 2>/dev/null && pwd)"
+        break
+      fi
+    done
+
+    # Writable check
+    local writable="yes"
+    [ -w "$dist_src/memory/memory-initializer.js" ] || writable="no"
+
+    # Use "-" for empty fields to prevent bash IFS collapsing consecutive delimiters
+    printf '%s\t%s\t%s\t%s\t%s\n' "$dist_src" "$version" "$rv_cli" "$rs_root" "$writable"
+  done
+}
+
+# ── Discover all global installs ──
+# Outputs tab-separated lines (same format as _cfp_probe_node_modules).
+
+discover_all_cf_installs() {
+  local _global_seen=()
+
+  # 1. npx cache directories
+  while IFS= read -r cache_root; do
+    [ -n "$cache_root" ] || continue
+    for hash_dir in "$cache_root"/*/; do
+      [ -d "$hash_dir/node_modules" ] || continue
+      while IFS= read -r line; do
+        [ -n "$line" ] || continue
+        local ds="${line%%	*}"
+        local real
+        real="$(realpath "$ds" 2>/dev/null || echo "$ds")"
+        local dup=0
+        for s in "${_global_seen[@]}"; do
+          [ "$s" = "$real" ] && { dup=1; break; }
+        done
+        [ "$dup" -eq 1 ] && continue
+        _global_seen+=("$real")
+        echo "$line"
+      done < <(_cfp_probe_node_modules "$hash_dir/node_modules")
+    done
+  done < <(_cfp_npx_cache_roots)
+
+  # 2. Global npm prefix
+  local npm_prefix
+  npm_prefix="$(npm config get prefix 2>/dev/null)" || true
+  if [ -n "$npm_prefix" ]; then
+    # Linux/macOS: {prefix}/lib/node_modules
+    # Windows: {prefix}/node_modules (no /lib/)
+    local prefix_dirs=("$npm_prefix/lib/node_modules" "$npm_prefix/node_modules")
+    for pdir in "${prefix_dirs[@]}"; do
+      [ -d "$pdir" ] || continue
+      while IFS= read -r line; do
+        [ -n "$line" ] || continue
+        local ds="${line%%	*}"
+        local real
+        real="$(realpath "$ds" 2>/dev/null || echo "$ds")"
+        local dup=0
+        for s in "${_global_seen[@]}"; do
+          [ "$s" = "$real" ] && { dup=1; break; }
+        done
+        [ "$dup" -eq 1 ] && continue
+        _global_seen+=("$real")
+        echo "$line"
+      done < <(_cfp_probe_node_modules "$pdir")
+    done
+  fi
+}
+
+# ── Discover installs in a --target directory ──
+# Args: <target_dir>
+# Now handles both direct and umbrella layouts.
+
+discover_target_installs() {
+  local dir="$1"
+  [ -d "$dir/node_modules" ] || return 0
+  _cfp_probe_node_modules "$dir/node_modules"
+}