@siduri-x/core 1.0.9 → 2.0.1

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';
@@ -122,13 +124,15 @@ export interface MemoryOrgan {
     markClaimSessionOnly?(id: string): Promise<void>;
     expireClaim?(id: string): Promise<void>;
     revokeClaim?(id: string, reason?: string): Promise<void>;
-    getDirectives(): Promise<BehaviorDirective[]>;
-    proposeDirective(directiveData: Omit<BehaviorDirective, 'id' | 'status' | 'companionId'>): Promise<BehaviorDirective>;
-    approveDirective(id: string): Promise<void>;
-    rejectDirective(id: string): Promise<void>;
-    revokeDirective(id: string): Promise<void>;
-    disableDirective(id: string): Promise<void>;
-    expireDirective?(id: string): Promise<void>;
+    getDirectives(companionId?: string): Promise<BehaviorDirective[]>;
+    proposeDirective(directiveData: Omit<BehaviorDirective, 'id' | 'status' | 'companionId'> & {
+        companionId?: string;
+    }): Promise<BehaviorDirective>;
+    approveDirective(id: string, companionId?: string): Promise<void>;
+    rejectDirective(id: string, companionId?: string): Promise<void>;
+    revokeDirective(id: string, companionId?: string): Promise<void>;
+    disableDirective(id: string, companionId?: string): Promise<void>;
+    expireDirective?(id: string, companionId?: string): Promise<void>;
     supersedeClaim?(id: string, replacement: Omit<Claim, 'id' | 'status' | 'companionId'>): Promise<Claim>;
     updateClaim?(id: string, updates: Partial<Pick<Claim, 'subject' | 'predicate' | 'value' | 'scope' | 'sensitivity' | 'confidence' | 'validFrom' | 'validUntil'>>): Promise<Claim>;
     resetMemory?(): Promise<void>;
@@ -249,3 +253,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, ApproveActionOptions, ActionApprovalResult, 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;
@@ -85,10 +91,10 @@ export declare class SiduriRuntime {
     approveClaim(id: string): Promise<void>;
     rejectClaim(id: string): Promise<void>;
     updateClaim(id: string, updates: Partial<Pick<Claim, 'subject' | 'predicate' | 'value' | 'scope' | 'sensitivity' | 'confidence' | 'validFrom' | 'validUntil'>>): Promise<Claim>;
-    approveDirective(id: string): Promise<void>;
-    rejectDirective(id: string): Promise<void>;
-    revokeDirective(id: string): Promise<void>;
-    disableDirective(id: string): Promise<void>;
+    approveDirective(id: string, companionId?: string): Promise<void>;
+    rejectDirective(id: string, companionId?: string): Promise<void>;
+    revokeDirective(id: string, companionId?: string): Promise<void>;
+    disableDirective(id: string, companionId?: string): Promise<void>;
     resetMemory(): Promise<void>;
     stageResponse(options: StageResponseOptions): StagedResponsePlan;
     evaluateGate(plan: StagedResponsePlan, evidenceRecords?: EvidenceRecord[]): ResponseGateEvaluation;
@@ -102,6 +108,7 @@ export declare class SiduriRuntime {
         reason?: string;
         plan?: StagedResponsePlan;
     };
+    approveAction(options: ApproveActionOptions): Promise<ActionApprovalResult>;
     getStagedPlan(responseId: string): StagedResponsePlan | undefined;
     findStagedPlanByCorrelation(companionId: string, correlationId: string): StagedResponsePlan | undefined;
     /**

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) {
@@ -159,29 +163,37 @@ class SiduriRuntime {
         }
         return this.memory.updateClaim(id, updates);
     }
-    async approveDirective(id) {
+    async approveDirective(id, companionId) {
         if (!this.memory || typeof this.memory.approveDirective !== 'function') {
             throw new Error('Memory organ not configured');
         }
-        return this.memory.approveDirective(id);
+        return companionId !== undefined
+            ? this.memory.approveDirective(id, companionId)
+            : this.memory.approveDirective(id);
     }
-    async rejectDirective(id) {
+    async rejectDirective(id, companionId) {
         if (!this.memory || typeof this.memory.rejectDirective !== 'function') {
             throw new Error('Memory organ not configured');
         }
-        return this.memory.rejectDirective(id);
+        return companionId !== undefined
+            ? this.memory.rejectDirective(id, companionId)
+            : this.memory.rejectDirective(id);
     }
-    async revokeDirective(id) {
+    async revokeDirective(id, companionId) {
         if (!this.memory || typeof this.memory.revokeDirective !== 'function') {
             throw new Error('Memory organ not configured');
         }
-        return this.memory.revokeDirective(id);
+        return companionId !== undefined
+            ? this.memory.revokeDirective(id, companionId)
+            : this.memory.revokeDirective(id);
     }
-    async disableDirective(id) {
+    async disableDirective(id, companionId) {
         if (!this.memory || typeof this.memory.disableDirective !== 'function') {
             throw new Error('Memory organ not configured');
         }
-        return this.memory.disableDirective(id);
+        return companionId !== undefined
+            ? this.memory.disableDirective(id, companionId)
+            : this.memory.disableDirective(id);
     }
     async resetMemory() {
         if (!this.memory || typeof this.memory.resetMemory !== 'function') {
@@ -202,6 +214,9 @@ class SiduriRuntime {
     rejectResponse(options) {
         return this.gating.rejectResponse(options);
     }
+    async approveAction(options) {
+        return this.actionPolicy.approveAction(options);
+    }
     getStagedPlan(responseId) {
         return this.gating.getStagedPlan(responseId);
     }
@@ -244,6 +259,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 +273,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.test.js

@@ -31,7 +31,7 @@ describe('validateCompanionConfig', () => {
                         properties: {
                             provider: {
                                 type: 'string',
-                                enum: ['postgres', 'in-memory', 'none'],
+                                enum: ['sqlite', 'in-memory', 'none'],
                             },
                             maxConnections: { type: 'number' },
                         },
@@ -107,7 +107,7 @@ describe('validateCompanionConfig', () => {
             name: 'Test',
             organs: {
                 memory: {
-                    provider: 'postgres',
+                    provider: 'sqlite',
                     maxConnections: 'ten', // should be number
                 },
             },

package/dist/siduri-db.d.ts

@@ -0,0 +1,138 @@
+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: 'PENDING' | 'ACTIVE' | 'DISABLED' | 'SUPERSEDED' | 'REJECTED' | 'REVOKED' | 'EXPIRED';
+    category: 'behavioral' | 'guardrail' | 'relational' | string;
+    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' | 'SESSION_ONLY' | 'SUPERSEDED' | 'REVOKED' | 'EXPIRED';
+    confidence: number;
+    validFrom?: string;
+    validUntil?: string;
+    evidence?: string[];
+    assertedAt: string;
+    supersedes?: string;
+    sourceEventId?: 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;
+    getDirective(id: string, companionId?: string): SelfDirective | undefined;
+    approveDirective(id: string, companionId?: string): void;
+    rejectDirective(id: string, companionId?: string): void;
+    revokeDirective(id: string, companionId?: string): void;
+    expireDirective(id: string, companionId?: string): void;
+    disableDirective(id: string, companionId?: 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[];
+    getEvent(id: string): EpisodicEvent | undefined;
+    proposeClaim(claim: Omit<MemoryClaim, 'status' | 'confidence' | 'assertedAt'> & {
+        confidence?: number;
+        assertedAt?: string;
+        supersedes?: string;
+        sourceEventId?: string;
+    }): MemoryClaim;
+    approveClaim(id: string, companionId?: string): void;
+    rejectClaim(id: string, companionId?: string): void;
+    revokeClaim(id: string, companionId?: string): void;
+    expireClaim(id: string, companionId?: string): void;
+    markClaimSessionOnly(id: string, companionId?: string): void;
+    searchClaims(companionId: string, query: string, limit?: number): MemoryClaim[];
+    getPendingClaims(companionId: string, limit?: number): MemoryClaim[];
+    getApprovedClaims(companionId: string, limit?: number): MemoryClaim[];
+    getClaim(id: string): MemoryClaim | undefined;
+    resetMemory(companionId: string): void;
+}