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

package/dist/lifeops/repository.d.ts

@@ -0,0 +1,638 @@
+import { type EntityStore, type RelationshipStore } from "@elizaos/agent";
+import type { IAgentRuntime } from "@elizaos/core";
+import type { BrowserBridgeCompanionStatus, BrowserBridgePageContext, BrowserBridgeSettings, BrowserBridgeTabSummary } from "@elizaos/plugin-browser";
+import type { LifeOpsScheduleMergedState, LifeOpsScheduleObservation } from "@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-contracts";
+import type { LifeOpsPaymentSource, LifeOpsPaymentTransaction } from "@elizaos/plugin-finances/payment-types";
+import type { LifeOpsSubscriptionAudit, LifeOpsSubscriptionCancellation, LifeOpsSubscriptionCandidate } from "@elizaos/plugin-finances/subscriptions-types";
+import type { LifeOpsXDm, LifeOpsXFeedItem, LifeOpsXFeedType, LifeOpsXSyncState } from "@elizaos/shared";
+import { type LifeOpsActivitySignal, type LifeOpsAuditEvent, type LifeOpsBrowserSession, type LifeOpsCalendarEvent, type LifeOpsChannelPolicy, type LifeOpsCircadianState, type LifeOpsConnectorGrant, type LifeOpsConnectorSide, type LifeOpsGmailMessageSummary, type LifeOpsGmailSpamReviewItem, type LifeOpsGmailSpamReviewStatus, type LifeOpsGoalDefinition, type LifeOpsGoalLink, type LifeOpsHealthMetricSample, type LifeOpsHealthSleepEpisode, type LifeOpsHealthSyncState, type LifeOpsHealthWorkout, type LifeOpsInboxChannel, type LifeOpsInboxMessage, type LifeOpsOccurrence, type LifeOpsOccurrenceView, type LifeOpsRelationshipInteraction, type LifeOpsReminderAttempt, type LifeOpsReminderPlan, type LifeOpsScheduleInsight, type LifeOpsSchedulingNegotiation, type LifeOpsSchedulingProposal, type LifeOpsScreenTimeDaily, type LifeOpsScreenTimeSession, type LifeOpsTaskDefinition, type LifeOpsTelemetryEvent, type LifeOpsTelemetryFamily, type LifeOpsUnclearReason, type LifeOpsWorkflowDefinition, type LifeOpsWorkflowRun } from "../contracts/index.js";
+import { type LifeOpsConnectorAccountPrivacyPolicy } from "./privacy-egress.js";
+import { type TransactionalDb } from "./sql.js";
+type BrowserCompanionCredential = {
+    companion: BrowserBridgeCompanionStatus;
+    pairingTokenHash: string | null;
+    pendingPairingTokens: BrowserCompanionPendingPairingToken[];
+    pendingPairingTokenHashes: string[];
+};
+type BrowserCompanionPendingPairingToken = {
+    hash: string;
+    expiresAt: string | null;
+};
+export interface LifeOpsWebsiteAccessGrant {
+    id: string;
+    agentId: string;
+    groupKey: string;
+    definitionId: string;
+    occurrenceId: string | null;
+    websites: string[];
+    unlockMode: "fixed_duration" | "until_manual_lock" | "until_callback";
+    unlockDurationMinutes: number | null;
+    callbackKey: string | null;
+    unlockedAt: string;
+    expiresAt: string | null;
+    revokedAt: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface LifeOpsScheduleInsightRecord extends LifeOpsScheduleInsight {
+    id: string;
+    agentId: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface LifeOpsScheduleObservationRecord extends LifeOpsScheduleObservation {
+}
+export interface LifeOpsScheduleMergedStateRecord extends LifeOpsScheduleMergedState {
+}
+export { createLifeOpsHealthMetricSample, createLifeOpsHealthSleepEpisode, createLifeOpsHealthSyncState, createLifeOpsHealthWorkout, } from "@elizaos/plugin-health/health-bridge/health-records";
+export type { LifeOpsPersistedSleepEpisodeSource, LifeOpsSleepEpisodeRecord, } from "@elizaos/plugin-health/sleep/sleep-episode-types";
+export { createLifeOpsSleepEpisode } from "@elizaos/plugin-health/sleep/sleep-episode-types";
+import type { LifeOpsSleepEpisodeRecord } from "@elizaos/plugin-health/sleep/sleep-episode-types";
+export interface LifeOpsCachedInboxMessage extends LifeOpsInboxMessage {
+    cachedAt: string;
+    updatedAt: string;
+    priorityFlags: string[];
+}
+type LifeOpsInboxCacheWriteMessage = LifeOpsInboxMessage & {
+    priorityFlags?: readonly string[];
+};
+interface LifeOpsCalendarSyncState {
+    id: string;
+    agentId: string;
+    provider: LifeOpsConnectorGrant["provider"];
+    side: LifeOpsConnectorSide;
+    calendarId: string;
+    windowStartAt: string;
+    windowEndAt: string;
+    syncedAt: string;
+    updatedAt: string;
+}
+interface LifeOpsGmailSyncState {
+    id: string;
+    agentId: string;
+    provider: LifeOpsConnectorGrant["provider"];
+    side: LifeOpsConnectorSide;
+    mailbox: string;
+    grantId: string;
+    maxResults: number;
+    syncedAt: string;
+    updatedAt: string;
+}
+export interface LifeOpsEscalationStateRow {
+    id: string;
+    agentId: string;
+    reason: string;
+    text: string;
+    currentStep: number;
+    channelsSent: string[];
+    startedAt: string;
+    lastSentAt: string;
+    resolved: boolean;
+    resolvedAt: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface LifeOpsCircadianStateRow {
+    agentId: string;
+    circadianState: LifeOpsCircadianState;
+    stateConfidence: number;
+    uncertaintyReason: LifeOpsUnclearReason | null;
+    enteredAt: string;
+    sinceSleepDetectedAt: string | null;
+    sinceWakeObservedAt: string | null;
+    sinceWakeConfirmedAt: string | null;
+    evidenceRefs: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class LifeOpsRepository {
+    private readonly runtime;
+    /**
+     * Per-agent counter for telemetry-mirror failures inside
+     * {@link createActivitySignal}. The live signal insert is the primary
+     * source of truth; mirror failures must not block persistence, but we
+     * still want visibility when the mirror is broken. First failure logs,
+     * then we throttle to once every 100 failures so a broken backend
+     * doesn't flood logs.
+     */
+    private static telemetryMirrorFailures;
+    /**
+     * Finance back-end repository. The finance tables (payment sources /
+     * transactions, subscription audits / candidates / cancellations) moved to
+     * @elizaos/plugin-finances; the finance methods below delegate here so the
+     * subscriptions mixin keeps reaching them through `this.repository`.
+     */
+    private readonly financesRepo;
+    constructor(runtime: IAgentRuntime);
+    /**
+     * EntityStore / RelationshipStore accessors for the typed graph. The
+     * knowledge graph is a runtime primitive owned by `@elizaos/agent`; these
+     * factories resolve the per-agent stores from the registered
+     * `KnowledgeGraphService` rather than constructing them directly.
+     */
+    private knowledgeGraph;
+    entityStore(agentId: string): Promise<EntityStore>;
+    relationshipStore(agentId: string): Promise<RelationshipStore>;
+    static bootstrapSchema(runtime: IAgentRuntime): Promise<void>;
+    static ensureSchedulingNegotiationColumns(runtime: IAgentRuntime): Promise<void>;
+    static ensureActivitySignalColumns(runtime: IAgentRuntime): Promise<void>;
+    static ensureBrowserBridgeCompanionTokenColumns(runtime: IAgentRuntime): Promise<void>;
+    static ensureReminderReviewColumns(runtime: IAgentRuntime): Promise<void>;
+    static ensureConnectorAccountColumns(runtime: IAgentRuntime): Promise<void>;
+    static ensureInboxCacheIndexes(runtime: IAgentRuntime): Promise<void>;
+    createDefinition(definition: LifeOpsTaskDefinition): Promise<void>;
+    updateDefinition(definition: LifeOpsTaskDefinition): Promise<void>;
+    getDefinition(agentId: string, definitionId: string): Promise<LifeOpsTaskDefinition | null>;
+    listDefinitions(agentId: string): Promise<LifeOpsTaskDefinition[]>;
+    listActiveDefinitions(agentId: string): Promise<LifeOpsTaskDefinition[]>;
+    deleteDefinition(agentId: string, definitionId: string): Promise<void>;
+    upsertOccurrence(occurrence: LifeOpsOccurrence): Promise<void>;
+    listOccurrencesForDefinition(agentId: string, definitionId: string): Promise<LifeOpsOccurrence[]>;
+    listOccurrencesForDefinitions(agentId: string, definitionIds: string[]): Promise<LifeOpsOccurrence[]>;
+    getOccurrence(agentId: string, occurrenceId: string): Promise<LifeOpsOccurrence | null>;
+    getOccurrenceView(agentId: string, occurrenceId: string): Promise<LifeOpsOccurrenceView | null>;
+    listOccurrenceViewsForOverview(agentId: string, horizonIso: string): Promise<LifeOpsOccurrenceView[]>;
+    updateOccurrence(occurrence: LifeOpsOccurrence): Promise<void>;
+    pruneNonTerminalOccurrences(agentId: string, definitionId: string, keepOccurrenceKeys: string[]): Promise<void>;
+    createGoal(goal: LifeOpsGoalDefinition): Promise<void>;
+    updateGoal(goal: LifeOpsGoalDefinition): Promise<void>;
+    getGoal(agentId: string, goalId: string): Promise<LifeOpsGoalDefinition | null>;
+    listGoals(agentId: string): Promise<LifeOpsGoalDefinition[]>;
+    deleteGoal(agentId: string, goalId: string): Promise<void>;
+    upsertGoalLink(link: LifeOpsGoalLink): Promise<void>;
+    deleteGoalLinksForLinked(agentId: string, linkedType: LifeOpsGoalLink["linkedType"], linkedId: string): Promise<void>;
+    listGoalLinksForGoal(agentId: string, goalId: string): Promise<LifeOpsGoalLink[]>;
+    createReminderPlan(plan: LifeOpsReminderPlan): Promise<void>;
+    updateReminderPlan(plan: LifeOpsReminderPlan): Promise<void>;
+    deleteReminderPlan(agentId: string, planId: string): Promise<void>;
+    getReminderPlan(agentId: string, planId: string): Promise<LifeOpsReminderPlan | null>;
+    listReminderPlansForOwners(agentId: string, ownerType: string, ownerIds: string[]): Promise<LifeOpsReminderPlan[]>;
+    createAuditEvent(event: LifeOpsAuditEvent): Promise<void>;
+    /**
+     * Returns `true` when the audit row for this id was newly inserted, `false`
+     * when the id already existed. Used by circadian event emission to dedupe
+     * across runtime restarts (same state transition -> same id).
+     */
+    createAuditEventIfNew(event: LifeOpsAuditEvent): Promise<boolean>;
+    listAuditEvents(agentId: string, ownerType: string, ownerId: string): Promise<LifeOpsAuditEvent[]>;
+    createSubscriptionAudit(audit: LifeOpsSubscriptionAudit): Promise<void>;
+    updateSubscriptionAudit(audit: LifeOpsSubscriptionAudit): Promise<void>;
+    getSubscriptionAudit(agentId: string, auditId: string): Promise<LifeOpsSubscriptionAudit | null>;
+    getLatestSubscriptionAudit(agentId: string): Promise<LifeOpsSubscriptionAudit | null>;
+    createSubscriptionCandidate(candidate: LifeOpsSubscriptionCandidate): Promise<void>;
+    listSubscriptionCandidatesForAudit(agentId: string, auditId: string): Promise<LifeOpsSubscriptionCandidate[]>;
+    getSubscriptionCandidate(agentId: string, candidateId: string): Promise<LifeOpsSubscriptionCandidate | null>;
+    createSubscriptionCancellation(cancellation: LifeOpsSubscriptionCancellation): Promise<void>;
+    updateSubscriptionCancellation(cancellation: LifeOpsSubscriptionCancellation): Promise<void>;
+    getSubscriptionCancellation(agentId: string, cancellationId: string): Promise<LifeOpsSubscriptionCancellation | null>;
+    getLatestSubscriptionCancellation(agentId: string, serviceSlug?: string): Promise<LifeOpsSubscriptionCancellation | null>;
+    upsertPaymentSource(source: LifeOpsPaymentSource): Promise<void>;
+    listPaymentSources(agentId: string): Promise<LifeOpsPaymentSource[]>;
+    getPaymentSource(agentId: string, sourceId: string): Promise<LifeOpsPaymentSource | null>;
+    deletePaymentSource(agentId: string, sourceId: string): Promise<void>;
+    deletePaymentTransactionById(agentId: string, transactionId: string): Promise<void>;
+    insertPaymentTransaction(transaction: LifeOpsPaymentTransaction): Promise<boolean>;
+    listPaymentTransactions(agentId: string, args?: {
+        sourceId?: string | null;
+        sinceAt?: string | null;
+        untilAt?: string | null;
+        limit?: number | null;
+        merchantContains?: string | null;
+        onlyDebits?: boolean | null;
+    }): Promise<LifeOpsPaymentTransaction[]>;
+    countPaymentTransactionsForSource(agentId: string, sourceId: string): Promise<number>;
+    createActivitySignal(signal: LifeOpsActivitySignal): Promise<void>;
+    listActivitySignals(agentId: string, args?: {
+        sinceAt?: string | null;
+        limit?: number | null;
+        states?: LifeOpsActivitySignal["state"][] | null;
+    }): Promise<LifeOpsActivitySignal[]>;
+    upsertHealthMetricSample(sample: LifeOpsHealthMetricSample): Promise<void>;
+    listHealthMetricSamples(agentId: string, args?: {
+        provider?: LifeOpsHealthMetricSample["provider"] | null;
+        startDate?: string | null;
+        endDate?: string | null;
+        metrics?: LifeOpsHealthMetricSample["metric"][] | null;
+        limit?: number | null;
+    }): Promise<LifeOpsHealthMetricSample[]>;
+    upsertHealthWorkout(workout: LifeOpsHealthWorkout): Promise<void>;
+    listHealthWorkouts(agentId: string, args?: {
+        provider?: LifeOpsHealthWorkout["provider"] | null;
+        startDate?: string | null;
+        endDate?: string | null;
+        limit?: number | null;
+    }): Promise<LifeOpsHealthWorkout[]>;
+    upsertHealthSleepEpisode(episode: LifeOpsHealthSleepEpisode): Promise<void>;
+    listHealthSleepEpisodes(agentId: string, args?: {
+        provider?: LifeOpsHealthSleepEpisode["provider"] | null;
+        startDate?: string | null;
+        endDate?: string | null;
+        limit?: number | null;
+    }): Promise<LifeOpsHealthSleepEpisode[]>;
+    upsertHealthSyncState(state: LifeOpsHealthSyncState): Promise<void>;
+    getHealthSyncState(agentId: string, provider: LifeOpsHealthSyncState["provider"], grantId: string): Promise<LifeOpsHealthSyncState | null>;
+    upsertChannelPolicy(policy: LifeOpsChannelPolicy): Promise<void>;
+    listChannelPolicies(agentId: string): Promise<LifeOpsChannelPolicy[]>;
+    getChannelPolicy(agentId: string, channelType: LifeOpsChannelPolicy["channelType"], channelRef: string): Promise<LifeOpsChannelPolicy | null>;
+    upsertWebsiteAccessGrant(grant: LifeOpsWebsiteAccessGrant): Promise<void>;
+    listWebsiteAccessGrants(agentId: string): Promise<LifeOpsWebsiteAccessGrant[]>;
+    revokeWebsiteAccessGrants(agentId: string, args: {
+        groupKey?: string;
+        callbackKey?: string;
+        revokedAt: string;
+    }): Promise<void>;
+    ensureConnectorAccountPrivacy(input: {
+        agentId: string;
+        provider: string;
+        connectorAccountId: string;
+    }): Promise<LifeOpsConnectorAccountPrivacyPolicy>;
+    upsertConnectorAccountPrivacy(input: LifeOpsConnectorAccountPrivacyPolicy): Promise<void>;
+    listConnectorAccountPrivacy(agentId: string): Promise<LifeOpsConnectorAccountPrivacyPolicy[]>;
+    getConnectorAccountPrivacy(agentId: string, provider: string, connectorAccountId: string): Promise<LifeOpsConnectorAccountPrivacyPolicy | null>;
+    upsertConnectorGrant(grant: LifeOpsConnectorGrant): Promise<void>;
+    listConnectorGrants(agentId: string): Promise<LifeOpsConnectorGrant[]>;
+    getConnectorGrant(agentId: string, provider: LifeOpsConnectorGrant["provider"], mode: LifeOpsConnectorGrant["mode"], side?: LifeOpsConnectorSide): Promise<LifeOpsConnectorGrant | null>;
+    deleteConnectorGrant(agentId: string, provider: LifeOpsConnectorGrant["provider"], mode?: LifeOpsConnectorGrant["mode"], side?: LifeOpsConnectorSide, grantId?: string): Promise<void>;
+    upsertCalendarEvent(event: LifeOpsCalendarEvent, side?: LifeOpsConnectorSide): Promise<void>;
+    deleteCalendarEventsForProvider(agentId: string, provider: LifeOpsConnectorGrant["provider"], calendarId?: string, side?: LifeOpsConnectorSide): Promise<void>;
+    deleteCalendarEventByExternalId(agentId: string, provider: LifeOpsConnectorGrant["provider"], calendarId: string | null | undefined, externalEventId: string, side?: LifeOpsConnectorSide): Promise<void>;
+    pruneCalendarEventsInWindow(agentId: string, provider: LifeOpsConnectorGrant["provider"], calendarId: string, timeMin: string, timeMax: string, keepExternalIds: readonly string[], side?: LifeOpsConnectorSide): Promise<void>;
+    listCalendarEvents(agentId: string, provider: LifeOpsConnectorGrant["provider"], timeMin?: string, timeMax?: string, side?: LifeOpsConnectorSide): Promise<LifeOpsCalendarEvent[]>;
+    /**
+     * Returns events whose `end_at` falls in (cursorEndAt, upToIso] OR
+     * (end_at == cursorEndAt AND id > cursorId). Ordered by (end_at, id) ascending
+     * so callers can advance a tuple cursor and never re-fire for the same event.
+     */
+    listCalendarEventsEndedAfterCursor(args: {
+        agentId: string;
+        provider: LifeOpsConnectorGrant["provider"];
+        side?: LifeOpsConnectorSide;
+        cursorEndAt: string | null;
+        cursorEventId: string | null;
+        upToIso: string;
+        limit: number;
+    }): Promise<LifeOpsCalendarEvent[]>;
+    upsertCalendarSyncState(state: LifeOpsCalendarSyncState): Promise<void>;
+    getCalendarSyncState(agentId: string, provider: LifeOpsConnectorGrant["provider"], calendarId: string, side?: LifeOpsConnectorSide): Promise<LifeOpsCalendarSyncState | null>;
+    deleteCalendarSyncState(agentId: string, provider: LifeOpsConnectorGrant["provider"], calendarId?: string, side?: LifeOpsConnectorSide): Promise<void>;
+    upsertGmailMessage(message: LifeOpsGmailMessageSummary, side?: LifeOpsConnectorSide): Promise<void>;
+    pruneGmailMessages(agentId: string, provider: LifeOpsConnectorGrant["provider"], keepExternalIds: readonly string[], side?: LifeOpsConnectorSide, grantId?: string): Promise<void>;
+    listGmailMessages(agentId: string, provider: LifeOpsConnectorGrant["provider"], options?: {
+        maxResults?: number;
+        threadId?: string;
+        since?: string;
+        grantId?: string;
+    }, side?: LifeOpsConnectorSide): Promise<LifeOpsGmailMessageSummary[]>;
+    getGmailMessage(agentId: string, provider: LifeOpsConnectorGrant["provider"], messageId: string, side?: LifeOpsConnectorSide, grantId?: string): Promise<LifeOpsGmailMessageSummary | null>;
+    upsertCachedInboxMessages(agentId: string, messages: readonly LifeOpsInboxCacheWriteMessage[]): Promise<void>;
+    listCachedInboxMessages(agentId: string, options?: {
+        channels?: readonly LifeOpsInboxChannel[];
+        maxResults?: number;
+        gmailAccountId?: string;
+    }): Promise<LifeOpsCachedInboxMessage[]>;
+    markCachedInboxMessageRead(agentId: string, messageId: string, readAt?: string): Promise<LifeOpsCachedInboxMessage | null>;
+    deleteGmailMessages(agentId: string, provider: LifeOpsConnectorGrant["provider"], messageIds: readonly string[], side?: LifeOpsConnectorSide, grantId?: string): Promise<void>;
+    deleteGmailMessagesForProvider(agentId: string, provider: LifeOpsConnectorGrant["provider"], side?: LifeOpsConnectorSide, grantId?: string): Promise<void>;
+    upsertGmailSyncState(state: LifeOpsGmailSyncState): Promise<void>;
+    getGmailSyncState(agentId: string, provider: LifeOpsConnectorGrant["provider"], mailbox: string, side?: LifeOpsConnectorSide, grantId?: string): Promise<LifeOpsGmailSyncState | null>;
+    deleteGmailSyncState(agentId: string, provider: LifeOpsConnectorGrant["provider"], mailbox?: string, side?: LifeOpsConnectorSide, grantId?: string): Promise<void>;
+    upsertGmailSpamReviewItem(item: LifeOpsGmailSpamReviewItem): Promise<void>;
+    listGmailSpamReviewItems(agentId: string, provider: LifeOpsConnectorGrant["provider"], options?: {
+        maxResults?: number;
+        status?: LifeOpsGmailSpamReviewStatus;
+        grantId?: string;
+    }, side?: LifeOpsConnectorSide): Promise<LifeOpsGmailSpamReviewItem[]>;
+    getGmailSpamReviewItem(agentId: string, provider: LifeOpsConnectorGrant["provider"], itemId: string, side?: LifeOpsConnectorSide): Promise<LifeOpsGmailSpamReviewItem | null>;
+    updateGmailSpamReviewItemStatus(agentId: string, provider: LifeOpsConnectorGrant["provider"], itemId: string, status: LifeOpsGmailSpamReviewStatus, reviewedAt: string | null, updatedAt: string, side?: LifeOpsConnectorSide): Promise<void>;
+    deleteGmailSpamReviewItemsForProvider(agentId: string, provider: LifeOpsConnectorGrant["provider"], side?: LifeOpsConnectorSide, grantId?: string): Promise<void>;
+    createWorkflow(definition: LifeOpsWorkflowDefinition): Promise<void>;
+    updateWorkflow(definition: LifeOpsWorkflowDefinition): Promise<void>;
+    listWorkflows(agentId: string): Promise<LifeOpsWorkflowDefinition[]>;
+    deleteWorkflow(agentId: string, workflowId: string): Promise<void>;
+    getWorkflow(agentId: string, workflowId: string): Promise<LifeOpsWorkflowDefinition | null>;
+    createWorkflowRun(run: LifeOpsWorkflowRun): Promise<void>;
+    listWorkflowRuns(agentId: string, workflowId: string): Promise<LifeOpsWorkflowRun[]>;
+    createReminderAttempt(attempt: LifeOpsReminderAttempt): Promise<void>;
+    listReminderAttempts(agentId: string, options?: {
+        ownerType?: LifeOpsReminderAttempt["ownerType"];
+        ownerId?: string;
+        planId?: string;
+    }): Promise<LifeOpsReminderAttempt[]>;
+    listDueReminderReviewAttempts(agentId: string, nowIso: string, limit?: number): Promise<LifeOpsReminderAttempt[]>;
+    claimDueReminderReviewAttempts(agentId: string, nowIso: string, limit?: number, claimedBy?: `${string}-${string}-${string}-${string}-${string}`): Promise<LifeOpsReminderAttempt[]>;
+    updateReminderAttemptOutcome(id: string, outcome: string, metadata?: Record<string, unknown>): Promise<void>;
+    createBrowserSession(session: LifeOpsBrowserSession): Promise<void>;
+    updateBrowserSession(session: LifeOpsBrowserSession): Promise<void>;
+    getBrowserSession(agentId: string, sessionId: string): Promise<LifeOpsBrowserSession | null>;
+    listBrowserSessions(agentId: string): Promise<LifeOpsBrowserSession[]>;
+    getBrowserSettings(agentId: string): Promise<BrowserBridgeSettings | null>;
+    upsertBrowserSettings(agentId: string, settings: BrowserBridgeSettings): Promise<void>;
+    getBrowserCompanionByProfile(agentId: string, browser: BrowserBridgeCompanionStatus["browser"], profileId: string): Promise<BrowserBridgeCompanionStatus | null>;
+    getBrowserCompanionCredential(agentId: string, companionId: string): Promise<BrowserCompanionCredential | null>;
+    upsertBrowserCompanion(companion: BrowserBridgeCompanionStatus): Promise<void>;
+    updateBrowserCompanionPairingToken(agentId: string, companionId: string, pairingTokenHash: string, pairingTokenExpiresAt: string | null, pairedAt: string, updatedAt: string): Promise<void>;
+    updateBrowserCompanionPendingPairingTokenHashes(agentId: string, companionId: string, pendingPairingTokenHashes: Array<string | {
+        hash: string;
+        expiresAt?: string | null;
+    }>, updatedAt: string): Promise<void>;
+    promoteBrowserCompanionPendingPairingToken(agentId: string, companionId: string, pairingTokenHash: string, pendingPairingTokenHashes: Array<string | {
+        hash: string;
+        expiresAt?: string | null;
+    }>, pairingTokenExpiresAt: string | null, pairedAt: string, updatedAt: string): Promise<void>;
+    revokeBrowserCompanionPairingToken(agentId: string, companionId: string, revokedAt: string): Promise<void>;
+    listBrowserCompanions(agentId: string): Promise<BrowserBridgeCompanionStatus[]>;
+    upsertBrowserTab(tab: BrowserBridgeTabSummary): Promise<void>;
+    listBrowserTabs(agentId: string): Promise<BrowserBridgeTabSummary[]>;
+    deleteBrowserTabsByIds(agentId: string, ids: string[]): Promise<void>;
+    deleteAllBrowserTabs(agentId: string): Promise<void>;
+    upsertBrowserPageContext(context: BrowserBridgePageContext): Promise<void>;
+    listBrowserPageContexts(agentId: string): Promise<BrowserBridgePageContext[]>;
+    deleteBrowserPageContextsByIds(agentId: string, ids: string[]): Promise<void>;
+    deleteAllBrowserPageContexts(agentId: string): Promise<void>;
+    deleteBrowserSession(agentId: string, sessionId: string): Promise<void>;
+    upsertEscalationState(state: {
+        id: string;
+        agentId: string;
+        reason: string;
+        text: string;
+        currentStep: number;
+        channelsSent: string[];
+        startedAt: string;
+        lastSentAt: string;
+        resolved: boolean;
+        resolvedAt?: string | null;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    getActiveEscalationState(agentId: string): Promise<LifeOpsEscalationStateRow | null>;
+    resolveEscalationState(id: string, resolvedAt: string): Promise<void>;
+    listRecentEscalationStates(agentId: string, limit?: number): Promise<LifeOpsEscalationStateRow[]>;
+    deleteAllEscalationStates(agentId: string): Promise<void>;
+    logRelationshipInteraction(interaction: LifeOpsRelationshipInteraction): Promise<void>;
+    upsertXDm(dm: LifeOpsXDm): Promise<void>;
+    listXDms(agentId: string, opts?: {
+        conversationId?: string;
+        limit?: number;
+    }): Promise<LifeOpsXDm[]>;
+    upsertXFeedItem(item: LifeOpsXFeedItem): Promise<void>;
+    listXFeedItems(agentId: string, feedType: LifeOpsXFeedType, opts?: {
+        limit?: number;
+    }): Promise<LifeOpsXFeedItem[]>;
+    upsertXSyncState(state: LifeOpsXSyncState): Promise<void>;
+    getXSyncState(agentId: string, feedType: LifeOpsXFeedType): Promise<LifeOpsXSyncState | null>;
+    upsertScreenTimeSession(session: LifeOpsScreenTimeSession): Promise<void>;
+    getScreenTimeSession(agentId: string, id: string): Promise<LifeOpsScreenTimeSession | null>;
+    finishScreenTimeSession(agentId: string, id: string, endAt: string, durationSeconds: number): Promise<void>;
+    listScreenTimeSessionsBetween(agentId: string, start: string, end: string, opts?: {
+        source?: string;
+        limit?: number;
+    }): Promise<LifeOpsScreenTimeSession[]>;
+    listScreenTimeSessionsOverlapping(agentId: string, start: string, end: string, opts?: {
+        source?: string;
+        limit?: number;
+    }): Promise<LifeOpsScreenTimeSession[]>;
+    upsertScreenTimeDaily(row: LifeOpsScreenTimeDaily): Promise<void>;
+    upsertScheduleInsight(insight: LifeOpsScheduleInsightRecord): Promise<void>;
+    /**
+     * Insert a telemetry event with content-hash dedupe. Returns `true` when a
+     * new row was written, `false` when the `(agent_id, dedupe_key)` pair
+     * already existed. See `telemetry-event-families.md` §5 for the derivation
+     * of `dedupeKey`.
+     */
+    insertTelemetryEvent(event: LifeOpsTelemetryEvent): Promise<boolean>;
+    listTelemetryEvents(args: {
+        agentId: string;
+        familyIn?: LifeOpsTelemetryFamily[];
+        sinceIso?: string;
+        untilIso?: string;
+        limit?: number;
+    }): Promise<LifeOpsTelemetryEvent[]>;
+    /**
+     * Delete telemetry rows older than the retention window. Callers should
+     * prune daily via the scheduler. Daily rollups in
+     * `app_lifeops.life_telemetry_rollup_daily` are retained indefinitely.
+     */
+    pruneTelemetryEvents(args: {
+        agentId: string;
+        retentionDays: number;
+    }): Promise<{
+        deletedCount: number;
+    }>;
+    /**
+     * Roll up raw telemetry events within `[sinceIso, untilIso)` into daily
+     * per-family aggregates. Upserts per (agent, family, local_date). Callers
+     * should run this before `pruneTelemetryEvents` so the 60-day retention
+     * cutoff doesn't drop un-aggregated history.
+     *
+     * The bucket key (`local_date`) is the UTC date of `occurred_at` — local
+     * timezone bucketing would require per-agent TZ, which higher-level callers
+     * can project off the merged schedule state when they need it.
+     */
+    upsertTelemetryDailyRollup(args: {
+        agentId: string;
+        sinceIso: string;
+        untilIso: string;
+    }): Promise<{
+        bucketsWritten: number;
+    }>;
+    readCircadianState(agentId: string): Promise<LifeOpsCircadianStateRow | null>;
+    upsertCircadianState(state: LifeOpsCircadianStateRow): Promise<void>;
+    upsertSleepEpisode(episode: LifeOpsSleepEpisodeRecord): Promise<void>;
+    listSleepEpisodesBetween(agentId: string, startAt: string, endAt: string, opts?: {
+        includeOpen?: boolean;
+        limit?: number;
+    }): Promise<LifeOpsSleepEpisodeRecord[]>;
+    upsertScheduleObservation(observation: LifeOpsScheduleObservationRecord): Promise<void>;
+    listScheduleObservations(agentId: string, sinceAt: string, opts?: {
+        origin?: LifeOpsScheduleObservationRecord["origin"];
+        deviceId?: string;
+        limit?: number;
+    }): Promise<LifeOpsScheduleObservationRecord[]>;
+    upsertScheduleMergedState(state: LifeOpsScheduleMergedStateRecord): Promise<void>;
+    getScheduleMergedState(agentId: string, scope: LifeOpsScheduleMergedStateRecord["scope"], timezone: string): Promise<LifeOpsScheduleMergedStateRecord | null>;
+    listScreenTimeDaily(agentId: string, date: string, opts?: {
+        source?: string;
+        limit?: number;
+    }): Promise<LifeOpsScreenTimeDaily[]>;
+    aggregateScreenTimeDailyForDate(agentId: string, date: string): Promise<{
+        updated: number;
+    }>;
+    upsertSchedulingNegotiation(neg: LifeOpsSchedulingNegotiation): Promise<void>;
+    getSchedulingNegotiation(agentId: string, id: string): Promise<LifeOpsSchedulingNegotiation | null>;
+    listSchedulingNegotiations(agentId: string, opts?: {
+        state?: string;
+        limit?: number;
+    }): Promise<LifeOpsSchedulingNegotiation[]>;
+    updateSchedulingNegotiationState(agentId: string, id: string, state: string, finalizedAt?: string | null): Promise<void>;
+    upsertSchedulingProposal(p: LifeOpsSchedulingProposal): Promise<void>;
+    getSchedulingProposal(agentId: string, id: string): Promise<LifeOpsSchedulingProposal | null>;
+    listSchedulingProposals(agentId: string, negotiationId: string): Promise<LifeOpsSchedulingProposal[]>;
+    updateSchedulingProposalStatus(agentId: string, id: string, status: string): Promise<void>;
+    /**
+     * Upsert a scheduled task. When `expectedVersion` is omitted, behavior
+     * matches the pre-version contract: last-write-wins. When provided, the
+     * UPDATE clause filters on `version = expectedVersion` AND increments
+     * `version = version + 1` atomically. If the UPDATE affects 0 rows (the row
+     * doesn't exist or another caller already bumped the version) we throw
+     * {@link import("./sql.js").OptimisticLockError}.
+     *
+     * Use `expectedVersion` for the scheduler's `fire()` transition so two
+     * concurrent fires for the same task can't both dispatch.
+     */
+    upsertScheduledTask(agentId: string, task: import("@elizaos/plugin-scheduling").ScheduledTask, options?: {
+        expectedVersion?: number;
+        tx?: TransactionalDb;
+        nextFireAtIso?: string | null;
+    }): Promise<void>;
+    /**
+     * Atomically transition a ScheduledTask row from
+     * `state_json->>'status' = 'scheduled'` to `'fired'`. The whole flip
+     * happens inside one Postgres statement so two parallel ticks racing on
+     * the same task cannot both see "scheduled". The loser sees zero rows
+     * affected → `{ kind: "raced" }`; the winner gets the post-update row.
+     *
+     * Also clears `next_fire_at` so the partial index slice no longer keeps
+     * the row in the per-tick due-task scan until the runner re-computes a
+     * fresh value on its next mutation.
+     */
+    claimScheduledTaskForFire(agentId: string, args: {
+        taskId: string;
+        firedAtIso: string;
+    }): Promise<{
+        kind: "fired";
+        task: import("@elizaos/plugin-scheduling").ScheduledTask;
+    } | {
+        kind: "raced";
+    }>;
+    getScheduledTask(agentId: string, taskId: string): Promise<import("@elizaos/plugin-scheduling").ScheduledTask | null>;
+    getScheduledTaskByIdempotencyKey(agentId: string, idempotencyKey: string): Promise<import("@elizaos/plugin-scheduling").ScheduledTask | null>;
+    listScheduledTasks(agentId: string, filter?: {
+        kind?: string;
+        status?: string | string[];
+        subjectKind?: string;
+        subjectId?: string;
+        source?: string;
+        ownerVisibleOnly?: boolean;
+        /**
+         * When set, the SELECT restricts to rows whose `next_fire_at <= value`
+         * or whose `next_fire_at IS NULL` (the latter so event/manual/after_task
+         * triggers — which deliberately have no wall-clock fire time but may
+         * still need a tick pass for completion-timeout handling — remain
+         * visible). The partial index `idx_life_scheduled_tasks_due` is used
+         * when this filter is combined with a status list of
+         * `('scheduled', 'fired')`.
+         */
+        dueAtOrBeforeIso?: string;
+        /**
+         * Restrict to rows with `next_fire_at IS NOT NULL`. Used by tests
+         * that want to validate the index slice without the NULL escape hatch.
+         */
+        requireNextFireAt?: boolean;
+    }): Promise<import("@elizaos/plugin-scheduling").ScheduledTask[]>;
+    deleteScheduledTask(agentId: string, taskId: string): Promise<void>;
+    appendScheduledTaskLog(entry: import("@elizaos/plugin-scheduling").ScheduledTaskLogEntry): Promise<void>;
+    listScheduledTaskLog(args: {
+        agentId: string;
+        taskId: string;
+        sinceIso?: string;
+        untilIso?: string;
+        excludeRollups?: boolean;
+        limit?: number;
+    }): Promise<import("@elizaos/plugin-scheduling").ScheduledTaskLogEntry[]>;
+    rollupScheduledTaskLog(args: {
+        agentId: string;
+        olderThanIso: string;
+    }): Promise<{
+        rolledUp: number;
+        deletedRaw: number;
+    }>;
+    /**
+     * Upsert a work thread. When `expectedVersion` is omitted, behavior matches
+     * the pre-version contract: last-write-wins. When provided, the UPDATE clause
+     * filters on `version = expectedVersion` AND increments `version = version + 1`
+     * atomically. If the UPDATE affects 0 rows (someone else bumped the version
+     * first) we throw {@link import("./sql.js").OptimisticLockError}.
+     *
+     * Use `expectedVersion` from inside `withTransaction` for any multi-step
+     * operation that must observe a consistent snapshot of the row across reads
+     * and writes (e.g., thread merge).
+     */
+    upsertWorkThread(agentId: string, thread: import("./work-threads/types.js").WorkThread, options?: {
+        expectedVersion?: number;
+    }): Promise<void>;
+    getWorkThread(agentId: string, workThreadId: string): Promise<import("./work-threads/types.js").WorkThread | null>;
+    listWorkThreads(agentId: string, filter?: import("./work-threads/types.js").WorkThreadListFilter): Promise<import("./work-threads/types.js").WorkThread[]>;
+    appendWorkThreadEvent(event: import("./work-threads/types.js").WorkThreadEvent): Promise<void>;
+    /**
+     * Transactional analogue of `appendWorkThreadEvent`. Pass the `tx` handle
+     * from `withTransaction`'s callback so the INSERT participates in the same
+     * transaction as the surrounding UPDATEs.
+     */
+    appendWorkThreadEventTx(tx: TransactionalDb, event: import("./work-threads/types.js").WorkThreadEvent): Promise<void>;
+    /**
+     * Find an existing merge event by mergeRequestId on a target thread. Used
+     * for idempotency: if a merge with the same request id already happened,
+     * `mergeWorkThreadsAtomic` returns the recorded result without re-running.
+     */
+    findWorkThreadMergeEvent(args: {
+        agentId: string;
+        targetWorkThreadId: string;
+        mergeRequestId: string;
+    }): Promise<{
+        sourceWorkThreadIds: string[];
+        occurredAt: string;
+    } | null>;
+    /**
+     * Atomic thread merge. All four steps below commit together or none:
+     *   1. UPDATE target thread (sourceRefs, participants, summary, plan, metadata, version+1)
+     *   2. UPDATE each source thread (status=stopped, metadata.mergedIntoWorkThreadId, version+1)
+     *   3. INSERT 'merged' event on target (with mergeRequestId in detail_json)
+     *   4. INSERT 'merged_into' event on each source (with mergeRequestId in detail_json)
+     *
+     * Throws {@link OptimisticLockError} if any UPDATE affects 0 rows (someone
+     * else bumped a version first). Caller catches and retries via
+     * {@link withOptimisticRetry}.
+     *
+     * Idempotency: if a 'merged' event on the target already exists with the
+     * given `mergeRequestId`, this is a no-op and returns null without writing.
+     */
+    mergeWorkThreadsAtomic(args: {
+        agentId: string;
+        target: import("./work-threads/types.js").WorkThread;
+        sources: import("./work-threads/types.js").WorkThread[];
+        nextTarget: import("./work-threads/types.js").WorkThread;
+        mergeRequestId: string;
+        reason?: string | null;
+        instruction?: string | null;
+    }): Promise<{
+        targetWorkThreadId: string;
+        sourceWorkThreadIds: string[];
+    }>;
+    /**
+     * Transactional version of {@link findWorkThreadMergeEvent}, scoped to the
+     * `tx` so the lookup sees uncommitted changes within the same transaction.
+     */
+    private findWorkThreadMergeEventTx;
+    listWorkThreadEvents(args: {
+        agentId: string;
+        workThreadId: string;
+        limit?: number;
+    }): Promise<import("./work-threads/types.js").WorkThreadEvent[]>;
+}
+export declare function createLifeOpsTaskDefinition(params: Omit<LifeOpsTaskDefinition, "id" | "createdAt" | "updatedAt">): LifeOpsTaskDefinition;
+export declare function createLifeOpsGoalDefinition(params: Omit<LifeOpsGoalDefinition, "id" | "createdAt" | "updatedAt">): LifeOpsGoalDefinition;
+export declare function createLifeOpsReminderPlan(params: Omit<LifeOpsReminderPlan, "id" | "createdAt" | "updatedAt">): LifeOpsReminderPlan;
+export declare function createLifeOpsChannelPolicy(params: Omit<LifeOpsChannelPolicy, "id" | "createdAt" | "updatedAt">): LifeOpsChannelPolicy;
+export declare function createLifeOpsWebsiteAccessGrant(params: Omit<LifeOpsWebsiteAccessGrant, "id" | "createdAt" | "updatedAt">): LifeOpsWebsiteAccessGrant;
+export declare function createLifeOpsAuditEvent(params: Omit<LifeOpsAuditEvent, "id" | "createdAt">): LifeOpsAuditEvent;
+export declare function createLifeOpsActivitySignal(params: Omit<LifeOpsActivitySignal, "id" | "createdAt">): LifeOpsActivitySignal;
+export declare function createLifeOpsConnectorGrant(params: Omit<LifeOpsConnectorGrant, "id" | "createdAt" | "updatedAt" | "side" | "executionTarget" | "sourceOfTruth" | "preferredByAgent" | "cloudConnectionId"> & Partial<Pick<LifeOpsConnectorGrant, "side" | "executionTarget" | "sourceOfTruth" | "preferredByAgent" | "cloudConnectionId">>): LifeOpsConnectorGrant;
+export declare function createLifeOpsCalendarSyncState(params: Omit<LifeOpsCalendarSyncState, "id" | "updatedAt">): LifeOpsCalendarSyncState;
+export declare function createLifeOpsGmailSyncState(params: Omit<LifeOpsGmailSyncState, "id" | "updatedAt">): LifeOpsGmailSyncState;
+export declare function createLifeOpsWorkflowDefinition(params: Omit<LifeOpsWorkflowDefinition, "id" | "createdAt" | "updatedAt">): LifeOpsWorkflowDefinition;
+export declare function createLifeOpsWorkflowRun(params: Omit<LifeOpsWorkflowRun, "id">): LifeOpsWorkflowRun;
+export declare function createLifeOpsReminderAttempt(params: Omit<LifeOpsReminderAttempt, "id">): LifeOpsReminderAttempt;
+export declare function createLifeOpsBrowserSession(params: Omit<LifeOpsBrowserSession, "id" | "createdAt" | "updatedAt">): LifeOpsBrowserSession;
+//# sourceMappingURL=repository.d.ts.map