@elizaos/plugin-personal-assistant 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/lifeops/schema.js

@@ -0,0 +1,1689 @@
+import { sql } from "drizzle-orm";
+import {
+  bigint,
+  boolean,
+  index,
+  integer,
+  jsonb,
+  pgSchema,
+  real,
+  text,
+  timestamp,
+  unique,
+  uuid
+} from "drizzle-orm/pg-core";
+const appLifeopsPgSchema = pgSchema("app_lifeops");
+const lifeConnectorGrants = appLifeopsPgSchema.table(
+  "life_connector_grants",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull(),
+    connectorAccountId: text("connector_account_id"),
+    side: text("side").notNull().default("owner"),
+    identityJson: text("identity_json").notNull().default("{}"),
+    identityEmail: text("identity_email"),
+    grantedScopesJson: text("granted_scopes_json").notNull().default("[]"),
+    capabilitiesJson: text("capabilities_json").notNull().default("[]"),
+    tokenRef: text("token_ref"),
+    mode: text("mode").notNull().default("oauth"),
+    executionTarget: text("execution_target").notNull().default("local"),
+    sourceOfTruth: text("source_of_truth").notNull().default("local_storage"),
+    preferredByAgent: boolean("preferred_by_agent").notNull().default(false),
+    cloudConnectionId: text("cloud_connection_id"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    lastRefreshAt: text("last_refresh_at"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.provider, t.side, t.mode, t.identityEmail)]
+);
+const lifeAccountPrivacy = appLifeopsPgSchema.table(
+  "life_account_privacy",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull(),
+    connectorAccountId: text("connector_account_id").notNull(),
+    visibilityScope: text("visibility_scope").notNull().default("owner_only"),
+    allowedDataClassesJson: text("allowed_data_classes_json").notNull().default("[]"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.provider, t.connectorAccountId),
+    index("idx_life_account_privacy_agent").on(t.agentId, t.provider)
+  ]
+);
+const lifeTaskDefinitions = appLifeopsPgSchema.table(
+  "life_task_definitions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    domain: text("domain").notNull().default("user_lifeops"),
+    subjectType: text("subject_type").notNull().default("owner"),
+    subjectId: text("subject_id").notNull(),
+    visibilityScope: text("visibility_scope").notNull().default("owner_only"),
+    contextPolicy: text("context_policy").notNull().default("explicit_only"),
+    kind: text("kind").notNull(),
+    title: text("title").notNull(),
+    description: text("description").notNull().default(""),
+    originalIntent: text("original_intent").notNull().default(""),
+    timezone: text("timezone").notNull().default("UTC"),
+    status: text("status").notNull().default("active"),
+    priority: integer("priority").notNull().default(3),
+    cadenceJson: text("cadence_json").notNull().default("{}"),
+    windowPolicyJson: text("window_policy_json").notNull().default("{}"),
+    progressionRuleJson: text("progression_rule_json").notNull().default("{}"),
+    websiteAccessJson: text("website_access_json"),
+    reminderPlanId: text("reminder_plan_id"),
+    goalId: text("goal_id"),
+    source: text("source").notNull().default("manual"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    index("idx_life_task_definitions_agent_status").on(t.agentId, t.status),
+    index("idx_life_task_definitions_subject").on(
+      t.agentId,
+      t.domain,
+      t.subjectType,
+      t.subjectId,
+      t.status
+    )
+  ]
+);
+const lifeTaskOccurrences = appLifeopsPgSchema.table(
+  "life_task_occurrences",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    domain: text("domain").notNull().default("user_lifeops"),
+    subjectType: text("subject_type").notNull().default("owner"),
+    subjectId: text("subject_id").notNull(),
+    visibilityScope: text("visibility_scope").notNull().default("owner_only"),
+    contextPolicy: text("context_policy").notNull().default("explicit_only"),
+    definitionId: text("definition_id").notNull(),
+    occurrenceKey: text("occurrence_key").notNull(),
+    scheduledAt: text("scheduled_at"),
+    dueAt: text("due_at"),
+    relevanceStartAt: text("relevance_start_at").notNull(),
+    relevanceEndAt: text("relevance_end_at").notNull(),
+    windowName: text("window_name"),
+    state: text("state").notNull().default("pending"),
+    snoozedUntil: text("snoozed_until"),
+    completionPayloadJson: text("completion_payload_json"),
+    derivedTargetJson: text("derived_target_json"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.definitionId, t.occurrenceKey),
+    index("idx_life_task_occurrences_agent_state_start").on(
+      t.agentId,
+      t.state,
+      t.relevanceStartAt
+    ),
+    index("idx_life_task_occurrences_subject").on(
+      t.agentId,
+      t.domain,
+      t.subjectType,
+      t.subjectId,
+      t.state,
+      t.relevanceStartAt
+    ),
+    index("idx_life_task_occurrences_definition").on(
+      t.definitionId,
+      t.relevanceStartAt
+    )
+  ]
+);
+const lifeGoalDefinitions = appLifeopsPgSchema.table(
+  "life_goal_definitions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    domain: text("domain").notNull().default("user_lifeops"),
+    subjectType: text("subject_type").notNull().default("owner"),
+    subjectId: text("subject_id").notNull(),
+    visibilityScope: text("visibility_scope").notNull().default("owner_only"),
+    contextPolicy: text("context_policy").notNull().default("explicit_only"),
+    title: text("title").notNull(),
+    description: text("description").notNull().default(""),
+    cadenceJson: text("cadence_json"),
+    supportStrategyJson: text("support_strategy_json").notNull().default("{}"),
+    successCriteriaJson: text("success_criteria_json").notNull().default("{}"),
+    status: text("status").notNull().default("active"),
+    reviewState: text("review_state").notNull().default("pending"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    index("idx_life_goal_definitions_agent_status").on(t.agentId, t.status),
+    index("idx_life_goal_definitions_subject").on(
+      t.agentId,
+      t.domain,
+      t.subjectType,
+      t.subjectId,
+      t.status
+    )
+  ]
+);
+const lifeGoalLinks = appLifeopsPgSchema.table(
+  "life_goal_links",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    goalId: text("goal_id").notNull(),
+    linkedType: text("linked_type").notNull(),
+    linkedId: text("linked_id").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.goalId, t.linkedType, t.linkedId),
+    index("idx_life_goal_links_goal").on(t.goalId),
+    index("idx_life_goal_links_linked").on(t.linkedType, t.linkedId)
+  ]
+);
+const lifeReminderPlans = appLifeopsPgSchema.table(
+  "life_reminder_plans",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    ownerType: text("owner_type").notNull(),
+    ownerId: text("owner_id").notNull(),
+    stepsJson: text("steps_json").notNull().default("[]"),
+    mutePolicyJson: text("mute_policy_json").notNull().default("{}"),
+    quietHoursJson: text("quiet_hours_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    index("idx_life_reminder_plans_owner").on(
+      t.agentId,
+      t.ownerType,
+      t.ownerId
+    )
+  ]
+);
+const lifeReminderAttempts = appLifeopsPgSchema.table(
+  "life_reminder_attempts",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    planId: text("plan_id").notNull(),
+    ownerType: text("owner_type").notNull(),
+    ownerId: text("owner_id").notNull(),
+    occurrenceId: text("occurrence_id"),
+    channel: text("channel").notNull(),
+    stepIndex: integer("step_index").notNull().default(0),
+    scheduledFor: text("scheduled_for").notNull(),
+    attemptedAt: text("attempted_at"),
+    outcome: text("outcome").notNull().default("pending"),
+    connectorRef: text("connector_ref"),
+    deliveryMetadataJson: text("delivery_metadata_json").notNull().default("{}"),
+    reviewAt: text("review_at"),
+    reviewStatus: text("review_status"),
+    reviewClaimedAt: text("review_claimed_at"),
+    reviewClaimedBy: text("review_claimed_by"),
+    reviewAttemptCount: integer("review_attempt_count").notNull().default(0),
+    reviewNextRetryAt: text("review_next_retry_at"),
+    reviewLastError: text("review_last_error")
+  },
+  (t) => [
+    index("idx_life_reminder_attempts_plan").on(
+      t.planId,
+      t.ownerType,
+      t.ownerId
+    ),
+    index("idx_life_reminder_attempts_review_scan").on(
+      t.agentId,
+      t.outcome,
+      t.reviewStatus,
+      t.reviewAt
+    )
+  ]
+);
+const lifeAuditEvents = appLifeopsPgSchema.table(
+  "life_audit_events",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    eventType: text("event_type").notNull(),
+    ownerType: text("owner_type").notNull(),
+    ownerId: text("owner_id").notNull(),
+    reason: text("reason").notNull().default(""),
+    inputsJson: text("inputs_json").notNull().default("{}"),
+    decisionJson: text("decision_json").notNull().default("{}"),
+    actor: text("actor").notNull().default("agent"),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => [
+    index("idx_life_audit_events_owner").on(
+      t.agentId,
+      t.ownerType,
+      t.ownerId,
+      t.createdAt
+    )
+  ]
+);
+const lifeEmailUnsubscribes = appLifeopsPgSchema.table(
+  "life_email_unsubscribes",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    senderEmail: text("sender_email").notNull(),
+    senderDisplay: text("sender_display").notNull().default(""),
+    senderDomain: text("sender_domain"),
+    listId: text("list_id"),
+    method: text("method").notNull().default("manual_only"),
+    status: text("status").notNull().default("failed"),
+    httpStatusCode: integer("http_status_code"),
+    httpFinalUrl: text("http_final_url"),
+    filterCreated: boolean("filter_created").notNull().default(false),
+    filterId: text("filter_id"),
+    threadsTrashed: integer("threads_trashed").notNull().default(0),
+    errorMessage: text("error_message"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  }
+);
+const lifeActivitySignals = appLifeopsPgSchema.table(
+  "life_activity_signals",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    source: text("source").notNull(),
+    platform: text("platform").notNull().default(""),
+    state: text("state").notNull(),
+    observedAt: text("observed_at").notNull(),
+    idleState: text("idle_state"),
+    idleTimeSeconds: integer("idle_time_seconds"),
+    onBattery: boolean("on_battery"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => [index("idx_life_activity_signals_agent").on(t.agentId, t.observedAt)]
+);
+const lifeHealthMetricSamples = appLifeopsPgSchema.table(
+  "life_health_metric_samples",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull(),
+    grantId: text("grant_id").notNull(),
+    metric: text("metric").notNull(),
+    value: real("value").notNull(),
+    unit: text("unit").notNull(),
+    startAt: text("start_at").notNull(),
+    endAt: text("end_at").notNull(),
+    localDate: text("local_date").notNull(),
+    sourceExternalId: text("source_external_id").notNull(),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(
+      t.agentId,
+      t.provider,
+      t.grantId,
+      t.metric,
+      t.startAt,
+      t.sourceExternalId
+    ),
+    index("idx_life_health_metric_samples_agent_date").on(
+      t.agentId,
+      t.provider,
+      t.localDate
+    )
+  ]
+);
+const lifeHealthWorkouts = appLifeopsPgSchema.table(
+  "life_health_workouts",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull(),
+    grantId: text("grant_id").notNull(),
+    sourceExternalId: text("source_external_id").notNull(),
+    workoutType: text("workout_type").notNull(),
+    title: text("title").notNull().default(""),
+    startAt: text("start_at").notNull(),
+    endAt: text("end_at"),
+    durationSeconds: integer("duration_seconds").notNull().default(0),
+    distanceMeters: real("distance_meters"),
+    calories: real("calories"),
+    averageHeartRate: real("average_heart_rate"),
+    maxHeartRate: real("max_heart_rate"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.provider, t.grantId, t.sourceExternalId),
+    index("idx_life_health_workouts_agent_start").on(
+      t.agentId,
+      t.provider,
+      t.startAt
+    )
+  ]
+);
+const lifeHealthSyncStates = appLifeopsPgSchema.table(
+  "life_health_sync_states",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull(),
+    grantId: text("grant_id").notNull(),
+    cursor: text("cursor"),
+    lastSyncedAt: text("last_synced_at"),
+    lastSyncStartedAt: text("last_sync_started_at"),
+    lastSyncError: text("last_sync_error"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.provider, t.grantId)]
+);
+const lifeHealthSleepEpisodes = appLifeopsPgSchema.table(
+  "life_health_sleep_episodes",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull(),
+    grantId: text("grant_id").notNull(),
+    sourceExternalId: text("source_external_id").notNull(),
+    localDate: text("local_date").notNull(),
+    timezone: text("timezone"),
+    startAt: text("start_at").notNull(),
+    endAt: text("end_at").notNull(),
+    isMainSleep: boolean("is_main_sleep").notNull().default(false),
+    sleepType: text("sleep_type"),
+    durationSeconds: integer("duration_seconds").notNull().default(0),
+    timeInBedSeconds: integer("time_in_bed_seconds"),
+    efficiency: real("efficiency"),
+    latencySeconds: integer("latency_seconds"),
+    awakeSeconds: integer("awake_seconds"),
+    lightSleepSeconds: integer("light_sleep_seconds"),
+    deepSleepSeconds: integer("deep_sleep_seconds"),
+    remSleepSeconds: integer("rem_sleep_seconds"),
+    sleepScore: real("sleep_score"),
+    readinessScore: real("readiness_score"),
+    averageHeartRate: real("average_heart_rate"),
+    lowestHeartRate: real("lowest_heart_rate"),
+    averageHrvMs: real("average_hrv_ms"),
+    respiratoryRate: real("respiratory_rate"),
+    bloodOxygenPercent: real("blood_oxygen_percent"),
+    stageSamplesJson: text("stage_samples_json").notNull().default("[]"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.provider, t.grantId, t.sourceExternalId),
+    index("idx_life_health_sleep_episodes_agent_date").on(
+      t.agentId,
+      t.provider,
+      t.localDate
+    )
+  ]
+);
+const lifeChannelPolicies = appLifeopsPgSchema.table(
+  "life_channel_policies",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    channelType: text("channel_type").notNull(),
+    channelRef: text("channel_ref").notNull(),
+    privacyClass: text("privacy_class").notNull().default("private"),
+    allowReminders: boolean("allow_reminders").notNull().default(true),
+    allowEscalation: boolean("allow_escalation").notNull().default(false),
+    allowPosts: boolean("allow_posts").notNull().default(false),
+    requireConfirmationForActions: boolean("require_confirmation_for_actions").notNull().default(true),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.channelType, t.channelRef),
+    index("idx_life_channel_policies_agent").on(t.agentId, t.channelType)
+  ]
+);
+const lifeWebsiteAccessGrants = appLifeopsPgSchema.table(
+  "life_website_access_grants",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    groupKey: text("group_key").notNull(),
+    definitionId: text("definition_id").notNull(),
+    occurrenceId: text("occurrence_id"),
+    websitesJson: text("websites_json").notNull().default("[]"),
+    unlockMode: text("unlock_mode").notNull().default("fixed_duration"),
+    unlockDurationMinutes: integer("unlock_duration_minutes"),
+    callbackKey: text("callback_key"),
+    unlockedAt: text("unlocked_at").notNull(),
+    expiresAt: text("expires_at"),
+    revokedAt: text("revoked_at"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    index("idx_life_website_access_grants_group").on(
+      t.agentId,
+      t.groupKey,
+      t.revokedAt,
+      t.expiresAt
+    )
+  ]
+);
+const lifeCalendarEvents = appLifeopsPgSchema.table(
+  "life_calendar_events",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull().default("google"),
+    side: text("side").notNull().default("owner"),
+    calendarId: text("calendar_id").notNull(),
+    externalEventId: text("external_event_id").notNull(),
+    // New writes set connector_account_id from the owning account.
+    connectorAccountId: text("connector_account_id"),
+    purgeResyncRequired: boolean("purge_resync_required").notNull().default(false),
+    purgeResyncReason: text("purge_resync_reason"),
+    grantId: text("grant_id"),
+    title: text("title").notNull().default(""),
+    description: text("description").notNull().default(""),
+    location: text("location").notNull().default(""),
+    status: text("status").notNull().default(""),
+    startAt: text("start_at").notNull(),
+    endAt: text("end_at").notNull(),
+    isAllDay: boolean("is_all_day").notNull().default(false),
+    timezone: text("timezone"),
+    htmlLink: text("html_link"),
+    conferenceLink: text("conference_link"),
+    organizerJson: text("organizer_json"),
+    attendeesJson: text("attendees_json").notNull().default("[]"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    syncedAt: text("synced_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.provider, t.side, t.calendarId, t.externalEventId)
+  ]
+);
+const lifeCalendarSyncStates = appLifeopsPgSchema.table(
+  "life_calendar_sync_states",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull().default("google"),
+    side: text("side").notNull().default("owner"),
+    calendarId: text("calendar_id").notNull(),
+    connectorAccountId: text("connector_account_id"),
+    grantId: text("grant_id"),
+    purgeResyncRequired: boolean("purge_resync_required").notNull().default(false),
+    purgeResyncReason: text("purge_resync_reason"),
+    windowStartAt: text("window_start_at").notNull(),
+    windowEndAt: text("window_end_at").notNull(),
+    syncedAt: text("synced_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.provider, t.side, t.calendarId)]
+);
+const lifeGmailMessages = appLifeopsPgSchema.table(
+  "life_gmail_messages",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull().default("google"),
+    side: text("side").notNull().default("owner"),
+    externalMessageId: text("external_message_id").notNull(),
+    connectorAccountId: text("connector_account_id"),
+    grantId: text("grant_id"),
+    threadId: text("thread_id").notNull().default(""),
+    subject: text("subject").notNull().default(""),
+    fromDisplay: text("from_display").notNull().default(""),
+    fromEmail: text("from_email"),
+    replyTo: text("reply_to"),
+    toJson: text("to_json").notNull().default("[]"),
+    ccJson: text("cc_json").notNull().default("[]"),
+    snippet: text("snippet").notNull().default(""),
+    receivedAt: text("received_at").notNull(),
+    isUnread: boolean("is_unread").notNull().default(true),
+    isImportant: boolean("is_important").notNull().default(false),
+    likelyReplyNeeded: boolean("likely_reply_needed").notNull().default(false),
+    triageScore: integer("triage_score").notNull().default(0),
+    triageReason: text("triage_reason").notNull().default(""),
+    labelIdsJson: text("label_ids_json").notNull().default("[]"),
+    htmlLink: text("html_link"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    syncedAt: text("synced_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.provider, t.side, t.grantId, t.externalMessageId)
+  ]
+);
+const lifeInboxMessages = appLifeopsPgSchema.table(
+  "life_inbox_messages",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    channel: text("channel").notNull(),
+    externalId: text("external_id").notNull(),
+    threadId: text("thread_id"),
+    senderId: text("sender_id").notNull(),
+    senderDisplay: text("sender_display").notNull(),
+    senderEmail: text("sender_email"),
+    subject: text("subject"),
+    snippet: text("snippet").notNull().default(""),
+    receivedAt: text("received_at").notNull(),
+    isUnread: boolean("is_unread").notNull().default(true),
+    deepLink: text("deep_link"),
+    sourceRefJson: text("source_ref_json").notNull().default("{}"),
+    chatType: text("chat_type").notNull().default("channel"),
+    participantCount: integer("participant_count"),
+    gmailAccountId: text("gmail_account_id"),
+    gmailAccountEmail: text("gmail_account_email"),
+    lastSeenAt: text("last_seen_at"),
+    repliedAt: text("replied_at"),
+    priorityScore: integer("priority_score"),
+    priorityCategory: text("priority_category"),
+    priorityFlagsJson: text("priority_flags_json").notNull().default("[]"),
+    connectorAccountId: text("connector_account_id"),
+    cachedAt: text("cached_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.channel, t.externalId),
+    index("idx_life_inbox_messages_agent_received").on(t.agentId, t.receivedAt),
+    index("idx_life_inbox_messages_agent_channel").on(t.agentId, t.channel)
+  ]
+);
+const lifeGmailSyncStates = appLifeopsPgSchema.table(
+  "life_gmail_sync_states",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull().default("google"),
+    side: text("side").notNull().default("owner"),
+    mailbox: text("mailbox").notNull(),
+    grantId: text("grant_id"),
+    maxResults: integer("max_results").notNull().default(0),
+    syncedAt: text("synced_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.provider, t.side, t.grantId, t.mailbox)]
+);
+const lifeGmailSpamReviewItems = appLifeopsPgSchema.table(
+  "life_gmail_spam_review_items",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    provider: text("provider").notNull().default("google"),
+    side: text("side").notNull().default("owner"),
+    grantId: text("grant_id").notNull(),
+    accountEmail: text("account_email"),
+    messageId: text("message_id").notNull(),
+    externalMessageId: text("external_message_id").notNull(),
+    threadId: text("thread_id").notNull(),
+    subject: text("subject").notNull().default(""),
+    fromDisplay: text("from_display").notNull().default(""),
+    fromEmail: text("from_email"),
+    receivedAt: text("received_at").notNull(),
+    snippet: text("snippet").notNull().default(""),
+    labelIdsJson: text("label_ids_json").notNull().default("[]"),
+    rationale: text("rationale").notNull().default(""),
+    confidence: real("confidence").notNull().default(0),
+    status: text("status").notNull().default("pending"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    reviewedAt: text("reviewed_at")
+  },
+  (t) => [
+    unique().on(t.agentId, t.provider, t.side, t.grantId, t.externalMessageId),
+    index("idx_life_gmail_spam_review_status").on(
+      t.agentId,
+      t.status,
+      t.updatedAt
+    )
+  ]
+);
+const lifeWorkflowDefinitions = appLifeopsPgSchema.table(
+  "life_workflow_definitions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    domain: text("domain").notNull().default("user_lifeops"),
+    subjectType: text("subject_type").notNull().default("owner"),
+    subjectId: text("subject_id").notNull(),
+    visibilityScope: text("visibility_scope").notNull().default("owner_only"),
+    contextPolicy: text("context_policy").notNull().default("explicit_only"),
+    title: text("title").notNull(),
+    triggerType: text("trigger_type").notNull(),
+    scheduleJson: text("schedule_json").notNull().default("{}"),
+    actionPlanJson: text("action_plan_json").notNull().default("{}"),
+    permissionPolicyJson: text("permission_policy_json").notNull().default("{}"),
+    status: text("status").notNull().default("active"),
+    createdBy: text("created_by").notNull().default("agent"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    index("idx_life_workflow_definitions_agent").on(
+      t.agentId,
+      t.status,
+      t.updatedAt
+    ),
+    index("idx_life_workflow_definitions_subject").on(
+      t.agentId,
+      t.domain,
+      t.subjectType,
+      t.subjectId,
+      t.status,
+      t.updatedAt
+    )
+  ]
+);
+const lifeWorkflowRuns = appLifeopsPgSchema.table(
+  "life_workflow_runs",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    workflowId: text("workflow_id").notNull(),
+    startedAt: text("started_at").notNull(),
+    finishedAt: text("finished_at"),
+    status: text("status").notNull().default("running"),
+    resultJson: text("result_json").notNull().default("{}"),
+    auditRef: text("audit_ref")
+  },
+  (t) => [
+    index("idx_life_workflow_runs_workflow").on(
+      t.agentId,
+      t.workflowId,
+      t.startedAt
+    )
+  ]
+);
+const lifeWorkflowBrowserSessions = appLifeopsPgSchema.table(
+  "life_workflow_browser_sessions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    domain: text("domain").notNull().default("user_lifeops"),
+    subjectType: text("subject_type").notNull().default("owner"),
+    subjectId: text("subject_id").notNull(),
+    visibilityScope: text("visibility_scope").notNull().default("owner_only"),
+    contextPolicy: text("context_policy").notNull().default("explicit_only"),
+    workflowId: text("workflow_id"),
+    browser: text("browser"),
+    companionId: text("companion_id"),
+    profileId: text("profile_id"),
+    windowId: text("window_id"),
+    tabId: text("tab_id"),
+    title: text("title").notNull().default(""),
+    status: text("status").notNull().default("pending"),
+    actionsJson: text("actions_json").notNull().default("[]"),
+    currentActionIndex: integer("current_action_index").notNull().default(0),
+    awaitingConfirmationForActionId: text(
+      "awaiting_confirmation_for_action_id"
+    ),
+    resultJson: text("result_json").notNull().default("{}"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    finishedAt: text("finished_at")
+  },
+  (t) => [
+    index("idx_life_workflow_browser_sessions_agent").on(
+      t.agentId,
+      t.status,
+      t.updatedAt
+    ),
+    index("idx_life_workflow_browser_sessions_subject").on(
+      t.agentId,
+      t.domain,
+      t.subjectType,
+      t.subjectId,
+      t.status,
+      t.updatedAt
+    )
+  ]
+);
+const lifeEscalationStates = appLifeopsPgSchema.table(
+  "life_escalation_states",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    reason: text("reason").notNull().default(""),
+    text: text("text").notNull().default(""),
+    currentStep: integer("current_step").notNull().default(0),
+    channelsSentJson: text("channels_sent_json").notNull().default("[]"),
+    startedAt: text("started_at").notNull(),
+    lastSentAt: text("last_sent_at").notNull(),
+    resolved: boolean("resolved").notNull().default(false),
+    resolvedAt: text("resolved_at"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    index("idx_life_escalation_states_agent_resolved").on(
+      t.agentId,
+      t.resolved
+    )
+  ]
+);
+const lifeInboxTriageEntries = appLifeopsPgSchema.table(
+  "life_inbox_triage_entries",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    source: text("source").notNull(),
+    sourceRoomId: text("source_room_id"),
+    sourceEntityId: text("source_entity_id"),
+    sourceMessageId: text("source_message_id"),
+    channelName: text("channel_name").notNull(),
+    channelType: text("channel_type").notNull(),
+    deepLink: text("deep_link"),
+    classification: text("classification").notNull(),
+    urgency: text("urgency").notNull().default("low"),
+    confidence: real("confidence").notNull().default(0.5),
+    snippet: text("snippet").notNull().default(""),
+    senderName: text("sender_name"),
+    threadContext: text("thread_context"),
+    triageReasoning: text("triage_reasoning"),
+    suggestedResponse: text("suggested_response"),
+    draftResponse: text("draft_response"),
+    autoReplied: boolean("auto_replied").notNull().default(false),
+    resolved: boolean("resolved").notNull().default(false),
+    resolvedAt: text("resolved_at"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  }
+);
+const lifeInboxTriageExamples = appLifeopsPgSchema.table(
+  "life_inbox_triage_examples",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    source: text("source").notNull(),
+    snippet: text("snippet").notNull().default(""),
+    classification: text("classification").notNull(),
+    ownerAction: text("owner_action").notNull(),
+    ownerClassification: text("owner_classification"),
+    contextJson: text("context_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull()
+  }
+);
+const lifeIntents = appLifeopsPgSchema.table("life_intents", {
+  id: text("id").primaryKey(),
+  agentId: text("agent_id").notNull(),
+  kind: text("kind").notNull(),
+  target: text("target").notNull(),
+  targetDeviceId: text("target_device_id"),
+  title: text("title").notNull(),
+  body: text("body").notNull(),
+  actionUrl: text("action_url"),
+  priority: text("priority").notNull(),
+  createdAt: text("created_at").notNull(),
+  expiresAt: text("expires_at"),
+  acknowledgedAt: text("acknowledged_at"),
+  acknowledgedBy: text("acknowledged_by"),
+  metadataJson: text("metadata_json")
+});
+const lifeCheckinReports = appLifeopsPgSchema.table(
+  "life_checkin_reports",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    kind: text("kind").notNull(),
+    generatedAt: text("generated_at").notNull(),
+    generatedAtMs: bigint("generated_at_ms", { mode: "number" }).notNull(),
+    escalationLevel: integer("escalation_level").notNull(),
+    payloadJson: text("payload_json").notNull(),
+    acknowledgedAt: text("acknowledged_at")
+  }
+);
+const lifeopsFeaturesTable = appLifeopsPgSchema.table(
+  "lifeops_features",
+  {
+    featureKey: text("feature_key").primaryKey(),
+    enabled: boolean("enabled").notNull(),
+    source: text("source").notNull(),
+    enabledAt: timestamp("enabled_at", { withTimezone: true, mode: "date" }),
+    enabledBy: uuid("enabled_by"),
+    metadata: jsonb("metadata").notNull().default(sql`'{}'::jsonb`),
+    createdAt: timestamp("created_at", {
+      withTimezone: true,
+      mode: "date"
+    }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", {
+      withTimezone: true,
+      mode: "date"
+    }).notNull().defaultNow()
+  }
+);
+const lifeRelationshipInteractions = appLifeopsPgSchema.table(
+  "life_relationship_interactions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    relationshipId: text("relationship_id").notNull(),
+    channel: text("channel").notNull(),
+    direction: text("direction").notNull(),
+    summary: text("summary").notNull(),
+    occurredAt: text("occurred_at").notNull(),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull()
+  }
+);
+const lifeXDms = appLifeopsPgSchema.table(
+  "life_x_dms",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    externalDmId: text("external_dm_id").notNull(),
+    conversationId: text("conversation_id").notNull(),
+    senderHandle: text("sender_handle").notNull(),
+    senderId: text("sender_id").notNull(),
+    isInbound: boolean("is_inbound").notNull(),
+    text: text("text").notNull(),
+    receivedAt: text("received_at").notNull(),
+    readAt: text("read_at"),
+    repliedAt: text("replied_at"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    syncedAt: text("synced_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.externalDmId)]
+);
+const lifeXFeedItems = appLifeopsPgSchema.table(
+  "life_x_feed_items",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    externalTweetId: text("external_tweet_id").notNull(),
+    authorHandle: text("author_handle").notNull(),
+    authorId: text("author_id").notNull(),
+    text: text("text").notNull(),
+    createdAtSource: text("created_at_source").notNull(),
+    feedType: text("feed_type").notNull(),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    syncedAt: text("synced_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.externalTweetId, t.feedType)]
+);
+const lifeXSyncStates = appLifeopsPgSchema.table(
+  "life_x_sync_states",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    feedType: text("feed_type").notNull(),
+    lastCursor: text("last_cursor"),
+    syncedAt: text("synced_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.feedType)]
+);
+const lifeScreenTimeSessions = appLifeopsPgSchema.table(
+  "life_screen_time_sessions",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    source: text("source").notNull(),
+    identifier: text("identifier").notNull(),
+    displayName: text("display_name").notNull(),
+    startAt: text("start_at").notNull(),
+    endAt: text("end_at"),
+    durationSeconds: integer("duration_seconds").notNull().default(0),
+    isActive: boolean("is_active").notNull().default(false),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  }
+);
+const lifeScreenTimeDaily = appLifeopsPgSchema.table(
+  "life_screen_time_daily",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    source: text("source").notNull(),
+    identifier: text("identifier").notNull(),
+    date: text("date").notNull(),
+    totalSeconds: integer("total_seconds").notNull().default(0),
+    sessionCount: integer("session_count").notNull().default(0),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.source, t.identifier, t.date)]
+);
+const lifeSleepEpisodes = appLifeopsPgSchema.table(
+  "life_sleep_episodes",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    startAt: text("start_at").notNull(),
+    endAt: text("end_at"),
+    source: text("source").notNull(),
+    confidence: real("confidence").notNull().default(0),
+    cycleType: text("cycle_type").notNull().default("unknown"),
+    sealed: boolean("sealed").notNull().default(false),
+    evidenceJson: text("evidence_json").notNull().default("[]"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.startAt),
+    index("idx_life_sleep_episodes_agent_start").on(t.agentId, t.startAt),
+    index("idx_life_sleep_episodes_agent_sealed").on(
+      t.agentId,
+      t.sealed,
+      t.startAt
+    )
+  ]
+);
+const lifeTelemetryEvents = appLifeopsPgSchema.table(
+  "life_telemetry_events",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    family: text("family").notNull(),
+    occurredAt: text("occurred_at").notNull(),
+    ingestedAt: text("ingested_at").notNull(),
+    /** Content hash used to dedupe at ingest time. */
+    dedupeKey: text("dedupe_key").notNull(),
+    /** Snapshotted source reliability so historical analysis stays stable. */
+    sourceReliability: real("source_reliability").notNull().default(0.5),
+    /** Payload — must match the discriminated union shape for `family`. */
+    payloadJson: text("payload_json").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.dedupeKey),
+    index("idx_life_telemetry_agent_family_occurred").on(
+      t.agentId,
+      t.family,
+      t.occurredAt
+    ),
+    index("idx_life_telemetry_agent_occurred").on(t.agentId, t.occurredAt)
+  ]
+);
+const lifeTelemetryRollupDaily = appLifeopsPgSchema.table(
+  "life_telemetry_rollup_daily",
+  {
+    agentId: text("agent_id").notNull(),
+    family: text("family").notNull(),
+    localDate: text("local_date").notNull(),
+    eventCount: integer("event_count").notNull().default(0),
+    lastObservedAt: text("last_observed_at").notNull(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.family, t.localDate)]
+);
+const lifeCircadianStates = appLifeopsPgSchema.table(
+  "life_circadian_states",
+  {
+    agentId: text("agent_id").primaryKey(),
+    circadianState: text("circadian_state").notNull().default("unclear"),
+    stateConfidence: real("state_confidence").notNull().default(0),
+    uncertaintyReason: text("uncertainty_reason"),
+    enteredAt: text("entered_at").notNull(),
+    sinceSleepDetectedAt: text("since_sleep_detected_at"),
+    sinceWakeObservedAt: text("since_wake_observed_at"),
+    sinceWakeConfirmedAt: text("since_wake_confirmed_at"),
+    evidenceRefsJson: text("evidence_refs_json").notNull().default("[]"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    index("idx_life_circadian_states_updated").on(t.agentId, t.updatedAt)
+  ]
+);
+const lifeScheduleInsights = appLifeopsPgSchema.table(
+  "life_schedule_insights",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    effectiveDayKey: text("effective_day_key").notNull(),
+    localDate: text("local_date").notNull(),
+    timezone: text("timezone").notNull(),
+    inferredAt: text("inferred_at").notNull(),
+    // Canonical circadian state - default `unclear` so migrations on existing
+    // rows succeed; new rows always write the real value from the scorer.
+    circadianState: text("circadian_state").notNull().default("unclear"),
+    stateConfidence: real("state_confidence").notNull().default(0),
+    uncertaintyReason: text("uncertainty_reason"),
+    sleepStatus: text("sleep_status").notNull(),
+    sleepConfidence: real("sleep_confidence").notNull().default(0),
+    currentSleepStartedAt: text("current_sleep_started_at"),
+    lastSleepStartedAt: text("last_sleep_started_at"),
+    lastSleepEndedAt: text("last_sleep_ended_at"),
+    lastSleepDurationMinutes: integer("last_sleep_duration_minutes"),
+    wakeAt: text("wake_at"),
+    firstActiveAt: text("first_active_at"),
+    lastActiveAt: text("last_active_at"),
+    lastMealAt: text("last_meal_at"),
+    nextMealLabel: text("next_meal_label"),
+    nextMealWindowStartAt: text("next_meal_window_start_at"),
+    nextMealWindowEndAt: text("next_meal_window_end_at"),
+    nextMealConfidence: real("next_meal_confidence").notNull().default(0),
+    mealsJson: text("meals_json").notNull().default("[]"),
+    awakeProbabilityJson: text("awake_probability_json").notNull().default("{}"),
+    regularityJson: text("regularity_json").notNull().default("{}"),
+    baselineJson: text("baseline_json"),
+    /**
+     * Scorer rule firings that fed this insight, as a JSON array of
+     * `LifeOpsCircadianRuleFiring`. Surfaced by the inspection UI so the
+     * user can see exactly which rules drove the current state.
+     */
+    circadianRuleFiringsJson: text("circadian_rule_firings_json").notNull().default("[]"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.effectiveDayKey)]
+);
+const lifeScheduleObservations = appLifeopsPgSchema.table(
+  "life_schedule_observations",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    origin: text("origin").notNull(),
+    deviceId: text("device_id").notNull(),
+    deviceKind: text("device_kind").notNull(),
+    timezone: text("timezone").notNull(),
+    observedAt: text("observed_at").notNull(),
+    windowStartAt: text("window_start_at").notNull(),
+    windowEndAt: text("window_end_at"),
+    // Default `unclear` so ADD COLUMN migrations succeed on tables with rows.
+    circadianState: text("circadian_state").notNull().default("unclear"),
+    stateConfidence: real("state_confidence").notNull().default(0),
+    uncertaintyReason: text("uncertainty_reason"),
+    mealLabel: text("meal_label"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  }
+);
+const lifeScheduleMergedStates = appLifeopsPgSchema.table(
+  "life_schedule_merged_states",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    scope: text("scope").notNull(),
+    effectiveDayKey: text("effective_day_key").notNull(),
+    localDate: text("local_date").notNull(),
+    timezone: text("timezone").notNull(),
+    mergedAt: text("merged_at").notNull(),
+    inferredAt: text("inferred_at").notNull(),
+    circadianState: text("circadian_state").notNull().default("unclear"),
+    stateConfidence: real("state_confidence").notNull().default(0),
+    uncertaintyReason: text("uncertainty_reason"),
+    sleepStatus: text("sleep_status").notNull(),
+    sleepConfidence: real("sleep_confidence").notNull().default(0),
+    currentSleepStartedAt: text("current_sleep_started_at"),
+    lastSleepStartedAt: text("last_sleep_started_at"),
+    lastSleepEndedAt: text("last_sleep_ended_at"),
+    lastSleepDurationMinutes: integer("last_sleep_duration_minutes"),
+    wakeAt: text("wake_at"),
+    firstActiveAt: text("first_active_at"),
+    lastActiveAt: text("last_active_at"),
+    lastMealAt: text("last_meal_at"),
+    nextMealLabel: text("next_meal_label"),
+    nextMealWindowStartAt: text("next_meal_window_start_at"),
+    nextMealWindowEndAt: text("next_meal_window_end_at"),
+    nextMealConfidence: real("next_meal_confidence").notNull().default(0),
+    mealsJson: text("meals_json").notNull().default("[]"),
+    awakeProbabilityJson: text("awake_probability_json").notNull().default("{}"),
+    regularityJson: text("regularity_json").notNull().default("{}"),
+    baselineJson: text("baseline_json"),
+    circadianRuleFiringsJson: text("circadian_rule_firings_json").notNull().default("[]"),
+    observationCount: integer("observation_count").notNull().default(0),
+    deviceCount: integer("device_count").notNull().default(0),
+    contributingDeviceKindsJson: text("contributing_device_kinds_json").notNull().default("[]"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [unique().on(t.agentId, t.scope, t.timezone)]
+);
+const lifeSchedulingNegotiations = appLifeopsPgSchema.table(
+  "life_scheduling_negotiations",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    relationshipId: text("relationship_id"),
+    subject: text("subject").notNull(),
+    state: text("state").notNull(),
+    durationMinutes: integer("duration_minutes").notNull().default(30),
+    timezone: text("timezone").notNull(),
+    acceptedProposalId: text("accepted_proposal_id"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    startedAt: text("started_at").notNull(),
+    finalizedAt: text("finalized_at"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  }
+);
+const lifeSchedulingProposals = appLifeopsPgSchema.table(
+  "life_scheduling_proposals",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    negotiationId: text("negotiation_id").notNull(),
+    startAt: text("start_at").notNull(),
+    endAt: text("end_at").notNull(),
+    status: text("status").notNull(),
+    proposedBy: text("proposed_by").notNull(),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  }
+);
+const lifeActivityEvents = appLifeopsPgSchema.table(
+  "life_activity_events",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    observedAt: text("observed_at").notNull(),
+    eventKind: text("event_kind").notNull(),
+    bundleId: text("bundle_id").notNull(),
+    appName: text("app_name").notNull(),
+    windowTitle: text("window_title"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    createdAt: text("created_at").notNull()
+  }
+);
+const lifeBlockRules = appLifeopsPgSchema.table("life_block_rules", {
+  id: uuid("id").primaryKey(),
+  agentId: uuid("agent_id").notNull(),
+  profile: text("profile").notNull(),
+  websites: jsonb("websites").notNull(),
+  gateType: text("gate_type").notNull(),
+  gateTodoId: text("gate_todo_id"),
+  gateUntilMs: bigint("gate_until_ms", { mode: "number" }),
+  fixedDurationMs: bigint("fixed_duration_ms", { mode: "number" }),
+  unlockDurationMs: bigint("unlock_duration_ms", { mode: "number" }),
+  active: boolean("active").default(true),
+  createdAt: bigint("created_at", { mode: "number" }).notNull(),
+  releasedAt: bigint("released_at", { mode: "number" }),
+  releasedReason: text("released_reason")
+});
+const lifeScheduledTasks = appLifeopsPgSchema.table(
+  "life_scheduled_tasks",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    kind: text("kind").notNull(),
+    promptInstructions: text("prompt_instructions").notNull(),
+    contextRequestJson: text("context_request_json"),
+    triggerJson: text("trigger_json").notNull(),
+    priority: text("priority").notNull().default("medium"),
+    shouldFireJson: text("should_fire_json"),
+    completionCheckJson: text("completion_check_json"),
+    escalationJson: text("escalation_json"),
+    outputJson: text("output_json"),
+    pipelineJson: text("pipeline_json"),
+    subjectKind: text("subject_kind"),
+    subjectId: text("subject_id"),
+    idempotencyKey: text("idempotency_key"),
+    respectsGlobalPause: boolean("respects_global_pause").notNull().default(true),
+    stateJson: text("state_json").notNull().default("{}"),
+    source: text("source").notNull().default("user_chat"),
+    createdBy: text("created_by").notNull().default(""),
+    ownerVisible: boolean("owner_visible").notNull().default(true),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    // Optimistic concurrency version. Incremented on each update.
+    // Used by withTransaction-wrapped operations to detect concurrent updates
+    // and surface OptimisticLockError instead of silently overwriting.
+    version: integer("version").notNull().default(1),
+    // Indexed earliest-next-fire timestamp. Computed by the runner on each
+    // mutation that changes the firing window (schedule, fire, snooze, edit)
+    // for `cron` / `interval` / `relative_to_anchor` / `during_window` /
+    // `once` triggers. NULL for `event`, `manual`, and `after_task` triggers
+    // (those wake on signal, not on a wall-clock time). The scheduler tick
+    // filters by this column instead of loading every row.
+    nextFireAt: timestamp("next_fire_at", { withTimezone: true }),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => [
+    unique().on(t.agentId, t.idempotencyKey),
+    index("idx_life_scheduled_tasks_agent_kind").on(t.agentId, t.kind),
+    index("idx_life_scheduled_tasks_subject").on(
+      t.agentId,
+      t.subjectKind,
+      t.subjectId
+    ),
+    // Partial index supporting the per-tick due-task scan: live tasks only
+    // (`scheduled` or `fired`), ordered by their next fire-at time.
+    index("idx_life_scheduled_tasks_due").on(t.agentId, t.nextFireAt).where(sql`(state_json::jsonb ->> 'status') IN ('scheduled', 'fired')`)
+  ]
+);
+const lifeScheduledTaskLog = appLifeopsPgSchema.table(
+  "life_scheduled_task_log",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    taskId: text("task_id").notNull(),
+    occurredAt: text("occurred_at").notNull(),
+    transition: text("transition").notNull(),
+    reason: text("reason"),
+    rolledUp: boolean("rolled_up").notNull().default(false),
+    detailJson: text("detail_json")
+  },
+  (t) => [
+    index("idx_life_scheduled_task_log_agent_task").on(t.agentId, t.taskId),
+    index("idx_life_scheduled_task_log_agent_time").on(t.agentId, t.occurredAt)
+  ]
+);
+const lifeWorkThreads = appLifeopsPgSchema.table(
+  "life_work_threads",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    ownerEntityId: text("owner_entity_id"),
+    status: text("status").notNull().default("active"),
+    title: text("title").notNull().default(""),
+    summary: text("summary").notNull().default(""),
+    currentPlanSummary: text("current_plan_summary"),
+    primarySourceRefJson: text("primary_source_ref_json").notNull(),
+    sourceRefsJson: text("source_refs_json").notNull().default("[]"),
+    participantEntityIdsJson: text("participant_entity_ids_json").notNull().default("[]"),
+    currentScheduledTaskId: text("current_scheduled_task_id"),
+    workflowRunId: text("workflow_run_id"),
+    approvalId: text("approval_id"),
+    lastMessageMemoryId: text("last_message_memory_id"),
+    metadataJson: text("metadata_json").notNull().default("{}"),
+    // Optimistic concurrency version. Incremented on each update.
+    // Used by withTransaction-wrapped operations to detect concurrent updates
+    // (e.g., two simultaneous merges) and surface OptimisticLockError instead
+    // of silently overwriting one merge's sourceRefs with the other.
+    version: integer("version").notNull().default(1),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    lastActivityAt: text("last_activity_at").notNull()
+  },
+  (t) => [
+    index("idx_life_work_threads_agent_status").on(t.agentId, t.status),
+    index("idx_life_work_threads_agent_owner").on(
+      t.agentId,
+      t.ownerEntityId,
+      t.status
+    ),
+    index("idx_life_work_threads_agent_activity").on(
+      t.agentId,
+      t.lastActivityAt
+    )
+  ]
+);
+const lifeWorkThreadEvents = appLifeopsPgSchema.table(
+  "life_work_thread_events",
+  {
+    id: text("id").primaryKey(),
+    agentId: text("agent_id").notNull(),
+    workThreadId: text("work_thread_id").notNull(),
+    occurredAt: text("occurred_at").notNull(),
+    type: text("type").notNull(),
+    reason: text("reason"),
+    detailJson: text("detail_json")
+  },
+  (t) => [
+    index("idx_life_work_thread_events_thread").on(
+      t.agentId,
+      t.workThreadId,
+      t.occurredAt
+    )
+  ]
+);
+const lifeOpsSchema = {
+  lifeConnectorGrants,
+  lifeAccountPrivacy,
+  lifeTaskDefinitions,
+  lifeTaskOccurrences,
+  lifeGoalDefinitions,
+  lifeGoalLinks,
+  lifeReminderPlans,
+  lifeReminderAttempts,
+  lifeAuditEvents,
+  lifeEmailUnsubscribes,
+  lifeActivitySignals,
+  lifeHealthMetricSamples,
+  lifeHealthWorkouts,
+  lifeHealthSyncStates,
+  lifeHealthSleepEpisodes,
+  lifeChannelPolicies,
+  lifeWebsiteAccessGrants,
+  lifeCalendarEvents,
+  lifeCalendarSyncStates,
+  lifeGmailMessages,
+  lifeInboxMessages,
+  lifeGmailSyncStates,
+  lifeGmailSpamReviewItems,
+  lifeWorkflowDefinitions,
+  lifeWorkflowRuns,
+  lifeWorkflowBrowserSessions,
+  lifeEscalationStates,
+  lifeIntents,
+  lifeCheckinReports,
+  lifeRelationshipInteractions,
+  // life_entities / life_entity_* / life_relationships_v2 /
+  // life_relationship_audit_events are now owned by the runtime
+  // (`@elizaos/agent` KnowledgeGraphService schema) — registered there,
+  // not here, to avoid double-registration of the same app_lifeops tables.
+  lifeInboxTriageEntries,
+  lifeInboxTriageExamples,
+  lifeXDms,
+  lifeXFeedItems,
+  lifeXSyncStates,
+  lifeScreenTimeSessions,
+  lifeScreenTimeDaily,
+  lifeSleepEpisodes,
+  lifeCircadianStates,
+  lifeTelemetryEvents,
+  lifeTelemetryRollupDaily,
+  lifeScheduleInsights,
+  lifeScheduleObservations,
+  lifeScheduleMergedStates,
+  lifeActivityEvents,
+  lifeSchedulingNegotiations,
+  lifeSchedulingProposals,
+  lifeBlockRules,
+  lifeScheduledTasks,
+  lifeScheduledTaskLog,
+  lifeWorkThreads,
+  lifeWorkThreadEvents,
+  lifeopsFeaturesTable
+};
+import { z } from "zod";
+const isoString = z.string().min(1).refine(
+  (v) => !Number.isNaN(new Date(v).getTime()),
+  "must be an ISO timestamp"
+);
+const terminalStateSchema = z.enum([
+  "completed",
+  "skipped",
+  "expired",
+  "failed",
+  "dismissed"
+]);
+const scheduledTaskKindSchema = z.enum([
+  "reminder",
+  "checkin",
+  "followup",
+  "approval",
+  "recap",
+  "watcher",
+  "output",
+  "custom"
+]);
+const scheduledTaskPrioritySchema = z.enum(["low", "medium", "high"]);
+const scheduledTaskSourceSchema = z.enum([
+  "default_pack",
+  "user_chat",
+  "first_run",
+  "plugin"
+]);
+const scheduledTaskSubjectSchema = z.object({
+  kind: z.enum([
+    "entity",
+    "relationship",
+    "thread",
+    "document",
+    "calendar_event",
+    "self"
+  ]),
+  id: z.string().min(1)
+});
+const scheduledTaskTriggerSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("once"), atIso: isoString }),
+  z.object({
+    kind: z.literal("cron"),
+    expression: z.string().min(1),
+    tz: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal("interval"),
+    everyMinutes: z.number().int().positive(),
+    from: isoString.optional(),
+    until: isoString.optional()
+  }),
+  z.object({
+    kind: z.literal("relative_to_anchor"),
+    anchorKey: z.string().min(1),
+    offsetMinutes: z.number().int()
+  }),
+  z.object({
+    kind: z.literal("during_window"),
+    windowKey: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal("event"),
+    eventKind: z.string().min(1),
+    filter: z.unknown().optional()
+  }),
+  z.object({ kind: z.literal("manual") }),
+  z.object({
+    kind: z.literal("after_task"),
+    taskId: z.string().min(1),
+    outcome: terminalStateSchema
+  })
+]);
+const scheduledTaskShouldFireSchema = z.object({
+  compose: z.enum(["all", "any", "first_deny"]).optional(),
+  gates: z.array(
+    z.object({
+      kind: z.string().min(1),
+      params: z.unknown().optional()
+    })
+  ).min(1)
+});
+const scheduledTaskCompletionCheckSchema = z.object({
+  kind: z.string().min(1),
+  params: z.unknown().optional(),
+  followupAfterMinutes: z.number().int().positive().optional()
+});
+const escalationStepSchema = z.object({
+  delayMinutes: z.number().int().min(0),
+  channelKey: z.string().min(1),
+  intensity: z.enum(["soft", "normal", "urgent"]).optional()
+});
+const scheduledTaskEscalationSchema = z.object({
+  ladderKey: z.string().min(1).optional(),
+  steps: z.array(escalationStepSchema).optional()
+});
+const scheduledTaskOutputSchema = z.object({
+  destination: z.enum([
+    "in_app_card",
+    "channel",
+    "apple_notes",
+    "gmail_draft",
+    "memory"
+  ]),
+  target: z.string().min(1).optional(),
+  persistAs: z.enum(["task_metadata", "external_only"]).optional()
+});
+const scheduledTaskRefSchema = z.lazy(
+  () => z.union([z.string().min(1), scheduledTaskInputBaseSchema])
+);
+const scheduledTaskPipelineSchema = z.object({
+  onComplete: z.array(scheduledTaskRefSchema).optional(),
+  onSkip: z.array(scheduledTaskRefSchema).optional(),
+  onFail: z.array(scheduledTaskRefSchema).optional()
+});
+const scheduledTaskContextRequestSchema = z.object({
+  includeOwnerFacts: z.array(
+    z.enum([
+      "preferredName",
+      "timezone",
+      "morningWindow",
+      "eveningWindow",
+      "locale"
+    ])
+  ).optional(),
+  includeEntities: z.object({
+    entityIds: z.array(z.string().min(1)),
+    fields: z.array(
+      z.enum([
+        "preferredName",
+        "type",
+        "identities",
+        "state.lastInteractionPlatform"
+      ])
+    ).optional()
+  }).optional(),
+  includeRelationships: z.object({
+    relationshipIds: z.array(z.string().min(1)).optional(),
+    forEntityIds: z.array(z.string().min(1)).optional(),
+    types: z.array(z.string().min(1)).optional()
+  }).optional(),
+  includeRecentTaskStates: z.object({
+    kind: scheduledTaskKindSchema.optional(),
+    lookbackHours: z.number().int().positive().optional()
+  }).optional(),
+  includeEventPayload: z.boolean().optional()
+});
+const scheduledTaskInputBaseSchema = z.object({
+  kind: scheduledTaskKindSchema,
+  promptInstructions: z.string().min(1),
+  contextRequest: scheduledTaskContextRequestSchema.optional(),
+  trigger: scheduledTaskTriggerSchema,
+  priority: scheduledTaskPrioritySchema,
+  shouldFire: scheduledTaskShouldFireSchema.optional(),
+  completionCheck: scheduledTaskCompletionCheckSchema.optional(),
+  escalation: scheduledTaskEscalationSchema.optional(),
+  output: scheduledTaskOutputSchema.optional(),
+  pipeline: scheduledTaskPipelineSchema.optional(),
+  subject: scheduledTaskSubjectSchema.optional(),
+  idempotencyKey: z.string().min(1).optional(),
+  respectsGlobalPause: z.boolean(),
+  source: scheduledTaskSourceSchema,
+  createdBy: z.string().min(1),
+  ownerVisible: z.boolean(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+const scheduledTaskInputSchema = scheduledTaskInputBaseSchema;
+const scheduledTaskStateSchema = z.object({
+  status: z.enum([
+    "completed",
+    "skipped",
+    "expired",
+    "failed",
+    "dismissed",
+    "scheduled",
+    "fired",
+    "acknowledged"
+  ]),
+  firedAt: isoString.optional(),
+  acknowledgedAt: isoString.optional(),
+  completedAt: isoString.optional(),
+  followupCount: z.number().int().min(0),
+  lastFollowupAt: isoString.optional(),
+  pipelineParentId: z.string().min(1).optional(),
+  lastDecisionLog: z.string().optional()
+});
+const scheduledTaskSchema = scheduledTaskInputBaseSchema.extend({
+  taskId: z.string().min(1),
+  state: scheduledTaskStateSchema
+});
+const scheduledTaskVerbSchema = z.enum([
+  "snooze",
+  "skip",
+  "complete",
+  "dismiss",
+  "escalate",
+  "acknowledge",
+  "edit",
+  "reopen"
+]);
+const scheduledTaskSnoozePayloadSchema = z.object({
+  minutes: z.number().int().positive().optional(),
+  untilIso: isoString.optional()
+}).refine(
+  (v) => typeof v.minutes === "number" || typeof v.untilIso === "string",
+  "snooze: provide minutes or untilIso"
+);
+const scheduledTaskFilterSchema = z.object({
+  kind: scheduledTaskKindSchema.optional(),
+  status: z.union([
+    scheduledTaskStateSchema.shape.status,
+    z.array(scheduledTaskStateSchema.shape.status)
+  ]).optional(),
+  subject: scheduledTaskSubjectSchema.optional(),
+  source: scheduledTaskSourceSchema.optional(),
+  firedSince: isoString.optional(),
+  ownerVisibleOnly: z.boolean().optional()
+});
+export {
+  appLifeopsPgSchema,
+  lifeAccountPrivacy,
+  lifeActivityEvents,
+  lifeActivitySignals,
+  lifeAuditEvents,
+  lifeBlockRules,
+  lifeCalendarEvents,
+  lifeCalendarSyncStates,
+  lifeChannelPolicies,
+  lifeCheckinReports,
+  lifeCircadianStates,
+  lifeConnectorGrants,
+  lifeEmailUnsubscribes,
+  lifeEscalationStates,
+  lifeGmailMessages,
+  lifeGmailSpamReviewItems,
+  lifeGmailSyncStates,
+  lifeGoalDefinitions,
+  lifeGoalLinks,
+  lifeHealthMetricSamples,
+  lifeHealthSleepEpisodes,
+  lifeHealthSyncStates,
+  lifeHealthWorkouts,
+  lifeInboxMessages,
+  lifeInboxTriageEntries,
+  lifeInboxTriageExamples,
+  lifeIntents,
+  lifeOpsSchema,
+  lifeRelationshipInteractions,
+  lifeReminderAttempts,
+  lifeReminderPlans,
+  lifeScheduleInsights,
+  lifeScheduleMergedStates,
+  lifeScheduleObservations,
+  lifeScheduledTaskLog,
+  lifeScheduledTasks,
+  lifeSchedulingNegotiations,
+  lifeSchedulingProposals,
+  lifeScreenTimeDaily,
+  lifeScreenTimeSessions,
+  lifeSleepEpisodes,
+  lifeTaskDefinitions,
+  lifeTaskOccurrences,
+  lifeTelemetryEvents,
+  lifeTelemetryRollupDaily,
+  lifeWebsiteAccessGrants,
+  lifeWorkThreadEvents,
+  lifeWorkThreads,
+  lifeWorkflowBrowserSessions,
+  lifeWorkflowDefinitions,
+  lifeWorkflowRuns,
+  lifeXDms,
+  lifeXFeedItems,
+  lifeXSyncStates,
+  lifeopsFeaturesTable,
+  scheduledTaskFilterSchema,
+  scheduledTaskInputSchema,
+  scheduledTaskSchema,
+  scheduledTaskSnoozePayloadSchema,
+  scheduledTaskStateSchema,
+  scheduledTaskVerbSchema
+};
+//# sourceMappingURL=schema.js.map