@siduri-x/core 2.0.3 → 2.0.5

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-retriever.d.ts

@@ -19,6 +19,9 @@ export interface RetrievedContext {
     collectedEvidence: EvidenceRecord[];
     citations: ResponseCitation[];
     lifeContext?: string[];
+    selfIdentity?: any;
+    selfRelationship?: any;
+    personality?: any;
 }
 /**
  * Concurrently queries Self, Knowledge (Life DB), External Knowledge, and Memory

package/dist/context-retriever.js

@@ -15,8 +15,8 @@ async function retrieveRuntimeContext(params) {
     const subsystemDiagnostics = {};
     // 1. Resolve External Knowledge organ (either explicitly passed or from legacy knowledge with .search)
     const extKnowledge = externalKnowledge || (knowledge && typeof knowledge.search === 'function' ? knowledge : undefined);
-    // 2. Query all 4 streams in parallel
-    const [knowledgeData, memoryData, selfOrMemoryDirectives, lifeContext] = await Promise.all([
+    // 2. Query streams in parallel
+    const [knowledgeData, memoryData, selfOrMemoryDirectives, lifeContext, selfIdentity, selfRelationship, personality,] = await Promise.all([
         // Stream A: External Cited Lore / Documentation
         extKnowledge && shouldQueryKnowledge && typeof extKnowledge.search === 'function'
             ? extKnowledge.search(perceivedText).catch((e) => {
@@ -62,6 +62,24 @@ async function retrieveRuntimeContext(params) {
                 return [];
             })
             : Promise.resolve([]),
+        // Stream E: Self Identity
+        self && typeof self.getIdentity === 'function'
+            ? self.getIdentity(companionId).catch((e) => {
+                console.error('[SiduriRuntime] Self identity failed:', e.message);
+                return undefined;
+            })
+            : Promise.resolve(undefined),
+        // Stream F: Self Relationship toward interacting actor
+        self && typeof self.getRelationship === 'function' && requestContext.actor?.actorId
+            ? self.getRelationship(companionId, requestContext.actor.actorId).catch((e) => {
+                console.error('[SiduriRuntime] Self relationship failed:', e.message);
+                return null;
+            })
+            : Promise.resolve(null),
+        // Stream G: Self Personality
+        self && typeof self.getPersonality === 'function'
+            ? self.getPersonality(companionId).catch(() => undefined)
+            : Promise.resolve(undefined),
     ]);
     const activeDirectives = (selfOrMemoryDirectives || []);
     // Build evidence records from retrieved external knowledge context
@@ -115,5 +133,8 @@ async function retrieveRuntimeContext(params) {
         collectedEvidence,
         citations,
         lifeContext,
+        selfIdentity,
+        selfRelationship,
+        personality,
     };
 }

package/dist/conversational-teach.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/conversational-teach.test.js

@@ -0,0 +1,513 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const index_1 = require("./index");
+describe('Conversational Teach Mode End-to-End Lifecycle', () => {
+    let tmpDir;
+    let dbPath;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'siduri-teach-test-'));
+        dbPath = path.join(tmpDir, 'siduri.db');
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    });
+    /**
+     * Helper to build a SelfRepository wrapping a SiduriDatabase
+     */
+    function createSelfRepository(db) {
+        return {
+            getIdentity: async (companionId) => db.getIdentity(companionId),
+            setIdentity: async (identity) => db.setIdentity(identity),
+            getPersonality: async (companionId) => db.getPersonality(companionId) || {
+                warmth: 0.5,
+                formality: 0.5,
+                sarcasm: 0.5,
+                verbosity: 0.5,
+                curiosity: 0.5,
+            },
+            setPersonality: async (companionId, traits) => db.setPersonality(companionId, traits),
+            getActiveDirectives: async (companionId) => db.getActiveDirectives(companionId),
+            commitDirectives: async (companionId, directives) => {
+                for (const d of directives) {
+                    db.commitDirective(d);
+                }
+            },
+            getRelationship: async (companionId, entityId) => db.getRelationship(companionId, entityId) || null,
+            updateRelationship: async (companionId, rel) => db.upsertRelationship({ ...rel, companionId }),
+            approveDirective: async (id, companionId) => db.approveDirective(id, companionId),
+            rejectDirective: async (id, companionId) => db.rejectDirective(id, companionId),
+            revokeDirective: async (id, companionId) => db.revokeDirective(id, companionId),
+        };
+    }
+    /**
+     * Helper to build a MemoryOrgan wrapping a SiduriDatabase
+     */
+    function createMemoryOrgan(db) {
+        return {
+            initialize: async () => { },
+            proposeClaim: async (claim) => db.proposeClaim(claim),
+            searchClaims: async () => [],
+            getClaims: async (limit) => db.getAllClaims(undefined, limit || 500),
+            getPendingClaims: async (limit) => db.getAllClaims(undefined, limit || 500).filter((c) => c.status === 'pending'),
+            approveClaim: async (id) => db.approveClaim(id),
+            rejectClaim: async (id) => db.rejectClaim(id),
+            getDirectives: async (companionId) => db.getActiveDirectives(companionId || 'default'),
+            proposeDirective: async (dir) => {
+                const id = `dir-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+                const directive = {
+                    ...dir,
+                    id,
+                    status: 'pending',
+                    createdAt: new Date().toISOString(),
+                };
+                db.commitDirective(directive);
+                return directive;
+            },
+            approveDirective: async (id, companionId) => db.approveDirective(id, companionId),
+            rejectDirective: async (id, companionId) => db.rejectDirective(id, companionId),
+            revokeDirective: async (id, companionId) => db.revokeDirective(id, companionId),
+            disableDirective: async (id, companionId) => db.disableDirective(id, companionId),
+        };
+    }
+    /**
+     * Mock behavior compiler that compiles active_self tags from context
+     */
+    function createBehaviorCompiler() {
+        return {
+            compile: async (ctx) => {
+                const parts = ['<active_self>'];
+                if (ctx.identity) {
+                    parts.push(`Identity:\n- Name: ${ctx.identity.name}`);
+                    if (ctx.identity.archetype || ctx.identity.role) {
+                        parts.push(`- Role: ${ctx.identity.role || ctx.identity.archetype}`);
+                    }
+                }
+                if (ctx.relationship) {
+                    parts.push(`Relationship Stance:\n- Stance toward ${ctx.relationship.entityId}: ${ctx.relationship.stance} (Role: ${ctx.relationship.role})`);
+                }
+                if (ctx.directives && ctx.directives.length > 0) {
+                    parts.push(`Behavioral Directives:\n${ctx.directives.map((d) => `- ${d.directive}`).join('\n')}`);
+                }
+                parts.push('</active_self>');
+                return parts.join('\n\n');
+            },
+        };
+    }
+    function createRequestContext(companionId, mode = 'teach', actorId = 'kur-zagin') {
+        return {
+            companionId,
+            mode,
+            actor: {
+                actorId,
+                sessionId: 'sess-teach-1',
+                authorizationRole: 'OWNER',
+                authenticated: true,
+            },
+            conversation: {
+                channel: 'direct',
+                correlationId: `corr-${Date.now()}`,
+            },
+        };
+    }
+    // =========================================================================
+    // Test A: Conversational role teaching in Teach mode
+    // =========================================================================
+    it('Test A: teaches companion role in Teach mode, approves proposal, and reflects role in Active Self', async () => {
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const companionId = 'comp-test-a';
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const behavior = createBehaviorCompiler();
+        const mockBrain = {
+            generatePlan: jest.fn().mockImplementation(async (brainCtx) => {
+                return {
+                    speech: 'Understood, I have acknowledged my role.',
+                    language: 'en',
+                    // Brain context should have received the system prompt
+                    _receivedSystemPrompt: brainCtx.systemPrompt,
+                };
+            }),
+        };
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            brain: mockBrain,
+            memory,
+            self,
+            behavior,
+        });
+        await runtime.initialize();
+        // 1. Send conversational role teaching message
+        const perceptionResult = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'Siduri, you are an AI researcher at VXNUS Studio.',
+            context: createRequestContext(companionId, 'teach'),
+        });
+        expect(perceptionResult.status).toBe('APPROVED');
+        // 2. Verify proposal was generated
+        const proposals = perceptionResult.metadata?.proposals || [];
+        expect(proposals.length).toBeGreaterThanOrEqual(1);
+        const roleProposal = proposals.find((p) => p.predicate === 'role' || p.predicate === 'archetype');
+        expect(roleProposal).toBeDefined();
+        expect(roleProposal.value).toBe('AI researcher at VXNUS Studio');
+        expect(roleProposal.status).toBe('pending');
+        // 3. Truth Gate check: Before approval, SelfRepository must NOT contain the new role
+        const identityBefore = await self.getIdentity(companionId);
+        expect(identityBefore?.role).toBeUndefined();
+        expect(identityBefore?.archetype).toBeUndefined();
+        // 4. Operator / Owner approves the proposal
+        const approveResult = await runtime.approveProposal(roleProposal.id, { companionId });
+        expect(approveResult.success).toBe(true);
+        // 5. Verify SelfRepository now has the learned role
+        const identityAfter = await self.getIdentity(companionId);
+        expect(identityAfter).toBeDefined();
+        expect(identityAfter?.role).toBe('AI researcher at VXNUS Studio');
+        expect(identityAfter?.archetype).toBe('AI researcher at VXNUS Studio');
+        // Also verify a relational directive acknowledging the role was added
+        const directives = await self.getActiveDirectives(companionId);
+        const roleDirective = directives.find((d) => d.directive.includes('AI researcher at VXNUS Studio'));
+        expect(roleDirective).toBeDefined();
+        // 6. Next conversational turn: verify prompt compiler injects the updated Active Self
+        await runtime.processPerception({
+            source: 'text_chat',
+            text: 'What is your primary mission?',
+            context: createRequestContext(companionId, 'hybrid'),
+        });
+        expect(mockBrain.generatePlan).toHaveBeenCalled();
+        const lastCallCtx = mockBrain.generatePlan.mock.calls[1][0];
+        expect(lastCallCtx.systemPrompt).toContain('<active_self>');
+        expect(lastCallCtx.systemPrompt).toContain('Role: AI researcher at VXNUS Studio');
+        db.close();
+    });
+    // =========================================================================
+    // Test B: Creator relationship teaching
+    // =========================================================================
+    it('Test B: teaches creator relationship, approves proposal, and updates relationship stance', async () => {
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const companionId = 'comp-test-b';
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const behavior = createBehaviorCompiler();
+        const mockBrain = {
+            generatePlan: jest.fn().mockResolvedValue({
+                speech: 'Greetings, Creator.',
+                language: 'en',
+            }),
+        };
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            brain: mockBrain,
+            memory,
+            self,
+            behavior,
+        });
+        await runtime.initialize();
+        // 1. Send creator teaching message
+        const perceptionResult = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'I am your creator, Kur Zagin.',
+            context: createRequestContext(companionId, 'teach', 'actor:kur-zagin'),
+        });
+        const proposals = perceptionResult.metadata?.proposals || [];
+        const relProposal = proposals.find((p) => p.predicate === 'stated_relationship' ||
+            p.predicate === 'relationship' ||
+            p.claimType === 'relationship');
+        expect(relProposal).toBeDefined();
+        expect(relProposal.value).toBe('creator');
+        // 2. Truth Gate: Before approval, relationship does not have creator stance
+        const relBefore = await self.getRelationship?.(companionId, 'actor:kur-zagin');
+        expect(relBefore?.role).toBeUndefined();
+        // 3. Approve the relationship proposal
+        await runtime.approveProposal(relProposal.id, { companionId });
+        // 4. Verify SelfRepository now has creator relationship with loyal stance
+        const relAfter = await self.getRelationship?.(companionId, 'actor:kur-zagin');
+        expect(relAfter).toBeDefined();
+        expect(relAfter?.role).toBe('creator');
+        expect(relAfter?.stance).toBe('familiar_loyal');
+        expect(relAfter?.trustScore).toBe(1.0);
+        // 5. Subsequent conversation retrieves relationship in prompt
+        await runtime.processPerception({
+            source: 'text_chat',
+            text: 'Status update please.',
+            context: createRequestContext(companionId, 'hybrid', 'actor:kur-zagin'),
+        });
+        const lastCallCtx = mockBrain.generatePlan.mock.calls[1][0];
+        expect(lastCallCtx.systemPrompt).toContain('Stance toward actor:kur-zagin: familiar_loyal (Role: creator)');
+        db.close();
+    });
+    // =========================================================================
+    // Test C: Behavioral rule teaching
+    // =========================================================================
+    it('Test C: teaches behavioral rule, generates proposal, approves, and activates directive in Self', async () => {
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const companionId = 'comp-test-c';
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const behavior = createBehaviorCompiler();
+        const mockBrain = {
+            generatePlan: jest.fn().mockResolvedValue({
+                speech: 'Rule noted.',
+                language: 'en',
+            }),
+        };
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            brain: mockBrain,
+            memory,
+            self,
+            behavior,
+        });
+        await runtime.initialize();
+        // 1. Send behavioral rule teaching message
+        const perceptionResult = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'Remember this rule: be concise when answering technical questions.',
+            context: createRequestContext(companionId, 'teach'),
+        });
+        // Check behavioral proposals or memory proposals
+        const behavioralReceipts = perceptionResult.metadata?.behavioral_proposals || [];
+        const memoryProposals = perceptionResult.metadata?.proposals || [];
+        const hasDirectiveProposal = behavioralReceipts.length > 0 ||
+            memoryProposals.some((p) => p.predicate === 'rule' || p.predicate === 'behavioral_rule');
+        expect(hasDirectiveProposal).toBe(true);
+        const directiveId = behavioralReceipts[0]?.directive_id;
+        const proposalId = memoryProposals[0]?.id;
+        // 2. Active directives before approval must not include the new rule
+        const directivesBefore = await self.getActiveDirectives(companionId);
+        expect(directivesBefore.some((d) => d.directive.toLowerCase().includes('be concise when answering technical questions'))).toBe(false);
+        // 3. Approve directive via runtime
+        if (directiveId) {
+            await runtime.approveDirective(directiveId, { companionId });
+        }
+        else if (proposalId) {
+            await runtime.approveProposal(proposalId, { companionId });
+        }
+        // 4. Verify directive is now ACTIVE in SelfRepository
+        const directivesAfter = await self.getActiveDirectives(companionId);
+        expect(directivesAfter.some((d) => d.directive.toLowerCase().includes('be concise when answering technical questions'))).toBe(true);
+        db.close();
+    });
+    // =========================================================================
+    // Test D: Casual banter in Casual mode (Zero Memory Drift)
+    // =========================================================================
+    it('Test D: casual banter in casual mode causes Zero Memory Drift and does NOT mutate Self', async () => {
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const companionId = 'comp-test-d';
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const mockBrain = {
+            generatePlan: jest.fn().mockResolvedValue({
+                speech: 'Haha, thank you! I try my best.',
+                language: 'en',
+            }),
+        };
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            brain: mockBrain,
+            memory,
+            self,
+        });
+        await runtime.initialize();
+        // "You are probably the funniest AI I've ever talked to." in casual mode
+        const perceptionResult = await runtime.processPerception({
+            source: 'text_chat',
+            text: "You are probably the funniest AI I've ever talked to.",
+            context: createRequestContext(companionId, 'casual'),
+        });
+        expect(perceptionResult.status).toBe('APPROVED');
+        // Zero proposals allowed in casual mode
+        expect(perceptionResult.metadata?.proposals).toEqual([]);
+        expect(perceptionResult.metadata?.memory_proposals).toEqual([]);
+        // Self must remain unchanged
+        const identity = await self.getIdentity(companionId);
+        expect(identity?.role).toBeUndefined();
+        expect(identity?.archetype).toBeUndefined();
+        const directives = await self.getActiveDirectives(companionId);
+        expect(directives).toHaveLength(0);
+        db.close();
+    });
+    // =========================================================================
+    // Test E: Approval gating: rejection leaves Self unchanged
+    // =========================================================================
+    it('Test E: rejecting a proposal prevents mutation of Self', async () => {
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const companionId = 'comp-test-e';
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const mockBrain = {
+            generatePlan: jest.fn().mockResolvedValue({
+                speech: 'Understood.',
+                language: 'en',
+            }),
+        };
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            brain: mockBrain,
+            memory,
+            self,
+        });
+        await runtime.initialize();
+        // 1. Propose a role change
+        const perceptionResult = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'Siduri, your role is Security Officer.',
+            context: createRequestContext(companionId, 'teach'),
+        });
+        const proposal = perceptionResult.metadata?.proposals?.[0];
+        expect(proposal).toBeDefined();
+        // 2. Reject the proposal
+        await runtime.rejectProposal(proposal.id, { companionId });
+        // 3. Verify Self is NOT mutated
+        const identity = await self.getIdentity(companionId);
+        expect(identity?.role).toBeUndefined();
+        expect(identity?.archetype).toBeUndefined();
+        db.close();
+    });
+    // =========================================================================
+    // Test F: Cross-restart durability (survives runtime restart)
+    // =========================================================================
+    it('Test F: persists learned state across runtime destruction and recreation', async () => {
+        const companionId = 'comp-test-f';
+        // --- Phase 1: Runtime 1 teaches and approves ---
+        {
+            const db1 = new index_1.SiduriDatabase({ dbPath });
+            const self1 = createSelfRepository(db1);
+            const memory1 = createMemoryOrgan(db1);
+            const mockBrain1 = {
+                generatePlan: jest.fn().mockResolvedValue({
+                    speech: 'I have recorded my new role as Lead Architect.',
+                    language: 'en',
+                }),
+            };
+            const runtime1 = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+                brain: mockBrain1,
+                memory: memory1,
+                self: self1,
+            });
+            await runtime1.initialize();
+            const res = await runtime1.processPerception({
+                source: 'text_chat',
+                text: 'Siduri, you are the Lead Architect at VXNUS Studio.',
+                context: createRequestContext(companionId, 'teach'),
+            });
+            const roleProposal = res.metadata?.proposals?.find((p) => p.predicate === 'role');
+            expect(roleProposal).toBeDefined();
+            await runtime1.approveProposal(roleProposal.id, { companionId });
+            // Verify in runtime 1
+            const id1 = await self1.getIdentity(companionId);
+            expect(id1?.role).toBe('Lead Architect at VXNUS Studio');
+            // Close and destroy runtime 1 completely
+            db1.close();
+        }
+        // --- Phase 2: Runtime 2 initialized afresh pointing to same SQLite database ---
+        {
+            const db2 = new index_1.SiduriDatabase({ dbPath });
+            const self2 = createSelfRepository(db2);
+            const memory2 = createMemoryOrgan(db2);
+            const behavior2 = createBehaviorCompiler();
+            const mockBrain2 = {
+                generatePlan: jest.fn().mockResolvedValue({
+                    speech: 'Ready to build architecture.',
+                    language: 'en',
+                }),
+            };
+            const runtime2 = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+                brain: mockBrain2,
+                memory: memory2,
+                self: self2,
+                behavior: behavior2,
+            });
+            await runtime2.initialize();
+            // Verify that runtime 2 retrieves the learned role from SQLite!
+            const id2 = await self2.getIdentity(companionId);
+            expect(id2).toBeDefined();
+            expect(id2?.role).toBe('Lead Architect at VXNUS Studio');
+            expect(id2?.archetype).toBe('Lead Architect at VXNUS Studio');
+            // Verify that conversation in runtime 2 retrieves the learned role in prompt compilation
+            await runtime2.processPerception({
+                source: 'text_chat',
+                text: 'What do you do?',
+                context: createRequestContext(companionId, 'hybrid'),
+            });
+            const lastCallCtx = mockBrain2.generatePlan.mock.calls[0][0];
+            expect(lastCallCtx.systemPrompt).toContain('Role: Lead Architect at VXNUS Studio');
+            db2.close();
+        }
+    });
+    // =========================================================================
+    // Test G: Idempotency (duplicate approval does not corrupt database)
+    // =========================================================================
+    it('Test G: approving the same proposal twice is idempotent and does not create duplicate entries', async () => {
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const companionId = 'comp-test-g';
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const mockBrain = {
+            generatePlan: jest.fn().mockResolvedValue({
+                speech: 'Understood.',
+                language: 'en',
+            }),
+        };
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            brain: mockBrain,
+            memory,
+            self,
+        });
+        await runtime.initialize();
+        const res = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'Siduri, you are a Research Specialist.',
+            context: createRequestContext(companionId, 'teach'),
+        });
+        const proposal = res.metadata?.proposals?.[0];
+        expect(proposal).toBeDefined();
+        // Approve once
+        await runtime.approveProposal(proposal.id, { companionId });
+        const idFirst = await self.getIdentity(companionId);
+        expect(idFirst?.role).toBe('Research Specialist');
+        // Approve a second time (should be completely idempotent and not error)
+        await runtime.approveProposal(proposal.id, { companionId });
+        const idSecond = await self.getIdentity(companionId);
+        expect(idSecond?.role).toBe('Research Specialist');
+        // Check directives: should only have one directive for acknowledging the role
+        const directives = await self.getActiveDirectives(companionId);
+        const roleDirectives = directives.filter((d) => d.directive.includes('Research Specialist'));
+        expect(roleDirectives).toHaveLength(1);
+        db.close();
+    });
+});