@siduri-x/core 1.0.9 → 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

@@ -23,6 +23,8 @@ 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';
@@ -249,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

@@ -40,5 +40,7 @@ __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.d.ts

@@ -1,4 +1,4 @@
-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 } 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,6 +12,8 @@ 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';
@@ -32,6 +34,8 @@ export interface RuntimeOrgans {
     ear?: EarOrgan;
     observation?: ObservationOrgan;
     mouth?: MouthOrgan;
+    self?: SelfRepository;
+    externalKnowledge?: EKnowledgeOrgan;
     actionStore?: ActionStore;
     actionPolicy?: ActionPolicyEngine;
 }
@@ -65,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,6 +58,8 @@ 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();
         let actionStore = organs.actionStore;
         if (!actionStore) {
@@ -244,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)({
@@ -256,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/siduri-db.d.ts

@@ -0,0 +1,119 @@
+export interface SelfIdentity {
+    companionId: string;
+    name: string;
+    archetype?: string;
+    version: string;
+    updatedAt: string;
+}
+export interface PersonalityTraits {
+    warmth: number;
+    formality: number;
+    sarcasm: number;
+    verbosity: number;
+    curiosity: number;
+}
+export interface SelfDirective {
+    id: string;
+    companionId: string;
+    priority: number;
+    directive: string;
+    status: 'ACTIVE' | 'DISABLED' | 'SUPERSEDED';
+    category: 'behavioral' | 'guardrail' | 'relational';
+    supersedesId?: string;
+    createdAt: string;
+}
+export interface SelfRelationship {
+    companionId: string;
+    entityId: string;
+    entityType: 'human' | 'companion' | 'system';
+    trustScore: number;
+    familiarity: number;
+    interactionConventions: string[];
+}
+export interface LifeInventoryItem {
+    id: string;
+    companionId: string;
+    domain: string;
+    entityName: string;
+    properties: Record<string, unknown>;
+    updatedAt: string;
+}
+export interface LifeFinanceEntry {
+    id: string;
+    companionId: string;
+    category: string;
+    amount: number;
+    currency: string;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LifeScheduleItem {
+    id: string;
+    companionId: string;
+    title: string;
+    startTime: string;
+    endTime?: string;
+    isRecurring: boolean;
+    status: string;
+}
+export interface LifePreference {
+    id: string;
+    companionId: string;
+    preferenceKey: string;
+    preferenceValue: string;
+    category: string;
+    updatedAt: string;
+}
+export interface EpisodicEvent {
+    id: string;
+    companionId: string;
+    sourceType: 'chat_turn' | 'tool_result' | 'sensory';
+    occurredAt: string;
+    payload: Record<string, unknown>;
+}
+export interface MemoryClaim {
+    id: string;
+    companionId: string;
+    subject: string;
+    predicate: string;
+    value: string;
+    status: 'PENDING' | 'APPROVED' | 'REJECTED';
+    confidence: number;
+    validFrom?: string;
+    validUntil?: string;
+    evidence?: string[];
+    assertedAt: string;
+}
+export interface SiduriDatabaseOptions {
+    dbPath?: string;
+}
+export declare class SiduriDatabase {
+    private db;
+    constructor(options?: SiduriDatabaseOptions);
+    private initSchema;
+    close(): void;
+    getIdentity(companionId: string): SelfIdentity | undefined;
+    setIdentity(identity: SelfIdentity): void;
+    getPersonality(companionId: string): PersonalityTraits | undefined;
+    setPersonality(companionId: string, traits: PersonalityTraits): void;
+    getActiveDirectives(companionId: string): SelfDirective[];
+    commitDirective(directive: SelfDirective): void;
+    disableDirective(id: string): void;
+    getRelationship(companionId: string, entityId: string): SelfRelationship | undefined;
+    upsertRelationship(rel: SelfRelationship): void;
+    getInventory(companionId: string, domain?: string): LifeInventoryItem[];
+    upsertInventoryItem(item: LifeInventoryItem): void;
+    getFinanceEntries(companionId: string, limit?: number): LifeFinanceEntry[];
+    addFinanceEntry(entry: LifeFinanceEntry): void;
+    getSchedule(companionId: string): LifeScheduleItem[];
+    upsertScheduleItem(item: LifeScheduleItem): void;
+    getPreferences(companionId: string): LifePreference[];
+    upsertPreference(pref: LifePreference): void;
+    recordEvent(event: EpisodicEvent): void;
+    getRecentEvents(companionId: string, limit?: number): EpisodicEvent[];
+    proposeClaim(claim: Omit<MemoryClaim, 'status'>): MemoryClaim;
+    approveClaim(id: string): void;
+    rejectClaim(id: string): void;
+    searchClaims(companionId: string, query: string, limit?: number): MemoryClaim[];
+    getApprovedClaims(companionId: string, limit?: number): MemoryClaim[];
+}