@vxnus/siduri 2.0.5 → 2.0.7

package/dist/builtin-manifests.js

@@ -6,8 +6,8 @@ exports.BUILTIN_ORGAN_MANIFESTS = [
         name: '@siduri-x/self',
         organType: 'behavior',
         version: '2.0.2',
-        displayName: 'Behavior & Self (Personality Directives)',
-        description: 'Atomic directive state machine and personality projection compiler',
+        displayName: 'Self & Persona (Identity & Directives)',
+        description: 'Autonomous persona compiler, relational stances, and .self asset loader',
         entrypoint: './dist/index.js',
         factory: 'ActiveSelfCompiler',
         configKey: 'behavior',
@@ -19,7 +19,20 @@ exports.BUILTIN_ORGAN_MANIFESTS = [
                     type: 'string',
                     enum: ['active_self', 'none']
                 },
-                preset: {
+                mode: {
+                    type: 'string',
+                    enum: ['blank_slate', 'custom']
+                },
+                archetype: {
+                    type: 'string'
+                },
+                ethos: {
+                    type: 'string'
+                },
+                directive: {
+                    type: 'string'
+                },
+                selfPath: {
                     type: 'string'
                 }
             }

package/dist/configurators/behavior.js

@@ -6,31 +6,74 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureBehavior = configureBehavior;
 const inquirer_1 = __importDefault(require("inquirer"));
 async function configureBehavior(_context) {
-    const { preset } = await inquirer_1.default.prompt({
+    const companionName = _context.companionName || 'Companion';
+    const companionSlug = companionName.toLowerCase().replace(/[^a-z0-9_-]/g, '') || 'default';
+    const { personaMode } = await inquirer_1.default.prompt({
         type: 'list',
-        name: 'preset',
-        message: 'Personality projection preset:',
+        name: 'personaMode',
+        message: 'Define base persona now or later?',
         choices: [
-            { name: 'Calm & Precise (Default)', value: 'calm_precise' },
-            { name: 'Cheerful & Enthusiastic', value: 'cheerful' },
-            { name: 'Analytical & Methodical', value: 'analytical' },
-            { name: 'Custom Directive State Machine', value: 'custom' },
+            {
+                name: 'Later (Start as a pure blank slate; evolve via interaction or add .self later)',
+                value: 'later',
+            },
+            {
+                name: 'Now (Define archetype, ethos, and generate base .self persona asset)',
+                value: 'now',
+            },
         ],
+        default: 'later',
     });
-    const presetLabels = {
-        calm_precise: 'Calm & Precise',
-        cheerful: 'Cheerful & Enthusiastic',
-        analytical: 'Analytical & Methodical',
-        custom: 'Custom Directives',
-    };
+    if (personaMode === 'later') {
+        return {
+            config: {
+                provider: 'active_self',
+                mode: 'blank_slate',
+            },
+            summary: {
+                Persona: 'Blank Slate (Evolve via interaction)',
+                Directives: 'Zero predeclared biases',
+            },
+        };
+    }
+    const personaAnswers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'archetype',
+            message: 'Companion archetype or role:',
+            default: 'Knowledge Assistant & Research Partner',
+        },
+        {
+            type: 'input',
+            name: 'ethos',
+            message: 'Core ethos & speaking demeanor:',
+            default: 'Direct technical candor, thoughtful, concise, and loyal',
+        },
+        {
+            type: 'input',
+            name: 'directive',
+            message: 'Primary behavioral directive or rule:',
+            default: 'Speak concisely and stay in character without sycophantic filler',
+        },
+    ]);
+    const archetype = personaAnswers.archetype.trim() || 'Knowledge Assistant & Research Partner';
+    const ethos = personaAnswers.ethos.trim() || 'Direct technical candor, thoughtful, concise, and loyal';
+    const directive = personaAnswers.directive.trim() || 'Speak concisely and stay in character without sycophantic filler';
+    const selfPath = `./assets/self/${companionSlug}.self`;
     return {
         config: {
             provider: 'active_self',
-            preset,
+            mode: 'custom',
+            archetype,
+            ethos,
+            directive,
+            selfPath,
         },
         summary: {
-            Provider: 'Active Self Directives',
-            Preset: presetLabels[preset] || preset,
+            Persona: 'Configured (.self asset)',
+            Archetype: archetype,
+            Ethos: ethos,
+            'Self Asset': selfPath,
         },
     };
 }

package/dist/configurators/ear.js

@@ -13,8 +13,16 @@ async function configureEar(_context) {
         choices: [
             { name: 'Text Chat (Standard multimodal chat ingress)', value: 'text_chat' },
             { name: 'Audio Streaming Ingress', value: 'audio_stream' },
+            { name: 'None (Skip / Disable sensory ingress)', value: 'none' },
         ],
+        default: 'none',
     });
+    if (defaultSource === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Ear disabled)' },
+        };
+    }
     return {
         config: {
             defaultSource,

package/dist/configurators/hands.js

@@ -6,6 +6,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureHands = configureHands;
 const inquirer_1 = __importDefault(require("inquirer"));
 async function configureHands(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Hands tool execution engine?',
+        choices: [
+            { name: 'MCP Client (Model Context Protocol & signed capability tokens)', value: 'mcp' },
+            { name: 'None (Skip / No external tool execution)', value: 'none' },
+        ],
+        default: 'none',
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Hands disabled)' },
+        };
+    }
     const { timeoutSeconds } = await inquirer_1.default.prompt({
         type: 'input',
         name: 'timeoutSeconds',

package/dist/configurators/mouth.js

@@ -1,14 +1,34 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureMouth = configureMouth;
+const inquirer_1 = __importDefault(require("inquirer"));
 async function configureMouth(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Mouth output delivery channel?',
+        choices: [
+            { name: 'Web Streaming (Server-Sent Events, Live2D visemes & SSML)', value: 'web' },
+            { name: 'None (Silent / Disable speech streaming output)', value: 'none' },
+        ],
+        default: 'web',
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Mouth disabled)' },
+        };
+    }
     return {
         config: {
             defaultMedium: 'web',
             maxTextLength: 8000,
         },
         summary: {
-            'Default Medium': 'Web',
+            'Delivery Medium': 'Web SSE Streaming',
             'Max Text Length': '8000 chars',
         },
     };

package/dist/configurators/observation.js

@@ -1,7 +1,27 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureObservation = configureObservation;
+const inquirer_1 = __importDefault(require("inquirer"));
 async function configureObservation(_context) {
+    const { provider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'provider',
+        message: 'Screen observation & frame capture?',
+        choices: [
+            { name: 'Frame Ingest (SHA-256 deduplicated visual grounding for vision)', value: 'fixture' },
+            { name: 'None (Skip / Disable screen observation)', value: 'none' },
+        ],
+        default: 'none',
+    });
+    if (provider === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Observation disabled)' },
+        };
+    }
     return {
         config: {},
         summary: {

package/dist/configurators/vision.js

@@ -14,8 +14,16 @@ async function configureVision(_context) {
             { name: 'GPT-4 Vision / GPT-4o (Multimodal OCR & Object Inspection)', value: 'gpt-4-vision' },
             { name: 'Claude 3.5 Sonnet Vision', value: 'anthropic/claude-3.5-sonnet' },
             { name: 'Custom Vision Model', value: 'custom' },
+            { name: 'None (Skip / Disable visual perception)', value: 'none' },
         ],
+        default: 'none',
     });
+    if (model === 'none') {
+        return {
+            config: { provider: 'none' },
+            summary: { Provider: 'None (Vision disabled)' },
+        };
+    }
     let selectedModel = model;
     if (model === 'custom') {
         const { customModel } = await inquirer_1.default.prompt({

package/dist/configurators.test.js

@@ -302,15 +302,39 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
             expect(result.summary?.['Model Path']).toBe('./assets/body/sparkle/model.model3.json');
         });
         test('Hands configurator configures MCP tool execution timeout', async () => {
-            inquirer_1.default.prompt.mockResolvedValueOnce({ timeoutSeconds: '15' });
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ provider: 'mcp' })
+                .mockResolvedValueOnce({ timeoutSeconds: '15' });
             const result = await (0, hands_1.configureHands)({ companionName: 'Sparkle', manifest: handsManifest });
             expect(result.config.defaultTimeoutMs).toBe(15000);
+            expect(result.summary?.Provider).toBeUndefined();
+        });
+        test('Hands configurator disables tool execution when none is selected', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ provider: 'none' });
+            const result = await (0, hands_1.configureHands)({ companionName: 'Sparkle', manifest: handsManifest });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Provider).toBe('None (Hands disabled)');
         });
-        test('Behavior configurator configures active self personality preset', async () => {
-            inquirer_1.default.prompt.mockResolvedValueOnce({ preset: 'cheerful' });
+        test('Behavior configurator configures blank slate mode when later is chosen', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ personaMode: 'later' });
             const result = await (0, behavior_1.configureBehavior)({ companionName: 'Sparkle', manifest: behaviorManifest });
             expect(result.config.provider).toBe('active_self');
-            expect(result.config.preset).toBe('cheerful');
+            expect(result.config.mode).toBe('blank_slate');
+            expect(result.summary?.Persona).toBe('Blank Slate (Evolve via interaction)');
+        });
+        test('Behavior configurator configures custom persona asset when now is chosen', async () => {
+            inquirer_1.default.prompt
+                .mockResolvedValueOnce({ personaMode: 'now' })
+                .mockResolvedValueOnce({
+                archetype: 'System Sentinel',
+                ethos: 'Snarky and loyal',
+                directive: 'No sycophantic greetings',
+            });
+            const result = await (0, behavior_1.configureBehavior)({ companionName: 'Sparkle', manifest: behaviorManifest });
+            expect(result.config.provider).toBe('active_self');
+            expect(result.config.mode).toBe('custom');
+            expect(result.config.archetype).toBe('System Sentinel');
+            expect(result.config.selfPath).toBe('./assets/self/sparkle.self');
         });
         test('Vision configurator configures OpenRouter vision model', async () => {
             inquirer_1.default.prompt.mockResolvedValueOnce({ model: 'gpt-4-vision' });
@@ -318,6 +342,12 @@ describe('Guided Manifest-Driven Configuration UX Specification Tests', () => {
             expect(result.config.provider).toBe('openrouter');
             expect(result.config.model).toBe('gpt-4-vision');
         });
+        test('Vision configurator disables vision when none is selected', async () => {
+            inquirer_1.default.prompt.mockResolvedValueOnce({ model: 'none' });
+            const result = await (0, vision_1.configureVision)({ companionName: 'Sparkle', manifest: visionManifest });
+            expect(result.config.provider).toBe('none');
+            expect(result.summary?.Provider).toBe('None (Vision disabled)');
+        });
     });
     describe('Review Summary Formatting & Generator Integration', () => {
         test('formatReviewSummary displays actual configuration values and metadata', () => {

package/dist/generator.d.ts

@@ -9,6 +9,7 @@ export interface GeneratedInstanceFiles {
     'public/index.html': string;
     createAssetsBodyDir?: boolean;
     createAssetsDirs?: string[];
+    [key: string]: string | boolean | string[] | undefined;
 }
 export interface InstanceGeneratorOptions {
     name: string;

package/dist/generator.js

@@ -73,6 +73,7 @@ function getDefaultConfigForManifest(manifest) {
 }
 function generateInstanceFiles(options) {
     const instanceName = options.name || 'my-siduri';
+    const companionSlug = instanceName.toLowerCase().replace(/[^a-z0-9_-]/g, '') || 'default';
     const instanceId = options.id || 'default';
     const coreVersion = options.coreVersion || '^2.0.3';
     const manifests = options.selectedManifests;
@@ -172,7 +173,7 @@ function generateInstanceFiles(options) {
     ];
     for (const m of manifests) {
         if (m.name === '@siduri-x/self') {
-            importLines.push(`import { ActiveSelfCompiler, SqliteSelfRepository } from '@siduri-x/self';`);
+            importLines.push(`import { ActiveSelfCompiler, SqliteSelfRepository, SelfPackageParser } from '@siduri-x/self';`);
         }
         else {
             importLines.push(`import { ${m.factory} } from '${m.name}';`);
@@ -184,6 +185,19 @@ function generateInstanceFiles(options) {
         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);`);
+            instantiationLines.push(`const selfFile = path.resolve(rootDir, config.organs.behavior?.selfPath || 'assets/self/${companionSlug}.self');`);
+            instantiationLines.push(`try {`);
+            instantiationLines.push(`  const selfRaw = await readFile(selfFile, 'utf8').catch(() => null);`);
+            instantiationLines.push(`  if (selfRaw) {`);
+            instantiationLines.push(`    const parsedSelf = SelfPackageParser.parse(selfRaw);`);
+            instantiationLines.push(`    if (parsedSelf.isValid && parsedSelf.manifest) {`);
+            instantiationLines.push(`      await self.setIdentity({ companionId: config.id || 'default', name: parsedSelf.manifest.identity?.name || config.name, archetype: parsedSelf.manifest.identity?.archetype, version: parsedSelf.manifest.version || '1.0.0', updatedAt: new Date().toISOString() });`);
+            instantiationLines.push(`      if (parsedSelf.manifest.directives) {`);
+            instantiationLines.push(`        await self.commitDirectives(config.id || 'default', parsedSelf.manifest.directives.map((d) => ({ id: d.id, companionId: config.id || 'default', directive: d.directive, category: (d.category || 'behavioral'), status: 'ACTIVE', priority: d.priority || 50, createdAt: new Date().toISOString() })));`);
+            instantiationLines.push(`      }`);
+            instantiationLines.push(`    }`);
+            instantiationLines.push(`  }`);
+            instantiationLines.push(`} catch {}`);
             organMapEntries.push(`  behavior,`);
             organMapEntries.push(`  self,`);
         }
@@ -665,7 +679,6 @@ function generateInstanceFiles(options) {
     }
     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`.');
     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) {
         createAssetsDirs.push(`assets/body/${companionSlug}`);
@@ -681,6 +694,38 @@ function generateInstanceFiles(options) {
         createAssetsDirs.push(cleanPackDir);
         readmeLines.push('', '### Knowledge Pack Assets', `Local knowledge pack files reside in \`./${cleanPackDir}/\`.`);
     }
+    const behaviorConfig = options.organConfigs?.behavior || options.organConfigs?.['@siduri-x/self'];
+    let selfPersonaFile = null;
+    if (manifests.some((m) => m.organType === 'behavior')) {
+        createAssetsDirs.push('assets/self');
+        if (behaviorConfig?.mode === 'custom' || behaviorConfig?.archetype) {
+            const selfRelPath = `assets/self/${companionSlug}.self`;
+            const selfContent = [
+                `specVersion: "2.0.0"`,
+                `kind: "self"`,
+                `id: "${companionSlug}-self"`,
+                `name: "${instanceName} Persona"`,
+                `version: "1.0.0"`,
+                `author:`,
+                `  name: "Operator"`,
+                `license: "MIT"`,
+                ``,
+                `identity:`,
+                `  name: "${instanceName}"`,
+                `  archetype: "${(behaviorConfig.archetype || 'Knowledge Assistant & Research Partner').replace(/"/g, '\\"')}"`,
+                `  origin: "Constructed companion"`,
+                `  ethos: "${(behaviorConfig.ethos || 'Direct technical candor, thoughtful, concise, and loyal').replace(/"/g, '\\"')}"`,
+                ``,
+                `directives:`,
+                `  - id: "dir-01"`,
+                `    category: "behavioral"`,
+                `    directive: "${(behaviorConfig.directive || 'Speak concisely and stay in character without sycophantic filler').replace(/"/g, '\\"')}"`,
+                ``,
+            ].join('\n');
+            selfPersonaFile = { path: selfRelPath, content: selfContent };
+            readmeLines.push('', '### Self & Persona Assets', `Companion persona manifest resides in \`./${selfRelPath}\`.`);
+        }
+    }
     readmeLines.push('');
     const readmeMd = readmeLines.join('\n');
     const webHtml = (0, web_template_1.generateWebHtml)(instanceName, manifests);
@@ -695,5 +740,8 @@ function generateInstanceFiles(options) {
         createAssetsBodyDir: hasBody,
         createAssetsDirs,
     };
+    if (selfPersonaFile) {
+        result[selfPersonaFile.path] = selfPersonaFile.content;
+    }
     return result;
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { OrganManifest } from './manifest';
-export declare const CLI_VERSION = "2.0.4";
+export declare const CLI_VERSION = "2.0.7";
 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.4';
+exports.CLI_VERSION = '2.0.7';
 exports.colors = {
     cyan: '\u001b[36m',
     dim: '\u001b[2m',
@@ -120,50 +120,21 @@ 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}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
-        .filter((m) => m.organType !== 'brain')
-        .sort((a, b) => {
+    printSection('Organ Configuration');
+    console.log(`${exports.colors.dim}Configuring capability organs for ${companionName} sequentially from cognition to physical embodiment.${exports.colors.reset}\n`);
+    // Canonical organ presentation order: Cognition -> Memory/State -> Identity -> Embodiment & Peripheral
+    const canonicalOrder = ['brain', 'memory', 'knowledge', 'behavior', 'voice', 'body', 'mouth', 'hands', 'vision', 'ear', 'observation'];
+    const orderedManifests = [...availableManifests].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;
     });
-    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) {
+    for (const m of orderedManifests) {
         const isRequired = m.organType === 'brain';
         const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
         printSection(sectionTitle);
@@ -171,10 +142,14 @@ async function runCreateWizard(targetDir) {
             companionName,
             existingConfig: organConfigs[m.configKey],
         });
+        if (res.config?.provider === 'none') {
+            continue;
+        }
+        selectedManifests.push(m);
         organConfigs[m.configKey] = res.config;
         organSummaries[m.configKey] = res.summary || {};
     }
-    // 3. Final Review and Edit Loop
+    // 2. Final Review and Edit Loop
     while (true) {
         console.log(formatReviewSummary(companionName, selectedManifests, organSummaries));
         const { reviewAction } = await inquirer_1.default.prompt({
@@ -195,10 +170,13 @@ async function runCreateWizard(targetDir) {
             break;
         }
         if (reviewAction === 'edit') {
-            const editChoices = selectedManifests.map((m) => ({
-                name: `Edit ${m.displayName}`,
-                value: m.configKey,
-            }));
+            const editChoices = orderedManifests.map((m) => {
+                const isSelected = selectedManifests.some((sm) => sm.organType === m.organType);
+                return {
+                    name: `${m.displayName} (${isSelected ? 'Enabled' : 'Disabled / Skipped'})`,
+                    value: m.configKey,
+                };
+            });
             editChoices.push({ name: 'Edit all organs in sequence', value: '__ALL__' });
             editChoices.push({ name: 'Back to review', value: '__BACK__' });
             const { organToEdit } = await inquirer_1.default.prompt({
@@ -211,8 +189,8 @@ async function runCreateWizard(targetDir) {
                 continue;
             }
             const organsToReconfigure = organToEdit === '__ALL__'
-                ? selectedManifests
-                : selectedManifests.filter((m) => m.configKey === organToEdit);
+                ? orderedManifests
+                : orderedManifests.filter((m) => m.configKey === organToEdit);
             for (const m of organsToReconfigure) {
                 const isRequired = m.organType === 'brain';
                 const sectionTitle = isRequired ? `${m.displayName.split(' ')[0] || m.organType} · required` : m.displayName.split(' ')[0] || m.organType;
@@ -221,8 +199,25 @@ async function runCreateWizard(targetDir) {
                     companionName,
                     existingConfig: organConfigs[m.configKey],
                 });
-                organConfigs[m.configKey] = res.config;
-                organSummaries[m.configKey] = res.summary || {};
+                if (res.config?.provider === 'none') {
+                    const idx = selectedManifests.findIndex((sm) => sm.organType === m.organType);
+                    if (idx !== -1)
+                        selectedManifests.splice(idx, 1);
+                    delete organConfigs[m.configKey];
+                    delete organSummaries[m.configKey];
+                }
+                else {
+                    if (!selectedManifests.some((sm) => sm.organType === m.organType)) {
+                        selectedManifests.push(m);
+                        selectedManifests.sort((a, b) => {
+                            const idxA = canonicalOrder.indexOf(a.organType);
+                            const idxB = canonicalOrder.indexOf(b.organType);
+                            return (idxA === -1 ? 99 : idxA) - (idxB === -1 ? 99 : idxB);
+                        });
+                    }
+                    organConfigs[m.configKey] = res.config;
+                    organSummaries[m.configKey] = res.summary || {};
+                }
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vxnus/siduri",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Experimental CLI for installing and configuring Siduri companions",
   "license": "Apache-2.0",
   "repository": {