@elizaos/agent 0.25.9 → 2.0.0-alpha.151

package/apps/app-lifeops/src/lifeops/runtime.d.ts

@@ -0,0 +1,14 @@
+import type { IAgentRuntime, UUID } from "@elizaos/core";
+export declare const LIFEOPS_TASK_NAME: "LIFEOPS_SCHEDULER";
+export declare const LIFEOPS_TASK_TAGS: readonly ["queue", "repeat", "lifeops"];
+/** Base interval for the LifeOps scheduler polling loop. */
+export declare const LIFEOPS_TASK_INTERVAL_MS = 60000;
+/** Maximum deterministic jitter added per agent to avoid synchronized polls. */
+export declare const LIFEOPS_TASK_JITTER_MS = 10000;
+export declare function resolveLifeOpsTaskIntervalMs(agentId: UUID): number;
+export declare function executeLifeOpsSchedulerTask(runtime: IAgentRuntime, options?: Record<string, unknown>): Promise<{
+    nextInterval: number;
+}>;
+export declare function registerLifeOpsTaskWorker(runtime: IAgentRuntime): void;
+export declare function ensureLifeOpsSchedulerTask(runtime: IAgentRuntime): Promise<UUID>;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAsB,IAAI,EAAE,MAAM,eAAe,CAAC;AAK7E,eAAO,MAAM,iBAAiB,EAAG,mBAA4B,CAAC;AAC9D,eAAO,MAAM,iBAAiB,yCAA0C,CAAC;AACzE,4DAA4D;AAC5D,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAC/C,gFAAgF;AAChF,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAqC7C,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,IAAI,GAAG,MAAM,CAMlE;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACpC,OAAO,CAAC;IACT,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC,CAQD;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAUtE;AA0CD,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CAkCf"}

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

@@ -0,0 +1,120 @@
+import { logger, stringToUuid } from "@elizaos/core";
+import { LifeOpsService } from "./service.js";
+import { readTwilioCredentialsFromEnv } from "./twilio.js";
+export const LIFEOPS_TASK_NAME = "LIFEOPS_SCHEDULER";
+export const LIFEOPS_TASK_TAGS = ["queue", "repeat", "lifeops"];
+/** Base interval for the LifeOps scheduler polling loop. */
+export const LIFEOPS_TASK_INTERVAL_MS = 60_000;
+/** Maximum deterministic jitter added per agent to avoid synchronized polls. */
+export const LIFEOPS_TASK_JITTER_MS = 10_000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isLifeOpsSchedulerTask(task) {
+    const metadata = isRecord(task.metadata) ? task.metadata : null;
+    const scheduler = metadata?.lifeopsScheduler;
+    return (task.name === LIFEOPS_TASK_NAME &&
+        isRecord(scheduler) &&
+        scheduler.kind === "runtime_runner");
+}
+function buildSchedulerMetadata(agentId, current = null) {
+    const intervalMs = resolveLifeOpsTaskIntervalMs(agentId);
+    return {
+        ...(current ?? {}),
+        updateInterval: intervalMs,
+        baseInterval: intervalMs,
+        blocking: true,
+        lifeopsScheduler: {
+            kind: "runtime_runner",
+            version: 1,
+        },
+    };
+}
+export function resolveLifeOpsTaskIntervalMs(agentId) {
+    let hash = 0;
+    for (let index = 0; index < agentId.length; index++) {
+        hash = (hash * 31 + agentId.charCodeAt(index)) >>> 0;
+    }
+    return LIFEOPS_TASK_INTERVAL_MS + (hash % (LIFEOPS_TASK_JITTER_MS + 1));
+}
+export async function executeLifeOpsSchedulerTask(runtime, options = {}) {
+    const service = new LifeOpsService(runtime);
+    await service.processScheduledWork({
+        now: typeof options.now === "string" ? options.now : undefined,
+    });
+    return {
+        nextInterval: resolveLifeOpsTaskIntervalMs(runtime.agentId),
+    };
+}
+export function registerLifeOpsTaskWorker(runtime) {
+    if (runtime.getTaskWorker(LIFEOPS_TASK_NAME)) {
+        return;
+    }
+    runtime.registerTaskWorker({
+        name: LIFEOPS_TASK_NAME,
+        shouldRun: async () => true,
+        execute: async (rt, options) => executeLifeOpsSchedulerTask(rt, isRecord(options) ? options : {}),
+    });
+}
+/**
+ * Wait for the database adapter to be ready before running task queries.
+ * PGlite may still be initializing when plugin init fires; a short probe
+ * avoids a noisy retry cycle in plugin-sql.
+ */
+async function waitForDbReady(runtime, maxAttempts = 3, delayMs = 500) {
+    for (let i = 0; i < maxAttempts; i++) {
+        try {
+            // Light-weight probe: fetch tasks with a filter that should match nothing.
+            await runtime.getTasks({
+                agentIds: [runtime.agentId],
+                tags: ["__db_ready_probe__"],
+            });
+            return;
+        }
+        catch {
+            if (i < maxAttempts - 1) {
+                await new Promise((r) => setTimeout(r, delayMs));
+            }
+        }
+    }
+    // If still failing, let the caller proceed — the original retry logic in
+    // plugin-sql will handle it, we just reduced the likelihood of hitting it.
+}
+let credentialStatusLogged = false;
+function logCredentialStatus() {
+    if (credentialStatusLogged)
+        return;
+    credentialStatusLogged = true;
+    const hasTwilio = Boolean(readTwilioCredentialsFromEnv());
+    if (!hasTwilio) {
+        logger.info("[lifeops] Twilio credentials not configured — SMS and voice reminders will be blocked. Set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_PHONE_NUMBER to enable.");
+    }
+}
+export async function ensureLifeOpsSchedulerTask(runtime) {
+    await waitForDbReady(runtime);
+    logCredentialStatus();
+    const tasks = await runtime.getTasks({
+        agentIds: [runtime.agentId],
+        tags: [...LIFEOPS_TASK_TAGS],
+    });
+    const existing = tasks.find(isLifeOpsSchedulerTask);
+    const metadata = buildSchedulerMetadata(runtime.agentId, isRecord(existing?.metadata) ? existing.metadata : null);
+    if (existing?.id) {
+        await runtime.updateTask(existing.id, {
+            description: "Process life-ops reminders and scheduled workflows",
+            metadata,
+        });
+        return existing.id;
+    }
+    const autonomy = runtime.getService("AUTONOMY");
+    const roomId = autonomy?.getAutonomousRoomId?.() ??
+        stringToUuid(`lifeops-scheduler-room-${runtime.agentId}`);
+    return runtime.createTask({
+        name: LIFEOPS_TASK_NAME,
+        description: "Process life-ops reminders and scheduled workflows",
+        roomId,
+        tags: [...LIFEOPS_TASK_TAGS],
+        metadata,
+        dueAt: Date.now(),
+    });
+}

package/apps/app-lifeops/src/lifeops/screen-context.d.ts

@@ -0,0 +1,52 @@
+export type LifeOpsScreenFocus = "work" | "leisure" | "transition" | "idle" | "unknown";
+export type LifeOpsScreenSource = "disabled" | "browser-capture" | "vision";
+export interface LifeOpsScreenContextSummary {
+    sampledAtMs: number;
+    source: LifeOpsScreenSource;
+    available: boolean;
+    throttled: boolean;
+    stale: boolean;
+    busy: boolean;
+    framePath: string;
+    capturedAtMs: number | null;
+    width: number | null;
+    height: number | null;
+    byteLength: number;
+    averageLuma: number | null;
+    lumaStdDev: number | null;
+    ocrAvailable: boolean;
+    ocrText: string | null;
+    focus: LifeOpsScreenFocus;
+    contextTags: string[];
+    cues: string[];
+    confidence: number;
+    disabledReason: string | null;
+}
+export interface LifeOpsScreenOcrAdapter {
+    extractText(imageBuffer: Buffer): Promise<string | null>;
+}
+export interface LifeOpsScreenContextSamplerOptions {
+    framePath?: string;
+    minSampleIntervalMs?: number;
+    maxFrameAgeMs?: number;
+    ocr?: LifeOpsScreenOcrAdapter | null;
+}
+export declare function analyzeLifeOpsScreenBuffer(args: {
+    framePath: string;
+    frameBytes: Buffer;
+    ocrText: string | null;
+    capturedAtMs: number;
+    sampledAtMs: number;
+    stale: boolean;
+}): Promise<LifeOpsScreenContextSummary>;
+export declare class LifeOpsScreenContextSampler {
+    private readonly options;
+    private lastSampleAtMs;
+    private lastSummary;
+    constructor(options?: LifeOpsScreenContextSamplerOptions);
+    shouldSample(nowMs?: number): boolean;
+    getLastSummary(): LifeOpsScreenContextSummary | null;
+    sample(nowMs?: number): Promise<LifeOpsScreenContextSummary>;
+}
+export declare function tryCreateVisionOcrAdapter(): Promise<LifeOpsScreenOcrAdapter | null>;
+//# sourceMappingURL=screen-context.d.ts.map

package/apps/app-lifeops/src/lifeops/screen-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-context.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/screen-context.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,SAAS,GACT,YAAY,GACZ,MAAM,GACN,SAAS,CAAC;AAEd,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,iBAAiB,GAAG,QAAQ,CAAC;AAE5E,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,uBAAuB;IACtC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,kCAAkC;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAAC;CACtC;AA0OD,wBAAsB,0BAA0B,CAAC,IAAI,EAAE;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;CAChB,GAAG,OAAO,CAAC,2BAA2B,CAAC,CA8BvC;AAED,qBAAa,2BAA2B;IAKpC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,WAAW,CAA4C;gBAG5C,OAAO,GAAE,kCAAuC;IAGnE,YAAY,CAAC,KAAK,SAAa,GAAG,OAAO;IAQzC,cAAc,IAAI,2BAA2B,GAAG,IAAI;IAI9C,MAAM,CAAC,KAAK,SAAa,GAAG,OAAO,CAAC,2BAA2B,CAAC;CAoDvE;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAuCzF"}

package/apps/app-lifeops/src/lifeops/screen-context.js

@@ -0,0 +1,332 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import fs from "node:fs";
+import sharp from "sharp";
+import { FRAME_FILE } from "@elizaos/agent/services/browser-capture";
+const DEFAULT_MIN_SAMPLE_INTERVAL_MS = 5 * 60_000;
+const DEFAULT_MAX_FRAME_AGE_MS = 30 * 60_000;
+const HEURISTIC_TEXT_LIMIT = 1_024;
+const WORK_KEYWORDS = [
+    "inbox",
+    "email",
+    "calendar",
+    "meeting",
+    "docs",
+    "document",
+    "spreadsheet",
+    "sheet",
+    "slack",
+    "discord",
+    "github",
+    "pull request",
+    "jira",
+    "terminal",
+    "code",
+    "editor",
+    "notion",
+    "figma",
+];
+const LEISURE_KEYWORDS = [
+    "youtube",
+    "netflix",
+    "twitch",
+    "instagram",
+    "twitter",
+    "x.com",
+    "reddit",
+    "game",
+    "gaming",
+    "spotify",
+];
+const TRANSITION_KEYWORDS = [
+    "lock screen",
+    "login",
+    "sign in",
+    "password",
+    "desktop",
+    "wallpaper",
+    "home screen",
+    "launchpad",
+];
+function normalizeText(value) {
+    return (value ?? "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, HEURISTIC_TEXT_LIMIT);
+}
+function keywordMatches(text, keywords) {
+    const lower = text.toLowerCase();
+    return keywords.filter((keyword) => lower.includes(keyword));
+}
+async function analyzeImage(buffer) {
+    const image = sharp(buffer).rotate().greyscale().resize({
+        width: 160,
+        withoutEnlargement: true,
+        fit: "inside",
+    });
+    const { data, info } = await image
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const pixels = data;
+    let sum = 0;
+    let sumSquares = 0;
+    let dark = 0;
+    let bright = 0;
+    let edges = 0;
+    let comparisons = 0;
+    for (let index = 0; index < pixels.length; index += 1) {
+        const value = pixels[index] ?? 0;
+        sum += value;
+        sumSquares += value * value;
+        if (value < 32)
+            dark += 1;
+        if (value > 224)
+            bright += 1;
+        const left = pixels[index - 1];
+        if (left !== undefined) {
+            const diff = Math.abs(value - left);
+            if (diff > 28)
+                edges += 1;
+            comparisons += 1;
+        }
+    }
+    const count = Math.max(1, pixels.length);
+    const averageLuma = sum / count / 255;
+    const variance = sumSquares / count - (sum / count) ** 2;
+    const lumaStdDev = Math.sqrt(Math.max(0, variance)) / 255;
+    return {
+        width: info.width ?? 0,
+        height: info.height ?? 0,
+        averageLuma,
+        lumaStdDev,
+        darkRatio: dark / count,
+        brightRatio: bright / count,
+        edgeRatio: comparisons > 0 ? edges / comparisons : 0,
+    };
+}
+function inferFocusFromSignals(args) {
+    const normalizedText = normalizeText(args.text);
+    const workCues = keywordMatches(normalizedText, WORK_KEYWORDS);
+    const leisureCues = keywordMatches(normalizedText, LEISURE_KEYWORDS);
+    const transitionCues = keywordMatches(normalizedText, TRANSITION_KEYWORDS);
+    const cues = [...workCues, ...leisureCues, ...transitionCues];
+    const tags = new Set();
+    let focus = "unknown";
+    let confidence = 0.28;
+    if (workCues.length > 0) {
+        focus = "work";
+        confidence = 0.86;
+        tags.add("work");
+        tags.add("text-heavy");
+    }
+    else if (leisureCues.length > 0) {
+        focus = "leisure";
+        confidence = 0.84;
+        tags.add("leisure");
+        tags.add("screen-entertainment");
+    }
+    else if (transitionCues.length > 0) {
+        focus = "transition";
+        confidence = 0.78;
+        tags.add("transition");
+    }
+    if (focus === "unknown") {
+        if (args.stats.darkRatio > 0.92 && args.stats.lumaStdDev < 0.025) {
+            focus = "idle";
+            confidence = 0.72;
+            tags.add("idle");
+        }
+        else if (args.stats.brightRatio > 0.92 && args.stats.lumaStdDev < 0.025) {
+            focus = "transition";
+            confidence = 0.66;
+            tags.add("transition");
+        }
+        else if (args.stats.edgeRatio > 0.08 &&
+            args.stats.averageLuma > 0.18 &&
+            args.stats.averageLuma < 0.88) {
+            focus = "work";
+            confidence = 0.52;
+            tags.add("busy");
+            tags.add("text-or-ui-dense");
+        }
+    }
+    if (focus === "idle") {
+        tags.add("idle");
+    }
+    else if (focus === "unknown") {
+        tags.add("uncertain");
+    }
+    else {
+        tags.add("screen-active");
+    }
+    return {
+        focus,
+        contextTags: [...tags],
+        cues,
+        confidence,
+        busy: focus === "work" || focus === "transition",
+    };
+}
+async function readOcrText(ocr, frameBytes) {
+    if (!ocr) {
+        return null;
+    }
+    try {
+        const text = await ocr.extractText(frameBytes);
+        return normalizeText(text) || null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildDisabledSummary(args) {
+    return {
+        sampledAtMs: args.sampledAtMs,
+        source: "disabled",
+        available: false,
+        throttled: false,
+        stale: false,
+        busy: false,
+        framePath: args.framePath,
+        capturedAtMs: null,
+        width: null,
+        height: null,
+        byteLength: 0,
+        averageLuma: null,
+        lumaStdDev: null,
+        ocrAvailable: false,
+        ocrText: null,
+        focus: "unknown",
+        contextTags: ["disabled"],
+        cues: [],
+        confidence: 0,
+        disabledReason: args.disabledReason,
+    };
+}
+export async function analyzeLifeOpsScreenBuffer(args) {
+    const stats = await analyzeImage(args.frameBytes);
+    const inference = inferFocusFromSignals({
+        text: args.ocrText,
+        stats,
+    });
+    return {
+        sampledAtMs: args.sampledAtMs,
+        source: args.ocrText ? "vision" : "browser-capture",
+        available: !args.stale,
+        throttled: false,
+        stale: args.stale,
+        busy: !args.stale && inference.busy,
+        framePath: args.framePath,
+        capturedAtMs: args.capturedAtMs,
+        width: stats.width,
+        height: stats.height,
+        byteLength: args.frameBytes.byteLength,
+        averageLuma: stats.averageLuma,
+        lumaStdDev: stats.lumaStdDev,
+        ocrAvailable: Boolean(args.ocrText && args.ocrText.length > 0),
+        ocrText: normalizeText(args.ocrText) || null,
+        focus: args.stale ? "unknown" : inference.focus,
+        contextTags: args.stale ? ["stale-frame"] : inference.contextTags,
+        cues: args.stale ? [] : inference.cues,
+        confidence: args.stale ? 0.2 : inference.confidence,
+        disabledReason: args.stale
+            ? "The latest browser-capture frame is stale."
+            : null,
+    };
+}
+export class LifeOpsScreenContextSampler {
+    options;
+    lastSampleAtMs = 0;
+    lastSummary = null;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    shouldSample(nowMs = Date.now()) {
+        const minIntervalMs = this.options.minSampleIntervalMs ?? DEFAULT_MIN_SAMPLE_INTERVAL_MS;
+        return (this.lastSampleAtMs === 0 || nowMs - this.lastSampleAtMs >= minIntervalMs);
+    }
+    getLastSummary() {
+        return this.lastSummary;
+    }
+    async sample(nowMs = Date.now()) {
+        if (!this.shouldSample(nowMs) && this.lastSummary) {
+            return {
+                ...this.lastSummary,
+                throttled: true,
+                sampledAtMs: nowMs,
+            };
+        }
+        const framePath = this.options.framePath ?? FRAME_FILE;
+        const maxFrameAgeMs = this.options.maxFrameAgeMs ?? DEFAULT_MAX_FRAME_AGE_MS;
+        if (!fs.existsSync(framePath)) {
+            const summary = buildDisabledSummary({
+                sampledAtMs: nowMs,
+                framePath,
+                disabledReason: "No browser-capture frame is available.",
+            });
+            this.lastSampleAtMs = nowMs;
+            this.lastSummary = summary;
+            return summary;
+        }
+        try {
+            const stat = fs.statSync(framePath);
+            const stale = nowMs - stat.mtimeMs > maxFrameAgeMs;
+            const frameBytes = fs.readFileSync(framePath);
+            const ocrText = await readOcrText(this.options.ocr, frameBytes);
+            const summary = await analyzeLifeOpsScreenBuffer({
+                framePath,
+                frameBytes,
+                ocrText,
+                capturedAtMs: stat.mtimeMs,
+                sampledAtMs: nowMs,
+                stale,
+            });
+            this.lastSampleAtMs = nowMs;
+            this.lastSummary = summary;
+            return summary;
+        }
+        catch {
+            const summary = buildDisabledSummary({
+                sampledAtMs: nowMs,
+                framePath,
+                disabledReason: "Unable to read or analyze the browser-capture frame.",
+            });
+            this.lastSampleAtMs = nowMs;
+            this.lastSummary = summary;
+            return summary;
+        }
+    }
+}
+export async function tryCreateVisionOcrAdapter() {
+    const visionImportCandidates = [
+        "@elizaos/plugin-vision",
+        new URL("../../../../plugins/plugin-vision/typescript/src/ocr-service.ts", import.meta.url).href,
+    ];
+    for (const specifier of visionImportCandidates) {
+        try {
+            const mod = await import(__rewriteRelativeImportExtension(/* @vite-ignore */ specifier));
+            const OCRService = mod.OCRService;
+            if (!OCRService) {
+                continue;
+            }
+            const service = new OCRService();
+            if (typeof service.initialize === "function") {
+                await service.initialize();
+            }
+            return {
+                async extractText(imageBuffer) {
+                    const result = await service.extractText(imageBuffer);
+                    return normalizeText(result.fullText ?? result.text ?? null) || null;
+                },
+            };
+        }
+        catch { }
+    }
+    return null;
+}

package/apps/app-lifeops/src/lifeops/seed-routines.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Seed routine templates offered during first-run onboarding.
+ *
+ * These are data-only definitions — no hardcoded logic is tied to any
+ * specific routine.  The seeding flow creates standard task definitions
+ * through the normal LifeOps service API so they benefit from the same
+ * adaptive timing, reminders, and escalation as user-created tasks.
+ */
+import type { CreateLifeOpsDefinitionRequest } from "@elizaos/shared/contracts/lifeops";
+export interface RoutineSeedTemplate {
+    /** Stable key used to deduplicate across seeding offers. */
+    key: string;
+    title: string;
+    description: string;
+    category: "hygiene" | "health" | "fitness" | "nutrition";
+    /** Partial request — the caller supplies agent/domain/tz fields. */
+    request: Pick<CreateLifeOpsDefinitionRequest, "kind" | "title" | "cadence" | "priority" | "originalIntent">;
+}
+export declare const ROUTINE_SEED_TEMPLATES: RoutineSeedTemplate[];
+//# sourceMappingURL=seed-routines.d.ts.map

package/apps/app-lifeops/src/lifeops/seed-routines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-routines.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/seed-routines.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AAExF,MAAM,WAAW,mBAAmB;IAClC,4DAA4D;IAC5D,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,CAAC;IACzD,oEAAoE;IACpE,OAAO,EAAE,IAAI,CACX,8BAA8B,EAC9B,MAAM,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,gBAAgB,CAC7D,CAAC;CACH;AAED,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,EAsGvD,CAAC"}

package/apps/app-lifeops/src/lifeops/seed-routines.js

@@ -0,0 +1,111 @@
+/**
+ * Seed routine templates offered during first-run onboarding.
+ *
+ * These are data-only definitions — no hardcoded logic is tied to any
+ * specific routine.  The seeding flow creates standard task definitions
+ * through the normal LifeOps service API so they benefit from the same
+ * adaptive timing, reminders, and escalation as user-created tasks.
+ */
+export const ROUTINE_SEED_TEMPLATES = [
+    {
+        key: "brush_teeth",
+        title: "Brush teeth",
+        description: "Morning and night tooth brushing",
+        category: "hygiene",
+        request: {
+            kind: "routine",
+            title: "Brush teeth",
+            cadence: { kind: "daily", windows: ["morning", "night"] },
+            priority: 4,
+            originalIntent: "brush teeth morning and night",
+        },
+    },
+    {
+        key: "drink_water",
+        title: "Drink water",
+        description: "Stay hydrated throughout the day",
+        category: "health",
+        request: {
+            kind: "habit",
+            title: "Drink water",
+            cadence: {
+                kind: "interval",
+                everyMinutes: 120,
+                windows: ["morning", "afternoon", "evening"],
+                maxOccurrencesPerDay: 4,
+            },
+            priority: 3,
+            originalIntent: "drink water regularly throughout the day",
+        },
+    },
+    {
+        key: "stretch",
+        title: "Stretch break",
+        description: "Short stretch breaks during the day",
+        category: "health",
+        request: {
+            kind: "habit",
+            title: "Stretch break",
+            cadence: {
+                kind: "interval",
+                everyMinutes: 240,
+                windows: ["morning", "afternoon"],
+                maxOccurrencesPerDay: 2,
+            },
+            priority: 2,
+            originalIntent: "stretch breaks during the day",
+        },
+    },
+    {
+        key: "vitamins",
+        title: "Take vitamins",
+        description: "Vitamins with meals",
+        category: "nutrition",
+        request: {
+            kind: "routine",
+            title: "Take vitamins",
+            cadence: { kind: "daily", windows: ["morning", "evening"] },
+            priority: 3,
+            originalIntent: "take vitamins with breakfast and dinner",
+        },
+    },
+    {
+        key: "workout",
+        title: "Workout",
+        description: "Daily exercise session",
+        category: "fitness",
+        request: {
+            kind: "habit",
+            title: "Workout",
+            cadence: { kind: "daily", windows: ["afternoon"] },
+            priority: 4,
+            originalIntent: "daily afternoon workout",
+        },
+    },
+    {
+        key: "shower",
+        title: "Shower",
+        description: "Regular showers",
+        category: "hygiene",
+        request: {
+            kind: "routine",
+            title: "Shower",
+            cadence: { kind: "weekly", weekdays: [1, 3, 5], windows: ["morning"] },
+            priority: 3,
+            originalIntent: "shower three times per week",
+        },
+    },
+    {
+        key: "shave",
+        title: "Shave",
+        description: "Regular shaving",
+        category: "hygiene",
+        request: {
+            kind: "routine",
+            title: "Shave",
+            cadence: { kind: "weekly", weekdays: [2, 5], windows: ["morning"] },
+            priority: 2,
+            originalIntent: "shave twice per week",
+        },
+    },
+];