@sidurijs/core 1.0.1 → 1.0.3

package/dist/adversarial.test.js

@@ -53,38 +53,43 @@ describe('Adversarial Hardening Verification Suite (Phase 3)', () => {
                 validFrom: pastTime,
                 validUntil: futureTime,
             };
-            const mockMemory = {
+            const mockArchive = {
                 initialize: jest.fn().mockResolvedValue(undefined),
-                searchClaims: jest.fn().mockResolvedValue([validClaim]),
-                getDirectives: jest.fn().mockResolvedValue([]),
+                searchEvents: jest.fn().mockResolvedValue([{
+                        id: 'evt-valid',
+                        companionId: 'companion-adv',
+                        sourceType: 'User',
+                        occurredAt: new Date().toISOString(),
+                        payload: 'favoriteColor Azure',
+                    }]),
             };
             const runtime = new index_1.SiduriRuntime('companion-adv', { name: 'AdvCompanion' }, {
                 brain: mockBrain,
-                memory: mockMemory,
+                archive: mockArchive,
             });
             await runtime.handleUserMessage('What is my favorite color?', baseOwnerContext);
-            expect(mockMemory.searchClaims).toHaveBeenCalled();
+            expect(mockArchive.searchEvents).toHaveBeenCalled();
             const brainCall = mockBrain.generatePlan.mock.calls[0][0];
-            expect(brainCall.contextPrompt).toContain('User favoriteColor Azure');
+            expect(brainCall.contextPrompt).toContain('ARCHIVE:');
+            expect(brainCall.contextPrompt).toContain('favoriteColor Azure');
         });
         test('companion isolation: runtime passes only companionId matching context', async () => {
             const mockBrain = {
                 generatePlan: jest.fn().mockResolvedValue({ speech: 'OK', language: 'en' }),
             };
-            const mockMemory = {
+            const mockArchive = {
                 initialize: jest.fn().mockResolvedValue(undefined),
-                searchClaims: jest.fn().mockResolvedValue([]),
-                getDirectives: jest.fn().mockResolvedValue([]),
+                searchEvents: jest.fn().mockResolvedValue([]),
             };
             const runtime = new index_1.SiduriRuntime('companion-A', { name: 'AdvA' }, {
                 brain: mockBrain,
-                memory: mockMemory,
+                archive: mockArchive,
             });
             await runtime.handleUserMessage('Query', {
                 ...baseOwnerContext,
                 companionId: 'companion-A',
             });
-            expect(mockMemory.searchClaims).toHaveBeenCalledWith('Query', expect.objectContaining({ limit: 5 }), 5);
+            expect(mockArchive.searchEvents).toHaveBeenCalledWith('companion-A', 'Query', 5);
         });
     });
     // INVARIANT 2: Authority & Request Boundary
@@ -349,27 +354,30 @@ describe('Adversarial Hardening Verification Suite (Phase 3)', () => {
     });
     // INVARIANT 6: Failure Semantics & Degradation
     describe('Invariant 6: Subsystem Failure Diagnostics & Non-Empty Propagation', () => {
-        test('database/memory query failure surfaces diagnostic in contextPrompt and metadata', async () => {
+        test('archive/self query failure surfaces diagnostic in contextPrompt and metadata', async () => {
             const mockBrain = {
                 generatePlan: jest.fn().mockResolvedValue({ speech: 'Graceful fallback response', language: 'en' }),
             };
-            const failingMemory = {
+            const failingArchive = {
                 initialize: jest.fn().mockResolvedValue(undefined),
-                searchClaims: jest.fn().mockRejectedValue(new Error('Connection terminated unexpectedly')),
-                getDirectives: jest.fn().mockRejectedValue(new Error('Database read timeout')),
+                searchEvents: jest.fn().mockRejectedValue(new Error('Connection terminated unexpectedly')),
+            };
+            const failingSelf = {
+                getActiveDirectives: jest.fn().mockRejectedValue(new Error('Database read timeout')),
             };
             const runtime = new index_1.SiduriRuntime('companion-adv', { name: 'AdvCompanion' }, {
                 brain: mockBrain,
-                memory: failingMemory,
+                archive: failingArchive,
+                self: failingSelf,
             });
             const response = await runtime.handleUserMessage('Hello companion', baseOwnerContext);
             expect(response.status).toBe('APPROVED');
             expect(response.metadata.subsystem_diagnostics).toBeDefined();
-            expect(response.metadata.subsystem_diagnostics.memory_claims).toContain('UNAVAILABLE');
-            expect(response.metadata.subsystem_diagnostics.memory_directives).toContain('UNAVAILABLE');
+            expect(response.metadata.subsystem_diagnostics.archive).toContain('UNAVAILABLE');
+            expect(response.metadata.subsystem_diagnostics.self_directives).toContain('UNAVAILABLE');
             const brainCall = mockBrain.generatePlan.mock.calls[0][0];
             expect(brainCall.contextPrompt).toContain('SUBSYSTEM STATUS (DEGRADED):');
-            expect(brainCall.contextPrompt).toContain('memory_claims');
+            expect(brainCall.contextPrompt).toContain('archive');
         });
     });
     // INVARIANT 8: Truth Gate Admissibility vs Factuality

package/dist/chat-contract.d.ts

@@ -46,6 +46,15 @@ export interface ChatResponsePlan {
 export interface ChatResponseMetadata {
     language?: string;
     proposals?: Claim[];
+    claim_proposals?: Array<{
+        proposal_id: string;
+        subject?: string;
+        predicate?: string;
+        value?: string;
+        status: string;
+        content?: string;
+        claim_type?: string;
+    }>;
     memory_proposals?: Array<{
         proposal_id: string;
         subject?: string;

package/dist/cognition-planner.d.ts

@@ -1,11 +1,11 @@
-import { BrainOrgan, Message, ResponsePlan, MemoryScope } from './index';
+import { BrainOrgan, Message, ResponsePlan, ClaimScope } from './index';
 export interface CognitionPlanningParams {
     companionName: string;
     brain?: BrainOrgan;
     systemPrompt: string;
     contextPrompt: string;
     recentMessages: Message[];
-    recipient?: MemoryScope;
+    recipient?: ClaimScope;
     perceivedText: string;
 }
 /**

package/dist/context-retriever.d.ts

@@ -1,4 +1,4 @@
-import { KnowledgeOrgan, KnowledgeItem, Claim, BehaviorDirective, EvidenceRecord, ResponseCitation, RequestContext, SelfRepository, LifeDatabase, ArchiveLedger, EpisodicMemoryStore, EKnowledgeOrgan } from './index';
+import { KnowledgeOrgan, KnowledgeItem, Claim, BehaviorDirective, EvidenceRecord, ResponseCitation, RequestContext, SelfRepository, LifeDatabase, ArchiveLedger, EKnowledgeOrgan } from './index';
 export interface ContextRetrievalParams {
     companionId: string;
     perceivedText: string;
@@ -7,17 +7,17 @@ export interface ContextRetrievalParams {
     isContextObject: boolean;
     shouldQueryKnowledge: boolean;
     knowledgeQueries?: string[];
-    memoryQueries?: string[];
+    archiveQueries?: string[];
     isSelfIdentityRequest?: boolean;
     knowledge?: KnowledgeOrgan | LifeDatabase;
     archive?: ArchiveLedger;
-    memory?: EpisodicMemoryStore;
+    memory?: any;
     self?: SelfRepository;
     externalKnowledge?: EKnowledgeOrgan | KnowledgeOrgan;
 }
 export interface RetrievedContext {
     knowledgeData: KnowledgeItem[];
-    memoryData: Claim[];
+    archiveData: Claim[];
     activeDirectives: BehaviorDirective[];
     subsystemDiagnostics: Record<string, string>;
     collectedEvidence: EvidenceRecord[];

package/dist/context-retriever.js

@@ -7,7 +7,7 @@ const intent_classifier_1 = require("./intent-classifier");
  * in a single parallel pass with graceful degradation.
  */
 async function retrieveRuntimeContext(params) {
-    const { companionId, perceivedText, requestContext, role, isContextObject, shouldQueryKnowledge, knowledgeQueries, memoryQueries, isSelfIdentityRequest, knowledge, archive, memory, self, externalKnowledge, } = params;
+    const { companionId, perceivedText, requestContext, role, isContextObject, shouldQueryKnowledge, knowledgeQueries, archiveQueries, isSelfIdentityRequest, knowledge, archive, memory, self, externalKnowledge, } = params;
     const queryOptions = isContextObject
         ? {
             limit: 5,
@@ -31,11 +31,11 @@ async function retrieveRuntimeContext(params) {
         queryCandidateSet.add(perceivedText.trim());
     }
     const finalKnowledgeQueries = Array.from(queryCandidateSet);
-    const memoryQueryToRun = (memoryQueries && memoryQueries.length > 0 && memoryQueries[0])
-        ? memoryQueries[0]
+    const archiveQueryToRun = (archiveQueries && archiveQueries.length > 0 && archiveQueries[0])
+        ? archiveQueries[0]
         : (0, intent_classifier_1.extractSearchKeywords)(perceivedText, companionId)[0] || perceivedText;
     // 2. Query streams in parallel
-    const [knowledgeData, memoryData, selfOrMemoryDirectives, lifeContext, selfIdentity, selfRelationship, personality,] = await Promise.all([
+    const [knowledgeData, archiveData, selfDirectives, lifeContext, selfIdentity, selfRelationship, personality,] = await Promise.all([
         // Stream A: External Cited Lore / Documentation
         extKnowledge && shouldQueryKnowledge && typeof extKnowledge.search === 'function'
             ? Promise.all(finalKnowledgeQueries.map((q) => extKnowledge.search(q).catch((e) => {
@@ -46,10 +46,8 @@ async function retrieveRuntimeContext(params) {
                 const merged = [];
                 const seen = new Set();
                 for (const list of resultsArray) {
-                    if (!Array.isArray(list))
-                        continue;
                     for (const item of list) {
-                        const key = item.id || item.content || item.text || JSON.stringify(item.citations);
+                        const key = item.content.slice(0, 100);
                         if (!seen.has(key)) {
                             seen.add(key);
                             merged.push(item);
@@ -59,12 +57,11 @@ async function retrieveRuntimeContext(params) {
                 return merged;
             })
             : Promise.resolve([]),
-        // Stream B: Interaction Archive / Verified Claims (FTS5 search with fallback)
+        // Stream B: Interaction Archive / Claims
         memory && typeof memory.searchClaims === 'function'
             ? (async () => {
                 try {
-                    // Support both (companionId, query, limit) and (query, options, limit)
-                    let result = await memory.searchClaims(memoryQueryToRun, queryOptions, 5);
+                    let result = await memory.searchClaims(archiveQueryToRun, queryOptions, 5);
                     if ((!result || result.length === 0) && isSelfIdentityRequest) {
                         if (typeof memory.getApprovedClaims === 'function') {
                             const approved = await memory.getApprovedClaims(companionId, 10);
@@ -96,7 +93,7 @@ async function retrieveRuntimeContext(params) {
             : archive && typeof archive.searchEvents === 'function'
                 ? (async () => {
                     try {
-                        const events = await archive.searchEvents(companionId, memoryQueryToRun, 5);
+                        const events = await archive.searchEvents(companionId, archiveQueryToRun, 5);
                         return (events || []).map((evt) => ({
                             id: evt.id,
                             companionId: evt.companionId,
@@ -156,7 +153,7 @@ async function retrieveRuntimeContext(params) {
             ? self.getPersonality(companionId).catch(() => undefined)
             : Promise.resolve(undefined),
     ]);
-    const activeDirectives = (selfOrMemoryDirectives || []);
+    const activeDirectives = (selfDirectives || []);
     // Build evidence records from retrieved context streams
     const collectedEvidence = [];
     const citations = [];
@@ -208,19 +205,19 @@ async function retrieveRuntimeContext(params) {
             }
         }
     }
-    // Stream B: Episodic Memory Claims
-    if (memoryData.length > 0) {
-        for (const m of memoryData) {
-            const claimId = m.claim_id || m.id || `claim-${Date.now()}`;
-            const sourceId = m.provenance || 'sqlite-memory';
-            const evId = `ev-mem-${claimId}`;
-            const claimPreview = m.content || `${m.subject || 'user'} ${m.predicate || 'claims'}: ${m.value || ''}`;
+    // Stream B: Interaction Archive
+    if (archiveData.length > 0) {
+        for (const m of archiveData) {
+            const claimId = m.claim_id || m.id || `evt-${Date.now()}`;
+            const sourceId = m.provenance || 'archive_ledger';
+            const evId = `ev-arc-${claimId}`;
+            const claimPreview = m.content || `${m.subject || 'event'} ${m.predicate || 'event'}: ${m.value || ''}`;
             collectedEvidence.push({
                 evidenceId: evId,
                 sourceId,
                 documentId: claimId,
-                chunkId: `${m.subject || 'user'}:${m.predicate || 'claim'}`,
-                origin: 'memory',
+                chunkId: `${m.subject || 'archive'}:${m.predicate || 'event'}`,
+                origin: 'archive',
                 trust: 'configured',
                 sensitivity: 'private',
                 companionId,
@@ -229,11 +226,11 @@ async function retrieveRuntimeContext(params) {
             });
             citations.push({
                 evidenceId: evId,
-                provenance: 'memory',
+                provenance: 'archive',
                 sourceId,
                 documentId: claimId,
-                chunkId: `${m.subject || 'user'}.${m.predicate || 'claim'}`,
-                locator: `claim:${claimId}`,
+                chunkId: `${m.subject || 'archive'}.${m.predicate || 'event'}`,
+                locator: `archive:${claimId}`,
                 preview: claimPreview.slice(0, 300),
             });
         }
@@ -268,7 +265,7 @@ async function retrieveRuntimeContext(params) {
     }
     return {
         knowledgeData,
-        memoryData,
+        archiveData,
         activeDirectives,
         subsystemDiagnostics,
         collectedEvidence,

package/dist/conversational-teach.test.js

@@ -172,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',
@@ -189,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',
@@ -232,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',
@@ -252,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',
@@ -261,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,
                 };
@@ -399,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);
@@ -450,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();
@@ -666,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',
@@ -683,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',
@@ -711,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,
                 };
@@ -819,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();
     });

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

@@ -18,7 +18,6 @@ export * from './context-retriever';
 export * from './prompt-compiler';
 export * from './cognition-planner';
 export * from './interaction-settler';
-export * from './memory-settler';
 export * from './action-executor';
 export * from './experience-emitter';
 export * from './response-envelope';
@@ -32,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;
@@ -57,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;
@@ -72,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 {
@@ -127,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;
@@ -135,7 +134,7 @@ export interface Claim {
     value: string;
     status: ClaimStatus;
     evidence?: string[];
-    scope?: MemoryScope;
+    scope?: ClaimScope;
     companionId: string;
     provenance?: string;
     sourceEventId?: string;
@@ -158,7 +157,6 @@ export interface BehaviorDirective {
     priority: number;
     status: DirectiveStatus;
     supersedesId?: string;
-    memoryClass?: 'identity' | 'relationship' | 'behavioral';
     subject?: string;
     predicate?: string;
     value?: string;
@@ -166,13 +164,6 @@ export interface BehaviorDirective {
     validUntil?: string;
     [key: string]: unknown;
 }
-export interface MemoryQueryOptions {
-    sensitivity?: string;
-    limit?: number;
-    minConfidence?: number;
-    now?: string | Date;
-    [key: string]: unknown;
-}
 export interface ArchiveEvent {
     id: string;
     companionId: string;
@@ -323,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>;
@@ -361,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

@@ -36,7 +36,6 @@ __exportStar(require("./context-retriever"), exports);
 __exportStar(require("./prompt-compiler"), exports);
 __exportStar(require("./cognition-planner"), exports);
 __exportStar(require("./interaction-settler"), exports);
-__exportStar(require("./memory-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' },