fix

src/lib/components/Piclets/PicletDetail.svelte

@@ -18,7 +18,6 @@
   let { instance, onClose, onDeleted }: Props = $props();
   let showDeleteConfirm = $state(false);
   let selectedTab = $state<'about' | 'stats' | 'abilities' | 'moves'>('about');
-  let expandedMoves = $state(new Set<number>());
   let isSharing = $state(false);
   
   // Convert to battle definition to get enhanced ability data
@@ -59,14 +58,6 @@
     return '#34c759';
   }
   
-  function toggleMoveExpanded(index: number) {
-    if (expandedMoves.has(index)) {
-      expandedMoves.delete(index);
-    } else {
-      expandedMoves.add(index);
-    }
-    expandedMoves = new Set(expandedMoves);
-  }
   
   async function handleShare() {
     isSharing = true;
@@ -217,15 +208,10 @@
           <div class="content-card">
             <div class="moves-list">
               {#each instance.moves as move, index}
-                <button 
-                  class="move-item"
-                  onclick={() => toggleMoveExpanded(index)}
-                >
-                  <MoveDisplay 
-                    {move}
-                    expanded={expandedMoves.has(index)}
-                  />
-                </button>
+                <MoveDisplay 
+                  {move}
+                  expanded={true}
+                />
               {/each}
             </div>
           </div>

src/lib/db/piclets.ts

@@ -2,7 +2,6 @@ import { db } from './index';
 import type { PicletInstance, Monster, BattleMove } from './schema';
 import { PicletType, AttackType, getTypeFromConcept } from '../types/picletTypes';
 import type { PicletStats } from '../types';
-import { Nature } from '../types';
 
 // Convert a generated Monster to a PicletInstance
 export async function monsterToPicletInstance(monster: Monster, level: number = 5): Promise<Omit<PicletInstance, 'id'>> {
@@ -10,98 +9,39 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     throw new Error('Monster must have stats to create PicletInstance');
   }
 
-  // Check if this is a new battle-ready monster or legacy format
-  const isBattleReady = 'baseStats' in monster.stats;
+  // All monsters must now have the battle-ready format
+  const stats = monster.stats as PicletStats;
   
-  let baseHp: number, baseAttack: number, baseDefense: number, baseSpeed: number;
-  let moves: BattleMove[];
-  let primaryType: PicletType;
-  let tier: string;
+  if (!stats.baseStats || !stats.specialAbility || !stats.movepool) {
+    throw new Error('Monster stats must be in battle-ready format with baseStats, specialAbility, and movepool');
+  }
   
-  if (isBattleReady) {
-    const stats = monster.stats as PicletStats;
-    
-    // Calculate base stats from battle-ready format
-    baseHp = Math.floor(stats.baseStats.hp * 2 + 50);
-    baseAttack = Math.floor(stats.baseStats.attack * 1.5 + 30);
-    baseDefense = Math.floor(stats.baseStats.defense * 1.5 + 30);
-    baseSpeed = Math.floor(stats.baseStats.speed * 1.5 + 30);
-    
-    // Determine primary type from battle stats
-    const normalizedType = stats.primaryType.toLowerCase();
-    const validType = Object.values(PicletType).find(type => type === normalizedType);
-    primaryType = validType || getTypeFromConcept(monster.concept, monster.imageCaption);
-    
-    if (!validType) {
-      console.warn(`Invalid primaryType "${stats.primaryType}" from stats, falling back to concept detection`);
-    }
-    
-    // Create moves from battle-ready format
-    moves = stats.movepool.map(move => ({
-      name: move.name,
-      type: move.type as unknown as AttackType,
-      power: move.power,
-      accuracy: move.accuracy,
-      pp: move.pp,
-      currentPp: move.pp,
-      description: `${move.effects.length} effects` // Simplified description for now
-    }));
-    
-    tier = stats.tier;
-  } else {
-    // Legacy format
-    const legacyStats = monster.stats as any;
-    baseHp = Math.floor(legacyStats.HP * 2 + 50);
-    baseAttack = Math.floor(legacyStats.attack * 1.5 + 30);
-    baseDefense = Math.floor(legacyStats.defence * 1.5 + 30);
-    baseSpeed = Math.floor(legacyStats.speed * 1.5 + 30);
-    
-    // Auto-detect type for legacy monsters
-    primaryType = getTypeFromConcept(monster.concept, monster.imageCaption);
-    
-    // Create legacy moves
-    moves = [
-      {
-        name: legacyStats.attackActionName,
-        type: primaryType as unknown as AttackType,
-        power: 50,
-        accuracy: 95,
-        pp: 20,
-        currentPp: 20,
-        description: legacyStats.attackActionDescription
-      },
-      {
-        name: legacyStats.buffActionName,
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 100,
-        pp: 15,
-        currentPp: 15,
-        description: legacyStats.buffActionDescription
-      },
-      {
-        name: legacyStats.debuffActionName,
-        type: AttackType.NORMAL,
-        power: 0,
-        accuracy: 85,
-        pp: 15,
-        currentPp: 15,
-        description: legacyStats.debuffActionDescription
-      },
-      {
-        name: legacyStats.specialActionName,
-        type: primaryType as unknown as AttackType,
-        power: 80,
-        accuracy: 90,
-        pp: 5,
-        currentPp: 5,
-        description: legacyStats.specialActionDescription
-      }
-    ];
-    
-    tier = legacyStats.tier || 'medium';
+  // Calculate base stats from battle-ready format
+  const baseHp = Math.floor(stats.baseStats.hp * 2 + 50);
+  const baseAttack = Math.floor(stats.baseStats.attack * 1.5 + 30);
+  const baseDefense = Math.floor(stats.baseStats.defense * 1.5 + 30);
+  const baseSpeed = Math.floor(stats.baseStats.speed * 1.5 + 30);
+  
+  // Determine primary type from battle stats
+  const normalizedType = stats.primaryType.toLowerCase();
+  const validType = Object.values(PicletType).find(type => type === normalizedType);
+  const primaryType = validType || getTypeFromConcept(monster.concept, monster.imageCaption);
+  
+  if (!validType) {
+    console.warn(`Invalid primaryType "${stats.primaryType}" from stats, falling back to concept detection`);
   }
   
+  // Create moves from battle-ready format
+  const moves: BattleMove[] = stats.movepool.map(move => ({
+    name: move.name,
+    type: move.type as unknown as AttackType,
+    power: move.power,
+    accuracy: move.accuracy,
+    pp: move.pp,
+    currentPp: move.pp,
+    description: `${move.effects?.length || 0} effects` // Show number of effects
+  }));
+  
   // Field stats are variations of regular stats
   const baseFieldAttack = Math.floor(baseAttack * 0.8);
   const baseFieldDefense = Math.floor(baseDefense * 0.8);
@@ -143,7 +83,8 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     
     // Battle
     moves,
-    nature: Nature.HARDY, // Default nature
+    nature: stats.nature,
+    specialAbility: stats.specialAbility,
     
     // Roster
     isInRoster: false,
@@ -152,7 +93,7 @@ export async function monsterToPicletInstance(monster: Monster, level: number =
     // Metadata
     caughtAt: new Date(),
     bst,
-    tier: tier, // Use tier from stats
+    tier: stats.tier, // Use tier from stats
     role: 'balanced', // Could be enhanced based on stat distribution
     variance: 0,
     

src/lib/db/schema.ts

@@ -1,4 +1,5 @@
 import type { PicletType, AttackType } from '../types/picletTypes';
+import type { SpecialAbility } from '../battle-engine/types';
 
 // Enums
 export enum EncounterType {
@@ -51,6 +52,7 @@ export interface PicletInstance {
   // Battle
   moves: BattleMove[];
   nature: string;
+  specialAbility: SpecialAbility;
   
   // Roster
   isInRoster: boolean;
@@ -133,7 +135,7 @@ export interface BattleState {
   capturedPiclet?: PicletInstance;
 }
 
-// Legacy Monster interface for backward compatibility
+// Monster interface - now only supports battle-ready format
 export interface Monster {
   id?: number;
   name: string;
@@ -142,23 +144,6 @@ export interface Monster {
   imageCaption: string;
   concept: string;
   imagePrompt: string;
-  stats?: {
-    name: string;
-    description: string;
-    tier?: 'low' | 'medium' | 'high' | 'legendary';
-    HP: number;
-    defence: number;
-    attack: number;
-    speed: number;
-    specialPassiveTrait: string;
-    attackActionName: string;
-    attackActionDescription: string;
-    buffActionName: string;
-    buffActionDescription: string;
-    debuffActionName: string;
-    debuffActionDescription: string;
-    specialActionName: string;
-    specialActionDescription: string;
-  };
+  stats?: import('../types').PicletStats; // Only battle-ready format
   createdAt: Date;
 }

src/lib/utils/battleConversion.ts

@@ -22,20 +22,8 @@ export function picletInstanceToBattleDefinition(instance: PicletInstance): Picl
   // Convert simple moves to full battle moves
   const movepool: Move[] = instance.moves.map(move => convertBattleMoveToMove(move, instance.primaryType));
 
-  // Create a basic special ability if none exists
-  const specialAbility: SpecialAbility = {
-    name: "Adaptive",
-    description: "A basic ability that adapts to combat situations",
-    triggers: [{
-      event: "endOfTurn",
-      effects: [{
-        type: 'heal',
-        target: 'self',
-        amount: 'small',
-        condition: 'ifLowHp'
-      }]
-    }]
-  };
+  // Use the actual special ability data from the instance
+  const specialAbility: SpecialAbility = instance.specialAbility;
 
   // Determine tier based on BST (Base Stat Total)
   const bst = baseStats.hp + baseStats.attack + baseStats.defense + baseStats.speed;