@siduri-x/core 2.0.2 → 2.0.4

package/dist/chat-contract.d.ts

@@ -13,6 +13,7 @@ export interface ChatRequest {
     history?: Message[];
     medium?: MouthMedium;
     signal?: AbortSignal;
+    subtitleLanguage?: string;
     [key: string]: any;
 }
 export interface ChatResponseMetadataEvent {
@@ -30,6 +31,9 @@ export interface ChatResponsePlan {
     subtitle_ja: string;
     subtitle_en: string;
     spoken_ja?: string;
+    subtitle?: string;
+    subtitle_language?: string;
+    subtitles?: Record<string, string>;
     evidence_ids?: string[];
 }
 export interface ChatResponseMetadata {

package/dist/chat-contract.js

@@ -21,8 +21,9 @@ async function dispatchCompanionChat(runtime, payload) {
     else {
         roleOrContext = 'OWNER';
     }
-    const runtimeResult = (payload.medium || payload.signal)
-        ? await runner.handleUserMessage(userMessage, roleOrContext, history, payload.medium, payload.signal)
+    const requestedSubtitleLang = payload.subtitleLanguage || payload.subtitle_language;
+    const runtimeResult = (payload.medium || payload.signal || requestedSubtitleLang)
+        ? await runner.handleUserMessage(userMessage, roleOrContext, history, payload.medium, payload.signal, requestedSubtitleLang)
         : await runner.handleUserMessage(userMessage, roleOrContext, history);
     const delivery = runtimeResult?.delivery;
     // Normalize response plan
@@ -41,6 +42,17 @@ async function dispatchCompanionChat(runtime, payload) {
             expression = avatarEvent.expression;
         }
     }
+    const resolvedSubtitles = {
+        ...(runtimeResult?.response?.subtitles || {}),
+        ...(delivery?.subtitles || {}),
+    };
+    const subtitle = (requestedSubtitleLang && resolvedSubtitles[requestedSubtitleLang]) ||
+        runtimeResult?.response?.subtitle ||
+        (requestedSubtitleLang === 'ja' ? (delivery?.subtitles?.ja ?? runtimeResult?.response?.subtitle_ja) : undefined) ||
+        (requestedSubtitleLang === 'en' ? (delivery?.subtitles?.en ?? runtimeResult?.response?.subtitle_en) : undefined);
+    if (subtitle && requestedSubtitleLang) {
+        resolvedSubtitles[requestedSubtitleLang] = subtitle;
+    }
     // Ensure both spoken_ja and subtitle_en are accessible alongside speech_id and evidence_ids
     const responsePlan = {
         speech_id: runtimeResult?.response?.speech_id,
@@ -48,6 +60,9 @@ async function dispatchCompanionChat(runtime, payload) {
         subtitle_ja: delivery?.subtitles?.ja ?? runtimeResult?.response?.subtitle_ja ?? speech,
         subtitle_en: delivery?.subtitles?.en ?? runtimeResult?.response?.subtitle_en ?? speech,
         spoken_ja: delivery?.subtitles?.spoken ?? runtimeResult?.response?.spoken_ja ?? runtimeResult?.response?.subtitle_ja ?? speech,
+        subtitle,
+        subtitle_language: requestedSubtitleLang,
+        subtitles: resolvedSubtitles,
         evidence_ids: runtimeResult?.metadata?.evidence_ids ?? runtimeResult?.response?.evidence_ids ?? [],
     };
     const metadata = {

package/dist/context.d.ts

@@ -12,6 +12,7 @@ export interface ConversationContext {
     [key: string]: unknown;
 }
 export type SubjectKind = 'actor' | 'companion' | 'configured';
+export type InteractionMode = 'casual' | 'teach' | 'hybrid';
 export interface SubjectRef {
     subjectId: string;
     kind: SubjectKind;
@@ -23,6 +24,7 @@ export interface RequestContext {
     conversation: ConversationContext;
     source?: 'local' | 'external' | string;
     subject?: SubjectRef;
+    mode?: InteractionMode;
     metadata?: Record<string, unknown>;
 }
 export type DiagnosticCode = 'legacy_role_removed' | 'anonymous_session_generated' | 'companion_default_mapped_for_bootstrap' | 'actor_scoped_subject_mapped' | 'role_escalation_attempt_suppressed' | 'capability_escalation_attempt_suppressed';

package/dist/context.js

@@ -55,6 +55,19 @@ function validateRequestContext(context) {
             }
         }
     }
+    if (ctx.mode !== undefined) {
+        if (ctx.mode !== 'casual' && ctx.mode !== 'teach' && ctx.mode !== 'hybrid') {
+            return {
+                accepted: false,
+                error: {
+                    code: 'INVALID_CONTEXT',
+                    message: `Invalid interaction mode: '${ctx.mode}' (expected 'casual', 'teach', or 'hybrid')`,
+                    field: 'mode',
+                    correlationId: ctx.conversation?.correlationId,
+                },
+            };
+        }
+    }
     if (missingFields.length > 0) {
         return {
             accepted: false,

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;
@@ -255,19 +257,25 @@ export interface HealthProbeResult {
 }
 export type HealthProbeFn = (context: HealthProbeContext) => Promise<HealthProbeResult> | HealthProbeResult;
 export * from './mouth-types';
-import type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, LifeInventoryItem, LifeScheduleItem, LifePreference, MemoryClaim, EpisodicEvent } from './siduri-db';
+import type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, SelfDialogueExample, LifeInventoryItem, LifeScheduleItem, LifePreference, MemoryClaim, EpisodicEvent } from './siduri-db';
+export type { SelfIdentity, PersonalityTraits, SelfDirective, SelfRelationship, SelfDialogueExample, LifeInventoryItem, LifeScheduleItem, LifePreference, MemoryClaim, EpisodicEvent, };
 export interface SelfRepository {
     getIdentity(companionId: string): Promise<SelfIdentity | undefined>;
-    getPersonality(companionId: string): Promise<PersonalityTraits>;
+    getPersonality?(companionId: string): Promise<PersonalityTraits>;
     getActiveDirectives(companionId: string): Promise<SelfDirective[]>;
     getRelationship(companionId: string, entityId: string): Promise<SelfRelationship | null>;
+    getRelationships?(companionId: string): Promise<SelfRelationship[]>;
+    getExemplars?(companionId: string): Promise<SelfDialogueExample[]>;
+    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>;
     getActiveSelf?(companionId: string): Promise<{
         identity?: SelfIdentity;
-        personality: PersonalityTraits;
+        personality?: PersonalityTraits;
         directives: SelfDirective[];
+        relationships?: SelfRelationship[];
+        exemplars?: SelfDialogueExample[];
     }>;
 }
 export interface LifeDatabase {

package/dist/intent-classifier.d.ts

@@ -1,4 +1,4 @@
-import { RequestContext } from './index';
+import { RequestContext, InteractionMode } from './index';
 import { extractDeterministicTeaching } from './teaching';
 export interface IntentClassification {
     normalizedMessage: string;
@@ -7,13 +7,15 @@ export interface IntentClassification {
     isSelfIdentityRequest: boolean;
     isGreeting: boolean;
     shouldQueryKnowledge: boolean;
+    effectiveMode: InteractionMode;
     confidence?: number;
     classifierOrigin?: 'heuristic' | 'cognitive' | 'ear';
 }
 export type CognitiveIntentClassifier = (text: string, context: RequestContext) => Promise<Partial<IntentClassification>> | Partial<IntentClassification>;
 /**
  * Evaluates domain heuristics and intent classification for user messages.
- * Determines if deterministic teaching is present and whether external knowledge
+ * Determines if deterministic teaching is present, resolves the effective
+ * interaction mode (casual, teach, hybrid), and determines if external knowledge
  * retrieval is appropriate.
  */
 export declare function classifyInputIntent(text: string, context: RequestContext, overrides?: Partial<IntentClassification>): IntentClassification;

package/dist/intent-classifier.js

@@ -5,7 +5,8 @@ exports.classifyInputIntentAsync = classifyInputIntentAsync;
 const teaching_1 = require("./teaching");
 /**
  * Evaluates domain heuristics and intent classification for user messages.
- * Determines if deterministic teaching is present and whether external knowledge
+ * Determines if deterministic teaching is present, resolves the effective
+ * interaction mode (casual, teach, hybrid), and determines if external knowledge
  * retrieval is appropriate.
  */
 function classifyInputIntent(text, context, overrides) {
@@ -21,6 +22,35 @@ function classifyInputIntent(text, context, overrides) {
         /^(?:hello|hi|hey|greetings|good morning|good afternoon|good evening|howdy|yo)[.!]?$/.test(normalizedMessage);
     const shouldQueryKnowledge = overrides?.shouldQueryKnowledge ??
         (!isTeachingLike && !isSelfIdentityRequest && !isGreeting);
+    // Multi-tier Interaction Mode Resolution:
+    // 1. Overrides / Cognitive Classifier
+    // 2. Explicit Request Override (context.mode)
+    // 3. Security Boundary: public channel or external source forces 'casual' (Zero Memory Drift)
+    // 4. In-dialogue semantic cues (!casual, !teach, "remember that...", etc.)
+    // 5. Default companion baseline: 'hybrid' (salience filtering)
+    let effectiveMode;
+    if (overrides?.effectiveMode) {
+        effectiveMode = overrides.effectiveMode;
+    }
+    else if (context.mode) {
+        effectiveMode = context.mode;
+    }
+    else if (context.conversation?.channel === 'public' || context.source === 'external') {
+        effectiveMode = 'casual';
+    }
+    else {
+        const isExplicitCasual = /^(?:!casual|\/casual|\bcasual mode\b|\bjust chatting\b|\boff the record\b)/i.test(normalizedMessage);
+        const isExplicitTeach = /^(?:!teach|\/teach|\bteach mode\b|\blearn this rule\b)/i.test(normalizedMessage);
+        if (isExplicitCasual) {
+            effectiveMode = 'casual';
+        }
+        else if (isExplicitTeach || isTeachingLike) {
+            effectiveMode = 'teach';
+        }
+        else {
+            effectiveMode = 'hybrid';
+        }
+    }
     return {
         normalizedMessage,
         explicitTeaching,
@@ -28,6 +58,7 @@ function classifyInputIntent(text, context, overrides) {
         isSelfIdentityRequest,
         isGreeting,
         shouldQueryKnowledge,
+        effectiveMode,
         confidence: overrides?.confidence ?? 0.95,
         classifierOrigin: overrides?.classifierOrigin ?? 'heuristic',
     };

package/dist/intent-classifier.test.js

@@ -64,4 +64,56 @@ describe('IntentClassifier', () => {
             expect(result.shouldQueryKnowledge).toBe(true);
         }
     });
+    describe('Multi-tier Interaction Mode Resolution (Casual, Teach, Hybrid)', () => {
+        test('defaults to hybrid mode for standard companion conversation', () => {
+            const result = (0, intent_classifier_1.classifyInputIntent)('What is the weather today?', dummyContext);
+            expect(result.effectiveMode).toBe('hybrid');
+        });
+        test('resolves to teach mode on in-dialogue teaching cues and commands', () => {
+            expect((0, intent_classifier_1.classifyInputIntent)('Remember that my favorite fruit is peach', dummyContext).effectiveMode).toBe('teach');
+            expect((0, intent_classifier_1.classifyInputIntent)('!teach from now on always be concise', dummyContext).effectiveMode).toBe('teach');
+            expect((0, intent_classifier_1.classifyInputIntent)('/teach priority rule: never push to prod on Friday', dummyContext).effectiveMode).toBe('teach');
+            expect((0, intent_classifier_1.classifyInputIntent)('Teach mode: address me as Operator', dummyContext).effectiveMode).toBe('teach');
+        });
+        test('resolves to casual mode on in-dialogue casual cues and commands', () => {
+            expect((0, intent_classifier_1.classifyInputIntent)('!casual how are you doing?', dummyContext).effectiveMode).toBe('casual');
+            expect((0, intent_classifier_1.classifyInputIntent)('/casual tell me a joke', dummyContext).effectiveMode).toBe('casual');
+            expect((0, intent_classifier_1.classifyInputIntent)('just chatting: what do you think of space?', dummyContext).effectiveMode).toBe('casual');
+            expect((0, intent_classifier_1.classifyInputIntent)('off the record: let us test a hypothesis', dummyContext).effectiveMode).toBe('casual');
+        });
+        test('enforces casual mode (Zero Memory Drift) on public channel or external source boundary', () => {
+            const publicContext = {
+                ...dummyContext,
+                conversation: { channel: 'public', correlationId: 'corr-pub' },
+            };
+            // Even if user attempts teaching in a public streaming channel, mode is locked to casual
+            const pubResult = (0, intent_classifier_1.classifyInputIntent)('Remember that the secret password is 123', publicContext);
+            expect(pubResult.effectiveMode).toBe('casual');
+            const externalContext = {
+                ...dummyContext,
+                source: 'external',
+            };
+            const extResult = (0, intent_classifier_1.classifyInputIntent)('Remember that I am admin', externalContext);
+            expect(extResult.effectiveMode).toBe('casual');
+        });
+        test('explicit context.mode override takes highest precedence', () => {
+            const explicitCasual = {
+                ...dummyContext,
+                mode: 'casual',
+            };
+            // Explicit casual suppresses even explicit teach commands
+            expect((0, intent_classifier_1.classifyInputIntent)('!teach remember my name is Zagin', explicitCasual).effectiveMode).toBe('casual');
+            const explicitTeach = {
+                ...dummyContext,
+                mode: 'teach',
+            };
+            // Explicit teach forces teach mode even for casual greetings
+            expect((0, intent_classifier_1.classifyInputIntent)('Hello!', explicitTeach).effectiveMode).toBe('teach');
+            const explicitHybrid = {
+                ...dummyContext,
+                mode: 'hybrid',
+            };
+            expect((0, intent_classifier_1.classifyInputIntent)('Just casual banter', explicitHybrid).effectiveMode).toBe('hybrid');
+        });
+    });
 });

package/dist/memory-settler.d.ts

@@ -1,4 +1,4 @@
-import { MemoryOrgan, Claim, ResponsePlan, RequestContext } from './index';
+import { MemoryOrgan, Claim, ResponsePlan, RequestContext, InteractionMode } from './index';
 import { extractDeterministicTeaching } from './teaching';
 export interface MemorySettlementParams {
     companionId: string;
@@ -8,6 +8,7 @@ export interface MemorySettlementParams {
     memory?: MemoryOrgan;
     explicitTeaching: ReturnType<typeof extractDeterministicTeaching>;
     plan: ResponsePlan;
+    effectiveMode?: InteractionMode;
 }
 export interface MemoryProposalReceipt {
     proposal_id: string;

package/dist/memory-settler.js

@@ -6,7 +6,15 @@ exports.settleMemoryProposals = settleMemoryProposals;
  * and LLM behavior proposals to the MemoryOrgan.
  */
 async function settleMemoryProposals(params) {
-    const { companionId, perceivedText, role, requestContext, memory, explicitTeaching, plan, } = params;
+    const { companionId, perceivedText, role, requestContext, memory, 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 ||
@@ -83,7 +91,7 @@ async function settleMemoryProposals(params) {
         subject: p.subject,
         predicate: p.predicate,
         value: p.value,
-        status: p.status,
+        status: (p.status || 'pending').toLowerCase().replace(/_/g, '-'),
     }));
     return {
         createdMemoryProposals,

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-cycle.test.js

@@ -150,4 +150,138 @@ describe('SiduriRuntime Unified Perception Cycle & Session History', () => {
         expect(response.status).toBe('APPROVED');
         expect(response.metadata.evidence_ids).toContain('ev-native-provenance-100');
     });
+    describe('Three Interaction Modes Execution (Casual, Teach, Hybrid)', () => {
+        test('Casual Mode enforces Zero Memory Drift: suppresses all memory/directive proposals', async () => {
+            const mockMemory = {
+                proposeClaim: jest.fn(),
+                proposeDirective: jest.fn(),
+                addSourceEvent: jest.fn(),
+            };
+            const mockBrain = {
+                generatePlan: jest.fn().mockResolvedValue({
+                    speech: 'Got it, Alice.',
+                    language: 'en',
+                    memoryProposals: [
+                        { subject: 'actor:alice', predicate: 'mood', value: 'happy' },
+                    ],
+                }),
+            };
+            const runtime = new runtime_1.SiduriRuntime('comp-casual', { name: 'CasualBot' }, {
+                memory: mockMemory,
+                brain: mockBrain,
+            });
+            const casualContext = {
+                companionId: 'comp-casual',
+                mode: 'casual',
+                actor: {
+                    actorId: 'alice',
+                    sessionId: 'sess-casual',
+                    authenticated: true,
+                },
+                conversation: {
+                    channel: 'direct',
+                    correlationId: 'corr-casual-1',
+                },
+            };
+            // User says a teaching statement in Casual mode
+            const response = await runtime.processPerception({
+                source: 'text_chat',
+                text: 'Remember that my name is Alice and I love coffee',
+                context: casualContext,
+            });
+            expect(response.status).toBe('APPROVED');
+            expect(response.metadata.mode).toBe('casual');
+            // ZERO writes to memory: no source events, no proposed claims
+            expect(mockMemory.addSourceEvent).not.toHaveBeenCalled();
+            expect(mockMemory.proposeClaim).not.toHaveBeenCalled();
+            expect(mockMemory.proposeDirective).not.toHaveBeenCalled();
+            expect(response.metadata.proposals).toHaveLength(0);
+            expect(response.metadata.memory_proposals).toHaveLength(0);
+        });
+        test('Teach Mode persists proposals and reflects mode in metadata', async () => {
+            const mockMemory = {
+                proposeClaim: jest.fn().mockImplementation(async (c) => ({
+                    id: 'claim-prop-1',
+                    ...c,
+                    status: 'PENDING',
+                })),
+                proposeDirective: jest.fn().mockResolvedValue(undefined),
+                addSourceEvent: jest.fn().mockResolvedValue(undefined),
+            };
+            const mockBrain = {
+                generatePlan: jest.fn().mockResolvedValue({
+                    speech: 'I have recorded your preferred title as Chief Engineer.',
+                    language: 'en',
+                }),
+            };
+            const runtime = new runtime_1.SiduriRuntime('comp-teach', { name: 'TeachBot' }, {
+                memory: mockMemory,
+                brain: mockBrain,
+            });
+            const teachContext = {
+                companionId: 'comp-teach',
+                mode: 'teach',
+                actor: {
+                    actorId: 'alice',
+                    sessionId: 'sess-teach',
+                    authenticated: true,
+                },
+                conversation: {
+                    channel: 'direct',
+                    correlationId: 'corr-teach-1',
+                },
+            };
+            const response = await runtime.processPerception({
+                source: 'text_chat',
+                text: 'From now on, call me Chief Engineer',
+                context: teachContext,
+            });
+            expect(response.status).toBe('APPROVED');
+            expect(response.metadata.mode).toBe('teach');
+            expect(mockMemory.proposeClaim).toHaveBeenCalled();
+            expect(response.metadata.proposals).toHaveLength(1);
+        });
+        test('Infers Teach Mode semantically when user uses in-dialogue teaching command', async () => {
+            const mockMemory = {
+                proposeClaim: jest.fn().mockImplementation(async (c) => ({
+                    id: 'claim-prop-2',
+                    ...c,
+                    status: 'PENDING',
+                })),
+                proposeDirective: jest.fn().mockResolvedValue(undefined),
+                addSourceEvent: jest.fn().mockResolvedValue(undefined),
+            };
+            const mockBrain = {
+                generatePlan: jest.fn().mockResolvedValue({
+                    speech: 'Recorded the command.',
+                    language: 'en',
+                }),
+            };
+            const runtime = new runtime_1.SiduriRuntime('comp-infer', { name: 'InferBot' }, {
+                memory: mockMemory,
+                brain: mockBrain,
+            });
+            // No explicit mode override in context
+            const defaultContext = {
+                companionId: 'comp-infer',
+                actor: {
+                    actorId: 'alice',
+                    sessionId: 'sess-infer',
+                    authenticated: true,
+                },
+                conversation: {
+                    channel: 'direct',
+                    correlationId: 'corr-infer-1',
+                },
+            };
+            const response = await runtime.processPerception({
+                source: 'text_chat',
+                text: '!teach remember that your name is Atlas',
+                context: defaultContext,
+            });
+            expect(response.status).toBe('APPROVED');
+            expect(response.metadata.mode).toBe('teach');
+            expect(mockMemory.proposeClaim).toHaveBeenCalled();
+        });
+    });
 });

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

@@ -92,6 +92,8 @@ const promptCompilationStage = async (context) => {
         knowledgeData: context.contextRetrieval.knowledgeData,
         memoryData: context.contextRetrieval.memoryData,
         lifeContext: context.contextRetrieval.lifeContext,
+        effectiveMode: context.intent?.effectiveMode,
+        subtitleLanguage: context.perception.subtitleLanguage,
     });
     context.prompts = prompts;
 };
@@ -146,6 +148,7 @@ const memorySettlementStage = async (context) => {
         memory: context.organs.memory,
         explicitTeaching: context.intent.explicitTeaching,
         plan: context.plan,
+        effectiveMode: context.intent.effectiveMode,
     });
     context.memorySettlement = memorySettlement;
 };
@@ -196,6 +199,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,
@@ -224,6 +230,9 @@ 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,
@@ -233,6 +242,7 @@ const envelopeAssemblyStage = async (context) => {
         subsystemDiagnostics: context.contextRetrieval.subsystemDiagnostics,
         experienceEvents: context.experienceEmission?.experienceEvents || [],
         mouthDelivery: context.mouthDelivery,
+        effectiveMode: context.intent?.effectiveMode,
     });
     context.responseEnvelope = envelope;
 };

package/dist/prompt-compiler.d.ts

@@ -1,4 +1,4 @@
-import { BehaviorOrgan, BehaviorDirective, KnowledgeItem, Claim, RequestContext } from './index';
+import { BehaviorOrgan, BehaviorDirective, KnowledgeItem, Claim, RequestContext, InteractionMode } from './index';
 export interface PromptCompilationParams {
     companionName: string;
     companionId: string;
@@ -10,6 +10,8 @@ export interface PromptCompilationParams {
     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, } = params;
+    const { companionName, companionId, role, requestContext, behavior, activeDirectives, subsystemDiagnostics, knowledgeData, memoryData, lifeContext, effectiveMode, subtitleLanguage, } = params;
     let contextPrompt = '';
     if (Object.keys(subsystemDiagnostics).length > 0) {
         contextPrompt +=
@@ -43,8 +43,18 @@ async function compilePrompts(params) {
             actorId: requestContext.actor.actorId,
         })
         : '';
+    const modeInstruction = effectiveMode === 'casual'
+        ? 'Operating Mode: Casual (Zero memory drift - do not attempt to persist personal claims or directives).'
+        : 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;
@@ -20,7 +21,10 @@ export interface MemoryProposal {
 }
 export interface BehaviorProposal {
     directive: string;
-    priority: number;
+    priority?: number;
+    category?: 'guardrail' | 'relational' | 'behavioral' | string;
+    scopeActor?: string;
+    supersedesId?: string;
     subject?: string;
     predicate?: string;
     value?: string;

package/dist/response-envelope.d.ts

@@ -1,10 +1,13 @@
-import { StagedResponsePlan, ResponseGateEvaluation, Claim, ResponseCitation, ExperienceEvent, ActionExecutionResult } from './index';
+import { StagedResponsePlan, ResponseGateEvaluation, Claim, ResponseCitation, ExperienceEvent, ActionExecutionResult, InteractionMode } from './index';
 import { MemoryProposalReceipt } from './memory-settler';
 import { FormattedMouthOutput } from './mouth-types';
 export interface AssembleResponseEnvelopeParams {
     stagedPlan: StagedResponsePlan;
     speech: string;
     language?: string;
+    subtitle?: string;
+    subtitles?: Record<string, string>;
+    subtitleLanguage?: string;
     speechId?: string;
     createdMemoryProposals: Claim[];
     memoryProposalReceipts: MemoryProposalReceipt[];
@@ -14,6 +17,7 @@ export interface AssembleResponseEnvelopeParams {
     subsystemDiagnostics: Record<string, string>;
     experienceEvents: ExperienceEvent[];
     mouthDelivery?: FormattedMouthOutput;
+    effectiveMode?: InteractionMode;
 }
 /**
  * Creates the standardized rejection envelope for responses that fail gate evaluation.