@siduri-x/core 2.0.4 → 2.0.5

package/dist/siduri-db.js

@@ -26,6 +26,7 @@ class SiduriDatabase {
         companion_id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         archetype TEXT,
+        role TEXT,
         origin TEXT,
         ethos TEXT,
         version TEXT NOT NULL,
@@ -215,6 +216,12 @@ class SiduriDatabase {
         catch {
             // Column already exists
         }
+        try {
+            this.db.exec("ALTER TABLE self_identity ADD COLUMN role TEXT");
+        }
+        catch {
+            // Column already exists
+        }
     }
     close() {
         this.db.close();
@@ -231,6 +238,7 @@ class SiduriDatabase {
             companionId: row.companion_id,
             name: row.name,
             archetype: row.archetype || undefined,
+            role: row.role || row.archetype || undefined,
             origin: row.origin || undefined,
             ethos: row.ethos || undefined,
             version: row.version,
@@ -238,18 +246,21 @@ class SiduriDatabase {
         };
     }
     setIdentity(identity) {
+        const role = identity.role || identity.archetype || null;
+        const archetype = identity.archetype || identity.role || null;
         const stmt = this.db.prepare(`
-      INSERT INTO self_identity (companion_id, name, archetype, origin, ethos, version, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, datetime('now'))
+      INSERT INTO self_identity (companion_id, name, archetype, role, origin, ethos, version, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
       ON CONFLICT(companion_id) DO UPDATE SET
         name = excluded.name,
         archetype = excluded.archetype,
+        role = excluded.role,
         origin = excluded.origin,
         ethos = excluded.ethos,
         version = excluded.version,
         updated_at = datetime('now')
     `);
-        stmt.run(identity.companionId, identity.name, identity.archetype || null, identity.origin || null, identity.ethos || null, identity.version);
+        stmt.run(identity.companionId, identity.name, archetype, role, identity.origin || null, identity.ethos || null, identity.version);
     }
     getPersonality(companionId) {
         const stmt = this.db.prepare('SELECT * FROM self_personality WHERE companion_id = ?');
@@ -311,6 +322,14 @@ class SiduriDatabase {
         const stmt = this.db.prepare(`
       INSERT INTO self_directives (id, companion_id, priority, directive, status, category, scope_actor, supersedes_id, created_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        companion_id = excluded.companion_id,
+        priority = excluded.priority,
+        directive = excluded.directive,
+        status = excluded.status,
+        category = excluded.category,
+        scope_actor = excluded.scope_actor,
+        supersedes_id = excluded.supersedes_id
     `);
         stmt.run(directive.id, directive.companionId, directive.priority !== undefined ? directive.priority : 50, directive.directive, normalizeStatus(directive.status, 'active'), directive.category || 'behavioral', directive.scopeActor || null, directive.supersedesId || null, directive.createdAt || new Date().toISOString());
     }
@@ -332,6 +351,9 @@ class SiduriDatabase {
             return;
         }
         if (normalizeStatus(row.status) !== 'pending') {
+            if (normalizeStatus(row.status) === 'active') {
+                return;
+            }
             throw new Error(`Cannot approve directive '${id}': invalid transition from status '${row.status}' to 'active' (only pending directives can be approved)`);
         }
         // If this directive supersedes an earlier directive, transition that prior directive to superseded
@@ -407,8 +429,10 @@ class SiduriDatabase {
         }
     }
     getRelationship(companionId, entityId) {
-        const stmt = this.db.prepare('SELECT * FROM self_relationships WHERE companion_id = ? AND entity_id = ?');
-        const row = stmt.get(companionId, entityId);
+        const stripped = entityId.startsWith('actor:') ? entityId.slice(6) : entityId;
+        const prefixed = entityId.startsWith('actor:') ? entityId : `actor:${entityId}`;
+        const stmt = this.db.prepare('SELECT * FROM self_relationships WHERE companion_id = ? AND (entity_id = ? OR entity_id = ? OR entity_id = ?)');
+        const row = stmt.get(companionId, entityId, stripped, prefixed);
         if (!row)
             return undefined;
         return {
@@ -636,7 +660,7 @@ class SiduriDatabase {
       INSERT INTO memory_claims (id, companion_id, subject, predicate, value, status, confidence, valid_from, valid_until, evidence, asserted_at, supersedes, source_event_id)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, coalesce(?, datetime('now')), ?, ?)
     `);
-        stmt.run(id, claim.companionId, claim.subject, claim.predicate, claim.value, status, confidence, claim.validFrom || null, claim.validUntil || null, claim.evidence ? JSON.stringify(claim.evidence) : null, assertedAt || null, claim.supersedes || null, claim.sourceEventId || null);
+        stmt.run(id, claim.companionId || 'default', claim.subject, claim.predicate, claim.value, status, confidence, claim.validFrom || null, claim.validUntil || null, claim.evidence ? JSON.stringify(claim.evidence) : null, assertedAt || null, claim.supersedes || null, claim.sourceEventId || null);
         return {
             ...claim,
             id,
@@ -656,6 +680,9 @@ class SiduriDatabase {
             return;
         }
         if (normalizeStatus(row.status) !== 'pending') {
+            if (normalizeStatus(row.status) === 'approved') {
+                return;
+            }
             throw new Error(`Cannot approve claim '${id}': invalid transition from status '${row.status}' to 'approved' (only pending claims can be approved)`);
         }
         // If this claim supersedes an earlier claim, transition that prior claim to superseded
@@ -678,6 +705,94 @@ class SiduriDatabase {
             const stmt = this.db.prepare("UPDATE memory_claims SET status = 'approved' WHERE id = ? AND LOWER(status) = 'pending'");
             stmt.run(id);
         }
+        // Canonically promote approved claim to Self domain state (identity, role, relationships)
+        const approvedClaim = this.getClaim(id);
+        if (approvedClaim) {
+            this.promoteClaimToSelf(approvedClaim);
+        }
+    }
+    /**
+     * Canonically promotes a Claim into Self domain tables.
+     */
+    promoteClaimToSelf(claim) {
+        const companionId = claim.companionId || 'default';
+        const subject = (claim.subject || '').toLowerCase();
+        const predicate = (claim.predicate || '').toLowerCase();
+        const value = claim.value || '';
+        if (!value)
+            return;
+        // 1. Identity mutations: companion identity/role/origin/name/ethos
+        if (subject.startsWith('companion:') ||
+            subject === 'companion' ||
+            subject === 'siduri' ||
+            subject === 'self') {
+            const existing = this.getIdentity(companionId) || {
+                companionId,
+                name: 'Siduri',
+                version: '1.0.0',
+                updatedAt: new Date().toISOString(),
+            };
+            if (predicate === 'role' || predicate === 'archetype') {
+                existing.archetype = value;
+                existing.role = value;
+                this.setIdentity(existing);
+                this.commitDirective({
+                    id: `dir-role-${claim.id || Date.now()}`,
+                    companionId,
+                    priority: 70,
+                    directive: `Acknowledge role as ${value}`,
+                    status: 'active',
+                    category: 'relational',
+                    createdAt: new Date().toISOString(),
+                });
+            }
+            else if (predicate === 'origin' || predicate === 'created_by') {
+                existing.origin = value;
+                this.setIdentity(existing);
+            }
+            else if (predicate === 'name') {
+                existing.name = value;
+                this.setIdentity(existing);
+            }
+            else if (predicate === 'ethos') {
+                existing.ethos = value;
+                this.setIdentity(existing);
+            }
+            return;
+        }
+        // 2. Relationship mutations: creator or user stated relationship
+        if (claim.claimType === 'relationship' ||
+            predicate === 'stated_relationship' ||
+            predicate === 'relationship' ||
+            predicate === 'relationship_to_siduri') {
+            const rawSubject = (claim.subject || 'actor:user').replace(/^actor:actor:/, 'actor:');
+            const isCreator = value.toLowerCase() === 'creator';
+            this.upsertRelationship({
+                companionId,
+                entityId: rawSubject,
+                entityType: 'human',
+                role: value,
+                stance: isCreator ? 'familiar_loyal' : 'neutral',
+                trustScore: isCreator ? 1.0 : 0.8,
+                familiarity: isCreator ? 0.9 : 0.5,
+                interactionConventions: isCreator
+                    ? ['Direct communication', 'Highest administrative trust']
+                    : [],
+            });
+            return;
+        }
+        // 3. Behavioral rule claim
+        if (predicate === 'behavioral_rule' || predicate === 'rule') {
+            this.commitDirective({
+                id: `dir-rule-${claim.id || Date.now()}`,
+                companionId,
+                priority: 60,
+                directive: value,
+                status: 'active',
+                category: 'behavioral',
+                createdAt: new Date().toISOString(),
+            });
+        }
     }
     rejectClaim(id, companionId) {
         if (companionId) {

package/dist/siduri-db.test.js

@@ -730,7 +730,8 @@ describe('SiduriDatabase', () => {
                 status: 'active',
                 category: 'behavioral',
             });
-            expect(() => db.approveDirective('dir-active-1')).toThrow(/invalid transition from status 'active' to 'active'/i);
+            // 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'/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.4",
+  "version": "2.0.5",
   "description": "Core runtime types, evidence protocol, action dispatcher, capability validation, and SiduriRuntime protocol",
   "license": "Apache-2.0",
   "repository": {