@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

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

@@ -1,46 +1,180 @@
 import { logger } from "@elizaos/core";
-import { gatePluginSessionForHostedApp } from "@elizaos/agent/services/app-session-gate";
+import { lifeOpsSchema } from "./lifeops/schema.js";
+import { LifeOpsRepository } from "./lifeops/repository.js";
 import { manageLifeOpsBrowserAction } from "./action.js";
 import { lifeOpsBrowserProvider } from "./provider.js";
 import { LifeOpsBrowserPluginService } from "./service.js";
-import { blockWebsitesAction, getWebsiteBlockStatusAction, requestWebsiteBlockingPermissionAction, unblockWebsitesAction, } from "./selfcontrol/action.js";
-import { websiteBlockerProvider } from "./selfcontrol/provider.js";
-import { getSelfControlStatus, setSelfControlPluginConfig, } from "./selfcontrol/selfcontrol.js";
-import { WebsiteBlockerService } from "./selfcontrol/service.js";
+import { blockWebsitesAction, getWebsiteBlockStatusAction, requestWebsiteBlockingPermissionAction, unblockWebsitesAction, } from "./actions/website-blocker.js";
+import { blockAppsAction, unblockAppsAction, getAppBlockStatusAction, } from "./actions/app-blocker.js";
+import { websiteBlockerProvider } from "./providers/website-blocker.js";
+import { appBlockerProvider } from "./providers/app-blocker.js";
+import { getSelfControlStatus, setSelfControlPluginConfig, } from "./website-blocker/engine.js";
+import { WebsiteBlockerService } from "./website-blocker/service.js";
+// T7g — Website blocker chat integration (plan §6.8).
+import { blockUntilTaskCompleteAction, listActiveBlocksAction, registerBlockRuleReconcilerWorker, releaseBlockAction, } from "./website-blocker/chat-integration/index.js";
 // LifeOps core actions (calendar, gmail, life/tasks, goals, inbox, owner profile)
 import { calendarAction } from "./actions/calendar.js";
 import { gmailAction } from "./actions/gmail.js";
+import { xReadAction } from "./actions/x-read.js";
 import { inboxAction } from "./actions/inbox.js";
 import { lifeAction } from "./actions/life.js";
 import { updateOwnerProfileAction } from "./actions/update-owner-profile.js";
+// T9f — Morning/night check-in engine (plan §6.23).
+import { runMorningCheckinAction, runNightCheckinAction, } from "./actions/checkin.js";
+import { relationshipAction } from "./actions/relationships.js";
+import { screenTimeAction } from "./actions/screen-time.js";
+// T8d — Activity tracker (plan §6.12).
+import { getActivityReportAction, getTimeOnAppAction, getTimeOnSiteAction, } from "./actions/activity-report.js";
+import { ActivityTrackerService } from "./activity-profile/activity-tracker-service.js";
+import { callExternalAction, callUserAction, twilioCallAction, } from "./actions/twilio-call.js";
+import { remoteDesktopAction } from "./actions/remote-desktop.js";
+import { startRemoteSessionAction } from "./actions/start-remote-session.js";
+import { revokeRemoteSessionAction } from "./actions/revoke-remote-session.js";
+import { listRemoteSessionsAction } from "./actions/list-remote-sessions.js";
+import { lifeOpsComputerUseAction } from "./actions/computer-use.js";
+import { crossChannelSendAction } from "./actions/cross-channel-send.js";
+import { searchAcrossChannelsAction } from "./actions/search-across-channels.js";
+import { intentSyncAction } from "./actions/intent-sync.js";
+import { publishDeviceIntentAction } from "./actions/device-bus.js";
+import { passwordManagerAction } from "./actions/password-manager.js";
+import { addAutofillWhitelistAction, listAutofillWhitelistAction, requestFieldFillAction, } from "./actions/autofill.js";
+import { calendlyAction } from "./actions/calendly.js";
+import { checkAvailabilityAction, proposeMeetingTimesAction, schedulingAction, updateMeetingPreferencesAction, } from "./actions/scheduling.js";
+import { dossierAction } from "./actions/dossier.js";
+// T7f — meeting dossier (plan §6.7).
+import { generateDossierAction } from "./dossier/action.js";
+// T8a — travel-time awareness (plan §6.9).
+import { computeTravelBufferAction } from "./travel-time/action.js";
+import { healthAction } from "./actions/health.js";
+// T8e — browser extension bridge actions (plan §6.13).
+import { fetchBrowserActivityAction, registerBrowserSessionAction, } from "./actions/browser-extension.js";
 // LifeOps core providers
 import { inboxTriageProvider } from "./providers/inbox-triage.js";
 import { lifeOpsProvider } from "./providers/lifeops.js";
+import { crossChannelContextProvider } from "./providers/cross-channel-context.js";
 // LifeOps runtime (scheduler task worker + registration)
-import { ensureLifeOpsSchedulerTask, registerLifeOpsTaskWorker, } from "./lifeops/runtime.js";
+import { ensureLifeOpsSchedulerTask, LIFEOPS_TASK_NAME, registerLifeOpsTaskWorker, } from "./lifeops/runtime.js";
+// Activity-profile (proactive agent: GM/GN/nudges)
+import { activityProfileProvider } from "./providers/activity-profile.js";
+import { ensureProactiveAgentTask, PROACTIVE_TASK_NAME, registerProactiveTaskWorker, } from "./activity-profile/proactive-worker.js";
+// Follow-up tracker (T7c — plan §6.4)
+import { FOLLOWUP_TRACKER_TASK_NAME, listOverdueFollowupsAction, markFollowupDoneAction, setFollowupThresholdAction, registerFollowupTrackerWorker, } from "./followup/index.js";
+async function ensureTaskWithRetries(args) {
+    const delays = args.delays ?? [2_000, 5_000, 10_000];
+    for (let attempt = 0; attempt <= delays.length; attempt += 1) {
+        try {
+            await args.ensure();
+            return;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (attempt < delays.length) {
+                args.runtime.logger?.warn?.(`${args.prefix} ${args.label} init failed (attempt ${attempt + 1}/${delays.length + 1}), retrying in ${delays[attempt]}ms: ${message}`);
+                await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+                continue;
+            }
+            args.runtime.logger?.error?.(`${args.prefix} ${args.label} init failed after ${delays.length + 1} attempts: ${message}`);
+            throw error instanceof Error
+                ? error
+                : new Error(`${args.label} init failed: ${message}`);
+        }
+    }
+}
+function scheduleTaskEnsureAfterRuntimeInit(args) {
+    void args.runtime.initPromise
+        .then(async () => {
+        await ensureTaskWithRetries(args);
+    })
+        .catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        args.runtime.logger?.error?.(`${args.prefix} ${args.label} init failed after runtime initialization: ${message}`);
+    });
+}
 const rawAppLifeOpsPlugin = {
     name: "@elizaos/app-lifeops",
-    description: "LifeOps: routines, goals, Google Workspace, Apple Reminders, Twilio, browser companions (Chrome/Safari), hosts-file website blocking, and related surfaces.",
+    description: "LifeOps: routines, goals, Google Workspace, Apple Reminders, Twilio, browser companions (Chrome/Safari), website blocking, app blocking, and related surfaces.",
+    schema: lifeOpsSchema,
     actions: [
         manageLifeOpsBrowserAction,
         blockWebsitesAction,
         getWebsiteBlockStatusAction,
         requestWebsiteBlockingPermissionAction,
         unblockWebsitesAction,
+        blockUntilTaskCompleteAction,
+        listActiveBlocksAction,
+        releaseBlockAction,
+        blockAppsAction,
+        unblockAppsAction,
+        getAppBlockStatusAction,
         calendarAction,
         gmailAction,
+        xReadAction,
         inboxAction,
         lifeAction,
         updateOwnerProfileAction,
+        runMorningCheckinAction,
+        runNightCheckinAction,
+        relationshipAction,
+        screenTimeAction,
+        getActivityReportAction,
+        getTimeOnAppAction,
+        getTimeOnSiteAction,
+        twilioCallAction,
+        callUserAction,
+        callExternalAction,
+        remoteDesktopAction,
+        startRemoteSessionAction,
+        revokeRemoteSessionAction,
+        listRemoteSessionsAction,
+        lifeOpsComputerUseAction,
+        crossChannelSendAction,
+        searchAcrossChannelsAction,
+        publishDeviceIntentAction,
+        intentSyncAction,
+        passwordManagerAction,
+        requestFieldFillAction,
+        addAutofillWhitelistAction,
+        listAutofillWhitelistAction,
+        calendlyAction,
+        proposeMeetingTimesAction,
+        checkAvailabilityAction,
+        updateMeetingPreferencesAction,
+        schedulingAction,
+        listOverdueFollowupsAction,
+        markFollowupDoneAction,
+        setFollowupThresholdAction,
+        dossierAction,
+        generateDossierAction,
+        computeTravelBufferAction,
+        healthAction,
+        registerBrowserSessionAction,
+        fetchBrowserActivityAction,
     ],
     providers: [
         lifeOpsBrowserProvider,
         websiteBlockerProvider,
+        appBlockerProvider,
         lifeOpsProvider,
         inboxTriageProvider,
+        crossChannelContextProvider,
+        activityProfileProvider,
+    ],
+    services: [
+        LifeOpsBrowserPluginService,
+        WebsiteBlockerService,
+        ActivityTrackerService,
     ],
-    services: [LifeOpsBrowserPluginService, WebsiteBlockerService],
     init: async (pluginConfig, runtime) => {
+        // Bootstrap LifeOps database tables before anything else runs.
+        try {
+            await LifeOpsRepository.bootstrapSchema(runtime);
+            logger.info("[lifeops] Database schema bootstrapped");
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            logger.error(`[lifeops] Failed to bootstrap database schema: ${msg}`);
+            throw error instanceof Error ? error : new Error(msg);
+        }
         setSelfControlPluginConfig(pluginConfig);
         const status = await getSelfControlStatus();
         if (status.available) {
@@ -49,30 +183,104 @@ const rawAppLifeOpsPlugin = {
         else {
             logger.warn(`[selfcontrol] Plugin loaded, but local website blocking is unavailable: ${status.reason ?? "unknown reason"}`);
         }
+        // Register the proactive agent (activity-profile: GM/GN/nudges)
+        const proactiveAgentDisabled = (() => {
+            const disableValue = (process.env.ELIZA_DISABLE_PROACTIVE_AGENT ?? "")
+                .trim()
+                .toLowerCase();
+            if (disableValue === "1" ||
+                disableValue === "true" ||
+                disableValue === "yes") {
+                return true;
+            }
+            const enableValue = (process.env.ENABLE_PROACTIVE_AGENT ?? "")
+                .trim()
+                .toLowerCase();
+            return enableValue === "0" || enableValue === "false";
+        })();
+        if (!proactiveAgentDisabled) {
+            registerProactiveTaskWorker(runtime);
+            scheduleTaskEnsureAfterRuntimeInit({
+                runtime,
+                prefix: "[proactive]",
+                label: "task",
+                ensure: async () => {
+                    await ensureProactiveAgentTask(runtime);
+                },
+            });
+        }
+        else {
+            runtime.logger?.info("[proactive] Proactive agent task skipped — ELIZA_DISABLE_PROACTIVE_AGENT=1");
+        }
+        // Register the follow-up tracker worker (T7c). computeOverdueFollowups
+        // degrades gracefully when RelationshipsService isn't registered.
+        registerFollowupTrackerWorker(runtime);
+        // T7g — Register the website blocker chat integration reconciler.
+        registerBlockRuleReconcilerWorker(runtime);
         // Register the LifeOps scheduler task worker and ensure the scheduler task exists
         registerLifeOpsTaskWorker(runtime);
-        void (async () => {
-            const DELAYS = [2_000, 5_000, 10_000];
-            for (let attempt = 0; attempt <= DELAYS.length; attempt++) {
-                try {
-                    await ensureLifeOpsSchedulerTask(runtime);
-                    return;
-                }
-                catch (error) {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    if (attempt < DELAYS.length) {
-                        runtime.logger?.warn?.(`[lifeops] Scheduler task init failed (attempt ${attempt + 1}/${DELAYS.length + 1}), retrying in ${DELAYS[attempt]}ms: ${msg}`);
-                        await new Promise((r) => setTimeout(r, DELAYS[attempt]));
-                    }
-                    else {
-                        runtime.logger?.error?.(`[lifeops] Scheduler task init failed after ${DELAYS.length + 1} attempts — LifeOps scheduler is NOT running: ${msg}`);
+        scheduleTaskEnsureAfterRuntimeInit({
+            runtime,
+            prefix: "[lifeops]",
+            label: "scheduler task",
+            ensure: async () => {
+                await ensureLifeOpsSchedulerTask(runtime);
+            },
+        });
+    },
+    /**
+     * Tear down everything `init` registered so `runtime.unloadPlugin(...)`
+     * produces an actually-stopped LifeOps:
+     *   - Unregister task workers (proactive, follow-up, scheduler)
+     *   - Delete the persisted task rows that reference those workers
+     *
+     * Routes, services, actions, providers, and event listeners are cleaned
+     * up automatically by the runtime's plugin-lifecycle teardown — no need
+     * to touch those here.
+     */
+    dispose: async (runtime) => {
+        const taskNames = [
+            PROACTIVE_TASK_NAME,
+            LIFEOPS_TASK_NAME,
+            FOLLOWUP_TRACKER_TASK_NAME,
+        ];
+        // Delete persisted Task rows so the scheduler doesn't try to run them
+        // on restart (the worker function will be gone).
+        for (const name of taskNames) {
+            try {
+                const tasks = await runtime.getTasks({
+                    agentIds: [runtime.agentId],
+                });
+                for (const task of tasks) {
+                    if (task.name === name && task.id) {
+                        try {
+                            await runtime.deleteTask(task.id);
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            runtime.logger?.warn?.(`[lifeops:dispose] Failed to delete task ${name} (${task.id}): ${msg}`);
+                        }
                     }
                 }
             }
-        })();
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                runtime.logger?.warn?.(`[lifeops:dispose] Failed to list tasks for "${name}": ${msg}`);
+            }
+        }
+        // Unregister the in-memory worker functions.
+        for (const name of taskNames) {
+            try {
+                runtime.unregisterTaskWorker?.(name);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                runtime.logger?.warn?.(`[lifeops:dispose] Failed to unregister task worker "${name}": ${msg}`);
+            }
+        }
     },
 };
-export const appLifeOpsPlugin = gatePluginSessionForHostedApp(rawAppLifeOpsPlugin, "@elizaos/app-lifeops");
+export const appLifeOpsPlugin = rawAppLifeOpsPlugin;
 export const lifeOpsBrowserPlugin = appLifeOpsPlugin;
 export { LifeOpsBrowserPluginService, lifeOpsBrowserProvider, manageLifeOpsBrowserAction, };
 // LifeOps core exports
@@ -81,12 +289,23 @@ export { gmailAction } from "./actions/gmail.js";
 export { inboxAction } from "./actions/inbox.js";
 export { lifeAction } from "./actions/life.js";
 export { updateOwnerProfileAction } from "./actions/update-owner-profile.js";
+export { checkAvailabilityAction, proposeMeetingTimesAction, schedulingAction, updateMeetingPreferencesAction, } from "./actions/scheduling.js";
 export { inboxTriageProvider } from "./providers/inbox-triage.js";
 export { lifeOpsProvider } from "./providers/lifeops.js";
+// T9f — Morning/night check-in engine (plan §6.23).
+export { runMorningCheckinAction, runNightCheckinAction, } from "./actions/checkin.js";
+export { CheckinService } from "./lifeops/checkin/checkin-service.js";
+export { resolveCheckinSchedule } from "./lifeops/checkin/schedule-resolver.js";
 // Routes (consumed by agent server.ts via import)
 export { handleLifeOpsRoutes } from "./routes/lifeops-routes.js";
 export { handleWebsiteBlockerRoutes } from "./routes/website-blocker-routes.js";
 // LifeOps runtime exports
 export { ensureLifeOpsSchedulerTask, registerLifeOpsTaskWorker, executeLifeOpsSchedulerTask, resolveLifeOpsTaskIntervalMs, LIFEOPS_TASK_NAME, LIFEOPS_TASK_TAGS, LIFEOPS_TASK_INTERVAL_MS, LIFEOPS_TASK_JITTER_MS, } from "./lifeops/runtime.js";
-export * from "./selfcontrol/index.js";
+export * from "./website-blocker/public.js";
+// App blocker exports
+export { blockAppsAction, unblockAppsAction, getAppBlockStatusAction } from "./actions/app-blocker.js";
+export { appBlockerProvider } from "./providers/app-blocker.js";
+export { getAppBlockerStatus, getCachedAppBlockerStatus, getAppBlockerPermissionState, requestAppBlockerPermission, getInstalledApps, selectAppsForBlocking, startAppBlock, stopAppBlock, } from "./app-blocker/engine.js";
+// Follow-up tracker (T7c)
+export { listOverdueFollowupsAction, markFollowupDoneAction, setFollowupThresholdAction, registerFollowupTrackerWorker, reconcileFollowupsOnce, computeOverdueFollowups, writeOverdueDigestMemory, getFollowupTrackerRoomId, FOLLOWUP_TRACKER_TASK_NAME, FOLLOWUP_TRACKER_TASK_TAGS, FOLLOWUP_TRACKER_INTERVAL_MS, FOLLOWUP_DEFAULT_THRESHOLD_DAYS, FOLLOWUP_MEMORY_TABLE, } from "./followup/index.js";
 export default appLifeOpsPlugin;

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

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-lifeops/src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAiCvB,eAAO,MAAM,sBAAsB,EAAE,QAiEpC,CAAC"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-lifeops/src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAiCvB,eAAO,MAAM,sBAAsB,EAAE,QAkEpC,CAAC"}

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

@@ -21,6 +21,7 @@ function formatTabLine(tab) {
 export const lifeOpsBrowserProvider = {
     name: "lifeops_browser",
     description: "Owner/admin-only context for the user's personal Chrome and Safari LifeOps Browser companions. Separate from the Eliza browser workspace.",
+    descriptionCompressed: "Owner: Chrome/Safari LifeOps Browser companion context.",
     dynamic: true,
     position: 13,
     async get(runtime, message, _state) {

package/apps/app-lifeops/src/providers/activity-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-profile.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/providers/activity-profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAuBvB,eAAO,MAAM,uBAAuB,EAAE,QA2IrC,CAAC"}

package/apps/app-lifeops/src/providers/activity-profile.js

@@ -0,0 +1,140 @@
+import { logger } from "@elizaos/core";
+import { resolveCurrentBucket } from "../activity-profile/analyzer.js";
+import { PROACTIVE_TASK_TAGS } from "../activity-profile/proactive-worker.js";
+import { readProfileFromMetadata } from "../activity-profile/service.js";
+import { resolveDefaultTimeZone } from "../lifeops/defaults.js";
+import { getLocalDateKey, getZonedDateParts } from "../lifeops/time.js";
+import { hasAdminAccess } from "@elizaos/agent/security/access";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function formatAgo(ms) {
+    if (ms < 60_000)
+        return "just now";
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+export const activityProfileProvider = {
+    name: "activity-profile",
+    description: "Owner/admin and agent only. Compact user activity context: platform, time bucket, recency.",
+    dynamic: true,
+    position: 13,
+    async get(runtime, message, _state) {
+        if (!(await hasAdminAccess(runtime, message))) {
+            return { text: "", values: {}, data: {} };
+        }
+        const timezone = resolveDefaultTimeZone();
+        const now = new Date();
+        const bucket = resolveCurrentBucket(timezone, now);
+        try {
+            const tasks = await runtime.getTasks({
+                agentIds: [runtime.agentId],
+                tags: [...PROACTIVE_TASK_TAGS],
+            });
+            const task = tasks.find((t) => t.name === "PROACTIVE_AGENT" && isRecord(t.metadata));
+            const metadata = isRecord(task?.metadata) ? task.metadata : null;
+            const profile = readProfileFromMetadata(metadata);
+            if (profile) {
+                const parts = [];
+                const localDateKey = getLocalDateKey(getZonedDateParts(now, timezone));
+                const hasActiveScreen = profile.screenContextAvailable &&
+                    profile.screenContextFocus !== null &&
+                    profile.screenContextFocus !== "idle" &&
+                    profile.screenContextFocus !== "unknown";
+                if (!hasActiveScreen &&
+                    profile.lastSeenPlatform &&
+                    profile.lastSeenAt > 0) {
+                    const ago = formatAgo(now.getTime() - profile.lastSeenAt);
+                    parts.push(profile.isCurrentlyActive
+                        ? `active on ${profile.lastSeenPlatform} ${ago}`
+                        : `last seen on ${profile.lastSeenPlatform} ${ago}`);
+                }
+                if (hasActiveScreen && profile.screenContextFocus) {
+                    const screenAgo = profile.screenContextSampledAt
+                        ? formatAgo(now.getTime() - profile.screenContextSampledAt)
+                        : "recently";
+                    const screenParts = [`screen ${profile.screenContextFocus}`];
+                    if (profile.screenContextSource &&
+                        profile.screenContextSource !== "disabled") {
+                        screenParts.push(`via ${profile.screenContextSource}`);
+                    }
+                    screenParts.push(screenAgo);
+                    parts.push(screenParts.join(" "));
+                }
+                if (profile.isCurrentlySleeping) {
+                    parts.push("sleeping");
+                }
+                else if (profile.hasSleepData) {
+                    parts.push("sleep data ready");
+                }
+                parts.push(bucket);
+                if (profile.effectiveDayKey !== localDateKey) {
+                    parts.push("previous day still open");
+                }
+                return {
+                    text: parts.length > 0 ? `User: ${parts.join(" | ")}` : "",
+                    values: {
+                        userIsActive: profile.isCurrentlyActive,
+                        userPrimaryPlatform: profile.primaryPlatform,
+                        userLastSeenPlatform: profile.lastSeenPlatform,
+                        userLastSeenAt: profile.lastSeenAt,
+                        userTimeBucket: bucket,
+                        userEffectiveDayKey: profile.effectiveDayKey,
+                        userHasOpenActivityCycle: profile.hasOpenActivityCycle,
+                        userTypicalWakeHour: profile.typicalWakeHour,
+                        userTypicalSleepHour: profile.typicalSleepHour,
+                        userHasSleepData: profile.hasSleepData,
+                        userIsSleeping: profile.isCurrentlySleeping,
+                        userLastSleepSignalAt: profile.lastSleepSignalAt,
+                        userLastWakeSignalAt: profile.lastWakeSignalAt,
+                        userTypicalSleepDurationMinutes: profile.typicalSleepDurationMinutes,
+                        userScreenContextFocus: profile.screenContextFocus,
+                        userScreenContextSource: profile.screenContextSource,
+                        userScreenContextSampledAt: profile.screenContextSampledAt,
+                        userScreenContextConfidence: profile.screenContextConfidence,
+                        userScreenContextBusy: profile.screenContextBusy,
+                        userScreenContextAvailable: profile.screenContextAvailable,
+                        userScreenContextStale: profile.screenContextStale,
+                    },
+                    data: {},
+                };
+            }
+        }
+        catch (error) {
+            logger.warn({
+                boundary: "activity_profile",
+                operation: "provider_profile_read",
+                err: error instanceof Error ? error : undefined,
+            }, "[activity-profile] Failed to read proactive task metadata; falling back to time-bucket-only context.");
+        }
+        return {
+            text: `User context: ${bucket}`,
+            values: {
+                userIsActive: false,
+                userPrimaryPlatform: null,
+                userLastSeenPlatform: null,
+                userLastSeenAt: 0,
+                userTimeBucket: bucket,
+                userScreenContextFocus: null,
+                userScreenContextSource: null,
+                userScreenContextSampledAt: null,
+                userScreenContextConfidence: null,
+                userScreenContextBusy: false,
+                userScreenContextAvailable: false,
+                userScreenContextStale: false,
+                userHasSleepData: false,
+                userIsSleeping: false,
+                userLastSleepSignalAt: null,
+                userLastWakeSignalAt: null,
+                userTypicalSleepDurationMinutes: null,
+            },
+            data: {},
+        };
+    },
+};

package/apps/app-lifeops/src/providers/app-blocker.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "@elizaos/core";
+export declare const appBlockerProvider: Provider;
+//# sourceMappingURL=app-blocker.d.ts.map

package/apps/app-lifeops/src/providers/app-blocker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-blocker.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/providers/app-blocker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,QAAQ,EAGT,MAAM,eAAe,CAAC;AAIvB,eAAO,MAAM,kBAAkB,EAAE,QA8FhC,CAAC"}

package/apps/app-lifeops/src/providers/app-blocker.js

@@ -0,0 +1,86 @@
+import { getAppBlockerAccess } from "../app-blocker/access.js";
+import { getCachedAppBlockerStatus } from "../app-blocker/engine.js";
+export const appBlockerProvider = {
+    name: "appBlocker",
+    description: "Admin-only provider for the native mobile app blocker integration (Family Controls on iPhone, Usage Access overlay on Android)",
+    descriptionCompressed: "Admin: mobile app blocker integration.",
+    dynamic: true,
+    get: async (runtime, message, _state) => {
+        const access = await getAppBlockerAccess(runtime, message);
+        if (!access.allowed) {
+            return {
+                text: "",
+                values: { appBlockerAuthorized: false },
+                data: { appBlockerAuthorized: false },
+            };
+        }
+        let status;
+        try {
+            status = await getCachedAppBlockerStatus();
+        }
+        catch {
+            return {
+                text: "App blocking plugin is not loaded on this device.",
+                values: {
+                    appBlockerAuthorized: true,
+                    appBlockerAvailable: false,
+                },
+                data: {
+                    appBlockerAuthorized: true,
+                    appBlockerAvailable: false,
+                },
+            };
+        }
+        if (!status.available) {
+            return {
+                text: status.reason ??
+                    "App blocking is not available on this device.",
+                values: {
+                    appBlockerAuthorized: true,
+                    appBlockerAvailable: false,
+                    appBlockerEngine: status.engine,
+                    appBlockerPlatform: status.platform,
+                },
+                data: {
+                    appBlockerAuthorized: true,
+                    appBlockerAvailable: false,
+                    appBlockerEngine: status.engine,
+                    appBlockerPlatform: status.platform,
+                },
+            };
+        }
+        const statusLine = status.active
+            ? status.endsAt
+                ? `An app block is active (${status.blockedCount} apps) until ${status.endsAt}.`
+                : `An app block is active (${status.blockedCount} apps) until you remove it.`
+            : "No app block is active right now.";
+        const permissionLine = status.permissionStatus === "granted"
+            ? "Eliza has permission to block apps on this device."
+            : status.reason ??
+                "App blocking permissions have not been granted yet.";
+        return {
+            text: [statusLine, permissionLine].join(" "),
+            values: {
+                appBlockerAuthorized: true,
+                appBlockerAvailable: true,
+                appBlockerActive: status.active,
+                appBlockerBlockedCount: status.blockedCount,
+                appBlockerEndsAt: status.endsAt,
+                appBlockerEngine: status.engine,
+                appBlockerPlatform: status.platform,
+                appBlockerPermissionStatus: status.permissionStatus,
+            },
+            data: {
+                appBlockerAuthorized: true,
+                appBlockerAvailable: true,
+                appBlockerActive: status.active,
+                appBlockerBlockedCount: status.blockedCount,
+                appBlockerBlockedPackageNames: status.blockedPackageNames,
+                appBlockerEndsAt: status.endsAt,
+                appBlockerEngine: status.engine,
+                appBlockerPlatform: status.platform,
+                appBlockerPermissionStatus: status.permissionStatus,
+            },
+        };
+    },
+};

package/apps/app-lifeops/src/providers/cross-channel-context.d.ts

@@ -0,0 +1,29 @@
+/**
+ * cross-channel-context provider (WS1).
+ *
+ * When the planner's signal detector flags the current turn as involving
+ * a named person or a topic worth pulling prior signal for, this
+ * provider injects the top-N cross-channel hits into context. It never
+ * fires on empty signal and never silently returns stale data.
+ *
+ * Signal sources (in priority order):
+ *   1. Explicit state key `crossChannelContextRequest` — set by actions
+ *      or the planner when they already know what to fetch.
+ *   2. Structured hint in state.data.cross_channel_context_key.
+ *
+ * When neither signal is present, the provider returns EMPTY rather
+ * than running a speculative search on every turn.
+ */
+import type { Provider, UUID } from "@elizaos/core";
+import { type UnifiedSearchChannel } from "../lifeops/unified-search.js";
+export type CrossChannelContextRequest = {
+    query: string;
+    person?: string;
+    primaryEntityId?: UUID;
+    startIso?: string;
+    endIso?: string;
+    channels?: UnifiedSearchChannel[];
+    limit?: number;
+};
+export declare const crossChannelContextProvider: Provider;
+//# sourceMappingURL=cross-channel-context.d.ts.map

package/apps/app-lifeops/src/providers/cross-channel-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-channel-context.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/providers/cross-channel-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAGV,QAAQ,EAGR,IAAI,EACL,MAAM,eAAe,CAAC;AAGvB,OAAO,EAEL,KAAK,oBAAoB,EAG1B,MAAM,8BAA8B,CAAC;AAWtC,MAAM,MAAM,0BAA0B,GAAG;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,IAAI,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AA0FF,eAAO,MAAM,2BAA2B,EAAE,QAuHzC,CAAC"}