diff --git a/app/components/ClaimPackageModal.vue b/app/components/ClaimPackageModal.vue
new file mode 100644
index 0000000000..30ac41de5b
--- /dev/null
+++ b/app/components/ClaimPackageModal.vue
@@ -0,0 +1,424 @@
+<script setup lang="ts">
+import type { CheckNameResult } from '~/utils/package-name'
+import { checkPackageName } from '~/utils/package-name'
+
+const props = defineProps<{
+  packageName: string
+}>()
+
+const open = defineModel<boolean>('open', { default: false })
+
+const {
+  isConnected,
+  state,
+  npmUser,
+  addOperation,
+  approveOperation,
+  executeOperations,
+  refreshState,
+} = useConnector()
+
+// Fetch name availability when modal opens
+const checkResult = ref<CheckNameResult | null>(null)
+
+const isChecking = ref(false)
+const isPublishing = ref(false)
+const publishError = ref<string | null>(null)
+const publishSuccess = ref(false)
+
+async function checkAvailability() {
+  isChecking.value = true
+  publishError.value = null
+  try {
+    checkResult.value = await checkPackageName(props.packageName)
+  } catch (err) {
+    publishError.value = err instanceof Error ? err.message : 'Failed to check name availability'
+  } finally {
+    isChecking.value = false
+  }
+}
+
+async function handleClaim() {
+  if (!checkResult.value?.available || !isConnected.value) return
+
+  isPublishing.value = true
+  publishError.value = null
+
+  try {
+    // Add the operation
+    const operation = await addOperation({
+      type: 'package:init',
+      params: { name: props.packageName, ...(npmUser.value && { author: npmUser.value }) },
+      description: `Initialize package ${props.packageName}`,
+      command: `npm publish (${props.packageName}@0.0.0)`,
+    })
+
+    if (!operation) {
+      throw new Error('Failed to create operation')
+    }
+
+    // Auto-approve and execute
+    await approveOperation(operation.id)
+    const result = await executeOperations()
+
+    // Refresh state and check if operation completed successfully
+    await refreshState()
+
+    // Find the operation and check its status
+    const completedOp = state.value.operations.find(op => op.id === operation.id)
+    if (completedOp?.status === 'completed') {
+      publishSuccess.value = true
+    } else if (completedOp?.status === 'failed') {
+      if (completedOp.result?.requiresOtp) {
+        // OTP is needed - open connector panel to handle it
+        open.value = false
+        connectorModalOpen.value = true
+      } else {
+        publishError.value = completedOp.result?.stderr || 'Failed to publish package'
+      }
+    } else {
+      // Still pending/approved/running - open connector panel to show progress
+      open.value = false
+      connectorModalOpen.value = true
+    }
+  } catch (err) {
+    publishError.value = err instanceof Error ? err.message : 'Failed to claim package'
+  } finally {
+    isPublishing.value = false
+  }
+}
+
+// Check availability when modal opens
+watch(open, isOpen => {
+  if (isOpen) {
+    checkResult.value = null
+    publishError.value = null
+    publishSuccess.value = false
+    checkAvailability()
+  }
+})
+
+// Computed for similar packages with warnings
+const hasDangerousSimilarPackages = computed(() => {
+  if (!checkResult.value?.similarPackages) return false
+  return checkResult.value.similarPackages.some(
+    pkg => pkg.similarity === 'exact-match' || pkg.similarity === 'very-similar',
+  )
+})
+
+const isScoped = computed(() => props.packageName.startsWith('@'))
+
+// Preview of the package.json that will be published
+const previewPackageJson = computed(() => {
+  const access = isScoped.value ? 'public' : undefined
+  return {
+    name: props.packageName,
+    version: '0.0.0',
+    description: `Placeholder for ${props.packageName}`,
+    main: 'index.js',
+    scripts: {},
+    keywords: [],
+    author: npmUser.value ? `${npmUser.value} (https://www.npmjs.com/~${npmUser.value})` : '',
+    license: 'UNLICENSED',
+    private: false,
+    ...(access && { publishConfig: { access } }),
+  }
+})
+
+const connectorModalOpen = ref(false)
+</script>
+
+<template>
+  <Teleport to="body">
+    <Transition
+      enter-active-class="transition-opacity duration-200"
+      leave-active-class="transition-opacity duration-200"
+      enter-from-class="opacity-0"
+      leave-to-class="opacity-0"
+    >
+      <div v-if="open" class="fixed inset-0 z-50 flex items-center justify-center p-4">
+        <!-- Backdrop -->
+        <button
+          type="button"
+          class="absolute inset-0 bg-black/60 cursor-default"
+          aria-label="Close modal"
+          @click="open = false"
+        />
+
+        <!-- Modal -->
+        <div
+          class="relative w-full max-w-lg bg-bg border border-border rounded-lg shadow-xl max-h-[90vh] overflow-y-auto overscroll-contain"
+          role="dialog"
+          aria-modal="true"
+          aria-labelledby="claim-modal-title"
+        >
+          <div class="p-6">
+            <div class="flex items-center justify-between mb-6">
+              <h2 id="claim-modal-title" class="font-mono text-lg font-medium">
+                Claim Package Name
+              </h2>
+              <button
+                type="button"
+                class="text-fg-subtle hover:text-fg transition-colors duration-200 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50 rounded"
+                aria-label="Close"
+                @click="open = false"
+              >
+                <span class="i-carbon-close block w-5 h-5" aria-hidden="true" />
+              </button>
+            </div>
+
+            <!-- Loading state -->
+            <div v-if="isChecking" class="py-8 text-center">
+              <LoadingSpinner text="Checking availability…" />
+            </div>
+
+            <!-- Success state -->
+            <div v-else-if="publishSuccess" class="space-y-4">
+              <div
+                class="flex items-center gap-3 p-4 bg-green-500/10 border border-green-500/20 rounded-lg"
+              >
+                <span class="i-carbon-checkmark-filled text-green-500 w-6 h-6" aria-hidden="true" />
+                <div>
+                  <p class="font-mono text-sm text-fg">Package claimed!</p>
+                  <p class="text-xs text-fg-muted">
+                    {{ packageName }}@0.0.0 has been published to npm.
+                  </p>
+                </div>
+              </div>
+
+              <p class="text-sm text-fg-muted">
+                You can now publish new versions to this package using
+                <code class="font-mono bg-bg-subtle px-1 rounded">npm publish</code>.
+              </p>
+
+              <div class="flex gap-3">
+                <NuxtLink
+                  :to="`/package/${packageName}`"
+                  class="flex-1 px-4 py-2 font-mono text-sm text-center text-bg bg-fg rounded-md transition-colors duration-200 hover:bg-fg/90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50"
+                  @click="open = false"
+                >
+                  View Package
+                </NuxtLink>
+                <button
+                  type="button"
+                  class="flex-1 px-4 py-2 font-mono text-sm text-fg-muted bg-bg-subtle border border-border rounded-md transition-colors duration-200 hover:text-fg hover:border-border-hover focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50"
+                  @click="open = false"
+                >
+                  Close
+                </button>
+              </div>
+            </div>
+
+            <!-- Check result -->
+            <div v-else-if="checkResult" class="space-y-4">
+              <!-- Package name display -->
+              <div class="p-4 bg-bg-subtle border border-border rounded-lg">
+                <p class="font-mono text-lg text-fg">{{ checkResult.name }}</p>
+              </div>
+
+              <!-- Validation errors -->
+              <div
+                v-if="checkResult.validationErrors?.length"
+                class="p-3 text-sm text-red-400 bg-red-500/10 border border-red-500/20 rounded-md"
+                role="alert"
+              >
+                <p class="font-medium mb-1">Invalid package name:</p>
+                <ul class="list-disc list-inside space-y-1">
+                  <li v-for="err in checkResult.validationErrors" :key="err">{{ err }}</li>
+                </ul>
+              </div>
+
+              <!-- Validation warnings -->
+              <div
+                v-if="checkResult.validationWarnings?.length"
+                class="p-3 text-sm text-yellow-400 bg-yellow-500/10 border border-yellow-500/20 rounded-md"
+                role="alert"
+              >
+                <p class="font-medium mb-1">Warnings:</p>
+                <ul class="list-disc list-inside space-y-1">
+                  <li v-for="warn in checkResult.validationWarnings" :key="warn">{{ warn }}</li>
+                </ul>
+              </div>
+
+              <!-- Availability status -->
+              <div v-if="checkResult.valid">
+                <div
+                  v-if="checkResult.available"
+                  class="flex items-center gap-3 p-4 bg-green-500/10 border border-green-500/20 rounded-lg"
+                >
+                  <span
+                    class="i-carbon-checkmark-filled text-green-500 w-5 h-5"
+                    aria-hidden="true"
+                  />
+                  <p class="font-mono text-sm text-fg">This name is available!</p>
+                </div>
+
+                <div
+                  v-else
+                  class="flex items-center gap-3 p-4 bg-red-500/10 border border-red-500/20 rounded-lg"
+                >
+                  <span class="i-carbon-close-filled text-red-500 w-5 h-5" aria-hidden="true" />
+                  <p class="font-mono text-sm text-fg">This name is already taken.</p>
+                </div>
+              </div>
+
+              <!-- Similar packages warning -->
+              <div v-if="checkResult.similarPackages?.length && checkResult.available">
+                <div
+                  :class="
+                    hasDangerousSimilarPackages
+                      ? 'bg-yellow-500/10 border-yellow-500/20'
+                      : 'bg-bg-subtle border-border'
+                  "
+                  class="p-4 border rounded-lg"
+                >
+                  <p
+                    :class="hasDangerousSimilarPackages ? 'text-yellow-400' : 'text-fg-muted'"
+                    class="text-sm font-medium mb-3"
+                  >
+                    <span v-if="hasDangerousSimilarPackages">
+                      Similar packages exist - npm may reject this name:
+                    </span>
+                    <span v-else> Related packages: </span>
+                  </p>
+                  <ul class="space-y-2">
+                    <li
+                      v-for="pkg in checkResult.similarPackages.slice(0, 5)"
+                      :key="pkg.name"
+                      class="flex items-start gap-2"
+                    >
+                      <span
+                        v-if="pkg.similarity === 'exact-match'"
+                        class="i-carbon-warning-filled text-red-500 w-4 h-4 mt-0.5 shrink-0"
+                        aria-hidden="true"
+                      />
+                      <span
+                        v-else-if="pkg.similarity === 'very-similar'"
+                        class="i-carbon-warning text-yellow-500 w-4 h-4 mt-0.5 shrink-0"
+                        aria-hidden="true"
+                      />
+                      <span v-else class="w-4 h-4 shrink-0" />
+                      <div class="min-w-0">
+                        <NuxtLink
+                          :to="`/package/${pkg.name}`"
+                          class="font-mono text-sm text-fg hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50 rounded"
+                          target="_blank"
+                        >
+                          {{ pkg.name }}
+                        </NuxtLink>
+                        <p v-if="pkg.description" class="text-xs text-fg-subtle truncate">
+                          {{ pkg.description }}
+                        </p>
+                      </div>
+                    </li>
+                  </ul>
+                </div>
+              </div>
+
+              <!-- Error message -->
+              <div
+                v-if="publishError"
+                role="alert"
+                class="p-3 text-sm text-red-400 bg-red-500/10 border border-red-500/20 rounded-md"
+              >
+                {{ publishError }}
+              </div>
+
+              <!-- Actions -->
+              <div v-if="checkResult.available && checkResult.valid" class="space-y-3">
+                <!-- Warning for unscoped packages -->
+                <div
+                  v-if="!isScoped"
+                  class="p-3 text-sm text-yellow-400 bg-yellow-500/10 border border-yellow-500/20 rounded-md"
+                >
+                  <p class="font-medium mb-1">Consider using a scoped package instead</p>
+                  <p class="text-xs text-yellow-400/80">
+                    Unscoped package names are a shared resource. Only claim a name if you intend to
+                    publish and maintain a package. For personal or organizational projects, use a
+                    scoped name like
+                    <code class="font-mono">@{{ npmUser || 'username' }}/{{ packageName }}</code
+                    >.
+                  </p>
+                </div>
+
+                <!-- Not connected warning -->
+                <div v-if="!isConnected" class="space-y-3">
+                  <div
+                    class="p-3 text-sm text-yellow-400 bg-yellow-500/10 border border-yellow-500/20 rounded-md"
+                  >
+                    <p>Connect to the local connector to claim this package name.</p>
+                  </div>
+                  <button
+                    type="button"
+                    class="w-full px-4 py-2 font-mono text-sm text-bg bg-fg rounded-md transition-colors duration-200 hover:bg-fg/90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50"
+                    @click="connectorModalOpen = true"
+                  >
+                    Connect to Connector
+                  </button>
+                </div>
+
+                <!-- Claim button -->
+                <div v-else class="space-y-3">
+                  <p class="text-sm text-fg-muted">
+                    This will publish a minimal placeholder package.
+                  </p>
+
+                  <!-- Expandable package.json preview -->
+                  <details class="border border-border rounded-md overflow-hidden">
+                    <summary
+                      class="px-3 py-2 text-sm text-fg-muted bg-bg-subtle cursor-pointer hover:text-fg transition-colors select-none"
+                    >
+                      Preview package.json
+                    </summary>
+                    <pre class="p-3 text-xs font-mono text-fg-muted bg-[#0d0d0d] overflow-x-auto">{{
+                      JSON.stringify(previewPackageJson, null, 2)
+                    }}</pre>
+                  </details>
+
+                  <button
+                    type="button"
+                    :disabled="isPublishing"
+                    class="w-full px-4 py-2 font-mono text-sm text-bg bg-fg rounded-md transition-colors duration-200 hover:bg-fg/90 disabled:opacity-50 disabled:cursor-not-allowed focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50"
+                    @click="handleClaim"
+                  >
+                    {{ isPublishing ? 'Publishing…' : 'Claim Package Name' }}
+                  </button>
+                </div>
+              </div>
+
+              <!-- Close button for unavailable/invalid -->
+              <button
+                v-if="!checkResult.available || !checkResult.valid"
+                type="button"
+                class="w-full px-4 py-2 font-mono text-sm text-fg-muted bg-bg-subtle border border-border rounded-md transition-colors duration-200 hover:text-fg hover:border-border-hover focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50"
+                @click="open = false"
+              >
+                Close
+              </button>
+            </div>
+
+            <!-- Error state -->
+            <div v-else-if="publishError" class="space-y-4">
+              <div
+                role="alert"
+                class="p-3 text-sm text-red-400 bg-red-500/10 border border-red-500/20 rounded-md"
+              >
+                {{ publishError }}
+              </div>
+              <button
+                type="button"
+                class="w-full px-4 py-2 font-mono text-sm text-fg-muted bg-bg-subtle border border-border rounded-md transition-colors duration-200 hover:text-fg hover:border-border-hover focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50"
+                @click="checkAvailability"
+              >
+                Retry
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </Transition>
+  </Teleport>
+
+  <!-- Connector modal -->
+  <ConnectorModal v-model:open="connectorModalOpen" />
+</template>
diff --git a/app/pages/search.vue b/app/pages/search.vue
index 56781f8428..63ab145234 100644
--- a/app/pages/search.vue
+++ b/app/pages/search.vue
@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { formatNumber } from '#imports'
 import { debounce } from 'perfect-debounce'
+import { isValidNewPackageName, checkPackageExists } from '~/utils/package-name'
 
 const route = useRoute()
 const router = useRouter()
@@ -153,6 +154,107 @@ watch(query, () => {
   hasInteracted.value = true
 })
 
+// Check if current query could be a valid package name
+const isValidPackageName = computed(() => isValidNewPackageName(query.value.trim()))
+
+// Check if package name is available (doesn't exist on npm)
+const packageAvailability = ref<{ name: string; available: boolean } | null>(null)
+
+// Debounced check for package availability
+const checkAvailability = debounce(async (name: string) => {
+  if (!isValidNewPackageName(name)) {
+    packageAvailability.value = null
+    return
+  }
+
+  try {
+    const exists = await checkPackageExists(name)
+    // Only update if this is still the current query
+    if (name === query.value.trim()) {
+      packageAvailability.value = { name, available: !exists }
+    }
+  } catch {
+    packageAvailability.value = null
+  }
+}, 300)
+
+// Trigger availability check when query changes
+watch(
+  query,
+  q => {
+    const trimmed = q.trim()
+    if (isValidNewPackageName(trimmed)) {
+      checkAvailability(trimmed)
+    } else {
+      packageAvailability.value = null
+    }
+  },
+  { immediate: true },
+)
+
+// Get connector state
+const { isConnected, npmUser, listOrgUsers } = useConnector()
+
+// Check if this is a scoped package and extract scope
+const packageScope = computed(() => {
+  const q = query.value.trim()
+  if (!q.startsWith('@')) return null
+  const match = q.match(/^@([^/]+)\//)
+  return match ? match[1] : null
+})
+
+// Track org membership for scoped packages
+const orgMembership = ref<Record<string, boolean>>({})
+
+// Check org membership when scope changes
+watch(
+  [packageScope, isConnected, npmUser],
+  async ([scope, connected, user]) => {
+    if (!scope || !connected || !user) return
+    // Skip if already checked
+    if (scope in orgMembership.value) return
+
+    try {
+      const users = await listOrgUsers(scope)
+      // Check if current user is in the org's user list
+      if (users && user in users) {
+        orgMembership.value[scope] = true
+      } else {
+        orgMembership.value[scope] = false
+      }
+    } catch {
+      orgMembership.value[scope] = false
+    }
+  },
+  { immediate: true },
+)
+
+// Check if user can publish to scope (either their username or an org they're a member of)
+const canPublishToScope = computed(() => {
+  const scope = packageScope.value
+  if (!scope) return true // Unscoped package
+  if (!npmUser.value) return false
+  // Can publish if scope matches username
+  if (scope.toLowerCase() === npmUser.value.toLowerCase()) return true
+  // Can publish if user is a member of the org
+  return orgMembership.value[scope] === true
+})
+
+// Show claim prompt when valid name, available, connected, and has permission
+const showClaimPrompt = computed(() => {
+  return (
+    isConnected.value &&
+    isValidPackageName.value &&
+    packageAvailability.value?.available === true &&
+    packageAvailability.value.name === query.value.trim() &&
+    canPublishToScope.value &&
+    status.value !== 'pending'
+  )
+})
+
+// Modal state for claiming a package
+const claimModalOpen = ref(false)
+
 useSeoMeta({
   title: () => (query.value ? `Search: ${query.value} - npmx` : 'Search Packages - npmx'),
 })
@@ -192,9 +294,9 @@ defineOgImageComponent('Default', {
                   v-model="inputValue"
                   type="search"
                   name="q"
-                  placeholder="search packages..."
+                  placeholder="search packages…"
                   autocomplete="off"
-                  class="w-full max-w-full bg-bg-subtle border border-border rounded-lg pl-8 pr-4 py-3 font-mono text-base text-fg placeholder:text-fg-subtle transition-all duration-300 focus:(border-border-hover outline-none) appearance-none"
+                  class="w-full max-w-full bg-bg-subtle border border-border rounded-lg pl-8 pr-4 py-3 font-mono text-base text-fg placeholder:text-fg-subtle transition-colors duration-300 focus:(border-border-hover outline-none) appearance-none"
                   @focus="isSearchFocused = true"
                   @blur="isSearchFocused = false"
                 />
@@ -208,29 +310,63 @@ defineOgImageComponent('Default', {
     </header>
 
     <!-- Results area with container padding -->
-    <div class="container py-6">
+    <div class="container pt-20 pb-6">
       <section v-if="query" aria-label="Search results">
         <!-- Initial loading (only after user interaction, not during view transition) -->
-        <LoadingSpinner v-if="showSearching" text="Searching..." />
+        <LoadingSpinner v-if="showSearching" text="Searching…" />
 
         <div v-else-if="visibleResults">
+          <!-- Claim prompt - shown at top when valid name but no exact match -->
+          <div
+            v-if="showClaimPrompt && visibleResults.total > 0"
+            class="mb-6 p-4 bg-bg-subtle border border-border rounded-lg flex flex-col sm:flex-row sm:items-center gap-3 sm:gap-4"
+          >
+            <div class="flex-1 min-w-0">
+              <p class="font-mono text-sm text-fg">
+                "<span class="text-fg font-medium">{{ query }}</span
+                >" is not taken
+              </p>
+              <p class="text-xs text-fg-muted mt-0.5">Claim this package name on npm</p>
+            </div>
+            <button
+              type="button"
+              class="shrink-0 px-4 py-2 font-mono text-sm text-bg bg-fg rounded-md transition-all duration-200 hover:bg-fg/90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50"
+              @click="claimModalOpen = true"
+            >
+              Claim "{{ query }}"
+            </button>
+          </div>
+
           <p
             v-if="visibleResults.total > 0"
             role="status"
             class="text-fg-muted text-sm mb-6 font-mono"
           >
             Found <span class="text-fg">{{ formatNumber(visibleResults.total) }}</span> packages
-            <span v-if="status === 'pending'" class="text-fg-subtle">(updating...)</span>
+            <span v-if="status === 'pending'" class="text-fg-subtle">(updating…)</span>
           </p>
 
-          <p
-            v-else-if="status !== 'pending'"
-            role="status"
-            class="text-fg-muted py-12 text-center font-mono"
-          >
-            No packages found for "<span class="text-fg">{{ query }}</span
-            >"
-          </p>
+          <!-- No results found -->
+          <div v-else-if="status !== 'pending'" role="status" class="py-12 text-center">
+            <p class="text-fg-muted font-mono mb-6">
+              No packages found for "<span class="text-fg">{{ query }}</span
+              >"
+            </p>
+
+            <!-- Offer to claim the package name if it's valid -->
+            <div v-if="showClaimPrompt" class="max-w-md mx-auto">
+              <div class="p-4 bg-bg-subtle border border-border rounded-lg">
+                <p class="text-sm text-fg-muted mb-3">Want to claim this package name?</p>
+                <button
+                  type="button"
+                  class="px-4 py-2 font-mono text-sm text-bg bg-fg rounded-md transition-all duration-200 hover:bg-fg/90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-fg/50"
+                  @click="claimModalOpen = true"
+                >
+                  Claim "{{ query }}"
+                </button>
+              </div>
+            </div>
+          </div>
 
           <PackageList
             v-if="visibleResults.objects.length > 0"
@@ -251,5 +387,8 @@ defineOgImageComponent('Default', {
         <p class="text-fg-subtle font-mono text-sm">Start typing to search packages</p>
       </section>
     </div>
+
+    <!-- Claim package modal -->
+    <ClaimPackageModal v-model:open="claimModalOpen" :package-name="query" />
   </main>
 </template>
diff --git a/app/utils/package-name.ts b/app/utils/package-name.ts
new file mode 100644
index 0000000000..30162099b4
--- /dev/null
+++ b/app/utils/package-name.ts
@@ -0,0 +1,188 @@
+import validatePackageName from 'validate-npm-package-name'
+
+/**
+ * Normalize a package name for comparison by removing common variations.
+ * This aims to mirror npm's typosquatting detection algorithm.
+ */
+export function normalizePackageName(name: string): string {
+  // Remove scope if present
+  const unscoped = name.startsWith('@') ? name.split('/')[1] || name : name
+
+  // Normalize: lowercase, remove punctuation (.-_), remove 'js' and 'node' suffixes/prefixes
+  return (
+    unscoped
+      .toLowerCase()
+      // Remove all punctuation
+      .replace(/[.\-_]/g, '')
+      // Remove common suffixes/prefixes
+      .replace(/^(node|js)|(-?js|-?node)$/g, '')
+  )
+}
+
+/**
+ * Calculate similarity between two strings using Levenshtein distance.
+ */
+export function levenshteinDistance(a: string, b: string): number {
+  const matrix: number[][] = []
+
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i]
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0]![j] = j
+  }
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i]![j] = matrix[i - 1]![j - 1]!
+      } else {
+        matrix[i]![j] = Math.min(
+          matrix[i - 1]![j - 1]! + 1, // substitution
+          matrix[i]![j - 1]! + 1, // insertion
+          matrix[i - 1]![j]! + 1, // deletion
+        )
+      }
+    }
+  }
+
+  return matrix[b.length]![a.length]!
+}
+
+export function isValidNewPackageName(name: string): boolean {
+  if (!name) return false
+  const result = validatePackageName(name)
+  return result.validForNewPackages === true
+}
+
+export interface SimilarPackage {
+  name: string
+  description?: string
+  similarity: 'exact-match' | 'very-similar' | 'similar'
+}
+
+export interface CheckNameResult {
+  name: string
+  available: boolean
+  valid: boolean
+  validationErrors?: string[]
+  validationWarnings?: string[]
+  similarPackages?: SimilarPackage[]
+}
+
+const NPM_REGISTRY = 'https://registry.npmjs.org'
+
+export async function checkPackageExists(name: string): Promise<boolean> {
+  try {
+    const encodedName = name.startsWith('@')
+      ? `@${encodeURIComponent(name.slice(1))}`
+      : encodeURIComponent(name)
+
+    await $fetch(`${NPM_REGISTRY}/${encodedName}`, {
+      method: 'HEAD',
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function findSimilarPackages(name: string): Promise<SimilarPackage[]> {
+  const normalized = normalizePackageName(name)
+  const similar: SimilarPackage[] = []
+
+  try {
+    const searchResponse = await $fetch<{
+      objects: Array<{
+        package: {
+          name: string
+          description?: string
+        }
+      }>
+    }>(`${NPM_REGISTRY}/-/v1/search?text=${encodeURIComponent(name)}&size=20`)
+
+    for (const obj of searchResponse.objects) {
+      const pkgName = obj.package.name
+      const pkgNormalized = normalizePackageName(pkgName)
+
+      // Skip if it's the exact same name
+      if (pkgName === name) {
+        similar.push({
+          name: pkgName,
+          description: obj.package.description,
+          similarity: 'exact-match',
+        })
+        continue
+      }
+
+      // Check if normalized names match (high similarity)
+      if (normalized === pkgNormalized) {
+        similar.push({
+          name: pkgName,
+          description: obj.package.description,
+          similarity: 'very-similar',
+        })
+        continue
+      }
+
+      // Check Levenshtein distance for similar names
+      const distance = levenshteinDistance(normalized, pkgNormalized)
+      const maxLen = Math.max(normalized.length, pkgNormalized.length)
+
+      // Guard against division by zero
+      if (maxLen === 0) continue
+
+      const similarityScore = 1 - distance / maxLen
+
+      if (similarityScore >= 0.8 || distance <= 2) {
+        similar.push({
+          name: pkgName,
+          description: obj.package.description,
+          similarity: 'similar',
+        })
+      }
+    }
+
+    // Sort by similarity (exact > very-similar > similar)
+    const order = { 'exact-match': 0, 'very-similar': 1, 'similar': 2 }
+    similar.sort((a, b) => order[a.similarity] - order[b.similarity])
+
+    return similar.slice(0, 10) // Limit to 10 results
+  } catch {
+    return []
+  }
+}
+
+export async function checkPackageName(name: string): Promise<CheckNameResult> {
+  const validation = validatePackageName(name)
+  const valid = validation.validForNewPackages === true
+
+  const result: CheckNameResult = {
+    name,
+    available: false,
+    valid,
+  }
+
+  if (validation.errors?.length) {
+    result.validationErrors = validation.errors
+  }
+  if (validation.warnings?.length) {
+    result.validationWarnings = validation.warnings
+  }
+
+  // If name is not valid for new packages, return early
+  if (!valid) {
+    return result
+  }
+
+  // Check if package exists and find similar packages in parallel
+  const [exists, similarPackages] = await Promise.all([
+    checkPackageExists(name),
+    findSimilarPackages(name),
+  ])
+
+  result.available = !exists
+  result.similarPackages = similarPackages
+
+  return result
+}
diff --git a/cli/src/npm-client.ts b/cli/src/npm-client.ts
index 3f4cac08de..461ffcc17a 100644
--- a/cli/src/npm-client.ts
+++ b/cli/src/npm-client.ts
@@ -1,6 +1,9 @@
 import process from 'node:process'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
+import { mkdtemp, writeFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 import validateNpmPackageName from 'validate-npm-package-name'
 import { logCommand, logSuccess, logError } from './logger.ts'
 
@@ -286,3 +289,105 @@ export async function accessListCollaborators(pkg: string): Promise<NpmExecResul
   validatePackageName(pkg)
   return execNpm(['access', 'list', 'collaborators', pkg, '--json'], { silent: true })
 }
+
+/**
+ * Initialize and publish a new package to claim the name.
+ * Creates a minimal package.json in a temp directory and publishes it.
+ * @param name Package name to claim
+ * @param author npm username of the publisher (for author field)
+ * @param otp Optional OTP for 2FA
+ */
+export async function packageInit(
+  name: string,
+  author?: string,
+  otp?: string,
+): Promise<NpmExecResult> {
+  validatePackageName(name)
+
+  // Create a temporary directory
+  const tempDir = await mkdtemp(join(tmpdir(), 'npmx-init-'))
+
+  try {
+    // Determine access type based on whether it's a scoped package
+    const isScoped = name.startsWith('@')
+    const access = isScoped ? 'public' : undefined
+
+    // Create minimal package.json
+    const packageJson = {
+      name,
+      version: '0.0.0',
+      description: `Placeholder for ${name}`,
+      main: 'index.js',
+      scripts: {},
+      keywords: [],
+      author: author ? `${author} (https://www.npmjs.com/~${author})` : '',
+      license: 'UNLICENSED',
+      private: false,
+      ...(access && { publishConfig: { access } }),
+    }
+
+    await writeFile(join(tempDir, 'package.json'), JSON.stringify(packageJson, null, 2))
+
+    // Create empty index.js
+    await writeFile(join(tempDir, 'index.js'), '// Placeholder\n')
+
+    // Build npm publish args
+    const args = ['publish']
+    if (access) {
+      args.push('--access', access)
+    }
+
+    // Run npm publish from the temp directory
+    const npmArgs = otp ? [...args, '--otp', otp] : args
+
+    // Log the command being run (hide OTP value for security)
+    const displayCmd = otp ? `npm ${args.join(' ')} --otp ******` : `npm ${args.join(' ')}`
+    logCommand(`${displayCmd} (in temp dir for ${name})`)
+
+    try {
+      const { stdout, stderr } = await execFileAsync('npm', npmArgs, {
+        timeout: 60000,
+        cwd: tempDir,
+        env: { ...process.env, FORCE_COLOR: '0' },
+      })
+
+      logSuccess(`Published ${name}@0.0.0`)
+
+      return {
+        stdout: stdout.trim(),
+        stderr: filterNpmWarnings(stderr),
+        exitCode: 0,
+      }
+    } catch (error) {
+      const err = error as { stdout?: string; stderr?: string; code?: number }
+      const stderr = err.stderr?.trim() ?? String(error)
+      const requiresOtp = detectOtpRequired(stderr)
+      const authFailure = detectAuthFailure(stderr)
+
+      if (requiresOtp) {
+        logError('OTP required')
+      } else if (authFailure) {
+        logError('Authentication required - please run "npm login" and restart the connector')
+      } else {
+        logError(filterNpmWarnings(stderr).split('\n')[0] || 'Command failed')
+      }
+
+      return {
+        stdout: err.stdout?.trim() ?? '',
+        stderr: requiresOtp
+          ? 'This operation requires a one-time password (OTP).'
+          : authFailure
+            ? 'Authentication failed. Please run "npm login" and restart the connector.'
+            : filterNpmWarnings(stderr),
+        exitCode: err.code ?? 1,
+        requiresOtp,
+        authFailure,
+      }
+    }
+  } finally {
+    // Clean up temp directory
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {
+      // Ignore cleanup errors
+    })
+  }
+}
diff --git a/cli/src/server.ts b/cli/src/server.ts
index 101d7215e6..1e7498bb73 100644
--- a/cli/src/server.ts
+++ b/cli/src/server.ts
@@ -19,6 +19,7 @@ import {
   accessListCollaborators,
   ownerAdd,
   ownerRemove,
+  packageInit,
   type NpmExecResult,
 } from './npm-client.ts'
 
@@ -245,8 +246,13 @@ export function createConnectorApp(expectedToken: string) {
     }
 
     // OTP can be passed directly in the request body for this execution
-    const body = (await event.req.json()) as { otp?: string } | null
-    const otp = body?.otp
+    let otp: string | undefined
+    try {
+      const body = (await event.req.json()) as { otp?: string } | null
+      otp = body?.otp
+    } catch {
+      // Empty body is fine - no OTP provided
+    }
 
     const approvedOps = state.operations.filter(op => op.status === 'approved')
     const results: Array<{ id: string; result: NpmExecResult }> = []
@@ -508,34 +514,36 @@ async function executeOperation(op: PendingOperation, otp?: string): Promise<Npm
   switch (type) {
     case 'org:add-user':
       return orgAddUser(
-        params.org!,
-        params.user!,
+        params.org,
+        params.user,
         params.role as 'developer' | 'admin' | 'owner',
         otp,
       )
     case 'org:rm-user':
-      return orgRemoveUser(params.org!, params.user!, otp)
+      return orgRemoveUser(params.org, params.user, otp)
     case 'team:create':
-      return teamCreate(params.scopeTeam!, otp)
+      return teamCreate(params.scopeTeam, otp)
     case 'team:destroy':
-      return teamDestroy(params.scopeTeam!, otp)
+      return teamDestroy(params.scopeTeam, otp)
     case 'team:add-user':
-      return teamAddUser(params.scopeTeam!, params.user!, otp)
+      return teamAddUser(params.scopeTeam, params.user, otp)
     case 'team:rm-user':
-      return teamRemoveUser(params.scopeTeam!, params.user!, otp)
+      return teamRemoveUser(params.scopeTeam, params.user, otp)
     case 'access:grant':
       return accessGrant(
         params.permission as 'read-only' | 'read-write',
-        params.scopeTeam!,
-        params.pkg!,
+        params.scopeTeam,
+        params.pkg,
         otp,
       )
     case 'access:revoke':
-      return accessRevoke(params.scopeTeam!, params.pkg!, otp)
+      return accessRevoke(params.scopeTeam, params.pkg, otp)
     case 'owner:add':
-      return ownerAdd(params.user!, params.pkg!, otp)
+      return ownerAdd(params.user, params.pkg, otp)
     case 'owner:rm':
-      return ownerRemove(params.user!, params.pkg!, otp)
+      return ownerRemove(params.user, params.pkg, otp)
+    case 'package:init':
+      return packageInit(params.name, params.author, otp)
     default:
       return {
         stdout: '',
diff --git a/cli/src/types.ts b/cli/src/types.ts
index e355b542d1..4a4a5bed45 100644
--- a/cli/src/types.ts
+++ b/cli/src/types.ts
@@ -21,6 +21,7 @@ export type OperationType =
   | 'access:revoke'
   | 'owner:add'
   | 'owner:rm'
+  | 'package:init'
 
 export type OperationStatus =
   | 'pending'
diff --git a/test/unit/check-name.spec.ts b/test/unit/check-name.spec.ts
new file mode 100644
index 0000000000..fc7dfc2577
--- /dev/null
+++ b/test/unit/check-name.spec.ts
@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest'
+import {
+  normalizePackageName,
+  levenshteinDistance,
+  isValidNewPackageName,
+} from '../../app/utils/package-name'
+
+describe('package-name utilities', () => {
+  describe('normalizePackageName', () => {
+    it('normalizes simple names', () => {
+      expect(normalizePackageName('lodash')).toBe('lodash')
+      expect(normalizePackageName('my-package')).toBe('mypackage')
+      expect(normalizePackageName('my_package')).toBe('mypackage')
+      expect(normalizePackageName('my.package')).toBe('mypackage')
+    })
+
+    it('removes js/node suffixes', () => {
+      expect(normalizePackageName('lodash-js')).toBe('lodash')
+      expect(normalizePackageName('lodashjs')).toBe('lodash')
+      expect(normalizePackageName('lodash-node')).toBe('lodash')
+    })
+
+    it('removes js/node prefixes', () => {
+      expect(normalizePackageName('js-yaml')).toBe('yaml')
+      expect(normalizePackageName('node-fetch')).toBe('fetch')
+    })
+
+    it('handles scoped packages', () => {
+      expect(normalizePackageName('@scope/my-package')).toBe('mypackage')
+      expect(normalizePackageName('@vue/core')).toBe('core')
+    })
+
+    it('handles edge cases', () => {
+      expect(normalizePackageName('js')).toBe('')
+      expect(normalizePackageName('node')).toBe('')
+    })
+  })
+
+  describe('levenshteinDistance', () => {
+    it('returns 0 for identical strings', () => {
+      expect(levenshteinDistance('hello', 'hello')).toBe(0)
+    })
+
+    it('returns correct distance for single character changes', () => {
+      expect(levenshteinDistance('hello', 'hallo')).toBe(1)
+      expect(levenshteinDistance('hello', 'hell')).toBe(1)
+      expect(levenshteinDistance('hello', 'helloo')).toBe(1)
+    })
+
+    it('handles empty strings', () => {
+      expect(levenshteinDistance('', '')).toBe(0)
+      expect(levenshteinDistance('hello', '')).toBe(5)
+      expect(levenshteinDistance('', 'hello')).toBe(5)
+    })
+  })
+
+  describe('isValidNewPackageName', () => {
+    it('validates correct package names', () => {
+      expect(isValidNewPackageName('my-package')).toBe(true)
+      expect(isValidNewPackageName('my_package')).toBe(true)
+      expect(isValidNewPackageName('@scope/package')).toBe(true)
+    })
+
+    it('rejects invalid package names', () => {
+      expect(isValidNewPackageName('.hidden')).toBe(false)
+      expect(isValidNewPackageName('-invalid')).toBe(false)
+      expect(isValidNewPackageName('UPPERCASE')).toBe(false)
+      expect(isValidNewPackageName('has spaces')).toBe(false)
+      expect(isValidNewPackageName('')).toBe(false)
+    })
+  })
+})