@siduri-x/core 2.0.3 → 2.0.5

package/dist/runtime.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SiduriRuntime = void 0;
+exports.promoteApprovedClaimToSelf = promoteApprovedClaimToSelf;
 const perception_pipeline_1 = require("./perception-pipeline");
 const container_1 = require("./container");
 /**
@@ -52,7 +53,25 @@ class SiduriRuntime {
         this.container.sessionHistory.setHistory('default', messages);
     }
     async initialize() {
-        return this.container.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);
+                }
+            };
+        }
     }
     getSessionHistory(sessionKey) {
         return this.container.sessionHistory.getHistory(sessionKey);
@@ -60,6 +79,102 @@ class SiduriRuntime {
     clearHistory(sessionKey) {
         this.container.sessionHistory.clear(sessionKey);
     }
+    /**
+     * Approves a memory proposal or behavior proposal and canonically promotes
+     * Self-affecting mutations to SelfRepository.
+     */
+    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);
+        }
+        // 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);
+                claim = pending.find((c) => c.id === proposalId);
+            }
+        }
+        // 3. Promote to Self if Self exists and claim is Self-affecting
+        if (claim && this.self) {
+            await promoteApprovedClaimToSelf(claim, this.self, companionId);
+            return { success: true, target: 'self' };
+        }
+        // 4. Also check if proposalId is a directive ID
+        if (this.self && typeof this.self.approveDirective === 'function') {
+            try {
+                await this.self.approveDirective(proposalId, companionId);
+                return { success: true, target: 'self_directive' };
+            }
+            catch {
+                // Not a pending directive or already active
+            }
+        }
+        return { success: true, target: 'memory' };
+    }
+    /**
+     * Rejects a memory or behavior 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);
+            }
+            catch {
+                // ignore
+            }
+        }
+        return { success: true };
+    }
+    /**
+     * Approves a behavioral directive in Self and Memory.
+     */
+    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);
+        }
+        return { success: true };
+    }
+    /**
+     * Rejects a behavioral directive in Self and Memory.
+     */
+    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);
+        }
+        return { success: true };
+    }
+    /**
+     * Revokes a behavioral directive in Self and Memory.
+     */
+    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 };
+    }
     /**
      * Processes an incoming perception (sensory audio, text, platform event, or observation alert)
      * through the decoupled PerceptionPipeline.
@@ -81,7 +196,7 @@ class SiduriRuntime {
     /**
      * Primary entrypoint for text chat messages.
      */
-    async handleUserMessage(message, roleOrContext = 'OWNER', history = [], medium, signal) {
+    async handleUserMessage(message, roleOrContext = 'OWNER', history = [], medium, signal, subtitleLanguage) {
         return this.processPerception({
             source: 'text_chat',
             text: message,
@@ -89,7 +204,99 @@ class SiduriRuntime {
             history,
             medium,
             signal,
+            subtitleLanguage,
         });
     }
 }
 exports.SiduriRuntime = SiduriRuntime;
+/**
+ * Canonically promotes an approved Claim into SelfRepository state.
+ */
+async function promoteApprovedClaimToSelf(claim, self, companionId) {
+    const targetCompanionId = companionId || claim.companionId || 'default';
+    const subject = (claim.subject || '').toLowerCase();
+    const predicate = (claim.predicate || '').toLowerCase();
+    const value = claim.value || '';
+    if (!value)
+        return;
+    // 1. Identity mutations: companion identity/role/origin/name/ethos
+    if (subject.startsWith('companion:') ||
+        subject === 'companion' ||
+        subject === 'siduri' ||
+        subject === 'self') {
+        const existing = (await self.getIdentity(targetCompanionId)) || {
+            companionId: targetCompanionId,
+            name: 'Siduri',
+            version: '1.0.0',
+            updatedAt: new Date().toISOString(),
+        };
+        if (predicate === 'role' || predicate === 'archetype') {
+            existing.archetype = value;
+            existing.role = value;
+            existing.updatedAt = new Date().toISOString();
+            await self.setIdentity(existing);
+            await self.commitDirectives(targetCompanionId, [
+                {
+                    id: `dir-role-${claim.id || Date.now()}`,
+                    companionId: targetCompanionId,
+                    priority: 70,
+                    directive: `Acknowledge role as ${value}`,
+                    status: 'active',
+                    category: 'relational',
+                    createdAt: new Date().toISOString(),
+                },
+            ]);
+        }
+        else if (predicate === 'origin' || predicate === 'created_by') {
+            existing.origin = value;
+            existing.updatedAt = new Date().toISOString();
+            await self.setIdentity(existing);
+        }
+        else if (predicate === 'name') {
+            existing.name = value;
+            existing.updatedAt = new Date().toISOString();
+            await self.setIdentity(existing);
+        }
+        else if (predicate === 'ethos') {
+            existing.ethos = value;
+            existing.updatedAt = new Date().toISOString();
+            await self.setIdentity(existing);
+        }
+        return;
+    }
+    // 2. Relationship mutations: creator or user stated relationship
+    if (claim.claimType === 'relationship' ||
+        predicate === 'stated_relationship' ||
+        predicate === 'relationship' ||
+        predicate === 'relationship_to_siduri') {
+        const rawSubject = (claim.subject || 'actor:user').replace(/^actor:actor:/, 'actor:');
+        const isCreator = value.toLowerCase() === 'creator';
+        await self.updateRelationship(targetCompanionId, {
+            companionId: targetCompanionId,
+            entityId: rawSubject,
+            entityType: 'human',
+            role: value,
+            stance: isCreator ? 'familiar_loyal' : 'neutral',
+            trustScore: isCreator ? 1.0 : 0.8,
+            familiarity: isCreator ? 0.9 : 0.5,
+            interactionConventions: isCreator
+                ? ['Direct communication', 'Highest administrative trust']
+                : [],
+        });
+        return;
+    }
+    // 3. Behavioral rule claim
+    if (predicate === 'behavioral_rule' || predicate === 'rule') {
+        await self.commitDirectives(targetCompanionId, [
+            {
+                id: `dir-rule-${claim.id || Date.now()}`,
+                companionId: targetCompanionId,
+                priority: 60,
+                directive: value,
+                status: 'active',
+                category: 'behavioral',
+                createdAt: new Date().toISOString(),
+            },
+        ]);
+    }
+}

package/dist/siduri-db.d.ts

@@ -1,7 +1,9 @@
+import { ClaimStatus, DirectiveStatus } from './proposals';
 export interface SelfIdentity {
     companionId: string;
     name: string;
     archetype?: string;
+    role?: string;
     origin?: string;
     ethos?: string;
     version: string;
@@ -19,7 +21,7 @@ export interface SelfDirective {
     companionId: string;
     priority?: number;
     directive: string;
-    status: 'PENDING' | 'ACTIVE' | 'DISABLED' | 'SUPERSEDED' | 'REJECTED' | 'REVOKED' | 'EXPIRED';
+    status: DirectiveStatus;
     category: 'behavioral' | 'guardrail' | 'relational' | string;
     scopeActor?: string;
     supersedesId?: string;
@@ -90,7 +92,7 @@ export interface MemoryClaim {
     subject: string;
     predicate: string;
     value: string;
-    status: 'PENDING' | 'APPROVED' | 'REJECTED' | 'SESSION_ONLY' | 'SUPERSEDED' | 'REVOKED' | 'EXPIRED';
+    status: ClaimStatus;
     confidence: number;
     validFrom?: string;
     validUntil?: string;
@@ -99,6 +101,7 @@ export interface MemoryClaim {
     supersedes?: string;
     sourceEventId?: string;
 }
+export declare function normalizeStatus(status?: string, defaultStatus?: string): string;
 export interface SiduriDatabaseOptions {
     dbPath?: string;
 }
@@ -111,7 +114,9 @@ export declare class SiduriDatabase {
     setIdentity(identity: SelfIdentity): void;
     getPersonality(companionId: string): PersonalityTraits | undefined;
     setPersonality(companionId: string, traits: PersonalityTraits): void;
+    private rowToSelfDirective;
     getActiveDirectives(companionId: string): SelfDirective[];
+    getAllDirectives(companionId: string): SelfDirective[];
     commitDirective(directive: SelfDirective): void;
     getDirective(id: string, companionId?: string): SelfDirective | undefined;
     approveDirective(id: string, companionId?: string): void;
@@ -135,13 +140,19 @@ export declare class SiduriDatabase {
     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;
@@ -149,6 +160,7 @@ export declare class SiduriDatabase {
     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;
 }