@vxnus/siduri 0.1.11 → 2.0.1

package/dist/doctor-db.test.js

@@ -11,10 +11,9 @@ const generator_1 = require("./generator");
 const discovery_1 = require("./discovery");
 describe('Phase 4: Diagnostics and Database Provisioning Tests', () => {
     const rootOrgansDir = node_path_1.default.resolve(__dirname, '../../packages/organs');
-    const registry = discovery_1.OrganRegistry.discover([rootOrgansDir]);
+    const registry = discovery_1.OrganRegistry.discover();
     const brain = registry.get('brain');
     const hands = registry.get('hands');
-    const memory = registry.get('memory');
     const testTempRoot = node_path_1.default.resolve(__dirname, '../temp-phase4-test');
     beforeAll(() => {
         if (node_fs_1.default.existsSync(testTempRoot)) {
@@ -27,14 +26,6 @@ describe('Phase 4: Diagnostics and Database Provisioning Tests', () => {
             node_fs_1.default.rmSync(testTempRoot, { recursive: true, force: true });
         }
     });
-    test('redactDatabaseUrl redacts password and sensitive credentials', () => {
-        const raw = 'postgresql://myuser:supersecretpassword@db.example.com:5432/siduri_db';
-        const redacted = (0, db_1.redactDatabaseUrl)(raw);
-        expect(redacted).not.toContain('supersecretpassword');
-        expect(redacted).toContain('***');
-        expect(redacted).toContain('myuser');
-        expect(redacted).toContain('db.example.com:5432/siduri_db');
-    });
     test('Test Matrix A: Brain only instance doctor and db push', async () => {
         const instanceDir = node_path_1.default.join(testTempRoot, 'brain-only');
         node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
@@ -49,93 +40,13 @@ describe('Phase 4: Diagnostics and Database Provisioning Tests', () => {
                 node_fs_1.default.writeFileSync(fullPath, content);
             }
         }
-        // 1. Doctor without OPENROUTER_API_KEY -> FAIL (Brain Health Probe fails)
-        const doctorFail = await (0, doctor_1.runDoctor)({ projectDir: instanceDir, env: { OPENROUTER_API_KEY: '' } });
-        expect(doctorFail.passed).toBe(false);
-        expect(doctorFail.results.some((r) => r.category === 'Health Probe' && r.status === 'FAIL')).toBe(true);
-        // Database check must be SKIPPED
-        expect(doctorFail.results.some((r) => r.category === 'Database' && r.status === 'SKIPPED')).toBe(true);
-        // 2. Doctor with OPENROUTER_API_KEY -> PASS
         const doctorPass = await (0, doctor_1.runDoctor)({
             projectDir: instanceDir,
             env: { OPENROUTER_API_KEY: 'test-key-123' },
         });
         expect(doctorPass.passed).toBe(true);
-        // 3. db push -> NOOP ("No database migrations are required...")
-        const dbResult = await (0, db_1.runDbPush)({ projectDir: instanceDir });
-        expect(dbResult.status).toBe('NOOP');
-        expect(dbResult.message).toContain('No database migrations are required');
-    });
-    test('Test Matrix B: Brain + Hands instance doctor and db push', async () => {
-        const instanceDir = node_path_1.default.join(testTempRoot, 'brain-hands');
-        node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
-        const files = (0, generator_1.generateInstanceFiles)({
-            name: 'BrainHandsInstance',
-            selectedManifests: [brain, hands],
-        });
-        for (const [name, content] of Object.entries(files)) {
-            if (typeof content === 'string') {
-                const fullPath = node_path_1.default.join(instanceDir, name);
-                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
-                node_fs_1.default.writeFileSync(fullPath, content);
-            }
-        }
-        // Doctor checks both keys
-        const doctorRes = await (0, doctor_1.runDoctor)({
-            projectDir: instanceDir,
-            env: {
-                OPENROUTER_API_KEY: 'test-openrouter-key',
-                ACTION_POLICY_SECRET: 'test-policy-secret',
-            },
-        });
-        expect(doctorRes.passed).toBe(true);
-        expect(doctorRes.results.some((r) => r.name === 'OPENROUTER_API_KEY' && r.status === 'PASS')).toBe(true);
-        expect(doctorRes.results.some((r) => r.name === 'ACTION_POLICY_SECRET' && r.status === 'PASS')).toBe(true);
-        // Database check must be SKIPPED
-        expect(doctorRes.results.some((r) => r.category === 'Database' && r.status === 'SKIPPED')).toBe(true);
-        // db push returns NOOP
         const dbResult = await (0, db_1.runDbPush)({ projectDir: instanceDir });
         expect(dbResult.status).toBe('NOOP');
-    });
-    test('Test Matrix C: Brain + Memory instance requires DATABASE_URL', async () => {
-        const instanceDir = node_path_1.default.join(testTempRoot, 'brain-memory');
-        node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
-        const files = (0, generator_1.generateInstanceFiles)({
-            name: 'BrainMemoryInstance',
-            selectedManifests: [brain, memory],
-        });
-        for (const [name, content] of Object.entries(files)) {
-            if (typeof content === 'string') {
-                const fullPath = node_path_1.default.join(instanceDir, name);
-                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
-                node_fs_1.default.writeFileSync(fullPath, content);
-            }
-        }
-        // 1. Doctor fails without DATABASE_URL
-        const doctorMissingDb = await (0, doctor_1.runDoctor)({
-            projectDir: instanceDir,
-            env: { OPENROUTER_API_KEY: 'test-key' },
-        });
-        expect(doctorMissingDb.passed).toBe(false);
-        expect(doctorMissingDb.results.some((r) => r.name === 'DATABASE_URL' && r.status === 'FAIL')).toBe(true);
-        // 2. db push fails clearly without DATABASE_URL
-        await expect((0, db_1.runDbPush)({ projectDir: instanceDir, env: {} })).rejects.toThrow(/DATABASE_URL is required/);
-    });
-    test('Test Matrix D: Diagnostics and Error Handling for invalid or missing configs', async () => {
-        // 1. Missing siduri.config.json
-        const nonExistentDir = node_path_1.default.join(testTempRoot, 'non-existent-dir');
-        await expect((0, doctor_1.runDoctor)({ projectDir: nonExistentDir })).rejects.toThrow(/siduri.config.json not found/);
-        await expect((0, db_1.runDbPush)({ projectDir: nonExistentDir })).rejects.toThrow(/siduri.config.json not found/);
-        // 2. Unreachable PostgreSQL host reported gracefully by doctor
-        const instDir = node_path_1.default.join(testTempRoot, 'brain-memory');
-        const doctorUnreachable = await (0, doctor_1.runDoctor)({
-            projectDir: instDir,
-            env: {
-                OPENROUTER_API_KEY: 'test-key',
-                DATABASE_URL: 'postgresql://postgres:postgres@127.0.0.1:59999/non_existent_db',
-            },
-        });
-        expect(doctorUnreachable.passed).toBe(false);
-        expect(doctorUnreachable.results.some((r) => r.category === 'Database' && r.status === 'FAIL')).toBe(true);
+        expect(dbResult.message).toContain('SQLite manages schema natively.');
     });
 });

package/dist/doctor.js

@@ -7,7 +7,6 @@ exports.runDoctor = runDoctor;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const discovery_1 = require("./discovery");
-const pg_1 = require("pg");
 const schema_validator_1 = require("./schema-validator");
 async function runDoctor(options = {}) {
     const projectDir = options.projectDir ? node_path_1.default.resolve(options.projectDir) : process.cwd();
@@ -130,61 +129,74 @@ async function runDoctor(options = {}) {
     // 3. Check External Services
     for (const m of selectedManifests) {
         for (const service of m.services || []) {
-            results.push({
-                category: 'Services',
-                name: `${service.name} (${m.organType})`,
-                status: 'PASS',
-                organName: m.name,
-                message: 'Service requirement declared',
-            });
+            const organConf = configuredOrgansMap[m.configKey] || configuredOrgansMap[m.organType];
+            const configuredUrl = organConf?.baseUrl || organConf?.url || effectiveEnv[`${service.name.toUpperCase()}_URL`];
+            if (configuredUrl && typeof configuredUrl === 'string' && configuredUrl.startsWith('http')) {
+                try {
+                    const controller = new AbortController();
+                    const timer = setTimeout(() => controller.abort(), 1000);
+                    await fetch(configuredUrl, { signal: controller.signal }).catch(() => { });
+                    clearTimeout(timer);
+                    results.push({
+                        category: 'Services',
+                        name: `${service.name} (${m.organType})`,
+                        status: 'PASS',
+                        organName: m.name,
+                        message: `Endpoint configured: ${configuredUrl}`,
+                    });
+                }
+                catch {
+                    results.push({
+                        category: 'Services',
+                        name: `${service.name} (${m.organType})`,
+                        status: 'OPTIONAL_MISSING',
+                        organName: m.name,
+                        message: `Service at ${configuredUrl} is not responding (optional local service)`,
+                        remediation: `Start ${service.name} or allow auto-download if applicable.`,
+                    });
+                }
+            }
+            else {
+                results.push({
+                    category: 'Services',
+                    name: `${service.name} (${m.organType})`,
+                    status: 'PASS',
+                    organName: m.name,
+                    message: 'Service requirement declared (managed locally)',
+                });
+            }
         }
     }
     // 4. Database Check (only if an organ declares database requirement)
     const dbOrgan = selectedManifests.find((m) => m.database !== null && m.database !== undefined);
     if (dbOrgan) {
-        const dbUrl = effectiveEnv.DATABASE_URL;
-        if (!dbUrl) {
+        try {
+            const testDbPath = node_path_1.default.join(projectDir, '.doctor-sqlite-test.tmp');
+            node_fs_1.default.writeFileSync(testDbPath, '');
+            node_fs_1.default.unlinkSync(testDbPath);
             results.push({
                 category: 'Database',
-                name: 'PostgreSQL Connection',
-                status: 'FAIL',
+                name: 'SQLite Database',
+                status: 'PASS',
                 organName: dbOrgan.name,
-                message: 'DATABASE_URL is not configured.',
-                remediation: 'Provide DATABASE_URL in .env (e.g. postgresql://postgres:postgres@localhost:5432/siduri)',
+                message: 'Local storage directory writeable; SQLite operational',
             });
         }
-        else {
-            const pool = new pg_1.Pool({ connectionString: dbUrl, connectionTimeoutMillis: 3000 });
-            try {
-                const client = await pool.connect();
-                await client.query('SELECT 1');
-                client.release();
-                await pool.end();
-                results.push({
-                    category: 'Database',
-                    name: 'PostgreSQL Connection',
-                    status: 'PASS',
-                    organName: dbOrgan.name,
-                    message: 'Connection successful',
-                });
-            }
-            catch (err) {
-                await pool.end().catch(() => { });
-                results.push({
-                    category: 'Database',
-                    name: 'PostgreSQL Connection',
-                    status: 'FAIL',
-                    organName: dbOrgan.name,
-                    message: `Connection failed: ${err.message}`,
-                    remediation: 'Check database host availability, port, credentials, and network accessibility.',
-                });
-            }
+        catch (err) {
+            results.push({
+                category: 'Database',
+                name: 'SQLite Database',
+                status: 'FAIL',
+                organName: dbOrgan.name,
+                message: `Storage directory write check failed: ${err.message}`,
+                remediation: 'Verify write permissions for the companion directory.',
+            });
         }
     }
     else {
         results.push({
             category: 'Database',
-            name: 'PostgreSQL Database',
+            name: 'SQLite Database',
             status: 'SKIPPED',
             message: 'Not required by current composition',
         });

package/dist/generator.js

@@ -36,7 +36,7 @@ function getDefaultConfigForManifest(manifest) {
         config.apiKeyEnv = 'OPENROUTER_API_KEY';
     }
     else if (manifest.organType === 'memory') {
-        config.provider = config.provider || 'postgres';
+        config.provider = config.provider || 'sqlite';
     }
     else if (manifest.organType === 'voice') {
         config.provider = config.provider || 'voicevox';
@@ -72,7 +72,7 @@ function getDefaultConfigForManifest(manifest) {
 function generateInstanceFiles(options) {
     const instanceName = options.name || 'my-siduri';
     const instanceId = options.id || 'default';
-    const coreVersion = options.coreVersion || '^1.0.9';
+    const coreVersion = options.coreVersion || '^2.0.1';
     const manifests = options.selectedManifests;
     const hasMemory = manifests.some((m) => m.organType === 'memory');
     const hasVoice = manifests.some((m) => m.organType === 'voice');
@@ -80,14 +80,12 @@ function generateInstanceFiles(options) {
     const hasMouth = manifests.some((m) => m.organType === 'mouth');
     const voiceConfig = options.organConfigs?.voice || options.organConfigs?.['@siduri-x/voice'];
     const isVoicevox = hasVoice && (!voiceConfig || voiceConfig.provider === 'voicevox');
-    const memoryConfig = options.organConfigs?.memory || options.organConfigs?.['@siduri-x/memory'];
-    const isPostgresLocal = hasMemory && (!memoryConfig || memoryConfig.deployment === 'local' || memoryConfig.provider === 'postgres');
     // 1. package.json
     const dependencies = {
         '@siduri-x/core': coreVersion,
     };
     for (const m of manifests) {
-        dependencies[m.name] = `^${m.version || '1.0.1'}`;
+        dependencies[m.name] = `^${m.version || '2.0.1'}`;
     }
     const scripts = {
         start: 'node src/index.js',
@@ -95,12 +93,19 @@ function generateInstanceFiles(options) {
         doctor: 'siduri doctor',
         db: 'siduri db',
     };
+    const devDependencies = {
+        '@vxnus/siduri': coreVersion,
+    };
     const packageJsonObj = {
         name: instanceName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'my-siduri',
         private: true,
         type: 'module',
+        engines: {
+            node: '>=22.16.0',
+        },
         scripts,
         dependencies,
+        devDependencies,
     };
     const packageJson = JSON.stringify(packageJsonObj, null, 2) + '\n';
     // 3. siduri.config.json
@@ -164,14 +169,35 @@ function generateInstanceFiles(options) {
         `import { SiduriRuntime, dispatchCompanionChat, validateCompanionConfig } from '@siduri-x/core';`,
     ];
     for (const m of manifests) {
-        importLines.push(`import { ${m.factory} } from '${m.name}';`);
+        if (m.name === '@siduri-x/self') {
+            importLines.push(`import { ActiveSelfCompiler, SqliteSelfRepository } from '@siduri-x/self';`);
+        }
+        else {
+            importLines.push(`import { ${m.factory} } from '${m.name}';`);
+        }
     }
     const instantiationLines = [];
     const organMapEntries = [];
     for (const m of manifests) {
-        const varName = m.configKey;
-        instantiationLines.push(`const ${varName} = new ${m.factory}(config.organs.${m.configKey});`);
-        organMapEntries.push(`  ${varName},`);
+        if (m.name === '@siduri-x/self') {
+            instantiationLines.push(`const self = new SqliteSelfRepository({ dbPath: path.resolve(rootDir, 'siduri.sqlite') });`);
+            instantiationLines.push(`const behavior = new ActiveSelfCompiler(config.organs.behavior);`);
+            organMapEntries.push(`  behavior,`);
+            organMapEntries.push(`  self,`);
+        }
+        else if (m.name === '@siduri-x/memory') {
+            instantiationLines.push(`const memory = new ${m.factory}({ ...config.organs.${m.configKey}, dbPath: path.resolve(rootDir, config.organs.${m.configKey}?.dbPath || 'siduri.sqlite') });`);
+            organMapEntries.push(`  ${m.configKey},`);
+        }
+        else if (m.name === '@siduri-x/knowledge') {
+            instantiationLines.push(`const knowledge = new ${m.factory}({ ...config.organs.${m.configKey}, dbPath: path.resolve(rootDir, config.organs.${m.configKey}?.dbPath || 'siduri.sqlite') });`);
+            organMapEntries.push(`  ${m.configKey},`);
+        }
+        else {
+            const varName = m.configKey;
+            instantiationLines.push(`const ${varName} = new ${m.factory}(config.organs.${m.configKey});`);
+            organMapEntries.push(`  ${varName},`);
+        }
     }
     if (hasMouth && hasVoice) {
         instantiationLines.push(`if (typeof mouth?.setVoiceOrgan === 'function') mouth.setVoiceOrgan(voice);`);
@@ -184,6 +210,14 @@ function generateInstanceFiles(options) {
         `const __dirname = path.dirname(__filename);`,
         `const rootDir = path.resolve(__dirname, '..');`,
         '',
+        `try {`,
+        `  process.loadEnvFile(path.join(rootDir, '.env'));`,
+        `} catch (err) {`,
+        `  if (err?.code !== 'ENOENT') {`,
+        `    console.error('Failed to load .env file:', err.message);`,
+        `  }`,
+        `}`,
+        '',
         `const config = JSON.parse(`,
         `  await readFile(path.join(rootDir, 'siduri.config.json'), 'utf8')`,
         `);`,
@@ -222,6 +256,51 @@ function generateInstanceFiles(options) {
         `    return;`,
         `  }`,
         '',
+        `  // API: Ready probe`,
+        `  if (pathname === '/ready' && req.method === 'GET') {`,
+        `    res.writeHead(200, { 'Content-Type': 'application/json' });`,
+        `    res.end(JSON.stringify({ status: 'ready', companionId: config.id }));`,
+        `    return;`,
+        `  }`,
+        '',
+        `  // API: Version info`,
+        `  if (pathname === '/version' && req.method === 'GET') {`,
+        `    res.writeHead(200, { 'Content-Type': 'application/json' });`,
+        `    res.end(JSON.stringify({ version: '2.0.1', name: config.name, id: config.id }));`,
+        `    return;`,
+        `  }`,
+        '',
+        `  // API: Identity info`,
+        `  if (pathname === '/me' && req.method === 'GET') {`,
+        `    res.writeHead(200, { 'Content-Type': 'application/json' });`,
+        `    res.end(JSON.stringify({`,
+        `      id: config.id,`,
+        `      name: config.name,`,
+        `      organs: Object.keys(config.organs || {}),`,
+        `    }));`,
+        `    return;`,
+        `  }`,
+        '',
+        `  // API: Voice & Observation health probes`,
+        `  if (pathname === '/voice/health' && req.method === 'GET') {`,
+        `    res.writeHead(200, { 'Content-Type': 'application/json' });`,
+        `    res.end(JSON.stringify({ provider: config.organs?.voice?.provider || 'none', configured: Boolean(runtime.voice) }));`,
+        `    return;`,
+        `  }`,
+        '',
+        `  if (pathname === '/obs/health' && req.method === 'GET') {`,
+        `    res.writeHead(200, { 'Content-Type': 'application/json' });`,
+        `    res.end(JSON.stringify({ provider: config.organs?.vision?.provider || 'none', configured: Boolean(runtime.vision) }));`,
+        `    return;`,
+        `  }`,
+        '',
+        `  // API: Evidence & observations`,
+        `  if ((pathname === '/evidence' || pathname === '/observations') && req.method === 'GET') {`,
+        `    res.writeHead(200, { 'Content-Type': 'application/json' });`,
+        `    res.end(JSON.stringify({ items: [] }));`,
+        `    return;`,
+        `  }`,
+        '',
         `  // API: Audio buffer retrieval for voice playback`,
         `  if (pathname.startsWith('/api/audio/') && req.method === 'GET') {`,
         `    const audioId = pathname.slice('/api/audio/'.length);`,
@@ -573,20 +652,17 @@ function generateInstanceFiles(options) {
         '',
         '## Prerequisites',
         '',
-        '- **Node.js**: `v20.0.0` or higher',
+        '- **Node.js**: `v22.16.0` or higher',
         '- **Environment**: Valid `.env` file (configured from `.env.example`)',
     ];
     if (hasMemory) {
-        readmeLines.push('- **PostgreSQL (Optional)**: Required if PostgreSQL memory organ is enabled (local PostgreSQL server or cloud Supabase/Neon).');
+        readmeLines.push('- **Database**: Embedded SQLite (`siduri.sqlite`). Automatically initialized with WAL mode and FTS5 full-text indexing with zero external setup.');
     }
     if (isVoicevox) {
         readmeLines.push('- **VOICEVOX**: Note: The Voicevox engine executable will be securely auto-downloaded at runtime by Siduri if no local URL is provided.');
     }
     readmeLines.push('', '## Getting Started', '', '### 1. Install Dependencies', '```bash', 'npm install', '```', '', '### 2. Configure Environment', '```bash', 'cp .env.example .env', '```', 'Fill in your LLM API key (e.g. `OPENROUTER_API_KEY`) and any other service credentials in `.env`.');
-    if (hasMemory) {
-        readmeLines.push('', '### 3. Database Migrations', 'Ensure `DATABASE_URL` in `.env` is reachable, then push the memory organ PostgreSQL schema:', '```bash', 'npx @vxnus/siduri db push', '```');
-    }
-    readmeLines.push('', `### ${hasMemory ? '4' : '3'}. Diagnostics & Health Probe`, 'Verify all environment variables, schema conformance, services, and organ connections:', '```bash', 'npm run doctor', '```', '', `### ${hasMemory ? '5' : '4'}. Start Companion & Web Console`, 'Launch your companion runtime and Web UI / Memory Control Panel:', '```bash', 'npm start', '```', 'Then open `http://localhost:3000` in your browser.');
+    readmeLines.push('', '### 3. Diagnostics & Health Probe', 'Verify all environment variables, schema conformance, services, and organ connections:', '```bash', 'npm run doctor', '```', '', '### 4. Start Companion & Web Console', 'Launch your companion runtime and Web UI / Memory Control Panel:', '```bash', 'npm start', '```', 'Then open `http://localhost:3000` in your browser.');
     const companionSlug = instanceName.toLowerCase().replace(/[^a-z0-9_-]/g, '') || 'default';
     const createAssetsDirs = [];
     if (hasBody) {

package/dist/generator.test.js

@@ -31,14 +31,14 @@ describe('Instance Generator Composition Invariants (Phase 3)', () => {
             name: '@siduri-x/memory',
             organType: 'memory',
             version: '1.0.0',
-            displayName: 'Memory (PostgreSQL FTS Claims)',
+            displayName: 'Memory (SQLite FTS5 Claims)',
             entrypoint: './dist/index.js',
-            factory: 'PostgresMemoryOrgan',
+            factory: 'SqliteMemoryStore',
             configKey: 'memory',
             configSchema: { type: 'object', properties: { provider: { type: 'string' } } },
-            environment: [{ name: 'DATABASE_URL', required: true, secret: true }],
-            services: [{ name: 'PostgreSQL', kind: 'database' }],
-            database: { engine: 'postgres', migrationsDir: './migrations' },
+            environment: [],
+            services: [],
+            database: { engine: 'sqlite' },
         },
         body: {
             name: '@siduri-x/body',
@@ -77,6 +77,7 @@ describe('Instance Generator Composition Invariants (Phase 3)', () => {
         expect(pkg.dependencies['@siduri-x/hands']).toBeUndefined();
         expect(pkg.dependencies['@siduri-x/voice']).toBeUndefined();
         expect(pkg.dependencies['@siduri-x/body']).toBeUndefined();
+        expect(pkg.devDependencies['@vxnus/siduri']).toBeDefined();
         // src/index.js
         expect(files['src/index.js']).toContain("import { OpenRouterBrain } from '@siduri-x/brain'");
         expect(files['src/index.js']).not.toContain('@siduri-x/hands');
@@ -126,11 +127,12 @@ describe('Instance Generator Composition Invariants (Phase 3)', () => {
         expect(pkg.dependencies['@siduri-x/hands']).toBeUndefined();
         // .env.example
         expect(files['.env.example']).toContain('OPENROUTER_API_KEY');
-        expect(files['.env.example']).toContain('DATABASE_URL');
+        expect(files['.env.example']).not.toContain('DATABASE_URL');
         expect(files['.env.example']).not.toContain('ACTION_POLICY_SECRET');
         // README mentions database
-        expect(files['README.md']).toContain('DATABASE_URL');
-        expect(files['README.md']).toContain('npx @vxnus/siduri db push');
+        expect(files['README.md']).toContain('siduri.sqlite');
+        expect(files['README.md']).not.toContain('PostgreSQL');
+        expect(files['README.md']).not.toContain('npx @vxnus/siduri db push');
     });
     test('Composition D: Full with Body', () => {
         const files = (0, generator_1.generateInstanceFiles)({

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { OrganManifest } from './manifest';
-export declare const CLI_VERSION = "0.1.10";
+export declare const CLI_VERSION = "2.0.1";
 export declare const colors: {
     cyan: string;
     dim: string;

package/dist/index.js

@@ -26,7 +26,7 @@ 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);
-exports.CLI_VERSION = '0.1.10';
+exports.CLI_VERSION = '2.0.1';
 exports.colors = {
     cyan: '\u001b[36m',
     dim: '\u001b[2m',
@@ -120,37 +120,46 @@ 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(`${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');
-    const organChoices = nonBrainManifests.map((m) => ({
-        name: `${m.displayName} (${m.name})`,
-        value: m.organType,
-        checked: m.organType === 'memory', // default memory checked
-    }));
-    const { selectedOrganTypes } = await inquirer_1.default.prompt({
-        type: 'checkbox',
-        name: 'selectedOrganTypes',
-        message: 'Select organs to install:',
-        choices: organChoices,
-    });
+    printSection('Organ Configuration');
+    console.log(`${exports.colors.dim}Configure each capability organ for your standalone companion instance.${exports.colors.reset}\n`);
     const selectedManifests = [];
+    const organConfigs = {};
+    const organSummaries = {};
+    // Brain is required by architecture contract for cognition
+    const brainManifest = registry.get('brain') || availableManifests.find((m) => m.organType === 'brain');
     if (brainManifest) {
         selectedManifests.push(brainManifest);
+        printSection('Brain · required');
+        const res = await (0, configurators_1.configureOrgan)(brainManifest, {
+            companionName,
+        });
+        organConfigs[brainManifest.configKey] = res.config;
+        organSummaries[brainManifest.configKey] = res.summary || {};
     }
-    for (const organType of selectedOrganTypes) {
-        const m = registry.get(organType);
-        if (m)
-            selectedManifests.push(m);
-    }
-    // 2. Interactive Organ Configuration Stage
-    const organConfigs = {};
-    const organSummaries = {};
-    for (const m of selectedManifests) {
-        const isRequired = m.organType === 'brain';
-        const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
+    // Canonical organ presentation order
+    const canonicalOrder = ['memory', 'knowledge', 'behavior', 'voice', 'body', 'mouth', 'hands', 'vision', 'ear', 'observation'];
+    const nonBrainManifests = availableManifests
+        .filter((m) => m.organType !== 'brain')
+        .sort((a, b) => {
+        const idxA = canonicalOrder.indexOf(a.organType);
+        const idxB = canonicalOrder.indexOf(b.organType);
+        const valA = idxA === -1 ? 99 : idxA;
+        const valB = idxB === -1 ? 99 : idxB;
+        return valA - valB;
+    });
+    for (const m of nonBrainManifests) {
+        const isRecommended = ['memory', 'knowledge', 'behavior', 'voice', 'body', 'mouth'].includes(m.organType);
+        const { enableOrgan } = await inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'enableOrgan',
+            message: `Enable ${m.displayName}?`,
+            default: isRecommended,
+        });
+        if (!enableOrgan) {
+            continue;
+        }
+        selectedManifests.push(m);
+        const sectionTitle = m.displayName.split(' ')[0] || m.organType;
         printSection(sectionTitle);
         const res = await (0, configurators_1.configureOrgan)(m, {
             companionName,
@@ -264,10 +273,6 @@ async function runCreateWizard(targetDir) {
     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          ${exports.colors.dim}# Fill in required API keys/credentials${exports.colors.reset}`);
-    const hasMemory = selectedManifests.some((m) => m.organType === 'memory');
-    if (hasMemory) {
-        console.log(`  npx @vxnus/siduri db push     ${exports.colors.dim}# Push PostgreSQL memory schema${exports.colors.reset}`);
-    }
     console.log(`  npm run doctor                ${exports.colors.dim}# Run diagnostic health probes${exports.colors.reset}`);
     console.log(`  npm start                     ${exports.colors.dim}# Start Web Companion & Memory Console at http://localhost:3000${exports.colors.reset}\n`);
 }

package/dist/manifest.d.ts

@@ -12,7 +12,7 @@ export interface OrganServiceRequirement {
     description?: string;
 }
 export interface OrganDatabaseRequirement {
-    engine: 'postgres' | 'sqlite' | string;
+    engine: 'sqlite' | string;
     migrationsDir?: string;
 }
 export interface OrganManifest {

package/dist/providers/openrouter.js

@@ -32,7 +32,7 @@ class OpenRouterModelProvider {
                 method: 'GET',
                 headers: {
                     Accept: 'application/json',
-                    'User-Agent': 'Siduri-CLI/1.0',
+                    'User-Agent': 'Siduri-CLI/2.0',
                 },
                 signal: controller.signal,
             });

package/dist/release-check.js

@@ -19,11 +19,12 @@ function runReleaseCheck(repoRoot = node_path_1.default.resolve(__dirname, '../.
     const getPkgVer = (dir) => JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.resolve(repoRoot, dir, 'package.json'), 'utf8')).version;
     const canonicalPackages = [
         { name: '@siduri-x/core', dir: 'packages/core', isOrgan: false, tarName: `siduri-x-core-${getPkgVer('packages/core')}.tgz` },
+        { name: '@siduri-x/self', dir: 'packages/self', isOrgan: false, tarName: `siduri-x-self-${getPkgVer('packages/self')}.tgz` },
+        { name: '@siduri-x/knowledge', dir: 'packages/knowledge', isOrgan: false, tarName: `siduri-x-knowledge-${getPkgVer('packages/knowledge')}.tgz` },
+        { name: '@siduri-x/memory', dir: 'packages/memory', isOrgan: false, tarName: `siduri-x-memory-${getPkgVer('packages/memory')}.tgz` },
         { name: '@siduri-x/brain', dir: 'packages/organs/brain', isOrgan: true, tarName: `siduri-x-brain-${getPkgVer('packages/organs/brain')}.tgz` },
-        { name: '@siduri-x/memory', dir: 'packages/organs/memory', isOrgan: true, tarName: `siduri-x-memory-${getPkgVer('packages/organs/memory')}.tgz` },
-        { name: '@siduri-x/knowledge', dir: 'packages/organs/knowledge', isOrgan: true, tarName: `siduri-x-knowledge-${getPkgVer('packages/organs/knowledge')}.tgz` },
-        { name: '@siduri-x/behavior', dir: 'packages/organs/behavior', isOrgan: true, tarName: `siduri-x-behavior-${getPkgVer('packages/organs/behavior')}.tgz` },
         { name: '@siduri-x/ear', dir: 'packages/organs/ear', isOrgan: true, tarName: `siduri-x-ear-${getPkgVer('packages/organs/ear')}.tgz` },
+        { name: '@siduri-x/eknowledge', dir: 'packages/organs/eknowledge', isOrgan: true, tarName: `siduri-x-eknowledge-${getPkgVer('packages/organs/eknowledge')}.tgz` },
         { name: '@siduri-x/vision', dir: 'packages/organs/vision', isOrgan: true, tarName: `siduri-x-vision-${getPkgVer('packages/organs/vision')}.tgz` },
         { name: '@siduri-x/hands', dir: 'packages/organs/hands', isOrgan: true, tarName: `siduri-x-hands-${getPkgVer('packages/organs/hands')}.tgz` },
         { name: '@siduri-x/body', dir: 'packages/organs/body', isOrgan: true, tarName: `siduri-x-body-${getPkgVer('packages/organs/body')}.tgz` },
@@ -40,7 +41,7 @@ function runReleaseCheck(repoRoot = node_path_1.default.resolve(__dirname, '../.
         for (const pkg of canonicalPackages) {
             packagesChecked++;
             try {
-                run(`pnpm --filter ${pkg.name} pack --pack-destination ${tempPackDir}`, repoRoot);
+                run(`pnpm pack --pack-destination ${tempPackDir}`, node_path_1.default.resolve(repoRoot, pkg.dir));
             }
             catch (err) {
                 errors.push(`Failed to pack ${pkg.name}: ${err.message}`);
@@ -88,11 +89,6 @@ function runReleaseCheck(repoRoot = node_path_1.default.resolve(__dirname, '../.
                     manifestsValidated++;
                 }
             }
-            if (pkg.name === '@siduri-x/memory') {
-                if (!listing.some((l) => l.includes('package/migrations/001_initial_schema.sql'))) {
-                    errors.push(`${pkg.name}: migrations/001_initial_schema.sql missing in tarball`);
-                }
-            }
             if (pkg.name === '@vxnus/siduri') {
                 if (!pkgJson.bin || !pkgJson.bin.siduri) {
                     errors.push(`${pkg.name}: bin.siduri field missing in package.json`);