@2025-6-19/clawfight 1.3.0 → 1.5.0

package/dist/index.js

@@ -148,6 +148,29 @@ ${archetype.values}
 }
 
 // src/lib/types.ts
+var EQUIP_RARITY_WEIGHTS = {
+  common: 60,
+  rare: 25,
+  epic: 12,
+  legendary: 3
+};
+var EQUIP_RARITY_LABELS = {
+  common: "\u666E\u901A",
+  rare: "\u7A00\u6709",
+  epic: "\u53F2\u8BD7",
+  legendary: "\u4F20\u8BF4"
+};
+var SLOT_LABELS = {
+  claw: "\u94B3",
+  shell: "\u58F3",
+  charm: "\u9970"
+};
+var SLOT_ICONS = {
+  claw: "\u2694\uFE0F",
+  shell: "\u{1F6E1}\uFE0F",
+  charm: "\u{1F48E}"
+};
+var MAX_INVENTORY = 6;
 var RARITY_WEIGHTS = {
   common: 70,
   calico: 20,
@@ -238,7 +261,128 @@ var zh = {
   wake_no_bonus: "\uFF08\u4F11\u7720\u4E0D\u8DB3 4 \u5C0F\u65F6\uFF0C\u65E0\u52A0\u6210\uFF09",
   wake_ready: "\u{1F7E2} {name} \u7CBE\u795E\u7115\u53D1\uFF0C\u51C6\u5907\u597D\u518D\u6B21\u51FA\u51FB\uFF01",
   duration_minutes: "{n} \u5206\u949F",
-  duration_hours: "{n} \u5C0F\u65F6"
+  duration_hours: "{n} \u5C0F\u65F6",
+  depth_display: "\u6DF1\u5EA6:{depth}",
+  soul_trait: "   \u6027\u683C\u7279\u8D28: [{trait}]",
+  equip_drop: "\u{1F381} \u83B7\u5F97: {item}",
+  auto_equip: "\u{1F99E} {name}\uFF08{reason}\uFF09\u2192 \u81EA\u52A8\u88C5\u5907 {item}",
+  auto_swap: "\u{1F99E} {name}\uFF08{reason}\uFF09\u2192 \u6362\u4E0B {old}\uFF0C\u88C5\u5907 {item}",
+  auto_discard: "\u{1F99E} {name} \u4E22\u5F03\u4E86 {item}\uFF08{reason}\uFF09",
+  equip_degrade: "\u{1F527} \u78E8\u635F: {items}",
+  equip_broken: "\u{1F4A5} \u635F\u574F: {items}",
+  equip_inv_full: "\u{1F4E6} \u80CC\u5305\u5DF2\u6EE1({max})\uFF0C\u4E22\u5F03\u4E86 {item}",
+  equip_title: "\u{1F392} \u88C5\u5907\u7BA1\u7406",
+  equip_slot_empty: "   {icon} {slot}: (\u7A7A)",
+  equip_slot_item: "   {icon} {slot}: {item}",
+  equip_inv_title: "\u{1F4E6} \u80CC\u5305 ({count}/{max}):",
+  equip_inv_item: "   [{index}] {item}",
+  equip_inv_empty: "   (\u7A7A)",
+  equip_equipped: "\u2705 \u5DF2\u88C5\u5907 {item} \u2192 {slot}",
+  equip_swapped: "\u{1F504} \u66FF\u6362 {old} \u2192 {item}",
+  equip_dropped: "\u{1F5D1}\uFE0F  \u5DF2\u4E22\u5F03 {item}",
+  equip_unequipped: "\u{1F4E4} \u5DF2\u5378\u4E0B {item}",
+  equip_bad_index: "\u26A0\uFE0F  \u65E0\u6548\u7F16\u53F7\u3002\u67E5\u770B\u80CC\u5305: npx clawfight equip",
+  equip_usage: "\u7528\u6CD5: equip / equip <\u7F16\u53F7> / equip drop <\u7F16\u53F7> / equip unequip <\u69FD\u4F4D>",
+  achieve_unlock: "\u{1F3C6} \u6210\u5C31\u89E3\u9501: {name} \u2014 {desc}",
+  achieve_title: "\u{1F3C6} \u6210\u5C31 ({count}/{total}):",
+  achieve_item: "   \u2705 {name} \u2014 {desc}",
+  achieve_locked: "   \u{1F512} {name} \u2014 {desc}",
+  achieve_none: "   \u8FD8\u6CA1\u6709\u89E3\u9501\u4EFB\u4F55\u6210\u5C31\u3002\u7EE7\u7EED\u5192\u9669\u5427\uFF01",
+  patrol_depth: "\u{1F4CA} Lv.{level} | EXP:{exp}/{next} | \u4ECA\u65E5:{today}/{cap} | \u6DF1\u5EA6:{depth} | \u80CC\u5305:{inv}/{inv_max}",
+  depth_reset: "\u{1F4A4} \u6DF1\u5EA6\u5DF2\u91CD\u7F6E",
+  dg_connecting: "\u{1F4E1} \u8FDE\u63A5\u5730\u4E0B\u57CE\u670D\u52A1\u5668...",
+  dg_resume: "\u{1F3F0} \u68C0\u6D4B\u5230\u8FDB\u884C\u4E2D\u7684\u5730\u4E0B\u57CE\u63A2\u7D22\uFF1A",
+  dg_no_maps: "\u{1F5FA}\uFE0F  \u6CA1\u6709\u5730\u4E0B\u57CE\u5730\u56FE\u3002\u7EE7\u7EED\u5DE1\u903B\u83B7\u53D6\u5730\u56FE\uFF01",
+  dg_bad_map_index: "\u26A0\uFE0F  \u65E0\u6548\u5730\u56FE\u7F16\u53F7\uFF08\u5171{count}\u5F20\uFF09",
+  dg_entering: "\u{1F3F0} \u8FDB\u5165\u5730\u4E0B\u57CE: {theme} | {rooms}\u623F\u95F4 | {diff}",
+  dg_no_active: "\u26A0\uFE0F  \u6CA1\u6709\u8FDB\u884C\u4E2D\u7684\u5730\u4E0B\u57CE\u3002\u5148\u7528 explore \u8FDB\u5165\u4E00\u4E2A\u3002",
+  dg_complete: "\u{1F389} \u5730\u4E0B\u57CE\u901A\u5173\uFF01",
+  dg_failed: "\u{1F480} \u5730\u4E0B\u57CE\u63A2\u7D22\u5931\u8D25\u2026HP\u5F52\u96F6",
+  dg_rewards_exp: "\u{1F4CA} \u5730\u4E0B\u57CE\u7ECF\u9A8C: +{exp}",
+  dg_abandoning: "\u{1F3F3}\uFE0F  \u653E\u5F03\u5730\u4E0B\u57CE\u63A2\u7D22...",
+  dg_abandoned: "\u{1F3F3}\uFE0F  \u5DF2\u64A4\u9000 | EXP+{exp} | \u6218\u5229\u54C1\xD7{loot} | \u6DF1\u5EA6\u2192{depth}",
+  dg_maps_title: "\u{1F5FA}\uFE0F  \u5730\u4E0B\u57CE\u5730\u56FE\uFF08{count}\u5F20\uFF09:",
+  dg_rooms: "\u623F\u95F4",
+  dg_maps_hint: "  \u{1F4A1} \u7528\u6CD5: explore <\u7F16\u53F7> \u8FDB\u5165 | explore maps \u67E5\u770B",
+  dg_map_found: "\u{1F5FA}\uFE0F  \u53D1\u73B0\u5730\u4E0B\u57CE\u5730\u56FE: {theme} ({rooms}\u623F\u95F4, {diff})",
+  dg_summary: "\u{1F4CA} Lv.{level} | EXP:{exp}/{next} | \u4ECA\u65E5:{today}/{cap}",
+  dg_theme_coral_maze: "\u73CA\u745A\u8FF7\u5BAB",
+  dg_theme_deep_rift: "\u6DF1\u6D77\u88C2\u9699",
+  dg_theme_thermal_vent: "\u70ED\u6CC9\u55B7\u53E3",
+  dg_theme_ice_cavern: "\u51B0\u6676\u6D1E\u7A74",
+  dg_theme_shipwreck: "\u6C89\u8239\u9057\u8FF9",
+  dg_theme_abyss_trench: "\u6DF1\u6E0A\u6D77\u6C9F",
+  dg_theme_tide_pool: "\u6F6E\u6C50\u6D45\u6EE9",
+  dg_theme_void_rift: "\u865A\u7A7A\u88C2\u7F1D",
+  dg_risk_low: "\u4F4E\u98CE\u9669",
+  dg_risk_mid: "\u4E2D\u98CE\u9669",
+  dg_risk_high: "\u9AD8\u98CE\u9669",
+  dg_diff_easy: "\u7B80\u5355",
+  dg_diff_normal: "\u666E\u901A",
+  dg_diff_hard: "\u56F0\u96BE",
+  dg_diff_nightmare: "\u5669\u68A6",
+  dg_charge_attack: "\u731B\u529B\u51B2\u51FB",
+  dg_defensive_stance: "\u9632\u5FA1\u59FF\u6001",
+  dg_rush_strike: "\u95EA\u7535\u7A81\u88AD",
+  dg_counter_wait: "\u4F3A\u673A\u53CD\u51FB",
+  dg_open_golden_chest: "\u6253\u5F00\u91D1\u8272\u5B9D\u7BB1",
+  dg_open_stone_chest: "\u6253\u5F00\u77F3\u8D28\u5B9D\u7BB1",
+  dg_reach_deep_cache: "\u63A2\u7D22\u6DF1\u5C42\u5B9D\u85CF",
+  dg_take_surface_loot: "\u62FE\u53D6\u8868\u5C42\u6218\u5229\u54C1",
+  dg_disarm_mechanism: "\u62C6\u89E3\u673A\u5173",
+  dg_dodge_through: "\u7075\u5DE7\u95EA\u907F",
+  dg_brute_force: "\u86EE\u529B\u7A81\u7834",
+  dg_careful_bypass: "\u5C0F\u5FC3\u7ED5\u884C",
+  dg_deep_rest: "\u6DF1\u5EA6\u4F11\u606F",
+  dg_search_hidden: "\u641C\u7D22\u9690\u85CF\u7269",
+  dg_investigate: "\u8C03\u67E5\u7EBF\u7D22",
+  dg_proceed_cautiously: "\u8C28\u614E\u524D\u884C",
+  dg_touch_artifact: "\u89E6\u78B0\u795E\u5668",
+  dg_observe_only: "\u4EC5\u89C2\u5BDF",
+  dg_all_out_assault: "\u5168\u529B\u8FDB\u653B",
+  dg_tactical_approach: "\u7B56\u7565\u63A5\u8FD1",
+  dg_bravery_bonus: "\u52C7\u6C14\u52A0\u6210: ATK+20%",
+  dg_curiosity_bonus: "\u597D\u5947\u5FC3\u52A0\u6210: \u53D1\u73B0\u7387\u2191",
+  dg_temper_bonus: "\u66B4\u6012\u52A0\u6210: \u62C6\u89E3\u529B\u2191",
+  dg_charge_attack_success: "\u731B\u529B\u51B2\u51FB\u547D\u4E2D\uFF01",
+  dg_charge_attack_fail: "\u731B\u529B\u51B2\u51FB\u843D\u7A7A\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_defensive_stance_success: "\u9632\u5FA1\u59FF\u6001\u6210\u529F\uFF01\u5B89\u5168\u5EA6\u8FC7",
+  dg_defensive_stance_fail: "\u9632\u5FA1\u59FF\u6001\u88AB\u7A81\u7834\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_rush_strike_success: "\u95EA\u7535\u7A81\u88AD\u5F97\u624B\uFF01",
+  dg_rush_strike_fail: "\u7A81\u88AD\u5931\u8D25\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_counter_wait_success: "\u53CD\u51FB\u6210\u529F\uFF01",
+  dg_counter_wait_fail: "\u53CD\u51FB\u65F6\u673A\u5931\u8BEF\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_open_golden_chest_success: "\u91D1\u8272\u5B9D\u7BB1\u5F00\u542F\uFF01\u5B9D\u7269\u95EA\u8000",
+  dg_open_golden_chest_fail: "\u9677\u9631\u89E6\u53D1\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_open_stone_chest_success: "\u77F3\u8D28\u5B9D\u7BB1\u5F00\u542F\uFF01\u83B7\u5F97\u7269\u54C1",
+  dg_open_stone_chest_fail: "\u5B9D\u7BB1\u662F\u7A7A\u7684...",
+  dg_reach_deep_cache_success: "\u53D1\u73B0\u6DF1\u5C42\u5B9D\u85CF\uFF01",
+  dg_reach_deep_cache_fail: "\u6DF1\u5C42\u641C\u7D22\u65E0\u679C",
+  dg_take_surface_loot_success: "\u62FE\u53D6\u8868\u5C42\u6218\u5229\u54C1\uFF01",
+  dg_take_surface_loot_fail: "\u4EC0\u4E48\u90FD\u6CA1\u627E\u5230",
+  dg_disarm_mechanism_success: "\u673A\u5173\u62C6\u89E3\u6210\u529F\uFF01",
+  dg_disarm_mechanism_fail: "\u673A\u5173\u89E6\u53D1\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_dodge_through_success: "\u7075\u5DE7\u5730\u95EA\u907F\u4E86\u673A\u5173\uFF01",
+  dg_dodge_through_fail: "\u95EA\u907F\u5931\u8D25\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_brute_force_success: "\u86EE\u529B\u7A81\u7834\u6210\u529F\uFF01",
+  dg_brute_force_fail: "\u86EE\u529B\u7A81\u7834\u5931\u8D25\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_careful_bypass_success: "\u5C0F\u5FC3\u7ED5\u884C\u6210\u529F\uFF01",
+  dg_careful_bypass_fail: "\u7ED5\u884C\u5931\u8D25\u2026",
+  dg_rest_healed: "\u4F11\u606F\u6062\u590D HP+{heal}",
+  dg_search_hidden_success: "\u641C\u7D22\u5230\u9690\u85CF\u7269\u54C1\uFF01",
+  dg_search_hidden_fail: "\u641C\u7D22\u672A\u679C",
+  dg_investigate_success: "\u8C03\u67E5\u53D1\u73B0\u4E86\u79D8\u5BC6\uFF01",
+  dg_investigate_fail: "\u8C03\u67E5\u65E0\u679C",
+  dg_proceed_cautiously_success: "\u8C28\u614E\u524D\u884C\uFF0C\u5B89\u5168\u901A\u8FC7",
+  dg_proceed_cautiously_fail: "\u610F\u5916\u906D\u9047\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_touch_artifact_success: "\u795E\u5668\u91CA\u653E\u4E86\u529B\u91CF\uFF01",
+  dg_touch_artifact_fail: "\u795E\u5668\u53CD\u566C\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_observe_only_success: "\u89C2\u5BDF\u5230\u4E86\u6709\u7528\u7684\u7EBF\u7D22",
+  dg_observe_only_fail: "\u4EC0\u4E48\u4E5F\u6CA1\u53D1\u73B0",
+  dg_all_out_assault_success: "\u5168\u529B\u8FDB\u653B\u594F\u6548\uFF01Boss\u53D7\u5230\u91CD\u521B",
+  dg_all_out_assault_fail: "Boss\u53CD\u51FB\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3",
+  dg_tactical_approach_success: "\u7B56\u7565\u63A5\u8FD1\u6210\u529F\uFF01\u627E\u5230\u5F31\u70B9",
+  dg_tactical_approach_fail: "Boss\u8BC6\u7834\u7B56\u7565\uFF01\u53D7\u5230{damage}\u70B9\u4F24\u5BB3"
 };
 var en = {
   no_lobster: "\u{1F95A} No lobster yet. Run npx clawfight hatch to hatch one!",
@@ -309,7 +453,128 @@ var en = {
   wake_no_bonus: "(Less than 4 hours, no bonus)",
   wake_ready: "\u{1F7E2} {name} is refreshed and ready to go!",
   duration_minutes: "{n} min",
-  duration_hours: "{n} hours"
+  duration_hours: "{n} hours",
+  depth_display: "Depth:{depth}",
+  soul_trait: "   Traits: [{trait}]",
+  equip_drop: "\u{1F381} Loot: {item}",
+  auto_equip: "\u{1F99E} {name} ({reason}) \u2192 auto-equipped {item}",
+  auto_swap: "\u{1F99E} {name} ({reason}) \u2192 swapped out {old} for {item}",
+  auto_discard: "\u{1F99E} {name} discarded {item} ({reason})",
+  equip_degrade: "\u{1F527} Worn: {items}",
+  equip_broken: "\u{1F4A5} Broken: {items}",
+  equip_inv_full: "\u{1F4E6} Inventory full({max}), discarded {item}",
+  equip_title: "\u{1F392} Equipment",
+  equip_slot_empty: "   {icon} {slot}: (empty)",
+  equip_slot_item: "   {icon} {slot}: {item}",
+  equip_inv_title: "\u{1F4E6} Inventory ({count}/{max}):",
+  equip_inv_item: "   [{index}] {item}",
+  equip_inv_empty: "   (empty)",
+  equip_equipped: "\u2705 Equipped {item} \u2192 {slot}",
+  equip_swapped: "\u{1F504} Swapped {old} \u2192 {item}",
+  equip_dropped: "\u{1F5D1}\uFE0F  Discarded {item}",
+  equip_unequipped: "\u{1F4E4} Unequipped {item}",
+  equip_bad_index: "\u26A0\uFE0F  Invalid index. Check: npx clawfight equip",
+  equip_usage: "Usage: equip / equip <index> / equip drop <index> / equip unequip <slot>",
+  achieve_unlock: "\u{1F3C6} Achievement: {name} \u2014 {desc}",
+  achieve_title: "\u{1F3C6} Achievements ({count}/{total}):",
+  achieve_item: "   \u2705 {name} \u2014 {desc}",
+  achieve_locked: "   \u{1F512} {name} \u2014 {desc}",
+  achieve_none: "   No achievements yet. Keep exploring!",
+  patrol_depth: "\u{1F4CA} Lv.{level} | EXP:{exp}/{next} | Today:{today}/{cap} | Depth:{depth} | Bag:{inv}/{inv_max}",
+  depth_reset: "\u{1F4A4} Depth reset",
+  dg_connecting: "\u{1F4E1} Connecting to dungeon server...",
+  dg_resume: "\u{1F3F0} Active dungeon detected:",
+  dg_no_maps: "\u{1F5FA}\uFE0F  No dungeon maps. Keep patrolling to find some!",
+  dg_bad_map_index: "\u26A0\uFE0F  Invalid map index (have {count})",
+  dg_entering: "\u{1F3F0} Entering dungeon: {theme} | {rooms} rooms | {diff}",
+  dg_no_active: "\u26A0\uFE0F  No active dungeon. Use explore to enter one.",
+  dg_complete: "\u{1F389} Dungeon cleared!",
+  dg_failed: "\u{1F480} Dungeon failed\u2026 HP reached zero",
+  dg_rewards_exp: "\u{1F4CA} Dungeon EXP: +{exp}",
+  dg_abandoning: "\u{1F3F3}\uFE0F  Abandoning dungeon...",
+  dg_abandoned: "\u{1F3F3}\uFE0F  Retreated | EXP+{exp} | Loot\xD7{loot} | Depth\u2192{depth}",
+  dg_maps_title: "\u{1F5FA}\uFE0F  Dungeon maps ({count}):",
+  dg_rooms: " rooms",
+  dg_maps_hint: "  \u{1F4A1} Usage: explore <index> to enter | explore maps to view",
+  dg_map_found: "\u{1F5FA}\uFE0F  Found dungeon map: {theme} ({rooms} rooms, {diff})",
+  dg_summary: "\u{1F4CA} Lv.{level} | EXP:{exp}/{next} | Today:{today}/{cap}",
+  dg_theme_coral_maze: "Coral Maze",
+  dg_theme_deep_rift: "Deep Rift",
+  dg_theme_thermal_vent: "Thermal Vent",
+  dg_theme_ice_cavern: "Ice Cavern",
+  dg_theme_shipwreck: "Shipwreck",
+  dg_theme_abyss_trench: "Abyss Trench",
+  dg_theme_tide_pool: "Tide Pool",
+  dg_theme_void_rift: "Void Rift",
+  dg_risk_low: "Low",
+  dg_risk_mid: "Mid",
+  dg_risk_high: "High",
+  dg_diff_easy: "Easy",
+  dg_diff_normal: "Normal",
+  dg_diff_hard: "Hard",
+  dg_diff_nightmare: "Nightmare",
+  dg_charge_attack: "Charge Attack",
+  dg_defensive_stance: "Defensive Stance",
+  dg_rush_strike: "Rush Strike",
+  dg_counter_wait: "Counter Wait",
+  dg_open_golden_chest: "Open Golden Chest",
+  dg_open_stone_chest: "Open Stone Chest",
+  dg_reach_deep_cache: "Reach Deep Cache",
+  dg_take_surface_loot: "Take Surface Loot",
+  dg_disarm_mechanism: "Disarm Mechanism",
+  dg_dodge_through: "Dodge Through",
+  dg_brute_force: "Brute Force",
+  dg_careful_bypass: "Careful Bypass",
+  dg_deep_rest: "Deep Rest",
+  dg_search_hidden: "Search Hidden",
+  dg_investigate: "Investigate",
+  dg_proceed_cautiously: "Proceed Cautiously",
+  dg_touch_artifact: "Touch Artifact",
+  dg_observe_only: "Observe Only",
+  dg_all_out_assault: "All-Out Assault",
+  dg_tactical_approach: "Tactical Approach",
+  dg_bravery_bonus: "Bravery bonus: ATK+20%",
+  dg_curiosity_bonus: "Curiosity bonus: Discovery\u2191",
+  dg_temper_bonus: "Temper bonus: Disarm\u2191",
+  dg_charge_attack_success: "Charge hit!",
+  dg_charge_attack_fail: "Charge missed! Took {damage} damage",
+  dg_defensive_stance_success: "Defense held!",
+  dg_defensive_stance_fail: "Defense breached! Took {damage} damage",
+  dg_rush_strike_success: "Rush strike landed!",
+  dg_rush_strike_fail: "Rush failed! Took {damage} damage",
+  dg_counter_wait_success: "Counter hit!",
+  dg_counter_wait_fail: "Counter mistimed! Took {damage} damage",
+  dg_open_golden_chest_success: "Golden chest opened! Treasure shines",
+  dg_open_golden_chest_fail: "Trap triggered! Took {damage} damage",
+  dg_open_stone_chest_success: "Stone chest opened! Item found",
+  dg_open_stone_chest_fail: "Chest was empty...",
+  dg_reach_deep_cache_success: "Deep cache found!",
+  dg_reach_deep_cache_fail: "Deep search failed",
+  dg_take_surface_loot_success: "Surface loot collected!",
+  dg_take_surface_loot_fail: "Nothing found",
+  dg_disarm_mechanism_success: "Mechanism disarmed!",
+  dg_disarm_mechanism_fail: "Trap triggered! Took {damage} damage",
+  dg_dodge_through_success: "Dodged through the trap!",
+  dg_dodge_through_fail: "Dodge failed! Took {damage} damage",
+  dg_brute_force_success: "Brute force worked!",
+  dg_brute_force_fail: "Brute force failed! Took {damage} damage",
+  dg_careful_bypass_success: "Bypassed safely!",
+  dg_careful_bypass_fail: "Bypass failed\u2026",
+  dg_rest_healed: "Rested. HP+{heal}",
+  dg_search_hidden_success: "Found hidden item!",
+  dg_search_hidden_fail: "Search found nothing",
+  dg_investigate_success: "Investigation uncovered a secret!",
+  dg_investigate_fail: "Investigation found nothing",
+  dg_proceed_cautiously_success: "Proceeded safely",
+  dg_proceed_cautiously_fail: "Unexpected encounter! Took {damage} damage",
+  dg_touch_artifact_success: "Artifact releases power!",
+  dg_touch_artifact_fail: "Artifact backlash! Took {damage} damage",
+  dg_observe_only_success: "Observed useful clue",
+  dg_observe_only_fail: "Nothing observed",
+  dg_all_out_assault_success: "All-out assault devastated the Boss!",
+  dg_all_out_assault_fail: "Boss counterattacked! Took {damage} damage",
+  dg_tactical_approach_success: "Tactical approach found weakness!",
+  dg_tactical_approach_fail: "Boss saw through the strategy! Took {damage} damage"
 };
 function detectLocale() {
   const lang = process.env.LANG || process.env.LANGUAGE || process.env.LC_ALL || "";
@@ -394,7 +659,15 @@ async function hatch(name) {
     last_patrol: "",
     last_battle: "",
     today_exp: 0,
-    daily_exp_cap: 100
+    daily_exp_cap: 100,
+    equipped: {},
+    inventory: [],
+    depth: 0,
+    achievements: [],
+    dungeon_maps: [],
+    dungeons_completed: 0,
+    boss_kills: 0,
+    dungeon_epics_found: 0
   };
   await writeLobster(lobster);
   const soulMd = buildSoulMarkdown(lobsterName, soul, rarity, "coastal");
@@ -419,6 +692,191 @@ async function hatch(name) {
   console.log(t("hatch_next"));
 }
 
+// src/lib/equipment.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var SLOT_STATS = {
+  claw: ["attack", "speed"],
+  shell: ["hp", "defense"],
+  charm: ["luck", "intimidation"]
+};
+var NAMES = {
+  claw: {
+    common: ["\u94C1\u94B3\u5957", "\u77F3\u523A\u94B3", "\u78E8\u7259\u5957"],
+    rare: ["\u73CA\u745A\u523A\u94B3", "\u9CA8\u9F7F\u5957", "\u950B\u5203\u94B3"],
+    epic: ["\u6DF1\u6D77\u952F\u9F7F", "\u96F7\u9706\u4E4B\u94B3", "\u9F99\u9AA8\u94B3"],
+    legendary: ["\u6BC1\u706D\u4E4B\u94B3", "\u6D77\u795E\u4E4B\u63E1", "\u6DF7\u6C8C\u88C2\u722A"]
+  },
+  shell: {
+    common: ["\u77F3\u7532\u58F3", "\u786C\u76AE\u7532", "\u6CE5\u6C99\u76FE"],
+    rare: ["\u73CA\u745A\u94E0", "\u6D77\u85FB\u7EC7\u7532", "\u8D1D\u58F3\u76FE"],
+    epic: ["\u73CD\u73E0\u9F99\u94E0", "\u6DF1\u6E0A\u58F3\u7532", "\u51B0\u6676\u7532"],
+    legendary: ["\u4E0D\u706D\u7532\u58F3", "\u6D77\u795E\u4E4B\u94E0", "\u8679\u5149\u94E0"]
+  },
+  charm: {
+    common: ["\u5C0F\u6D77\u661F", "\u788E\u8D1D\u58F3", "\u6D77\u8349\u7ED3"],
+    rare: ["\u9CA8\u7259\u94FE", "\u73CA\u745A\u5760", "\u6F6E\u6C50\u73E0"],
+    epic: ["\u6DF1\u6D77\u4E4B\u773C", "\u96F7\u66B4\u6838", "\u5E7B\u6D77\u73E0"],
+    legendary: ["\u6D77\u795E\u4E4B\u5FC3", "\u547D\u8FD0\u4E4B\u73E0", "\u6DF7\u6C8C\u4E4B\u773C"]
+  }
+};
+var RARITY_MUL = { common: 1, rare: 2, epic: 3, legendary: 5 };
+var RARITY_DUR = { common: 8, rare: 12, epic: 18, legendary: 30 };
+var RARITY_POWER = { common: 1, rare: 1.5, epic: 2, legendary: 3 };
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function rollRarity2(depth, soul) {
+  const w = { ...EQUIP_RARITY_WEIGHTS };
+  w.rare += depth * 3;
+  w.epic += depth * 1.5;
+  w.legendary += depth * 0.5;
+  if (soul.talkativeness <= 3) {
+    w.rare += 5;
+    w.epic += 3;
+    w.legendary += 1;
+  }
+  const total = Object.values(w).reduce((a, b) => a + b, 0);
+  let roll = Math.random() * total;
+  for (const [r, weight] of Object.entries(w)) {
+    roll -= weight;
+    if (roll <= 0) return r;
+  }
+  return "common";
+}
+function rollLevel(depth, soul) {
+  let lv = Math.floor(depth / 3) + 1;
+  if (soul.curiosity >= 7) lv++;
+  return Math.min(5, Math.max(1, lv));
+}
+function generateEquipment(depth, soul) {
+  const slot = pick(["claw", "shell", "charm"]);
+  const rarity = rollRarity2(depth, soul);
+  const level = rollLevel(depth, soul);
+  const mul = RARITY_MUL[rarity];
+  const levelMul = 1 + (level - 1) * 0.3;
+  const keys = SLOT_STATS[slot];
+  let dur = RARITY_DUR[rarity];
+  if (soul.bravery <= 3) dur += 2;
+  const bonuses = {};
+  for (const k of keys) {
+    bonuses[k] = Math.ceil(Math.random() * 2 * mul * levelMul);
+  }
+  const allStats = ["hp", "attack", "defense", "speed", "intimidation", "luck"];
+  if (Math.random() < 0.2 * mul) {
+    const extra = allStats.filter((s) => !keys.includes(s));
+    if (extra.length) bonuses[pick(extra)] = Math.ceil(Math.random() * mul * levelMul);
+  }
+  return {
+    id: randomUUID2().slice(0, 8),
+    name: pick(NAMES[slot][rarity]),
+    slot,
+    rarity,
+    level,
+    bonuses,
+    durability: dur,
+    max_durability: dur
+  };
+}
+function powerScore(e) {
+  const sum = Object.values(e.bonuses).reduce((a, b) => a + (b ?? 0), 0);
+  const lv = e.level ?? 1;
+  return sum * RARITY_POWER[e.rarity] * lv * (e.durability / e.max_durability);
+}
+function shouldDrop(depth, soul) {
+  let chance = Math.min(0.8, 0.25 + depth * 0.05);
+  if (soul.bravery >= 7) chance += 0.1;
+  if (soul.bravery <= 3) chance -= 0.1;
+  return Math.random() < Math.max(0.05, chance);
+}
+function depthPenalty(soul) {
+  if (soul.temper >= 7) return 3;
+  if (soul.bravery >= 7) return 1;
+  return 2;
+}
+function winExpMultiplier(soul) {
+  if (soul.temper >= 7) return 1.2;
+  return 1;
+}
+function autoManageLoot(lobster, loot) {
+  const actions = [];
+  if (!lobster.equipped) lobster.equipped = {};
+  if (!lobster.inventory) lobster.inventory = [];
+  const current = lobster.equipped[loot.slot];
+  const lootPower = powerScore(loot);
+  if (!current) {
+    lobster.equipped[loot.slot] = loot;
+    actions.push({ type: "auto_equip", item: loot, reason: slotReason(lobster.soul, loot.slot) });
+    return actions;
+  }
+  const currentPower = powerScore(current);
+  if (lootPower > currentPower) {
+    lobster.equipped[loot.slot] = loot;
+    if (lobster.inventory.length < MAX_INVENTORY) {
+      lobster.inventory.push(current);
+    }
+    actions.push({ type: "auto_swap", item: loot, old: current, reason: slotReason(lobster.soul, loot.slot) });
+    return actions;
+  }
+  if (lobster.inventory.length < MAX_INVENTORY) {
+    lobster.inventory.push(loot);
+    return actions;
+  }
+  let worstIdx = -1;
+  let worstScore = Infinity;
+  for (let i = 0; i < lobster.inventory.length; i++) {
+    const s = powerScore(lobster.inventory[i]);
+    if (s < worstScore) {
+      worstScore = s;
+      worstIdx = i;
+    }
+  }
+  if (worstIdx >= 0 && lootPower > worstScore) {
+    const discarded = lobster.inventory[worstIdx];
+    lobster.inventory[worstIdx] = loot;
+    actions.push({ type: "auto_discard", item: discarded, reason: "\u54C1\u8D28\u4E0D\u8DB3" });
+  } else {
+    actions.push({ type: "auto_discard", item: loot, reason: "\u54C1\u8D28\u4E0D\u8DB3" });
+  }
+  return actions;
+}
+function slotReason(soul, slot) {
+  if (slot === "claw" && soul.bravery >= 7) return "\u52C7\u731B\u672C\u80FD";
+  if (slot === "claw" && soul.temper >= 7) return "\u66B4\u8E81\u5929\u6027";
+  if (slot === "shell" && soul.bravery <= 3) return "\u8C28\u614E\u76F4\u89C9";
+  if (slot === "charm" && soul.curiosity >= 7) return "\u597D\u5947\u5FC3\u9A71\u4F7F";
+  return "\u81EA\u884C\u5224\u65AD";
+}
+function getEffectiveStats(lobster) {
+  const s = { ...lobster.stats };
+  if (!lobster.equipped) return s;
+  for (const eq of Object.values(lobster.equipped)) {
+    if (!eq || eq.durability <= 0) continue;
+    for (const [k, v] of Object.entries(eq.bonuses)) {
+      s[k] += v;
+    }
+  }
+  return s;
+}
+function degradeEquipment(lobster) {
+  const broken = [];
+  if (!lobster.equipped) return broken;
+  for (const [slot, eq] of Object.entries(lobster.equipped)) {
+    if (!eq) continue;
+    eq.durability--;
+    if (eq.durability <= 0) {
+      broken.push(eq.name);
+      delete lobster.equipped[slot];
+    }
+  }
+  return broken;
+}
+function formatEquip(e) {
+  const lv = (e.level ?? 1) > 1 ? `+${e.level}` : "";
+  const label = EQUIP_RARITY_LABELS[e.rarity] || e.rarity;
+  const b = Object.entries(e.bonuses).map(([k, v]) => `${k}+${v}`).join(" ");
+  return `[${label}${lv}] ${e.name} ${b} (${e.durability}/${e.max_durability})`;
+}
+
 // src/commands/status.ts
 function bar(current, max, width = 20) {
   const filled = Math.round(current / Math.max(max, 1) * width);
@@ -433,6 +891,7 @@ async function status() {
   const totalBattles = lobster.wins + lobster.losses;
   const winRate = totalBattles > 0 ? Math.round(lobster.wins / totalBattles * 100) : 0;
   const expPct = lobster.exp_to_next > 0 ? Math.round(lobster.exp / lobster.exp_to_next * 100) : 0;
+  const eff = getEffectiveStats(lobster);
   const statusEmoji = {
     active: "\u{1F7E2} \u6D3B\u8DC3",
     molting: "\u{1F7E1} \u8715\u58F3\u4E2D",
@@ -443,28 +902,54 @@ async function status() {
   console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
   console.log(`\u2502  \u7B49\u7EA7: Lv.${String(lobster.level).padEnd(5)} \u7A00\u6709\u5EA6: ${(RARITY_LABELS[lobster.rarity] || lobster.rarity).padEnd(15)}\u2502`);
   console.log(`\u2502  \u72B6\u6001: ${(statusEmoji[lobster.status] || lobster.status).padEnd(36)}\u2502`);
-  console.log(`\u2502  \u73AF\u5883: ${lobster.environment.padEnd(36)}\u2502`);
+  console.log(`\u2502  \u73AF\u5883: ${lobster.environment.padEnd(20)} \u6DF1\u5EA6: ${String(lobster.depth ?? 0).padEnd(13)}\u2502`);
   console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
   console.log(`\u2502  EXP: ${bar(lobster.exp, lobster.exp_to_next)} ${String(expPct).padStart(3)}%  \u2502`);
   console.log(`\u2502       ${String(lobster.exp).padStart(5)} / ${String(lobster.exp_to_next).padEnd(28)}\u2502`);
   console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
-  console.log(`\u2502  \u2764\uFE0F  HP:  ${String(lobster.stats.hp).padEnd(6)} \u2694\uFE0F  ATK: ${String(lobster.stats.attack).padEnd(15)}\u2502`);
-  console.log(`\u2502  \u{1F6E1}\uFE0F  DEF: ${String(lobster.stats.defense).padEnd(6)} \u{1F4A8} SPD: ${String(lobster.stats.speed).padEnd(15)}\u2502`);
-  console.log(`\u2502  \u{1F441}\uFE0F  INT: ${String(lobster.stats.intimidation).padEnd(6)} \u{1F340} LCK: ${String(lobster.stats.luck).padEnd(15)}\u2502`);
+  console.log(`\u2502  \u2764\uFE0F  HP:  ${String(eff.hp).padEnd(6)} \u2694\uFE0F  ATK: ${String(eff.attack).padEnd(15)}\u2502`);
+  console.log(`\u2502  \u{1F6E1}\uFE0F  DEF: ${String(eff.defense).padEnd(6)} \u{1F4A8} SPD: ${String(eff.speed).padEnd(15)}\u2502`);
+  console.log(`\u2502  \u{1F441}\uFE0F  INT: ${String(eff.intimidation).padEnd(6)} \u{1F340} LCK: ${String(eff.luck).padEnd(15)}\u2502`);
   console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
   console.log(`\u2502  \u6218\u7EE9: ${lobster.wins}\u80DC ${lobster.losses}\u8D1F (\u80DC\u7387${winRate}%)${" ".repeat(Math.max(0, 20 - String(lobster.wins).length - String(lobster.losses).length - String(winRate).length))}\u2502`);
   console.log(`\u2502  \u8FDE\u80DC: ${lobster.streak}  \u58F0\u671B: ${lobster.reputation}  \u5DE1\u903B: ${lobster.patrol_count}${" ".repeat(Math.max(0, 15 - String(lobster.streak).length - String(lobster.reputation).length - String(lobster.patrol_count).length))}\u2502`);
+  const slots = ["claw", "shell", "charm"];
+  const hasEquip = slots.some((s) => lobster.equipped?.[s]);
+  if (hasEquip) {
+    console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
+    for (const s of slots) {
+      const eq = lobster.equipped?.[s];
+      const label = `${SLOT_ICONS[s]} ${SLOT_LABELS[s]}`;
+      const lv = eq && (eq.level ?? 1) > 1 ? `+${eq.level}` : "";
+      const info = eq ? `${eq.name}${lv}(${eq.durability}/${eq.max_durability})` : "-";
+      console.log(`\u2502  ${label}: ${info.padEnd(36)}\u2502`);
+    }
+  }
+  const invCount = lobster.inventory?.length ?? 0;
+  if (invCount > 0) {
+    console.log(`\u2502  \u{1F4E6} \u80CC\u5305: ${invCount}/${MAX_INVENTORY}${" ".repeat(31 - String(invCount).length - String(MAX_INVENTORY).length)}\u2502`);
+  }
   console.log("\u251C" + "\u2500".repeat(44) + "\u2524");
   console.log(`\u2502  \u6027\u683C:                                     \u2502`);
   console.log(`\u2502    \u52C7\u6C14 ${lobster.soul.bravery}/10 | \u597D\u5947 ${lobster.soul.curiosity}/10 | \u8BDD\u91CF ${lobster.soul.talkativeness}/10 | \u813E\u6C14 ${lobster.soul.temper}/10  \u2502`);
+  const mapCount = lobster.dungeon_maps?.length ?? 0;
+  const dgCompleted = lobster.dungeons_completed ?? 0;
+  if (mapCount > 0 || dgCompleted > 0) {
+    console.log(`\u2502  \u{1F3F0} \u5730\u4E0B\u57CE: ${dgCompleted}\u901A\u5173  \u{1F5FA}\uFE0F \u5730\u56FE: ${mapCount}${" ".repeat(Math.max(0, 19 - String(dgCompleted).length - String(mapCount).length))}\u2502`);
+  }
+  if (lobster.active_dungeon) {
+    console.log(`\u2502  \u26A1 \u8FDB\u884C\u4E2D\u5730\u4E0B\u57CE: \u6709${" ".repeat(24)}\u2502`);
+  }
+  const achieveCount = lobster.achievements?.length ?? 0;
+  if (achieveCount > 0) {
+    console.log(`\u2502  \u{1F3C6} \u6210\u5C31: ${achieveCount}${" ".repeat(33 - String(achieveCount).length)}\u2502`);
+  }
   console.log("\u2514" + "\u2500".repeat(44) + "\u2518");
   console.log("\n" + t("status_battle_code", { code: lobster.id.slice(0, 8) }));
   const soulText = await readSoul();
   if (soulText) {
     const firstLine = soulText.split("\n").find((l) => l.trim() && !l.startsWith("#"));
-    if (firstLine) {
-      console.log(`\u{1F4DC} \u7075\u9B42: ${firstLine.trim().slice(0, 60)}`);
-    }
+    if (firstLine) console.log(`\u{1F4DC} \u7075\u9B42: ${firstLine.trim().slice(0, 60)}`);
   }
 }
 
@@ -472,7 +957,7 @@ async function status() {
 import { createHash } from "crypto";
 var API_BASE = "https://api.clawfight.online";
 function statsHash(lobster) {
-  const raw = JSON.stringify(lobster.stats);
+  const raw = JSON.stringify(getEffectiveStats(lobster));
   return createHash("sha256").update(raw).digest("hex");
 }
 function getProxyUrl() {
@@ -507,7 +992,7 @@ async function apiPatrol(lobster) {
         lobster_id: lobster.id,
         level: lobster.level,
         stats_hash: statsHash(lobster),
-        stats: lobster.stats,
+        stats: getEffectiveStats(lobster),
         environment: lobster.environment,
         name: lobster.name,
         color: lobster.rarity,
@@ -556,6 +1041,74 @@ async function apiLeaderboard(limit = 20) {
     return null;
   }
 }
+async function apiDungeonEnter(lobster, theme) {
+  try {
+    const pfetch = await getProxiedFetch();
+    const res = await pfetch(`${API_BASE}/api/dungeon/enter`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json; charset=utf-8" },
+      body: JSON.stringify({
+        lobster_id: lobster.id,
+        level: lobster.level,
+        stats: getEffectiveStats(lobster),
+        soul: lobster.soul,
+        depth: lobster.depth ?? 0,
+        environment: lobster.environment,
+        theme
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      const err = await res.json();
+      return { error: err.error };
+    }
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function apiDungeonAct(dungeonId, lobsterId, choice) {
+  try {
+    const pfetch = await getProxiedFetch();
+    const res = await pfetch(`${API_BASE}/api/dungeon/act`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json; charset=utf-8" },
+      body: JSON.stringify({ dungeon_id: dungeonId, lobster_id: lobsterId, choice }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function apiDungeonState(lobsterId) {
+  try {
+    const pfetch = await getProxiedFetch();
+    const res = await pfetch(`${API_BASE}/api/dungeon/state?lobster_id=${lobsterId}`, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function apiDungeonAbandon(lobsterId) {
+  try {
+    const pfetch = await getProxiedFetch();
+    const res = await pfetch(`${API_BASE}/api/dungeon/abandon`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json; charset=utf-8" },
+      body: JSON.stringify({ lobster_id: lobsterId }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
 
 // src/lib/events.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -595,11 +1148,11 @@ async function rollEvent(lobster) {
   });
   if (candidates.length === 0) return null;
   const totalWeight = candidates.reduce((s, c) => s + c.probability, 0);
-  let pick = Math.random() * totalWeight;
+  let pick2 = Math.random() * totalWeight;
   let chosen = null;
   for (const c of candidates) {
-    pick -= c.probability;
-    if (pick <= 0) {
+    pick2 -= c.probability;
+    if (pick2 <= 0) {
       chosen = c;
       break;
     }
@@ -630,6 +1183,43 @@ function applyEventEffects(lobster, effects) {
   return changes;
 }
 
+// src/lib/achievements.ts
+var ACHIEVEMENTS = {
+  first_blood: { name: "\u521D\u6218\u544A\u6377", desc: "\u8D62\u5F97\u9996\u80DC", check: (l) => l.wins >= 1 },
+  veteran: { name: "\u6C99\u573A\u8001\u5175", desc: "10\u80DC", check: (l) => l.wins >= 10 },
+  warlord: { name: "\u6DF1\u6D77\u6218\u795E", desc: "50\u80DC", check: (l) => l.wins >= 50 },
+  explorer: { name: "\u6D77\u57DF\u63A2\u7D22\u8005", desc: "20\u6B21\u5DE1\u903B", check: (l) => l.patrol_count >= 20 },
+  deep_diver: { name: "\u6DF1\u6F5C\u8005", desc: "\u6DF1\u5EA65", check: (l) => (l.depth ?? 0) >= 5 },
+  abyss_walker: { name: "\u6DF1\u6E0A\u884C\u8005", desc: "\u6DF1\u5EA610", check: (l) => (l.depth ?? 0) >= 10 },
+  fully_armed: { name: "\u5168\u526F\u6B66\u88C5", desc: "\u88C5\u5907\u6EE13\u69FD", check: (l) => {
+    if (!l.equipped) return false;
+    return !!(l.equipped.claw && l.equipped.shell && l.equipped.charm);
+  } },
+  survivor: { name: "\u767E\u6298\u4E0D\u6320", desc: "\u7D2F\u8BA110\u8D1F\u540E\u4ECD\u5728\u6218\u6597", check: (l) => l.losses >= 10 && l.wins > 0 },
+  streak_5: { name: "\u52BF\u4E0D\u53EF\u6321", desc: "5\u8FDE\u80DC", check: (l) => l.streak >= 5 },
+  streak_10: { name: "\u65E0\u4EBA\u80FD\u654C", desc: "10\u8FDE\u80DC", check: (l) => l.streak >= 10 },
+  high_level: { name: "\u738B\u8005\u9F99\u867E", desc: "\u8FBE\u523010\u7EA7", check: (l) => l.level >= 10 },
+  molt_master: { name: "\u8715\u53D8\u5927\u5E08", desc: "\u8715\u58F33\u6B21", check: (l) => l.molt_count >= 3 },
+  first_dungeon: { name: "\u521D\u63A2\u5730\u4E0B\u57CE", desc: "\u5B8C\u6210\u9996\u4E2A\u5730\u4E0B\u57CE", check: (l) => (l.dungeons_completed ?? 0) >= 1 },
+  dungeon_master: { name: "\u5730\u4E0B\u57CE\u4E4B\u738B", desc: "\u5B8C\u621010\u4E2A\u5730\u4E0B\u57CE", check: (l) => (l.dungeons_completed ?? 0) >= 10 },
+  boss_slayer: { name: "Boss\u730E\u624B", desc: "\u51FB\u8D25\u5730\u4E0B\u57CEBoss", check: (l) => (l.boss_kills ?? 0) >= 1 },
+  perfect_run: { name: "\u5B8C\u7F8E\u901A\u5173", desc: "\u6EE1HP\u901A\u5173\u5730\u4E0B\u57CE", check: () => false },
+  treasure_hunter: { name: "\u5BFB\u5B9D\u730E\u4EBA", desc: "\u5728\u5730\u4E0B\u57CE\u83B7\u5F975\u4EF6\u53F2\u8BD7+\u88C5\u5907", check: (l) => (l.dungeon_epics_found ?? 0) >= 5 }
+};
+function checkAchievements(lobster) {
+  const unlocked = [];
+  const existing = new Set(lobster.achievements ?? []);
+  for (const [id, def] of Object.entries(ACHIEVEMENTS)) {
+    if (existing.has(id)) continue;
+    if (def.check(lobster)) {
+      unlocked.push(id);
+      if (!lobster.achievements) lobster.achievements = [];
+      lobster.achievements.push(id);
+    }
+  }
+  return unlocked;
+}
+
 // src/commands/patrol.ts
 var PATROL_EXP = 15;
 async function patrol() {
@@ -648,10 +1238,12 @@ async function patrol() {
   }
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const lastDay = lobster.last_patrol ? lobster.last_patrol.split("T")[0] : "";
-  if (today !== lastDay) {
-    lobster.today_exp = 0;
-  }
-  console.log("\n" + t("patrol_start", { name: lobster.name }));
+  if (today !== lastDay) lobster.today_exp = 0;
+  const depth = lobster.depth ?? 0;
+  const soul = lobster.soul;
+  const trait = soulTag(soul);
+  console.log("\n" + t("patrol_start", { name: lobster.name }) + ` [${t("depth_display", { depth })}]`);
+  if (trait) console.log(t("soul_trait", { trait }));
   console.log("\u2500".repeat(40));
   const expGain = Math.min(PATROL_EXP, lobster.daily_exp_cap - lobster.today_exp);
   if (expGain > 0) {
@@ -665,9 +1257,7 @@ async function patrol() {
     console.log(t("event_prefix", { category: eventResult.event.category, id: eventResult.event.id }));
     console.log(`   ${eventResult.narrative}`);
     const changes = applyEventEffects(lobster, eventResult.event.effects);
-    if (changes.length > 0) {
-      console.log(t("event_effects", { changes: changes.join(", ") }));
-    }
+    if (changes.length > 0) console.log(t("event_effects", { changes: changes.join(", ") }));
     await appendLog(`\u{1F3B2} ${eventResult.event.id}: ${eventResult.narrative.slice(0, 60)}...`);
   }
   checkLevelUp(lobster);
@@ -691,8 +1281,12 @@ async function patrol() {
         lobster.losses++;
         lobster.streak = Math.min(0, lobster.streak) - 1;
         lobster.reputation = Math.max(0, lobster.reputation - 1);
+        const penalty = depthPenalty(soul);
+        lobster.depth = Math.max(0, (lobster.depth ?? 0) - penalty);
       }
-      const battleExp = Math.min(br.exp_gain, lobster.daily_exp_cap - lobster.today_exp);
+      let battleExp = br.exp_gain;
+      if (br.result === "win") battleExp = Math.floor(battleExp * winExpMultiplier(soul));
+      battleExp = Math.min(battleExp, lobster.daily_exp_cap - lobster.today_exp);
       if (battleExp > 0) {
         lobster.exp += battleExp;
         lobster.today_exp += battleExp;
@@ -700,6 +1294,8 @@ async function patrol() {
       lobster.last_battle = (/* @__PURE__ */ new Date()).toISOString();
       console.log(t("patrol_exp_stats", { exp: battleExp, wins: lobster.wins, losses: lobster.losses, streak: lobster.streak }));
       await appendLog(`\u2694\uFE0F VS ${opp.name}(Lv.${opp.level}) \u2192 ${br.result} (${br.rounds}R)`);
+      const broken = degradeEquipment(lobster);
+      if (broken.length) console.log(t("equip_broken", { items: broken.join(", ") }));
       checkLevelUp(lobster);
     } else if (serverResponse.encounter && serverResponse.opponent) {
       console.log(t("patrol_no_battle", { name: serverResponse.opponent.name, level: serverResponse.opponent.level }));
@@ -709,9 +1305,86 @@ async function patrol() {
   } else {
     console.log(t("patrol_offline"));
   }
+  lobster.depth = (lobster.depth ?? 0) + 1;
+  if (shouldDrop(depth, soul)) {
+    const loot = generateEquipment(depth, soul);
+    console.log(t("equip_drop", { item: formatEquip(loot) }));
+    await appendLog(`\u{1F381} ${loot.rarity}+${loot.level} ${loot.name}`);
+    const actions = autoManageLoot(lobster, loot);
+    for (const a of actions) {
+      switch (a.type) {
+        case "auto_equip":
+          console.log(t("auto_equip", { name: lobster.name, item: formatEquip(a.item), reason: a.reason }));
+          break;
+        case "auto_swap":
+          console.log(t("auto_swap", { name: lobster.name, item: formatEquip(a.item), old: a.old.name, reason: a.reason }));
+          break;
+        case "auto_discard":
+          console.log(t("auto_discard", { name: lobster.name, item: a.item.name, reason: a.reason }));
+          break;
+      }
+    }
+  }
+  if (shouldDropMap(lobster.depth ?? 0, lobster.soul)) {
+    const map = generateMap(lobster.depth ?? 0, lobster.environment);
+    if (!lobster.dungeon_maps) lobster.dungeon_maps = [];
+    if (lobster.dungeon_maps.length < 5) {
+      lobster.dungeon_maps.push(map);
+      console.log(t("dg_map_found", { theme: t(`dg_theme_${map.theme}`), rooms: map.rooms, diff: t(`dg_diff_${map.difficulty}`) }));
+      await appendLog(`\u{1F5FA}\uFE0F \u53D1\u73B0\u5730\u56FE: ${map.theme} (${map.rooms}\u623F\u95F4, ${map.difficulty})`);
+    }
+  }
+  const newAchievements = checkAchievements(lobster);
+  for (const id of newAchievements) {
+    const def = ACHIEVEMENTS[id];
+    console.log(t("achieve_unlock", { name: def.name, desc: def.desc }));
+  }
   await writeLobster(lobster);
   console.log("\u2500".repeat(40));
-  console.log(t("patrol_summary", { level: lobster.level, exp: lobster.exp, next: lobster.exp_to_next, today: lobster.today_exp, cap: lobster.daily_exp_cap }));
+  const inv = lobster.inventory?.length ?? 0;
+  console.log(t("patrol_depth", {
+    level: lobster.level,
+    exp: lobster.exp,
+    next: lobster.exp_to_next,
+    today: lobster.today_exp,
+    cap: lobster.daily_exp_cap,
+    depth: lobster.depth ?? 0,
+    inv,
+    inv_max: MAX_INVENTORY
+  }));
+}
+function soulTag(soul) {
+  const tags = [];
+  if (soul.bravery >= 7) tags.push("\u52C7\u731B");
+  if (soul.bravery <= 3) tags.push("\u8C28\u614E");
+  if (soul.curiosity >= 7) tags.push("\u535A\u5B66");
+  if (soul.curiosity <= 3) tags.push("\u4E13\u6CE8");
+  if (soul.talkativeness <= 3) tags.push("\u9690\u533F");
+  if (soul.temper >= 7) tags.push("\u66B4\u70C8");
+  if (soul.temper <= 3) tags.push("\u6C89\u7A33");
+  return tags.join("\xB7");
+}
+var ENV_THEMES = {
+  coastal: ["coral_maze", "shipwreck", "tide_pool"],
+  "deep-sea": ["deep_rift", "abyss_trench"],
+  "hot-spring": ["thermal_vent", "coral_maze"],
+  polar: ["ice_cavern", "deep_rift"],
+  space: ["void_rift", "abyss_trench"],
+  freshwater: ["tide_pool", "coral_maze"]
+};
+function shouldDropMap(depth, soul) {
+  let chance = Math.min(0.5, 0.1 + depth * 0.03);
+  if (soul.curiosity >= 7) chance += 0.1;
+  return Math.random() < chance;
+}
+function generateMap(depth, environment) {
+  const themes = ENV_THEMES[environment] || ENV_THEMES.coastal;
+  const theme = themes[Math.floor(Math.random() * themes.length)];
+  const rooms = Math.min(5, 3 + Math.floor(depth / 5));
+  const difficulties = ["easy", "normal", "hard", "nightmare"];
+  const di = Math.min(3, Math.floor(depth / 3));
+  const difficulty = difficulties[di];
+  return { theme, rooms, difficulty };
 }
 function checkLevelUp(lobster) {
   const l = lobster;
@@ -894,6 +1567,8 @@ async function rest() {
   }
   lobster.status = "hibernating";
   lobster.hibernated_at = (/* @__PURE__ */ new Date()).toISOString();
+  const hadDepth = lobster.depth && lobster.depth > 0;
+  if (hadDepth) lobster.depth = 0;
   await writeLobster(lobster);
   await appendLog(`\u{1F4A4} ${lobster.name} \u2192 hibernation`);
   console.log("\n" + "\u2500".repeat(40));
@@ -901,6 +1576,7 @@ async function rest() {
   console.log(t("rest_desc2"));
   console.log(t("rest_desc3"));
   console.log(t("rest_desc4"));
+  if (hadDepth) console.log(t("depth_reset"));
   console.log("\u2500".repeat(40));
   console.log("\n" + t("rest_wake_hint"));
 }
@@ -952,9 +1628,358 @@ async function wake() {
   console.log("\n" + t("wake_ready", { name: lobster.name }));
 }
 
+// src/commands/equip.ts
+var SLOTS = ["claw", "shell", "charm"];
+async function equip(action, arg) {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n" + t("no_lobster"));
+    return;
+  }
+  if (!lobster.equipped) lobster.equipped = {};
+  if (!lobster.inventory) lobster.inventory = [];
+  if (!action) {
+    console.log("\n" + t("equip_title"));
+    console.log("\u2500".repeat(40));
+    for (const s of SLOTS) {
+      const eq = lobster.equipped[s];
+      if (eq) {
+        console.log(t("equip_slot_item", { icon: SLOT_ICONS[s], slot: SLOT_LABELS[s], item: formatEquip(eq) }));
+      } else {
+        console.log(t("equip_slot_empty", { icon: SLOT_ICONS[s], slot: SLOT_LABELS[s] }));
+      }
+    }
+    console.log();
+    console.log(t("equip_inv_title", { count: lobster.inventory.length, max: MAX_INVENTORY }));
+    if (lobster.inventory.length === 0) {
+      console.log(t("equip_inv_empty"));
+    } else {
+      for (let i = 0; i < lobster.inventory.length; i++) {
+        console.log(t("equip_inv_item", { index: i + 1, item: formatEquip(lobster.inventory[i]) }));
+      }
+    }
+    console.log("\u2500".repeat(40));
+    console.log(t("equip_usage"));
+    return;
+  }
+  if (action === "drop") {
+    const idx2 = parseInt(arg || "", 10) - 1;
+    if (isNaN(idx2) || idx2 < 0 || idx2 >= lobster.inventory.length) {
+      console.log("\n" + t("equip_bad_index"));
+      return;
+    }
+    const removed = lobster.inventory.splice(idx2, 1)[0];
+    await writeLobster(lobster);
+    console.log("\n" + t("equip_dropped", { item: formatEquip(removed) }));
+    return;
+  }
+  if (action === "unequip") {
+    const slot = arg;
+    if (!slot || !SLOTS.includes(slot)) {
+      console.log("\n" + t("equip_bad_index"));
+      return;
+    }
+    const eq = lobster.equipped[slot];
+    if (!eq) {
+      console.log("\n" + t("equip_slot_empty", { icon: SLOT_ICONS[slot], slot: SLOT_LABELS[slot] }));
+      return;
+    }
+    if (lobster.inventory.length >= MAX_INVENTORY) {
+      console.log("\n" + t("equip_inv_full", { max: MAX_INVENTORY, item: eq.name }));
+      return;
+    }
+    lobster.inventory.push(eq);
+    delete lobster.equipped[slot];
+    await writeLobster(lobster);
+    console.log("\n" + t("equip_unequipped", { item: formatEquip(eq) }));
+    return;
+  }
+  const idx = parseInt(action, 10) - 1;
+  if (isNaN(idx) || idx < 0 || idx >= lobster.inventory.length) {
+    console.log("\n" + t("equip_bad_index"));
+    return;
+  }
+  const item = lobster.inventory[idx];
+  const existing = lobster.equipped[item.slot];
+  lobster.inventory.splice(idx, 1);
+  lobster.equipped[item.slot] = item;
+  if (existing) {
+    lobster.inventory.push(existing);
+    await writeLobster(lobster);
+    console.log("\n" + t("equip_swapped", { old: existing.name, item: formatEquip(item) }));
+  } else {
+    await writeLobster(lobster);
+    console.log("\n" + t("equip_equipped", { item: formatEquip(item), slot: SLOT_LABELS[item.slot] }));
+  }
+}
+
+// src/commands/achievements.ts
+async function achievements() {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n" + t("no_lobster"));
+    return;
+  }
+  const unlocked = new Set(lobster.achievements ?? []);
+  const total = Object.keys(ACHIEVEMENTS).length;
+  console.log("\n" + t("achieve_title", { count: unlocked.size, total }));
+  console.log("\u2500".repeat(40));
+  for (const [id, def] of Object.entries(ACHIEVEMENTS)) {
+    if (unlocked.has(id)) {
+      console.log(t("achieve_item", { name: def.name, desc: def.desc }));
+    } else {
+      console.log(t("achieve_locked", { name: def.name, desc: def.desc }));
+    }
+  }
+  console.log("\u2500".repeat(40));
+}
+
+// src/commands/explore.ts
+var RISK_ICON = { low: "\u{1F7E2}", mid: "\u{1F7E1}", high: "\u{1F534}" };
+var THEME_ICON = {
+  coral_maze: "\u{1FAB8}",
+  deep_rift: "\u{1F30A}",
+  thermal_vent: "\u{1F30B}",
+  ice_cavern: "\u2744\uFE0F",
+  shipwreck: "\u{1F6A2}",
+  abyss_trench: "\u{1F573}\uFE0F",
+  tide_pool: "\u{1F3D6}\uFE0F",
+  void_rift: "\u{1F300}"
+};
+function formatRoom(room, theme) {
+  const icon = THEME_ICON[theme] || "\u{1F3D4}\uFE0F";
+  const lines = [];
+  lines.push(`${icon} ${t(`dg_theme_${theme}`)} | ${room.index + 1}/${room.total} | HP:${room.hp.current}/${room.hp.max}`);
+  const c1 = room.choices[0];
+  const c2 = room.choices[1];
+  lines.push(`  [1] ${t(`dg_${c1.key}`)} (${c1.stat.toUpperCase()}, ${RISK_ICON[c1.risk]}${t(`dg_risk_${c1.risk}`)})  [2] ${t(`dg_${c2.key}`)} (${c2.stat.toUpperCase()}, ${RISK_ICON[c2.risk]}${t(`dg_risk_${c2.risk}`)})`);
+  if (c1.soul_hint) lines.push(`  \u{1F99E} ${t(`dg_${c1.soul_hint}`)}`);
+  if (c2.soul_hint) lines.push(`  \u{1F99E} ${t(`dg_${c2.soul_hint}`)}`);
+  return lines.join("\n");
+}
+function lootToEquipment(l) {
+  return { ...l, id: Math.random().toString(36).slice(2, 10) };
+}
+async function explore(action) {
+  const lobster = await readLobster();
+  if (!lobster) {
+    console.log("\n" + t("no_lobster"));
+    return;
+  }
+  if (lobster.status === "molting") {
+    console.log("\n" + t("status_cant_patrol_molt", { name: lobster.name }));
+    return;
+  }
+  if (lobster.status === "hibernating") {
+    console.log("\n" + t("status_cant_patrol_hibernate", { name: lobster.name }));
+    return;
+  }
+  if (action === "abandon") {
+    return await abandonDungeon(lobster);
+  }
+  if (action === "1" || action === "2") {
+    return await makeChoice(lobster, parseInt(action));
+  }
+  if (action === "maps") {
+    return showMaps(lobster);
+  }
+  return await enterOrResume(lobster, action);
+}
+async function enterOrResume(lobster, mapIndex) {
+  console.log("\n" + t("dg_connecting"));
+  const stateRes = await apiDungeonState(lobster.id);
+  if (!stateRes) {
+    console.log(t("patrol_offline"));
+    return;
+  }
+  if (stateRes.active && stateRes.room) {
+    console.log(t("dg_resume"));
+    console.log(formatRoom(stateRes.room, stateRes.theme));
+    return;
+  }
+  const maps = lobster.dungeon_maps || [];
+  if (maps.length === 0) {
+    console.log(t("dg_no_maps"));
+    return;
+  }
+  let idx = 0;
+  if (mapIndex && !isNaN(parseInt(mapIndex))) {
+    idx = parseInt(mapIndex) - 1;
+    if (idx < 0 || idx >= maps.length) {
+      console.log(t("dg_bad_map_index", { count: maps.length }));
+      return;
+    }
+  }
+  const map = maps[idx];
+  console.log(t("dg_entering", { theme: t(`dg_theme_${map.theme}`), rooms: map.rooms, diff: t(`dg_diff_${map.difficulty}`) }));
+  const res = await apiDungeonEnter(lobster, map.theme);
+  if (!res) {
+    console.log(t("patrol_offline"));
+    return;
+  }
+  if (res.error) {
+    console.log(`\u26A0\uFE0F  ${res.error}`);
+    return;
+  }
+  lobster.active_dungeon = res.dungeon_id;
+  maps.splice(idx, 1);
+  lobster.dungeon_maps = maps;
+  await writeLobster(lobster);
+  await appendLog(`\u{1F5FA}\uFE0F \u8FDB\u5165\u5730\u4E0B\u57CE: ${map.theme} (${map.rooms}\u623F\u95F4)`);
+  console.log("\u2500".repeat(40));
+  console.log(formatRoom(res.room, res.theme));
+}
+async function makeChoice(lobster, choice) {
+  if (!lobster.active_dungeon) {
+    console.log("\n" + t("dg_no_active"));
+    return;
+  }
+  console.log("");
+  const res = await apiDungeonAct(lobster.active_dungeon, lobster.id, choice);
+  if (!res) {
+    console.log(t("patrol_offline"));
+    return;
+  }
+  const o = res.outcome;
+  const icon = o.success ? "\u2705" : "\u274C";
+  console.log(`${icon} ${t(`dg_${o.key}`, { damage: o.damage_taken, heal: o.hp_healed })} | EXP+${o.exp_gained}`);
+  if (o.damage_taken > 0) console.log(`  \u{1F494} HP -${o.damage_taken} \u2192 ${res.hp.current}/${res.hp.max}`);
+  if (o.hp_healed > 0) console.log(`  \u{1F49A} HP +${o.hp_healed} \u2192 ${res.hp.current}/${res.hp.max}`);
+  if (o.soul_activated) console.log(`  \u{1F99E} ${t(`dg_${o.soul_activated}`)}`);
+  if (o.loot) {
+    const equip2 = lootToEquipment(o.loot);
+    console.log(`  ${t("equip_drop", { item: formatEquip(equip2) })}`);
+  }
+  if (res.status === "completed" || res.status === "failed") {
+    console.log("\u2500".repeat(40));
+    if (res.status === "completed") {
+      console.log(t("dg_complete"));
+      lobster.dungeons_completed = (lobster.dungeons_completed ?? 0) + 1;
+    } else {
+      console.log(t("dg_failed"));
+    }
+    if (res.rewards) {
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const lastDay = lobster.last_patrol ? lobster.last_patrol.split("T")[0] : "";
+      if (today !== lastDay) lobster.today_exp = 0;
+      const expGain = Math.min(res.rewards.total_exp, lobster.daily_exp_cap - lobster.today_exp);
+      if (expGain > 0) {
+        lobster.exp += expGain;
+        lobster.today_exp += expGain;
+      }
+      console.log(t("dg_rewards_exp", { exp: expGain }));
+      for (const loot of res.rewards.loot) {
+        const equip2 = lootToEquipment(loot);
+        console.log(`  ${t("equip_drop", { item: formatEquip(equip2) })}`);
+        if (loot.rarity === "epic" || loot.rarity === "legendary") {
+          lobster.dungeon_epics_found = (lobster.dungeon_epics_found ?? 0) + 1;
+        }
+        const actions = autoManageLoot(lobster, equip2);
+        for (const a of actions) {
+          if (a.type === "auto_equip") console.log(`  ${t("auto_equip", { name: lobster.name, item: formatEquip(a.item), reason: a.reason })}`);
+          else if (a.type === "auto_swap") console.log(`  ${t("auto_swap", { name: lobster.name, item: formatEquip(a.item), old: a.old.name, reason: a.reason })}`);
+          else if (a.type === "auto_discard") console.log(`  ${t("auto_discard", { name: lobster.name, item: a.item.name, reason: a.reason })}`);
+        }
+      }
+      checkLevelUp2(lobster);
+      for (const loot of res.rewards.loot) {
+        if (loot.rarity === "epic" || loot.rarity === "legendary") {
+          const room = res.rewards.loot.indexOf(loot);
+          if (room === res.rewards.loot.length - 1) {
+            lobster.boss_kills = (lobster.boss_kills ?? 0) + 1;
+          }
+        }
+      }
+      await appendLog(`\u{1F3F0} \u5730\u4E0B\u57CE${res.status === "completed" ? "\u901A\u5173" : "\u5931\u8D25"}: EXP+${expGain}, \u6218\u5229\u54C1\xD7${res.rewards.loot.length}`);
+    }
+    lobster.active_dungeon = void 0;
+    const newAch = checkAchievements(lobster);
+    for (const id of newAch) {
+      const def = ACHIEVEMENTS[id];
+      console.log(t("achieve_unlock", { name: def.name, desc: def.desc }));
+    }
+    await writeLobster(lobster);
+    console.log(t("dg_summary", {
+      level: lobster.level,
+      exp: lobster.exp,
+      next: lobster.exp_to_next,
+      today: lobster.today_exp,
+      cap: lobster.daily_exp_cap
+    }));
+    return;
+  }
+  if (res.next_room) {
+    console.log("\u2500".repeat(40));
+    const stateRes = await apiDungeonState(lobster.id);
+    const theme = stateRes?.theme || "";
+    console.log(formatRoom(res.next_room, theme));
+  }
+}
+async function abandonDungeon(lobster) {
+  if (!lobster.active_dungeon) {
+    console.log("\n" + t("dg_no_active"));
+    return;
+  }
+  console.log("\n" + t("dg_abandoning"));
+  const res = await apiDungeonAbandon(lobster.id);
+  if (!res) {
+    console.log(t("patrol_offline"));
+    return;
+  }
+  const expGain = Math.min(res.partial_exp, lobster.daily_exp_cap - lobster.today_exp);
+  if (expGain > 0) {
+    lobster.exp += expGain;
+    lobster.today_exp += expGain;
+  }
+  for (const loot of res.partial_loot) {
+    const equip2 = lootToEquipment(loot);
+    autoManageLoot(lobster, equip2);
+  }
+  lobster.active_dungeon = void 0;
+  const penalty = Math.max(0, (lobster.depth ?? 0) - 2);
+  lobster.depth = penalty;
+  await writeLobster(lobster);
+  await appendLog(`\u{1F3F0} \u653E\u5F03\u5730\u4E0B\u57CE: EXP+${expGain}, \u6DF1\u5EA6\u2192${lobster.depth}`);
+  console.log(t("dg_abandoned", { exp: expGain, loot: res.partial_loot.length, depth: lobster.depth }));
+}
+function showMaps(lobster) {
+  const maps = lobster.dungeon_maps || [];
+  if (maps.length === 0) {
+    console.log("\n" + t("dg_no_maps"));
+    return;
+  }
+  console.log("\n" + t("dg_maps_title", { count: maps.length }));
+  for (let i = 0; i < maps.length; i++) {
+    const m = maps[i];
+    const icon = THEME_ICON[m.theme] || "\u{1F3D4}\uFE0F";
+    console.log(`  [${i + 1}] ${icon} ${t(`dg_theme_${m.theme}`)} | ${m.rooms}${t("dg_rooms")} | ${t(`dg_diff_${m.difficulty}`)}`);
+  }
+  console.log(t("dg_maps_hint"));
+}
+function checkLevelUp2(lobster) {
+  while (lobster.exp >= lobster.exp_to_next) {
+    lobster.exp -= lobster.exp_to_next;
+    lobster.level++;
+    lobster.exp_to_next = calcExpToNext(lobster.level);
+    const statKeys = ["hp", "attack", "defense", "speed", "intimidation", "luck"];
+    const gains = [];
+    for (const key of statKeys) {
+      const gain = 1 + Math.floor(Math.random() * 3);
+      lobster.stats[key] += gain;
+      gains.push(`${key}+${gain}`);
+    }
+    console.log("\n" + t("level_up", { level: lobster.level, gains: gains.join(", ") }));
+    if (lobster.level % 5 === 0) {
+      console.log(t("molt_trigger"));
+      lobster.status = "molting";
+      lobster.molt_count++;
+    }
+  }
+}
+
 // src/index.ts
 var program = new Command();
-program.name("clawfight").description("\u{1F99E} ClawFight \u2014 \u9F99\u867E\u7535\u5B50\u5BA0\u7269\u5BF9\u6218").version("1.3.0");
+program.name("clawfight").description("\u{1F99E} ClawFight \u2014 \u9F99\u867E\u7535\u5B50\u5BA0\u7269\u5BF9\u6218").version("1.5.0");
 program.command("hatch").description("\u5B75\u5316\u4E00\u53EA\u65B0\u9F99\u867E").argument("[name]", "\u4E3A\u9F99\u867E\u53D6\u540D").action(async (name) => {
   await hatch(name);
 });
@@ -979,4 +2004,13 @@ program.command("rest").description("\u8FDB\u5165\u4F11\u7720\uFF08\u6682\u505C\
 program.command("wake").description("\u4ECE\u4F11\u7720\u4E2D\u5524\u9192\uFF08\u9644\u5E26\u6062\u590D\u52A0\u6210\uFF09").action(async () => {
   await wake();
 });
+program.command("equip").description("\u88C5\u5907\u7BA1\u7406\uFF08\u67E5\u770B/\u7A7F\u6234/\u5378\u4E0B/\u4E22\u5F03\uFF09").argument("[action]", "\u7F16\u53F7(\u88C5\u5907) / drop / unequip").argument("[arg]", "\u7F16\u53F7\u6216\u69FD\u4F4D(claw/shell/charm)").action(async (action, arg) => {
+  await equip(action, arg);
+});
+program.command("achievements").alias("ach").description("\u67E5\u770B\u6210\u5C31").action(async () => {
+  await achievements();
+});
+program.command("explore").alias("dg").description("\u5730\u4E0B\u57CE\u63A2\u7D22\uFF08\u8FDB\u5165/\u9009\u62E9/\u653E\u5F03/\u67E5\u770B\u5730\u56FE\uFF09").argument("[action]", "1|2(\u9009\u62E9) / abandon(\u653E\u5F03) / maps(\u67E5\u770B\u5730\u56FE) / \u5730\u56FE\u7F16\u53F7(\u8FDB\u5165)").action(async (action) => {
+  await explore(action);
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2025-6-19/clawfight",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "ClawFight — raise and battle a unique lobster pet with evolving soul 🦞",
   "author": "LIU",
   "license": "MIT",