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

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

@@ -1,14 +1,59 @@
-import { capabilitiesForSide, LIFEOPS_SIGNAL_CAPABILITIES, } from "@elizaos/shared";
 import { logger } from "@elizaos/core";
+import { LIFEOPS_SIGNAL_CAPABILITIES, } from "@elizaos/shared";
 import { createLifeOpsConnectorGrant } from "./repository.js";
-import { fail, } from "./service-normalize.js";
-import { normalizeOptionalConnectorSide, } from "./service-normalize-connector.js";
-import { startSignalPairing as startSignalPairingFlow, getSignalPairingStatus as getSignalPairingStatusFlow, getSignalPairingStatusForSide, stopSignalPairing as stopSignalPairingFlow, readSignalLinkedDeviceInfo, deleteSignalLinkedDevice, } from "./signal-auth.js";
+import { fail } from "./service-normalize.js";
+import { normalizeOptionalConnectorSide } from "./service-normalize-connector.js";
+import { deleteSignalLinkedDevice, findSignalLinkedDeviceInfoForSide, getSignalPairingStatus as getSignalPairingStatusFlow, getSignalPairingStatusForSide, readSignalLinkedDeviceInfo, startSignalPairing as startSignalPairingFlow, stopSignalPairing as stopSignalPairingFlow, } from "./signal-auth.js";
+import { readSignalInboundMessages, readSignalLocalClientConfigFromEnv, sendSignalLocalMessage, } from "./signal-local-client.js";
 import { removeSignalConnectorConfig, upsertSignalConnectorConfig, } from "./signal-runtime-config.js";
-import { readSignalInboundMessages, readSignalLocalClientConfigFromEnv, } from "./signal-local-client.js";
+const FULL_SIGNAL_CAPABILITIES = [
+    ...LIFEOPS_SIGNAL_CAPABILITIES,
+];
+function normalizeSignalCapabilities(capabilities) {
+    return (capabilities ?? []).filter((candidate) => candidate === "signal.read" || candidate === "signal.send");
+}
 function getConnectorSetupService(runtime) {
     return runtime.getService("connector-setup");
 }
+function getSignalService(runtime) {
+    const service = runtime.getService("signal");
+    return service && typeof service === "object" ? service : null;
+}
+function signalServiceConnected(service) {
+    return Boolean(service?.isServiceConnected?.());
+}
+function signalServiceCanRead(service) {
+    return (signalServiceConnected(service) &&
+        typeof service?.getRecentMessages === "function");
+}
+function signalServiceCanSend(service) {
+    return (signalServiceConnected(service) &&
+        typeof service?.sendMessage === "function");
+}
+function signalReadyCapabilities(args) {
+    return normalizeSignalCapabilities(args.granted).filter((capability) => capability === "signal.read" ? args.inboundReady : args.sendReady);
+}
+function signalStatusDegradations(args) {
+    const degradations = [];
+    const granted = new Set(args.grantedCapabilities);
+    if (args.connected && granted.has("signal.read") && !args.inboundReady) {
+        degradations.push({
+            axis: "transport-offline",
+            code: "signal_inbound_unavailable",
+            message: "Signal is linked, but no runtime or signal-cli receive path is available for inbound reads.",
+            retryable: true,
+        });
+    }
+    if (args.connected && granted.has("signal.send") && !args.sendReady) {
+        degradations.push({
+            axis: "delivery-degraded",
+            code: "signal_send_service_unavailable",
+            message: "Signal is linked, but no runtime or signal-cli send path is available.",
+            retryable: true,
+        });
+    }
+    return degradations;
+}
 function setSignalRuntimeEnv(authDir, phoneNumber) {
     if (authDir && authDir.trim().length > 0) {
         process.env.SIGNAL_AUTH_DIR = authDir.trim();
@@ -30,15 +75,15 @@ async function ensureSignalPluginLoaded(runtime) {
         return false;
     }
     const mod = await import("@elizaos/plugin-signal");
-    const plugin = (mod.default ??
-        mod.plugin);
+    const plugin = (mod.default ?? mod.plugin);
     if (!plugin) {
         return false;
     }
     const existingOwnership = typeof runtimeWithLifecycle.getPluginOwnership === "function"
         ? runtimeWithLifecycle.getPluginOwnership("signal")
         : null;
-    if (existingOwnership && typeof runtimeWithLifecycle.reloadPlugin === "function") {
+    if (existingOwnership &&
+        typeof runtimeWithLifecycle.reloadPlugin === "function") {
         await runtimeWithLifecycle.reloadPlugin(plugin);
         return true;
     }
@@ -52,8 +97,7 @@ async function ensureSignalPluginLoaded(runtime) {
 export function withSignal(Base) {
     class LifeOpsSignalServiceMixin extends Base {
         lifeOpsSignalServiceConnected() {
-            const signalService = this.runtime.getService("signal");
-            return Boolean(signalService?.isServiceConnected?.());
+            return signalServiceConnected(getSignalService(this.runtime));
         }
         lifeOpsSignalServiceRegistered() {
             return Boolean(this.runtime.getService("signal"));
@@ -84,6 +128,8 @@ export function withSignal(Base) {
             setSignalRuntimeEnv(authDir, phoneNumber);
             this.runtime.setSetting("SIGNAL_AUTH_DIR", authDir, false);
             this.runtime.setSetting("SIGNAL_ACCOUNT_NUMBER", phoneNumber, false);
+            this.runtime.setSetting("SIGNAL_RECEIVE_MODE", "manual", false);
+            this.runtime.setSetting("SIGNAL_AUTO_REPLY", "false", false);
             if (!configChanged && this.lifeOpsSignalServiceRegistered()) {
                 return;
             }
@@ -129,17 +175,52 @@ export function withSignal(Base) {
         }
         async getSignalConnectorStatus(side) {
             const resolvedSide = normalizeOptionalConnectorSide(side, "side") ?? "owner";
-            const grant = await this.repository.getConnectorGrant(this.agentId(), "signal", "local", resolvedSide);
+            let grant = await this.repository.getConnectorGrant(this.agentId(), "signal", "local", resolvedSide);
             const pairing = getSignalPairingStatusForSide(this.agentId(), resolvedSide);
             let connected = false;
             let reason = "disconnected";
             let identity = null;
+            if (!grant) {
+                const candidate = findSignalLinkedDeviceInfoForSide(this.agentId(), resolvedSide);
+                if (candidate) {
+                    grant = createLifeOpsConnectorGrant({
+                        agentId: this.agentId(),
+                        provider: "signal",
+                        identity: {
+                            phoneNumber: candidate.info.phoneNumber,
+                            uuid: candidate.info.uuid,
+                            deviceName: candidate.info.deviceName,
+                        },
+                        grantedScopes: [],
+                        capabilities: FULL_SIGNAL_CAPABILITIES,
+                        tokenRef: candidate.tokenRef,
+                        mode: "local",
+                        side: resolvedSide,
+                        metadata: {
+                            adoptedFromAgentId: candidate.agentId === this.agentId() ? null : candidate.agentId,
+                            adoptedTokenRef: candidate.tokenRef === candidate.info.authDir
+                                ? null
+                                : candidate.info.authDir,
+                        },
+                        lastRefreshAt: new Date().toISOString(),
+                    });
+                    await this.repository.upsertConnectorGrant(grant);
+                }
+            }
+            let inboundReady = false;
+            let sendReady = false;
             if (grant?.tokenRef) {
                 const deviceInfo = readSignalLinkedDeviceInfo(grant.tokenRef);
                 if (deviceInfo) {
                     await this.lifeOpsEnsureSignalRuntimeReady(deviceInfo.authDir, deviceInfo.phoneNumber);
-                    connected = true;
-                    reason = "connected";
+                    const signalService = getSignalService(this.runtime);
+                    const localClientConfig = readSignalLocalClientConfigFromEnv();
+                    inboundReady =
+                        signalServiceCanRead(signalService) || localClientConfig !== null;
+                    sendReady =
+                        signalServiceCanSend(signalService) || localClientConfig !== null;
+                    connected = inboundReady || sendReady;
+                    reason = connected ? "connected" : "disconnected";
                     identity = {
                         phoneNumber: deviceInfo.phoneNumber,
                         uuid: deviceInfo.uuid,
@@ -156,7 +237,18 @@ export function withSignal(Base) {
             else if (pairing) {
                 reason = "pairing";
             }
-            const capabilities = (grant?.capabilities ?? []).filter((candidate) => candidate === "signal.read" || candidate === "signal.send");
+            const grantedCapabilities = normalizeSignalCapabilities(grant?.capabilities);
+            const capabilities = signalReadyCapabilities({
+                granted: grantedCapabilities,
+                inboundReady,
+                sendReady,
+            });
+            const degradations = signalStatusDegradations({
+                connected,
+                grantedCapabilities,
+                inboundReady,
+                sendReady,
+            });
             return {
                 provider: "signal",
                 side: resolvedSide,
@@ -167,6 +259,7 @@ export function withSignal(Base) {
                 grantedCapabilities: capabilities,
                 pairing,
                 grant,
+                ...(degradations.length > 0 ? { degradations } : {}),
             };
         }
         async startSignalPairing(side) {
@@ -177,7 +270,7 @@ export function withSignal(Base) {
                 provider: "signal",
                 identity: {},
                 grantedScopes: [],
-                capabilities: capabilitiesForSide(LIFEOPS_SIGNAL_CAPABILITIES, resolvedSide),
+                capabilities: FULL_SIGNAL_CAPABILITIES,
                 tokenRef: session.authDir,
                 mode: "local",
                 side: resolvedSide,
@@ -229,7 +322,7 @@ export function withSignal(Base) {
                 reason: "disconnected",
                 identity: null,
                 grantedCapabilities: [],
-                inbound: true,
+                inbound: false,
                 pairing: null,
                 grant: null,
             };
@@ -246,42 +339,85 @@ export function withSignal(Base) {
          * This mirrors how `telegram-local-client.ts` reads Telegram sessions
          * without the plugin service being active.
          *
-         * Returns an empty array when neither path is available.
-         * Does not throw — callers should check connector status separately.
+         * Throws when neither path is available so a missing read transport is not
+         * mistaken for an empty Signal inbox.
          */
         async readSignalInbound(limit = 25) {
-            const signalService = this.runtime.getService("signal");
+            const signalService = getSignalService(this.runtime);
             const clampedLimit = Math.min(Math.max(1, Math.floor(limit)), 100);
-            // Primary path: use the Signal service's in-memory message store.
-            if (signalService?.isServiceConnected?.()) {
+            const localClientConfig = readSignalLocalClientConfigFromEnv();
+            let serviceReadAttempted = false;
+            // Primary path: use the Signal service's in-memory message store when it
+            // exists. In passive LifeOps mode the plugin is connected for send/status
+            // only, so this will usually be empty and the direct pull below owns reads.
+            if (signalServiceCanRead(signalService)) {
+                serviceReadAttempted = true;
                 const raw = await signalService.getRecentMessages?.(clampedLimit);
-                if (!raw || raw.length === 0) {
-                    return [];
+                if (raw && raw.length > 0) {
+                    return raw.map((entry) => ({
+                        id: entry.id,
+                        roomId: entry.roomId,
+                        channelId: entry.channelId,
+                        threadId: entry.channelId || entry.roomId,
+                        roomName: entry.roomName,
+                        speakerName: entry.speakerName,
+                        senderNumber: entry.isGroup ? null : entry.channelId || null,
+                        senderUuid: null,
+                        sourceDevice: null,
+                        groupId: entry.isGroup ? entry.channelId || null : null,
+                        groupType: null,
+                        text: entry.text,
+                        createdAt: entry.createdAt,
+                        isInbound: !entry.isFromAgent,
+                        isGroup: entry.isGroup,
+                    }));
                 }
-                return raw.map((entry) => ({
-                    id: entry.id,
-                    roomId: entry.roomId,
-                    channelId: entry.channelId,
-                    threadId: entry.channelId || entry.roomId,
-                    roomName: entry.roomName,
-                    speakerName: entry.speakerName,
-                    senderNumber: entry.isGroup ? null : entry.channelId || null,
-                    senderUuid: null,
-                    sourceDevice: null,
-                    groupId: entry.isGroup ? entry.channelId || null : null,
-                    groupType: null,
-                    text: entry.text,
-                    createdAt: entry.createdAt,
-                    isInbound: !entry.isFromAgent,
-                    isGroup: entry.isGroup,
-                }));
             }
-            // Fallback path: read directly from the signal-cli REST API.
-            const localClientConfig = readSignalLocalClientConfigFromEnv();
+            // Passive pull path: read directly from the signal-cli REST API.
             if (localClientConfig) {
                 return readSignalInboundMessages(localClientConfig, clampedLimit);
             }
-            return [];
+            if (serviceReadAttempted) {
+                return [];
+            }
+            fail(409, "Signal inbound is not configured. Link Signal or configure signal-cli receive before reading messages.");
+        }
+        async sendSignalMessage(request) {
+            const normalizedSide = normalizeOptionalConnectorSide(request.side, "side") ?? "owner";
+            const recipient = request.recipient.trim();
+            const text = request.text.trim();
+            if (!recipient) {
+                fail(400, "recipient is required");
+            }
+            if (!text) {
+                fail(400, "text is required");
+            }
+            const status = await this.getSignalConnectorStatus(normalizedSide);
+            if (!status.connected) {
+                fail(409, "Signal is not connected.");
+            }
+            if (!status.grantedCapabilities.includes("signal.send")) {
+                fail(403, "Signal send capability is not granted.");
+            }
+            const signalService = getSignalService(this.runtime);
+            const localClientConfig = readSignalLocalClientConfigFromEnv();
+            if (!signalServiceCanSend(signalService) && !localClientConfig) {
+                fail(503, "Signal send service is not available.");
+            }
+            const result = signalServiceCanSend(signalService)
+                ? await signalService.sendMessage(recipient, text)
+                : await sendSignalLocalMessage(localClientConfig, { recipient, text });
+            if (typeof result.timestamp !== "number" ||
+                !Number.isFinite(result.timestamp)) {
+                fail(502, "Signal send did not return a timestamp.");
+            }
+            return {
+                provider: "signal",
+                side: normalizedSide,
+                recipient,
+                ok: true,
+                timestamp: result.timestamp,
+            };
         }
     }
     return LifeOpsSignalServiceMixin;

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

@@ -18,11 +18,40 @@ function durationMinutesFor(startAt, endAt) {
     }
     const startMs = Date.parse(startAt);
     const endMs = Date.parse(endAt);
-    if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) {
+    if (!Number.isFinite(startMs) ||
+        !Number.isFinite(endMs) ||
+        endMs <= startMs) {
         return null;
     }
     return Math.round((endMs - startMs) / 60_000);
 }
+function summarizeSleepHistory(episodes) {
+    let totalDuration = 0;
+    let durationCount = 0;
+    let overnightCount = 0;
+    let napCount = 0;
+    let openCount = 0;
+    for (const episode of episodes) {
+        if (episode.cycleType === "overnight")
+            overnightCount += 1;
+        if (episode.cycleType === "nap")
+            napCount += 1;
+        if (episode.endedAt === null)
+            openCount += 1;
+        if (typeof episode.durationMin === "number" &&
+            Number.isFinite(episode.durationMin)) {
+            totalDuration += episode.durationMin;
+            durationCount += 1;
+        }
+    }
+    return {
+        cycleCount: episodes.length,
+        averageDurationMin: durationCount > 0 ? Math.round(totalDuration / durationCount) : null,
+        overnightCount,
+        napCount,
+        openCount,
+    };
+}
 /** @internal */
 export function withSleep(Base) {
     class LifeOpsSleepServiceMixin extends Base {
@@ -52,6 +81,7 @@ export function withSleep(Base) {
             }));
             return {
                 episodes,
+                summary: summarizeSleepHistory(episodes),
                 windowDays,
                 includeNaps,
             };

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

@@ -1 +1 @@
-{"version":3,"file":"service-mixin-status.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-mixin-status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAQ,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EACV,4BAA4B,EAC5B,qBAAqB,EACtB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAKV,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAKzB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAM/E,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE/E,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,kBAAkB,GAAG;IACzD,OAAO,EAAE,aAAa,CAAC;IACvB,sBAAsB,CAAC,IAAI,CAAC,EAAE;QAC5B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;QACxC,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,GAAG,CAAC,EAAE,IAAI,CAAC;KACZ,GAAG,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAAC;IAC/C,kBAAkB,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACrD,qBAAqB,IAAI,OAAO,CAAC,4BAA4B,EAAE,CAAC,CAAC;IACjE,mBAAmB,CACjB,IAAI,CAAC,EAAE,oBAAoB,GAC1B,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACpC,wBAAwB,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAC5D,CAAC"}
+{"version":3,"file":"service-mixin-status.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-mixin-status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAQ,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EACV,4BAA4B,EAC5B,qBAAqB,EACtB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAKV,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAUzB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAM/E,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE/E,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,kBAAkB,GAAG;IACzD,OAAO,EAAE,aAAa,CAAC;IACvB,sBAAsB,CAAC,IAAI,CAAC,EAAE;QAC5B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;QACxC,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,GAAG,CAAC,EAAE,IAAI,CAAC;KACZ,GAAG,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAAC;IAC/C,kBAAkB,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACrD,qBAAqB,IAAI,OAAO,CAAC,4BAA4B,EAAE,CAAC,CAAC;IACjE,mBAAmB,CACjB,IAAI,CAAC,EAAE,oBAAoB,GAC1B,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACpC,wBAAwB,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAC5D,CAAC"}

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

@@ -1,4 +1,5 @@
 import { loadLifeOpsAppState } from "./app-state.js";
+import { resolveBrowserBridgeReadiness, } from "./browser-readiness.js";
 import { resolveDefaultTimeZone } from "./defaults.js";
 import { createFeatureFlagService } from "./feature-flags.js";
 import { LIFEOPS_TASK_NAME, LIFEOPS_TASK_TAGS, resolveLifeOpsTaskIntervalMs, } from "./scheduler-task.js";
@@ -107,6 +108,58 @@ function summarizeCapabilities(capabilities) {
         notConfiguredCount: capabilities.filter((item) => item.state === "not_configured").length,
     };
 }
+function browserReadinessCapabilityState(state) {
+    switch (state) {
+        case "ready":
+            return "working";
+        case "paused":
+        case "permission_blocked":
+            return "blocked";
+        case "control_disabled":
+        case "stale":
+            return "degraded";
+        case "disabled":
+        case "tracking_off":
+        case "no_companion":
+            return "not_configured";
+    }
+}
+function browserReadinessSummary(readiness, settings) {
+    switch (readiness.state) {
+        case "ready":
+            return `${settings.trackingMode} tracking; ${readiness.recentConnectedCompanions.length} recent companion`;
+        case "disabled":
+            return "Browser tracking is disabled";
+        case "tracking_off":
+            return "Browser tracking mode is off";
+        case "paused":
+            return "Browser tracking is paused";
+        case "control_disabled":
+            return "Browser control is disabled";
+        case "no_companion":
+            return "No browser companion has paired yet";
+        case "stale":
+            return "No connected browser companion has checked in recently";
+        case "permission_blocked":
+            return "Browser companion permissions or site access are incomplete";
+    }
+}
+function browserReadinessConfidence(state) {
+    switch (state) {
+        case "ready":
+            return 0.9;
+        case "control_disabled":
+        case "stale":
+        case "permission_blocked":
+            return 0.55;
+        case "paused":
+            return 0.7;
+        case "disabled":
+        case "tracking_off":
+        case "no_companion":
+            return 0.35;
+    }
+}
 /** @internal */
 export function withStatus(Base) {
     class LifeOpsStatusServiceMixin extends Base {
@@ -143,6 +196,9 @@ export function withStatus(Base) {
                     companions: browserCompanions.value,
                 }
                 : null;
+            const browserReadiness = browser
+                ? resolveBrowserBridgeReadiness(browser.settings, browser.companions, now.getTime())
+                : null;
             const xStatuses = [xLocal, xCloud]
                 .filter((result) => result.ok)
                 .map((result) => result.value);
@@ -272,32 +328,45 @@ export function withStatus(Base) {
                     id: "activity.browser",
                     domain: "activity",
                     label: "Browser activity",
-                    state: browser
-                        ? browser.settings.enabled &&
-                            browser.settings.trackingMode !== "off"
-                            ? "working"
-                            : "not_configured"
+                    state: browserReadiness
+                        ? browserReadinessCapabilityState(browserReadiness.state)
                         : "degraded",
-                    summary: browser
-                        ? `${browser.settings.trackingMode} tracking; ${browser.companions.length} companions`
+                    summary: browser && browserReadiness
+                        ? browserReadinessSummary(browserReadiness, browser.settings)
                         : "Browser status failed to load",
-                    confidence: browser ? 0.75 : 0.3,
+                    confidence: browserReadiness
+                        ? browserReadinessConfidence(browserReadiness.state)
+                        : 0.3,
                     checkedAt,
                     evidence: [
                         {
                             label: "Browser settings",
-                            state: browser
-                                ? browser.settings.enabled
-                                    ? "working"
-                                    : "not_configured"
+                            state: browserReadiness
+                                ? browserReadinessCapabilityState(browserReadiness.state)
                                 : "degraded",
                             detail: browser
-                                ? `site access ${browser.settings.siteAccessMode}`
+                                ? `${browser.settings.trackingMode}; site access ${browser.settings.siteAccessMode}; control ${browser.settings.allowBrowserControl ? "on" : "off"}`
                                 : browserSettings.ok
                                     ? "Missing browser companions"
                                     : browserSettings.message,
                             observedAt: browser?.settings.updatedAt ?? checkedAt,
                         },
+                        {
+                            label: "Browser companions",
+                            state: browserReadiness
+                                ? browserReadiness.ready
+                                    ? "working"
+                                    : browserReadiness.connectedCompanions.length > 0
+                                        ? "degraded"
+                                        : "not_configured"
+                                : "degraded",
+                            detail: browserReadiness
+                                ? `${browserReadiness.recentConnectedCompanions.length}/${browserReadiness.connectedCompanions.length}/${browser?.companions.length ?? 0} recent/connected/paired`
+                                : browserCompanions.ok
+                                    ? "Browser settings failed"
+                                    : browserCompanions.message,
+                            observedAt: browserReadiness?.primaryCompanion?.lastSeenAt ?? checkedAt,
+                        },
                     ],
                 }),
                 createCapability({

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

@@ -1,6 +1,6 @@
 import { createLifeOpsSubscriptionAudit, createLifeOpsSubscriptionCancellation, createLifeOpsSubscriptionCandidate, } from "./repository.js";
 import { fail, normalizeOptionalBoolean, normalizeOptionalString, requireNonEmptyString, } from "./service-normalize.js";
-import { PLAYBOOK_NOT_IMPLEMENTED_ERROR, findLifeOpsSubscriptionPlaybook, listLifeOpsSubscriptionPlaybooks, } from "./subscriptions-playbooks.js";
+import { findLifeOpsSubscriptionPlaybook, listLifeOpsSubscriptionPlaybooks, PLAYBOOK_NOT_IMPLEMENTED_ERROR, } from "./subscriptions-playbooks.js";
 const MAX_AUDIT_MESSAGES = 80;
 const DEFAULT_AUDIT_WINDOW_DAYS = 180;
 function normalizeSubscriptionLookup(value) {

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

@@ -1,9 +1,9 @@
 // @ts-nocheck — mixin: type safety is enforced on the composed class
 import { LIFEOPS_TELEGRAM_CAPABILITIES, } from "@elizaos/shared";
 import { createLifeOpsConnectorGrant } from "./repository.js";
-import { fail, requireNonEmptyString, } from "./service-normalize.js";
-import { normalizeOptionalConnectorSide, } from "./service-normalize-connector.js";
-import { buildTelegramTokenRef, cancelTelegramAuth, deleteStoredTelegramToken, findPendingTelegramAuthSession, inferRetryableTelegramAuthState, hasManagedTelegramCredentials, readStoredTelegramToken, startTelegramAuth as startTelegramAuthFlow, submitTelegramAuthCode, submitTelegramAuthPassword, } from "./telegram-auth.js";
+import { fail, requireNonEmptyString } from "./service-normalize.js";
+import { normalizeOptionalConnectorSide } from "./service-normalize-connector.js";
+import { buildTelegramTokenRef, cancelTelegramAuth, deleteStoredTelegramToken, findPendingTelegramAuthSession, findStoredTelegramTokenForSide, hasManagedTelegramCredentials, inferRetryableTelegramAuthState, readStoredTelegramToken, startTelegramAuth as startTelegramAuthFlow, submitTelegramAuthCode, submitTelegramAuthPassword, } from "./telegram-auth.js";
 import { getTelegramReadReceipts, searchTelegramMessages, sendTelegramAccountMessage, telegramLocalSessionAvailable, verifyTelegramLocalConnector, } from "./telegram-local-client.js";
 function isLifeOpsTelegramCapability(value) {
     return (typeof value === "string" &&
@@ -14,12 +14,58 @@ export function withTelegram(Base) {
     class LifeOpsTelegramServiceMixin extends Base {
         async getTelegramConnectorStatus(requestedSide) {
             const side = normalizeOptionalConnectorSide(requestedSide, "side") ?? "owner";
-            const grant = await this.repository.getConnectorGrant(this.agentId(), "telegram", "local", side);
+            let grant = await this.repository.getConnectorGrant(this.agentId(), "telegram", "local", side);
             const pendingSession = findPendingTelegramAuthSession(this.agentId(), side);
-            const tokenRef = grant?.tokenRef ?? null;
-            const storedToken = tokenRef
-                ? readStoredTelegramToken(tokenRef)
-                : null;
+            let tokenRef = grant?.tokenRef ?? null;
+            let storedToken = tokenRef ? readStoredTelegramToken(tokenRef) : null;
+            if (!storedToken) {
+                const candidate = findStoredTelegramTokenForSide(this.agentId(), side);
+                if (candidate) {
+                    const identity = {
+                        ...candidate.token.identity,
+                        phone: candidate.token.phone,
+                    };
+                    const capabilities = [
+                        ...LIFEOPS_TELEGRAM_CAPABILITIES,
+                    ];
+                    grant = grant
+                        ? {
+                            ...grant,
+                            identity,
+                            capabilities,
+                            tokenRef: candidate.tokenRef,
+                            metadata: {
+                                ...grant.metadata,
+                                phone: candidate.token.phone,
+                                adoptedFromAgentId: candidate.agentId === this.agentId()
+                                    ? null
+                                    : candidate.agentId,
+                            },
+                            lastRefreshAt: new Date().toISOString(),
+                            updatedAt: new Date().toISOString(),
+                        }
+                        : createLifeOpsConnectorGrant({
+                            agentId: this.agentId(),
+                            provider: "telegram",
+                            identity,
+                            grantedScopes: [],
+                            capabilities,
+                            tokenRef: candidate.tokenRef,
+                            mode: "local",
+                            side,
+                            metadata: {
+                                phone: candidate.token.phone,
+                                adoptedFromAgentId: candidate.agentId === this.agentId()
+                                    ? null
+                                    : candidate.agentId,
+                            },
+                            lastRefreshAt: new Date().toISOString(),
+                        });
+                    await this.repository.upsertConnectorGrant(grant);
+                    tokenRef = candidate.tokenRef;
+                    storedToken = candidate.token;
+                }
+            }
             const sessionAvailable = telegramLocalSessionAvailable();
             const connected = Boolean(grant && storedToken && sessionAvailable);
             const retryableAuthState = pendingSession
@@ -30,7 +76,7 @@ export function withTelegram(Base) {
                 : null;
             const authState = connected
                 ? "connected"
-                : retryableAuthState ?? pendingSession?.state ?? "idle";
+                : (retryableAuthState ?? pendingSession?.state ?? "idle");
             const capabilities = grant
                 ? grant.capabilities.filter(isLifeOpsTelegramCapability)
                 : [];
@@ -49,8 +95,7 @@ export function withTelegram(Base) {
                     Object.keys(storedToken.identity).length > 0 &&
                     storedToken.identity.id
                     ? storedToken.identity
-                    : grant?.identity &&
-                        Object.keys(grant.identity).length > 0
+                    : grant?.identity && Object.keys(grant.identity).length > 0
                         ? grant.identity
                         : null,
                 grantedCapabilities: capabilities,
@@ -58,7 +103,9 @@ export function withTelegram(Base) {
                 authError: pendingSession?.error ?? null,
                 phone: pendingSession?.phone ??
                     storedToken?.phone ??
-                    (typeof grant?.metadata.phone === "string" ? grant.metadata.phone : null),
+                    (typeof grant?.metadata.phone === "string"
+                        ? grant.metadata.phone
+                        : null),
                 managedCredentialsAvailable: hasManagedTelegramCredentials(),
                 storedCredentialsAvailable: Boolean(storedToken?.apiId && storedToken?.apiHash),
                 grant: grant ?? null,