@siduri-x/core 1.0.8 → 2.0.0

package/dist/architecture-boundary.test.js

@@ -41,16 +41,14 @@ describe('Architecture: Core & Organ Package Boundaries (Phase 2)', () => {
     const corePackageJsonPath = path.resolve(__dirname, '../package.json');
     const EXPECTED_ORGANS = [
         { dir: 'brain', name: '@siduri-x/brain', organType: 'brain', configKey: 'brain' },
-        { dir: 'memory', name: '@siduri-x/memory', organType: 'memory', configKey: 'memory' },
-        { dir: 'knowledge', name: '@siduri-x/knowledge', organType: 'knowledge', configKey: 'knowledge' },
-        { dir: 'behavior', name: '@siduri-x/behavior', organType: 'behavior', configKey: 'behavior' },
         { dir: 'ear', name: '@siduri-x/ear', organType: 'ear', configKey: 'ear' },
+        { dir: 'voice', name: '@siduri-x/voice', organType: 'voice', configKey: 'voice' },
+        { dir: 'mouth', name: '@siduri-x/mouth', organType: 'mouth', configKey: 'mouth' },
         { dir: 'vision', name: '@siduri-x/vision', organType: 'vision', configKey: 'vision' },
         { dir: 'hands', name: '@siduri-x/hands', organType: 'hands', configKey: 'hands' },
         { dir: 'body', name: '@siduri-x/body', organType: 'body', configKey: 'body' },
-        { dir: 'voice', name: '@siduri-x/voice', organType: 'voice', configKey: 'voice' },
         { dir: 'observation', name: '@siduri-x/observation', organType: 'observation', configKey: 'observation' },
-        { dir: 'mouth', name: '@siduri-x/mouth', organType: 'mouth', configKey: 'mouth' },
+        { dir: 'eknowledge', name: '@siduri-x/eknowledge', organType: 'eknowledge', configKey: 'eknowledge' },
     ];
     it('package.json has zero dependencies on @siduri-x organ packages', () => {
         const pkg = JSON.parse(fs.readFileSync(corePackageJsonPath, 'utf8'));
@@ -78,7 +76,7 @@ describe('Architecture: Core & Organ Package Boundaries (Phase 2)', () => {
         }
         expect(forbiddenImports).toEqual([]);
     });
-    it('all 10 organ packages have a valid organ-manifest.json', () => {
+    it('all 9 peripheral organ packages have a valid organ-manifest.json', () => {
         for (const organ of EXPECTED_ORGANS) {
             const manifestPath = path.join(rootOrgansDir, organ.dir, 'organ-manifest.json');
             expect(fs.existsSync(manifestPath)).toBe(true);
@@ -108,10 +106,4 @@ describe('Architecture: Core & Organ Package Boundaries (Phase 2)', () => {
             }
         }
     });
-    it('memory organ packages SQL migrations', () => {
-        const memoryMigrationsDir = path.join(rootOrgansDir, 'memory', 'migrations');
-        expect(fs.existsSync(memoryMigrationsDir)).toBe(true);
-        const files = fs.readdirSync(memoryMigrationsDir).filter((f) => f.endsWith('.sql'));
-        expect(files.length).toBeGreaterThanOrEqual(1);
-    });
 });

package/dist/context-retriever.d.ts

@@ -1,4 +1,4 @@
-import { KnowledgeOrgan, MemoryOrgan, KnowledgeItem, Claim, BehaviorDirective, EvidenceRecord, ResponseCitation, RequestContext } from './index';
+import { KnowledgeOrgan, MemoryOrgan, KnowledgeItem, Claim, BehaviorDirective, EvidenceRecord, ResponseCitation, RequestContext, SelfRepository, LifeDatabase, EpisodicMemoryStore, EKnowledgeOrgan } from './index';
 export interface ContextRetrievalParams {
     companionId: string;
     perceivedText: string;
@@ -6,8 +6,10 @@ export interface ContextRetrievalParams {
     role: 'OWNER' | 'VIEWER' | 'OPERATOR';
     isContextObject: boolean;
     shouldQueryKnowledge: boolean;
-    knowledge?: KnowledgeOrgan;
-    memory?: MemoryOrgan;
+    knowledge?: KnowledgeOrgan | LifeDatabase;
+    memory?: MemoryOrgan | EpisodicMemoryStore;
+    self?: SelfRepository;
+    externalKnowledge?: EKnowledgeOrgan | KnowledgeOrgan;
 }
 export interface RetrievedContext {
     knowledgeData: KnowledgeItem[];
@@ -16,9 +18,10 @@ export interface RetrievedContext {
     subsystemDiagnostics: Record<string, string>;
     collectedEvidence: EvidenceRecord[];
     citations: ResponseCitation[];
+    lifeContext?: string[];
 }
 /**
- * Concurrently queries Knowledge and Memory organs with graceful degradation,
- * collecting diagnostics and synthesizing evidence records and citations.
+ * Concurrently queries Self, Knowledge (Life DB), External Knowledge, and Memory
+ * in a single parallel pass with graceful degradation.
  */
 export declare function retrieveRuntimeContext(params: ContextRetrievalParams): Promise<RetrievedContext>;

package/dist/context-retriever.js

@@ -2,41 +2,69 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.retrieveRuntimeContext = retrieveRuntimeContext;
 /**
- * Concurrently queries Knowledge and Memory organs with graceful degradation,
- * collecting diagnostics and synthesizing evidence records and citations.
+ * Concurrently queries Self, Knowledge (Life DB), External Knowledge, and Memory
+ * in a single parallel pass with graceful degradation.
  */
 async function retrieveRuntimeContext(params) {
-    const { companionId, perceivedText, requestContext, role, isContextObject, shouldQueryKnowledge, knowledge, memory, } = params;
+    const { companionId, perceivedText, requestContext, role, isContextObject, shouldQueryKnowledge, knowledge, memory, self, externalKnowledge, } = params;
     const queryOptions = isContextObject
         ? {
             limit: 5,
         }
         : role;
     const subsystemDiagnostics = {};
-    const [knowledgeData, memoryData, activeDirectives] = await Promise.all([
-        knowledge && shouldQueryKnowledge && typeof knowledge.search === 'function'
-            ? knowledge.search(perceivedText).catch((e) => {
+    // 1. Resolve External Knowledge organ (either explicitly passed or from legacy knowledge with .search)
+    const extKnowledge = externalKnowledge || (knowledge && typeof knowledge.search === 'function' ? knowledge : undefined);
+    // 2. Query all 4 streams in parallel
+    const [knowledgeData, memoryData, selfOrMemoryDirectives, lifeContext] = await Promise.all([
+        // Stream A: External Cited Lore / Documentation
+        extKnowledge && shouldQueryKnowledge && typeof extKnowledge.search === 'function'
+            ? extKnowledge.search(perceivedText).catch((e) => {
                 console.error('[SiduriRuntime] Knowledge search failed:', e.message);
                 subsystemDiagnostics['knowledge'] = `UNAVAILABLE: ${e.message}`;
                 return [];
             })
             : Promise.resolve([]),
+        // Stream B: Episodic Memory / Verified Claims (SQLite FTS5)
         memory && typeof memory.searchClaims === 'function'
-            ? memory.searchClaims(perceivedText, queryOptions, 5).catch((e) => {
-                console.error('[SiduriRuntime] Memory search failed:', e.message);
-                subsystemDiagnostics['memory_claims'] = `UNAVAILABLE: ${e.message}`;
+            ? (async () => {
+                try {
+                    // Support both (companionId, query, limit) and (query, options, limit)
+                    const result = await memory.searchClaims(perceivedText, queryOptions, 5);
+                    return result || [];
+                }
+                catch (e) {
+                    console.error('[SiduriRuntime] Memory search failed:', e.message);
+                    subsystemDiagnostics['memory_claims'] = `UNAVAILABLE: ${e.message}`;
+                    return [];
+                }
+            })()
+            : Promise.resolve([]),
+        // Stream C: Active Directives from Self (or fallback Memory)
+        self && typeof self.getActiveDirectives === 'function'
+            ? self.getActiveDirectives(companionId).catch((e) => {
+                console.error('[SiduriRuntime] Self directives failed:', e.message);
+                subsystemDiagnostics['self_directives'] = `UNAVAILABLE: ${e.message}`;
                 return [];
             })
-            : Promise.resolve([]),
-        memory && typeof memory.getDirectives === 'function'
-            ? memory.getDirectives().catch((e) => {
-                console.error('[SiduriRuntime] Memory directives failed:', e.message);
-                subsystemDiagnostics['memory_directives'] = `UNAVAILABLE: ${e.message}`;
+            : memory && typeof memory.getDirectives === 'function'
+                ? memory.getDirectives().catch((e) => {
+                    console.error('[SiduriRuntime] Memory directives failed:', e.message);
+                    subsystemDiagnostics['memory_directives'] = `UNAVAILABLE: ${e.message}`;
+                    return [];
+                })
+                : Promise.resolve([]),
+        // Stream D: Sovereign Life DB Context (Finances, Inventory, Schedule, Preferences)
+        knowledge && typeof knowledge.queryContext === 'function'
+            ? knowledge.queryContext(companionId, perceivedText).catch((e) => {
+                console.error('[SiduriRuntime] Life DB context failed:', e.message);
+                subsystemDiagnostics['life_db'] = `UNAVAILABLE: ${e.message}`;
                 return [];
             })
             : Promise.resolve([]),
     ]);
-    // Build evidence records from retrieved knowledge context
+    const activeDirectives = (selfOrMemoryDirectives || []);
+    // Build evidence records from retrieved external knowledge context
     const collectedEvidence = [];
     const citations = [];
     if (knowledgeData.length > 0) {
@@ -86,5 +114,6 @@ async function retrieveRuntimeContext(params) {
         subsystemDiagnostics,
         collectedEvidence,
         citations,
+        lifeContext,
     };
 }

package/dist/database.d.ts

@@ -0,0 +1 @@
+export * from './siduri-db';

package/dist/database.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./siduri-db"), exports);

package/dist/index.d.ts

@@ -22,6 +22,9 @@ export * from './action-executor';
 export * from './experience-emitter';
 export * from './response-envelope';
 export * from './session-history';
+export * from './schema-validator';
+export * from './siduri-db';
+export * from './database';
 import { EvidenceRecord } from './evidence';
 import { ActionIntent } from './action';
 import { RequestContext } from './context';
@@ -248,3 +251,38 @@ export interface HealthProbeResult {
 }
 export type HealthProbeFn = (context: HealthProbeContext) => Promise<HealthProbeResult> | HealthProbeResult;
 export * from './mouth-types';
+import type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, LifeInventoryItem, LifeScheduleItem, LifePreference, MemoryClaim, EpisodicEvent } from './siduri-db';
+export interface SelfRepository {
+    getIdentity(companionId: string): Promise<SelfIdentity | undefined>;
+    getPersonality(companionId: string): Promise<PersonalityTraits>;
+    getActiveDirectives(companionId: string): Promise<SelfDirective[]>;
+    getRelationship(companionId: string, entityId: string): Promise<SelfRelationship | null>;
+    commitDirectives(companionId: string, directives: SelfDirective[]): Promise<void>;
+    updateRelationship(companionId: string, rel: SelfRelationship): Promise<void>;
+    disableDirective?(id: string): Promise<void>;
+    getActiveSelf?(companionId: string): Promise<{
+        identity?: SelfIdentity;
+        personality: PersonalityTraits;
+        directives: SelfDirective[];
+    }>;
+}
+export interface LifeDatabase {
+    getInventory(companionId: string, domain?: string): Promise<LifeInventoryItem[]>;
+    getFinanceSummary?(companionId: string): Promise<any>;
+    getSchedule?(companionId: string, windowStart?: Date, windowEnd?: Date): Promise<LifeScheduleItem[]>;
+    getPreferences?(companionId: string): Promise<Record<string, string> | LifePreference[]>;
+    queryContext(companionId: string, query: string): Promise<string[]>;
+    searchLifeContext?(queryText: string): Promise<string[]>;
+}
+export interface EpisodicMemoryStore {
+    recordEvent(companionId: string, event: any): Promise<void>;
+    searchClaims(companionId: string, query: string, limit?: number): Promise<MemoryClaim[]>;
+    proposeClaim(claim: any): Promise<MemoryClaim>;
+    approveClaim(claimId: string): Promise<void>;
+    rejectClaim?(claimId: string): Promise<void>;
+    getApprovedClaims?(companionId: string, limit?: number): Promise<MemoryClaim[]>;
+    getRecentEvents?(companionId: string, limit?: number): Promise<EpisodicEvent[]>;
+}
+export interface EKnowledgeOrgan {
+    search(query: string): Promise<KnowledgeItem[]>;
+}

package/dist/index.js

@@ -39,5 +39,8 @@ __exportStar(require("./action-executor"), exports);
 __exportStar(require("./experience-emitter"), exports);
 __exportStar(require("./response-envelope"), exports);
 __exportStar(require("./session-history"), exports);
+__exportStar(require("./schema-validator"), exports);
+__exportStar(require("./siduri-db"), exports);
+__exportStar(require("./database"), exports);
 // Mouth (Communication & Output Delivery)
 __exportStar(require("./mouth-types"), exports);

package/dist/prompt-compiler.d.ts

@@ -9,6 +9,7 @@ export interface PromptCompilationParams {
     subsystemDiagnostics: Record<string, string>;
     knowledgeData: KnowledgeItem[];
     memoryData: Claim[];
+    lifeContext?: string[];
 }
 export interface CompiledPrompts {
     systemPrompt: string;

package/dist/prompt-compiler.js

@@ -5,7 +5,7 @@ exports.compilePrompts = compilePrompts;
  * Compiles neutral system prompt and formatted context prompt from structured data.
  */
 async function compilePrompts(params) {
-    const { companionName, companionId, role, requestContext, behavior, activeDirectives, subsystemDiagnostics, knowledgeData, memoryData, } = params;
+    const { companionName, companionId, role, requestContext, behavior, activeDirectives, subsystemDiagnostics, knowledgeData, memoryData, lifeContext, } = params;
     let contextPrompt = '';
     if (Object.keys(subsystemDiagnostics).length > 0) {
         contextPrompt +=
@@ -29,6 +29,12 @@ async function compilePrompts(params) {
                 memoryData.map((m) => `- ${m.subject} ${m.predicate} ${m.value}`).join('\n') +
                 '\n';
     }
+    if (lifeContext && lifeContext.length > 0) {
+        contextPrompt +=
+            'LIFE CONTEXT:\n' +
+                lifeContext.map((l) => `- ${l}`).join('\n') +
+                '\n';
+    }
     // Compile Behavior with neutral context metadata
     const behaviorInjections = behavior && typeof behavior.compile === 'function'
         ? await behavior.compile({

package/dist/runtime-facades.test.js

@@ -66,4 +66,30 @@ describe('SiduriRuntime Facade Methods & Delegation', () => {
         await runtime.resetMemory();
         expect(mockMemory.resetMemory).toHaveBeenCalled();
     });
+    test('configures SqliteActionStore when actionStore is sqlite', () => {
+        const runtime = new runtime_1.SiduriRuntime('comp-sqlite', {
+            id: 'comp-sqlite',
+            name: 'Sqlite Test',
+            actionStore: 'sqlite',
+        });
+        expect(runtime.actionPolicy.getStore()).toBeDefined();
+        // Verify it is an instance of SqliteActionStore
+        expect(runtime.actionPolicy.getStore().constructor.name).toBe('SqliteActionStore');
+    });
+    test('accepts custom actionStore via RuntimeOrgans', () => {
+        const customStore = {
+            recordExecution: jest.fn(),
+            getExecution: jest.fn(),
+            updateExecution: jest.fn(),
+            recordApproval: jest.fn(),
+            getApproval: jest.fn(),
+            recordAudit: jest.fn(),
+            getAuditLog: jest.fn(),
+            verifyAuditChain: jest.fn(),
+        };
+        const runtime = new runtime_1.SiduriRuntime('comp-custom', { id: 'comp-custom', name: 'Custom' }, {
+            actionStore: customStore,
+        });
+        expect(runtime.actionPolicy.getStore()).toBe(customStore);
+    });
 });

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, ObservationResult, Observation, Message, RequestContext, ActionPolicyEngine, ResponseGatingEngine, StageResponseOptions, ApproveResponseOptions, RejectResponseOptions, ExperienceDispatcher, ExperienceAdapter, OrganConfig, Claim, BehaviorDirective, StagedResponsePlan, ResponseGateEvaluation, EvidenceRecord, MouthOrgan, MouthUtterance, MouthMedium, FormattedMouthOutput, MouthStreamChunk, MouthChannel } from './index';
+import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, ObservationResult, Observation, Message, RequestContext, ActionPolicyEngine, ActionStore, ResponseGatingEngine, StageResponseOptions, ApproveResponseOptions, RejectResponseOptions, ExperienceDispatcher, ExperienceAdapter, OrganConfig, Claim, BehaviorDirective, StagedResponsePlan, ResponseGateEvaluation, EvidenceRecord, MouthOrgan, MouthUtterance, MouthMedium, FormattedMouthOutput, MouthStreamChunk, MouthChannel, SelfRepository, EKnowledgeOrgan } from './index';
 export interface SiduriRuntimeConfig {
     name: string;
     brain?: OrganConfig | Record<string, unknown>;
@@ -12,7 +12,14 @@ export interface SiduriRuntimeConfig {
     ear?: OrganConfig | Record<string, unknown>;
     observation?: OrganConfig | Record<string, unknown>;
     mouth?: OrganConfig | Record<string, unknown>;
+    self?: OrganConfig | Record<string, unknown>;
+    externalKnowledge?: OrganConfig | Record<string, unknown>;
     actionPolicy?: Record<string, unknown>;
+    actionStore?: 'in-memory' | 'sqlite' | {
+        type: 'sqlite' | 'in-memory';
+        dbPath?: string;
+    };
+    actionStorePath?: string;
     [key: string]: unknown;
 }
 export interface RuntimeOrgans {
@@ -27,6 +34,9 @@ export interface RuntimeOrgans {
     ear?: EarOrgan;
     observation?: ObservationOrgan;
     mouth?: MouthOrgan;
+    self?: SelfRepository;
+    externalKnowledge?: EKnowledgeOrgan;
+    actionStore?: ActionStore;
     actionPolicy?: ActionPolicyEngine;
 }
 export interface CompanionPerception {
@@ -59,6 +69,8 @@ export declare class SiduriRuntime {
     ear?: EarOrgan;
     observation?: ObservationOrgan;
     mouth?: MouthOrgan;
+    self?: SelfRepository;
+    externalKnowledge?: EKnowledgeOrgan;
     gating: ResponseGatingEngine;
     actionPolicy: ActionPolicyEngine;
     dispatcher: ExperienceDispatcher;

package/dist/runtime.js

@@ -31,6 +31,8 @@ class SiduriRuntime {
     ear;
     observation;
     mouth;
+    self;
+    externalKnowledge;
     gating;
     actionPolicy;
     dispatcher;
@@ -56,8 +58,20 @@ class SiduriRuntime {
         this.ear = organs.ear;
         this.observation = organs.observation;
         this.mouth = organs.mouth;
+        this.self = organs.self;
+        this.externalKnowledge = organs.externalKnowledge;
         this.gating = new index_1.ResponseGatingEngine();
-        this.actionPolicy = organs.actionPolicy || new index_1.ActionPolicyEngine();
+        let actionStore = organs.actionStore;
+        if (!actionStore) {
+            const storeOpt = config.actionStore;
+            const storePath = config.actionStorePath || (typeof storeOpt === 'object' ? storeOpt.dbPath : undefined);
+            if (storeOpt === 'sqlite' || (typeof storeOpt === 'object' && storeOpt.type === 'sqlite') || storePath) {
+                actionStore = new index_1.SqliteActionStore({ dbPath: storePath });
+            }
+        }
+        this.actionPolicy = organs.actionPolicy || new index_1.ActionPolicyEngine({
+            store: actionStore,
+        });
         this.dispatcher = new index_1.ExperienceDispatcher();
         if (this.voice && typeof this.voice.handleEvent === 'function') {
             this.dispatcher.registerAdapter(this.voice);
@@ -234,6 +248,8 @@ class SiduriRuntime {
             shouldQueryKnowledge: intent.shouldQueryKnowledge,
             knowledge: this.knowledge,
             memory: this.memory,
+            self: this.self,
+            externalKnowledge: this.externalKnowledge,
         });
         // 4. Neutral system prompt and contextual prompt compilation
         const prompts = await (0, prompt_compiler_1.compilePrompts)({
@@ -246,6 +262,7 @@ class SiduriRuntime {
             subsystemDiagnostics: contextRetrieval.subsystemDiagnostics,
             knowledgeData: contextRetrieval.knowledgeData,
             memoryData: contextRetrieval.memoryData,
+            lifeContext: contextRetrieval.lifeContext,
         });
         // 5. Cognition planning via BrainOrgan
         const plan = await (0, cognition_planner_1.generateCognitionPlan)({

package/dist/schema-validator.d.ts

@@ -0,0 +1,9 @@
+export declare class ConfigValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+/**
+ * Validates a companion configuration object against a JSON schema (draft-07 compatible).
+ * Throws ConfigValidationError if validation errors are detected.
+ */
+export declare function validateCompanionConfig(config: unknown, schema: any, path?: string): void;

package/dist/schema-validator.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidationError = void 0;
+exports.validateCompanionConfig = validateCompanionConfig;
+class ConfigValidationError extends Error {
+    errors;
+    constructor(errors) {
+        super(`Siduri configuration validation failed:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
+        this.name = 'ConfigValidationError';
+        this.errors = errors;
+    }
+}
+exports.ConfigValidationError = ConfigValidationError;
+/**
+ * Validates a companion configuration object against a JSON schema (draft-07 compatible).
+ * Throws ConfigValidationError if validation errors are detected.
+ */
+function validateCompanionConfig(config, schema, path = '$') {
+    const errors = [];
+    function validateNode(value, nodeSchema, curPath) {
+        if (!nodeSchema || typeof nodeSchema !== 'object')
+            return;
+        // Type validation
+        if (nodeSchema.type !== undefined) {
+            const type = nodeSchema.type;
+            if (type === 'object') {
+                if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                    errors.push(`${curPath}: expected object, received ${value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'array') {
+                if (!Array.isArray(value)) {
+                    errors.push(`${curPath}: expected array, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'string') {
+                if (typeof value !== 'string') {
+                    errors.push(`${curPath}: expected string, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'number') {
+                if (typeof value !== 'number' || Number.isNaN(value)) {
+                    errors.push(`${curPath}: expected number, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'integer') {
+                if (typeof value !== 'number' || !Number.isInteger(value)) {
+                    errors.push(`${curPath}: expected integer, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'boolean') {
+                if (typeof value !== 'boolean') {
+                    errors.push(`${curPath}: expected boolean, received ${typeof value}`);
+                    return;
+                }
+            }
+        }
+        // Enum validation
+        if (Array.isArray(nodeSchema.enum)) {
+            if (!nodeSchema.enum.includes(value)) {
+                errors.push(`${curPath}: invalid value ${JSON.stringify(value)}, expected one of: ${nodeSchema.enum.map((v) => JSON.stringify(v)).join(', ')}`);
+                return;
+            }
+        }
+        // Object properties validation
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            if (Array.isArray(nodeSchema.required)) {
+                for (const reqKey of nodeSchema.required) {
+                    if (value[reqKey] === undefined) {
+                        errors.push(`${curPath}.${reqKey}: is required`);
+                    }
+                }
+            }
+            const definedProps = nodeSchema.properties || {};
+            if (nodeSchema.additionalProperties === false) {
+                for (const key of Object.keys(value)) {
+                    // Allow $schema property at root level
+                    if (curPath === '$' && key === '$schema')
+                        continue;
+                    if (!(key in definedProps)) {
+                        errors.push(`${curPath}.${key}: unexpected property is not allowed`);
+                    }
+                }
+            }
+            for (const [propName, propSchema] of Object.entries(definedProps)) {
+                if (value[propName] !== undefined) {
+                    validateNode(value[propName], propSchema, `${curPath}.${propName}`);
+                }
+            }
+        }
+        // Array items validation
+        if (Array.isArray(value) && nodeSchema.items) {
+            value.forEach((item, index) => {
+                validateNode(item, nodeSchema.items, `${curPath}[${index}]`);
+            });
+        }
+    }
+    validateNode(config, schema, path);
+    if (errors.length > 0) {
+        throw new ConfigValidationError(errors);
+    }
+}

package/dist/schema-validator.test.d.ts

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

package/dist/schema-validator.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_validator_1 = require("./schema-validator");
+describe('validateCompanionConfig', () => {
+    const sampleSchema = {
+        type: 'object',
+        required: ['id', 'name', 'organs'],
+        additionalProperties: false,
+        properties: {
+            $schema: { type: 'string' },
+            id: { type: 'string' },
+            name: { type: 'string' },
+            organs: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    brain: {
+                        type: 'object',
+                        required: ['provider', 'model'],
+                        properties: {
+                            provider: {
+                                type: 'string',
+                                enum: ['openrouter', 'openai-compatible'],
+                            },
+                            model: { type: 'string' },
+                        },
+                    },
+                    memory: {
+                        type: 'object',
+                        required: ['provider'],
+                        properties: {
+                            provider: {
+                                type: 'string',
+                                enum: ['postgres', 'in-memory', 'none'],
+                            },
+                            maxConnections: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    test('accepts valid configuration matching schema', () => {
+        const validConfig = {
+            $schema: './siduri.schema.json',
+            id: 'companion-1',
+            name: 'Test Companion',
+            organs: {
+                brain: {
+                    provider: 'openrouter',
+                    model: 'gpt-4o',
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(validConfig, sampleSchema)).not.toThrow();
+    });
+    test('throws ConfigValidationError if missing required root field', () => {
+        const invalidConfig = {
+            name: 'Missing Id and Organs',
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.id: is required');
+            expect(err.errors).toContain('$.organs: is required');
+        }
+    });
+    test('throws ConfigValidationError on unexpected property when additionalProperties is false', () => {
+        const invalidConfig = {
+            id: 'c-1',
+            name: 'Test',
+            organs: {},
+            extraField: 'not allowed',
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.extraField: unexpected property is not allowed');
+        }
+    });
+    test('throws ConfigValidationError on invalid enum value', () => {
+        const invalidConfig = {
+            id: 'c-1',
+            name: 'Test',
+            organs: {
+                brain: {
+                    provider: 'invalid-brain-provider',
+                    model: 'gpt-4',
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors.some((e) => e.includes('invalid value "invalid-brain-provider"'))).toBe(true);
+        }
+    });
+    test('throws ConfigValidationError on invalid type', () => {
+        const invalidConfig = {
+            id: 12345, // should be string
+            name: 'Test',
+            organs: {
+                memory: {
+                    provider: 'postgres',
+                    maxConnections: 'ten', // should be number
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.id: expected string, received number');
+            expect(err.errors).toContain('$.organs.memory.maxConnections: expected number, received string');
+        }
+    });
+});