@siduri-x/core 2.0.3 → 2.0.5

package/dist/siduri-db.test.js

@@ -370,7 +370,7 @@ describe('SiduriDatabase', () => {
                 evidence: ['lore book chapter 3'],
                 assertedAt: new Date().toISOString(),
             });
-            expect(claim.status).toBe('PENDING');
+            expect(claim.status).toBe('pending');
             expect(claim.subject).toBe('Kur');
             expect(claim.predicate).toBe('is');
             expect(claim.value).toBe('a dark entity from the underworld');
@@ -401,7 +401,7 @@ describe('SiduriDatabase', () => {
             const approved = db.getApprovedClaims('siduri-test');
             expect(approved).toHaveLength(1);
             expect(approved[0].id).toBe(claim1.id);
-            expect(approved[0].status).toBe('APPROVED');
+            expect(approved[0].status).toBe('approved');
         });
         it('searches claims using FTS5 full-text search', () => {
             db = new siduri_db_1.SiduriDatabase({ dbPath });
@@ -617,7 +617,7 @@ describe('SiduriDatabase', () => {
             expect(db2.getInventory(cId)).toHaveLength(1);
             expect(db2.getInventory(cId)[0].entityName).toBe('Aged Wine');
             const claims = db2.searchClaims(cId, 'wine');
-            expect(claims.some((c) => c.id === claim.id && c.status === 'APPROVED')).toBe(true);
+            expect(claims.some((c) => c.id === claim.id && c.status === 'approved')).toBe(true);
             db2.close();
             // Prevent afterEach from double-closing
             db = null;
@@ -691,7 +691,7 @@ describe('SiduriDatabase', () => {
             const active = db.getActiveDirectives(cId);
             expect(active).toHaveLength(1);
             expect(active[0].id).toBe(dId);
-            expect(active[0].status).toBe('ACTIVE');
+            expect(active[0].status).toBe('active');
             // 3. Revoke directive
             db.revokeDirective(dId);
             expect(db.getActiveDirectives(cId)).toHaveLength(0);
@@ -702,7 +702,7 @@ describe('SiduriDatabase', () => {
                 companionId: cId,
                 priority: 50,
                 directive: 'Unsafe rule',
-                status: 'PENDING',
+                status: 'pending',
                 category: 'behavioral',
             });
             db.rejectDirective(d2Id);
@@ -717,22 +717,23 @@ describe('SiduriDatabase', () => {
                 companionId: cId,
                 priority: 50,
                 directive: 'Rejected directive',
-                status: 'REJECTED',
+                status: 'rejected',
                 category: 'behavioral',
             });
-            expect(() => db.approveDirective('dir-rejected-1')).toThrow(/invalid transition from status 'REJECTED' to 'ACTIVE'/);
+            expect(() => db.approveDirective('dir-rejected-1')).toThrow(/invalid transition from status 'rejected' to 'active'/i);
             // 2. Commit directive in ACTIVE state
             db.commitDirective({
                 id: 'dir-active-1',
                 companionId: cId,
                 priority: 50,
                 directive: 'Already active directive',
-                status: 'ACTIVE',
+                status: 'active',
                 category: 'behavioral',
             });
-            expect(() => db.approveDirective('dir-active-1')).toThrow(/invalid transition from status 'ACTIVE' to 'ACTIVE'/);
+            // Approving an already-active directive is now idempotent (no-op, does not throw)
+            expect(() => db.approveDirective('dir-active-1')).not.toThrow();
             // 3. Rejecting an already ACTIVE directive throws
-            expect(() => db.rejectDirective('dir-active-1')).toThrow(/invalid transition from status 'ACTIVE' to 'REJECTED'/);
+            expect(() => db.rejectDirective('dir-active-1')).toThrow(/invalid transition from status 'active' to 'rejected'/i);
         });
         it('automatically marks prior directive as SUPERSEDED when approving superseding directive', () => {
             db = new siduri_db_1.SiduriDatabase({ dbPath });
@@ -766,7 +767,7 @@ describe('SiduriDatabase', () => {
             expect(active).toHaveLength(1);
             expect(active[0].id).toBe('dir-replacement-1');
             const original = db.getDirective('dir-original-1', cId);
-            expect(original?.status).toBe('SUPERSEDED');
+            expect(original?.status).toBe('superseded');
         });
         it('enforces companion isolation on directive approval', () => {
             db = new siduri_db_1.SiduriDatabase({ dbPath });
@@ -777,14 +778,14 @@ describe('SiduriDatabase', () => {
                 companionId: cIdB,
                 priority: 50,
                 directive: 'Beta private rule',
-                status: 'PENDING',
+                status: 'pending',
                 category: 'behavioral',
             });
             // Alpha attempts to approve Beta's directive scoped to Alpha
             db.approveDirective('dir-beta-1', cIdA);
-            // Beta's directive must remain PENDING and unapproved
+            // Beta's directive must remain pending and unapproved
             const betaDirective = db.getDirective('dir-beta-1', cIdB);
-            expect(betaDirective?.status).toBe('PENDING');
+            expect(betaDirective?.status).toBe('pending');
             expect(db.getActiveDirectives(cIdB)).toHaveLength(0);
             // Beta approves its own directive successfully
             db.approveDirective('dir-beta-1', cIdB);
@@ -800,7 +801,7 @@ describe('SiduriDatabase', () => {
                 predicate: 'likes',
                 value: 'matcha',
             });
-            expect(claim.status).toBe('PENDING');
+            expect(claim.status).toBe('pending');
             expect(db.getApprovedClaims(cId)).toHaveLength(0);
             // Approve
             db.approveClaim('claim-1');
@@ -835,7 +836,7 @@ describe('SiduriDatabase', () => {
             });
             db.rejectClaim(rejectedClaim.id);
             // Attempting to approve a REJECTED claim must throw
-            expect(() => db.approveClaim(rejectedClaim.id)).toThrow(/invalid transition from status 'REJECTED' to 'APPROVED'/);
+            expect(() => db.approveClaim(rejectedClaim.id)).toThrow(/invalid transition from status 'rejected' to 'approved'/i);
             // 2. Propose and approve claim, then revoke
             const revokedClaim = db.proposeClaim({
                 id: 'claim-revoked',
@@ -847,7 +848,7 @@ describe('SiduriDatabase', () => {
             db.approveClaim(revokedClaim.id);
             db.revokeClaim(revokedClaim.id);
             // Attempting to approve a REVOKED claim must throw
-            expect(() => db.approveClaim(revokedClaim.id)).toThrow(/invalid transition from status 'REVOKED' to 'APPROVED'/);
+            expect(() => db.approveClaim(revokedClaim.id)).toThrow(/invalid transition from status 'revoked' to 'approved'/i);
             // 3. Propose and expire claim
             const expiredClaim = db.proposeClaim({
                 id: 'claim-expired',
@@ -858,7 +859,7 @@ describe('SiduriDatabase', () => {
             });
             db.expireClaim(expiredClaim.id);
             // Attempting to approve an EXPIRED claim must throw
-            expect(() => db.approveClaim(expiredClaim.id)).toThrow(/invalid transition from status 'EXPIRED' to 'APPROVED'/);
+            expect(() => db.approveClaim(expiredClaim.id)).toThrow(/invalid transition from status 'expired' to 'approved'/i);
         });
     });
 });

package/dist/teaching.js

@@ -20,12 +20,20 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
     if (!text) {
         return { claims, behaviorProposals };
     }
-    const actorId = context?.actor?.actorId;
-    const actorSubject = actorId ? `actor:${actorId}` : 'actor:anonymous';
+    const rawActorId = context?.actor?.actorId;
+    const cleanActorId = rawActorId ? rawActorId.replace(/^actor:/, '') : undefined;
+    const actorSubject = cleanActorId ? `actor:${cleanActorId}` : 'actor:anonymous';
     const companionId = context?.companionId || 'default';
     const sensitivity = context?.conversation?.channel === 'public' ? 'public' : 'private';
+    // Strip leading companion addressing: "Siduri, you are...", "Hey Siduri: ..."
+    const cleanText = text.replace(/^(?:(?:hey|hi|hello)\s+)?(?:siduri|companion|assistant)\s*[,:]\s*/i, '');
+    const isTeachMode = context?.mode === 'teach' || /^(?:!teach|\/teach|\bteach mode\b|\blearn this rule\b)/i.test(text);
+    const hasExplicitTeachingCue = isTeachMode ||
+        /\b(?:remember that|remember this rule|remember this|from now on|learn this|rule:)\b/i.test(text);
+    // Casual banter / hedged opinion filter to avoid mutating Self from generic conversation
+    const isCasualBanter = /\b(?:probably|maybe|such a|so |very |really |just |not |the funniest|the best|the worst|the coolest|great|awesome|funny|nice|kind|crazy|wrong|right|silly)\b/i;
     // 1. Companion's Name: "your name is X" / "you are called X"
-    const companionNameMatch = text.match(/\b(?:your name is|you are called)\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    const companionNameMatch = cleanText.match(/\b(?:your name is|you are called)\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
     if (companionNameMatch) {
         const name = cleanValue(companionNameMatch[1], 80);
         claims.push({
@@ -45,12 +53,124 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             predicate: 'name',
             value: name,
             memoryClass: 'identity',
+            category: 'relational',
             sourceEventId,
         });
     }
-    // 2. Actor's Name: "my name is X"
-    const myNameMatch = text.match(/\bmy name is\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
-    if (myNameMatch && !/\b(?:private|public|everywhere)\b/i.test(text)) {
+    // 2. Identity / Role Teaching:
+    // "your role is X", "you work at X", "you were created by X", "you are from X",
+    // or explicit "you are [an/a] X [at Y]" when in teach mode or with explicit teaching cues
+    const roleMatch = cleanText.match(/\byour role is\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    const workMatch = cleanText.match(/\byou work (?:at|for)\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    const createdByMatch = cleanText.match(/\byou (?:were|are) created by\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    const fromMatch = cleanText.match(/\byou are from\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    // Match "you are [an/a/the] X [at Y]" only when in Teach mode or explicit teaching cues, and not casual banter
+    const youAreMatch = (isTeachMode || hasExplicitTeachingCue)
+        ? cleanText.match(/\b(?:remember that\s+)?you are\s+(?:(?:an?|the)\s+)?(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i)
+        : null;
+    const validYouAreRole = youAreMatch &&
+        !companionNameMatch &&
+        !fromMatch &&
+        !isCasualBanter.test(youAreMatch[1]) &&
+        !/^(?:called|named)\b/i.test(youAreMatch[1])
+        ? cleanValue(youAreMatch[1].replace(/^(?:an?|the)\s+/i, ''), 100)
+        : undefined;
+    const rawEffectiveRole = roleMatch ? cleanValue(roleMatch[1], 100) : validYouAreRole;
+    const effectiveRole = rawEffectiveRole ? rawEffectiveRole.replace(/^(?:an?|the)\s+/i, '') : undefined;
+    if (effectiveRole) {
+        claims.push({
+            subject: `companion:${companionId}`,
+            predicate: 'role',
+            value: effectiveRole,
+            content: `The companion's role is ${effectiveRole}.`,
+            claimType: 'semantic',
+            provenance: 'deterministic_teaching',
+            sensitivity: 'public',
+            sourceEventId,
+        });
+        behaviorProposals.push({
+            directive: `Acknowledge role as ${effectiveRole}`,
+            priority: 70,
+            subject: `companion:${companionId}`,
+            predicate: 'role',
+            value: effectiveRole,
+            memoryClass: 'identity',
+            category: 'relational',
+            sourceEventId,
+        });
+    }
+    if (workMatch) {
+        const workplace = cleanValue(workMatch[1], 80);
+        claims.push({
+            subject: `companion:${companionId}`,
+            predicate: 'origin',
+            value: workplace,
+            content: `The companion works at ${workplace}.`,
+            claimType: 'semantic',
+            provenance: 'deterministic_teaching',
+            sensitivity: 'public',
+            sourceEventId,
+        });
+        behaviorProposals.push({
+            directive: `Acknowledge workplace as ${workplace}`,
+            priority: 70,
+            subject: `companion:${companionId}`,
+            predicate: 'origin',
+            value: workplace,
+            memoryClass: 'identity',
+            category: 'relational',
+            sourceEventId,
+        });
+    }
+    if (createdByMatch) {
+        const creator = cleanValue(createdByMatch[1], 80);
+        claims.push({
+            subject: `companion:${companionId}`,
+            predicate: 'created_by',
+            value: creator,
+            content: `The companion was created by ${creator}.`,
+            claimType: 'semantic',
+            provenance: 'deterministic_teaching',
+            sensitivity: 'public',
+            sourceEventId,
+        });
+        behaviorProposals.push({
+            directive: `Acknowledge creator as ${creator}`,
+            priority: 75,
+            subject: `companion:${companionId}`,
+            predicate: 'created_by',
+            value: creator,
+            memoryClass: 'identity',
+            category: 'relational',
+            sourceEventId,
+        });
+    }
+    if (fromMatch) {
+        const origin = cleanValue(fromMatch[1], 80);
+        claims.push({
+            subject: `companion:${companionId}`,
+            predicate: 'origin',
+            value: origin,
+            content: `The companion is from ${origin}.`,
+            claimType: 'semantic',
+            provenance: 'deterministic_teaching',
+            sensitivity: 'public',
+            sourceEventId,
+        });
+        behaviorProposals.push({
+            directive: `Acknowledge origin as ${origin}`,
+            priority: 70,
+            subject: `companion:${companionId}`,
+            predicate: 'origin',
+            value: origin,
+            memoryClass: 'identity',
+            category: 'relational',
+            sourceEventId,
+        });
+    }
+    // 3. Actor's Name: "my name is X"
+    const myNameMatch = cleanText.match(/\bmy name is\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    if (myNameMatch && !/\b(?:private|public|everywhere)\b/i.test(cleanText)) {
         const name = cleanValue(myNameMatch[1], 80);
         claims.push({
             subject: actorSubject,
@@ -63,8 +183,8 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             sourceEventId,
         });
     }
-    // 3. Preferred Address / Call me X: "call me X"
-    const callMeMatch = text.match(/\b(?:(?:from now on|only),?\s*)?call me\s+(.+?)(?:\s+(?:in private|privately|in public|publicly|everywhere|in direct conversations))?(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    // 4. Preferred Address / Call me X: "call me X"
+    const callMeMatch = cleanText.match(/\b(?:(?:from now on|only),?\s*)?call me\s+(.+?)(?:\s+(?:in private|privately|in public|publicly|everywhere|in direct conversations))?(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
     if (callMeMatch) {
         const address = cleanValue(callMeMatch[1], 80);
         const directiveInstruction = `Address ${actorSubject} as ${address}`;
@@ -85,13 +205,15 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             predicate: 'preferred_address',
             value: address,
             memoryClass: 'behavioral',
+            category: 'behavioral',
             sourceEventId,
         });
     }
-    // 4. Stated relationship: "I am your X" / "I'm your creator"
-    const relMatch = text.match(/\b(?:i am|i'm)\s+your\s+([A-Za-z0-9_\s-]+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    // 5. Stated relationship: "I am your creator, Kur Zagin" / "I am your X" / "I'm your creator"
+    const relMatch = cleanText.match(/\b(?:i am|i'm)\s+your\s+([A-Za-z0-9_-]+)(?:,\s*([A-Za-z0-9_\s-]+?))?(?=\s+and\s+(?:i\b|my\b|you\b)|[.;]|$)/i);
     if (relMatch) {
         const relationship = cleanValue(relMatch[1], 60);
+        const actorName = relMatch[2] ? cleanValue(relMatch[2], 80) : undefined;
         claims.push({
             subject: actorSubject,
             predicate: 'stated_relationship',
@@ -109,11 +231,78 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             predicate: 'stated_relationship',
             value: relationship,
             memoryClass: 'relationship',
+            category: 'relational',
+            sourceEventId,
+        });
+        if (actorName) {
+            claims.push({
+                subject: actorSubject,
+                predicate: 'name',
+                value: actorName,
+                content: `The actor's name is ${actorName}.`,
+                claimType: 'preference',
+                provenance: 'deterministic_teaching',
+                sensitivity,
+                sourceEventId,
+            });
+        }
+    }
+    // 6. Behavioral rule / directive: "Remember this rule: X" / "Remember that rule: X" / "Rule: X" / "From now on, always X"
+    const ruleMatch = cleanText.match(/\b(?:remember\s+(?:this|that)\s+rule:\s*|rule:\s*|(?:from now on,?\s+)?always\s+)(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;]|$)/i);
+    if (ruleMatch) {
+        let instruction = cleanValue(ruleMatch[1], 160);
+        if (instruction) {
+            instruction = instruction.charAt(0).toUpperCase() + instruction.slice(1);
+            behaviorProposals.push({
+                directive: instruction,
+                priority: 60,
+                subject: actorSubject,
+                predicate: 'rule',
+                value: instruction,
+                category: 'behavioral',
+                memoryClass: 'behavioral',
+                sourceEventId,
+            });
+            claims.push({
+                subject: actorSubject,
+                predicate: 'behavioral_rule',
+                value: instruction,
+                content: `Behavioral rule: ${instruction}`,
+                claimType: 'preference',
+                provenance: 'deterministic_teaching',
+                sensitivity,
+                sourceEventId,
+            });
+        }
+    }
+    // Preference: "I prefer concise answers"
+    const prefAnswersMatch = cleanText.match(/\b(?:i prefer|my preference is)\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    if (prefAnswersMatch && !cleanText.match(/\bmy\s+preferred\s+([A-Za-z0-9_]+)\s+is\b/i)) {
+        const prefVal = cleanValue(prefAnswersMatch[1], 100);
+        const directive = `Prefer ${prefVal}`;
+        behaviorProposals.push({
+            directive,
+            priority: 60,
+            subject: actorSubject,
+            predicate: 'preference',
+            value: prefVal,
+            category: 'behavioral',
+            memoryClass: 'behavioral',
+            sourceEventId,
+        });
+        claims.push({
+            subject: actorSubject,
+            predicate: 'preference',
+            value: prefVal,
+            content: `The actor prefers ${prefVal}.`,
+            claimType: 'preference',
+            provenance: 'deterministic_teaching',
+            sensitivity,
             sourceEventId,
         });
     }
-    // 5. Explicit Domain / Preference fact: "my preferred X is Y" / "my X is Y"
-    const prefMatch = text.match(/\bmy\s+preferred\s+([A-Za-z0-9_]+)\s+is\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    // 7. Explicit Domain / Preference fact: "my preferred X is Y" / "my X is Y"
+    const prefMatch = cleanText.match(/\bmy\s+preferred\s+([A-Za-z0-9_]+)\s+is\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
     if (prefMatch) {
         const predicate = cleanValue(prefMatch[1], 40);
         const val = cleanValue(prefMatch[2], 100);

package/package.json

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