cue-ai 0.3.0 → 0.4.1

package/resources/skills/scripts/import-globals.sh

@@ -1,102 +0,0 @@
-#!/usr/bin/env bash
-# Pull in skills installed globally (e.g. via `npx skills add` or
-# Claude/Codex marketplaces) so the soul/skills repo stays the source
-# of truth for everything routable on this laptop.
-#
-# Behaviour:
-#   - Walks ~/.claude/skills and ~/.codex/skills.
-#   - For any entry that is a real dir OR a symlink pointing OUTSIDE this
-#     repo (typically into ~/.agents/skills), copies the resolved content
-#     into skills/imported/<name>/ and replaces the global entry with a
-#     symlink back into the repo.
-#   - Skips backups, hidden entries (.system, etc.), entries already
-#     symlinked into this repo, and any name already present elsewhere
-#     in the repo (don't shadow an existing categorized skill).
-#
-# Idempotent. Silent on no-op. Best-effort: never blocks the session.
-# Disable per-session by exporting SKILLS_AUTO_IMPORT=0.
-
-set -euo pipefail
-
-repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-imported_dir="$repo_root/skills/imported"
-
-if [[ "${SKILLS_AUTO_IMPORT:-1}" == "0" ]]; then
-  exit 0
-fi
-
-# All skill names that already live somewhere under skills/<category>/<name>/
-# (so we don't shadow them with a duplicate under skills/imported/).
-existing_names() {
-  find "$repo_root/skills" -mindepth 2 -maxdepth 2 -type d -printf '%f\n' 2>/dev/null
-}
-
-# Returns 0 if the skill name already exists in the repo (any category)
-exists_in_repo() {
-  local name="$1"
-  existing_names | grep -Fxq "$name"
-}
-
-# Walk one global skills root
-process_root() {
-  local root="$1"
-  [[ -d "$root" ]] || return 0
-
-  shopt -s nullglob
-  for entry in "$root"/*; do
-    local name; name="$(basename "$entry")"
-
-    # Skip dotfiles, backup folders, junk
-    [[ "$name" == .* ]] && continue
-    [[ "$name" == *.backup.* ]] && continue
-    [[ "$name" == *.original ]] && continue
-
-    # Resolve target if symlink
-    local target
-    if [[ -L "$entry" ]]; then
-      target="$(readlink -f "$entry")"
-      # Already pointing into our repo → nothing to do
-      case "$target" in
-        "$repo_root"/*) continue ;;
-      esac
-    elif [[ -d "$entry" ]]; then
-      target="$entry"
-    else
-      continue
-    fi
-
-    # Need a SKILL.md to consider it a skill
-    [[ -f "$target/SKILL.md" ]] || continue
-
-    # Don't shadow an existing categorized copy
-    if exists_in_repo "$name"; then
-      continue
-    fi
-
-    # Pull into skills/imported/<name>/
-    mkdir -p "$imported_dir"
-    local dest="$imported_dir/$name"
-    if [[ -e "$dest" ]]; then
-      # Already imported on a previous run — just refresh symlink and continue
-      :
-    else
-      # Use rsync if available for a clean copy that follows symlinks within;
-      # otherwise fall back to cp -RL
-      if command -v rsync >/dev/null 2>&1; then
-        rsync -a --delete --copy-links "$target/" "$dest/" 2>/dev/null || cp -RL "$target" "$dest"
-      else
-        cp -RL "$target" "$dest"
-      fi
-      echo "[import-globals] imported $name from $target"
-    fi
-
-    # Replace the global entry with a symlink into the repo
-    if [[ -L "$entry" ]] || [[ -e "$entry" ]]; then
-      rm -rf "$entry"
-    fi
-    ln -s "$dest" "$entry"
-  done
-}
-
-process_root "$HOME/.claude/skills"
-process_root "$HOME/.codex/skills"

package/resources/skills/scripts/install-claude.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-"$repo_root/scripts/activate-profile.sh" \
-  --profile "${SOUL_SKILL_PROFILE:-all}" \
-  --agent claude \
-  --target "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/skills"

package/resources/skills/scripts/install-codex.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-"$repo_root/scripts/activate-profile.sh" \
-  --profile "${SOUL_SKILL_PROFILE:-all}" \
-  --agent codex \
-  --target "${CODEX_HOME:-$HOME/.codex}/skills"

package/resources/skills/scripts/install-local.sh

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-"$repo_root/scripts/install-codex.sh"
-"$repo_root/scripts/install-claude.sh"

package/resources/skills/scripts/refresh-catalog.sh

@@ -1,207 +0,0 @@
-#!/usr/bin/env bash
-# refresh-catalog.sh
-#
-# Builds ~/Documents/soul/skills/catalog/catalog.json — an index of:
-#   1. Locally-installed skills (from ~/.claude/skills/ and soul/skills/skills/)
-#   2. Available skills in trusted upstream repos (from known_repos.json)
-#   3. MCP servers under soul/mcps/mcps/
-#
-# Used by the `skill-suggestion` skill to answer "is there an existing skill
-# that does X?" without burning a fresh GitHub search every turn.
-#
-# Run via:
-#   ~/Documents/soul/skills/scripts/refresh-catalog.sh
-#   just refresh-catalog
-#
-# Requires: bash, jq, gh (with valid auth), find, awk.
-# Network: hits GitHub via `gh` to enumerate upstream repo trees.
-# Best-effort: skips upstream sources that fail; never errors on partial data.
-# Kill switch: SOUL_CATALOG_OFFLINE=1 → skip the upstream fetch, only refresh local.
-
-set -euo pipefail
-
-ROOT="${HOME}/Documents/soul/skills"
-CATALOG_DIR="${ROOT}/catalog"
-KNOWN_REPOS="${CATALOG_DIR}/known_repos.json"
-OUT="${CATALOG_DIR}/catalog.json"
-TMP="$(mktemp)"
-trap 'rm -f "$TMP"' EXIT
-
-OFFLINE="${SOUL_CATALOG_OFFLINE:-0}"
-LOG=()
-log() { LOG+=("$1"); echo "  $1" >&2; }
-
-# ----------------------------------------------------------------------------
-# Pre-flight
-# ----------------------------------------------------------------------------
-command -v jq >/dev/null || { echo "ERROR: jq required" >&2; exit 1; }
-[[ -f "$KNOWN_REPOS" ]] || { echo "ERROR: $KNOWN_REPOS missing" >&2; exit 1; }
-
-if [[ "$OFFLINE" != "1" ]]; then
-  command -v gh >/dev/null || { echo "WARN: gh missing — running offline" >&2; OFFLINE=1; }
-  if [[ "$OFFLINE" != "1" ]] && ! gh auth status >/dev/null 2>&1; then
-    echo "WARN: gh not authenticated — running offline" >&2
-    OFFLINE=1
-  fi
-fi
-
-echo "Building skill catalog..." >&2
-echo "  out:     $OUT" >&2
-echo "  offline: $OFFLINE" >&2
-echo >&2
-
-# ----------------------------------------------------------------------------
-# Helpers — extract `name` and `description` from a SKILL.md frontmatter
-# ----------------------------------------------------------------------------
-extract_field() {
-  local file="$1" field="$2"
-  awk -v f="$field" '
-    BEGIN { in_fm=0; collecting=0; out="" }
-    /^---[[:space:]]*$/ { if (!in_fm) { in_fm=1; next } else { exit } }
-    in_fm && $0 ~ ("^"f":") {
-      sub("^"f":[[:space:]]*","")
-      if ($0 == ">-" || $0 == ">") { collecting=1; next }
-      gsub(/^[[:space:]]*"|"[[:space:]]*$/, "")
-      out = $0
-      print out; exit
-    }
-    in_fm && collecting {
-      if ($0 ~ /^[a-zA-Z_-]+:/) { print out; exit }
-      sub(/^[[:space:]]+/,"")
-      out = (out=="" ? $0 : out " " $0)
-    }
-    END { if (collecting) print out }
-  ' "$file" 2>/dev/null
-}
-
-# ----------------------------------------------------------------------------
-# Section 1: locally installed skills
-# ----------------------------------------------------------------------------
-log "Scanning locally-installed skills..."
-INSTALLED_JSON="$(mktemp)"
-trap 'rm -f "$TMP" "$INSTALLED_JSON" "$UPSTREAM_JSON" "$MCP_JSON"' EXIT
-
-# Source paths to scan: soul source-of-truth + Claude/Codex symlinks
-declare -a SCAN_PATHS=(
-  "${ROOT}/skills"
-  "${HOME}/.claude/skills"
-)
-
-echo "[]" > "$INSTALLED_JSON"
-INSTALLED_COUNT=0
-SEEN_NAMES="$(mktemp)"; trap 'rm -f "$TMP" "$INSTALLED_JSON" "$UPSTREAM_JSON" "$MCP_JSON" "$SEEN_NAMES"' EXIT
-
-while IFS= read -r skill_md; do
-  name="$(extract_field "$skill_md" name)"
-  [[ -z "$name" ]] && continue
-  grep -qxF "$name" "$SEEN_NAMES" 2>/dev/null && continue
-  echo "$name" >> "$SEEN_NAMES"
-
-  desc="$(extract_field "$skill_md" description)"
-  # Resolve real source path (follow symlinks)
-  src="$(readlink -f "$skill_md")"
-  category="$(dirname "$src" | sed 's|.*/skills/skills/||; s|/[^/]*$||')"
-
-  jq --arg n "$name" --arg d "$desc" --arg s "$src" --arg c "$category" \
-     '. += [{name: $n, description: $d, source: $s, category: $c}]' \
-     "$INSTALLED_JSON" > "$TMP" && mv "$TMP" "$INSTALLED_JSON"
-  INSTALLED_COUNT=$((INSTALLED_COUNT + 1))
-done < <(find "${SCAN_PATHS[@]}" -name SKILL.md -not -path '*/node_modules/*' 2>/dev/null | sort -u)
-
-log "Found $INSTALLED_COUNT locally-installed skills"
-
-# ----------------------------------------------------------------------------
-# Section 2: upstream available skills (from known_repos.json)
-# ----------------------------------------------------------------------------
-UPSTREAM_JSON="$(mktemp)"
-echo "[]" > "$UPSTREAM_JSON"
-UPSTREAM_COUNT=0
-
-if [[ "$OFFLINE" == "1" ]]; then
-  log "Skipping upstream fetch (offline mode)"
-else
-  log "Fetching upstream skill catalogs..."
-  REPOS_LEN="$(jq '.repos | length' "$KNOWN_REPOS")"
-  for i in $(seq 0 $((REPOS_LEN - 1))); do
-    owner="$(jq -r ".repos[$i].owner" "$KNOWN_REPOS")"
-    name="$(jq -r ".repos[$i].name" "$KNOWN_REPOS")"
-    trust="$(jq -r ".repos[$i].trust" "$KNOWN_REPOS")"
-    url="$(jq -r ".repos[$i].url" "$KNOWN_REPOS")"
-
-    log "  → $owner/$name"
-
-    # Use gh API to list SKILL.md files in default branch (best-effort)
-    if ! tree_json="$(gh api "repos/$owner/$name/git/trees/HEAD?recursive=1" 2>/dev/null)"; then
-      log "    (skip: API failed)"
-      continue
-    fi
-
-    # Find every SKILL.md path
-    while IFS= read -r path; do
-      [[ -z "$path" ]] && continue
-      skill_name="$(basename "$(dirname "$path")")"
-      raw_url="https://raw.githubusercontent.com/$owner/$name/HEAD/$path"
-      jq --arg n "$skill_name" \
-         --arg p "$path" \
-         --arg r "$owner/$name" \
-         --arg t "$trust" \
-         --arg u "$raw_url" \
-         --arg w "$url" \
-         '. += [{name: $n, repo: $r, trust: $t, path: $p, raw_url: $u, web_url: $w}]' \
-         "$UPSTREAM_JSON" > "$TMP" && mv "$TMP" "$UPSTREAM_JSON"
-      UPSTREAM_COUNT=$((UPSTREAM_COUNT + 1))
-    done < <(echo "$tree_json" | jq -r '.tree[]?.path | select(endswith("/SKILL.md") or . == "SKILL.md")')
-  done
-  log "Found $UPSTREAM_COUNT upstream skills across $REPOS_LEN repos"
-fi
-
-# ----------------------------------------------------------------------------
-# Section 3: locally installed MCPs
-# ----------------------------------------------------------------------------
-MCP_JSON="$(mktemp)"
-echo "[]" > "$MCP_JSON"
-MCP_COUNT=0
-
-if [[ -d "${HOME}/Documents/soul/mcps/mcps" ]]; then
-  while IFS= read -r mcp_dir; do
-    mcp_name="$(basename "$mcp_dir")"
-    desc=""
-    if [[ -f "$mcp_dir/README.md" ]]; then
-      # First non-blank, non-heading line as a quick description
-      desc="$(awk '/^[^#[:space:]]/{print; exit}' "$mcp_dir/README.md" | head -c 200)"
-    fi
-    jq --arg n "$mcp_name" --arg d "$desc" --arg p "$mcp_dir" \
-       '. += [{name: $n, description: $d, source: $p}]' \
-       "$MCP_JSON" > "$TMP" && mv "$TMP" "$MCP_JSON"
-    MCP_COUNT=$((MCP_COUNT + 1))
-  done < <(find "${HOME}/Documents/soul/mcps/mcps" -mindepth 1 -maxdepth 1 -type d 2>/dev/null | sort)
-fi
-log "Found $MCP_COUNT MCP servers"
-
-# ----------------------------------------------------------------------------
-# Assemble catalog
-# ----------------------------------------------------------------------------
-mkdir -p "$CATALOG_DIR"
-jq -n \
-  --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
-  --arg offline "$OFFLINE" \
-  --slurpfile installed "$INSTALLED_JSON" \
-  --slurpfile upstream "$UPSTREAM_JSON" \
-  --slurpfile mcps "$MCP_JSON" \
-  '{
-    schema_version: 1,
-    generated_at: $ts,
-    offline: ($offline == "1"),
-    counts: {
-      installed: ($installed[0] | length),
-      upstream:  ($upstream[0]  | length),
-      mcps:      ($mcps[0]      | length)
-    },
-    installed: $installed[0],
-    upstream:  $upstream[0],
-    mcps:      $mcps[0]
-  }' > "$OUT"
-
-echo >&2
-echo "✓ Catalog written: $OUT" >&2
-echo "  installed: $INSTALLED_COUNT  upstream: $UPSTREAM_COUNT  mcps: $MCP_COUNT" >&2

package/resources/skills/scripts/soul-lint.sh

@@ -1,66 +0,0 @@
-#!/usr/bin/env bash
-# soul-lint: human-readable summary of soul SKILL.md health.
-# Modes:
-#   soul-lint            — human output (default), exit 1 on errors
-#   soul-lint --quiet    — only errors, silent on clean
-#   soul-lint --json     — raw JSON from the linter
-# Called by sync-all.sh in --quiet mode every 15 min.
-
-set -euo pipefail
-
-MODE="${1:-human}"
-LINTER="${HOME}/Documents/soul/mcps/mcps/soul-skills/lint.py"
-
-if [[ ! -f "$LINTER" ]]; then
-  echo "soul-lint: linter not found: $LINTER" >&2
-  exit 2
-fi
-
-# linter is stdlib-only; plain python3 works. PEP 723 shebang is a fallback
-# when running under uv. Prefer plain python3 here for portability.
-# lint.py exits 1 when it finds errors (not when it crashes). Capture stdout
-# regardless of exit code; we'll classify pass/fail from error_count below.
-if command -v python3 >/dev/null 2>&1; then
-  result=$(python3 "$LINTER" 2>/dev/null || true)
-elif command -v uv >/dev/null 2>&1; then
-  result=$(uv run --quiet "$LINTER" 2>/dev/null || true)
-else
-  echo "soul-lint: python3 or uv required" >&2
-  exit 2
-fi
-
-if [[ -z "$result" ]] || ! echo "$result" | jq empty 2>/dev/null; then
-  echo "soul-lint: linter produced no parsable output (it crashed)" >&2
-  exit 2
-fi
-
-err_count=$(echo "$result" | jq -r '.error_count // 0')
-warn_count=$(echo "$result" | jq -r '.warning_count // 0')
-checked=$(echo "$result" | jq -r '.checked // 0')
-
-case "$MODE" in
-  --json)
-    echo "$result"
-    ;;
-  --quiet)
-    if [[ "$err_count" -gt 0 ]]; then
-      echo "$result" | jq -r '.errors[] | "[soul-lint ERROR] \(.path): \(.issue)"' >&2
-      exit 1
-    fi
-    ;;
-  *)
-    echo "soul-lint: checked $checked skill(s)"
-    if [[ "$err_count" -gt 0 ]]; then
-      echo "$result" | jq -r '.errors[] | "  [ERROR] \(.path): \(.issue)"' >&2
-    fi
-    if [[ "$warn_count" -gt 0 ]]; then
-      echo "$result" | jq -r '.warnings[] | "  [warn]  \(.path): \(.issue)"' >&2
-    fi
-    if [[ "$err_count" -eq 0 && "$warn_count" -eq 0 ]]; then
-      echo "  all clean"
-    else
-      echo "  $err_count error(s), $warn_count warning(s)"
-    fi
-    [[ "$err_count" -gt 0 ]] && exit 1 || exit 0
-    ;;
-esac

package/resources/skills/scripts/sync-all.sh

@@ -1,112 +0,0 @@
-#!/usr/bin/env bash
-# Orchestrate sync of skills + mcps repos to GitHub.
-#
-# Cadence approved by user 2026-05-09: Stop hook (per-turn, debounced) +
-# systemd user timer (every 15 min backstop). flock serializes so
-# concurrent firings can't race.
-#
-# Order:
-#   1. git pull --ff-only on both repos        — pick up any remote reorg
-#   2. skills/scripts/install-local.sh         — refresh ~/.claude + ~/.codex
-#                                                 symlinks from the current
-#                                                 source-tree organization
-#                                                 (idempotent via `ln -sfn`)
-#   3. skills/scripts/sync-claude-desktop-mcps.sh — propagate ~/.claude.json
-#                                                 mcpServers into Desktop's
-#                                                 config (Claude Code → Desktop)
-#   4. skills/scripts/auto-push.sh             — commit+push skills repo
-#   5. mcps/scripts/refresh-all.sh             — refresh mcps snapshots
-#   6. mcps/scripts/auto-push.sh               — commit+push mcps repo
-#   7. sweep broken symlinks under ~/.claude/skills + ~/.codex/skills
-#      (catches deleted-from-source skills; `ln -sfn` already handles moves)
-#
-# Each auto-push is a no-op when its tracked paths are unchanged (built-in
-# git diff --cached --quiet check), so per-turn firing is cheap.
-#
-# Best-effort: never blocks the session. Errors logged to
-# ~/.cache/soul-sync.log only.
-# Kill switch: export SOUL_SYNC_OFF=1.
-
-set -euo pipefail
-
-if [[ "${SOUL_SYNC_OFF:-0}" == "1" ]]; then
-  exit 0
-fi
-
-LOCK_FILE="/tmp/soul-sync.lock"
-LOG_FILE="${HOME}/.cache/soul-sync.log"
-mkdir -p "$(dirname "$LOG_FILE")"
-
-SKILLS="${HOME}/Documents/soul/skills"
-MCPS="${HOME}/Documents/soul/mcps"
-
-exec 9>"$LOCK_FILE"
-if ! flock -n 9; then
-  exit 0
-fi
-
-stamp() { date -u +"%Y-%m-%dT%H:%M:%SZ"; }
-log()   { echo "[$(stamp)] $*" >> "$LOG_FILE"; }
-
-log "sync start"
-
-# Pull remote changes first (multi-machine workflows). --ff-only refuses on
-# divergence, leaving conflict resolution to the human — never auto-merge.
-( cd "$SKILLS" && git pull --ff-only ) >> "$LOG_FILE" 2>&1 || log "skills pull skipped (likely diverged or offline)"
-( cd "$MCPS"   && git pull --ff-only ) >> "$LOG_FILE" 2>&1 || log "mcps pull skipped (likely diverged or offline)"
-
-# Refresh local symlinks so any source-tree reorg (local or just pulled)
-# materializes in ~/.claude/skills and ~/.codex/skills before we push.
-# install-local.sh is idempotent via `ln -sfn` — no .backup.* clutter.
-if [[ -x "$SKILLS/scripts/install-local.sh" ]]; then
-  "$SKILLS/scripts/install-local.sh" >> "$LOG_FILE" 2>&1 || log "install-local failed"
-fi
-
-# Run soul-lint in --quiet mode. Silent on clean (errors only). Errors land
-# in the sync log so a SKILL.md regression doesn't go unnoticed.
-if [[ -x "$SKILLS/scripts/soul-lint.sh" ]]; then
-  "$SKILLS/scripts/soul-lint.sh" --quiet >> "$LOG_FILE" 2>&1 || log "soul-lint reported errors (see log)"
-fi
-
-# Propagate ~/.claude.json mcpServers into Claude Desktop's config so MCPs
-# added via `claude mcp add` flow into the desktop app on its next restart.
-# Now bidirectional: reverse-merges Desktop-only orphans before forward-sync.
-if [[ -x "$SKILLS/scripts/sync-claude-desktop-mcps.sh" ]]; then
-  "$SKILLS/scripts/sync-claude-desktop-mcps.sh" >> "$LOG_FILE" 2>&1 || log "claude-desktop mcp sync failed"
-fi
-
-# MCP + plugin snapshots are owned by soul/mcps (sole source of truth).
-# skills/scripts/sync-mcps.sh was removed 2026-05-09 to dedup; the skills
-# repo references mcps/ via README pointers. mcps/scripts/refresh-all.sh
-# below regenerates the canonical snapshots.
-
-if [[ -x "$SKILLS/scripts/auto-push.sh" ]]; then
-  "$SKILLS/scripts/auto-push.sh" >> "$LOG_FILE" 2>&1 || log "skills auto-push failed"
-fi
-
-if [[ -x "$MCPS/scripts/refresh-all.sh" ]]; then
-  ( cd "$MCPS" && "$MCPS/scripts/refresh-all.sh" ) >> "$LOG_FILE" 2>&1 || log "mcps refresh-all failed"
-fi
-
-if [[ -x "$MCPS/scripts/auto-push.sh" ]]; then
-  "$MCPS/scripts/auto-push.sh" >> "$LOG_FILE" 2>&1 || log "mcps auto-push failed"
-fi
-
-# Mirror skills/ + mcps/ into the unified public recodeee/soul repo.
-# Snapshot lives at ~/.local/state/soul-mirror; auto-push-soul.sh rsyncs
-# and pushes only when contents change. Runs after the per-repo pushes
-# so soul reflects the just-pushed state of both halves.
-if [[ -x "$SKILLS/scripts/auto-push-soul.sh" ]]; then
-  "$SKILLS/scripts/auto-push-soul.sh" >> "$LOG_FILE" 2>&1 || log "soul auto-push failed"
-fi
-
-# Sweep BROKEN symlinks (target no longer exists). Catches:
-#   - skills deleted from the source tree
-#   - any leftover `.backup.*` symlinks from older install-script versions
-# `-xtype l` matches symlinks whose target doesn't resolve. Real skill
-# symlinks point to existing dirs and are never touched.
-find "${HOME}/.claude/skills" "${HOME}/.codex/skills" -maxdepth 1 \
-  -xtype l -delete 2>>"$LOG_FILE" || true
-
-log "sync done"
-exit 0

package/resources/skills/scripts/sync-claude-desktop-mcps.sh

@@ -1,123 +0,0 @@
-#!/usr/bin/env bash
-# One-way sync: ~/.claude.json `mcpServers` → ~/.config/Claude/claude_desktop_config.json
-#
-# Why: `claude mcp add` writes to ~/.claude.json (Claude Code's canonical
-# config). Claude Desktop reads its own file and doesn't share state. This
-# script propagates new/removed/changed MCPs into Desktop's config so a
-# Desktop restart picks them up.
-#
-# Adapter rules (Claude Desktop's stdio schema is stricter than Claude Code's):
-#   - Drop entries with type="http" / "sse" / a `url` field — those are remote
-#     MCPs and Desktop expects them via the Connectors UI, not local config.
-#     Keeping them in mcpServers makes Desktop reject the WHOLE block.
-#   - Strip the `type` field from stdio entries — Desktop's strict schema
-#     rejects entries that have it.
-#   - Preserve Desktop's existing `preferences` block byte-for-byte.
-#
-# Sync direction is one-way (CLI → Desktop). If you add an MCP via Desktop's
-# "Edit Config" UI, the next sync run will overwrite it from ~/.claude.json.
-# Treat ~/.claude.json as the source of truth for both CLI and Desktop MCPs.
-#
-# Idempotent: only writes when the resulting file content actually differs.
-# Silent on no-op. Best-effort: never blocks the calling sync.
-# Kill switch: export CLAUDE_DESKTOP_MCP_SYNC_OFF=1.
-
-set -euo pipefail
-
-if [[ "${CLAUDE_DESKTOP_MCP_SYNC_OFF:-0}" == "1" ]]; then
-  exit 0
-fi
-
-src="${HOME}/.claude.json"
-dst="${HOME}/.config/Claude/claude_desktop_config.json"
-
-[[ -f "$src" ]] || exit 0
-[[ -f "$dst" ]] || exit 0
-command -v jq >/dev/null 2>&1 || exit 0
-
-# ── REVERSE merge: if Desktop has stdio MCPs not in ~/.claude.json (because
-# user added them via Desktop's "Edit Config" UI), pull them back so the next
-# forward-sync pass doesn't wipe them. Skips http/sse entries.
-orphans=$(jq -r --slurpfile cli "$src" '
-  ($cli[0].mcpServers // {}) as $known
-  | (.mcpServers // {}) | to_entries
-  | map(
-      select(($known[.key] // null) == null)
-      | select((.value.type // "stdio") == "stdio")
-      | select((.value.command // null) != null)
-    )
-  | .[].key
-' "$dst" 2>/dev/null || true)
-
-if [[ -n "$orphans" ]]; then
-  bak="${src}.soul-backup"
-  cp -f "$src" "$bak"
-  merged=$(jq -s '
-    .[0] as $cli
-    | (.[1].mcpServers // {}) as $desktop
-    | $cli * { mcpServers: (
-        ($cli.mcpServers // {}) + (
-          $desktop | with_entries(
-            select((.value.type // "stdio") == "stdio")
-            | select((.value.command // null) != null)
-          )
-        )
-      ) }
-  ' "$src" "$dst" 2>/dev/null) || merged=""
-  if [[ -n "$merged" ]] && echo "$merged" | jq empty 2>/dev/null; then
-    tmp=$(mktemp "${src}.XXXXXX")
-    echo "$merged" > "$tmp"
-    mv "$tmp" "$src"
-    echo "[claude-desktop sync] reverse-merged orphans → ~/.claude.json (backup: $bak):" >&2
-    while IFS= read -r k; do echo "  + $k" >&2; done <<< "$orphans"
-  else
-    echo "[claude-desktop sync] reverse-merge produced invalid JSON; skipped" >&2
-  fi
-fi
-
-new_content=$(jq -s '
-  .[0].mcpServers as $cli_mcps |
-  .[1] as $desktop |
-  ( ($cli_mcps // {}) | with_entries(
-      select(
-        (.value.type // "stdio") != "http"
-        and (.value.type // "stdio") != "sse"
-        and (.value.url // null) == null
-      )
-      | .value |= (del(.type) | del(.url))
-    )
-  ) as $stdio_only |
-  ($desktop // {}) | .mcpServers = $stdio_only
-' "$src" "$dst" 2>/dev/null) || exit 0
-
-[[ -z "$new_content" ]] && exit 0
-
-old_norm=$(jq -S '.' "$dst" 2>/dev/null || echo '{}')
-new_norm=$(echo "$new_content" | jq -S '.')
-
-if [[ "$old_norm" == "$new_norm" ]]; then
-  exit 0
-fi
-
-# Show what's changing — useful when this fires from the timer
-diff_summary=$(diff <(echo "$old_norm" | jq -r '.mcpServers // {} | keys[]' 2>/dev/null | sort) \
-                    <(echo "$new_norm" | jq -r '.mcpServers // {} | keys[]' 2>/dev/null | sort) \
-                | grep -E '^[<>]' || true)
-
-# Atomic write: temp file then rename. Avoids a half-written file if Desktop
-# is reading at the same instant (it never is in practice — only reads on boot).
-tmp=$(mktemp "${dst}.XXXXXX")
-echo "$new_content" > "$tmp"
-mv "$tmp" "$dst"
-
-echo "[claude-desktop sync] mcpServers updated:" >&2
-[[ -n "$diff_summary" ]] && echo "$diff_summary" >&2
-
-# Best-effort desktop notification — non-blocking, ignored if notify-send absent
-if command -v notify-send >/dev/null 2>&1; then
-  notify-send -u low \
-    "Claude Desktop MCPs synced" \
-    "Restart Claude Desktop to load the new MCPs." 2>/dev/null || true
-fi
-
-exit 0