@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

package/apps/app-lifeops/src/lifeops/repository.js

@@ -1,43 +1,15 @@
 import crypto from "node:crypto";
-import { executeRawSql, getRuntimeDbCacheKey, isRetryableLifeOpsStorageError, listTableColumns, parseJsonArray, parseJsonRecord, sqlBoolean, sqlInteger, sqlJson, sqlQuote, sqlText, toBoolean, toNumber, toText, } from "./sql.js";
-const schemaReady = new WeakSet();
-const schemaInitializing = new WeakMap();
-const LIFEOPS_SCHEMA_RETRY_DELAY_MS = 150;
-async function hasLifeOpsSchema(runtime) {
-    try {
-        const rows = await executeRawSql(runtime, `SELECT 1
-         FROM information_schema.tables
-        WHERE table_schema = current_schema()
-          AND table_name = 'life_task_definitions'
-        LIMIT 1`);
-        return rows.length > 0;
-    }
-    catch {
-        return false;
-    }
+import { executeRawSql, parseJsonArray, parseJsonRecord, sqlBoolean, sqlInteger, sqlJson, sqlQuote, sqlText, toBoolean, toNumber, toText, } from "./sql.js";
+function normalizeConnectorIdentityEmail(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
 }
-async function runMigrationWithSavepoint(runtime, name, migration) {
-    const safeName = name.replace(/[^a-zA-Z0-9_]/g, "_");
-    // Postgres / PGlite: SAVEPOINT only works inside a transaction. Each raw
-    // execute is typically autocommit, so open an explicit outer transaction.
-    // SQLite: BEGIN + SAVEPOINT is also valid.
-    await executeRawSql(runtime, "BEGIN");
-    try {
-        await executeRawSql(runtime, `SAVEPOINT ${safeName}`);
-        try {
-            await migration();
-            await executeRawSql(runtime, `RELEASE SAVEPOINT ${safeName}`);
-        }
-        catch (error) {
-            await executeRawSql(runtime, `ROLLBACK TO SAVEPOINT ${safeName}`).catch(() => { });
-            throw error;
-        }
-        await executeRawSql(runtime, "COMMIT");
-    }
-    catch (error) {
-        await executeRawSql(runtime, "ROLLBACK").catch(() => { });
-        throw error;
-    }
+function deriveConnectorIdentityEmail(identity) {
+    return (normalizeConnectorIdentityEmail(identity.email) ??
+        normalizeConnectorIdentityEmail(identity.emailAddress) ??
+        normalizeConnectorIdentityEmail(identity.primaryEmail));
 }
 function isoNow() {
     return new Date().toISOString();
@@ -185,6 +157,55 @@ function parseChannelPolicy(row) {
         updatedAt: toText(row.updated_at),
     };
 }
+function parseRelationship(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        name: toText(row.name),
+        primaryChannel: toText(row.primary_channel),
+        primaryHandle: toText(row.primary_handle),
+        email: row.email ? toText(row.email) : null,
+        phone: row.phone ? toText(row.phone) : null,
+        notes: toText(row.notes, ""),
+        tags: parseJsonArray(row.tags_json),
+        relationshipType: toText(row.relationship_type),
+        lastContactedAt: row.last_contacted_at ? toText(row.last_contacted_at) : null,
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseRelationshipInteraction(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        relationshipId: toText(row.relationship_id),
+        channel: toText(row.channel),
+        direction: toText(row.direction),
+        summary: toText(row.summary),
+        occurredAt: toText(row.occurred_at),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+    };
+}
+function parseFollowUp(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        relationshipId: toText(row.relationship_id),
+        dueAt: toText(row.due_at),
+        reason: toText(row.reason),
+        status: toText(row.status),
+        priority: toNumber(row.priority, 3),
+        draft: row.draft_json
+            ? parseJsonRecord(row.draft_json)
+            : null,
+        completedAt: row.completed_at ? toText(row.completed_at) : null,
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
 function parseWebsiteAccessGrant(row) {
     return {
         id: toText(row.id),
@@ -207,12 +228,13 @@ function parseWebsiteAccessGrant(row) {
     };
 }
 function parseConnectorGrant(row) {
+    const identity = parseJsonRecord(row.identity_json);
     return {
         id: toText(row.id),
         agentId: toText(row.agent_id),
         provider: toText(row.provider),
         side: toText(row.side, "owner"),
-        identity: parseJsonRecord(row.identity_json),
+        identity,
         grantedScopes: parseJsonArray(row.granted_scopes_json),
         capabilities: parseJsonArray(row.capabilities_json),
         tokenRef: row.token_ref ? toText(row.token_ref) : null,
@@ -621,578 +643,163 @@ function parseEscalationStateRow(row) {
         updatedAt: toText(row.updated_at),
     };
 }
-export async function ensureLifeOpsTables(runtime) {
-    // Cache schema readiness per underlying DB connection rather than per
-    // runtime or per Drizzle wrapper. Multiple runtimes/adapters can share the
-    // same PGlite connection manager, and keying on the wrapper lets concurrent
-    // lifeops bootstraps race the same DDL.
-    const key = getRuntimeDbCacheKey(runtime);
-    if (schemaReady.has(key)) {
-        if (await hasLifeOpsSchema(runtime))
-            return;
-        schemaReady.delete(key);
-    }
-    // Prevent concurrent migration runs — PGlite cannot handle concurrent DDL.
-    // The first caller creates the migration promise; concurrent callers await it.
-    const pending = schemaInitializing.get(key);
-    if (pending)
-        return pending;
-    const migrationPromise = runLifeOpsSchemaSetupWithRetry(runtime, key);
-    schemaInitializing.set(key, migrationPromise);
-    try {
-        await migrationPromise;
-    }
-    finally {
-        schemaInitializing.delete(key);
-    }
+function parseXDm(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        externalDmId: toText(row.external_dm_id),
+        conversationId: toText(row.conversation_id),
+        senderHandle: toText(row.sender_handle),
+        senderId: toText(row.sender_id),
+        isInbound: toBoolean(row.is_inbound),
+        text: toText(row.text),
+        receivedAt: toText(row.received_at),
+        readAt: row.read_at ? toText(row.read_at) : null,
+        repliedAt: row.replied_at ? toText(row.replied_at) : null,
+        metadata: parseJsonRecord(row.metadata_json),
+        syncedAt: toText(row.synced_at),
+        updatedAt: toText(row.updated_at),
+    };
 }
-async function runLifeOpsSchemaSetup(runtime, key) {
-    const statements = [
-        `CREATE TABLE IF NOT EXISTS life_task_definitions (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      domain TEXT NOT NULL,
-      subject_type TEXT NOT NULL,
-      subject_id TEXT NOT NULL,
-      visibility_scope TEXT NOT NULL,
-      context_policy TEXT NOT NULL,
-      kind TEXT NOT NULL,
-      title TEXT NOT NULL,
-      description TEXT NOT NULL DEFAULT '',
-      original_intent TEXT NOT NULL DEFAULT '',
-      timezone TEXT NOT NULL,
-      status TEXT NOT NULL,
-      priority INTEGER NOT NULL DEFAULT 3,
-      cadence_json TEXT NOT NULL,
-      window_policy_json TEXT NOT NULL,
-      progression_rule_json TEXT NOT NULL,
-      website_access_json TEXT,
-      reminder_plan_id TEXT,
-      goal_id TEXT,
-      source TEXT NOT NULL DEFAULT 'manual',
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_task_occurrences (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      domain TEXT NOT NULL,
-      subject_type TEXT NOT NULL,
-      subject_id TEXT NOT NULL,
-      visibility_scope TEXT NOT NULL,
-      context_policy TEXT NOT NULL,
-      definition_id TEXT NOT NULL,
-      occurrence_key TEXT NOT NULL,
-      scheduled_at TEXT,
-      due_at TEXT,
-      relevance_start_at TEXT NOT NULL,
-      relevance_end_at TEXT NOT NULL,
-      window_name TEXT,
-      state TEXT NOT NULL,
-      snoozed_until TEXT,
-      completion_payload_json TEXT,
-      derived_target_json TEXT,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, definition_id, occurrence_key)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_goal_definitions (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      domain TEXT NOT NULL,
-      subject_type TEXT NOT NULL,
-      subject_id TEXT NOT NULL,
-      visibility_scope TEXT NOT NULL,
-      context_policy TEXT NOT NULL,
-      title TEXT NOT NULL,
-      description TEXT NOT NULL DEFAULT '',
-      cadence_json TEXT,
-      support_strategy_json TEXT NOT NULL DEFAULT '{}',
-      success_criteria_json TEXT NOT NULL DEFAULT '{}',
-      status TEXT NOT NULL,
-      review_state TEXT NOT NULL,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_goal_links (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      goal_id TEXT NOT NULL,
-      linked_type TEXT NOT NULL,
-      linked_id TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      UNIQUE(agent_id, goal_id, linked_type, linked_id)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_workflow_definitions (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      domain TEXT NOT NULL,
-      subject_type TEXT NOT NULL,
-      subject_id TEXT NOT NULL,
-      visibility_scope TEXT NOT NULL,
-      context_policy TEXT NOT NULL,
-      title TEXT NOT NULL,
-      trigger_type TEXT NOT NULL,
-      schedule_json TEXT NOT NULL,
-      action_plan_json TEXT NOT NULL,
-      permission_policy_json TEXT NOT NULL,
-      status TEXT NOT NULL,
-      created_by TEXT NOT NULL,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_workflow_runs (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      workflow_id TEXT NOT NULL,
-      started_at TEXT NOT NULL,
-      finished_at TEXT,
-      status TEXT NOT NULL,
-      result_json TEXT NOT NULL DEFAULT '{}',
-      audit_ref TEXT
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_browser_sessions (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      domain TEXT NOT NULL,
-      subject_type TEXT NOT NULL,
-      subject_id TEXT NOT NULL,
-      visibility_scope TEXT NOT NULL,
-      context_policy TEXT NOT NULL,
-      workflow_id TEXT,
-      browser TEXT,
-      companion_id TEXT,
-      profile_id TEXT,
-      window_id TEXT,
-      tab_id TEXT,
-      title TEXT NOT NULL,
-      status TEXT NOT NULL,
-      actions_json TEXT NOT NULL DEFAULT '[]',
-      current_action_index INTEGER NOT NULL DEFAULT 0,
-      awaiting_confirmation_for_action_id TEXT,
-      result_json TEXT NOT NULL DEFAULT '{}',
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      finished_at TEXT
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_browser_settings (
-      agent_id TEXT PRIMARY KEY,
-      enabled BOOLEAN NOT NULL DEFAULT FALSE,
-      tracking_mode TEXT NOT NULL DEFAULT 'current_tab',
-      allow_browser_control BOOLEAN NOT NULL DEFAULT FALSE,
-      require_confirmation_for_account_affecting BOOLEAN NOT NULL DEFAULT TRUE,
-      incognito_enabled BOOLEAN NOT NULL DEFAULT FALSE,
-      site_access_mode TEXT NOT NULL DEFAULT 'current_site_only',
-      granted_origins_json TEXT NOT NULL DEFAULT '[]',
-      blocked_origins_json TEXT NOT NULL DEFAULT '[]',
-      max_remembered_tabs INTEGER NOT NULL DEFAULT 10,
-      pause_until TEXT,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_browser_companions (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      browser TEXT NOT NULL,
-      profile_id TEXT NOT NULL,
-      profile_label TEXT NOT NULL DEFAULT '',
-      label TEXT NOT NULL,
-      extension_version TEXT,
-      connection_state TEXT NOT NULL DEFAULT 'disconnected',
-      permissions_json TEXT NOT NULL DEFAULT '{}',
-      last_seen_at TEXT,
-      paired_at TEXT,
-      pairing_token_hash TEXT,
-      pending_pairing_token_hashes_json TEXT NOT NULL DEFAULT '[]',
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, browser, profile_id)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_browser_tabs (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      companion_id TEXT,
-      browser TEXT NOT NULL,
-      profile_id TEXT NOT NULL,
-      window_id TEXT NOT NULL,
-      tab_id TEXT NOT NULL,
-      url TEXT NOT NULL,
-      title TEXT NOT NULL,
-      active_in_window BOOLEAN NOT NULL DEFAULT FALSE,
-      focused_window BOOLEAN NOT NULL DEFAULT FALSE,
-      focused_active BOOLEAN NOT NULL DEFAULT FALSE,
-      incognito BOOLEAN NOT NULL DEFAULT FALSE,
-      favicon_url TEXT,
-      last_seen_at TEXT NOT NULL,
-      last_focused_at TEXT,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, browser, profile_id, window_id, tab_id)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_browser_page_contexts (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      browser TEXT NOT NULL,
-      profile_id TEXT NOT NULL,
-      window_id TEXT NOT NULL,
-      tab_id TEXT NOT NULL,
-      url TEXT NOT NULL,
-      title TEXT NOT NULL,
-      selection_text TEXT,
-      main_text TEXT,
-      headings_json TEXT NOT NULL DEFAULT '[]',
-      links_json TEXT NOT NULL DEFAULT '[]',
-      forms_json TEXT NOT NULL DEFAULT '[]',
-      captured_at TEXT NOT NULL,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      UNIQUE(agent_id, browser, profile_id, window_id, tab_id)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_reminder_plans (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      owner_type TEXT NOT NULL,
-      owner_id TEXT NOT NULL,
-      steps_json TEXT NOT NULL,
-      mute_policy_json TEXT NOT NULL DEFAULT '{}',
-      quiet_hours_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_reminder_attempts (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      plan_id TEXT NOT NULL,
-      owner_type TEXT NOT NULL,
-      owner_id TEXT NOT NULL,
-      occurrence_id TEXT,
-      channel TEXT NOT NULL,
-      step_index INTEGER NOT NULL,
-      scheduled_for TEXT NOT NULL,
-      attempted_at TEXT,
-      outcome TEXT NOT NULL,
-      connector_ref TEXT,
-      delivery_metadata_json TEXT NOT NULL DEFAULT '{}'
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_connector_grants (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      provider TEXT NOT NULL,
-      side TEXT NOT NULL DEFAULT 'owner',
-      identity_json TEXT NOT NULL DEFAULT '{}',
-      granted_scopes_json TEXT NOT NULL DEFAULT '[]',
-      capabilities_json TEXT NOT NULL DEFAULT '[]',
-      token_ref TEXT,
-      mode TEXT NOT NULL,
-      execution_target TEXT NOT NULL DEFAULT 'local',
-      source_of_truth TEXT NOT NULL DEFAULT 'local_storage',
-      preferred_by_agent BOOLEAN NOT NULL DEFAULT FALSE,
-      cloud_connection_id TEXT,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      last_refresh_at TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, provider, side, mode)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_calendar_events (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      provider TEXT NOT NULL,
-      side TEXT NOT NULL DEFAULT 'owner',
-      calendar_id TEXT NOT NULL,
-      external_event_id TEXT NOT NULL,
-      title TEXT NOT NULL,
-      description TEXT NOT NULL DEFAULT '',
-      location TEXT NOT NULL DEFAULT '',
-      status TEXT NOT NULL,
-      start_at TEXT NOT NULL,
-      end_at TEXT NOT NULL,
-      is_all_day BOOLEAN NOT NULL,
-      timezone TEXT,
-      html_link TEXT,
-      conference_link TEXT,
-      organizer_json TEXT,
-      attendees_json TEXT NOT NULL DEFAULT '[]',
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      synced_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, provider, side, calendar_id, external_event_id)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_calendar_sync_states (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      provider TEXT NOT NULL,
-      side TEXT NOT NULL DEFAULT 'owner',
-      calendar_id TEXT NOT NULL,
-      window_start_at TEXT NOT NULL,
-      window_end_at TEXT NOT NULL,
-      synced_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, provider, side, calendar_id)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_gmail_messages (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      provider TEXT NOT NULL,
-      side TEXT NOT NULL DEFAULT 'owner',
-      external_message_id TEXT NOT NULL,
-      thread_id TEXT NOT NULL,
-      subject TEXT NOT NULL DEFAULT '',
-      from_display TEXT NOT NULL DEFAULT '',
-      from_email TEXT,
-      reply_to TEXT,
-      to_json TEXT NOT NULL DEFAULT '[]',
-      cc_json TEXT NOT NULL DEFAULT '[]',
-      snippet TEXT NOT NULL DEFAULT '',
-      received_at TEXT NOT NULL,
-      is_unread BOOLEAN NOT NULL DEFAULT FALSE,
-      is_important BOOLEAN NOT NULL DEFAULT FALSE,
-      likely_reply_needed BOOLEAN NOT NULL DEFAULT FALSE,
-      triage_score INTEGER NOT NULL DEFAULT 0,
-      triage_reason TEXT NOT NULL DEFAULT '',
-      label_ids_json TEXT NOT NULL DEFAULT '[]',
-      html_link TEXT,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      synced_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, provider, side, external_message_id)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_gmail_sync_states (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      provider TEXT NOT NULL,
-      side TEXT NOT NULL DEFAULT 'owner',
-      mailbox TEXT NOT NULL,
-      max_results INTEGER NOT NULL DEFAULT 0,
-      synced_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, provider, side, mailbox)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_channel_policies (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      channel_type TEXT NOT NULL,
-      channel_ref TEXT NOT NULL,
-      privacy_class TEXT NOT NULL,
-      allow_reminders BOOLEAN NOT NULL,
-      allow_escalation BOOLEAN NOT NULL,
-      allow_posts BOOLEAN NOT NULL,
-      require_confirmation_for_actions BOOLEAN NOT NULL,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(agent_id, channel_type, channel_ref)
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_website_access_grants (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      group_key TEXT NOT NULL,
-      definition_id TEXT NOT NULL,
-      occurrence_id TEXT,
-      websites_json TEXT NOT NULL DEFAULT '[]',
-      unlock_mode TEXT NOT NULL,
-      unlock_duration_minutes INTEGER,
-      callback_key TEXT,
-      unlocked_at TEXT NOT NULL,
-      expires_at TEXT,
-      revoked_at TEXT,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_audit_events (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      event_type TEXT NOT NULL,
-      owner_type TEXT NOT NULL,
-      owner_id TEXT NOT NULL,
-      reason TEXT NOT NULL,
-      inputs_json TEXT NOT NULL DEFAULT '{}',
-      decision_json TEXT NOT NULL DEFAULT '{}',
-      actor TEXT NOT NULL,
-      created_at TEXT NOT NULL
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_activity_signals (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      source TEXT NOT NULL,
-      platform TEXT NOT NULL,
-      state TEXT NOT NULL,
-      observed_at TEXT NOT NULL,
-      idle_state TEXT,
-      idle_time_seconds INTEGER,
-      on_battery BOOLEAN,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL
-    )`,
-        `CREATE TABLE IF NOT EXISTS life_escalation_states (
-      id TEXT PRIMARY KEY,
-      agent_id TEXT NOT NULL,
-      reason TEXT NOT NULL,
-      text TEXT NOT NULL,
-      current_step INTEGER NOT NULL DEFAULT 0,
-      channels_sent_json TEXT NOT NULL DEFAULT '[]',
-      started_at TEXT NOT NULL,
-      last_sent_at TEXT NOT NULL,
-      resolved BOOLEAN NOT NULL DEFAULT FALSE,
-      resolved_at TEXT,
-      metadata_json TEXT NOT NULL DEFAULT '{}',
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    )`,
-    ];
-    /** Applied after legacy ownership columns are added — old DBs may lack domain/subject_* until ALTERs below. */
-    const coreIndexStatements = [
-        `CREATE INDEX IF NOT EXISTS idx_life_task_definitions_agent_status
-      ON life_task_definitions(agent_id, status)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_task_definitions_subject
-      ON life_task_definitions(agent_id, domain, subject_type, subject_id, status)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_task_occurrences_agent_state_start
-      ON life_task_occurrences(agent_id, state, relevance_start_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_task_occurrences_subject
-      ON life_task_occurrences(agent_id, domain, subject_type, subject_id, state, relevance_start_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_task_occurrences_definition
-      ON life_task_occurrences(definition_id, relevance_start_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_goal_definitions_agent_status
-      ON life_goal_definitions(agent_id, status)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_goal_definitions_subject
-      ON life_goal_definitions(agent_id, domain, subject_type, subject_id, status)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_reminder_plans_owner
-      ON life_reminder_plans(agent_id, owner_type, owner_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_audit_events_owner
-      ON life_audit_events(agent_id, owner_type, owner_id, created_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_activity_signals_agent
-      ON life_activity_signals(agent_id, observed_at DESC)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_workflow_definitions_agent
-      ON life_workflow_definitions(agent_id, status, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_workflow_definitions_subject
-      ON life_workflow_definitions(agent_id, domain, subject_type, subject_id, status, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_workflow_runs_workflow
-      ON life_workflow_runs(agent_id, workflow_id, started_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_browser_sessions_agent
-      ON life_browser_sessions(agent_id, status, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_browser_sessions_subject
-      ON life_browser_sessions(agent_id, domain, subject_type, subject_id, status, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_browser_companions_agent
-      ON life_browser_companions(agent_id, browser, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_browser_tabs_agent
-      ON life_browser_tabs(agent_id, focused_active, active_in_window, last_seen_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_browser_page_contexts_agent
-      ON life_browser_page_contexts(agent_id, captured_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_goal_links_goal
-      ON life_goal_links(goal_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_goal_links_linked
-      ON life_goal_links(linked_type, linked_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_reminder_attempts_plan
-      ON life_reminder_attempts(plan_id, owner_type, owner_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_channel_policies_agent
-      ON life_channel_policies(agent_id, channel_type)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_website_access_grants_group
-      ON life_website_access_grants(agent_id, group_key, revoked_at, expires_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_escalation_states_agent_resolved
-      ON life_escalation_states(agent_id, resolved)`,
-    ];
-    for (const statement of statements) {
-        await executeRawSql(runtime, statement);
-    }
-    const ownershipTables = [
-        "life_task_definitions",
-        "life_task_occurrences",
-        "life_goal_definitions",
-        "life_workflow_definitions",
-        "life_browser_sessions",
-    ];
-    const ownershipColumns = [
-        {
-            name: "domain",
-            definition: "TEXT NOT NULL DEFAULT 'user_lifeops'",
-        },
-        {
-            name: "subject_type",
-            definition: "TEXT NOT NULL DEFAULT 'owner'",
-        },
-        {
-            name: "subject_id",
-            definition: "TEXT NOT NULL DEFAULT ''",
-        },
-        {
-            name: "visibility_scope",
-            definition: "TEXT NOT NULL DEFAULT 'owner_agent_admin'",
-        },
-        {
-            name: "context_policy",
-            definition: "TEXT NOT NULL DEFAULT 'explicit_only'",
-        },
-    ];
-    for (const tableName of ownershipTables) {
-        const existingColumns = new Set(await listTableColumns(runtime, tableName));
-        for (const column of ownershipColumns) {
-            if (existingColumns.has(column.name))
-                continue;
-            await executeRawSql(runtime, `ALTER TABLE ${tableName} ADD COLUMN ${column.name} ${column.definition}`);
-        }
-        await executeRawSql(runtime, `UPDATE ${tableName}
-          SET subject_id = agent_id
-        WHERE subject_id = '' OR subject_id IS NULL`);
-    }
-    const browserSessionColumns = [
-        { name: "browser", definition: "TEXT" },
-        { name: "companion_id", definition: "TEXT" },
-        { name: "profile_id", definition: "TEXT" },
-        { name: "window_id", definition: "TEXT" },
-        { name: "tab_id", definition: "TEXT" },
-    ];
-    const existingBrowserSessionColumns = new Set(await listTableColumns(runtime, "life_browser_sessions"));
-    for (const column of browserSessionColumns) {
-        if (existingBrowserSessionColumns.has(column.name))
-            continue;
-        await executeRawSql(runtime, `ALTER TABLE life_browser_sessions ADD COLUMN ${column.name} ${column.definition}`);
-    }
-    const browserCompanionColumns = [
-        { name: "pairing_token_hash", definition: "TEXT" },
-        {
-            name: "pending_pairing_token_hashes_json",
-            definition: "TEXT NOT NULL DEFAULT '[]'",
-        },
-    ];
-    const existingBrowserCompanionColumns = new Set(await listTableColumns(runtime, "life_browser_companions"));
-    for (const column of browserCompanionColumns) {
-        if (existingBrowserCompanionColumns.has(column.name))
-            continue;
-        await executeRawSql(runtime, `ALTER TABLE life_browser_companions ADD COLUMN ${column.name} ${column.definition}`);
-    }
-    const existingDefinitionColumns = new Set(await listTableColumns(runtime, "life_task_definitions"));
-    if (!existingDefinitionColumns.has("website_access_json")) {
-        await executeRawSql(runtime, "ALTER TABLE life_task_definitions ADD COLUMN website_access_json TEXT");
-    }
-    // Indexes reference ownership columns (see coreIndexStatements doc). Running
-    // this loop before the ALTERs above used to break legacy DBs that lacked
-    // domain / subject_* until migration — PGlite would fail CREATE INDEX.
-    for (const statement of coreIndexStatements) {
-        await executeRawSql(runtime, statement);
-    }
-    const existingConnectorGrantColumns = new Set(await listTableColumns(runtime, "life_connector_grants"));
-    if (existingConnectorGrantColumns.size > 0 &&
-        !existingConnectorGrantColumns.has("side")) {
-        await runMigrationWithSavepoint(runtime, "migrate_connector_grants", async () => {
-            await executeRawSql(runtime, `DROP TABLE IF EXISTS life_connector_grants_next`);
-            await executeRawSql(runtime, `CREATE TABLE life_connector_grants_next (
+function parseXFeedItem(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        externalTweetId: toText(row.external_tweet_id),
+        authorHandle: toText(row.author_handle),
+        authorId: toText(row.author_id),
+        text: toText(row.text),
+        createdAtSource: toText(row.created_at_source),
+        feedType: toText(row.feed_type),
+        metadata: parseJsonRecord(row.metadata_json),
+        syncedAt: toText(row.synced_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseXSyncState(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        feedType: toText(row.feed_type),
+        lastCursor: row.last_cursor ? toText(row.last_cursor) : null,
+        syncedAt: toText(row.synced_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseScreenTimeSession(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        source: toText(row.source),
+        identifier: toText(row.identifier),
+        displayName: toText(row.display_name, toText(row.identifier)),
+        startAt: toText(row.start_at),
+        endAt: row.end_at ? toText(row.end_at) : null,
+        durationSeconds: toNumber(row.duration_seconds, 0),
+        isActive: toBoolean(row.is_active),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseScreenTimeDaily(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        source: toText(row.source),
+        identifier: toText(row.identifier),
+        date: toText(row.date),
+        totalSeconds: toNumber(row.total_seconds, 0),
+        sessionCount: toNumber(row.session_count, 0),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseSchedulingNegotiation(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        subject: toText(row.subject),
+        relationshipId: row.relationship_id ? toText(row.relationship_id) : null,
+        durationMinutes: toNumber(row.duration_minutes, 0),
+        timezone: toText(row.timezone, "UTC"),
+        state: toText(row.state, "initiated"),
+        acceptedProposalId: row.accepted_proposal_id
+            ? toText(row.accepted_proposal_id)
+            : null,
+        startedAt: toText(row.started_at),
+        finalizedAt: row.finalized_at ? toText(row.finalized_at) : null,
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseSchedulingProposal(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        negotiationId: toText(row.negotiation_id),
+        startAt: toText(row.start_at),
+        endAt: toText(row.end_at),
+        proposedBy: toText(row.proposed_by, "agent"),
+        status: toText(row.status, "pending"),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseDossier(row) {
+    const rawSources = parseJsonArray(row.sources_json);
+    const sources = rawSources
+        .filter((s) => !!s && typeof s === "object")
+        .map((s) => ({
+        kind: toText(s.kind),
+        ref: toText(s.ref),
+        ...(typeof s.snippet === "string" && s.snippet.length > 0
+            ? { snippet: s.snippet }
+            : {}),
+    }));
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        calendarEventId: row.calendar_event_id
+            ? toText(row.calendar_event_id)
+            : null,
+        subject: toText(row.subject),
+        generatedForAt: toText(row.generated_for_at),
+        contentMd: toText(row.content_md, ""),
+        sources,
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+export class LifeOpsRepository {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    /**
+     * Create all LifeOps tables if they do not already exist.
+     * Must be called once during plugin init before any queries run.
+     */
+    static async bootstrapSchema(runtime) {
+        // Each statement is idempotent (CREATE TABLE IF NOT EXISTS).
+        // We run them sequentially so tables referenced by foreign-key-like
+        // patterns exist before dependent tables, but there are no actual FK
+        // constraints — ordering is just for clarity.
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_connector_grants (
         id TEXT PRIMARY KEY,
         agent_id TEXT NOT NULL,
         provider TEXT NOT NULL,
         side TEXT NOT NULL DEFAULT 'owner',
         identity_json TEXT NOT NULL DEFAULT '{}',
+        identity_email TEXT,
         granted_scopes_json TEXT NOT NULL DEFAULT '[]',
         capabilities_json TEXT NOT NULL DEFAULT '[]',
         token_ref TEXT,
-        mode TEXT NOT NULL,
+        mode TEXT NOT NULL DEFAULT 'oauth',
         execution_target TEXT NOT NULL DEFAULT 'local',
         source_of_truth TEXT NOT NULL DEFAULT 'local_storage',
         preferred_by_agent BOOLEAN NOT NULL DEFAULT FALSE,
@@ -1201,84 +808,184 @@ async function runLifeOpsSchemaSetup(runtime, key) {
         last_refresh_at TEXT,
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
-        UNIQUE(agent_id, provider, side, mode)
+        UNIQUE(agent_id, provider, side, mode, identity_email)
       )`);
-            await executeRawSql(runtime, `INSERT INTO life_connector_grants_next (
-        id, agent_id, provider, side, identity_json, granted_scopes_json,
-        capabilities_json, token_ref, mode, execution_target, source_of_truth,
-        preferred_by_agent, cloud_connection_id, metadata_json,
-        last_refresh_at, created_at, updated_at
-      )
-      SELECT
-        id,
-        agent_id,
-        provider,
-        'owner',
-        identity_json,
-        granted_scopes_json,
-        capabilities_json,
-        token_ref,
-        mode,
-        'local',
-        'local_storage',
-        FALSE,
-        NULL,
-        COALESCE(metadata_json, '{}'),
-        last_refresh_at,
-        created_at,
-        updated_at
-      FROM life_connector_grants`);
-            await executeRawSql(runtime, `DROP TABLE life_connector_grants`);
-            await executeRawSql(runtime, `ALTER TABLE life_connector_grants_next RENAME TO life_connector_grants`);
-        });
-    }
-    const connectorGrantColumns = [
-        {
-            name: "side",
-            definition: "TEXT NOT NULL DEFAULT 'owner'",
-        },
-        {
-            name: "execution_target",
-            definition: "TEXT NOT NULL DEFAULT 'local'",
-        },
-        {
-            name: "source_of_truth",
-            definition: "TEXT NOT NULL DEFAULT 'local_storage'",
-        },
-        {
-            name: "preferred_by_agent",
-            definition: "BOOLEAN NOT NULL DEFAULT FALSE",
-        },
-        {
-            name: "cloud_connection_id",
-            definition: "TEXT",
-        },
-    ];
-    const refreshedConnectorGrantColumns = new Set(await listTableColumns(runtime, "life_connector_grants"));
-    for (const column of connectorGrantColumns) {
-        if (refreshedConnectorGrantColumns.has(column.name))
-            continue;
-        await executeRawSql(runtime, `ALTER TABLE life_connector_grants ADD COLUMN ${column.name} ${column.definition}`);
-    }
-    const existingCalendarEventColumns = new Set(await listTableColumns(runtime, "life_calendar_events"));
-    if (existingCalendarEventColumns.size > 0 &&
-        !existingCalendarEventColumns.has("side")) {
-        await runMigrationWithSavepoint(runtime, "migrate_calendar_events", async () => {
-            await executeRawSql(runtime, `DROP TABLE IF EXISTS life_calendar_events_next`);
-            await executeRawSql(runtime, `CREATE TABLE life_calendar_events_next (
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_task_definitions (
         id TEXT PRIMARY KEY,
         agent_id TEXT NOT NULL,
-        provider TEXT NOT NULL,
+        domain TEXT NOT NULL DEFAULT 'user_lifeops',
+        subject_type TEXT NOT NULL DEFAULT 'owner',
+        subject_id TEXT NOT NULL,
+        visibility_scope TEXT NOT NULL DEFAULT 'owner_agent_admin',
+        context_policy TEXT NOT NULL DEFAULT 'explicit_only',
+        kind TEXT NOT NULL,
+        title TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        original_intent TEXT NOT NULL DEFAULT '',
+        timezone TEXT NOT NULL DEFAULT 'UTC',
+        status TEXT NOT NULL DEFAULT 'active',
+        priority INTEGER NOT NULL DEFAULT 3,
+        cadence_json TEXT NOT NULL DEFAULT '{}',
+        window_policy_json TEXT NOT NULL DEFAULT '{}',
+        progression_rule_json TEXT NOT NULL DEFAULT '{}',
+        website_access_json TEXT,
+        reminder_plan_id TEXT,
+        goal_id TEXT,
+        source TEXT NOT NULL DEFAULT 'manual',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_task_occurrences (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        domain TEXT NOT NULL DEFAULT 'user_lifeops',
+        subject_type TEXT NOT NULL DEFAULT 'owner',
+        subject_id TEXT NOT NULL,
+        visibility_scope TEXT NOT NULL DEFAULT 'owner_agent_admin',
+        context_policy TEXT NOT NULL DEFAULT 'explicit_only',
+        definition_id TEXT NOT NULL,
+        occurrence_key TEXT NOT NULL,
+        scheduled_at TEXT,
+        due_at TEXT,
+        relevance_start_at TEXT NOT NULL,
+        relevance_end_at TEXT NOT NULL,
+        window_name TEXT,
+        state TEXT NOT NULL DEFAULT 'pending',
+        snoozed_until TEXT,
+        completion_payload_json TEXT,
+        derived_target_json TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(agent_id, definition_id, occurrence_key)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_goal_definitions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        domain TEXT NOT NULL DEFAULT 'user_lifeops',
+        subject_type TEXT NOT NULL DEFAULT 'owner',
+        subject_id TEXT NOT NULL,
+        visibility_scope TEXT NOT NULL DEFAULT 'owner_agent_admin',
+        context_policy TEXT NOT NULL DEFAULT 'explicit_only',
+        title TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        cadence_json TEXT,
+        support_strategy_json TEXT NOT NULL DEFAULT '{}',
+        success_criteria_json TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'active',
+        review_state TEXT NOT NULL DEFAULT 'pending',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_goal_links (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        goal_id TEXT NOT NULL,
+        linked_type TEXT NOT NULL,
+        linked_id TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        UNIQUE(agent_id, goal_id, linked_type, linked_id)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_reminder_plans (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        owner_type TEXT NOT NULL,
+        owner_id TEXT NOT NULL,
+        steps_json TEXT NOT NULL DEFAULT '[]',
+        mute_policy_json TEXT NOT NULL DEFAULT '{}',
+        quiet_hours_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_reminder_attempts (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        plan_id TEXT NOT NULL,
+        owner_type TEXT NOT NULL,
+        owner_id TEXT NOT NULL,
+        occurrence_id TEXT,
+        channel TEXT NOT NULL,
+        step_index INTEGER NOT NULL DEFAULT 0,
+        scheduled_for TEXT NOT NULL,
+        attempted_at TEXT,
+        outcome TEXT NOT NULL DEFAULT 'pending',
+        connector_ref TEXT,
+        delivery_metadata_json TEXT NOT NULL DEFAULT '{}'
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_audit_events (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        owner_type TEXT NOT NULL,
+        owner_id TEXT NOT NULL,
+        reason TEXT NOT NULL DEFAULT '',
+        inputs_json TEXT NOT NULL DEFAULT '{}',
+        decision_json TEXT NOT NULL DEFAULT '{}',
+        actor TEXT NOT NULL DEFAULT 'agent',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_activity_signals (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        platform TEXT NOT NULL DEFAULT '',
+        state TEXT NOT NULL,
+        observed_at TEXT NOT NULL,
+        idle_state TEXT,
+        idle_time_seconds INTEGER,
+        on_battery BOOLEAN,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_channel_policies (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        channel_type TEXT NOT NULL,
+        channel_ref TEXT NOT NULL,
+        privacy_class TEXT NOT NULL DEFAULT 'private',
+        allow_reminders BOOLEAN NOT NULL DEFAULT TRUE,
+        allow_escalation BOOLEAN NOT NULL DEFAULT FALSE,
+        allow_posts BOOLEAN NOT NULL DEFAULT FALSE,
+        require_confirmation_for_actions BOOLEAN NOT NULL DEFAULT TRUE,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(agent_id, channel_type, channel_ref)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_website_access_grants (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        group_key TEXT NOT NULL,
+        definition_id TEXT NOT NULL,
+        occurrence_id TEXT,
+        websites_json TEXT NOT NULL DEFAULT '[]',
+        unlock_mode TEXT NOT NULL DEFAULT 'fixed_duration',
+        unlock_duration_minutes INTEGER,
+        callback_key TEXT,
+        unlocked_at TEXT NOT NULL,
+        expires_at TEXT,
+        revoked_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_calendar_events (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        provider TEXT NOT NULL DEFAULT 'google',
         side TEXT NOT NULL DEFAULT 'owner',
         calendar_id TEXT NOT NULL,
         external_event_id TEXT NOT NULL,
-        title TEXT NOT NULL,
+        grant_id TEXT,
+        title TEXT NOT NULL DEFAULT '',
         description TEXT NOT NULL DEFAULT '',
         location TEXT NOT NULL DEFAULT '',
-        status TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT '',
         start_at TEXT NOT NULL,
         end_at TEXT NOT NULL,
-        is_all_day BOOLEAN NOT NULL,
+        is_all_day BOOLEAN NOT NULL DEFAULT FALSE,
         timezone TEXT,
         html_link TEXT,
         conference_link TEXT,
@@ -1289,63 +996,27 @@ async function runLifeOpsSchemaSetup(runtime, key) {
         updated_at TEXT NOT NULL,
         UNIQUE(agent_id, provider, side, calendar_id, external_event_id)
       )`);
-            await executeRawSql(runtime, `INSERT INTO life_calendar_events_next (
-        id, agent_id, provider, side, calendar_id, external_event_id, title,
-        description, location, status, start_at, end_at, is_all_day, timezone,
-        html_link, conference_link, organizer_json, attendees_json,
-        metadata_json, synced_at, updated_at
-      )
-      SELECT
-        id, agent_id, provider, 'owner', calendar_id, external_event_id, title,
-        description, location, status, start_at, end_at, is_all_day, timezone,
-        html_link, conference_link, organizer_json, attendees_json,
-        COALESCE(metadata_json, '{}'), synced_at, updated_at
-      FROM life_calendar_events`);
-            await executeRawSql(runtime, `DROP TABLE life_calendar_events`);
-            await executeRawSql(runtime, `ALTER TABLE life_calendar_events_next RENAME TO life_calendar_events`);
-        });
-    }
-    const existingCalendarSyncStateColumns = new Set(await listTableColumns(runtime, "life_calendar_sync_states"));
-    if (existingCalendarSyncStateColumns.size > 0 &&
-        !existingCalendarSyncStateColumns.has("side")) {
-        await runMigrationWithSavepoint(runtime, "migrate_calendar_sync_states", async () => {
-            await executeRawSql(runtime, `DROP TABLE IF EXISTS life_calendar_sync_states_next`);
-            await executeRawSql(runtime, `CREATE TABLE life_calendar_sync_states_next (
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_calendar_sync_states (
         id TEXT PRIMARY KEY,
         agent_id TEXT NOT NULL,
-        provider TEXT NOT NULL,
+        provider TEXT NOT NULL DEFAULT 'google',
         side TEXT NOT NULL DEFAULT 'owner',
         calendar_id TEXT NOT NULL,
+        grant_id TEXT,
         window_start_at TEXT NOT NULL,
         window_end_at TEXT NOT NULL,
         synced_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
         UNIQUE(agent_id, provider, side, calendar_id)
       )`);
-            await executeRawSql(runtime, `INSERT INTO life_calendar_sync_states_next (
-        id, agent_id, provider, side, calendar_id, window_start_at,
-        window_end_at, synced_at, updated_at
-      )
-      SELECT
-        id, agent_id, provider, 'owner', calendar_id, window_start_at,
-        window_end_at, synced_at, updated_at
-      FROM life_calendar_sync_states`);
-            await executeRawSql(runtime, `DROP TABLE life_calendar_sync_states`);
-            await executeRawSql(runtime, `ALTER TABLE life_calendar_sync_states_next RENAME TO life_calendar_sync_states`);
-        });
-    }
-    const existingGmailMessageColumns = new Set(await listTableColumns(runtime, "life_gmail_messages"));
-    if (existingGmailMessageColumns.size > 0 &&
-        !existingGmailMessageColumns.has("side")) {
-        await runMigrationWithSavepoint(runtime, "migrate_gmail_messages", async () => {
-            await executeRawSql(runtime, `DROP TABLE IF EXISTS life_gmail_messages_next`);
-            await executeRawSql(runtime, `CREATE TABLE life_gmail_messages_next (
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_gmail_messages (
         id TEXT PRIMARY KEY,
         agent_id TEXT NOT NULL,
-        provider TEXT NOT NULL,
+        provider TEXT NOT NULL DEFAULT 'google',
         side TEXT NOT NULL DEFAULT 'owner',
         external_message_id TEXT NOT NULL,
-        thread_id TEXT NOT NULL,
+        grant_id TEXT,
+        thread_id TEXT NOT NULL DEFAULT '',
         subject TEXT NOT NULL DEFAULT '',
         from_display TEXT NOT NULL DEFAULT '',
         from_email TEXT,
@@ -1354,7 +1025,7 @@ async function runLifeOpsSchemaSetup(runtime, key) {
         cc_json TEXT NOT NULL DEFAULT '[]',
         snippet TEXT NOT NULL DEFAULT '',
         received_at TEXT NOT NULL,
-        is_unread BOOLEAN NOT NULL DEFAULT FALSE,
+        is_unread BOOLEAN NOT NULL DEFAULT TRUE,
         is_important BOOLEAN NOT NULL DEFAULT FALSE,
         likely_reply_needed BOOLEAN NOT NULL DEFAULT FALSE,
         triage_score INTEGER NOT NULL DEFAULT 0,
@@ -1366,134 +1037,382 @@ async function runLifeOpsSchemaSetup(runtime, key) {
         updated_at TEXT NOT NULL,
         UNIQUE(agent_id, provider, side, external_message_id)
       )`);
-            await executeRawSql(runtime, `INSERT INTO life_gmail_messages_next (
-        id, agent_id, provider, side, external_message_id, thread_id, subject,
-        from_display, from_email, reply_to, to_json, cc_json, snippet,
-        received_at, is_unread, is_important, likely_reply_needed,
-        triage_score, triage_reason, label_ids_json, html_link, metadata_json,
-        synced_at, updated_at
-      )
-      SELECT
-        id, agent_id, provider, 'owner', external_message_id, thread_id,
-        subject, from_display, from_email, reply_to, to_json, cc_json,
-        snippet, received_at, is_unread, is_important, likely_reply_needed,
-        triage_score, triage_reason, label_ids_json, html_link,
-        COALESCE(metadata_json, '{}'), synced_at, updated_at
-      FROM life_gmail_messages`);
-            await executeRawSql(runtime, `DROP TABLE life_gmail_messages`);
-            await executeRawSql(runtime, `ALTER TABLE life_gmail_messages_next RENAME TO life_gmail_messages`);
-        });
-    }
-    const existingGmailSyncStateColumns = new Set(await listTableColumns(runtime, "life_gmail_sync_states"));
-    if (existingGmailSyncStateColumns.size > 0 &&
-        !existingGmailSyncStateColumns.has("side")) {
-        await runMigrationWithSavepoint(runtime, "migrate_gmail_sync_states", async () => {
-            await executeRawSql(runtime, `DROP TABLE IF EXISTS life_gmail_sync_states_next`);
-            await executeRawSql(runtime, `CREATE TABLE life_gmail_sync_states_next (
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_gmail_sync_states (
         id TEXT PRIMARY KEY,
         agent_id TEXT NOT NULL,
-        provider TEXT NOT NULL,
+        provider TEXT NOT NULL DEFAULT 'google',
         side TEXT NOT NULL DEFAULT 'owner',
         mailbox TEXT NOT NULL,
+        grant_id TEXT,
         max_results INTEGER NOT NULL DEFAULT 0,
         synced_at TEXT NOT NULL,
         updated_at TEXT NOT NULL,
         UNIQUE(agent_id, provider, side, mailbox)
       )`);
-            await executeRawSql(runtime, `INSERT INTO life_gmail_sync_states_next (
-        id, agent_id, provider, side, mailbox, max_results, synced_at, updated_at
-      )
-      SELECT
-        id, agent_id, provider, 'owner', mailbox, max_results, synced_at,
-        updated_at
-      FROM life_gmail_sync_states`);
-            await executeRawSql(runtime, `DROP TABLE life_gmail_sync_states`);
-            await executeRawSql(runtime, `ALTER TABLE life_gmail_sync_states_next RENAME TO life_gmail_sync_states`);
-        });
-    }
-    const postMigrationIndexStatements = [
-        `CREATE INDEX IF NOT EXISTS idx_life_task_definitions_agent_status
-      ON life_task_definitions(agent_id, status)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_task_definitions_subject
-      ON life_task_definitions(agent_id, domain, subject_type, subject_id, status)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_task_occurrences_agent_state_start
-      ON life_task_occurrences(agent_id, state, relevance_start_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_task_occurrences_subject
-      ON life_task_occurrences(agent_id, domain, subject_type, subject_id, state, relevance_start_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_task_occurrences_definition
-      ON life_task_occurrences(definition_id, relevance_start_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_goal_definitions_agent_status
-      ON life_goal_definitions(agent_id, status)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_goal_definitions_subject
-      ON life_goal_definitions(agent_id, domain, subject_type, subject_id, status)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_reminder_plans_owner
-      ON life_reminder_plans(agent_id, owner_type, owner_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_audit_events_owner
-      ON life_audit_events(agent_id, owner_type, owner_id, created_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_activity_signals_agent
-      ON life_activity_signals(agent_id, observed_at DESC)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_workflow_definitions_agent
-      ON life_workflow_definitions(agent_id, status, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_workflow_definitions_subject
-      ON life_workflow_definitions(agent_id, domain, subject_type, subject_id, status, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_workflow_runs_workflow
-      ON life_workflow_runs(agent_id, workflow_id, started_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_browser_sessions_agent
-      ON life_browser_sessions(agent_id, status, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_browser_sessions_subject
-      ON life_browser_sessions(agent_id, domain, subject_type, subject_id, status, updated_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_goal_links_goal
-      ON life_goal_links(goal_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_goal_links_linked
-      ON life_goal_links(linked_type, linked_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_reminder_attempts_plan
-      ON life_reminder_attempts(plan_id, owner_type, owner_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_channel_policies_agent
-      ON life_channel_policies(agent_id, channel_type)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_website_access_grants_group
-      ON life_website_access_grants(agent_id, group_key, revoked_at, expires_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_calendar_events_agent
-      ON life_calendar_events(agent_id, provider, side)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_calendar_events_window
-      ON life_calendar_events(agent_id, provider, side, start_at, end_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_calendar_sync_states_agent
-      ON life_calendar_sync_states(agent_id, provider, side, calendar_id)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_gmail_messages_agent
-      ON life_gmail_messages(agent_id, provider, side, triage_score DESC)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_gmail_messages_priority
-      ON life_gmail_messages(agent_id, provider, side, triage_score, received_at)`,
-        `CREATE INDEX IF NOT EXISTS idx_life_gmail_sync_states_agent
-      ON life_gmail_sync_states(agent_id, provider, side, mailbox)`,
-    ];
-    for (const statement of postMigrationIndexStatements) {
-        await executeRawSql(runtime, statement);
-    }
-    schemaReady.add(key);
-}
-async function runLifeOpsSchemaSetupWithRetry(runtime, key) {
-    for (let attempt = 1; attempt <= 2; attempt += 1) {
-        try {
-            await runLifeOpsSchemaSetup(runtime, key);
-            return;
-        }
-        catch (error) {
-            if (attempt >= 2 || !isRetryableLifeOpsStorageError(error)) {
-                throw error;
-            }
-            await new Promise((resolve) => setTimeout(resolve, LIFEOPS_SCHEMA_RETRY_DELAY_MS));
-        }
-    }
-}
-export class LifeOpsRepository {
-    runtime;
-    constructor(runtime) {
-        this.runtime = runtime;
-    }
-    async ensureReady() {
-        await ensureLifeOpsTables(this.runtime);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_workflow_definitions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        domain TEXT NOT NULL DEFAULT 'user_lifeops',
+        subject_type TEXT NOT NULL DEFAULT 'owner',
+        subject_id TEXT NOT NULL,
+        visibility_scope TEXT NOT NULL DEFAULT 'owner_agent_admin',
+        context_policy TEXT NOT NULL DEFAULT 'explicit_only',
+        title TEXT NOT NULL,
+        trigger_type TEXT NOT NULL,
+        schedule_json TEXT NOT NULL DEFAULT '{}',
+        action_plan_json TEXT NOT NULL DEFAULT '{}',
+        permission_policy_json TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'active',
+        created_by TEXT NOT NULL DEFAULT 'agent',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_workflow_runs (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        workflow_id TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        finished_at TEXT,
+        status TEXT NOT NULL DEFAULT 'running',
+        result_json TEXT NOT NULL DEFAULT '{}',
+        audit_ref TEXT
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_browser_companions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        browser TEXT NOT NULL,
+        profile_id TEXT NOT NULL,
+        profile_label TEXT NOT NULL DEFAULT '',
+        label TEXT NOT NULL DEFAULT '',
+        extension_version TEXT,
+        connection_state TEXT NOT NULL DEFAULT 'disconnected',
+        permissions_json TEXT NOT NULL DEFAULT '{}',
+        pairing_token_hash TEXT,
+        pending_pairing_token_hashes_json TEXT NOT NULL DEFAULT '[]',
+        last_seen_at TEXT,
+        paired_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(agent_id, browser, profile_id)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_browser_settings (
+        agent_id TEXT PRIMARY KEY,
+        enabled BOOLEAN NOT NULL DEFAULT FALSE,
+        tracking_mode TEXT NOT NULL DEFAULT 'current_tab',
+        allow_browser_control BOOLEAN NOT NULL DEFAULT FALSE,
+        require_confirmation_for_account_affecting BOOLEAN NOT NULL DEFAULT TRUE,
+        incognito_enabled BOOLEAN NOT NULL DEFAULT FALSE,
+        site_access_mode TEXT NOT NULL DEFAULT 'current_site_only',
+        granted_origins_json TEXT NOT NULL DEFAULT '[]',
+        blocked_origins_json TEXT NOT NULL DEFAULT '[]',
+        max_remembered_tabs INTEGER NOT NULL DEFAULT 10,
+        pause_until TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_browser_sessions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        domain TEXT NOT NULL DEFAULT 'user_lifeops',
+        subject_type TEXT NOT NULL DEFAULT 'owner',
+        subject_id TEXT NOT NULL,
+        visibility_scope TEXT NOT NULL DEFAULT 'owner_agent_admin',
+        context_policy TEXT NOT NULL DEFAULT 'explicit_only',
+        workflow_id TEXT,
+        browser TEXT,
+        companion_id TEXT,
+        profile_id TEXT,
+        window_id TEXT,
+        tab_id TEXT,
+        title TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        actions_json TEXT NOT NULL DEFAULT '[]',
+        current_action_index INTEGER NOT NULL DEFAULT 0,
+        awaiting_confirmation_for_action_id TEXT,
+        result_json TEXT NOT NULL DEFAULT '{}',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        finished_at TEXT
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_browser_tabs (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        companion_id TEXT,
+        browser TEXT NOT NULL,
+        profile_id TEXT NOT NULL,
+        window_id TEXT NOT NULL,
+        tab_id TEXT NOT NULL,
+        url TEXT NOT NULL DEFAULT '',
+        title TEXT NOT NULL DEFAULT '',
+        active_in_window BOOLEAN NOT NULL DEFAULT FALSE,
+        focused_window BOOLEAN NOT NULL DEFAULT FALSE,
+        focused_active BOOLEAN NOT NULL DEFAULT FALSE,
+        incognito BOOLEAN NOT NULL DEFAULT FALSE,
+        favicon_url TEXT,
+        last_seen_at TEXT NOT NULL,
+        last_focused_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(agent_id, browser, profile_id, window_id, tab_id)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_browser_page_contexts (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        browser TEXT NOT NULL,
+        profile_id TEXT NOT NULL,
+        window_id TEXT NOT NULL,
+        tab_id TEXT NOT NULL,
+        url TEXT NOT NULL DEFAULT '',
+        title TEXT NOT NULL DEFAULT '',
+        selection_text TEXT,
+        main_text TEXT,
+        headings_json TEXT NOT NULL DEFAULT '[]',
+        links_json TEXT NOT NULL DEFAULT '[]',
+        forms_json TEXT NOT NULL DEFAULT '[]',
+        captured_at TEXT NOT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        UNIQUE(agent_id, browser, profile_id, window_id, tab_id)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_escalation_states (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        reason TEXT NOT NULL DEFAULT '',
+        text TEXT NOT NULL DEFAULT '',
+        current_step INTEGER NOT NULL DEFAULT 0,
+        channels_sent_json TEXT NOT NULL DEFAULT '[]',
+        started_at TEXT NOT NULL,
+        last_sent_at TEXT NOT NULL,
+        resolved BOOLEAN NOT NULL DEFAULT FALSE,
+        resolved_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_relationships (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        primary_channel TEXT NOT NULL,
+        primary_handle TEXT NOT NULL,
+        email TEXT,
+        phone TEXT,
+        notes TEXT NOT NULL DEFAULT '',
+        tags_json TEXT NOT NULL DEFAULT '[]',
+        relationship_type TEXT NOT NULL DEFAULT '',
+        last_contacted_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_relationship_interactions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        relationship_id TEXT NOT NULL,
+        channel TEXT NOT NULL,
+        direction TEXT NOT NULL,
+        summary TEXT NOT NULL DEFAULT '',
+        occurred_at TEXT NOT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_follow_ups (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        relationship_id TEXT NOT NULL,
+        due_at TEXT NOT NULL,
+        reason TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        priority INTEGER NOT NULL DEFAULT 3,
+        draft_json TEXT,
+        completed_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_inbox_triage_entries (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        source_room_id TEXT,
+        source_entity_id TEXT,
+        source_message_id TEXT,
+        channel_name TEXT NOT NULL,
+        channel_type TEXT NOT NULL,
+        deep_link TEXT,
+        classification TEXT NOT NULL,
+        urgency TEXT NOT NULL DEFAULT 'low',
+        confidence REAL NOT NULL DEFAULT 0.5,
+        snippet TEXT NOT NULL DEFAULT '',
+        sender_name TEXT,
+        thread_context TEXT,
+        triage_reasoning TEXT,
+        suggested_response TEXT,
+        draft_response TEXT,
+        auto_replied BOOLEAN NOT NULL DEFAULT FALSE,
+        resolved BOOLEAN NOT NULL DEFAULT FALSE,
+        resolved_at TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE INDEX IF NOT EXISTS idx_life_inbox_triage_entries_agent_created
+       ON life_inbox_triage_entries(agent_id, created_at DESC)`);
+        await executeRawSql(runtime, `CREATE INDEX IF NOT EXISTS idx_life_inbox_triage_entries_agent_source_message
+       ON life_inbox_triage_entries(agent_id, source_message_id)`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_inbox_triage_examples (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        snippet TEXT NOT NULL DEFAULT '',
+        classification TEXT NOT NULL,
+        owner_action TEXT NOT NULL,
+        owner_classification TEXT,
+        context_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE INDEX IF NOT EXISTS idx_life_inbox_triage_examples_agent_created
+       ON life_inbox_triage_examples(agent_id, created_at DESC)`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_x_dms (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        external_dm_id TEXT NOT NULL,
+        conversation_id TEXT NOT NULL DEFAULT '',
+        sender_handle TEXT NOT NULL DEFAULT '',
+        sender_id TEXT NOT NULL DEFAULT '',
+        is_inbound BOOLEAN NOT NULL DEFAULT TRUE,
+        text TEXT NOT NULL DEFAULT '',
+        received_at TEXT NOT NULL,
+        read_at TEXT,
+        replied_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        synced_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(agent_id, external_dm_id)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_x_feed_items (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        external_tweet_id TEXT NOT NULL,
+        author_handle TEXT NOT NULL DEFAULT '',
+        author_id TEXT NOT NULL DEFAULT '',
+        text TEXT NOT NULL DEFAULT '',
+        created_at_source TEXT NOT NULL,
+        feed_type TEXT NOT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        synced_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(agent_id, external_tweet_id, feed_type)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_x_sync_states (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        feed_type TEXT NOT NULL,
+        last_cursor TEXT,
+        synced_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(agent_id, feed_type)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_screen_time_sessions (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        identifier TEXT NOT NULL,
+        display_name TEXT NOT NULL DEFAULT '',
+        start_at TEXT NOT NULL,
+        end_at TEXT,
+        duration_seconds INTEGER NOT NULL DEFAULT 0,
+        is_active BOOLEAN NOT NULL DEFAULT FALSE,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_screen_time_daily (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        identifier TEXT NOT NULL,
+        date TEXT NOT NULL,
+        total_seconds INTEGER NOT NULL DEFAULT 0,
+        session_count INTEGER NOT NULL DEFAULT 0,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        UNIQUE(agent_id, source, identifier, date)
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_scheduling_negotiations (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        subject TEXT NOT NULL DEFAULT '',
+        relationship_id TEXT,
+        duration_minutes INTEGER NOT NULL DEFAULT 0,
+        timezone TEXT NOT NULL DEFAULT 'UTC',
+        state TEXT NOT NULL DEFAULT 'initiated',
+        accepted_proposal_id TEXT,
+        started_at TEXT NOT NULL,
+        finalized_at TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_scheduling_proposals (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        negotiation_id TEXT NOT NULL,
+        start_at TEXT NOT NULL,
+        end_at TEXT NOT NULL,
+        proposed_by TEXT NOT NULL DEFAULT 'agent',
+        status TEXT NOT NULL DEFAULT 'pending',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_dossiers (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        calendar_event_id TEXT,
+        subject TEXT NOT NULL DEFAULT '',
+        generated_for_at TEXT NOT NULL,
+        content_md TEXT NOT NULL DEFAULT '',
+        sources_json TEXT NOT NULL DEFAULT '[]',
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )`);
+        // T8d — Activity tracker events (append-only). Plan §6.12.
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_activity_events (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        observed_at TEXT NOT NULL,
+        event_kind TEXT NOT NULL,
+        bundle_id TEXT NOT NULL,
+        app_name TEXT NOT NULL,
+        window_title TEXT,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      )`);
+        // T7g — Website blocker chat integration block rules. Plan §6.8.
+        await executeRawSql(runtime, `CREATE TABLE IF NOT EXISTS life_block_rules (
+        id UUID PRIMARY KEY,
+        agent_id UUID NOT NULL,
+        profile TEXT NOT NULL,
+        websites JSONB NOT NULL,
+        gate_type TEXT NOT NULL,
+        gate_todo_id TEXT,
+        gate_until_ms BIGINT,
+        fixed_duration_ms BIGINT,
+        unlock_duration_ms BIGINT,
+        active BOOLEAN DEFAULT TRUE,
+        created_at BIGINT NOT NULL,
+        released_at BIGINT,
+        released_reason TEXT
+      )`);
+        await executeRawSql(runtime, `CREATE INDEX IF NOT EXISTS idx_block_rules_active_gate ON life_block_rules(active, gate_type) WHERE active = TRUE`);
     }
     async createDefinition(definition) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_task_definitions (
         id, agent_id, domain, subject_type, subject_id, visibility_scope,
         context_policy, kind, title, description, original_intent, timezone,
@@ -1530,7 +1449,6 @@ export class LifeOpsRepository {
       )`);
     }
     async updateDefinition(definition) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_task_definitions
          SET domain = ${sqlQuote(definition.domain)},
              subject_type = ${sqlQuote(definition.subjectType)},
@@ -1558,7 +1476,6 @@ export class LifeOpsRepository {
          AND agent_id = ${sqlQuote(definition.agentId)}`);
     }
     async getDefinition(agentId, definitionId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_task_definitions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1568,7 +1485,6 @@ export class LifeOpsRepository {
         return row ? parseTaskDefinition(row) : null;
     }
     async listDefinitions(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_task_definitions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1576,7 +1492,6 @@ export class LifeOpsRepository {
         return rows.map(parseTaskDefinition);
     }
     async listActiveDefinitions(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_task_definitions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1585,7 +1500,6 @@ export class LifeOpsRepository {
         return rows.map(parseTaskDefinition);
     }
     async deleteDefinition(agentId, definitionId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_reminder_plans
         WHERE agent_id = ${sqlQuote(agentId)}
           AND owner_type = 'definition'
@@ -1602,7 +1516,6 @@ export class LifeOpsRepository {
           AND id = ${sqlQuote(definitionId)}`);
     }
     async upsertOccurrence(occurrence) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_task_occurrences (
         id, agent_id, domain, subject_type, subject_id, visibility_scope,
         context_policy, definition_id, occurrence_key, scheduled_at, due_at,
@@ -1651,7 +1564,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async listOccurrencesForDefinition(agentId, definitionId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_task_occurrences
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1660,7 +1572,6 @@ export class LifeOpsRepository {
         return rows.map(parseOccurrence);
     }
     async listOccurrencesForDefinitions(agentId, definitionIds) {
-        await this.ensureReady();
         if (definitionIds.length === 0) {
             return [];
         }
@@ -1675,7 +1586,6 @@ export class LifeOpsRepository {
         return rows.map(parseOccurrence);
     }
     async getOccurrence(agentId, occurrenceId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_task_occurrences
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1685,7 +1595,6 @@ export class LifeOpsRepository {
         return row ? parseOccurrence(row) : null;
     }
     async getOccurrenceView(agentId, occurrenceId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT occurrence.*,
               definition.kind AS definition_kind,
               definition.status AS definition_status,
@@ -1707,7 +1616,6 @@ export class LifeOpsRepository {
         return row ? parseOccurrenceView(row) : null;
     }
     async listOccurrenceViewsForOverview(agentId, horizonIso) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT occurrence.*,
               definition.kind AS definition_kind,
               definition.status AS definition_status,
@@ -1735,7 +1643,6 @@ export class LifeOpsRepository {
         return rows.map(parseOccurrenceView);
     }
     async updateOccurrence(occurrence) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_task_occurrences
           SET domain = ${sqlQuote(occurrence.domain)},
               subject_type = ${sqlQuote(occurrence.subjectType)},
@@ -1757,7 +1664,6 @@ export class LifeOpsRepository {
           AND agent_id = ${sqlQuote(occurrence.agentId)}`);
     }
     async pruneNonTerminalOccurrences(agentId, definitionId, keepOccurrenceKeys) {
-        await this.ensureReady();
         const keepClause = keepOccurrenceKeys.length > 0
             ? `AND occurrence_key NOT IN (${keepOccurrenceKeys
                 .map((occurrenceKey) => sqlQuote(occurrenceKey))
@@ -1770,7 +1676,6 @@ export class LifeOpsRepository {
           ${keepClause}`);
     }
     async createGoal(goal) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_goal_definitions (
         id, agent_id, domain, subject_type, subject_id, visibility_scope,
         context_policy, title, description, cadence_json, support_strategy_json,
@@ -1797,7 +1702,6 @@ export class LifeOpsRepository {
       )`);
     }
     async updateGoal(goal) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_goal_definitions
           SET domain = ${sqlQuote(goal.domain)},
               subject_type = ${sqlQuote(goal.subjectType)},
@@ -1817,7 +1721,6 @@ export class LifeOpsRepository {
           AND agent_id = ${sqlQuote(goal.agentId)}`);
     }
     async getGoal(agentId, goalId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_goal_definitions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1827,7 +1730,6 @@ export class LifeOpsRepository {
         return row ? parseGoal(row) : null;
     }
     async listGoals(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_goal_definitions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1835,7 +1737,6 @@ export class LifeOpsRepository {
         return rows.map(parseGoal);
     }
     async deleteGoal(agentId, goalId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_goal_links
         WHERE agent_id = ${sqlQuote(agentId)}
           AND goal_id = ${sqlQuote(goalId)}`);
@@ -1848,7 +1749,6 @@ export class LifeOpsRepository {
           AND id = ${sqlQuote(goalId)}`);
     }
     async upsertGoalLink(link) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_goal_links (
         id, agent_id, goal_id, linked_type, linked_id, created_at
       ) VALUES (
@@ -1862,14 +1762,12 @@ export class LifeOpsRepository {
       ON CONFLICT(agent_id, goal_id, linked_type, linked_id) DO NOTHING`);
     }
     async deleteGoalLinksForLinked(agentId, linkedType, linkedId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_goal_links
         WHERE agent_id = ${sqlQuote(agentId)}
           AND linked_type = ${sqlQuote(linkedType)}
           AND linked_id = ${sqlQuote(linkedId)}`);
     }
     async listGoalLinksForGoal(agentId, goalId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_goal_links
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1878,7 +1776,6 @@ export class LifeOpsRepository {
         return rows.map(parseGoalLink);
     }
     async createReminderPlan(plan) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_reminder_plans (
         id, agent_id, owner_type, owner_id, steps_json,
         mute_policy_json, quiet_hours_json, created_at, updated_at
@@ -1895,7 +1792,6 @@ export class LifeOpsRepository {
       )`);
     }
     async updateReminderPlan(plan) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_reminder_plans
           SET steps_json = ${sqlJson(plan.steps)},
               mute_policy_json = ${sqlJson(plan.mutePolicy)},
@@ -1905,13 +1801,11 @@ export class LifeOpsRepository {
           AND agent_id = ${sqlQuote(plan.agentId)}`);
     }
     async deleteReminderPlan(agentId, planId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_reminder_plans
         WHERE agent_id = ${sqlQuote(agentId)}
           AND id = ${sqlQuote(planId)}`);
     }
     async getReminderPlan(agentId, planId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_reminder_plans
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1921,7 +1815,6 @@ export class LifeOpsRepository {
         return row ? parseReminderPlan(row) : null;
     }
     async listReminderPlansForOwners(agentId, ownerType, ownerIds) {
-        await this.ensureReady();
         if (ownerIds.length === 0)
             return [];
         const ownerList = ownerIds.map((ownerId) => sqlQuote(ownerId)).join(", ");
@@ -1933,7 +1826,6 @@ export class LifeOpsRepository {
         return rows.map(parseReminderPlan);
     }
     async createAuditEvent(event) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_audit_events (
         id, agent_id, event_type, owner_type, owner_id, reason,
         inputs_json, decision_json, actor, created_at
@@ -1951,7 +1843,6 @@ export class LifeOpsRepository {
       )`);
     }
     async listAuditEvents(agentId, ownerType, ownerId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_audit_events
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -1961,7 +1852,6 @@ export class LifeOpsRepository {
         return rows.map(parseAuditEvent);
     }
     async createActivitySignal(signal) {
-        await this.ensureReady();
         const metadata = signal.health !== null && signal.health !== undefined
             ? { ...signal.metadata, health: signal.health }
             : signal.metadata;
@@ -1983,7 +1873,6 @@ export class LifeOpsRepository {
       )`);
     }
     async listActivitySignals(agentId, args = {}) {
-        await this.ensureReady();
         const clauses = [`agent_id = ${sqlQuote(agentId)}`];
         if (args.sinceAt) {
             clauses.push(`observed_at >= ${sqlQuote(args.sinceAt)}`);
@@ -2003,7 +1892,6 @@ export class LifeOpsRepository {
         return rows.map(parseActivitySignal);
     }
     async upsertChannelPolicy(policy) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_channel_policies (
         id, agent_id, channel_type, channel_ref, privacy_class,
         allow_reminders, allow_escalation, allow_posts,
@@ -2032,7 +1920,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async listChannelPolicies(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_channel_policies
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2040,7 +1927,6 @@ export class LifeOpsRepository {
         return rows.map(parseChannelPolicy);
     }
     async getChannelPolicy(agentId, channelType, channelRef) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_channel_policies
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2051,7 +1937,6 @@ export class LifeOpsRepository {
         return row ? parseChannelPolicy(row) : null;
     }
     async upsertWebsiteAccessGrant(grant) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_website_access_grants (
         id, agent_id, group_key, definition_id, occurrence_id, websites_json,
         unlock_mode, unlock_duration_minutes, callback_key, unlocked_at,
@@ -2075,7 +1960,6 @@ export class LifeOpsRepository {
       )`);
     }
     async listWebsiteAccessGrants(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_website_access_grants
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2083,7 +1967,6 @@ export class LifeOpsRepository {
         return rows.map(parseWebsiteAccessGrant);
     }
     async revokeWebsiteAccessGrants(agentId, args) {
-        await this.ensureReady();
         const clauses = [`agent_id = ${sqlQuote(agentId)}`, "revoked_at IS NULL"];
         if (args.groupKey) {
             clauses.push(`group_key = ${sqlQuote(args.groupKey)}`);
@@ -2097,9 +1980,10 @@ export class LifeOpsRepository {
         WHERE ${clauses.join("\n          AND ")}`);
     }
     async upsertConnectorGrant(grant) {
-        await this.ensureReady();
+        const identityEmail = deriveConnectorIdentityEmail(grant.identity);
         await executeRawSql(this.runtime, `INSERT INTO life_connector_grants (
-        id, agent_id, provider, side, identity_json, granted_scopes_json,
+        id, agent_id, provider, side, identity_json, identity_email,
+        granted_scopes_json,
         capabilities_json, token_ref, mode, execution_target, source_of_truth,
         preferred_by_agent, cloud_connection_id, metadata_json,
         last_refresh_at, created_at, updated_at
@@ -2109,6 +1993,7 @@ export class LifeOpsRepository {
         ${sqlQuote(grant.provider)},
         ${sqlQuote(grant.side)},
         ${sqlJson(grant.identity)},
+        ${sqlText(identityEmail)},
         ${sqlJson(grant.grantedScopes)},
         ${sqlJson(grant.capabilities)},
         ${sqlText(grant.tokenRef)},
@@ -2122,8 +2007,9 @@ export class LifeOpsRepository {
         ${sqlQuote(grant.createdAt)},
         ${sqlQuote(grant.updatedAt)}
       )
-      ON CONFLICT(agent_id, provider, side, mode) DO UPDATE SET
+      ON CONFLICT(agent_id, provider, side, mode, identity_email) DO UPDATE SET
         identity_json = excluded.identity_json,
+        identity_email = excluded.identity_email,
         granted_scopes_json = excluded.granted_scopes_json,
         capabilities_json = excluded.capabilities_json,
         token_ref = excluded.token_ref,
@@ -2136,7 +2022,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async listConnectorGrants(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_connector_grants
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2144,7 +2029,6 @@ export class LifeOpsRepository {
         return rows.map(parseConnectorGrant);
     }
     async getConnectorGrant(agentId, provider, mode, side = "owner") {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
         FROM life_connector_grants
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2156,7 +2040,6 @@ export class LifeOpsRepository {
         return row ? parseConnectorGrant(row) : null;
     }
     async deleteConnectorGrant(agentId, provider, mode, side) {
-        await this.ensureReady();
         const modeClause = mode ? `AND mode = ${sqlQuote(mode)}` : "";
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_connector_grants
@@ -2166,7 +2049,6 @@ export class LifeOpsRepository {
           ${sideClause}`);
     }
     async upsertCalendarEvent(event, side = event.side) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_calendar_events (
         id, agent_id, provider, side, calendar_id, external_event_id, title,
         description, location, status, start_at, end_at, is_all_day,
@@ -2213,7 +2095,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async deleteCalendarEventsForProvider(agentId, provider, calendarId, side) {
-        await this.ensureReady();
         const calendarClause = calendarId
             ? `AND calendar_id = ${sqlQuote(calendarId)}`
             : "";
@@ -2225,7 +2106,6 @@ export class LifeOpsRepository {
           ${sideClause}`);
     }
     async deleteCalendarEventByExternalId(agentId, provider, calendarId, externalEventId, side) {
-        await this.ensureReady();
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_calendar_events
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2235,7 +2115,6 @@ export class LifeOpsRepository {
           ${sideClause}`);
     }
     async pruneCalendarEventsInWindow(agentId, provider, calendarId, timeMin, timeMax, keepExternalIds, side = "owner") {
-        await this.ensureReady();
         const keepClause = keepExternalIds.length > 0
             ? `AND external_event_id NOT IN (${keepExternalIds
                 .map((externalId) => sqlQuote(externalId))
@@ -2251,7 +2130,6 @@ export class LifeOpsRepository {
           ${keepClause}`);
     }
     async listCalendarEvents(agentId, provider, timeMin, timeMax, side) {
-        await this.ensureReady();
         const timeMinClause = timeMin ? `AND end_at > ${sqlQuote(timeMin)}` : "";
         const timeMaxClause = timeMax ? `AND start_at < ${sqlQuote(timeMax)}` : "";
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
@@ -2266,7 +2144,6 @@ export class LifeOpsRepository {
         return rows.map(parseCalendarEvent);
     }
     async upsertCalendarSyncState(state) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_calendar_sync_states (
         id, agent_id, provider, side, calendar_id, window_start_at,
         window_end_at, synced_at, updated_at
@@ -2288,7 +2165,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async getCalendarSyncState(agentId, provider, calendarId, side) {
-        await this.ensureReady();
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_calendar_sync_states
@@ -2301,7 +2177,6 @@ export class LifeOpsRepository {
         return row ? parseCalendarSyncState(row) : null;
     }
     async deleteCalendarSyncState(agentId, provider, calendarId, side) {
-        await this.ensureReady();
         const calendarClause = calendarId
             ? `AND calendar_id = ${sqlQuote(calendarId)}`
             : "";
@@ -2313,7 +2188,6 @@ export class LifeOpsRepository {
           ${sideClause}`);
     }
     async upsertGmailMessage(message, side = message.side) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_gmail_messages (
         id, agent_id, provider, side, external_message_id, thread_id, subject,
         from_display, from_email, reply_to, to_json, cc_json, snippet,
@@ -2368,7 +2242,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async pruneGmailMessages(agentId, provider, keepExternalIds, side) {
-        await this.ensureReady();
         const keepClause = keepExternalIds.length > 0
             ? `AND external_message_id NOT IN (${keepExternalIds
                 .map((externalId) => sqlQuote(externalId))
@@ -2382,7 +2255,6 @@ export class LifeOpsRepository {
           ${keepClause}`);
     }
     async listGmailMessages(agentId, provider, options, side) {
-        await this.ensureReady();
         const DEFAULT_GMAIL_LIST_LIMIT = 200;
         const limit = options?.maxResults !== undefined && Number.isFinite(options.maxResults)
             ? options.maxResults
@@ -2407,7 +2279,6 @@ export class LifeOpsRepository {
         return rows.map(parseGmailMessageSummary);
     }
     async getGmailMessage(agentId, provider, messageId, side) {
-        await this.ensureReady();
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_gmail_messages
@@ -2420,7 +2291,6 @@ export class LifeOpsRepository {
         return row ? parseGmailMessageSummary(row) : null;
     }
     async deleteGmailMessagesForProvider(agentId, provider, side) {
-        await this.ensureReady();
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_gmail_messages
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2428,7 +2298,6 @@ export class LifeOpsRepository {
           ${sideClause}`);
     }
     async upsertGmailSyncState(state) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_gmail_sync_states (
         id, agent_id, provider, side, mailbox, max_results, synced_at, updated_at
       ) VALUES (
@@ -2447,7 +2316,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async getGmailSyncState(agentId, provider, mailbox, side) {
-        await this.ensureReady();
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_gmail_sync_states
@@ -2460,7 +2328,6 @@ export class LifeOpsRepository {
         return row ? parseGmailSyncState(row) : null;
     }
     async deleteGmailSyncState(agentId, provider, mailbox, side) {
-        await this.ensureReady();
         const mailboxClause = mailbox ? `AND mailbox = ${sqlQuote(mailbox)}` : "";
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_gmail_sync_states
@@ -2470,7 +2337,6 @@ export class LifeOpsRepository {
           ${sideClause}`);
     }
     async createWorkflow(definition) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_workflow_definitions (
         id, agent_id, domain, subject_type, subject_id, visibility_scope,
         context_policy, title, trigger_type, schedule_json, action_plan_json,
@@ -2497,7 +2363,6 @@ export class LifeOpsRepository {
       )`);
     }
     async updateWorkflow(definition) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_workflow_definitions
           SET domain = ${sqlQuote(definition.domain)},
               subject_type = ${sqlQuote(definition.subjectType)},
@@ -2516,7 +2381,6 @@ export class LifeOpsRepository {
           AND agent_id = ${sqlQuote(definition.agentId)}`);
     }
     async listWorkflows(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_workflow_definitions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2524,7 +2388,6 @@ export class LifeOpsRepository {
         return rows.map(parseWorkflowDefinition);
     }
     async deleteWorkflow(agentId, workflowId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_workflow_runs
         WHERE agent_id = ${sqlQuote(agentId)}
           AND workflow_id = ${sqlQuote(workflowId)}`);
@@ -2537,7 +2400,6 @@ export class LifeOpsRepository {
           AND id = ${sqlQuote(workflowId)}`);
     }
     async getWorkflow(agentId, workflowId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_workflow_definitions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2547,7 +2409,6 @@ export class LifeOpsRepository {
         return row ? parseWorkflowDefinition(row) : null;
     }
     async createWorkflowRun(run) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_workflow_runs (
         id, agent_id, workflow_id, started_at, finished_at, status,
         result_json, audit_ref
@@ -2563,7 +2424,6 @@ export class LifeOpsRepository {
       )`);
     }
     async listWorkflowRuns(agentId, workflowId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_workflow_runs
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2572,7 +2432,6 @@ export class LifeOpsRepository {
         return rows.map(parseWorkflowRun);
     }
     async createReminderAttempt(attempt) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_reminder_attempts (
         id, agent_id, plan_id, owner_type, owner_id, occurrence_id,
         channel, step_index, scheduled_for, attempted_at, outcome,
@@ -2594,7 +2453,6 @@ export class LifeOpsRepository {
       )`);
     }
     async listReminderAttempts(agentId, options) {
-        await this.ensureReady();
         const ownerTypeClause = options?.ownerType
             ? `AND owner_type = ${sqlQuote(options.ownerType)}`
             : "";
@@ -2614,7 +2472,6 @@ export class LifeOpsRepository {
         return rows.map(parseReminderAttempt);
     }
     async updateReminderAttemptOutcome(id, outcome, metadata) {
-        await this.ensureReady();
         if (metadata && Object.keys(metadata).length > 0) {
             await executeRawSql(this.runtime, `UPDATE life_reminder_attempts
             SET outcome = ${sqlQuote(outcome)},
@@ -2628,7 +2485,6 @@ export class LifeOpsRepository {
         }
     }
     async createBrowserSession(session) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_browser_sessions (
         id, agent_id, domain, subject_type, subject_id, visibility_scope,
         context_policy, workflow_id, browser, companion_id, profile_id,
@@ -2662,7 +2518,6 @@ export class LifeOpsRepository {
       )`);
     }
     async updateBrowserSession(session) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_browser_sessions
           SET domain = ${sqlQuote(session.domain)},
               subject_type = ${sqlQuote(session.subjectType)},
@@ -2688,7 +2543,6 @@ export class LifeOpsRepository {
           AND agent_id = ${sqlQuote(session.agentId)}`);
     }
     async getBrowserSession(agentId, sessionId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_browser_sessions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2698,7 +2552,6 @@ export class LifeOpsRepository {
         return row ? parseBrowserSession(row) : null;
     }
     async listBrowserSessions(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_browser_sessions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2706,7 +2559,6 @@ export class LifeOpsRepository {
         return rows.map(parseBrowserSession);
     }
     async getBrowserSettings(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_browser_settings
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2715,7 +2567,6 @@ export class LifeOpsRepository {
         return row ? parseBrowserSettings(row) : null;
     }
     async upsertBrowserSettings(agentId, settings) {
-        await this.ensureReady();
         const createdAt = settings.updatedAt ?? isoNow();
         await executeRawSql(this.runtime, `INSERT INTO life_browser_settings (
         agent_id, enabled, tracking_mode, allow_browser_control,
@@ -2753,7 +2604,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async getBrowserCompanionByProfile(agentId, browser, profileId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_browser_companions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2764,7 +2614,6 @@ export class LifeOpsRepository {
         return row ? parseBrowserCompanion(row) : null;
     }
     async getBrowserCompanionCredential(agentId, companionId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_browser_companions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2774,7 +2623,6 @@ export class LifeOpsRepository {
         return row ? parseBrowserCompanionCredential(row) : null;
     }
     async upsertBrowserCompanion(companion) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_browser_companions (
         id, agent_id, browser, profile_id, profile_label, label,
         extension_version, connection_state, permissions_json, last_seen_at,
@@ -2807,7 +2655,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async updateBrowserCompanionPairingToken(agentId, companionId, pairingTokenHash, pairedAt, updatedAt) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_browser_companions
           SET pairing_token_hash = ${sqlQuote(pairingTokenHash)},
               pending_pairing_token_hashes_json = '[]',
@@ -2817,7 +2664,6 @@ export class LifeOpsRepository {
           AND id = ${sqlQuote(companionId)}`);
     }
     async updateBrowserCompanionPendingPairingTokenHashes(agentId, companionId, pendingPairingTokenHashes, updatedAt) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_browser_companions
           SET pending_pairing_token_hashes_json = ${sqlJson(pendingPairingTokenHashes)},
               updated_at = ${sqlQuote(updatedAt)}
@@ -2825,7 +2671,6 @@ export class LifeOpsRepository {
           AND id = ${sqlQuote(companionId)}`);
     }
     async promoteBrowserCompanionPendingPairingToken(agentId, companionId, pairingTokenHash, pendingPairingTokenHashes, pairedAt, updatedAt) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `UPDATE life_browser_companions
           SET pairing_token_hash = ${sqlQuote(pairingTokenHash)},
               pending_pairing_token_hashes_json = ${sqlJson(pendingPairingTokenHashes)},
@@ -2835,7 +2680,6 @@ export class LifeOpsRepository {
           AND id = ${sqlQuote(companionId)}`);
     }
     async listBrowserCompanions(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_browser_companions
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2843,7 +2687,6 @@ export class LifeOpsRepository {
         return rows.map(parseBrowserCompanion);
     }
     async upsertBrowserTab(tab) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_browser_tabs (
         id, agent_id, companion_id, browser, profile_id, window_id, tab_id,
         url, title, active_in_window, focused_window, focused_active,
@@ -2885,7 +2728,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async listBrowserTabs(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_browser_tabs
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2896,7 +2738,6 @@ export class LifeOpsRepository {
         return rows.map(parseBrowserTabSummary);
     }
     async deleteBrowserTabsByIds(agentId, ids) {
-        await this.ensureReady();
         if (ids.length === 0)
             return;
         const values = ids.map((id) => sqlQuote(id)).join(", ");
@@ -2905,12 +2746,10 @@ export class LifeOpsRepository {
           AND id IN (${values})`);
     }
     async deleteAllBrowserTabs(agentId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_browser_tabs
         WHERE agent_id = ${sqlQuote(agentId)}`);
     }
     async upsertBrowserPageContext(context) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `INSERT INTO life_browser_page_contexts (
         id, agent_id, browser, profile_id, window_id, tab_id, url, title,
         selection_text, main_text, headings_json, links_json, forms_json,
@@ -2944,7 +2783,6 @@ export class LifeOpsRepository {
         metadata_json = excluded.metadata_json`);
     }
     async listBrowserPageContexts(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_browser_page_contexts
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -2952,7 +2790,6 @@ export class LifeOpsRepository {
         return rows.map(parseBrowserPageContext);
     }
     async deleteBrowserPageContextsByIds(agentId, ids) {
-        await this.ensureReady();
         if (ids.length === 0)
             return;
         const values = ids.map((id) => sqlQuote(id)).join(", ");
@@ -2961,12 +2798,10 @@ export class LifeOpsRepository {
           AND id IN (${values})`);
     }
     async deleteAllBrowserPageContexts(agentId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_browser_page_contexts
         WHERE agent_id = ${sqlQuote(agentId)}`);
     }
     async deleteBrowserSession(agentId, sessionId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_browser_sessions
         WHERE agent_id = ${sqlQuote(agentId)}
           AND id = ${sqlQuote(sessionId)}`);
@@ -2975,7 +2810,6 @@ export class LifeOpsRepository {
     // Escalation state persistence
     // ---------------------------------------------------------------------------
     async upsertEscalationState(state) {
-        await this.ensureReady();
         const now = isoNow();
         await executeRawSql(this.runtime, `INSERT INTO life_escalation_states (
         id, agent_id, reason, text, current_step,
@@ -3009,7 +2843,6 @@ export class LifeOpsRepository {
         updated_at = excluded.updated_at`);
     }
     async getActiveEscalationState(agentId) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_escalation_states
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -3020,7 +2853,6 @@ export class LifeOpsRepository {
         return row ? parseEscalationStateRow(row) : null;
     }
     async resolveEscalationState(id, resolvedAt) {
-        await this.ensureReady();
         const now = isoNow();
         await executeRawSql(this.runtime, `UPDATE life_escalation_states
          SET resolved = TRUE,
@@ -3029,7 +2861,6 @@ export class LifeOpsRepository {
        WHERE id = ${sqlQuote(id)}`);
     }
     async listRecentEscalationStates(agentId, limit = 10) {
-        await this.ensureReady();
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_escalation_states
         WHERE agent_id = ${sqlQuote(agentId)}
@@ -3038,10 +2869,621 @@ export class LifeOpsRepository {
         return rows.map(parseEscalationStateRow);
     }
     async deleteAllEscalationStates(agentId) {
-        await this.ensureReady();
         await executeRawSql(this.runtime, `DELETE FROM life_escalation_states
         WHERE agent_id = ${sqlQuote(agentId)}`);
     }
+    // -----------------------------------------------------------------------
+    // Relationships, interactions & follow-ups
+    // -----------------------------------------------------------------------
+    async upsertRelationship(rel) {
+        await executeRawSql(this.runtime, `INSERT INTO life_relationships (
+         id, agent_id, name, primary_channel, primary_handle, email, phone,
+         notes, tags_json, relationship_type, last_contacted_at, metadata_json,
+         created_at, updated_at
+       ) VALUES (
+         ${sqlQuote(rel.id)},
+         ${sqlQuote(rel.agentId)},
+         ${sqlQuote(rel.name)},
+         ${sqlQuote(rel.primaryChannel)},
+         ${sqlQuote(rel.primaryHandle)},
+         ${sqlText(rel.email)},
+         ${sqlText(rel.phone)},
+         ${sqlQuote(rel.notes)},
+         ${sqlJson(rel.tags)},
+         ${sqlQuote(rel.relationshipType)},
+         ${sqlText(rel.lastContactedAt)},
+         ${sqlJson(rel.metadata)},
+         ${sqlQuote(rel.createdAt)},
+         ${sqlQuote(rel.updatedAt)}
+       )
+       ON CONFLICT (id) DO UPDATE SET
+         name = EXCLUDED.name,
+         primary_channel = EXCLUDED.primary_channel,
+         primary_handle = EXCLUDED.primary_handle,
+         email = EXCLUDED.email,
+         phone = EXCLUDED.phone,
+         notes = EXCLUDED.notes,
+         tags_json = EXCLUDED.tags_json,
+         relationship_type = EXCLUDED.relationship_type,
+         last_contacted_at = EXCLUDED.last_contacted_at,
+         metadata_json = EXCLUDED.metadata_json,
+         updated_at = EXCLUDED.updated_at`);
+    }
+    async getRelationship(agentId, id) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_relationships
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseRelationship(row) : null;
+    }
+    async listRelationships(agentId, opts) {
+        const clauses = [`agent_id = ${sqlQuote(agentId)}`];
+        if (opts?.primaryChannel) {
+            clauses.push(`primary_channel = ${sqlQuote(opts.primaryChannel)}`);
+        }
+        const limitClause = typeof opts?.limit === "number"
+            ? `LIMIT ${sqlInteger(opts.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_relationships
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY name ASC
+        ${limitClause}`);
+        return rows.map(parseRelationship);
+    }
+    async logRelationshipInteraction(interaction) {
+        await executeRawSql(this.runtime, `INSERT INTO life_relationship_interactions (
+         id, agent_id, relationship_id, channel, direction, summary,
+         occurred_at, metadata_json, created_at
+       ) VALUES (
+         ${sqlQuote(interaction.id)},
+         ${sqlQuote(interaction.agentId)},
+         ${sqlQuote(interaction.relationshipId)},
+         ${sqlQuote(interaction.channel)},
+         ${sqlQuote(interaction.direction)},
+         ${sqlQuote(interaction.summary)},
+         ${sqlQuote(interaction.occurredAt)},
+         ${sqlJson(interaction.metadata)},
+         ${sqlQuote(interaction.createdAt)}
+       )`);
+    }
+    async listInteractions(agentId, relationshipId, opts) {
+        const limitClause = typeof opts?.limit === "number"
+            ? `LIMIT ${sqlInteger(opts.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_relationship_interactions
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND relationship_id = ${sqlQuote(relationshipId)}
+        ORDER BY occurred_at DESC
+        ${limitClause}`);
+        return rows.map(parseRelationshipInteraction);
+    }
+    async updateRelationshipLastContactedAt(agentId, relationshipId, timestamp) {
+        await executeRawSql(this.runtime, `UPDATE life_relationships
+          SET last_contacted_at = ${sqlQuote(timestamp)},
+              updated_at = ${sqlQuote(timestamp)}
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(relationshipId)}
+          AND (last_contacted_at IS NULL OR last_contacted_at < ${sqlQuote(timestamp)})`);
+    }
+    async upsertFollowUp(fu) {
+        await executeRawSql(this.runtime, `INSERT INTO life_follow_ups (
+         id, agent_id, relationship_id, due_at, reason, status, priority,
+         draft_json, completed_at, metadata_json, created_at, updated_at
+       ) VALUES (
+         ${sqlQuote(fu.id)},
+         ${sqlQuote(fu.agentId)},
+         ${sqlQuote(fu.relationshipId)},
+         ${sqlQuote(fu.dueAt)},
+         ${sqlQuote(fu.reason)},
+         ${sqlQuote(fu.status)},
+         ${sqlInteger(fu.priority)},
+         ${fu.draft ? sqlJson(fu.draft) : "NULL"},
+         ${sqlText(fu.completedAt)},
+         ${sqlJson(fu.metadata)},
+         ${sqlQuote(fu.createdAt)},
+         ${sqlQuote(fu.updatedAt)}
+       )
+       ON CONFLICT (id) DO UPDATE SET
+         relationship_id = EXCLUDED.relationship_id,
+         due_at = EXCLUDED.due_at,
+         reason = EXCLUDED.reason,
+         status = EXCLUDED.status,
+         priority = EXCLUDED.priority,
+         draft_json = EXCLUDED.draft_json,
+         completed_at = EXCLUDED.completed_at,
+         metadata_json = EXCLUDED.metadata_json,
+         updated_at = EXCLUDED.updated_at`);
+    }
+    async getFollowUp(agentId, id) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_follow_ups
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseFollowUp(row) : null;
+    }
+    async listFollowUps(agentId, opts) {
+        const clauses = [`agent_id = ${sqlQuote(agentId)}`];
+        if (opts?.status) {
+            clauses.push(`status = ${sqlQuote(opts.status)}`);
+        }
+        if (opts?.dueOnOrBefore) {
+            clauses.push(`due_at <= ${sqlQuote(opts.dueOnOrBefore)}`);
+        }
+        const limitClause = typeof opts?.limit === "number"
+            ? `LIMIT ${sqlInteger(opts.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_follow_ups
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY due_at ASC
+        ${limitClause}`);
+        return rows.map(parseFollowUp);
+    }
+    async updateFollowUpStatus(agentId, id, status, completedAt) {
+        const now = isoNow();
+        const completedClause = completedAt
+            ? `, completed_at = ${sqlQuote(completedAt)}`
+            : "";
+        await executeRawSql(this.runtime, `UPDATE life_follow_ups
+          SET status = ${sqlQuote(status)},
+              updated_at = ${sqlQuote(now)}
+              ${completedClause}
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}`);
+    }
+    async updateFollowUpDueAt(agentId, id, dueAt) {
+        const now = isoNow();
+        await executeRawSql(this.runtime, `UPDATE life_follow_ups
+          SET due_at = ${sqlQuote(dueAt)},
+              updated_at = ${sqlQuote(now)}
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}`);
+    }
+    // -----------------------------------------------------------------------
+    // X (Twitter) DMs, feed items, and sync state
+    // -----------------------------------------------------------------------
+    async upsertXDm(dm) {
+        await executeRawSql(this.runtime, `INSERT INTO life_x_dms (
+        id, agent_id, external_dm_id, conversation_id, sender_handle, sender_id,
+        is_inbound, text, received_at, read_at, replied_at, metadata_json,
+        synced_at, updated_at
+      ) VALUES (
+        ${sqlQuote(dm.id)},
+        ${sqlQuote(dm.agentId)},
+        ${sqlQuote(dm.externalDmId)},
+        ${sqlQuote(dm.conversationId)},
+        ${sqlQuote(dm.senderHandle)},
+        ${sqlQuote(dm.senderId)},
+        ${sqlBoolean(dm.isInbound)},
+        ${sqlQuote(dm.text)},
+        ${sqlQuote(dm.receivedAt)},
+        ${sqlText(dm.readAt)},
+        ${sqlText(dm.repliedAt)},
+        ${sqlJson(dm.metadata)},
+        ${sqlQuote(dm.syncedAt)},
+        ${sqlQuote(dm.updatedAt)}
+      )
+      ON CONFLICT(agent_id, external_dm_id) DO UPDATE SET
+        conversation_id = excluded.conversation_id,
+        sender_handle = excluded.sender_handle,
+        sender_id = excluded.sender_id,
+        is_inbound = excluded.is_inbound,
+        text = excluded.text,
+        received_at = excluded.received_at,
+        read_at = excluded.read_at,
+        replied_at = excluded.replied_at,
+        metadata_json = excluded.metadata_json,
+        synced_at = excluded.synced_at,
+        updated_at = excluded.updated_at`);
+    }
+    async listXDms(agentId, opts = {}) {
+        const DEFAULT_LIMIT = 100;
+        const limit = opts.limit !== undefined && Number.isFinite(opts.limit)
+            ? opts.limit
+            : DEFAULT_LIMIT;
+        const conversationClause = opts.conversationId
+            ? `AND conversation_id = ${sqlQuote(opts.conversationId)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_x_dms
+        WHERE agent_id = ${sqlQuote(agentId)}
+          ${conversationClause}
+        ORDER BY received_at DESC
+        LIMIT ${sqlInteger(limit)}`);
+        return rows.map(parseXDm);
+    }
+    async upsertXFeedItem(item) {
+        await executeRawSql(this.runtime, `INSERT INTO life_x_feed_items (
+        id, agent_id, external_tweet_id, author_handle, author_id, text,
+        created_at_source, feed_type, metadata_json, synced_at, updated_at
+      ) VALUES (
+        ${sqlQuote(item.id)},
+        ${sqlQuote(item.agentId)},
+        ${sqlQuote(item.externalTweetId)},
+        ${sqlQuote(item.authorHandle)},
+        ${sqlQuote(item.authorId)},
+        ${sqlQuote(item.text)},
+        ${sqlQuote(item.createdAtSource)},
+        ${sqlQuote(item.feedType)},
+        ${sqlJson(item.metadata)},
+        ${sqlQuote(item.syncedAt)},
+        ${sqlQuote(item.updatedAt)}
+      )
+      ON CONFLICT(agent_id, external_tweet_id, feed_type) DO UPDATE SET
+        author_handle = excluded.author_handle,
+        author_id = excluded.author_id,
+        text = excluded.text,
+        created_at_source = excluded.created_at_source,
+        metadata_json = excluded.metadata_json,
+        synced_at = excluded.synced_at,
+        updated_at = excluded.updated_at`);
+    }
+    async listXFeedItems(agentId, feedType, opts = {}) {
+        const DEFAULT_LIMIT = 100;
+        const limit = opts.limit !== undefined && Number.isFinite(opts.limit)
+            ? opts.limit
+            : DEFAULT_LIMIT;
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_x_feed_items
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND feed_type = ${sqlQuote(feedType)}
+        ORDER BY created_at_source DESC
+        LIMIT ${sqlInteger(limit)}`);
+        return rows.map(parseXFeedItem);
+    }
+    async upsertXSyncState(state) {
+        await executeRawSql(this.runtime, `INSERT INTO life_x_sync_states (
+        id, agent_id, feed_type, last_cursor, synced_at, updated_at
+      ) VALUES (
+        ${sqlQuote(state.id)},
+        ${sqlQuote(state.agentId)},
+        ${sqlQuote(state.feedType)},
+        ${sqlText(state.lastCursor)},
+        ${sqlQuote(state.syncedAt)},
+        ${sqlQuote(state.updatedAt)}
+      )
+      ON CONFLICT(agent_id, feed_type) DO UPDATE SET
+        last_cursor = excluded.last_cursor,
+        synced_at = excluded.synced_at,
+        updated_at = excluded.updated_at`);
+    }
+    async getXSyncState(agentId, feedType) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_x_sync_states
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND feed_type = ${sqlQuote(feedType)}
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseXSyncState(row) : null;
+    }
+    // -----------------------------------------------------------------------
+    // Screen time — per-app and per-website dwell sessions + daily rollups
+    // -----------------------------------------------------------------------
+    async upsertScreenTimeSession(session) {
+        await executeRawSql(this.runtime, `INSERT INTO life_screen_time_sessions (
+         id, agent_id, source, identifier, display_name, start_at, end_at,
+         duration_seconds, is_active, metadata_json, created_at, updated_at
+       ) VALUES (
+         ${sqlQuote(session.id)},
+         ${sqlQuote(session.agentId)},
+         ${sqlQuote(session.source)},
+         ${sqlQuote(session.identifier)},
+         ${sqlQuote(session.displayName)},
+         ${sqlQuote(session.startAt)},
+         ${sqlText(session.endAt)},
+         ${sqlInteger(session.durationSeconds)},
+         ${sqlBoolean(session.isActive)},
+         ${sqlJson(session.metadata)},
+         ${sqlQuote(session.createdAt)},
+         ${sqlQuote(session.updatedAt)}
+       )
+       ON CONFLICT (id) DO UPDATE SET
+         source = EXCLUDED.source,
+         identifier = EXCLUDED.identifier,
+         display_name = EXCLUDED.display_name,
+         start_at = EXCLUDED.start_at,
+         end_at = EXCLUDED.end_at,
+         duration_seconds = EXCLUDED.duration_seconds,
+         is_active = EXCLUDED.is_active,
+         metadata_json = EXCLUDED.metadata_json,
+         updated_at = EXCLUDED.updated_at`);
+    }
+    async getScreenTimeSession(agentId, id) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_screen_time_sessions
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseScreenTimeSession(row) : null;
+    }
+    async finishScreenTimeSession(agentId, id, endAt, durationSeconds) {
+        const now = isoNow();
+        await executeRawSql(this.runtime, `UPDATE life_screen_time_sessions
+          SET end_at = ${sqlQuote(endAt)},
+              duration_seconds = ${sqlInteger(durationSeconds)},
+              is_active = ${sqlBoolean(false)},
+              updated_at = ${sqlQuote(now)}
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}`);
+    }
+    async listScreenTimeSessionsBetween(agentId, start, end, opts) {
+        const clauses = [
+            `agent_id = ${sqlQuote(agentId)}`,
+            `start_at >= ${sqlQuote(start)}`,
+            `start_at < ${sqlQuote(end)}`,
+        ];
+        if (opts?.source) {
+            clauses.push(`source = ${sqlQuote(opts.source)}`);
+        }
+        const limitClause = typeof opts?.limit === "number"
+            ? `LIMIT ${sqlInteger(opts.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_screen_time_sessions
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY start_at ASC
+        ${limitClause}`);
+        return rows.map(parseScreenTimeSession);
+    }
+    async upsertScreenTimeDaily(row) {
+        await executeRawSql(this.runtime, `INSERT INTO life_screen_time_daily (
+         id, agent_id, source, identifier, date, total_seconds, session_count,
+         metadata_json, created_at, updated_at
+       ) VALUES (
+         ${sqlQuote(row.id)},
+         ${sqlQuote(row.agentId)},
+         ${sqlQuote(row.source)},
+         ${sqlQuote(row.identifier)},
+         ${sqlQuote(row.date)},
+         ${sqlInteger(row.totalSeconds)},
+         ${sqlInteger(row.sessionCount)},
+         ${sqlJson(row.metadata)},
+         ${sqlQuote(row.createdAt)},
+         ${sqlQuote(row.updatedAt)}
+       )
+       ON CONFLICT (agent_id, source, identifier, date) DO UPDATE SET
+         total_seconds = EXCLUDED.total_seconds,
+         session_count = EXCLUDED.session_count,
+         metadata_json = EXCLUDED.metadata_json,
+         updated_at = EXCLUDED.updated_at`);
+    }
+    async listScreenTimeDaily(agentId, date, opts) {
+        const clauses = [
+            `agent_id = ${sqlQuote(agentId)}`,
+            `date = ${sqlQuote(date)}`,
+        ];
+        if (opts?.source) {
+            clauses.push(`source = ${sqlQuote(opts.source)}`);
+        }
+        const limitClause = typeof opts?.limit === "number"
+            ? `LIMIT ${sqlInteger(opts.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_screen_time_daily
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY total_seconds DESC
+        ${limitClause}`);
+        return rows.map(parseScreenTimeDaily);
+    }
+    async aggregateScreenTimeDailyForDate(agentId, date) {
+        // Sessions counted when their start_at falls within the UTC day window.
+        const dayStart = `${date}T00:00:00.000Z`;
+        const dayEnd = `${date}T23:59:59.999Z`;
+        const rows = await executeRawSql(this.runtime, `SELECT source,
+              identifier,
+              MAX(display_name) AS display_name,
+              SUM(duration_seconds) AS total_seconds,
+              COUNT(*) AS session_count
+         FROM life_screen_time_sessions
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND start_at >= ${sqlQuote(dayStart)}
+          AND start_at <= ${sqlQuote(dayEnd)}
+        GROUP BY source, identifier`);
+        const now = isoNow();
+        let updated = 0;
+        for (const row of rows) {
+            const rollup = {
+                id: crypto.randomUUID(),
+                agentId,
+                source: toText(row.source),
+                identifier: toText(row.identifier),
+                date,
+                totalSeconds: toNumber(row.total_seconds, 0),
+                sessionCount: toNumber(row.session_count, 0),
+                metadata: {
+                    displayName: toText(row.display_name, toText(row.identifier)),
+                },
+                createdAt: now,
+                updatedAt: now,
+            };
+            await this.upsertScreenTimeDaily(rollup);
+            updated += 1;
+        }
+        return { updated };
+    }
+    // -----------------------------------------------------------------------
+    // Scheduling negotiations + proposals
+    // -----------------------------------------------------------------------
+    async upsertSchedulingNegotiation(neg) {
+        await executeRawSql(this.runtime, `INSERT INTO life_scheduling_negotiations (
+         id, agent_id, subject, relationship_id, duration_minutes, timezone,
+         state, accepted_proposal_id, started_at, finalized_at, metadata_json,
+         created_at, updated_at
+       ) VALUES (
+         ${sqlQuote(neg.id)},
+         ${sqlQuote(neg.agentId)},
+         ${sqlQuote(neg.subject)},
+         ${sqlText(neg.relationshipId)},
+         ${sqlInteger(neg.durationMinutes)},
+         ${sqlQuote(neg.timezone)},
+         ${sqlQuote(neg.state)},
+         ${sqlText(neg.acceptedProposalId)},
+         ${sqlQuote(neg.startedAt)},
+         ${sqlText(neg.finalizedAt)},
+         ${sqlJson(neg.metadata)},
+         ${sqlQuote(neg.createdAt)},
+         ${sqlQuote(neg.updatedAt)}
+       )
+       ON CONFLICT (id) DO UPDATE SET
+         subject = EXCLUDED.subject,
+         relationship_id = EXCLUDED.relationship_id,
+         duration_minutes = EXCLUDED.duration_minutes,
+         timezone = EXCLUDED.timezone,
+         state = EXCLUDED.state,
+         accepted_proposal_id = EXCLUDED.accepted_proposal_id,
+         finalized_at = EXCLUDED.finalized_at,
+         metadata_json = EXCLUDED.metadata_json,
+         updated_at = EXCLUDED.updated_at`);
+    }
+    async getSchedulingNegotiation(agentId, id) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_scheduling_negotiations
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseSchedulingNegotiation(row) : null;
+    }
+    async listSchedulingNegotiations(agentId, opts) {
+        const clauses = [`agent_id = ${sqlQuote(agentId)}`];
+        if (opts?.state) {
+            clauses.push(`state = ${sqlQuote(opts.state)}`);
+        }
+        const limitClause = typeof opts?.limit === "number"
+            ? `LIMIT ${sqlInteger(opts.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_scheduling_negotiations
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY updated_at DESC
+        ${limitClause}`);
+        return rows.map(parseSchedulingNegotiation);
+    }
+    async updateSchedulingNegotiationState(agentId, id, state, finalizedAt) {
+        const now = isoNow();
+        const finalizedClause = finalizedAt === undefined
+            ? ""
+            : `, finalized_at = ${sqlText(finalizedAt)}`;
+        await executeRawSql(this.runtime, `UPDATE life_scheduling_negotiations
+          SET state = ${sqlQuote(state)},
+              updated_at = ${sqlQuote(now)}${finalizedClause}
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}`);
+    }
+    async upsertSchedulingProposal(p) {
+        await executeRawSql(this.runtime, `INSERT INTO life_scheduling_proposals (
+         id, agent_id, negotiation_id, start_at, end_at, proposed_by, status,
+         metadata_json, created_at, updated_at
+       ) VALUES (
+         ${sqlQuote(p.id)},
+         ${sqlQuote(p.agentId)},
+         ${sqlQuote(p.negotiationId)},
+         ${sqlQuote(p.startAt)},
+         ${sqlQuote(p.endAt)},
+         ${sqlQuote(p.proposedBy)},
+         ${sqlQuote(p.status)},
+         ${sqlJson(p.metadata)},
+         ${sqlQuote(p.createdAt)},
+         ${sqlQuote(p.updatedAt)}
+       )
+       ON CONFLICT (id) DO UPDATE SET
+         start_at = EXCLUDED.start_at,
+         end_at = EXCLUDED.end_at,
+         proposed_by = EXCLUDED.proposed_by,
+         status = EXCLUDED.status,
+         metadata_json = EXCLUDED.metadata_json,
+         updated_at = EXCLUDED.updated_at`);
+    }
+    async getSchedulingProposal(agentId, id) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_scheduling_proposals
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseSchedulingProposal(row) : null;
+    }
+    async listSchedulingProposals(agentId, negotiationId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_scheduling_proposals
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND negotiation_id = ${sqlQuote(negotiationId)}
+        ORDER BY created_at ASC`);
+        return rows.map(parseSchedulingProposal);
+    }
+    async updateSchedulingProposalStatus(agentId, id, status) {
+        const now = isoNow();
+        await executeRawSql(this.runtime, `UPDATE life_scheduling_proposals
+          SET status = ${sqlQuote(status)},
+              updated_at = ${sqlQuote(now)}
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}`);
+    }
+    // -----------------------------------------------------------------------
+    // Dossiers
+    // -----------------------------------------------------------------------
+    async upsertDossier(d) {
+        await executeRawSql(this.runtime, `INSERT INTO life_dossiers (
+         id, agent_id, calendar_event_id, subject, generated_for_at,
+         content_md, sources_json, metadata_json, created_at, updated_at
+       ) VALUES (
+         ${sqlQuote(d.id)},
+         ${sqlQuote(d.agentId)},
+         ${sqlText(d.calendarEventId)},
+         ${sqlQuote(d.subject)},
+         ${sqlQuote(d.generatedForAt)},
+         ${sqlQuote(d.contentMd)},
+         ${sqlJson(d.sources)},
+         ${sqlJson(d.metadata)},
+         ${sqlQuote(d.createdAt)},
+         ${sqlQuote(d.updatedAt)}
+       )
+       ON CONFLICT (id) DO UPDATE SET
+         calendar_event_id = EXCLUDED.calendar_event_id,
+         subject = EXCLUDED.subject,
+         generated_for_at = EXCLUDED.generated_for_at,
+         content_md = EXCLUDED.content_md,
+         sources_json = EXCLUDED.sources_json,
+         metadata_json = EXCLUDED.metadata_json,
+         updated_at = EXCLUDED.updated_at`);
+    }
+    async getDossier(agentId, id) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_dossiers
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(id)}
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseDossier(row) : null;
+    }
+    async getDossierByCalendarEvent(agentId, calendarEventId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_dossiers
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND calendar_event_id = ${sqlQuote(calendarEventId)}
+        ORDER BY generated_for_at DESC
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseDossier(row) : null;
+    }
+    async listDossiers(agentId, opts) {
+        const limitClause = typeof opts?.limit === "number"
+            ? `LIMIT ${sqlInteger(opts.limit)}`
+            : "LIMIT 50";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_dossiers
+        WHERE agent_id = ${sqlQuote(agentId)}
+        ORDER BY generated_for_at DESC
+        ${limitClause}`);
+        return rows.map(parseDossier);
+    }
 }
 export function createLifeOpsTaskDefinition(params) {
     const timestamp = isoNow();