@vxnus/siduri 2.0.2 → 2.0.4

package/dist/builtin-manifests.js

@@ -5,8 +5,8 @@ exports.BUILTIN_ORGAN_MANIFESTS = [
     {
         name: '@siduri-x/self',
         organType: 'behavior',
-        version: '2.0.1',
-        displayName: 'Behavior / Self (Active Self Directives)',
+        version: '2.0.2',
+        displayName: 'Behavior & Self (Personality Directives)',
         description: 'Atomic directive state machine and personality projection compiler',
         entrypoint: './dist/index.js',
         factory: 'ActiveSelfCompiler',
@@ -207,8 +207,8 @@ exports.BUILTIN_ORGAN_MANIFESTS = [
     {
         name: '@siduri-x/knowledge',
         organType: 'knowledge',
-        version: '2.0.1',
-        displayName: 'Knowledge (Life DB & Portable E-Packs)',
+        version: '2.0.2',
+        displayName: 'Knowledge (Sovereign Life DB & Knowledge Packs)',
         description: 'Sovereign Life Database (finances, inventory, schedule, preferences) and portable E knowledge packs',
         entrypoint: './dist/index.js',
         factory: 'UnifiedKnowledgeOrgan',
@@ -286,7 +286,7 @@ exports.BUILTIN_ORGAN_MANIFESTS = [
         name: '@siduri-x/memory',
         organType: 'memory',
         version: '2.0.1',
-        displayName: 'Memory (SQLite FTS5 Claims)',
+        displayName: 'Memory (Long-term Recall & State)',
         description: 'Relational semantic claims with Full-Text Search (FTS5) and companion isolation',
         entrypoint: './dist/index.js',
         factory: 'SqliteMemoryStore',
@@ -380,9 +380,9 @@ exports.BUILTIN_ORGAN_MANIFESTS = [
     {
         name: '@siduri-x/voice',
         organType: 'voice',
-        version: '2.0.1',
-        displayName: 'Voice (VOICEVOX Speech Synthesis)',
-        description: 'Queued speech synthesis and audio rendering lifecycle adapter',
+        version: '2.0.2',
+        displayName: 'Voice (Speech Synthesis & Voice Conversion)',
+        description: 'Queued speech synthesis and audio rendering lifecycle adapter (Edge-TTS, Kokoro, Piper, VOICEVOX, RVC)',
         entrypoint: './dist/index.js',
         factory: 'VoicevoxAdapter',
         configKey: 'voice',

package/dist/configurators/knowledge.js

@@ -5,90 +5,38 @@ 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: 'Select knowledge configuration:',
-        choices: [
-            { 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' },
-        ],
-    });
-    if (source === 'none') {
-        return {
-            config: {
-                provider: 'none',
-                lifeDatabase: false,
-            },
-            summary: {
-                Source: 'Do not use knowledge',
-                Knowledge: 'Disabled',
-            },
-        };
-    }
-    const summary = {};
     const config = {
+        provider: 'unified',
         dbPath: 'siduri.sqlite',
         lifeDatabase: true,
     };
-    if (source === 'life-only') {
-        config.provider = 'unified';
-        summary.Source = 'Life Database';
-        summary['Life Database'] = 'Enabled (siduri.sqlite)';
+    const summary = {
+        'Life Database': 'Enabled (siduri.sqlite)',
+    };
+    // 1. Life Database is the sovereign default. Ask whether to attach an external knowledge pack
+    const { useExternalPack } = await inquirer_1.default.prompt({
+        type: 'confirm',
+        name: 'useExternalPack',
+        message: 'Attach an external knowledge pack from E Knowledge Hub?',
+        default: false,
+    });
+    if (!useExternalPack) {
         summary['E-Pack'] = 'None';
         return { config, summary };
     }
-    // 2. Discovery-First E-Knowledge Resolution Flow
+    // 2. Discover and resolve E Knowledge Hub package
     while (true) {
         const promptRes = await inquirer_1.default.prompt({
             type: 'input',
             name: 'packId',
-            message: 'Enter package ID (@publisher/name), local pack path, or remote URL:',
+            message: 'Enter package ID (@publisher/name):',
             default: '@vxnus/e-teyvat',
-            validate: (val) => val.trim().length > 0 || 'Please enter a package ID, path, or URL.',
+            validate: (val) => val.trim().length > 0 || 'Please enter a package ID.',
         });
         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('\x1b[2mResolving knowledge metadata...\x1b[0m');
@@ -103,82 +51,90 @@ async function configureKnowledge(_context, options = {}) {
                 name: 'failureAction',
                 message: 'What would you like to do?',
                 choices: [
-                    { name: 'Try again / Enter another package ID or path', value: 'retry' },
-                    { name: 'Skip attaching E-pack (keep Life DB only)', value: 'skip' },
+                    { name: 'Try again / Enter another package ID', value: 'retry' },
+                    { name: 'Continue without external pack (Life DB only)', value: 'skip' },
                     { name: 'Cancel', value: 'cancel' },
                 ],
             });
             if (failureAction === 'retry')
                 continue;
             if (failureAction === 'skip') {
-                config.provider = 'unified';
-                summary.Source = 'Life Database';
                 summary['E-Pack'] = 'None';
                 return { config, summary };
             }
             throw new Error('Knowledge configuration cancelled.');
         }
-        // Display metadata
+        // Display provider summary
         (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',
+        // Determine connection type: User selects strictly 1 mode (Remote OR Local)
+        let connectionType;
+        const isHybrid = manifest.distributionType === 'both';
+        const isLocalOnly = manifest.distributionType === 'local' || manifest.distribution?.kind === 'archive';
+        if (isHybrid) {
+            const { selectedMode } = await inquirer_1.default.prompt({
+                type: 'list',
+                name: 'selectedMode',
+                message: 'This pack offers both remote and local options. Select connection type:',
+                choices: [
+                    {
+                        name: `Remote (Stream directly from ${manifest.distribution?.url || 'provider'} without local storage)`,
+                        value: 'remote',
+                    },
+                    {
+                        name: 'Local (Download archive and run offline on this machine)',
+                        value: 'local',
+                    },
+                ],
             });
+            connectionType = selectedMode;
+        }
+        else if (isLocalOnly) {
+            connectionType = 'local';
         }
         else {
-            connectorChoices.push({
-                name: 'Local (Offline pack files on this machine)',
-                value: 'local',
-            });
+            connectionType = 'remote';
         }
-        connectorChoices.push({
-            name: 'Choose another provider',
-            value: 'retry',
-        });
-        const choiceRes = await inquirer_1.default.prompt({
-            type: 'list',
-            name: 'connectorMode',
-            message: 'Choose connection type for this pack:',
-            choices: connectorChoices,
-        });
-        const rawChoice = choiceRes.connectorMode ?? choiceRes.confirmProvider;
-        if (rawChoice === 'retry') {
-            continue;
+        if (connectionType === 'remote') {
+            config.provider = 'e-hub';
+            config.registryUrl = 'https://e.vxnus.xyz/api/v1/knowledge';
+            config.packId = target;
+            config.pack = {
+                mode: 'remote',
+                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['E-Pack'] = `${manifest.displayName || manifest.name} (Remote)`;
         }
-        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;
+        else {
+            // Local archive: stored in our defined path inside companion assets (user doesn't type path)
+            const packSlug = target.replace(/^@/, '').replace(/[/_]/g, '-');
+            const packDir = `./assets/knowledge/${packSlug}`;
+            config.provider = 'e-knowledge';
+            config.packPath = packDir;
+            config.packId = target;
+            config.pack = {
+                mode: 'local',
+                packId: target,
+                packPath: packDir,
+                archiveUrl: manifest.distribution?.url,
+                checksum: manifest.distribution?.checksum,
+                preferredMode: 'lexical',
+            };
+            summary.Source = 'E Knowledge Hub';
+            summary.Provider = manifest.displayName || manifest.name;
+            summary.Package = target;
+            summary.Version = manifest.version;
+            summary['E-Pack'] = `${manifest.displayName || manifest.name} (Local @ ${packDir})`;
         }
-        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,

package/dist/configurators.test.js

@@ -110,16 +110,18 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
         });
     });
     describe('Discrepancy #2 & #3: Knowledge Choices & Manifest Metadata Confirmation', () => {
-        test('Selecting "Do not use knowledge" sets provider: none and skips discovery', async () => {
-            inquirer_1.default.prompt.mockResolvedValueOnce({ source: 'none' });
+        test('Declining external pack uses sovereign Life Database by default and skips discovery', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ useExternalPack: false });
             const result = await (0, knowledge_1.configureKnowledge)({
                 companionName: 'Sparkle',
                 manifest: knowledgeManifest,
             });
-            expect(result.config.provider).toBe('none');
-            expect(result.summary?.Source).toBe('Do not use knowledge');
+            expect(result.config.provider).toBe('unified');
+            expect(result.config.lifeDatabase).toBe(true);
+            expect(result.summary?.['Life Database']).toBe('Enabled (siduri.sqlite)');
+            expect(result.summary?.['E-Pack']).toBe('None');
         });
-        test('Selecting "E Knowledge Hub" discovers manifest, extracts capabilities, and confirms provider', async () => {
+        test('Attaching E Knowledge Hub pack discovers manifest and configures remote provider automatically', async () => {
             const mockClient = {
                 resolveProvider: jest.fn().mockResolvedValue({
                     name: 'e-teyvat',
@@ -128,13 +130,17 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
                     version: '1.2.0',
                     description: 'Teyvat knowledge provider for Siduri.',
                     capabilities: ['Search', 'Retrieval', 'Context injection'],
+                    distributionType: 'remote',
+                    distribution: {
+                        kind: 'provider',
+                        url: 'https://teyvat.e.vxnus.xyz',
+                    },
                     source: 'E Knowledge Hub',
                 }),
             };
             inquirer_1.default.prompt
-                .mockResolvedValueOnce({ source: 'e-hub' }) // Knowledge source
-                .mockResolvedValueOnce({ packId: '@vxnus/e-teyvat' }) // Package ID
-                .mockResolvedValueOnce({ confirmProvider: 'yes' }); // Confirm provider
+                .mockResolvedValueOnce({ useExternalPack: true }) // Attach external pack
+                .mockResolvedValueOnce({ packId: '@vxnus/e-teyvat' }); // Package ID
             const result = await (0, knowledge_1.configureKnowledge)({ companionName: 'Sparkle', manifest: knowledgeManifest }, { client: mockClient });
             expect(result.config.provider).toBe('e-hub');
             expect(result.config.packId).toBe('@vxnus/e-teyvat');
@@ -142,6 +148,33 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
             expect(result.summary?.Provider).toBe('E Teyvat');
             expect(result.summary?.Package).toBe('@vxnus/e-teyvat');
             expect(result.summary?.Version).toBe('1.2.0');
+            expect(result.summary?.['E-Pack']).toContain('Remote');
+        });
+        test('Attaching hybrid pack allows choosing between remote and local with automated path', async () => {
+            const mockClient = {
+                resolveProvider: jest.fn().mockResolvedValue({
+                    name: 'e-teyvat',
+                    displayName: 'E Teyvat',
+                    package: '@vxnus/e-teyvat',
+                    version: '1.2.0',
+                    description: 'Teyvat knowledge provider for Siduri.',
+                    capabilities: ['Search', 'Retrieval', 'Context injection'],
+                    distributionType: 'both',
+                    distribution: {
+                        kind: 'archive',
+                        url: 'https://knowledge.e.vxnus.xyz/archives/teyvat.tar.gz',
+                    },
+                    source: 'E Knowledge Hub',
+                }),
+            };
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ useExternalPack: true })
+                .mockResolvedValueOnce({ packId: '@vxnus/e-teyvat' })
+                .mockResolvedValueOnce({ selectedMode: 'local' });
+            const result = await (0, knowledge_1.configureKnowledge)({ companionName: 'Sparkle', manifest: knowledgeManifest }, { client: mockClient });
+            expect(result.config.provider).toBe('e-knowledge');
+            expect(result.config.packPath).toBe('./assets/knowledge/vxnus-e-teyvat');
+            expect(result.summary?.['E-Pack']).toContain('Local @ ./assets/knowledge/vxnus-e-teyvat');
         });
         test('Knowledge manifest validation enforces name and version', () => {
             expect(() => (0, knowledge_hub_1.validateKnowledgeManifest)({})).toThrow('Invalid knowledge manifest');

package/dist/generator.js

@@ -54,7 +54,9 @@ function getDefaultConfigForManifest(manifest) {
         config.providers = config.providers || [];
     }
     else if (manifest.organType === 'knowledge') {
-        config.provider = config.provider || 'none';
+        config.provider = config.provider || 'unified';
+        config.lifeDatabase = config.lifeDatabase ?? true;
+        config.dbPath = config.dbPath || 'siduri.sqlite';
     }
     else if (manifest.organType === 'behavior') {
         config.provider = config.provider || 'active_self';
@@ -72,7 +74,7 @@ function getDefaultConfigForManifest(manifest) {
 function generateInstanceFiles(options) {
     const instanceName = options.name || 'my-siduri';
     const instanceId = options.id || 'default';
-    const coreVersion = options.coreVersion || '^2.0.2';
+    const coreVersion = options.coreVersion || '^2.0.3';
     const manifests = options.selectedManifests;
     const hasMemory = manifests.some((m) => m.organType === 'memory');
     const hasVoice = manifests.some((m) => m.organType === 'voice');
@@ -266,7 +268,7 @@ function generateInstanceFiles(options) {
         `  // 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 }));`,
+        `    res.end(JSON.stringify({ version: '2.0.3', name: config.name, id: config.id }));`,
         `    return;`,
         `  }`,
         '',
@@ -673,6 +675,12 @@ function generateInstanceFiles(options) {
         createAssetsDirs.push(`assets/voice/${companionSlug}`);
         readmeLines.push('', '### Voice & RVC Models', `Place your character RVC voice models into \`./assets/voice/${companionSlug}/\`:`, `- \`${companionSlug}.pth\` (Target voice weights)`, `- \`${companionSlug}.index\` (Feature index file)`);
     }
+    const knowledgeConfig = options.organConfigs?.knowledge || options.organConfigs?.['@siduri-x/knowledge'];
+    if (manifests.some((m) => m.organType === 'knowledge') && knowledgeConfig?.packPath) {
+        const cleanPackDir = String(knowledgeConfig.packPath).replace(/^\.\//, '');
+        createAssetsDirs.push(cleanPackDir);
+        readmeLines.push('', '### Knowledge Pack Assets', `Local knowledge pack files reside in \`./${cleanPackDir}/\`.`);
+    }
     readmeLines.push('');
     const readmeMd = readmeLines.join('\n');
     const webHtml = (0, web_template_1.generateWebHtml)(instanceName, manifests);

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { OrganManifest } from './manifest';
-export declare const CLI_VERSION = "2.0.2";
+export declare const CLI_VERSION = "2.0.4";
 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 = '2.0.2';
+exports.CLI_VERSION = '2.0.4';
 exports.colors = {
     cyan: '\u001b[36m',
     dim: '\u001b[2m',
@@ -120,22 +120,10 @@ 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 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 || {};
-    }
+    printSection('Organ Selection');
+    console.log(`${exports.colors.dim}In Siduri, a companion is assembled from modular capability organs:${exports.colors.reset}`);
+    console.log(`${exports.colors.dim}• Brain provides central cognition and LLM reasoning (required).${exports.colors.reset}`);
+    console.log(`${exports.colors.dim}• Select any capability organs below to attach to ${companionName}.${exports.colors.reset}\n`);
     // Canonical organ presentation order
     const canonicalOrder = ['memory', 'knowledge', 'behavior', 'voice', 'body', 'mouth', 'hands', 'vision', 'ear', 'observation'];
     const nonBrainManifests = availableManifests
@@ -147,19 +135,37 @@ async function runCreateWizard(targetDir) {
         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;
+    const isRecommendedType = (type) => ['memory', 'knowledge', 'behavior', 'voice', 'body', 'mouth'].includes(type);
+    const organChoices = nonBrainManifests.map((m) => ({
+        name: `${m.displayName} ${exports.colors.dim}— ${m.description}${exports.colors.reset}`,
+        value: m.organType,
+        checked: isRecommendedType(m.organType),
+    }));
+    const { selectedOrganTypes } = await inquirer_1.default.prompt({
+        type: 'checkbox',
+        name: 'selectedOrganTypes',
+        message: 'Select capability organs to enable:',
+        choices: organChoices,
+    });
+    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);
+    }
+    for (const organType of selectedOrganTypes) {
+        const m = registry.get(organType) || availableManifests.find((item) => item.organType === organType);
+        if (m)
+            selectedManifests.push(m);
+    }
+    // 2. Interactive Organ Configuration Stage
+    printSection('Organ Configuration');
+    console.log(`${exports.colors.dim}Configure each enabled organ for ${companionName}.${exports.colors.reset}\n`);
+    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;
         printSection(sectionTitle);
         const res = await (0, configurators_1.configureOrgan)(m, {
             companionName,
@@ -258,6 +264,27 @@ async function runCreateWizard(targetDir) {
     else if (files.createAssetsBodyDir) {
         await (0, promises_1.mkdir)(node_path_1.default.join(projectDir, 'assets/body'), { recursive: true });
     }
+    // If local knowledge archive is configured with a download URL, automatically fetch and unpack it
+    const knowledgeConfig = organConfigs.knowledge || organConfigs['@siduri-x/knowledge'];
+    if (knowledgeConfig?.pack?.mode === 'local' && knowledgeConfig?.pack?.archiveUrl) {
+        const packRelDir = (knowledgeConfig.packPath || 'assets/knowledge/pack').replace(/^\.\//, '');
+        const packDest = node_path_1.default.join(projectDir, packRelDir);
+        try {
+            await withTask(`Downloading knowledge archive (${knowledgeConfig.pack.packId || 'pack'})`, async () => {
+                const res = await fetch(knowledgeConfig.pack.archiveUrl);
+                if (res.ok) {
+                    const tarPath = node_path_1.default.join(packDest, 'pack.tar.gz');
+                    const buffer = Buffer.from(await res.arrayBuffer());
+                    await (0, promises_1.writeFile)(tarPath, buffer);
+                    await execFile('tar', ['-xzf', tarPath, '-C', packDest]);
+                    await node_fs_1.default.promises.unlink(tarPath).catch(() => { });
+                }
+            });
+        }
+        catch (err) {
+            console.warn(`${exports.colors.yellow}!${exports.colors.reset} Notice: Could not download or unpack knowledge archive: ${err.message}`);
+        }
+    }
     printSuccess(`Generated standalone files at ${projectDir}`);
     // 5. Install dependencies from registry
     try {

package/dist/providers/knowledge-hub.d.ts

@@ -14,10 +14,17 @@ export interface KnowledgeHubManifest {
     version: string;
     description?: string;
     capabilities?: KnowledgeHubCapabilities | string[];
+    distributionType?: 'local' | 'remote' | 'both';
     distribution?: {
-        kind?: string;
+        kind?: 'archive' | 'provider' | string;
         url?: string;
+        checksum?: string;
     };
+    distributions?: Array<{
+        kind?: 'archive' | 'provider' | string;
+        url?: string;
+        checksum?: string;
+    }>;
     source?: string;
     environment?: Array<{
         name: string;

package/dist/providers/knowledge-hub.js

@@ -13,6 +13,7 @@ exports.KNOWN_KNOWLEDGE_PACKS = {
         version: '1.2.0',
         description: 'Teyvat knowledge provider for Siduri.',
         capabilities: ['Search', 'Retrieval', 'Context injection'],
+        distributionType: 'remote',
         distribution: {
             kind: 'provider',
             url: 'https://teyvat.e.vxnus.xyz',
@@ -31,6 +32,18 @@ function validateKnowledgeManifest(raw, packId) {
     if (!m.version || typeof m.version !== 'string') {
         throw new Error(`Invalid knowledge manifest: missing 'version' field.`);
     }
+    const distributions = m.distributions || (m.distribution ? [m.distribution] : []);
+    let distributionType = m.distributionType;
+    if (!distributionType) {
+        const hasArchive = distributions.some((d) => d.kind === 'archive');
+        const hasProvider = distributions.some((d) => d.kind === 'provider');
+        if (hasArchive && hasProvider)
+            distributionType = 'both';
+        else if (hasProvider)
+            distributionType = 'remote';
+        else
+            distributionType = 'local';
+    }
     return {
         name: m.name,
         displayName: m.displayName || m.name,
@@ -39,7 +52,9 @@ function validateKnowledgeManifest(raw, packId) {
         version: m.version,
         description: m.description || 'Knowledge pack provider',
         capabilities: m.capabilities || ['Search', 'Retrieval'],
+        distributionType,
         distribution: m.distribution,
+        distributions: m.distributions,
         source: m.source || 'E Knowledge Hub',
         environment: m.environment || [],
     };
@@ -127,6 +142,12 @@ function displayKnowledgeProviderSummary(manifest, packId) {
     console.log(`  ${dim}Name:${reset}        ${manifest.displayName || manifest.name}`);
     console.log(`  ${dim}Package:${reset}     ${packId}`);
     console.log(`  ${dim}Version:${reset}     ${manifest.version}`);
+    const typeLabel = manifest.distributionType === 'both'
+        ? 'Hybrid (Available as Remote Provider & Local Archive)'
+        : manifest.distributionType === 'remote'
+            ? 'Remote Provider'
+            : 'Local Archive';
+    console.log(`  ${dim}Distribution:${reset} ${typeLabel}`);
     if (manifest.description) {
         console.log(`\n  ${dim}Description:${reset}`);
         console.log(`  ${manifest.description}`);