siduri 1.0.0

package/dist/configurators.test.js

@@ -0,0 +1,464 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = __importDefault(require("inquirer"));
+const discovery_1 = require("./discovery");
+const generator_1 = require("./generator");
+const index_1 = require("./index");
+const openrouter_1 = require("./providers/openrouter");
+const knowledge_hub_1 = require("./providers/knowledge-hub");
+const brain_1 = require("./configurators/brain");
+const knowledge_1 = require("./configurators/knowledge");
+const memory_1 = require("./configurators/memory");
+const voice_1 = require("./configurators/voice");
+const body_1 = require("./configurators/body");
+const hands_1 = require("./configurators/hands");
+const behavior_1 = require("./configurators/behavior");
+const vision_1 = require("./configurators/vision");
+const ear_1 = require("./configurators/ear");
+const observation_1 = require("./configurators/observation");
+// Mock inquirer.prompt
+jest.mock('inquirer', () => ({
+    prompt: jest.fn(),
+    Separator: jest.fn((label) => ({ type: 'separator', line: label })),
+}));
+describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
+    const registry = discovery_1.OrganRegistry.discover();
+    const brainManifest = registry.get('brain');
+    const knowledgeManifest = registry.get('knowledge');
+    const archiveManifest = registry.get('archive');
+    const voiceManifest = registry.get('voice');
+    const bodyManifest = registry.get('body');
+    const handsManifest = registry.get('hands');
+    const behaviorManifest = registry.get('behavior');
+    const visionManifest = registry.get('vision');
+    const earManifest = registry.get('ear');
+    const observationManifest = registry.get('observation');
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('Discrepancy #1: OpenRouter Model Discovery & Brain Configurator', () => {
+        test('OpenRouter model provider parses model catalog correctly', async () => {
+            const mockModels = [
+                { id: 'openai/gpt-4o-mini', name: 'OpenAI: GPT-4o Mini', description: 'Fast model', context_length: 128000 },
+                { id: 'anthropic/claude-3.5-sonnet', name: 'Anthropic: Claude 3.5 Sonnet', context_length: 200000 },
+            ];
+            const globalFetch = global.fetch;
+            global.fetch = jest.fn().mockResolvedValue({
+                ok: true,
+                json: async () => ({ data: mockModels }),
+            });
+            const provider = new openrouter_1.OpenRouterModelProvider('https://mock-api.com/models');
+            const models = await provider.listModels();
+            expect(models.length).toBe(2);
+            expect(models[0].id).toBe('openai/gpt-4o-mini');
+            expect(models[0].name).toBe('OpenAI: GPT-4o Mini');
+            expect(models[1].id).toBe('anthropic/claude-3.5-sonnet');
+            global.fetch = globalFetch;
+        });
+        test('Brain configurator selects OpenRouter model and retains canonical model ID', async () => {
+            const mockProvider = {
+                listModels: jest.fn().mockResolvedValue([
+                    { id: 'openai/gpt-4o-mini', name: 'OpenAI: GPT-4o Mini' },
+                    { id: 'anthropic/claude-3.5-sonnet', name: 'Anthropic: Claude 3.5 Sonnet' },
+                ]),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'openrouter' }) // Brain provider
+                .mockResolvedValueOnce({ selectedValue: 'openai/gpt-4o-mini' }); // Select model
+            const result = await (0, brain_1.configureBrain)({ companionName: 'Sparkle', manifest: brainManifest }, { modelProvider: mockProvider });
+            expect(result.config.provider).toBe('openrouter');
+            expect(result.config.model).toBe('openai/gpt-4o-mini');
+            expect(result.summary?.Model).toBe('openai/gpt-4o-mini');
+            expect(result.summary?.Provider).toBe('OpenRouter');
+        });
+        test('Brain configurator handles discovery failure with curated fallback models', async () => {
+            const failingProvider = {
+                listModels: jest.fn().mockRejectedValue(new Error('Network request failed')),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'openrouter' }) // Brain provider
+                .mockResolvedValueOnce({ failureAction: 'curated' }) // Pick curated fallback
+                .mockResolvedValueOnce({ selectedValue: 'anthropic/claude-3.5-sonnet' }); // Select model
+            const result = await (0, brain_1.configureBrain)({ companionName: 'Sparkle', manifest: brainManifest }, { modelProvider: failingProvider });
+            expect(result.config.provider).toBe('openrouter');
+            expect(result.config.model).toBe('anthropic/claude-3.5-sonnet');
+        });
+        test('Brain configurator handles discovery failure with manual fallback entry', async () => {
+            const failingProvider = {
+                listModels: jest.fn().mockRejectedValue(new Error('Network request failed')),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'openrouter' })
+                .mockResolvedValueOnce({ failureAction: 'manual' })
+                .mockResolvedValueOnce({ manualId: 'mistralai/mistral-large' });
+            const result = await (0, brain_1.configureBrain)({ companionName: 'Sparkle', manifest: brainManifest }, { modelProvider: failingProvider });
+            expect(result.config.provider).toBe('openrouter');
+            expect(result.config.model).toBe('mistralai/mistral-large');
+        });
+        test('Brain configurator supports OpenAI-compatible / Custom endpoint', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'openai-compatible' })
+                .mockResolvedValueOnce({
+                baseUrl: 'http://localhost:11434/v1',
+                model: 'llama3:latest',
+                apiKeyEnv: 'OLLAMA_API_KEY',
+            });
+            const result = await (0, brain_1.configureBrain)({ companionName: 'Sparkle', manifest: brainManifest });
+            expect(result.config.provider).toBe('openai-compatible');
+            expect(result.config.model).toBe('llama3:latest');
+            expect(result.config.baseUrl).toBe('http://localhost:11434/v1');
+            expect(result.config.apiKeyEnv).toBe('OLLAMA_API_KEY');
+        });
+    });
+    describe('Discrepancy #2 & #3: Knowledge Choices & Manifest Metadata Confirmation', () => {
+        test('Declining external pack uses sovereign Life Database by default and skips discovery', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ useExternalPack: false });
+            const result = await (0, knowledge_1.configureKnowledge)({
+                companionName: 'Sparkle',
+                manifest: knowledgeManifest,
+            });
+            expect(result.config.provider).toBe('unified');
+            expect(result.config.lifeDatabase).toBe(true);
+            expect(result.summary?.['Life Database']).toBe('Enabled (siduri.sqlite)');
+            expect(result.summary?.['E-Pack']).toBe('None');
+        });
+        test('Attaching E Knowledge Hub pack discovers manifest and configures remote provider automatically', async () => {
+            const mockClient = {
+                resolveProvider: jest.fn().mockResolvedValue({
+                    name: 'e-teyvat',
+                    displayName: 'E Teyvat',
+                    package: '@vxnus/e-teyvat',
+                    version: '1.2.0',
+                    description: 'Teyvat knowledge provider for Siduri.',
+                    capabilities: ['Search', 'Retrieval', 'Context injection'],
+                    distributionType: 'remote',
+                    distribution: {
+                        kind: 'provider',
+                        url: 'https://teyvat.e.vxnus.xyz',
+                    },
+                    source: 'E Knowledge Hub',
+                }),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ useExternalPack: true }) // Attach external pack
+                .mockResolvedValueOnce({ packId: '@vxnus/e-teyvat' }); // Package ID
+            const result = await (0, knowledge_1.configureKnowledge)({ companionName: 'Sparkle', manifest: knowledgeManifest }, { client: mockClient });
+            expect(result.config.provider).toBe('e-hub');
+            expect(result.config.packId).toBe('@vxnus/e-teyvat');
+            expect(result.summary?.Source).toBe('E Knowledge Hub');
+            expect(result.summary?.Provider).toBe('E Teyvat');
+            expect(result.summary?.Package).toBe('@vxnus/e-teyvat');
+            expect(result.summary?.Version).toBe('1.2.0');
+            expect(result.summary?.['E-Pack']).toContain('Remote');
+        });
+        test('Attaching hybrid pack allows choosing between remote and local with automated path', async () => {
+            const mockClient = {
+                resolveProvider: jest.fn().mockResolvedValue({
+                    name: 'e-teyvat',
+                    displayName: 'E Teyvat',
+                    package: '@vxnus/e-teyvat',
+                    version: '1.2.0',
+                    description: 'Teyvat knowledge provider for Siduri.',
+                    capabilities: ['Search', 'Retrieval', 'Context injection'],
+                    distributionType: 'both',
+                    distribution: {
+                        kind: 'archive',
+                        url: 'https://knowledge.e.vxnus.xyz/archives/teyvat.tar.gz',
+                    },
+                    source: 'E Knowledge Hub',
+                }),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ useExternalPack: true })
+                .mockResolvedValueOnce({ packId: '@vxnus/e-teyvat' })
+                .mockResolvedValueOnce({ selectedMode: 'local' });
+            const result = await (0, knowledge_1.configureKnowledge)({ companionName: 'Sparkle', manifest: knowledgeManifest }, { client: mockClient });
+            expect(result.config.provider).toBe('e-knowledge');
+            expect(result.config.packPath).toBe('./assets/knowledge/vxnus-e-teyvat');
+            expect(result.summary?.['E-Pack']).toContain('Local @ ./assets/knowledge/vxnus-e-teyvat');
+        });
+        test('Knowledge manifest validation enforces name and version', () => {
+            expect(() => (0, knowledge_hub_1.validateKnowledgeManifest)({})).toThrow('Invalid knowledge manifest');
+            expect(() => (0, knowledge_hub_1.validateKnowledgeManifest)({ name: 'test' })).toThrow('missing \'version\'');
+            const valid = (0, knowledge_hub_1.validateKnowledgeManifest)({
+                name: 'e-teyvat',
+                displayName: 'E Teyvat',
+                version: '1.0.0',
+                description: 'Teyvat lore',
+            }, '@vxnus/e-teyvat');
+            expect(valid.name).toBe('e-teyvat');
+            expect(valid.package).toBe('@vxnus/e-teyvat');
+            expect(valid.version).toBe('1.0.0');
+        });
+        test('extractCapabilitiesList formats object and array capabilities correctly', () => {
+            const arrayCaps = (0, knowledge_hub_1.extractCapabilitiesList)(['Search', 'Retrieval', 'Custom Tool']);
+            expect(arrayCaps).toEqual(['Search', 'Retrieval', 'Custom Tool']);
+            const objCaps = (0, knowledge_hub_1.extractCapabilitiesList)({
+                search: true,
+                retrieval: true,
+                contextInjection: true,
+                semanticSearch: true,
+            });
+            expect(objCaps).toContain('Search');
+            expect(objCaps).toContain('Retrieval');
+            expect(objCaps).toContain('Context injection');
+            expect(objCaps).toContain('Semantic search');
+        });
+        test('Knowledge Hub client fallback returns known pack for @vxnus/e-teyvat', async () => {
+            const client = new knowledge_hub_1.KnowledgeHubClient('https://invalid-non-existent-url.local/api');
+            const manifest = await client.resolveProvider('@vxnus/e-teyvat');
+            expect(manifest.package).toBe('@vxnus/e-teyvat');
+            expect(manifest.displayName).toBe('E Teyvat');
+            expect(manifest.version).toBe('1.2.0');
+        });
+    });
+    describe('Other Organ Configurators & Generic Router', () => {
+        test('Memory configurator configures SQLite with WAL and FTS5', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'sqlite' });
+            const result = await (0, memory_1.configureMemory)({ companionName: 'Sparkle', manifest: archiveManifest });
+            expect(result.config.provider).toBe('sqlite');
+            expect(result.summary?.Database).toBe('SQLite (WAL + FTS5)');
+            expect(result.summary?.Storage).toBe('siduri.sqlite');
+        });
+        test('Voice configurator configures VOICEVOX engine and speaker ID', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'voicevox' })
+                .mockResolvedValueOnce({ baseUrl: 'http://localhost:50021' })
+                .mockResolvedValueOnce({ speaker: { id: 2, label: '四国めたん (Shikoku Metan) - ノーマル (Normal) (ID: 2)' } });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('voicevox');
+            expect(result.config.speakerId).toBe(2);
+            expect(result.summary?.['Speaker ID']).toBe(2);
+        });
+        test('Voice configurator configures RVC with Base TTS Engine', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'rvc' })
+                .mockResolvedValueOnce({
+                modelPath: './assets/voice/sparkle/sparkle.pth',
+                indexPath: './assets/voice/sparkle/sparkle.index',
+                pitchShift: '12',
+                f0Method: 'rmvpe',
+                baseTts: 'edge-tts',
+                serviceUrl: 'http://localhost:50055',
+            });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('edge-tts');
+            expect(result.config.rvc.enabled).toBe(true);
+            expect(result.config.rvc.pitchShift).toBe(12);
+            expect(result.summary?.['Base TTS']).toBe('edge-tts');
+        });
+        test('Voice configurator disables voice when none is selected', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'none' });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Provider).toBe('None (Voice disabled)');
+        });
+        test('Voice configurator configures RVC with Kokoro as Base TTS Engine', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'rvc' })
+                .mockResolvedValueOnce({
+                modelPath: './assets/voice/sparkle/sparkle.pth',
+                indexPath: './assets/voice/sparkle/sparkle.index',
+                pitchShift: '0',
+                f0Method: 'pm',
+                baseTts: 'kokoro',
+                serviceUrl: 'http://localhost:50055',
+            });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('kokoro');
+            expect(result.config.rvc.enabled).toBe(true);
+            expect(result.summary?.['Base TTS']).toBe('kokoro');
+        });
+        test('Voice configurator configures RVC with Piper as Base TTS Engine', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'rvc' })
+                .mockResolvedValueOnce({
+                modelPath: './assets/voice/sparkle/sparkle.pth',
+                indexPath: '',
+                pitchShift: '-6',
+                f0Method: 'harvest',
+                baseTts: 'piper',
+                serviceUrl: 'http://localhost:50055',
+            });
+            const result = await (0, voice_1.configureVoice)({ companionName: 'Sparkle', manifest: voiceManifest });
+            expect(result.config.provider).toBe('piper');
+            expect(result.config.rvc.enabled).toBe(true);
+            expect(result.config.rvc.pitchShift).toBe(-6);
+            expect(result.summary?.['Base TTS']).toBe('piper');
+        });
+        test('Body configurator configures Live2D and custom model path', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'live2d' })
+                .mockResolvedValueOnce({
+                modelSource: './assets/body/sparkle/model.model3.json',
+            });
+            const result = await (0, body_1.configureBody)({ companionName: 'Sparkle', manifest: bodyManifest });
+            expect(result.config.provider).toBe('live2d');
+            expect(result.config.modelPath).toBe('./assets/body/sparkle/model.model3.json');
+            expect(result.config.modelUrl).toBe('/assets/body/sparkle/model.model3.json');
+            expect(result.config.initialExpression).toBe('neutral');
+            expect(result.summary?.['Model Path']).toBe('./assets/body/sparkle/model.model3.json');
+        });
+        test('Body configurator defaults model path to assets/body/default', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'live2d' })
+                .mockResolvedValueOnce({
+                modelSource: '',
+            });
+            const result = await (0, body_1.configureBody)({ companionName: 'MyCompanion', manifest: bodyManifest });
+            expect(result.config.provider).toBe('live2d');
+            expect(result.config.modelPath).toBe('./assets/body/default/model.model3.json');
+            expect(result.config.modelUrl).toBe('/assets/body/default/model.model3.json');
+            expect(result.summary?.['Model Path']).toBe('./assets/body/default/model.model3.json');
+        });
+        test('Body configurator configures VRM 3D avatar with lookAt mode', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'vrm' })
+                .mockResolvedValueOnce({
+                modelSource: './assets/body/vroid/model.vrm',
+                lookAtMode: 'cursor',
+            });
+            const result = await (0, body_1.configureBody)({ companionName: 'VRoidCompanion', manifest: bodyManifest });
+            expect(result.config.provider).toBe('vrm');
+            expect(result.config.format).toBe('vrm');
+            expect(result.config.modelPath).toBe('./assets/body/vroid/model.vrm');
+            expect(result.config.modelUrl).toBe('/assets/body/vroid/model.vrm');
+            expect(result.config.vrm?.lookAtMode).toBe('cursor');
+            expect(result.summary?.Provider).toBe('VRM (3D Avatar)');
+            expect(result.summary?.['LookAt Mode']).toBe('cursor');
+        });
+        test('Body configurator disables body when none is selected', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'none' });
+            const result = await (0, body_1.configureBody)({ companionName: 'HeadlessCompanion', manifest: bodyManifest });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Provider).toBe('None (Headless)');
+        });
+        test('Hands configurator configures MCP tool execution timeout', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'mcp' })
+                .mockResolvedValueOnce({ timeoutSeconds: '15' });
+            const result = await (0, hands_1.configureHands)({ companionName: 'Sparkle', manifest: handsManifest });
+            expect(result.config.defaultTimeoutMs).toBe(15000);
+            expect(result.summary?.Provider).toBeUndefined();
+        });
+        test('Hands configurator disables tool execution when none is selected', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ provider: 'none' });
+            const result = await (0, hands_1.configureHands)({ companionName: 'Sparkle', manifest: handsManifest });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Provider).toBe('None (Hands disabled)');
+        });
+        test('Behavior configurator configures blank slate mode when later is chosen', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ personaMode: 'later' });
+            const result = await (0, behavior_1.configureBehavior)({ companionName: 'Sparkle', manifest: behaviorManifest });
+            expect(result.config.provider).toBe('active_self');
+            expect(result.config.mode).toBe('blank_slate');
+            expect(result.summary?.Persona).toBe('Blank Slate (Evolve via interaction)');
+        });
+        test('Behavior configurator configures custom persona asset when now is chosen', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ personaMode: 'now' })
+                .mockResolvedValueOnce({
+                archetype: 'System Sentinel',
+                ethos: 'Snarky and loyal',
+                directive: 'No sycophantic greetings',
+            });
+            const result = await (0, behavior_1.configureBehavior)({ companionName: 'Sparkle', manifest: behaviorManifest });
+            expect(result.config.provider).toBe('active_self');
+            expect(result.config.mode).toBe('custom');
+            expect(result.config.archetype).toBe('System Sentinel');
+            expect(result.config.selfPath).toBe('./assets/self/default.self');
+        });
+        test('Vision configurator configures OpenRouter vision model', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ model: 'gpt-4-vision' });
+            const result = await (0, vision_1.configureVision)({ companionName: 'Sparkle', manifest: visionManifest });
+            expect(result.config.provider).toBe('openrouter');
+            expect(result.config.model).toBe('gpt-4-vision');
+        });
+        test('Vision configurator disables vision when none is selected', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ model: 'none' });
+            const result = await (0, vision_1.configureVision)({ companionName: 'Sparkle', manifest: visionManifest });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Provider).toBe('None (Vision disabled)');
+        });
+        test('Ear configurator enables sensory bounds by default', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ choice: 'enabled' });
+            const result = await (0, ear_1.configureEar)({ companionName: 'Sparkle', manifest: earManifest });
+            expect(result.config.defaultSource).toBe('text_chat');
+            expect(result.config.maxTextLength).toBe(4000);
+            expect(result.config.maxAudioBytes).toBe(10485760);
+            expect(result.summary?.Status).toContain('Enabled');
+        });
+        test('Ear configurator disables sensory ingress when none is selected', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ choice: 'none' });
+            const result = await (0, ear_1.configureEar)({ companionName: 'Sparkle', manifest: earManifest });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Provider).toBe('None (Ear disabled)');
+        });
+        test('Observation configurator disables observation by default as work in progress', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ provider: 'none' });
+            const result = await (0, observation_1.configureObservation)({ companionName: 'Sparkle', manifest: observationManifest });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Provider).toContain('Disabled (Work in progress)');
+        });
+        test('Observation configurator configures experimental fixture ingest when chosen', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ provider: 'fixture' });
+            const result = await (0, observation_1.configureObservation)({ companionName: 'Sparkle', manifest: observationManifest });
+            expect(result.summary?.Provider).toContain('Work in progress');
+        });
+    });
+    describe('Review Summary Formatting & Generator Integration', () => {
+        test('formatReviewSummary displays actual configuration values and metadata', () => {
+            const summaryOutput = (0, index_1.formatReviewSummary)('Sparkle', [brainManifest, archiveManifest, knowledgeManifest, voiceManifest], {
+                brain: { Provider: 'OpenRouter', Model: 'openai/gpt-4o-mini' },
+                archive: { Database: 'SQLite (WAL + FTS5)', Storage: 'siduri.sqlite' },
+                knowledge: { Source: 'E Knowledge Hub', Provider: 'E Teyvat', Package: '@vxnus/e-teyvat', Version: '1.2.0' },
+                voice: { Provider: 'VOICEVOX', 'Speaker ID': 1 },
+            });
+            expect(summaryOutput).toContain('Sparkle');
+            expect(summaryOutput).toContain('Brain');
+            expect(summaryOutput).toContain('OpenRouter');
+            expect(summaryOutput).toContain('openai/gpt-4o-mini');
+            expect(summaryOutput).toContain('Archive');
+            expect(summaryOutput).toContain('SQLite');
+            expect(summaryOutput).toContain('siduri.sqlite');
+            expect(summaryOutput).toContain('Knowledge');
+            expect(summaryOutput).toContain('E Knowledge Hub');
+            expect(summaryOutput).toContain('E Teyvat');
+            expect(summaryOutput).toContain('@vxnus/e-teyvat');
+            expect(summaryOutput).toContain('Voice');
+            expect(summaryOutput).toContain('VOICEVOX');
+        });
+        test('generateInstanceFiles accurately embeds configured organ values in siduri.config.json', () => {
+            const organConfigs = {
+                brain: { provider: 'openrouter', model: 'openai/gpt-4o-mini', apiKeyEnv: 'OPENROUTER_API_KEY' },
+                archive: { provider: 'sqlite' },
+                knowledge: { provider: 'e-hub', registryUrl: 'https://e.vxnus.xyz/api/v1/knowledge', packId: '@vxnus/e-teyvat' },
+                voice: { provider: 'voicevox', speakerId: 2, baseUrl: 'http://localhost:50021' },
+            };
+            const files = (0, generator_1.generateInstanceFiles)({
+                name: 'Sparkle',
+                selectedManifests: [brainManifest, archiveManifest, knowledgeManifest, voiceManifest],
+                organConfigs,
+            });
+            const config = JSON.parse(files['siduri.config.json']);
+            expect(config.name).toBe('Sparkle');
+            expect(config.organs.brain.provider).toBe('openrouter');
+            expect(config.organs.brain.model).toBe('openai/gpt-4o-mini');
+            expect(config.organs.archive.provider).toBe('sqlite');
+            expect(config.organs.knowledge.provider).toBe('e-hub');
+            expect(config.organs.knowledge.packId).toBe('@vxnus/e-teyvat');
+            expect(config.organs.voice.speakerId).toBe(2);
+            // Verify explicit imports in src/index.js
+            expect(files['src/index.js']).toContain("import { OpenRouterBrain } from '@sidurijs/brain'");
+            expect(files['src/index.js']).toContain("import { SqliteArchiveLedger } from '@sidurijs/archive'");
+            expect(files['src/index.js']).toContain("import { UnifiedKnowledgeOrgan } from '@sidurijs/knowledge'");
+            expect(files['src/index.js']).toContain("import { VoiceAdapter } from '@sidurijs/voice'");
+        });
+    });
+});

package/dist/db.d.ts

@@ -0,0 +1,13 @@
+export declare function redactDatabaseUrl(url: string): string;
+export interface DbPushOptions {
+    projectDir?: string;
+    connectionString?: string;
+    env?: Record<string, string | undefined>;
+}
+export interface DbPushResult {
+    status: 'NOOP' | 'APPLIED' | 'UP_TO_DATE';
+    appliedMigrations: string[];
+    skippedMigrations: string[];
+    message: string;
+}
+export declare function runDbPush(options?: DbPushOptions): Promise<DbPushResult>;

package/dist/db.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactDatabaseUrl = redactDatabaseUrl;
+exports.runDbPush = runDbPush;
+function redactDatabaseUrl(url) {
+    return url;
+}
+async function runDbPush(options = {}) {
+    return {
+        status: 'NOOP',
+        appliedMigrations: [],
+        skippedMigrations: [],
+        message: 'SQLite manages schema natively. No CLI migrations required.',
+    };
+}

package/dist/discovery.d.ts

@@ -0,0 +1,13 @@
+import { OrganManifest } from './manifest';
+export declare class OrganRegistry {
+    private manifests;
+    constructor(manifests?: OrganManifest[]);
+    register(manifest: OrganManifest): void;
+    get(organType: string): OrganManifest | undefined;
+    getAll(): OrganManifest[];
+    getAvailableOrganTypes(): string[];
+    /**
+     * Discover installed or monorepo organ packages.
+     */
+    static discover(searchRoots?: string[]): OrganRegistry;
+}

package/dist/discovery.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganRegistry = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const manifest_1 = require("./manifest");
+const builtin_manifests_1 = require("./builtin-manifests");
+class OrganRegistry {
+    manifests = new Map();
+    constructor(manifests) {
+        if (manifests) {
+            for (const m of manifests) {
+                this.manifests.set(m.organType, m);
+            }
+        }
+    }
+    register(manifest) {
+        const validated = (0, manifest_1.validateOrganManifest)(manifest);
+        this.manifests.set(validated.organType, validated);
+    }
+    get(organType) {
+        return this.manifests.get(organType);
+    }
+    getAll() {
+        return Array.from(this.manifests.values());
+    }
+    getAvailableOrganTypes() {
+        return Array.from(this.manifests.keys());
+    }
+    /**
+     * Discover installed or monorepo organ packages.
+     */
+    static discover(searchRoots) {
+        const registry = new OrganRegistry();
+        const rootsToScan = searchRoots && searchRoots.length > 0
+            ? searchRoots
+            : [
+                node_path_1.default.resolve(__dirname, '../../packages/organs'),
+                node_path_1.default.resolve(process.cwd(), 'packages/organs'),
+                node_path_1.default.resolve(__dirname, '../../packages'),
+                node_path_1.default.resolve(process.cwd(), 'packages'),
+                node_path_1.default.resolve(process.cwd(), 'node_modules/@siduri-x'),
+                node_path_1.default.resolve(__dirname, '../node_modules/@siduri-x'),
+            ];
+        const visitedDirs = new Set();
+        for (const root of rootsToScan) {
+            if (!node_fs_1.default.existsSync(root) || visitedDirs.has(root))
+                continue;
+            visitedDirs.add(root);
+            try {
+                const entries = node_fs_1.default.readdirSync(root, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const candidateDir = node_path_1.default.join(root, entry.name);
+                    const manifestPath = node_path_1.default.join(candidateDir, 'organ-manifest.json');
+                    if (node_fs_1.default.existsSync(manifestPath)) {
+                        try {
+                            const raw = JSON.parse(node_fs_1.default.readFileSync(manifestPath, 'utf8'));
+                            const manifest = (0, manifest_1.validateOrganManifest)(raw, manifestPath);
+                            registry.register(manifest);
+                        }
+                        catch (err) {
+                            console.warn(`[Siduri CLI] Warning: failed to parse manifest at ${manifestPath}: ${err.message}`);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                // Continue scanning other roots
+            }
+        }
+        // Always merge canonical built-in @sidurijs/* organ manifests as fallback for ones that weren't found
+        for (const builtinManifest of builtin_manifests_1.BUILTIN_ORGAN_MANIFESTS) {
+            if (!registry.get(builtinManifest.organType)) {
+                registry.register(builtinManifest);
+            }
+        }
+        return registry;
+    }
+}
+exports.OrganRegistry = OrganRegistry;

package/dist/discovery.test.d.ts

@@ -0,0 +1 @@
+export {};