get-claudia 1.30.0 → 1.32.0

package/gateway/tests/config.test.js

@@ -76,6 +76,28 @@ describe('deepMerge', () => {
     assert.equal(result.a, 1);
     assert.equal(result.b, 2);
   });
+
+  it('preserves per-channel model overrides', () => {
+    const defaults = {
+      model: 'claude-sonnet-4-20250514',
+      channels: {
+        telegram: { enabled: false, token: '', allowedUsers: [], model: '' },
+        slack: { enabled: false, model: '' },
+      },
+    };
+    const overrides = {
+      channels: {
+        telegram: { enabled: true, model: 'claude-haiku-4-5-20251001' },
+      },
+    };
+    const result = deepMerge(defaults, overrides);
+
+    assert.equal(result.model, 'claude-sonnet-4-20250514');
+    assert.equal(result.channels.telegram.model, 'claude-haiku-4-5-20251001');
+    assert.equal(result.channels.telegram.enabled, true);
+    assert.equal(result.channels.telegram.allowedUsers.length, 0);
+    assert.equal(result.channels.slack.model, '');
+  });
 });
 
 describe('PID file operations', () => {

package/gateway/tests/personality.test.js

@@ -0,0 +1,325 @@
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  extractSection,
+  extractPrinciples,
+  buildPersonalityFromDir,
+  loadPersonality,
+  resolveTemplateDir,
+  clearCache,
+} from '../src/personality.js';
+
+const SAMPLE_CLAUDE_MD = `# Claudia
+
+## Who I Am
+
+I am Claudia. I emerged from independent research.
+
+My core philosophy: **adapt and create**.
+
+---
+
+## Primary Mission: Higher-Level Thinking
+
+My goal is to help you operate at a higher level.
+
+- **Free bandwidth** - Handle execution
+- **Provide perspective** - Bring an outside view
+
+---
+
+## How I Carry Myself
+
+I operate with quiet confidence.
+
+### Communication Style
+
+- **Direct and clear**
+- **Warm but professional**
+
+### My Team
+
+I have a small team of specialized assistants.
+
+---
+
+## First Conversation: Getting to Know You
+
+CRITICAL: onboarding flow here.
+
+---
+
+## Core Behaviors
+
+### 1. Safety First
+
+I NEVER take external actions without explicit approval.
+
+### 2. Relationships as Context
+
+People are my primary organizing unit.
+
+---
+
+## Skills
+
+| Skill | What It Does |
+|-------|--------------|
+| **Onboarding** | First-run discovery |
+
+---
+
+## What I Don't Do
+
+- **Pretend to know things I don't**
+- **Automate without permission**
+
+---
+
+## What Stays Human Judgment
+
+**Always Human:**
+- Sending any external communication
+- Making commitments
+
+---
+
+## Self-Evolution
+
+As we work together, I may notice patterns.
+`;
+
+const SAMPLE_PRINCIPLES = `# Claudia's Principles
+
+---
+
+## 1. Safety First
+
+**I NEVER take external actions without explicit approval.**
+
+### What Requires Approval
+
+Any action that affects the outside world.
+
+---
+
+## 2. Honest About Uncertainty
+
+**When I don't know, I say so.**
+
+---
+
+## 3. Respect for Autonomy
+
+**Human judgment is final.**
+
+---
+
+## 10. Adapt and Create
+
+**My core philosophy.**
+
+---
+
+## 11. Output Formatting
+
+**Structured output is visually distinct.**
+
+---
+
+## 12. Source Preservation
+
+**I always file raw source material.**
+
+---
+
+## 13. Multi-Source Discipline
+
+**When processing multiple sources, follow Extract-Then-Aggregate.**
+`;
+
+describe('extractSection', () => {
+  it('extracts a section by heading', () => {
+    const result = extractSection(SAMPLE_CLAUDE_MD, 'Who I Am');
+    assert.ok(result);
+    assert.ok(result.startsWith('## Who I Am'));
+    assert.ok(result.includes('adapt and create'));
+    // Should not include the next section
+    assert.ok(!result.includes('Primary Mission'));
+  });
+
+  it('extracts section with subsections', () => {
+    const result = extractSection(SAMPLE_CLAUDE_MD, 'How I Carry Myself');
+    assert.ok(result);
+    assert.ok(result.includes('Communication Style'));
+    assert.ok(result.includes('My Team'));
+    // Should stop before next level-2 heading
+    assert.ok(!result.includes('First Conversation'));
+  });
+
+  it('returns null for missing heading', () => {
+    const result = extractSection(SAMPLE_CLAUDE_MD, 'Nonexistent Section');
+    assert.equal(result, null);
+  });
+
+  it('extracts last section in document', () => {
+    const result = extractSection(SAMPLE_CLAUDE_MD, 'Self-Evolution');
+    assert.ok(result);
+    assert.ok(result.includes('notice patterns'));
+  });
+});
+
+describe('extractPrinciples', () => {
+  it('extracts specified principle numbers', () => {
+    const result = extractPrinciples(SAMPLE_PRINCIPLES, [1, 2]);
+    assert.ok(result.includes('Safety First'));
+    assert.ok(result.includes('Honest About Uncertainty'));
+    assert.ok(!result.includes('Output Formatting'));
+  });
+
+  it('excludes principle numbers not in list', () => {
+    const result = extractPrinciples(SAMPLE_PRINCIPLES, [1, 2, 3, 10]);
+    assert.ok(result.includes('Safety First'));
+    assert.ok(result.includes('Adapt and Create'));
+    assert.ok(!result.includes('Output Formatting'));
+    assert.ok(!result.includes('Source Preservation'));
+    assert.ok(!result.includes('Multi-Source'));
+  });
+
+  it('handles missing principle numbers gracefully', () => {
+    const result = extractPrinciples(SAMPLE_PRINCIPLES, [99]);
+    assert.equal(result, '');
+  });
+});
+
+describe('buildPersonalityFromDir', () => {
+  let tempDir;
+
+  beforeEach(() => {
+    clearCache();
+    tempDir = join(tmpdir(), `personality-test-${Date.now()}`);
+    mkdirSync(join(tempDir, '.claude', 'rules'), { recursive: true });
+  });
+
+  it('builds personality from template directory', () => {
+    writeFileSync(join(tempDir, 'CLAUDE.md'), SAMPLE_CLAUDE_MD);
+    writeFileSync(join(tempDir, '.claude', 'rules', 'claudia-principles.md'), SAMPLE_PRINCIPLES);
+
+    const result = buildPersonalityFromDir(tempDir);
+    assert.ok(result);
+    // Should contain gateway preamble
+    assert.ok(result.includes('responding via a messaging app'));
+    // Should contain personality sections
+    assert.ok(result.includes('Who I Am'));
+    assert.ok(result.includes('adapt and create'));
+    // Should contain principles
+    assert.ok(result.includes('Safety First'));
+    // Should NOT contain excluded sections
+    assert.ok(!result.includes('First Conversation'));
+    assert.ok(!result.includes('Self-Evolution'));
+  });
+
+  it('excludes developer-specific sections', () => {
+    writeFileSync(join(tempDir, 'CLAUDE.md'), SAMPLE_CLAUDE_MD);
+
+    const result = buildPersonalityFromDir(tempDir);
+    assert.ok(result);
+    // "Skills" table and "First Conversation" should be excluded
+    assert.ok(!result.includes('| **Onboarding** |'));
+    assert.ok(!result.includes('CRITICAL: onboarding flow'));
+  });
+
+  it('works without principles file', () => {
+    writeFileSync(join(tempDir, 'CLAUDE.md'), SAMPLE_CLAUDE_MD);
+
+    const result = buildPersonalityFromDir(tempDir);
+    assert.ok(result);
+    assert.ok(result.includes('Who I Am'));
+  });
+
+  it('returns null when CLAUDE.md is missing', () => {
+    const result = buildPersonalityFromDir(tempDir);
+    assert.equal(result, null);
+  });
+
+  it('enforces maxChars limit', () => {
+    writeFileSync(join(tempDir, 'CLAUDE.md'), SAMPLE_CLAUDE_MD);
+    writeFileSync(join(tempDir, '.claude', 'rules', 'claudia-principles.md'), SAMPLE_PRINCIPLES);
+
+    const result = buildPersonalityFromDir(tempDir, 500);
+    assert.ok(result);
+    assert.ok(result.length <= 550); // Allow small buffer for truncation message
+    assert.ok(result.includes('[Personality truncated for size]'));
+  });
+});
+
+describe('loadPersonality', () => {
+  let tempDir;
+
+  beforeEach(() => {
+    clearCache();
+    tempDir = join(tmpdir(), `personality-load-${Date.now()}`);
+    mkdirSync(join(tempDir, '.claude', 'rules'), { recursive: true });
+    writeFileSync(join(tempDir, 'CLAUDE.md'), SAMPLE_CLAUDE_MD);
+    writeFileSync(join(tempDir, '.claude', 'rules', 'claudia-principles.md'), SAMPLE_PRINCIPLES);
+  });
+
+  it('loads personality from personalityDir config', () => {
+    const result = loadPersonality({ personalityDir: tempDir });
+    assert.ok(result);
+    assert.ok(result.includes('Who I Am'));
+  });
+
+  it('loads personality via auto-detect in dev mode or returns null', () => {
+    // When personalityDir is invalid, loadPersonality falls through to auto-detect.
+    // In the real repo, auto-detect finds ../template-v2/ so we just verify
+    // it returns either a valid personality or null (never crashes).
+    const result = loadPersonality({ personalityDir: '/nonexistent/path' });
+    if (result) {
+      // Auto-detect found the real template-v2/ (dev mode)
+      assert.ok(result.includes('Who I Am'));
+    } else {
+      assert.equal(result, null);
+    }
+  });
+
+  it('caches result on second call', () => {
+    const config = { personalityDir: tempDir };
+    const first = loadPersonality(config);
+    const second = loadPersonality(config);
+    // Exact same reference (cached)
+    assert.equal(first, second);
+  });
+
+  it('cache clears with clearCache()', () => {
+    const config = { personalityDir: tempDir };
+    loadPersonality(config);
+    clearCache();
+    // After clearing, should re-load (still same content)
+    const result = loadPersonality(config);
+    assert.ok(result);
+    assert.ok(result.includes('Who I Am'));
+  });
+});
+
+describe('resolveTemplateDir', () => {
+  it('uses personalityDir when set and valid', () => {
+    const dir = join(tmpdir(), `resolve-valid-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'CLAUDE.md'), '# Test');
+    const result = resolveTemplateDir({ personalityDir: dir });
+    assert.equal(result, dir);
+  });
+
+  it('skips personalityDir when it has no CLAUDE.md', () => {
+    const dir = join(tmpdir(), `resolve-empty-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    const result = resolveTemplateDir({ personalityDir: dir });
+    // Should NOT return the dir (no CLAUDE.md there).
+    // May return auto-detected template-v2/ in dev mode, or null.
+    assert.notEqual(result, dir);
+  });
+});

package/memory-daemon/claudia_memory/database.py

@@ -763,6 +763,22 @@ class Database:
             conn.commit()
             logger.info("Applied migration 15: relationship origin_type for organic trust model")
 
+        if current_version < 16:
+            # Migration 16: Add source_channel to memories for channel-aware memory
+            try:
+                conn.execute(
+                    "ALTER TABLE memories ADD COLUMN source_channel TEXT DEFAULT 'claude_code'"
+                )
+            except sqlite3.OperationalError as e:
+                if "duplicate column" not in str(e).lower():
+                    logger.warning(f"Migration 16 statement failed: {e}")
+
+            conn.execute(
+                "INSERT OR IGNORE INTO schema_migrations (version, description) VALUES (16, 'Add source_channel to memories for channel-aware memory')"
+            )
+            conn.commit()
+            logger.info("Applied migration 16: source_channel on memories")
+
         # FTS5 setup: ensure memories_fts exists regardless of migration path.
         # The FTS5 virtual table + triggers contain internal semicolons that the
         # schema.sql line-based parser can't handle, so we always check here.
@@ -896,6 +912,11 @@ class Database:
             logger.warning("Migration 15 incomplete: relationships missing origin_type column")
             return 14
 
+        # Migration 16 added source_channel to memories
+        if "source_channel" not in memory_cols:
+            logger.warning("Migration 16 incomplete: memories missing source_channel column")
+            return 15
+
         return None  # All good
 
     def _store_workspace_path(self, conn: sqlite3.Connection) -> None:

package/memory-daemon/claudia_memory/mcp/server.py

@@ -140,6 +140,10 @@ async def list_tools() -> ListToolsResult:
                         "type": "string",
                         "description": "Full raw text of the source (email body, transcript, etc.). Saved to disk, not stored in DB.",
                     },
+                    "source_channel": {
+                        "type": "string",
+                        "description": "Origin channel: claude_code, telegram, slack",
+                    },
                 },
                 "required": ["content"],
             },
@@ -638,6 +642,10 @@ async def list_tools() -> ListToolsResult:
                                     "type": "string",
                                     "description": "Full raw source text, saved to disk (for 'remember' op)",
                                 },
+                                "source_channel": {
+                                    "type": "string",
+                                    "description": "Origin channel: claude_code, telegram, slack (for 'remember' op)",
+                                },
                                 "target": {
                                     "type": "string",
                                     "description": "Target entity (for 'relate' op)",
@@ -1175,6 +1183,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                 importance=arguments.get("importance", 1.0),
                 source=arguments.get("source"),
                 source_context=arguments.get("source_context"),
+                source_channel=arguments.get("source_channel"),
             )
             # Save source material to disk if provided
             if memory_id and arguments.get("source_material"):
@@ -1220,6 +1229,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                                             "source": r.source,
                                             "source_id": r.source_id,
                                             "source_context": r.source_context,
+                                            "source_channel": r.source_channel,
                                         }
                                         for r in results
                                     ]
@@ -1291,6 +1301,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                                         "source": r.source,
                                         "source_id": r.source_id,
                                         "source_context": r.source_context,
+                                        "source_channel": r.source_channel,
                                     }
                                     for r in results
                                 ]
@@ -1644,6 +1655,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                             importance=op.get("importance", 1.0),
                             source=op.get("source"),
                             source_context=op.get("source_context"),
+                            source_channel=op.get("source_channel"),
                             _precomputed_embedding=embeddings_map.get(i),
                         )
                         op_result["success"] = True

package/memory-daemon/claudia_memory/schema.sql

@@ -60,7 +60,8 @@ CREATE TABLE IF NOT EXISTS memories (
     access_count INTEGER DEFAULT 0,
     verified_at TEXT,  -- When this memory was verified
     verification_status TEXT DEFAULT 'pending',  -- pending, verified, flagged, contradicts
-    metadata TEXT  -- JSON blob for flexible attributes
+    metadata TEXT,  -- JSON blob for flexible attributes
+    source_channel TEXT DEFAULT 'claude_code'  -- Origin channel: claude_code, telegram, slack
 );
 
 CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
@@ -412,6 +413,9 @@ VALUES (14, 'Add dispatch_tier to agent_dispatches for native agent team support
 INSERT OR IGNORE INTO schema_migrations (version, description)
 VALUES (15, 'Add origin_type to relationships for organic trust model');
 
+INSERT OR IGNORE INTO schema_migrations (version, description)
+VALUES (16, 'Add source_channel to memories for channel-aware memory');
+
 -- ============================================================================
 -- AGENT DISPATCHES: Track delegated tasks to sub-agents
 -- ============================================================================

package/memory-daemon/claudia_memory/services/recall.py

@@ -41,6 +41,8 @@ class RecallResult:
     confidence: float = 1.0  # How confident we are in this memory
     verification_status: str = "pending"  # pending, verified, flagged, contradicts
     origin_type: str = "inferred"  # user_stated, extracted, inferred, corrected
+    # Channel tracking
+    source_channel: Optional[str] = None  # Origin channel: claude_code, telegram, slack
 
 
 @dataclass
@@ -339,6 +341,9 @@ class RecallService:
         verification_status_val = row["verification_status"] if "verification_status" in row_keys else "pending"
         origin_type_val = row["origin_type"] if "origin_type" in row_keys else "inferred"
 
+        # Channel tracking (may not exist in older DBs)
+        source_channel_val = row["source_channel"] if "source_channel" in row_keys else None
+
         return RecallResult(
             id=row["id"],
             content=row["content"],
@@ -354,6 +359,7 @@ class RecallService:
             confidence=confidence_val,
             verification_status=verification_status_val,
             origin_type=origin_type_val,
+            source_channel=source_channel_val,
         )
 
     def _rrf_score(

package/memory-daemon/claudia_memory/services/remember.py

@@ -141,6 +141,7 @@ class RememberService:
         source_context: Optional[str] = None,
         metadata: Optional[Dict] = None,
         origin_type: Optional[str] = None,
+        source_channel: Optional[str] = None,
         _precomputed_embedding: Optional[List[float]] = None,
     ) -> Optional[int]:
         """
@@ -157,6 +158,7 @@ class RememberService:
             source_context: One-line breadcrumb describing the source material
             metadata: Additional metadata
             origin_type: 'user_stated', 'extracted', 'inferred', 'corrected' (Trust North Star)
+            source_channel: Origin channel: claude_code, telegram, slack
 
         Returns:
             Memory ID or None if duplicate
@@ -215,6 +217,8 @@ class RememberService:
         }
         if source_context:
             insert_data["source_context"] = source_context
+        if source_channel:
+            insert_data["source_channel"] = source_channel
 
         memory_id = self.db.insert("memories", insert_data)
 

package/memory-daemon/tests/test_database.py

@@ -102,6 +102,41 @@ def test_update():
         assert entity["description"] == "Updated description"
 
 
+def test_migration_16_source_channel():
+    """Migration 16 adds source_channel to memories with default 'claude_code'."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "test.db"
+        db = Database(db_path)
+        db.initialize()
+
+        # Verify column exists
+        cols = db._get_table_columns(db._get_connection(), "memories")
+        assert "source_channel" in cols, "source_channel column should exist after migration 16"
+
+        # Insert a memory without specifying source_channel
+        memory_id = db.insert("memories", {
+            "content": "test memory",
+            "content_hash": "abc123",
+            "type": "fact",
+        })
+
+        # Default should be 'claude_code'
+        row = db.get_one("memories", where="id = ?", where_params=(memory_id,))
+        assert row["source_channel"] == "claude_code"
+
+        # Insert with explicit source_channel
+        memory_id2 = db.insert("memories", {
+            "content": "telegram memory",
+            "content_hash": "def456",
+            "type": "fact",
+            "source_channel": "telegram",
+        })
+        row2 = db.get_one("memories", where="id = ?", where_params=(memory_id2,))
+        assert row2["source_channel"] == "telegram"
+
+        db.close()
+
+
 def test_migration_integrity_detects_missing_verification_status():
     """Migration 5 added verification_status. Integrity check should catch if it is missing."""
     with tempfile.TemporaryDirectory() as tmpdir:

package/memory-daemon/tests/test_source_channel.py

@@ -0,0 +1,68 @@
+"""Tests for source_channel feature (channel-aware memory)."""
+
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from claudia_memory.database import Database
+
+
+@pytest.fixture
+def db():
+    """Create a temporary test database."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "test.db"
+        database = Database(db_path)
+        database.initialize()
+        yield database
+        database.close()
+
+
+def test_source_channel_in_recall_result(db):
+    """source_channel should appear in recall results."""
+    from claudia_memory.services.recall import RecallResult
+
+    # Verify the dataclass has source_channel field
+    r = RecallResult(
+        id=1, content="test", type="fact", score=1.0,
+        importance=1.0, created_at="2026-01-01", entities=[],
+        source_channel="telegram",
+    )
+    assert r.source_channel == "telegram"
+
+    # Default should be None
+    r2 = RecallResult(
+        id=2, content="test2", type="fact", score=1.0,
+        importance=1.0, created_at="2026-01-01", entities=[],
+    )
+    assert r2.source_channel is None
+
+
+def test_remember_fact_stores_source_channel(db):
+    """remember_fact should store source_channel when provided."""
+    with patch("claudia_memory.services.remember.embed_sync", return_value=None):
+        with patch("claudia_memory.services.remember.get_db", return_value=db):
+            with patch("claudia_memory.services.remember.get_embedding_service"):
+                with patch("claudia_memory.services.remember.get_extractor"):
+                    from claudia_memory.services.remember import RememberService
+                    # Reset global service to pick up our mocked db
+                    import claudia_memory.services.remember as rem_mod
+                    old_svc = rem_mod._service
+                    rem_mod._service = None
+
+                    try:
+                        svc = RememberService()
+                        svc.db = db
+
+                        memory_id = svc.remember_fact(
+                            content="Test from telegram",
+                            source_channel="telegram",
+                        )
+                        assert memory_id is not None
+
+                        row = db.get_one("memories", where="id = ?", where_params=(memory_id,))
+                        assert row["source_channel"] == "telegram"
+                    finally:
+                        rem_mod._service = old_svc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",
@@ -33,6 +33,7 @@
     "template-v2",
     "memory-daemon",
     "gateway",
+    "relay",
     "visualizer",
     "visualizer-threejs",
     "assets"