@sidurijs/core 1.0.0 → 1.0.1

package/dist/interaction-settler.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settleMemoryProposals = void 0;
+exports.settleInteractionProposals = settleInteractionProposals;
+/**
+ * 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.
+ */
+async function settleInteractionProposals(params) {
+    const { companionId, perceivedText, role, requestContext, archive, self, explicitTeaching, plan, effectiveMode, } = params;
+    // Zero Drift: Casual mode completely suppresses all proposal generation
+    const mode = effectiveMode || requestContext.mode || 'hybrid';
+    if (mode === 'casual') {
+        return {
+            createdMemoryProposals: [],
+            memoryProposalReceipts: [],
+        };
+    }
+    const createdMemoryProposals = [];
+    let sourceEventId;
+    const hasTeaching = explicitTeaching.claims.length > 0 ||
+        explicitTeaching.behaviorProposals.length > 0;
+    const hasPlanProposals = Boolean(plan.memoryProposals?.length) ||
+        Boolean(plan.behaviorProposals?.length);
+    if (archive && typeof archive.recordEvent === 'function') {
+        if (hasTeaching || hasPlanProposals) {
+            const sourceEvent = {
+                id: `evt-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+                sourceType: 'user_chat_explicit',
+                occurredAt: new Date().toISOString(),
+                payload: {
+                    message: perceivedText,
+                    role,
+                    companionId,
+                    actorId: requestContext.actor?.actorId || 'owner-user',
+                    channel: requestContext.conversation?.channel || 'direct',
+                },
+            };
+            await archive.recordEvent(sourceEvent);
+            sourceEventId = sourceEvent.id;
+        }
+    }
+    for (const claim of explicitTeaching.claims) {
+        let proposal;
+        if (params.memory && typeof params.memory.proposeClaim === 'function') {
+            proposal = await params.memory.proposeClaim({
+                companionId,
+                subject: claim.subject,
+                predicate: claim.predicate,
+                value: claim.value,
+                scope: claim.subject?.startsWith('companion:') ? 'companion' : 'user',
+                provenance: claim.provenance || 'deterministic_teaching',
+                sourceEventId,
+                claimType: claim.claimType || 'preference',
+                authority: 'user_explicit',
+                userConfirmation: 'none',
+                sensitivity: claim.sensitivity ||
+                    (requestContext.conversation?.channel === 'public' ? 'public' : 'private'),
+            });
+        }
+        if (!proposal) {
+            proposal = {
+                id: `claim-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+                companionId,
+                subject: claim.subject,
+                predicate: claim.predicate,
+                value: claim.value,
+                scope: claim.subject?.startsWith('companion:') ? 'companion' : 'user',
+                provenance: claim.provenance || 'deterministic_teaching',
+                sourceEventId,
+                claimType: claim.claimType || 'preference',
+                authority: 'user_explicit',
+                userConfirmation: 'none',
+                status: 'pending',
+                sensitivity: claim.sensitivity ||
+                    (requestContext.conversation?.channel === 'public' ? 'public' : 'private'),
+            };
+        }
+        if (proposal) {
+            createdMemoryProposals.push(proposal);
+        }
+    }
+    if (plan.memoryProposals && plan.memoryProposals.length > 0) {
+        for (const p of plan.memoryProposals) {
+            let proposal;
+            if (params.memory && typeof params.memory.proposeClaim === 'function') {
+                proposal = await params.memory.proposeClaim({
+                    companionId,
+                    subject: p.subject || `actor:${requestContext.actor?.actorId || 'unknown'}`,
+                    predicate: p.predicate,
+                    value: p.value,
+                    scope: p.subject?.startsWith('companion:') ? 'companion' : 'user',
+                    provenance: p.provenance || 'llm_proposal',
+                    sourceEventId: sourceEventId || p.sourceEventId,
+                    claimType: p.claimType || 'semantic',
+                    sensitivity: p.sensitivity || 'private',
+                });
+            }
+            if (!proposal) {
+                proposal = {
+                    id: `claim-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+                    companionId,
+                    subject: p.subject || `actor:${requestContext.actor?.actorId || 'unknown'}`,
+                    predicate: p.predicate,
+                    value: p.value,
+                    scope: p.subject?.startsWith('companion:') ? 'companion' : 'user',
+                    provenance: p.provenance || 'llm_proposal',
+                    sourceEventId: sourceEventId || p.sourceEventId,
+                    claimType: p.claimType || 'semantic',
+                    status: 'pending',
+                    sensitivity: p.sensitivity || 'private',
+                };
+            }
+            if (proposal) {
+                createdMemoryProposals.push(proposal);
+            }
+        }
+    }
+    const createdBehavioralProposals = [];
+    const behavioralProposalReceipts = [];
+    const allBehaviorProposals = [
+        ...explicitTeaching.behaviorProposals,
+        ...(plan.behaviorProposals || []),
+    ];
+    for (const bp of allBehaviorProposals) {
+        const directive = {
+            id: `dir-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+            companionId,
+            directive: bp.directive,
+            priority: bp.priority || 50,
+            status: 'pending',
+            category: (bp.category || 'behavioral'),
+            scopeActor: bp.scopeActor,
+            supersedesId: bp.supersedesId,
+            createdAt: new Date().toISOString(),
+        };
+        createdBehavioralProposals.push(directive);
+        if (self && typeof self.commitDirectives === 'function') {
+            await self.commitDirectives(companionId, [directive]);
+        }
+        behavioralProposalReceipts.push({
+            directive_id: directive.id,
+            domain: 'behavioral',
+            knowledge_domain: 'behavioral',
+            memory_class: bp.memoryClass || 'behavioral',
+            runtime_effect: bp.memoryClass || 'behavioral',
+            subject: bp.subject || `companion:${companionId}`,
+            predicate: bp.predicate || 'rule',
+            value: bp.value || bp.directive,
+            status: 'pending',
+            behavior: {
+                instruction: bp.directive,
+                frequency: 'continuous',
+                preferred_positions: [],
+            },
+        });
+    }
+    const memoryProposalReceipts = createdMemoryProposals.map((p) => ({
+        proposal_id: p.id,
+        subject: p.subject,
+        predicate: p.predicate,
+        value: p.value,
+        status: (p.status || 'pending').toLowerCase().replace(/_/g, '-'),
+        claim_type: p.claimType,
+        content: p.content,
+    }));
+    return {
+        createdMemoryProposals,
+        memoryProposalReceipts,
+        createdBehavioralProposals,
+        behavioralProposalReceipts,
+    };
+}
+/**
+ * @deprecated Use `settleInteractionProposals` instead. RFC VX-26-13.
+ */
+exports.settleMemoryProposals = settleInteractionProposals;

package/dist/memory-settler.d.ts

@@ -1,49 +1,5 @@
-import { MemoryOrgan, SelfRepository, Claim, BehaviorDirective, ResponsePlan, RequestContext, InteractionMode } from './index';
-import { extractDeterministicTeaching } from './teaching';
-export interface MemorySettlementParams {
-    companionId: string;
-    perceivedText: string;
-    role: 'OWNER' | 'VIEWER' | 'OPERATOR';
-    requestContext: RequestContext;
-    memory?: MemoryOrgan;
-    self?: SelfRepository;
-    explicitTeaching: ReturnType<typeof extractDeterministicTeaching>;
-    plan: ResponsePlan;
-    effectiveMode?: InteractionMode;
-}
-export interface MemoryProposalReceipt {
-    proposal_id: string;
-    subject: string;
-    predicate: string;
-    value: string;
-    status: string;
-    claim_type?: string;
-    content?: string;
-}
-export interface BehavioralProposalReceipt {
-    directive_id: string;
-    domain?: string;
-    knowledge_domain?: string;
-    memory_class?: string;
-    runtime_effect?: string;
-    subject?: string;
-    predicate?: string;
-    value?: string;
-    status: string;
-    behavior?: {
-        instruction: string;
-        frequency?: string;
-        preferred_positions?: string[];
-    };
-}
-export interface MemorySettlementResult {
-    createdMemoryProposals: Claim[];
-    memoryProposalReceipts: MemoryProposalReceipt[];
-    createdBehavioralProposals?: BehaviorDirective[];
-    behavioralProposalReceipts?: BehavioralProposalReceipt[];
-}
 /**
- * Persists source events, deterministic teaching claims, LLM memory proposals,
- * and LLM behavior proposals to the MemoryOrgan.
+ * @deprecated RFC VX-26-13: Deconstructing Memory into Sovereign Primitives.
+ * Use `@sidurijs/core/interaction-settler` instead.
  */
-export declare function settleMemoryProposals(params: MemorySettlementParams): Promise<MemorySettlementResult>;
+export * from './interaction-settler';

package/dist/memory-settler.js

@@ -1,161 +1,21 @@
 "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 });
-exports.settleMemoryProposals = settleMemoryProposals;
 /**
- * Persists source events, deterministic teaching claims, LLM memory proposals,
- * and LLM behavior proposals to the MemoryOrgan.
+ * @deprecated RFC VX-26-13: Deconstructing Memory into Sovereign Primitives.
+ * Use `@sidurijs/core/interaction-settler` instead.
  */
-async function settleMemoryProposals(params) {
-    const { companionId, perceivedText, role, requestContext, memory, self, explicitTeaching, plan, effectiveMode, } = params;
-    // Zero Memory Drift: Casual mode completely suppresses all proposal generation
-    const mode = effectiveMode || requestContext.mode || 'hybrid';
-    if (mode === 'casual') {
-        return {
-            createdMemoryProposals: [],
-            memoryProposalReceipts: [],
-        };
-    }
-    const createdMemoryProposals = [];
-    let sourceEventId;
-    const hasTeaching = explicitTeaching.claims.length > 0 ||
-        explicitTeaching.behaviorProposals.length > 0;
-    const hasPlanProposals = Boolean(plan.memoryProposals?.length) ||
-        Boolean(plan.behaviorProposals?.length);
-    if (memory &&
-        (hasTeaching || hasPlanProposals) &&
-        typeof memory.addSourceEvent === 'function') {
-        const sourceEvent = {
-            id: `evt-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
-            sourceType: 'user_chat_explicit',
-            occurredAt: new Date().toISOString(),
-            payload: {
-                message: perceivedText,
-                role,
-                companionId,
-                actorId: requestContext.actor?.actorId || 'owner-user',
-                channel: requestContext.conversation?.channel || 'direct',
-            },
-        };
-        await memory.addSourceEvent(sourceEvent);
-        sourceEventId = sourceEvent.id;
-    }
-    // Persist deterministic memory proposals as PENDING if memory is available
-    if (memory && typeof memory.proposeClaim === 'function') {
-        for (const claim of explicitTeaching.claims) {
-            const proposal = await memory.proposeClaim({
-                companionId,
-                subject: claim.subject,
-                predicate: claim.predicate,
-                value: claim.value,
-                scope: claim.subject?.startsWith('companion:') ? 'companion' : 'user',
-                provenance: claim.provenance || 'deterministic_teaching',
-                sourceEventId,
-                claimType: claim.claimType || 'preference',
-                authority: 'user_explicit',
-                userConfirmation: 'none',
-                sensitivity: claim.sensitivity ||
-                    (requestContext.conversation?.channel === 'public' ? 'public' : 'private'),
-            });
-            createdMemoryProposals.push(proposal);
-        }
-        // Also persist plan memory proposals if model returned structured proposals
-        if (plan.memoryProposals && plan.memoryProposals.length > 0) {
-            for (const p of plan.memoryProposals) {
-                const proposal = await memory.proposeClaim({
-                    companionId,
-                    subject: p.subject || `actor:${requestContext.actor.actorId}`,
-                    predicate: p.predicate,
-                    value: p.value,
-                    scope: p.subject?.startsWith('companion:') ? 'companion' : 'user',
-                    provenance: p.provenance || 'llm_proposal',
-                    sourceEventId: sourceEventId || p.sourceEventId,
-                    claimType: p.claimType || 'semantic',
-                    sensitivity: p.sensitivity || 'private',
-                });
-                createdMemoryProposals.push(proposal);
-            }
-        }
-    }
-    const createdBehavioralProposals = [];
-    const behavioralProposalReceipts = [];
-    const allBehaviorProposals = [
-        ...explicitTeaching.behaviorProposals,
-        ...(plan.behaviorProposals || []),
-    ];
-    for (const bp of allBehaviorProposals) {
-        let directive;
-        if (memory && typeof memory.proposeDirective === 'function') {
-            directive = await memory.proposeDirective({
-                companionId,
-                directive: bp.directive,
-                priority: bp.priority || 50,
-                category: bp.category || 'behavioral',
-                supersedesId: bp.supersedesId,
-                scopeActor: bp.scopeActor || (bp.subject?.startsWith('actor:') ? bp.subject.slice(6) : undefined),
-                memoryClass: bp.memoryClass,
-                subject: bp.subject,
-                predicate: bp.predicate,
-                value: bp.value,
-                sourceEventId: sourceEventId || bp.sourceEventId,
-            });
-        }
-        if (!directive || !directive.id) {
-            directive = {
-                id: directive?.id || `dir-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
-                companionId,
-                directive: bp.directive,
-                priority: bp.priority || 50,
-                status: 'pending',
-                category: (bp.category || 'behavioral'),
-                scopeActor: bp.scopeActor,
-                supersedesId: bp.supersedesId,
-                createdAt: new Date().toISOString(),
-            };
-        }
-        createdBehavioralProposals.push(directive);
-        if (self && typeof self.commitDirectives === 'function') {
-            await self.commitDirectives(companionId, [{
-                    id: directive.id,
-                    companionId,
-                    directive: bp.directive,
-                    priority: bp.priority || 50,
-                    status: 'pending',
-                    category: (bp.category || 'behavioral'),
-                    scopeActor: bp.scopeActor,
-                    supersedesId: bp.supersedesId,
-                    createdAt: new Date().toISOString(),
-                }]);
-        }
-        behavioralProposalReceipts.push({
-            directive_id: directive.id,
-            domain: 'behavioral',
-            knowledge_domain: 'behavioral',
-            memory_class: bp.memoryClass || 'behavioral',
-            runtime_effect: bp.memoryClass || 'behavioral',
-            subject: bp.subject || `companion:${companionId}`,
-            predicate: bp.predicate || 'rule',
-            value: bp.value || bp.directive,
-            status: 'pending',
-            behavior: {
-                instruction: bp.directive,
-                frequency: 'continuous',
-                preferred_positions: [],
-            },
-        });
-    }
-    const memoryProposalReceipts = createdMemoryProposals.map((p) => ({
-        proposal_id: p.id,
-        subject: p.subject,
-        predicate: p.predicate,
-        value: p.value,
-        status: (p.status || 'pending').toLowerCase().replace(/_/g, '-'),
-        claim_type: p.claimType,
-        content: p.content,
-    }));
-    return {
-        createdMemoryProposals,
-        memoryProposalReceipts,
-        createdBehavioralProposals,
-        behavioralProposalReceipts,
-    };
-}
+__exportStar(require("./interaction-settler"), exports);

package/dist/perception-pipeline.d.ts

@@ -1,9 +1,9 @@
-import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, Message, RequestContext, ActionPolicyEngine, ResponseGatingEngine, ExperienceDispatcher, ExperienceAdapter, StagedResponsePlan, ResponseGateEvaluation, MouthOrgan, MouthMedium, FormattedMouthOutput, SelfRepository, EKnowledgeOrgan, ActionExecutionResult, ResponsePlan } from './index';
+import { BrainOrgan, ArchiveLedger, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, Message, RequestContext, ActionPolicyEngine, ResponseGatingEngine, ExperienceDispatcher, ExperienceAdapter, StagedResponsePlan, ResponseGateEvaluation, MouthOrgan, MouthMedium, FormattedMouthOutput, SelfRepository, EKnowledgeOrgan, ActionExecutionResult, ResponsePlan } from './index';
 import { NormalizedInput } from './input-normalizer';
 import { IntentClassification } from './intent-classifier';
 import { RetrievedContext } from './context-retriever';
 import { CompiledPrompts } from './prompt-compiler';
-import { MemorySettlementResult } from './memory-settler';
+import { MemorySettlementResult } from './interaction-settler';
 import { ExperienceEmissionResult } from './experience-emitter';
 import { SessionHistoryManager } from './session-history';
 export interface CompanionPerception {
@@ -24,7 +24,8 @@ export interface PerceptionPipelineContext {
     perception: CompanionPerception;
     organs: {
         brain?: BrainOrgan;
-        memory?: MemoryOrgan;
+        archive?: ArchiveLedger;
+        memory?: any;
         voice?: VoiceOrgan | ExperienceAdapter;
         knowledge?: KnowledgeOrgan;
         vision?: VisionOrgan;
@@ -69,6 +70,7 @@ export declare const contextRetrievalStage: PerceptionPipelineStage;
 export declare const promptCompilationStage: PerceptionPipelineStage;
 export declare const cognitionPlanningStage: PerceptionPipelineStage;
 export declare const responseGatingStage: PerceptionPipelineStage;
+export declare const interactionSettlementStage: PerceptionPipelineStage;
 export declare const memorySettlementStage: PerceptionPipelineStage;
 export declare const actionExecutionStage: PerceptionPipelineStage;
 export declare const experienceEmissionStage: PerceptionPipelineStage;

package/dist/perception-pipeline.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.envelopeAssemblyStage = exports.mouthDeliveryStage = exports.experienceEmissionStage = exports.actionExecutionStage = exports.memorySettlementStage = exports.responseGatingStage = exports.cognitionPlanningStage = exports.promptCompilationStage = exports.contextRetrievalStage = exports.intentClassificationStage = exports.inputNormalizationStage = exports.earTranscriptionStage = exports.PerceptionPipeline = void 0;
+exports.envelopeAssemblyStage = exports.mouthDeliveryStage = exports.experienceEmissionStage = exports.actionExecutionStage = exports.memorySettlementStage = exports.interactionSettlementStage = exports.responseGatingStage = exports.cognitionPlanningStage = exports.promptCompilationStage = exports.contextRetrievalStage = exports.intentClassificationStage = exports.inputNormalizationStage = exports.earTranscriptionStage = exports.PerceptionPipeline = void 0;
 exports.createDefaultPerceptionPipeline = createDefaultPerceptionPipeline;
 const input_normalizer_1 = require("./input-normalizer");
 const intent_classifier_1 = require("./intent-classifier");
 const context_retriever_1 = require("./context-retriever");
 const prompt_compiler_1 = require("./prompt-compiler");
 const cognition_planner_1 = require("./cognition-planner");
-const memory_settler_1 = require("./memory-settler");
+const interaction_settler_1 = require("./interaction-settler");
 const action_executor_1 = require("./action-executor");
 const experience_emitter_1 = require("./experience-emitter");
 const response_envelope_1 = require("./response-envelope");
@@ -97,6 +97,7 @@ const contextRetrievalStage = async (context) => {
         memoryQueries: context.intent.memoryQueries,
         isSelfIdentityRequest: context.intent.isSelfIdentityRequest,
         knowledge: context.organs.knowledge,
+        archive: context.organs.archive,
         memory: context.organs.memory,
         self: context.organs.self,
         externalKnowledge: context.organs.externalKnowledge,
@@ -174,23 +175,25 @@ const responseGatingStage = async (context) => {
     context.sessionHistory.append('default', { role: 'assistant', content: context.plan.speech });
 };
 exports.responseGatingStage = responseGatingStage;
-const memorySettlementStage = async (context) => {
+const interactionSettlementStage = async (context) => {
     if (!context.input || !context.plan || !context.intent)
         return;
-    const memorySettlement = await (0, memory_settler_1.settleMemoryProposals)({
+    const settlement = await (0, interaction_settler_1.settleInteractionProposals)({
         companionId: context.companionId,
         perceivedText: context.input.perceivedText,
         role: context.input.role,
         requestContext: context.input.requestContext,
-        memory: context.organs.memory,
+        archive: context.organs.archive,
         self: context.organs.self,
         explicitTeaching: context.intent.explicitTeaching,
         plan: context.plan,
         effectiveMode: context.intent.effectiveMode,
+        memory: context.organs.memory,
     });
-    context.memorySettlement = memorySettlement;
+    context.memorySettlement = settlement;
 };
-exports.memorySettlementStage = memorySettlementStage;
+exports.interactionSettlementStage = interactionSettlementStage;
+exports.memorySettlementStage = exports.interactionSettlementStage;
 const actionExecutionStage = async (context) => {
     if (!context.input || !context.plan)
         return;

package/dist/response-envelope.d.ts

@@ -1,5 +1,5 @@
 import { StagedResponsePlan, ResponseGateEvaluation, Claim, ResponseCitation, ExperienceEvent, ActionExecutionResult, InteractionMode } from './index';
-import { MemoryProposalReceipt } from './memory-settler';
+import { MemoryProposalReceipt } from './interaction-settler';
 import { FormattedMouthOutput } from './mouth-types';
 export interface AssembleResponseEnvelopeParams {
     stagedPlan: StagedResponsePlan;

package/dist/response-envelope.js

@@ -63,6 +63,7 @@ function assembleResponseEnvelope(params) {
             mode: effectiveMode ?? 'hybrid',
             language,
             proposals: createdMemoryProposals,
+            directive_proposals: behavioralProposalReceipts || [],
             memory_proposals: memoryProposalReceipts,
             behavioral_proposals: behavioralProposalReceipts || [],
             action_results: actionResults,

package/dist/runtime-facades.test.js

@@ -27,44 +27,21 @@ describe('CompanionContainer & Direct Domain Access', () => {
         const cleared = container.observation.clearExpired();
         expect(cleared).toBe(1);
     });
-    test('delegates memory operations directly on the memory organ', async () => {
-        const mockMemory = {
-            initialize: jest.fn().mockResolvedValue(undefined),
-            getClaims: jest.fn().mockResolvedValue([{ id: 'claim-1' }]),
-            getPendingClaims: jest.fn().mockResolvedValue([{ id: 'claim-pending-1' }]),
-            getDirectives: jest.fn().mockResolvedValue([{ id: 'dir-1' }]),
-            approveClaim: jest.fn().mockResolvedValue(undefined),
-            rejectClaim: jest.fn().mockResolvedValue(undefined),
-            updateClaim: jest.fn().mockResolvedValue({ id: 'claim-1', value: 'updated' }),
-            approveDirective: jest.fn().mockResolvedValue(undefined),
-            rejectDirective: jest.fn().mockResolvedValue(undefined),
-            revokeDirective: jest.fn().mockResolvedValue(undefined),
-            disableDirective: jest.fn().mockResolvedValue(undefined),
-            resetMemory: jest.fn().mockResolvedValue(undefined),
+    test('delegates archive operations directly on the archive organ', async () => {
+        const mockArchive = {
+            recordEvent: jest.fn().mockResolvedValue(undefined),
+            getRecentEvents: jest.fn().mockResolvedValue([{ id: 'evt-1' }]),
+            searchEvents: jest.fn().mockResolvedValue([{ id: 'evt-1' }]),
         };
         const container = new container_1.CompanionContainer('test-comp', { name: 'Test' }, {
-            memory: mockMemory,
+            archive: mockArchive,
         });
-        expect(await container.memory.getClaims(10)).toEqual([{ id: 'claim-1' }]);
-        expect(mockMemory.getClaims).toHaveBeenCalledWith(10);
-        expect(await container.memory.getPendingClaims()).toEqual([{ id: 'claim-pending-1' }]);
-        expect(await container.memory.getDirectives()).toEqual([{ id: 'dir-1' }]);
-        await container.memory.approveClaim('c-1');
-        expect(mockMemory.approveClaim).toHaveBeenCalledWith('c-1');
-        await container.memory.rejectClaim('c-2');
-        expect(mockMemory.rejectClaim).toHaveBeenCalledWith('c-2');
-        await container.memory.updateClaim('c-1', { value: 'updated' });
-        expect(mockMemory.updateClaim).toHaveBeenCalledWith('c-1', { value: 'updated' });
-        await container.memory.approveDirective('d-1');
-        expect(mockMemory.approveDirective).toHaveBeenCalledWith('d-1');
-        await container.memory.rejectDirective('d-2');
-        expect(mockMemory.rejectDirective).toHaveBeenCalledWith('d-2');
-        await container.memory.revokeDirective('d-3');
-        expect(mockMemory.revokeDirective).toHaveBeenCalledWith('d-3');
-        await container.memory.disableDirective('d-4');
-        expect(mockMemory.disableDirective).toHaveBeenCalledWith('d-4');
-        await container.memory.resetMemory();
-        expect(mockMemory.resetMemory).toHaveBeenCalled();
+        expect(await container.archive.getRecentEvents('test-comp', 10)).toEqual([{ id: 'evt-1' }]);
+        expect(mockArchive.getRecentEvents).toHaveBeenCalledWith('test-comp', 10);
+        expect(await container.archive.searchEvents('test-comp', 'query', 5)).toEqual([{ id: 'evt-1' }]);
+        expect(mockArchive.searchEvents).toHaveBeenCalledWith('test-comp', 'query', 5);
+        await container.archive.recordEvent({ id: 'evt-2' });
+        expect(mockArchive.recordEvent).toHaveBeenCalledWith({ id: 'evt-2' });
     });
     test('configures SqliteActionStore when actionStore is sqlite', () => {
         const container = new container_1.CompanionContainer('comp-sqlite', {

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, MouthOrgan, SelfRepository, EKnowledgeOrgan, Message, RequestContext, MouthMedium, ResponseGatingEngine, ActionPolicyEngine, ExperienceDispatcher } from './index';
+import { BrainOrgan, ArchiveLedger, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, MouthOrgan, SelfRepository, EKnowledgeOrgan, Message, RequestContext, MouthMedium, ResponseGatingEngine, ActionPolicyEngine, ExperienceDispatcher } from './index';
 import { SiduriDatabase, LogLevel, SystemLog } from './siduri-db';
 import { SessionHistoryManager } from './session-history';
 import { CompanionPerception, PerceptionPipeline } from './perception-pipeline';
@@ -17,7 +17,7 @@ export declare class SiduriRuntime {
     constructor(id: string, config: SiduriRuntimeConfig, containerOrOrgans?: CompanionContainer | RuntimeOrgans, pipeline?: PerceptionPipeline);
     get organs(): RuntimeOrgans;
     get brain(): BrainOrgan | undefined;
-    get memory(): MemoryOrgan | undefined;
+    get archive(): ArchiveLedger | undefined;
     get voice(): VoiceOrgan | undefined;
     get knowledge(): KnowledgeOrgan | undefined;
     get vision(): VisionOrgan | undefined;
@@ -51,8 +51,9 @@ export declare class SiduriRuntime {
     getSessionHistory(sessionKey: string): Message[];
     clearHistory(sessionKey?: string): void;
     /**
-     * Approves a memory proposal or behavior proposal and canonically promotes
-     * Self-affecting mutations to SelfRepository.
+     * Approves a proposal using Direct Domain Routing (RFC VX-26-13):
+     * - Behavioral & relational directives route directly to SelfRepository.
+     * - Life state facts route directly to Knowledge / Life DB.
      */
     approveProposal(proposalId: string, options?: {
         companionId?: string;
@@ -62,7 +63,7 @@ export declare class SiduriRuntime {
         name?: string;
     }>;
     /**
-     * Rejects a memory or behavior proposal.
+     * Rejects a proposal.
      */
     rejectProposal(proposalId: string, options?: {
         companionId?: string;
@@ -70,7 +71,7 @@ export declare class SiduriRuntime {
         success: boolean;
     }>;
     /**
-     * Approves a behavioral directive in Self and Memory.
+     * Approves a behavioral directive directly in Self.
      */
     approveDirective(directiveId: string, options?: {
         companionId?: string;
@@ -79,7 +80,7 @@ export declare class SiduriRuntime {
         name?: string;
     }>;
     /**
-     * Rejects a behavioral directive in Self and Memory.
+     * Rejects a behavioral directive in Self.
      */
     rejectDirective(directiveId: string, options?: {
         companionId?: string;
@@ -87,7 +88,7 @@ export declare class SiduriRuntime {
         success: boolean;
     }>;
     /**
-     * Revokes a behavioral directive in Self and Memory.
+     * Revokes a behavioral directive in Self.
      */
     revokeDirective(directiveId: string, options?: {
         companionId?: string;
@@ -105,12 +106,17 @@ export declare class SiduriRuntime {
     handleUserMessage(message: string, roleOrContext?: 'OWNER' | 'VIEWER' | 'OPERATOR' | RequestContext | string, history?: Message[], medium?: MouthMedium, signal?: AbortSignal, subtitleLanguage?: string): Promise<any>;
 }
 /**
- * Canonically promotes an approved Claim into SelfRepository state.
+ * @deprecated RFC VX-26-13: Deconstructing Memory.
+ * Prefer Direct Domain Routing: behavioral directives, identity mutations, and relational
+ * stances should route directly to SelfRepository (`commitDirectives`, `setIdentity`, `updateRelationship`)
+ * rather than being staged in memory_claims and promoted downstream.
  */
 export declare function promoteApprovedClaimToSelf(claim: any, self: SelfRepository, companionId?: string): Promise<void>;
 export declare function isSelfAffectingClaim(claim: any): boolean;
 export declare function isKnowledgeAffectingClaim(claim: any): boolean;
 /**
- * Canonically promotes an approved Claim into Knowledge / LifeDatabase state.
+ * @deprecated RFC VX-26-13: Deconstructing Memory.
+ * Prefer Direct Domain Routing: user life facts (entities, inventory, finances, schedule, preferences)
+ * should route directly to Knowledge / LifeDatabase rather than being staged as generic memory claims.
  */
 export declare function promoteApprovedClaimToKnowledge(claim: any, knowledge: any, companionId?: string): Promise<boolean>;