briyah 1.1.0 → 1.1.1

package/{dist → dist-sdk}/server/src/app.controller.js

@@ -827,6 +827,34 @@ let AppController = class AppController {
             throw new common_1.HttpException('Failed to reload agent', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
+    async compactAgentConversation(req, agentId) {
+        if (!agentId) {
+            throw new common_1.BadRequestException('Agent ID is required');
+        }
+        try {
+            const appService = this.getAppService(req, agentId);
+            if (req.user.type === 'agent-access') {
+                const agentDetails = await appService.getAgentDetails(agentId);
+                if (!agentDetails || !agentDetails.isPublished) {
+                    throw new common_1.ForbiddenException('Agent is not published');
+                }
+            }
+            await appService.compactAgentConversation(agentId);
+        }
+        catch (error) {
+            logger_1.logger.error(`[${req.user?.sub}] Error compacting agent ${agentId}:`, error);
+            if (error instanceof errors_1.NotFoundError) {
+                throw new common_1.NotFoundException(error.message);
+            }
+            if (error instanceof errors_1.OperationFailedError) {
+                throw new common_1.HttpException(error.message, common_1.HttpStatus.INTERNAL_SERVER_ERROR);
+            }
+            if (error instanceof common_1.ForbiddenException) {
+                throw error;
+            }
+            throw new common_1.HttpException('Failed to compact agent conversation', common_1.HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
     async resetRoom(req, roomId) {
         if (!roomId) {
             throw new common_1.BadRequestException('Room ID is required');
@@ -1412,6 +1440,9 @@ let AppController = class AppController {
                 subscriber.next({
                     data: { type: 'connected', storyId },
                 });
+                if (storyInfo.pendingSuggestion) {
+                    subscriber.next({ data: storyInfo.pendingSuggestion });
+                }
                 const updateHandler = (data) => {
                     subscriber.next({ data });
                 };
@@ -2076,6 +2107,16 @@ __decorate([
     __metadata("design:paramtypes", [Object, String]),
     __metadata("design:returntype", Promise)
 ], AppController.prototype, "reloadAgent", null);
+__decorate([
+    (0, agent_access_decorator_1.AgentAccess)(),
+    (0, common_1.Post)('agents/:agentId/compact'),
+    (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),
+    __param(0, (0, common_1.Request)()),
+    __param(1, (0, common_1.Param)('agentId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], AppController.prototype, "compactAgentConversation", null);
 __decorate([
     (0, common_1.Post)('rooms/:roomId/reset'),
     (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),

package/{dist → dist-sdk}/server/src/app.service.d.ts

@@ -111,6 +111,7 @@ export declare class AppService {
     deleteAttachedFile(agentId: string, fileName: string): Promise<void>;
     deleteAttachedFileById(documentId: string): Promise<void>;
     reloadAgent(agentId: string): Promise<void>;
+    compactAgentConversation(agentId: string): Promise<void>;
     resetRoom(roomId: string): Promise<void>;
     resetStory(storyId: string): Promise<void>;
     createStory(name: string, idea: string, userCharacterDesc: string, otherCharactersDesc: string, storyModel?: string, isImport?: boolean, imageModelName?: string): Promise<StoryInfo>;

package/{dist → dist-sdk}/server/src/app.service.js

@@ -890,6 +890,13 @@ class AppService {
         }
         agent.save();
     }
+    async compactAgentConversation(agentId) {
+        const agent = await this.agentStore.getAgent(agentId);
+        if (!agent) {
+            throw new errors_1.NotFoundError('Agent not found');
+        }
+        await agent.compact();
+    }
     async resetRoom(roomId) {
         const room = await this.roomStore.getRoom(roomId);
         if (!room) {

package/{dist → dist-sdk}/server/src/auth/users.service.js

@@ -52,7 +52,7 @@ let UsersService = class UsersService {
     usersFilePath;
     dataDir;
     constructor() {
-        this.dataDir = process.env.SERVER_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
+        this.dataDir = process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
         const commonDir = path.resolve(this.dataDir, 'common');
         const usersDir = path.resolve(commonDir, 'users');
         this.usersFilePath = path.resolve(usersDir, 'users.json');

package/{dist → dist-sdk}/server/src/config/configuration.service.js

@@ -49,7 +49,7 @@ class ConfigurationService {
     userId;
     constructor(userId, baseDataPath) {
         this.userId = userId;
-        const dataPath = baseDataPath || process.env.SERVER_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
+        const dataPath = baseDataPath || process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
         this.dataDir = path.resolve(dataPath);
         if (!fs.existsSync(this.dataDir)) {
             fs.mkdirSync(this.dataDir, { recursive: true });

package/{dist → dist-sdk}/server/src/room/published-rooms.service.js

@@ -51,7 +51,7 @@ let PublishedRoomsService = class PublishedRoomsService {
     mapping;
     filePath;
     constructor() {
-        const dataPath = process.env.SERVER_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
+        const dataPath = process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
         this.filePath = path.join(dataPath, 'common', 'published-rooms.json');
         this.mapping = new Map();
         this.load();

package/{dist → dist-sdk}/server/src/room/room.js

@@ -272,6 +272,7 @@ class Room {
             let response = await agent.instructedPrompt(prompt, 'perceive', variables, false, true, maxOutputChars);
             answer = this.parseAgentResponse(agent, response);
             agent.addToConversationHistory(response, true);
+            agent.save();
         }
         catch (e) {
             if (e instanceof errors_1.InsufficientBalanceError) {

package/{dist → dist-sdk}/server/src/sdk/briyah-config.js

@@ -9,8 +9,8 @@ class BriyahConfigService {
             ...(options?.envOverrides || {}),
         };
         if (options?.dataPath) {
-            this.env.SERVER_DATA_PATH = options.dataPath;
-            process.env.SERVER_DATA_PATH = options.dataPath;
+            this.env.BRIYAH_DATA_PATH = options.dataPath;
+            process.env.BRIYAH_DATA_PATH = options.dataPath;
         }
         if (options?.userServiceCacheTimeoutMinutes !== undefined) {
             this.env.USER_SERVICE_CACHE_TIMEOUT_MINUTES = String(options.userServiceCacheTimeoutMinutes);

package/{dist → dist-sdk}/server/src/sdk/briyah.js

@@ -72,7 +72,7 @@ class Briyah {
     initialized = false;
     constructor(options) {
         this.configService = new briyah_config_1.BriyahConfigService(options);
-        const dataPath = this.configService.get('SERVER_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
+        const dataPath = this.configService.get('BRIYAH_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
         logger_1.logger.configure({
             enabled: options?.logging?.enabled !== false,
             console: options?.logging?.console !== false,
@@ -131,7 +131,7 @@ class Briyah {
         this.initialized = true;
     }
     seedCommonData() {
-        const dataPath = this.configService.get('SERVER_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
+        const dataPath = this.configService.get('BRIYAH_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
         const userCommonDir = path.resolve(dataPath, 'common');
         const packageCommonDir = path.resolve(__dirname, '../../../../data/common');
         if (!fs.existsSync(packageCommonDir)) {

package/{dist → dist-sdk}/server/src/story/story-message.service.js

@@ -23,44 +23,36 @@ let StoryMessageService = class StoryMessageService {
         return this.messageEmitters.get(storyId);
     }
     emitStoryState(storyId, state) {
-        const emitter = this.messageEmitters.get(storyId);
-        if (emitter) {
-            const payload = { type: 'story-state', state, timestamp: Date.now() };
-            emitter.emit('story-state', payload);
-        }
+        const emitter = this.getOrCreateEmitter(storyId);
+        const payload = { type: 'story-state', state, timestamp: Date.now() };
+        emitter.emit('story-state', payload);
     }
     emitIntroduceCharacter(storyId, characterName) {
-        const emitter = this.messageEmitters.get(storyId);
-        if (emitter) {
-            const payload = {
-                type: 'suggest-introduce-character',
-                characterName,
-                timestamp: Date.now(),
-            };
-            emitter.emit('suggest-introduce-character', payload);
-        }
+        const emitter = this.getOrCreateEmitter(storyId);
+        const payload = {
+            type: 'suggest-introduce-character',
+            characterName,
+            timestamp: Date.now(),
+        };
+        emitter.emit('suggest-introduce-character', payload);
     }
     emitProgressChapter(storyId) {
-        const emitter = this.messageEmitters.get(storyId);
-        if (emitter) {
-            const payload = {
-                type: 'suggest-progress-chapter',
-                timestamp: Date.now(),
-            };
-            emitter.emit('suggest-progress-chapter', payload);
-        }
+        const emitter = this.getOrCreateEmitter(storyId);
+        const payload = {
+            type: 'suggest-progress-chapter',
+            timestamp: Date.now(),
+        };
+        emitter.emit('suggest-progress-chapter', payload);
     }
     emitError(storyId, error) {
-        const emitter = this.messageEmitters.get(storyId);
-        if (emitter) {
-            const payload = {
-                type: 'story-error',
-                errorType: error.name,
-                message: error.message,
-                timestamp: Date.now(),
-            };
-            emitter.emit('story-error', payload);
-        }
+        const emitter = this.getOrCreateEmitter(storyId);
+        const payload = {
+            type: 'story-error',
+            errorType: error.name,
+            message: error.message,
+            timestamp: Date.now(),
+        };
+        emitter.emit('story-error', payload);
     }
     cleanup(storyId) {
         const emitter = this.messageEmitters.get(storyId);

package/{dist → dist-sdk}/server/src/story/story.service.d.ts

@@ -20,6 +20,7 @@ export declare class StoryService {
     private readonly agentFactory;
     private readonly roomFactory;
     private readonly storyArtifactServices;
+    private readonly chaptersInProgress;
     constructor(storyStore: StoryStoreService, agentStore: AgentStoreService, roomStore: RoomStoreService, progressService: StoryProgressService, messageService: StoryMessageService, configService: ConfigurationService, agentFactory: AgentFactory, roomFactory: RoomFactory);
     getProgressEmitter(storyId: string): import("node:events")<any>;
     getMessageEmitter(storyId: string): import("node:events")<any>;
@@ -72,7 +73,6 @@ export declare class StoryService {
     private progressStoryToNextChapterAsync;
     private generateOpeningScene;
     private compactAgentHistories;
-    private compactAgentHistory;
     private extractMarkdownContent;
     private updatePlotPlan;
     private updateCharacterProfiles;

package/{dist → dist-sdk}/server/src/story/story.service.js

@@ -74,6 +74,7 @@ let StoryService = class StoryService {
     agentFactory;
     roomFactory;
     storyArtifactServices = new Map();
+    chaptersInProgress = new Set();
     constructor(storyStore, agentStore, roomStore, progressService, messageService, configService, agentFactory, roomFactory) {
         this.storyStore = storyStore;
         this.agentStore = agentStore;
@@ -254,6 +255,7 @@ let StoryService = class StoryService {
         }
         const storyInfo = this.storyStore.createStory(name);
         storyInfo.turnNumber = 0;
+        let storyTitle = name;
         try {
             this.progressService.createProgressEmitter(storyInfo.id);
             this.progressService.emitProgress(storyInfo.id, 'start', 'Starting story creation...');
@@ -270,7 +272,7 @@ let StoryService = class StoryService {
             }
             if (!aiServiceName || !aiModelName)
                 throw new Error(`Failed to find model config for "${storyModel}"`);
-            let moderator = this.agentFactory.createAgent(process.env.MODERATOR_AI_SERVICE || aiServiceName, 'Moderator', '', 'Story moderator responsible for message routing and conversation flow', 'story_moderator', process.env.MODERATOR_AI_MODEL || aiModelName, storyAgentsDir, storyArtifactService);
+            let moderator = this.agentFactory.createAgent(process.env.MODERATOR_AI_SERVICE || aiServiceName, `${storyTitle} - Moderator`, 'Moderator', 'Story moderator responsible for message routing and conversation flow', 'story_moderator', process.env.MODERATOR_AI_MODEL || aiModelName, storyAgentsDir, storyArtifactService);
             moderator.maxHistoryMessages = 16;
             moderator.reasoningEffort = 'low';
             moderator.promptCacheTTL = 60;
@@ -281,14 +283,14 @@ let StoryService = class StoryService {
             const artist = this.createArtistAgent(storyInfo.id, storyAgentsDir, storyArtifactService, imageModelName);
             let illustrator = null;
             if (artist) {
-                illustrator = this.agentFactory.createAgent(process.env.MODERATOR_AI_SERVICE || aiServiceName, 'Illustrator', '', 'Visual artist for generating scene illustrations', 'illustrator', process.env.MODERATOR_AI_MODEL || aiModelName, storyAgentsDir, storyArtifactService);
+                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.maxHistoryMessages = 10;
                 illustrator.promptCacheTTL = 60;
                 illustrator.ownerRoomId = storyInfo.id;
                 illustrator.save();
                 logger_1.logger.log(`Created illustrator agent: ${illustrator.agentName}`);
             }
-            let narrator = this.agentFactory.createAgent(aiServiceName, 'Narrator', '', 'Story narrator. Should receive all messages where a character wants to perform an action or PASS or INTRODUCE a new character. Responds to all dialog with characters not listed in Available Agents.', 'narrator', aiModelName, storyAgentsDir, storyArtifactService);
+            let narrator = this.agentFactory.createAgent(aiServiceName, `${storyTitle} - Narrator`, 'Narrator', 'Story narrator. Should receive all messages where a character wants to perform an action or PASS or INTRODUCE a new character. Responds to all dialog with characters not listed in Available Agents.', 'narrator', aiModelName, storyAgentsDir, storyArtifactService);
             narrator.reasoningEffort = 'low';
             narrator.allowSearch = true;
             narrator.promptCacheTTL = 60;
@@ -974,6 +976,21 @@ let StoryService = class StoryService {
         const introducedCharPlotPlanArtifact = introducedCharArtifacts.find((a) => a.name === 'Plot Plan');
         const introducedCharPlotPlan = introducedCharPlotPlanArtifact?.body || '';
         await this.updateCharacterProfiles(room, [characterAgent], introducedCharPlotPlan);
+        if (!story.characters) {
+            story.characters = [];
+        }
+        if (!story.characters.some((c) => c.name === characterName)) {
+            story.characters.push({
+                name: characterName,
+                description: characterAgent.description,
+                isControlledByHuman: false,
+            });
+        }
+        if (story.pendingSuggestion?.type === 'suggest-introduce-character' &&
+            story.pendingSuggestion.characterName === characterName) {
+            story.pendingSuggestion = undefined;
+        }
+        this.storyStore.updateStoryMetadata(storyId, story);
         try {
             const artifactId = await this.generateCharacterPortrait(room, characterAgent, storyId);
             if (artifactId) {
@@ -1000,9 +1017,13 @@ let StoryService = class StoryService {
         }
         if (!story.declinedCharacters.includes(characterName)) {
             story.declinedCharacters.push(characterName);
-            this.storyStore.updateStoryMetadata(storyId, story);
             logger_1.logger.log(`Recorded declined character: ${characterName} for story ${storyId}`);
         }
+        if (story.pendingSuggestion?.type === 'suggest-introduce-character' &&
+            story.pendingSuggestion.characterName === characterName) {
+            story.pendingSuggestion = undefined;
+        }
+        this.storyStore.updateStoryMetadata(storyId, story);
     }
     async deleteCharacter(storyId, characterName) {
         let room;
@@ -1029,6 +1050,17 @@ let StoryService = class StoryService {
         room.setAgents(filteredAgents);
         room.saveMetadata();
         this.agentStore.removeAgent(agent.id);
+        const story = this.storyStore.getStory(storyId);
+        if (story?.characters) {
+            const filtered = story.characters.filter((c) => {
+                const firstWord = c.name.trim().split(/\s+/)[0];
+                return c.name !== characterName && firstWord !== characterName;
+            });
+            if (filtered.length !== story.characters.length) {
+                story.characters = filtered;
+                this.storyStore.updateStoryMetadata(storyId, story);
+            }
+        }
     }
     async deleteStory(storyId) {
         logger_1.logger.log(`Deleting story ${storyId}...`);
@@ -1132,7 +1164,7 @@ let StoryService = class StoryService {
                     return;
                 }
                 try {
-                    await this.compactAgentHistory(agent);
+                    await agent.compact();
                 }
                 catch (error) {
                     logger_1.logger.error(`Error compacting ${agent.agentName}:`, error);
@@ -1157,36 +1189,54 @@ let StoryService = class StoryService {
         if (!story) {
             throw new Error('Story not found');
         }
-        const existingEmitter = this.progressService.getProgressEmitter(storyId);
-        if (!existingEmitter) {
-            this.progressService.createProgressEmitter(storyId);
+        if (this.chaptersInProgress.has(storyId)) {
+            throw new errors_1.OperationFailedError('Chapter progression is already in progress for this story');
         }
-        const room = await this.getStoryRoom(storyId);
-        room.setCurrentSpeaker('system');
-        this.progressService.emitProgress(storyId, 'opening-scene', 'Generating opening scene of chapter...');
-        const agents = room.getAgents();
-        const narrator = agents.find((agent) => agent.promptFolder === 'narrator');
-        const { openingScene, chapterTitle } = await this.generateOpeningScene(room, narrator);
-        this.progressService.emitProgress(storyId, 'chapter-backup', `Saving previous chapter: "${chapterTitle}"...`);
-        const chapterIndex = this.storyStore.getNextChapterIndex(storyId);
-        const backupSuccess = this.storyStore.createChapterBackup(storyId, chapterIndex, chapterTitle);
-        if (!backupSuccess) {
-            throw new Error('Failed to backup chapter');
-        }
-        room.clearRoomMessages();
-        this.populateStoryHistory(room, openingScene);
-        const humanAgent = room.getAgents().find((a) => a.isControlledByHuman);
-        if (humanAgent) {
-            room.setCurrentSpeaker(humanAgent.agentNickname);
-        }
-        this.progressService.emitProgress(storyId, 'ready', 'Chapter opening is ready! Continuing chapter progression in the background...');
-        setImmediate(() => {
-            this.progressStoryToNextChapterAsync(storyId).catch((error) => {
-                logger_1.logger.error('Error in async chapter progression:', error);
-                this.progressService.emitProgress(storyId, 'error', `Error: ${error.message}`);
+        this.chaptersInProgress.add(storyId);
+        try {
+            if (story.pendingSuggestion?.type === 'suggest-progress-chapter') {
+                story.pendingSuggestion = undefined;
+                this.storyStore.updateStoryMetadata(storyId, story);
+            }
+            const existingEmitter = this.progressService.getProgressEmitter(storyId);
+            if (!existingEmitter) {
+                this.progressService.createProgressEmitter(storyId);
+            }
+            const room = await this.getStoryRoom(storyId);
+            room.setCurrentSpeaker('system');
+            this.progressService.emitProgress(storyId, 'opening-scene', 'Generating opening scene of chapter...');
+            const agents = room.getAgents();
+            const narrator = agents.find((agent) => agent.promptFolder === 'narrator');
+            const { openingScene, chapterTitle } = await this.generateOpeningScene(room, narrator);
+            this.progressService.emitProgress(storyId, 'chapter-backup', `Saving previous chapter: "${chapterTitle}"...`);
+            const chapterIndex = this.storyStore.getNextChapterIndex(storyId);
+            const backupSuccess = this.storyStore.createChapterBackup(storyId, chapterIndex, chapterTitle);
+            if (!backupSuccess) {
+                throw new Error('Failed to backup chapter');
+            }
+            room.clearRoomMessages();
+            this.populateStoryHistory(room, openingScene);
+            const humanAgent = room.getAgents().find((a) => a.isControlledByHuman);
+            if (humanAgent) {
+                room.setCurrentSpeaker(humanAgent.agentNickname);
+            }
+            this.progressService.emitProgress(storyId, 'ready', 'Chapter opening is ready! Continuing chapter progression in the background...');
+            setImmediate(() => {
+                this.progressStoryToNextChapterAsync(storyId)
+                    .catch((error) => {
+                    logger_1.logger.error('Error in async chapter progression:', error);
+                    this.progressService.emitProgress(storyId, 'error', `Error: ${error.message}`);
+                })
+                    .finally(() => {
+                    this.chaptersInProgress.delete(storyId);
+                });
             });
-        });
-        return { chapterIndex };
+            return { chapterIndex };
+        }
+        catch (err) {
+            this.chaptersInProgress.delete(storyId);
+            throw err;
+        }
     }
     async progressStoryToNextChapterAsync(storyId) {
         let room = null;
@@ -1251,50 +1301,16 @@ let StoryService = class StoryService {
         await Promise.all(agents.map(async (agent) => {
             let numMessageChars = agent.history?.map((m) => m.content?.length).reduce((a, b) => a + b, 0);
             if (numMessageChars > threshold) {
-                await this.compactAgentHistory(agent);
-            }
-            else {
-                return Promise.resolve();
+                try {
+                    await agent.compact();
+                }
+                catch (error) {
+                    logger_1.logger.error(`Error compacting ${agent.agentName}:`, error);
+                    throw error;
+                }
             }
         }));
     }
-    async compactAgentHistory(agent) {
-        const originalHistory = [...agent.history];
-        const originalLength = originalHistory.length;
-        if (originalHistory.length == 0) {
-            return {
-                success: true,
-                originalLength: originalLength,
-                newLength: originalLength,
-                message: 'No conversation history to compact',
-            };
-        }
-        const formattedHistory = agent.getFormattedMessages(0);
-        try {
-            agent.history = [];
-            const summaryResponse = await agent.preparedPrompt('compact_story', {
-                agentName: agent.agentNickname,
-                formattedHistory: formattedHistory,
-            }, false);
-            const summary = summaryResponse?.summary || summaryResponse;
-            agent.addToConversationHistory(`[CONVERSATION HISTORY SUMMARY]\n\n${summary}`, true);
-            const newLength = agent.history.length;
-            logger_1.logger.log(`Compacted ${agent.agentName}: ${originalLength} messages`);
-            agent.save();
-            return {
-                success: true,
-                originalLength: originalLength,
-                newLength: newLength,
-                message: `${originalLength} messages -> ${newLength} messages`,
-                summary: summary,
-            };
-        }
-        catch (error) {
-            agent.history = originalHistory;
-            logger_1.logger.error(`Error compacting ${agent.agentName}:`, error);
-            throw error;
-        }
-    }
     extractMarkdownContent(response) {
         const fenceMatch = response.match(/```(?:markdown)?\s*\n([\s\S]*?)```/);
         if (fenceMatch) {
@@ -1415,12 +1431,13 @@ let StoryService = class StoryService {
         }
     }
     createArtistAgent(storyId, storyAgentsDir, storyArtifactService, imageModelName) {
+        const storyInfo = this.storyStore.getStory(storyId);
         const imageConfig = this.getImageModelConfig(imageModelName);
         if (!imageConfig) {
             logger_1.logger.log('Artist agent creation skipped: images disabled');
             return null;
         }
-        const artistAgent = this.agentFactory.createAgent(imageConfig.service, 'Artist', '', 'AI artist for generating character portraits and scene illustrations', 'default', imageConfig.model, storyAgentsDir, storyArtifactService);
+        const artistAgent = this.agentFactory.createAgent(imageConfig.service, `${storyInfo.name} - Artist`, 'Artist', 'AI artist for generating character portraits and scene illustrations', 'default', imageConfig.model, storyAgentsDir, storyArtifactService);
         artistAgent.maxHistoryMessages = 10;
         artistAgent.promptCacheTTL = 0;
         artistAgent.save();
@@ -1622,8 +1639,12 @@ let StoryService = class StoryService {
         if (progressChapter) {
             if (story) {
                 story.declinedCharacters = [];
-                this.storyStore.updateStoryMetadata(storyId, story);
             }
+            story.pendingSuggestion = {
+                type: 'suggest-progress-chapter',
+                timestamp: Date.now(),
+            };
+            this.storyStore.updateStoryMetadata(storyId, story);
             this.messageService.emitProgressChapter(storyId);
             return;
         }
@@ -1638,6 +1659,12 @@ let StoryService = class StoryService {
                     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;

package/{dist → dist-sdk}/shared/types/app.types.d.ts

@@ -220,6 +220,7 @@ export interface StoryInfo {
     totalOutputTokens: number;
     turnNumber: number;
     declinedCharacters?: string[];
+    pendingSuggestion?: StoryIntroduceCharacterEvent | StoryProgressChapterEvent;
 }
 export interface CreateStoryResponse {
     storyId: string;

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJx1jc0KwjAQhN9lzqklLRbdd/DitfQQ2tUG0wSy8VTy7hL/KIKngZ1v51sRQ0gC6jvdDgqRL47HZIMX0IpOtyW8WRiEE4uYK0PhZv0Eavadwj06EKxPHC9mZKnf1G5Oi4PC6IwICEmmqrxVX7SUs3VTZA/qtdbHISuU3DjPISy/Xt0cPt7nOku9wf6KX4ec8wP/YVA+"
+window.hierarchyData = "eJx1jc0KwjAQhN9lzqkliq3sO3jxWnoI7dYG0wSy8VTy7hL/KIKngZ1v51sRQ0gC6hrd9gqRJ8dDssELaEWj2xLeLAzCmUXMlaFws34E7Y+Nwj06EKxPHCczsNRvajenxUFhcEYEhCRjVd6qL1rK2boxsgd1Wh90nxVKbpyXEJZfr96fPt7nOku9wf6KX4ec8wMBuFA6"