@sidurijs/core 1.0.0 → 1.0.1

package/dist/runtime.js

@@ -31,7 +31,7 @@ class SiduriRuntime {
     // Direct organ accessors through container
     get organs() { return this.container.organs; }
     get brain() { return this.container.brain; }
-    get memory() { return this.container.memory; }
+    get archive() { return this.container.archive; }
     get voice() { return this.container.voice; }
     get knowledge() { return this.container.knowledge; }
     get vision() { return this.container.vision; }
@@ -57,45 +57,9 @@ class SiduriRuntime {
     }
     async initialize() {
         await this.container.initialize();
-        if (this.memory && this.self && typeof this.memory.approveClaim === 'function') {
-            const originalApproveClaim = this.memory.approveClaim.bind(this.memory);
-            this.memory.approveClaim = async (id) => {
-                await originalApproveClaim(id);
-                const targetCompId = this.id;
-                const claims = typeof this.memory.getAllClaims === 'function'
-                    ? await this.memory.getAllClaims(500)
-                    : await this.memory.getClaims(500);
-                let found = claims.find((c) => c.id === id);
-                if (!found && typeof this.memory.getPendingClaims === 'function') {
-                    const pending = await this.memory.getPendingClaims(500);
-                    found = pending.find((c) => c.id === id);
-                }
-                if (found && this.self) {
-                    await promoteApprovedClaimToSelf(found, this.self, targetCompId);
-                }
-                if (found && this.container.knowledge) {
-                    await promoteApprovedClaimToKnowledge(found, this.container.knowledge, targetCompId);
-                }
-            };
-        }
-        // Sync any pre-existing approved claims to Knowledge / Life DB
-        if (this.memory && this.container.knowledge) {
-            try {
-                const claims = typeof this.memory.getAllClaims === 'function'
-                    ? await this.memory.getAllClaims(500)
-                    : await this.memory.getClaims(500);
-                const approvedClaims = (claims || []).filter((c) => (c.status || '').toLowerCase() === 'approved');
-                for (const c of approvedClaims) {
-                    await promoteApprovedClaimToKnowledge(c, this.container.knowledge, this.id);
-                }
-            }
-            catch {
-                // non-blocking
-            }
-        }
     }
     get db() {
-        return this.container.db || this.memory?.db || this.self?.db;
+        return this.container.db || this.self?.db || this.archive?.db;
     }
     log(level, subsystem, message, metadata) {
         if (this.db && typeof this.db.insertLog === 'function') {
@@ -129,86 +93,101 @@ class SiduriRuntime {
         this.container.sessionHistory.clear(sessionKey);
     }
     /**
-     * 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.
      */
     async approveProposal(proposalId, options) {
         const companionId = options?.companionId || this.id;
-        // 1. Approve claim in memory if present
-        if (this.memory && typeof this.memory.approveClaim === 'function') {
-            await this.memory.approveClaim(proposalId);
+        // 1. Direct Domain Routing: If proposalId is a directive ID, route directly to Self
+        if (proposalId.startsWith('dir-') && this.self && typeof this.self.approveDirective === 'function') {
+            try {
+                const approved = await this.self.approveDirective(proposalId, companionId);
+                if (approved !== false) {
+                    const identity = typeof this.self.getIdentity === 'function' ? await this.self.getIdentity(companionId) : null;
+                    this.log('info', 'truth_gate', `Approved behavioral directive proposal '${proposalId}' directly in Self`, {
+                        proposalId,
+                        companionId,
+                        target: 'self',
+                    });
+                    return { success: true, target: 'self', name: identity?.name };
+                }
+            }
+            catch {
+                // Fall through
+            }
         }
-        // 2. Fetch claim
-        let claim;
-        if (this.memory) {
-            const claims = typeof this.memory.getAllClaims === 'function'
-                ? await this.memory.getAllClaims(500)
-                : await this.memory.getClaims(500);
-            claim = claims.find((c) => c.id === proposalId);
-            if (!claim && typeof this.memory.getPendingClaims === 'function') {
-                const pending = await this.memory.getPendingClaims(500);
+        // 2. If memory organ is present, support legacy claim approval
+        if (this.container.organs.memory) {
+            const memory = this.container.organs.memory;
+            if (typeof memory.approveClaim === 'function') {
+                await memory.approveClaim(proposalId);
+            }
+            let claim;
+            if (typeof memory.getAllClaims === 'function') {
+                const claims = await memory.getAllClaims(500);
+                claim = claims.find((c) => c.id === proposalId);
+            }
+            else if (typeof memory.getClaims === 'function') {
+                const claims = await memory.getClaims(500);
+                claim = claims.find((c) => c.id === proposalId);
+            }
+            if (!claim && typeof memory.getPendingClaims === 'function') {
+                const pending = await memory.getPendingClaims(500);
                 claim = pending.find((c) => c.id === proposalId);
             }
-        }
-        // 3. Promote to Knowledge / Life DB if claim is Knowledge-affecting
-        if (claim && this.container.knowledge) {
-            const promotedToKnowledge = await promoteApprovedClaimToKnowledge(claim, this.container.knowledge, companionId);
-            if (promotedToKnowledge) {
-                this.log('info', 'truth_gate', `Approved and promoted claim '${proposalId}' to Knowledge / Life DB`, {
+            if (claim && this.container.knowledge) {
+                const promotedToKnowledge = await promoteApprovedClaimToKnowledge(claim, this.container.knowledge, companionId);
+                if (promotedToKnowledge) {
+                    this.log('info', 'truth_gate', `Approved and promoted claim '${proposalId}' to Knowledge / Life DB`, {
+                        proposalId,
+                        companionId,
+                        target: 'knowledge',
+                        subject: claim.subject,
+                        predicate: claim.predicate,
+                    });
+                    return { success: true, target: 'knowledge' };
+                }
+            }
+            if (claim && this.self) {
+                await promoteApprovedClaimToSelf(claim, this.self, companionId);
+                const identity = typeof this.self.getIdentity === 'function' ? await this.self.getIdentity(companionId) : null;
+                this.log('info', 'truth_gate', `Approved and promoted claim '${proposalId}' to Self`, {
                     proposalId,
                     companionId,
-                    target: 'knowledge',
+                    target: 'self',
                     subject: claim.subject,
                     predicate: claim.predicate,
                 });
-                return { success: true, target: 'knowledge' };
+                return { success: true, target: 'self', name: identity?.name };
             }
         }
-        // 4. Promote to SelfRepository if claim is Self-affecting
-        if (claim && this.self) {
-            await promoteApprovedClaimToSelf(claim, this.self, companionId);
-            const identity = typeof this.self.getIdentity === 'function' ? await this.self.getIdentity(companionId) : null;
-            this.log('info', 'truth_gate', `Approved and promoted claim '${proposalId}' to Self`, {
-                proposalId,
-                companionId,
-                target: 'self',
-                subject: claim.subject,
-                predicate: claim.predicate,
-            });
-            return { success: true, target: 'self', name: identity?.name };
-        }
-        // 5. Also check if this proposal ID is a behavioral directive in Self
+        // 3. Direct Self directive check
         if (this.self && typeof this.self.approveDirective === 'function') {
             try {
-                await this.self.approveDirective(proposalId, companionId);
-                const identity = typeof this.self.getIdentity === 'function' ? await this.self.getIdentity(companionId) : null;
-                this.log('info', 'truth_gate', `Approved behavioral directive proposal '${proposalId}'`, {
-                    proposalId,
-                    companionId,
-                    target: 'self',
-                });
-                return { success: true, target: 'self', name: identity?.name };
+                const approved = await this.self.approveDirective(proposalId, companionId);
+                if (approved !== false) {
+                    const identity = typeof this.self.getIdentity === 'function' ? await this.self.getIdentity(companionId) : null;
+                    this.log('info', 'truth_gate', `Approved behavioral directive proposal '${proposalId}' directly in Self`, {
+                        proposalId,
+                        companionId,
+                        target: 'self',
+                    });
+                    return { success: true, target: 'self', name: identity?.name };
+                }
             }
             catch {
-                // Not a pending directive or already active
+                // Not a pending directive
             }
         }
         const identity = this.self && typeof this.self.getIdentity === 'function' ? await this.self.getIdentity(companionId) : null;
-        this.log('info', 'truth_gate', `Approved memory proposal '${proposalId}'`, {
-            proposalId,
-            companionId,
-            target: 'memory',
-        });
-        return { success: true, target: 'memory', name: identity?.name };
+        return { success: true, target: 'self', name: identity?.name };
     }
     /**
-     * Rejects a memory or behavior proposal.
+     * Rejects a proposal.
      */
     async rejectProposal(proposalId, options) {
         const companionId = options?.companionId || this.id;
-        if (this.memory && typeof this.memory.rejectClaim === 'function') {
-            await this.memory.rejectClaim(proposalId);
-        }
         if (this.self && typeof this.self.rejectDirective === 'function') {
             try {
                 await this.self.rejectDirective(proposalId, companionId);
@@ -217,6 +196,9 @@ class SiduriRuntime {
                 // ignore
             }
         }
+        if (this.container.organs.memory && typeof this.container.organs.memory.rejectClaim === 'function') {
+            await this.container.organs.memory.rejectClaim(proposalId);
+        }
         this.log('info', 'truth_gate', `Rejected proposal '${proposalId}'`, {
             proposalId,
             companionId,
@@ -224,16 +206,13 @@ class SiduriRuntime {
         return { success: true };
     }
     /**
-     * Approves a behavioral directive in Self and Memory.
+     * Approves a behavioral directive directly in Self.
      */
     async approveDirective(directiveId, options) {
         const companionId = options?.companionId || this.id;
         if (this.self && typeof this.self.approveDirective === 'function') {
             await this.self.approveDirective(directiveId, companionId);
         }
-        if (this.memory && typeof this.memory.approveDirective === 'function') {
-            await this.memory.approveDirective(directiveId, companionId);
-        }
         // If directive pertains to companion name, ensure self identity reflects it
         if (this.self && typeof this.self.getActiveDirectives === 'function') {
             try {
@@ -269,16 +248,13 @@ class SiduriRuntime {
         return { success: true, name: identity?.name };
     }
     /**
-     * Rejects a behavioral directive in Self and Memory.
+     * Rejects a behavioral directive in Self.
      */
     async rejectDirective(directiveId, options) {
         const companionId = options?.companionId || this.id;
         if (this.self && typeof this.self.rejectDirective === 'function') {
             await this.self.rejectDirective(directiveId, companionId);
         }
-        if (this.memory && typeof this.memory.rejectDirective === 'function') {
-            await this.memory.rejectDirective(directiveId, companionId);
-        }
         this.log('info', 'truth_gate', `Rejected behavioral directive '${directiveId}'`, {
             directiveId,
             companionId,
@@ -286,16 +262,13 @@ class SiduriRuntime {
         return { success: true };
     }
     /**
-     * Revokes a behavioral directive in Self and Memory.
+     * Revokes a behavioral directive in Self.
      */
     async revokeDirective(directiveId, options) {
         const companionId = options?.companionId || this.id;
         if (this.self && typeof this.self.revokeDirective === 'function') {
             await this.self.revokeDirective(directiveId, companionId);
         }
-        if (this.memory && typeof this.memory.revokeDirective === 'function') {
-            await this.memory.revokeDirective(directiveId, companionId);
-        }
         return { success: true };
     }
     /**
@@ -333,7 +306,10 @@ class SiduriRuntime {
 }
 exports.SiduriRuntime = SiduriRuntime;
 /**
- * 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.
  */
 async function promoteApprovedClaimToSelf(claim, self, companionId) {
     const targetCompanionId = companionId || claim.companionId || 'default';
@@ -551,7 +527,9 @@ function isKnowledgeAffectingClaim(claim) {
         predicate === 'prefers');
 }
 /**
- * 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.
  */
 async function promoteApprovedClaimToKnowledge(claim, knowledge, companionId) {
     if (!knowledge)

package/dist/session-history.d.ts

@@ -1,13 +1,13 @@
-import { Message } from './index';
+import { Message, DialogueHistory } from './index';
 export interface SessionHistoryOptions {
     maxSessions?: number;
     maxMessagesPerSession?: number;
 }
 /**
  * Manages conversation history scoped by session key to prevent cross-session
- * and cross-channel memory/conversation leakage.
+ * and cross-channel dialogue leakage. Implements the DialogueHistory primitive (RFC VX-26-13).
  */
-export declare class SessionHistoryManager {
+export declare class SessionHistoryManager implements DialogueHistory {
     private readonly sessions;
     private readonly maxSessions;
     private readonly maxMessagesPerSession;

package/dist/session-history.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionHistoryManager = void 0;
 /**
  * Manages conversation history scoped by session key to prevent cross-session
- * and cross-channel memory/conversation leakage.
+ * and cross-channel dialogue leakage. Implements the DialogueHistory primitive (RFC VX-26-13).
  */
 class SessionHistoryManager {
     sessions = new Map();

package/dist/siduri-db.d.ts

@@ -108,13 +108,14 @@ export interface LifeTask {
     metadata?: Record<string, unknown>;
     updatedAt?: string;
 }
-export interface EpisodicEvent {
+export interface ArchiveEvent {
     id: string;
     companionId: string;
-    sourceType: 'chat_turn' | 'tool_result' | 'sensory';
+    sourceType: string;
     occurredAt: string;
     payload: Record<string, unknown>;
 }
+export type EpisodicEvent = ArchiveEvent;
 export interface MemoryClaim {
     id: string;
     companionId: string;
@@ -188,32 +189,11 @@ export declare class SiduriDatabase {
     getTasks(companionId: string, status?: string): LifeTask[];
     upsertTask(task: LifeTask): void;
     deleteTask(id: string): boolean;
-    recordEvent(event: EpisodicEvent): void;
-    getRecentEvents(companionId: string, limit?: number): EpisodicEvent[];
-    getEvent(id: string): EpisodicEvent | undefined;
-    private rowToMemoryClaim;
-    proposeClaim(claim: Omit<MemoryClaim, 'status' | 'confidence' | 'assertedAt'> & {
-        confidence?: number;
-        assertedAt?: string;
-        supersedes?: string;
-        sourceEventId?: string;
-        status?: string;
-    }): MemoryClaim;
-    approveClaim(id: string, companionId?: string): void;
-    /**
-     * Canonically promotes a Claim into Self domain tables.
-     */
-    promoteClaimToSelf(claim: MemoryClaim | any): void;
-    rejectClaim(id: string, companionId?: string): void;
-    revokeClaim(id: string, companionId?: string): void;
-    expireClaim(id: string, companionId?: string): void;
-    markClaimSessionOnly(id: string, companionId?: string): void;
-    searchClaims(companionId: string, query: string, limit?: number): MemoryClaim[];
-    getPendingClaims(companionId: string, limit?: number): MemoryClaim[];
-    getApprovedClaims(companionId: string, limit?: number): MemoryClaim[];
-    getAllClaims(companionId?: string, limit?: number): MemoryClaim[];
-    getClaim(id: string): MemoryClaim | undefined;
-    resetMemory(companionId: string): void;
+    recordArchiveEvent(event: ArchiveEvent | EpisodicEvent): void;
+    getRecentArchiveEvents(companionId: string, limit?: number): ArchiveEvent[];
+    getArchiveEvent(id: string): ArchiveEvent | undefined;
+    searchArchiveEvents(companionId: string, query: string, limit?: number): ArchiveEvent[];
+    resetArchive(companionId: string): void;
     insertLog(entry: {
         id?: string;
         companionId?: string;