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

package/dist/lifeops/service.d.ts

@@ -0,0 +1,482 @@
+/**
+ * LifeOps Service — thin facade that composes domain-specific mixins.
+ *
+ * The implementation lives in the `service-mixin-*.ts` files; standalone
+ * helpers live in `service-normalize-*.ts` and `service-helpers-*.ts`.
+ * This file only re-exports the public surface that consumers already import.
+ */
+export { LifeOpsServiceError } from "./service-types.js";
+import type { LifeOpsReminderAttempt, LifeOpsWorkflowRun } from "@elizaos/shared";
+import type { BrowserBridgeService } from "./service-mixin-browser.js";
+import type { LifeOpsCalendarService } from "./service-mixin-calendar.js";
+import type { Constructor } from "./service-mixin-core.js";
+import { LifeOpsServiceBase } from "./service-mixin-core.js";
+import type { LifeOpsDefinitionService } from "./service-mixin-definitions.js";
+import type { LifeOpsDiscordService } from "./service-mixin-discord.js";
+import type { LifeOpsDriveService } from "./service-mixin-drive.js";
+import type { LifeOpsEmailUnsubscribeService } from "./service-mixin-email-unsubscribe.js";
+import type { LifeOpsGmailService } from "./service-mixin-gmail.js";
+import type { LifeOpsGoalService } from "./service-mixin-goals.js";
+import type { LifeOpsGoogleService } from "./service-mixin-google.js";
+import type { LifeOpsHealthServicePublic } from "./service-mixin-health.js";
+import type { LifeOpsIMessageService } from "./service-mixin-imessage.js";
+import type { LifeOpsInboxService } from "./service-mixin-inbox.js";
+import type { LifeOpsRelationshipService } from "./service-mixin-relationships.js";
+import type { LifeOpsReminderService } from "./service-mixin-reminders.js";
+import type { LifeOpsSchedulingService } from "./service-mixin-scheduling.js";
+import type { LifeOpsScreenTimeServicePublic } from "./service-mixin-screentime.js";
+import type { LifeOpsSignalService } from "./service-mixin-signal.js";
+import type { LifeOpsStatusService } from "./service-mixin-status.js";
+import { type StatusMixinDependencies } from "./service-mixin-status.js";
+import type { LifeOpsSubscriptionService } from "./service-mixin-subscriptions.js";
+import type { LifeOpsTelegramService } from "./service-mixin-telegram.js";
+import type { LifeOpsTravelServicePublic } from "./service-mixin-travel.js";
+import type { LifeOpsWhatsAppService } from "./service-mixin-whatsapp.js";
+import type { LifeOpsWorkflowService } from "./service-mixin-workflows.js";
+import type { LifeOpsXService } from "./service-mixin-x.js";
+import type { LifeOpsXReadService } from "./service-mixin-x-read.js";
+declare const LIFEOPS_COMPOSED: import("./service-mixin-core.js").MixinClass<{
+    new (...args: any[]): {
+        getSleepHistory(opts?: {
+            windowDays?: number;
+            includeNaps?: boolean;
+        } | undefined): Promise<import("@elizaos/shared").LifeOpsSleepHistoryResponse>;
+        getSleepRegularity(opts?: {
+            windowDays?: number;
+            includeNaps?: boolean;
+        } | undefined): Promise<import("@elizaos/shared").LifeOpsSleepRegularityResponse>;
+        getPersonalBaseline(opts?: {
+            windowDays?: number;
+        } | undefined): Promise<import("@elizaos/shared").LifeOpsPersonalBaselineResponse>;
+        createHealthSleepServiceMethods(): import("@elizaos/plugin-health").HealthSleepServiceMethods;
+        readonly repository: import("./repository.js").LifeOpsRepository;
+        readonly explicitOwnerEntityIdValue: string | null;
+        readonly ownerEntityIdValue: string;
+        readonly scheduleSyncClient: import("@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-client").LifeOpsScheduleSyncClient;
+        ownerRoutingEntityIdPromise: Promise<string | null> | null;
+        adaptiveWindowPolicyCache: {
+            policy: ReturnType<typeof import("./defaults.js").computeAdaptiveWindowPolicy>;
+            computedAt: number;
+        } | null;
+        readonly runtime: import("@elizaos/core").IAgentRuntime;
+        agentId(): string;
+        ownerEntityId(): string;
+        ownerRoutingEntityId(): Promise<string | null>;
+        getBrowserSettingsInternal(): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        isBrowserPaused(settings: import("@elizaos/plugin-browser").BrowserBridgeSettings): boolean;
+        requireBrowserAvailableForActions(actions: readonly import("@elizaos/plugin-browser").BrowserBridgeAction[]): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        buildBrowserCompanion(request: import("@elizaos/plugin-browser").UpsertBrowserBridgeCompanionRequest, current: import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus | null): import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus;
+        normalizeOwnership(input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, current?: import("@elizaos/shared").LifeOpsOwnership): import("@elizaos/shared").LifeOpsOwnership;
+        normalizeChildOwnership(parent: import("@elizaos/shared").LifeOpsOwnership, input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, field?: string): import("@elizaos/shared").LifeOpsOwnership;
+        logLifeOpsWarn(operation: string, message: string, context?: Record<string, unknown>): void;
+        logLifeOpsError(operation: string, error: unknown, context?: Record<string, unknown>): void;
+        withReminderProcessingLock<T>(operation: () => Promise<T>): Promise<T>;
+        recordAudit(eventType: import("@elizaos/shared").LifeOpsAuditEventType, ownerType: "definition" | "occurrence" | "goal", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordConnectorAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordChannelPolicyAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordWorkflowAudit(eventType: "workflow_created" | "workflow_updated" | "workflow_run", ownerId: string, actor: "user" | "workflow" | undefined, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<import("@elizaos/shared").LifeOpsAuditEvent>;
+        recordReminderAudit(eventType: "reminder_due" | "reminder_delivered" | "reminder_blocked" | "reminder_escalation_started" | "reminder_escalation_resolved", ownerType: "occurrence" | "calendar_event", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordBrowserAudit(eventType: "browser_session_created" | "browser_session_updated", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordXPostAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        clearGoogleGrantAuthFailure(grant: import("@elizaos/shared").LifeOpsConnectorGrant): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        markGoogleGrantNeedsReauth(grant: import("@elizaos/shared").LifeOpsConnectorGrant, message: string): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        emitAssistantEvent(text: string, source: string, data?: Record<string, unknown>): void;
+        getWorkflowDefinition(workflowId: string): Promise<import("@elizaos/shared").LifeOpsWorkflowDefinition>;
+        requireXGrant(requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+    };
+} & import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<{
+    new (...args: any[]): {
+        listSubscriptionPlaybooks(): Promise<import("@elizaos/plugin-finances").LifeOpsSubscriptionPlaybook[]>;
+        findSubscriptionPlaybookForMerchant(merchant: string): {
+            key: string;
+            serviceName: string;
+            managementUrl: string;
+            executorPreference: import("@elizaos/plugin-finances").LifeOpsSubscriptionPlaybook["executorPreference"];
+        } | null;
+        getLatestSubscriptionAudit(): Promise<import("@elizaos/plugin-finances").LifeOpsSubscriptionAuditSummary | null>;
+        auditSubscriptions(_requestUrl: URL, request?: import("@elizaos/plugin-finances").LifeOpsSubscriptionDiscoveryRequest): Promise<import("@elizaos/plugin-finances").LifeOpsSubscriptionAuditSummary>;
+        getSubscriptionCancellationStatus(args: {
+            cancellationId?: string | null;
+            serviceName?: string | null;
+            serviceSlug?: string | null;
+        }): Promise<import("@elizaos/plugin-finances").LifeOpsSubscriptionCancellationSummary | null>;
+        cancelSubscription(request: import("@elizaos/plugin-finances").LifeOpsSubscriptionCancellationRequest): Promise<import("@elizaos/plugin-finances").LifeOpsSubscriptionCancellationSummary>;
+        summarizeSubscriptionAudit(summary: import("@elizaos/plugin-finances").LifeOpsSubscriptionAuditSummary): string;
+        summarizeSubscriptionCancellation(summary: import("@elizaos/plugin-finances").LifeOpsSubscriptionCancellationSummary): string;
+        resolveSubscriptionIntent(text: string): {
+            mode: "audit" | "cancel" | "status" | null;
+            serviceName?: string;
+            serviceSlug?: string;
+            executor?: import("@elizaos/plugin-finances").LifeOpsSubscriptionExecutor;
+        };
+        readonly repository: import("./repository.js").LifeOpsRepository;
+        readonly explicitOwnerEntityIdValue: string | null;
+        readonly ownerEntityIdValue: string;
+        readonly scheduleSyncClient: import("@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-client").LifeOpsScheduleSyncClient;
+        ownerRoutingEntityIdPromise: Promise<string | null> | null;
+        adaptiveWindowPolicyCache: {
+            policy: ReturnType<typeof import("./defaults.js").computeAdaptiveWindowPolicy>;
+            computedAt: number;
+        } | null;
+        readonly runtime: import("@elizaos/core").IAgentRuntime;
+        agentId(): string;
+        ownerEntityId(): string;
+        ownerRoutingEntityId(): Promise<string | null>;
+        getBrowserSettingsInternal(): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        isBrowserPaused(settings: import("@elizaos/plugin-browser").BrowserBridgeSettings): boolean;
+        requireBrowserAvailableForActions(actions: readonly import("@elizaos/plugin-browser").BrowserBridgeAction[]): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        buildBrowserCompanion(request: import("@elizaos/plugin-browser").UpsertBrowserBridgeCompanionRequest, current: import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus | null): import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus;
+        normalizeOwnership(input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, current?: import("@elizaos/shared").LifeOpsOwnership): import("@elizaos/shared").LifeOpsOwnership;
+        normalizeChildOwnership(parent: import("@elizaos/shared").LifeOpsOwnership, input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, field?: string): import("@elizaos/shared").LifeOpsOwnership;
+        logLifeOpsWarn(operation: string, message: string, context?: Record<string, unknown>): void;
+        logLifeOpsError(operation: string, error: unknown, context?: Record<string, unknown>): void;
+        withReminderProcessingLock<T>(operation: () => Promise<T>): Promise<T>;
+        recordAudit(eventType: import("@elizaos/shared").LifeOpsAuditEventType, ownerType: "definition" | "occurrence" | "goal", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordConnectorAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordChannelPolicyAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordWorkflowAudit(eventType: "workflow_created" | "workflow_updated" | "workflow_run", ownerId: string, actor: "user" | "workflow" | undefined, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<import("@elizaos/shared").LifeOpsAuditEvent>;
+        recordReminderAudit(eventType: "reminder_due" | "reminder_delivered" | "reminder_blocked" | "reminder_escalation_started" | "reminder_escalation_resolved", ownerType: "occurrence" | "calendar_event", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordBrowserAudit(eventType: "browser_session_created" | "browser_session_updated", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordXPostAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        clearGoogleGrantAuthFailure(grant: import("@elizaos/shared").LifeOpsConnectorGrant): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        markGoogleGrantNeedsReauth(grant: import("@elizaos/shared").LifeOpsConnectorGrant, message: string): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        emitAssistantEvent(text: string, source: string, data?: Record<string, unknown>): void;
+        getWorkflowDefinition(workflowId: string): Promise<import("@elizaos/shared").LifeOpsWorkflowDefinition>;
+        requireXGrant(requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+    };
+} & import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<{
+    new (...args: any[]): {
+        getWhatsAppConnectorStatus(): Promise<import("@elizaos/shared").LifeOpsWhatsAppConnectorStatus>;
+        sendWhatsAppMessage(req: {
+            to: string;
+            text: string;
+            replyToMessageId?: string;
+        }): Promise<{
+            ok: true;
+            messageId: string;
+        }>;
+        ingestWhatsAppWebhook(payload: unknown): Promise<{
+            ingested: number;
+            messages: {
+                id: string;
+                from: string;
+                channelId: string;
+                timestamp: string;
+                type: "text" | "image" | "audio" | "document" | "unknown";
+                text?: string;
+                metadata?: Record<string, unknown>;
+            }[];
+        }>;
+        syncWhatsAppInbound(): Promise<{
+            drained: number;
+            messages: {
+                id: string;
+                from: string;
+                channelId: string;
+                timestamp: string;
+                type: "text" | "image" | "audio" | "document" | "unknown";
+                text?: string;
+                metadata?: Record<string, unknown>;
+            }[];
+        }>;
+        pullWhatsAppRecent(limit?: number): Promise<{
+            count: number;
+            messages: {
+                id: string;
+                from: string;
+                channelId: string;
+                timestamp: string;
+                type: "text" | "image" | "audio" | "document" | "unknown";
+                text?: string;
+                metadata?: Record<string, unknown>;
+            }[];
+        }>;
+        readonly repository: import("./repository.js").LifeOpsRepository;
+        readonly explicitOwnerEntityIdValue: string | null;
+        readonly ownerEntityIdValue: string;
+        readonly scheduleSyncClient: import("@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-client").LifeOpsScheduleSyncClient;
+        ownerRoutingEntityIdPromise: Promise<string | null> | null;
+        adaptiveWindowPolicyCache: {
+            policy: ReturnType<typeof import("./defaults.js").computeAdaptiveWindowPolicy>;
+            computedAt: number;
+        } | null;
+        readonly runtime: import("@elizaos/core").IAgentRuntime;
+        agentId(): string;
+        ownerEntityId(): string;
+        ownerRoutingEntityId(): Promise<string | null>;
+        getBrowserSettingsInternal(): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        isBrowserPaused(settings: import("@elizaos/plugin-browser").BrowserBridgeSettings): boolean;
+        requireBrowserAvailableForActions(actions: readonly import("@elizaos/plugin-browser").BrowserBridgeAction[]): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        buildBrowserCompanion(request: import("@elizaos/plugin-browser").UpsertBrowserBridgeCompanionRequest, current: import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus | null): import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus;
+        normalizeOwnership(input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, current?: import("@elizaos/shared").LifeOpsOwnership): import("@elizaos/shared").LifeOpsOwnership;
+        normalizeChildOwnership(parent: import("@elizaos/shared").LifeOpsOwnership, input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, field?: string): import("@elizaos/shared").LifeOpsOwnership;
+        logLifeOpsWarn(operation: string, message: string, context?: Record<string, unknown>): void;
+        logLifeOpsError(operation: string, error: unknown, context?: Record<string, unknown>): void;
+        withReminderProcessingLock<T>(operation: () => Promise<T>): Promise<T>;
+        recordAudit(eventType: import("@elizaos/shared").LifeOpsAuditEventType, ownerType: "definition" | "occurrence" | "goal", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordConnectorAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordChannelPolicyAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordWorkflowAudit(eventType: "workflow_created" | "workflow_updated" | "workflow_run", ownerId: string, actor: "user" | "workflow" | undefined, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<import("@elizaos/shared").LifeOpsAuditEvent>;
+        recordReminderAudit(eventType: "reminder_due" | "reminder_delivered" | "reminder_blocked" | "reminder_escalation_started" | "reminder_escalation_resolved", ownerType: "occurrence" | "calendar_event", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordBrowserAudit(eventType: "browser_session_created" | "browser_session_updated", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordXPostAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        clearGoogleGrantAuthFailure(grant: import("@elizaos/shared").LifeOpsConnectorGrant): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        markGoogleGrantNeedsReauth(grant: import("@elizaos/shared").LifeOpsConnectorGrant, message: string): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        emitAssistantEvent(text: string, source: string, data?: Record<string, unknown>): void;
+        getWorkflowDefinition(workflowId: string): Promise<import("@elizaos/shared").LifeOpsWorkflowDefinition>;
+        requireXGrant(requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+    };
+} & {
+    new (...args: any[]): {
+        lifeOpsSignalServiceConnected(): boolean;
+        lifeOpsSignalServiceRegistered(): boolean;
+        getSignalConnectorStatus(side?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("@elizaos/shared").LifeOpsSignalConnectorStatus>;
+        readSignalInbound(limit?: number, side?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("@elizaos/shared").LifeOpsSignalInboundMessage[]>;
+        sendSignalMessage(request: {
+            side?: import("@elizaos/shared").LifeOpsConnectorSide;
+            recipient: string;
+            text: string;
+        }): Promise<{
+            provider: "signal";
+            side: import("@elizaos/shared").LifeOpsConnectorSide;
+            recipient: string;
+            ok: true;
+            timestamp: number;
+        }>;
+        readonly repository: import("./repository.js").LifeOpsRepository;
+        readonly explicitOwnerEntityIdValue: string | null;
+        readonly ownerEntityIdValue: string;
+        readonly scheduleSyncClient: import("@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-client").LifeOpsScheduleSyncClient;
+        ownerRoutingEntityIdPromise: Promise<string | null> | null;
+        adaptiveWindowPolicyCache: {
+            policy: ReturnType<typeof import("./defaults.js").computeAdaptiveWindowPolicy>;
+            computedAt: number;
+        } | null;
+        readonly runtime: import("@elizaos/core").IAgentRuntime;
+        agentId(): string;
+        ownerEntityId(): string;
+        ownerRoutingEntityId(): Promise<string | null>;
+        getBrowserSettingsInternal(): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        isBrowserPaused(settings: import("@elizaos/plugin-browser").BrowserBridgeSettings): boolean;
+        requireBrowserAvailableForActions(actions: readonly import("@elizaos/plugin-browser").BrowserBridgeAction[]): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        buildBrowserCompanion(request: import("@elizaos/plugin-browser").UpsertBrowserBridgeCompanionRequest, current: import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus | null): import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus;
+        normalizeOwnership(input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, current?: import("@elizaos/shared").LifeOpsOwnership): import("@elizaos/shared").LifeOpsOwnership;
+        normalizeChildOwnership(parent: import("@elizaos/shared").LifeOpsOwnership, input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, field?: string): import("@elizaos/shared").LifeOpsOwnership;
+        logLifeOpsWarn(operation: string, message: string, context?: Record<string, unknown>): void;
+        logLifeOpsError(operation: string, error: unknown, context?: Record<string, unknown>): void;
+        withReminderProcessingLock<T>(operation: () => Promise<T>): Promise<T>;
+        recordAudit(eventType: import("@elizaos/shared").LifeOpsAuditEventType, ownerType: "definition" | "occurrence" | "goal", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordConnectorAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordChannelPolicyAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordWorkflowAudit(eventType: "workflow_created" | "workflow_updated" | "workflow_run", ownerId: string, actor: "user" | "workflow" | undefined, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<import("@elizaos/shared").LifeOpsAuditEvent>;
+        recordReminderAudit(eventType: "reminder_due" | "reminder_delivered" | "reminder_blocked" | "reminder_escalation_started" | "reminder_escalation_resolved", ownerType: "occurrence" | "calendar_event", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordBrowserAudit(eventType: "browser_session_created" | "browser_session_updated", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordXPostAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        clearGoogleGrantAuthFailure(grant: import("@elizaos/shared").LifeOpsConnectorGrant): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        markGoogleGrantNeedsReauth(grant: import("@elizaos/shared").LifeOpsConnectorGrant, message: string): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        emitAssistantEvent(text: string, source: string, data?: Record<string, unknown>): void;
+        getWorkflowDefinition(workflowId: string): Promise<import("@elizaos/shared").LifeOpsWorkflowDefinition>;
+        requireXGrant(requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+    };
+} & import("./service-mixin-core.js").MixinClass<{
+    new (...args: any[]): {
+        getTelegramConnectorStatus(requestedSide?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("@elizaos/shared").LifeOpsTelegramConnectorStatus>;
+        sendTelegramMessage(request: {
+            side?: import("@elizaos/shared").LifeOpsConnectorSide;
+            target: string;
+            message: string;
+        }): Promise<{
+            ok: true;
+            messageId: string | null;
+        }>;
+        verifyTelegramConnector(request: import("@elizaos/shared").VerifyLifeOpsTelegramConnectorRequest): Promise<import("@elizaos/shared").VerifyLifeOpsTelegramConnectorResponse>;
+        searchTelegramMessages(request: {
+            side?: import("@elizaos/shared").LifeOpsConnectorSide;
+            query: string;
+            scope?: string;
+            limit?: number;
+        }): Promise<{
+            id: string | null;
+            dialogId: string | null;
+            threadId: string | null;
+            dialogTitle: string | null;
+            username: string | null;
+            peerId: string | null;
+            senderId: string | null;
+            content: string;
+            timestamp: string | null;
+            outgoing: boolean;
+        }[]>;
+        getTelegramDeliveryStatus(_request: {
+            side?: import("@elizaos/shared").LifeOpsConnectorSide;
+            target: string;
+            messageIds: string[];
+        }): Promise<{
+            messageId: string;
+            status: "delivered_read" | "sent" | "unknown";
+            isRead: boolean | null;
+            timestamp: string | null;
+            content: string | null;
+            outgoing: boolean | null;
+        }[]>;
+        readonly repository: import("./repository.js").LifeOpsRepository;
+        readonly explicitOwnerEntityIdValue: string | null;
+        readonly ownerEntityIdValue: string;
+        readonly scheduleSyncClient: import("@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-client").LifeOpsScheduleSyncClient;
+        ownerRoutingEntityIdPromise: Promise<string | null> | null;
+        adaptiveWindowPolicyCache: {
+            policy: ReturnType<typeof import("./defaults.js").computeAdaptiveWindowPolicy>;
+            computedAt: number;
+        } | null;
+        readonly runtime: import("@elizaos/core").IAgentRuntime;
+        agentId(): string;
+        ownerEntityId(): string;
+        ownerRoutingEntityId(): Promise<string | null>;
+        getBrowserSettingsInternal(): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        isBrowserPaused(settings: import("@elizaos/plugin-browser").BrowserBridgeSettings): boolean;
+        requireBrowserAvailableForActions(actions: readonly import("@elizaos/plugin-browser").BrowserBridgeAction[]): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        buildBrowserCompanion(request: import("@elizaos/plugin-browser").UpsertBrowserBridgeCompanionRequest, current: import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus | null): import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus;
+        normalizeOwnership(input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, current?: import("@elizaos/shared").LifeOpsOwnership): import("@elizaos/shared").LifeOpsOwnership;
+        normalizeChildOwnership(parent: import("@elizaos/shared").LifeOpsOwnership, input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, field?: string): import("@elizaos/shared").LifeOpsOwnership;
+        logLifeOpsWarn(operation: string, message: string, context?: Record<string, unknown>): void;
+        logLifeOpsError(operation: string, error: unknown, context?: Record<string, unknown>): void;
+        withReminderProcessingLock<T>(operation: () => Promise<T>): Promise<T>;
+        recordAudit(eventType: import("@elizaos/shared").LifeOpsAuditEventType, ownerType: "definition" | "occurrence" | "goal", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordConnectorAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordChannelPolicyAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordWorkflowAudit(eventType: "workflow_created" | "workflow_updated" | "workflow_run", ownerId: string, actor: "user" | "workflow" | undefined, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<import("@elizaos/shared").LifeOpsAuditEvent>;
+        recordReminderAudit(eventType: "reminder_due" | "reminder_delivered" | "reminder_blocked" | "reminder_escalation_started" | "reminder_escalation_resolved", ownerType: "occurrence" | "calendar_event", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordBrowserAudit(eventType: "browser_session_created" | "browser_session_updated", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordXPostAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        clearGoogleGrantAuthFailure(grant: import("@elizaos/shared").LifeOpsConnectorGrant): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        markGoogleGrantNeedsReauth(grant: import("@elizaos/shared").LifeOpsConnectorGrant, message: string): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        emitAssistantEvent(text: string, source: string, data?: Record<string, unknown>): void;
+        getWorkflowDefinition(workflowId: string): Promise<import("@elizaos/shared").LifeOpsWorkflowDefinition>;
+        requireXGrant(requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+    };
+} & {
+    new (...args: any[]): {
+        getIMessageConnectorStatus(): Promise<import("@elizaos/shared").LifeOpsIMessageConnectorStatus>;
+        sendIMessage(req: import("./service-mixin-imessage.js").IMessageSendRequest): Promise<{
+            ok: true;
+            messageId?: string;
+        }>;
+        readIMessages(opts: {
+            chatId?: string;
+            since?: string;
+            limit?: number;
+        }): Promise<import("./service-mixin-imessage.js").IMessageRecord[]>;
+        listIMessageChats(): Promise<import("./service-mixin-imessage.js").IMessageChat[]>;
+        searchIMessages(opts: {
+            query: string;
+            chatId?: string;
+            limit?: number;
+        }): Promise<import("./service-mixin-imessage.js").IMessageRecord[]>;
+        getIMessageDeliveryStatus(messageIds: string[]): Promise<import("./service-mixin-imessage.js").IMessageDeliveryResult[]>;
+        readonly repository: import("./repository.js").LifeOpsRepository;
+        readonly explicitOwnerEntityIdValue: string | null;
+        readonly ownerEntityIdValue: string;
+        readonly scheduleSyncClient: import("@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-client").LifeOpsScheduleSyncClient;
+        ownerRoutingEntityIdPromise: Promise<string | null> | null;
+        adaptiveWindowPolicyCache: {
+            policy: ReturnType<typeof import("./defaults.js").computeAdaptiveWindowPolicy>;
+            computedAt: number;
+        } | null;
+        readonly runtime: import("@elizaos/core").IAgentRuntime;
+        agentId(): string;
+        ownerEntityId(): string;
+        ownerRoutingEntityId(): Promise<string | null>;
+        getBrowserSettingsInternal(): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        isBrowserPaused(settings: import("@elizaos/plugin-browser").BrowserBridgeSettings): boolean;
+        requireBrowserAvailableForActions(actions: readonly import("@elizaos/plugin-browser").BrowserBridgeAction[]): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        buildBrowserCompanion(request: import("@elizaos/plugin-browser").UpsertBrowserBridgeCompanionRequest, current: import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus | null): import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus;
+        normalizeOwnership(input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, current?: import("@elizaos/shared").LifeOpsOwnership): import("@elizaos/shared").LifeOpsOwnership;
+        normalizeChildOwnership(parent: import("@elizaos/shared").LifeOpsOwnership, input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, field?: string): import("@elizaos/shared").LifeOpsOwnership;
+        logLifeOpsWarn(operation: string, message: string, context?: Record<string, unknown>): void;
+        logLifeOpsError(operation: string, error: unknown, context?: Record<string, unknown>): void;
+        withReminderProcessingLock<T>(operation: () => Promise<T>): Promise<T>;
+        recordAudit(eventType: import("@elizaos/shared").LifeOpsAuditEventType, ownerType: "definition" | "occurrence" | "goal", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordConnectorAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordChannelPolicyAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordWorkflowAudit(eventType: "workflow_created" | "workflow_updated" | "workflow_run", ownerId: string, actor: "user" | "workflow" | undefined, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<import("@elizaos/shared").LifeOpsAuditEvent>;
+        recordReminderAudit(eventType: "reminder_due" | "reminder_delivered" | "reminder_blocked" | "reminder_escalation_started" | "reminder_escalation_resolved", ownerType: "occurrence" | "calendar_event", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordBrowserAudit(eventType: "browser_session_created" | "browser_session_updated", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordXPostAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        clearGoogleGrantAuthFailure(grant: import("@elizaos/shared").LifeOpsConnectorGrant): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        markGoogleGrantNeedsReauth(grant: import("@elizaos/shared").LifeOpsConnectorGrant, message: string): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        emitAssistantEvent(text: string, source: string, data?: Record<string, unknown>): void;
+        getWorkflowDefinition(workflowId: string): Promise<import("@elizaos/shared").LifeOpsWorkflowDefinition>;
+        requireXGrant(requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+    };
+} & import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<{
+    new (...args: any[]): {
+        upsertRelationship(input: Omit<import("@elizaos/shared").LifeOpsRelationship, "id" | "agentId" | "createdAt" | "updatedAt"> & {
+            id?: string;
+        }): Promise<import("@elizaos/shared").LifeOpsRelationship>;
+        getRelationship(id: string): Promise<import("@elizaos/shared").LifeOpsRelationship | null>;
+        listRelationships(opts?: {
+            limit?: number;
+            primaryChannel?: import("@elizaos/shared").LifeOpsMessageChannel;
+        } | undefined): Promise<import("@elizaos/shared").LifeOpsRelationship[]>;
+        logInteraction(input: Omit<import("@elizaos/shared").LifeOpsRelationshipInteraction, "id" | "agentId" | "createdAt">): Promise<import("@elizaos/shared").LifeOpsRelationshipInteraction>;
+        getDaysSinceContact(relationshipId: string): Promise<number | null>;
+        readonly repository: import("./repository.js").LifeOpsRepository;
+        readonly explicitOwnerEntityIdValue: string | null;
+        readonly ownerEntityIdValue: string;
+        readonly scheduleSyncClient: import("@elizaos/plugin-elizacloud/cloud/lifeops-schedule-sync-client").LifeOpsScheduleSyncClient;
+        ownerRoutingEntityIdPromise: Promise<string | null> | null;
+        adaptiveWindowPolicyCache: {
+            policy: ReturnType<typeof import("./defaults.js").computeAdaptiveWindowPolicy>;
+            computedAt: number;
+        } | null;
+        readonly runtime: import("@elizaos/core").IAgentRuntime;
+        agentId(): string;
+        ownerEntityId(): string;
+        ownerRoutingEntityId(): Promise<string | null>;
+        getBrowserSettingsInternal(): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        isBrowserPaused(settings: import("@elizaos/plugin-browser").BrowserBridgeSettings): boolean;
+        requireBrowserAvailableForActions(actions: readonly import("@elizaos/plugin-browser").BrowserBridgeAction[]): Promise<import("@elizaos/plugin-browser").BrowserBridgeSettings>;
+        buildBrowserCompanion(request: import("@elizaos/plugin-browser").UpsertBrowserBridgeCompanionRequest, current: import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus | null): import("@elizaos/plugin-browser").BrowserBridgeCompanionStatus;
+        normalizeOwnership(input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, current?: import("@elizaos/shared").LifeOpsOwnership): import("@elizaos/shared").LifeOpsOwnership;
+        normalizeChildOwnership(parent: import("@elizaos/shared").LifeOpsOwnership, input: import("@elizaos/shared").LifeOpsOwnershipInput | undefined, field?: string): import("@elizaos/shared").LifeOpsOwnership;
+        logLifeOpsWarn(operation: string, message: string, context?: Record<string, unknown>): void;
+        logLifeOpsError(operation: string, error: unknown, context?: Record<string, unknown>): void;
+        withReminderProcessingLock<T>(operation: () => Promise<T>): Promise<T>;
+        recordAudit(eventType: import("@elizaos/shared").LifeOpsAuditEventType, ownerType: "definition" | "occurrence" | "goal", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordConnectorAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordChannelPolicyAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordWorkflowAudit(eventType: "workflow_created" | "workflow_updated" | "workflow_run", ownerId: string, actor: "user" | "workflow" | undefined, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<import("@elizaos/shared").LifeOpsAuditEvent>;
+        recordReminderAudit(eventType: "reminder_due" | "reminder_delivered" | "reminder_blocked" | "reminder_escalation_started" | "reminder_escalation_resolved", ownerType: "occurrence" | "calendar_event", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordBrowserAudit(eventType: "browser_session_created" | "browser_session_updated", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        recordXPostAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+        clearGoogleGrantAuthFailure(grant: import("@elizaos/shared").LifeOpsConnectorGrant): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        markGoogleGrantNeedsReauth(grant: import("@elizaos/shared").LifeOpsConnectorGrant, message: string): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+        emitAssistantEvent(text: string, source: string, data?: Record<string, unknown>): void;
+        getWorkflowDefinition(workflowId: string): Promise<import("@elizaos/shared").LifeOpsWorkflowDefinition>;
+        requireXGrant(requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
+    };
+} & import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<typeof LifeOpsServiceBase, LifeOpsGoogleService>, LifeOpsCalendarService>, LifeOpsGmailService>, LifeOpsDriveService>, LifeOpsReminderService>, BrowserBridgeService>, LifeOpsWorkflowService>, LifeOpsDefinitionService>, LifeOpsGoalService>, LifeOpsXService>, LifeOpsHealthServicePublic>, LifeOpsEmailUnsubscribeService>, LifeOpsXReadService>, LifeOpsDiscordService>, LifeOpsTravelServicePublic>, LifeOpsSchedulingService> & Constructor<StatusMixinDependencies>, LifeOpsStatusService>, LifeOpsScreenTimeServicePublic>, LifeOpsInboxService>;
+declare class LifeOpsServiceComposed extends LIFEOPS_COMPOSED {
+}
+/**
+ * Main LifeOps service — assembled from domain mixins layered on top of
+ * {@link LifeOpsServiceBase}.
+ */
+export declare class LifeOpsService extends LifeOpsServiceComposed {
+}
+/** Declared explicitly: mixin composition exceeds TypeScript inference depth. */
+export interface LifeOpsService extends Omit<BrowserBridgeService, "getBrowserSettings" | "listBrowserCompanions">, LifeOpsSubscriptionService, LifeOpsTelegramService, LifeOpsIMessageService, LifeOpsRelationshipService, LifeOpsSignalService, LifeOpsWhatsAppService, LifeOpsCalendarService, Omit<LifeOpsHealthServicePublic, "getHealthConnectorStatus">, LifeOpsDefinitionService, LifeOpsDiscordService, LifeOpsDriveService, LifeOpsEmailUnsubscribeService, LifeOpsGmailService, LifeOpsGoalService, LifeOpsGoogleService, LifeOpsInboxService, LifeOpsReminderService, LifeOpsSchedulingService, LifeOpsScreenTimeServicePublic, LifeOpsStatusService, LifeOpsTravelServicePublic, LifeOpsWorkflowService, LifeOpsXReadService, Omit<LifeOpsXService, "getXConnectorStatus"> {
+    processScheduledWork(request?: {
+        now?: string;
+        reminderLimit?: number;
+        workflowLimit?: number;
+        scheduledTaskLimit?: number;
+    }): Promise<{
+        now: string;
+        reminderAttempts: LifeOpsReminderAttempt[];
+        workflowRuns: LifeOpsWorkflowRun[];
+        scheduledTaskFires: Array<Record<string, unknown>>;
+        scheduledTaskCompletionTimeouts: Array<Record<string, unknown>>;
+    }>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/lifeops/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/lifeops/service.ts"],"names":[],"mappings":"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"}

package/dist/lifeops/service.js

@@ -0,0 +1,62 @@
+import { LifeOpsServiceError } from "./service-types.js";
+import { withBrowser } from "./service-mixin-browser.js";
+import { withCalendar } from "./service-mixin-calendar.js";
+import { LifeOpsServiceBase } from "./service-mixin-core.js";
+import { withDefinitions } from "./service-mixin-definitions.js";
+import { withDiscord } from "./service-mixin-discord.js";
+import { withDrive } from "./service-mixin-drive.js";
+import { withEmailUnsubscribe } from "./service-mixin-email-unsubscribe.js";
+import { withGmail } from "./service-mixin-gmail.js";
+import { withGoals } from "./service-mixin-goals.js";
+import { withGoogle } from "./service-mixin-google.js";
+import { withHealth } from "./service-mixin-health.js";
+import { withIMessage } from "./service-mixin-imessage.js";
+import { withInbox } from "./service-mixin-inbox.js";
+import { withRelationships } from "./service-mixin-relationships.js";
+import { withReminders } from "./service-mixin-reminders.js";
+import { withScheduling } from "./service-mixin-scheduling.js";
+import { withScreenTime } from "./service-mixin-screentime.js";
+import { withSignal } from "./service-mixin-signal.js";
+import { withSleep } from "./service-mixin-sleep.js";
+import {
+  withStatus
+} from "./service-mixin-status.js";
+import { withSubscriptions } from "./service-mixin-subscriptions.js";
+import { withTelegram } from "./service-mixin-telegram.js";
+import { withTravel } from "./service-mixin-travel.js";
+import { withWhatsApp } from "./service-mixin-whatsapp.js";
+import { withWorkflows } from "./service-mixin-workflows.js";
+import { withX } from "./service-mixin-x.js";
+import { withXRead } from "./service-mixin-x-read.js";
+const LIFEOPS_BASE = withGoogle(LifeOpsServiceBase);
+const LIFEOPS_WITH_DATA = withDrive(withGmail(withCalendar(LIFEOPS_BASE)));
+const LIFEOPS_WITH_BUSINESS = withGoals(
+  withDefinitions(withWorkflows(withBrowser(withReminders(LIFEOPS_WITH_DATA))))
+);
+const LIFEOPS_WITH_X = withX(LIFEOPS_WITH_BUSINESS);
+const LIFEOPS_WITH_RELATIONS = withRelationships(LIFEOPS_WITH_X);
+const LIFEOPS_WITH_DOMAIN = withEmailUnsubscribe(
+  withHealth(LIFEOPS_WITH_RELATIONS)
+);
+const LIFEOPS_WITH_X_READ = withXRead(LIFEOPS_WITH_DOMAIN);
+const LIFEOPS_WITH_CONNECTORS = withWhatsApp(
+  withSignal(withDiscord(withTelegram(withIMessage(LIFEOPS_WITH_X_READ))))
+);
+const LIFEOPS_WITH_TRAVEL = withTravel(LIFEOPS_WITH_CONNECTORS);
+const LIFEOPS_WITH_SCHEDULING = withScheduling(LIFEOPS_WITH_TRAVEL);
+const LIFEOPS_WITH_SUBS = withSubscriptions(LIFEOPS_WITH_SCHEDULING);
+const LIFEOPS_WITH_STATUS = withStatus(
+  LIFEOPS_WITH_SUBS
+);
+const LIFEOPS_COMPOSED = withInbox(
+  withSleep(withScreenTime(LIFEOPS_WITH_STATUS))
+);
+class LifeOpsServiceComposed extends LIFEOPS_COMPOSED {
+}
+class LifeOpsService extends LifeOpsServiceComposed {
+}
+export {
+  LifeOpsService,
+  LifeOpsServiceError
+};
+//# sourceMappingURL=service.js.map

package/dist/lifeops/service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lifeops/service.ts"],"sourcesContent":["/**\n * LifeOps Service — thin facade that composes domain-specific mixins.\n *\n * The implementation lives in the `service-mixin-*.ts` files; standalone\n * helpers live in `service-normalize-*.ts` and `service-helpers-*.ts`.\n * This file only re-exports the public surface that consumers already import.\n */\n\nexport { LifeOpsServiceError } from \"./service-types.js\";\n\nimport type {\n  LifeOpsReminderAttempt,\n  LifeOpsWorkflowRun,\n} from \"@elizaos/shared\";\nimport type { BrowserBridgeService } from \"./service-mixin-browser.js\";\nimport { withBrowser } from \"./service-mixin-browser.js\";\n// Public method interfaces each mixin contributes. The composed class type\n// exceeds TypeScript's mixin-inference depth (~6 chained generics), so the\n// `interface LifeOpsService` merge below restates them explicitly to surface\n// every mixin method on the service type.\nimport type { LifeOpsCalendarService } from \"./service-mixin-calendar.js\";\nimport { withCalendar } from \"./service-mixin-calendar.js\";\nimport type { Constructor } from \"./service-mixin-core.js\";\nimport { LifeOpsServiceBase } from \"./service-mixin-core.js\";\nimport type { LifeOpsDefinitionService } from \"./service-mixin-definitions.js\";\nimport { withDefinitions } from \"./service-mixin-definitions.js\";\nimport type { LifeOpsDiscordService } from \"./service-mixin-discord.js\";\nimport { withDiscord } from \"./service-mixin-discord.js\";\nimport type { LifeOpsDriveService } from \"./service-mixin-drive.js\";\nimport { withDrive } from \"./service-mixin-drive.js\";\nimport type { LifeOpsEmailUnsubscribeService } from \"./service-mixin-email-unsubscribe.js\";\nimport { withEmailUnsubscribe } from \"./service-mixin-email-unsubscribe.js\";\nimport type { LifeOpsGmailService } from \"./service-mixin-gmail.js\";\nimport { withGmail } from \"./service-mixin-gmail.js\";\nimport type { LifeOpsGoalService } from \"./service-mixin-goals.js\";\nimport { withGoals } from \"./service-mixin-goals.js\";\nimport type { LifeOpsGoogleService } from \"./service-mixin-google.js\";\nimport { withGoogle } from \"./service-mixin-google.js\";\nimport type { LifeOpsHealthServicePublic } from \"./service-mixin-health.js\";\nimport { withHealth } from \"./service-mixin-health.js\";\nimport type { LifeOpsIMessageService } from \"./service-mixin-imessage.js\";\nimport { withIMessage } from \"./service-mixin-imessage.js\";\nimport type { LifeOpsInboxService } from \"./service-mixin-inbox.js\";\nimport { withInbox } from \"./service-mixin-inbox.js\";\nimport type { LifeOpsRelationshipService } from \"./service-mixin-relationships.js\";\nimport { withRelationships } from \"./service-mixin-relationships.js\";\nimport type { LifeOpsReminderService } from \"./service-mixin-reminders.js\";\nimport { withReminders } from \"./service-mixin-reminders.js\";\nimport type { LifeOpsSchedulingService } from \"./service-mixin-scheduling.js\";\nimport { withScheduling } from \"./service-mixin-scheduling.js\";\nimport type { LifeOpsScreenTimeServicePublic } from \"./service-mixin-screentime.js\";\nimport { withScreenTime } from \"./service-mixin-screentime.js\";\nimport type { LifeOpsSignalService } from \"./service-mixin-signal.js\";\nimport { withSignal } from \"./service-mixin-signal.js\";\nimport { withSleep } from \"./service-mixin-sleep.js\";\nimport type { LifeOpsStatusService } from \"./service-mixin-status.js\";\nimport {\n  type StatusMixinDependencies,\n  withStatus,\n} from \"./service-mixin-status.js\";\nimport type { LifeOpsSubscriptionService } from \"./service-mixin-subscriptions.js\";\nimport { withSubscriptions } from \"./service-mixin-subscriptions.js\";\nimport type { LifeOpsTelegramService } from \"./service-mixin-telegram.js\";\nimport { withTelegram } from \"./service-mixin-telegram.js\";\nimport type { LifeOpsTravelServicePublic } from \"./service-mixin-travel.js\";\nimport { withTravel } from \"./service-mixin-travel.js\";\nimport type { LifeOpsWhatsAppService } from \"./service-mixin-whatsapp.js\";\nimport { withWhatsApp } from \"./service-mixin-whatsapp.js\";\nimport type { LifeOpsWorkflowService } from \"./service-mixin-workflows.js\";\nimport { withWorkflows } from \"./service-mixin-workflows.js\";\nimport type { LifeOpsXService } from \"./service-mixin-x.js\";\nimport { withX } from \"./service-mixin-x.js\";\nimport type { LifeOpsXReadService } from \"./service-mixin-x-read.js\";\nimport { withXRead } from \"./service-mixin-x-read.js\";\n\n/**\n * Mixin order follows dependency direction: Google auth → data layers\n * (Calendar, Gmail, Drive) → business logic (Reminders, Browser, Workflows,\n * Definitions, Goals) → connectors (X, Telegram, Discord, Signal).\n */\nconst LIFEOPS_BASE = withGoogle(LifeOpsServiceBase);\nconst LIFEOPS_WITH_DATA = withDrive(withGmail(withCalendar(LIFEOPS_BASE)));\nconst LIFEOPS_WITH_BUSINESS = withGoals(\n  withDefinitions(withWorkflows(withBrowser(withReminders(LIFEOPS_WITH_DATA)))),\n);\nconst LIFEOPS_WITH_X = withX(LIFEOPS_WITH_BUSINESS);\nconst LIFEOPS_WITH_RELATIONS = withRelationships(LIFEOPS_WITH_X);\nconst LIFEOPS_WITH_DOMAIN = withEmailUnsubscribe(\n  withHealth(LIFEOPS_WITH_RELATIONS),\n);\nconst LIFEOPS_WITH_X_READ = withXRead(LIFEOPS_WITH_DOMAIN);\nconst LIFEOPS_WITH_CONNECTORS = withWhatsApp(\n  withSignal(withDiscord(withTelegram(withIMessage(LIFEOPS_WITH_X_READ)))),\n);\nconst LIFEOPS_WITH_TRAVEL = withTravel(LIFEOPS_WITH_CONNECTORS);\nconst LIFEOPS_WITH_SCHEDULING = withScheduling(LIFEOPS_WITH_TRAVEL);\n// Payment-source / transaction / spending logic moved to\n// @elizaos/plugin-finances (FinancesService). Subscription audit / cancellation\n// also moved there (SubscriptionsService), which reaches Gmail + the browser\n// bridge through runtime-service seams. LifeOpsService no longer implements\n// either back-end; the OWNER_FINANCES handler + the /api/lifeops/money/* and\n// /api/lifeops/subscriptions/* routes delegate to the finances services. The\n// `withSubscriptions` mixin is a thin forwarding shim that keeps the service\n// surface stable for those call sites.\nconst LIFEOPS_WITH_SUBS = withSubscriptions(LIFEOPS_WITH_SCHEDULING);\n// TypeScript loses track of constraint satisfaction past ~6 chained generic\n// mixins, so we cast explicitly. The runtime composition has every method\n// `withStatus` depends on (getScheduleMergedState from withScheduling,\n// getBrowserSettings/listBrowserCompanions from withBrowser,\n// getXConnectorStatus from withX, getHealthConnectorStatus from withHealth).\ntype LifeOpsSubsCtor = typeof LIFEOPS_WITH_SUBS;\nconst LIFEOPS_WITH_STATUS = withStatus(\n  LIFEOPS_WITH_SUBS as LifeOpsSubsCtor & Constructor<StatusMixinDependencies>,\n);\nconst LIFEOPS_COMPOSED = withInbox(\n  withSleep(withScreenTime(LIFEOPS_WITH_STATUS)),\n);\n\nclass LifeOpsServiceComposed extends LIFEOPS_COMPOSED {}\n\n/**\n * Main LifeOps service — assembled from domain mixins layered on top of\n * {@link LifeOpsServiceBase}.\n */\nexport class LifeOpsService extends LifeOpsServiceComposed {}\n\n/** Declared explicitly: mixin composition exceeds TypeScript inference depth. */\n// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: intentional class+interface merge to surface mixin methods past TS inference depth\nexport interface LifeOpsService\n  extends Omit<\n      BrowserBridgeService,\n      // both already surfaced (with slightly different signatures) by the\n      // composed class / status-mixin deps; omit to avoid an extends conflict.\n      \"getBrowserSettings\" | \"listBrowserCompanions\"\n    >,\n    LifeOpsSubscriptionService,\n    LifeOpsTelegramService,\n    LifeOpsIMessageService,\n    LifeOpsRelationshipService,\n    LifeOpsSignalService,\n    LifeOpsWhatsAppService,\n    LifeOpsCalendarService,\n    // `getHealthConnectorStatus` is also declared (with a different return\n    // type) by the status mixin already on the composed class, so omit it here.\n    Omit<LifeOpsHealthServicePublic, \"getHealthConnectorStatus\">,\n    LifeOpsDefinitionService,\n    LifeOpsDiscordService,\n    LifeOpsDriveService,\n    LifeOpsEmailUnsubscribeService,\n    LifeOpsGmailService,\n    LifeOpsGoalService,\n    LifeOpsGoogleService,\n    LifeOpsInboxService,\n    LifeOpsReminderService,\n    LifeOpsSchedulingService,\n    LifeOpsScreenTimeServicePublic,\n    LifeOpsStatusService,\n    LifeOpsTravelServicePublic,\n    LifeOpsWorkflowService,\n    LifeOpsXReadService,\n    // `getXConnectorStatus` is also surfaced (with a slightly different\n    // signature) by the status mixin already on the composed class, so omit it\n    // here to avoid an extends conflict while keeping the other X methods.\n    Omit<LifeOpsXService, \"getXConnectorStatus\"> {\n  processScheduledWork(request?: {\n    now?: string;\n    reminderLimit?: number;\n    workflowLimit?: number;\n    scheduledTaskLimit?: number;\n  }): Promise<{\n    now: string;\n    reminderAttempts: LifeOpsReminderAttempt[];\n    workflowRuns: LifeOpsWorkflowRun[];\n    scheduledTaskFires: Array<Record<string, unknown>>;\n    scheduledTaskCompletionTimeouts: Array<Record<string, unknown>>;\n  }>;\n}\n"],"mappings":"AAQA,SAAS,2BAA2B;AAOpC,SAAS,mBAAmB;AAM5B,SAAS,oBAAoB;AAE7B,SAAS,0BAA0B;AAEnC,SAAS,uBAAuB;AAEhC,SAAS,mBAAmB;AAE5B,SAAS,iBAAiB;AAE1B,SAAS,4BAA4B;AAErC,SAAS,iBAAiB;AAE1B,SAAS,iBAAiB;AAE1B,SAAS,kBAAkB;AAE3B,SAAS,kBAAkB;AAE3B,SAAS,oBAAoB;AAE7B,SAAS,iBAAiB;AAE1B,SAAS,yBAAyB;AAElC,SAAS,qBAAqB;AAE9B,SAAS,sBAAsB;AAE/B,SAAS,sBAAsB;AAE/B,SAAS,kBAAkB;AAC3B,SAAS,iBAAiB;AAE1B;AAAA,EAEE;AAAA,OACK;AAEP,SAAS,yBAAyB;AAElC,SAAS,oBAAoB;AAE7B,SAAS,kBAAkB;AAE3B,SAAS,oBAAoB;AAE7B,SAAS,qBAAqB;AAE9B,SAAS,aAAa;AAEtB,SAAS,iBAAiB;AAO1B,MAAM,eAAe,WAAW,kBAAkB;AAClD,MAAM,oBAAoB,UAAU,UAAU,aAAa,YAAY,CAAC,CAAC;AACzE,MAAM,wBAAwB;AAAA,EAC5B,gBAAgB,cAAc,YAAY,cAAc,iBAAiB,CAAC,CAAC,CAAC;AAC9E;AACA,MAAM,iBAAiB,MAAM,qBAAqB;AAClD,MAAM,yBAAyB,kBAAkB,cAAc;AAC/D,MAAM,sBAAsB;AAAA,EAC1B,WAAW,sBAAsB;AACnC;AACA,MAAM,sBAAsB,UAAU,mBAAmB;AACzD,MAAM,0BAA0B;AAAA,EAC9B,WAAW,YAAY,aAAa,aAAa,mBAAmB,CAAC,CAAC,CAAC;AACzE;AACA,MAAM,sBAAsB,WAAW,uBAAuB;AAC9D,MAAM,0BAA0B,eAAe,mBAAmB;AASlE,MAAM,oBAAoB,kBAAkB,uBAAuB;AAOnE,MAAM,sBAAsB;AAAA,EAC1B;AACF;AACA,MAAM,mBAAmB;AAAA,EACvB,UAAU,eAAe,mBAAmB,CAAC;AAC/C;AAEA,MAAM,+BAA+B,iBAAiB;AAAC;AAMhD,MAAM,uBAAuB,uBAAuB;AAAC;","names":[]}

package/dist/lifeops/signal-runtime-config.d.ts

@@ -0,0 +1,13 @@
+type ConfigRecord = Record<string, unknown> & {
+    connectors?: Record<string, unknown>;
+};
+export declare function upsertSignalConnectorConfig(config: ConfigRecord, args: {
+    authDir: string;
+    account: string;
+}): boolean;
+export declare function removeSignalConnectorConfig(config: ConfigRecord, args?: {
+    authDir?: string | null;
+    account?: string | null;
+}): boolean;
+export {};
+//# sourceMappingURL=signal-runtime-config.d.ts.map

package/dist/lifeops/signal-runtime-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-runtime-config.d.ts","sourceRoot":"","sources":["../../src/lifeops/signal-runtime-config.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC,CAAC;AAgBF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE;IACJ,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,GACA,OAAO,CAwBT;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,YAAY,EACpB,IAAI,GAAE;IACJ,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB,GACL,OAAO,CAgBT"}