@zodic/shared 0.0.372 → 0.0.374

package/app/services/ArchetypeService.ts

@@ -28,42 +28,42 @@ export class ArchetypeService {
     message: string,
     context: Record<string, any> = {}
   ) {
-    const logMessage = `[${level.toUpperCase()}] ${message}`;
-
-    console.log(logMessage, context);
-    // try {
-    //   await db
-    //     .insert(schema.logs)
-    //     .values({
-    //       id: logId,
-    //       level,
-    //       message,
-    //       context: JSON.stringify(context),
-    //       createdAt: new Date().getTime(),
-    //     })
-    //     .execute();
-    // } catch (error) {
-    //   console.error('[ERROR] Failed to persist log to database:', {
-    //     error,
-    //     logId,
-    //     message,
-    //     context,
-    //   });
-    // }
+    const logMessage = `[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}`;
+
+    console[level](logMessage, context);
   }
 
-  // Replace generateArchetypeNames and generateArchetypeNamesBatch
   async generateArchetypeNames(
     combinationString: string,
-    overrideExisting: boolean = false,
+    override: boolean = false,
     indexesToGenerate: number[] = [1, 2, 3]
   ) {
     await this.log('info', 'Starting generateArchetypeNames', {
       combinationString,
-      overrideExisting,
+      override,
       indexesToGenerate,
     });
 
+    const db = this.context.drizzle();
+    const existingArchetypes = await db
+      .select()
+      .from(schema.archetypesData)
+      .where(eq(schema.archetypesData.combination, combinationString))
+      .orderBy(schema.archetypesData.archetypeIndex)
+      .execute();
+
+    if (
+      !override &&
+      existingArchetypes.length >= 3 * 2 * 2 && // 3 indexes * 2 genders * 2 languages
+      existingArchetypes.every((a) => a.name && a.essenceLine)
+    ) {
+      await this.log('info', 'Skipping archetype names generation', {
+        reason: 'All archetypes have names and essence lines',
+        existingCount: existingArchetypes.length,
+      });
+      return;
+    }
+
     const [sun, ascendant, moon] = combinationString.split(
       '-'
     ) as ZodiacSignSlug[];
@@ -95,8 +95,6 @@ export class ArchetypeService {
       portugueseVariants,
     });
 
-    const db = this.context.drizzle();
-
     async function isEnglishNameDuplicate(name: string): Promise<boolean> {
       const result = await db
         .select({ name: schema.archetypesData.name })
@@ -121,7 +119,10 @@ export class ArchetypeService {
         await this.log(
           'debug',
           `Skipping index ${index} as it is not in indexesToGenerate`,
-          { index, indexesToGenerate }
+          {
+            index,
+            indexesToGenerate,
+          }
         );
         continue;
       }
@@ -134,7 +135,7 @@ export class ArchetypeService {
         continue;
       }
 
-      for (const gender of ['male', 'female']) {
+      for (const gender of ['male', 'female'] as Gender[]) {
         for (const lang of ['en-us', 'pt-br']) {
           const id = `${combinationString}:${gender}:${index}${
             lang === 'pt-br' ? ':pt' : ''
@@ -148,9 +149,22 @@ export class ArchetypeService {
           const essenceLine =
             lang === 'en-us' ? entry.essenceLine : ptVariant.essenceLine;
 
+          const existing = existingArchetypes.find((a) => a.id === id);
+          if (existing && !override && existing.name && existing.essenceLine) {
+            await this.log('debug', `Skipping existing archetype ${id}`, {
+              name: existing.name,
+              essenceLine: existing.essenceLine,
+              archetypeIndex: index,
+            });
+            continue;
+          }
+
           await this.log('debug', `Saving archetype name for ${id}`, {
             name,
             essenceLine,
+            archetypeIndex: index,
+            gender,
+            language: lang,
           });
 
           await db
@@ -171,6 +185,7 @@ export class ArchetypeService {
                 name,
                 essenceLine,
                 updatedAt: new Date().getTime(),
+                status: 'idle',
               },
             });
 
@@ -200,6 +215,13 @@ export class ArchetypeService {
       blocksCount: blocks.length,
     });
 
+    if (blocks.length !== 3) {
+      this.log('error', 'Expected exactly 3 archetype blocks', {
+        blocksCount: blocks.length,
+      });
+      throw new Error(`Expected 3 archetype blocks, got ${blocks.length}`);
+    }
+
     const english: Array<{ name: string; essenceLine: string }> = [];
     const portuguese: Array<{
       masc: string;
@@ -207,7 +229,7 @@ export class ArchetypeService {
       essenceLine: string;
     }> = [];
 
-    for (const block of blocks) {
+    blocks.forEach((block, index) => {
       const nameMatch = block.match(/- Name: (.+)/);
       const essenceLineMatch = block.match(/- Essence Line: (.+)/);
       const ptMascMatch = block.match(/- Portuguese \(Masc\): (.+)/);
@@ -230,10 +252,21 @@ export class ArchetypeService {
           fem: ptFemMatch[1].trim(),
           essenceLine: ptEssenceLineMatch[1].trim(),
         });
+        this.log('debug', `Parsed block for archetypeIndex ${index + 1}`, {
+          english: english[index],
+          portuguese: portuguese[index],
+        });
       } else {
-        this.log('warn', 'Malformed archetype name block', { block });
+        this.log(
+          'error',
+          `Malformed archetype name block for index ${index + 1}`,
+          { block }
+        );
+        throw new Error(
+          `Malformed archetype name block for index ${index + 1}`
+        );
       }
-    }
+    });
 
     this.log('info', 'Completed parseArchetypeNameBlocks', {
       english,
@@ -244,42 +277,82 @@ export class ArchetypeService {
 
   async generateDescriptionsAndVirtues(
     combinationString: string,
-    gender: Gender,
-    language: string
+    gender: Gender, // Used for compatibility, but processes both genders
+    language: string,
+    override: boolean = false
   ): Promise<ParsedDescriptionAndVirtues[]> {
     await this.log('info', 'Starting generateDescriptionsAndVirtues', {
       combinationString,
       gender,
       language,
+      override,
     });
 
     const db = this.context.drizzle();
-    const archetypes = await db
-      .select()
-      .from(schema.archetypesData)
-      .where(
-        and(
-          eq(schema.archetypesData.combination, combinationString),
-          eq(schema.archetypesData.gender, gender),
-          eq(schema.archetypesData.language, 'en-us')
+    const allGenders: Gender[] = ['male', 'female'];
+    const archetypesByGender: Record<Gender, any[]> = { male: [], female: [] };
+
+    for (const g of allGenders) {
+      const archetypes = await db
+        .select()
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.combination, combinationString),
+            eq(schema.archetypesData.gender, g),
+            eq(schema.archetypesData.language, language)
+          )
         )
-      )
-      .execute();
+        .orderBy(schema.archetypesData.archetypeIndex)
+        .execute();
+      archetypesByGender[g] = archetypes;
+    }
+
+    const needsGeneration = allGenders.some(
+      (g) =>
+        archetypesByGender[g].length !== 3 ||
+        archetypesByGender[g].some((a) => !a.description || a.virtues === '[]')
+    );
+
+    if (!override && !needsGeneration) {
+      await this.log('info', 'Skipping descriptions and virtues generation', {
+        reason: 'Descriptions and virtues already exist for all archetypes',
+      });
+      return archetypesByGender['male'].map((a, i) => ({
+        descriptionEN: a.description || '',
+        descriptionPTM: archetypesByGender['male'][i].description || '',
+        descriptionPTF: archetypesByGender['female'][i].description || '',
+        virtuesEN: JSON.parse(a.virtues || '[]'),
+        virtuesPT: JSON.parse(a.virtues || '[]'),
+      }));
+    }
 
     await this.log('info', 'Fetched archetypes for description generation', {
-      archetypesCount: archetypes.length,
-      names: archetypes.map((a) => a.name),
+      maleArchetypes: archetypesByGender['male'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
+      femaleArchetypes: archetypesByGender['female'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
     });
 
     const descVirtueMessages = this.context
       .buildLLMMessages()
       .generateCosmicMirrorDescriptionAndVirtues({
         combination: combinationString,
-        names: [archetypes[0].name, archetypes[1].name, archetypes[2].name],
-        essenceLines: [
-          archetypes[0].essenceLine,
-          archetypes[1].essenceLine,
-          archetypes[2].essenceLine,
+        names: archetypesByGender['male'].map((a) => a.name) as [
+          string,
+          string,
+          string
+        ],
+        essenceLines: archetypesByGender['male'].map((a) => a.essenceLine) as [
+          string,
+          string,
+          string
         ],
       });
 
@@ -289,9 +362,7 @@ export class ArchetypeService {
     const descVirtueResponse = await this.context
       .api()
       .callTogether.single(descVirtueMessages, {
-        options: {
-          temperature: 0.5,
-        },
+        options: { temperature: 0.3 },
       });
     if (!descVirtueResponse) {
       await this.log('error', 'No response for descriptions and virtues', {
@@ -313,87 +384,79 @@ export class ArchetypeService {
 
     for (let i = 0; i < 3; i++) {
       const index = (i + 1).toString();
-
-      // Update English entry (en-us)
-      const enId = `${combinationString}:${gender}:${index}`;
-      await this.log('debug', `Updating description and virtues for ${enId}`, {
-        description: parsedDescVirtues[i].descriptionEN,
-        virtues: parsedDescVirtues[i].virtuesEN,
-      });
-      await db
-        .update(schema.archetypesData)
-        .set({
-          description: parsedDescVirtues[i].descriptionEN,
-          virtues: JSON.stringify(parsedDescVirtues[i].virtuesEN),
-          updatedAt: new Date().getTime(),
-        })
-        .where(
-          and(
-            eq(schema.archetypesData.id, enId),
-            eq(schema.archetypesData.language, 'en-us')
-          )
-        )
-        .execute();
-      await this.log('info', `Updated description and virtues for ${enId}`);
-
-      // Update Portuguese entries (pt-br) for both male and female
-      const ptIdMale = `${combinationString}:${gender}:${index}:pt`;
-      await this.log(
-        'debug',
-        `Updating description and virtues for ${ptIdMale} (male)`,
-        {
-          description: parsedDescVirtues[i].descriptionPTM,
-          virtues: parsedDescVirtues[i].virtuesPT,
+      for (const g of allGenders) {
+        const archetype = archetypesByGender[g][i];
+        if (!archetype || archetype.archetypeIndex !== index) {
+          await this.log(
+            'error',
+            `Archetype index mismatch for gender ${g} at position ${i + 1}`,
+            {
+              expectedIndex: index,
+              actualIndex: archetype?.archetypeIndex,
+              archetypeId: archetype?.id,
+            }
+          );
+          throw new Error(
+            `Archetype index mismatch for gender ${g}: expected ${index}, got ${archetype?.archetypeIndex}`
+          );
         }
-      );
-      await db
-        .update(schema.archetypesData)
-        .set({
-          description: parsedDescVirtues[i].descriptionPTM,
-          virtues: JSON.stringify(parsedDescVirtues[i].virtuesPT),
-          updatedAt: new Date().getTime(),
-        })
-        .where(
-          and(
-            eq(schema.archetypesData.id, ptIdMale),
-            eq(schema.archetypesData.language, 'pt-br'),
-            eq(schema.archetypesData.gender, 'male')
-          )
-        )
-        .execute();
-      await this.log(
-        'info',
-        `Updated description and virtues for ${ptIdMale} (male)`
-      );
 
-      const ptIdFemale = `${combinationString}:${gender}:${index}:pt`;
-      await this.log(
-        'debug',
-        `Updating description and virtues for ${ptIdFemale} (female)`,
-        {
-          description: parsedDescVirtues[i].descriptionPTF,
-          virtues: parsedDescVirtues[i].virtuesPT,
+        const id = `${combinationString}:${g}:${index}${
+          language === 'pt-br' ? ':pt' : ''
+        }`;
+        if (!override && archetype.description && archetype.virtues !== '[]') {
+          await this.log(
+            'debug',
+            `Skipping existing description and virtues for ${id}`,
+            {
+              description: archetype.description,
+              virtues: archetype.virtues,
+              archetypeIndex: index,
+              gender: g,
+              language,
+            }
+          );
+          continue;
         }
-      );
-      await db
-        .update(schema.archetypesData)
-        .set({
-          description: parsedDescVirtues[i].descriptionPTF,
-          virtues: JSON.stringify(parsedDescVirtues[i].virtuesPT),
-          updatedAt: new Date().getTime(),
-        })
-        .where(
-          and(
-            eq(schema.archetypesData.id, ptIdFemale),
-            eq(schema.archetypesData.language, 'pt-br'),
-            eq(schema.archetypesData.gender, 'female')
+
+        const description =
+          language === 'en-us'
+            ? parsedDescVirtues[i].descriptionEN
+            : g === 'male'
+            ? parsedDescVirtues[i].descriptionPTM
+            : parsedDescVirtues[i].descriptionPTF;
+        const virtues =
+          language === 'en-us'
+            ? parsedDescVirtues[i].virtuesEN
+            : parsedDescVirtues[i].virtuesPT;
+
+        await this.log('debug', `Updating description and virtues for ${id}`, {
+          description,
+          virtues,
+          archetypeIndex: index,
+          gender: g,
+          language,
+        });
+
+        await db
+          .update(schema.archetypesData)
+          .set({
+            description,
+            virtues: JSON.stringify(virtues),
+            updatedAt: new Date().getTime(),
+          })
+          .where(
+            and(
+              eq(schema.archetypesData.id, id),
+              eq(schema.archetypesData.language, language),
+              eq(schema.archetypesData.gender, g),
+              eq(schema.archetypesData.archetypeIndex, index)
+            )
           )
-        )
-        .execute();
-      await this.log(
-        'info',
-        `Updated description and virtues for ${ptIdFemale} (female)`
-      );
+          .execute();
+
+        await this.log('info', `Updated description and virtues for ${id}`);
+      }
     }
 
     await this.log('info', 'Completed generateDescriptionsAndVirtues', {
@@ -442,6 +505,22 @@ export class ArchetypeService {
         lines,
       });
 
+      if (lines[0] !== `${entryIndex + 1}.`) {
+        this.log(
+          'error',
+          `Invalid archetype index in entry ${entryIndex + 1}`,
+          {
+            expected: `${entryIndex + 1}.`,
+            found: lines[0],
+          }
+        );
+        throw new Error(
+          `Invalid archetype index in entry ${entryIndex + 1}: expected ${
+            entryIndex + 1
+          }, got ${lines[0]}`
+        );
+      }
+
       let descriptionEN = '';
       let descriptionPTM = '';
       let descriptionPTF = '';
@@ -449,20 +528,10 @@ export class ArchetypeService {
       let virtuesPT: string[] = [];
       let currentField = '';
 
-      for (let i = 0; i < lines.length; i++) {
+      for (let i = 1; i < lines.length; i++) {
         let line = lines[i];
-
-        // Remove markdown bold (**...**) from field names
         line = line.replace(/\*\*(.*?)\*\*/g, '$1');
 
-        if (
-          line.startsWith('1.') ||
-          line.startsWith('2.') ||
-          line.startsWith('3.')
-        ) {
-          continue; // Skip entry number lines
-        }
-
         if (line.startsWith('• Description EN:')) {
           currentField = 'descriptionEN';
           descriptionEN = line.split('• Description EN:')[1]?.trim() || '';
@@ -510,7 +579,6 @@ export class ArchetypeService {
             virtuesPT,
           });
         } else if (line.startsWith('• Virtues:')) {
-          // Fallback for older response format: use English virtues and attempt to translate
           currentField = 'virtuesEN';
           virtuesEN = line
             .split('• Virtues:')[1]
@@ -524,14 +592,12 @@ export class ArchetypeService {
             { virtuesEN }
           );
 
-          // Simple translation mapping for common virtues (as a fallback)
           const virtueTranslations: { [key: string]: string } = {
             Harmony: 'Harmonia',
             Intuition: 'Intuição',
             Grace: 'Graça',
-            // Add more translations as needed
           };
-          virtuesPT = virtuesEN.map((v) => virtueTranslations[v] || v); // Fallback to English if no translation
+          virtuesPT = virtuesEN.map((v) => virtueTranslations[v] || v);
           this.log(
             'debug',
             `Generated virtuesPT (fallback) for entry ${entryIndex + 1}`,
@@ -563,7 +629,6 @@ export class ArchetypeService {
         }
       }
 
-      // Validate the parsed data
       if (
         !descriptionEN ||
         !descriptionPTM ||
@@ -572,7 +637,7 @@ export class ArchetypeService {
         virtuesPT.length !== 3
       ) {
         this.log(
-          'warn',
+          'error',
           `Malformed description and virtues response for entry ${
             entryIndex + 1
           }`,
@@ -592,13 +657,19 @@ export class ArchetypeService {
         );
       }
 
-      return {
+      const parsed = {
         descriptionEN,
         descriptionPTM,
         descriptionPTF,
         virtuesEN,
         virtuesPT,
       };
+      this.log(
+        'debug',
+        `Parsed description and virtues for archetypeIndex ${entryIndex + 1}`,
+        { parsed }
+      );
+      return parsed;
     });
 
     this.log('info', 'Completed parseDescriptionAndVirtuesResponse', {
@@ -609,85 +680,156 @@ export class ArchetypeService {
 
   async generateContent(
     combinationString: string,
-    gender: Gender,
+    gender: Gender, // Used for compatibility, but processes both genders
     language: string,
-    descriptions: Array<{ descriptionEN: string }>
+    descriptions: Array<{ descriptionEN: string }>,
+    override: boolean = false
   ) {
     await this.log('info', 'Starting generateContent', {
       combinationString,
       gender,
       language,
+      override,
     });
 
     const db = this.context.drizzle();
-    const archetypes = await db
-      .select()
-      .from(schema.archetypesData)
-      .where(
-        and(
-          eq(schema.archetypesData.combination, combinationString),
-          eq(schema.archetypesData.gender, gender),
-          eq(schema.archetypesData.language, 'en-us')
+    const allGenders: Gender[] = ['male', 'female'];
+    const archetypesByGender: Record<Gender, any[]> = { male: [], female: [] };
+
+    for (const g of allGenders) {
+      const archetypes = await db
+        .select()
+        .from(schema.archetypesData)
+        .where(
+          and(
+            eq(schema.archetypesData.combination, combinationString),
+            eq(schema.archetypesData.gender, g),
+            eq(schema.archetypesData.language, language)
+          )
         )
-      )
-      .execute();
+        .orderBy(schema.archetypesData.archetypeIndex)
+        .execute();
+      archetypesByGender[g] = archetypes;
+    }
+
+    const needsGeneration = allGenders.some(
+      (g) =>
+        archetypesByGender[g].length !== 3 ||
+        archetypesByGender[g].some((a) => a.content === '[]')
+    );
+
+    if (!override && !needsGeneration) {
+      await this.log('info', 'Skipping content generation', {
+        reason: 'Content already exists for all archetypes',
+      });
+      return;
+    }
 
     await this.log('info', 'Fetched archetypes for content generation', {
-      archetypesCount: archetypes.length,
-      names: archetypes.map((a) => a.name),
+      maleArchetypes: archetypesByGender['male'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
+      femaleArchetypes: archetypesByGender['female'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
     });
 
     const contentResults = [];
     for (let i = 0; i < 3; i++) {
-      await this.log('debug', `Generating content for archetype ${i + 1}`, {
-        name: archetypes[i].name,
-      });
-      const contentMessages = this.context
-        .buildLLMMessages()
-        .generateCosmicMirrorArchetypeContent({
-          combination: combinationString,
-          name: archetypes[i].name,
-          description: descriptions[i].descriptionEN,
-        });
+      const index = (i + 1).toString();
+      for (const g of allGenders) {
+        const archetype = archetypesByGender[g][i];
+        if (!archetype || archetype.archetypeIndex !== index) {
+          await this.log(
+            'error',
+            `Archetype index mismatch for gender ${g} at position ${i + 1}`,
+            {
+              expectedIndex: index,
+              actualIndex: archetype?.archetypeIndex,
+              archetypeId: archetype?.id,
+            }
+          );
+          throw new Error(
+            `Archetype index mismatch for gender ${g}: expected ${index}, got ${archetype?.archetypeIndex}`
+          );
+        }
+
+        const id = `${combinationString}:${g}:${index}${
+          language === 'pt-br' ? ':pt' : ''
+        }`;
+        if (!override && archetype.content !== '[]') {
+          await this.log('debug', `Skipping existing content for ${id}`, {
+            content: archetype.content,
+            archetypeIndex: index,
+            gender: g,
+            language,
+          });
+          if (g === 'male') contentResults.push({}); // Placeholder for male only
+          continue;
+        }
 
-      await this.log('debug', `Calling API for content of archetype ${i + 1}`, {
-        messages: contentMessages,
-      });
-      const contentResponse = await this.context
-        .api()
-        .callTogether.single(contentMessages, {});
-      if (!contentResponse) {
         await this.log(
-          'error',
-          `No response for content of archetype ${i + 1}`,
-          { combinationString, archetype: archetypes[i].name }
+          'debug',
+          `Generating content for archetype ${index} (${g})`,
+          {
+            name: archetype.name,
+          }
         );
-        throw new Error(
-          `Failed to generate content for archetype ${
-            i + 1
-          } of: ${combinationString}`
+        const contentMessages = this.context
+          .buildLLMMessages()
+          .generateCosmicMirrorArchetypeContent({
+            combination: combinationString,
+            name: archetype.name,
+            description: descriptions[i].descriptionEN,
+          });
+
+        await this.log(
+          'debug',
+          `Calling API for content of archetype ${index} (${g})`,
+          {
+            messages: contentMessages,
+          }
+        );
+        const contentResponse = await this.context
+          .api()
+          .callTogether.single(contentMessages, {});
+        if (!contentResponse) {
+          await this.log(
+            'error',
+            `No response for content of archetype ${index} (${g})`,
+            {
+              combinationString,
+              archetype: archetype.name,
+            }
+          );
+          throw new Error(
+            `Failed to generate content for archetype ${index} (${g}) of: ${combinationString}`
+          );
+        }
+        await this.log(
+          'info',
+          `Received content response for archetype ${index} (${g})`,
+          {
+            responseLength: contentResponse.length,
+          }
         );
-      }
-      await this.log(
-        'info',
-        `Received content response for archetype ${i + 1}`,
-        { responseLength: contentResponse.length }
-      );
 
-      await this.log(
-        'debug',
-        `Parsing content response for archetype ${i + 1}`
-      );
-      const parsedContent = this.parseContentResponse(contentResponse);
-      contentResults.push(parsedContent);
-      await this.log('info', `Parsed content for archetype ${i + 1}`, {
-        parsedContent,
-      });
+        await this.log(
+          'debug',
+          `Parsing content response for archetype ${index} (${g})`
+        );
+        const parsedContent = this.parseContentResponse(contentResponse);
+        if (g === 'male') contentResults.push(parsedContent);
+        await this.log('info', `Parsed content for archetype ${index} (${g})`, {
+          parsedContent,
+        });
 
-      const index = (i + 1).toString();
-      for (const lang of ['en-us', 'pt-br']) {
         const contentLangIndex =
-          lang === 'en-us' ? 0 : gender === 'male' ? 1 : 2;
+          language === 'en-us' ? 0 : g === 'male' ? 1 : 2;
         const content = [
           {
             section: 'voiceOfTheSoul',
@@ -715,10 +857,12 @@ export class ArchetypeService {
           },
         ];
 
-        const id = `${combinationString}:${gender}:${index}${
-          lang === 'pt-br' ? ':pt' : ''
-        }`;
-        await this.log('debug', `Updating content for ${id}`, { content });
+        await this.log('debug', `Updating content for ${id}`, {
+          content,
+          archetypeIndex: index,
+          gender: g,
+          language,
+        });
 
         await db
           .update(schema.archetypesData)
@@ -729,7 +873,9 @@ export class ArchetypeService {
           .where(
             and(
               eq(schema.archetypesData.id, id),
-              eq(schema.archetypesData.language, lang)
+              eq(schema.archetypesData.language, language),
+              eq(schema.archetypesData.gender, g),
+              eq(schema.archetypesData.archetypeIndex, index)
             )
           )
           .execute();
@@ -759,6 +905,14 @@ export class ArchetypeService {
       sectionsCount: sections.length,
     });
 
+    if (sections.length !== 3) {
+      this.log('error', 'Expected exactly 3 content sections', {
+        sectionsCount: sections.length,
+        response,
+      });
+      throw new Error(`Expected 3 content sections, got ${sections.length}`);
+    }
+
     const result = sections.map((section, sectionIndex) => {
       this.log('debug', `Processing section ${sectionIndex + 1}`, { section });
 
@@ -768,24 +922,27 @@ export class ArchetypeService {
         lines,
       });
 
+      const expectedHeader =
+        sectionIndex === 0 ? 'EN:' : sectionIndex === 1 ? 'PT-M:' : 'PT-F:';
+      if (lines[0] !== expectedHeader) {
+        this.log(
+          'error',
+          `Invalid language header in section ${sectionIndex + 1}`,
+          {
+            expected: expectedHeader,
+            found: lines[0],
+          }
+        );
+        throw new Error(
+          `Invalid language header in section ${sectionIndex + 1}`
+        );
+      }
+
       const content: Record<string, string> = {};
       let currentSection = '';
       let currentText: string[] = [];
 
-      for (const line of lines) {
-        if (
-          line.startsWith('EN:') ||
-          line.startsWith('PT-M:') ||
-          line.startsWith('PT-F:')
-        ) {
-          this.log(
-            'debug',
-            `Skipping language header in section ${sectionIndex + 1}`,
-            { line }
-          );
-          continue;
-        }
-
+      for (const line of lines.slice(1)) {
         if (line.startsWith('#')) {
           if (currentSection && currentText.length > 0) {
             const key = currentSection
@@ -798,7 +955,10 @@ export class ArchetypeService {
               `Extracted section ${currentSection} in section ${
                 sectionIndex + 1
               }`,
-              { key, text: content[key] }
+              {
+                key,
+                text: content[key],
+              }
             );
           }
           currentSection = line.replace('# ', '');
@@ -825,7 +985,10 @@ export class ArchetypeService {
           `Extracted final section ${currentSection} in section ${
             sectionIndex + 1
           }`,
-          { key, text: content[key] }
+          {
+            key,
+            text: content[key],
+          }
         );
       }
 
@@ -845,15 +1008,21 @@ export class ArchetypeService {
 
       if (Object.values(parsedContent).some((value) => !value)) {
         this.log(
-          'warn',
+          'error',
           `Malformed content response for section ${sectionIndex + 1}`,
           {
             parsedContent,
             response: section,
           }
         );
+        throw new Error(
+          `Malformed content response for section ${sectionIndex + 1}`
+        );
       }
 
+      this.log('debug', `Parsed content for section ${sectionIndex + 1}`, {
+        parsedContent,
+      });
       return parsedContent;
     });
 
@@ -863,26 +1032,21 @@ export class ArchetypeService {
 
   async generateLeonardoPrompts(
     combinationString: string,
-    gender: Gender, // User's gender, used for filtering results in ArchetypeWorkflow.execute
-    language: string, // User's language, used for filtering results in ArchetypeWorkflow.execute
-    descriptions: Array<{ descriptionEN: string }>
+    gender: Gender, // Used for compatibility, but processes both genders
+    language: string,
+    descriptions: Array<{ descriptionEN: string }>,
+    override: boolean = false
   ) {
     await this.log('info', 'Starting generateLeonardoPrompts', {
       combinationString,
       gender,
       language,
+      override,
     });
 
     const db = this.context.drizzle();
-
-    type Binary = 'male' | 'female';
-
-    // Fetch archetypes for male and female with language = 'en-us'
-    const allGenders: Binary[] = ['male', 'female'];
-    const archetypesByGender: Record<Binary, any[]> = {
-      male: [],
-      female: [],
-    };
+    const allGenders: Gender[] = ['male', 'female'];
+    const archetypesByGender: Record<Gender, any[]> = { male: [], female: [] };
 
     for (const g of allGenders) {
       const archetypes = await db
@@ -892,41 +1056,40 @@ export class ArchetypeService {
           and(
             eq(schema.archetypesData.combination, combinationString),
             eq(schema.archetypesData.gender, g),
-            eq(schema.archetypesData.language, 'en-us')
+            eq(schema.archetypesData.language, language)
           )
         )
+        .orderBy(schema.archetypesData.archetypeIndex)
         .execute();
       archetypesByGender[g] = archetypes;
     }
 
-    // Validate that we have archetypes for all genders (3 archetypes per gender)
-    for (const g of allGenders) {
-      if (archetypesByGender[g].length !== 3) {
-        await this.log(
-          'error',
-          `Expected 3 archetypes for gender ${g}, but found ${archetypesByGender[g].length}`,
-          {
-            combinationString,
-            gender: g,
-          }
-        );
-        throw new Error(
-          `Expected 3 archetypes for gender ${g}, but found ${archetypesByGender[g].length}`
-        );
-      }
+    const needsGeneration = allGenders.some(
+      (g) =>
+        archetypesByGender[g].length !== 3 ||
+        archetypesByGender[g].some((a) => !a.leonardoPrompt)
+    );
+
+    if (!override && !needsGeneration) {
+      await this.log('info', 'Skipping Leonardo prompts generation', {
+        reason: 'Leonardo prompts already exist for all archetypes',
+      });
+      return;
     }
 
     await this.log('info', 'Fetched archetypes for Leonardo prompts', {
-      maleArchetypesCount: archetypesByGender['male'].length,
-      femaleArchetypesCount: archetypesByGender['female'].length,
-      names: {
-        male: archetypesByGender['male'].map((a) => a.name),
-        female: archetypesByGender['female'].map((a) => a.name),
-      },
+      maleArchetypes: archetypesByGender['male'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
+      femaleArchetypes: archetypesByGender['female'].map((a) => ({
+        id: a.id,
+        name: a.name,
+        index: a.archetypeIndex,
+      })),
     });
 
-    // Since descriptions are provided as an input (from generateDescriptionsAndVirtues),
-    // we can use the same descriptions for all genders, as they are gender-neutral (en-us)
     const promptMessages = this.context
       .buildLLMMessages()
       .generateCosmicMirrorArchetypeLeonardoPrompts(
@@ -957,115 +1120,73 @@ export class ArchetypeService {
     const parsedPrompts = this.parseLeonardoPromptResponse(promptResponse);
     await this.log('info', 'Parsed Leonardo prompts', { parsedPrompts });
 
-    // Update archetypes for all genders
     for (const g of allGenders) {
       for (let i = 0; i < 3; i++) {
+        const archetype = archetypesByGender[g][i];
         const index = (i + 1).toString();
-        const leonardoPrompt =
-          g === 'male'
-            ? parsedPrompts[i].malePrompt
-            : parsedPrompts[i].femalePrompt;
-
-        // Update English entry (en-us)
-        const enId = `${combinationString}:${g}:${index}`;
-        await this.log(
-          'debug',
-          `Updating Leonardo prompt for ${enId} (en-us)`,
-          {
-            leonardoPrompt,
-          }
-        );
-
-        const enUpdateResult = await db
-          .update(schema.archetypesData)
-          .set({
-            leonardoPrompt,
-            updatedAt: new Date().getTime(),
-          })
-          .where(
-            and(
-              eq(schema.archetypesData.id, enId),
-              eq(schema.archetypesData.language, 'en-us'),
-              eq(schema.archetypesData.gender, g)
-            )
-          )
-          .execute();
-
-        await this.log('info', `Updated Leonardo prompt for ${enId} (en-us)`, {
-          rowsAffected: enUpdateResult.rowsAffected,
-        });
-
-        if (enUpdateResult.rowsAffected === 0) {
+        if (!archetype || archetype.archetypeIndex !== index) {
           await this.log(
             'error',
-            `Failed to update Leonardo prompt for ${enId} (en-us)`,
+            `Archetype index mismatch for gender ${g} at position ${i + 1}`,
             {
-              enId,
-              language: 'en-us',
-              gender: g,
+              expectedIndex: index,
+              actualIndex: archetype?.archetypeIndex,
+              archetypeId: archetype?.id,
             }
           );
           throw new Error(
-            `Failed to update Leonardo prompt for ${enId} (en-us)`
+            `Archetype index mismatch for gender ${g}: expected ${index}, got ${archetype?.archetypeIndex}`
           );
         }
 
-        // Update Portuguese entries (pt-br) for male and female
-        const ptId = `${combinationString}:${g}:${index}:pt`;
-        const ptGenders = ['male', 'female'];
-
-        for (const ptGender of ptGenders) {
-          const ptLeonardoPrompt =
-            ptGender === 'male'
-              ? parsedPrompts[i].malePrompt
-              : parsedPrompts[i].femalePrompt;
+        const leonardoPrompt =
+          g === 'male'
+            ? parsedPrompts[i].malePrompt
+            : parsedPrompts[i].femalePrompt;
+        const id = `${combinationString}:${g}:${index}${
+          language === 'pt-br' ? ':pt' : ''
+        }`;
 
+        if (!override && archetype.leonardoPrompt) {
           await this.log(
             'debug',
-            `Updating Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`,
+            `Skipping existing Leonardo prompt for ${id}`,
             {
-              leonardoPrompt: ptLeonardoPrompt,
+              leonardoPrompt: archetype.leonardoPrompt,
+              archetypeIndex: index,
+              gender: g,
+              language,
             }
           );
+          continue;
+        }
 
-          const ptUpdateResult = await db
-            .update(schema.archetypesData)
-            .set({
-              leonardoPrompt: ptLeonardoPrompt,
-              updatedAt: new Date().getTime(),
-            })
-            .where(
-              and(
-                eq(schema.archetypesData.id, ptId),
-                eq(schema.archetypesData.language, 'pt-br'),
-                eq(schema.archetypesData.gender, ptGender)
-              )
-            )
-            .execute();
+        await this.log('debug', `Updating Leonardo prompt for ${id}`, {
+          leonardoPrompt,
+          archetypeIndex: index,
+          gender: g,
+          language,
+        });
 
-          await this.log(
-            'info',
-            `Updated Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`,
-            {
-              rowsAffected: ptUpdateResult.rowsAffected,
-            }
-          );
+        const updateResult = await db
+          .update(schema.archetypesData)
+          .set({
+            leonardoPrompt,
+            updatedAt: new Date().getTime(),
+          })
+          .where(
+            and(
+              eq(schema.archetypesData.id, id),
+              eq(schema.archetypesData.language, language),
+              eq(schema.archetypesData.gender, g),
+              eq(schema.archetypesData.archetypeIndex, index)
+            )
+          )
+          .execute();
 
-          if (ptUpdateResult.rowsAffected === 0) {
-            await this.log(
-              'error',
-              `Failed to update Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`,
-              {
-                ptId,
-                language: 'pt-br',
-                gender: ptGender,
-              }
-            );
-            throw new Error(
-              `Failed to update Leonardo prompt for ${ptId} (pt-br, gender: ${ptGender})`
-            );
-          }
-        }
+        await this.log('info', `Updated Leonardo prompt for ${id}`, {
+          rowsAffected: updateResult.rowsAffected,
+        });
       }
     }
 
@@ -1088,39 +1209,45 @@ export class ArchetypeService {
       lines,
     });
 
-    const prompts: LeonardoPrompt[] = [];
-    let currentArchetype = 0;
+    if (lines.length !== 12) {
+      this.log('error', 'Expected exactly 12 lines for 3 archetype prompts', {
+        linesCount: lines.length,
+        response,
+      });
+      throw new Error(
+        `Expected 12 lines for 3 archetype prompts, got ${lines.length}`
+      );
+    }
 
+    const prompts: LeonardoPrompt[] = [];
     for (let i = 0; i < lines.length; i += 4) {
-      // Expect pairs of label and prompt: "1.m", male prompt, "1.f", female prompt
-      const maleLabel = lines[i]; // "1.m"
-      const malePromptLine = lines[i + 1]; // Male prompt text
-      const femaleLabel = lines[i + 2]; // "1.f"
-      const femalePromptLine = lines[i + 3]; // Female prompt text
+      const archetypeIndex = i / 4 + 1;
+      const maleLabel = lines[i];
+      const malePromptLine = lines[i + 1];
+      const femaleLabel = lines[i + 2];
+      const femalePromptLine = lines[i + 3];
 
-      currentArchetype++;
-      const expectedMaleLabel = `${currentArchetype}.m`;
-      const expectedFemaleLabel = `${currentArchetype}.f`;
+      const expectedMaleLabel = `${archetypeIndex}.m`;
+      const expectedFemaleLabel = `${archetypeIndex}.f`;
 
       if (
         !maleLabel?.startsWith(expectedMaleLabel) ||
         !femaleLabel?.startsWith(expectedFemaleLabel)
       ) {
         this.log(
-          'warn',
-          `Malformed Leonardo prompt format for archetype ${currentArchetype}`,
+          'error',
+          `Malformed Leonardo prompt format for archetype ${archetypeIndex}`,
           {
             maleLabel,
             malePromptLine,
             femaleLabel,
             femalePromptLine,
-            lines,
+            expectedMaleLabel,
+            expectedFemaleLabel,
           }
         );
         throw new Error(
-          `Expected ${expectedMaleLabel} and ${expectedFemaleLabel} at lines ${i} and ${
-            i + 2
-          }`
+          `Malformed prompt format for archetype ${archetypeIndex}`
         );
       }
 
@@ -1129,42 +1256,30 @@ export class ArchetypeService {
 
       if (!malePrompt || !femalePrompt) {
         this.log(
-          'warn',
-          `Empty Leonardo prompt for archetype ${currentArchetype}`,
+          'error',
+          `Empty Leonardo prompt for archetype ${archetypeIndex}`,
           {
             malePrompt,
             femalePrompt,
-            malePromptLine,
-            femalePromptLine,
           }
         );
-        throw new Error(`Empty prompt for archetype ${currentArchetype}`);
+        throw new Error(`Empty prompt for archetype ${archetypeIndex}`);
       }
 
       prompts.push({ malePrompt, femalePrompt });
-      this.log('debug', `Parsed prompts for archetype ${currentArchetype}`, {
+      this.log('debug', `Parsed prompts for archetypeIndex ${archetypeIndex}`, {
         malePrompt,
         femalePrompt,
       });
     }
 
-    if (prompts.length !== 3) {
-      this.log('error', 'Expected exactly 3 archetype prompts', {
-        promptsCount: prompts.length,
-        response,
-      });
-      throw new Error(
-        `Expected exactly 3 archetype prompts, but got ${prompts.length}`
-      );
-    }
-
     this.log('info', 'Completed parseLeonardoPromptResponse', { prompts });
     return prompts;
   }
 
   async fetchArchetypesFromDB(
     combinationString: string,
-    gender: Gender,
+    gender: Gender | null, // null to fetch both genders
     language: string
   ) {
     await this.log('debug', 'Executing fetchArchetypesFromDB', {
@@ -1173,20 +1288,23 @@ export class ArchetypeService {
       language,
     });
     const db = this.context.drizzle();
+    const conditions = [
+      eq(schema.archetypesData.combination, combinationString),
+      eq(schema.archetypesData.language, language),
+    ];
+    if (gender) {
+      conditions.push(eq(schema.archetypesData.gender, gender));
+    }
     const result = await db
       .select()
       .from(schema.archetypesData)
-      .where(
-        and(
-          eq(schema.archetypesData.combination, combinationString),
-          eq(schema.archetypesData.gender, gender),
-          eq(schema.archetypesData.language, language)
-        )
-      )
+      .where(and(...conditions))
+      .orderBy(schema.archetypesData.archetypeIndex)
       .execute();
     await this.log('debug', 'fetchArchetypesFromDB result', {
       resultCount: result.length,
-      result,
+      indexes: result.map((r) => r.archetypeIndex),
+      genders: result.map((r) => r.gender),
     });
     return result;
   }