refactor(scribe): retire calendar/events + person/place/list entities (backend)

Narrow Scribe to a Claude-Code work system-of-record (milestone #194,
decision note #1759). Wholesale removal per rule #22 — backend + schema half.

Calendar/events + CalDAV: delete models/event, services/{events,caldav,
caldav_sync}, routes/events, mcp/tools/events; strip event branches from
backup (bump v3->v4), dashboard (upcoming_events), trash, recent, and the
mcp server read-only allowlist + instructions.

Typed entities (person/place/list): delete mcp/tools/entities; drop the
notes.metadata (entity_meta) column from model/service/routes and the
knowledge browse service. note_type STAYS — it also marks 'process' notes.

Scheduler: event_scheduler -> recurrence_scheduler, keeping only the
recurring-task spawn job (drops event reminders + CalDAV sync).

Schema: migration 0069 drops the events table + notes.metadata column +
orphan caldav settings rows (faithful downgrade recreates them).

KEEP: recurrence.py (task recurrence), notifications task reminders, graph
view, and every work surface. Frontend + plugin/docs true-up follow next.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BPtbSzA4JLMAKgFZ8VTg7Q

src/scribe/mcp/server.py

@@ -45,15 +45,10 @@ What each part is for, and when to reach for it:
   record (note, task, issue) with it via system_ids so research, build-work, and
   fixes for the same area line up, and recurring problem-spots surface. Manage
   with create_system / list_systems / get_system.
-- Typed entities (person/place/list): structured records about people, places,
-  and checklists.
 
 Mechanics:
 - Notes and Tasks share a model; tasks are notes with is_task=True.
 - Use the *_note tools for notes, the *_task tools for tasks. Don't mix them.
-- Typed entities (person, place, list) are notes with a non-default note_type
-  plus type-specific columns; use the dedicated *_person / *_place / *_list
-  tools rather than create_note.
 - Tags are plain strings (no `#` prefix). Empty list clears tags; omit to leave
   unchanged on updates.
 - For optional integer FKs (project_id, milestone_id, parent_id), use 0 to mean
@@ -224,10 +219,9 @@ operator. "Works for one user" is not done.
 # write for read keys (default-deny), so a newly-added tool is locked down
 # until explicitly classified here.
 _READ_ONLY_TOOLS = frozenset({
-    "get_event", "get_note", "get_project", "get_rule", "get_rulebook",
+    "get_note", "get_project", "get_rule", "get_rulebook",
     "get_task", "get_milestone", "get_recent", "enter_project",
-    "list_events", "list_lists", "list_milestones", "list_notes",
-    "list_persons", "list_places", "list_projects", "list_rulebooks",
+    "list_milestones", "list_notes", "list_projects", "list_rulebooks",
     "list_rules", "list_tags", "list_tasks", "list_topics", "list_trash",
     "list_always_on_rules", "search",
     "get_system", "list_systems", "list_system_records",

src/scribe/mcp/tools/__init__.py

@@ -5,7 +5,7 @@ to a FastMCP instance. `register_all(mcp)` is the single entry point called
 from `mcp.server.build_mcp_server`.
 """
 from scribe.mcp.tools import (
-    entities, events, milestones, notes, processes, projects, recent, repos, rulebooks, search, systems, tags, tasks, trash,
+    milestones, notes, processes, projects, recent, repos, rulebooks, search, systems, tags, tasks, trash,
 )
 
 
@@ -17,10 +17,8 @@ def register_all(mcp) -> None:
     projects.register(mcp)
     milestones.register(mcp)
     systems.register(mcp)
-    events.register(mcp)
     tags.register(mcp)
     recent.register(mcp)
-    entities.register(mcp)
     repos.register(mcp)
     processes.register(mcp)
     rulebooks.register(mcp)

src/scribe/mcp/tools/entities.py

@@ -1,245 +0,0 @@
-"""Typed-entity MCP tools: person, place, list.
-
-These are notes with a non-'note' note_type and type-specific JSON metadata
-stored in the entity_meta column. Three tools per type — list, create, update.
-For get and delete, use get_note / delete_note (typed entities
-share the Note model).
-
-The wrappers translate typed-field kwargs into the entity_meta dict shape that
-KnowledgeView.vue and services/knowledge.py expect.
-
-Lists: a list entity stores its items in entity_meta["list_items"] as a list
-of {text, checked} dicts. The create/update tools take a simpler `items` list
-of plain strings for ergonomics; checked-state is reset to False on each call.
-"""
-from __future__ import annotations
-
-from scribe.mcp._context import current_user_id
-from scribe.services import knowledge as knowledge_svc
-from scribe.services import notes as notes_svc
-
-
-async def _list_by_type(note_type: str, q: str, tag: str, limit: int) -> dict:
-    """Common list query for a typed entity."""
-    uid = current_user_id()
-    items, total = await knowledge_svc.query_knowledge(
-        user_id=uid,
-        note_type=note_type,
-        tags=[tag] if tag else [],
-        sort="modified",
-        q=q or None,
-        limit=max(1, min(limit, 100)),
-        offset=0,
-    )
-    # Map "items" key to a type-specific key for caller clarity.
-    plural = {"person": "persons", "place": "places", "list": "lists"}[note_type]
-    return {plural: items, "total": total}
-
-
-async def _create_entity(note_type: str, name: str, entity_meta: dict,
-                         tags: list[str] | None = None) -> dict:
-    """Create a typed note with the given metadata."""
-    uid = current_user_id()
-    note = await notes_svc.create_note(
-        uid,
-        title=name,
-        note_type=note_type,
-        entity_meta=entity_meta or None,
-        tags=tags,
-    )
-    return note.to_dict()
-
-
-async def _update_entity(entity_id: int, note_type: str, name: str,
-                         meta_updates: dict) -> dict:
-    """Merge updates into entity_meta and (optionally) update the title."""
-    uid = current_user_id()
-    note = await notes_svc.get_note(uid, entity_id)
-    if note is None or note.note_type != note_type:
-        raise ValueError(f"{note_type} {entity_id} not found")
-    new_meta = dict(note.entity_meta or {})
-    new_meta.update(meta_updates)
-    fields: dict = {"entity_meta": new_meta}
-    if name:
-        fields["title"] = name
-    updated = await notes_svc.update_note(uid, entity_id, **fields)
-    return updated.to_dict()
-
-
-# ─── Person ──────────────────────────────────────────────────────────────────
-
-_PERSON_FIELDS = ("relationship", "email", "phone", "birthday",
-                  "organization", "address")
-
-
-async def list_persons(q: str = "", tag: str = "", limit: int = 25) -> dict:
-    """List people in the user's knowledge base.
-
-    Args:
-        q: Free-text search across name + body (optional).
-        tag: Filter to a single tag (optional).
-        limit: Max results (1-100).
-    """
-    return await _list_by_type("person", q, tag, limit)
-
-
-async def create_person(
-    name: str,
-    relationship: str = "",
-    email: str = "",
-    phone: str = "",
-    birthday: str = "",
-    organization: str = "",
-    address: str = "",
-    tags: list[str] | None = None,
-) -> dict:
-    """Create a person in the user's knowledge base.
-
-    Args:
-        name: Person's name (required).
-        relationship: How the user knows them (e.g. "colleague", "friend").
-        email / phone / birthday (YYYY-MM-DD) / organization / address: optional.
-        tags: Plain-string tags, no # prefix.
-    """
-    meta = {f: v for f, v in (
-        ("relationship", relationship), ("email", email), ("phone", phone),
-        ("birthday", birthday), ("organization", organization),
-        ("address", address),
-    ) if v}
-    return await _create_entity("person", name, meta, tags)
-
-
-async def update_person(
-    person_id: int,
-    name: str = "",
-    relationship: str = "",
-    email: str = "",
-    phone: str = "",
-    birthday: str = "",
-    organization: str = "",
-    address: str = "",
-) -> dict:
-    """Update a person. Only explicitly provided fields are changed.
-
-    To clear a field, pass an explicit space character (this preserves the
-    fable-mcp empty-string-means-omit convention).
-    """
-    meta_updates = {f: v for f, v in (
-        ("relationship", relationship), ("email", email), ("phone", phone),
-        ("birthday", birthday), ("organization", organization),
-        ("address", address),
-    ) if v}
-    return await _update_entity(person_id, "person", name, meta_updates)
-
-
-# ─── Place ───────────────────────────────────────────────────────────────────
-
-
-async def list_places(q: str = "", tag: str = "", limit: int = 25) -> dict:
-    """List places (cafes, offices, addresses) in the user's knowledge base."""
-    return await _list_by_type("place", q, tag, limit)
-
-
-async def create_place(
-    name: str,
-    address: str = "",
-    phone: str = "",
-    hours: str = "",
-    website: str = "",
-    category: str = "",
-    tags: list[str] | None = None,
-) -> dict:
-    """Create a place in the user's knowledge base.
-
-    Args:
-        name: Place name (required).
-        address / phone / hours / website / category: optional.
-        tags: Plain-string tags, no # prefix.
-    """
-    meta = {f: v for f, v in (
-        ("address", address), ("phone", phone), ("hours", hours),
-        ("website", website), ("category", category),
-    ) if v}
-    return await _create_entity("place", name, meta, tags)
-
-
-async def update_place(
-    place_id: int,
-    name: str = "",
-    address: str = "",
-    phone: str = "",
-    hours: str = "",
-    website: str = "",
-    category: str = "",
-) -> dict:
-    """Update a place. Only explicitly provided fields are changed."""
-    meta_updates = {f: v for f, v in (
-        ("address", address), ("phone", phone), ("hours", hours),
-        ("website", website), ("category", category),
-    ) if v}
-    return await _update_entity(place_id, "place", name, meta_updates)
-
-
-# ─── List ────────────────────────────────────────────────────────────────────
-
-
-async def list_lists(q: str = "", tag: str = "", limit: int = 25) -> dict:
-    """List checklists in the user's knowledge base."""
-    return await _list_by_type("list", q, tag, limit)
-
-
-async def create_list(
-    name: str,
-    category: str = "",
-    items: list[str] | None = None,
-    tags: list[str] | None = None,
-) -> dict:
-    """Create a checklist (a list-type entity).
-
-    Args:
-        name: List name (required).
-        category: Optional category label (e.g. "shopping", "packing").
-        items: Initial item texts. All items start unchecked.
-        tags: Plain-string tags, no # prefix.
-    """
-    meta: dict = {}
-    if category:
-        meta["category"] = category
-    if items:
-        meta["list_items"] = [{"text": t, "checked": False} for t in items]
-    return await _create_entity("list", name, meta, tags)
-
-
-async def update_list(
-    list_id: int,
-    name: str = "",
-    category: str = "",
-    items: list[str] | None = None,
-) -> dict:
-    """Update a checklist.
-
-    Args:
-        list_id: ID of the list to update.
-        name: New title (optional).
-        category: New category (optional).
-        items: REPLACES the entire item set with these texts (all reset to
-            unchecked). Omit (None) to leave items unchanged. Pass an empty
-            list to clear all items.
-    """
-    meta_updates: dict = {}
-    if category:
-        meta_updates["category"] = category
-    if items is not None:
-        meta_updates["list_items"] = [
-            {"text": t, "checked": False} for t in items
-        ]
-    return await _update_entity(list_id, "list", name, meta_updates)
-
-
-def register(mcp) -> None:
-    for fn in (
-        list_persons, create_person, update_person,
-        list_places, create_place, update_place,
-        list_lists, create_list, update_list,
-    ):
-        mcp.tool(name=fn.__name__)(fn)

src/scribe/mcp/tools/events.py

@@ -1,171 +0,0 @@
-"""Calendar event MCP tools — new in Phase 3.
-
-Events were previously only an internal-LLM tool; the MCP surface didn't have
-them. Wraps services/events.py.
-
-Date/time inputs are split: start_date (YYYY-MM-DD) + start_time (HH:MM) get
-combined into a naive datetime; the service layer interprets it in the user's
-local timezone. duration_minutes=0 ⇒ point event (NULL duration). The
-LLM-era expected_weekday verification check is intentionally not replicated —
-Claude doesn't need it.
-
-For update, sentinels:
-  - title="" / location="" / description="" → leave unchanged
-  - start_date="" / start_time="" → leave unchanged (both must be provided to
-    move the event)
-  - duration_minutes=-1 → leave unchanged; 0 means "set to point event"
-"""
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-
-from scribe.mcp._context import current_user_id
-from scribe.services import events as events_svc
-from scribe.services import trash as trash_svc
-
-
-def _combine(start_date: str, start_time: str) -> datetime:
-    """Combine YYYY-MM-DD + HH:MM into a naive datetime.
-
-    The events service interprets naive datetimes for create/update against
-    the user's configured timezone, so we don't attach tzinfo here.
-    """
-    t = start_time or "00:00"
-    return datetime.fromisoformat(f"{start_date}T{t}:00")
-
-
-def _day_range_utc(date_from: str, date_to: str) -> tuple[datetime, datetime]:
-    """Return a UTC datetime range [start_of_date_from, end_of_date_to).
-
-    Event.start_dt is stored timezone-aware in the DB; comparing it against a
-    naive datetime raises TypeError. We anchor the range in UTC, which is a
-    reasonable default — refining to the user's local timezone for the
-    range boundaries is a separate improvement.
-    """
-    start = datetime.fromisoformat(date_from).replace(tzinfo=timezone.utc)
-    # `date_to` is inclusive at the day level — bump by 24h so events later
-    # on date_to are included.
-    end = (
-        datetime.fromisoformat(date_to).replace(tzinfo=timezone.utc)
-        + timedelta(days=1)
-    )
-    return start, end
-
-
-def _event_dict(event) -> dict:
-    """Render an Event model to a dict, handling list_events (already dicts)."""
-    return event if isinstance(event, dict) else event.to_dict()
-
-
-async def list_events(date_from: str, date_to: str) -> dict:
-    """List events between date_from and date_to (YYYY-MM-DD, both inclusive at
-    the day level — `date_to` is interpreted as end-of-that-day).
-
-    Recurring events are expanded into individual occurrences within the range.
-    """
-    uid = current_user_id()
-    start, end = _day_range_utc(date_from, date_to)
-    rows = await events_svc.list_events(uid, start, end)
-    return {"events": [_event_dict(e) for e in rows], "total": len(rows)}
-
-
-async def create_event(
-    title: str,
-    start_date: str,
-    start_time: str = "00:00",
-    duration_minutes: int = 0,
-    all_day: bool = False,
-    location: str = "",
-    description: str = "",
-) -> dict:
-    """Create a calendar event.
-
-    Args:
-        title: Event title (required).
-        start_date: YYYY-MM-DD.
-        start_time: HH:MM (24-hour). Ignored when all_day=True.
-        duration_minutes: 0 for a point event (no duration); otherwise minutes.
-        all_day: True to make this an all-day event.
-        location: Optional location string.
-        description: Optional longer description.
-    """
-    uid = current_user_id()
-    event = await events_svc.create_event(
-        uid,
-        title=title,
-        start_dt=_combine(start_date, start_time),
-        duration_minutes=duration_minutes or None,
-        all_day=all_day,
-        location=location,
-        description=description,
-    )
-    return event.to_dict()
-
-
-async def get_event(event_id: int) -> dict:
-    """Fetch a single event by ID."""
-    uid = current_user_id()
-    event = await events_svc.get_event(uid, event_id)
-    if event is None:
-        raise ValueError(f"event {event_id} not found")
-    return event.to_dict()
-
-
-async def update_event(
-    event_id: int,
-    title: str = "",
-    start_date: str = "",
-    start_time: str = "",
-    duration_minutes: int = -1,
-    location: str = "",
-    description: str = "",
-) -> dict:
-    """Update an event. Only explicitly provided fields are changed.
-
-    Args:
-        event_id: ID of the event to update.
-        title: New title; omit to leave unchanged.
-        start_date / start_time: BOTH must be set to move the event. Omit either
-            to leave the start_dt unchanged.
-        duration_minutes: -1 leaves unchanged; 0 sets to point event; any
-            positive value sets the duration.
-        location / description: omit to leave unchanged.
-    """
-    uid = current_user_id()
-    fields: dict = {}
-    if title:
-        fields["title"] = title
-    if location:
-        fields["location"] = location
-    if description:
-        fields["description"] = description
-    if start_date and start_time:
-        fields["start_dt"] = _combine(start_date, start_time)
-    if duration_minutes >= 0:
-        # 0 means point event (NULL); positive sets a real duration.
-        fields["duration_minutes"] = duration_minutes or None
-    event = await events_svc.update_event(uid, event_id, **fields)
-    if event is None:
-        raise ValueError(f"event {event_id} not found")
-    return event.to_dict()
-
-
-async def delete_event(event_id: int) -> dict:
-    """Move a calendar event to the trash (recoverable). Restore via restore(batch_id)."""
-    uid = current_user_id()
-    batch = await trash_svc.delete(uid, "event", event_id)
-    if batch is None:
-        raise ValueError(f"event {event_id} not found")
-    return {"deleted_batch_id": batch,
-            "message": f"Event {event_id} moved to trash. Restore with restore('{batch}')."}
-
-
-def register(mcp) -> None:
-    for fn in (
-        list_events,
-        create_event,
-        get_event,
-        update_event,
-        delete_event,
-    ):
-        mcp.tool(name=fn.__name__)(fn)

src/scribe/mcp/tools/recent.py

@@ -1,10 +1,10 @@
 """get_recent — cross-type recent-activity tool.
 
-Returns the most-recently-touched notes, tasks, projects, and events for the
-user, ordered by updated_at descending. Useful for Claude to bootstrap context
-at the start of a conversation ("what was I working on?").
+Returns the most-recently-touched notes, tasks, and projects for the user,
+ordered by updated_at descending. Useful for Claude to bootstrap context at
+the start of a conversation ("what was I working on?").
 
-Aggregation is Python-side after three small per-table queries — simpler than
+Aggregation is Python-side after two small per-table queries — simpler than
 a UNION ALL with type-discriminating columns, and fine for personal-scale data.
 """
 from __future__ import annotations
@@ -15,13 +15,12 @@ from sqlalchemy import select
 
 from scribe.mcp._context import current_user_id
 from scribe.models import async_session
-from scribe.models.event import Event
 from scribe.models.note import Note
 from scribe.models.project import Project
 
 
 async def get_recent(days: int = 7, limit: int = 25) -> dict:
-    """Return recently-touched items across notes, tasks, projects, events.
+    """Return recently-touched items across notes, tasks, and projects.
 
     Args:
         days: Look-back window in days (1-90).
@@ -66,19 +65,6 @@ async def get_recent(days: int = 7, limit: int = 25) -> dict:
                 "title": p.title,
                 "updated_at": p.updated_at.isoformat(),
             })
-        events = (await session.execute(
-            select(Event).where(Event.user_id == uid,
-                                Event.updated_at >= since,
-                                Event.deleted_at.is_(None))
-            .order_by(Event.updated_at.desc()).limit(limit)
-        )).scalars().all()
-        for e in events:
-            items.append({
-                "id": e.id,
-                "type": "event",
-                "title": e.title,
-                "updated_at": e.updated_at.isoformat(),
-            })
     items.sort(key=lambda r: r["updated_at"], reverse=True)
     items = items[:limit]
     return {"items": items, "total": len(items)}