get-claudia 1.29.2 → 1.31.0

package/bin/index.js

@@ -220,7 +220,7 @@ async function main() {
 
   // Helper: run visualizer install script and call back when done (auto-install, no prompt)
   function runVisualizerSetup(callback) {
-    console.log(`\n${colors.boldYellow}━━━ Phase 2/3: Brain Visualizer ━━━${colors.reset}\n`);
+    console.log(`\n${colors.boldYellow}━━━ Phase 2/4: Brain Visualizer ━━━${colors.reset}\n`);
 
     const visualizerScriptPath = isWindows
       ? join(__dirname, '..', 'visualizer', 'scripts', 'install.ps1')
@@ -263,7 +263,7 @@ async function main() {
 
   // Helper: run gateway install script and call back when done
   function runGatewaySetup(callback) {
-    console.log(`\n${colors.boldYellow}━━━ Phase 3/3: Messaging Gateway ━━━${colors.reset}\n`);
+    console.log(`\n${colors.boldYellow}━━━ Phase 3/4: Messaging Gateway ━━━${colors.reset}\n`);
 
     const gatewayScriptPath = isWindows
       ? join(__dirname, '..', 'gateway', 'scripts', 'install.ps1')
@@ -309,6 +309,54 @@ async function main() {
     }
   }
 
+  // Helper: run relay install script and call back when done
+  function runRelaySetup(callback) {
+    console.log(`\n${colors.boldYellow}━━━ Phase 4/4: Telegram Relay ━━━${colors.reset}\n`);
+
+    const relayScriptPath = isWindows
+      ? join(__dirname, '..', 'relay', 'scripts', 'install.ps1')
+      : join(__dirname, '..', 'relay', 'scripts', 'install.sh');
+
+    if (!existsSync(relayScriptPath)) {
+      console.log(`${colors.yellow}!${colors.reset} Relay files not found. Skipping.`);
+      callback(false);
+      return;
+    }
+
+    try {
+      const spawnCmd = isWindows ? powershellPath : 'bash';
+      const spawnArgs = isWindows
+        ? ['-ExecutionPolicy', 'Bypass', '-File', relayScriptPath]
+        : [relayScriptPath];
+      const relayResult = spawn(spawnCmd, spawnArgs, {
+        stdio: 'inherit',
+        env: {
+          ...process.env,
+          CLAUDIA_RELAY_UPGRADE: isUpgrade ? '1' : '0',
+          CLAUDIA_RELAY_SKIP_SETUP: '1'
+        }
+      });
+
+      relayResult.on('close', (code) => {
+        if (code === 0) {
+          console.log(`${colors.green}✓${colors.reset} Relay installed`);
+          callback(true);
+        } else {
+          console.log(`${colors.yellow}!${colors.reset} Relay setup had issues. You can run it later with:`);
+          if (isWindows) {
+            console.log(`  ${colors.cyan}powershell.exe -ExecutionPolicy Bypass -File "${relayScriptPath}"${colors.reset}`);
+          } else {
+            console.log(`  ${colors.cyan}bash ${relayScriptPath}${colors.reset}`);
+          }
+          callback(false);
+        }
+      });
+    } catch (error) {
+      console.log(`${colors.yellow}!${colors.reset} Could not set up relay: ${error.message}`);
+      callback(false);
+    }
+  }
+
   // Helper: run system health check after install
   function runSystemHealthCheck(callback) {
     const diagnoseScript = isWindows
@@ -343,20 +391,25 @@ async function main() {
   }
 
   // Helper: finish install after optional components
-  function finishInstall(memoryInstalled, visualizerInstalled, gatewayInstalled) {
+  function finishInstall(memoryInstalled, visualizerInstalled, gatewayInstalled, relayInstalled) {
     if (memoryInstalled) {
       // Run health check when memory system was installed
       runSystemHealthCheck((healthy) => {
-        showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, healthy);
+        showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, relayInstalled, healthy);
       });
     } else {
-      showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, true);
+      showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, relayInstalled, true);
     }
   }
 
-  // Helper: run gateway setup (auto-install like visualizer), then finish
+  // Helper: run relay setup after gateway, then finish
+  function maybeRunRelay(memoryInstalled, visualizerInstalled, gatewayInstalled) {
+    runRelaySetup((relayOk) => finishInstall(memoryInstalled, visualizerInstalled, gatewayInstalled, relayOk));
+  }
+
+  // Helper: run gateway setup (auto-install like visualizer), then chain to relay
   function maybeRunGateway(memoryInstalled, visualizerInstalled) {
-    runGatewaySetup((gatewayOk) => finishInstall(memoryInstalled, visualizerInstalled, gatewayOk));
+    runGatewaySetup((gatewayOk) => maybeRunRelay(memoryInstalled, visualizerInstalled, gatewayOk));
   }
 
   // Helper: auto-install visualizer after memory (if memory was installed), then chain to gateway
@@ -371,7 +424,7 @@ async function main() {
   }
 
   // Memory system always installs (no prompt)
-  console.log(`\n${colors.boldYellow}━━━ Phase 1/3: Memory System ━━━${colors.reset}\n`);
+  console.log(`\n${colors.boldYellow}━━━ Phase 1/4: Memory System ━━━${colors.reset}\n`);
 
   const memoryDaemonPath = isWindows
     ? join(__dirname, '..', 'memory-daemon', 'scripts', 'install.ps1')
@@ -453,7 +506,7 @@ async function main() {
   // Memory failed to spawn -- continue with visualizer/gateway
   maybeRunVisualizer(false);
 
-  function showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, systemHealthy = true) {
+  function showNextSteps(memoryInstalled, visualizerInstalled, gatewayInstalled, relayInstalled, systemHealthy = true) {
     const cdStep = isCurrentDir ? '' : `  ${colors.cyan}cd ${targetDir}${colors.reset}\n`;
 
     // Installation summary
@@ -465,11 +518,16 @@ async function main() {
     console.log(`${memoryInstalled ? check : warn} Memory system    ${memoryInstalled ? 'Active' : 'Skipped'}`);
     console.log(`${visualizerInstalled ? check : warn} Brain visualizer ${visualizerInstalled ? 'Active' : 'Skipped'}`);
     console.log(`${gatewayInstalled ? check : warn} Gateway          ${gatewayInstalled ? 'Installed' : 'Skipped'}`);
+    console.log(`${relayInstalled ? check : warn} Telegram relay   ${relayInstalled ? 'Installed' : 'Skipped'}`);
 
     if (gatewayInstalled) {
       console.log(`${colors.yellow}->${colors.reset} Configure tokens: ~/.claudia/gateway.json`);
     }
 
+    if (relayInstalled) {
+      console.log(`${colors.yellow}->${colors.reset} Configure relay: run /setup-telegram inside Claude`);
+    }
+
     if (!systemHealthy) {
       console.log(`\n${colors.yellow}Some issues were detected above.${colors.reset}`);
       console.log(`${colors.dim}You can fix them now, or Claudia will work in fallback mode until they're resolved.${colors.reset}`);

package/memory-daemon/claudia_memory/database.py

@@ -138,6 +138,21 @@ class Database:
         else:
             conn.commit()
 
+    @contextmanager
+    def transaction(self) -> Generator[sqlite3.Connection, None, None]:
+        """Explicit multi-step transaction. Commits on success, rolls back on error.
+
+        Use this when multiple operations must succeed or fail atomically.
+        Unlike connection(), the caller uses conn.execute() directly.
+        """
+        conn = self._get_connection()
+        try:
+            yield conn
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+
     @contextmanager
     def cursor(self) -> Generator[sqlite3.Cursor, None, None]:
         """Context manager for database cursor"""
@@ -724,6 +739,46 @@ class Database:
             conn.commit()
             logger.info("Applied migration 14: dispatch_tier for native agent teams")
 
+        if current_version < 15:
+            # Migration 15: Add origin_type to relationships for organic trust model
+            try:
+                conn.execute(
+                    "ALTER TABLE relationships ADD COLUMN origin_type TEXT DEFAULT 'extracted'"
+                )
+            except sqlite3.OperationalError as e:
+                if "duplicate column" not in str(e).lower():
+                    logger.warning(f"Migration 15 statement failed: {e}")
+
+            # Grandfather existing relationships: all get 'extracted' (the safe default)
+            try:
+                conn.execute(
+                    "UPDATE relationships SET origin_type = 'extracted' WHERE origin_type IS NULL"
+                )
+            except sqlite3.OperationalError as e:
+                logger.warning(f"Migration 15 grandfather failed: {e}")
+
+            conn.execute(
+                "INSERT OR IGNORE INTO schema_migrations (version, description) VALUES (15, 'Add origin_type to relationships for organic trust model')"
+            )
+            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.
@@ -852,6 +907,16 @@ class Database:
             logger.warning("Migration 14 incomplete: agent_dispatches missing dispatch_tier column")
             return 13
 
+        # Migration 15 added origin_type to relationships
+        if "origin_type" not in rel_cols:
+            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

@@ -57,6 +57,7 @@ from ..services.remember import (
     get_remember_service,
     get_unsummarized_turns,
     invalidate_memory,
+    invalidate_relationship,
     merge_entities,
     relate_entities,
     store_reflection,
@@ -139,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"],
             },
@@ -240,6 +245,16 @@ async def list_tools() -> ListToolsResult:
                         "description": "If true, invalidate existing relationship of same type between same entities and create new one",
                         "default": False,
                     },
+                    "origin_type": {
+                        "type": "string",
+                        "description": "How this was learned: user_stated, extracted, inferred, corrected",
+                        "default": "extracted",
+                    },
+                    "direction": {
+                        "type": "string",
+                        "description": "Relationship direction: forward, backward, or bidirectional",
+                        "default": "bidirectional",
+                    },
                 },
                 "required": ["source", "target", "relationship"],
             },
@@ -627,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)",
@@ -639,6 +658,23 @@ async def list_tools() -> ListToolsResult:
                                     "type": "number",
                                     "description": "Relationship strength 0.0-1.0 (for 'relate' op)",
                                 },
+                                "origin_type": {
+                                    "type": "string",
+                                    "description": "How this was learned: user_stated, extracted, inferred (for 'relate' op)",
+                                },
+                                "supersedes": {
+                                    "type": "boolean",
+                                    "description": "Invalidate existing relationship of same type (for 'relate' op)",
+                                    "default": False,
+                                },
+                                "valid_at": {
+                                    "type": "string",
+                                    "description": "When this relationship became true (for 'relate' op)",
+                                },
+                                "direction": {
+                                    "type": "string",
+                                    "description": "Relationship direction (for 'relate' op)",
+                                },
                             },
                             "required": ["op"],
                         },
@@ -1060,6 +1096,37 @@ async def list_tools() -> ListToolsResult:
                 "required": ["memory_id"],
             },
         ),
+        Tool(
+            name="memory.invalidate_relationship",
+            description=(
+                "Mark a relationship as incorrect or ended without creating a replacement. "
+                "Use when the user says a relationship is wrong, or when someone leaves a "
+                "company, ends a partnership, etc. The relationship is preserved for history "
+                "but excluded from active queries."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "source": {
+                        "type": "string",
+                        "description": "Source entity name",
+                    },
+                    "target": {
+                        "type": "string",
+                        "description": "Target entity name",
+                    },
+                    "relationship": {
+                        "type": "string",
+                        "description": "Relationship type to invalidate (works_with, manages, etc.)",
+                    },
+                    "reason": {
+                        "type": "string",
+                        "description": "Why this relationship is being invalidated",
+                    },
+                },
+                "required": ["source", "target", "relationship"],
+            },
+        ),
         Tool(
             name="memory.audit_history",
             description=(
@@ -1116,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"):
@@ -1161,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
                                     ]
@@ -1232,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
                                 ]
@@ -1281,6 +1351,8 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                 strength=arguments.get("strength", 1.0),
                 valid_at=arguments.get("valid_at"),
                 supersedes=arguments.get("supersedes", False),
+                origin_type=arguments.get("origin_type", "extracted"),
+                direction=arguments.get("direction", "bidirectional"),
             )
             return CallToolResult(
                 content=[
@@ -1583,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
@@ -1604,6 +1677,10 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                             target=op["target"],
                             relationship=op["relationship"],
                             strength=op.get("strength", 1.0),
+                            supersedes=op.get("supersedes", False),
+                            valid_at=op.get("valid_at"),
+                            direction=op.get("direction", "bidirectional"),
+                            origin_type=op.get("origin_type", "extracted"),
                         )
                         op_result["success"] = True
                         op_result["relationship_id"] = relationship_id
@@ -1873,6 +1950,22 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                 ]
             )
 
+        elif name == "memory.invalidate_relationship":
+            result = invalidate_relationship(
+                source=arguments["source"],
+                target=arguments["target"],
+                relationship=arguments["relationship"],
+                reason=arguments.get("reason"),
+            )
+            return CallToolResult(
+                content=[
+                    TextContent(
+                        type="text",
+                        text=json.dumps(result),
+                    )
+                ]
+            )
+
         elif name == "memory.audit_history":
             # Get audit history for entity or memory
             entity_id = arguments.get("entity_id")

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);
@@ -89,6 +90,7 @@ CREATE TABLE IF NOT EXISTS relationships (
     target_entity_id INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
     relationship_type TEXT NOT NULL,  -- works_with, manages, client_of, etc.
     strength REAL DEFAULT 1.0,  -- Relationship strength (decays/grows)
+    origin_type TEXT DEFAULT 'extracted',  -- user_stated, extracted, inferred, corrected
     direction TEXT DEFAULT 'bidirectional' CHECK (direction IN ('forward', 'backward', 'bidirectional')),
     valid_at TEXT,  -- When this relationship became true in the real world
     invalid_at TEXT,  -- When this relationship was superseded (NULL = current)
@@ -408,6 +410,12 @@ VALUES (13, 'Add origin_type to memories, agent_dispatches table for Trust North
 INSERT OR IGNORE INTO schema_migrations (version, description)
 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/guards.py

@@ -112,15 +112,37 @@ def validate_entity(
     return result
 
 
-def validate_relationship(strength: float = 1.0) -> ValidationResult:
+# Origin-aware strength ceilings: relationships can't exceed their evidence level
+ORIGIN_STRENGTH_CEILING = {
+    "user_stated": 1.0,    # User said it directly -- full trust
+    "extracted": 0.8,      # Evidence from a document -- high but not absolute
+    "inferred": 0.5,       # Co-occurrence guess -- must earn trust through repetition
+    "corrected": 1.0,      # User corrected it -- full trust
+}
+
+# Origin-scaled reinforcement increments (Hebbian: stronger signals potentiate more)
+REINFORCEMENT_BY_ORIGIN = {
+    "user_stated": 0.2,
+    "extracted": 0.1,
+    "inferred": 0.05,
+    "corrected": 0.2,
+}
+
+
+def validate_relationship(
+    strength: float = 1.0,
+    origin_type: str = "extracted",
+) -> ValidationResult:
     """
     Validate a relationship before storage.
 
     Checks:
     - Strength clamped to [0, 1]
+    - Strength capped by origin authority ceiling
     """
     result = ValidationResult()
 
+    # Clamp to [0, 1]
     if strength < 0:
         result.warnings.append(f"Relationship strength {strength} clamped to 0.0")
         result.adjustments["strength"] = 0.0
@@ -128,4 +150,13 @@ def validate_relationship(strength: float = 1.0) -> ValidationResult:
         result.warnings.append(f"Relationship strength {strength} clamped to 1.0")
         result.adjustments["strength"] = 1.0
 
+    # Cap by origin authority
+    ceiling = ORIGIN_STRENGTH_CEILING.get(origin_type, 0.5)
+    effective = result.adjustments.get("strength", strength)
+    if effective > ceiling:
+        result.warnings.append(
+            f"Strength {effective} exceeds ceiling {ceiling} for origin '{origin_type}', capped"
+        )
+        result.adjustments["strength"] = ceiling
+
     return result

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(
@@ -696,10 +702,12 @@ class RecallService:
 
         relationships = []
         for row in rel_rows:
+            row_keys = row.keys()
             rel_dict = {
                 "type": row["relationship_type"],
                 "direction": row["direction"],
                 "strength": row["strength"],
+                "origin_type": row["origin_type"] if "origin_type" in row_keys else "extracted",
                 "other_entity": (
                     row["target_name"]
                     if row["source_entity_id"] == entity["id"]
@@ -713,7 +721,6 @@ class RecallService:
             }
             # Include temporal fields when showing historical data
             if include_historical:
-                row_keys = row.keys()
                 rel_dict["valid_at"] = row["valid_at"] if "valid_at" in row_keys else None
                 rel_dict["invalid_at"] = row["invalid_at"] if "invalid_at" in row_keys else None
             relationships.append(rel_dict)