@elizaos/agent 2.0.0-alpha.358 → 2.0.0-alpha.376

package/apps/app-lifeops/src/followup/followup-tracker.js

@@ -0,0 +1,279 @@
+import { MemoryType, createUniqueUuid, logger, stringToUuid, } from "@elizaos/core";
+import { loadLifeOpsAppState } from "../lifeops/app-state.js";
+import { BackgroundPlannerError, planJob, } from "../lifeops/background-planner.js";
+import { enqueueIfSensitive } from "../lifeops/background-planner-dispatch.js";
+export const FOLLOWUP_TRACKER_TASK_NAME = "FOLLOWUP_TRACKER_RECONCILE";
+export const FOLLOWUP_TRACKER_TASK_TAGS = [
+    "queue",
+    "repeat",
+    "relationships",
+    "followup-tracker",
+];
+export const FOLLOWUP_TRACKER_INTERVAL_MS = 60 * 60 * 1000; // 60 minutes
+export const FOLLOWUP_DEFAULT_THRESHOLD_DAYS = 30;
+export const FOLLOWUP_MEMORY_TABLE = "reminders";
+const DAY_MS = 24 * 60 * 60 * 1000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveTrackerNowMs(options = {}) {
+    const raw = options.now;
+    if (raw instanceof Date) {
+        return raw.getTime();
+    }
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        return raw;
+    }
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        const parsed = new Date(raw).getTime();
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return Date.now();
+}
+export function getRelationshipsServiceLike(runtime) {
+    const service = runtime.getService("relationships");
+    if (!service)
+        return null;
+    const candidate = service;
+    if (typeof candidate.searchContacts !== "function" ||
+        typeof candidate.getContact !== "function" ||
+        typeof candidate.updateContact !== "function") {
+        return null;
+    }
+    return candidate;
+}
+let degradedLogged = false;
+function getNumberField(contact, key) {
+    const value = contact.customFields[key];
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function getStringField(contact, key) {
+    const value = contact.customFields[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function resolveLastContactedAtMs(contact) {
+    const raw = getStringField(contact, "lastContactedAt") ??
+        getStringField(contact, "lastInteractionAt");
+    if (!raw)
+        return null;
+    const ms = new Date(raw).getTime();
+    return Number.isFinite(ms) ? ms : null;
+}
+function resolveThresholdDays(contact, defaultDays) {
+    const days = getNumberField(contact, "followupThresholdDays");
+    if (days !== null && days > 0)
+        return days;
+    return defaultDays;
+}
+async function resolveDisplayName(runtime, contact) {
+    const explicit = getStringField(contact, "displayName");
+    if (explicit)
+        return explicit;
+    const entity = await runtime.getEntityById(contact.entityId);
+    return entity?.names?.[0] ?? String(contact.entityId);
+}
+/**
+ * One tick of the tracker. Pure async fn — safe to call from tests.
+ */
+export async function computeOverdueFollowups(runtime, now = Date.now(), defaultThresholdDays = FOLLOWUP_DEFAULT_THRESHOLD_DAYS) {
+    const service = getRelationshipsServiceLike(runtime);
+    if (!service) {
+        if (!degradedLogged) {
+            degradedLogged = true;
+            logger.info("[FollowupTracker] RelationshipsService unavailable; follow-up tracking is disabled until contacts exist");
+        }
+        return {
+            generatedAt: new Date(now).toISOString(),
+            thresholdDefaultDays: defaultThresholdDays,
+            overdue: [],
+        };
+    }
+    const contacts = await service.searchContacts({});
+    const overdue = [];
+    for (const contact of contacts) {
+        const lastMs = resolveLastContactedAtMs(contact);
+        if (lastMs === null)
+            continue;
+        const thresholdDays = resolveThresholdDays(contact, defaultThresholdDays);
+        const thresholdMs = thresholdDays * DAY_MS;
+        const ageMs = now - lastMs;
+        if (ageMs <= thresholdMs)
+            continue;
+        const displayName = await resolveDisplayName(runtime, contact);
+        overdue.push({
+            entityId: contact.entityId,
+            displayName,
+            lastContactedAt: new Date(lastMs).toISOString(),
+            daysOverdue: Math.floor((ageMs - thresholdMs) / DAY_MS),
+            thresholdDays,
+        });
+    }
+    overdue.sort((a, b) => b.daysOverdue - a.daysOverdue);
+    return {
+        generatedAt: new Date(now).toISOString(),
+        thresholdDefaultDays: defaultThresholdDays,
+        overdue,
+    };
+}
+function followupDigestRoomId(agentId) {
+    return stringToUuid(`followup-tracker-${agentId}`);
+}
+function followupDigestWorldId(agentId) {
+    return stringToUuid(`followup-tracker-world-${agentId}`);
+}
+/**
+ * Persist the digest as a memory so morning check-in + actions can retrieve
+ * it. One memory per tick; callers querying the most recent
+ * `followup_overdue_digest` memory in the followup room get the latest view.
+ */
+export async function writeOverdueDigestMemory(runtime, digest) {
+    const worldId = followupDigestWorldId(runtime.agentId);
+    const roomId = followupDigestRoomId(runtime.agentId);
+    if (typeof runtime.ensureWorldExists === "function") {
+        await runtime.ensureWorldExists({
+            id: worldId,
+            name: "Follow-up Tracker",
+            agentId: runtime.agentId,
+        });
+    }
+    if (typeof runtime.ensureRoomExists === "function") {
+        await runtime.ensureRoomExists({
+            id: roomId,
+            name: "Follow-up Tracker",
+            source: "followup-tracker",
+            type: "API",
+            channelId: `followup-tracker-${runtime.agentId}`,
+            worldId,
+        });
+    }
+    const memory = {
+        id: createUniqueUuid(runtime, `followup-digest-${Date.now()}`),
+        entityId: runtime.agentId,
+        agentId: runtime.agentId,
+        roomId,
+        worldId,
+        content: {
+            text: digest.overdue.length === 0
+                ? "No overdue follow-ups."
+                : `Overdue follow-ups (${digest.overdue.length}): ${digest.overdue
+                    .map((o) => `${o.displayName} (+${o.daysOverdue}d)`)
+                    .join(", ")}`,
+            type: "followup_overdue_digest",
+        },
+        metadata: {
+            type: MemoryType.CUSTOM,
+            source: "followup-tracker",
+            generatedAt: digest.generatedAt,
+            thresholdDefaultDays: digest.thresholdDefaultDays,
+            overdue: digest.overdue.map((entry) => ({
+                entityId: String(entry.entityId),
+                displayName: entry.displayName,
+                lastContactedAt: entry.lastContactedAt,
+                daysOverdue: entry.daysOverdue,
+                thresholdDays: entry.thresholdDays,
+            })),
+        },
+        createdAt: Date.now(),
+    };
+    const memoryId = await runtime.createMemory(memory, FOLLOWUP_MEMORY_TABLE);
+    logger.info(`[FollowupTracker] Wrote overdue digest memory ${memoryId} with ${digest.overdue.length} entries`);
+    return memoryId;
+}
+/**
+ * One reconciler tick. Compute + persist. Returns the digest for testability.
+ */
+export async function reconcileFollowupsOnce(runtime, now = Date.now(), defaultThresholdDays = FOLLOWUP_DEFAULT_THRESHOLD_DAYS) {
+    const digest = await computeOverdueFollowups(runtime, now, defaultThresholdDays);
+    await writeOverdueDigestMemory(runtime, digest);
+    // Route each overdue contact through the shared LLM planner. Sensitive
+    // actions are enqueued into the approval queue; the tracker never auto-sends.
+    for (const entry of digest.overdue) {
+        const plannerContext = {
+            jobKind: "followup_watchdog",
+            subjectUserId: String(entry.entityId),
+            snapshot: {
+                entityId: String(entry.entityId),
+                displayName: entry.displayName,
+                lastContactedAt: entry.lastContactedAt,
+                daysOverdue: entry.daysOverdue,
+                thresholdDays: entry.thresholdDays,
+                generatedAt: digest.generatedAt,
+            },
+            availableChannels: ["telegram", "imessage", "sms", "email", "internal"],
+            trigger: `followup_watchdog:${entry.daysOverdue}d_overdue`,
+        };
+        try {
+            const plan = await planJob(runtime, plannerContext);
+            await enqueueIfSensitive(runtime, plannerContext, plan);
+        }
+        catch (error) {
+            if (error instanceof BackgroundPlannerError) {
+                logger.warn(`[FollowupTracker] background planner unavailable — ${error.message}`);
+                break;
+            }
+            throw error;
+        }
+    }
+    return digest;
+}
+export async function executeFollowupTrackerTick(runtime, options = {}) {
+    const defaultThresholdDays = typeof options.defaultThresholdDays === "number" &&
+        Number.isFinite(options.defaultThresholdDays) &&
+        options.defaultThresholdDays > 0
+        ? options.defaultThresholdDays
+        : FOLLOWUP_DEFAULT_THRESHOLD_DAYS;
+    const digest = await reconcileFollowupsOnce(runtime, resolveTrackerNowMs(options), defaultThresholdDays);
+    return {
+        nextInterval: FOLLOWUP_TRACKER_INTERVAL_MS,
+        digest,
+    };
+}
+/**
+ * Register the tracker as a periodic task worker. Mirrors the
+ * BlockRuleReconciler pattern so it integrates with the agent scheduler.
+ */
+export function registerFollowupTrackerWorker(runtime) {
+    if (runtime.getTaskWorker(FOLLOWUP_TRACKER_TASK_NAME)) {
+        return;
+    }
+    runtime.registerTaskWorker({
+        name: FOLLOWUP_TRACKER_TASK_NAME,
+        // Skip execution when LifeOps is disabled via the UI. Cycles become
+        // cheap no-ops; re-enabling requires no restart.
+        shouldRun: async (rt) => {
+            try {
+                const state = await loadLifeOpsAppState(rt);
+                return state.enabled;
+            }
+            catch (error) {
+                logger.warn(`[followup-tracker] loadLifeOpsAppState failed; skipping follow-up tick because LifeOps toggle state is unknown: ${error instanceof Error ? error.message : String(error)}`);
+                return false;
+            }
+        },
+        execute: (rt, options) => executeFollowupTrackerTick(rt, isRecord(options) ? options : {}),
+    });
+}
+/**
+ * Resolve the room used to store follow-up tracker memories. Exposed for
+ * callers (e.g. LIST_OVERDUE_FOLLOWUPS action or morning check-in) that need
+ * to query the digest.
+ */
+export function getFollowupTrackerRoomId(runtime) {
+    return followupDigestRoomId(runtime.agentId);
+}
+/**
+ * Test-only: reset the one-time degraded-mode log so unit tests can observe
+ * the log path repeatedly.
+ */
+export function __resetFollowupTrackerForTests() {
+    degradedLogged = false;
+}

package/apps/app-lifeops/src/followup/index.d.ts

@@ -0,0 +1,5 @@
+export { FOLLOWUP_TRACKER_TASK_NAME, FOLLOWUP_TRACKER_TASK_TAGS, FOLLOWUP_TRACKER_INTERVAL_MS, FOLLOWUP_DEFAULT_THRESHOLD_DAYS, FOLLOWUP_MEMORY_TABLE, computeOverdueFollowups, writeOverdueDigestMemory, reconcileFollowupsOnce, executeFollowupTrackerTick, registerFollowupTrackerWorker, getFollowupTrackerRoomId, getRelationshipsServiceLike, __resetFollowupTrackerForTests, type ContactInfo, type OverdueFollowup, type OverdueDigest, type RelationshipsServiceLike, } from "./followup-tracker.js";
+export { listOverdueFollowupsAction } from "./actions/listOverdueFollowups.js";
+export { markFollowupDoneAction } from "./actions/markFollowupDone.js";
+export { setFollowupThresholdAction } from "./actions/setFollowupThreshold.js";
+//# sourceMappingURL=index.d.ts.map

package/apps/app-lifeops/src/followup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/followup/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,EAC1B,4BAA4B,EAC5B,+BAA+B,EAC/B,qBAAqB,EACrB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,0BAA0B,EAC1B,6BAA6B,EAC7B,wBAAwB,EACxB,2BAA2B,EAC3B,8BAA8B,EAC9B,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC"}

package/apps/app-lifeops/src/followup/index.js

@@ -0,0 +1,4 @@
+export { FOLLOWUP_TRACKER_TASK_NAME, FOLLOWUP_TRACKER_TASK_TAGS, FOLLOWUP_TRACKER_INTERVAL_MS, FOLLOWUP_DEFAULT_THRESHOLD_DAYS, FOLLOWUP_MEMORY_TABLE, computeOverdueFollowups, writeOverdueDigestMemory, reconcileFollowupsOnce, executeFollowupTrackerTick, registerFollowupTrackerWorker, getFollowupTrackerRoomId, getRelationshipsServiceLike, __resetFollowupTrackerForTests, } from "./followup-tracker.js";
+export { listOverdueFollowupsAction } from "./actions/listOverdueFollowups.js";
+export { markFollowupDoneAction } from "./actions/markFollowupDone.js";
+export { setFollowupThresholdAction } from "./actions/setFollowupThreshold.js";

package/apps/app-lifeops/src/hooks/useCalendarWeek.d.ts

@@ -0,0 +1,28 @@
+/**
+ * useCalendarWeek — fetches calendar events for a date window.
+ *
+ * Defaults to the current week (7 days from today). The caller can
+ * switch to day or month views by passing windowDays.
+ */
+import type { LifeOpsCalendarEvent } from "@elizaos/shared";
+export type CalendarViewMode = "day" | "week" | "month";
+export interface UseCalendarWeekOptions {
+    viewMode?: CalendarViewMode;
+    /** Base date for the window. Defaults to today. */
+    baseDate?: Date;
+}
+export interface UseCalendarWeekResult {
+    events: LifeOpsCalendarEvent[];
+    loading: boolean;
+    error: string | null;
+    viewMode: CalendarViewMode;
+    setViewMode: (mode: CalendarViewMode) => void;
+    windowStart: Date;
+    windowEnd: Date;
+    refresh: () => Promise<void>;
+    goToToday: () => void;
+    goPrevious: () => void;
+    goNext: () => void;
+}
+export declare function useCalendarWeek(opts?: UseCalendarWeekOptions): UseCalendarWeekResult;
+//# sourceMappingURL=useCalendarWeek.d.ts.map

package/apps/app-lifeops/src/hooks/useCalendarWeek.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCalendarWeek.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useCalendarWeek.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAG5D,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;AAExD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC9C,WAAW,EAAE,IAAI,CAAC;IAClB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAmBD,wBAAgB,eAAe,CAC7B,IAAI,GAAE,sBAA2B,GAChC,qBAAqB,CAmFvB"}

package/apps/app-lifeops/src/hooks/useCalendarWeek.js

@@ -0,0 +1,93 @@
+/**
+ * useCalendarWeek — fetches calendar events for a date window.
+ *
+ * Defaults to the current week (7 days from today). The caller can
+ * switch to day or month views by passing windowDays.
+ */
+import { client, useApp } from "@elizaos/app-core";
+import { useCallback, useEffect, useMemo, useState } from "react";
+function windowDaysForMode(mode) {
+    switch (mode) {
+        case "day":
+            return 1;
+        case "month":
+            return 31;
+        default:
+            return 7;
+    }
+}
+function startOfLocalDay(date = new Date()) {
+    const d = new Date(date);
+    d.setHours(0, 0, 0, 0);
+    return d;
+}
+export function useCalendarWeek(opts = {}) {
+    const { t } = useApp();
+    const [viewMode, setViewMode] = useState(opts.viewMode ?? "week");
+    const [baseDate, setBaseDate] = useState(() => opts.baseDate ?? new Date());
+    const [events, setEvents] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const windowStart = useMemo(() => startOfLocalDay(baseDate), [baseDate]);
+    const windowEnd = useMemo(() => {
+        const end = new Date(windowStart);
+        end.setDate(end.getDate() + windowDaysForMode(viewMode));
+        return end;
+    }, [windowStart, viewMode]);
+    const shiftBase = useCallback((direction) => {
+        setBaseDate((current) => {
+            const next = new Date(current);
+            const days = windowDaysForMode(viewMode);
+            if (viewMode === "month") {
+                next.setMonth(next.getMonth() + direction);
+            }
+            else {
+                next.setDate(next.getDate() + direction * days);
+            }
+            return next;
+        });
+    }, [viewMode]);
+    const goToToday = useCallback(() => setBaseDate(new Date()), []);
+    const goPrevious = useCallback(() => shiftBase(-1), [shiftBase]);
+    const goNext = useCallback(() => shiftBase(1), [shiftBase]);
+    const fetch = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const feed = await client.getLifeOpsCalendarFeed({
+                side: "owner",
+                timeMin: windowStart.toISOString(),
+                timeMax: windowEnd.toISOString(),
+                timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            });
+            const sorted = [...feed.events].sort((a, b) => a.startAt.localeCompare(b.startAt));
+            setEvents(sorted);
+        }
+        catch (cause) {
+            setError(cause instanceof Error && cause.message.trim().length > 0
+                ? cause.message.trim()
+                : t("lifeopsCalendar.loadFailed", {
+                    defaultValue: "Calendar failed to load.",
+                }));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [windowStart, windowEnd, t]);
+    useEffect(() => {
+        void fetch();
+    }, [fetch]);
+    return {
+        events,
+        loading,
+        error,
+        viewMode,
+        setViewMode,
+        windowStart,
+        windowEnd,
+        refresh: fetch,
+        goToToday,
+        goPrevious,
+        goNext,
+    };
+}

package/apps/app-lifeops/src/hooks/useDiscordConnector.d.ts

@@ -0,0 +1,14 @@
+import type { LifeOpsConnectorSide, LifeOpsDiscordConnectorStatus, LifeOpsOwnerBrowserAccessSource } from "@elizaos/shared/contracts/lifeops";
+export interface UseDiscordConnectorOptions {
+    side?: LifeOpsConnectorSide;
+}
+export declare function useDiscordConnector(options?: UseDiscordConnectorOptions): {
+    readonly status: LifeOpsDiscordConnectorStatus;
+    readonly loading: boolean;
+    readonly actionPending: boolean;
+    readonly error: string;
+    readonly connect: (source?: LifeOpsOwnerBrowserAccessSource) => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly refresh: () => Promise<void>;
+};
+//# sourceMappingURL=useDiscordConnector.d.ts.map

package/apps/app-lifeops/src/hooks/useDiscordConnector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDiscordConnector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useDiscordConnector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,6BAA6B,EAC7B,+BAA+B,EAChC,MAAM,mCAAmC,CAAC;AAU3C,MAAM,WAAW,0BAA0B;IACzC,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAID,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B;;;;;gCAiFxD,+BAA+B;;;EAwClD"}

package/apps/app-lifeops/src/hooks/useDiscordConnector.js

@@ -0,0 +1,126 @@
+import { client } from "@elizaos/app-core/api";
+import { useCallback, useEffect, useRef, useState } from "react";
+function formatError(cause, fallback) {
+    if (cause instanceof Error && cause.message.trim().length > 0) {
+        return cause.message.trim();
+    }
+    return fallback;
+}
+const LOGIN_POLL_INTERVAL_MS = 3_000;
+export function useDiscordConnector(options = {}) {
+    const side = options.side ?? "owner";
+    const [status, setStatus] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [actionPending, setActionPending] = useState(false);
+    const [error, setError] = useState(null);
+    const pollRef = useRef(null);
+    const clearPoll = useCallback(() => {
+        if (pollRef.current) {
+            clearInterval(pollRef.current);
+            pollRef.current = null;
+        }
+    }, []);
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        try {
+            const nextStatus = await client.getDiscordConnectorStatus(side);
+            setStatus(nextStatus);
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "Discord connector status failed to load."));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [side]);
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            setLoading(true);
+            try {
+                const nextStatus = await client.getDiscordConnectorStatus(side);
+                if (cancelled)
+                    return;
+                setStatus(nextStatus);
+                setError(null);
+            }
+            catch (cause) {
+                if (cancelled)
+                    return;
+                setError(formatError(cause, "Discord connector status failed to load."));
+            }
+            finally {
+                if (!cancelled)
+                    setLoading(false);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [side]);
+    useEffect(() => () => clearPoll(), [clearPoll]);
+    useEffect(() => {
+        const shouldPoll = status?.reason === "pairing" || status?.reason === "auth_pending";
+        if (shouldPoll && !pollRef.current) {
+            pollRef.current = setInterval(() => {
+                void (async () => {
+                    try {
+                        const next = await client.getDiscordConnectorStatus(side);
+                        setStatus(next);
+                        if (next.reason !== "pairing" && next.reason !== "auth_pending") {
+                            clearPoll();
+                        }
+                        setError(null);
+                    }
+                    catch (cause) {
+                        setError(formatError(cause, "Discord connector status poll failed."));
+                    }
+                })();
+            }, LOGIN_POLL_INTERVAL_MS);
+        }
+        else if (!shouldPoll) {
+            clearPoll();
+        }
+    }, [status?.reason, side, clearPoll]);
+    const connect = useCallback(async (source) => {
+        try {
+            setActionPending(true);
+            setError(null);
+            const nextStatus = await client.startDiscordConnector({ side, source });
+            setStatus(nextStatus);
+        }
+        catch (cause) {
+            setError(formatError(cause, "Discord connector failed to start."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side]);
+    const disconnect = useCallback(async () => {
+        try {
+            setActionPending(true);
+            const nextStatus = await client.disconnectDiscordConnector({
+                side,
+                provider: "discord",
+            });
+            setStatus(nextStatus);
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "Discord connector disconnect failed."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side]);
+    return {
+        status,
+        loading,
+        actionPending,
+        error,
+        connect,
+        disconnect,
+        refresh,
+    };
+}

package/apps/app-lifeops/src/hooks/useGoogleLifeOpsConnector.d.ts

@@ -0,0 +1,29 @@
+import type { LifeOpsConnectorMode, LifeOpsConnectorSide, LifeOpsGoogleConnectorStatus } from "../contracts/index.js";
+export interface UseGoogleLifeOpsConnectorOptions {
+    includeAccounts?: boolean;
+    pollIntervalMs?: number;
+    pollWhileDisconnected?: boolean;
+    side?: LifeOpsConnectorSide;
+}
+export declare function useGoogleLifeOpsConnector(options?: UseGoogleLifeOpsConnectorOptions): {
+    readonly accounts: LifeOpsGoogleConnectorStatus[];
+    readonly activeMode: "local" | "remote" | "cloud_managed";
+    readonly actionPending: boolean;
+    readonly connect: () => Promise<void>;
+    readonly connectAdditional: () => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly disconnectAccount: (grantId: string) => Promise<void>;
+    readonly error: string;
+    readonly loading: boolean;
+    readonly modeOptions: ("local" | "remote" | "cloud_managed")[];
+    readonly pendingAuthUrl: string;
+    readonly refresh: ({ silent, mode, }?: {
+        silent?: boolean;
+        mode?: LifeOpsConnectorMode | null;
+    }) => Promise<void>;
+    readonly selectMode: (mode: LifeOpsConnectorMode) => Promise<void>;
+    readonly selectedMode: "local" | "remote" | "cloud_managed";
+    readonly side: "agent" | "owner";
+    readonly status: LifeOpsGoogleConnectorStatus;
+};
+//# sourceMappingURL=useGoogleLifeOpsConnector.d.ts.map

package/apps/app-lifeops/src/hooks/useGoogleLifeOpsConnector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGoogleLifeOpsConnector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useGoogleLifeOpsConnector.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,oBAAoB,EACpB,oBAAoB,EAEpB,4BAA4B,EAC7B,MAAM,uBAAuB,CAAC;AA4K/B,MAAM,WAAW,gCAAgC;IAC/C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAED,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC;;;;;;;0CA0X5B,MAAM;;;;;2CAjVnB;QACD,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,IAAI,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;KACpC;gCAuPY,oBAAoB;;;;EAkKpC"}