@sidurijs/core 1.0.0

package/dist/conversational-teach.test.js

@@ -0,0 +1,941 @@
+"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 () => [],
+            getApprovedClaims: async (companionId, limit) => db.getApprovedClaims(companionId || 'default', limit || 50),
+            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.identity.origin) {
+                        parts.push(`- Origin/Created By: ${ctx.identity.origin}`);
+                    }
+                }
+                if (ctx.relationship) {
+                    const nameStr = ctx.relationship.name ? ` [Name: ${ctx.relationship.name}]` : '';
+                    parts.push(`Relationship Stance:\n- Stance toward ${ctx.relationship.entityId}${nameStr}: ${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()}`,
+            },
+        };
+    }
+    function createCognitiveMockBrain(companionId) {
+        return {
+            generatePlan: jest.fn().mockImplementation(async (brainCtx) => {
+                const lastMsg = brainCtx.recentMessages?.[brainCtx.recentMessages.length - 1]?.content || '';
+                const memoryProposals = [];
+                const behaviorProposals = [];
+                if (/AI researcher at VXNUS Studio/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: `companion:${companionId}`,
+                        predicate: 'role',
+                        value: 'AI researcher at VXNUS Studio',
+                    });
+                    behaviorProposals.push({
+                        directive: 'Acknowledge role as AI researcher at VXNUS Studio',
+                        category: 'relational',
+                        subject: `companion:${companionId}`,
+                        predicate: 'role',
+                        value: 'AI researcher at VXNUS Studio',
+                    });
+                }
+                else if (/Lead Architect at VXNUS Studio/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: `companion:${companionId}`,
+                        predicate: 'role',
+                        value: 'Lead Architect at VXNUS Studio',
+                    });
+                }
+                else if (/Research Specialist/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: `companion:${companionId}`,
+                        predicate: 'role',
+                        value: 'Research Specialist',
+                    });
+                }
+                else if (/Security Officer/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: `companion:${companionId}`,
+                        predicate: 'role',
+                        value: 'Security Officer',
+                    });
+                }
+                else if (/VXNUS Studio Staff/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: `companion:${companionId}`,
+                        predicate: 'role',
+                        value: 'VXNUS Studio Staff',
+                    });
+                }
+                if (/\bcreator\b/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: 'actor:kur-zagin',
+                        predicate: 'stated_relationship',
+                        value: 'creator',
+                        claimType: 'relationship',
+                    });
+                    behaviorProposals.push({
+                        directive: 'Recognize actor:kur-zagin stated relationship as creator',
+                        category: 'relational',
+                        subject: 'actor:kur-zagin',
+                        predicate: 'stated_relationship',
+                        value: 'creator',
+                    });
+                }
+                if (/Kur Zagin/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: 'actor:kur-zagin',
+                        predicate: 'name',
+                        value: 'Kur Zagin',
+                        claimType: 'preference',
+                    });
+                    behaviorProposals.push({
+                        directive: 'Address actor:kur-zagin as Kur Zagin',
+                        category: 'relational',
+                        subject: 'actor:kur-zagin',
+                        predicate: 'name',
+                        value: 'Kur Zagin',
+                    });
+                }
+                if (/be concise when answering technical questions/i.test(lastMsg)) {
+                    behaviorProposals.push({
+                        directive: 'Be concise when answering technical questions',
+                        category: 'behavioral',
+                        priority: 60,
+                    });
+                    memoryProposals.push({
+                        subject: 'actor:kur-zagin',
+                        predicate: 'rule',
+                        value: 'Be concise when answering technical questions',
+                    });
+                }
+                return {
+                    speech: 'Understood, I have acknowledged your input.',
+                    language: 'en',
+                    memoryProposals: memoryProposals.length > 0 ? memoryProposals : undefined,
+                    behaviorProposals: behaviorProposals.length > 0 ? behaviorProposals : undefined,
+                    _receivedSystemPrompt: brainCtx.systemPrompt,
+                };
+            }),
+        };
+    }
+    // =========================================================================
+    // 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 = createCognitiveMockBrain(companionId);
+        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 = createCognitiveMockBrain(companionId);
+        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 = createCognitiveMockBrain(companionId);
+        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 = createCognitiveMockBrain(companionId);
+        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 = createCognitiveMockBrain(companionId);
+            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 = createCognitiveMockBrain(companionId);
+            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 = createCognitiveMockBrain(companionId);
+        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();
+    });
+    // =========================================================================
+    // Test H: Natural conversational teaching (past-tense role, user name, creator)
+    // =========================================================================
+    it('Test H: teaches companion past role ("she was VXNUS Studio Staff"), creator, and name, then recognizes user on subsequent turn', async () => {
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const companionId = 'comp-test-h';
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const behavior = createBehaviorCompiler();
+        const mockBrain = createCognitiveMockBrain(companionId);
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            brain: mockBrain,
+            memory,
+            self,
+            behavior,
+        });
+        await runtime.initialize();
+        // 1. "she was VXNUS Studio Staff" in Teach mode
+        const resRole = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'She was VXNUS Studio Staff.',
+            context: createRequestContext(companionId, 'teach', 'actor:kur-zagin'),
+        });
+        expect(resRole.status).toBe('APPROVED');
+        const roleProp = resRole.metadata?.proposals?.find((p) => p.predicate === 'role');
+        expect(roleProp).toBeDefined();
+        expect(roleProp.value).toBe('VXNUS Studio Staff');
+        await runtime.approveProposal(roleProp.id, { companionId });
+        // 2. "my name is Kur Zagin" in Teach mode
+        const resName = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'My name is Kur Zagin.',
+            context: createRequestContext(companionId, 'teach', 'actor:kur-zagin'),
+        });
+        expect(resName.status).toBe('APPROVED');
+        const nameProp = resName.metadata?.proposals?.find((p) => p.predicate === 'name');
+        expect(nameProp).toBeDefined();
+        expect(nameProp.value).toBe('Kur Zagin');
+        await runtime.approveProposal(nameProp.id, { companionId });
+        // 3. "I am your creator" in Teach mode
+        const resRel = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'I am your creator.',
+            context: createRequestContext(companionId, 'teach', 'actor:kur-zagin'),
+        });
+        expect(resRel.status).toBe('APPROVED');
+        const relProp = resRel.metadata?.proposals?.find((p) => p.predicate === 'stated_relationship');
+        expect(relProp).toBeDefined();
+        await runtime.approveProposal(relProp.id, { companionId });
+        // 4. Verify Self relationship has both creator stance AND user name preserved
+        const rel = await self.getRelationship?.(companionId, 'actor:kur-zagin');
+        expect(rel).toBeDefined();
+        expect(rel?.role).toBe('creator');
+        expect(rel?.stance).toBe('familiar_loyal');
+        expect(rel?.name).toBe('Kur Zagin');
+        // 5. Subsequent conversation turn: "do you know me?"
+        await runtime.processPerception({
+            source: 'text_chat',
+            text: 'do you know me?',
+            context: createRequestContext(companionId, 'hybrid', 'actor:kur-zagin'),
+        });
+        const lastCallCtx = mockBrain.generatePlan.mock.calls[mockBrain.generatePlan.mock.calls.length - 1][0];
+        // Active Self contains both the creator stance and the user's name
+        expect(lastCallCtx.systemPrompt).toContain('Role: VXNUS Studio Staff');
+        expect(lastCallCtx.systemPrompt).toContain('familiar_loyal');
+        expect(lastCallCtx.systemPrompt).toContain('Kur Zagin');
+        db.close();
+    });
+    // =========================================================================
+    // Test I: Benchmark replication (name, creator, new chat turn-1 recognition)
+    // =========================================================================
+    it('Test I: reproduces benchmark scenario: teaches name, teaches creator relationship, and verifies new session recognizes creator in origin and relationship', async () => {
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const companionId = 'comp-test-i';
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const behavior = createBehaviorCompiler();
+        const mockBrain = {
+            generatePlan: jest.fn().mockImplementation(async (brainCtx) => {
+                const lastMsg = brainCtx.recentMessages?.[brainCtx.recentMessages.length - 1]?.content || '';
+                const memoryProposals = [];
+                const behaviorProposals = [];
+                if (/your name is Siduri/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: 'companion:self',
+                        predicate: 'name',
+                        value: 'Siduri',
+                    });
+                    behaviorProposals.push({
+                        directive: 'Address self as Siduri',
+                        category: 'relational',
+                        subject: 'companion:self',
+                        predicate: 'name',
+                        value: 'Siduri',
+                    });
+                }
+                if (/i am Kur Zagin, your creator/i.test(lastMsg)) {
+                    memoryProposals.push({
+                        subject: 'actor:kur_zagin',
+                        predicate: 'name',
+                        value: 'Kur Zagin',
+                    });
+                    memoryProposals.push({
+                        subject: 'actor:kur_zagin',
+                        predicate: 'stated_relationship',
+                        value: 'creator of companion Siduri',
+                    });
+                    behaviorProposals.push({
+                        directive: 'Acknowledge actor:kur_zagin as creator of companion Siduri',
+                        category: 'relational',
+                        subject: 'actor:kur_zagin',
+                        predicate: 'stated_relationship',
+                        value: 'creator of companion Siduri',
+                    });
+                    behaviorProposals.push({
+                        directive: 'Address actor:kur_zagin as Kur Zagin',
+                        category: 'behavioral',
+                        subject: 'actor:kur_zagin',
+                        predicate: 'name',
+                        value: 'Kur Zagin',
+                    });
+                }
+                return {
+                    speech: 'I understand and acknowledge.',
+                    language: 'en',
+                    memoryProposals: memoryProposals.length > 0 ? memoryProposals : undefined,
+                    behaviorProposals: behaviorProposals.length > 0 ? behaviorProposals : undefined,
+                    _receivedSystemPrompt: brainCtx.systemPrompt,
+                };
+            }),
+        };
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            brain: mockBrain,
+            memory,
+            self,
+            behavior,
+        });
+        await runtime.initialize();
+        // Session 1 - Turn 1: "your name is Siduri"
+        const res1 = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'your name is Siduri',
+            context: createRequestContext(companionId, 'teach', 'owner-user'),
+        });
+        expect(res1.status).toBe('APPROVED');
+        const nameProp = res1.metadata?.proposals?.find((p) => p.predicate === 'name');
+        expect(nameProp).toBeDefined();
+        await runtime.approveProposal(nameProp.id, { companionId });
+        // Verify companion name in self_identity
+        const idStep1 = await self.getIdentity(companionId);
+        expect(idStep1?.name).toBe('Siduri');
+        // Session 1 - Turn 2: "i am Kur Zagin, your creator"
+        const res2 = await runtime.processPerception({
+            source: 'text_chat',
+            text: 'i am Kur Zagin, your creator',
+            context: createRequestContext(companionId, 'teach', 'owner-user'),
+        });
+        expect(res2.status).toBe('APPROVED');
+        // Approve both proposals (name and creator of companion Siduri)
+        const proposals2 = res2.metadata?.proposals || [];
+        const creatorProp = proposals2.find((p) => p.predicate === 'stated_relationship');
+        const userProp = proposals2.find((p) => p.predicate === 'name');
+        expect(creatorProp).toBeDefined();
+        expect(userProp).toBeDefined();
+        await runtime.approveProposal(creatorProp.id, { companionId });
+        await runtime.approveProposal(userProp.id, { companionId });
+        // Also approve the behavioral directives
+        const dirProps = res2.metadata?.behavioral_proposals || [];
+        for (const d of dirProps) {
+            if (d.directive_id) {
+                await runtime.approveDirective(d.directive_id, { companionId });
+            }
+        }
+        // Verify self_identity.origin has been dual-promoted!
+        const idStep2 = await self.getIdentity(companionId);
+        expect(idStep2?.name).toBe('Siduri');
+        expect(idStep2?.origin).toBe('Kur Zagin');
+        // Verify relationship has creator role, loyal stance, and user name
+        const relStep2 = await self.getRelationship(companionId, 'actor:kur_zagin');
+        expect(relStep2).toBeDefined();
+        expect(relStep2?.role).toBe('creator');
+        expect(relStep2?.stance).toBe('familiar_loyal');
+        expect(relStep2?.trustScore).toBe(1.0);
+        expect(relStep2?.name).toBe('Kur Zagin');
+        // Verify single-owner fallback: an incoming request with 'owner-user' gets the primary relationship!
+        const relOwnerUser = await self.getRelationship(companionId, 'owner-user');
+        expect(relOwnerUser).toBeDefined();
+        expect(relOwnerUser?.name).toBe('Kur Zagin');
+        expect(relOwnerUser?.role).toBe('creator');
+        expect(relOwnerUser?.stance).toBe('familiar_loyal');
+        // =======================================================================
+        // Session 2 ("New Chat"): user opens a fresh session as 'owner-user'
+        // =======================================================================
+        // Turn 1: "hey, who are you?"
+        await runtime.processPerception({
+            source: 'text_chat',
+            text: 'hey, who are you?',
+            context: createRequestContext(companionId, 'hybrid', 'owner-user'),
+        });
+        const calls = mockBrain.generatePlan.mock.calls;
+        const newChatTurn1Ctx = calls[calls.length - 1][0];
+        // Identity nucleus has origin
+        expect(newChatTurn1Ctx.systemPrompt).toContain('Name: Siduri');
+        expect(newChatTurn1Ctx.systemPrompt).toContain('Origin/Created By: Kur Zagin');
+        // Relationship stance recognizes Kur Zagin as creator
+        expect(newChatTurn1Ctx.systemPrompt).toContain('Kur Zagin');
+        expect(newChatTurn1Ctx.systemPrompt).toContain('familiar_loyal');
+        // Turn 2: "who is your creator?"
+        await runtime.processPerception({
+            source: 'text_chat',
+            text: 'who is your creator?',
+            context: createRequestContext(companionId, 'hybrid', 'owner-user'),
+        });
+        const newChatTurn2Ctx = calls[calls.length - 1][0];
+        expect(newChatTurn2Ctx.systemPrompt).toContain('Origin/Created By: Kur Zagin');
+        // Turn 3: From an anonymous guest session:
+        // Should NOT get the personal relationship stance, but Identity origin remains!
+        await runtime.processPerception({
+            source: 'text_chat',
+            text: 'who is your creator?',
+            context: createRequestContext(companionId, 'hybrid', 'anonymous-session'),
+        });
+        const guestTurnCtx = calls[calls.length - 1][0];
+        expect(guestTurnCtx.systemPrompt).toContain('Origin/Created By: Kur Zagin');
+        expect(guestTurnCtx.systemPrompt).not.toContain('Stance toward anonymous-session [Name: Kur Zagin]');
+        // Turn 4: "who am i?" from owner session:
+        // Approved memory claims are retrieved in MEMORY: context even if FTS search yielded 0 keyword matches
+        await runtime.processPerception({
+            source: 'text_chat',
+            text: 'who am i?',
+            context: createRequestContext(companionId, 'hybrid', 'owner-user'),
+        });
+        const whoAmICtx = calls[calls.length - 1][0];
+        expect(whoAmICtx.contextPrompt).toContain('MEMORY:');
+        expect(whoAmICtx.contextPrompt).toContain('Kur Zagin');
+        db.close();
+    });
+    it('promotes approved Life / Knowledge proposals to sovereign Life DB via Truth Gate', async () => {
+        const companionId = 'comp-truth-knowledge';
+        const db = new index_1.SiduriDatabase({ dbPath });
+        const self = createSelfRepository(db);
+        const memory = createMemoryOrgan(db);
+        const mockKnowledge = {
+            entities: {
+                saveEntity: jest.fn(async (entity) => db.upsertEntity(entity)),
+            },
+            events: {
+                addEvent: jest.fn(async (event) => db.addEvent(event)),
+            },
+            tasks: {
+                saveTask: jest.fn(async (task) => db.upsertTask(task)),
+            },
+            schedule: {
+                saveItem: jest.fn(async (sch) => db.upsertScheduleItem(sch)),
+            },
+            preferences: {
+                setPreference: jest.fn(async (pref) => db.upsertPreference(pref)),
+            },
+            queryContext: jest.fn(async () => []),
+        };
+        const runtime = new index_1.SiduriRuntime(companionId, {
+            name: 'Siduri',
+            initialMode: 'teach',
+        }, {
+            self,
+            memory,
+            knowledge: mockKnowledge,
+        });
+        // 1. Propose knowledge claims in memory store (quarantined as PENDING)
+        const entityClaim = await memory.proposeClaim({
+            companionId,
+            subject: 'entity:Workstation Rig',
+            predicate: 'inventory',
+            value: 'Threadripper 64-core',
+            claimType: 'life_entity',
+            evidence: { domain: 'hardware', properties: { cores: 64, ram: '256GB' } },
+        });
+        const eventClaim = await memory.proposeClaim({
+            companionId,
+            subject: 'finance:expense',
+            predicate: 'expense',
+            value: '45.00',
+            claimType: 'life_event',
+            evidence: { metricValue: -45.0, stream: 'finance', category: 'dining' },
+        });
+        const taskClaim = await memory.proposeClaim({
+            companionId,
+            subject: 'task:Review PR',
+            predicate: 'todo',
+            value: 'Review PR #42 for Life DB',
+            claimType: 'life_task',
+            evidence: { status: 'in_progress' },
+        });
+        // Before approval, Life DB tables in sqlite are empty
+        expect(db.getEntities(companionId)).toHaveLength(0);
+        expect(db.getEvents(companionId)).toHaveLength(0);
+        expect(db.getTasks(companionId)).toHaveLength(0);
+        // 2. Truth Gate Approval
+        const resEntity = await runtime.approveProposal(entityClaim.id, { companionId });
+        expect(resEntity.success).toBe(true);
+        expect(resEntity.target).toBe('knowledge');
+        const resEvent = await runtime.approveProposal(eventClaim.id, { companionId });
+        expect(resEvent.success).toBe(true);
+        expect(resEvent.target).toBe('knowledge');
+        const resTask = await runtime.approveProposal(taskClaim.id, { companionId });
+        expect(resTask.success).toBe(true);
+        expect(resTask.target).toBe('knowledge');
+        // 3. Verify persistent commit to sovereign Life DB in SQLite
+        const entities = db.getEntities(companionId);
+        expect(entities).toHaveLength(1);
+        expect(entities[0].name).toBe('Workstation Rig');
+        expect(entities[0].domain).toBe('hardware');
+        const events = db.getEvents(companionId);
+        expect(events).toHaveLength(1);
+        expect(events[0].stream).toBe('finance');
+        expect(events[0].metricValue).toBe(-45.0);
+        const tasks = db.getTasks(companionId);
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0].title).toBe('Review PR #42 for Life DB');
+        expect(tasks[0].status).toBe('in_progress');
+        db.close();
+    });
+    it('updates companion identity name dynamically when companion naming claim or directive is approved', async () => {
+        const companionId = 'dynamic-companion';
+        const db = new index_1.SiduriDatabase({ dbPath: ':memory:' });
+        const memory = createMemoryOrgan(db);
+        const self = createSelfRepository(db);
+        const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
+            memory,
+            self,
+        });
+        await runtime.initialize();
+        // Verify initial default identity
+        const initialIdentity = await self.getIdentity(companionId);
+        expect(initialIdentity?.name || 'Siduri').toBe('Siduri');
+        // 1. Propose and approve claim with subject "assistant" and predicate "name"
+        const nameClaim = await memory.proposeClaim({
+            companionId,
+            subject: 'assistant',
+            predicate: 'name',
+            value: 'Athena',
+            claimType: 'semantic',
+        });
+        await runtime.approveProposal(nameClaim.id, { companionId });
+        const identityAfterClaim = await self.getIdentity(companionId);
+        expect(identityAfterClaim?.name).toBe('Athena');
+        // 2. Propose and approve behavioral directive "Address companion as Athena Prime"
+        const dir = {
+            id: 'dir-name-test-1',
+            companionId,
+            directive: 'Address companion as Athena Prime',
+            priority: 80,
+            status: 'pending',
+            category: 'relational',
+            createdAt: new Date().toISOString(),
+        };
+        await self.commitDirectives(companionId, [dir]);
+        await runtime.approveDirective(dir.id, { companionId });
+        const identityAfterDirective = await self.getIdentity(companionId);
+        expect(identityAfterDirective?.name).toBe('Athena Prime');
+        db.close();
+    });
+});