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

package/apps/app-lifeops/src/actions/x-read.js

@@ -0,0 +1,367 @@
+import { ModelType, parseJSONObjectFromText, parseKeyValueXml, } from "@elizaos/core";
+import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
+import { hasLifeOpsAccess, messageText } from "./lifeops-google-helpers.js";
+import { recentConversationTexts as collectRecentConversationTexts } from "./life-recent-context.js";
+function normalizeSubaction(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "read_dms" || normalized === "dms")
+        return "read_dms";
+    if (normalized === "read_feed" || normalized === "feed")
+        return "read_feed";
+    if (normalized === "search")
+        return "search";
+    return null;
+}
+function normalizeFeedType(value) {
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "home_timeline" || normalized === "home" || normalized === "timeline") {
+            return "home_timeline";
+        }
+        if (normalized === "mentions")
+            return "mentions";
+        if (normalized === "search")
+            return "search";
+    }
+    return "home_timeline";
+}
+function normalizeOptionalFeedType(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return undefined;
+    }
+    return normalizeFeedType(value);
+}
+function normalizeLimit(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return undefined;
+    }
+    return Math.min(100, Math.floor(value));
+}
+function normalizeShouldAct(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true") {
+            return true;
+        }
+        if (normalized === "false") {
+            return false;
+        }
+    }
+    return null;
+}
+function normalizePlannerResponse(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+async function resolveXReadPlanWithLlm(args) {
+    const recentConversation = (await collectRecentConversationTexts({
+        runtime: args.runtime,
+        message: args.message,
+        state: args.state,
+        limit: 8,
+    })).join("\n");
+    const currentMessage = messageText(args.message).trim();
+    const prompt = [
+        "Plan the X read action for this request.",
+        "The user may speak in any language.",
+        "Use the current request plus recent conversation context.",
+        "Return a JSON object with exactly these fields:",
+        "  subaction: one of read_dms, read_feed, search, or null",
+        "  feedType: one of home_timeline or mentions when subaction is read_feed, otherwise null",
+        "  query: short search query when subaction is search, otherwise empty or null",
+        "  limit: optional integer 1-100 when the user explicitly requests an amount",
+        "  shouldAct: boolean",
+        "  response: short natural-language reply when shouldAct is false or clarification is needed",
+        "",
+        "Use read_dms for direct messages or inbox reads.",
+        "Use read_feed for the timeline or mentions feed.",
+        "Use search only when the user is explicitly asking to find posts by keyword, phrase, author, or topic.",
+        "Set feedType=mentions when the user asks for mentions; otherwise use home_timeline for feed reads.",
+        "Set shouldAct=false when the user is vague or only asks for general X help.",
+        "",
+        "Examples:",
+        '  "check my X DMs" -> {"subaction":"read_dms","feedType":null,"query":null,"limit":null,"shouldAct":true,"response":null}',
+        '  "show me my mentions" -> {"subaction":"read_feed","feedType":"mentions","query":null,"limit":null,"shouldAct":true,"response":null}',
+        '  "search X for Milady" -> {"subaction":"search","feedType":null,"query":"Milady","limit":null,"shouldAct":true,"response":null}',
+        '  "help me with X" -> {"subaction":null,"feedType":null,"query":null,"limit":null,"shouldAct":false,"response":"Do you want me to read your X DMs, timeline, mentions, or run a search?"}',
+        "",
+        "Return ONLY valid JSON.",
+        `Current request: ${JSON.stringify(currentMessage)}`,
+        `Resolved intent: ${JSON.stringify(args.intent)}`,
+        `Recent conversation: ${JSON.stringify(recentConversation)}`,
+    ].join("\n");
+    try {
+        const result = await args.runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+        });
+        const rawResponse = typeof result === "string" ? result : "";
+        const parsed = parseKeyValueXml(rawResponse) ??
+            parseJSONObjectFromText(rawResponse);
+        if (!parsed) {
+            return {
+                subaction: null,
+                shouldAct: null,
+            };
+        }
+        return {
+            subaction: normalizeSubaction(parsed.subaction),
+            query: typeof parsed.query === "string" && parsed.query.trim().length > 0
+                ? parsed.query.trim()
+                : undefined,
+            feedType: normalizeOptionalFeedType(parsed.feedType),
+            limit: normalizeLimit(parsed.limit),
+            shouldAct: normalizeShouldAct(parsed.shouldAct),
+            response: normalizePlannerResponse(parsed.response),
+        };
+    }
+    catch (error) {
+        args.runtime.logger?.warn?.({
+            src: "action:x-read",
+            error: error instanceof Error ? error.message : String(error),
+        }, "X read planning model call failed");
+        return {
+            subaction: null,
+            shouldAct: null,
+        };
+    }
+}
+function summarizeDms(dms) {
+    if (dms.length === 0)
+        return "No X DMs found.";
+    const preview = dms
+        .slice(0, 10)
+        .map((dm) => {
+        const who = dm.senderHandle ? `@${dm.senderHandle}` : dm.senderId || "unknown";
+        return `- ${who}: ${dm.text}`;
+    })
+        .join("\n");
+    return `X DMs (${dms.length}):\n${preview}`;
+}
+function summarizeFeedItems(items, feedType) {
+    if (items.length === 0)
+        return `No items in X ${feedType}.`;
+    const preview = items
+        .slice(0, 10)
+        .map((item) => {
+        const who = item.authorHandle ? `@${item.authorHandle}` : item.authorId || "unknown";
+        return `- ${who}: ${item.text}`;
+    })
+        .join("\n");
+    return `X ${feedType} (${items.length}):\n${preview}`;
+}
+export const xReadAction = {
+    name: "X_READ",
+    similes: ["READ_X", "READ_TWITTER", "X_DMS", "X_FEED", "X_SEARCH"],
+    description: "Read X/Twitter DMs, the home timeline or mentions feed, or run a recent search. " +
+        "Use this for retrieving content from X (not posting).",
+    validate: async (runtime, message) => {
+        if (!(await hasLifeOpsAccess(runtime, message)))
+            return false;
+        const service = new LifeOpsService(runtime);
+        try {
+            const status = await service.getXConnectorStatus();
+            return Boolean(status.connected);
+        }
+        catch {
+            return false;
+        }
+    },
+    handler: async (runtime, message, state, options, callback) => {
+        if (!(await hasLifeOpsAccess(runtime, message))) {
+            return {
+                text: "",
+                success: false,
+                data: { error: "PERMISSION_DENIED" },
+            };
+        }
+        const params = (options?.parameters ?? {});
+        const intent = (params.intent ?? messageText(message) ?? "").trim();
+        const explicitSubaction = normalizeSubaction(params.subaction);
+        const llmPlan = await resolveXReadPlanWithLlm({
+            runtime,
+            message,
+            state,
+            intent,
+        });
+        const subaction = explicitSubaction ?? llmPlan.subaction;
+        const feedType = normalizeFeedType(params.feedType ?? llmPlan.feedType);
+        const limit = normalizeLimit(params.limit ?? llmPlan.limit);
+        const query = typeof params.query === "string" && params.query.trim().length > 0
+            ? params.query.trim()
+            : llmPlan.query ?? "";
+        const service = new LifeOpsService(runtime);
+        const respond = async (payload) => {
+            await callback?.({
+                text: payload.text ?? "",
+                source: "action",
+                action: "X_READ",
+            });
+            return payload;
+        };
+        if (llmPlan.shouldAct === false &&
+            !explicitSubaction &&
+            !params.query &&
+            !params.feedType &&
+            params.limit === undefined) {
+            return respond({
+                success: true,
+                text: llmPlan.response ??
+                    "Do you want me to read your X DMs, timeline, mentions, or run a search?",
+                data: { noop: true },
+            });
+        }
+        if (!subaction) {
+            return respond({
+                success: false,
+                text: llmPlan.response ??
+                    "Do you want me to read your X DMs, timeline, mentions, or run a search?",
+                data: { error: "MISSING_SUBACTION" },
+            });
+        }
+        try {
+            if (subaction === "read_dms") {
+                const syncResult = await service.syncXDms({ limit });
+                const dms = await service.getXDms({ limit });
+                return respond({
+                    success: true,
+                    text: summarizeDms(dms),
+                    data: {
+                        subaction,
+                        synced: syncResult.synced,
+                        items: dms,
+                    },
+                });
+            }
+            if (subaction === "search") {
+                if (query.length === 0) {
+                    return respond({
+                        success: false,
+                        text: "Please provide a search query.",
+                        data: { subaction, error: "MISSING_QUERY" },
+                    });
+                }
+                const results = await service.searchXPosts(query, { limit });
+                return respond({
+                    success: true,
+                    text: summarizeFeedItems(results, "search"),
+                    data: {
+                        subaction,
+                        query,
+                        items: results,
+                    },
+                });
+            }
+            const effectiveFeedType = feedType === "search" ? "home_timeline" : feedType;
+            const syncResult = await service.syncXFeed(effectiveFeedType, { limit });
+            const items = await service.getXFeedItems(effectiveFeedType, { limit });
+            return respond({
+                success: true,
+                text: summarizeFeedItems(items, effectiveFeedType),
+                data: {
+                    subaction,
+                    feedType: effectiveFeedType,
+                    synced: syncResult.synced,
+                    items,
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof LifeOpsServiceError) {
+                return respond({
+                    success: false,
+                    text: error.message,
+                    data: {
+                        subaction,
+                        error: "X_READ_FAILED",
+                        status: error.status,
+                    },
+                });
+            }
+            throw error;
+        }
+    },
+    parameters: [
+        {
+            name: "subaction",
+            description: "X read operation. read_dms for direct messages, read_feed for timeline/mentions, search for recent tweet search.",
+            required: false,
+            schema: {
+                type: "string",
+                enum: ["read_dms", "read_feed", "search"],
+            },
+        },
+        {
+            name: "intent",
+            description: 'Free-text description of the request, e.g. "check my X DMs", "show my mentions", "search X for elizaOS".',
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "query",
+            description: "Search query string for the search subaction.",
+            required: false,
+            schema: { type: "string" },
+        },
+        {
+            name: "feedType",
+            description: "Feed to read for read_feed. One of home_timeline (default), mentions, or search.",
+            required: false,
+            schema: {
+                type: "string",
+                enum: ["home_timeline", "mentions", "search"],
+            },
+        },
+        {
+            name: "limit",
+            description: "Max items to return (1-100).",
+            required: false,
+            schema: { type: "number" },
+        },
+    ],
+    examples: [
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "Check my X DMs." },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "X DMs (2):\n- @alice: hey!\n- @bob: see you tomorrow",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: "What are my recent X mentions?" },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "X mentions (3):\n- @carol: great post!",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: { text: 'Search X for "elizaOS".' },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "X search (5):\n- @dev: elizaOS is shipping fast",
+                },
+            },
+        ],
+    ],
+};

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

@@ -0,0 +1,28 @@
+/**
+ * Repository helpers for T8d `life_activity_events`.
+ *
+ * Writes are append-only (one row per `activate` / `deactivate`). Reads
+ * derive per-app dwell time by pairing consecutive `activate` events (the
+ * collector always emits exactly one activate per focused app, and emits a
+ * synthetic activate on startup so the first window has an anchor).
+ */
+import type { IAgentRuntime } from "@elizaos/core";
+export interface ActivityEventRow {
+    id: string;
+    agentId: string;
+    observedAt: string;
+    eventKind: "activate" | "deactivate";
+    bundleId: string;
+    appName: string;
+    windowTitle: string | null;
+}
+export declare function insertActivityEvent(runtime: IAgentRuntime, event: {
+    agentId: string;
+    observedAt: string;
+    eventKind: "activate" | "deactivate";
+    bundleId: string;
+    appName: string;
+    windowTitle: string | null;
+}): Promise<string>;
+export declare function listActivityEvents(runtime: IAgentRuntime, agentId: string, sinceIso: string): Promise<ActivityEventRow[]>;
+//# sourceMappingURL=activity-tracker-repo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activity-tracker-repo.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/activity-profile/activity-tracker-repo.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAQnD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,UAAU,GAAG,YAAY,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAyBD,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE;IACL,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,UAAU,GAAG,YAAY,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GACA,OAAO,CAAC,MAAM,CAAC,CAqBjB;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAY7B"}

package/apps/app-lifeops/src/activity-profile/activity-tracker-repo.js

@@ -0,0 +1,62 @@
+/**
+ * Repository helpers for T8d `life_activity_events`.
+ *
+ * Writes are append-only (one row per `activate` / `deactivate`). Reads
+ * derive per-app dwell time by pairing consecutive `activate` events (the
+ * collector always emits exactly one activate per focused app, and emits a
+ * synthetic activate on startup so the first window has an anchor).
+ */
+import crypto from "node:crypto";
+import { executeRawSql, sqlQuote, sqlText, toText, } from "../lifeops/sql.js";
+function mapRow(row) {
+    const kindRaw = toText(row.event_kind, "");
+    if (kindRaw !== "activate" && kindRaw !== "deactivate")
+        return null;
+    const id = toText(row.id, "");
+    const agentId = toText(row.agent_id, "");
+    const observedAt = toText(row.observed_at, "");
+    const bundleId = toText(row.bundle_id, "");
+    const appName = toText(row.app_name, "");
+    if (!id || !agentId || !observedAt || !bundleId)
+        return null;
+    const windowTitleRaw = row.window_title;
+    const windowTitle = typeof windowTitleRaw === "string" ? windowTitleRaw : null;
+    return {
+        id,
+        agentId,
+        observedAt,
+        eventKind: kindRaw,
+        bundleId,
+        appName,
+        windowTitle,
+    };
+}
+export async function insertActivityEvent(runtime, event) {
+    const id = crypto.randomUUID();
+    const createdAt = new Date().toISOString();
+    await executeRawSql(runtime, `INSERT INTO life_activity_events (
+      id, agent_id, observed_at, event_kind, bundle_id, app_name,
+      window_title, metadata_json, created_at
+    ) VALUES (
+      ${sqlQuote(id)},
+      ${sqlQuote(event.agentId)},
+      ${sqlQuote(event.observedAt)},
+      ${sqlQuote(event.eventKind)},
+      ${sqlQuote(event.bundleId)},
+      ${sqlQuote(event.appName)},
+      ${sqlText(event.windowTitle)},
+      ${sqlQuote("{}")},
+      ${sqlQuote(createdAt)}
+    )`);
+    return id;
+}
+export async function listActivityEvents(runtime, agentId, sinceIso) {
+    const rows = await executeRawSql(runtime, `SELECT id, agent_id, observed_at, event_kind, bundle_id, app_name, window_title
+     FROM life_activity_events
+     WHERE agent_id = ${sqlQuote(agentId)}
+       AND observed_at >= ${sqlQuote(sinceIso)}
+     ORDER BY observed_at ASC`);
+    return rows
+        .map(mapRow)
+        .filter((row) => row !== null);
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Reporting layer for T8d activity tracker.
+ *
+ * Converts the append-only `life_activity_events` stream into per-app dwell
+ * summaries. Window titles are passed through {@link redactWindowTitle} when
+ * ACTIVITY_REDACT_TITLES is enabled.
+ *
+ * Duration model:
+ *   - Events are sorted ascending by observed_at.
+ *   - Each `activate` anchors a dwell interval; the interval ends at the
+ *     timestamp of the NEXT event (activate or deactivate), or at `now`
+ *     if no following event exists.
+ *   - `deactivate` events do not anchor a new interval.
+ *   - Intervals are clipped to the report window [since, until].
+ */
+import type { IAgentRuntime } from "@elizaos/core";
+import { type RedactorConfig } from "./redactor.js";
+export interface ActivityAppBreakdown {
+    bundleId: string;
+    appName: string;
+    totalMs: number;
+    sampleWindowTitles: string[];
+}
+export interface ActivityReport {
+    sinceMs: number;
+    untilMs: number;
+    totalMs: number;
+    apps: ActivityAppBreakdown[];
+}
+export interface ActivityReportOptions {
+    windowMs: number;
+    nowMs?: number;
+    limit?: number;
+    redactor?: RedactorConfig;
+}
+export declare function getActivityReport(runtime: IAgentRuntime, agentId: string, options: ActivityReportOptions): Promise<ActivityReport>;
+export declare function getTimeOnApp(runtime: IAgentRuntime, agentId: string, appNameOrBundleId: string, options: {
+    windowMs: number;
+    nowMs?: number;
+    redactor?: RedactorConfig;
+}): Promise<{
+    totalMs: number;
+    matchedBy: "bundleId" | "appName" | "none";
+}>;
+//# sourceMappingURL=activity-tracker-reporting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activity-tracker-reporting.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/activity-profile/activity-tracker-reporting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAKnD,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,oBAAoB,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAwFD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,cAAc,CAAC,CAYzB;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,EACzB,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,cAAc,CAAA;CAAE,GACvE,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAA;CAAE,CAAC,CAoB1E"}

package/apps/app-lifeops/src/activity-profile/activity-tracker-reporting.js

@@ -0,0 +1,112 @@
+/**
+ * Reporting layer for T8d activity tracker.
+ *
+ * Converts the append-only `life_activity_events` stream into per-app dwell
+ * summaries. Window titles are passed through {@link redactWindowTitle} when
+ * ACTIVITY_REDACT_TITLES is enabled.
+ *
+ * Duration model:
+ *   - Events are sorted ascending by observed_at.
+ *   - Each `activate` anchors a dwell interval; the interval ends at the
+ *     timestamp of the NEXT event (activate or deactivate), or at `now`
+ *     if no following event exists.
+ *   - `deactivate` events do not anchor a new interval.
+ *   - Intervals are clipped to the report window [since, until].
+ */
+import { listActivityEvents, } from "./activity-tracker-repo.js";
+import { redactWindowTitle, resolveRedactorConfigFromEnv, } from "./redactor.js";
+function intervalsFromEvents(events, sinceMs, untilMs) {
+    const intervals = [];
+    const timestamps = events.map((e) => Date.parse(e.observedAt));
+    for (let i = 0; i < events.length; i++) {
+        const ev = events[i];
+        if (ev.eventKind !== "activate")
+            continue;
+        const startMs = timestamps[i];
+        if (!Number.isFinite(startMs))
+            continue;
+        const nextTs = i + 1 < events.length ? timestamps[i + 1] : untilMs;
+        const endMs = Number.isFinite(nextTs) ? nextTs : untilMs;
+        const clippedStart = Math.max(startMs, sinceMs);
+        const clippedEnd = Math.min(endMs, untilMs);
+        if (clippedEnd <= clippedStart)
+            continue;
+        intervals.push({
+            bundleId: ev.bundleId,
+            appName: ev.appName,
+            startMs: clippedStart,
+            endMs: clippedEnd,
+            windowTitle: ev.windowTitle,
+        });
+    }
+    return intervals;
+}
+function aggregateByApp(intervals, redactor, limit) {
+    const byKey = new Map();
+    let totalMs = 0;
+    for (const it of intervals) {
+        const key = it.bundleId || it.appName;
+        const durationMs = it.endMs - it.startMs;
+        totalMs += durationMs;
+        let bucket = byKey.get(key);
+        if (!bucket) {
+            bucket = {
+                bundleId: it.bundleId,
+                appName: it.appName,
+                totalMs: 0,
+                titles: new Set(),
+            };
+            byKey.set(key, bucket);
+        }
+        bucket.totalMs += durationMs;
+        const redacted = redactWindowTitle(it.windowTitle, redactor);
+        if (redacted !== null && redacted.length > 0 && bucket.titles.size < 5) {
+            bucket.titles.add(redacted);
+        }
+    }
+    const apps = [...byKey.values()]
+        .map((b) => ({
+        bundleId: b.bundleId,
+        appName: b.appName,
+        totalMs: b.totalMs,
+        sampleWindowTitles: [...b.titles],
+    }))
+        .sort((a, b) => b.totalMs - a.totalMs);
+    return {
+        apps: limit ? apps.slice(0, limit) : apps,
+        totalMs,
+    };
+}
+export async function getActivityReport(runtime, agentId, options) {
+    const nowMs = options.nowMs ?? Date.now();
+    const sinceMs = nowMs - options.windowMs;
+    const redactor = options.redactor ?? resolveRedactorConfigFromEnv();
+    const events = await listActivityEvents(runtime, agentId, new Date(sinceMs).toISOString());
+    const intervals = intervalsFromEvents(events, sinceMs, nowMs);
+    const { apps, totalMs } = aggregateByApp(intervals, redactor, options.limit);
+    return { sinceMs, untilMs: nowMs, totalMs, apps };
+}
+export async function getTimeOnApp(runtime, agentId, appNameOrBundleId, options) {
+    const needle = appNameOrBundleId.trim().toLowerCase();
+    if (!needle)
+        return { totalMs: 0, matchedBy: "none" };
+    const report = await getActivityReport(runtime, agentId, {
+        windowMs: options.windowMs,
+        nowMs: options.nowMs,
+        redactor: options.redactor,
+    });
+    let totalMs = 0;
+    let matchedBy = "none";
+    for (const app of report.apps) {
+        if (app.bundleId.toLowerCase() === needle) {
+            totalMs += app.totalMs;
+            matchedBy = "bundleId";
+        }
+        else if (app.appName.toLowerCase() === needle) {
+            totalMs += app.totalMs;
+            if (matchedBy === "none")
+                matchedBy = "appName";
+        }
+    }
+    return { totalMs, matchedBy };
+}

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

@@ -0,0 +1,26 @@
+/**
+ * T8d — Activity tracker service.
+ *
+ * Starts the macOS Swift collector (when available) and writes focus events
+ * to `life_activity_events`. On non-Darwin platforms the service is a no-op
+ * that logs "no events" once at startup and returns empty reports via the
+ * action layer.
+ *
+ * The service does not mutate any cached profile state; reporting runs on
+ * demand via {@link getActivityReport}.
+ */
+import { type IAgentRuntime, Service } from "@elizaos/core";
+export type ActivityTrackerMode = "running" | "disabled-non-darwin" | "failed";
+export declare class ActivityTrackerService extends Service {
+    static readonly serviceType = "activity_tracker";
+    capabilityDescription: string;
+    private handle;
+    private mode;
+    private writeFailures;
+    static start(runtime: IAgentRuntime): Promise<ActivityTrackerService>;
+    stop(): Promise<void>;
+    getMode(): ActivityTrackerMode;
+    private startCollector;
+    private persistEvent;
+}
+//# sourceMappingURL=activity-tracker-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activity-tracker-service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/activity-profile/activity-tracker-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAE,OAAO,EAAU,MAAM,eAAe,CAAC;AASpE,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,qBAAqB,GAAG,QAAQ,CAAC;AAE/E,qBAAa,sBAAuB,SAAQ,OAAO;IACjD,gBAAyB,WAAW,sBAAsB;IAEjD,qBAAqB,SAC0F;IAExH,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,IAAI,CAA8C;IAC1D,OAAO,CAAC,aAAa,CAAK;WAEJ,KAAK,CACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,sBAAsB,CAAC;IAMnB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAOpC,OAAO,IAAI,mBAAmB;YAIhB,cAAc;YAsCd,YAAY;CAyB3B"}