get-claudia 1.29.2 → 1.30.0

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,30 @@ 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")
+
         # 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 +891,11 @@ 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
+
         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,
@@ -240,6 +241,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"],
             },
@@ -639,6 +650,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 +1088,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=(
@@ -1281,6 +1340,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=[
@@ -1604,6 +1665,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 +1938,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

@@ -89,6 +89,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 +409,9 @@ 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');
+
 -- ============================================================================
 -- 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

@@ -696,10 +696,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 +715,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)

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

@@ -376,6 +376,7 @@ class RememberService:
         metadata: Optional[Dict] = None,
         valid_at: Optional[str] = None,
         supersedes: bool = False,
+        origin_type: str = "extracted",
     ) -> Optional[int]:
         """
         Create or strengthen a relationship between entities.
@@ -390,12 +391,15 @@ class RememberService:
             valid_at: When this relationship became true (ISO string, defaults to now)
             supersedes: If True, invalidate existing relationship of same type
                         between same entities before creating a new one
+            origin_type: How this was learned: user_stated, extracted, inferred, corrected
 
         Returns:
             Relationship ID or None
         """
-        # Run deterministic guards
-        guard_result = validate_relationship(strength)
+        from .guards import ORIGIN_STRENGTH_CEILING, REINFORCEMENT_BY_ORIGIN
+
+        # Run deterministic guards (origin-aware)
+        guard_result = validate_relationship(strength, origin_type=origin_type)
         if guard_result.warnings:
             for w in guard_result.warnings:
                 logger.warning(f"Relationship guard: {w}")
@@ -412,44 +416,56 @@ class RememberService:
         effective_valid_at = valid_at or now
 
         if supersedes:
-            # Invalidate any existing relationship of same type FROM this source entity
+            # Invalidate existing relationship of same type between same entities (atomic)
             existing_to_supersede = self.db.get_one(
                 "relationships",
-                where="source_entity_id = ? AND relationship_type = ? AND invalid_at IS NULL",
-                where_params=(source_id, relationship_type),
+                where="source_entity_id = ? AND target_entity_id = ? AND relationship_type = ? AND invalid_at IS NULL",
+                where_params=(source_id, target_id, relationship_type),
             )
             if existing_to_supersede:
-                # Invalidate the old relationship (mark when it ended)
-                self.db.update(
-                    "relationships",
-                    {
-                        "invalid_at": now,
-                        "updated_at": now,
-                    },
-                    "id = ?",
-                    (existing_to_supersede["id"],),
-                )
-                # Rename the type to free the UNIQUE constraint slot
-                old_meta = json.loads(existing_to_supersede["metadata"] or "{}")
-                old_meta["superseded_by_at"] = now
-                self.db.update(
-                    "relationships",
-                    {
-                        "relationship_type": f"{relationship_type}__superseded_{existing_to_supersede['id']}",
-                        "metadata": json.dumps(old_meta),
+                with self.db.transaction() as conn:
+                    # Invalidate the old relationship (mark when it ended)
+                    conn.execute(
+                        "UPDATE relationships SET invalid_at = ?, updated_at = ? WHERE id = ?",
+                        (now, now, existing_to_supersede["id"]),
+                    )
+                    # Rename the type to free the UNIQUE constraint slot
+                    old_meta = json.loads(existing_to_supersede["metadata"] or "{}")
+                    old_meta["superseded_by_at"] = now
+                    conn.execute(
+                        "UPDATE relationships SET relationship_type = ?, metadata = ? WHERE id = ?",
+                        (
+                            f"{relationship_type}__superseded_{existing_to_supersede['id']}",
+                            json.dumps(old_meta),
+                            existing_to_supersede["id"],
+                        ),
+                    )
+
+                # Audit log for supersede
+                _audit_log(
+                    "relationship_supersede",
+                    details={
+                        "old_id": existing_to_supersede["id"],
+                        "source": source_name,
+                        "target": target_name,
+                        "type": relationship_type,
                     },
-                    "id = ?",
-                    (existing_to_supersede["id"],),
                 )
 
+            # Supersede always sets origin_type to 'corrected' (user is correcting the record)
+            supersede_origin = "corrected"
+            ceiling = ORIGIN_STRENGTH_CEILING.get(supersede_origin, 0.5)
+            capped_strength = min(strength, ceiling)
+
             # Create new relationship
-            return self.db.insert(
+            new_id = self.db.insert(
                 "relationships",
                 {
                     "source_entity_id": source_id,
                     "target_entity_id": target_id,
                     "relationship_type": relationship_type,
-                    "strength": strength,
+                    "strength": capped_strength,
+                    "origin_type": supersede_origin,
                     "direction": direction,
                     "valid_at": effective_valid_at,
                     "created_at": now,
@@ -458,6 +474,21 @@ class RememberService:
                 },
             )
 
+            # Audit log for create
+            _audit_log(
+                "relationship_create",
+                details={
+                    "id": new_id,
+                    "source": source_name,
+                    "target": target_name,
+                    "type": relationship_type,
+                    "origin_type": supersede_origin,
+                    "strength": capped_strength,
+                },
+            )
+
+            return new_id
+
         # Check for existing current relationship (non-supersede path)
         existing = self.db.get_one(
             "relationships",
@@ -466,11 +497,23 @@ class RememberService:
         )
 
         if existing:
-            # Default behavior: strengthen existing relationship
-            new_strength = min(1.0, existing["strength"] + 0.1)
+            # Determine ceiling: if new origin is higher-authority, upgrade
+            existing_origin = existing["origin_type"] if "origin_type" in existing.keys() else "extracted"
+            effective_origin = existing_origin
+
+            # Origin upgrade: user_stated/corrected outrank extracted, which outranks inferred
+            origin_rank = {"inferred": 0, "extracted": 1, "user_stated": 2, "corrected": 2}
+            if origin_rank.get(origin_type, 0) > origin_rank.get(existing_origin, 0):
+                effective_origin = origin_type
+
+            ceiling = ORIGIN_STRENGTH_CEILING.get(effective_origin, 0.5)
+            increment = REINFORCEMENT_BY_ORIGIN.get(origin_type, 0.1)
+            new_strength = min(ceiling, existing["strength"] + increment)
+
             update_data = {
                 "strength": new_strength,
                 "updated_at": now,
+                "origin_type": effective_origin,
             }
             # Ensure valid_at is set on existing relationships
             row_keys = existing.keys()
@@ -485,13 +528,14 @@ class RememberService:
             return existing["id"]
         else:
             # Create new relationship
-            return self.db.insert(
+            new_id = self.db.insert(
                 "relationships",
                 {
                     "source_entity_id": source_id,
                     "target_entity_id": target_id,
                     "relationship_type": relationship_type,
                     "strength": strength,
+                    "origin_type": origin_type,
                     "direction": direction,
                     "valid_at": effective_valid_at,
                     "created_at": now,
@@ -500,6 +544,105 @@ class RememberService:
                 },
             )
 
+            # Audit log
+            _audit_log(
+                "relationship_create",
+                details={
+                    "id": new_id,
+                    "source": source_name,
+                    "target": target_name,
+                    "type": relationship_type,
+                    "origin_type": origin_type,
+                    "strength": strength,
+                },
+            )
+
+            return new_id
+
+    def invalidate_relationship(
+        self,
+        source_name: str,
+        target_name: str,
+        relationship_type: str,
+        reason: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Invalidate a relationship without creating a replacement.
+
+        Finds the active relationship by source + target + type, marks it with
+        invalid_at, and renames the type to free the UNIQUE constraint. Atomic.
+
+        Args:
+            source_name: Source entity name
+            target_name: Target entity name
+            relationship_type: Type of relationship to invalidate
+            reason: Why this relationship is being invalidated
+
+        Returns:
+            Dict with invalidated relationship info, or None if not found
+        """
+        source_id = self._find_or_create_entity(source_name)
+        target_id = self._find_or_create_entity(target_name)
+
+        if not source_id or not target_id:
+            return None
+
+        existing = self.db.get_one(
+            "relationships",
+            where="source_entity_id = ? AND target_entity_id = ? AND relationship_type = ? AND invalid_at IS NULL",
+            where_params=(source_id, target_id, relationship_type),
+        )
+
+        if not existing:
+            return None
+
+        now = datetime.utcnow().isoformat()
+
+        with self.db.transaction() as conn:
+            # Invalidate and rename type atomically
+            old_meta = json.loads(existing["metadata"] or "{}")
+            old_meta["invalidated_reason"] = reason
+            old_meta["invalidated_at"] = now
+
+            conn.execute(
+                "UPDATE relationships SET invalid_at = ?, updated_at = ?, "
+                "relationship_type = ?, metadata = ? WHERE id = ?",
+                (
+                    now,
+                    now,
+                    f"{relationship_type}__invalidated_{existing['id']}",
+                    json.dumps(old_meta),
+                    existing["id"],
+                ),
+            )
+
+        # Audit log
+        _audit_log(
+            "relationship_invalidate",
+            details={
+                "id": existing["id"],
+                "source": source_name,
+                "target": target_name,
+                "type": relationship_type,
+                "reason": reason,
+            },
+        )
+
+        logger.info(
+            f"Invalidated relationship {existing['id']}: "
+            f"{source_name} -> {relationship_type} -> {target_name}"
+            + (f" ({reason})" if reason else "")
+        )
+
+        return {
+            "relationship_id": existing["id"],
+            "source": source_name,
+            "target": target_name,
+            "relationship_type": relationship_type,
+            "invalidated_at": now,
+            "reason": reason,
+        }
+
     def merge_entities(
         self,
         source_id: int,
@@ -1576,3 +1719,10 @@ def correct_memory(memory_id: int, correction: str, reason: Optional[str] = None
 def invalidate_memory(memory_id: int, reason: Optional[str] = None) -> Dict[str, Any]:
     """Mark a memory as no longer true"""
     return get_remember_service().invalidate_memory(memory_id, reason)
+
+
+def invalidate_relationship(
+    source: str, target: str, relationship: str, reason: Optional[str] = None
+) -> Optional[Dict[str, Any]]:
+    """Invalidate a relationship without creating a replacement"""
+    return get_remember_service().invalidate_relationship(source, target, relationship, reason)

package/memory-daemon/tests/test_batch_parallel.py

@@ -346,3 +346,122 @@ class TestBatchWithParallelEmbeddings:
 
         mem2 = db.get_one("memories", where="content = ?", where_params=("Meeting scheduled for Friday",))
         assert mem2 is not None
+
+
+class TestBatchRelateForwarding:
+    """Test that batch relate operations forward origin_type and other parameters."""
+
+    def test_batch_relate_forwards_origin_type(self, db):
+        """origin_type is stored in DB when passed through batch relate."""
+        svc = _get_remember_service(db)
+
+        # Create entities first
+        svc.remember_entity(
+            name="Ford Perry",
+            entity_type="person",
+            _precomputed_embedding=_fake_embedding("Ford Perry"),
+        )
+        svc.remember_entity(
+            name="Beemok Capital",
+            entity_type="organization",
+            _precomputed_embedding=_fake_embedding("Beemok Capital"),
+        )
+
+        # Relate with inferred origin
+        rel_id = svc.relate_entities(
+            source_name="Ford Perry",
+            target_name="Beemok Capital",
+            relationship_type="works_at",
+            origin_type="inferred",
+        )
+        assert rel_id is not None
+
+        row = db.get_one("relationships", where="id = ?", where_params=(rel_id,))
+        assert row["origin_type"] == "inferred"
+        # Inferred ceiling is 0.5, so strength should be capped
+        assert row["strength"] <= 0.5
+
+    def test_batch_relate_forwards_supersedes(self, db):
+        """Batch supersede works: old relationship invalidated, new one created."""
+        svc = _get_remember_service(db)
+
+        svc.remember_entity(
+            name="Ford Perry",
+            entity_type="person",
+            _precomputed_embedding=_fake_embedding("Ford Perry"),
+        )
+        svc.remember_entity(
+            name="Acme Corp",
+            entity_type="organization",
+            _precomputed_embedding=_fake_embedding("Acme Corp"),
+        )
+
+        # Create initial relationship
+        rel1 = svc.relate_entities(
+            source_name="Ford Perry",
+            target_name="Acme Corp",
+            relationship_type="works_at",
+            origin_type="extracted",
+        )
+
+        # Supersede it
+        rel2 = svc.relate_entities(
+            source_name="Ford Perry",
+            target_name="Acme Corp",
+            relationship_type="works_at",
+            supersedes=True,
+        )
+
+        assert rel2 != rel1
+
+        # Old should be invalidated
+        old_row = db.get_one("relationships", where="id = ?", where_params=(rel1,))
+        assert old_row["invalid_at"] is not None
+
+        # New should be active with origin_type='corrected'
+        new_row = db.get_one("relationships", where="id = ?", where_params=(rel2,))
+        assert new_row["invalid_at"] is None
+        assert new_row["origin_type"] == "corrected"
+
+    def test_origin_upgrade_lifts_ceiling(self, db):
+        """Re-encountering with higher-authority origin upgrades origin_type and lifts ceiling."""
+        svc = _get_remember_service(db)
+
+        svc.remember_entity(
+            name="Ford Perry",
+            entity_type="person",
+            _precomputed_embedding=_fake_embedding("Ford Perry"),
+        )
+        svc.remember_entity(
+            name="Beemok Capital",
+            entity_type="organization",
+            _precomputed_embedding=_fake_embedding("Beemok Capital"),
+        )
+
+        # Create with inferred origin (ceiling 0.5)
+        rel_id = svc.relate_entities(
+            source_name="Ford Perry",
+            target_name="Beemok Capital",
+            relationship_type="works_at",
+            origin_type="inferred",
+        )
+
+        row1 = db.get_one("relationships", where="id = ?", where_params=(rel_id,))
+        assert row1["origin_type"] == "inferred"
+        assert row1["strength"] <= 0.5
+
+        # Re-encounter with user_stated (should upgrade origin and lift ceiling)
+        rel_id2 = svc.relate_entities(
+            source_name="Ford Perry",
+            target_name="Beemok Capital",
+            relationship_type="works_at",
+            origin_type="user_stated",
+        )
+
+        # Same relationship ID (strengthened, not replaced)
+        assert rel_id2 == rel_id
+
+        row2 = db.get_one("relationships", where="id = ?", where_params=(rel_id,))
+        assert row2["origin_type"] == "user_stated"
+        # With user_stated ceiling of 1.0 and +0.2 increment, strength should increase
+        assert row2["strength"] > row1["strength"]

package/memory-daemon/tests/test_bitemporal.py

@@ -18,7 +18,7 @@ def _setup_db():
 
 
 def _create_entities(db):
-    """Create Sarah, Acme, and Beta entities."""
+    """Create Sarah, Acme, Beta, and Casey entities."""
     sarah_id = db.insert("entities", {
         "name": "Sarah Chen",
         "type": "person",
@@ -37,7 +37,13 @@ def _create_entities(db):
         "canonical_name": "beta corp",
         "importance": 1.0,
     })
-    return sarah_id, acme_id, beta_id
+    casey_id = db.insert("entities", {
+        "name": "Casey Potenzone",
+        "type": "person",
+        "canonical_name": "casey potenzone",
+        "importance": 1.0,
+    })
+    return sarah_id, acme_id, beta_id, casey_id
 
 
 class TestBitemporalRelationships:
@@ -46,7 +52,7 @@ class TestBitemporalRelationships:
     def test_new_relationship_gets_valid_at(self):
         """New relationship gets valid_at set automatically."""
         db, tmpdir = _setup_db()
-        sarah_id, acme_id, _ = _create_entities(db)
+        sarah_id, acme_id, _, _ = _create_entities(db)
 
         import claudia_memory.database as db_mod
         import claudia_memory.services.remember as rem_mod
@@ -70,9 +76,14 @@ class TestBitemporalRelationships:
             rem_mod._service = old_svc
 
     def test_supersedes_invalidates_old_creates_new(self):
-        """supersedes=True invalidates old relationship and creates new one."""
+        """supersedes=True invalidates old relationship of same triple and creates new one.
+
+        Note: supersede now correctly matches source + target + type (not just source + type).
+        To replace Sarah->Acme with Sarah->Beta, use invalidate+create, not supersede.
+        Supersede is for correcting the SAME relationship (same source, target, type).
+        """
         db, tmpdir = _setup_db()
-        sarah_id, acme_id, beta_id = _create_entities(db)
+        sarah_id, acme_id, beta_id, _ = _create_entities(db)
 
         import claudia_memory.database as db_mod
         import claudia_memory.services.remember as rem_mod
@@ -89,9 +100,9 @@ class TestBitemporalRelationships:
             rel1_id = svc.relate_entities("Sarah Chen", "Acme Corp", "works_at")
             assert rel1_id is not None
 
-            # Supersede with new relationship
+            # Supersede same triple (correction to same relationship)
             rel2_id = svc.relate_entities(
-                "Sarah Chen", "Beta Corp", "works_at",
+                "Sarah Chen", "Acme Corp", "works_at",
                 supersedes=True,
             )
             assert rel2_id is not None
@@ -102,11 +113,12 @@ class TestBitemporalRelationships:
             assert old_row["invalid_at"] is not None
             assert "__superseded_" in old_row["relationship_type"]
 
-            # New relationship should be current
+            # New relationship should be current with origin_type='corrected'
             new_row = db.get_one("relationships", where="id = ?", where_params=(rel2_id,))
             assert new_row["invalid_at"] is None
             assert new_row["valid_at"] is not None
             assert new_row["relationship_type"] == "works_at"
+            assert new_row["origin_type"] == "corrected"
         finally:
             db_mod._db = old_db
             rem_mod._service = old_svc
@@ -114,7 +126,7 @@ class TestBitemporalRelationships:
     def test_default_recall_shows_current_only(self):
         """Default recall_about only shows current (non-invalidated) relationships."""
         db, tmpdir = _setup_db()
-        sarah_id, acme_id, beta_id = _create_entities(db)
+        sarah_id, acme_id, beta_id, _ = _create_entities(db)
 
         import claudia_memory.database as db_mod
         import claudia_memory.services.remember as rem_mod
@@ -132,9 +144,11 @@ class TestBitemporalRelationships:
             rem_svc = RememberService()
             rec_svc = RecallService()
 
-            # Create and supersede
+            # Create Acme relationship, then invalidate and create Beta
             rem_svc.relate_entities("Sarah Chen", "Acme Corp", "works_at")
-            rem_svc.relate_entities("Sarah Chen", "Beta Corp", "works_at", supersedes=True)
+            rem_svc.invalidate_relationship("Sarah Chen", "Acme Corp", "works_at",
+                                             reason="Left company")
+            rem_svc.relate_entities("Sarah Chen", "Beta Corp", "works_at")
 
             # Default: only current
             result = rec_svc.recall_about("Sarah Chen")
@@ -152,7 +166,7 @@ class TestBitemporalRelationships:
     def test_include_historical_shows_all(self):
         """include_historical=True shows all relationships including invalidated."""
         db, tmpdir = _setup_db()
-        sarah_id, acme_id, beta_id = _create_entities(db)
+        sarah_id, acme_id, beta_id, _ = _create_entities(db)
 
         import claudia_memory.database as db_mod
         import claudia_memory.services.remember as rem_mod
@@ -170,11 +184,13 @@ class TestBitemporalRelationships:
             rem_svc = RememberService()
             rec_svc = RecallService()
 
-            # Create and supersede
+            # Create Acme relationship, then invalidate and create Beta
             rem_svc.relate_entities("Sarah Chen", "Acme Corp", "works_at")
-            rem_svc.relate_entities("Sarah Chen", "Beta Corp", "works_at", supersedes=True)
+            rem_svc.invalidate_relationship("Sarah Chen", "Acme Corp", "works_at",
+                                             reason="Left company")
+            rem_svc.relate_entities("Sarah Chen", "Beta Corp", "works_at")
 
-            # Historical: shows both
+            # Historical: shows both (Acme invalidated + Beta current)
             result = rec_svc.recall_about("Sarah Chen", include_historical=True)
             assert len(result["relationships"]) >= 2
 
@@ -190,7 +206,7 @@ class TestBitemporalRelationships:
     def test_migration_grandfathers_existing(self):
         """Migration sets valid_at = created_at for existing relationships."""
         db, tmpdir = _setup_db()
-        sarah_id, acme_id, _ = _create_entities(db)
+        sarah_id, acme_id, _, _ = _create_entities(db)
 
         # Insert a relationship without valid_at (simulating pre-migration)
         db.execute(
@@ -251,3 +267,173 @@ class TestBitemporalRelationships:
         finally:
             db_mod._db = old_db
             rem_mod._service = old_svc
+
+    def test_supersede_targets_correct_relationship(self):
+        """Superseding A->X only affects X, not A->Y of the same type.
+
+        This was a real bug: the old supersede query only matched source + type,
+        not target. When Sarah had works_with->Acme AND works_with->Beta,
+        superseding works_with->Acme could invalidate works_with->Beta instead.
+        """
+        db, tmpdir = _setup_db()
+        sarah_id, acme_id, beta_id, _ = _create_entities(db)
+
+        import claudia_memory.database as db_mod
+        import claudia_memory.services.remember as rem_mod
+        old_db = db_mod._db
+        old_svc = rem_mod._service
+
+        try:
+            db_mod._db = db
+            rem_mod._service = None
+            from claudia_memory.services.remember import RememberService
+            svc = RememberService()
+
+            # Create two relationships of the same type to different targets
+            rel_acme = svc.relate_entities("Sarah Chen", "Acme Corp", "works_at")
+            rel_beta = svc.relate_entities("Sarah Chen", "Beta Corp", "works_at")
+            assert rel_acme is not None
+            assert rel_beta is not None
+            assert rel_acme != rel_beta
+
+            # Supersede the Acme relationship specifically
+            rel_acme_new = svc.relate_entities(
+                "Sarah Chen", "Acme Corp", "works_at",
+                supersedes=True,
+            )
+
+            # The Beta relationship should be UNTOUCHED
+            beta_row = db.get_one("relationships", where="id = ?", where_params=(rel_beta,))
+            assert beta_row["invalid_at"] is None
+            assert beta_row["relationship_type"] == "works_at"
+
+            # The old Acme relationship should be invalidated
+            acme_old = db.get_one("relationships", where="id = ?", where_params=(rel_acme,))
+            assert acme_old["invalid_at"] is not None
+        finally:
+            db_mod._db = old_db
+            rem_mod._service = old_svc
+
+    def test_supersede_same_triple_correction(self):
+        """Superseding A->X with a new A->X (same triple) works as a correction."""
+        db, tmpdir = _setup_db()
+        _create_entities(db)
+
+        import claudia_memory.database as db_mod
+        import claudia_memory.services.remember as rem_mod
+        old_db = db_mod._db
+        old_svc = rem_mod._service
+
+        try:
+            db_mod._db = db
+            rem_mod._service = None
+            from claudia_memory.services.remember import RememberService
+            svc = RememberService()
+
+            # Create initial relationship
+            rel1 = svc.relate_entities("Sarah Chen", "Acme Corp", "works_at",
+                                       strength=0.5, origin_type="inferred")
+
+            # Supersede with a correction (same source, target, type)
+            rel2 = svc.relate_entities("Sarah Chen", "Acme Corp", "works_at",
+                                       supersedes=True, origin_type="user_stated")
+
+            assert rel2 is not None
+            assert rel2 != rel1
+
+            # Old should be invalidated
+            old_row = db.get_one("relationships", where="id = ?", where_params=(rel1,))
+            assert old_row["invalid_at"] is not None
+
+            # New should have origin_type='corrected' (supersede always sets this)
+            new_row = db.get_one("relationships", where="id = ?", where_params=(rel2,))
+            assert new_row["origin_type"] == "corrected"
+            assert new_row["invalid_at"] is None
+        finally:
+            db_mod._db = old_db
+            rem_mod._service = old_svc
+
+    def test_invalidate_relationship(self):
+        """Invalidation sets invalid_at without creating a replacement."""
+        db, tmpdir = _setup_db()
+        _create_entities(db)
+
+        import claudia_memory.database as db_mod
+        import claudia_memory.services.remember as rem_mod
+        old_db = db_mod._db
+        old_svc = rem_mod._service
+
+        try:
+            db_mod._db = db
+            rem_mod._service = None
+            from claudia_memory.services.remember import RememberService
+            svc = RememberService()
+
+            # Create a relationship
+            rel_id = svc.relate_entities("Sarah Chen", "Acme Corp", "works_at")
+            assert rel_id is not None
+
+            # Invalidate it
+            result = svc.invalidate_relationship(
+                "Sarah Chen", "Acme Corp", "works_at",
+                reason="She left the company",
+            )
+            assert result is not None
+            assert result["relationship_id"] == rel_id
+            assert result["reason"] == "She left the company"
+
+            # The row should be invalidated with renamed type
+            row = db.get_one("relationships", where="id = ?", where_params=(rel_id,))
+            assert row["invalid_at"] is not None
+            assert "__invalidated_" in row["relationship_type"]
+
+            # No new relationship should have been created
+            active = db.execute(
+                "SELECT COUNT(*) as cnt FROM relationships WHERE invalid_at IS NULL",
+                fetch=True,
+            )
+            assert active[0]["cnt"] == 0
+        finally:
+            db_mod._db = old_db
+            rem_mod._service = old_svc
+
+    def test_invalidate_logs_audit(self):
+        """Invalidation logs to the audit trail."""
+        db, tmpdir = _setup_db()
+        _create_entities(db)
+
+        import claudia_memory.database as db_mod
+        import claudia_memory.services.remember as rem_mod
+        import claudia_memory.services.audit as audit_mod
+        old_db = db_mod._db
+        old_svc = rem_mod._service
+        old_audit_svc = audit_mod._service
+
+        try:
+            db_mod._db = db
+            rem_mod._service = None
+            audit_mod._service = None  # Reset audit singleton to use test DB
+            from claudia_memory.services.remember import RememberService
+            svc = RememberService()
+
+            rel_id = svc.relate_entities("Sarah Chen", "Acme Corp", "works_at")
+            svc.invalidate_relationship(
+                "Sarah Chen", "Acme Corp", "works_at",
+                reason="Incorrect data",
+            )
+
+            # Check audit log for invalidation entry
+            audit_rows = db.execute(
+                "SELECT * FROM audit_log WHERE operation = 'relationship_invalidate'",
+                fetch=True,
+            ) or []
+            assert len(audit_rows) >= 1
+            # The audit should reference the correct relationship
+            import json
+            details = json.loads(audit_rows[0]["details"])
+            assert details["id"] == rel_id
+            assert details["reason"] == "Incorrect data"
+        finally:
+            db_mod._db = old_db
+            rem_mod._service = old_svc
+            audit_mod._service = old_audit_svc

package/memory-daemon/tests/test_guards.py

@@ -68,8 +68,9 @@ def test_validate_entity_empty_name():
 
 def test_validate_relationship_strength_clamped():
     """Strength outside [0, 1] gets clamped"""
-    result = validate_relationship(1.5)
+    # Use user_stated (ceiling=1.0) to isolate the clamping logic from origin ceilings
+    result = validate_relationship(1.5, origin_type="user_stated")
     assert result.adjustments["strength"] == 1.0
 
-    result2 = validate_relationship(-0.2)
+    result2 = validate_relationship(-0.2, origin_type="user_stated")
     assert result2.adjustments["strength"] == 0.0

package/memory-daemon/tests/test_relationship_guards.py

@@ -0,0 +1,79 @@
+"""Tests for origin-aware relationship strength guards."""
+
+import pytest
+
+from claudia_memory.services.guards import (
+    ORIGIN_STRENGTH_CEILING,
+    REINFORCEMENT_BY_ORIGIN,
+    validate_relationship,
+)
+
+
+class TestOriginStrengthCeilings:
+    """Test that relationship strength is capped by origin authority."""
+
+    def test_inferred_capped_at_half(self):
+        """Inferred relationships are capped at 0.5 strength."""
+        result = validate_relationship(strength=1.0, origin_type="inferred")
+        assert "strength" in result.adjustments
+        assert result.adjustments["strength"] == 0.5
+        assert any("ceiling" in w for w in result.warnings)
+
+    def test_user_stated_uncapped(self):
+        """User-stated relationships allow full 1.0 strength."""
+        result = validate_relationship(strength=1.0, origin_type="user_stated")
+        # No cap needed -- user_stated ceiling is 1.0
+        assert result.adjustments.get("strength", 1.0) == 1.0
+        assert not any("ceiling" in w for w in result.warnings)
+
+    def test_extracted_capped_at_0_8(self):
+        """Extracted relationships are capped at 0.8 strength."""
+        result = validate_relationship(strength=1.0, origin_type="extracted")
+        assert "strength" in result.adjustments
+        assert result.adjustments["strength"] == 0.8
+        assert any("ceiling" in w for w in result.warnings)
+
+    def test_corrected_uncapped(self):
+        """Corrected relationships allow full 1.0 strength (same as user_stated)."""
+        result = validate_relationship(strength=1.0, origin_type="corrected")
+        assert result.adjustments.get("strength", 1.0) == 1.0
+        assert not any("ceiling" in w for w in result.warnings)
+
+    def test_unknown_origin_defaults_to_0_5(self):
+        """Unknown origin types default to 0.5 ceiling."""
+        result = validate_relationship(strength=0.9, origin_type="mystery")
+        assert result.adjustments["strength"] == 0.5
+
+    def test_strength_below_ceiling_untouched(self):
+        """Strength already below ceiling is not adjusted."""
+        result = validate_relationship(strength=0.3, origin_type="inferred")
+        # 0.3 < 0.5 ceiling, so no adjustment for ceiling
+        assert "strength" not in result.adjustments or result.adjustments.get("strength") == 0.3
+
+
+class TestReinforcementScaling:
+    """Test that reinforcement increments scale by origin."""
+
+    def test_inferred_increment_is_0_05(self):
+        assert REINFORCEMENT_BY_ORIGIN["inferred"] == 0.05
+
+    def test_extracted_increment_is_0_1(self):
+        assert REINFORCEMENT_BY_ORIGIN["extracted"] == 0.1
+
+    def test_user_stated_increment_is_0_2(self):
+        assert REINFORCEMENT_BY_ORIGIN["user_stated"] == 0.2
+
+    def test_corrected_increment_is_0_2(self):
+        assert REINFORCEMENT_BY_ORIGIN["corrected"] == 0.2
+
+
+class TestCeilingValues:
+    """Verify the ceiling constants are correct."""
+
+    def test_ceiling_values(self):
+        assert ORIGIN_STRENGTH_CEILING == {
+            "user_stated": 1.0,
+            "extracted": 0.8,
+            "inferred": 0.5,
+            "corrected": 1.0,
+        }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.29.2",
+  "version": "1.30.0",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/skills/map-connections/SKILL.md

@@ -60,9 +60,10 @@ For each file, extract:
 
 ### 3. Extract Relationships
 
-Identify explicit and implicit relationships:
+Identify explicit and implicit relationships. For each relationship, set `origin_type` honestly based on how you know it. The system automatically caps strength based on origin, so always use `strength: 1.0` and let the guards enforce the ceiling.
 
-**Explicit Relationships (High Confidence: 0.9)**
+**Extracted Relationships** (origin_type: "extracted", ceiling: 0.8)
+Explicitly stated in the file:
 - "works with [Name]" -> `works_with`
 - "client of [Name]" -> `client_of`
 - "reports to [Name]" -> `reports_to`
@@ -71,11 +72,10 @@ Identify explicit and implicit relationships:
 - "partner at [Org]" -> `partner_at`
 - "advisor to [Name/Org]" -> `advisor_to`
 
-**Co-mention Relationships (Medium Confidence: 0.6)**
+**Inferred Relationships** (origin_type: "inferred", ceiling: 0.5)
+Co-mentioned or contextually implied:
 - Two people mentioned in the same file -> `mentioned_with`
 - People in the same project file -> `collaborates_on`
-
-**Inferred Relationships (Low Confidence: 0.3)**
 - Same city + same industry -> `likely_connected`
 - Same organization -> `colleagues`
 - Same community group -> `community_connection`
@@ -96,18 +96,20 @@ Use `memory.batch` for efficiency:
 memory.batch operations=[
   {op: "entity", name: "Sarah Chen", type: "person", description: "CEO at Acme Corp"},
   {op: "entity", name: "Acme Corp", type: "organization"},
-  {op: "relate", source: "Sarah Chen", target: "Acme Corp", relationship: "works_at", strength: 0.9},
-  {op: "relate", source: "Sarah Chen", target: "Tom Miller", relationship: "works_with", strength: 0.6},
+  {op: "relate", source: "Sarah Chen", target: "Acme Corp", relationship: "works_at", strength: 1.0, origin_type: "extracted"},
+  {op: "relate", source: "Sarah Chen", target: "Tom Miller", relationship: "works_with", strength: 1.0, origin_type: "inferred"},
   ...
 ]
 ```
 
-For relationship strength:
-- High confidence (explicit): 0.9
-- Medium confidence (co-mention): 0.6
-- Low confidence (inferred): 0.3
+For relationship `origin_type`:
+- Explicitly stated in the file ("Sarah is CEO of Acme"): `origin_type: "extracted"`
+- Co-mentioned or contextually implied: `origin_type: "inferred"`
+- User told you directly: `origin_type: "user_stated"`
+
+The system automatically caps strength based on origin. You don't need to manually calibrate. Just be honest about how you know, and always use `strength: 1.0`.
 
-When updating existing relationships, take the maximum strength.
+When re-encountering existing relationships, the system strengthens them incrementally (scaled by origin). Repeated evidence builds trust organically.
 
 ### 6. Report Results
 
@@ -129,23 +131,23 @@ Output format:
 
 ### New Relationships ([count])
 
-| Source | Relationship | Target | Confidence |
-|--------|--------------|--------|------------|
-| Sarah Chen | works_at | Acme Corp | high (0.9) |
-| Sarah Chen | collaborates_on | Website Redesign | high (0.9) |
-| Sarah Chen | mentioned_with | Tom Miller | medium (0.6) |
+| Source | Relationship | Target | Origin |
+|--------|--------------|--------|--------|
+| Sarah Chen | works_at | Acme Corp | extracted |
+| Sarah Chen | collaborates_on | Website Redesign | extracted |
+| Sarah Chen | mentioned_with | Tom Miller | inferred |
 
 ### Inferred Connections ([count])
 
-| Entity A | Entity B | Reason | Confidence |
-|----------|----------|--------|------------|
-| Sarah Chen | Jane Doe | Same city (Palm Beach) + industry (real estate) | low (0.3) |
+| Entity A | Entity B | Reason | Origin |
+|----------|----------|--------|--------|
+| Sarah Chen | Jane Doe | Same city (Palm Beach) + industry (real estate) | inferred |
 
 ### Updated Relationships ([count])
 
 | Relationship | Change |
 |--------------|--------|
-| Sarah Chen -> client_of -> Beta Inc | strength: 0.6 -> 0.9 |
+| Sarah Chen -> client_of -> Beta Inc | strengthened (re-encountered, extracted) |
 
 ### Summary