@siduri-x/core 2.0.4 → 2.0.5

package/dist/memory-settler.js

@@ -6,7 +6,7 @@ exports.settleMemoryProposals = settleMemoryProposals;
  * and LLM behavior proposals to the MemoryOrgan.
  */
 async function settleMemoryProposals(params) {
-    const { companionId, perceivedText, role, requestContext, memory, explicitTeaching, plan, effectiveMode, } = 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') {
@@ -43,6 +43,7 @@ async function settleMemoryProposals(params) {
     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,
@@ -61,6 +62,7 @@ async function settleMemoryProposals(params) {
         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,
@@ -74,17 +76,72 @@ async function settleMemoryProposals(params) {
             }
         }
     }
-    if (memory &&
-        plan.behaviorProposals &&
-        plan.behaviorProposals.length > 0 &&
-        typeof memory.proposeDirective === 'function') {
-        for (const bp of plan.behaviorProposals) {
-            await memory.proposeDirective({
+    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,
-                scopeMatcher: [role],
+                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,
@@ -92,9 +149,13 @@ async function settleMemoryProposals(params) {
         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,
     };
 }

package/dist/perception-pipeline.js

@@ -88,6 +88,9 @@ const promptCompilationStage = async (context) => {
         requestContext: context.input.requestContext,
         behavior: context.organs.behavior,
         activeDirectives: context.contextRetrieval.activeDirectives,
+        selfIdentity: context.contextRetrieval.selfIdentity,
+        selfRelationship: context.contextRetrieval.selfRelationship,
+        personality: context.contextRetrieval.personality,
         subsystemDiagnostics: context.contextRetrieval.subsystemDiagnostics,
         knowledgeData: context.contextRetrieval.knowledgeData,
         memoryData: context.contextRetrieval.memoryData,
@@ -121,8 +124,14 @@ const responseGatingStage = async (context) => {
         candidateSpeech: context.plan.speech,
         candidateLanguage: context.plan.language || 'ja',
         internalMonologue: context.plan.internalMonologue,
-        memoryProposals: context.plan.memoryProposals,
-        behaviorProposals: context.plan.behaviorProposals,
+        memoryProposals: [
+            ...(context.intent?.explicitTeaching?.claims || []),
+            ...(context.plan.memoryProposals || []),
+        ],
+        behaviorProposals: [
+            ...(context.intent?.explicitTeaching?.behaviorProposals || []),
+            ...(context.plan.behaviorProposals || []),
+        ],
         evidenceRecords: context.contextRetrieval.collectedEvidence,
         citations: context.contextRetrieval.citations,
     });
@@ -146,6 +155,7 @@ const memorySettlementStage = async (context) => {
         role: context.input.role,
         requestContext: context.input.requestContext,
         memory: context.organs.memory,
+        self: context.organs.self,
         explicitTeaching: context.intent.explicitTeaching,
         plan: context.plan,
         effectiveMode: context.intent.effectiveMode,
@@ -236,6 +246,7 @@ const envelopeAssemblyStage = async (context) => {
         speechId: context.experienceEmission?.speechId,
         createdMemoryProposals: context.memorySettlement.createdMemoryProposals,
         memoryProposalReceipts: context.memorySettlement.memoryProposalReceipts,
+        behavioralProposalReceipts: context.memorySettlement.behavioralProposalReceipts,
         actionResults: context.actionResults || [],
         filteredEvidenceIds: context.gateEval.filteredEvidenceIds,
         filteredCitations: context.gateEval.filteredCitations,

package/dist/prompt-compiler.d.ts

@@ -6,6 +6,9 @@ export interface PromptCompilationParams {
     requestContext: RequestContext;
     behavior?: BehaviorOrgan;
     activeDirectives: BehaviorDirective[];
+    selfIdentity?: any;
+    selfRelationship?: any;
+    personality?: any;
     subsystemDiagnostics: Record<string, string>;
     knowledgeData: KnowledgeItem[];
     memoryData: Claim[];

package/dist/prompt-compiler.js

@@ -5,7 +5,7 @@ exports.compilePrompts = compilePrompts;
  * Compiles neutral system prompt and formatted context prompt from structured data.
  */
 async function compilePrompts(params) {
-    const { companionName, companionId, role, requestContext, behavior, activeDirectives, subsystemDiagnostics, knowledgeData, memoryData, lifeContext, effectiveMode, subtitleLanguage, } = params;
+    const { companionName, companionId, role, requestContext, behavior, activeDirectives, selfIdentity, selfRelationship, personality, subsystemDiagnostics, knowledgeData, memoryData, lifeContext, effectiveMode, subtitleLanguage, } = params;
     let contextPrompt = '';
     if (Object.keys(subsystemDiagnostics).length > 0) {
         contextPrompt +=
@@ -40,6 +40,9 @@ async function compilePrompts(params) {
         ? await behavior.compile({
             directives: activeDirectives,
             companionId,
+            identity: selfIdentity,
+            relationship: selfRelationship,
+            personality,
             actorId: requestContext.actor.actorId,
         })
         : '';

package/dist/response-envelope.d.ts

@@ -11,6 +11,7 @@ export interface AssembleResponseEnvelopeParams {
     speechId?: string;
     createdMemoryProposals: Claim[];
     memoryProposalReceipts: MemoryProposalReceipt[];
+    behavioralProposalReceipts?: any[];
     actionResults: ActionExecutionResult[];
     filteredEvidenceIds?: string[];
     filteredCitations?: ResponseCitation[];

package/dist/response-envelope.js

@@ -29,7 +29,7 @@ function createGateRejectionEnvelope(stagedPlan, gateEval) {
  * Assembles the standardized response structure for approved companion responses.
  */
 function assembleResponseEnvelope(params) {
-    const { stagedPlan, speech, language, subtitle, subtitles, subtitleLanguage, speechId, createdMemoryProposals, memoryProposalReceipts, actionResults, filteredEvidenceIds, filteredCitations, subsystemDiagnostics, experienceEvents, mouthDelivery, effectiveMode, } = params;
+    const { stagedPlan, speech, language, subtitle, subtitles, subtitleLanguage, speechId, createdMemoryProposals, memoryProposalReceipts, behavioralProposalReceipts, actionResults, filteredEvidenceIds, filteredCitations, subsystemDiagnostics, experienceEvents, mouthDelivery, effectiveMode, } = params;
     const resolvedSubtitles = {
         ...(mouthDelivery?.subtitles || {}),
         ...(subtitles || {}),
@@ -56,6 +56,7 @@ function assembleResponseEnvelope(params) {
             language,
             proposals: createdMemoryProposals,
             memory_proposals: memoryProposalReceipts,
+            behavioral_proposals: behavioralProposalReceipts || [],
             action_results: actionResults,
             evidence_ids: filteredEvidenceIds,
             citations: filteredCitations,

package/dist/runtime.d.ts

@@ -38,6 +38,48 @@ export declare class SiduriRuntime {
     initialize(): Promise<void>;
     getSessionHistory(sessionKey: string): Message[];
     clearHistory(sessionKey?: string): void;
+    /**
+     * Approves a memory proposal or behavior proposal and canonically promotes
+     * Self-affecting mutations to SelfRepository.
+     */
+    approveProposal(proposalId: string, options?: {
+        companionId?: string;
+    }): Promise<{
+        success: boolean;
+        target?: string;
+    }>;
+    /**
+     * Rejects a memory or behavior proposal.
+     */
+    rejectProposal(proposalId: string, options?: {
+        companionId?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Approves a behavioral directive in Self and Memory.
+     */
+    approveDirective(directiveId: string, options?: {
+        companionId?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Rejects a behavioral directive in Self and Memory.
+     */
+    rejectDirective(directiveId: string, options?: {
+        companionId?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Revokes a behavioral directive in Self and Memory.
+     */
+    revokeDirective(directiveId: string, options?: {
+        companionId?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
     /**
      * Processes an incoming perception (sensory audio, text, platform event, or observation alert)
      * through the decoupled PerceptionPipeline.
@@ -48,3 +90,7 @@ 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.
+ */
+export declare function promoteApprovedClaimToSelf(claim: any, self: SelfRepository, companionId?: string): Promise<void>;

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.
@@ -94,3 +209,94 @@ class SiduriRuntime {
     }
 }
 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

@@ -3,6 +3,7 @@ export interface SelfIdentity {
     companionId: string;
     name: string;
     archetype?: string;
+    role?: string;
     origin?: string;
     ethos?: string;
     version: string;
@@ -148,6 +149,10 @@ export declare class SiduriDatabase {
         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;