@sidurijs/core 1.0.0 → 1.0.2

package/dist/conversational-teach.test.js

@@ -81,18 +81,31 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         };
     }
     /**
-     * Helper to build a MemoryOrgan wrapping a SiduriDatabase
+     * Helper to build a MemoryOrgan wrapping a SiduriDatabase & local claim mock
      */
     function createMemoryOrgan(db) {
+        const claims = [];
         return {
             initialize: async () => { },
-            proposeClaim: async (claim) => db.proposeClaim(claim),
+            proposeClaim: async (claim) => {
+                const c = { id: claim.id || `claim-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`, status: 'pending', ...claim };
+                claims.push(c);
+                return c;
+            },
             searchClaims: async () => [],
-            getApprovedClaims: async (companionId, limit) => db.getApprovedClaims(companionId || 'default', limit || 50),
-            getClaims: async (limit) => db.getAllClaims(undefined, limit || 500),
-            getPendingClaims: async (limit) => db.getAllClaims(undefined, limit || 500).filter((c) => c.status === 'pending'),
-            approveClaim: async (id) => db.approveClaim(id),
-            rejectClaim: async (id) => db.rejectClaim(id),
+            getApprovedClaims: async (companionId, limit) => claims.filter((c) => c.status === 'approved').slice(0, limit || 50),
+            getClaims: async (limit) => claims.slice(0, limit || 500),
+            getPendingClaims: async (limit) => claims.filter((c) => c.status === 'pending').slice(0, limit || 500),
+            approveClaim: async (id) => {
+                const found = claims.find((c) => c.id === id);
+                if (found)
+                    found.status = 'approved';
+            },
+            rejectClaim: async (id) => {
+                const found = claims.find((c) => c.id === id);
+                if (found)
+                    found.status = 'rejected';
+            },
             getDirectives: async (companionId) => db.getActiveDirectives(companionId || 'default'),
             proposeDirective: async (dir) => {
                 const id = `dir-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
@@ -159,10 +172,10 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         return {
             generatePlan: jest.fn().mockImplementation(async (brainCtx) => {
                 const lastMsg = brainCtx.recentMessages?.[brainCtx.recentMessages.length - 1]?.content || '';
-                const memoryProposals = [];
+                const claimProposals = [];
                 const behaviorProposals = [];
                 if (/AI researcher at VXNUS Studio/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: `companion:${companionId}`,
                         predicate: 'role',
                         value: 'AI researcher at VXNUS Studio',
@@ -176,35 +189,35 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
                     });
                 }
                 else if (/Lead Architect at VXNUS Studio/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: `companion:${companionId}`,
                         predicate: 'role',
                         value: 'Lead Architect at VXNUS Studio',
                     });
                 }
                 else if (/Research Specialist/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: `companion:${companionId}`,
                         predicate: 'role',
                         value: 'Research Specialist',
                     });
                 }
                 else if (/Security Officer/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: `companion:${companionId}`,
                         predicate: 'role',
                         value: 'Security Officer',
                     });
                 }
                 else if (/VXNUS Studio Staff/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: `companion:${companionId}`,
                         predicate: 'role',
                         value: 'VXNUS Studio Staff',
                     });
                 }
                 if (/\bcreator\b/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: 'actor:kur-zagin',
                         predicate: 'stated_relationship',
                         value: 'creator',
@@ -219,7 +232,7 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
                     });
                 }
                 if (/Kur Zagin/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: 'actor:kur-zagin',
                         predicate: 'name',
                         value: 'Kur Zagin',
@@ -239,7 +252,7 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
                         category: 'behavioral',
                         priority: 60,
                     });
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: 'actor:kur-zagin',
                         predicate: 'rule',
                         value: 'Be concise when answering technical questions',
@@ -248,7 +261,7 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
                 return {
                     speech: 'Understood, I have acknowledged your input.',
                     language: 'en',
-                    memoryProposals: memoryProposals.length > 0 ? memoryProposals : undefined,
+                    claimProposals: claimProposals.length > 0 ? claimProposals : undefined,
                     behaviorProposals: behaviorProposals.length > 0 ? behaviorProposals : undefined,
                     _receivedSystemPrompt: brainCtx.systemPrompt,
                 };
@@ -376,7 +389,6 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         const mockBrain = createCognitiveMockBrain(companionId);
         const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
             brain: mockBrain,
-            memory,
             self,
             behavior,
         });
@@ -387,14 +399,14 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
             text: 'Remember this rule: be concise when answering technical questions.',
             context: createRequestContext(companionId, 'teach'),
         });
-        // Check behavioral proposals or memory proposals
+        // Check behavioral proposals or claim proposals
         const behavioralReceipts = perceptionResult.metadata?.behavioral_proposals || [];
-        const memoryProposals = perceptionResult.metadata?.proposals || [];
+        const claimProposals = perceptionResult.metadata?.proposals || [];
         const hasDirectiveProposal = behavioralReceipts.length > 0 ||
-            memoryProposals.some((p) => p.predicate === 'rule' || p.predicate === 'behavioral_rule');
+            claimProposals.some((p) => p.predicate === 'rule' || p.predicate === 'behavioral_rule');
         expect(hasDirectiveProposal).toBe(true);
         const directiveId = behavioralReceipts[0]?.directive_id;
-        const proposalId = memoryProposals[0]?.id;
+        const proposalId = claimProposals[0]?.id;
         // 2. Active directives before approval must not include the new rule
         const directivesBefore = await self.getActiveDirectives(companionId);
         expect(directivesBefore.some((d) => d.directive.toLowerCase().includes('be concise when answering technical questions'))).toBe(false);
@@ -426,7 +438,6 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         };
         const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
             brain: mockBrain,
-            memory,
             self,
         });
         await runtime.initialize();
@@ -439,7 +450,7 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         expect(perceptionResult.status).toBe('APPROVED');
         // Zero proposals allowed in casual mode
         expect(perceptionResult.metadata?.proposals).toEqual([]);
-        expect(perceptionResult.metadata?.memory_proposals).toEqual([]);
+        expect(perceptionResult.metadata?.claim_proposals).toEqual([]);
         // Self must remain unchanged
         const identity = await self.getIdentity(companionId);
         expect(identity?.role).toBeUndefined();
@@ -459,7 +470,6 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         const mockBrain = createCognitiveMockBrain(companionId);
         const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
             brain: mockBrain,
-            memory,
             self,
         });
         await runtime.initialize();
@@ -656,10 +666,10 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         const mockBrain = {
             generatePlan: jest.fn().mockImplementation(async (brainCtx) => {
                 const lastMsg = brainCtx.recentMessages?.[brainCtx.recentMessages.length - 1]?.content || '';
-                const memoryProposals = [];
+                const claimProposals = [];
                 const behaviorProposals = [];
                 if (/your name is Siduri/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: 'companion:self',
                         predicate: 'name',
                         value: 'Siduri',
@@ -673,12 +683,12 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
                     });
                 }
                 if (/i am Kur Zagin, your creator/i.test(lastMsg)) {
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: 'actor:kur_zagin',
                         predicate: 'name',
                         value: 'Kur Zagin',
                     });
-                    memoryProposals.push({
+                    claimProposals.push({
                         subject: 'actor:kur_zagin',
                         predicate: 'stated_relationship',
                         value: 'creator of companion Siduri',
@@ -701,7 +711,7 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
                 return {
                     speech: 'I understand and acknowledge.',
                     language: 'en',
-                    memoryProposals: memoryProposals.length > 0 ? memoryProposals : undefined,
+                    claimProposals: claimProposals.length > 0 ? claimProposals : undefined,
                     behaviorProposals: behaviorProposals.length > 0 ? behaviorProposals : undefined,
                     _receivedSystemPrompt: brainCtx.systemPrompt,
                 };
@@ -809,7 +819,7 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
             context: createRequestContext(companionId, 'hybrid', 'owner-user'),
         });
         const whoAmICtx = calls[calls.length - 1][0];
-        expect(whoAmICtx.contextPrompt).toContain('MEMORY:');
+        expect(whoAmICtx.contextPrompt).toContain('ARCHIVE:');
         expect(whoAmICtx.contextPrompt).toContain('Kur Zagin');
         db.close();
     });
@@ -841,48 +851,47 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
             initialMode: 'teach',
         }, {
             self,
-            memory,
             knowledge: mockKnowledge,
         });
-        // 1. Propose knowledge claims in memory store (quarantined as PENDING)
-        const entityClaim = await memory.proposeClaim({
+        // 1. Propose knowledge claims (quarantined as PENDING)
+        const entityClaim = {
+            id: 'claim-ent-1',
             companionId,
             subject: 'entity:Workstation Rig',
             predicate: 'inventory',
             value: 'Threadripper 64-core',
             claimType: 'life_entity',
             evidence: { domain: 'hardware', properties: { cores: 64, ram: '256GB' } },
-        });
-        const eventClaim = await memory.proposeClaim({
+        };
+        const eventClaim = {
+            id: 'claim-evt-1',
             companionId,
             subject: 'finance:expense',
             predicate: 'expense',
             value: '45.00',
             claimType: 'life_event',
             evidence: { metricValue: -45.0, stream: 'finance', category: 'dining' },
-        });
-        const taskClaim = await memory.proposeClaim({
+        };
+        const taskClaim = {
+            id: 'claim-task-1',
             companionId,
             subject: 'task:Review PR',
             predicate: 'todo',
             value: 'Review PR #42 for Life DB',
             claimType: 'life_task',
             evidence: { status: 'in_progress' },
-        });
+        };
         // Before approval, Life DB tables in sqlite are empty
         expect(db.getEntities(companionId)).toHaveLength(0);
         expect(db.getEvents(companionId)).toHaveLength(0);
         expect(db.getTasks(companionId)).toHaveLength(0);
         // 2. Truth Gate Approval
-        const resEntity = await runtime.approveProposal(entityClaim.id, { companionId });
-        expect(resEntity.success).toBe(true);
-        expect(resEntity.target).toBe('knowledge');
-        const resEvent = await runtime.approveProposal(eventClaim.id, { companionId });
-        expect(resEvent.success).toBe(true);
-        expect(resEvent.target).toBe('knowledge');
-        const resTask = await runtime.approveProposal(taskClaim.id, { companionId });
-        expect(resTask.success).toBe(true);
-        expect(resTask.target).toBe('knowledge');
+        const resEntity = await (0, index_1.promoteApprovedClaimToKnowledge)(entityClaim, mockKnowledge, companionId);
+        expect(resEntity).toBe(true);
+        const resEvent = await (0, index_1.promoteApprovedClaimToKnowledge)(eventClaim, mockKnowledge, companionId);
+        expect(resEvent).toBe(true);
+        const resTask = await (0, index_1.promoteApprovedClaimToKnowledge)(taskClaim, mockKnowledge, companionId);
+        expect(resTask).toBe(true);
         // 3. Verify persistent commit to sovereign Life DB in SQLite
         const entities = db.getEntities(companionId);
         expect(entities).toHaveLength(1);
@@ -901,10 +910,8 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
     it('updates companion identity name dynamically when companion naming claim or directive is approved', async () => {
         const companionId = 'dynamic-companion';
         const db = new index_1.SiduriDatabase({ dbPath: ':memory:' });
-        const memory = createMemoryOrgan(db);
         const self = createSelfRepository(db);
         const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
-            memory,
             self,
         });
         await runtime.initialize();
@@ -912,14 +919,15 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         const initialIdentity = await self.getIdentity(companionId);
         expect(initialIdentity?.name || 'Siduri').toBe('Siduri');
         // 1. Propose and approve claim with subject "assistant" and predicate "name"
-        const nameClaim = await memory.proposeClaim({
+        const nameClaim = {
+            id: 'claim-name-1',
             companionId,
             subject: 'assistant',
             predicate: 'name',
             value: 'Athena',
             claimType: 'semantic',
-        });
-        await runtime.approveProposal(nameClaim.id, { companionId });
+        };
+        await (0, index_1.promoteApprovedClaimToSelf)(nameClaim, self, companionId);
         const identityAfterClaim = await self.getIdentity(companionId);
         expect(identityAfterClaim?.name).toBe('Athena');
         // 2. Propose and approve behavioral directive "Address companion as Athena Prime"

package/dist/evidence.d.ts

@@ -1,5 +1,5 @@
-import { MemoryProposal, BehaviorProposal } from './proposals';
-export type EvidenceOrigin = 'knowledge' | 'memory' | 'life' | 'observation' | 'ocr' | 'platform' | 'conversation';
+import { ClaimProposal, BehaviorProposal } from './proposals';
+export type EvidenceOrigin = 'knowledge' | 'archive' | 'life' | 'observation' | 'ocr' | 'platform' | 'conversation';
 export type EvidenceTrust = 'configured' | 'provider' | 'untrusted';
 export type EvidenceSensitivity = 'public' | 'private' | 'restricted';
 export interface EvidenceRecord {
@@ -47,7 +47,7 @@ export interface StagedResponsePlan {
     status: ResponseApprovalStatus;
     createdAt: string;
     expiresAt?: string;
-    memoryProposals?: MemoryProposal[];
+    claimProposals?: ClaimProposal[];
     behaviorProposals?: BehaviorProposal[];
     internalMonologue?: string;
     [key: string]: unknown;

package/dist/gating.d.ts

@@ -1,12 +1,12 @@
 import { RequestContext } from './context';
-import { MemoryProposal, BehaviorProposal } from './proposals';
+import { ClaimProposal, BehaviorProposal } from './proposals';
 import { EvidenceRecord, StagedResponsePlan, ResponseGateEvaluation, ResponseCitation } from './evidence';
 export interface StageResponseOptions {
     requestContext: RequestContext;
     candidateSpeech: string;
     candidateLanguage: string;
     internalMonologue?: string;
-    memoryProposals?: MemoryProposal[];
+    claimProposals?: ClaimProposal[];
     behaviorProposals?: BehaviorProposal[];
     evidenceRecords?: EvidenceRecord[];
     citations?: ResponseCitation[];

package/dist/gating.js

@@ -50,7 +50,7 @@ class ResponseGatingEngine {
             status: 'STAGED',
             createdAt: new Date(nowTime).toISOString(),
             expiresAt,
-            memoryProposals: options.memoryProposals,
+            claimProposals: options.claimProposals,
             behaviorProposals: options.behaviorProposals,
             internalMonologue: options.internalMonologue,
         };

package/dist/index.d.ts

@@ -17,7 +17,7 @@ export * from './intent-classifier';
 export * from './context-retriever';
 export * from './prompt-compiler';
 export * from './cognition-planner';
-export * from './memory-settler';
+export * from './interaction-settler';
 export * from './action-executor';
 export * from './experience-emitter';
 export * from './response-envelope';
@@ -31,7 +31,7 @@ import { EvidenceRecord } from './evidence';
 import { ActionIntent } from './action';
 import { RequestContext } from './context';
 import { EarIngestOptions } from './ear-types';
-import { ClaimType, ClaimAuthority, ClaimStatus, DirectiveStatus, SourceEvent, MemoryProposal, BehaviorProposal } from './proposals';
+import { ClaimType, ClaimAuthority, ClaimStatus, DirectiveStatus, SourceEvent, ClaimProposal, BehaviorProposal } from './proposals';
 export interface OrganConfig {
     provider: string;
     [key: string]: unknown;
@@ -41,7 +41,7 @@ export interface CompanionConfig {
     name: string;
     brain: OrganConfig;
     voice: OrganConfig;
-    memory: OrganConfig;
+    archive: OrganConfig;
     knowledge: OrganConfig;
     behavior: OrganConfig;
     body: OrganConfig;
@@ -56,14 +56,14 @@ export interface BrainContext {
     systemPrompt: string;
     contextPrompt: string;
     recentMessages: Message[];
-    recipient?: MemoryScope;
+    recipient?: ClaimScope;
 }
 export interface ResponsePlan {
     speech: string;
     language: string;
     subtitle?: string;
     subtitles?: Record<string, string>;
-    memoryProposals?: MemoryProposal[];
+    claimProposals?: ClaimProposal[];
     behaviorProposals?: BehaviorProposal[];
     actionIntents?: ActionIntent[];
     internalMonologue?: string;
@@ -71,8 +71,8 @@ export interface ResponsePlan {
 export interface RetrievalPlan {
     shouldQueryKnowledge: boolean;
     knowledgeQueries: string[];
-    shouldQueryMemory?: boolean;
-    memoryQueries?: string[];
+    shouldQueryArchive?: boolean;
+    archiveQueries?: string[];
     reasoning?: string;
 }
 export interface PersonaCompilationResult {
@@ -126,7 +126,7 @@ export interface BrainOrgan {
         companionId?: string;
     }): Promise<PersonaCompilationResult>;
 }
-export type MemoryScope = 'companion' | 'user' | string;
+export type ClaimScope = 'companion' | 'user' | string;
 export interface Claim {
     id: string;
     subject: string;
@@ -134,7 +134,7 @@ export interface Claim {
     value: string;
     status: ClaimStatus;
     evidence?: string[];
-    scope?: MemoryScope;
+    scope?: ClaimScope;
     companionId: string;
     provenance?: string;
     sourceEventId?: string;
@@ -157,7 +157,6 @@ export interface BehaviorDirective {
     priority: number;
     status: DirectiveStatus;
     supersedesId?: string;
-    memoryClass?: 'identity' | 'relationship' | 'behavioral';
     subject?: string;
     predicate?: string;
     value?: string;
@@ -165,39 +164,41 @@ export interface BehaviorDirective {
     validUntil?: string;
     [key: string]: unknown;
 }
-export interface MemoryQueryOptions {
-    sensitivity?: string;
+export interface ArchiveEvent {
+    id: string;
+    companionId: string;
+    sourceType: string;
+    occurredAt: string;
+    payload: Record<string, unknown>;
+}
+export interface ArchiveQueryOptions {
     limit?: number;
-    minConfidence?: number;
-    now?: string | Date;
+    sourceType?: string;
+    since?: string;
+    until?: string;
     [key: string]: unknown;
 }
-export interface MemoryOrgan {
-    initialize(companionId: string): Promise<void>;
-    proposeClaim(claim: Omit<Claim, 'id' | 'status' | 'companionId'>): Promise<Claim>;
-    searchClaims(query: string, scopeOrOptions?: MemoryScope | MemoryQueryOptions, limit?: number): Promise<Claim[]>;
-    getClaims(limit?: number): Promise<Claim[]>;
-    getPendingClaims(limit?: number): Promise<Claim[]>;
-    getApprovedClaims?(companionId?: string, limit?: number): Promise<any[]>;
-    approveClaim(id: string): Promise<void>;
-    rejectClaim(id: string): Promise<void>;
-    markClaimSessionOnly?(id: string): Promise<void>;
-    expireClaim?(id: string): Promise<void>;
-    revokeClaim?(id: string, reason?: 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>;
-    addSourceEvent?(event: SourceEvent): Promise<SourceEvent>;
-    getSourceEvent?(id: string): Promise<SourceEvent | undefined>;
+/**
+ * Sovereign interaction archive: cold, append-only interaction audit ledger and full-text search.
+ * Replaces the overloaded 'Memory' metaphor for audit trails, past tool runs, and historical interaction logs.
+ */
+export interface ArchiveLedger {
+    recordEvent(event: ArchiveEvent | SourceEvent): Promise<ArchiveEvent | SourceEvent>;
+    getRecentEvents(companionId: string, limit?: number): Promise<ArchiveEvent[]>;
+    getEvent?(id: string): Promise<ArchiveEvent | undefined>;
+    searchEvents?(companionId: string, query: string, limit?: number): Promise<ArchiveEvent[]>;
+    close?(): void;
+}
+export type ArchiveStore = ArchiveLedger;
+export type EpisodicLedger = ArchiveLedger;
+/**
+ * Active dialogue continuity interface for working conversational context.
+ */
+export interface DialogueHistory {
+    getHistory(sessionKey?: string): Message[];
+    setHistory(sessionKey: string, history: Message[]): void;
+    append(sessionKey: string, message: Message): void;
+    clear(sessionKey?: string): void;
 }
 export interface AudioEvent {
     type: 'STARTED' | 'COMPLETED' | 'FAILED';
@@ -313,8 +314,8 @@ export interface HealthProbeResult {
 }
 export type HealthProbeFn = (context: HealthProbeContext) => Promise<HealthProbeResult> | HealthProbeResult;
 export * from './mouth-types';
-import type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, SelfDialogueExample, LifeInventoryItem, LifeScheduleItem, LifePreference, LifeEntity, LifeEvent, LifeTask, MemoryClaim, EpisodicEvent } from './siduri-db';
-export type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, SelfDialogueExample, LifeInventoryItem, LifeScheduleItem, LifePreference, LifeEntity, LifeEvent, LifeTask, MemoryClaim, EpisodicEvent, };
+import type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, SelfDialogueExample, LifeInventoryItem, LifeScheduleItem, LifePreference, LifeEntity, LifeEvent, LifeTask, ClaimRecord, MemoryClaim, EpisodicEvent } from './siduri-db';
+export type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, SelfDialogueExample, LifeInventoryItem, LifeScheduleItem, LifePreference, LifeEntity, LifeEvent, LifeTask, ClaimRecord, MemoryClaim, EpisodicEvent, };
 export interface SelfRepository {
     getIdentity(companionId: string): Promise<SelfIdentity | undefined>;
     setIdentity(identity: SelfIdentity): Promise<void>;
@@ -351,15 +352,6 @@ export interface LifeDatabase {
     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

@@ -35,7 +35,7 @@ __exportStar(require("./intent-classifier"), exports);
 __exportStar(require("./context-retriever"), exports);
 __exportStar(require("./prompt-compiler"), exports);
 __exportStar(require("./cognition-planner"), exports);
-__exportStar(require("./memory-settler"), exports);
+__exportStar(require("./interaction-settler"), exports);
 __exportStar(require("./action-executor"), exports);
 __exportStar(require("./experience-emitter"), exports);
 __exportStar(require("./response-envelope"), exports);

package/dist/intent-classifier.d.ts

@@ -9,7 +9,7 @@ export interface IntentClassification {
     shouldQueryKnowledge: boolean;
     knowledgeQueries?: string[];
     primaryQuery?: string;
-    memoryQueries?: string[];
+    archiveQueries?: string[];
     effectiveMode: InteractionMode;
     confidence?: number;
     classifierOrigin?: 'heuristic' | 'cognitive' | 'ear' | 'brain';

package/dist/intent-classifier.js

@@ -93,12 +93,12 @@ function classifyInputIntent(text, context, overrides) {
         ? Array.from(new Set([...aiKnowledgeQueries, ...rawKeywords]))
         : (shouldQueryKnowledge ? rawKeywords : []);
     const primaryQuery = knowledgeQueries[0] || (shouldQueryKnowledge ? text.trim() : undefined);
-    const memoryQueries = (overrides?.memoryQueries && overrides.memoryQueries.length > 0)
-        ? overrides.memoryQueries
+    const archiveQueries = (overrides?.archiveQueries && overrides.archiveQueries.length > 0)
+        ? overrides.archiveQueries
         : rawKeywords;
     // Multi-tier Interaction Mode Resolution:
     // 1. Overrides / Cognitive Classifier
-    // 2. Security Boundary: public channel or external source forces 'casual' (Zero Memory Drift)
+    // 2. Security Boundary: public channel or external source forces 'casual' (Zero Drift)
     // 3. Explicit Request Mode (context.mode: 'casual' | 'teach' | 'hybrid')
     // 4. Default companion baseline: 'hybrid' (salience filtering)
     let effectiveMode;
@@ -123,7 +123,7 @@ function classifyInputIntent(text, context, overrides) {
         shouldQueryKnowledge,
         knowledgeQueries,
         primaryQuery,
-        memoryQueries,
+        archiveQueries,
         effectiveMode,
         confidence: overrides?.confidence ?? 0.95,
         classifierOrigin: overrides?.classifierOrigin ?? 'heuristic',

package/dist/intent-classifier.test.js

@@ -80,7 +80,7 @@ describe('IntentClassifier', () => {
             expect((0, intent_classifier_1.classifyInputIntent)('How are you doing?', casualContext).effectiveMode).toBe('casual');
             expect((0, intent_classifier_1.classifyInputIntent)('Tell me a joke', casualContext).effectiveMode).toBe('casual');
         });
-        test('enforces casual mode (Zero Memory Drift) on public channel or external source boundary', () => {
+        test('enforces casual mode (Zero Drift) on public channel or external source boundary', () => {
             const publicContext = {
                 ...dummyContext,
                 conversation: { channel: 'public', correlationId: 'corr-pub' },

package/dist/{memory-settler.d.ts → interaction-settler.d.ts}

@@ -1,17 +1,18 @@
-import { MemoryOrgan, SelfRepository, Claim, BehaviorDirective, ResponsePlan, RequestContext, InteractionMode } from './index';
+import { ArchiveLedger, SelfRepository, Claim, BehaviorDirective, ResponsePlan, RequestContext, InteractionMode } from './index';
 import { extractDeterministicTeaching } from './teaching';
-export interface MemorySettlementParams {
+export interface InteractionSettlementParams {
     companionId: string;
     perceivedText: string;
     role: 'OWNER' | 'VIEWER' | 'OPERATOR';
     requestContext: RequestContext;
-    memory?: MemoryOrgan;
+    archive?: ArchiveLedger;
+    memory?: any;
     self?: SelfRepository;
     explicitTeaching: ReturnType<typeof extractDeterministicTeaching>;
     plan: ResponsePlan;
     effectiveMode?: InteractionMode;
 }
-export interface MemoryProposalReceipt {
+export interface ProposalReceipt {
     proposal_id: string;
     subject: string;
     predicate: string;
@@ -20,11 +21,11 @@ export interface MemoryProposalReceipt {
     claim_type?: string;
     content?: string;
 }
+export type ClaimProposalReceipt = ProposalReceipt;
 export interface BehavioralProposalReceipt {
     directive_id: string;
     domain?: string;
     knowledge_domain?: string;
-    memory_class?: string;
     runtime_effect?: string;
     subject?: string;
     predicate?: string;
@@ -36,14 +37,14 @@ export interface BehavioralProposalReceipt {
         preferred_positions?: string[];
     };
 }
-export interface MemorySettlementResult {
-    createdMemoryProposals: Claim[];
-    memoryProposalReceipts: MemoryProposalReceipt[];
+export interface InteractionSettlementResult {
+    createdClaimProposals: Claim[];
+    claimProposalReceipts: ProposalReceipt[];
     createdBehavioralProposals?: BehaviorDirective[];
     behavioralProposalReceipts?: BehavioralProposalReceipt[];
 }
 /**
- * Persists source events, deterministic teaching claims, LLM memory proposals,
- * and LLM behavior proposals to the MemoryOrgan.
+ * Persists source events to ArchiveLedger and behavioral directive proposals directly to SelfRepository.
+ * Direct Domain Routing under RFC VX-26-13: Deconstructing Memory into Sovereign Primitives.
  */
-export declare function settleMemoryProposals(params: MemorySettlementParams): Promise<MemorySettlementResult>;
+export declare function settleInteractionProposals(params: InteractionSettlementParams): Promise<InteractionSettlementResult>;