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

package/apps/app-lifeops/src/activity-profile/proactive-worker.js

@@ -0,0 +1,571 @@
+import { logger, ModelType, parseJSONObjectFromText, stringToUuid, } from "@elizaos/core";
+import { loadOwnerContactsConfig, resolveOwnerContactWithFallback, } from "@elizaos/agent/config/owner-contacts";
+import { loadLifeOpsAppState } from "../lifeops/app-state.js";
+import { ensureRuntimeAgentRecord } from "../lifeops/runtime.js";
+import { resolveDefaultTimeZone } from "../lifeops/defaults.js";
+import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
+import { BackgroundPlannerError, planJob, } from "../lifeops/background-planner.js";
+import { enqueueIfSensitive } from "../lifeops/background-planner-dispatch.js";
+import { getAgentEventService } from "@elizaos/agent/runtime/agent-event-service";
+import { resolveEffectiveDayKey } from "./analyzer.js";
+import { planDowntimeNudges, planGm, planGn, planGoalCheckIns, planNudges, } from "./proactive-planner.js";
+import { buildActivityProfile, profileNeedsRebuild, readFiredLogFromMetadata, readProfileFromMetadata, refreshCurrentState, resolveOwnerEntityId, } from "./service.js";
+export const PROACTIVE_TASK_NAME = "PROACTIVE_AGENT";
+export const PROACTIVE_TASK_TAGS = ["queue", "repeat", "proactive"];
+export const PROACTIVE_TASK_INTERVAL_MS = 60_000;
+const SEEDING_MIN_IDLE_MS = 15 * 60_000;
+const CALENDAR_PROACTIVE_CLASSIFICATION_HORIZON_DAYS = 21;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isProactiveTask(task) {
+    const metadata = isRecord(task.metadata) ? task.metadata : null;
+    const agent = metadata?.proactiveAgent;
+    return (task.name === PROACTIVE_TASK_NAME &&
+        isRecord(agent) &&
+        agent.kind === "runtime_runner");
+}
+function buildProactiveMetadata(current = null) {
+    return {
+        ...(current ?? {}),
+        updateInterval: PROACTIVE_TASK_INTERVAL_MS,
+        baseInterval: PROACTIVE_TASK_INTERVAL_MS,
+        blocking: true,
+        proactiveAgent: {
+            kind: "runtime_runner",
+            version: 1,
+        },
+    };
+}
+function normalizeCalendarEventProactiveDecisions(parsed, allowedIds) {
+    const records = Array.isArray(parsed?.events)
+        ? parsed.events
+        : Array.isArray(parsed?.decisions)
+            ? parsed.decisions
+            : Array.isArray(parsed)
+                ? parsed
+                : [];
+    const decisions = new Map();
+    for (const item of records) {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            continue;
+        }
+        const record = item;
+        const id = typeof record.id === "string" && record.id.trim().length > 0
+            ? record.id.trim()
+            : null;
+        if (!id || !allowedIds.has(id)) {
+            continue;
+        }
+        decisions.set(id, {
+            id,
+            shouldCheckIn: record.shouldCheckIn === true,
+            reason: typeof record.reason === "string" && record.reason.trim().length > 0
+                ? record.reason.trim()
+                : null,
+        });
+    }
+    return decisions;
+}
+export async function classifyCalendarEventsForProactivePlanning(runtime, events, timezone, now) {
+    if (typeof runtime.useModel !== "function") {
+        return null;
+    }
+    const horizonMs = now.getTime() +
+        CALENDAR_PROACTIVE_CLASSIFICATION_HORIZON_DAYS * 24 * 60 * 60 * 1000;
+    const candidateEvents = events
+        .filter((event) => {
+        const startMs = Date.parse(event.startAt);
+        return (Number.isFinite(startMs) &&
+            startMs >= now.getTime() &&
+            startMs <= horizonMs);
+    })
+        .sort((left, right) => Date.parse(left.startAt) - Date.parse(right.startAt))
+        .slice(0, 40);
+    if (candidateEvents.length === 0) {
+        return new Map();
+    }
+    const prompt = [
+        "Decide which calendar events deserve a proactive check-in or reminder from the assistant.",
+        "Do not use fixed numeric weights. Judge naturally from the event details.",
+        "A proactive check-in should be reserved for events where a gentle heads-up would actually help.",
+        "Meetings, calls, interviews, appointments, therapy, coffee or dinner with people, and other short scheduled social/professional events usually deserve a check-in.",
+        "Hotel stays, flights, travel blocks, reservations, check-in/check-out, passive itinerary items, and long all-day or near-all-day logistics usually do not deserve a check-in.",
+        "If an event would be extremely hard to forget or has no clear actionability, mark shouldCheckIn=false.",
+        'Return only valid JSON with this shape: {"events":[{"id":"...","shouldCheckIn":true|false,"reason":"short reason"}]}',
+        "",
+        `Current timezone: ${timezone}`,
+        `Current ISO datetime: ${now.toISOString()}`,
+        "Events:",
+        JSON.stringify(candidateEvents.map((event) => ({
+            id: event.id,
+            summary: event.summary,
+            description: event.description ?? "",
+            location: event.location ?? "",
+            startAt: event.startAt,
+            endAt: event.endAt,
+            isAllDay: event.isAllDay,
+            attendeeCount: event.attendeeCount ?? 0,
+            hasConferenceLink: Boolean(event.conferenceLink),
+        }))),
+    ].join("\n");
+    try {
+        const result = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
+        const raw = typeof result === "string" ? result : "";
+        const parsed = parseJSONObjectFromText(raw);
+        if (!parsed) {
+            return null;
+        }
+        return normalizeCalendarEventProactiveDecisions(parsed, new Set(candidateEvents.map((event) => event.id)));
+    }
+    catch (error) {
+        logger.warn({
+            boundary: "activity_profile",
+            operation: "planner_calendar_event_classification",
+            err: error instanceof Error ? error : undefined,
+        }, `[proactive] Failed to classify proactive calendar events: ${String(error)}`);
+        return null;
+    }
+}
+export function resolveProactiveDeliverySource(targetPlatform) {
+    if (targetPlatform === "web_app" ||
+        targetPlatform === "desktop_app" ||
+        targetPlatform === "mobile_app") {
+        return "client_chat";
+    }
+    return targetPlatform;
+}
+export function resolveProactiveOwnerContact(args) {
+    const deliverySource = resolveProactiveDeliverySource(args.targetPlatform);
+    if (deliverySource === "client_chat") {
+        return {
+            source: "client_chat",
+            contact: { entityId: args.ownerEntityId },
+        };
+    }
+    const resolved = resolveOwnerContactWithFallback({
+        ownerContacts: args.ownerContacts,
+        source: deliverySource,
+        ownerEntityId: args.ownerEntityId,
+    });
+    if (resolved) {
+        return {
+            source: resolved.source,
+            contact: resolved.contact,
+        };
+    }
+    return null;
+}
+export async function executeProactiveTask(runtime) {
+    const now = new Date();
+    const timezone = resolveDefaultTimeZone();
+    try {
+        const ownerEntityId = await resolveOwnerEntityId(runtime);
+        if (!ownerEntityId) {
+            return { nextInterval: PROACTIVE_TASK_INTERVAL_MS };
+        }
+        // WS5: Route this tick through the shared LLM planner. The planner
+        // decides whether any action is warranted and whether it requires
+        // human approval. We invoke it up-front so every proactive tick is
+        // observable via `planJob` and so sensitive actions are always
+        // enqueued into the WS6 approval queue.
+        const plannerContext = {
+            jobKind: "daily_brief",
+            subjectUserId: ownerEntityId,
+            snapshot: {
+                now: now.toISOString(),
+                timezone,
+            },
+            availableChannels: ["internal"],
+            trigger: "proactive_tick",
+        };
+        try {
+            const plan = await planJob(runtime, plannerContext);
+            await enqueueIfSensitive(runtime, plannerContext, plan);
+        }
+        catch (error) {
+            if (error instanceof BackgroundPlannerError) {
+                logger.warn(`[proactive] background planner unavailable — ${error.message}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        const tasks = await runtime.getTasks({
+            agentIds: [runtime.agentId],
+            tags: [...PROACTIVE_TASK_TAGS],
+        });
+        const task = tasks.find(isProactiveTask);
+        if (!task?.id) {
+            return { nextInterval: PROACTIVE_TASK_INTERVAL_MS };
+        }
+        const metadata = isRecord(task.metadata) ? task.metadata : {};
+        const currentProfile = readProfileFromMetadata(metadata);
+        let profile;
+        if (profileNeedsRebuild(currentProfile, now)) {
+            logger.info("[proactive] Building full activity profile");
+            profile = await buildActivityProfile(runtime, ownerEntityId, timezone, now);
+        }
+        else if (currentProfile) {
+            profile = await refreshCurrentState(runtime, ownerEntityId, currentProfile, now);
+        }
+        else {
+            profile = null;
+        }
+        if (!profile) {
+            return { nextInterval: PROACTIVE_TASK_INTERVAL_MS };
+        }
+        const todayStr = resolveEffectiveDayKey(profile, timezone, now);
+        let firedLog = readFiredLogFromMetadata(metadata, todayStr);
+        const { occurrences, calendarEvents, goals } = await fetchPlannerContext(runtime, timezone, now);
+        // NOTE: planGm/planGn apply their own time-of-day gating today; the
+        // canonical source of truth for morning/night enforcement windows is
+        // `src/lifeops/enforcement-windows.ts` (getCurrentEnforcementWindow).
+        // If planner gating is ever consolidated, switch these helpers to use
+        // that utility so the reminder pipeline and the proactive worker agree.
+        const gmAction = planGm(profile, occurrences, calendarEvents, firedLog, timezone, now);
+        const gnAction = planGn(profile, firedLog, timezone, now);
+        const nudgeActions = planNudges(profile, occurrences, calendarEvents, firedLog, timezone, now);
+        const downtimeActions = planDowntimeNudges(profile, occurrences, calendarEvents, firedLog, timezone, now);
+        const goalCheckInActions = planGoalCheckIns(profile, goals, firedLog, timezone, now);
+        const seedingAction = await planSeedingOffer(runtime, profile, firedLog, now);
+        const allActions = [
+            seedingAction,
+            gmAction,
+            gnAction,
+            ...nudgeActions,
+            ...downtimeActions,
+            ...goalCheckInActions,
+        ].filter((action) => action !== null && action.status === "pending");
+        const ownerContacts = loadOwnerContactsConfig({
+            boundary: "activity_profile",
+            operation: "owner_contacts_config",
+            message: "[proactive] Failed to load owner contacts config; proactive messages cannot route to owner channels until config is available.",
+        });
+        for (const action of allActions) {
+            if (action.scheduledFor > now.getTime()) {
+                continue;
+            }
+            const resolvedTarget = resolveProactiveOwnerContact({
+                targetPlatform: action.targetPlatform,
+                ownerEntityId,
+                ownerContacts,
+            });
+            const contact = resolvedTarget?.contact;
+            if (!resolvedTarget || !contact) {
+                logger.warn(`[proactive] No owner contact for platform ${action.targetPlatform}, skipping ${action.kind}`);
+                continue;
+            }
+            if (!contact.entityId && !contact.channelId && !contact.roomId) {
+                logger.warn(`[proactive] No owner contact for platform ${action.targetPlatform}, skipping ${action.kind}`);
+                continue;
+            }
+            try {
+                if (resolvedTarget.source === "client_chat") {
+                    if (emitProactiveAssistantEvent(runtime, action)) {
+                        firedLog = recordFiredAction(firedLog, todayStr, action);
+                        if (action.kind === "onboarding_seed") {
+                            try {
+                                await new LifeOpsService(runtime).markSeedingOffered();
+                            }
+                            catch (err) {
+                                logger.warn(`[proactive] Failed to record onboarding seed offer audit: ${err}`);
+                            }
+                        }
+                        logger.info(`[proactive] Emitted ${action.kind} as assistant event`);
+                        continue;
+                    }
+                    logger.warn(`[proactive] AGENT_EVENT emit unavailable for ${action.kind}; skipping in-app proactive delivery`);
+                    continue;
+                }
+                await runtime.sendMessageToTarget({
+                    source: resolvedTarget.source,
+                    entityId: contact.entityId,
+                    channelId: contact.channelId,
+                    roomId: contact.roomId,
+                }, buildProactiveDeliveryContent(action, resolvedTarget.source));
+                firedLog = recordFiredAction(firedLog, todayStr, action);
+                if (action.kind === "onboarding_seed") {
+                    try {
+                        await new LifeOpsService(runtime).markSeedingOffered();
+                    }
+                    catch (err) {
+                        logger.warn(`[proactive] Failed to record onboarding seed offer audit: ${err}`);
+                    }
+                }
+                logger.info(`[proactive] Fired ${action.kind} on ${resolvedTarget.source}`);
+            }
+            catch (err) {
+                logger.warn(`[proactive] Failed to send ${action.kind}: ${err}`);
+            }
+        }
+        await runtime.updateTask(task.id, {
+            metadata: {
+                ...metadata,
+                activityProfile: profile,
+                firedActionsLog: firedLog,
+            },
+        });
+    }
+    catch (err) {
+        logger.error(`[proactive] Worker error: ${err}`);
+    }
+    return { nextInterval: PROACTIVE_TASK_INTERVAL_MS };
+}
+const SEEDING_MESSAGE = "I notice you haven't set up any routines yet. Want me to set up some " +
+    "foundational habits? I can add: brush teeth, drink water, stretch breaks, " +
+    "vitamins, workout, shower, and shave reminders. Say 'set up my routines' " +
+    "or pick and choose.";
+async function planSeedingOffer(runtime, profile, firedLog, now) {
+    // Only offer seeding once per day at most
+    if (firedLog?.seedingOfferedAt) {
+        return null;
+    }
+    if (profile.isCurrentlyActive ||
+        now.getTime() - profile.lastSeenAt < SEEDING_MIN_IDLE_MS) {
+        return null;
+    }
+    try {
+        const service = new LifeOpsService(runtime);
+        const result = await service.checkAndOfferSeeding();
+        if (!result.needsSeeding) {
+            return null;
+        }
+    }
+    catch (error) {
+        logger.warn(`[proactive] Failed to check seeding status: ${error}`);
+        return null;
+    }
+    return {
+        kind: "onboarding_seed",
+        scheduledFor: now.getTime(),
+        targetPlatform: profile.primaryPlatform ?? "web_app",
+        contextSummary: "No routines configured; offering seed templates",
+        messageText: SEEDING_MESSAGE,
+        status: "pending",
+    };
+}
+async function fetchPlannerContext(runtime, _timezone, now) {
+    const occurrences = [];
+    const calendarEvents = [];
+    const goals = [];
+    const lifeOpsService = new LifeOpsService(runtime);
+    try {
+        const overview = await lifeOpsService.getOverview(now);
+        for (const occ of overview.occurrences) {
+            occurrences.push({
+                id: occ.id,
+                title: occ.title ?? occ.definitionId ?? "untitled",
+                dueAt: occ.dueAt,
+                state: occ.state,
+                definitionKind: occ.definitionKind,
+                cadence: occ.cadence ? { kind: occ.cadence.kind } : undefined,
+                priority: occ.priority,
+            });
+        }
+    }
+    catch (error) {
+        logger.warn({
+            boundary: "activity_profile",
+            operation: "planner_overview",
+            err: error instanceof Error ? error : undefined,
+        }, `[proactive] Failed to read LifeOps overview for planner context: ${String(error)}`);
+    }
+    try {
+        const feed = await lifeOpsService.getCalendarFeed(new URL("http://localhost/api/lifeops/calendar"), {}, now);
+        const rawCalendarEvents = feed.events.map((event) => ({
+            id: event.id,
+            summary: event.title ?? "",
+            startAt: event.startAt,
+            endAt: event.endAt,
+            isAllDay: event.isAllDay,
+            description: event.description ?? "",
+            location: event.location ?? "",
+            attendeeCount: Array.isArray(event.attendees)
+                ? event.attendees.length
+                : 0,
+            conferenceLink: event.conferenceLink ?? null,
+        }));
+        const decisions = await classifyCalendarEventsForProactivePlanning(runtime, rawCalendarEvents, _timezone, now);
+        for (const event of feed.events) {
+            const decision = decisions?.get(event.id) ?? null;
+            calendarEvents.push({
+                id: event.id,
+                summary: event.title ?? "",
+                startAt: event.startAt,
+                endAt: event.endAt,
+                isAllDay: event.isAllDay,
+                description: event.description ?? "",
+                location: event.location ?? "",
+                attendeeCount: Array.isArray(event.attendees)
+                    ? event.attendees.length
+                    : 0,
+                conferenceLink: event.conferenceLink ?? null,
+                proactiveCheckIn: decision?.shouldCheckIn ?? null,
+                proactiveCheckInReason: decision?.reason ?? null,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof LifeOpsServiceError && error.status === 409) {
+            return { occurrences, calendarEvents, goals };
+        }
+        logger.warn({
+            boundary: "activity_profile",
+            operation: "planner_calendar_feed",
+            err: error instanceof Error ? error : undefined,
+        }, `[proactive] Failed to read calendar context for proactive planning: ${String(error)}`);
+    }
+    try {
+        const goalRecords = await lifeOpsService.listGoals();
+        for (const record of goalRecords) {
+            if (record.goal.status !== "active")
+                continue;
+            const review = await lifeOpsService.reviewGoal(record.goal.id, now);
+            const scheduled = review.summary.activeOccurrenceCount +
+                review.summary.overdueOccurrenceCount +
+                review.summary.completedLast7Days;
+            goals.push({
+                id: record.goal.id,
+                title: record.goal.title,
+                status: record.goal.status,
+                linkedDefinitionCount: review.summary.linkedDefinitionCount,
+                recentCompletionRate: scheduled > 0 ? review.summary.completedLast7Days / scheduled : 0,
+                lastReviewedAt: review.summary.lastActivityAt,
+            });
+        }
+    }
+    catch (error) {
+        logger.warn({
+            boundary: "activity_profile",
+            operation: "planner_goals",
+            err: error instanceof Error ? error : undefined,
+        }, `[proactive] Failed to read goal context for proactive planning: ${String(error)}`);
+    }
+    return { occurrences, calendarEvents, goals };
+}
+function recordFiredAction(log, todayStr, action) {
+    const current = {
+        date: log?.date ?? todayStr,
+        gmFiredAt: log?.gmFiredAt,
+        gnFiredAt: log?.gnFiredAt,
+        nudgedOccurrenceIds: [...(log?.nudgedOccurrenceIds ?? [])],
+        nudgedCalendarEventIds: [...(log?.nudgedCalendarEventIds ?? [])],
+        checkedGoalIds: [...(log?.checkedGoalIds ?? [])],
+    };
+    if (action.kind === "gm") {
+        current.gmFiredAt = Date.now();
+    }
+    else if (action.kind === "gn") {
+        current.gnFiredAt = Date.now();
+    }
+    else if (action.kind === "pre_activity_nudge") {
+        if (action.occurrenceId &&
+            !current.nudgedOccurrenceIds.includes(action.occurrenceId)) {
+            current.nudgedOccurrenceIds.push(action.occurrenceId);
+        }
+        if (action.calendarEventId &&
+            !current.nudgedCalendarEventIds.includes(action.calendarEventId)) {
+            current.nudgedCalendarEventIds.push(action.calendarEventId);
+        }
+    }
+    else if (action.kind === "goal_check_in") {
+        if (action.goalId && !current.checkedGoalIds?.includes(action.goalId)) {
+            current.checkedGoalIds?.push(action.goalId);
+        }
+    }
+    else if (action.kind === "onboarding_seed") {
+        current.seedingOfferedAt = Date.now();
+    }
+    return current;
+}
+function buildProactiveDeliveryContent(action, deliverySource) {
+    const text = action.messageText.trim() || action.contextSummary.trim();
+    return { text, source: deliverySource };
+}
+function emitProactiveAssistantEvent(runtime, action) {
+    const eventService = getAgentEventService(runtime);
+    if (!eventService?.emit) {
+        return false;
+    }
+    const text = action.messageText.trim() || action.contextSummary.trim();
+    eventService.emit({
+        runId: crypto.randomUUID(),
+        stream: "assistant",
+        agentId: runtime.agentId,
+        data: {
+            text,
+            source: resolveProactiveAssistantEventSource(action),
+            kind: action.kind,
+            scheduledFor: action.scheduledFor,
+            targetPlatform: action.targetPlatform,
+            occurrenceId: action.occurrenceId,
+            calendarEventId: action.calendarEventId,
+            goalId: action.goalId,
+        },
+    });
+    return true;
+}
+function resolveProactiveAssistantEventSource(action) {
+    if (action.kind === "gm") {
+        return "proactive-gm";
+    }
+    if (action.kind === "gn") {
+        return "proactive-gn";
+    }
+    if (action.kind === "goal_check_in") {
+        return "proactive-goal-check-in";
+    }
+    if (action.kind === "onboarding_seed") {
+        return "proactive-onboarding";
+    }
+    return "proactive-nudge";
+}
+export function registerProactiveTaskWorker(runtime) {
+    if (runtime.getTaskWorker(PROACTIVE_TASK_NAME)) {
+        return;
+    }
+    runtime.registerTaskWorker({
+        name: PROACTIVE_TASK_NAME,
+        // Skip execution when the user has disabled LifeOps via the UI. The task
+        // record and worker stay registered so toggling back on requires no
+        // restart — cycles just become cheap no-ops while disabled.
+        shouldRun: async (rt) => {
+            try {
+                const state = await loadLifeOpsAppState(rt);
+                return state.enabled;
+            }
+            catch {
+                return true;
+            }
+        },
+        execute: (rt) => executeProactiveTask(rt),
+    });
+}
+export async function ensureProactiveAgentTask(runtime) {
+    await ensureRuntimeAgentRecord(runtime);
+    const tasks = await runtime.getTasks({
+        agentIds: [runtime.agentId],
+        tags: [...PROACTIVE_TASK_TAGS],
+    });
+    const existing = tasks.find(isProactiveTask);
+    const metadata = buildProactiveMetadata(isRecord(existing?.metadata) ? existing.metadata : null);
+    if (existing?.id) {
+        await runtime.updateTask(existing.id, {
+            description: "Proactive agent: GM/GN/nudges based on activity profile",
+            metadata,
+        });
+        return existing.id;
+    }
+    const autonomy = runtime.getService("AUTONOMY");
+    const roomId = autonomy?.getAutonomousRoomId?.() ??
+        stringToUuid(`proactive-agent-room-${runtime.agentId}`);
+    return runtime.createTask({
+        name: PROACTIVE_TASK_NAME,
+        description: "Proactive agent: GM/GN/nudges based on activity profile",
+        roomId,
+        tags: [...PROACTIVE_TASK_TAGS],
+        metadata,
+        dueAt: Date.now(),
+    });
+}

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

@@ -0,0 +1 @@
+{"version":3,"file":"profile-metadata.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/activity-profile/profile-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAMlD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GACvC,eAAe,GAAG,IAAI,CASxB"}

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

@@ -0,0 +1,18 @@
+/**
+ * Window-title PII redactor for the T8d activity tracker.
+ *
+ * Stripped when `ACTIVITY_REDACT_TITLES` is "1" or unset (default on):
+ *  - Email addresses          → [redacted-email]
+ *  - Phone numbers (e.164 / 10-digit US)  → [redacted-phone]
+ *  - Credit-card-like digit runs (13–19 contiguous digits, optional separators) → [redacted-cc]
+ *
+ * Redaction is applied in the reporting layer before results leave the
+ * process. The raw title stays in the database so the user can disable
+ * redaction retroactively.
+ */
+export interface RedactorConfig {
+    enabled: boolean;
+}
+export declare function resolveRedactorConfigFromEnv(env?: NodeJS.ProcessEnv): RedactorConfig;
+export declare function redactWindowTitle(title: string | null | undefined, config: RedactorConfig): string | null;
+//# sourceMappingURL=redactor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redactor.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/activity-profile/redactor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAaH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,4BAA4B,CAC1C,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,cAAc,CAIhB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,MAAM,EAAE,cAAc,GACrB,MAAM,GAAG,IAAI,CAWf"}

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

@@ -0,0 +1,39 @@
+/**
+ * Window-title PII redactor for the T8d activity tracker.
+ *
+ * Stripped when `ACTIVITY_REDACT_TITLES` is "1" or unset (default on):
+ *  - Email addresses          → [redacted-email]
+ *  - Phone numbers (e.164 / 10-digit US)  → [redacted-phone]
+ *  - Credit-card-like digit runs (13–19 contiguous digits, optional separators) → [redacted-cc]
+ *
+ * Redaction is applied in the reporting layer before results leave the
+ * process. The raw title stays in the database so the user can disable
+ * redaction retroactively.
+ */
+const EMAIL = /[\w.!#$%&'*+/=?^`{|}~-]+@[\w-]+(?:\.[\w-]+)+/g;
+// Credit-card-like digit runs. Checked BEFORE phone numbers because a 16-digit
+// PAN would otherwise be partially matched by the phone regex.
+const CC_LIKE = /(?:\d[ -]?){13,19}/g;
+// Phone: e.164 (+ followed by 7-15 digits), or 10-digit US formats with an
+// optional +1 country code and separators.
+const PHONE = /(?<!\d)(?:\+\d{7,15}|(?:\+1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4})(?!\d)/g;
+export function resolveRedactorConfigFromEnv(env = process.env) {
+    const raw = env.ACTIVITY_REDACT_TITLES;
+    if (raw === undefined)
+        return { enabled: true };
+    return { enabled: raw === "1" || raw.toLowerCase() === "true" };
+}
+export function redactWindowTitle(title, config) {
+    if (title === null || title === undefined)
+        return null;
+    if (!config.enabled)
+        return title;
+    let out = title;
+    out = out.replace(CC_LIKE, (match) => {
+        const digitCount = (match.match(/\d/g) ?? []).length;
+        return digitCount >= 13 && digitCount <= 19 ? "[redacted-cc]" : match;
+    });
+    out = out.replace(EMAIL, "[redacted-email]");
+    out = out.replace(PHONE, "[redacted-phone]");
+    return out;
+}

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

@@ -0,0 +1,11 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import { LifeOpsScreenContextSampler } from "../lifeops/screen-context.js";
+export { resolveOwnerEntityId } from "@elizaos/agent/runtime/owner-entity";
+import type { ActivityProfile, FiredActionsLog } from "./types.js";
+export declare function setScreenContextSamplerForTesting(sampler: LifeOpsScreenContextSampler | null): void;
+export declare function buildActivityProfile(runtime: IAgentRuntime, ownerEntityId: string, timezone?: string, now?: Date): Promise<ActivityProfile>;
+export declare function refreshCurrentState(runtime: IAgentRuntime, ownerEntityId: string, profile: ActivityProfile, now?: Date): Promise<ActivityProfile>;
+export { readProfileFromMetadata } from "./profile-metadata.js";
+export declare function readFiredLogFromMetadata(metadata: Record<string, unknown> | null, todayDateStr: string): FiredActionsLog | null;
+export declare function profileNeedsRebuild(profile: ActivityProfile | null, now: Date): boolean;
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/activity-profile/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAQ,MAAM,eAAe,CAAC;AAIzD,OAAO,EACL,2BAA2B,EAE5B,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAU3E,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EAChB,MAAM,YAAY,CAAC;AAiBpB,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,2BAA2B,GAAG,IAAI,GAC1C,IAAI,CAEN;AAqFD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,aAAa,EACtB,aAAa,EAAE,MAAM,EACrB,QAAQ,CAAC,EAAE,MAAM,EACjB,GAAG,CAAC,EAAE,IAAI,GACT,OAAO,CAAC,eAAe,CAAC,CAsF1B;AAID,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,aAAa,EACtB,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,eAAe,EACxB,GAAG,CAAC,EAAE,IAAI,GACT,OAAO,CAAC,eAAe,CAAC,CAgF1B;AAMD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EACxC,YAAY,EAAE,MAAM,GACnB,eAAe,GAAG,IAAI,CAOxB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,eAAe,GAAG,IAAI,EAC/B,GAAG,EAAE,IAAI,GACR,OAAO,CAGT"}