diff --git a/.gitignore b/.gitignore
index c4cc07442b..42119a2c78 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,6 +29,7 @@ test-results
 
 # Test coverage
 coverage/
+*.junit.xml
 
 # Playwright
 playwright-report/
diff --git a/app/components/Package/DeprecatePackageModal.vue b/app/components/Package/DeprecatePackageModal.vue
new file mode 100644
index 0000000000..cb9614300b
--- /dev/null
+++ b/app/components/Package/DeprecatePackageModal.vue
@@ -0,0 +1,270 @@
+<script setup lang="ts">
+import type { NewOperation } from '~/composables/useConnector'
+import { PackageDeprecateParamsSchema, safeParse } from '~~/cli/src/schemas'
+
+const DEPRECATE_MESSAGE_MAX_LENGTH = 500
+
+const props = withDefaults(
+  defineProps<{
+    packageName: string
+    version?: string
+    /** When true, the package or version is already deprecated; form is hidden and state cannot be changed. */
+    isAlreadyDeprecated?: boolean
+    /** Version strings that are already deprecated (computed by parent from pkg.versions). */
+    deprecatedVersions?: string[]
+  }>(),
+  { version: '', isAlreadyDeprecated: false, deprecatedVersions: () => [] },
+)
+
+const { t } = useI18n()
+const { isConnected, state, addOperation, approveOperation, executeOperations, refreshState } =
+  useConnector()
+
+const deprecateMessage = ref('')
+const deprecateVersion = ref(props.version)
+const isDeprecating = shallowRef(false)
+const deprecateSuccess = shallowRef(false)
+const deprecateError = shallowRef<string | null>(null)
+
+const connectorModal = useModal('connector-modal')
+
+const modalTitle = computed(() =>
+  deprecateVersion.value
+    ? `${t('package.deprecation.modal.title')} ${props.packageName}@${deprecateVersion.value}`
+    : `${t('package.deprecation.modal.title')} ${props.packageName}`,
+)
+
+/** True when the user has entered a version in the form that is already deprecated. */
+const isSelectedVersionDeprecated = computed(() => {
+  const v = deprecateVersion.value.trim()
+  if (!v || !props.deprecatedVersions.length) return false
+  return props.deprecatedVersions.includes(v)
+})
+
+async function handleDeprecate() {
+  if (props.isAlreadyDeprecated || isSelectedVersionDeprecated.value) return
+  const message = deprecateMessage.value.trim()
+  if (!isConnected.value) return
+
+  const params: Record<string, string> = {
+    pkg: props.packageName,
+    message,
+  }
+  if (deprecateVersion.value.trim()) {
+    params.version = deprecateVersion.value.trim()
+  }
+
+  const parsed = safeParse(PackageDeprecateParamsSchema, params)
+  if (!parsed.success) {
+    deprecateError.value = parsed.error
+    return
+  }
+
+  isDeprecating.value = true
+  deprecateError.value = null
+
+  try {
+    const escapedMessage = parsed.data.message.replace(/"/g, '\\"')
+    const command = parsed.data.version
+      ? `npm deprecate ${parsed.data.pkg}@${parsed.data.version} "${escapedMessage}"`
+      : `npm deprecate ${parsed.data.pkg} "${escapedMessage}"`
+
+    const operation = await addOperation({
+      type: 'package:deprecate',
+      params: {
+        pkg: parsed.data.pkg,
+        message: parsed.data.message,
+        ...(parsed.data.version && { version: parsed.data.version }),
+      },
+      description: parsed.data.version
+        ? `Deprecate ${parsed.data.pkg}@${parsed.data.version}`
+        : `Deprecate ${parsed.data.pkg}`,
+      command,
+    } as NewOperation)
+
+    if (!operation) {
+      throw new Error('Failed to create operation')
+    }
+
+    await approveOperation(operation.id)
+    await executeOperations()
+    await refreshState()
+
+    const completedOp = state.value.operations.find(op => op.id === operation.id)
+    if (completedOp?.status === 'completed') {
+      deprecateSuccess.value = true
+    } else if (completedOp?.status === 'failed') {
+      if (completedOp.result?.requiresOtp) {
+        close()
+        connectorModal.open()
+      } else {
+        deprecateError.value = completedOp.result?.stderr || t('common.try_again')
+      }
+    } else {
+      close()
+      connectorModal.open()
+    }
+  } catch (err) {
+    deprecateError.value = err instanceof Error ? err.message : t('common.try_again')
+  } finally {
+    isDeprecating.value = false
+  }
+}
+
+const dialogRef = useTemplateRef('dialogRef')
+
+function open() {
+  deprecateError.value = null
+  deprecateSuccess.value = false
+  deprecateMessage.value = ''
+  deprecateVersion.value = props.version ?? ''
+  dialogRef.value?.showModal()
+}
+
+function close() {
+  dialogRef.value?.close()
+}
+
+defineExpose({ open, close })
+</script>
+
+<template>
+  <Modal ref="dialogRef" :modal-title="modalTitle" id="deprecate-package-modal" class="max-w-md">
+    <!-- Already deprecated: entire module read-only, hint only, no form / no deprecate button -->
+    <div v-if="isAlreadyDeprecated" class="space-y-4" aria-readonly="true">
+      <div
+        class="flex items-center gap-3 p-4 bg-amber-500/10 border border-amber-500/20 rounded-lg"
+        role="status"
+      >
+        <span class="i-carbon-warning-alt text-amber-500 w-6 h-6 shrink-0" aria-hidden="true" />
+        <div>
+          <p class="font-mono text-sm text-fg">
+            {{
+              deprecateVersion
+                ? $t('package.deprecation.modal.already_deprecated_version')
+                : $t('package.deprecation.modal.already_deprecated')
+            }}
+          </p>
+          <p class="text-xs text-fg-muted mt-0.5">
+            {{ $t('package.deprecation.modal.already_deprecated_detail') }}
+          </p>
+        </div>
+      </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-accent/70"
+        @click="close"
+      >
+        {{ $t('common.close') }}
+      </button>
+    </div>
+
+    <!-- Success state -->
+    <div v-else-if="deprecateSuccess" 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">{{ $t('package.deprecation.modal.success') }}</p>
+          <p class="text-xs text-fg-muted">
+            {{ $t('package.deprecation.modal.success_detail') }}
+          </p>
+        </div>
+      </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-accent/70"
+        @click="close"
+      >
+        {{ $t('common.close') }}
+      </button>
+    </div>
+
+    <!-- Form -->
+    <div v-else class="space-y-4">
+      <!-- Hint when user-entered version is already deprecated -->
+      <div
+        v-if="isSelectedVersionDeprecated"
+        class="flex items-center gap-3 p-4 bg-amber-500/10 border border-amber-500/20 rounded-lg"
+        role="status"
+      >
+        <span class="i-carbon-warning-alt text-amber-500 w-6 h-6 shrink-0" aria-hidden="true" />
+        <div>
+          <p class="font-mono text-sm text-fg">
+            {{ $t('package.deprecation.modal.already_deprecated_version') }}
+          </p>
+          <p class="text-xs text-fg-muted mt-0.5">
+            {{ $t('package.deprecation.modal.already_deprecated_detail') }}
+          </p>
+        </div>
+      </div>
+      <div>
+        <label
+          for="deprecate-message"
+          class="block text-xs text-fg-subtle uppercase tracking-wider mb-1.5"
+        >
+          {{ $t('package.deprecation.modal.reason') }}
+        </label>
+        <textarea
+          id="deprecate-message"
+          v-model="deprecateMessage"
+          rows="3"
+          :maxlength="DEPRECATE_MESSAGE_MAX_LENGTH"
+          :disabled="isSelectedVersionDeprecated"
+          class="w-full appearance-none bg-bg-subtle border border-border font-mono text-sm leading-none px-3 py-2.5 rounded-lg text-fg placeholder:text-fg-subtle transition-[border-color,outline-color] duration-300 hover:border-fg-subtle outline-2 outline-transparent outline-offset-2 focus:border-accent focus-visible:outline-accent/70 disabled:(opacity-50 cursor-not-allowed)"
+          :placeholder="$t('package.deprecation.modal.reason_placeholder')"
+          :aria-describedby="
+            deprecateMessage.length >= DEPRECATE_MESSAGE_MAX_LENGTH
+              ? 'deprecate-message-hint'
+              : undefined
+          "
+        />
+        <p
+          v-if="deprecateMessage.length >= DEPRECATE_MESSAGE_MAX_LENGTH * 0.9"
+          id="deprecate-message-hint"
+          class="mt-1 text-xs text-fg-muted"
+        >
+          {{ deprecateMessage.length }} / {{ DEPRECATE_MESSAGE_MAX_LENGTH }}
+        </p>
+      </div>
+      <div>
+        <label
+          for="deprecate-version"
+          class="block text-xs text-fg-subtle uppercase tracking-wider mb-1.5"
+        >
+          {{ $t('package.deprecation.modal.version') }}
+        </label>
+        <InputBase
+          id="deprecate-version"
+          v-model="deprecateVersion"
+          type="text"
+          name="deprecate-version"
+          :disabled="isSelectedVersionDeprecated"
+          class="w-full"
+          size="medium"
+          :placeholder="$t('package.deprecation.modal.version_placeholder')"
+        />
+      </div>
+      <div
+        v-if="deprecateError"
+        role="alert"
+        class="p-3 text-sm text-red-400 bg-red-500/10 border border-red-500/20 rounded-md"
+      >
+        {{ deprecateError }}
+      </div>
+      <button
+        type="button"
+        :disabled="isDeprecating || !deprecateMessage.trim() || isSelectedVersionDeprecated"
+        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="handleDeprecate"
+      >
+        {{
+          isDeprecating
+            ? $t('package.deprecation.modal.deprecating')
+            : $t('package.deprecation.action')
+        }}
+      </button>
+    </div>
+  </Modal>
+</template>
diff --git a/app/pages/package/[[org]]/[name].vue b/app/pages/package/[[org]]/[name].vue
index 1d81f70eba..39b96f0d92 100644
--- a/app/pages/package/[[org]]/[name].vue
+++ b/app/pages/package/[[org]]/[name].vue
@@ -375,6 +375,21 @@ const latestVersion = computed(() => {
   return pkg.value.versions[latestTag] ?? null
 })
 
+/** True when the currently displayed version (or resolved version) is deprecated; used to hide deprecate button. */
+const isCurrentVersionDeprecated = computed(() => {
+  if (displayVersion.value?.deprecated) return true
+  const ver = resolvedVersion.value
+  return !!(ver && pkg.value?.versions?.[ver]?.deprecated)
+})
+
+/** Version strings that are already deprecated; passed to DeprecatePackageModal to avoid extra fetch. */
+const deprecatedVersions = computed(() => {
+  if (!pkg.value?.versions) return []
+  return Object.entries(pkg.value.versions)
+    .filter(([, metadata]) => !!metadata.deprecated)
+    .map(([version]) => version)
+})
+
 const deprecationNotice = computed(() => {
   if (!displayVersion.value?.deprecated) return null
 
@@ -396,6 +411,17 @@ const deprecationNoticeMessage = useMarkdown(() => ({
   text: deprecationNotice.value?.message ?? '',
 }))
 
+const { isConnected, npmUser } = useConnector()
+const deprecateModal = useTemplateRef<{ open: () => void }>('deprecateModal')
+
+const isPackageOwner = computed(() => {
+  const maintainers = pkg.value?.maintainers
+  const user = npmUser.value
+  if (!maintainers?.length || !user) return false
+  const userLower = user.toLowerCase()
+  return maintainers.some((m: { name?: string }) => (m.name ?? '').toLowerCase() === userLower)
+})
+
 const publishSecurityDowngrade = computed(() => {
   const currentVersion = displayVersion.value?.version
   if (!currentVersion) return null
@@ -1496,6 +1522,21 @@ const showSkeleton = shallowRef(false)
 
           <!-- Maintainers (with admin actions when connected) -->
           <PackageMaintainers :package-name="pkg.name" :maintainers="pkg.maintainers" />
+
+          <!-- Deprecation (when connected as package owner; hidden when current version is already deprecated) -->
+          <div
+            v-if="isConnected && resolvedVersion && isPackageOwner && !isCurrentVersionDeprecated"
+            class="space-y-1"
+          >
+            <button
+              type="button"
+              class="flex items-center justify-center gap-1.5 w-full px-3 py-1.5 bg-bg-subtle rounded text-sm font-mono text-red-400 hover:text-red-500 transition-colors"
+              @click="deprecateModal?.open()"
+            >
+              <span class="i-carbon-warning-alt w-4 h-4 shrink-0" aria-hidden="true" />
+              {{ $t('package.deprecation.action') }}
+            </button>
+          </div>
         </div>
       </PackageSidebar>
     </article>
@@ -1516,6 +1557,16 @@ const showSkeleton = shallowRef(false)
         $t('common.go_back_home')
       }}</LinkBase>
     </div>
+    <ClientOnly>
+      <PackageDeprecatePackageModal
+        v-if="pkg"
+        ref="deprecateModal"
+        :package-name="pkg.name"
+        :version="resolvedVersion ?? ''"
+        :is-already-deprecated="isCurrentVersionDeprecated"
+        :deprecated-versions="deprecatedVersions"
+      />
+    </ClientOnly>
   </main>
 </template>
 
diff --git a/cli/src/mock-state.ts b/cli/src/mock-state.ts
index 829e0ff3c7..fd58eb9709 100644
--- a/cli/src/mock-state.ts
+++ b/cli/src/mock-state.ts
@@ -489,6 +489,11 @@ export class MockConnectorStateManager {
         }
         break
       }
+      case 'package:deprecate': {
+        // Params: { pkg, message, version? } — PackageDeprecateParamsSchema
+        // Deprecation is a registry-side mutation; no local mock state to update.
+        break
+      }
     }
   }
 
diff --git a/cli/src/npm-client.ts b/cli/src/npm-client.ts
index a3f61a5c10..612e42e3ec 100644
--- a/cli/src/npm-client.ts
+++ b/cli/src/npm-client.ts
@@ -650,3 +650,40 @@ export async function packageInit(
     })
   }
 }
+
+/**
+ * Deprecate a package or a specific version with a custom message.
+ * @param pkg Package name (e.g. "vue" or "@nuxt/kit")
+ * @param reason Deprecation message shown to users
+ * @param version Optional version to deprecate (e.g. "1.0.0"); if omitted, deprecates the whole package
+ * @param options.dryRun If true, passes --dry-run to npm (report what would be done without making changes)
+ * @param options.registry Registry URL (e.g. "https://registry.npmjs.org"); if set, passes --registry
+ */
+export async function packageDeprecate(
+  pkg: string,
+  reason: string,
+  version?: string,
+  otp?: string,
+  options?: { dryRun?: boolean; registry?: string },
+): Promise<NpmExecResult> {
+  validatePackageName(pkg)
+
+  const reasonText = reason.trim()
+
+  if (!reasonText) {
+    throw new Error('Deprecation reason must not be empty')
+  }
+
+  const target = version ? `${pkg}@${version}` : pkg
+  const args = ['deprecate', target, reasonText]
+
+  if (options?.dryRun) {
+    args.push('--dry-run')
+  }
+
+  if (options?.registry?.trim()) {
+    args.push('--registry', options.registry.trim())
+  }
+
+  return execNpm(args, { otp })
+}
diff --git a/cli/src/schemas.ts b/cli/src/schemas.ts
index de2cb627b9..6d0c10bb83 100644
--- a/cli/src/schemas.ts
+++ b/cli/src/schemas.ts
@@ -109,6 +109,7 @@ export const OperationTypeSchema = v.picklist([
   'owner:add',
   'owner:rm',
   'package:init',
+  'package:deprecate',
 ])
 
 /**
@@ -245,6 +246,19 @@ export const PackageInitParamsSchema = v.object({
   author: v.optional(UsernameSchema),
 })
 
+/** Schema for package:deprecate operation params. Exported for client-side validation. */
+export const PackageDeprecateParamsSchema = v.object({
+  pkg: PackageNameSchema,
+  message: v.pipe(
+    v.string(),
+    v.nonEmpty('Deprecation message is required'),
+    v.maxLength(500, 'Message is too long'),
+  ),
+  version: v.optional(v.pipe(v.string(), v.nonEmpty())),
+  dryRun: v.optional(v.picklist(['true', 'false'], 'dryRun must be "true" or "false"')),
+  registry: v.optional(v.pipe(v.string(), v.minLength(1, 'Registry URL cannot be empty'))),
+})
+
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -294,6 +308,9 @@ export function validateOperationParams(
     case 'package:init':
       v.parse(PackageInitParamsSchema, params)
       break
+    case 'package:deprecate':
+      v.parse(PackageDeprecateParamsSchema, params)
+      break
   }
 }
 
diff --git a/cli/src/server.ts b/cli/src/server.ts
index ee798c7a90..04f748d8e0 100644
--- a/cli/src/server.ts
+++ b/cli/src/server.ts
@@ -50,6 +50,7 @@ import {
   ownerAdd,
   ownerRemove,
   packageInit,
+  packageDeprecate,
   listUserPackages,
   extractUrls,
   type ExecNpmOptions,
@@ -813,6 +814,15 @@ async function executeOperation(
       // and does not support interactive mode
       result = await packageInit(params.name, params.author, options.otp)
       break
+    case 'package:deprecate': {
+      const dryRun = params.dryRun === 'true'
+      const registry = params.registry?.trim() ?? undefined
+      result = await packageDeprecate(params.pkg, params.message, params.version, options.otp, {
+        dryRun: dryRun || undefined,
+        registry,
+      })
+      break
+    }
     default:
       return {
         stdout: '',
diff --git a/cli/src/types.ts b/cli/src/types.ts
index fcd0db2a4d..f8b9353541 100644
--- a/cli/src/types.ts
+++ b/cli/src/types.ts
@@ -26,6 +26,7 @@ export type OperationType =
   | 'owner:add'
   | 'owner:rm'
   | 'package:init'
+  | 'package:deprecate'
 
 export type OperationStatus =
   | 'pending'
diff --git a/i18n/locales/en.json b/i18n/locales/en.json
index 3e4354e485..b4ae270a50 100644
--- a/i18n/locales/en.json
+++ b/i18n/locales/en.json
@@ -153,9 +153,23 @@
     "copy_name": "Copy package name",
     "copy_version": "Copy package version",
     "deprecation": {
+      "action": "Deprecate",
       "package": "This package has been deprecated.",
       "version": "This version has been deprecated.",
-      "no_reason": "No reason provided"
+      "no_reason": "No reason provided",
+      "modal": {
+        "deprecating": "Deprecating",
+        "title": "Deprecate",
+        "reason": "Reason",
+        "reason_placeholder": "e.g. Use package-x instead. This package is no longer maintained.",
+        "success": "Package deprecated",
+        "success_detail": "The package has been deprecated.",
+        "version": "Version",
+        "version_placeholder": "Leave empty to deprecate the whole package",
+        "already_deprecated": "Already deprecated",
+        "already_deprecated_version": "This version is already deprecated.",
+        "already_deprecated_detail": "This package or version is already deprecated. Deprecation status cannot be changed."
+      }
     },
     "replacement": {
       "title": "You might not need this dependency.",
diff --git a/i18n/locales/zh-CN.json b/i18n/locales/zh-CN.json
index 14593b04af..778488df37 100644
--- a/i18n/locales/zh-CN.json
+++ b/i18n/locales/zh-CN.json
@@ -153,9 +153,23 @@
     "copy_name": "复制包名",
     "copy_version": "复制版本号",
     "deprecation": {
+      "action": "废弃",
       "package": "此包已废弃。",
       "version": "此版本已废弃。",
-      "no_reason": "未提供原因"
+      "no_reason": "未提供原因",
+      "modal": {
+        "deprecating": "废弃中",
+        "title": "废弃",
+        "reason": "原因",
+        "reason_placeholder": "例如：使用 package-x 替代。这个包不再维护。",
+        "success": "包已废弃",
+        "success_detail": "这个包已废弃。",
+        "version": "版本",
+        "version_placeholder": "留空则废弃整个包",
+        "already_deprecated": "已废弃",
+        "already_deprecated_version": "该版本已废弃。",
+        "already_deprecated_detail": "该包或版本已处于废弃状态，无法再修改废弃状态。"
+      }
     },
     "replacement": {
       "title": "你可能不需要这个依赖。",
diff --git a/i18n/schema.json b/i18n/schema.json
index aa7681bc31..40e28670f3 100644
--- a/i18n/schema.json
+++ b/i18n/schema.json
@@ -463,6 +463,9 @@
         "deprecation": {
           "type": "object",
           "properties": {
+            "action": {
+              "type": "string"
+            },
             "package": {
               "type": "string"
             },
@@ -471,6 +474,45 @@
             },
             "no_reason": {
               "type": "string"
+            },
+            "modal": {
+              "type": "object",
+              "properties": {
+                "deprecating": {
+                  "type": "string"
+                },
+                "title": {
+                  "type": "string"
+                },
+                "reason": {
+                  "type": "string"
+                },
+                "reason_placeholder": {
+                  "type": "string"
+                },
+                "success": {
+                  "type": "string"
+                },
+                "success_detail": {
+                  "type": "string"
+                },
+                "version": {
+                  "type": "string"
+                },
+                "version_placeholder": {
+                  "type": "string"
+                },
+                "already_deprecated": {
+                  "type": "string"
+                },
+                "already_deprecated_version": {
+                  "type": "string"
+                },
+                "already_deprecated_detail": {
+                  "type": "string"
+                }
+              },
+              "additionalProperties": false
             }
           },
           "additionalProperties": false
diff --git a/lunaria/files/en-GB.json b/lunaria/files/en-GB.json
index 4ca9ba59df..54fcc04059 100644
--- a/lunaria/files/en-GB.json
+++ b/lunaria/files/en-GB.json
@@ -152,9 +152,23 @@
     "copy_name": "Copy package name",
     "copy_version": "Copy package version",
     "deprecation": {
+      "action": "Deprecate",
       "package": "This package has been deprecated.",
       "version": "This version has been deprecated.",
-      "no_reason": "No reason provided"
+      "no_reason": "No reason provided",
+      "modal": {
+        "deprecating": "Deprecating",
+        "title": "Deprecate",
+        "reason": "Reason",
+        "reason_placeholder": "e.g. Use package-x instead. This package is no longer maintained.",
+        "success": "Package deprecated",
+        "success_detail": "The package has been deprecated.",
+        "version": "Version",
+        "version_placeholder": "Leave empty to deprecate the whole package",
+        "already_deprecated": "Already deprecated",
+        "already_deprecated_version": "This version is already deprecated.",
+        "already_deprecated_detail": "This package or version is already deprecated. Deprecation status cannot be changed."
+      }
     },
     "replacement": {
       "title": "You might not need this dependency.",
diff --git a/lunaria/files/en-US.json b/lunaria/files/en-US.json
index 69a66c3f7f..cd87a9f2d6 100644
--- a/lunaria/files/en-US.json
+++ b/lunaria/files/en-US.json
@@ -152,9 +152,23 @@
     "copy_name": "Copy package name",
     "copy_version": "Copy package version",
     "deprecation": {
+      "action": "Deprecate",
       "package": "This package has been deprecated.",
       "version": "This version has been deprecated.",
-      "no_reason": "No reason provided"
+      "no_reason": "No reason provided",
+      "modal": {
+        "deprecating": "Deprecating",
+        "title": "Deprecate",
+        "reason": "Reason",
+        "reason_placeholder": "e.g. Use package-x instead. This package is no longer maintained.",
+        "success": "Package deprecated",
+        "success_detail": "The package has been deprecated.",
+        "version": "Version",
+        "version_placeholder": "Leave empty to deprecate the whole package",
+        "already_deprecated": "Already deprecated",
+        "already_deprecated_version": "This version is already deprecated.",
+        "already_deprecated_detail": "This package or version is already deprecated. Deprecation status cannot be changed."
+      }
     },
     "replacement": {
       "title": "You might not need this dependency.",
diff --git a/lunaria/files/zh-CN.json b/lunaria/files/zh-CN.json
index eb86181ec2..daf52672fc 100644
--- a/lunaria/files/zh-CN.json
+++ b/lunaria/files/zh-CN.json
@@ -152,9 +152,23 @@
     "copy_name": "复制包名",
     "copy_version": "复制版本号",
     "deprecation": {
+      "action": "废弃",
       "package": "此包已废弃。",
       "version": "此版本已废弃。",
-      "no_reason": "未提供原因"
+      "no_reason": "未提供原因",
+      "modal": {
+        "deprecating": "废弃中",
+        "title": "废弃",
+        "reason": "原因",
+        "reason_placeholder": "例如：使用 package-x 替代。这个包不再维护。",
+        "success": "包已废弃",
+        "success_detail": "这个包已废弃。",
+        "version": "版本",
+        "version_placeholder": "留空则废弃整个包",
+        "already_deprecated": "已废弃",
+        "already_deprecated_version": "该版本已废弃。",
+        "already_deprecated_detail": "该包或版本已处于废弃状态，无法再修改废弃状态。"
+      }
     },
     "replacement": {
       "title": "你可能不需要这个依赖。",
diff --git a/test/nuxt/a11y.spec.ts b/test/nuxt/a11y.spec.ts
index e3ef8e09c3..c9c15dce66 100644
--- a/test/nuxt/a11y.spec.ts
+++ b/test/nuxt/a11y.spec.ts
@@ -155,6 +155,7 @@ import {
   PackageChartModal,
   PackageClaimPackageModal,
   PackageCompatibility,
+  PackageDeprecatePackageModal,
   PackageDependencies,
   PackageDeprecatedTree,
   PackageInstallScripts,
@@ -1137,6 +1138,29 @@ describe('component accessibility audits', () => {
     })
   })
 
+  describe('PackageDeprecatePackageModal', () => {
+    it('should have no accessibility violations when closed', async () => {
+      const component = await mountSuspended(PackageDeprecatePackageModal, {
+        props: {
+          packageName: 'test-package',
+        },
+      })
+      const results = await runAxe(component)
+      expect(results.violations).toEqual([])
+    })
+
+    it('should have no accessibility violations when closed with version', async () => {
+      const component = await mountSuspended(PackageDeprecatePackageModal, {
+        props: {
+          packageName: 'test-package',
+          version: '1.0.0',
+        },
+      })
+      const results = await runAxe(component)
+      expect(results.violations).toEqual([])
+    })
+  })
+
   describe('PackageProvenanceSection', () => {
     it('should have no accessibility violations with minimal details', async () => {
       const component = await mountSuspended(PackageProvenanceSection, {
diff --git a/test/nuxt/components/DeprecatePackageModal.spec.ts b/test/nuxt/components/DeprecatePackageModal.spec.ts
new file mode 100644
index 0000000000..6f20b6eec6
--- /dev/null
+++ b/test/nuxt/components/DeprecatePackageModal.spec.ts
@@ -0,0 +1,439 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { Ref } from 'vue'
+import { defineComponent, h, ref } from 'vue'
+import { mountSuspended } from '@nuxt/test-utils/runtime'
+import DeprecatePackageModal from '~/components/Package/DeprecatePackageModal.vue'
+import type { PendingOperation } from '../../../cli/src/types'
+
+/** Internal state exposed on vm for testing (not in defineExpose) */
+interface DeprecateModalVM {
+  deprecateMessage?: Ref<string>
+  deprecateVersion?: Ref<string>
+  deprecateError?: Ref<string | null>
+  deprecateSuccess?: Ref<boolean>
+  handleDeprecate?: () => Promise<void>
+  open?: () => void
+  close?: () => void
+}
+
+function getVM(component: { vm: unknown }) {
+  return component.vm as DeprecateModalVM
+}
+
+const mockAddOperation = vi.fn()
+const mockApproveOperation = vi.fn()
+const mockExecuteOperations = vi.fn()
+const mockRefreshState = vi.fn()
+const mockConnectorModalOpen = vi.fn()
+
+const mockIsConnected = ref(true)
+const mockState = ref<{ operations: PendingOperation[] }>({
+  operations: [],
+})
+
+vi.mock('~/composables/useConnector', () => ({
+  useConnector: () => ({
+    isConnected: mockIsConnected,
+    state: mockState,
+    addOperation: (...args: unknown[]) => mockAddOperation(...args),
+    approveOperation: (...args: unknown[]) => mockApproveOperation(...args),
+    executeOperations: (...args: unknown[]) => mockExecuteOperations(...args),
+    refreshState: (...args: unknown[]) => mockRefreshState(...args),
+  }),
+}))
+
+vi.mock('~/composables/useModal', () => ({
+  useModal: (id: string) => ({
+    id,
+    open: mockConnectorModalOpen,
+    close: vi.fn(),
+  }),
+}))
+
+// Stub Modal so slot content is rendered inline (no Teleport to body), making form elements findable
+const ModalStub = defineComponent({
+  name: 'ModalStub',
+  inheritAttrs: false,
+  setup() {
+    const showModal = vi.fn()
+    const close = vi.fn()
+    return { showModal, close }
+  },
+  render() {
+    return h('div', { ...this.$attrs, 'data-testid': 'modal-stub' }, this.$slots.default?.())
+  },
+})
+
+const mountOptions = {
+  global: {
+    stubs: {
+      Modal: ModalStub,
+    },
+  },
+}
+
+function createMockOperation(overrides: Partial<PendingOperation> = {}): PendingOperation {
+  return {
+    id: 'op-1',
+    type: 'package:deprecate',
+    params: { pkg: 'test-package', message: 'test message' },
+    description: 'Deprecate test-package',
+    command: 'npm deprecate test-package "test message"',
+    status: 'completed',
+    createdAt: Date.now(),
+    ...overrides,
+  }
+}
+
+describe('DeprecatePackageModal', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockIsConnected.value = true
+    mockState.value = { operations: [] }
+  })
+
+  describe('props and rendering', () => {
+    it('renders with packageName only', async () => {
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'my-pkg' },
+        ...mountOptions,
+      })
+
+      expect(component.find('[data-testid="modal-stub"]').exists()).toBe(true)
+      expect(component.find('#deprecate-message').exists()).toBe(true)
+      expect(component.find('#deprecate-version').exists()).toBe(true)
+    })
+
+    it('renders with packageName and version', async () => {
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'my-pkg', version: '2.0.0' },
+        ...mountOptions,
+      })
+
+      const versionInput = component.find('#deprecate-version')
+      expect(versionInput.exists()).toBe(true)
+      expect((versionInput.element as HTMLInputElement).value).toBe('2.0.0')
+    })
+
+    it('shows already-deprecated message and no form when isAlreadyDeprecated is true', async () => {
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'my-pkg', version: '1.0.0', isAlreadyDeprecated: true },
+        ...mountOptions,
+      })
+
+      expect(component.find('#deprecate-message').exists()).toBe(false)
+      expect(component.find('#deprecate-version').exists()).toBe(false)
+      expect(component.html()).toMatch(/already deprecated|已废弃/i)
+    })
+  })
+
+  describe('exposed open() and close()', () => {
+    it('open() resets form state and calls showModal on inner Modal', async () => {
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg', version: '1.0.0' },
+        ...mountOptions,
+      })
+
+      const modalStub = component.findComponent({ name: 'ModalStub' })
+      expect(modalStub.exists()).toBe(true)
+      getVM(component).open?.()
+
+      expect(modalStub.vm.showModal).toHaveBeenCalled()
+      const vm = getVM(component)
+      expect(vm.deprecateMessage?.value ?? vm.deprecateMessage).toBe('')
+      expect(vm.deprecateVersion?.value ?? vm.deprecateVersion).toBe('1.0.0')
+      expect(vm.deprecateError?.value ?? vm.deprecateError).toBeNull()
+      expect(vm.deprecateSuccess?.value ?? vm.deprecateSuccess).toBe(false)
+    })
+
+    it('close() calls close on inner Modal', async () => {
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      const modalStub = component.findComponent({ name: 'ModalStub' })
+      getVM(component).close?.()
+
+      expect(modalStub.vm.close).toHaveBeenCalled()
+    })
+  })
+
+  describe('form state', () => {
+    it('deprecate button is disabled when message is empty', async () => {
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      const submitBtn = component.get('[data-testid="modal-stub"]')
+      expect(submitBtn.attributes('disabled')).toBeUndefined()
+    })
+
+    it('deprecate button is enabled when message is filled and connected', async () => {
+      mockIsConnected.value = true
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      await component.find('#deprecate-message').setValue('Deprecated, use foo instead')
+      await component.vm.$nextTick()
+
+      const submitBtn = component.get('[data-testid="modal-stub"]')
+      expect(submitBtn.attributes('disabled')).toBeUndefined()
+    })
+
+    it('handleDeprecate does nothing when not connected', async () => {
+      mockIsConnected.value = false
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      await component.find('#deprecate-message').setValue('message')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      expect(mockAddOperation).not.toHaveBeenCalled()
+    })
+
+    it('handleDeprecate does nothing when isAlreadyDeprecated is true', async () => {
+      mockIsConnected.value = true
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg', isAlreadyDeprecated: true },
+        ...mountOptions,
+      })
+
+      await getVM(component).handleDeprecate?.()
+
+      expect(mockAddOperation).not.toHaveBeenCalled()
+    })
+
+    it('handleDeprecate does nothing when message is empty', async () => {
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      await getVM(component).handleDeprecate?.()
+
+      expect(mockAddOperation).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('handleDeprecate flow', () => {
+    it('calls addOperation with correct params (no version)', async () => {
+      const op = createMockOperation({ status: 'completed' })
+      mockAddOperation.mockResolvedValue(op)
+      mockApproveOperation.mockResolvedValue(true)
+      mockExecuteOperations.mockResolvedValue({ success: true })
+      mockRefreshState.mockImplementation(() => {
+        mockState.value = { operations: [op] }
+        return Promise.resolve()
+      })
+
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'test-package' },
+        ...mountOptions,
+      })
+
+      await component.find('#deprecate-message').setValue('  use other-pkg  ')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      expect(mockAddOperation).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'package:deprecate',
+          params: { pkg: 'test-package', message: 'use other-pkg' },
+          description: 'Deprecate test-package',
+          command: 'npm deprecate test-package "use other-pkg"',
+        }),
+      )
+      expect(mockApproveOperation).toHaveBeenCalledWith('op-1')
+      expect(mockExecuteOperations).toHaveBeenCalled()
+      expect(mockRefreshState).toHaveBeenCalled()
+    })
+
+    it('calls addOperation with version when version is set', async () => {
+      const op = createMockOperation({
+        status: 'completed',
+        params: { pkg: 'pkg', message: 'msg', version: '1.0.0' },
+      })
+      mockAddOperation.mockResolvedValue(op)
+      mockApproveOperation.mockResolvedValue(true)
+      mockExecuteOperations.mockResolvedValue({ success: true })
+      mockRefreshState.mockImplementation(() => {
+        mockState.value = { operations: [op] }
+        return Promise.resolve()
+      })
+
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg', version: '1.0.0' },
+        ...mountOptions,
+      })
+
+      await component.find('#deprecate-message').setValue('deprecated')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      expect(mockAddOperation).toHaveBeenCalledWith(
+        expect.objectContaining({
+          params: expect.objectContaining({ pkg: 'pkg', message: 'deprecated', version: '1.0.0' }),
+          description: 'Deprecate pkg@1.0.0',
+          command: 'npm deprecate pkg@1.0.0 "deprecated"',
+        }),
+      )
+    })
+
+    it('shows success state when operation completes successfully', async () => {
+      const op = createMockOperation({ status: 'completed' })
+      mockAddOperation.mockResolvedValue(op)
+      mockApproveOperation.mockResolvedValue(true)
+      mockExecuteOperations.mockResolvedValue({ success: true })
+      mockRefreshState.mockImplementation(() => {
+        mockState.value = { operations: [op] }
+        return Promise.resolve()
+      })
+
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      await component.find('#deprecate-message').setValue('use other')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      await component.vm.$nextTick()
+      const success = getVM(component).deprecateSuccess?.value ?? getVM(component).deprecateSuccess
+      expect(success).toBe(true)
+      expect(component.html()).toMatch(/Package deprecated|deprecated/i)
+    })
+
+    it('shows error when operation fails without requiresOtp', async () => {
+      const op = createMockOperation({
+        status: 'failed',
+        result: { stdout: '', stderr: 'EPERM', exitCode: 1 },
+      })
+      mockAddOperation.mockResolvedValue(op)
+      mockApproveOperation.mockResolvedValue(true)
+      mockExecuteOperations.mockResolvedValue({ success: true })
+      mockRefreshState.mockImplementation(() => {
+        mockState.value = { operations: [op] }
+        return Promise.resolve()
+      })
+
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      await component.find('#deprecate-message').setValue('msg')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      await component.vm.$nextTick()
+      const vm = getVM(component)
+      expect(vm.deprecateError?.value ?? vm.deprecateError).toBe('EPERM')
+      expect(vm.deprecateSuccess?.value ?? vm.deprecateSuccess).toBe(false)
+    })
+
+    it('closes modal and opens connector when operation fails with requiresOtp', async () => {
+      const op = createMockOperation({
+        status: 'failed',
+        result: { stdout: '', stderr: '', exitCode: 1, requiresOtp: true },
+      })
+      mockAddOperation.mockResolvedValue(op)
+      mockApproveOperation.mockResolvedValue(true)
+      mockExecuteOperations.mockResolvedValue({ success: true })
+      mockRefreshState.mockImplementation(() => {
+        mockState.value = { operations: [op] }
+        return Promise.resolve()
+      })
+
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+      const modalStub = component.findComponent({ name: 'ModalStub' })
+
+      await component.find('#deprecate-message').setValue('msg')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      await component.vm.$nextTick()
+      expect(modalStub.vm.close).toHaveBeenCalled()
+      expect(mockConnectorModalOpen).toHaveBeenCalled()
+    })
+
+    it('closes modal and opens connector when operation is not completed', async () => {
+      const op = createMockOperation({ status: 'pending' })
+      mockAddOperation.mockResolvedValue(op)
+      mockApproveOperation.mockResolvedValue(true)
+      mockExecuteOperations.mockResolvedValue({ success: true })
+      mockRefreshState.mockImplementation(() => {
+        mockState.value = { operations: [op] }
+        return Promise.resolve()
+      })
+
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+      const modalStub = component.findComponent({ name: 'ModalStub' })
+
+      await component.find('#deprecate-message').setValue('msg')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      await component.vm.$nextTick()
+      expect(modalStub.vm.close).toHaveBeenCalled()
+      expect(mockConnectorModalOpen).toHaveBeenCalled()
+    })
+
+    it('sets deprecateError when addOperation throws', async () => {
+      mockAddOperation.mockRejectedValue(new Error('Network error'))
+
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      await component.find('#deprecate-message').setValue('msg')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      await component.vm.$nextTick()
+      expect(getVM(component).deprecateError?.value ?? getVM(component).deprecateError).toBe(
+        'Network error',
+      )
+    })
+
+    it('escapes double quotes in command', async () => {
+      const op = createMockOperation({ status: 'completed' })
+      mockAddOperation.mockResolvedValue(op)
+      mockApproveOperation.mockResolvedValue(true)
+      mockExecuteOperations.mockResolvedValue({ success: true })
+      mockRefreshState.mockImplementation(() => {
+        mockState.value = { operations: [op] }
+        return Promise.resolve()
+      })
+
+      const component = await mountSuspended(DeprecatePackageModal, {
+        props: { packageName: 'pkg' },
+        ...mountOptions,
+      })
+
+      await component.find('#deprecate-message').setValue('say "hello"')
+      await component.vm.$nextTick()
+      await getVM(component).handleDeprecate?.()
+
+      expect(mockAddOperation).toHaveBeenCalledWith(
+        expect.objectContaining({
+          command: 'npm deprecate pkg "say \\"hello\\""',
+        }),
+      )
+    })
+  })
+})