@elizaos/agent 2.0.0-alpha.441 → 2.0.0-alpha.501

package/apps/app-lifeops/src/lifeops/service.d.ts

@@ -6,12 +6,13 @@
  * This file only re-exports the public surface that consumers already import.
  */
 export { LifeOpsServiceError } from "./service-types.js";
-import { LifeOpsServiceBase } from "./service-mixin-core.js";
 import type { Constructor } from "./service-mixin-core.js";
+import { LifeOpsServiceBase } from "./service-mixin-core.js";
 import { type StatusMixinDependencies } from "./service-mixin-status.js";
 declare const LIFEOPS_COMPOSED: {
     new (...args: any[]): {
         getInbox(request?: import("@elizaos/shared").GetLifeOpsInboxRequest): Promise<import("@elizaos/shared").LifeOpsInbox>;
+        markInboxEntryRead(inboxEntryId: string): Promise<import("@elizaos/shared").LifeOpsInboxMessage>;
         readonly repository: import("./repository.js").LifeOpsRepository;
         readonly explicitOwnerEntityIdValue: string | null;
         readonly ownerEntityIdValue: string;
@@ -118,9 +119,10 @@ declare const LIFEOPS_COMPOSED: {
         collectScreenTimeRows(opts: {
             since: string;
             until: string;
-            source?: "app" | "website";
+            source?: import("@elizaos/shared").LifeOpsScreenTimeSource;
+            identifier?: string;
         }): Promise<{
-            source: "app" | "website";
+            source: import("@elizaos/shared").LifeOpsScreenTimeSource;
             identifier: string;
             displayName: string;
             totalSeconds: number;
@@ -129,134 +131,39 @@ declare const LIFEOPS_COMPOSED: {
         }[]>;
         getScreenTimeDaily(opts: {
             date: string;
-            source?: "app" | "website";
+            source?: import("@elizaos/shared").LifeOpsScreenTimeSource;
+            identifier?: string;
             limit?: number;
         }): Promise<import("@elizaos/shared").LifeOpsScreenTimeDaily[]>;
         getScreenTimeSummary(opts: {
             since: string;
             until: string;
-            source?: "app" | "website";
+            source?: import("@elizaos/shared").LifeOpsScreenTimeSource;
+            identifier?: string;
             topN?: number;
-        }): Promise<{
-            items: {
-                source: "app" | "website";
-                identifier: string;
-                displayName: string;
-                totalSeconds: number;
-            }[];
-            totalSeconds: number;
-        }>;
+        }): Promise<import("@elizaos/shared").LifeOpsScreenTimeSummary>;
         getScreenTimeBreakdown(opts: {
             since: string;
             until: string;
-            source?: "app" | "website";
+            source?: import("@elizaos/shared").LifeOpsScreenTimeSource;
+            identifier?: string;
             topN?: number;
-        }): Promise<{
-            items: {
-                source: "app" | "website";
-                identifier: string;
-                displayName: string;
-                totalSeconds: number;
-                sessionCount: number;
-                category: string;
-                device: string;
-                service: string | null;
-                serviceLabel: string | null;
-                browser: string | null;
-            }[];
-            totalSeconds: number;
-            bySource: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            byCategory: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            byDevice: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            byService: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            byBrowser: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            fetchedAt: string;
-        }>;
+        }): Promise<import("@elizaos/shared").LifeOpsScreenTimeBreakdown>;
         getSocialHabitSummary(opts: {
             since: string;
             until: string;
             topN?: number;
-        }): Promise<{
-            since: string;
-            until: string;
-            totalSeconds: number;
-            services: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            devices: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            surfaces: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            browsers: {
-                key: string;
-                label: string;
-                totalSeconds: number;
-            }[];
-            sessions: {
-                source: "app" | "website";
-                identifier: string;
-                displayName: string;
-                totalSeconds: number;
-                sessionCount: number;
-                category: string;
-                device: string;
-                service: string | null;
-                serviceLabel: string | null;
-                browser: string | null;
-            }[];
-            messages: {
-                channels: Array<{
-                    channel: "x_dm";
-                    label: string;
-                    inbound: number;
-                    outbound: number;
-                    opened: number;
-                    replied: number;
-                }>;
-                inbound: number;
-                outbound: number;
-                opened: number;
-                replied: number;
-            };
-            dataSources: Array<{
-                id: string;
-                label: string;
-                state: "live" | "partial" | "unwired";
-            }>;
-            fetchedAt: string;
-        }>;
+        }): Promise<import("@elizaos/shared").LifeOpsSocialHabitSummary>;
+        getScreenTimeHistory(opts: {
+            range: import("@elizaos/shared").LifeOpsScreenTimeRangeKey;
+            topN?: number;
+            socialTopN?: number;
+        }): Promise<import("@elizaos/shared").LifeOpsScreenTimeHistoryResponse>;
         getScreenTimeWeeklyAverageByApp(opts: {
             since: string;
             until: string;
             daysInWindow: number;
+            identifier?: string;
             topN?: number;
         }): Promise<{
             items: {
@@ -776,6 +683,17 @@ declare const LIFEOPS_COMPOSED: {
         stopSignalPairing(side?: import("@elizaos/shared").LifeOpsConnectorSide): import("@elizaos/shared").LifeOpsSignalPairingStatus;
         disconnectSignal(side?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("@elizaos/shared").LifeOpsSignalConnectorStatus>;
         readSignalInbound(limit?: number): 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;
@@ -834,6 +752,13 @@ declare const LIFEOPS_COMPOSED: {
             reason: import("@elizaos/shared").LifeOpsMessagingConnectorReason;
         }>;
         lifeOpsDiscordBuildWorkspaceStatus(normalizedSide: import("@elizaos/shared").LifeOpsConnectorSide, grant: import("@elizaos/shared").LifeOpsConnectorGrant | null): Promise<import("@elizaos/shared").LifeOpsDiscordConnectorStatus>;
+        lifeOpsDiscordUpsertGrantForActiveSession(args: {
+            side: import("@elizaos/shared").LifeOpsConnectorSide;
+            grant: import("@elizaos/shared").LifeOpsConnectorGrant | null;
+            identity: Record<string, unknown>;
+            capabilities: readonly import("@elizaos/shared").LifeOpsDiscordCapability[];
+            metadata?: Record<string, unknown>;
+        }): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
         getDiscordConnectorStatus(side?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("@elizaos/shared").LifeOpsDiscordConnectorStatus>;
         authorizeDiscordConnector(side?: import("@elizaos/shared").LifeOpsConnectorSide, source?: import("@elizaos/shared").LifeOpsOwnerBrowserAccessSource): Promise<import("@elizaos/shared").LifeOpsDiscordConnectorStatus>;
         searchDiscordMessages(request: {
@@ -842,6 +767,34 @@ declare const LIFEOPS_COMPOSED: {
             channelId?: string;
         }): Promise<import("./discord-browser-scraper.js").DiscordMessageSearchResult[]>;
         captureDiscordDeliveryStatus(side?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("./discord-browser-scraper.js").DiscordMessageSearchResult[]>;
+        sendDiscordMessage(request: {
+            side?: import("@elizaos/shared").LifeOpsConnectorSide;
+            channelId?: string;
+            text: string;
+        }): Promise<{
+            provider: "discord";
+            side: import("@elizaos/shared").LifeOpsConnectorSide;
+            channelId: string;
+            ok: true;
+            deliveryStatus: "sent" | "sending" | "failed" | "unknown";
+        }>;
+        verifyDiscordConnector(request: {
+            side?: import("@elizaos/shared").LifeOpsConnectorSide;
+            channelId?: string;
+            sendMessage?: string;
+        }): Promise<{
+            provider: "discord";
+            side: import("@elizaos/shared").LifeOpsConnectorSide;
+            verifiedAt: string;
+            status: import("@elizaos/shared").LifeOpsDiscordConnectorStatus;
+            send: {
+                ok: boolean;
+                error: string | null;
+                channelId: string | null;
+                message: string;
+                deliveryStatus: "sent" | "sending" | "failed" | "unknown" | null;
+            };
+        }>;
         disconnectDiscord(side?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("@elizaos/shared").LifeOpsDiscordConnectorStatus>;
         readonly repository: import("./repository.js").LifeOpsRepository;
         readonly explicitOwnerEntityIdValue: string | null;
@@ -955,6 +908,10 @@ declare const LIFEOPS_COMPOSED: {
             ok: true;
             messageId?: string;
         }>;
+        sendIMessageViaMessagesUrl(req: import("./imessage-bridge.js").IMessageSendRequest, cause: unknown): Promise<{
+            ok: true;
+            messageId?: string;
+        }>;
         readIMessages(opts: {
             chatId?: string;
             since?: string;
@@ -1122,58 +1079,7 @@ declare const LIFEOPS_COMPOSED: {
         getWorkflowDefinition(workflowId: string): Promise<import("@elizaos/shared").LifeOpsWorkflowDefinition>;
         requireXGrant(requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode): Promise<import("@elizaos/shared").LifeOpsConnectorGrant>;
     };
-} & {
-    new (...args: any[]): {
-        getHealthConnectorStatus(): Promise<{
-            available: boolean;
-            backend: import("./health-bridge.js").HealthBackend;
-            lastCheckedAt: string;
-        }>;
-        getHealthDailySummary(date: string): Promise<import("./health-bridge.js").HealthDailySummary>;
-        getHealthTrend(days: number): Promise<import("./health-bridge.js").HealthDailySummary[]>;
-        getHealthDataPoints(opts: {
-            metric: import("./health-bridge.js").HealthDataPoint["metric"];
-            startAt: string;
-            endAt: string;
-        }): Promise<import("./health-bridge.js").HealthDataPoint[]>;
-        readonly repository: import("./repository.js").LifeOpsRepository;
-        readonly explicitOwnerEntityIdValue: string | null;
-        readonly ownerEntityIdValue: string;
-        readonly googleManagedClient: import("./google-managed-client.js").GoogleManagedClient;
-        readonly xManagedClient: import("./x-managed-client.js").XManagedClient;
-        readonly scheduleSyncClient: import("./schedule-sync-client.js").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-bridge").BrowserBridgeSettings>;
-        isBrowserPaused(settings: import("@elizaos/plugin-browser-bridge").BrowserBridgeSettings): boolean;
-        requireBrowserAvailableForActions(actions: readonly import("@elizaos/plugin-browser-bridge").BrowserBridgeAction[]): Promise<import("@elizaos/plugin-browser-bridge").BrowserBridgeSettings>;
-        buildBrowserCompanion(request: import("@elizaos/plugin-browser-bridge").UpsertBrowserBridgeCompanionRequest, current: import("@elizaos/plugin-browser-bridge").BrowserBridgeCompanionStatus | null): import("@elizaos/plugin-browser-bridge").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", 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[]): {
         generateDossier(input: {
             subject: string;
@@ -1407,7 +1313,27 @@ declare const LIFEOPS_COMPOSED: {
         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<typeof LifeOpsServiceBase, import("./service-mixin-google.js").LifeOpsGoogleService>, import("./service-mixin-calendar.js").LifeOpsCalendarService>, import("./service-mixin-gmail.js").LifeOpsGmailService>, import("./service-mixin-reminders.js").LifeOpsReminderService>, import("./service-mixin-browser.js").BrowserBridgeService>, import("./service-mixin-workflows.js").LifeOpsWorkflowService>, import("./service-mixin-definitions.js").LifeOpsDefinitionService>, import("./service-mixin-goals.js").LifeOpsGoalService>, import("./service-mixin-x.js").LifeOpsXService> & Constructor<StatusMixinDependencies>;
+} & import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<import("./service-mixin-core.js").MixinClass<typeof LifeOpsServiceBase, import("./service-mixin-google.js").LifeOpsGoogleService>, import("./service-mixin-calendar.js").LifeOpsCalendarService>, import("./service-mixin-gmail.js").LifeOpsGmailService>, import("./service-mixin-reminders.js").LifeOpsReminderService>, import("./service-mixin-browser.js").BrowserBridgeService>, import("./service-mixin-workflows.js").LifeOpsWorkflowService>, import("./service-mixin-definitions.js").LifeOpsDefinitionService>, import("./service-mixin-goals.js").LifeOpsGoalService>, import("./service-mixin-x.js").LifeOpsXService>, {
+    getHealthConnectorStatus(): Promise<{
+        available: boolean;
+        backend: import("./health-bridge.js").HealthBackend;
+        lastCheckedAt: string;
+    }>;
+    getHealthDataConnectorStatuses(requestUrl: URL, requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode, requestedSide?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("@elizaos/shared").LifeOpsHealthConnectorStatus[]>;
+    getHealthDataConnectorStatus(provider: import("@elizaos/shared").LifeOpsHealthConnectorProvider, requestUrl: URL, requestedMode?: import("@elizaos/shared").LifeOpsConnectorMode, requestedSide?: import("@elizaos/shared").LifeOpsConnectorSide): Promise<import("@elizaos/shared").LifeOpsHealthConnectorStatus>;
+    startHealthConnector(request: import("@elizaos/shared").StartLifeOpsHealthConnectorRequest, requestUrl: URL): Promise<import("@elizaos/shared").StartLifeOpsHealthConnectorResponse>;
+    completeHealthConnectorCallback(callbackUrl: URL): Promise<import("@elizaos/shared").LifeOpsHealthConnectorStatus>;
+    disconnectHealthConnector(request: import("@elizaos/shared").DisconnectLifeOpsHealthConnectorRequest, requestUrl: URL): Promise<import("@elizaos/shared").LifeOpsHealthConnectorStatus>;
+    syncHealthConnectors(request?: import("@elizaos/shared").SyncLifeOpsHealthConnectorRequest): Promise<import("@elizaos/shared").LifeOpsHealthSummaryResponse>;
+    getHealthSummary(request?: import("@elizaos/shared").GetLifeOpsHealthSummaryRequest): Promise<import("@elizaos/shared").LifeOpsHealthSummaryResponse>;
+    getHealthDailySummary(date: string): Promise<import("./health-bridge.js").HealthDailySummary>;
+    getHealthTrend(days: number): Promise<import("./health-bridge.js").HealthDailySummary[]>;
+    getHealthDataPoints(opts: {
+        metric: import("./health-bridge.js").HealthDataPoint["metric"];
+        startAt: string;
+        endAt: string;
+    }): Promise<import("./health-bridge.js").HealthDataPoint[]>;
+}> & Constructor<StatusMixinDependencies>;
 declare class LifeOpsServiceComposed extends LIFEOPS_COMPOSED {
 }
 /**

package/apps/app-lifeops/src/lifeops/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAIzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAkB7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EACL,KAAK,uBAAuB,EAE7B,MAAM,2BAA2B,CAAC;AAgDnC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBA3DqB,CAAC;iBAClC,CAAC;mBAA8C,CAAC;eACnD,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uuBA2DN,CAAC;AAEF,cAAM,sBAAuB,SAAQ,gBAAgB;CAAG;AAExD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,sBAAsB;CAAG"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAIzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAmB7D,OAAO,EACL,KAAK,uBAAuB,EAE7B,MAAM,2BAA2B,CAAC;AAyCnC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAlDX,CAAC;iBAA0B,CAAC;mBACxB,CAAC;eAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAmDlC,CAAC;AAEF,cAAM,sBAAuB,SAAQ,gBAAgB;CAAG;AAExD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,sBAAsB;CAAG"}

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

@@ -14,12 +14,13 @@ import { withDiscord } from "./service-mixin-discord.js";
 import { withDossier } from "./service-mixin-dossier.js";
 import { withDrive } from "./service-mixin-drive.js";
 import { withEmailUnsubscribe } from "./service-mixin-email-unsubscribe.js";
-import { withPayments } from "./service-mixin-payments.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 { withPayments } from "./service-mixin-payments.js";
 import { withRelationships } from "./service-mixin-relationships.js";
 import { withReminders } from "./service-mixin-reminders.js";
 import { withScheduling } from "./service-mixin-scheduling.js";
@@ -30,7 +31,6 @@ 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 { withInbox } from "./service-mixin-inbox.js";
 import { withWhatsApp } from "./service-mixin-whatsapp.js";
 import { withWorkflows } from "./service-mixin-workflows.js";
 import { withX } from "./service-mixin-x.js";

package/apps/app-lifeops/src/lifeops/signal-auth.d.ts

@@ -17,6 +17,12 @@ export interface SignalLinkedDeviceInfo {
     uuid: string;
     deviceName: string;
 }
+export interface SignalLinkedDeviceCandidate {
+    agentId: string;
+    side: LifeOpsConnectorSide;
+    tokenRef: string;
+    info: SignalLinkedDeviceInfo;
+}
 export declare function startSignalPairing(agentId: string, side: LifeOpsConnectorSide): PendingSignalPairingSession;
 export declare function getSignalPairingStatus(sessionId: string): LifeOpsSignalPairingStatus;
 export declare function getSignalPairingStatusForSide(agentId: string, side: LifeOpsConnectorSide): LifeOpsSignalPairingStatus | null;
@@ -25,5 +31,6 @@ export declare function stopSignalPairing(agentId: string, side: LifeOpsConnecto
     readonly sessionId: string | null;
 };
 export declare function readSignalLinkedDeviceInfo(tokenRef: string): SignalLinkedDeviceInfo | null;
+export declare function findSignalLinkedDeviceInfoForSide(agentId: string, side: LifeOpsConnectorSide, env?: NodeJS.ProcessEnv): SignalLinkedDeviceCandidate | null;
 export declare function deleteSignalLinkedDevice(tokenRef: string): void;
 //# sourceMappingURL=signal-auth.d.ts.map

package/apps/app-lifeops/src/lifeops/signal-auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signal-auth.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/signal-auth.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,oBAAoB,EACpB,0BAA0B,EAC3B,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;IAC3C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAmUD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,oBAAoB,GACzB,2BAA2B,CA4B7B;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,0BAA0B,CAoB5B;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,oBAAoB,GACzB,0BAA0B,GAAG,IAAI,CAOnC;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,oBAAoB,GACzB;IAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAUlE;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,GACf,sBAAsB,GAAG,IAAI,CAgB/B;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAI/D"}
+{"version":3,"file":"signal-auth.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/signal-auth.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,oBAAoB,EACpB,0BAA0B,EAC3B,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,0BAA0B,CAAC,OAAO,CAAC,CAAC;IAC3C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,sBAAsB,CAAC;CAC9B;AAmUD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,oBAAoB,GACzB,2BAA2B,CA4B7B;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,0BAA0B,CAoB5B;AAED,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,oBAAoB,GACzB,0BAA0B,GAAG,IAAI,CAOnC;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,oBAAoB,GACzB;IAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAUlE;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,GACf,sBAAsB,GAAG,IAAI,CA6B/B;AAqCD,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,oBAAoB,EAC1B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,2BAA2B,GAAG,IAAI,CAUpC;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAI/D"}

package/apps/app-lifeops/src/lifeops/signal-auth.js

@@ -285,18 +285,62 @@ export function readSignalLinkedDeviceInfo(tokenRef) {
     if (!fs.existsSync(filePath)) {
         return null;
     }
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.authDir || !parsed.phoneNumber) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed.authDir !== "string" ||
+        parsed.authDir.trim().length === 0 ||
+        typeof parsed.phoneNumber !== "string" ||
+        parsed.phoneNumber.trim().length === 0) {
         return null;
     }
     return {
         authDir: parsed.authDir,
-        phoneNumber: parsed.phoneNumber,
-        uuid: parsed.uuid ?? "",
-        deviceName: parsed.deviceName ?? "Eliza Mac",
+        phoneNumber: parsed.phoneNumber.trim(),
+        uuid: typeof parsed.uuid === "string" ? parsed.uuid : "",
+        deviceName: typeof parsed.deviceName === "string" &&
+            parsed.deviceName.trim().length > 0
+            ? parsed.deviceName
+            : "Eliza Mac",
     };
 }
+function linkedDeviceCandidate(agentId, side, env = process.env) {
+    const tokenRef = signalAuthDir(agentId, side, env);
+    const info = readSignalLinkedDeviceInfo(tokenRef);
+    return info
+        ? {
+            agentId,
+            side,
+            tokenRef,
+            info,
+        }
+        : null;
+}
+function listLinkedDeviceCandidatesForSide(side, env = process.env) {
+    const root = signalStorageRoot(env);
+    if (!fs.existsSync(root)) {
+        return [];
+    }
+    return fs
+        .readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name !== "pending")
+        .flatMap((entry) => {
+        const candidate = linkedDeviceCandidate(entry.name, side, env);
+        return candidate ? [candidate] : [];
+    });
+}
+export function findSignalLinkedDeviceInfoForSide(agentId, side, env = process.env) {
+    const exact = linkedDeviceCandidate(agentId, side, env);
+    if (exact) {
+        return exact;
+    }
+    const candidates = listLinkedDeviceCandidatesForSide(side, env).filter((candidate) => candidate.agentId !== agentId);
+    return candidates.length === 1 ? candidates[0] : null;
+}
 export function deleteSignalLinkedDevice(tokenRef) {
     if (fs.existsSync(tokenRef)) {
         fs.rmSync(tokenRef, { recursive: true, force: true });

package/apps/app-lifeops/src/lifeops/signal-local-client.d.ts

@@ -32,6 +32,10 @@ export interface SignalLocalClientConfig {
      */
     accountNumber: string;
 }
+export interface SignalLocalSendRequest {
+    recipient: string;
+    text: string;
+}
 export declare class SignalLocalClientError extends Error {
     readonly status: number | null;
     readonly category: "auth" | "not_found" | "network" | "unknown";
@@ -58,4 +62,7 @@ export declare function readSignalLocalClientConfigFromEnv(env?: NodeJS.ProcessE
  * empty inbox.
  */
 export declare function readSignalInboundMessages(config: SignalLocalClientConfig, limit?: number): Promise<LifeOpsSignalInboundMessage[]>;
+export declare function sendSignalLocalMessage(config: SignalLocalClientConfig, request: SignalLocalSendRequest): Promise<{
+    timestamp: number;
+}>;
 //# sourceMappingURL=signal-local-client.d.ts.map

package/apps/app-lifeops/src/lifeops/signal-local-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signal-local-client.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/signal-local-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;gBAG9D,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QACP,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,QAAQ,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAC;KAC9C;CAOJ;AAMD;;;GAGG;AACH,wBAAgB,kCAAkC,CAChD,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,uBAAuB,GAAG,IAAI,CAKhC;AA0CD;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,uBAAuB,EAC/B,KAAK,SAAwB,GAC5B,OAAO,CAAC,2BAA2B,EAAE,CAAC,CA+HxC"}
+{"version":3,"file":"signal-local-client.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/signal-local-client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;gBAG9D,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QACP,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,QAAQ,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAC;KAC9C;CAOJ;AAOD;;;GAGG;AACH,wBAAgB,kCAAkC,CAChD,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,uBAAuB,GAAG,IAAI,CAKhC;AA2DD;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,uBAAuB,EAC/B,KAAK,SAAwB,GAC5B,OAAO,CAAC,2BAA2B,EAAE,CAAC,CAyIxC;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,uBAAuB,EAC/B,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAsGhC"}

package/apps/app-lifeops/src/lifeops/signal-local-client.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { logger } from "@elizaos/core";
 export class SignalLocalClientError extends Error {
     status;
@@ -12,20 +13,24 @@ export class SignalLocalClientError extends Error {
 const REQUEST_TIMEOUT_MS = 10_000;
 const MAX_RECEIVE_LIMIT = 100;
 const DEFAULT_RECEIVE_LIMIT = 25;
+const DEFAULT_SIGNAL_HTTP_URL = "http://127.0.0.1:8080";
 /**
  * Read env-based configuration for the signal-cli HTTP client.
  * Returns null if the required vars are absent.
  */
 export function readSignalLocalClientConfigFromEnv(env = process.env) {
-    const httpUrl = env.SIGNAL_HTTP_URL?.trim();
+    const httpUrl = env.SIGNAL_HTTP_URL?.trim() || DEFAULT_SIGNAL_HTTP_URL;
     const accountNumber = env.SIGNAL_ACCOUNT_NUMBER?.trim();
-    if (!httpUrl || !accountNumber)
+    if (!accountNumber)
         return null;
     return { httpUrl, accountNumber };
 }
 function isSignalCliReceiveResponse(value) {
     return Boolean(value && typeof value === "object");
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object");
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -96,7 +101,9 @@ export async function readSignalInboundMessages(config, limit = DEFAULT_RECEIVE_
         throw new SignalLocalClientError("Signal local receive returned an unexpected payload", { status: response.status, category: "unknown" });
     }
     const messages = [];
-    for (const item of body.filter(isSignalCliReceiveResponse).slice(0, clampedLimit)) {
+    for (const item of body
+        .filter(isSignalCliReceiveResponse)
+        .slice(0, clampedLimit)) {
         const envelope = item.envelope;
         if (!envelope)
             continue;
@@ -132,7 +139,9 @@ export async function readSignalInboundMessages(config, limit = DEFAULT_RECEIVE_
             speakerName,
             senderNumber,
             senderUuid,
-            sourceDevice: typeof envelope.sourceDevice === "number" ? envelope.sourceDevice : null,
+            sourceDevice: typeof envelope.sourceDevice === "number"
+                ? envelope.sourceDevice
+                : null,
             groupId,
             groupType,
             text: dataMessage.message,
@@ -143,3 +152,85 @@ export async function readSignalInboundMessages(config, limit = DEFAULT_RECEIVE_
     }
     return messages;
 }
+export async function sendSignalLocalMessage(config, request) {
+    const url = `${config.httpUrl.replace(/\/$/, "")}/api/v1/rpc`;
+    const rpcId = randomUUID();
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: rpcId,
+                method: "send",
+                params: {
+                    account: config.accountNumber,
+                    recipients: [request.recipient],
+                    message: request.text,
+                },
+            }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn({
+            boundary: "lifeops",
+            integration: "signal",
+            operation: "signal_local_send",
+            httpUrl: config.httpUrl,
+        }, `[lifeops] Signal local client send network failure: ${message}`);
+        throw new SignalLocalClientError(`Signal local send failed: ${message}`, {
+            status: null,
+            category: "network",
+        });
+    }
+    if (!response.ok) {
+        const category = response.status === 401 || response.status === 403
+            ? "auth"
+            : response.status === 404
+                ? "not_found"
+                : "unknown";
+        logger.warn({
+            boundary: "lifeops",
+            integration: "signal",
+            operation: "signal_local_send",
+            statusCode: response.status,
+        }, `[lifeops] Signal local client send HTTP ${response.status}`);
+        throw new SignalLocalClientError(`Signal local send failed with HTTP ${response.status}`, { status: response.status, category });
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        logger.warn({
+            boundary: "lifeops",
+            integration: "signal",
+            operation: "signal_local_send",
+        }, "[lifeops] Signal local client send returned non-JSON body");
+        throw new SignalLocalClientError("Signal local send returned non-JSON", {
+            status: response.status,
+            category: "unknown",
+        });
+    }
+    const rpcResponse = body;
+    if (isRecord(rpcResponse.error)) {
+        const message = typeof rpcResponse.error.message === "string"
+            ? rpcResponse.error.message
+            : "Signal RPC send failed";
+        throw new SignalLocalClientError(`Signal local send failed: ${message}`, {
+            status: response.status,
+            category: "unknown",
+        });
+    }
+    const result = rpcResponse.result;
+    if (!isRecord(result) || typeof result.timestamp !== "number") {
+        throw new SignalLocalClientError("Signal local send did not return a timestamp", { status: response.status, category: "unknown" });
+    }
+    return { timestamp: result.timestamp };
+}