@sidurijs/api 1.0.0

package/dist/auth.d.ts

@@ -0,0 +1,34 @@
+import { Request, Response, NextFunction } from 'express';
+export type Role = 'OWNER' | 'OPERATOR' | 'VIEWER' | 'user' | string;
+export interface Identity {
+    authenticated: boolean;
+    source: 'local' | 'external';
+    actorId?: string;
+    role?: Role;
+    [key: string]: unknown;
+}
+/**
+ * Checks whether an incoming request originates from the local machine loopback interface.
+ */
+export declare function isLocalRequest(req: Request): boolean;
+/**
+ * Resolves request identity according to the single-owner external machine boundary security model.
+ *
+ * - Security is enforced at the external machine boundary, NOT internally.
+ * - External network requests require a matching token (AUTH_TOKEN / OWNER_TOKEN).
+ * - There are no internal viewer/operator/owner role privileges inside the machine.
+ */
+export declare function resolveIdentity(req: Request): Identity;
+/**
+ * External boundary authentication middleware.
+ * Verifies that requests crossing the external boundary are authorized.
+ */
+export declare function requireAuth(req: Request, res: Response, next: NextFunction): Response<any, Record<string, any>> | undefined;
+/**
+ * Attaches the resolved machine identity to the request.
+ */
+export declare function attachIdentity(req: Request, res: Response, next: NextFunction): void;
+/**
+ * Compatibility alias: in single-owner model, all authenticated callers have full access.
+ */
+export declare function requireRole(allowedRoles?: Role[]): (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/dist/auth.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalRequest = isLocalRequest;
+exports.resolveIdentity = resolveIdentity;
+exports.requireAuth = requireAuth;
+exports.attachIdentity = attachIdentity;
+exports.requireRole = requireRole;
+/**
+ * Checks whether an incoming request originates from the local machine loopback interface.
+ */
+function isLocalRequest(req) {
+    const ip = req.ip || req.socket?.remoteAddress || '';
+    return (ip === '127.0.0.1' ||
+        ip === '::1' ||
+        ip === '::ffff:127.0.0.1' ||
+        ip.endsWith('127.0.0.1') ||
+        ip === 'localhost');
+}
+/**
+ * Resolves request identity according to the single-owner external machine boundary security model.
+ *
+ * - Security is enforced at the external machine boundary, NOT internally.
+ * - External network requests require a matching token (AUTH_TOKEN / OWNER_TOKEN).
+ * - There are no internal viewer/operator/owner role privileges inside the machine.
+ */
+function resolveIdentity(req) {
+    const authHeader = req.headers?.authorization;
+    const token = authHeader?.startsWith('Bearer ') ? authHeader.split(' ')[1] : undefined;
+    const ownerToken = process.env.AUTH_TOKEN || process.env.API_TOKEN || process.env.OWNER_TOKEN;
+    const operatorToken = process.env.OPERATOR_TOKEN;
+    const configuredToken = ownerToken || operatorToken;
+    const local = isLocalRequest(req);
+    // 1. Explicit token matches
+    if (ownerToken && token === ownerToken) {
+        return { authenticated: true, source: local ? 'local' : 'external', role: 'OWNER' };
+    }
+    if (operatorToken && token === operatorToken) {
+        return { authenticated: true, source: local ? 'local' : 'external', role: 'OPERATOR' };
+    }
+    // 2. Dev local auth role fallback
+    const isDev = process.env.NODE_ENV !== 'production';
+    if (isDev && process.env.DEV_LOCAL_AUTH_ROLE) {
+        const fallbackRole = process.env.DEV_LOCAL_AUTH_ROLE.toUpperCase();
+        return {
+            authenticated: fallbackRole === 'OWNER' || fallbackRole === 'OPERATOR',
+            source: 'local',
+            role: fallbackRole,
+        };
+    }
+    // 3. Default unauthenticated / visitor
+    return { authenticated: false, source: local ? 'local' : 'external', role: 'VIEWER' };
+}
+/**
+ * External boundary authentication middleware.
+ * Verifies that requests crossing the external boundary are authorized.
+ */
+function requireAuth(req, res, next) {
+    const identity = resolveIdentity(req);
+    req.identity = identity;
+    if (!identity.authenticated) {
+        return res.status(401).json({ error: 'Unauthorized: missing or invalid authentication token' });
+    }
+    next();
+}
+/**
+ * Attaches the resolved machine identity to the request.
+ */
+function attachIdentity(req, res, next) {
+    req.identity = resolveIdentity(req);
+    next();
+}
+/**
+ * Compatibility alias: in single-owner model, all authenticated callers have full access.
+ */
+function requireRole(allowedRoles) {
+    return (req, res, next) => {
+        const identity = resolveIdentity(req);
+        req.identity = identity;
+        if (!identity.authenticated) {
+            return res.status(403).json({ error: `Forbidden: requires one of ${(allowedRoles || []).join(', ')}` });
+        }
+        next();
+    };
+}

package/dist/auth.test.d.ts

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

package/dist/auth.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_1 = require("./auth");
+describe('Auth Identity Resolution (Single-Owner External Boundary)', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    const mockReq = (token, ip = '192.168.1.50') => ({
+        headers: {
+            authorization: token ? `Bearer ${token}` : undefined,
+        },
+        ip,
+        socket: { remoteAddress: ip },
+    });
+    test('authenticates external request when token matches configured AUTH_TOKEN', () => {
+        process.env.AUTH_TOKEN = 'secret-auth-key';
+        process.env.NODE_ENV = 'production';
+        const identity = (0, auth_1.resolveIdentity)(mockReq('secret-auth-key'));
+        expect(identity.authenticated).toBe(true);
+        expect(identity.source).toBe('external');
+    });
+    test('authenticates external request when token matches legacy OWNER_TOKEN', () => {
+        process.env.OWNER_TOKEN = 'owner-secret';
+        process.env.NODE_ENV = 'production';
+        const identity = (0, auth_1.resolveIdentity)(mockReq('owner-secret'));
+        expect(identity.authenticated).toBe(true);
+        expect(identity.source).toBe('external');
+    });
+    test('rejects external request when token is missing in production with configured token', () => {
+        process.env.AUTH_TOKEN = 'secret-auth-key';
+        process.env.NODE_ENV = 'production';
+        const identity = (0, auth_1.resolveIdentity)(mockReq());
+        expect(identity.authenticated).toBe(false);
+    });
+    test('rejects external request for invalid token in production', () => {
+        process.env.AUTH_TOKEN = 'secret-auth-key';
+        process.env.NODE_ENV = 'production';
+        const identity = (0, auth_1.resolveIdentity)(mockReq('invalid-token'));
+        expect(identity.authenticated).toBe(false);
+    });
+    test('authenticates local loopback request in development mode', () => {
+        process.env.NODE_ENV = 'development';
+        process.env.DEV_LOCAL_AUTH_ROLE = 'OWNER';
+        process.env.AUTH_TOKEN = 'secret-key';
+        const devIdentity = (0, auth_1.resolveIdentity)(mockReq(undefined, '127.0.0.1'));
+        expect(devIdentity.authenticated).toBe(true);
+        expect(devIdentity.source).toBe('local');
+    });
+    test('requireAuth middleware accepts authenticated request and rejects unauthenticated with 401', () => {
+        process.env.AUTH_TOKEN = 'secret-key';
+        process.env.NODE_ENV = 'production';
+        const nextFn = jest.fn();
+        const resUnauthorized = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn().mockReturnThis(),
+        };
+        // Unauthorized call
+        (0, auth_1.requireAuth)(mockReq('wrong-token'), resUnauthorized, nextFn);
+        expect(resUnauthorized.status).toHaveBeenCalledWith(401);
+        expect(nextFn).not.toHaveBeenCalled();
+        // Authorized call
+        const resAuthorized = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn().mockReturnThis(),
+        };
+        (0, auth_1.requireAuth)(mockReq('secret-key'), resAuthorized, nextFn);
+        expect(nextFn).toHaveBeenCalled();
+    });
+});

package/dist/b0-b6.test.d.ts

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

package/dist/b0-b6.test.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const supertest_1 = __importDefault(require("supertest"));
+const app_1 = require("./app");
+const runtime_1 = require("./runtime");
+describe('T0 B0 & B6 Runtime Proof Suite', () => {
+    let mockBrain;
+    let mockMemory;
+    let mockKnowledge;
+    let mockBehavior;
+    let runtime;
+    let app;
+    beforeEach(async () => {
+        mockBrain = {
+            generatePlan: jest.fn().mockImplementation(async (ctx) => {
+                return {
+                    speech: 'Hello. I am a neutral companion.',
+                    language: 'en',
+                };
+            }),
+        };
+        mockMemory = {
+            initialize: jest.fn().mockResolvedValue(undefined),
+            searchClaims: jest.fn().mockResolvedValue([]),
+            getClaims: jest.fn().mockResolvedValue([]),
+            getDirectives: jest.fn().mockResolvedValue([]),
+            getPendingClaims: jest.fn().mockResolvedValue([]),
+            proposeClaim: jest.fn().mockResolvedValue({}),
+            approveClaim: jest.fn().mockResolvedValue(undefined),
+            rejectClaim: jest.fn().mockResolvedValue(undefined),
+        };
+        mockKnowledge = {
+            search: jest.fn().mockResolvedValue([]),
+        };
+        mockBehavior = {
+            compile: jest.fn().mockResolvedValue(''),
+        };
+        const config = {
+            name: 'NeutralCompanion',
+            brain: { provider: 'openrouter' },
+            memory: { provider: 'sqlite' },
+            knowledge: { provider: 'e-knowledge' },
+            behavior: { provider: 'active-self' },
+            voice: { provider: 'none' },
+            vision: { provider: 'none' },
+            body: { provider: 'none' },
+        };
+        runtime = new runtime_1.SiduriRuntime('companion-a', config, {
+            brain: mockBrain,
+            memory: mockMemory,
+            knowledge: mockKnowledge,
+            behavior: mockBehavior,
+        });
+        await runtime.initialize();
+        const runtimes = new Map([['companion-a', runtime]]);
+        const created = (0, app_1.createApp)(runtimes);
+        app = created.app;
+    });
+    // B0: Fresh companion is empty (no prior claims, no user relationship, no knowledge search on greeting)
+    describe('B0 — Fresh companion is empty', () => {
+        test('initial state has empty memory and empty directives', async () => {
+            const claims = await runtime.memory?.getClaims();
+            const directives = await runtime.memory?.getDirectives();
+            expect(claims).toEqual([]);
+            expect(directives).toEqual([]);
+        });
+        test('greeting does not query knowledge or inject prior personal knowledge', async () => {
+            const res = await (0, supertest_1.default)(app)
+                .post('/chat')
+                .send({
+                companionId: 'companion-a',
+                message: 'Hello.',
+                history: [],
+            });
+            expect(res.status).toBe(200);
+            expect(mockKnowledge.search).not.toHaveBeenCalled();
+            expect(mockBrain.generatePlan).toHaveBeenCalledWith(expect.objectContaining({
+                contextPrompt: '',
+                recipient: 'OWNER',
+            }));
+        });
+    });
+    // B6: Identity and relationship are learned, not inferred (self identity questions do not query external knowledge)
+    describe('B6 — Identity and relationship are learned, not inferred', () => {
+        test('asking "Who are you?" suppresses knowledge query and asserts self identity without external search', async () => {
+            mockBrain.generatePlan.mockResolvedValueOnce({
+                speech: 'I am NeutralCompanion.',
+                language: 'en',
+            });
+            const res = await (0, supertest_1.default)(app)
+                .post('/chat')
+                .send({
+                companionId: 'companion-a',
+                message: 'Who are you?',
+                history: [],
+            });
+            expect(res.status).toBe(200);
+            // B6 oracle: self identity chat does not query external knowledge
+            expect(mockKnowledge.search).not.toHaveBeenCalled();
+            expect(mockMemory.searchClaims).toHaveBeenCalled();
+            expect(mockBrain.generatePlan).toHaveBeenCalledWith(expect.objectContaining({
+                contextPrompt: '',
+            }));
+            expect(res.body.response.subtitle_en).toBe('I am NeutralCompanion.');
+        });
+        test('asking "Tell me about yourself" suppresses knowledge query', async () => {
+            const res = await (0, supertest_1.default)(app)
+                .post('/chat')
+                .send({
+                companionId: 'companion-a',
+                message: 'Tell me about yourself',
+                history: [],
+            });
+            expect(res.status).toBe(200);
+            expect(mockKnowledge.search).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/boot.d.ts

@@ -0,0 +1,91 @@
+import { OpenAICompatibleBrain } from '@sidurijs/brain';
+import { SqliteMemoryStore } from '@sidurijs/memory';
+import { VoiceAdapter, VoiceConfig } from '@sidurijs/voice';
+import { UnifiedKnowledgeOrgan, UnifiedKnowledgeConfig } from '@sidurijs/knowledge';
+import { OpenRouterVisionAdapter, OpenRouterVisionConfig } from '@sidurijs/vision';
+import { ActiveSelfCompiler, SqliteSelfRepository } from '@sidurijs/self';
+import { NeutralBodyOrganConfig } from '@sidurijs/body';
+import { FixtureObservationOrgan } from '@sidurijs/observation';
+import { DefaultHandsOrgan, DefaultHandsOrganConfig } from '@sidurijs/hands';
+import { DefaultEarOrgan, EarOrganConfig } from '@sidurijs/ear';
+import { DefaultMouthOrgan, DefaultMouthOrganConfig } from '@sidurijs/mouth';
+import { SiduriRuntime } from './runtime';
+export interface AppBrainConfig {
+    provider?: 'openrouter' | 'openai-compatible' | string;
+    model?: string;
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    [key: string]: unknown;
+}
+export interface AppBehaviorConfig {
+    provider?: 'active_self' | 'none' | string;
+    preset?: string;
+    [key: string]: unknown;
+}
+export interface AppBootCompanionConfig {
+    name: string;
+    id?: string;
+    brain?: AppBrainConfig;
+    voice?: VoiceConfig;
+    memory?: {
+        provider?: string;
+        connectionString?: string;
+        maxConnections?: number;
+        dbPath?: string;
+        [key: string]: unknown;
+    };
+    knowledge?: UnifiedKnowledgeConfig;
+    vision?: OpenRouterVisionConfig;
+    behavior?: AppBehaviorConfig;
+    body?: NeutralBodyOrganConfig;
+    hands?: DefaultHandsOrganConfig;
+    ear?: EarOrganConfig;
+    mouth?: DefaultMouthOrganConfig;
+    self?: {
+        dbPath?: string;
+        [key: string]: unknown;
+    };
+    organs?: Record<string, any>;
+    [key: string]: unknown;
+}
+export interface BootCompanionOptions {
+    observationOrgan?: FixtureObservationOrgan;
+}
+export declare function isDisabled(config?: {
+    provider?: string;
+}): boolean;
+export declare function createBrain(config?: AppBrainConfig): OpenAICompatibleBrain;
+export declare function createVoice(config?: VoiceConfig): VoiceAdapter | undefined;
+export declare function createKnowledge(config?: UnifiedKnowledgeConfig): UnifiedKnowledgeOrgan | undefined;
+export declare function createVision(config?: OpenRouterVisionConfig & {
+    provider?: string;
+}): OpenRouterVisionAdapter | undefined;
+export declare function createBehavior(config?: AppBehaviorConfig): ActiveSelfCompiler | undefined;
+export declare function createBody(config?: NeutralBodyOrganConfig): import("@sidurijs/body").NeutralBodyOrgan | undefined;
+export declare function createHands(config?: DefaultHandsOrganConfig & {
+    provider?: string;
+}): DefaultHandsOrgan;
+export declare function createEar(config?: EarOrganConfig & {
+    provider?: string;
+}): DefaultEarOrgan;
+export declare function createMouth(config?: DefaultMouthOrganConfig & {
+    provider?: string;
+}, voice?: any): DefaultMouthOrgan;
+export declare function createMemory(config?: {
+    provider?: string;
+    connectionString?: string;
+    maxConnections?: number;
+    dbPath?: string;
+}): SqliteMemoryStore | undefined;
+export declare function createSelf(config?: {
+    dbPath?: string;
+    provider?: string;
+}): SqliteSelfRepository | undefined;
+export declare function createObservation(vision?: any): FixtureObservationOrgan;
+/**
+ * Canonical companion bootstrapper.
+ * Wires all 10 organs, runs memory migrations, and initializes the SiduriRuntime.
+ */
+export declare function bootCompanion(id: string, config: AppBootCompanionConfig, options?: BootCompanionOptions): Promise<SiduriRuntime>;

package/dist/boot.js

@@ -0,0 +1,154 @@
+"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("@sidurijs/brain");
+const memory_1 = require("@sidurijs/memory");
+const voice_1 = require("@sidurijs/voice");
+const knowledge_1 = require("@sidurijs/knowledge");
+const vision_1 = require("@sidurijs/vision");
+const self_1 = require("@sidurijs/self");
+const body_1 = require("@sidurijs/body");
+const observation_1 = require("@sidurijs/observation");
+const hands_1 = require("@sidurijs/hands");
+const ear_1 = require("@sidurijs/ear");
+const mouth_1 = require("@sidurijs/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) {
+    if (isDisabled(config)) {
+        return undefined;
+    }
+    if (config?.provider === 'vrm' || config?.format === 'vrm') {
+        return new body_1.VRMAdapter(config);
+    }
+    return 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;
+    const defaultPath = process.env.NODE_ENV === 'test' ? ':memory:' : 'siduri.sqlite';
+    return new memory_1.SqliteMemoryStore({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || defaultPath });
+}
+function createSelf(config) {
+    if (isDisabled(config))
+        return undefined;
+    const defaultPath = process.env.NODE_ENV === 'test' ? ':memory:' : 'siduri.sqlite';
+    return new self_1.SqliteSelfRepository({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || defaultPath });
+}
+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), knowledge });
+    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,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const boot_1 = require("./boot");
+const observation_1 = require("@sidurijs/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 bodyNone = (0, boot_1.createBody)({ provider: 'none' });
+        expect(bodyNone).toBeUndefined();
+        const bodyLive2d = (0, boot_1.createBody)({ provider: 'live2d', modelPath: './assets/avatar.model3.json' });
+        expect(bodyLive2d).toBeDefined();
+        expect(bodyLive2d.format).toBe('live2d');
+        const bodyVrm = (0, boot_1.createBody)({ provider: 'vrm', modelPath: './assets/avatar.vrm', vrm: { lookAtMode: 'camera' } });
+        expect(bodyVrm).toBeDefined();
+        expect(bodyVrm.format).toBe('vrm');
+        expect(bodyVrm.vrmOptions?.lookAtMode).toBe('camera');
+        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();
+    });
+});