@vxnus/siduri 2.0.0 → 2.0.2

package/dist/configurators/knowledge.js

@@ -5,15 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureKnowledge = configureKnowledge;
 const inquirer_1 = __importDefault(require("inquirer"));
+const node_fs_1 = __importDefault(require("node:fs"));
 const knowledge_hub_1 = require("../providers/knowledge-hub");
 async function configureKnowledge(_context, options = {}) {
     const client = options.client || new knowledge_hub_1.KnowledgeHubClient();
+    // 1. Ask Knowledge source / mode
     const { source } = await inquirer_1.default.prompt({
         type: 'list',
         name: 'source',
-        message: 'Knowledge source?',
+        message: 'Select knowledge configuration:',
         choices: [
-            { name: 'E Knowledge Hub (Search and attach remote factual pack)', value: 'e-hub' },
+            { name: 'E Knowledge Hub / Portable Pack (with Life Database)', value: 'e-hub' },
+            { name: 'Life Database Only (SQLite personal state, schedule, preferences)', value: 'life-only' },
             { name: 'Do not use knowledge', value: 'none' },
         ],
     });
@@ -21,80 +24,165 @@ async function configureKnowledge(_context, options = {}) {
         return {
             config: {
                 provider: 'none',
+                lifeDatabase: false,
             },
             summary: {
                 Source: 'Do not use knowledge',
+                Knowledge: 'Disabled',
             },
         };
     }
-    // E Knowledge Hub flow
+    const summary = {};
+    const config = {
+        dbPath: 'siduri.sqlite',
+        lifeDatabase: true,
+    };
+    if (source === 'life-only') {
+        config.provider = 'unified';
+        summary.Source = 'Life Database';
+        summary['Life Database'] = 'Enabled (siduri.sqlite)';
+        summary['E-Pack'] = 'None';
+        return { config, summary };
+    }
+    // 2. Discovery-First E-Knowledge Resolution Flow
     while (true) {
-        const { packId } = await inquirer_1.default.prompt({
+        const promptRes = await inquirer_1.default.prompt({
             type: 'input',
             name: 'packId',
-            message: 'Search E Knowledge Hub or enter package ID:',
+            message: 'Enter package ID (@publisher/name), local pack path, or remote URL:',
             default: '@vxnus/e-teyvat',
-            validate: (val) => val.trim().length > 0 || 'Please enter a package ID.',
+            validate: (val) => val.trim().length > 0 || 'Please enter a package ID, path, or URL.',
         });
-        const trimmedPackId = packId.trim();
+        const target = (promptRes.packId || promptRes.query || '').trim();
+        // Case A: Remote HTTP endpoint
+        if (target.startsWith('http://') || target.startsWith('https://')) {
+            console.log(`\n\x1b[36m── Knowledge Provider ────────────────────────\x1b[0m\n`);
+            console.log(`  \x1b[2mType:\x1b[0m        Remote E-Provider`);
+            console.log(`  \x1b[2mEndpoint:\x1b[0m    ${target}`);
+            console.log(`  \x1b[2mConnectors:\x1b[0m  Remote only (HTTP stream)\n`);
+            config.provider = 'e-remote';
+            config.baseUrl = target;
+            config.pack = {
+                mode: 'remote',
+                baseUrl: target,
+            };
+            summary.Source = 'Remote E-Provider';
+            summary.Provider = target;
+            summary['E-Pack'] = `Remote (${target})`;
+            return { config, summary };
+        }
+        // Case B: Local path / file
+        if (target.startsWith('./') || target.startsWith('/') || node_fs_1.default.existsSync(target)) {
+            console.log(`\n\x1b[36m── Knowledge Provider ────────────────────────\x1b[0m\n`);
+            console.log(`  \x1b[2mType:\x1b[0m        Local Knowledge Pack`);
+            console.log(`  \x1b[2mPath:\x1b[0m        ${target}`);
+            console.log(`  \x1b[2mConnectors:\x1b[0m  Local only (Filesystem)\n`);
+            config.provider = 'e-knowledge';
+            config.packPath = target;
+            config.pack = {
+                mode: 'local',
+                packPath: target,
+            };
+            summary.Source = 'Local Knowledge Pack';
+            summary.Provider = target;
+            summary['E-Pack'] = `Local (${target})`;
+            return { config, summary };
+        }
+        // Case C: E Knowledge Hub package ID (@publisher/name)
         let manifest;
         try {
-            process.stdout.write('\u001b[2mSearching E Knowledge Hub...\u001b[0m');
-            manifest = await client.resolveProvider(trimmedPackId);
-            process.stdout.write('\r\u001b[32m✓\u001b[0m Checking provider manifest\n');
+            process.stdout.write('\x1b[2mResolving knowledge metadata...\x1b[0m');
+            manifest = await client.resolveProvider(target);
+            process.stdout.write('\r\x1b[32m✓\x1b[0m Knowledge metadata resolved\n');
         }
         catch (err) {
-            process.stdout.write('\r\u001b[33m!\u001b[0m Provider resolution failed\n');
-            console.log(`\u001b[33mReason:\u001b[0m ${err.message}\n`);
+            process.stdout.write('\r\x1b[33m!\x1b[0m Knowledge resolution failed\n');
+            console.log(`\x1b[33mReason:\x1b[0m ${err.message}\n`);
             const { failureAction } = await inquirer_1.default.prompt({
                 type: 'list',
                 name: 'failureAction',
                 message: 'What would you like to do?',
                 choices: [
-                    { name: 'Try again / Search another provider', value: 'retry' },
-                    { name: 'Do not use knowledge', value: 'skip' },
+                    { name: 'Try again / Enter another package ID or path', value: 'retry' },
+                    { name: 'Skip attaching E-pack (keep Life DB only)', value: 'skip' },
                     { name: 'Cancel', value: 'cancel' },
                 ],
             });
-            if (failureAction === 'retry') {
+            if (failureAction === 'retry')
                 continue;
-            }
             if (failureAction === 'skip') {
-                return {
-                    config: { provider: 'none' },
-                    summary: { Source: 'Do not use knowledge' },
-                };
+                config.provider = 'unified';
+                summary.Source = 'Life Database';
+                summary['E-Pack'] = 'None';
+                return { config, summary };
             }
             throw new Error('Knowledge configuration cancelled.');
         }
-        // Display provider summary
-        (0, knowledge_hub_1.displayKnowledgeProviderSummary)(manifest, trimmedPackId);
-        const { confirmProvider } = await inquirer_1.default.prompt({
+        // Display metadata
+        (0, knowledge_hub_1.displayKnowledgeProviderSummary)(manifest, target);
+        // Inspect supported connectors
+        const hasRemoteUrl = Boolean(manifest.distribution?.url);
+        const connectorChoices = [];
+        if (hasRemoteUrl) {
+            connectorChoices.push({
+                name: `Remote (Stream directly from ${manifest.distribution?.url} without local storage)`,
+                value: 'remote',
+            });
+            connectorChoices.push({
+                name: 'Local (Download and run offline pack files on this machine)',
+                value: 'local',
+            });
+            connectorChoices.push({
+                name: 'Hybrid (Local pack cache with remote provider fallback/sync)',
+                value: 'hybrid',
+            });
+        }
+        else {
+            connectorChoices.push({
+                name: 'Local (Offline pack files on this machine)',
+                value: 'local',
+            });
+        }
+        connectorChoices.push({
+            name: 'Choose another provider',
+            value: 'retry',
+        });
+        const choiceRes = await inquirer_1.default.prompt({
             type: 'list',
-            name: 'confirmProvider',
-            message: 'Use this knowledge provider?',
-            choices: [
-                { name: 'Yes, use this provider', value: 'yes' },
-                { name: 'Choose another provider', value: 'retry' },
-            ],
+            name: 'connectorMode',
+            message: 'Choose connection type for this pack:',
+            choices: connectorChoices,
         });
-        if (confirmProvider === 'yes') {
-            return {
-                config: {
-                    provider: 'e-hub',
-                    registryUrl: 'https://e.vxnus.xyz/api/v1/knowledge',
-                    packId: trimmedPackId,
-                },
-                summary: {
-                    Source: 'E Knowledge Hub',
-                    Provider: manifest.displayName || manifest.name,
-                    Package: trimmedPackId,
-                    Version: manifest.version,
-                },
-                metadata: {
-                    manifest,
-                },
-            };
+        const rawChoice = choiceRes.connectorMode ?? choiceRes.confirmProvider;
+        if (rawChoice === 'retry') {
+            continue;
         }
+        const connectorMode = (rawChoice === 'yes'
+            ? (hasRemoteUrl ? 'remote' : 'local')
+            : (['remote', 'local', 'hybrid'].includes(rawChoice || '') ? rawChoice : 'local'));
+        config.provider = 'e-hub';
+        config.registryUrl = 'https://e.vxnus.xyz/api/v1/knowledge';
+        config.packId = target;
+        config.pack = {
+            mode: connectorMode,
+            packId: target,
+            registryUrl: 'https://e.vxnus.xyz/api/v1/knowledge',
+            baseUrl: manifest.distribution?.url,
+            preferredMode: 'lexical',
+        };
+        if (manifest.distribution?.url) {
+            config.baseUrl = manifest.distribution.url;
+        }
+        summary.Source = 'E Knowledge Hub';
+        summary.Provider = manifest.displayName || manifest.name;
+        summary.Package = target;
+        summary.Version = manifest.version;
+        summary['Life Database'] = 'Enabled (siduri.sqlite)';
+        summary['E-Pack'] = `${manifest.displayName || manifest.name} (${connectorMode})`;
+        return {
+            config,
+            summary,
+            metadata: { manifest },
+        };
     }
 }

package/dist/configurators/memory.js

@@ -6,39 +6,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureMemory = configureMemory;
 const inquirer_1 = __importDefault(require("inquirer"));
 async function configureMemory(_context) {
-    const { database } = await inquirer_1.default.prompt({
+    const { provider } = await inquirer_1.default.prompt({
         type: 'list',
-        name: 'database',
-        message: 'Memory database?',
+        name: 'provider',
+        message: 'Memory storage engine?',
         choices: [
-            { name: 'PostgreSQL (FTS relational claims with ACID durability)', value: 'postgres' },
+            { name: 'SQLite (Unified zero-config WAL + FTS5 full-text indexing)', value: 'sqlite' },
         ],
     });
-    const { deployment } = await inquirer_1.default.prompt({
-        type: 'list',
-        name: 'deployment',
-        message: 'PostgreSQL deployment target?',
-        choices: [
-            { name: 'Supabase (Hosted Postgres with connection pooling)', value: 'supabase' },
-            { name: 'Neon (Serverless Postgres with branch-per-companion)', value: 'neon' },
-            { name: 'Local PostgreSQL (System service or local installation)', value: 'local' },
-            { name: 'Other PostgreSQL URL', value: 'other' },
-        ],
-    });
-    const deploymentDisplayNames = {
-        supabase: 'Supabase',
-        neon: 'Neon',
-        local: 'Local PostgreSQL',
-        other: 'Other PostgreSQL',
-    };
     return {
         config: {
-            provider: database,
-            deployment,
+            provider,
         },
         summary: {
-            Database: 'PostgreSQL',
-            Deploy: deploymentDisplayNames[deployment] || deployment,
+            Database: 'SQLite (WAL + FTS5)',
+            Storage: 'siduri.sqlite',
         },
     };
 }

package/dist/configurators.test.js

@@ -179,14 +179,13 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
         });
     });
     describe('Other Organ Configurators & Generic Router', () => {
-        test('Memory configurator configures PostgreSQL with Supabase deployment', async () => {
+        test('Memory configurator configures SQLite with WAL and FTS5', async () => {
             inquirer_1.default.prompt
-                .mockResolvedValueOnce({ database: 'postgres' })
-                .mockResolvedValueOnce({ deployment: 'supabase' });
+                .mockResolvedValueOnce({ provider: 'sqlite' });
             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');
+            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
@@ -283,7 +282,7 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
         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' },
+                memory: { 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 },
             });
@@ -292,8 +291,8 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
             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('SQLite');
+            expect(summaryOutput).toContain('siduri.sqlite');
             expect(summaryOutput).toContain('Knowledge');
             expect(summaryOutput).toContain('E Knowledge Hub');
             expect(summaryOutput).toContain('E Teyvat');
@@ -304,7 +303,7 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
         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' },
+                memory: { 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' },
             };
@@ -317,14 +316,14 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
             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.memory.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 '@siduri-x/brain'");
             expect(files['src/index.js']).toContain("import { SqliteMemoryStore } from '@siduri-x/memory'");
-            expect(files['src/index.js']).toContain("import { EKnowledgeAdapter } from '@siduri-x/knowledge'");
+            expect(files['src/index.js']).toContain("import { UnifiedKnowledgeOrgan } from '@siduri-x/knowledge'");
             expect(files['src/index.js']).toContain("import { VoiceAdapter } from '@siduri-x/voice'");
         });
     });

package/dist/doctor.js

@@ -129,25 +129,69 @@ 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) {
-        results.push({
-            category: 'Database',
-            name: 'SQLite Database',
-            status: 'PASS',
-            organName: dbOrgan.name,
-            message: 'SQLite operates natively.',
-        });
+        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: 'SQLite Database',
+                status: 'PASS',
+                organName: dbOrgan.name,
+                message: 'Local storage directory writeable; SQLite operational',
+            });
+        }
+        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({

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.2';
     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.2', 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);`,
@@ -354,8 +433,8 @@ function generateInstanceFiles(options) {
         `      const abortController = new AbortController();`,
         `      const onClose = () => {`,
         `        abortController.abort('client_disconnect');`,
-        `        if (typeof runtime.interruptMouth === 'function') {`,
-        `          runtime.interruptMouth('client_disconnect');`,
+        `        if (runtime.mouth && typeof runtime.mouth.interrupt === 'function') {`,
+        `          runtime.mouth.interrupt('client_disconnect');`,
         `        }`,
         `      };`,
         `      req.on('close', onClose);`,
@@ -430,8 +509,8 @@ function generateInstanceFiles(options) {
         `      try {`,
         `        const payload = JSON.parse(body || '{}');`,
         `        const reason = payload.reason || 'user_barge_in';`,
-        `        if (typeof runtime.interruptMouth === 'function') {`,
-        `          runtime.interruptMouth(reason);`,
+        `        if (runtime.mouth && typeof runtime.mouth.interrupt === 'function') {`,
+        `          runtime.mouth.interrupt(reason);`,
         `        }`,
         `        res.writeHead(200, { 'Content-Type': 'application/json' });`,
         `        res.end(JSON.stringify({ success: true, interrupted: true, reason }));`,
@@ -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) {