briyah 1.1.8 → 1.2.1

package/dist-sdk/server/src/story/story.service.js

@@ -55,7 +55,7 @@ const agent_factory_1 = require("../ai/agent-factory");
 const room_factory_1 = require("../room/room-factory");
 const room_store_service_1 = require("../room/room-store.service");
 const app_types_1 = require("../../../shared/types/app.types");
-const configuration_service_1 = require("../config/configuration.service");
+const user_paths_service_1 = require("../config/user-paths.service");
 const artifact_service_1 = require("../ai/artifact.service");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -70,18 +70,18 @@ let StoryService = class StoryService {
     roomStore;
     progressService;
     messageService;
-    configService;
+    userPaths;
     agentFactory;
     roomFactory;
     storyArtifactServices = new Map();
     chaptersInProgress = new Set();
-    constructor(storyStore, agentStore, roomStore, progressService, messageService, configService, agentFactory, roomFactory) {
+    constructor(storyStore, agentStore, roomStore, progressService, messageService, userPaths, agentFactory, roomFactory) {
         this.storyStore = storyStore;
         this.agentStore = agentStore;
         this.roomStore = roomStore;
         this.progressService = progressService;
         this.messageService = messageService;
-        this.configService = configService;
+        this.userPaths = userPaths;
         this.agentFactory = agentFactory;
         this.roomFactory = roomFactory;
     }
@@ -101,7 +101,7 @@ let StoryService = class StoryService {
         let artifactService = this.storyArtifactServices.get(storyId);
         if (!artifactService) {
             const { artifactsDir } = this.getStoryStorageDirs(storyId);
-            artifactService = new artifact_service_1.ArtifactService(this.configService, artifactsDir);
+            artifactService = new artifact_service_1.ArtifactService(this.userPaths, artifactsDir);
             this.storyArtifactServices.set(storyId, artifactService);
         }
         return artifactService;
@@ -168,14 +168,14 @@ let StoryService = class StoryService {
         this.messageService.emitError(storyId, error);
     }
     getRandomWord() {
-        const randomWordsPath = path.join(this.configService.getCommonConfigDir(), 'random_words.txt');
+        const randomWordsPath = path.join(this.userPaths.getCommonConfigDir(), 'random_words.txt');
         const content = fs.readFileSync(randomWordsPath, 'utf-8');
         const words = content.split('\n').filter((word) => word.trim().length > 0);
         const randomIndex = Math.floor(Math.random() * words.length);
         return words[randomIndex];
     }
     getStoryStorageDirs(storyId) {
-        const userStoriesDir = path.join(this.configService.getUserDataDir(), 'stories');
+        const userStoriesDir = path.join(this.userPaths.getUserDataDir(), 'stories');
         return {
             agentsDir: path.join(userStoriesDir, storyId, 'agents'),
             roomsDir: path.join(userStoriesDir, storyId, 'rooms'),
@@ -183,7 +183,7 @@ let StoryService = class StoryService {
         };
     }
     getStoryModelConfig(storyModel) {
-        const storyModelsPath = path.join(this.configService.getCommonConfigDir(), 'story_models.json');
+        const storyModelsPath = path.join(this.userPaths.getCommonConfigDir(), 'story_models.json');
         try {
             const storyModels = JSON.parse(fs.readFileSync(storyModelsPath, 'utf8'));
             const modelConfig = storyModels.find((m) => m.name === storyModel);
@@ -242,8 +242,9 @@ let StoryService = class StoryService {
                 this.updateStorySituation(storyId, situation);
             });
             room.setOnModeratorResponse((message) => {
-                if (message.updatePortrait?.length) {
-                    for (const nickname of message.updatePortrait) {
+                const portraitsToUpdate = message.changes?.update_portrait ?? [];
+                if (portraitsToUpdate.length) {
+                    for (const nickname of portraitsToUpdate) {
                         const characterAgent = room
                             .getAgents()
                             .find((a) => a.agentNickname === nickname);
@@ -251,10 +252,11 @@ let StoryService = class StoryService {
                             this.updateCharacterPortrait(room, characterAgent, storyId).catch((e) => logger_1.logger.error(`Error updating portrait for ${nickname}:`, e));
                         }
                         else {
-                            logger_1.logger.warn(`update_portrait: agent "${nickname}" not found in room`);
+                            logger_1.logger.warn(`changes.update_portrait: agent "${nickname}" not found in room`);
                         }
                     }
                 }
+                this.applyInventoryUpdates(room, message);
             });
             if (story.situation) {
                 room.setSituation(story.situation);
@@ -311,6 +313,7 @@ let StoryService = class StoryService {
             let illustrator = null;
             if (artist) {
                 illustrator = this.agentFactory.createAgent(process.env.MODERATOR_AI_SERVICE || aiServiceName, `${storyTitle} - Illustrator`, 'Illustrator', 'Visual artist for generating scene illustrations', 'illustrator', process.env.MODERATOR_AI_MODEL || aiModelName, storyAgentsDir, storyArtifactService);
+                illustrator.reasoningEffort = 'low';
                 illustrator.maxHistoryMessages = 10;
                 illustrator.promptCacheTTL = 60;
                 illustrator.ownerRoomId = storyInfo.id;
@@ -440,8 +443,9 @@ let StoryService = class StoryService {
                 this.updateStorySituation(storyInfo.id, situation);
             });
             room.setOnModeratorResponse((message) => {
-                if (message.updatePortrait?.length) {
-                    for (const nickname of message.updatePortrait) {
+                const portraitsToUpdate = message.changes?.update_portrait ?? [];
+                if (portraitsToUpdate.length) {
+                    for (const nickname of portraitsToUpdate) {
                         const characterAgent = room
                             .getAgents()
                             .find((a) => a.agentNickname === nickname);
@@ -449,10 +453,11 @@ let StoryService = class StoryService {
                             this.updateCharacterPortrait(room, characterAgent, storyInfo.id).catch((e) => logger_1.logger.error(`Error updating portrait for ${nickname}:`, e));
                         }
                         else {
-                            logger_1.logger.warn(`update_portrait: agent "${nickname}" not found in room`);
+                            logger_1.logger.warn(`changes.update_portrait: agent "${nickname}" not found in room`);
                         }
                     }
                 }
+                this.applyInventoryUpdates(room, message);
             });
             storyInfo.roomId = roomId;
             storyInfo.moderatorAgentId = moderator.id;
@@ -543,6 +548,9 @@ let StoryService = class StoryService {
                     if (response.character?.character_profile) {
                         room.publishArtifact(`Character Profile - ${userAgent.agentNickname}`, userAgent.agentNickname, response.character.character_profile, [narrator.agentNickname, userAgent.agentNickname]);
                         logger_1.logger.log(`Published character profile for ${userCharacter.name} (human-controlled)`);
+                        if (response.character.inventory) {
+                            this.publishInventoryArtifact(room, userAgent.agentNickname, response.character.inventory);
+                        }
                         this.progressService.emitProgress(storyInfo.id, 'profiles', `Finished creating character profile for ${userCharacter.name}`);
                     }
                     else {
@@ -579,6 +587,9 @@ let StoryService = class StoryService {
                     if (response.character?.character_profile) {
                         room.publishArtifact(`Character Profile - ${agent.agentNickname}`, agent.agentNickname, response.character.character_profile, [agent.agentNickname]);
                         logger_1.logger.log(`Published character profile for ${charInfo.name}`);
+                        if (response.character.inventory) {
+                            this.publishInventoryArtifact(room, agent.agentNickname, response.character.inventory);
+                        }
                         this.progressService.emitProgress(storyInfo.id, 'profiles', `Finished creating character profile for ${charInfo.name}`);
                     }
                     else {
@@ -813,7 +824,7 @@ let StoryService = class StoryService {
         });
     }
     async importStoryFromZip(zipBuffer) {
-        const storiesDir = path.join(this.configService.getUserDataDir(), 'stories');
+        const storiesDir = path.join(this.userPaths.getUserDataDir(), 'stories');
         const importDir = path.join(storiesDir, 'import');
         try {
             if (fs.existsSync(importDir)) {
@@ -1057,6 +1068,7 @@ let StoryService = class StoryService {
         }
         else {
             logger_1.logger.log(`Skipping INTRODUCE message for ${characterName} (already introduced by narrator)`);
+            room.setCurrentSpeaker(room.getHumanAgentName());
         }
     }
     async declineCharacter(storyId, characterName) {
@@ -1440,6 +1452,33 @@ let StoryService = class StoryService {
         }
         return '';
     }
+    publishInventoryArtifact(room, characterNickname, body) {
+        if (!body || !body.trim())
+            return;
+        room.publishArtifact(`${characterNickname} - Inventory`, characterNickname, body, [characterNickname, 'Narrator', 'Moderator']);
+        logger_1.logger.log(`Published inventory for ${characterNickname}`);
+    }
+    applyInventoryUpdates(room, moderatorMessage) {
+        const updates = moderatorMessage.changes?.update_inventory ?? [];
+        if (!Array.isArray(updates) || updates.length === 0)
+            return;
+        for (const entry of updates) {
+            const characterName = entry?.characterName?.trim();
+            const inventory = entry?.inventory;
+            if (!characterName || !inventory) {
+                logger_1.logger.warn(`changes.update_inventory: skipping malformed entry: ${JSON.stringify(entry)}`);
+                continue;
+            }
+            const characterAgent = room
+                .getAgents()
+                .find((a) => a.agentNickname === characterName);
+            if (!characterAgent) {
+                logger_1.logger.warn(`changes.update_inventory: character "${characterName}" not found in room`);
+                continue;
+            }
+            this.publishInventoryArtifact(room, characterName, inventory);
+        }
+    }
     async updateCharacterProfiles(room, characterAgents, plotPlan = '') {
         const artifacts = room.getArtifacts();
         const updatePromises = characterAgents.map(async (character) => {
@@ -1467,6 +1506,9 @@ let StoryService = class StoryService {
                     character.save();
                 }
                 room.publishArtifact(`Character Profile - ${character.agentNickname}`, character.agentNickname, progressCharacterResponse.character_profile, [character.agentNickname]);
+                if (progressCharacterResponse.inventory) {
+                    this.publishInventoryArtifact(room, character.agentNickname, progressCharacterResponse.inventory);
+                }
             }
             catch (error) {
                 logger_1.logger.error(`Error updating character profile for ${character.agentNickname}:`, error);
@@ -1504,7 +1546,7 @@ let StoryService = class StoryService {
             if (!modelName) {
                 return null;
             }
-            const imageModelsPath = path.join(this.configService.getCommonConfigDir(), 'image_models.json');
+            const imageModelsPath = path.join(this.userPaths.getCommonConfigDir(), 'image_models.json');
             const imageModels = JSON.parse(fs.readFileSync(imageModelsPath, 'utf8'));
             const modelConfig = imageModels.find((m) => m.name === modelName);
             if (!modelConfig) {
@@ -1518,8 +1560,6 @@ let StoryService = class StoryService {
             return {
                 service: modelConfig.service,
                 model: modelConfig.model,
-                imageProperties: modelConfig.imageProperties,
-                centsPerImage: modelConfig.centsPerImage,
             };
         }
         catch (error) {
@@ -1527,6 +1567,27 @@ let StoryService = class StoryService {
             return null;
         }
     }
+    getImagePropertiesForAgent(agent) {
+        try {
+            const imageModelsPath = path.join(this.userPaths.getCommonConfigDir(), 'image_models.json');
+            const imageModels = JSON.parse(fs.readFileSync(imageModelsPath, 'utf8'));
+            const modelConfig = imageModels.find((m) => m.model === agent.modelName);
+            if (!modelConfig) {
+                logger_1.logger.warn(`No image_models.json entry for "${agent.modelName}"; image generation may fail`);
+                return {};
+            }
+            return {
+                ...(modelConfig.imageProperties ?? {}),
+                ...(modelConfig.centsPerImage != null
+                    ? { centsPerImage: modelConfig.centsPerImage }
+                    : {}),
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('Error loading image properties for agent:', error);
+            return {};
+        }
+    }
     createArtistAgent(storyId, storyAgentsDir, storyArtifactService, imageModelName, nickname = 'Artist') {
         const storyInfo = this.storyStore.getStory(storyId);
         const imageConfig = this.getImageModelConfig(imageModelName);
@@ -1537,26 +1598,26 @@ let StoryService = class StoryService {
         const artistAgent = this.agentFactory.createAgent(imageConfig.service, `${storyInfo.name} - ${nickname}`, nickname, 'AI artist for generating character portraits and scene illustrations', 'default', imageConfig.model, storyAgentsDir, storyArtifactService);
         artistAgent.maxHistoryMessages = 10;
         artistAgent.promptCacheTTL = 0;
-        artistAgent.imageProperties = {
-            ...(imageConfig?.imageProperties ?? {}),
-            ...(imageConfig?.centsPerImage != null ? { centsPerImage: imageConfig.centsPerImage } : {}),
-        };
         artistAgent.save();
         logger_1.logger.log(`Created artist agent: ${artistAgent.agentName} (${imageConfig.service}/${imageConfig.model})`);
         return artistAgent;
     }
     async generateCharacterPortrait(room, characterAgent, storyId) {
+        const artifacts = room.getArtifacts();
+        const profileArtifact = artifacts.find((a) => a.name === `Character Profile - ${characterAgent.agentNickname}`);
+        const storyInfo = this.storyStore.getStory(storyId);
+        const character = storyInfo.characters.find((c) => c.name === characterAgent.agentNickname);
+        const characterProfile = profileArtifact?.body || character?.description || '';
+        return this.generatePortraitForName(storyId, characterAgent.agentNickname, characterProfile, characterAgent);
+    }
+    async generatePortraitForName(storyId, characterName, characterProfile, promptAgent) {
         try {
-            const artifacts = room.getArtifacts();
-            const profileArtifact = artifacts.find((a) => a.name === `Character Profile - ${characterAgent.agentNickname}`);
-            const storyInfo = this.storyStore.getStory(storyId);
-            const scenario = storyInfo?.scenario || '';
-            const character = storyInfo.characters.find((c) => c.name === characterAgent.agentNickname);
-            let characterDescription = profileArtifact?.body || character?.description || '';
-            if (!characterDescription) {
-                logger_1.logger.warn(`No profile for ${characterAgent.agentNickname}, skipping portrait`);
+            if (!characterProfile) {
+                logger_1.logger.warn(`No profile for ${characterName}, skipping portrait`);
                 return null;
             }
+            const storyInfo = this.storyStore.getStory(storyId);
+            const scenario = storyInfo?.scenario || '';
             const storyArtifactService = this.getStoryArtifactService(storyId);
             const artistAgent = await this.agentStore.getAgent(storyInfo.artistAgentId);
             if (!artistAgent) {
@@ -1564,28 +1625,29 @@ let StoryService = class StoryService {
                 return null;
             }
             artistAgent.artifactService = storyArtifactService;
-            const visualDescription = await characterAgent.preparedPrompt('describe_character', {
-                characterName: characterAgent.agentNickname,
-                characterProfile: characterDescription,
-                scenario: scenario,
+            const describeAgent = promptAgent || artistAgent;
+            const visualDescription = await describeAgent.preparedPrompt('describe_character', {
+                characterName,
+                characterProfile,
+                scenario,
             }, false);
             if (!visualDescription || typeof visualDescription !== 'string') {
-                logger_1.logger.warn(`Failed to generate visual description for ${characterAgent.agentNickname}`);
+                logger_1.logger.warn(`Failed to generate visual description for ${characterName}`);
                 return null;
             }
-            const imageResult = await artistAgent.generateImage(visualDescription);
+            const imageResult = await artistAgent.generateImage(visualDescription, this.getImagePropertiesForAgent(artistAgent));
             if (imageResult.error) {
                 return null;
             }
             artistAgent.save();
             const artifactId = imageResult.artifactId;
-            storyArtifactService.renameArtifact(artifactId, `Portrait - ${characterAgent.agentNickname}`);
+            storyArtifactService.renameArtifact(artifactId, `Portrait - ${characterName}`);
             storyArtifactService.updateArtifactDescription(artifactId, visualDescription);
-            logger_1.logger.log(`Generated portrait for ${characterAgent.agentNickname}: ${artifactId}`);
+            logger_1.logger.log(`Generated portrait for ${characterName}: ${artifactId}`);
             return artifactId;
         }
         catch (error) {
-            logger_1.logger.error(`Error generating portrait for ${characterAgent.agentNickname}:`, error);
+            logger_1.logger.error(`Error generating portrait for ${characterName}:`, error);
             return null;
         }
     }
@@ -1617,8 +1679,8 @@ let StoryService = class StoryService {
                 .listArtifacts()
                 .find((a) => a.name === portraitName);
             if (!existingPortrait) {
-                logger_1.logger.warn(`No existing portrait for ${characterAgent.agentNickname}, cannot update`);
-                return null;
+                logger_1.logger.warn(`No existing portrait for ${characterAgent.agentNickname}, generating from scratch`);
+                return this.generateCharacterPortrait(room, characterAgent, storyId);
             }
             const visualDescription = await characterAgent.preparedPrompt('update_portrait', {
                 characterName: characterAgent.agentNickname,
@@ -1629,9 +1691,7 @@ let StoryService = class StoryService {
                 logger_1.logger.warn(`Failed to generate update description for ${characterAgent.agentNickname}`);
                 return null;
             }
-            const imageResult = await artistEditAgent.editImage(visualDescription, [
-                existingPortrait.artifactId,
-            ]);
+            const imageResult = await artistEditAgent.editImage(visualDescription, this.getImagePropertiesForAgent(artistEditAgent), [existingPortrait.artifactId]);
             if (imageResult.error) {
                 return null;
             }
@@ -1674,6 +1734,12 @@ let StoryService = class StoryService {
                 name: a.name.replace('Scene - ', ''),
                 description: a.description || '',
             }));
+            const portraitCharacters = allArtifacts
+                .filter((a) => a.name.startsWith('Portrait - '))
+                .map((a) => ({
+                name: a.name.replace('Portrait - ', ''),
+                description: a.description || '',
+            }));
             let existingScenesString = existingScenes
                 .map((s) => `- ${s.name}: ${s.description}`)
                 .join('\n');
@@ -1682,7 +1748,7 @@ let StoryService = class StoryService {
                     'No scene reference images have been created yet. (set isReference: true)';
             let prompt = `**Current Situation**:\n ${story.situation}\n\n**Existing Scenes**:\n ${existingScenesString}`;
             const sceneAnalysis = await illustrator.instructedPrompt(prompt, 'describe_scene', {
-                characters: story.characters,
+                characters: portraitCharacters,
             }, true, true);
             illustrator.save();
             if (!sceneAnalysis || !sceneAnalysis.createImage) {
@@ -1694,10 +1760,13 @@ let StoryService = class StoryService {
                     logger_1.logger.warn(`Illustrator requested another reference (${sceneAnalysis.sceneName}) after one was just created; skipping to avoid loop`);
                     return;
                 }
-                await this.generateSceneReference(storyId, sceneAnalysis.sceneName, sceneAnalysis.sceneDescription);
-                await this.generateSceneIllustration(storyId, situation, false);
+                const referenceCreated = await this.generateSceneReference(storyId, sceneAnalysis.sceneName, sceneAnalysis.sceneDescription);
+                if (referenceCreated) {
+                    await this.generateSceneIllustration(storyId, situation, false);
+                }
             }
             else {
+                await this.ensureMinorCharacterPortraits(storyId, sceneAnalysis.characterNames || [], sceneAnalysis.newCharacters || [], portraitCharacters.map((c) => c.name), illustrator);
                 await this.generateStoryImage(storyId, story.turnNumber, sceneAnalysis.imageCaption, sceneAnalysis.sceneName, sceneAnalysis.sceneDescription, sceneAnalysis.characterNames);
             }
         }
@@ -1705,37 +1774,54 @@ let StoryService = class StoryService {
             logger_1.logger.error('Scene illustration error:', error);
         }
     }
+    async ensureMinorCharacterPortraits(storyId, characterNames, newCharacters, existingPortraitNames, promptAgent) {
+        const existing = new Set(existingPortraitNames);
+        const descriptionsByName = new Map(newCharacters.map((c) => [c.name, c.briefDescription]));
+        for (const name of characterNames) {
+            if (existing.has(name))
+                continue;
+            const briefDescription = descriptionsByName.get(name);
+            if (!briefDescription) {
+                logger_1.logger.warn(`Illustrator named "${name}" but provided no newCharacters entry; portrait will be skipped`);
+                continue;
+            }
+            await this.generatePortraitForName(storyId, name, briefDescription, promptAgent);
+        }
+    }
     async generateSceneReference(storyId, sceneName, sceneDescription) {
         try {
             logger_1.logger.log(`Generating scene reference: ${sceneName}`);
             const storyInfo = this.storyStore.getStory(storyId);
             if (!storyInfo || !storyInfo.artistAgentId) {
                 logger_1.logger.error(`Cannot generate scene reference: story ${storyId} has no artist agent`);
-                return;
+                return false;
             }
             const artistAgent = await this.agentStore.getAgent(storyInfo.artistAgentId);
             if (!artistAgent) {
                 logger_1.logger.error(`Artist agent not found: ${storyInfo.artistAgentId}`);
-                return;
+                return false;
             }
             const storyArtifactService = this.getStoryArtifactService(storyId);
             if (!storyArtifactService) {
                 logger_1.logger.error(`Story artifact service not found: ${storyId}`);
-                return;
+                return false;
             }
             artistAgent.artifactService = storyArtifactService;
-            const imageResult = await artistAgent.generateImage(sceneDescription);
+            const imageResult = await artistAgent.generateImage(sceneDescription, this.getImagePropertiesForAgent(artistAgent));
             if (imageResult.error) {
-                return;
+                logger_1.logger.error(`Scene reference image generation failed for "${sceneName}":`, imageResult.error);
+                return false;
             }
             artistAgent.save();
             const artifactId = imageResult.artifactId;
             storyArtifactService.renameArtifact(artifactId, `Scene - ${sceneName}`);
             storyArtifactService.updateArtifactDescription(artifactId, sceneDescription);
             logger_1.logger.log(`Generated scene reference: ${sceneName} (${artifactId})`);
+            return true;
         }
         catch (error) {
             logger_1.logger.error('Scene reference generation error:', error);
+            return false;
         }
     }
     async generateStoryImage(storyId, turnNumber, imageCaption, sceneName, sceneDescription, characterNames) {
@@ -1748,17 +1834,6 @@ let StoryService = class StoryService {
                 logger_1.logger.warn(`Scene not found: ${sceneName}`);
                 return;
             }
-            const characterPortraitIds = [];
-            for (const charName of characterNames) {
-                const portrait = allArtifacts.find((a) => a.name === `Portrait - ${charName}`);
-                if (portrait) {
-                    characterPortraitIds.push(portrait.artifactId);
-                }
-                else {
-                    logger_1.logger.warn(`Portrait not found: ${charName}`);
-                }
-            }
-            const referenceImageIds = [sceneArtifact.artifactId, ...characterPortraitIds];
             const storyInfo = this.storyStore.getStory(storyId);
             if (!storyInfo || !storyInfo.artistAgentId) {
                 logger_1.logger.error(`Cannot generate story image: story ${storyId} has no artist agent`);
@@ -1770,6 +1845,34 @@ let StoryService = class StoryService {
                 return;
             }
             artistAgent.artifactService = storyArtifactService;
+            const room = await this.getStoryRoom(storyId);
+            const characterPortraitIds = [];
+            for (const charName of characterNames) {
+                const currentArtifacts = storyArtifactService.listArtifacts();
+                const portrait = currentArtifacts.find((a) => a.name === `Portrait - ${charName}`);
+                if (portrait) {
+                    characterPortraitIds.push(portrait.artifactId);
+                }
+                else {
+                    logger_1.logger.warn(`Portrait not found for ${charName}, generating now`);
+                    const characterAgent = room
+                        .getAgents()
+                        .find((a) => a.agentNickname === charName);
+                    if (characterAgent) {
+                        const newPortraitId = await this.generateCharacterPortrait(room, characterAgent, storyId);
+                        if (newPortraitId) {
+                            characterPortraitIds.push(newPortraitId);
+                        }
+                        else {
+                            logger_1.logger.warn(`Could not generate portrait for ${charName}, skipping`);
+                        }
+                    }
+                    else {
+                        logger_1.logger.warn(`No agent found for character ${charName}, skipping portrait`);
+                    }
+                }
+            }
+            const referenceImageIds = [sceneArtifact.artifactId, ...characterPortraitIds];
             const editAgent = storyInfo.artistEditAgentId
                 ? await this.agentStore.getAgent(storyInfo.artistEditAgentId)
                 : null;
@@ -1777,8 +1880,8 @@ let StoryService = class StoryService {
                 editAgent.artifactService = storyArtifactService;
             }
             const imageResult = referenceImageIds?.length && editAgent
-                ? await editAgent.editImage(sceneDescription, referenceImageIds)
-                : await artistAgent.generateImage(sceneDescription);
+                ? await editAgent.editImage(sceneDescription, this.getImagePropertiesForAgent(editAgent), referenceImageIds)
+                : await artistAgent.generateImage(sceneDescription, this.getImagePropertiesForAgent(artistAgent));
             if (imageResult.error) {
                 return;
             }
@@ -1788,7 +1891,6 @@ let StoryService = class StoryService {
             storyArtifactService.updateArtifactDescription(artifactId, imageCaption);
             logger_1.logger.log(`Generated story image: ${imageCaption} (${artifactId})`);
             try {
-                const room = await this.getStoryRoom(storyId);
                 const imgUrl = `/api/stories/${storyId}/artifacts/${artifactId}`;
                 const imageMarkdown = `![${imageCaption}](${imgUrl})`;
                 const imageMessage = new message_1.RoomMessage(imageCaption, app_types_1.MessageAction.SYSTEM, imageMarkdown);
@@ -1803,16 +1905,51 @@ let StoryService = class StoryService {
             logger_1.logger.error('Story image generation error:', error);
         }
     }
-    async updateStorySituation(storyId, situation) {
+    parseNarratorPreamble(preamble) {
+        const result = {};
+        if (!preamble)
+            return result;
+        const extractTag = (raw, tag) => {
+            const re = new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`, 'i');
+            const m = raw.match(re);
+            return m ? m[1].trim() : undefined;
+        };
+        const time = extractTag(preamble, 'time');
+        const situation = extractTag(preamble, 'situation');
+        const introduceRaw = extractTag(preamble, 'introduce_character');
+        const progressRaw = extractTag(preamble, 'progress_chapter');
+        if (time)
+            result.time = time;
+        if (situation)
+            result.situation = situation;
+        if (introduceRaw) {
+            const firstToken = introduceRaw.split(/[\s(:,]/)[0];
+            if (firstToken && firstToken.toLowerCase() !== 'none') {
+                result.introduceCharacter = firstToken;
+            }
+        }
+        if (progressRaw && /^\s*yes\b/i.test(progressRaw)) {
+            result.progressChapter = true;
+        }
+        return result;
+    }
+    formatDisplaySituation(parsed, fallback) {
+        if (parsed.time && parsed.situation)
+            return `${parsed.time} - ${parsed.situation}`;
+        if (parsed.situation)
+            return parsed.situation;
+        return fallback;
+    }
+    async updateStorySituation(storyId, preamble) {
         const story = this.storyStore.getStory(storyId);
         if (!story)
             return;
         const room = await this.getStoryRoom(storyId);
-        let progressChapter = situation.startsWith('PROGRESS');
-        if (progressChapter) {
-            if (story) {
-                story.declinedCharacters = [];
-            }
+        const parsed = this.parseNarratorPreamble(preamble);
+        const displaySituation = this.formatDisplaySituation(parsed, preamble);
+        room.setSituation(displaySituation);
+        if (parsed.progressChapter) {
+            story.declinedCharacters = [];
             story.pendingSuggestion = {
                 type: 'suggest-progress-chapter',
                 timestamp: Date.now(),
@@ -1821,36 +1958,33 @@ let StoryService = class StoryService {
             this.messageService.emitProgressChapter(storyId);
             return;
         }
-        let agentCompactionThreshold = Number(process.env.AGENT_COMPACTION_THRESHOLD) || 150000;
+        let agentCompactionThreshold = Number(process.env.AGENT_COMPACTION_THRESHOLD) || 100000;
         await this.compactAgentHistories(room.getAgents(), agentCompactionThreshold);
-        let introduce = situation.startsWith('INTRODUCE:');
-        if (introduce) {
-            let newCharacterName = situation.substring(11).trim();
-            if (newCharacterName) {
-                const existingAgent = room.getAgents().find((a) => room.checkAgentNicknameMatch(a.agentNickname, newCharacterName));
-                if (existingAgent) {
-                    logger_1.logger.log(`INTRODUCE: ${newCharacterName} ignored — character already in story`);
-                    return;
-                }
-                const declinedCharacters = story?.declinedCharacters || [];
-                if (declinedCharacters.includes(newCharacterName)) {
-                    logger_1.logger.log(`Character ${newCharacterName} was declined, skipping prompt`);
-                    return;
-                }
-                story.pendingSuggestion = {
-                    type: 'suggest-introduce-character',
-                    characterName: newCharacterName,
-                    timestamp: Date.now(),
-                };
-                this.storyStore.updateStoryMetadata(storyId, story);
-                this.messageService.emitIntroduceCharacter(storyId, newCharacterName);
+        if (parsed.introduceCharacter) {
+            const newCharacterName = parsed.introduceCharacter;
+            const existingAgent = room.getAgents().find((a) => room.checkAgentNicknameMatch(a.agentNickname, newCharacterName));
+            if (existingAgent) {
+                logger_1.logger.log(`INTRODUCE: ${newCharacterName} ignored - character already in story`);
+                return;
             }
+            const declinedCharacters = story?.declinedCharacters || [];
+            if (declinedCharacters.includes(newCharacterName)) {
+                logger_1.logger.log(`Character ${newCharacterName} was declined, skipping prompt`);
+                return;
+            }
+            story.pendingSuggestion = {
+                type: 'suggest-introduce-character',
+                characterName: newCharacterName,
+                timestamp: Date.now(),
+            };
+            this.storyStore.updateStoryMetadata(storyId, story);
+            this.messageService.emitIntroduceCharacter(storyId, newCharacterName);
             return;
         }
-        story.situation = situation;
+        story.situation = displaySituation;
         this.storyStore.updateStoryMetadata(storyId, story);
-        logger_1.logger.log(`Updated story ${storyId} situation: ${situation}`);
-        this.generateSceneIllustration(storyId, situation).catch((error) => {
+        logger_1.logger.log(`Updated story ${storyId} situation: ${displaySituation}`);
+        this.generateSceneIllustration(storyId, displaySituation).catch((error) => {
             logger_1.logger.error('Illustration generation error:', error);
         });
     }
@@ -1887,7 +2021,7 @@ let StoryService = class StoryService {
         if (!story) {
             throw new Error('Story not found');
         }
-        const userStoriesDir = path.join(this.configService.getUserDataDir(), 'stories');
+        const userStoriesDir = path.join(this.userPaths.getUserDataDir(), 'stories');
         const storyFolderPath = path.join(userStoriesDir, storyId);
         if (!fs.existsSync(storyFolderPath)) {
             throw new Error('Story folder not found on disk');
@@ -1981,7 +2115,7 @@ exports.StoryService = StoryService = __decorate([
         room_store_service_1.RoomStoreService,
         story_progress_service_1.StoryProgressService,
         story_message_service_1.StoryMessageService,
-        configuration_service_1.ConfigurationService,
+        user_paths_service_1.UserPathsService,
         agent_factory_1.AgentFactory,
         room_factory_1.RoomFactory])
 ], StoryService);

package/dist-sdk/shared/types/app.types.d.ts

@@ -307,6 +307,7 @@ export interface ChaptersResponse {
 export interface ProgressCharacterResponse {
     description: string;
     character_profile: string;
+    inventory?: string;
 }
 export interface CreatePaymentIntentRequest {
     amount: number;

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJx1jc0KgzAQhN9lzrESpWnJO/TSq3gIutbQmEA2niTvXtI/pNDTwM63822IISSG7lQre4FIk6Mh2eAZeoNqZQlvFoLGhZjNjSBwt36Ebo5KYI0OGtYnipMZiOs3dZjT4iAwOMMMjcRjVd6qL1rK2boxkofupDypPguU3DmvISy/XtmcP97nOnG9w/6KX4ec8wMB2FBE"
+window.hierarchyData = "eJx1jc0KgzAQhN9lzmklSkX2HXrpVTwEXWtoTCCbniTvXtI/pNDTwM63822IISQB9W2jB4XIs+Mx2eAFtKFtdAlvVgbhzCLmylC4WT+B6lOrcI8OBOsTx9mMLNWbOi5pdVAYnREBIcl0KG+HL1rKxbopsgf1WnfdkBVK7pyXENZfr667j/e5zlLtsL/i1yHn/AAEMlBK"