@siduri-x/api 2.0.1 → 2.0.2

package/dist/boot.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDisabled = isDisabled;
+exports.createBrain = createBrain;
+exports.createVoice = createVoice;
+exports.createKnowledge = createKnowledge;
+exports.createVision = createVision;
+exports.createBehavior = createBehavior;
+exports.createBody = createBody;
+exports.createHands = createHands;
+exports.createEar = createEar;
+exports.createMouth = createMouth;
+exports.createMemory = createMemory;
+exports.createSelf = createSelf;
+exports.createObservation = createObservation;
+exports.bootCompanion = bootCompanion;
+const brain_1 = require("@siduri-x/brain");
+const memory_1 = require("@siduri-x/memory");
+const voice_1 = require("@siduri-x/voice");
+const knowledge_1 = require("@siduri-x/knowledge");
+const vision_1 = require("@siduri-x/vision");
+const self_1 = require("@siduri-x/self");
+const body_1 = require("@siduri-x/body");
+const observation_1 = require("@siduri-x/observation");
+const hands_1 = require("@siduri-x/hands");
+const ear_1 = require("@siduri-x/ear");
+const mouth_1 = require("@siduri-x/mouth");
+const runtime_1 = require("./runtime");
+function isDisabled(config) {
+    return !config || config.provider === 'none';
+}
+function createBrain(config) {
+    const provider = config?.provider || 'openrouter';
+    const defaultKeyEnv = provider === 'openai-compatible' ? 'OPENAI_COMPATIBLE_API_KEY' : 'OPENROUTER_API_KEY';
+    const apiKey = config?.apiKey || process.env[config?.apiKeyEnv || defaultKeyEnv] || '';
+    if (provider === 'openai-compatible') {
+        return new brain_1.OpenAICompatibleBrain({
+            apiKey,
+            model: config?.model || 'local-model',
+            baseUrl: config?.baseUrl || 'http://127.0.0.1:1234/v1',
+        });
+    }
+    return new brain_1.OpenRouterBrain({ apiKey, model: config?.model || 'gpt-4o-mini' });
+}
+function createVoice(config) {
+    return isDisabled(config)
+        ? undefined
+        : new voice_1.VoiceAdapter({
+            provider: config?.provider || 'voicevox',
+            baseUrl: config?.baseUrl || process.env.VOICEVOX_URL || 'http://localhost:50021',
+            speakerId: config?.speakerId || 1,
+            ...config,
+        });
+}
+function createKnowledge(config) {
+    if (isDisabled(config))
+        return undefined;
+    const dbPath = config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite';
+    return new knowledge_1.UnifiedKnowledgeOrgan({
+        ...config,
+        dbPath,
+        lifeDatabase: config?.lifeDatabase ?? true,
+    });
+}
+function createVision(config) {
+    return isDisabled(config)
+        ? undefined
+        : new vision_1.OpenRouterVisionAdapter({
+            apiKey: config?.apiKey || process.env.OPENROUTER_API_KEY || '',
+            model: config?.model || 'gpt-4-vision',
+            ...config,
+        });
+}
+function createBehavior(config) {
+    return isDisabled(config) ? undefined : new self_1.ActiveSelfCompiler();
+}
+function createBody(config) {
+    return isDisabled(config)
+        ? undefined
+        : new body_1.Live2DAdapter(config);
+}
+function createHands(config) {
+    return isDisabled(config)
+        ? new hands_1.DefaultHandsOrgan()
+        : new hands_1.DefaultHandsOrgan(config);
+}
+function createEar(config) {
+    return isDisabled(config)
+        ? new ear_1.DefaultEarOrgan()
+        : new ear_1.DefaultEarOrgan(config);
+}
+function createMouth(config, voice) {
+    return isDisabled(config)
+        ? new mouth_1.DefaultMouthOrgan({ voice })
+        : new mouth_1.DefaultMouthOrgan({ ...config, voice });
+}
+function createMemory(config) {
+    if (isDisabled(config))
+        return undefined;
+    return new memory_1.SqliteMemoryStore({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
+}
+function createSelf(config) {
+    return new self_1.SqliteSelfRepository({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
+}
+function createObservation(vision) {
+    return new observation_1.FixtureObservationOrgan(vision ?? { analyze: async () => JSON.stringify({ readings: [] }) });
+}
+/**
+ * Canonical companion bootstrapper.
+ * Wires all 10 organs, runs memory migrations, and initializes the SiduriRuntime.
+ */
+async function bootCompanion(id, config, options) {
+    const organs = config?.organs || {};
+    const brain = createBrain(organs.brain || config?.brain);
+    const memory = createMemory(organs.memory || config?.memory);
+    const selfRepo = createSelf(organs.self || config?.self);
+    const voice = createVoice(organs.voice || config?.voice);
+    const knowledge = createKnowledge(organs.knowledge || config?.knowledge);
+    const vision = createVision(organs.vision || config?.vision);
+    const behavior = createBehavior(organs.behavior || config?.behavior);
+    const body = createBody(organs.body || config?.body);
+    const hands = createHands(organs.hands || config?.hands);
+    const ear = createEar(organs.ear || config?.ear);
+    const mouth = createMouth(organs.mouth || config?.mouth, voice);
+    const observation = options?.observationOrgan;
+    if (memory && typeof memory.runMigrations === 'function') {
+        await memory.runMigrations().catch((e) => console.warn("Migrations warning:", e.message));
+    }
+    const runtime = new runtime_1.SiduriRuntime(id, config, {
+        brain,
+        memory,
+        voice,
+        knowledge,
+        vision,
+        behavior,
+        body,
+        hands,
+        ear,
+        mouth,
+        observation,
+        self: selfRepo,
+        externalKnowledge: knowledge?.eAdapter ?? knowledge,
+    });
+    await runtime.initialize();
+    return runtime;
+}

package/dist/boot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/boot.test.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const boot_1 = require("./boot");
+const observation_1 = require("@siduri-x/observation");
+describe('Canonical bootCompanion & Organ Factory Suite', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    test('isDisabled correctly identifies undefined or none provider', () => {
+        expect((0, boot_1.isDisabled)(undefined)).toBe(true);
+        expect((0, boot_1.isDisabled)({ provider: 'none' })).toBe(true);
+        expect((0, boot_1.isDisabled)({ provider: 'openrouter' })).toBe(false);
+        expect((0, boot_1.isDisabled)({ provider: 'sqlite' })).toBe(false);
+    });
+    test('creates all standard organs with fallback configurations', () => {
+        const brain = (0, boot_1.createBrain)({ provider: 'openai-compatible', baseUrl: 'http://localhost:11434/v1', apiKey: 'test' });
+        expect(brain).toBeDefined();
+        const voice = (0, boot_1.createVoice)({ provider: 'none' });
+        expect(voice).toBeUndefined();
+        const memory = (0, boot_1.createMemory)({ provider: 'sqlite', dbPath: ':memory:' });
+        expect(memory).toBeDefined();
+        const selfRepo = (0, boot_1.createSelf)({ dbPath: ':memory:' });
+        expect(selfRepo).toBeDefined();
+        const vision = (0, boot_1.createVision)({ provider: 'none' });
+        expect(vision).toBeUndefined();
+        const behavior = (0, boot_1.createBehavior)({ provider: 'active_self' });
+        expect(behavior).toBeDefined();
+        const body = (0, boot_1.createBody)({ provider: 'none' });
+        expect(body).toBeUndefined();
+        const hands = (0, boot_1.createHands)();
+        expect(hands).toBeDefined();
+        const ear = (0, boot_1.createEar)();
+        expect(ear).toBeDefined();
+        const mouth = (0, boot_1.createMouth)(undefined, voice);
+        expect(mouth).toBeDefined();
+        const observation = (0, boot_1.createObservation)();
+        expect(observation).toBeInstanceOf(observation_1.FixtureObservationOrgan);
+    });
+    test('bootCompanion wires all organs and runs migrations', async () => {
+        let migrationsRun = false;
+        const testConfig = {
+            name: 'Test Companion',
+            brain: { provider: 'openrouter', apiKey: 'mock-key', model: 'mock-model' },
+            memory: { provider: 'none' }, // will use custom mock
+            voice: { provider: 'none' },
+            vision: { provider: 'none' },
+            behavior: { provider: 'none' },
+            body: { provider: 'none' },
+            hands: { provider: 'none' },
+            ear: { provider: 'none' },
+            mouth: { provider: 'none' },
+            knowledge: { provider: 'none' },
+        };
+        const mockObservation = new observation_1.FixtureObservationOrgan({ analyze: async () => JSON.stringify({ readings: [] }) });
+        const runtime = await (0, boot_1.bootCompanion)('test-comp-1', testConfig, {
+            observationOrgan: mockObservation,
+        });
+        expect(runtime).toBeDefined();
+        expect(runtime.id).toBe('test-comp-1');
+        expect(runtime.observation).toBe(mockObservation);
+        expect(runtime.hands).toBeDefined();
+        expect(runtime.ear).toBeDefined();
+        expect(runtime.mouth).toBeDefined();
+    });
+    test('bootCompanion handles nested organs configuration structure', async () => {
+        const nestedConfig = {
+            name: 'Nested Companion',
+            organs: {
+                brain: { provider: 'openrouter', apiKey: 'mock' },
+                memory: { provider: 'none' },
+                knowledge: { provider: 'none' },
+                voice: { provider: 'none' },
+            },
+        };
+        const runtime = await (0, boot_1.bootCompanion)('nested-comp', nestedConfig);
+        expect(runtime).toBeDefined();
+        expect(runtime.id).toBe('nested-comp');
+        expect(runtime.brain).toBeDefined();
+    });
+});

package/dist/context-mapper.d.ts

@@ -12,7 +12,9 @@ export interface MapRequestContextResult {
 /**
  * Maps incoming HTTP requests to a canonical RequestContext.
  * In a single-owner, single-machine model:
- * - Security is enforced at the external boundary, not internally between roles.
+ * - Security is enforced at the external machine boundary, NOT internally between roles.
  * - No internal audience or viewer/operator/owner role hierarchies.
+ * - Authenticated callers are the single owner with full companion access.
+ * - Unauthenticated callers are bounded to public chat.
  */
 export declare function mapRequestContext(input: any, options?: ContextMapperOptions): MapRequestContextResult;

package/dist/context-mapper.js

@@ -5,8 +5,10 @@ const core_1 = require("@siduri-x/core");
 /**
  * Maps incoming HTTP requests to a canonical RequestContext.
  * In a single-owner, single-machine model:
- * - Security is enforced at the external boundary, not internally between roles.
+ * - Security is enforced at the external machine boundary, NOT internally between roles.
  * - No internal audience or viewer/operator/owner role hierarchies.
+ * - Authenticated callers are the single owner with full companion access.
+ * - Unauthenticated callers are bounded to public chat.
  */
 function mapRequestContext(input, options = {}) {
     const diagnostics = [];
@@ -23,7 +25,9 @@ function mapRequestContext(input, options = {}) {
     if (input.context && typeof input.context === 'object') {
         const rawCtx = input.context;
         const companionId = input.companionId || rawCtx.companionId || input.id;
-        const correlationId = rawCtx.conversation?.correlationId || input.correlationId;
+        const correlationId = rawCtx.conversation?.correlationId ||
+            input.correlationId ||
+            (input.generateCorrelationId ? `corr-${Date.now()}` : undefined);
         if (!companionId) {
             return {
                 accepted: false,
@@ -57,16 +61,42 @@ function mapRequestContext(input, options = {}) {
                 },
             };
         }
-        // Determine server-enforced authentication status
+        const isViewerRequested = (typeof input.role === 'string' && input.role.toLowerCase() === 'viewer') ||
+            (typeof input.serverRole === 'string' && input.serverRole.toLowerCase() === 'viewer') ||
+            (typeof actor.authorizationRole === 'string' && actor.authorizationRole.toLowerCase() === 'viewer') ||
+            (typeof actor.role === 'string' && actor.role.toLowerCase() === 'viewer');
+        // Determine server-enforced authentication status at the machine boundary
         const isAuthenticated = input.authenticated !== undefined
             ? Boolean(input.authenticated)
             : (actor.authenticated !== undefined ? Boolean(actor.authenticated) : true);
-        const safeCapabilities = isAuthenticated
-            ? (Array.isArray(actor.capabilities) ? actor.capabilities : ['chat'])
-            : ['chat'];
-        const safeRole = isAuthenticated
-            ? actor.authorizationRole
-            : 'viewer';
+        const isViewer = !isAuthenticated || isViewerRequested;
+        const CANONICAL_CAPABILITIES = new Set(['chat', 'memory:approve', 'action:execute', 'system']);
+        const DEFAULT_OWNER_CAPABILITIES = ['chat', 'memory:approve', 'action:execute', 'system'];
+        let safeCapabilities;
+        let authorizationRole;
+        if (isViewer) {
+            safeCapabilities = ['chat'];
+            authorizationRole = 'viewer';
+            if (Array.isArray(actor.capabilities) && actor.capabilities.some((c) => c !== 'chat' && c !== 'chat:public')) {
+                diagnostics.push('capability_escalation_attempt_suppressed');
+            }
+            if (actor.authorizationRole && actor.authorizationRole.toLowerCase() !== 'viewer') {
+                diagnostics.push('role_escalation_attempt_suppressed');
+            }
+        }
+        else {
+            authorizationRole = 'administrator';
+            if (Array.isArray(actor.capabilities) && actor.capabilities.length > 0) {
+                const filtered = actor.capabilities.filter((c) => CANONICAL_CAPABILITIES.has(c));
+                if (filtered.length < actor.capabilities.length) {
+                    diagnostics.push('capability_escalation_attempt_suppressed');
+                }
+                safeCapabilities = filtered.length > 0 ? filtered : [...DEFAULT_OWNER_CAPABILITIES];
+            }
+            else {
+                safeCapabilities = [...DEFAULT_OWNER_CAPABILITIES];
+            }
+        }
         const constructed = {
             companionId,
             actor: {
@@ -75,7 +105,7 @@ function mapRequestContext(input, options = {}) {
                 sessionId: actor.sessionId,
                 capabilities: safeCapabilities,
                 authenticated: isAuthenticated,
-                authorizationRole: safeRole,
+                authorizationRole,
             },
             conversation: {
                 correlationId,
@@ -132,19 +162,47 @@ function mapRequestContext(input, options = {}) {
             },
         };
     }
-    const actorId = input.actorId || input.actor?.actorId || 'local-user';
+    const isViewerRequested = (typeof input.role === 'string' && input.role.toLowerCase() === 'viewer') ||
+        (typeof input.serverRole === 'string' && input.serverRole.toLowerCase() === 'viewer');
+    const isAuthenticated = input.authenticated !== undefined ? Boolean(input.authenticated) : true;
+    const isViewer = !isAuthenticated || isViewerRequested;
+    const actorId = input.actorId || input.actor?.actorId || (isAuthenticated && !isViewer ? 'local-user' : 'anonymous-session');
     const sessionId = input.sessionId || input.actor?.sessionId || `session-${Date.now()}`;
     if (!input.actorId && !input.actor?.actorId) {
         diagnostics.push('anonymous_session_generated');
     }
-    const isAuthenticated = input.authenticated !== undefined ? Boolean(input.authenticated) : true;
-    const capabilities = isAuthenticated
-        ? (Array.isArray(input.capabilities)
-            ? input.capabilities
-            : Array.isArray(input.actor?.capabilities)
-                ? input.actor.capabilities
-                : ['chat', 'system'])
-        : ['chat'];
+    const CANONICAL_CAPABILITIES = new Set(['chat', 'memory:approve', 'action:execute', 'system']);
+    const DEFAULT_OWNER_CAPABILITIES = ['chat', 'memory:approve', 'action:execute', 'system'];
+    const rawCaps = Array.isArray(input.capabilities)
+        ? input.capabilities
+        : Array.isArray(input.actor?.capabilities)
+            ? input.actor.capabilities
+            : undefined;
+    let capabilities;
+    let authorizationRole;
+    if (isViewer) {
+        capabilities = ['chat'];
+        authorizationRole = 'viewer';
+        if (rawCaps && rawCaps.some((c) => c !== 'chat' && c !== 'chat:public')) {
+            diagnostics.push('capability_escalation_attempt_suppressed');
+        }
+        if (input.role && input.role.toLowerCase() !== 'viewer') {
+            diagnostics.push('role_escalation_attempt_suppressed');
+        }
+    }
+    else {
+        authorizationRole = 'administrator';
+        if (rawCaps && rawCaps.length > 0) {
+            const filtered = rawCaps.filter((c) => CANONICAL_CAPABILITIES.has(c));
+            if (filtered.length < rawCaps.length) {
+                diagnostics.push('capability_escalation_attempt_suppressed');
+            }
+            capabilities = filtered.length > 0 ? filtered : [...DEFAULT_OWNER_CAPABILITIES];
+        }
+        else {
+            capabilities = [...DEFAULT_OWNER_CAPABILITIES];
+        }
+    }
     const mappedContext = {
         companionId,
         actor: {
@@ -152,7 +210,7 @@ function mapRequestContext(input, options = {}) {
             sessionId,
             capabilities,
             authenticated: isAuthenticated,
-            authorizationRole: input.role ? (input.role.toLowerCase() === 'viewer' ? 'viewer' : 'administrator') : undefined,
+            authorizationRole,
         },
         conversation: {
             channel: input.channel || input.conversation?.channel || 'direct',

package/dist/context-mapper.test.js

@@ -157,5 +157,96 @@ describe('API Request Context Mapper (Single-Owner, Single-Machine)', () => {
         expect(result.context?.actor.capabilities).toEqual(['chat']);
         expect(result.context?.actor.authorizationRole).toBe('viewer');
         expect(result.context?.source).toBe('external');
+        expect(result.diagnostics).toContain('role_escalation_attempt_suppressed');
+        expect(result.diagnostics).toContain('capability_escalation_attempt_suppressed');
+    });
+    test('Prevents attenuated caller from escalating to administrator role or forging elevated capabilities', () => {
+        const attenuatedPayload = {
+            companionId: 'companion-a',
+            authenticated: true,
+            role: 'VIEWER',
+            source: 'external',
+            context: {
+                actor: {
+                    actorId: 'visitor-bob',
+                    sessionId: 'session-vis-1',
+                    authorizationRole: 'administrator', // Forged owner/admin role
+                    capabilities: ['chat', 'system', 'root:manage', 'action:execute'], // Forged system/root capabilities
+                },
+                conversation: {
+                    correlationId: 'corr-att-escalate',
+                },
+            },
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(attenuatedPayload);
+        expect(result.accepted).toBe(true);
+        expect(result.context?.actor.authenticated).toBe(true);
+        expect(result.context?.actor.authorizationRole).toBe('viewer');
+        expect(result.context?.actor.capabilities).toEqual(['chat']);
+        expect(result.diagnostics).toContain('role_escalation_attempt_suppressed');
+        expect(result.diagnostics).toContain('capability_escalation_attempt_suppressed');
+    });
+    test('Strips unknown capabilities for authenticated owner while preserving canonical companion capabilities', () => {
+        const ownerPayload = {
+            companionId: 'companion-a',
+            authenticated: true,
+            source: 'local',
+            context: {
+                actor: {
+                    actorId: 'owner-user',
+                    sessionId: 'session-owner-1',
+                    capabilities: ['chat', 'system', 'root:unauthorized', 'arbitrary:hack'],
+                },
+                conversation: {
+                    correlationId: 'corr-owner-caps',
+                },
+            },
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(ownerPayload);
+        expect(result.accepted).toBe(true);
+        expect(result.context?.actor.authorizationRole).toBe('administrator');
+        expect(result.context?.actor.capabilities).toEqual(['chat', 'system']);
+        expect(result.diagnostics).toContain('capability_escalation_attempt_suppressed');
+    });
+    test('Flat envelope: suppresses role and capability escalation when serverRole is VIEWER', () => {
+        const viewerPayload = {
+            companionId: 'companion-a',
+            authenticated: false,
+            serverRole: 'VIEWER',
+            role: 'OWNER', // Forged in flat envelope
+            capabilities: ['chat', 'system', 'action:execute'],
+            generateCorrelationId: true,
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(viewerPayload);
+        expect(result.accepted).toBe(true);
+        expect(result.context?.actor.authorizationRole).toBe('viewer');
+        expect(result.context?.actor.capabilities).toEqual(['chat']);
+        expect(result.diagnostics).toContain('role_escalation_attempt_suppressed');
+    });
+    test('Authenticated owner receives canonical administrator role and capabilities, and can safely attenuate to viewer', () => {
+        const ownerPayload = {
+            companionId: 'companion-a',
+            authenticated: true,
+            serverRole: 'OWNER',
+            generateCorrelationId: true,
+        };
+        const ownerResult = (0, context_mapper_1.mapRequestContext)(ownerPayload);
+        expect(ownerResult.accepted).toBe(true);
+        expect(ownerResult.context?.actor.authorizationRole).toBe('administrator');
+        expect(ownerResult.context?.actor.capabilities).toEqual([
+            'chat',
+            'memory:approve',
+            'action:execute',
+            'system',
+        ]);
+        // Attenuation to viewer
+        const attenuatedPayload = {
+            ...ownerPayload,
+            role: 'VIEWER',
+        };
+        const attenuatedResult = (0, context_mapper_1.mapRequestContext)(attenuatedPayload);
+        expect(attenuatedResult.accepted).toBe(true);
+        expect(attenuatedResult.context?.actor.authorizationRole).toBe('viewer');
+        expect(attenuatedResult.diagnostics).not.toContain('role_escalation_attempt_suppressed');
     });
 });

package/dist/index.d.ts

@@ -2,5 +2,6 @@ import { Express } from 'express';
 import { createApp, AppInstance } from './app';
 export { createApp, AppInstance };
 export * from './context-mapper';
+export * from './boot';
 export declare const app: Express;
 export default app;

package/dist/index.js

@@ -24,76 +24,13 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const app_1 = require("./app");
 Object.defineProperty(exports, "createApp", { enumerable: true, get: function () { return app_1.createApp; } });
-const runtime_1 = require("./runtime");
-const brain_1 = require("@siduri-x/brain");
-const memory_1 = require("@siduri-x/memory");
-const voice_1 = require("@siduri-x/voice");
-const eknowledge_1 = require("@siduri-x/eknowledge");
-const vision_1 = require("@siduri-x/vision");
-const self_1 = require("@siduri-x/self");
-const body_1 = require("@siduri-x/body");
-const observation_1 = require("@siduri-x/observation");
+const boot_1 = require("./boot");
 __exportStar(require("./context-mapper"), exports);
+__exportStar(require("./boot"), exports);
 const runtimes = new Map();
 const instance = (0, app_1.createApp)(runtimes);
 exports.app = instance.app;
 exports.default = exports.app;
-function createBrain(config) {
-    const provider = config?.provider || 'openrouter';
-    const defaultKeyEnv = provider === 'openai-compatible' ? 'OPENAI_COMPATIBLE_API_KEY' : 'OPENROUTER_API_KEY';
-    const apiKey = config?.apiKey || process.env[config?.apiKeyEnv || defaultKeyEnv] || '';
-    if (provider === 'openai-compatible') {
-        return new brain_1.OpenAICompatibleBrain({
-            apiKey,
-            model: config?.model || 'local-model',
-            baseUrl: config?.baseUrl || 'http://127.0.0.1:1234/v1',
-        });
-    }
-    return new brain_1.OpenRouterBrain({ apiKey, model: config?.model || 'gpt-4o-mini' });
-}
-function isDisabled(config) {
-    return !config || config.provider === 'none';
-}
-function createVoice(config) {
-    return isDisabled(config)
-        ? undefined
-        : new voice_1.VoiceAdapter({
-            provider: config?.provider || 'voicevox',
-            baseUrl: config?.baseUrl || process.env.VOICEVOX_URL || 'http://localhost:50021',
-            speakerId: config?.speakerId || 1,
-            ...config,
-        });
-}
-function createKnowledge(config) {
-    if (isDisabled(config))
-        return undefined;
-    if (!config?.packPath && !config?.registryUrl && !config?.baseUrl) {
-        return undefined;
-    }
-    return new eknowledge_1.EKnowledgeAdapter(config || {});
-}
-function createVision(config) {
-    return isDisabled(config)
-        ? undefined
-        : new vision_1.OpenRouterVisionAdapter({
-            apiKey: config?.apiKey || process.env.OPENROUTER_API_KEY || '',
-            model: config?.model || 'gpt-4-vision',
-            ...config,
-        });
-}
-function createBehavior(config) {
-    return isDisabled(config) ? undefined : new self_1.ActiveSelfCompiler();
-}
-function createBody(config) {
-    return isDisabled(config)
-        ? undefined
-        : new body_1.Live2DAdapter(config);
-}
-function createMemory(config) {
-    if (isDisabled(config))
-        return undefined;
-    return new memory_1.SqliteMemoryStore({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
-}
 const PORT = process.env.PORT || 3001;
 const defaultCompanionConfig = {
     id: 'default',
@@ -102,7 +39,9 @@ const defaultCompanionConfig = {
     voice: { provider: 'voicevox', speakerId: 1 },
     memory: { provider: 'sqlite' },
     knowledge: {
-        provider: process.env.SIDURI_KNOWLEDGE_PROVIDER || 'e-knowledge',
+        provider: process.env.SIDURI_KNOWLEDGE_PROVIDER || 'unified',
+        lifeDatabase: true,
+        dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite',
         packPath: process.env.SIDURI_KNOWLEDGE_PACK || '',
         registryUrl: process.env.SIDURI_KNOWLEDGE_REGISTRY_URL || '',
         packId: process.env.SIDURI_KNOWLEDGE_PACK_ID || '',
@@ -149,6 +88,8 @@ async function loadCompanionConfig() {
         config.knowledge.packId = process.env.SIDURI_KNOWLEDGE_PACK_ID;
     if (process.env.SIDURI_KNOWLEDGE_MODE)
         config.knowledge.preferredMode = process.env.SIDURI_KNOWLEDGE_MODE;
+    if (process.env.SIDURI_KNOWLEDGE_DB_PATH)
+        config.knowledge.dbPath = process.env.SIDURI_KNOWLEDGE_DB_PATH;
     return config;
 }
 async function bootDefaultCompanion() {
@@ -156,31 +97,10 @@ async function bootDefaultCompanion() {
         return;
     console.log("Booting default companion...");
     const config = await loadCompanionConfig();
-    const brain = createBrain(config.brain);
-    const memory = createMemory(config.memory);
-    const voice = createVoice(config.voice);
-    const knowledge = createKnowledge(config.knowledge);
-    const vision = createVision(config.vision);
-    const observation = new observation_1.FixtureObservationOrgan(vision ?? { analyze: async () => JSON.stringify({ readings: [] }) });
+    const vision = (0, boot_1.createVision)(config.vision);
+    const observation = (0, boot_1.createObservation)(vision);
     instance.setObservationOrgan(observation);
-    const selfRepo = new self_1.SqliteSelfRepository({ dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
-    const behavior = createBehavior(config.behavior);
-    const body = createBody(config.body);
-    if (memory && typeof memory.runMigrations === 'function') {
-        await memory.runMigrations().catch((e) => console.warn("Migrations warning:", e.message));
-    }
-    const runtime = new runtime_1.SiduriRuntime('default', config, {
-        brain,
-        memory,
-        voice,
-        knowledge,
-        vision,
-        behavior,
-        body,
-        self: selfRepo,
-        externalKnowledge: knowledge
-    });
-    await runtime.initialize();
+    const runtime = await (0, boot_1.bootCompanion)('default', config, { observationOrgan: observation });
     runtimes.set('default', runtime);
     console.log("Default companion booted successfully.");
 }

package/dist/index.test.js

@@ -111,7 +111,7 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
         expect(res.text).toContain('event: done');
     });
     test('handles barge-in interruption via POST /chat/interrupt', async () => {
-        fakeRuntime.interruptMouth = jest.fn();
+        fakeRuntime.mouth = { interrupt: jest.fn() };
         const res = await (0, supertest_1.default)(app)
             .post('/chat/interrupt')
             .send({
@@ -120,10 +120,10 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
         });
         expect(res.status).toBe(200);
         expect(res.body.interrupted).toBe(true);
-        expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_stop');
+        expect(fakeRuntime.mouth.interrupt).toHaveBeenCalledWith('user_stop');
     });
     test('handles mouth interruption via POST /mouth/interrupt', async () => {
-        fakeRuntime.interruptMouth = jest.fn();
+        fakeRuntime.mouth = { interrupt: jest.fn() };
         const res = await (0, supertest_1.default)(app)
             .post('/mouth/interrupt')
             .send({
@@ -132,6 +132,6 @@ describe('API Boundary Context Validation (P2 Route Integration)', () => {
         });
         expect(res.status).toBe(200);
         expect(res.body.interrupted).toBe(true);
-        expect(fakeRuntime.interruptMouth).toHaveBeenCalledWith('user_barge_in');
+        expect(fakeRuntime.mouth.interrupt).toHaveBeenCalledWith('user_barge_in');
     });
 });

package/dist/knowledge.test.d.ts

@@ -0,0 +1 @@
+export {};