@siduri-x/core 2.0.2 → 2.0.3

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

@@ -255,19 +255,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 ||

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

@@ -92,6 +92,7 @@ const promptCompilationStage = async (context) => {
         knowledgeData: context.contextRetrieval.knowledgeData,
         memoryData: context.contextRetrieval.memoryData,
         lifeContext: context.contextRetrieval.lifeContext,
+        effectiveMode: context.intent?.effectiveMode,
     });
     context.prompts = prompts;
 };
@@ -146,6 +147,7 @@ const memorySettlementStage = async (context) => {
         memory: context.organs.memory,
         explicitTeaching: context.intent.explicitTeaching,
         plan: context.plan,
+        effectiveMode: context.intent.effectiveMode,
     });
     context.memorySettlement = memorySettlement;
 };
@@ -233,6 +235,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,7 @@ export interface PromptCompilationParams {
     knowledgeData: KnowledgeItem[];
     memoryData: Claim[];
     lifeContext?: string[];
+    effectiveMode?: InteractionMode;
 }
 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, } = params;
     let contextPrompt = '';
     if (Object.keys(subsystemDiagnostics).length > 0) {
         contextPrompt +=
@@ -43,8 +43,14 @@ 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 systemPrompt = [
         `You are ${companionName}.`,
+        modeInstruction,
         '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

@@ -20,7 +20,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,4 +1,4 @@
-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 {
@@ -14,6 +14,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.

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, speechId, createdMemoryProposals, memoryProposalReceipts, actionResults, filteredEvidenceIds, filteredCitations, subsystemDiagnostics, experienceEvents, mouthDelivery, } = params;
+    const { stagedPlan, speech, language, speechId, createdMemoryProposals, memoryProposalReceipts, actionResults, filteredEvidenceIds, filteredCitations, subsystemDiagnostics, experienceEvents, mouthDelivery, effectiveMode, } = params;
     return {
         status: 'APPROVED',
         response_id: stagedPlan.responseId,
@@ -42,6 +42,7 @@ function assembleResponseEnvelope(params) {
         },
         delivery: mouthDelivery,
         metadata: {
+            mode: effectiveMode ?? 'hybrid',
             language,
             proposals: createdMemoryProposals,
             memory_proposals: memoryProposalReceipts,

package/dist/siduri-db.d.ts

@@ -2,33 +2,46 @@ export interface SelfIdentity {
     companionId: string;
     name: string;
     archetype?: string;
+    origin?: string;
+    ethos?: string;
     version: string;
     updatedAt: string;
 }
 export interface PersonalityTraits {
-    warmth: number;
-    formality: number;
-    sarcasm: number;
-    verbosity: number;
-    curiosity: number;
+    warmth?: number;
+    formality?: number;
+    sarcasm?: number;
+    verbosity?: number;
+    curiosity?: number;
 }
 export interface SelfDirective {
     id: string;
     companionId: string;
-    priority: number;
+    priority?: number;
     directive: string;
     status: 'PENDING' | 'ACTIVE' | 'DISABLED' | 'SUPERSEDED' | 'REJECTED' | 'REVOKED' | 'EXPIRED';
     category: 'behavioral' | 'guardrail' | 'relational' | string;
+    scopeActor?: string;
     supersedesId?: string;
     createdAt?: string;
 }
 export interface SelfRelationship {
     companionId: string;
     entityId: string;
-    entityType: 'human' | 'companion' | 'system';
-    trustScore: number;
-    familiarity: number;
+    entityType?: 'human' | 'companion' | 'system';
+    role?: string;
+    stance?: string;
+    trustScore?: number;
+    familiarity?: number;
     interactionConventions: string[];
+    updatedAt?: string;
+}
+export interface SelfDialogueExample {
+    id?: string;
+    companionId?: string;
+    user: string;
+    assistant: string;
+    createdAt?: string;
 }
 export interface LifeInventoryItem {
     id: string;
@@ -107,7 +120,10 @@ export declare class SiduriDatabase {
     expireDirective(id: string, companionId?: string): void;
     disableDirective(id: string, companionId?: string): void;
     getRelationship(companionId: string, entityId: string): SelfRelationship | undefined;
+    getRelationships(companionId: string): SelfRelationship[];
     upsertRelationship(rel: SelfRelationship): void;
+    getExemplars(companionId: string): SelfDialogueExample[];
+    setExemplars(companionId: string, exemplars: SelfDialogueExample[]): void;
     getInventory(companionId: string, domain?: string): LifeInventoryItem[];
     upsertInventoryItem(item: LifeInventoryItem): void;
     getFinanceEntries(companionId: string, limit?: number): LifeFinanceEntry[];

package/dist/siduri-db.js

@@ -20,6 +20,8 @@ class SiduriDatabase {
         companion_id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         archetype TEXT,
+        origin TEXT,
+        ethos TEXT,
         version TEXT NOT NULL,
         updated_at TEXT DEFAULT (datetime('now'))
       );
@@ -41,6 +43,7 @@ class SiduriDatabase {
         directive TEXT NOT NULL,
         status TEXT DEFAULT 'ACTIVE',
         category TEXT DEFAULT 'behavioral',
+        scope_actor TEXT,
         supersedes_id TEXT,
         created_at TEXT DEFAULT (datetime('now'))
       );
@@ -48,13 +51,24 @@ class SiduriDatabase {
       CREATE TABLE IF NOT EXISTS self_relationships (
         companion_id TEXT NOT NULL,
         entity_id TEXT NOT NULL,
-        entity_type TEXT NOT NULL,
+        entity_type TEXT NOT NULL DEFAULT 'human',
+        role TEXT DEFAULT 'user',
+        stance TEXT DEFAULT 'neutral',
         trust_score REAL DEFAULT 0.5,
         familiarity REAL DEFAULT 0.5,
         interaction_conventions TEXT,
+        updated_at TEXT DEFAULT (datetime('now')),
         PRIMARY KEY(companion_id, entity_id)
       );
 
+      CREATE TABLE IF NOT EXISTS self_exemplars (
+        id TEXT PRIMARY KEY,
+        companion_id TEXT NOT NULL,
+        user_prompt TEXT NOT NULL,
+        companion_response TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
       -- Knowledge Tables
       CREATE TABLE IF NOT EXISTS life_inventory (
         id TEXT PRIMARY KEY,
@@ -159,6 +173,42 @@ class SiduriDatabase {
         catch {
             // Column already exists
         }
+        try {
+            this.db.exec("ALTER TABLE self_identity ADD COLUMN origin TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_identity ADD COLUMN ethos TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_directives ADD COLUMN scope_actor TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_relationships ADD COLUMN role TEXT DEFAULT 'user'");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_relationships ADD COLUMN stance TEXT DEFAULT 'neutral'");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE self_relationships ADD COLUMN updated_at TEXT");
+        }
+        catch {
+            // Column already exists
+        }
     }
     close() {
         this.db.close();
@@ -175,21 +225,25 @@ class SiduriDatabase {
             companionId: row.companion_id,
             name: row.name,
             archetype: row.archetype || undefined,
+            origin: row.origin || undefined,
+            ethos: row.ethos || undefined,
             version: row.version,
             updatedAt: row.updated_at
         };
     }
     setIdentity(identity) {
         const stmt = this.db.prepare(`
-      INSERT INTO self_identity (companion_id, name, archetype, version, updated_at)
-      VALUES (?, ?, ?, ?, datetime('now'))
+      INSERT INTO self_identity (companion_id, name, archetype, origin, ethos, version, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
       ON CONFLICT(companion_id) DO UPDATE SET
         name = excluded.name,
         archetype = excluded.archetype,
+        origin = excluded.origin,
+        ethos = excluded.ethos,
         version = excluded.version,
         updated_at = datetime('now')
     `);
-        stmt.run(identity.companionId, identity.name, identity.archetype || null, identity.version);
+        stmt.run(identity.companionId, identity.name, identity.archetype || null, identity.origin || null, identity.ethos || null, identity.version);
     }
     getPersonality(companionId) {
         const stmt = this.db.prepare('SELECT * FROM self_personality WHERE companion_id = ?');
@@ -231,16 +285,17 @@ class SiduriDatabase {
             directive: row.directive,
             status: row.status,
             category: row.category,
+            scopeActor: row.scope_actor || undefined,
             supersedesId: row.supersedes_id || undefined,
             createdAt: row.created_at
         }));
     }
     commitDirective(directive) {
         const stmt = this.db.prepare(`
-      INSERT INTO self_directives (id, companion_id, priority, directive, status, category, supersedes_id, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO self_directives (id, companion_id, priority, directive, status, category, scope_actor, supersedes_id, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        stmt.run(directive.id, directive.companionId, directive.priority, directive.directive, directive.status, directive.category, directive.supersedesId || null, directive.createdAt || new Date().toISOString());
+        stmt.run(directive.id, directive.companionId, directive.priority !== undefined ? directive.priority : 50, directive.directive, directive.status, directive.category || 'behavioral', directive.scopeActor || null, directive.supersedesId || null, directive.createdAt || new Date().toISOString());
     }
     getDirective(id, companionId) {
         const stmt = companionId
@@ -256,6 +311,7 @@ class SiduriDatabase {
             directive: row.directive,
             status: row.status,
             category: row.category,
+            scopeActor: row.scope_actor || undefined,
             supersedesId: row.supersedes_id || undefined,
             createdAt: row.created_at,
         };
@@ -351,23 +407,66 @@ class SiduriDatabase {
         return {
             companionId: row.companion_id,
             entityId: row.entity_id,
-            entityType: row.entity_type,
-            trustScore: row.trust_score,
-            familiarity: row.familiarity,
-            interactionConventions: row.interaction_conventions ? JSON.parse(row.interaction_conventions) : []
+            entityType: row.entity_type || 'human',
+            role: row.role || 'user',
+            stance: row.stance || 'neutral',
+            trustScore: row.trust_score !== undefined && row.trust_score !== null ? row.trust_score : 0.5,
+            familiarity: row.familiarity !== undefined && row.familiarity !== null ? row.familiarity : 0.5,
+            interactionConventions: row.interaction_conventions ? JSON.parse(row.interaction_conventions) : [],
+            updatedAt: row.updated_at || undefined,
         };
     }
+    getRelationships(companionId) {
+        const stmt = this.db.prepare('SELECT * FROM self_relationships WHERE companion_id = ? ORDER BY entity_id ASC');
+        return stmt.all(companionId).map((row) => ({
+            companionId: row.companion_id,
+            entityId: row.entity_id,
+            entityType: row.entity_type || 'human',
+            role: row.role || 'user',
+            stance: row.stance || 'neutral',
+            trustScore: row.trust_score !== undefined && row.trust_score !== null ? row.trust_score : 0.5,
+            familiarity: row.familiarity !== undefined && row.familiarity !== null ? row.familiarity : 0.5,
+            interactionConventions: row.interaction_conventions ? JSON.parse(row.interaction_conventions) : [],
+            updatedAt: row.updated_at || undefined,
+        }));
+    }
     upsertRelationship(rel) {
         const stmt = this.db.prepare(`
-      INSERT INTO self_relationships (companion_id, entity_id, entity_type, trust_score, familiarity, interaction_conventions)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO self_relationships (companion_id, entity_id, entity_type, role, stance, trust_score, familiarity, interaction_conventions, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
       ON CONFLICT(companion_id, entity_id) DO UPDATE SET
         entity_type = excluded.entity_type,
+        role = excluded.role,
+        stance = excluded.stance,
         trust_score = excluded.trust_score,
         familiarity = excluded.familiarity,
-        interaction_conventions = excluded.interaction_conventions
+        interaction_conventions = excluded.interaction_conventions,
+        updated_at = datetime('now')
     `);
-        stmt.run(rel.companionId, rel.entityId, rel.entityType, rel.trustScore, rel.familiarity, JSON.stringify(rel.interactionConventions || []));
+        stmt.run(rel.companionId, rel.entityId, rel.entityType || 'human', rel.role || 'user', rel.stance || 'neutral', rel.trustScore !== undefined && rel.trustScore !== null ? rel.trustScore : 0.5, rel.familiarity !== undefined && rel.familiarity !== null ? rel.familiarity : 0.5, JSON.stringify(rel.interactionConventions || []));
+    }
+    getExemplars(companionId) {
+        const stmt = this.db.prepare('SELECT * FROM self_exemplars WHERE companion_id = ? ORDER BY created_at ASC');
+        return stmt.all(companionId).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            user: row.user_prompt,
+            assistant: row.companion_response,
+            createdAt: row.created_at,
+        }));
+    }
+    setExemplars(companionId, exemplars) {
+        const delStmt = this.db.prepare('DELETE FROM self_exemplars WHERE companion_id = ?');
+        delStmt.run(companionId);
+        const insertStmt = this.db.prepare(`
+      INSERT INTO self_exemplars (id, companion_id, user_prompt, companion_response, created_at)
+      VALUES (?, ?, ?, ?, datetime('now'))
+    `);
+        for (let i = 0; i < exemplars.length; i++) {
+            const ex = exemplars[i];
+            const id = ex.id || `ex-${i + 1}-${Date.now()}`;
+            insertStmt.run(id, companionId, ex.user, ex.assistant);
+        }
     }
     // ==========================================
     // Knowledge / Life DB Methods

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siduri-x/core",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Core runtime types, evidence protocol, action dispatcher, capability validation, and SiduriRuntime protocol",
   "license": "Apache-2.0",
   "repository": {