@vxnus/siduri 0.0.7 → 0.0.8

package/dist/configurators.test.js

@@ -0,0 +1,275 @@
+"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");
+// 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 memoryManifest = registry.get('memory');
+    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');
+    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('Selecting "Do not use knowledge" sets provider: none and skips discovery', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ source: 'none' });
+            const result = await (0, knowledge_1.configureKnowledge)({
+                companionName: 'Sparkle',
+                manifest: knowledgeManifest,
+            });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Source).toBe('Do not use knowledge');
+        });
+        test('Selecting "E Knowledge Hub" discovers manifest, extracts capabilities, and confirms provider', 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'],
+                    source: 'E Knowledge Hub',
+                }),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ source: 'e-hub' }) // Knowledge source
+                .mockResolvedValueOnce({ packId: '@vxnus/e-teyvat' }) // Package ID
+                .mockResolvedValueOnce({ confirmProvider: 'yes' }); // Confirm provider
+            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');
+        });
+        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 PostgreSQL with Supabase deployment', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ database: 'postgres' })
+                .mockResolvedValueOnce({ deployment: 'supabase' });
+            const result = await (0, memory_1.configureMemory)({ companionName: 'Sparkle', manifest: memoryManifest });
+            expect(result.config.provider).toBe('postgres');
+            expect(result.config.deployment).toBe('supabase');
+            expect(result.summary?.Deploy).toBe('Supabase');
+        });
+        test('Voice configurator configures VOICEVOX engine and speaker ID', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'voicevox' })
+                .mockResolvedValueOnce({ baseUrl: 'http://localhost:50021', speakerId: '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('Body configurator configures Live2D and expression', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'live2d' })
+                .mockResolvedValueOnce({ initialExpression: 'happy' });
+            const result = await (0, body_1.configureBody)({ companionName: 'Sparkle', manifest: bodyManifest });
+            expect(result.config.provider).toBe('live2d');
+            expect(result.config.initialExpression).toBe('happy');
+        });
+        test('Hands configurator configures MCP tool execution timeout', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ timeoutSeconds: '15' });
+            const result = await (0, hands_1.configureHands)({ companionName: 'Sparkle', manifest: handsManifest });
+            expect(result.config.defaultTimeoutMs).toBe(15000);
+        });
+        test('Behavior configurator configures active self personality preset', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ preset: 'cheerful' });
+            const result = await (0, behavior_1.configureBehavior)({ companionName: 'Sparkle', manifest: behaviorManifest });
+            expect(result.config.provider).toBe('active_self');
+            expect(result.config.preset).toBe('cheerful');
+        });
+        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');
+        });
+    });
+    describe('Review Summary Formatting & Generator Integration', () => {
+        test('formatReviewSummary displays actual configuration values and metadata', () => {
+            const summaryOutput = (0, index_1.formatReviewSummary)('Sparkle', [brainManifest, memoryManifest, knowledgeManifest, voiceManifest], {
+                brain: { Provider: 'OpenRouter', Model: 'openai/gpt-4o-mini' },
+                memory: { Database: 'PostgreSQL', Deploy: 'Supabase' },
+                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('Memory');
+            expect(summaryOutput).toContain('PostgreSQL');
+            expect(summaryOutput).toContain('Supabase');
+            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' },
+                memory: { provider: 'postgres', deployment: 'supabase' },
+                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, memoryManifest, 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.memory.deployment).toBe('supabase');
+            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 '@siduri-x/brain'");
+            expect(files['src/index.js']).toContain("import { PostgresMemoryOrgan } from '@siduri-x/memory'");
+            expect(files['src/index.js']).toContain("import { EKnowledgeAdapter } from '@siduri-x/knowledge'");
+            expect(files['src/index.js']).toContain("import { VoicevoxAdapter } from '@siduri-x/voice'");
+        });
+    });
+});

package/dist/index.d.ts

@@ -1,4 +1,20 @@
 #!/usr/bin/env node
+import { OrganManifest } from './manifest';
+export declare const CLI_VERSION = "0.0.8";
+export declare const colors: {
+    cyan: string;
+    dim: string;
+    green: string;
+    yellow: string;
+    bold: string;
+    reset: string;
+};
+export declare function printHeader(): void;
+export declare function printSection(title: string): void;
+export declare function printSuccess(message: string): void;
+export declare function projectDirectoryName(value: string): string;
+export declare function formatReviewSummary(companionName: string, selectedManifests: OrganManifest[], organSummaries: Record<string, Record<string, unknown>>): string;
+export declare function withTask<T>(label: string, task: () => Promise<T>): Promise<T>;
 export declare function runCreateWizard(targetDir?: string): Promise<void>;
 export declare function runCliDoctor(targetDir?: string): Promise<void>;
 export declare function runCliDb(subcommand?: string, targetDir?: string): Promise<void>;

package/dist/index.js

@@ -4,6 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = exports.CLI_VERSION = void 0;
+exports.printHeader = printHeader;
+exports.printSection = printSection;
+exports.printSuccess = printSuccess;
+exports.projectDirectoryName = projectDirectoryName;
+exports.formatReviewSummary = formatReviewSummary;
+exports.withTask = withTask;
 exports.runCreateWizard = runCreateWizard;
 exports.runCliDoctor = runCliDoctor;
 exports.runCliDb = runCliDb;
@@ -16,24 +23,26 @@ const discovery_1 = require("./discovery");
 const generator_1 = require("./generator");
 const doctor_1 = require("./doctor");
 const db_1 = require("./db");
+const configurators_1 = require("./configurators");
 const execFile = (0, node_util_1.promisify)(node_child_process_1.execFile);
-const CLI_VERSION = '0.0.7';
-const colors = {
+exports.CLI_VERSION = '0.0.8';
+exports.colors = {
     cyan: '\u001b[36m',
     dim: '\u001b[2m',
     green: '\u001b[32m',
     yellow: '\u001b[33m',
+    bold: '\u001b[1m',
     reset: '\u001b[0m',
 };
 function printHeader() {
-    console.log(`\n${colors.cyan}◈ SIDURI${colors.reset} ${colors.dim}companion setup (manifest-driven)${colors.reset}`);
-    console.log(`${colors.yellow}Version ${CLI_VERSION}${colors.reset} · composable standalone architecture\n`);
+    console.log(`\n${exports.colors.cyan}◈ SIDURI${exports.colors.reset} ${exports.colors.dim}companion setup (manifest-driven)${exports.colors.reset}`);
+    console.log(`${exports.colors.yellow}Version ${exports.CLI_VERSION}${exports.colors.reset} · composable standalone architecture\n`);
 }
 function printSection(title) {
-    console.log(`\n${colors.cyan}── ${title} ${'─'.repeat(Math.max(2, 42 - title.length))}${colors.reset}`);
+    console.log(`\n${exports.colors.cyan}── ${title} ${'─'.repeat(Math.max(2, 42 - title.length))}${exports.colors.reset}\n`);
 }
 function printSuccess(message) {
-    console.log(`${colors.green}✓${colors.reset} ${message}`);
+    console.log(`${exports.colors.green}✓${exports.colors.reset} ${message}`);
 }
 function projectDirectoryName(value) {
     const slug = value
@@ -43,22 +52,47 @@ function projectDirectoryName(value) {
         .replace(/^-+|-+$/g, '');
     return slug || 'siduri';
 }
+function formatReviewSummary(companionName, selectedManifests, organSummaries) {
+    const lines = [];
+    lines.push(`\n${exports.colors.cyan}── Review ${companionName} ${'─'.repeat(Math.max(2, 42 - (companionName.length + 9)))}${exports.colors.reset}\n`);
+    lines.push(`  ${exports.colors.bold}Companion${exports.colors.reset}`);
+    lines.push(`    ${exports.colors.dim}Name:${exports.colors.reset}     ${companionName}\n`);
+    for (const m of selectedManifests) {
+        const isRequired = m.organType === 'brain';
+        const tag = isRequired ? ` ${exports.colors.dim}· required${exports.colors.reset}` : '';
+        lines.push(`  ${exports.colors.bold}${m.displayName.split(' ')[0] || m.organType}${exports.colors.reset}${tag}`);
+        const summary = organSummaries[m.configKey] || organSummaries[m.organType] || {};
+        const entries = Object.entries(summary);
+        if (entries.length === 0) {
+            lines.push(`    ${exports.colors.dim}Provider:${exports.colors.reset} ${m.displayName}`);
+        }
+        else {
+            for (const [key, val] of entries) {
+                const valStr = String(val);
+                lines.push(`    ${exports.colors.dim}${key}:${exports.colors.reset}${' '.repeat(Math.max(1, 10 - key.length))}${valStr}`);
+            }
+        }
+        lines.push('');
+    }
+    lines.push(`${exports.colors.cyan}${'─'.repeat(46)}${exports.colors.reset}\n`);
+    return lines.join('\n');
+}
 async function withTask(label, task) {
-    process.stdout.write(`${colors.dim}${label}${colors.reset}`);
+    process.stdout.write(`${exports.colors.dim}${label}${exports.colors.reset}`);
     const frames = ['·', '•', '●', '•'];
     let index = 0;
     const timer = setInterval(() => {
-        process.stdout.write(`\r${colors.dim}${label} ${frames[index++ % frames.length]}${colors.reset}`);
+        process.stdout.write(`\r${exports.colors.dim}${label} ${frames[index++ % frames.length]}${exports.colors.reset}`);
     }, 120);
     try {
         const result = await task();
         clearInterval(timer);
-        process.stdout.write(`\r${colors.green}✓${colors.reset} ${label}\n`);
+        process.stdout.write(`\r${exports.colors.green}✓${exports.colors.reset} ${label}\n`);
         return result;
     }
     catch (error) {
         clearInterval(timer);
-        process.stdout.write(`\r${colors.yellow}!${colors.reset} ${label}\n`);
+        process.stdout.write(`\r${exports.colors.yellow}!${exports.colors.reset} ${label}\n`);
         throw error;
     }
 }
@@ -86,7 +120,7 @@ async function runCreateWizard(targetDir) {
     const companionName = basicAnswers.name;
     const projectDir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : node_path_1.default.resolve(process.cwd(), projectDirectoryName(companionName));
     printSection('Organ Selection');
-    console.log(`${colors.dim}Select any combination of organs to compose into your standalone instance.${colors.reset}\n`);
+    console.log(`${exports.colors.dim}Select any combination of organs to compose into your standalone instance.${exports.colors.reset}\n`);
     // Brain is required by architecture contract for cognition
     const brainManifest = registry.get('brain');
     const nonBrainManifests = availableManifests.filter((m) => m.organType !== 'brain');
@@ -110,28 +144,77 @@ async function runCreateWizard(targetDir) {
         if (m)
             selectedManifests.push(m);
     }
-    printSection('Review Composition');
-    console.log(`  ${colors.dim}Companion Name:${colors.reset}  ${companionName}`);
-    console.log(`  ${colors.dim}Target Path:${colors.reset}     ${projectDir}`);
-    console.log(`  ${colors.dim}Core Protocol:${colors.reset}   @siduri-x/core`);
-    console.log(`  ${colors.dim}Selected Organs:${colors.reset}`);
+    // 2. Interactive Organ Configuration Stage
+    const organConfigs = {};
+    const organSummaries = {};
     for (const m of selectedManifests) {
-        console.log(`    - ${m.displayName} (${colors.dim}${m.name}${colors.reset})`);
+        const isRequired = m.organType === 'brain';
+        const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
+        printSection(sectionTitle);
+        const res = await (0, configurators_1.configureOrgan)(m, {
+            companionName,
+            existingConfig: organConfigs[m.configKey],
+        });
+        organConfigs[m.configKey] = res.config;
+        organSummaries[m.configKey] = res.summary || {};
     }
-    const { confirm } = await inquirer_1.default.prompt({
-        type: 'confirm',
-        name: 'confirm',
-        message: 'Generate standalone Siduri instance with these organs?',
-        default: true,
-    });
-    if (!confirm) {
-        console.log('Instance creation cancelled.');
-        return;
+    // 3. Final Review and Edit Loop
+    while (true) {
+        console.log(formatReviewSummary(companionName, selectedManifests, organSummaries));
+        const { reviewAction } = await inquirer_1.default.prompt({
+            type: 'list',
+            name: 'reviewAction',
+            message: `Create ${companionName} with this configuration?`,
+            choices: [
+                { name: 'Yes, create', value: 'create' },
+                { name: 'Go back and edit', value: 'edit' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+        if (reviewAction === 'cancel') {
+            console.log('Instance creation cancelled.');
+            return;
+        }
+        if (reviewAction === 'create') {
+            break;
+        }
+        if (reviewAction === 'edit') {
+            const editChoices = selectedManifests.map((m) => ({
+                name: `Edit ${m.displayName}`,
+                value: m.configKey,
+            }));
+            editChoices.push({ name: 'Edit all organs in sequence', value: '__ALL__' });
+            editChoices.push({ name: 'Back to review', value: '__BACK__' });
+            const { organToEdit } = await inquirer_1.default.prompt({
+                type: 'list',
+                name: 'organToEdit',
+                message: 'Which organ would you like to edit?',
+                choices: editChoices,
+            });
+            if (organToEdit === '__BACK__') {
+                continue;
+            }
+            const organsToReconfigure = organToEdit === '__ALL__'
+                ? selectedManifests
+                : selectedManifests.filter((m) => m.configKey === organToEdit);
+            for (const m of organsToReconfigure) {
+                const isRequired = m.organType === 'brain';
+                const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
+                printSection(sectionTitle);
+                const res = await (0, configurators_1.configureOrgan)(m, {
+                    companionName,
+                    existingConfig: organConfigs[m.configKey],
+                });
+                organConfigs[m.configKey] = res.config;
+                organSummaries[m.configKey] = res.summary || {};
+            }
+        }
     }
-    // 2. Generate Files
+    // 4. Generate Instance Files
     const files = (0, generator_1.generateInstanceFiles)({
         name: companionName,
         selectedManifests,
+        organConfigs,
     });
     await (0, promises_1.mkdir)(projectDir, { recursive: true });
     await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'src'), { recursive: true });
@@ -145,7 +228,7 @@ async function runCreateWizard(targetDir) {
         await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'assets/body/model'), { recursive: true });
     }
     printSuccess(`Generated standalone files at ${projectDir}`);
-    // 3. Install packages if not in dry-run
+    // 5. Install packages if not in dry-run
     try {
         await withTask('Installing dependencies (npm install)', async () => {
             await execFile('npm', ['install', '--no-audit', '--no-fund'], { cwd: projectDir });
@@ -153,48 +236,48 @@ async function runCreateWizard(targetDir) {
         printSuccess('Dependencies installed successfully.');
     }
     catch (err) {
-        console.warn(`${colors.yellow}!${colors.reset} Notice: npm install had warnings or requires network: ${err.message}`);
+        console.warn(`${exports.colors.yellow}!${exports.colors.reset} Notice: npm install had warnings or requires network: ${err.message}`);
     }
     printSection('Instance Ready');
-    console.log(`\nYour Siduri companion is ready! Next steps:\n`);
+    console.log(`Your Siduri companion is ready! Next steps:\n`);
     console.log(`  cd ${node_path_1.default.relative(process.cwd(), projectDir) || '.'}`);
-    console.log(`  cp .env.example .env   ${colors.dim}# Fill in required API keys/credentials${colors.reset}`);
-    console.log(`  npm start              ${colors.dim}# Start your standalone companion${colors.reset}\n`);
+    console.log(`  cp .env.example .env   ${exports.colors.dim}# Fill in required API keys/credentials${exports.colors.reset}`);
+    console.log(`  npm start              ${exports.colors.dim}# Start your standalone companion${exports.colors.reset}\n`);
 }
 async function runCliDoctor(targetDir) {
     printHeader();
     const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
-    console.log(`${colors.cyan}Siduri Doctor${colors.reset}`);
-    console.log(`${colors.dim}─────────────${colors.reset}\n`);
+    console.log(`${exports.colors.cyan}Siduri Doctor${exports.colors.reset}`);
+    console.log(`${exports.colors.dim}─────────────${exports.colors.reset}\n`);
     try {
         const report = await (0, doctor_1.runDoctor)({ projectDir: dir });
-        console.log(`${colors.dim}Instance:${colors.reset} ${report.instanceName}`);
-        console.log(`${colors.dim}Organs:${colors.reset}   ${report.configuredOrgans.join(', ')}\n`);
+        console.log(`${exports.colors.dim}Instance:${exports.colors.reset} ${report.instanceName}`);
+        console.log(`${exports.colors.dim}Organs:${exports.colors.reset}   ${report.configuredOrgans.join(', ')}\n`);
         const categories = ['Environment', 'Services', 'Database', 'Health Probe'];
         for (const cat of categories) {
             const items = report.results.filter((r) => r.category === cat);
             if (items.length > 0) {
-                console.log(`${colors.cyan}${cat}${colors.reset}`);
+                console.log(`${exports.colors.cyan}${cat}${exports.colors.reset}`);
                 for (const item of items) {
                     if (item.status === 'PASS') {
-                        console.log(`  ${colors.green}✓${colors.reset} ${item.name} ${colors.dim}(${item.message || 'OK'})${colors.reset}`);
+                        console.log(`  ${exports.colors.green}✓${exports.colors.reset} ${item.name} ${exports.colors.dim}(${item.message || 'OK'})${exports.colors.reset}`);
                     }
                     else if (item.status === 'OPTIONAL_MISSING') {
-                        console.log(`  ${colors.dim}○${colors.reset} ${item.name} ${colors.dim}(Optional, not set)${colors.reset}`);
+                        console.log(`  ${exports.colors.dim}○${exports.colors.reset} ${item.name} ${exports.colors.dim}(Optional, not set)${exports.colors.reset}`);
                     }
                     else if (item.status === 'SKIPPED') {
-                        console.log(`  ${colors.dim}— ${item.name} (${item.message})${colors.reset}`);
+                        console.log(`  ${exports.colors.dim}— ${item.name} (${item.message})${exports.colors.reset}`);
                     }
                     else {
-                        console.log(`  ${colors.yellow}✗${colors.reset} ${item.name}`);
+                        console.log(`  ${exports.colors.yellow}✗${exports.colors.reset} ${item.name}`);
                         if (item.organName) {
-                            console.log(`    ${colors.dim}Required by:${colors.reset} ${item.organName}`);
+                            console.log(`    ${exports.colors.dim}Required by:${exports.colors.reset} ${item.organName}`);
                         }
                         if (item.message) {
-                            console.log(`    ${colors.yellow}${item.message}${colors.reset}`);
+                            console.log(`    ${exports.colors.yellow}${item.message}${exports.colors.reset}`);
                         }
                         if (item.remediation) {
-                            console.log(`    ${colors.dim}Remediation:${colors.reset} ${item.remediation}`);
+                            console.log(`    ${exports.colors.dim}Remediation:${exports.colors.reset} ${item.remediation}`);
                         }
                     }
                 }
@@ -202,16 +285,16 @@ async function runCliDoctor(targetDir) {
             }
         }
         if (report.passed) {
-            console.log(`${colors.green}Result: PASS${colors.reset}\n`);
+            console.log(`${exports.colors.green}Result: PASS${exports.colors.reset}\n`);
             process.exitCode = 0;
         }
         else {
-            console.log(`${colors.yellow}Result: FAIL${colors.reset}\n`);
+            console.log(`${exports.colors.yellow}Result: FAIL${exports.colors.reset}\n`);
             process.exitCode = 1;
         }
     }
     catch (err) {
-        console.error(`\n${colors.yellow}Doctor Error:${colors.reset} ${err.message}\n`);
+        console.error(`\n${exports.colors.yellow}Doctor Error:${exports.colors.reset} ${err.message}\n`);
         process.exitCode = 2;
     }
 }
@@ -223,24 +306,24 @@ async function runCliDb(subcommand, targetDir) {
         return;
     }
     const dir = targetDir ? node_path_1.default.resolve(process.cwd(), targetDir) : process.cwd();
-    console.log(`${colors.cyan}Siduri Database Migrations${colors.reset}`);
-    console.log(`${colors.dim}──────────────────────────${colors.reset}\n`);
+    console.log(`${exports.colors.cyan}Siduri Database Migrations${exports.colors.reset}`);
+    console.log(`${exports.colors.dim}──────────────────────────${exports.colors.reset}\n`);
     try {
         const res = await (0, db_1.runDbPush)({ projectDir: dir });
         if (res.status === 'NOOP') {
-            console.log(`${colors.dim}— ${res.message}${colors.reset}\n`);
+            console.log(`${exports.colors.dim}— ${res.message}${exports.colors.reset}\n`);
         }
         else {
             printSuccess(res.message);
             if (res.appliedMigrations.length > 0) {
-                console.log(`${colors.dim}Applied:${colors.reset} ${res.appliedMigrations.join(', ')}`);
+                console.log(`${exports.colors.dim}Applied:${exports.colors.reset} ${res.appliedMigrations.join(', ')}`);
             }
             console.log();
         }
         process.exitCode = 0;
     }
     catch (err) {
-        console.error(`\n${colors.yellow}Database Migration Error:${colors.reset} ${err.message}\n`);
+        console.error(`\n${exports.colors.yellow}Database Migration Error:${exports.colors.reset} ${err.message}\n`);
         process.exitCode = 3;
     }
 }
@@ -248,7 +331,7 @@ async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
     if (command === '--version' || command === '-v') {
-        console.log(CLI_VERSION);
+        console.log(exports.CLI_VERSION);
         return;
     }
     if (command === 'create') {
@@ -279,7 +362,7 @@ if (require.main === module) {
             console.log('\nOperation cancelled.');
             return;
         }
-        console.error(`\n${colors.yellow}!${colors.reset} ${error instanceof Error ? error.message : error}`);
+        console.error(`\n${exports.colors.yellow}!${exports.colors.reset} ${error instanceof Error ? error.message : error}`);
         process.exitCode = 1;
     });
 }