@siduri-x/core 2.0.3 → 2.0.5

package/dist/index.d.ts

@@ -31,7 +31,7 @@ import { EvidenceRecord } from './evidence';
 import { ActionIntent } from './action';
 import { RequestContext } from './context';
 import { EarIngestOptions } from './ear-types';
-import { ClaimType, ClaimAuthority, ClaimStatus, SourceEvent, MemoryProposal, BehaviorProposal } from './proposals';
+import { ClaimType, ClaimAuthority, ClaimStatus, DirectiveStatus, SourceEvent, MemoryProposal, BehaviorProposal } from './proposals';
 export interface OrganConfig {
     provider: string;
     [key: string]: unknown;
@@ -61,6 +61,8 @@ export interface BrainContext {
 export interface ResponsePlan {
     speech: string;
     language: string;
+    subtitle?: string;
+    subtitles?: Record<string, string>;
     memoryProposals?: MemoryProposal[];
     behaviorProposals?: BehaviorProposal[];
     actionIntents?: ActionIntent[];
@@ -98,7 +100,7 @@ export interface BehaviorDirective {
     companionId: string;
     directive: string;
     priority: number;
-    status: 'PENDING' | 'ACTIVE' | 'DISABLED' | 'SUPERSEDED' | 'REJECTED' | 'REVOKED' | 'EXPIRED';
+    status: DirectiveStatus;
     supersedesId?: string;
     memoryClass?: 'identity' | 'relationship' | 'behavioral';
     subject?: string;
@@ -259,7 +261,9 @@ import type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship,
 export type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, SelfDialogueExample, LifeInventoryItem, LifeScheduleItem, LifePreference, MemoryClaim, EpisodicEvent, };
 export interface SelfRepository {
     getIdentity(companionId: string): Promise<SelfIdentity | undefined>;
+    setIdentity(identity: SelfIdentity): Promise<void>;
     getPersonality?(companionId: string): Promise<PersonalityTraits>;
+    setPersonality?(companionId: string, traits: PersonalityTraits): Promise<void>;
     getActiveDirectives(companionId: string): Promise<SelfDirective[]>;
     getRelationship(companionId: string, entityId: string): Promise<SelfRelationship | null>;
     getRelationships?(companionId: string): Promise<SelfRelationship[]>;
@@ -267,7 +271,11 @@ export interface SelfRepository {
     setExemplars?(companionId: string, exemplars: SelfDialogueExample[]): Promise<void>;
     commitDirectives(companionId: string, directives: SelfDirective[]): Promise<void>;
     updateRelationship(companionId: string, rel: SelfRelationship): Promise<void>;
-    disableDirective?(id: string): Promise<void>;
+    disableDirective?(id: string, companionId?: string): Promise<void>;
+    approveDirective?(id: string, companionId?: string): Promise<void>;
+    rejectDirective?(id: string, companionId?: string): Promise<void>;
+    revokeDirective?(id: string, companionId?: string): Promise<void>;
+    expireDirective?(id: string, companionId?: string): Promise<void>;
     getActiveSelf?(companionId: string): Promise<{
         identity?: SelfIdentity;
         personality?: PersonalityTraits;

package/dist/memory-settler.d.ts

@@ -1,4 +1,4 @@
-import { MemoryOrgan, Claim, ResponsePlan, RequestContext, InteractionMode } from './index';
+import { MemoryOrgan, SelfRepository, Claim, BehaviorDirective, ResponsePlan, RequestContext, InteractionMode } from './index';
 import { extractDeterministicTeaching } from './teaching';
 export interface MemorySettlementParams {
     companionId: string;
@@ -6,6 +6,7 @@ export interface MemorySettlementParams {
     role: 'OWNER' | 'VIEWER' | 'OPERATOR';
     requestContext: RequestContext;
     memory?: MemoryOrgan;
+    self?: SelfRepository;
     explicitTeaching: ReturnType<typeof extractDeterministicTeaching>;
     plan: ResponsePlan;
     effectiveMode?: InteractionMode;
@@ -16,10 +17,30 @@ export interface MemoryProposalReceipt {
     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,

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,27 +76,86 @@ 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,
         subject: p.subject,
         predicate: p.predicate,
         value: p.value,
-        status: p.status,
+        status: (p.status || 'pending').toLowerCase().replace(/_/g, '-'),
+        claim_type: p.claimType,
+        content: p.content,
     }));
     return {
         createdMemoryProposals,
         memoryProposalReceipts,
+        createdBehavioralProposals,
+        behavioralProposalReceipts,
     };
 }

package/dist/mouth-types.d.ts

@@ -17,6 +17,9 @@ export interface MouthUtterance {
     subtitleJa?: string;
     subtitleEn?: string;
     spokenJa?: string;
+    subtitle?: string;
+    subtitleLanguage?: string;
+    subtitles?: Record<string, string>;
     expression?: string;
     action?: string;
     medium?: MouthMedium;
@@ -35,10 +38,12 @@ export interface FormattedMouthOutput {
     ssml?: string;
     visemes?: MouthVisemeCue[];
     subtitles?: {
-        ja: string;
-        en: string;
+        ja?: string;
+        en?: string;
         spoken?: string;
+        [lang: string]: string | undefined;
     };
+    subtitle?: string;
     audioUrl?: string;
     audioBuffer?: Uint8Array;
     expression?: string;

package/dist/perception-pipeline.d.ts

@@ -14,6 +14,7 @@ export interface CompanionPerception {
     context?: RequestContext;
     history?: Message[];
     medium?: MouthMedium;
+    subtitleLanguage?: string;
     metadata?: Record<string, unknown>;
     signal?: AbortSignal;
 }

package/dist/perception-pipeline.js

@@ -88,11 +88,15 @@ 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,
         lifeContext: context.contextRetrieval.lifeContext,
         effectiveMode: context.intent?.effectiveMode,
+        subtitleLanguage: context.perception.subtitleLanguage,
     });
     context.prompts = prompts;
 };
@@ -120,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,
     });
@@ -145,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,
@@ -198,6 +209,9 @@ const mouthDeliveryStage = async (context) => {
                 subtitleJa: context.plan.speech,
                 subtitleEn: context.plan.speech,
                 spokenJa: context.plan.speech,
+                subtitle: context.plan.subtitle,
+                subtitles: context.plan.subtitles,
+                subtitleLanguage: context.perception.subtitleLanguage,
                 expression: avatarEvent?.expression,
                 medium: context.perception.medium,
                 signal: context.perception.signal,
@@ -226,9 +240,13 @@ const envelopeAssemblyStage = async (context) => {
         stagedPlan: context.stagedPlan,
         speech: context.plan.speech,
         language: context.plan.language,
+        subtitle: context.plan.subtitle,
+        subtitles: context.plan.subtitles,
+        subtitleLanguage: context.perception.subtitleLanguage,
         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,11 +6,15 @@ export interface PromptCompilationParams {
     requestContext: RequestContext;
     behavior?: BehaviorOrgan;
     activeDirectives: BehaviorDirective[];
+    selfIdentity?: any;
+    selfRelationship?: any;
+    personality?: any;
     subsystemDiagnostics: Record<string, string>;
     knowledgeData: KnowledgeItem[];
     memoryData: Claim[];
     lifeContext?: string[];
     effectiveMode?: InteractionMode;
+    subtitleLanguage?: string;
 }
 export interface CompiledPrompts {
     systemPrompt: string;

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, } = 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,
         })
         : '';
@@ -48,9 +51,13 @@ async function compilePrompts(params) {
         : effectiveMode === 'teach'
             ? 'Operating Mode: Teach Mode (Active learning session - accurately capture user preferences and proposed boundaries for operator review).'
             : undefined;
+    const subtitleInstruction = subtitleLanguage && subtitleLanguage !== 'off'
+        ? `Requested Subtitle Language: "${subtitleLanguage}". Along with your primary speech, provide a natural subtitle translation in "${subtitleLanguage}" in the subtitle field.`
+        : undefined;
     const systemPrompt = [
         `You are ${companionName}.`,
         modeInstruction,
+        subtitleInstruction,
         'This is a neutral conversation context.',
         'Use only approved, permitted memory as factual personal context.',
         'Do not claim prior personal knowledge when no approved memory supports it.',

package/dist/proposals.d.ts

@@ -1,6 +1,7 @@
 export type ClaimType = 'semantic' | 'preference' | 'episodic' | 'relationship';
 export type ClaimAuthority = 'user_explicit' | 'user_correction' | 'import' | 'repeated_dialogue' | 'inference' | 'observation';
-export type ClaimStatus = 'PENDING' | 'APPROVED' | 'REJECTED' | 'SESSION_ONLY' | 'EXPIRED' | 'SUPERSEDED' | 'REVOKED';
+export type ClaimStatus = 'pending' | 'approved' | 'rejected' | 'session-only' | 'expired' | 'superseded' | 'revoked' | 'PENDING' | 'APPROVED' | 'REJECTED' | 'SESSION_ONLY' | 'EXPIRED' | 'SUPERSEDED' | 'REVOKED';
+export type DirectiveStatus = 'pending' | 'active' | 'disabled' | 'superseded' | 'rejected' | 'revoked' | 'expired' | 'confirmed' | 'PENDING' | 'ACTIVE' | 'DISABLED' | 'SUPERSEDED' | 'REJECTED' | 'REVOKED' | 'EXPIRED';
 export interface SourceEvent {
     id: string;
     sourceType: string;

package/dist/response-envelope.d.ts

@@ -5,9 +5,13 @@ export interface AssembleResponseEnvelopeParams {
     stagedPlan: StagedResponsePlan;
     speech: string;
     language?: string;
+    subtitle?: string;
+    subtitles?: Record<string, string>;
+    subtitleLanguage?: string;
     speechId?: string;
     createdMemoryProposals: Claim[];
     memoryProposalReceipts: MemoryProposalReceipt[];
+    behavioralProposalReceipts?: any[];
     actionResults: ActionExecutionResult[];
     filteredEvidenceIds?: string[];
     filteredCitations?: ResponseCitation[];

package/dist/response-envelope.js

@@ -29,7 +29,14 @@ function createGateRejectionEnvelope(stagedPlan, gateEval) {
  * Assembles the standardized response structure for approved companion responses.
  */
 function assembleResponseEnvelope(params) {
-    const { stagedPlan, speech, language, 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 || {}),
+    };
+    if (subtitle && subtitleLanguage) {
+        resolvedSubtitles[subtitleLanguage] = subtitle;
+    }
     return {
         status: 'APPROVED',
         response_id: stagedPlan.responseId,
@@ -37,8 +44,11 @@ function assembleResponseEnvelope(params) {
         response: {
             speech_id: speechId,
             audio_url: mouthDelivery?.audioUrl ?? (speechId ? `/voice/stream?id=${speechId}` : undefined),
-            subtitle_ja: mouthDelivery?.subtitles?.ja ?? speech,
-            subtitle_en: mouthDelivery?.subtitles?.en ?? speech,
+            subtitle_ja: mouthDelivery?.subtitles?.ja ?? resolvedSubtitles['ja'] ?? speech,
+            subtitle_en: mouthDelivery?.subtitles?.en ?? resolvedSubtitles['en'] ?? speech,
+            subtitle: subtitle ?? (subtitleLanguage ? resolvedSubtitles[subtitleLanguage] : undefined),
+            subtitle_language: subtitleLanguage,
+            subtitles: resolvedSubtitles,
         },
         delivery: mouthDelivery,
         metadata: {
@@ -46,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.
@@ -46,5 +88,9 @@ export declare class SiduriRuntime {
     /**
      * Primary entrypoint for text chat messages.
      */
-    handleUserMessage(message: string, roleOrContext?: 'OWNER' | 'VIEWER' | 'OPERATOR' | RequestContext | string, history?: Message[], medium?: MouthMedium, signal?: AbortSignal): Promise<any>;
+    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>;