@vxnus/siduri 0.1.11 → 2.0.1

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 { PostgresMemoryOrgan } from '@siduri-x/memory'");
-            expect(files['src/index.js']).toContain("import { EKnowledgeAdapter } from '@siduri-x/knowledge'");
+            expect(files['src/index.js']).toContain("import { SqliteMemoryStore } from '@siduri-x/memory'");
+            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/db.d.ts

@@ -1,16 +1,4 @@
 export declare function redactDatabaseUrl(url: string): string;
-export interface MigrationFile {
-    name: string;
-    fullPath: string;
-    sql: string;
-    checksum: string;
-}
-export interface MigrationRecord {
-    id: number;
-    name: string;
-    checksum: string;
-    applied_at: string;
-}
 export interface DbPushOptions {
     projectDir?: string;
     connectionString?: string;

package/dist/db.js

@@ -1,152 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.redactDatabaseUrl = redactDatabaseUrl;
 exports.runDbPush = runDbPush;
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const pg_1 = require("pg");
-const discovery_1 = require("./discovery");
 function redactDatabaseUrl(url) {
-    try {
-        const parsed = new URL(url);
-        if (parsed.password) {
-            parsed.password = '***';
-        }
-        return parsed.toString();
-    }
-    catch {
-        return 'postgres://***:***@...';
-    }
+    return url;
 }
 async function runDbPush(options = {}) {
-    const projectDir = options.projectDir ? node_path_1.default.resolve(options.projectDir) : process.cwd();
-    const configPath = node_path_1.default.join(projectDir, 'siduri.config.json');
-    if (!node_fs_1.default.existsSync(configPath)) {
-        throw new Error(`siduri.config.json not found at ${projectDir}. Make sure you are in a Siduri instance directory.`);
-    }
-    const config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
-    const configuredOrgans = config.organs || {};
-    // 1. Discover manifests of configured organs
-    const registry = discovery_1.OrganRegistry.discover([
-        node_path_1.default.join(projectDir, 'node_modules/@siduri-x'),
-        node_path_1.default.resolve(__dirname, '../../packages/organs'),
-        node_path_1.default.resolve(process.cwd(), 'packages/organs'),
-    ]);
-    const databaseOrgans = [];
-    for (const [key] of Object.entries(configuredOrgans)) {
-        const manifest = registry.get(key) || registry.getAll().find((m) => m.configKey === key || m.organType === key);
-        if (manifest && manifest.database && manifest.database.migrationsDir) {
-            // Resolve migrations directory relative to the organ package
-            const candidatePaths = [
-                node_path_1.default.resolve(projectDir, 'node_modules', manifest.name, manifest.database.migrationsDir),
-                node_path_1.default.resolve(__dirname, '../../packages/organs', manifest.organType, manifest.database.migrationsDir),
-                node_path_1.default.resolve(process.cwd(), 'packages/organs', manifest.organType, manifest.database.migrationsDir),
-            ];
-            const resolvedDir = candidatePaths.find((p) => node_fs_1.default.existsSync(p));
-            if (resolvedDir) {
-                databaseOrgans.push({
-                    organType: manifest.organType,
-                    manifest,
-                    migrationsDir: resolvedDir,
-                });
-            }
-        }
-    }
-    if (databaseOrgans.length === 0) {
-        return {
-            status: 'NOOP',
-            appliedMigrations: [],
-            skippedMigrations: [],
-            message: 'No database migrations are required by this instance.',
-        };
-    }
-    // 2. Resolve DATABASE_URL
-    const connectionString = options.connectionString ||
-        options.env?.DATABASE_URL ||
-        process.env.DATABASE_URL;
-    if (!connectionString) {
-        throw new Error('DATABASE_URL is required to run database migrations. Set it in .env or environment.');
-    }
-    const pool = new pg_1.Pool({
-        connectionString,
-        connectionTimeoutMillis: 5000,
-    });
-    const client = await pool.connect();
-    try {
-        // 3. Ensure migrations table exists
-        await client.query(`
-      CREATE TABLE IF NOT EXISTS siduri_migrations (
-        id SERIAL PRIMARY KEY,
-        name VARCHAR(255) UNIQUE NOT NULL,
-        checksum VARCHAR(64) NOT NULL,
-        applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-      );
-    `);
-        // 4. Fetch applied migrations
-        const existingRes = await client.query('SELECT name, checksum FROM siduri_migrations ORDER BY id ASC;');
-        const appliedMap = new Map();
-        for (const row of existingRes.rows) {
-            appliedMap.set(row.name, row.checksum);
-        }
-        // 5. Gather all migration files across database organs in deterministic order
-        const allMigrationFiles = [];
-        for (const item of databaseOrgans) {
-            const files = node_fs_1.default.readdirSync(item.migrationsDir).filter((f) => f.endsWith('.sql')).sort();
-            for (const file of files) {
-                const fullPath = node_path_1.default.join(item.migrationsDir, file);
-                const sql = node_fs_1.default.readFileSync(fullPath, 'utf8');
-                const checksum = (0, node_crypto_1.createHash)('sha256').update(sql).digest('hex');
-                allMigrationFiles.push({
-                    name: `${item.organType}/${file}`,
-                    fullPath,
-                    sql,
-                    checksum,
-                });
-            }
-        }
-        allMigrationFiles.sort((a, b) => a.name.localeCompare(b.name));
-        const appliedList = [];
-        const skippedList = [];
-        for (const migration of allMigrationFiles) {
-            const recordedChecksum = appliedMap.get(migration.name);
-            if (recordedChecksum !== undefined) {
-                if (recordedChecksum !== migration.checksum) {
-                    throw new Error(`Migration checksum mismatch for ${migration.name}! Recorded: ${recordedChecksum.slice(0, 8)}, Current: ${migration.checksum.slice(0, 8)}. Refusing to apply modified migration.`);
-                }
-                skippedList.push(migration.name);
-            }
-            else {
-                // Apply migration in transaction
-                await client.query('BEGIN');
-                try {
-                    await client.query(migration.sql);
-                    await client.query('INSERT INTO siduri_migrations (name, checksum) VALUES ($1, $2)', [migration.name, migration.checksum]);
-                    await client.query('COMMIT');
-                    appliedList.push(migration.name);
-                }
-                catch (err) {
-                    await client.query('ROLLBACK');
-                    throw err;
-                }
-            }
-        }
-        const redacted = redactDatabaseUrl(connectionString);
-        const message = appliedList.length > 0
-            ? `Applied ${appliedList.length} migration(s) to ${redacted}`
-            : `Database schema up to date on ${redacted}`;
-        return {
-            status: appliedList.length > 0 ? 'APPLIED' : 'UP_TO_DATE',
-            appliedMigrations: appliedList,
-            skippedMigrations: skippedList,
-            message,
-        };
-    }
-    finally {
-        client.release();
-        await pool.end().catch(() => { });
-    }
+    return {
+        status: 'NOOP',
+        appliedMigrations: [],
+        skippedMigrations: [],
+        message: 'SQLite manages schema natively. No CLI migrations required.',
+    };
 }

package/dist/discovery.js

@@ -38,11 +38,10 @@ class OrganRegistry {
         const rootsToScan = searchRoots && searchRoots.length > 0
             ? searchRoots
             : [
-                // 1. Monorepo organs folder relative to cli
                 node_path_1.default.resolve(__dirname, '../../packages/organs'),
-                // 2. Monorepo organs folder relative to cwd
                 node_path_1.default.resolve(process.cwd(), 'packages/organs'),
-                // 3. Node modules of current directory or global resolution
+                node_path_1.default.resolve(__dirname, '../../packages'),
+                node_path_1.default.resolve(process.cwd(), 'packages'),
                 node_path_1.default.resolve(process.cwd(), 'node_modules/@siduri-x'),
                 node_path_1.default.resolve(__dirname, '../node_modules/@siduri-x'),
             ];
@@ -74,10 +73,9 @@ class OrganRegistry {
                 // Continue scanning other roots
             }
         }
-        // If running in a standalone environment without local package folders (e.g. via npx in an empty directory),
-        // register canonical built-in @siduri-x/* organ manifests as fallback.
-        if (registry.getAll().length === 0) {
-            for (const builtinManifest of builtin_manifests_1.BUILTIN_ORGAN_MANIFESTS) {
+        // Always merge canonical built-in @siduri-x/* organ manifests as fallback for ones that weren't found
+        for (const builtinManifest of builtin_manifests_1.BUILTIN_ORGAN_MANIFESTS) {
+            if (!registry.get(builtinManifest.organType)) {
                 registry.register(builtinManifest);
             }
         }

package/dist/discovery.test.js

@@ -8,16 +8,17 @@ const discovery_1 = require("./discovery");
 const generator_1 = require("./generator");
 describe('Discovery & Dynamic Composition System Tests (Phase 3)', () => {
     const rootOrgansDir = node_path_1.default.resolve(__dirname, '../../packages/organs');
-    test('Registry successfully discovers all 11 organ packages from workspace', () => {
-        const registry = discovery_1.OrganRegistry.discover([rootOrgansDir]);
+    test('Registry successfully discovers all 12 organ packages from workspace', () => {
+        const registry = discovery_1.OrganRegistry.discover();
         const manifests = registry.getAll();
-        expect(manifests.length).toBe(11);
+        expect(manifests.length).toBe(12);
         const organTypes = registry.getAvailableOrganTypes().sort();
         expect(organTypes).toEqual([
             'behavior',
             'body',
             'brain',
             'ear',
+            'eknowledge',
             'hands',
             'knowledge',
             'memory',
@@ -28,7 +29,7 @@ describe('Discovery & Dynamic Composition System Tests (Phase 3)', () => {
         ]);
     });
     test('Generates valid instances from discovered manifests', () => {
-        const registry = discovery_1.OrganRegistry.discover([rootOrgansDir]);
+        const registry = discovery_1.OrganRegistry.discover();
         // Test Brain + Hands + Vision
         const brain = registry.get('brain');
         const hands = registry.get('hands');