@quantiya/codevibe 2.0.16 → 2.0.17

package/bin/codevibe

@@ -149,85 +149,271 @@ show_version() {
 
 # ─── Update ──────────────────────────────────────────────────────────
 #
-# NOTE: Claude Code's plugin lifecycle has known bugs as of Claude Code 2.1.x:
-#   1. `claude plugin update` lies — reports "already at latest version" based on
-#      the installed plugin's own package.json, never consults the marketplace
-#      manifest for the authoritative latest version.
-#   2. `claude plugin install` doesn't refetch — if a cache directory for the
-#      plugin exists, it reuses it silently instead of downloading the version
-#      pinned in the marketplace manifest.
-#   3. `claude plugin uninstall` doesn't delete the cached plugin directory —
-#      only removes the installed_plugins.json entry, leaving stale code on disk
-#      for the next install to silently reuse.
-#
-# This function works around all three by detecting when the installed version
-# on disk doesn't match the version the marketplace says it should be, then
-# manually clearing all stale cache paths before reinstalling and verifying.
-#
-# If Anthropic fixes these bugs, the cache-nuking path is a no-op (the version
-# comparison will always match) and the code stays correct.
+# Claude's supported JSON CLI is the authority for registration state. Never
+# infer it from Claude's private JSON files or mutate Claude-owned cache paths.
+# A mismatched registration is removed through the CLI and reinstalled from the
+# exact marketplace pin, then its on-disk package identity is verified.
+
+# CodeVibe 2.x is private dogfood on this machine until GA. Keep the npm and
+# Claude marketplace channels paired; the GA cutover changes this marketplace
+# to codevibe-marketplace when @quantiya/codevibe moves from @next to @latest.
+CLAUDE_MARKETPLACE="codevibe-next"
+
+_read_next_meta_version() {
+  local raw
+  raw=$(npm view @quantiya/codevibe@next version 2>/dev/null) || return 1
+  node -e '
+    const value = process.argv[1];
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value)) process.exit(1);
+    process.stdout.write(value);
+  ' "$raw"
+}
+
+_resolve_installed_meta_launcher() {
+  local expected_version="$1"
+  local global_root
+  global_root=$(npm root -g 2>/dev/null) || return 1
+  node -e '
+    const fs = require("fs");
+    const path = require("path");
+    try {
+      const packageDir = path.join(process.argv[1], "@quantiya", "codevibe");
+      const packagePath = path.join(packageDir, "package.json");
+      const pkg = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+      if (pkg.name !== "@quantiya/codevibe" || pkg.version !== process.argv[2]) {
+        throw new Error("package identity mismatch");
+      }
+      if (pkg.bin?.codevibe !== "./bin/codevibe") throw new Error("launcher declaration mismatch");
+      const realPackageDir = fs.realpathSync(packageDir);
+      const launcher = fs.realpathSync(path.resolve(packageDir, pkg.bin.codevibe));
+      if (!launcher.startsWith(`${realPackageDir}${path.sep}`)) throw new Error("launcher escaped package");
+      if (!fs.statSync(launcher).isFile()) throw new Error("launcher is not a file");
+      process.stdout.write(launcher);
+    } catch {
+      process.exit(1);
+    }
+  ' "$global_root" "$expected_version" 2>/dev/null
+}
+
+_read_packaged_claude_version() {
+  node -e '
+    const fs = require("fs");
+    try {
+      const pkg = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+      const value = pkg.dependencies?.["@quantiya/codevibe-claude-plugin"];
+      if (typeof value === "string" && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value)) {
+        process.stdout.write(value);
+        process.exit(0);
+      }
+    } catch {}
+    process.exit(1);
+  ' "$PACKAGE_DIR/package.json" 2>/dev/null
+}
+
+_capture_claude_marketplaces() {
+  local raw
+  if ! raw=$(claude plugin marketplace list --json 2>/dev/null); then
+    return 1
+  fi
+  node -e '
+    const path = require("path");
+    try {
+      const rows = JSON.parse(process.argv[1]);
+      if (!Array.isArray(rows)) throw new Error("not an array");
+      const seen = new Set();
+      for (const row of rows) {
+        if (!row || typeof row !== "object" || Array.isArray(row)) throw new Error("invalid row");
+        if (typeof row.name !== "string" || !row.name) throw new Error("invalid name");
+        if (seen.has(row.name)) throw new Error("duplicate marketplace");
+        seen.add(row.name);
+        if (typeof row.installLocation !== "string" || !path.isAbsolute(row.installLocation)) {
+          throw new Error("invalid install location");
+        }
+      }
+      process.stdout.write(JSON.stringify(rows));
+    } catch {
+      process.exit(1);
+    }
+  ' "$raw"
+}
+
+_read_marketplace_root() {
+  local marketplace="$1"
+  local marketplaces="$2"
+  node -e '
+    const rows = JSON.parse(process.argv[1]);
+    const matches = rows.filter((row) => row.name === process.argv[2]);
+    if (matches.length !== 1) process.exit(1);
+    process.stdout.write(matches[0].installLocation);
+  ' "$marketplaces" "$marketplace" 2>/dev/null
+}
 
 _read_marketplace_version() {
-  # Read the pinned source.version for codevibe-claude from the marketplace manifest.
-  # Echoes the version string, or empty on failure.
-  local manifest="$HOME/.claude/plugins/marketplaces/codevibe-marketplace/.claude-plugin/marketplace.json"
-  [ -f "$manifest" ] || return 0
-  node -p "
+  local marketplace="$1"
+  local marketplaces="$2"
+  local root manifest
+  root=$(_read_marketplace_root "$marketplace" "$marketplaces") || return 1
+  manifest="$root/.claude-plugin/marketplace.json"
+  [ -f "$manifest" ] || return 1
+  node -e '
+    const fs = require("fs");
     try {
-      const m = require('$manifest');
-      const p = (m.plugins || []).find(x => x.name === 'codevibe-claude');
-      (p && p.source && p.source.version) || '';
-    } catch (e) { '' }
-  " 2>/dev/null
+      const manifest = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+      if (!Array.isArray(manifest.plugins)) throw new Error("missing plugins");
+      const matches = manifest.plugins.filter((item) => item?.name === "codevibe-claude");
+      if (matches.length !== 1) throw new Error("ambiguous plugin");
+      const plugin = matches[0];
+      const value = plugin?.source?.version;
+      if (typeof value !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value)) {
+        throw new Error("invalid version");
+      }
+      process.stdout.write(value);
+    } catch {
+      process.exit(1);
+    }
+  ' "$manifest" 2>/dev/null
 }
 
-_read_installed_version() {
-  # Read the installed version of codevibe-claude from installed_plugins.json.
-  # Echoes the version string, or empty if not installed.
-  local db="$HOME/.claude/plugins/installed_plugins.json"
-  [ -f "$db" ] || return 0
-  node -p "
+_capture_claude_plugins() {
+  local raw
+  if ! raw=$(claude plugin list --json 2>/dev/null); then
+    return 1
+  fi
+  node -e '
+    const path = require("path");
     try {
-      const ip = require('$db');
-      const e = (ip.plugins || {})['codevibe-claude@codevibe-marketplace'];
-      (e && e[0] && e[0].version) || '';
-    } catch (e) { '' }
-  " 2>/dev/null
+      const rows = JSON.parse(process.argv[1]);
+      if (!Array.isArray(rows)) throw new Error("not an array");
+      const selected = [];
+      const seen = new Set();
+      const supported = new Set([
+        "codevibe-claude@codevibe-next",
+        "codevibe-claude@codevibe-marketplace",
+      ]);
+      for (const row of rows) {
+        if (!row || typeof row !== "object" || Array.isArray(row)) throw new Error("invalid row");
+        if (typeof row.id !== "string" || !row.id) throw new Error("invalid id");
+        if (!row.id.startsWith("codevibe-claude@")) continue;
+        if (!supported.has(row.id)) throw new Error("unsupported CodeVibe registration");
+        if (seen.has(row.id)) throw new Error("duplicate registration");
+        seen.add(row.id);
+        if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(row.version)) throw new Error("invalid version");
+        if (!new Set(["user", "project", "local"]).has(row.scope)) throw new Error("invalid scope");
+        if (typeof row.enabled !== "boolean") throw new Error("invalid enabled state");
+        if (typeof row.installPath !== "string" || !path.isAbsolute(row.installPath)) throw new Error("invalid install path");
+        selected.push(row);
+      }
+      process.stdout.write(JSON.stringify(selected));
+    } catch {
+      process.exit(1);
+    }
+  ' "$raw"
 }
 
-_nuke_claude_plugin_cache() {
-  # Remove every path Claude Code's plugin loader might read stale code from.
-  rm -rf "$HOME/.claude/plugins/cache/codevibe-marketplace/codevibe-claude"
-  rm -rf "$HOME/.claude/plugins/npm-cache/node_modules/@quantiya/codevibe-claude-plugin"
-  rm -rf "$HOME/.claude/plugins/npm-cache/node_modules/codevibe-claude-plugin"
-  rm -f  "$HOME/.claude/plugins/npm-cache/package-lock.json"
+_verify_only_preview_registration() {
+  local plugins="$1"
+  node -e '
+    const rows = JSON.parse(process.argv[1]);
+    if (rows.length !== 1 || rows[0].id !== "codevibe-claude@codevibe-next") process.exit(1);
+  ' "$plugins" 2>/dev/null
+}
+
+_read_claude_plugin_state() {
+  local marketplace="$1"
+  local plugins="$2"
+  node -e '
+    const rows = JSON.parse(process.argv[1]);
+    const row = rows.find((item) => item.id === `codevibe-claude@${process.argv[2]}`);
+    if (!row) process.exit(3);
+    process.stdout.write(JSON.stringify(row));
+  ' "$plugins" "$marketplace" 2>/dev/null
+}
+
+_claude_plugin_state_field() {
+  local state="$1"
+  local field="$2"
+  node -e '
+    const row = JSON.parse(process.argv[1]);
+    const value = row[process.argv[2]];
+    if (!["string", "boolean"].includes(typeof value)) process.exit(1);
+    process.stdout.write(String(value));
+  ' "$state" "$field" 2>/dev/null
+}
+
+_verify_claude_plugin_files() {
+  local state="$1"
+  local expected_version="$2"
+  node -e '
+    const fs = require("fs");
+    const path = require("path");
+    try {
+      const row = JSON.parse(process.argv[1]);
+      const expected = process.argv[2];
+      if (row.version !== expected || row.enabled !== true || row.scope !== "user") throw new Error("state mismatch");
+      const installPath = fs.realpathSync(row.installPath);
+      const packagePath = path.join(installPath, "package.json");
+      const pkg = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+      if (pkg.name !== "@quantiya/codevibe-claude-plugin" || pkg.version !== expected) throw new Error("package mismatch");
+    } catch {
+      process.exit(1);
+    }
+  ' "$state" "$expected_version" 2>/dev/null
 }
 
 do_update() {
-  echo ""
-  echo -e "${BOLD}${PURPLE}CodeVibe Update${NC}"
-  echo ""
+  local update_phase="${CODEVIBE_UPDATE_AFTER_META:-meta}"
+  unset CODEVIBE_UPDATE_AFTER_META
+  case "$update_phase" in
+    meta|plugins) ;;
+    *)
+      echo "Invalid internal CodeVibe update phase." >&2
+      return 1
+      ;;
+  esac
 
-  # Show current meta-package version
-  if [ -f "$PACKAGE_DIR/package.json" ]; then
-    CUR_VER=$(node -p "require('$PACKAGE_DIR/package.json').version" 2>/dev/null || echo "?")
-    echo -e "  ${DIM}Current meta-package: $CUR_VER${NC}"
-  fi
-  echo ""
+  if [ "$update_phase" = "meta" ]; then
+    echo ""
+    echo -e "${BOLD}${PURPLE}CodeVibe Update${NC}"
+    echo ""
 
-  # ─── Step 1: Update the global meta-package on the CodeVibe 2.x channel ───
-  echo -e "${PURPLE}▸${NC} Updating @quantiya/codevibe..."
-  # Capture output so we can check npm's exit status directly instead of the
-  # pipe's (tail's exit status would mask npm failures without `set -o pipefail`).
-  local npm_output
-  if ! npm_output=$(npm install -g --force @quantiya/codevibe@next 2>&1); then
-    echo "$npm_output" | tail -10
+    if [ -f "$PACKAGE_DIR/package.json" ]; then
+      CUR_VER=$(node -p "require('$PACKAGE_DIR/package.json').version" 2>/dev/null || echo "?")
+      echo -e "  ${DIM}Current meta-package: $CUR_VER${NC}"
+    fi
     echo ""
-    echo -e "${YELLOW}!${NC} Meta-package update failed. Check the output above, fix the issue, and retry 'codevibe update'."
-    return 1
   fi
-  echo "$npm_output" | tail -3
-  echo -e "${GREEN}✓${NC} Meta-package updated"
+
+  if [ "$update_phase" = "meta" ]; then
+    # ─── Step 1: Update the global meta-package on the CodeVibe 2.x channel ─
+    echo -e "${PURPLE}▸${NC} Updating @quantiya/codevibe..."
+    local desired_meta_version
+    local installed_launcher
+    if ! desired_meta_version=$(_read_next_meta_version); then
+      echo ""
+      echo -e "${YELLOW}!${NC} Could not resolve the exact @quantiya/codevibe@next version. No package was changed."
+      return 1
+    fi
+    local npm_output
+    if ! npm_output=$(npm install -g --force @quantiya/codevibe@next 2>&1); then
+      echo "$npm_output" | tail -10
+      echo ""
+      echo -e "${YELLOW}!${NC} Meta-package update failed. Check the output above, fix the issue, and retry 'codevibe update'."
+      return 1
+    fi
+    echo "$npm_output" | tail -3
+    echo -e "${GREEN}✓${NC} Meta-package updated"
+
+    if ! installed_launcher=$(_resolve_installed_meta_launcher "$desired_meta_version"); then
+      echo ""
+      echo -e "${YELLOW}!${NC} The installed CodeVibe package does not match @next ${desired_meta_version}; plugin state was not changed."
+      return 1
+    fi
+
+    # The current process still holds old functions. Re-exec the verified
+    # launcher inside npm's actual global package before any plugin mutation.
+    export CODEVIBE_UPDATE_AFTER_META=plugins
+    exec "$installed_launcher" update
+  fi
 
   # ─── Step 2: Update the Claude Code plugin ─────────────────────────────────
   if ! command -v claude >/dev/null 2>&1; then
@@ -246,37 +432,94 @@ do_update() {
   echo ""
   echo -e "${PURPLE}▸${NC} Updating Claude Code plugin..."
 
-  # Refresh the marketplace manifest so we see the latest pinned version.
-  # Errors here are non-fatal at this step — the previously-cached manifest may
-  # still be usable — but the EXPECTED_VERSION read below is the real gate.
-  if claude plugin marketplace update codevibe-marketplace; then
-    echo -e "${GREEN}✓${NC} Marketplace refreshed"
-  else
-    echo -e "${YELLOW}!${NC} Marketplace refresh failed (falling back to cached manifest)"
-  fi
-
+  local DESIRED_VERSION
   local EXPECTED_VERSION
+  local MARKETPLACES
+  local PLUGINS
+  local PREVIEW_STATE=""
+  local CONFLICT_STATE=""
+  local PREVIEW_PRESENT=false
+  local CONFLICT_PRESENT=false
   local INSTALLED_VERSION
-  EXPECTED_VERSION=$(_read_marketplace_version)
-  INSTALLED_VERSION=$(_read_installed_version)
+  local INSTALLED_ENABLED
+  local INSTALLED_SCOPE
+  local CONFLICT_SCOPE
+  local REGISTRATION_CHANGED=false
 
-  # EXPECTED_VERSION is required — without it we have no ground truth to verify
-  # against, so the whole cache-bug workaround is blind. Fail loudly rather than
-  # claim success we can't prove.
-  if [ -z "$EXPECTED_VERSION" ]; then
+  DESIRED_VERSION=$(_read_packaged_claude_version)
+  if [ -z "$DESIRED_VERSION" ]; then
     echo ""
-    echo -e "${YELLOW}!${NC} Could not read expected version from marketplace manifest."
-    echo -e "  ${DIM}Expected at: \$HOME/.claude/plugins/marketplaces/codevibe-marketplace/.claude-plugin/marketplace.json${NC}"
-    echo -e "  ${DIM}This usually means the marketplace refresh failed or the manifest schema has drifted.${NC}"
-    echo -e "  ${DIM}Try: claude plugin marketplace update codevibe-marketplace${NC}"
+    echo -e "${YELLOW}!${NC} Could not read the exact Claude plugin version required by this CodeVibe package."
     return 1
   fi
 
-  echo -e "  ${DIM}installed: ${INSTALLED_VERSION:-<none>}   marketplace: ${EXPECTED_VERSION}${NC}"
+  # The 2.x package is distributed on @next and must use the matching private
+  # marketplace. Do not fall back to the public 1.x marketplace on this host.
+  if ! claude plugin marketplace update "$CLAUDE_MARKETPLACE" >/dev/null 2>&1; then
+    echo ""
+    echo -e "${YELLOW}!${NC} Could not refresh marketplace ${CLAUDE_MARKETPLACE}. No registration was changed."
+    return 1
+  fi
+  if ! MARKETPLACES=$(_capture_claude_marketplaces); then
+    echo ""
+    echo -e "${YELLOW}!${NC} Claude marketplace state is invalid or unavailable. No registration was changed."
+    return 1
+  fi
+  EXPECTED_VERSION=$(_read_marketplace_version "$CLAUDE_MARKETPLACE" "$MARKETPLACES") || EXPECTED_VERSION=""
+  if [ "$EXPECTED_VERSION" != "$DESIRED_VERSION" ]; then
+    echo ""
+    echo -e "${YELLOW}!${NC} Marketplace ${CLAUDE_MARKETPLACE} does not pin the required Claude plugin."
+    echo -e "  ${DIM}Required: ${DESIRED_VERSION:-<none>}   observed: ${EXPECTED_VERSION:-<none>}. No registration was changed.${NC}"
+    return 1
+  fi
+  if ! PLUGINS=$(_capture_claude_plugins); then
+    echo ""
+    echo -e "${YELLOW}!${NC} Claude plugin state is invalid or unavailable. No registration was changed."
+    return 1
+  fi
+  if PREVIEW_STATE=$(_read_claude_plugin_state "$CLAUDE_MARKETPLACE" "$PLUGINS"); then
+    PREVIEW_PRESENT=true
+    INSTALLED_VERSION=$(_claude_plugin_state_field "$PREVIEW_STATE" version) || return 1
+    INSTALLED_ENABLED=$(_claude_plugin_state_field "$PREVIEW_STATE" enabled) || return 1
+    INSTALLED_SCOPE=$(_claude_plugin_state_field "$PREVIEW_STATE" scope) || return 1
+    if [ "$INSTALLED_SCOPE" != "user" ]; then
+      echo ""
+      echo -e "${YELLOW}!${NC} Claude preview registration has unsupported scope: ${INSTALLED_SCOPE}. No registration was changed."
+      return 1
+    fi
+  else
+    [ "$?" -eq 3 ] || return 1
+    INSTALLED_VERSION=""
+    INSTALLED_ENABLED=false
+    INSTALLED_SCOPE=user
+  fi
+  echo -e "  ${DIM}channel: ${CLAUDE_MARKETPLACE}   installed: ${INSTALLED_VERSION:-<none>}   required: ${EXPECTED_VERSION}${NC}"
+
+  # This is the only 2.x dogfood machine. Remove its public 1.x registration so
+  # Claude resume cannot start competing daemons from both plugin generations.
+  if CONFLICT_STATE=$(_read_claude_plugin_state "codevibe-marketplace" "$PLUGINS"); then
+    CONFLICT_PRESENT=true
+    CONFLICT_SCOPE=$(_claude_plugin_state_field "$CONFLICT_STATE" scope) || return 1
+    if [ "$CONFLICT_SCOPE" != "user" ]; then
+      echo ""
+      echo -e "${YELLOW}!${NC} Conflicting Claude registration has unsupported scope: ${CONFLICT_SCOPE}. No registration was changed."
+      return 1
+    fi
+  else
+    [ "$?" -eq 3 ] || return 1
+  fi
+  if [ "$CONFLICT_PRESENT" = "true" ]; then
+    if ! claude plugin uninstall -s "$CONFLICT_SCOPE" -y "codevibe-claude@codevibe-marketplace" >/dev/null 2>&1; then
+      echo ""
+      echo -e "${YELLOW}!${NC} Could not remove conflicting Claude plugin registration: codevibe-claude@codevibe-marketplace"
+      return 1
+    fi
+    REGISTRATION_CHANGED=true
+  fi
 
   # ─── Step 3: Decide if we need to force a cache-clearing reinstall ─────────
   local NEEDS_REINSTALL=false
-  if [ -z "$INSTALLED_VERSION" ] || [ "$INSTALLED_VERSION" != "$EXPECTED_VERSION" ]; then
+  if [ "$PREVIEW_PRESENT" != "true" ] || [ "$INSTALLED_VERSION" != "$EXPECTED_VERSION" ]; then
     NEEDS_REINSTALL=true
     if [ -n "$INSTALLED_VERSION" ]; then
       echo -e "${YELLOW}!${NC} Cache is stale (${INSTALLED_VERSION} on disk, ${EXPECTED_VERSION} in marketplace)."
@@ -285,12 +528,14 @@ do_update() {
   fi
 
   if [ "$NEEDS_REINSTALL" = "true" ]; then
-    # Must uninstall + nuke cache BEFORE install. `claude plugin install` will
-    # silently reuse an existing cache dir even if the marketplace version changed.
-    claude plugin uninstall codevibe-claude@codevibe-marketplace >/dev/null 2>&1 || true
-    _nuke_claude_plugin_cache
+    if [ "$PREVIEW_PRESENT" = "true" ] \
+        && ! claude plugin uninstall -s "$INSTALLED_SCOPE" -y "codevibe-claude@$CLAUDE_MARKETPLACE" >/dev/null 2>&1; then
+      echo ""
+      echo -e "${YELLOW}!${NC} Could not remove stale Claude plugin registration: codevibe-claude@$CLAUDE_MARKETPLACE"
+      return 1
+    fi
 
-    if claude plugin install codevibe-claude@codevibe-marketplace; then
+    if claude plugin install -s user -y "codevibe-claude@$CLAUDE_MARKETPLACE"; then
       echo -e "${GREEN}✓${NC} Claude plugin reinstalled"
     else
       echo ""
@@ -298,25 +543,70 @@ do_update() {
       return 1
     fi
   else
-    # Version already matches. Still call install to make sure installed_plugins.json
-    # is in sync, but treat any error as non-fatal since we're not actually changing state.
-    claude plugin install codevibe-claude@codevibe-marketplace >/dev/null 2>&1 || true
+    # Version already matches. Re-enable the selected registration without
+    # asking Claude Code to reinstall or recache it.
+    if [ "$INSTALLED_ENABLED" != "true" ] \
+        && ! claude plugin enable -s "$INSTALLED_SCOPE" "codevibe-claude@$CLAUDE_MARKETPLACE" >/dev/null 2>&1; then
+      echo ""
+      echo -e "${YELLOW}!${NC} Could not enable Claude plugin registration: codevibe-claude@$CLAUDE_MARKETPLACE"
+      return 1
+    fi
     echo -e "${GREEN}✓${NC} Claude plugin already at ${INSTALLED_VERSION}"
   fi
 
   # ─── Step 4: Verify the installed version is now what we expected ──────────
   # EXPECTED_VERSION is guaranteed non-empty here (we bailed earlier otherwise),
   # so the verification is unconditional.
-  INSTALLED_VERSION=$(_read_installed_version)
-  if [ "$INSTALLED_VERSION" != "$EXPECTED_VERSION" ]; then
+  if ! PLUGINS=$(_capture_claude_plugins); then
+    echo ""
+    echo -e "${YELLOW}!${NC} Claude plugin state could not be verified after the update."
+    return 1
+  fi
+  if ! PREVIEW_STATE=$(_read_claude_plugin_state "$CLAUDE_MARKETPLACE" "$PLUGINS"); then
+    echo ""
+    echo -e "${YELLOW}!${NC} Claude preview registration is missing after the update."
+    return 1
+  fi
+  INSTALLED_VERSION=$(_claude_plugin_state_field "$PREVIEW_STATE" version) || return 1
+  INSTALLED_ENABLED=$(_claude_plugin_state_field "$PREVIEW_STATE" enabled) || return 1
+  INSTALLED_SCOPE=$(_claude_plugin_state_field "$PREVIEW_STATE" scope) || return 1
+  if [ "$INSTALLED_VERSION" != "$EXPECTED_VERSION" ] || [ "$INSTALLED_SCOPE" != "user" ]; then
     echo ""
     echo -e "${YELLOW}!${NC} WARNING: Installed version (${INSTALLED_VERSION:-<none>}) still doesn't match expected (${EXPECTED_VERSION})."
-    echo -e "  ${DIM}Try: rm -rf ~/.claude/plugins/cache/codevibe-marketplace/codevibe-claude && codevibe update${NC}"
+    echo -e "  ${DIM}Try: codevibe update again after checking the ${CLAUDE_MARKETPLACE} manifest.${NC}"
+    return 1
+  fi
+  if [ "$INSTALLED_ENABLED" != "true" ]; then
+    echo ""
+    echo -e "${YELLOW}!${NC} Claude plugin registration is installed but disabled: codevibe-claude@$CLAUDE_MARKETPLACE"
+    return 1
+  fi
+  local conflict_check_rc
+  _read_claude_plugin_state "codevibe-marketplace" "$PLUGINS" >/dev/null 2>&1
+  conflict_check_rc=$?
+  if [ "$conflict_check_rc" -eq 0 ]; then
+    echo ""
+    echo -e "${YELLOW}!${NC} Conflicting Claude plugin registration still exists: codevibe-claude@codevibe-marketplace"
+    return 1
+  fi
+  if [ "$conflict_check_rc" -ne 3 ]; then
+    echo ""
+    echo -e "${YELLOW}!${NC} Claude plugin state became ambiguous after the update."
+    return 1
+  fi
+  if ! _verify_only_preview_registration "$PLUGINS"; then
+    echo ""
+    echo -e "${YELLOW}!${NC} Claude plugin state contains an unexpected CodeVibe registration."
+    return 1
+  fi
+  if ! _verify_claude_plugin_files "$PREVIEW_STATE" "$EXPECTED_VERSION"; then
+    echo ""
+    echo -e "${YELLOW}!${NC} Claude plugin files do not match the required package identity."
     return 1
   fi
 
   # ─── Step 5: Tell the user about running sessions ──────────────────────────
-  if [ "$NEEDS_REINSTALL" = "true" ]; then
+  if [ "$NEEDS_REINSTALL" = "true" ] || [ "$REGISTRATION_CHANGED" = "true" ]; then
     echo ""
     echo -e "${YELLOW}!${NC} Running Claude Code sessions still have the OLD plugin server in memory."
     echo -e "  ${DIM}Exit and restart any active session to pick up the new plugin.${NC}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe",
-  "version": "2.0.16",
+  "version": "2.0.17",
   "description": "Companion and orchestration for Claude Code, OpenAI Codex CLI, and Antigravity, with secure mobile control.",
   "bin": {
     "codevibe": "./bin/codevibe"