feat(calendar): U1 backend data model, storage & RRULE expansion

Add calendar subsystem foundation mirroring documents/ pattern:
- models.py: 8 dataclasses (CalendarEvent with is_invited, EventType,
  Tag, EventTag, ReminderRule, ReminderDelivery, ExternalCalendarConfig,
  Invitation)
- db.py: aiosqlite bare-connection CRUD for all 8 tables with WAL mode
- recurrence.py: RRULE expansion via dateutil.rrule (RFC 5545)
- 16 unit tests covering DB CRUD and RRULE edge cases (DST, UNTIL, range)
- Add python-dateutil>=2.9 to pyproject.toml

pyproject.toml

@@ -24,6 +24,8 @@ dependencies = [
     "pyjwt>=2.8",
     "bcrypt>=4.0",
     "aiosqlite>=0.20",
+    # Calendar & schedule (RRULE expansion)
+    "python-dateutil>=2.9",
     # Document processing (U1-U9)
     "python-docx>=1.1",
     "openpyxl>=3.1",

src/agentkit/calendar/__init__.py

@@ -0,0 +1,7 @@
+"""Calendar & schedule subsystem.
+
+Mirrors the ``documents/`` structure: ``models.py`` (dataclass DTOs),
+``db.py`` (aiosqlite persistence), ``service.py`` (business logic),
+``recurrence.py`` (RRULE expansion), ``scheduler.py`` (reminder loop),
+``extraction.py`` (post-processing), and ``sync/`` (external calendars).
+"""

src/agentkit/calendar/db.py

@@ -0,0 +1,798 @@
+"""SQLite persistence for calendar data.
+
+Follows the aiosqlite bare-connection pattern from ``documents/db.py``:
+no SQLAlchemy session injection, just ``async with aiosqlite.connect(...)``.
+All timestamps are ISO 8601 UTC (see KTD-11).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from collections.abc import Mapping
+from pathlib import Path
+
+import aiosqlite
+
+from agentkit.calendar.models import (
+    CalendarEvent,
+    EventType,
+    ExternalCalendarConfig,
+    Invitation,
+    ReminderDelivery,
+    ReminderRule,
+    Tag,
+)
+
+logger = logging.getLogger(__name__)
+
+_PROJECT_ROOT = Path(__file__).parents[3]
+DEFAULT_CALENDAR_DB_PATH = Path(
+    os.environ.get("AGENTKIT_CALENDAR_DB", _PROJECT_ROOT / "data" / "calendar.db")
+)
+
+_SCHEMA_SQL = """
+CREATE TABLE IF NOT EXISTS calendar_event_types (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    color TEXT NOT NULL DEFAULT '#4A90D9',
+    is_default INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_event_types_user
+    ON calendar_event_types(user_id);
+
+CREATE TABLE IF NOT EXISTS calendar_tags (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    name TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_tags_user
+    ON calendar_tags(user_id);
+
+CREATE TABLE IF NOT EXISTS calendar_events (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT NOT NULL DEFAULT '',
+    start_time TEXT NOT NULL,
+    end_time TEXT NOT NULL,
+    is_all_day INTEGER NOT NULL DEFAULT 0,
+    location TEXT NOT NULL DEFAULT '',
+    event_type_id TEXT,
+    rrule TEXT,
+    source TEXT NOT NULL DEFAULT 'manual',
+    is_invited INTEGER NOT NULL DEFAULT 0,
+    conversation_id TEXT,
+    external_id TEXT,
+    external_provider TEXT,
+    last_modified TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    FOREIGN KEY (event_type_id) REFERENCES calendar_event_types(id)
+);
+CREATE INDEX IF NOT EXISTS idx_events_user
+    ON calendar_events(user_id);
+CREATE INDEX IF NOT EXISTS idx_events_start_time
+    ON calendar_events(start_time);
+CREATE INDEX IF NOT EXISTS idx_events_external
+    ON calendar_events(external_id, external_provider);
+
+CREATE TABLE IF NOT EXISTS calendar_event_tags (
+    event_id TEXT NOT NULL,
+    tag_id TEXT NOT NULL,
+    PRIMARY KEY (event_id, tag_id),
+    FOREIGN KEY (event_id) REFERENCES calendar_events(id) ON DELETE CASCADE,
+    FOREIGN KEY (tag_id) REFERENCES calendar_tags(id)
+);
+
+CREATE TABLE IF NOT EXISTS calendar_reminder_rules (
+    id TEXT PRIMARY KEY,
+    event_id TEXT,
+    event_type_id TEXT,
+    offset_minutes INTEGER NOT NULL DEFAULT -15,
+    channels TEXT NOT NULL DEFAULT '["client"]',
+    FOREIGN KEY (event_id) REFERENCES calendar_events(id) ON DELETE CASCADE,
+    FOREIGN KEY (event_type_id) REFERENCES calendar_event_types(id)
+);
+
+CREATE TABLE IF NOT EXISTS calendar_reminder_deliveries (
+    id TEXT PRIMARY KEY,
+    reminder_rule_id TEXT NOT NULL,
+    event_id TEXT NOT NULL,
+    scheduled_time TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending',
+    channel TEXT NOT NULL DEFAULT 'client',
+    attempts INTEGER NOT NULL DEFAULT 0,
+    last_error TEXT,
+    FOREIGN KEY (reminder_rule_id) REFERENCES calendar_reminder_rules(id),
+    FOREIGN KEY (event_id) REFERENCES calendar_events(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_deliveries_status
+    ON calendar_reminder_deliveries(status, scheduled_time);
+
+CREATE TABLE IF NOT EXISTS calendar_external_configs (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    provider TEXT NOT NULL,
+    credentials TEXT NOT NULL DEFAULT '',
+    sync_frequency INTEGER NOT NULL DEFAULT 30,
+    sync_scope TEXT NOT NULL DEFAULT '[]',
+    last_sync TEXT,
+    sync_token TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_external_configs_user
+    ON calendar_external_configs(user_id);
+
+CREATE TABLE IF NOT EXISTS calendar_invitations (
+    id TEXT PRIMARY KEY,
+    event_id TEXT NOT NULL,
+    inviter_user_id TEXT NOT NULL,
+    invitee_email TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending',
+    responded_at TEXT,
+    FOREIGN KEY (event_id) REFERENCES calendar_events(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_invitations_email
+    ON calendar_invitations(invitee_email, status);
+"""
+
+
+async def init_calendar_db(db_path: str | Path | None = None) -> Path:
+    """Create all calendar tables if they do not exist. Idempotent."""
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        await db.execute("PRAGMA journal_mode=WAL")
+        await db.execute("PRAGMA busy_timeout = 5000")
+        await db.execute("PRAGMA foreign_keys = ON")
+        await db.executescript(_SCHEMA_SQL)
+        await db.commit()
+
+    logger.info(f"Calendar DB initialized at {path}")
+    return path
+
+
+# ---------------------------------------------------------------------------
+# Row → dataclass converters
+# ---------------------------------------------------------------------------
+
+
+def _row_to_event_type(row: aiosqlite.Row | Mapping[str, object]) -> EventType:
+    return EventType(
+        id=row["id"],
+        user_id=row["user_id"],
+        name=row["name"],
+        color=row["color"],
+        is_default=bool(row["is_default"]),
+    )
+
+
+def _row_to_tag(row: aiosqlite.Row | Mapping[str, object]) -> Tag:
+    return Tag(id=row["id"], user_id=row["user_id"], name=row["name"])
+
+
+def _row_to_event(row: aiosqlite.Row | Mapping[str, object]) -> CalendarEvent:
+    return CalendarEvent(
+        id=row["id"],
+        user_id=row["user_id"],
+        title=row["title"],
+        description=row["description"],
+        start_time=row["start_time"],
+        end_time=row["end_time"],
+        is_all_day=bool(row["is_all_day"]),
+        location=row["location"],
+        event_type_id=row["event_type_id"],
+        rrule=row["rrule"],
+        source=row["source"],
+        is_invited=bool(row["is_invited"]),
+        conversation_id=row["conversation_id"],
+        external_id=row["external_id"],
+        external_provider=row["external_provider"],
+        last_modified=row["last_modified"],
+        created_at=row["created_at"],
+    )
+
+
+def _row_to_reminder_rule(row: aiosqlite.Row | Mapping[str, object]) -> ReminderRule:
+    return ReminderRule(
+        id=row["id"],
+        event_id=row["event_id"],
+        event_type_id=row["event_type_id"],
+        offset_minutes=row["offset_minutes"],
+        channels=json.loads(row["channels"]),
+    )
+
+
+def _row_to_reminder_delivery(row: aiosqlite.Row | Mapping[str, object]) -> ReminderDelivery:
+    return ReminderDelivery(
+        id=row["id"],
+        reminder_rule_id=row["reminder_rule_id"],
+        event_id=row["event_id"],
+        scheduled_time=row["scheduled_time"],
+        status=row["status"],
+        channel=row["channel"],
+        attempts=row["attempts"],
+        last_error=row["last_error"],
+    )
+
+
+def _row_to_external_config(row: aiosqlite.Row | Mapping[str, object]) -> ExternalCalendarConfig:
+    return ExternalCalendarConfig(
+        id=row["id"],
+        user_id=row["user_id"],
+        provider=row["provider"],
+        credentials=row["credentials"],
+        sync_frequency=row["sync_frequency"],
+        sync_scope=json.loads(row["sync_scope"]),
+        last_sync=row["last_sync"],
+        sync_token=row["sync_token"],
+    )
+
+
+def _row_to_invitation(row: aiosqlite.Row | Mapping[str, object]) -> Invitation:
+    return Invitation(
+        id=row["id"],
+        event_id=row["event_id"],
+        inviter_user_id=row["inviter_user_id"],
+        invitee_email=row["invitee_email"],
+        status=row["status"],
+        responded_at=row["responded_at"],
+    )
+
+
+# ---------------------------------------------------------------------------
+# Event CRUD
+# ---------------------------------------------------------------------------
+
+
+async def insert_event(event: CalendarEvent, db_path: str | Path | None = None) -> None:
+    """Insert a calendar event."""
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute("PRAGMA foreign_keys = ON")
+        await db.execute(
+            "INSERT INTO calendar_events (id, user_id, title, description, "
+            "start_time, end_time, is_all_day, location, event_type_id, rrule, "
+            "source, is_invited, conversation_id, external_id, external_provider, "
+            "last_modified, created_at) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                event.id,
+                event.user_id,
+                event.title,
+                event.description,
+                event.start_time,
+                event.end_time,
+                int(event.is_all_day),
+                event.location,
+                event.event_type_id,
+                event.rrule,
+                event.source,
+                int(event.is_invited),
+                event.conversation_id,
+                event.external_id,
+                event.external_provider,
+                event.last_modified,
+                event.created_at,
+            ),
+        )
+        await db.commit()
+
+
+async def get_event(event_id: str, db_path: str | Path | None = None) -> CalendarEvent | None:
+    """Return a single event by id, or None."""
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute("SELECT * FROM calendar_events WHERE id = ?", (event_id,))
+        row = await cursor.fetchone()
+        return _row_to_event(row) if row else None
+
+
+async def list_events(
+    user_id: str,
+    start: str | None = None,
+    end: str | None = None,
+    event_type_id: str | None = None,
+    tag_id: str | None = None,
+    db_path: str | Path | None = None,
+) -> list[CalendarEvent]:
+    """List events for a user with optional filters."""
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    query = "SELECT DISTINCT e.* FROM calendar_events e"
+    params: list[str] = []
+    conditions: list[str] = ["e.user_id = ?"]
+    params.append(user_id)
+
+    if start is not None:
+        conditions.append("e.start_time >= ?")
+        params.append(start)
+    if end is not None:
+        conditions.append("e.start_time < ?")
+        params.append(end)
+    if event_type_id is not None:
+        conditions.append("e.event_type_id = ?")
+        params.append(event_type_id)
+    if tag_id is not None:
+        query += " JOIN calendar_event_tags et ON et.event_id = e.id"
+        conditions.append("et.tag_id = ?")
+        params.append(tag_id)
+
+    query += " WHERE " + " AND ".join(conditions) + " ORDER BY e.start_time"
+
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(query, tuple(params))
+        rows = await cursor.fetchall()
+        return [_row_to_event(row) for row in rows]
+
+
+async def update_event(
+    event_id: str, fields: dict[str, object], db_path: str | Path | None = None
+) -> bool:
+    """Update specific fields of an event. Returns True if a row was updated."""
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    # Map dataclass field names to column names, handle bool → int
+    column_map = {
+        "title": "title",
+        "description": "description",
+        "start_time": "start_time",
+        "end_time": "end_time",
+        "is_all_day": "is_all_day",
+        "location": "location",
+        "event_type_id": "event_type_id",
+        "rrule": "rrule",
+        "source": "source",
+        "is_invited": "is_invited",
+        "conversation_id": "conversation_id",
+        "external_id": "external_id",
+        "external_provider": "external_provider",
+        "last_modified": "last_modified",
+    }
+    set_clauses: list[str] = []
+    params: list[object] = []
+    for field_name, value in fields.items():
+        col = column_map.get(field_name)
+        if col is None:
+            continue
+        if field_name in ("is_all_day", "is_invited"):
+            value = int(bool(value))
+        set_clauses.append(f"{col} = ?")
+        params.append(value)
+
+    if not set_clauses:
+        return False
+
+    params.append(event_id)
+    sql = f"UPDATE calendar_events SET {', '.join(set_clauses)} WHERE id = ?"
+
+    async with aiosqlite.connect(str(path)) as db:
+        cursor = await db.execute(sql, tuple(params))
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+async def delete_event(event_id: str, db_path: str | Path | None = None) -> bool:
+    """Delete an event and its dependent rows. Returns True if deleted."""
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute("PRAGMA foreign_keys = ON")
+        # Manual cascade for event_tags (no ON DELETE on junction FK in some SQLite versions)
+        await db.execute("DELETE FROM calendar_event_tags WHERE event_id = ?", (event_id,))
+        cursor = await db.execute("DELETE FROM calendar_events WHERE id = ?", (event_id,))
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+# ---------------------------------------------------------------------------
+# Event Type CRUD
+# ---------------------------------------------------------------------------
+
+
+async def insert_event_type(et: EventType, db_path: str | Path | None = None) -> None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute(
+            "INSERT INTO calendar_event_types (id, user_id, name, color, is_default) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (et.id, et.user_id, et.name, et.color, int(et.is_default)),
+        )
+        await db.commit()
+
+
+async def list_event_types(user_id: str, db_path: str | Path | None = None) -> list[EventType]:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT * FROM calendar_event_types WHERE user_id = ? ORDER BY name",
+            (user_id,),
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_event_type(row) for row in rows]
+
+
+async def update_event_type(
+    type_id: str, fields: dict[str, object], db_path: str | Path | None = None
+) -> bool:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    set_clauses: list[str] = []
+    params: list[object] = []
+    for field_name, value in fields.items():
+        if field_name == "name":
+            set_clauses.append("name = ?")
+            params.append(value)
+        elif field_name == "color":
+            set_clauses.append("color = ?")
+            params.append(value)
+        elif field_name == "is_default":
+            set_clauses.append("is_default = ?")
+            params.append(int(bool(value)))
+    if not set_clauses:
+        return False
+    params.append(type_id)
+    sql = f"UPDATE calendar_event_types SET {', '.join(set_clauses)} WHERE id = ?"
+    async with aiosqlite.connect(str(path)) as db:
+        cursor = await db.execute(sql, tuple(params))
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+async def delete_event_type(type_id: str, db_path: str | Path | None = None) -> bool:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        cursor = await db.execute("DELETE FROM calendar_event_types WHERE id = ?", (type_id,))
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+# ---------------------------------------------------------------------------
+# Tag CRUD
+# ---------------------------------------------------------------------------
+
+
+async def insert_tag(tag: Tag, db_path: str | Path | None = None) -> None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute(
+            "INSERT INTO calendar_tags (id, user_id, name) VALUES (?, ?, ?)",
+            (tag.id, tag.user_id, tag.name),
+        )
+        await db.commit()
+
+
+async def list_tags(user_id: str, db_path: str | Path | None = None) -> list[Tag]:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT * FROM calendar_tags WHERE user_id = ? ORDER BY name",
+            (user_id,),
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_tag(row) for row in rows]
+
+
+async def delete_tag(tag_id: str, db_path: str | Path | None = None) -> bool:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute("DELETE FROM calendar_event_tags WHERE tag_id = ?", (tag_id,))
+        cursor = await db.execute("DELETE FROM calendar_tags WHERE id = ?", (tag_id,))
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+# ---------------------------------------------------------------------------
+# Event-Tag junction
+# ---------------------------------------------------------------------------
+
+
+async def add_tag_to_event(event_id: str, tag_id: str, db_path: str | Path | None = None) -> None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute(
+            "INSERT OR IGNORE INTO calendar_event_tags (event_id, tag_id) VALUES (?, ?)",
+            (event_id, tag_id),
+        )
+        await db.commit()
+
+
+async def remove_tag_from_event(
+    event_id: str, tag_id: str, db_path: str | Path | None = None
+) -> None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute(
+            "DELETE FROM calendar_event_tags WHERE event_id = ? AND tag_id = ?",
+            (event_id, tag_id),
+        )
+        await db.commit()
+
+
+async def get_event_tags(event_id: str, db_path: str | Path | None = None) -> list[Tag]:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT t.* FROM calendar_tags t "
+            "JOIN calendar_event_tags et ON et.tag_id = t.id "
+            "WHERE et.event_id = ?",
+            (event_id,),
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_tag(row) for row in rows]
+
+
+# ---------------------------------------------------------------------------
+# Reminder Rule CRUD
+# ---------------------------------------------------------------------------
+
+
+async def insert_reminder_rule(rule: ReminderRule, db_path: str | Path | None = None) -> None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute(
+            "INSERT INTO calendar_reminder_rules "
+            "(id, event_id, event_type_id, offset_minutes, channels) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (
+                rule.id,
+                rule.event_id,
+                rule.event_type_id,
+                rule.offset_minutes,
+                json.dumps(rule.channels),
+            ),
+        )
+        await db.commit()
+
+
+async def list_reminder_rules_for_event(
+    event_id: str, db_path: str | Path | None = None
+) -> list[ReminderRule]:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT * FROM calendar_reminder_rules WHERE event_id = ?",
+            (event_id,),
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_reminder_rule(row) for row in rows]
+
+
+async def list_reminder_rules_for_type(
+    event_type_id: str, db_path: str | Path | None = None
+) -> list[ReminderRule]:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT * FROM calendar_reminder_rules WHERE event_type_id = ?",
+            (event_type_id,),
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_reminder_rule(row) for row in rows]
+
+
+async def delete_reminder_rule(rule_id: str, db_path: str | Path | None = None) -> bool:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        cursor = await db.execute("DELETE FROM calendar_reminder_rules WHERE id = ?", (rule_id,))
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+# ---------------------------------------------------------------------------
+# Reminder Delivery CRUD
+# ---------------------------------------------------------------------------
+
+
+async def insert_reminder_delivery(
+    delivery: ReminderDelivery, db_path: str | Path | None = None
+) -> None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute(
+            "INSERT INTO calendar_reminder_deliveries "
+            "(id, reminder_rule_id, event_id, scheduled_time, status, channel, "
+            "attempts, last_error) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                delivery.id,
+                delivery.reminder_rule_id,
+                delivery.event_id,
+                delivery.scheduled_time,
+                delivery.status,
+                delivery.channel,
+                delivery.attempts,
+                delivery.last_error,
+            ),
+        )
+        await db.commit()
+
+
+async def get_pending_deliveries(
+    event_id: str, reminder_rule_id: str, db_path: str | Path | None = None
+) -> list[ReminderDelivery]:
+    """Check idempotency — return existing deliveries for an event+rule."""
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT * FROM calendar_reminder_deliveries "
+            "WHERE event_id = ? AND reminder_rule_id = ?",
+            (event_id, reminder_rule_id),
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_reminder_delivery(row) for row in rows]
+
+
+async def update_delivery_status(
+    delivery_id: str,
+    status: str,
+    last_error: str | None = None,
+    db_path: str | Path | None = None,
+) -> bool:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        cursor = await db.execute(
+            "UPDATE calendar_reminder_deliveries "
+            "SET status = ?, attempts = attempts + 1, last_error = ? "
+            "WHERE id = ?",
+            (status, last_error, delivery_id),
+        )
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+# ---------------------------------------------------------------------------
+# External Calendar Config CRUD
+# ---------------------------------------------------------------------------
+
+
+async def insert_external_config(
+    config: ExternalCalendarConfig, db_path: str | Path | None = None
+) -> None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute(
+            "INSERT INTO calendar_external_configs "
+            "(id, user_id, provider, credentials, sync_frequency, sync_scope, "
+            "last_sync, sync_token) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                config.id,
+                config.user_id,
+                config.provider,
+                config.credentials,
+                config.sync_frequency,
+                json.dumps(config.sync_scope),
+                config.last_sync,
+                config.sync_token,
+            ),
+        )
+        await db.commit()
+
+
+async def list_external_configs(
+    user_id: str, db_path: str | Path | None = None
+) -> list[ExternalCalendarConfig]:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT * FROM calendar_external_configs WHERE user_id = ?",
+            (user_id,),
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_external_config(row) for row in rows]
+
+
+async def update_external_config(
+    config_id: str, fields: dict[str, object], db_path: str | Path | None = None
+) -> bool:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    set_clauses: list[str] = []
+    params: list[object] = []
+    for field_name, value in fields.items():
+        if field_name == "credentials":
+            set_clauses.append("credentials = ?")
+            params.append(value)
+        elif field_name == "sync_frequency":
+            set_clauses.append("sync_frequency = ?")
+            params.append(value)
+        elif field_name == "sync_scope":
+            set_clauses.append("sync_scope = ?")
+            params.append(json.dumps(value))
+        elif field_name == "last_sync":
+            set_clauses.append("last_sync = ?")
+            params.append(value)
+        elif field_name == "sync_token":
+            set_clauses.append("sync_token = ?")
+            params.append(value)
+    if not set_clauses:
+        return False
+    params.append(config_id)
+    sql = f"UPDATE calendar_external_configs SET {', '.join(set_clauses)} WHERE id = ?"
+    async with aiosqlite.connect(str(path)) as db:
+        cursor = await db.execute(sql, tuple(params))
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+async def delete_external_config(config_id: str, db_path: str | Path | None = None) -> bool:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        cursor = await db.execute(
+            "DELETE FROM calendar_external_configs WHERE id = ?", (config_id,)
+        )
+        await db.commit()
+        return cursor.rowcount > 0
+
+
+# ---------------------------------------------------------------------------
+# Invitation CRUD
+# ---------------------------------------------------------------------------
+
+
+async def insert_invitation(invitation: Invitation, db_path: str | Path | None = None) -> None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        await db.execute(
+            "INSERT INTO calendar_invitations "
+            "(id, event_id, inviter_user_id, invitee_email, status, responded_at) "
+            "VALUES (?, ?, ?, ?, ?, ?)",
+            (
+                invitation.id,
+                invitation.event_id,
+                invitation.inviter_user_id,
+                invitation.invitee_email,
+                invitation.status,
+                invitation.responded_at,
+            ),
+        )
+        await db.commit()
+
+
+async def get_invitation(
+    invitation_id: str, db_path: str | Path | None = None
+) -> Invitation | None:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT * FROM calendar_invitations WHERE id = ?", (invitation_id,)
+        )
+        row = await cursor.fetchone()
+        return _row_to_invitation(row) if row else None
+
+
+async def list_invitations(
+    invitee_email: str, db_path: str | Path | None = None
+) -> list[Invitation]:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        db.row_factory = aiosqlite.Row
+        cursor = await db.execute(
+            "SELECT * FROM calendar_invitations WHERE invitee_email = ? ORDER BY responded_at DESC",
+            (invitee_email,),
+        )
+        rows = await cursor.fetchall()
+        return [_row_to_invitation(row) for row in rows]
+
+
+async def update_invitation_status(
+    invitation_id: str,
+    status: str,
+    responded_at: str,
+    db_path: str | Path | None = None,
+) -> bool:
+    path = Path(db_path) if db_path is not None else DEFAULT_CALENDAR_DB_PATH
+    async with aiosqlite.connect(str(path)) as db:
+        cursor = await db.execute(
+            "UPDATE calendar_invitations SET status = ?, responded_at = ? WHERE id = ?",
+            (status, responded_at, invitation_id),
+        )
+        await db.commit()
+        return cursor.rowcount > 0

src/agentkit/calendar/models.py

@@ -0,0 +1,221 @@
+"""Data models for the calendar subsystem.
+
+All dataclasses are DTOs carried between CalendarService, Agent tools,
+REST routes, and the frontend. They mirror the ``calendar_*`` DB rows.
+All timestamps are ISO 8601 UTC (see KTD-11).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+
+def _now_iso() -> str:
+    """Return current UTC time as ISO 8601 string."""
+    return datetime.now(timezone.utc).isoformat()
+
+
+@dataclass
+class EventType:
+    """User-defined event type (e.g. "会议", "截止", "个人")."""
+
+    id: str
+    user_id: str
+    name: str
+    color: str = "#4A90D9"
+    is_default: bool = False
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "user_id": self.user_id,
+            "name": self.name,
+            "color": self.color,
+            "is_default": self.is_default,
+        }
+
+
+@dataclass
+class Tag:
+    """User-defined tag for events."""
+
+    id: str
+    user_id: str
+    name: str
+
+    def to_dict(self) -> dict[str, object]:
+        return {"id": self.id, "user_id": self.user_id, "name": self.name}
+
+
+@dataclass
+class CalendarEvent:
+    """A calendar event.
+
+    Attributes:
+        source: "manual" | "agent" | "post_extract" — origin traceability (R15).
+        is_invited: True if this event arrived via invitation (R33 — special styling).
+        rrule: RFC 5545 RRULE string, e.g. "FREQ=WEEKLY;BYDAY=MO;COUNT=10".
+        external_id: ID in external calendar (for sync).
+        external_provider: "caldav" | "outlook" | None.
+        last_modified: ISO 8601 UTC, for conflict resolution (last-write-wins).
+    """
+
+    id: str
+    user_id: str
+    title: str
+    description: str = ""
+    start_time: str = ""  # ISO 8601 UTC (KTD-11)
+    end_time: str = ""  # ISO 8601 UTC
+    is_all_day: bool = False
+    location: str = ""
+    event_type_id: str | None = None
+    rrule: str | None = None
+    source: str = "manual"  # "manual" | "agent" | "post_extract"
+    is_invited: bool = False
+    conversation_id: str | None = None
+    external_id: str | None = None
+    external_provider: str | None = None
+    last_modified: str = ""
+    created_at: str = ""
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "user_id": self.user_id,
+            "title": self.title,
+            "description": self.description,
+            "start_time": self.start_time,
+            "end_time": self.end_time,
+            "is_all_day": self.is_all_day,
+            "location": self.location,
+            "event_type_id": self.event_type_id,
+            "rrule": self.rrule,
+            "source": self.source,
+            "is_invited": self.is_invited,
+            "conversation_id": self.conversation_id,
+            "external_id": self.external_id,
+            "external_provider": self.external_provider,
+            "last_modified": self.last_modified,
+            "created_at": self.created_at,
+        }
+
+
+@dataclass
+class EventTag:
+    """Many-to-many junction between events and tags."""
+
+    event_id: str
+    tag_id: str
+
+    def to_dict(self) -> dict[str, object]:
+        return {"event_id": self.event_id, "tag_id": self.tag_id}
+
+
+@dataclass
+class ReminderRule:
+    """Reminder rule — per-event or per-event-type default.
+
+    Attributes:
+        event_id: FK to events (nullable for type-level defaults).
+        event_type_id: FK to event_types (for default reminders).
+        offset_minutes: -15 = 15 min before, -1440 = 1 day before.
+        channels: ["client", "email", "webhook"].
+    """
+
+    id: str
+    event_id: str | None = None
+    event_type_id: str | None = None
+    offset_minutes: int = -15
+    channels: list[str] = field(default_factory=lambda: ["client"])
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "event_id": self.event_id,
+            "event_type_id": self.event_type_id,
+            "offset_minutes": self.offset_minutes,
+            "channels": self.channels,
+        }
+
+
+@dataclass
+class ReminderDelivery:
+    """Tracks delivery status of a reminder instance."""
+
+    id: str
+    reminder_rule_id: str
+    event_id: str
+    scheduled_time: str  # ISO 8601 UTC
+    status: str = "pending"  # "pending" | "sent" | "failed" | "read"
+    channel: str = "client"
+    attempts: int = 0
+    last_error: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "reminder_rule_id": self.reminder_rule_id,
+            "event_id": self.event_id,
+            "scheduled_time": self.scheduled_time,
+            "status": self.status,
+            "channel": self.channel,
+            "attempts": self.attempts,
+            "last_error": self.last_error,
+        }
+
+
+@dataclass
+class ExternalCalendarConfig:
+    """Configuration for an external calendar sync provider.
+
+    Attributes:
+        provider: "caldav" | "outlook".
+        credentials: encrypted JSON (CalDAV URL+user+app_password, or OAuth refresh_token).
+        sync_frequency: sync interval in minutes.
+        sync_scope: event type IDs to sync, empty = all.
+        sync_token: delta token for incremental sync.
+    """
+
+    id: str
+    user_id: str
+    provider: str  # "caldav" | "outlook"
+    credentials: str = ""  # encrypted JSON
+    sync_frequency: int = 30  # minutes
+    sync_scope: list[str] = field(default_factory=list)
+    last_sync: str | None = None
+    sync_token: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "user_id": self.user_id,
+            "provider": self.provider,
+            "credentials": "***",  # Never expose credentials
+            "sync_frequency": self.sync_frequency,
+            "sync_scope": self.sync_scope,
+            "last_sync": self.last_sync,
+            "sync_token": self.sync_token,
+        }
+
+
+@dataclass
+class Invitation:
+    """Event invitation from one user to another."""
+
+    id: str
+    event_id: str
+    inviter_user_id: str
+    invitee_email: str
+    status: str = "pending"  # "pending" | "accepted" | "declined" | "tentative"
+    responded_at: str | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "id": self.id,
+            "event_id": self.event_id,
+            "inviter_user_id": self.inviter_user_id,
+            "invitee_email": self.invitee_email,
+            "status": self.status,
+            "responded_at": self.responded_at,
+        }

src/agentkit/calendar/recurrence.py

@@ -0,0 +1,67 @@
+"""RRULE recurrence expansion wrapper.
+
+Uses ``dateutil.rrule`` for RFC 5545 compliant recurrence rule expansion.
+All times are UTC (see KTD-11).
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from dateutil.rrule import rrulestr
+
+
+def _parse_dt(dt_str: str) -> datetime:
+    """Parse ISO 8601 string to timezone-aware datetime (UTC)."""
+    dt = datetime.fromisoformat(dt_str)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def expand_rrule(
+    rrule_str: str | None,
+    dtstart: str,
+    range_start: str | None = None,
+    range_end: str | None = None,
+) -> list[str]:
+    """Expand a recurrence rule into individual occurrence start times.
+
+    Args:
+        rrule_str: RFC 5545 RRULE string (e.g. "FREQ=WEEKLY;BYDAY=MO;COUNT=4").
+            If None or empty, returns ``[dtstart]``.
+        dtstart: ISO 8601 start time of the first occurrence (UTC).
+        range_start: Optional ISO 8601 lower bound (inclusive) for filtering.
+        range_end: Optional ISO 8601 upper bound (exclusive) for filtering.
+
+    Returns:
+        List of ISO 8601 UTC strings for each occurrence's start time
+        within the given range. If no range is specified, returns all
+        occurrences (bounded by COUNT or UNTIL in the RRULE).
+    """
+    if not rrule_str:
+        return [dtstart]
+
+    start_dt = _parse_dt(dtstart)
+
+    # rrulestr expects the RRULE to have a DTSTART context.
+    # We prepend DTSTART to ensure the rule starts from the event's start time.
+    full_rule = f"DTSTART:{start_dt.strftime('%Y%m%dT%H%M%SZ')}\nRRULE:{rrule_str}"
+    rule = rrulestr(full_rule)
+
+    if range_start is not None and range_end is not None:
+        rs = _parse_dt(range_start)
+        re_ = _parse_dt(range_end)
+        # Half-open interval [start, end) — standard date-range convention
+        occurrences = [dt for dt in rule if rs <= dt < re_]
+    elif range_start is not None:
+        rs = _parse_dt(range_start)
+        occurrences = [dt for dt in rule if dt >= rs]
+    elif range_end is not None:
+        re_ = _parse_dt(range_end)
+        occurrences = [dt for dt in rule if dt < re_]
+    else:
+        occurrences = list(rule)
+
+    # Convert back to ISO 8601 UTC strings
+    return [dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S+00:00") for dt in occurrences]

tests/unit/calendar/test_db.py

@@ -0,0 +1,305 @@
+"""Tests for calendar DB CRUD (U1)."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import pytest
+
+from agentkit.calendar.db import (
+    add_tag_to_event,
+    delete_event,
+    delete_event_type,
+    get_event,
+    get_event_tags,
+    init_calendar_db,
+    insert_event,
+    insert_event_type,
+    insert_external_config,
+    insert_invitation,
+    insert_reminder_rule,
+    insert_tag,
+    list_event_types,
+    list_events,
+    list_external_configs,
+    list_invitations,
+    list_reminder_rules_for_event,
+    list_reminder_rules_for_type,
+    list_tags,
+    update_event,
+    update_event_type,
+    update_invitation_status,
+)
+from agentkit.calendar.models import (
+    CalendarEvent,
+    EventType,
+    ExternalCalendarConfig,
+    Invitation,
+    ReminderRule,
+    Tag,
+    _now_iso,
+)
+
+
+@pytest.fixture
+def db_path(tmp_path: Path) -> Path:
+    path = tmp_path / "test_calendar.db"
+    asyncio.run(init_calendar_db(path))
+    return path
+
+
+def _make_event(
+    event_id: str = "evt-1",
+    user_id: str = "user-1",
+    title: str = "Test Event",
+    start: str = "2026-07-01T10:00:00+00:00",
+    end: str = "2026-07-01T11:00:00+00:00",
+    **kwargs,
+) -> CalendarEvent:
+    now = _now_iso()
+    return CalendarEvent(
+        id=event_id,
+        user_id=user_id,
+        title=title,
+        start_time=start,
+        end_time=end,
+        last_modified=now,
+        created_at=now,
+        **kwargs,
+    )
+
+
+# ---------------------------------------------------------------------------
+# init_calendar_db
+# ---------------------------------------------------------------------------
+
+
+def test_init_calendar_db_creates_all_tables(db_path: Path) -> None:
+    """init_calendar_db creates all 8 tables."""
+    import aiosqlite
+
+    async def check():
+        async with aiosqlite.connect(str(db_path)) as db:
+            cursor = await db.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+            )
+            tables = {row[0] for row in await cursor.fetchall()}
+        return tables
+
+    tables = asyncio.run(check())
+    expected = {
+        "calendar_events",
+        "calendar_event_types",
+        "calendar_tags",
+        "calendar_event_tags",
+        "calendar_reminder_rules",
+        "calendar_reminder_deliveries",
+        "calendar_external_configs",
+        "calendar_invitations",
+    }
+    assert expected.issubset(tables), f"Missing tables: {expected - tables}"
+
+
+# ---------------------------------------------------------------------------
+# Event CRUD
+# ---------------------------------------------------------------------------
+
+
+def test_insert_and_get_event_roundtrip(db_path: Path) -> None:
+    """Insert event, fetch by id, all fields preserved including is_invited."""
+    event = _make_event(is_invited=True, source="agent", conversation_id="conv-1")
+    asyncio.run(insert_event(event, db_path))
+
+    fetched = asyncio.run(get_event("evt-1", db_path))
+    assert fetched is not None
+    assert fetched.id == "evt-1"
+    assert fetched.title == "Test Event"
+    assert fetched.is_invited is True
+    assert fetched.source == "agent"
+    assert fetched.conversation_id == "conv-1"
+
+
+def test_list_events_by_user_filtered_by_date_range(db_path: Path) -> None:
+    """Insert 3 events, query range covering 2."""
+    for i, day in enumerate([1, 15, 28]):
+        evt = _make_event(
+            event_id=f"evt-{i}",
+            start=f"2026-07-{day:02d}T10:00:00+00:00",
+            end=f"2026-07-{day:02d}T11:00:00+00:00",
+        )
+        asyncio.run(insert_event(evt, db_path))
+
+    events = asyncio.run(
+        list_events(
+            "user-1",
+            start="2026-07-10T00:00:00+00:00",
+            end="2026-07-20T00:00:00+00:00",
+            db_path=db_path,
+        )
+    )
+    assert len(events) == 1
+    assert events[0].id == "evt-1"
+
+
+def test_update_event_modifies_fields(db_path: Path) -> None:
+    """Insert, update title, verify."""
+    asyncio.run(insert_event(_make_event(), db_path))
+    updated = asyncio.run(update_event("evt-1", {"title": "Updated"}, db_path))
+    assert updated is True
+
+    fetched = asyncio.run(get_event("evt-1", db_path))
+    assert fetched is not None
+    assert fetched.title == "Updated"
+
+
+def test_delete_event_removes_record(db_path: Path) -> None:
+    """Insert, delete, verify gone."""
+    asyncio.run(insert_event(_make_event(), db_path))
+    deleted = asyncio.run(delete_event("evt-1", db_path))
+    assert deleted is True
+
+    fetched = asyncio.run(get_event("evt-1", db_path))
+    assert fetched is None
+
+
+# ---------------------------------------------------------------------------
+# Event Type CRUD
+# ---------------------------------------------------------------------------
+
+
+def test_event_type_crud(db_path: Path) -> None:
+    """Create/list/update/delete event types."""
+    et = EventType(id="type-1", user_id="user-1", name="会议", color="#FF0000")
+    asyncio.run(insert_event_type(et, db_path))
+
+    types = asyncio.run(list_event_types("user-1", db_path))
+    assert len(types) == 1
+    assert types[0].name == "会议"
+    assert types[0].color == "#FF0000"
+
+    asyncio.run(update_event_type("type-1", {"name": "Meeting"}, db_path))
+    types = asyncio.run(list_event_types("user-1", db_path))
+    assert types[0].name == "Meeting"
+
+    deleted = asyncio.run(delete_event_type("type-1", db_path))
+    assert deleted is True
+    types = asyncio.run(list_event_types("user-1", db_path))
+    assert len(types) == 0
+
+
+# ---------------------------------------------------------------------------
+# Tag CRUD + many-to-many
+# ---------------------------------------------------------------------------
+
+
+def test_tag_many_to_many(db_path: Path) -> None:
+    """Event with 3 tags, query by tag returns event."""
+    asyncio.run(insert_event(_make_event(), db_path))
+
+    for i in range(3):
+        tag = Tag(id=f"tag-{i}", user_id="user-1", name=f"Tag{i}")
+        asyncio.run(insert_tag(tag, db_path))
+        asyncio.run(add_tag_to_event("evt-1", f"tag-{i}", db_path))
+
+    # Get tags for event
+    tags = asyncio.run(get_event_tags("evt-1", db_path))
+    assert len(tags) == 3
+
+    # List events filtered by tag
+    events = asyncio.run(list_events("user-1", tag_id="tag-1", db_path=db_path))
+    assert len(events) == 1
+    assert events[0].id == "evt-1"
+
+    # List all tags
+    all_tags = asyncio.run(list_tags("user-1", db_path))
+    assert len(all_tags) == 3
+
+
+# ---------------------------------------------------------------------------
+# Reminder Rule CRUD
+# ---------------------------------------------------------------------------
+
+
+def test_reminder_rule_crud(db_path: Path) -> None:
+    """Create rule for event, create default rule for type."""
+    asyncio.run(insert_event(_make_event(), db_path))
+    asyncio.run(
+        insert_event_type(EventType(id="type-1", user_id="user-1", name="Meeting"), db_path)
+    )
+
+    # Event-level rule
+    rule1 = ReminderRule(
+        id="rule-1", event_id="evt-1", offset_minutes=-15, channels=["client", "email"]
+    )
+    asyncio.run(insert_reminder_rule(rule1, db_path))
+
+    # Type-level default rule
+    rule2 = ReminderRule(
+        id="rule-2", event_type_id="type-1", offset_minutes=-1440, channels=["email"]
+    )
+    asyncio.run(insert_reminder_rule(rule2, db_path))
+
+    event_rules = asyncio.run(list_reminder_rules_for_event("evt-1", db_path))
+    assert len(event_rules) == 1
+    assert event_rules[0].offset_minutes == -15
+    assert event_rules[0].channels == ["client", "email"]
+
+    type_rules = asyncio.run(list_reminder_rules_for_type("type-1", db_path))
+    assert len(type_rules) == 1
+    assert type_rules[0].offset_minutes == -1440
+
+
+# ---------------------------------------------------------------------------
+# External Config
+# ---------------------------------------------------------------------------
+
+
+def test_external_config_stores_encrypted_credentials(db_path: Path) -> None:
+    """Insert config, verify credentials field is opaque (stored as-is)."""
+    config = ExternalCalendarConfig(
+        id="cfg-1",
+        user_id="user-1",
+        provider="caldav",
+        credentials='{"url":"https://caldav.icloud.com","user":"alice","pass":"xxx"}',
+        sync_frequency=15,
+        sync_scope=["type-1", "type-2"],
+    )
+    asyncio.run(insert_external_config(config, db_path))
+
+    configs = asyncio.run(list_external_configs("user-1", db_path))
+    assert len(configs) == 1
+    assert configs[0].provider == "caldav"
+    assert configs[0].sync_frequency == 15
+    assert configs[0].sync_scope == ["type-1", "type-2"]
+    # Credentials stored as-is (encryption happens at service layer)
+    assert "caldav.icloud.com" in configs[0].credentials
+
+
+# ---------------------------------------------------------------------------
+# Invitation CRUD
+# ---------------------------------------------------------------------------
+
+
+def test_invitation_crud(db_path: Path) -> None:
+    """Create invitation, list by email, update status."""
+    asyncio.run(insert_event(_make_event(), db_path))
+
+    inv = Invitation(
+        id="inv-1",
+        event_id="evt-1",
+        inviter_user_id="user-1",
+        invitee_email="alice@example.com",
+    )
+    asyncio.run(insert_invitation(inv, db_path))
+
+    invs = asyncio.run(list_invitations("alice@example.com", db_path))
+    assert len(invs) == 1
+    assert invs[0].status == "pending"
+
+    now = _now_iso()
+    asyncio.run(update_invitation_status("inv-1", "accepted", now, db_path))
+
+    invs = asyncio.run(list_invitations("alice@example.com", db_path))
+    assert invs[0].status == "accepted"
+    assert invs[0].responded_at == now

tests/unit/calendar/test_recurrence.py

@@ -0,0 +1,75 @@
+"""Tests for RRULE recurrence expansion (U1)."""
+
+from __future__ import annotations
+
+from agentkit.calendar.recurrence import expand_rrule
+
+
+def test_expand_rrule_weekly_count() -> None:
+    """FREQ=WEEKLY;BYDAY=MO;COUNT=4 from Monday → 4 occurrences."""
+    result = expand_rrule(
+        "FREQ=WEEKLY;BYDAY=MO;COUNT=4",
+        "2026-07-06T10:00:00+00:00",  # Monday
+    )
+    assert len(result) == 4
+    # All should be Mondays
+    for occ in result:
+        # 2026-07-06 is Monday, 07-13, 07-20, 07-27
+        assert "T10:00:00+00:00" in occ
+
+
+def test_expand_rrule_daily_range_filter() -> None:
+    """FREQ=DAILY starting Jan 1, range Jan 3–Jan 5 → 3 occurrences."""
+    result = expand_rrule(
+        "FREQ=DAILY",
+        "2026-01-01T00:00:00+00:00",
+        range_start="2026-01-03T00:00:00+00:00",
+        range_end="2026-01-06T00:00:00+00:00",
+    )
+    assert len(result) == 3  # Jan 3, 4, 5
+
+
+def test_expand_rrule_until_clause() -> None:
+    """FREQ=DAILY;UNTIL=20260131 → occurrences stop at Jan 31."""
+    result = expand_rrule(
+        "FREQ=DAILY;UNTIL=20260131T235959Z",
+        "2026-01-29T00:00:00+00:00",
+    )
+    assert len(result) == 3  # Jan 29, 30, 31
+
+
+def test_expand_rrule_no_rrule_returns_single() -> None:
+    """rrule=None → returns [start_time] only."""
+    result = expand_rrule(None, "2026-07-01T10:00:00+00:00")
+    assert result == ["2026-07-01T10:00:00+00:00"]
+
+    result = expand_rrule("", "2026-07-01T10:00:00+00:00")
+    assert result == ["2026-07-01T10:00:00+00:00"]
+
+
+def test_expand_rrule_all_day_event() -> None:
+    """All-day event with RRULE, verify date expansion (no time component issues)."""
+    result = expand_rrule(
+        "FREQ=DAILY;COUNT=3",
+        "2026-07-01T00:00:00+00:00",
+    )
+    assert len(result) == 3
+    assert result[0].startswith("2026-07-01")
+    assert result[1].startswith("2026-07-02")
+    assert result[2].startswith("2026-07-03")
+
+
+def test_expand_rrule_dst_boundary() -> None:
+    """Event crossing DST transition, verify UTC consistency.
+
+    March 8, 2026 is US DST spring-forward. A daily event starting
+    March 7 should produce correct UTC occurrences across the boundary.
+    """
+    result = expand_rrule(
+        "FREQ=DAILY;COUNT=3",
+        "2026-03-07T10:00:00+00:00",
+    )
+    assert len(result) == 3
+    # All should be at 10:00 UTC regardless of DST
+    for occ in result:
+        assert "T10:00:00+00:00" in occ