gameforge-cli 0.1.0 → 0.2.1

package/dist/agents/core/Architect.js

@@ -32,13 +32,23 @@ Do NOT wrap the JSON in \`\`\`json or \`\`\` tags.`,
             return `Q: ${t.question}\nA: ${t.answer}${marker}`;
         })
             .join('\n\n');
+        // Check if there are ambiguities that need clarification
+        const clarifications = await this.checkForAmbiguities(transcript, onProgress);
+        // If there are clarifications, add them to the transcript
+        const enhancedTranscript = [...transcript, ...clarifications];
+        const enhancedTranscriptStr = enhancedTranscript
+            .map(t => {
+            const marker = t.autoGenerated ? ' [Auto-Generated]' : '';
+            return `Q: ${t.question}\nA: ${t.answer}${marker}`;
+        })
+            .join('\n\n');
         // Multi-pass generation with constrained prompts
         onProgress?.('Pass 1/3: Generating meta and core features...');
-        const metaAndFeatures = await this.generateMetaAndFeatures(transcriptStr, onProgress);
+        const metaAndFeatures = await this.generateMetaAndFeatures(enhancedTranscriptStr, onProgress);
         onProgress?.('Pass 2/3: Generating key game objects...');
-        const gameObjects = await this.generateGameObjects(transcriptStr, metaAndFeatures, onProgress);
+        const gameObjects = await this.generateGameObjects(enhancedTranscriptStr, metaAndFeatures, onProgress);
         onProgress?.('Pass 3/3: Generating creative and technical specs...');
-        const creativeAndTech = await this.generateCreativeAndTech(transcriptStr, metaAndFeatures, onProgress);
+        const creativeAndTech = await this.generateCreativeAndTech(enhancedTranscriptStr, metaAndFeatures, onProgress);
         // Merge all parts into final GameBible
         onProgress?.('Merging and validating...');
         const gameBible = {
@@ -48,6 +58,10 @@ Do NOT wrap the JSON in \`\`\`json or \`\`\` tags.`,
             creative: creativeAndTech.creative,
             technical: creativeAndTech.technical
         };
+        // Check post-generation ambiguities
+        await this.checkPostGenerationAmbiguities(gameBible, enhancedTranscript, onProgress);
+        // Normalize/coerce common LLM output issues before validation
+        this.normalizeGameBible(gameBible);
         try {
             const validated = schema_1.GameBibleSchema.parse(gameBible);
             // Debug logging: Successful validation
@@ -86,16 +100,320 @@ Do NOT wrap the JSON in \`\`\`json or \`\`\` tags.`,
             throw error;
         }
     }
+    /**
+     * Normalize/coerce common LLM output issues before schema validation.
+     * Fixes issues like strings-instead-of-arrays, missing defaults, etc.
+     */
+    normalizeGameBible(bible) {
+        // Helper to convert string to array if needed
+        const ensureArray = (value) => {
+            if (Array.isArray(value))
+                return value;
+            if (typeof value === 'string' && value.trim())
+                return [value];
+            return [];
+        };
+        // Normalize features
+        if (bible.features) {
+            for (const feature of bible.features) {
+                // Ensure array fields are arrays
+                if (feature.dependencies !== undefined) {
+                    feature.dependencies = ensureArray(feature.dependencies);
+                }
+                if (feature.gameplayLoop !== undefined) {
+                    feature.gameplayLoop = ensureArray(feature.gameplayLoop);
+                }
+                if (feature.uiRequirements !== undefined) {
+                    feature.uiRequirements = ensureArray(feature.uiRequirements);
+                }
+                // Nested optional objects
+                if (feature.narrative?.storyBeats !== undefined) {
+                    feature.narrative.storyBeats = ensureArray(feature.narrative.storyBeats);
+                }
+                if (feature.narrative?.characters !== undefined) {
+                    feature.narrative.characters = ensureArray(feature.narrative.characters);
+                }
+                if (feature.economy?.currencies !== undefined) {
+                    feature.economy.currencies = ensureArray(feature.economy.currencies);
+                }
+                if (feature.economy?.balanceFactors !== undefined) {
+                    feature.economy.balanceFactors = ensureArray(feature.economy.balanceFactors);
+                }
+                if (feature.progression?.unlockConditions !== undefined) {
+                    feature.progression.unlockConditions = ensureArray(feature.progression.unlockConditions);
+                }
+                if (feature.procedural?.constraints !== undefined) {
+                    feature.procedural.constraints = ensureArray(feature.procedural.constraints);
+                }
+                if (feature.physics?.interactions !== undefined) {
+                    feature.physics.interactions = ensureArray(feature.physics.interactions);
+                }
+            }
+        }
+        // Normalize game objects/entities
+        if (bible.gameObjects) {
+            for (const entity of bible.gameObjects) {
+                // Ensure array fields are arrays
+                if (entity.narrative?.dialogues !== undefined) {
+                    entity.narrative.dialogues = ensureArray(entity.narrative.dialogues);
+                }
+                if (entity.stats?.behaviors !== undefined) {
+                    entity.stats.behaviors = ensureArray(entity.stats.behaviors);
+                }
+                if (entity.references?.features !== undefined) {
+                    entity.references.features = ensureArray(entity.references.features);
+                }
+                if (entity.references?.relatedEntities !== undefined) {
+                    entity.references.relatedEntities = ensureArray(entity.references.relatedEntities);
+                }
+                if (entity.combat?.abilities !== undefined) {
+                    entity.combat.abilities = ensureArray(entity.combat.abilities);
+                }
+                if (entity.cardGame?.effects !== undefined) {
+                    entity.cardGame.effects = ensureArray(entity.cardGame.effects);
+                }
+            }
+        }
+        // Normalize creative section
+        if (bible.creative?.referenceLinks !== undefined) {
+            bible.creative.referenceLinks = ensureArray(bible.creative.referenceLinks);
+        }
+        if (bible.creative?.rhythm?.difficulty_levels !== undefined) {
+            bible.creative.rhythm.difficulty_levels = ensureArray(bible.creative.rhythm.difficulty_levels);
+        }
+        if (bible.creative?.rhythm?.note_types !== undefined) {
+            bible.creative.rhythm.note_types = ensureArray(bible.creative.rhythm.note_types);
+        }
+        if (bible.creative?.horror?.scareTechniques !== undefined) {
+            bible.creative.horror.scareTechniques = ensureArray(bible.creative.horror.scareTechniques);
+        }
+        // Normalize technical section
+        if (bible.technical?.buildTargets !== undefined) {
+            bible.technical.buildTargets = ensureArray(bible.technical.buildTargets);
+        }
+        if (bible.technical?.localization?.languages !== undefined) {
+            bible.technical.localization.languages = ensureArray(bible.technical.localization.languages);
+        }
+        // Normalize meta section arrays
+        if (bible.meta?.genre !== undefined) {
+            bible.meta.genre = ensureArray(bible.meta.genre);
+        }
+        if (bible.meta?.targetPlatform !== undefined) {
+            bible.meta.targetPlatform = ensureArray(bible.meta.targetPlatform);
+        }
+    }
+    /**
+     * Check the transcript for potential ambiguities and ask clarifying questions
+     * Returns additional transcript entries with clarifications
+     */
+    async checkForAmbiguities(transcript, onProgress) {
+        onProgress?.('Checking for ambiguities...');
+        const clarifications = [];
+        // Check for vague scope
+        const scopeAnswer = transcript.find(t => t.question.toLowerCase().includes('scope'))?.answer || '';
+        if (scopeAnswer && scopeAnswer.length > 0 &&
+            !scopeAnswer.toLowerCase().includes('prototype') &&
+            !scopeAnswer.toLowerCase().includes('mvp') &&
+            !scopeAnswer.toLowerCase().includes('vertical slice') &&
+            !scopeAnswer.toLowerCase().includes('full game')) {
+            const result = await this.askClarification('The project scope seems unclear. What is the target development scope?', transcript, 'Scope Clarification');
+            clarifications.push({
+                question: 'Clarification: Project Scope',
+                answer: result.answer,
+                autoGenerated: result.wasAIGenerated
+            });
+        }
+        // Check for unclear monetization
+        const monetizationAnswer = transcript.find(t => t.question.toLowerCase().includes('monetization') ||
+            t.question.toLowerCase().includes('revenue'))?.answer || '';
+        const normalizedMonetizationAnswer = monetizationAnswer
+            .trim()
+            .toLowerCase()
+            .replace(/[^\w\s]/g, '');
+        if (monetizationAnswer && normalizedMonetizationAnswer === 'custom answer') {
+            const result = await this.askClarification('Could you clarify the monetization strategy? How will this game generate revenue?', transcript, 'Monetization Clarification');
+            clarifications.push({
+                question: 'Clarification: Monetization Details',
+                answer: result.answer,
+                autoGenerated: result.wasAIGenerated
+            });
+        }
+        // Check for vague art style
+        const artAnswer = transcript.find(t => t.question.toLowerCase().includes('art') ||
+            t.question.toLowerCase().includes('visual'))?.answer || '';
+        if (!artAnswer || artAnswer.length < 10) {
+            const result = await this.askClarification('The visual art style needs more detail. What specific art direction should we follow?', transcript, 'Art Style Clarification');
+            clarifications.push({
+                question: 'Clarification: Art Style Details',
+                answer: result.answer,
+                autoGenerated: result.wasAIGenerated
+            });
+        }
+        // Check for vague target audience
+        const audienceAnswer = transcript.find(t => t.question.toLowerCase().includes('audience') ||
+            t.question.toLowerCase().includes('target'))?.answer || '';
+        const normalizedAudience = audienceAnswer.toLowerCase();
+        if (audienceAnswer.length < 15 ||
+            normalizedAudience.includes('everyone') ||
+            normalizedAudience.includes('all ages') ||
+            normalizedAudience.includes('casual and hardcore') ||
+            normalizedAudience.includes('broad')) {
+            const result = await this.askClarification('The target audience is very broad. Who is the PRIMARY audience? (e.g., "competitive FPS players 18-35" vs "everyone")', transcript, 'Target Audience Clarification');
+            clarifications.push({
+                question: 'Clarification: Target Audience',
+                answer: result.answer,
+                autoGenerated: result.wasAIGenerated
+            });
+        }
+        // Check for genre mixing overload
+        const genreAnswer = transcript.find(t => t.question.toLowerCase().includes('genre'))?.answer || '';
+        const genreCount = genreAnswer.split(/[,/&+]/).filter(g => g.trim().length > 0).length;
+        if (genreCount > 3) {
+            const result = await this.askClarification(`You're mixing ${genreCount} genres. This can dilute the experience. What's the PRIMARY genre?`, transcript, 'Genre Focus');
+            clarifications.push({
+                question: 'Clarification: Primary Genre',
+                answer: result.answer,
+                autoGenerated: result.wasAIGenerated
+            });
+        }
+        if (clarifications.length > 0) {
+            onProgress?.(`Added ${clarifications.length} clarifications`);
+        }
+        return clarifications;
+    }
+    /**
+     * Check the generated GameBible for structural issues and ask clarifying questions
+     */
+    async checkPostGenerationAmbiguities(bible, transcript, onProgress) {
+        // Check for too many features for scope
+        const scope = bible.meta.estimatedScope;
+        const featureCount = bible.features.length;
+        const featureLimits = {
+            'Prototype': 5,
+            'Vertical Slice': 8,
+            'MVP': 12,
+            'Full Game': 20
+        };
+        const limit = featureLimits[scope] || 12;
+        if (featureCount > limit) {
+            const result = await this.askClarification(`You have ${featureCount} features for a "${scope}" project. This may be too ambitious. Should we prioritize the most critical features?`, bible, 'Feature Count');
+            // Note: We inform but don't auto-reduce features - user decides
+            onProgress?.(`Feature count acknowledged: ${featureCount} features for ${scope} scope`);
+        }
+        // Check for core gameplay loop
+        const hasGameplayLoop = bible.features.some((f) => f.gameplayLoop && f.gameplayLoop.length > 0);
+        if (!hasGameplayLoop) {
+            const result = await this.askClarification('No gameplay loops are defined. What does the player DO moment-to-moment in this game?', bible, 'Core Gameplay Loop');
+            onProgress?.('Core gameplay loop clarified');
+        }
+        // Check for genre-specific features
+        const genres = bible.meta.genre.map((g) => g.toLowerCase());
+        // RPG without progression
+        if (genres.some((g) => g.includes('rpg')) &&
+            !bible.features.some((f) => f.progression)) {
+            const result = await this.askClarification('RPG games typically need a progression system. Should we add character/player progression?', bible, 'RPG Progression');
+            const decision = (result.answer || '').toLowerCase();
+            if (decision.includes('yes') || decision.includes('add') || decision.includes('should')) {
+                onProgress?.('Note: User confirmed RPG progression system should be added - consider this for future feature expansion');
+            }
+            else {
+                onProgress?.('RPG progression acknowledged as intentional design decision');
+            }
+        }
+        // Multiplayer genre without networking
+        if ((genres.some((g) => g.includes('multiplayer') || g.includes('mmo') || g.includes('competitive')) ||
+            bible.features.some((f) => f.multiplayer)) &&
+            !bible.technical?.networking) {
+            const result = await this.askClarification('Multiplayer features detected but no networking architecture specified. What network model should we use?', bible, 'Multiplayer Networking');
+            const decision = (result.answer || '').toLowerCase();
+            // Extract network architecture from user response
+            if (!bible.technical) {
+                bible.technical = { engine: { primary: 'Unity', version: '2023.2', reasoning: 'Default engine' }, buildTargets: [] };
+            }
+            if (decision.includes('client-server') || decision.includes('client server')) {
+                bible.technical.networking = { architecture: 'Client-Server', maxPlayers: 8 };
+                onProgress?.('Added Client-Server networking architecture');
+            }
+            else if (decision.includes('peer-to-peer') || decision.includes('p2p')) {
+                bible.technical.networking = { architecture: 'Peer-to-Peer', maxPlayers: 4 };
+                onProgress?.('Added Peer-to-Peer networking architecture');
+            }
+            else if (decision.includes('relay')) {
+                bible.technical.networking = { architecture: 'Relay Server', maxPlayers: 8 };
+                onProgress?.('Added Relay Server networking architecture');
+            }
+            else {
+                onProgress?.('Multiplayer networking clarified - manual specification may be needed');
+            }
+        }
+        // Card game without cards
+        if (genres.some((g) => g.includes('card') || g.includes('ccg') || g.includes('tcg')) &&
+            !bible.gameObjects.some((e) => e.category === 'Card')) {
+            const result = await this.askClarification('Card game genre but no card entities defined. Should we add card definitions?', bible, 'Card Game Entities');
+            const decision = (result.answer || '').toLowerCase();
+            if (decision.includes('yes') || decision.includes('add') || decision.includes('should')) {
+                onProgress?.('Note: User confirmed cards should be added - consider expanding entity list');
+            }
+            else {
+                onProgress?.('Card-less design acknowledged as intentional');
+            }
+        }
+        // Horror without atmosphere
+        if (genres.some((g) => g.includes('horror')) &&
+            !bible.creative?.horror?.atmosphere) {
+            const result = await this.askClarification('Horror game but no horror atmosphere defined. What kind of horror experience are you creating?', bible, 'Horror Atmosphere');
+            const decision = (result.answer || '').toLowerCase();
+            // Attempt to add horror atmosphere based on user response
+            if (bible.creative && decision.length > 10) {
+                if (!bible.creative.horror) {
+                    bible.creative.horror = {};
+                }
+                const horror = bible.creative.horror;
+                // Extract atmosphere keywords from response
+                if (decision.includes('psychological')) {
+                    horror.atmosphere = 'Psychological tension and unease';
+                }
+                else if (decision.includes('survival')) {
+                    horror.atmosphere = 'Survival horror with resource scarcity';
+                }
+                else if (decision.includes('jump scare') || decision.includes('jumpscare')) {
+                    horror.atmosphere = 'Jump scares and sudden frights';
+                }
+                else if (decision.includes('cosmic') || decision.includes('lovecraft')) {
+                    horror.atmosphere = 'Cosmic horror and existential dread';
+                }
+                else {
+                    horror.atmosphere = result.answer.substring(0, 100);
+                }
+                onProgress?.('Added horror atmosphere based on user input');
+            }
+        }
+        // Story/narrative game without NPCs
+        if ((genres.some((g) => g.includes('rpg') || g.includes('adventure') || g.includes('story')) ||
+            bible.features.some((f) => f.narrative)) &&
+            !bible.gameObjects.some((e) => e.category === 'NPC')) {
+            const result = await this.askClarification('Story-driven game with no NPCs. Should we add key characters to populate the world?', bible, 'Story Characters');
+            const decision = (result.answer || '').toLowerCase();
+            if (decision.includes('yes') || decision.includes('add') || decision.includes('should')) {
+                onProgress?.('Note: User confirmed NPCs should be added - consider expanding entity list');
+            }
+            else {
+                onProgress?.('NPC-less design acknowledged as intentional (e.g., environmental storytelling)');
+            }
+        }
+    }
     async generateMetaAndFeatures(transcriptStr, onProgress) {
         const prompt = `Generate the meta section and core features for a Game Design Document.
 
 INTERVIEW:
 ${transcriptStr}
 
-CONSTRAINTS - Keep it focused:
+CONSTRAINTS - Keep it focused on DESIGN, not implementation:
 - Generate 3-8 core features maximum (prioritize the most important systems)
-- Keep technical specs concise
+- Focus on what the feature DOES for the player, not how it's coded
+- Describe gameplay loops in plain language
 - Limit to essential dependencies only
+- ONLY include fields that are relevant to the genre - omit optional fields that don't apply
 
 OUTPUT STRUCTURE (use this EXACT format):
 {
@@ -114,44 +432,36 @@ OUTPUT STRUCTURE (use this EXACT format):
     {
       "id": "FEAT-001",
       "name": "Feature Name",
-      "intent": "Why this feature exists",
-      "dependencies": ["FEAT-002"],
-      "gameplayLoop": ["step1", "step2", "step3"],
-      "uiRequirements": ["UI element description"],
+      "intent": "Why this feature exists and what it adds to player experience",
+      "dependencies": [],
+      "gameplayLoop": ["Player does X", "System responds with Y", "Player decides Z"],
+      "uiRequirements": ["Health bar", "Inventory panel"],
       "technical": {
-        "dataStructure": "struct FeatureName { field: type; }",
-        "mathFormulas": [
-          {
-            "expression": "damage = baseDamage * (1 + critChance)",
-            "variables": {
-              "baseDamage": { "type": "float", "range": "1.0-100.0" },
-              "critChance": { "type": "float", "range": "0.0-1.0" }
-            },
-            "validated": false,
-            "balanceNotes": "Adjust critChance if damage spikes too high"
-          }
-        ],
-        "fileLocation": "src/features/FeatureName/",
         "estimatedComplexity": "Medium"
       },
-      "agile": {
-        "epic": "EPIC-001: Epic Name",
-        "userStories": [
-          "As a player, I want to... so that..."
-        ],
-        "acceptanceCriteria": [
-          "Given... when... then..."
-        ]
+      "multiplayer": {
+        "playerCount": "2-8",
+        "networkModel": "Client-Server"
       }
     }
   ]
 }
 
-CRITICAL - For mathFormulas field:
-- If the feature has NO formulas, use: "mathFormulas": []
-- If it HAS formulas, each must be an OBJECT with structure shown above
-- NEVER use strings for mathFormulas elements
-- Variable types MUST be exactly "int", "float", or "bool" - NOT "array<int>", "number", "integer", or any other variation
+OPTIONAL FIELDS - Include ONLY if relevant to the game genre:
+- features[].gameplayLoop - OPTIONAL for non-gameplay features (e.g., settings, menus)
+- features[].monetization - OPTIONAL for games with monetization (strategy only)
+- features[].multiplayer - OPTIONAL for multiplayer features (playerCount as string, networkModel)
+- features[].narrative - OPTIONAL for story-driven features (storyBeats, characters)
+- features[].economy - OPTIONAL for games with currency/trading (currencies, tradeable)
+- features[].progression - OPTIONAL for games with leveling/unlocks (unlockConditions, skillTrees)
+- features[].procedural - OPTIONAL for procedural generation features (algorithm name only)
+- features[].physics - OPTIONAL for physics-heavy features (realism level only)
+
+IMPORTANT: This is a DESIGN document, not an engineering spec. Do NOT include:
+- Code or pseudo-code
+- File paths or directory structures
+- Detailed math formulas with variable types
+- Implementation details
 
 Output ONLY the JSON, no markdown blocks.`;
         const response = await this.callLLMWithAutoRetry(prompt, modelSelector_1.TaskComplexity.COMPLEX, {
@@ -170,50 +480,28 @@ ${transcriptStr}
 FEATURES:
 ${JSON.stringify(metaAndFeatures.features.map(f => ({ id: f.id, name: f.name })), null, 2)}
 
-CONSTRAINTS - Focus on essentials:
+CONSTRAINTS - Keep it design-focused:
 - Generate 5-15 game objects maximum (most important entities only)
 - For card games: include a few representative cards, not every single card
-- Keep backstories and dialogues brief (1-2 sentences max)
-- Minimal attributes per object
+- Keep backstories brief (1-2 sentences max)
+- Focus on what the entity IS and what it DOES, not technical implementation
+- ONLY include fields that are relevant to the entity type
 
 OUTPUT STRUCTURE (use this EXACT format):
 [
   {
     "id": "NPC-001",
     "name": "Character Name",
-    "category": "NPC",  // MUST be one of: "NPC", "Monster", "Item", "Interactable"
+    "category": "NPC",
     "narrative": {
-      "backstory": "Brief 1-2 sentence backstory",
-      "dialogues": ["Dialogue line 1", "Dialogue line 2"],
-      "externalData": {
-        "type": "Spreadsheet",
-        "schema": "columns: name (string), dialogueKey (string), emotion (string)",
-        "sampleRows": 5,
-        "fileReference": "npcs/character_name_dialogues.csv"
-      }
+      "backstory": "Brief 1-2 sentence backstory"
     },
     "stats": {
       "attributes": {
-        "HP": 100,
-        "Speed": "Fast",
-        "AttackPower": 25
+        "Role": "Merchant",
+        "Personality": "Friendly"
       },
-      "behaviors": ["patrol", "attack on sight"],
-      "balanceFormulas": [
-        {
-          "expression": "effectiveHP = HP * (1 + armor * 0.01)",
-          "variables": {
-            "HP": { "type": "int", "range": "1-1000" },
-            "armor": { "type": "int", "range": "0-100" }
-          },
-          "validated": false,
-          "balanceNotes": "Ensure armor doesn't make character invincible"
-        }
-      ]
-    },
-    "references": {
-      "features": ["FEAT-001"],
-      "relatedEntities": ["ITEM-005"]
+      "behaviors": ["sells items", "gives quests"]
     }
   },
   {
@@ -222,35 +510,30 @@ OUTPUT STRUCTURE (use this EXACT format):
     "category": "Item",
     "stats": {
       "attributes": {
-        "value": 100,
-        "weight": 5
+        "Type": "Consumable",
+        "Effect": "Restores health"
       },
-      "behaviors": ["consumable", "tradeable"]
-    },
-    "references": {
-      "features": ["FEAT-003"],
-      "relatedEntities": []
+      "behaviors": ["single use"]
     }
   }
 ]
 
-CRITICAL - For optional complex fields:
-- category MUST be exactly one of: "NPC", "Monster", "Item", "Interactable"
-  - NOT "Environment", "System", "Card", or any other value
-  - For environments, use category "Interactable"
-  - For game systems, use category "Item" or omit the object entirely
-- narrative is OPTIONAL - omit entirely if not needed, don't use empty strings
-- narrative.externalData is OPTIONAL - omit if not needed
-  - If present, MUST be an object: { type: "Spreadsheet"|"Database"|"JSON", schema: string, sampleRows: number }
-  - NEVER use a string for externalData
-- stats.balanceFormulas is OPTIONAL - use [] if no formulas
-  - If formulas exist, each MUST be an object (see example above)
-  - NEVER use strings for formula array elements
-  - Variable types MUST be exactly "int", "float", or "bool" - NOT "array<int>", "number", "integer", or any other variation
-- stats.attributes values MUST be numbers or strings - NOT booleans
-  - Use strings for descriptive values: "Fast", "Slow", "Marked", "Unmarked"
-  - Use numbers for numeric values: 100, 5.5, 0
-  - NEVER use true/false for attributes
+CRITICAL - Category must be one of these EXACT values:
+- "NPC", "Monster", "Item", "Interactable", "Vehicle", "Card", "Building", "Ability"
+
+OPTIONAL FIELDS - Include ONLY if relevant:
+- narrative - OPTIONAL - brief backstory only
+- stats - OPTIONAL - simple attributes and behaviors
+- combat - OPTIONAL for combat entities (health, damage, armor)
+- social - OPTIONAL for NPCs (relationship type, questGiver boolean)
+- cardGame - OPTIONAL for cards (cost, effects, cardType)
+- ai - OPTIONAL for AI entities (aiType like "Passive" or "Aggressive")
+
+IMPORTANT - This is a DESIGN document:
+- Use descriptive attributes, not numeric RPG stats unless the game is an RPG
+- Do NOT include balance formulas or detailed math
+- Do NOT include detection radiuses, behavior trees, or AI implementation details
+- Focus on the entity's role in the game, not how it's programmed
 
 Output ONLY the JSON array.`;
         const response = await this.callLLMWithAutoRetry(prompt, modelSelector_1.TaskComplexity.COMPLEX, {
@@ -261,22 +544,22 @@ Output ONLY the JSON array.`;
         return this.parseJSON(response.content);
     }
     async generateCreativeAndTech(transcriptStr, metaAndFeatures, onProgress) {
-        const prompt = `Generate creative and technical sections.
+        const prompt = `Generate creative vision and technical overview sections.
 
 GAME: ${metaAndFeatures.meta.title}
 GENRE: ${metaAndFeatures.meta.genre.join(', ')}
 
-CONSTRAINTS - Be concise:
-- Art style: 2-3 sentences max
-- Audio mood: 2-3 sentences max
-- Keep asset counts realistic
+CONSTRAINTS - Focus on creative vision and high-level technical decisions:
+- Art style: 2-3 sentences describing the visual mood and aesthetic
+- Audio mood: 2-3 sentences describing the sound and music direction
+- Keep asset counts realistic estimates
+- Technical section should be a brief overview, not an engineering spec
 
 OUTPUT STRUCTURE (use this EXACT format):
 {
   "creative": {
-    "artStyle": "2-3 sentence description of visual style",
-    "audioMood": "2-3 sentence description of audio direction",
-    "referenceLinks": ["https://example.com/reference1"],
+    "artStyle": "2-3 sentence description of visual style, mood, and aesthetic influences",
+    "audioMood": "2-3 sentence description of music style and sound design direction",
     "assetRequirements": {
       "characters": 10,
       "environments": 5,
@@ -284,48 +567,44 @@ OUTPUT STRUCTURE (use this EXACT format):
       "ui": 15,
       "sfx": 30,
       "music": 8
-    },
-    "pipeline": {
-      "toolsRequired": ["Blender", "Photoshop", "Audacity"],
-      "workflowNotes": "Brief workflow description"
     }
   },
   "technical": {
     "engine": {
-      "primary": "Unreal Engine 5",
-      "version": "5.4",
-      "plugins": ["Niagara", "Chaos Physics"],
-      "reasoning": "Why this engine was chosen"
+      "primary": "Unity",
+      "version": "2023.2",
+      "reasoning": "Brief explanation of why this engine fits the project"
     },
-    "toolsRequired": [
-      {
-        "name": "Visual Studio",
-        "purpose": "C++ development",
-        "required": true
-      },
-      {
-        "name": "Git",
-        "purpose": "Version control",
-        "required": true
-      }
-    ],
-    "localization": {
-      "strategy": "English Only",
-      "languages": ["en"],
-      "stringCount": 500
-    },
-    "directoryStructure": "Assets/\n  Characters/\n  Environments/\nSource/\n  Core/\n  Features/",
     "buildTargets": ["Windows", "Mac"]
   }
 }
 
-CRITICAL - Field requirements:
+OPTIONAL FIELDS - Include ONLY if relevant:
+Creative:
+- assetRequirements.vehicles - OPTIONAL for games with vehicles
+- assetRequirements.cards - OPTIONAL for card games
+- assetRequirements.animations - OPTIONAL for animation-heavy games
+- visualNovel - OPTIONAL for visual novel games
+- rhythm - OPTIONAL for rhythm games
+- horror - OPTIONAL for horror games (atmosphere, lighting mood)
+
+Technical:
+- localization - OPTIONAL (strategy and languages only)
+- networking - OPTIONAL for multiplayer (architecture and maxPlayers only)
+- accessibility - OPTIONAL (colorblindMode, subtitles, remappableControls, difficultyOptions)
+
+CRITICAL:
 - engine.primary MUST be one of: "Unreal Engine 5", "Unity", "Godot", "Custom"
-- engine.plugins is OPTIONAL - use [] if none, or omit field entirely
-- localization.strategy MUST be: "None", "English Only", "EFIGS", or "Global"
-- localization.languages is OPTIONAL but recommended (use ["en"] for English Only)
+- localization.strategy (if included) MUST be: "None", "English Only", "EFIGS", or "Global"
 - buildTargets MUST use exact values: "Windows", "Mac", "Linux", "iOS", "Android", "Console"
 
+DO NOT INCLUDE (these are implementation details, not design):
+- Production pipeline or workflow
+- Tool lists or software requirements
+- Directory structures
+- Tick rates, bandwidth, or networking implementation details
+- Performance targets or scalability settings
+
 Output ONLY the JSON.`;
         const response = await this.callLLMWithAutoRetry(prompt, modelSelector_1.TaskComplexity.COMPLEX, {
             initialMaxTokens: 16000,
@@ -439,45 +718,29 @@ Output ONLY the JSON.`;
     "name": "string",
     "intent": "string",
     "dependencies": ["FEAT-XXX"],
-    "monetization": { "strategy": "None|IAP|Premium|Ads|Hybrid", "implementation": "string" },
     "gameplayLoop": ["step1", "step2"],
     "uiRequirements": ["string"],
     "technical": {
-      "dataStructure": "pseudo-code string",
-      "mathFormulas": [{ "expression": "string", "variables": {"name": {"type": "int|float|bool", "range": "string"}}, "validated": false, "balanceNotes": "string" }],
-      "fileLocation": "path/to/files",
       "estimatedComplexity": "Low|Medium|High|Very High"
-    },
-    "agile": {
-      "epic": "EPIC-XXX: Name",
-      "userStories": ["As a player, I want..."],
-      "acceptanceCriteria": ["Criteria"]
     }
   }],
   "gameObjects": [{
     "id": "NPC-XXX|ITEM-XXX|MON-XXX",
     "name": "string",
     "category": "NPC|Monster|Item|Interactable",
-    "narrative": { "backstory": "string", "dialogues": ["string"], "externalData": {...} },
+    "narrative": { "backstory": "string" },
     "stats": {
-      "attributes": {"HP": 100, "Speed": "Fast"},
-      "behaviors": ["string"],
-      "balanceFormulas": [...]
-    },
-    "references": { "features": ["FEAT-XXX"], "relatedEntities": ["ENTITY-XXX"] }
+      "attributes": {"Role": "Merchant", "Type": "Friendly"},
+      "behaviors": ["string"]
+    }
   }],
   "creative": {
     "artStyle": "string",
     "audioMood": "string",
-    "referenceLinks": ["url"],
-    "assetRequirements": { "characters": 0, "environments": 0, "props": 0, "ui": 0, "sfx": 0, "music": 0 },
-    "pipeline": { "toolsRequired": ["Tool"], "workflowNotes": "string" }
+    "assetRequirements": { "characters": 0, "environments": 0, "props": 0, "ui": 0, "sfx": 0, "music": 0 }
   },
   "technical": {
-    "engine": { "primary": "Unreal Engine 5|Unity|Godot|Custom", "version": "string", "plugins": ["string"], "reasoning": "string" },
-    "toolsRequired": [{ "name": "Tool", "purpose": "string", "required": true }],
-    "localization": { "strategy": "None|English Only|EFIGS|Global", "languages": ["en"], "stringCount": 0 },
-    "directoryStructure": "path structure",
+    "engine": { "primary": "Unreal Engine 5|Unity|Godot|Custom", "version": "string", "reasoning": "string" },
     "buildTargets": ["Windows", "Mac", "Linux", "iOS", "Android", "Console"]
   }
 }`;