get-claudia 1.57.0 → 1.58.0

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 All notable changes to Claudia will be documented in this file.
 
+## 1.58.0 (2026-05-13)
+
+### The Memory Reliability Release
+
+Five PRs that fix the memory layer's biggest recurring failure mode and lock in the integration philosophy. After this release, memory writes that name entities ("Matt Blumberg") actually create those entities with the correct type. The release history's recurring memory-fix releases ("Recall Recovery", "Vector Search Fix", "Semantic Search Actually Works Now") get permanent regression-test sentinels so the same bug classes can't quietly come back. And the codebase loses a dual-maintenance hazard that was already costing time.
+
+#### Fixed
+- **`memory_remember` actually links entities and infers their type correctly (#54)** -- A confirmed bug from 2026-05-13: calling `memory_remember(content="Matt Blumberg said X", entities=["Matt Blumberg", "Markup AI"])` was creating entities but assigning them `type: person` by default, even when the name clearly indicated an organization. "Markup AI" was being saved as a person. The real bug was in `_infer_entity_type` -- it didn't recognise `AI` / `.ai` / `Co.` as corporate suffixes and fell back to `person`. Fixed with a pure-function rule-based type inference (corporate suffixes -> organization, project keywords -> project, person patterns -> person, fallback -> concept, never default to person). Plus a new `claudia-memory --backfill-entities` CLI to retroactively link orphaned references in existing user databases.
+
+#### Added
+- **`claudia memory backfill-entities` command (#54)** -- Default dry-run: prints a plan and writes nothing. `--apply` makes a timestamped backup to `~/.claudia/backups/memory-{timestamp}.db` first, then applies the backfill. Idempotent: re-running on an already-backfilled DB is a no-op. Aborts cleanly if backup creation fails.
+- **5 regression tests for recurring bug classes (#56)** -- New `memory-daemon/tests/test_recurring_regressions.py` adds permanent forward-looking sentinels for: entity linking on `memory_remember`, recall returning results after seed writes, embedding migration preserving recall, daemon startup tolerating stale SHM files, and `memory_briefing` returning a valid structure on an empty database. Each test docstring names the historical releases where its bug class appeared (v1.35.x, v1.51.5, v1.51.18, v1.55.7, v1.55.8, v1.55.14, v1.21.1, v1.40.1).
+- **API parameter aliases for read-side MCP tools (#57)** -- `memory_about` now accepts `entity_name` and `name` alongside `entity`. `memory_relate` accepts `source_entity` / `target_entity` / `relationship_type` alongside `source` / `target` / `relationship`. `memory_recall` accepts `q` and `search` alongside `query`. Purely additive: every existing caller continues to work unchanged. Aliases normalize at the MCP boundary; service-layer signatures are untouched. If both canonical and alias are passed in the same call, canonical wins.
+
+#### Removed
+- **Rube (Composio) MCP integration as a bundled default (#41)** -- Rube is no longer a recommended or bundled MCP server in `.mcp.json.example` (root and template-v2), README, or the Claudia documentation. Locks in the direct-integrations-only philosophy (claude.ai-native MCPs + user-built custom MCPs like Gmail/Calendar). Existing users with `rube` already configured continue to work unchanged; the installer simply no longer ships Rube as an example. The "Tool configuration" example in `claudia-principles.md` was updated to vendor-neutral phrasing.
+- **Legacy `claudia/` sibling files (#55)** -- Removed 3 stale sibling files (`post-tool-capture.py`, `session-health-check.py`, `settings.local.json`) that lived under `claudia/`. These were never reaching users (the installer ships from `template-v2/` only), but every hook bug fix had to remember to patch both locations. The dual-maintenance hazard was real: PR #38's sibling-fix step had to apply the same env-var fix twice. Removed at the source.
+
+#### Stats
+- **43 new tests** across 4 files (22 entity-resolution tests in #54, 5 regression sentinels in #56, 16 alias tests in #57)
+- **805 total daemon tests passing** (up from 762 before the v1.57.0 chain), 0 regressions
+- TDD sensitivity proofs for every behavior change: tests fail on the un-modified code, pass after the fix
+- 5 PRs merged, all with stop-gates and TDD discipline
+
+#### Notes
+- The bug in #54 was different from the original proposal (#51) described. The proposal said "entities are silently ignored." Actually the entity *records* were getting created -- the bug was that they were all getting `type: person`. Fixing the actual bug rather than the imagined one was a better outcome.
+- The `claudia memory backfill-entities` command surface lives on the daemon's argparse (alongside `--backfill-embeddings`, `--migrate-vault-para`), not as a `claudia memory ...` subcommand on the Node CLI. The Node CLI is the installer, not a memory-command dispatcher.
+- Aliases are NOT yet advertised in the MCP `list_tools()` `inputSchema`. They are tolerantly accepted at the request boundary. Schema-level advertisement is a future enhancement if it proves needed for client discoverability.
+
+---
+
 ## 1.57.0 (2026-05-13)
 
 ### The Curated Memory Release

package/README.md

@@ -320,19 +320,6 @@ This generates a one-click URL to enable all required Google APIs and walks you
 | **Extended** | 83 | Core + Docs, Sheets, Tasks, Chat |
 | **Complete** | 111 | Extended + Slides, Forms, Apps Script |
 
-### 500+ Apps via Rube
-
-[Rube](https://rube.app) (by Composio) connects Claudia to Slack, Notion, Jira, GitHub, Linear, HubSpot, Stripe, Figma, and hundreds more through one-click OAuth. No per-app MCP setup needed.
-
-| Category | Examples |
-|----------|----------|
-| **Communication** | Slack, Discord, Teams, Telegram |
-| **Project Management** | Jira, Linear, Asana, Trello, Monday.com |
-| **Knowledge & Docs** | Notion, Confluence, Google Docs, Coda |
-| **Code & Dev** | GitHub, GitLab, Bitbucket |
-| **CRM & Sales** | HubSpot, Salesforce, Pipedrive |
-| **And 500+ more** | [Browse the full list](https://rube.app) |
-
 ### Obsidian Vault
 
 Memory auto-syncs to an Obsidian vault at `~/.claudia/vault/` using PARA structure. Every entity becomes a markdown note with `[[wikilinks]]`, so Obsidian's graph view maps your network. SQLite is the source of truth; the vault is a read-only projection you can browse and search.

package/memory-daemon/claudia_memory/__main__.py

@@ -1110,6 +1110,24 @@ def main():
         action="store_true",
         help="Preview mode for --migrate-vault-para: show routing plan without making changes",
     )
+    parser.add_argument(
+        "--backfill-entities",
+        action="store_true",
+        help=(
+            "Scan memories for un-linked entity references and propose "
+            "creating/linking them (Proposal #51). Dry-run by default; "
+            "pass --apply to write changes (creates a SQLite backup first)."
+        ),
+    )
+    parser.add_argument(
+        "--apply",
+        action="store_true",
+        help=(
+            "With --backfill-entities: actually write the changes. "
+            "A SQLite backup is created at ~/.claudia/backups/ before any "
+            "writes; if backup creation fails, the command aborts."
+        ),
+    )
     parser.add_argument(
         "--migrate-legacy",
         action="store_true",
@@ -1704,6 +1722,61 @@ def main():
         run_para_migration(vault_path, db=db, preview=args.preview)
         return
 
+    if args.backfill_entities:
+        # Entity-link backfill (Proposal #51). Dry-run by default; --apply
+        # writes after creating a SQLite backup.
+        setup_logging(debug=args.debug)
+        from datetime import datetime as _dt
+
+        from .services.backfill import (
+            apply_backfill,
+            format_plan_summary,
+            plan_backfill,
+        )
+
+        db = get_db()
+        db.initialize()
+
+        plan = plan_backfill(db)
+        print(format_plan_summary(plan))
+
+        if not args.apply:
+            # Dry-run path: we already printed the plan; nothing more to do.
+            return
+
+        # --apply: take the mandatory backup first.
+        config = get_config()
+        backups_dir = Path(config.backup_dir)
+        try:
+            backups_dir.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            print(
+                f"\nCannot create backup directory {backups_dir}: {e}\n"
+                "Aborting before any database writes."
+            )
+            sys.exit(1)
+
+        timestamp = _dt.utcnow().strftime("%Y-%m-%dT%H%M%SZ")
+        backup_path = backups_dir / f"memory-{timestamp}.db"
+
+        try:
+            result = apply_backfill(db, plan, backup_path=backup_path)
+        except Exception as e:
+            print(
+                f"\nBackfill aborted (no DB writes performed): {e}\n"
+                f"Backup target was: {backup_path}"
+            )
+            sys.exit(1)
+
+        print(
+            "\nBackfill applied:\n"
+            f"  backup written to:   {result.backup_path}\n"
+            f"  entities created:    {result.entities_created}\n"
+            f"  entities reused:     {result.entities_reused}\n"
+            f"  memory_entities links created: {result.links_created}"
+        )
+        return
+
     if args.merge_databases:
         # Manual consolidation of hash-named databases
         setup_logging(debug=args.debug)

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

@@ -141,6 +141,79 @@ def _require(arguments: dict, key: str, tool_name: str):
     return value
 
 
+# ── Parameter-name aliases (v1.58.0 PR E) ──
+#
+# The memory MCP tools historically used different parameter conventions
+# (entity vs source/target/relationship vs query). The aliases below let
+# callers use a consistent variant while every existing caller continues
+# to work unchanged. Normalization happens here at the MCP boundary;
+# service-layer signatures in claudia_memory/services/ are untouched.
+#
+# Rules:
+#   1. Purely additive. The canonical name continues to work as before.
+#   2. If both the canonical name and an alias are provided in the same
+#      call, the canonical name wins (the alias is left in place and is
+#      not consulted by the handler).
+#   3. Otherwise, the first matching alias is renamed to the canonical
+#      key and the alias key is removed from the arguments dict so the
+#      handler only ever sees the canonical name.
+
+_PARAM_ALIASES: Dict[str, Dict[str, List[str]]] = {
+    "memory_about": {
+        "entity": ["entity_name", "name"],
+    },
+    "memory_relate": {
+        "source": ["source_entity"],
+        "target": ["target_entity"],
+        "relationship": ["relationship_type"],
+    },
+    "memory_recall": {
+        "query": ["q", "search"],
+    },
+}
+
+
+def _normalize_params(arguments: dict, canonical: str, aliases: List[str]) -> dict:
+    """Resolve alias parameter names to the canonical name.
+
+    If the canonical name is already present in `arguments`, it wins and
+    `arguments` is returned unchanged. Otherwise, the first alias from
+    `aliases` that is present is renamed to the canonical key, and the
+    alias key is removed. If no alias matches either, `arguments` is
+    returned unchanged.
+
+    The function never mutates the caller's dict: when a rewrite is
+    needed it returns a shallow copy with the alias key replaced.
+    """
+    if canonical in arguments:
+        return arguments
+    for alias in aliases:
+        if alias in arguments:
+            arguments = dict(arguments)
+            arguments[canonical] = arguments.pop(alias)
+            return arguments
+    return arguments
+
+
+def _apply_parameter_aliases(tool_name: str, arguments: dict) -> dict:
+    """Apply all registered aliases for the given tool, if any.
+
+    Tools without an entry in `_PARAM_ALIASES` (the vast majority) get
+    their arguments back unchanged. Dot-notation aliases (e.g.
+    'memory.about') are routed to the same canonical tool name for the
+    purposes of alias lookup.
+    """
+    # Dot-notation aliases (memory.about, etc.) share the same canonical
+    # alias map as their underscore counterparts.
+    lookup_name = tool_name.replace(".", "_", 1) if "." in tool_name else tool_name
+    aliases_for_tool = _PARAM_ALIASES.get(lookup_name)
+    if not aliases_for_tool:
+        return arguments
+    for canonical, alias_list in aliases_for_tool.items():
+        arguments = _normalize_params(arguments, canonical, alias_list)
+    return arguments
+
+
 MAX_RESPONSE_BYTES = 50_000
 
 
@@ -3142,6 +3215,10 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
     """Handle tool calls via dispatch registry."""
     db = get_db()
     try:
+        # Normalize parameter-name aliases at the MCP boundary so handlers
+        # only ever see canonical parameter names. Purely additive: tools
+        # without registered aliases are unchanged. See _PARAM_ALIASES.
+        arguments = _apply_parameter_aliases(name, arguments)
         with db.transaction():
             handler = _TOOL_HANDLERS.get(name)
             if handler:

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

@@ -0,0 +1,346 @@
+"""Entity-link backfill command (Proposal #51).
+
+The pre-v1.58 write path linked entities to memories *most* of the time
+but auto-created organisations as type=person and could miss entities
+referenced only in the content (no ``about_entities`` array supplied).
+
+This module scans existing memories that have no entity links and
+proposes new entity creations + ``memory_entities`` rows. Two phases:
+
+* ``plan_backfill(db)`` -- pure read. Returns a :class:`BackfillPlan`
+  with everything it would do. No writes.
+* ``apply_backfill(db, plan, backup_path)`` -- writes. **First** creates
+  a SQLite backup at ``backup_path``. If backup fails, raises BEFORE
+  any DB modification.
+
+CLI entry points live in ``claudia_memory/__main__.py``:
+``claudia-memory --backfill-entities`` (dry-run; default) and
+``claudia-memory --backfill-entities --apply``.
+
+No new deps. No schema migrations. Idempotent on re-apply.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import sqlite3
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .entities import infer_entity_type
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Plan / Result dataclasses
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class BackfillPlan:
+    """Read-only plan of what apply_backfill would do.
+
+    Attributes:
+        orphan_count: number of memory rows with zero memory_entities links
+            that the planner thinks SHOULD have at least one link.
+        proposed_entities: list of dicts ``{"name": str, "inferred_type":
+            str, "memory_ids": [int, ...]}``. Each dict represents a name
+            we detected in memory content for which we will (a) create the
+            entity if missing, (b) link it to those memories.
+        scanned_memories: total memories the planner looked at.
+    """
+
+    orphan_count: int = 0
+    proposed_entities: List[Dict[str, Any]] = field(default_factory=list)
+    scanned_memories: int = 0
+
+
+@dataclass
+class BackfillResult:
+    """Counts of writes performed by apply_backfill."""
+
+    entities_created: int = 0
+    entities_reused: int = 0
+    links_created: int = 0
+    backup_path: Optional[Path] = None
+
+
+# ---------------------------------------------------------------------------
+# Name detection -- intentionally conservative
+# ---------------------------------------------------------------------------
+
+# Two or more capitalised words: a reasonable signal for proper nouns.
+# We won't catch single-word entities like "Acme" here -- that prevents a
+# flood of false positives like "The", "She", "Monday" at sentence starts.
+_PROPER_NOUN_RE = re.compile(r"\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b")
+
+# Things we never want to propose as entity names.
+_STOPWORDS = frozenset(
+    {
+        "Project",  # Without a following noun, this is the keyword itself.
+        "Inc",
+        "LLC",
+        "Corp",
+        "AI",
+        "Ltd",
+        "Co",
+    }
+)
+
+
+def _candidate_names(content: str) -> List[str]:
+    """Extract proper-noun candidate names from memory content.
+
+    Returns a list of unique, order-preserved candidates.
+    """
+    if not content:
+        return []
+
+    seen: Dict[str, None] = {}
+    for match in _PROPER_NOUN_RE.finditer(content):
+        raw = match.group(1).strip()
+        # Reject single-token stopwords we accidentally captured.
+        if raw in _STOPWORDS:
+            continue
+        seen.setdefault(raw, None)
+    return list(seen.keys())
+
+
+# ---------------------------------------------------------------------------
+# Phase 1: plan_backfill (NO writes)
+# ---------------------------------------------------------------------------
+
+
+def plan_backfill(db) -> BackfillPlan:
+    """Scan memories with no entity links and propose new links.
+
+    Args:
+        db: The Database object (sqlite wrapper).
+
+    Returns:
+        A :class:`BackfillPlan`. The caller can inspect ``orphan_count``
+        and ``proposed_entities`` before deciding to ``--apply``.
+
+    This function MUST NOT write to the database. Tests assert this.
+    """
+    plan = BackfillPlan()
+
+    # Find memories that have no entity link at all and have content
+    # that looks like it mentions someone or something.
+    rows = db.execute(
+        """
+        SELECT m.id, m.content
+        FROM memories m
+        LEFT JOIN memory_entities me ON m.id = me.memory_id
+        WHERE me.memory_id IS NULL
+          AND m.invalidated_at IS NULL
+          AND m.content IS NOT NULL
+        """,
+        fetch=True,
+    ) or []
+
+    plan.scanned_memories = len(rows)
+    if not rows:
+        return plan
+
+    # name -> {"inferred_type": str, "memory_ids": [int]}
+    by_name: Dict[str, Dict[str, Any]] = {}
+
+    for row in rows:
+        memory_id = row["id"]
+        content = row["content"]
+        names = _candidate_names(content)
+        if not names:
+            continue
+        plan.orphan_count += 1
+        for name in names:
+            entry = by_name.setdefault(
+                name,
+                {
+                    "name": name,
+                    "inferred_type": infer_entity_type(name, content),
+                    "memory_ids": [],
+                },
+            )
+            entry["memory_ids"].append(memory_id)
+
+    plan.proposed_entities = list(by_name.values())
+    return plan
+
+
+# ---------------------------------------------------------------------------
+# Phase 2: apply_backfill (WRITES, but only after a successful backup)
+# ---------------------------------------------------------------------------
+
+
+def _create_backup(db, backup_path: Path) -> Path:
+    """Write a SQLite-native backup of ``db`` to ``backup_path``.
+
+    Uses :meth:`sqlite3.Connection.backup` for crash-consistent copy.
+    Creates parent directories. Raises on any failure so the caller can
+    abort the apply before touching the main DB.
+    """
+    backup_path = Path(backup_path)
+    backup_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # The Database wrapper exposes a thread-local connection via
+    # ``_get_connection``. We do not capture it as a long-lived
+    # attribute -- always ask the wrapper for the live one.
+    if hasattr(db, "_get_connection"):
+        source_conn = db._get_connection()  # noqa: SLF001
+    elif hasattr(db, "conn"):
+        source_conn = db.conn
+    else:
+        raise RuntimeError(
+            "Cannot create backup: db has no _get_connection or conn attribute"
+        )
+
+    target = sqlite3.connect(str(backup_path))
+    try:
+        source_conn.backup(target)
+    finally:
+        target.close()
+
+    if not backup_path.exists() or backup_path.stat().st_size == 0:
+        raise RuntimeError(f"Backup file at {backup_path} is missing or empty")
+
+    return backup_path
+
+
+def _ensure_entity_for_backfill(
+    db, name: str, entity_type: str
+) -> tuple[int, bool]:
+    """Return (entity_id, created_now).
+
+    Looks up by canonical_name (lowercased). Returns the existing id
+    if found, else inserts a new row. Does not touch embeddings (the
+    main daemon's normal flow will pick those up on next access).
+    """
+    canonical = name.lower().strip()
+    existing = db.get_one(
+        "entities",
+        where="canonical_name = ?",
+        where_params=(canonical,),
+    )
+    if existing:
+        return existing["id"], False
+
+    now = datetime.utcnow().isoformat()
+    new_id = db.insert(
+        "entities",
+        {
+            "name": name,
+            "type": entity_type,
+            "canonical_name": canonical,
+            "importance": 1.0,
+            "created_at": now,
+            "updated_at": now,
+        },
+    )
+    return new_id, True
+
+
+def apply_backfill(db, plan: BackfillPlan, backup_path: Path) -> BackfillResult:
+    """Apply the plan after first taking a SQLite backup.
+
+    Args:
+        db: Database wrapper.
+        plan: A :class:`BackfillPlan` from :func:`plan_backfill`.
+        backup_path: Where to write the SQLite backup. Required.
+
+    Returns:
+        A :class:`BackfillResult` with counts.
+
+    Raises:
+        Anything raised by :func:`_create_backup`. If the backup step
+        fails, NO writes are performed.
+    """
+    backup_path = Path(backup_path)
+
+    # Backup MUST come first. If it fails, abort before any DB write.
+    created_backup = _create_backup(db, backup_path)
+    logger.info("Backfill: backup created at %s", created_backup)
+
+    result = BackfillResult(backup_path=created_backup)
+
+    for proposal in plan.proposed_entities:
+        name = proposal["name"]
+        entity_type = proposal["inferred_type"]
+        memory_ids = proposal["memory_ids"]
+
+        entity_id, created_now = _ensure_entity_for_backfill(db, name, entity_type)
+        if created_now:
+            result.entities_created += 1
+        else:
+            result.entities_reused += 1
+
+        for memory_id in memory_ids:
+            try:
+                db.insert(
+                    "memory_entities",
+                    {
+                        "memory_id": memory_id,
+                        "entity_id": entity_id,
+                        "relationship": "about",
+                    },
+                )
+                result.links_created += 1
+            except Exception as e:
+                # Duplicate link (memory already has it) is harmless.
+                logger.debug(
+                    "Backfill: skipping duplicate link memory=%s entity=%s: %s",
+                    memory_id,
+                    entity_id,
+                    e,
+                )
+
+    logger.info(
+        "Backfill applied: %d entities created, %d reused, %d links",
+        result.entities_created,
+        result.entities_reused,
+        result.links_created,
+    )
+    return result
+
+
+# ---------------------------------------------------------------------------
+# CLI helper: render a plan summary for the dry-run output
+# ---------------------------------------------------------------------------
+
+
+def format_plan_summary(plan: BackfillPlan) -> str:
+    """Human-readable summary of a plan (printed in dry-run mode)."""
+    lines = [
+        "Entity-link backfill plan (dry-run, no writes):",
+        f"  Scanned memories without links: {plan.scanned_memories}",
+        f"  Memories with orphan name references: {plan.orphan_count}",
+        f"  Proposed new/linked entities: {len(plan.proposed_entities)}",
+    ]
+    if plan.proposed_entities:
+        lines.append("")
+        lines.append("  By inferred type:")
+        type_counts: Dict[str, int] = {}
+        for p in plan.proposed_entities:
+            type_counts[p["inferred_type"]] = (
+                type_counts.get(p["inferred_type"], 0) + 1
+            )
+        for t, n in sorted(type_counts.items()):
+            lines.append(f"    {t}: {n}")
+        # Show a small sample so the user can sanity-check.
+        sample = plan.proposed_entities[:10]
+        lines.append("")
+        lines.append("  Sample (first 10):")
+        for p in sample:
+            lines.append(
+                f"    - {p['name']!r} -> {p['inferred_type']} "
+                f"({len(p['memory_ids'])} memory link(s))"
+            )
+    lines.append("")
+    lines.append(
+        "Run with --apply to write changes. A SQLite backup will be created first."
+    )
+    return "\n".join(lines)

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

@@ -0,0 +1,192 @@
+"""Entity resolution helpers.
+
+Centralised home for the entity-type inference heuristic and (eventually)
+shared resolution logic. Pure-function module: no DB access, no I/O.
+
+Proposal #51 (2026-05-13) traced a real bug where memory.remember +
+memory.relate were both classifying organisations like "Markup AI" as
+type="person" because the heuristic in services/remember.py did not
+recognise the "AI" corporate suffix and silently defaulted to person.
+
+The fix lives here so it can be re-used by both call sites
+(remember_fact's about_entities path and relate_entities' auto-create
+path) and tested as a pure function.
+
+No new dependencies: pure Python stdlib, rule-based, no LLM, no spaCy.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Keyword tables -- kept narrow on purpose. Wider sets create false positives
+# more often than they catch new categories. Add reluctantly.
+# ---------------------------------------------------------------------------
+
+# Whole-word corporate signals (matched against lowercased tokens).
+_ORG_WORD_SUFFIXES = frozenset(
+    {
+        "inc",
+        "inc.",
+        "llc",
+        "ltd",
+        "ltd.",
+        "corp",
+        "corp.",
+        "corporation",
+        "co",
+        "co.",
+        "company",
+        "gmbh",
+        "ag",
+        "sa",
+        "plc",
+        "foundation",
+        "university",
+        "institute",
+        "lab",
+        "labs",
+        "associates",
+        "group",
+        "partners",
+        # "AI" as a standalone token has become a near-universal corporate
+        # marker (Anthropic AI, OpenAI, Markup AI, Hugging AI, etc.). Worth
+        # the rare false positive for a person literally named "AI".
+        "ai",
+    }
+)
+
+# Substring corporate signals on the trailing token (for dotted suffixes
+# like Hugging.ai, Acme.io, etc.).
+_ORG_DOMAIN_SUFFIXES = (".ai", ".io", ".com", ".dev", ".so", ".co")
+
+_PROJECT_KEYWORDS = frozenset(
+    {"project", "sprint", "mvp", "initiative", "campaign", "rollout"}
+)
+
+_CONCEPT_KEYWORDS = frozenset(
+    {"methodology", "framework", "theory", "protocol", "strategy", "principle"}
+)
+
+_LOCATION_KEYWORDS = frozenset(
+    {"office", "hq", "headquarters", "campus", "building"}
+)
+
+# Two-or-more capitalised words separated by spaces, no digits or punctuation,
+# e.g. "Matt Blumberg", "Mary Anne Smith". A reliable person signal when
+# no other classification fires.
+_PERSON_NAME_RE = re.compile(r"^[A-Z][a-z]+(?:\s+[A-Z][a-z]+)+$")
+
+
+def infer_entity_type(name: str, content: str = "") -> str:
+    """Infer the canonical entity type from a name and (optional) content.
+
+    Heuristic rules, evaluated in order. The first rule to match wins:
+
+    1. **Location keywords** ("office", "hq", "campus") on any token. Checked
+       first so "Company HQ" is a location, not an organisation.
+    2. **Organisation signals** -- whole-word corporate tokens like ``inc``,
+       ``llc``, ``corp``, ``ai``, ``foundation``, or domain-style suffixes
+       (``.ai``, ``.io``) on the trailing token. Catches "Markup AI",
+       "Hugging.ai", "Acme Inc.".
+    3. **Project keywords** ("project", "sprint", "mvp"). Matches "Project
+       Phoenix" and "Phoenix Project" alike.
+    4. **Concept keywords** ("methodology", "framework", "strategy").
+    5. **Person pattern** -- two-or-more capitalised words ("Matt Blumberg",
+       "Mary Anne Smith") with no other classification signal.
+    6. **Fallback: concept**, never ``person``. Proposal #51 explicitly
+       rejected ``person`` as the default because a single ambiguous token
+       like "Markup" was getting auto-typed as a person whenever it appeared
+       in the entities list.
+
+    Args:
+        name: The entity name (case-insensitive matching applies).
+        content: Optional surrounding memory text. Currently unused by the
+            heuristic but accepted so callers can pass context without
+            changing the signature later (we may grow the rules to peek at
+            the memory body for "company", "the team", etc. cues).
+
+    Returns:
+        One of: ``"organization"``, ``"person"``, ``"project"``,
+        ``"concept"``, ``"location"``.
+    """
+    if not name or not name.strip():
+        return "concept"
+
+    stripped = name.strip()
+    lowered = stripped.lower()
+    tokens = lowered.split()
+
+    # 1. Location keywords first (so "Company HQ" -> location, not org).
+    for tok in tokens:
+        if tok.rstrip(".,") in _LOCATION_KEYWORDS:
+            return "location"
+
+    # 2. Organisation: whole-word suffix on ANY token.
+    for tok in tokens:
+        if tok.rstrip(".,") in _ORG_WORD_SUFFIXES:
+            return "organization"
+        if tok in _ORG_WORD_SUFFIXES:
+            return "organization"
+
+    # 2b. Organisation: domain-style suffix on the trailing token
+    # (Hugging.ai, Acme.io, etc.).
+    if tokens:
+        last = tokens[-1]
+        for suffix in _ORG_DOMAIN_SUFFIXES:
+            if last.endswith(suffix):
+                return "organization"
+
+    # 3. Project keywords.
+    for tok in tokens:
+        if tok.rstrip(".,") in _PROJECT_KEYWORDS:
+            return "project"
+
+    # 4. Concept keywords.
+    for tok in tokens:
+        if tok.rstrip(".,") in _CONCEPT_KEYWORDS:
+            return "concept"
+
+    # 5. Person pattern: two-or-more capitalised words, plain ASCII.
+    if _PERSON_NAME_RE.match(stripped):
+        return "person"
+
+    # 6. Fallback: concept (NEVER person -- see Proposal #51).
+    return "concept"
+
+
+# ---------------------------------------------------------------------------
+# Aliases / shims so older callers in services/remember.py and tests keep
+# working without an import dance. The old private helper
+# remember._infer_entity_type is preserved as a thin wrapper for backward
+# compatibility.
+# ---------------------------------------------------------------------------
+
+
+def legacy_infer_entity_type(name: str) -> str:
+    """Backward-compatible shim for the original heuristic semantics.
+
+    The original ``remember._infer_entity_type`` (added Apr 2026) returned
+    ``"person"`` as the fallback. This shim still returns ``"person"`` for
+    plain single-word inputs like "Kamil" or "Sarah" so the existing
+    test_entity_type_inference.py suite keeps passing, while the new
+    ``infer_entity_type`` is free to default to concept for genuinely
+    ambiguous inputs.
+
+    Used by ``RememberService.remember_entity`` where an explicit empty
+    ``entity_type``  preserves the legacy "single-name = person" rule.
+    """
+    inferred = infer_entity_type(name)
+    if inferred == "concept":
+        # Legacy callers expected a single-token name to be a person.
+        # Preserve that for compatibility with existing test fixtures and
+        # callers that already passed an explicit "" type to mean
+        # "default to person".
+        tokens = (name or "").strip().split()
+        if len(tokens) == 1 and tokens[0] and tokens[0][:1].isupper():
+            return "person"
+        if len(tokens) == 1 and tokens[0]:
+            return "person"
+    return inferred

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

@@ -23,6 +23,7 @@ from ..extraction.entity_extractor import (
     extract_all,
     get_extractor,
 )
+from .entities import infer_entity_type as _smart_infer_entity_type
 from .guards import validate_entity, validate_memory, validate_relationship
 
 logger = logging.getLogger(__name__)
@@ -366,10 +367,14 @@ class RememberService:
             except Exception as e:
                 logger.warning(f"Could not store memory embedding: {e}")
 
-        # Link to entities
+        # Link to entities. Pass the memory content as context so the type
+        # inference heuristic can use it (Proposal #51).
         if about_entities:
+            now_iso = datetime.utcnow().isoformat()
             for entity_name in about_entities:
-                entity_id = self._find_or_create_entity(entity_name)
+                entity_id = self._find_or_create_entity(
+                    entity_name, content_context=content
+                )
                 if entity_id:
                     try:
                         self.db.insert(
@@ -382,6 +387,17 @@ class RememberService:
                         )
                     except Exception:
                         pass  # Duplicate link, ignore
+                    # Touch the entity so attention-tier and recency reflect
+                    # that we just heard about it. Safe on existing rows;
+                    # newly-created rows already have these set.
+                    try:
+                        self.db.execute(
+                            "UPDATE entities SET last_contact_at = ?, "
+                            "updated_at = ? WHERE id = ?",
+                            (now_iso, now_iso, entity_id),
+                        )
+                    except Exception as e:
+                        logger.debug(f"Could not touch entity {entity_id}: {e}")
 
         logger.debug(f"Remembered {memory_type}: {content[:50]}...")
 
@@ -1807,8 +1823,25 @@ class RememberService:
             entity_type=extracted.type,
         )
 
-    def _find_or_create_entity(self, name: str, entity_type: str = "") -> Optional[int]:
-        """Find entity by name or create if not exists"""
+    def _find_or_create_entity(
+        self,
+        name: str,
+        entity_type: str = "",
+        content_context: str = "",
+    ) -> Optional[int]:
+        """Find entity by name or create if not exists.
+
+        When ``entity_type`` is not supplied, the smarter heuristic in
+        ``services/entities.py`` is used so that names like "Markup AI"
+        get typed as ``organization`` instead of the legacy
+        ``person`` fallback. Proposal #51 (2026-05-13).
+
+        Args:
+            name: Entity name (canonical lookup is case-insensitive).
+            entity_type: Optional explicit type. If empty, inferred.
+            content_context: Optional surrounding memory text. Passed to
+                the inference helper for future content-aware rules.
+        """
         canonical = self.extractor.canonical_name(name)
 
         # Try exact match
@@ -1829,13 +1862,19 @@ class RememberService:
         if alias_match:
             return alias_match["entity_id"]
 
+        # Smart inference for the *type* we will use to fuzzy-match and create.
+        # Without this, _fuzzy_find_entity queries with type="" (no matches)
+        # and remember_entity falls back to person.
+        effective_type = entity_type or _smart_infer_entity_type(name, content_context)
+
         # Fuzzy pre-check: find near-matches of the same type
-        fuzzy_match = self._fuzzy_find_entity(canonical, entity_type)
+        fuzzy_match = self._fuzzy_find_entity(canonical, effective_type)
         if fuzzy_match:
             return fuzzy_match
 
-        # Create new
-        return self.remember_entity(name=name, entity_type=entity_type)
+        # Create new with the inferred (or explicit) type. We pass the type
+        # explicitly so remember_entity skips its own (legacy) inference.
+        return self.remember_entity(name=name, entity_type=effective_type)
 
     def _fuzzy_find_entity(self, canonical: str, entity_type: str) -> Optional[int]:
         """Find a near-match entity of the same type using fuzzy string matching.

package/package.json

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

package/template-v2/.claude/manifest.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.57.0",
-  "generated": "2026-05-13T09:56:45.377Z",
+  "version": "1.58.0",
+  "generated": "2026-05-13T11:19:49.402Z",
   "algorithm": "sha256",
   "files": {
-    ".claude/rules/claudia-principles.md": "b1c5e33aeb33857f3485231e5ed34a441c3cc4568b69e3341be770963418a240",
+    ".claude/rules/claudia-principles.md": "939e9720421628e7f2e4c8dfbaa4aeb9c1e18e8c6a5379cd6b772a6835b812e5",
     ".claude/rules/data-freshness.md": "052b3b8f3f489a54fff065b29e0ffc46bfad6da1c3a42386170034f298599233",
     ".claude/rules/memory-availability.md": "48309e2683b267c0a17ebf019fb3ee1116150d811b1d93b4ddb52fed89ae1fe3",
     ".claude/rules/memory-commitment.md": "49eee330b56c6ca0b5f1e01550931c4eef3dcb3249e3d0e2380de3e8dbfe31a8",
@@ -68,6 +68,6 @@
     ".claude/skills/vault-awareness.md": "5a9c3d3f0b907750b9941a51ec9308c2bd465aa9bf3c513124f640696e0a4c2c",
     ".claude/skills/weekly-review/SKILL.md": "fe7df64d3df18a0a47f98f7d4ef83cf98cef78cd9e0170a9316005035a2c6df7",
     ".claude/skills/what-am-i-missing/SKILL.md": "56736397717c4f0a25cab17e7258702e5b04d20b48727c262fdf66e3b2e5899f",
-    "CLAUDE.md": "8cbbebee457366978a9b7b1d8788ac569ab0670874728fd9324fed53df8845c2"
+    "CLAUDE.md": "736c5d95f1477ea6ef1c00d3006eeb4b369eb2bd5f3a926e4d78c42f857fa881"
   }
 }

package/template-v2/.claude/rules/claudia-principles.md

@@ -230,7 +230,7 @@ MEMORY.md persists across sessions automatically. Because of this convenience, i
 | File locations | "Interview files live in workspaces/beemok/interviews/" | Stable reference |
 | Process knowledge | "Interviews follow the capture-interview skill" | Process, not status |
 | Preferences | "User prefers detailed briefs over minimal ones" | Slow-changing |
-| Tool configuration | "Gmail MCP is connected, Otter.ai via Rube" | Infrastructure |
+| Tool configuration | "Gmail MCP is connected, Otter.ai integration enabled" | Infrastructure |
 
 ### What MUST NOT go in MEMORY.md
 

package/template-v2/.mcp.json.example

@@ -37,15 +37,6 @@
         "extended": "Adds Docs, Sheets, Tasks, Chat (83 tools)",
         "complete": "All services including Slides, Forms, Apps Script (111 tools)"
       }
-    },
-    "rube": {
-      "type": "http",
-      "url": "https://mcp.composio.dev",
-      "headers": {
-        "x-composio-api-key": ""
-      },
-      "_description": "Rube by Composio -- 500+ app integrations (HTTP, no stdio conflict)",
-      "_setup": "Connect 500+ apps via Rube: Slack, Notion, Drive, GitHub, Granola, Otter.ai, Jira, Linear, Airtable, HubSpot, Stripe, and more. 1) Sign up free at https://rube.app 2) Connect your apps in Rube's marketplace 3) Copy your API key from the dashboard 4) Paste it in x-composio-api-key above 5) Restart Claude Code. See Rube section in CLAUDE.md for full guide."
     }
   },
 
@@ -53,7 +44,6 @@
     "memory": "Claudia's memory is powered by the claudia-memory daemon (Python MCP server). It provides ~33 tools for semantic search, pattern detection, and relationship tracking. The installer (npx get-claudia) automatically sets up the daemon in a Python venv at ~/.claudia/daemon/venv/ and configures .mcp.json.",
     "google_options": "Two paths for Google integration: (A) gmail + google-calendar (lightweight, focused, fewer tools) or (B) google_workspace via workspace-mcp (all-in-one, more tools). Both can coexist. See Google Integration Setup in CLAUDE.md.",
     "google_workspace": "Google Workspace uses the workspace-mcp server (taylorwilsdon/google_workspace_mcp). One server covers Gmail, Calendar, Drive, Docs, Sheets, Tasks, and more. Tool tiers control context usage.",
-    "rube": "Rube (by Composio) connects 500+ apps through one HTTP MCP connection. Each user creates their own free Rube account at rube.app. See the Rube section in CLAUDE.md for setup and troubleshooting.",
     "security": "Each user authenticates with their own accounts and credentials. OAuth tokens are stored locally on your machine, never shared.",
     "not_included": {
       "filesystem": "Claude Code has native Read/Write/Edit tools",

package/template-v2/CLAUDE.md

@@ -334,85 +334,7 @@ I adapt to whatever tools are available. When you ask me to do something that ne
 
 Both options can coexist in `.mcp.json`. When both are present, I use whichever tools are available. If the MCP tools aren't responding or you see authentication errors, the user needs to set up their Google Cloud credentials. See the **Google Integration Setup** section below.
 
-**Rube (500+ Apps):** Rube (by Composio) is an optional MCP aggregator that connects Claudia to hundreds of apps through a single server. Each user creates their own free Rube account, connects the apps they want via one-click OAuth, and Claudia gets access to all of them through one MCP connection.
-
-If a user asks about connecting apps, integrations, or any of the services listed below, proactively suggest Rube as the easiest path. Walk them through setup step by step.
-
-**What you can connect through Rube:**
-
-| Category | Apps |
-|----------|------|
-| **Communication** | Slack, Discord, Microsoft Teams, Telegram |
-| **Email** | Gmail, Outlook, Yahoo Mail |
-| **Meeting Notes & Transcription** | Granola, Otter.ai, Fireflies.ai |
-| **Project Management** | Jira, Linear, Asana, Trello, Monday.com, ClickUp, Basecamp |
-| **Knowledge & Docs** | Notion, Confluence, Google Docs, Coda |
-| **Cloud Storage** | Google Drive, Dropbox, OneDrive, Box |
-| **Code & Dev** | GitHub, GitLab, Bitbucket |
-| **Databases & Spreadsheets** | Airtable, Google Sheets, Supabase, PostgreSQL |
-| **CRM & Sales** | HubSpot, Salesforce, Pipedrive |
-| **Design** | Figma, Canva |
-| **Social Media** | X/Twitter, LinkedIn, Instagram |
-| **Finance** | Stripe, QuickBooks, Xero |
-| **Calendar** | Google Calendar, Outlook Calendar, Calendly |
-| **And 500+ more** | Browse the full list at [rube.app](https://rube.app) |
-
-**External integrations** (Gmail, Calendar, Google Workspace, Rube, Brave Search) are optional add-ons that extend what I can see and do. I work fully without them. The core value is relationships and context.
-
-### Rube Setup (Guide Users Through This)
-
-**Step 1: Create a Rube account**
-- Go to [rube.app](https://rube.app) and sign up (free tier available)
-- This is the user's own account. They manage billing and app connections directly with Rube.
-
-**Step 2: Connect the apps you want**
-- In the Rube dashboard, browse the marketplace
-- Click any app to connect it (each uses its own OAuth popup, handled by Rube)
-- Start with the apps you use most: Slack, Notion, GitHub, Google Drive, etc.
-- You can add more apps at any time without reconfiguring Claudia
-
-**Step 3: Copy the API key**
-- In the Rube dashboard, find the API key / Bearer token
-- It may be under "Settings", "MCP Settings", or "Install Rube"
-
-**Step 4: Add to Claudia's config**
-- Open `.mcp.json` in the project root
-- Find the `rube` server section
-- Paste the API key into the `COMPOSIO_API_KEY` value:
-  ```json
-  "env": {
-    "COMPOSIO_API_KEY": "paste-key-here"
-  }
-  ```
-- Alternatively, set it as an environment variable: `export COMPOSIO_API_KEY=paste-key-here`
-
-**Step 5: Restart Claude Code**
-- Close and reopen Claude Code for the MCP to connect
-- Once connected, Rube's tools appear automatically
-
-**Using Rube-connected apps:** Once Rube is connected, use the tools naturally. Examples:
-- "Send a Slack message to #general saying the deploy is done"
-- "Create a Notion page with today's meeting notes"
-- "List my open GitHub issues on the claudia repo"
-- "Search my Google Drive for the Q4 report"
-- "Show me my Granola meeting notes from this week"
-- "Add a task to my Jira sprint"
-- "Check my Stripe dashboard for recent payments"
-- "Create an Airtable record in the Contacts table"
-
-The MCP tools from Rube will have names like `SLACK_SEND_MESSAGE`, `NOTION_CREATE_PAGE`, `GITHUB_LIST_ISSUES`, etc. Use them when they match what the user is asking for.
-
-**Troubleshooting Rube:**
-
-| Problem | Solution |
-|---------|----------|
-| Rube MCP not connecting | Check that `COMPOSIO_API_KEY` is set in `.mcp.json` or environment. Restart Claude Code. |
-| Tool not found for an app | The user needs to connect that app in Rube's marketplace first (rube.app dashboard). |
-| Authentication expired | The user should reconnect the specific app in Rube's dashboard (re-authorize OAuth). |
-| Rate limited | Rube has usage limits on the free tier. The user may need to upgrade at rube.app/pricing. |
-| Want to disconnect an app | Go to Rube dashboard and disconnect the app there. No Claudia config changes needed. |
-
-**Rube vs. direct Google MCPs:** Rube works alongside (not instead of) the direct Google MCP servers (gmail, google-calendar, or workspace-mcp). Direct servers give a connection with no intermediary but require Google Cloud setup. Rube gives one setup for everything but routes data through Composio servers. All can coexist. If a user has both direct Google MCPs and Rube's Google apps connected, prefer the direct MCP tools.
+**External integrations** (Gmail, Calendar, Google Workspace, Brave Search) are optional add-ons that extend what I can see and do. I work fully without them. The core value is relationships and context.
 
 ### Google Integration Setup