@better_openclaw/betterclaw 2.2.2 → 3.0.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "betterclaw",
   "name": "BetterClaw",
   "description": "Intelligent device context, event filtering, and proactive insights for BetterClaw iOS",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "main": "dist/index.js",
   "skills": ["./skills/betterclaw"],
   "configSchema": {
@@ -52,6 +52,13 @@
         "type": "number",
         "default": 1800,
         "description": "Default dedup cooldown in seconds for subscriptions not in deduplicationCooldowns"
+      },
+      "calibrationDays": {
+        "type": "number",
+        "default": 3,
+        "minimum": 1,
+        "maximum": 14,
+        "description": "Days of calibration before learner profile influences triage decisions"
       }
     },
     "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better_openclaw/betterclaw",
-  "version": "2.2.2",
+  "version": "3.0.0",
   "description": "Intelligent event filtering, context tracking, and proactive triggers for BetterClaw",
   "license": "AGPL-3.0-only",
   "repository": {

package/skills/betterclaw/SKILL.md

@@ -1,32 +1,48 @@
 ---
 name: BetterClaw Device Context
-description: Instructions for handling physical device events and context from BetterClaw iOS
+description: Instructions for accessing physical device state from BetterClaw iOS
 ---
 
 # BetterClaw Device Context
 
 You have access to the user's physical device state via BetterClaw (iOS companion app).
 
-## Capabilities
+## How to access device data
 
-- **Sensors**: battery level/state, GPS location, health metrics (steps, heart rate, HRV, sleep, distance, energy)
-- **Geofence events**: enter/exit named zones (Home, Office, etc.)
-- **Patterns**: location routines, health trends (7d/30d), battery drain rate
-- **Tool**: `get_context` — call anytime to read the full current device snapshot and derived patterns
+1. Call `check_tier` (or use your cached tier if still valid).
+2. Follow the `dataPath` instructions in the response.
 
-## Adaptive Behavior
+### Premium tier
 
-Check `get_context().smartMode` and `get_context().tier` to understand your data flow:
+You have two complementary tools:
 
-- **Smart mode ON**: Device events are being pushed to you automatically, pre-filtered for relevance. If you receive one, it's worth acknowledging.
-- **Smart mode OFF**: No events are pushed automatically. Call `get_context` when the user asks about their physical state (battery, location, health, activity) or when physical context would improve your response.
+- **Node commands** (`location.get`, `device.battery`, `health.*`, etc.)
+  return live data directly from the device. Use these when the user asks
+  for current state — "where am I?", "what's my battery?", "how many steps?"
 
-Check `get_context().triageProfile.summary` for a description of the user's notification preferences.
+- **`get_context`** returns patterns, trends, activity zone, event history,
+  and a cached device snapshot. The snapshot may not be perfectly recent.
+  Use this for contextual awareness — understanding routines, spotting
+  anomalies, checking trends, or getting a broad picture without
+  querying each sensor individually.
+
+Both are useful. Node commands for precision, `get_context` for the big picture.
+
+### Free tier
+
+`get_context` is the only data source. It returns a cached snapshot from the
+last time the user had BetterClaw open — check timestamps for freshness.
+If data is more than 1 hour old, mention that it may be outdated.
+
+## Pushed events (premium only)
+
+When smart mode is on, you may receive proactive alerts about the user's
+physical state. These are pre-filtered for relevance — if you receive one,
+it's worth acknowledging naturally. Don't parrot raw data.
 
 ## Guidelines
 
-- Use `get_context` when physical context would improve your response — don't rely on stale data.
-- Don't parrot raw data. Synthesize naturally: "You're running low and away from home" not "Battery: 0.15, location label: null".
-- Proactive insights are observations, not commands. Use your judgment about whether to relay them.
-- Respond with `no_reply` for routine events that don't need user attention.
-- Check timestamps (`updatedAt`, `computedAt`) to assess data freshness.
+- Synthesize naturally: "You're running low and away from home" not
+  "Battery: 0.15, location: 48.1234, 11.5678"
+- Check timestamps to assess data freshness before acting on data
+- Respond with `no_reply` for routine events that need no user attention

package/src/context.ts

@@ -66,6 +66,16 @@ export class ContextManager {
     return this.timestamps[field];
   }
 
+  /** Returns age of each device data section in seconds, or null if no data */
+  getDataAge(): { battery: number | null; location: number | null; health: number | null } {
+    const now = Date.now() / 1000;
+    return {
+      battery: this.timestamps.battery != null ? Math.round(now - this.timestamps.battery) : null,
+      location: this.timestamps.location != null ? Math.round(now - this.timestamps.location) : null,
+      health: this.timestamps.health != null ? Math.round(now - this.timestamps.health) : null,
+    };
+  }
+
   async save(): Promise<void> {
     await fs.mkdir(path.dirname(this.contextPath), { recursive: true });
     const data = { ...this.context, _timestamps: this.timestamps };
@@ -81,8 +91,8 @@ export class ContextManager {
     // Reset daily counters at local midnight
     const lastDate = new Date(this.context.meta.lastEventAt * 1000);
     const currentDate = new Date(now * 1000);
-    const lastDay = `${lastDate.getFullYear()}-${lastDate.getMonth()}-${lastDate.getDate()}`;
-    const currentDay = `${currentDate.getFullYear()}-${currentDate.getMonth()}-${currentDate.getDate()}`;
+    const lastDay = `${lastDate.getFullYear()}-${String(lastDate.getMonth() + 1).padStart(2, "0")}-${String(lastDate.getDate()).padStart(2, "0")}`;
+    const currentDay = `${currentDate.getFullYear()}-${String(currentDate.getMonth() + 1).padStart(2, "0")}-${String(currentDate.getDate()).padStart(2, "0")}`;
     if (lastDay !== currentDay && this.context.meta.lastEventAt > 0) {
       this.context.meta.eventsToday = 0;
       this.context.meta.pushesToday = 0;

package/src/index.ts

@@ -5,13 +5,15 @@ import { createGetContextTool } from "./tools/get-context.js";
 import { EventLog } from "./events.js";
 import { RulesEngine } from "./filter.js";
 import { PatternEngine } from "./patterns.js";
-import { ProactiveEngine } from "./triggers.js";
 import { processEvent } from "./pipeline.js";
 import type { PipelineDeps } from "./pipeline.js";
 import { BETTERCLAW_COMMANDS, mergeAllowCommands } from "./cli.js";
 import { storeJwt } from "./jwt.js";
 import { loadTriageProfile, runLearner } from "./learner.js";
 import { ReactionTracker } from "./reactions.js";
+import { createCheckTierTool } from "./tools/check-tier.js";
+import { scanPendingReactions } from "./reaction-scanner.js";
+import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 
@@ -33,6 +35,7 @@ const DEFAULT_CONFIG: PluginConfig = {
   analysisHour: 5,
   deduplicationCooldowns: DEFAULT_COOLDOWNS,
   defaultCooldown: 1800,
+  calibrationDays: 3,
 };
 
 function resolveConfig(raw: Record<string, unknown> | undefined): PluginConfig {
@@ -51,6 +54,7 @@ function resolveConfig(raw: Record<string, unknown> | undefined): PluginConfig {
         : {}),
     },
     defaultCooldown: typeof cfg.defaultCooldown === "number" && cfg.defaultCooldown > 0 ? cfg.defaultCooldown : 1800,
+    calibrationDays: typeof cfg.calibrationDays === "number" && cfg.calibrationDays > 0 ? cfg.calibrationDays : 3,
   };
 }
 
@@ -64,6 +68,27 @@ export default {
 
     api.logger.info(`betterclaw plugin loaded (model=${config.triageModel}, budget=${config.pushBudgetPerDay})`);
 
+    // Calibration state
+    let calibrationStartedAt: number | null = null;
+    let pingReceived = false;
+
+    const calibrationFile = path.join(stateDir, "calibration.json");
+    (async () => {
+      try {
+        const raw = await fs.readFile(calibrationFile, "utf8");
+        const parsed = JSON.parse(raw);
+        calibrationStartedAt = parsed.startedAt ?? null;
+      } catch {
+        // No calibration file yet — will be created on first premium ping
+      }
+    })();
+
+    function isCalibrating(): boolean {
+      if (!calibrationStartedAt) return true;
+      const elapsed = Date.now() / 1000 - calibrationStartedAt;
+      return elapsed < config.calibrationDays * 86400;
+    }
+
     // Context manager (load synchronously — file read deferred to first access)
     const ctxManager = new ContextManager(stateDir);
 
@@ -134,6 +159,20 @@ export default {
 
       ctxManager.setRuntimeState({ tier, smartMode });
 
+      pingReceived = true;
+
+      // Initialize calibration on first premium ping
+      if ((tier === "premium" || tier === "premium+") && calibrationStartedAt === null) {
+        const existingProfile = await loadTriageProfile(stateDir);
+        if (existingProfile?.computedAt) {
+          calibrationStartedAt = existingProfile.computedAt - config.calibrationDays * 86400;
+          api.logger.info("betterclaw: existing triage profile found — skipping calibration");
+        } else {
+          calibrationStartedAt = Date.now() / 1000;
+        }
+        fs.writeFile(calibrationFile, JSON.stringify({ startedAt: calibrationStartedAt }), "utf8").catch(() => {});
+      }
+
       const meta = ctxManager.get().meta;
       const effectiveBudget = ctxManager.getDeviceConfig().pushBudgetPerDay ?? config.pushBudgetPerDay;
       respond(true, {
@@ -233,19 +272,10 @@ export default {
             }
           : null;
 
-        const triggerIds = ["low-battery-away", "unusual-inactivity", "sleep-deficit", "routine-deviation", "health-weekly-digest"];
-        const cooldowns: Record<string, number> = {};
-        if (patterns?.triggerCooldowns) {
-          for (const id of triggerIds) {
-            const ts = patterns.triggerCooldowns[id];
-            if (ts != null) cooldowns[id] = ts;
-          }
-        }
-        const triggers = patterns ? { cooldowns } : null;
-
         respond(true, {
           tier: runtime.tier,
           smartMode: runtime.smartMode,
+          calibrating: isCalibrating(),
           activity,
           trends,
           decisions,
@@ -253,7 +283,6 @@ export default {
           routines,
           timestamps,
           triageProfile: profile ?? null,
-          triggers,
         });
       } catch (err) {
         api.logger.error(`betterclaw.context error: ${err instanceof Error ? err.message : String(err)}`);
@@ -333,7 +362,17 @@ export default {
       }
     });
 
-    // Agent tool
+    // Agent tools
+    api.registerTool(
+      createCheckTierTool(ctxManager, () => ({
+        pingReceived,
+        calibrating: isCalibrating(),
+        calibrationEndsAt: calibrationStartedAt
+          ? calibrationStartedAt + config.calibrationDays * 86400
+          : undefined,
+      })),
+      { optional: true },
+    );
     api.registerTool(createGetContextTool(ctxManager, stateDir), { optional: true });
 
     // Auto-reply command
@@ -405,17 +444,23 @@ export default {
       }
     });
 
-    // Pattern engine + proactive engine
+    // Pattern engine
     const patternEngine = new PatternEngine(ctxManager, eventLog, config.patternWindowDays);
-    const proactiveEngine = new ProactiveEngine(ctxManager, api, config);
 
     // Background service
     api.registerService({
       id: "betterclaw-engine",
       start: () => {
         patternEngine.startSchedule(config.analysisHour, async () => {
-          // Run learner after patterns (only if smartMode ON)
           if (ctxManager.getRuntimeState().smartMode) {
+            // Scan reactions first (feeds into learner)
+            try {
+              await scanPendingReactions({ reactions: reactionTracker, api, config, stateDir });
+            } catch (err) {
+              api.logger.error(`betterclaw: reaction scan failed: ${err}`);
+            }
+
+            // Then run learner
             try {
               await runLearner({
                 stateDir,
@@ -431,12 +476,10 @@ export default {
             }
           }
         });
-        proactiveEngine.startSchedule();
         api.logger.info("betterclaw: background services started");
       },
       stop: () => {
         patternEngine.stopSchedule();
-        proactiveEngine.stopSchedule();
         api.logger.info("betterclaw: background services stopped");
       },
     });

package/src/learner.ts

@@ -42,15 +42,12 @@ export function buildLearnerPrompt(input: LearnerInput): string {
 
   const reactionsSection = reactions.length > 0
     ? `## Notification Reactions\n\n${reactions
-        .map((r) => {
-          const status = r.engaged === true ? "engaged" : r.engaged === false ? "ignored" : "unknown";
-          return `- ${r.source} (${r.subscriptionId}): ${status}`;
-        })
+        .map((r) => `- ${r.source} (${r.subscriptionId}): ${r.status}`)
         .join("\n")}`
     : "## Notification Reactions\nNo push reaction data available.";
 
   const prevSection = previousProfile
-    ? `## Previous Triage Profile\n\nSummary: ${previousProfile.summary}\nLife context: ${previousProfile.lifeContext}\nInterruption tolerance: ${previousProfile.interruptionTolerance}`
+    ? `## Previous Triage Profile\n\nSummary: ${previousProfile.summary}\nInterruption tolerance: ${previousProfile.interruptionTolerance}`
     : "## Previous Triage Profile\nNo previous profile — this is the first analysis.";
 
   return `You are analyzing a user's device event patterns and daily activity to build a personalized notification triage profile.
@@ -67,13 +64,8 @@ ${patternsJson}
 ${prevSection}
 
 Based on all of the above, produce an updated triage profile as JSON with these fields:
-- eventPreferences: Record<string, "push"|"drop"|"context-dependent"> — per event source
-- lifeContext: string — brief description of user's current life situation
-- interruptionTolerance: "low"|"normal"|"high"
-- timePreferences: { quietHoursStart?, quietHoursEnd?, activeStart?, activeEnd? } — hours (0-23)
-- sensitivityThresholds: Record<string, number> — e.g. batteryLevel: 0.15
-- locationRules: Record<string, "push"|"drop"|"context-dependent"> — per zone name
 - summary: string — 1-2 sentence human-readable summary of this user's preferences
+- interruptionTolerance: "low"|"normal"|"high"
 
 Respond with ONLY the JSON object, no markdown fences.`;
 }
@@ -85,15 +77,10 @@ export function parseTriageProfile(text: string): TriageProfile | null {
     if (!parsed.summary || !parsed.interruptionTolerance) return null;
     const validTolerances = ["low", "normal", "high"];
     return {
-      eventPreferences: parsed.eventPreferences ?? {},
-      lifeContext: parsed.lifeContext ?? "",
+      summary: parsed.summary,
       interruptionTolerance: validTolerances.includes(parsed.interruptionTolerance)
         ? parsed.interruptionTolerance
         : "normal",
-      timePreferences: parsed.timePreferences ?? {},
-      sensitivityThresholds: parsed.sensitivityThresholds ?? {},
-      locationRules: parsed.locationRules ?? {},
-      summary: parsed.summary,
       computedAt: parsed.computedAt ?? Date.now() / 1000,
     };
   } catch {

package/src/patterns.ts

@@ -53,14 +53,11 @@ export class PatternEngine {
     const windowStart = Date.now() / 1000 - this.windowDays * 86400;
     const entries = await this.events.readSince(windowStart);
 
-    const existing = (await this.context.readPatterns()) ?? emptyPatterns();
-
     const patterns: Patterns = {
       locationRoutines: computeLocationRoutines(entries),
       healthTrends: computeHealthTrends(entries),
       batteryPatterns: computeBatteryPatterns(entries),
       eventStats: computeEventStats(entries),
-      triggerCooldowns: existing.triggerCooldowns,
       computedAt: Date.now() / 1000,
     };
 
@@ -96,7 +93,6 @@ export function emptyPatterns(): Patterns {
       dropRate7d: 0,
       topSources: [],
     },
-    triggerCooldowns: {},
     computedAt: 0,
   };
 }

package/src/pipeline.ts

@@ -25,7 +25,14 @@ export async function processEvent(deps: PipelineDeps, event: DeviceEvent): Prom
   context.updateFromEvent(event);
   await context.save();
 
-  // Gate event forwarding behind premium entitlement
+  // Tier gate: free users get store-only path — no triage, no push
+  if (context.getRuntimeState().tier === "free") {
+    api.logger.info(`betterclaw: event stored (free tier)`);
+    await events.append({ event, decision: "free_stored", reason: "free tier", timestamp: Date.now() / 1000 });
+    return;
+  }
+
+  // Gate event forwarding behind premium entitlement (security boundary)
   const entitlementError = requireEntitlement("premium");
   if (entitlementError) {
     api.logger.info(`betterclaw: event blocked (no premium entitlement)`);
@@ -50,7 +57,7 @@ export async function processEvent(deps: PipelineDeps, event: DeviceEvent): Prom
       event,
       deps.context,
       profile,
-      { triageModel: deps.config.triageModel, triageApiBase: deps.config.triageApiBase },
+      { triageModel: deps.config.triageModel, triageApiBase: deps.config.triageApiBase, budgetUsed: context.get().meta.pushesToday, budgetTotal: effectiveBudget },
       async () => {
         try {
           const auth = await deps.api.runtime.modelAuth.resolveApiKeyForProvider({
@@ -66,16 +73,17 @@ export async function processEvent(deps: PipelineDeps, event: DeviceEvent): Prom
     );
 
     if (triageResult.push) {
-      const pushed = await pushToAgent(deps, event, `triage: ${triageResult.reason}`);
+      const message = formatEnrichedMessage(event, deps.context);
+      const pushed = await pushToAgent(deps, event, `triage: ${triageResult.reason}`, message);
 
       if (pushed) {
         rules.recordFired(event.subscriptionId, event.firedAt);
         context.recordPush();
         deps.reactions.recordPush({
-          idempotencyKey: `event-${event.subscriptionId}-${Math.floor(event.firedAt)}`,
           subscriptionId: event.subscriptionId,
           source: event.source,
           pushedAt: Date.now() / 1000,
+          messageSummary: message.slice(0, 100),
         });
       }
 
@@ -100,16 +108,17 @@ export async function processEvent(deps: PipelineDeps, event: DeviceEvent): Prom
   }
 
   if (decision.action === "push") {
-    const pushed = await pushToAgent(deps, event, decision.reason);
+    const message = formatEnrichedMessage(event, deps.context);
+    const pushed = await pushToAgent(deps, event, decision.reason, message);
 
     if (pushed) {
       rules.recordFired(event.subscriptionId, event.firedAt);
       context.recordPush();
       deps.reactions.recordPush({
-        idempotencyKey: `event-${event.subscriptionId}-${Math.floor(event.firedAt)}`,
         subscriptionId: event.subscriptionId,
         source: event.source,
         pushedAt: Date.now() / 1000,
+        messageSummary: message.slice(0, 100),
       });
     }
 
@@ -134,8 +143,7 @@ export async function processEvent(deps: PipelineDeps, event: DeviceEvent): Prom
   await deps.reactions.save();
 }
 
-async function pushToAgent(deps: PipelineDeps, event: DeviceEvent, reason: string): Promise<boolean> {
-  const message = formatEnrichedMessage(event, deps.context);
+async function pushToAgent(deps: PipelineDeps, event: DeviceEvent, reason: string, message: string): Promise<boolean> {
   const idempotencyKey = `event-${event.subscriptionId}-${Math.floor(event.firedAt)}`;
 
   try {

package/src/reaction-scanner.ts

@@ -0,0 +1,238 @@
+import type { ReactionStatus } from "./types.js";
+import type { ReactionTracker } from "./reactions.js";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+// --- Types ---
+
+export interface PushMatch {
+  pushIndex: number;
+  subsequentMessages: Array<{ role: string; content: unknown }>;
+}
+
+export interface ClassificationResult {
+  status: ReactionStatus;
+  reason: string;
+}
+
+export interface ScanDeps {
+  api: OpenClawPluginApi;
+  reactions: ReactionTracker;
+  classificationModel: string;
+  classificationApiBase?: string;
+  getApiKey: () => Promise<string | undefined>;
+}
+
+// --- Helpers ---
+
+function extractText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((b: any) => b.type === "text")
+      .map((b: any) => b.text ?? "")
+      .join("");
+  }
+  return "";
+}
+
+function isBetterClawPush(text: string): boolean {
+  return text.includes("[BetterClaw device event");
+}
+
+// --- Exported functions ---
+
+/**
+ * Deterministic search: find the pushed message in the session transcript by
+ * timestamp proximity (within 30s) + content prefix match.
+ */
+export function findPushInMessages(
+  messages: Array<{ role: string; content: unknown; timestamp?: number }>,
+  pushedAt: number,
+  messageSummary: string,
+): PushMatch | null {
+  const prefix = messageSummary.slice(0, 30);
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    const text = extractText(msg.content);
+
+    // Must be a BetterClaw push message
+    if (!isBetterClawPush(text)) continue;
+
+    // Must be within 30s of pushedAt
+    if (msg.timestamp !== undefined) {
+      if (Math.abs(msg.timestamp - pushedAt) > 30) continue;
+    }
+
+    // Must contain the first 30 chars of messageSummary
+    if (!text.includes(prefix)) continue;
+
+    // Collect subsequent messages until next BetterClaw push or limit of 5
+    const subsequent: Array<{ role: string; content: unknown }> = [];
+    for (let j = i + 1; j < messages.length && subsequent.length < 5; j++) {
+      const next = messages[j];
+      const nextText = extractText(next.content);
+      if (isBetterClawPush(nextText)) break;
+      subsequent.push({ role: next.role, content: next.content });
+    }
+
+    return { pushIndex: i, subsequentMessages: subsequent };
+  }
+
+  return null;
+}
+
+/**
+ * Build a classification prompt asking the LLM to determine engagement status.
+ */
+export function buildClassificationPrompt(
+  pushMessage: string,
+  subsequentMessages: Array<{ role: string; content: unknown }>,
+): string {
+  const convoLines = subsequentMessages
+    .map((m) => `${m.role}: ${extractText(m.content)}`)
+    .join("\n");
+
+  return `You are classifying user engagement with a pushed device notification.
+
+The following message was pushed to the user's AI assistant:
+---
+${pushMessage}
+---
+
+Conversation that followed:
+${convoLines || "(no subsequent messages)"}
+
+Classify the user's engagement with this notification:
+- "engaged": the user acknowledged, replied, or acted on the notification
+- "ignored": the user changed topic, ignored it, or showed no reaction
+- "unclear": not enough information to determine
+
+Respond with JSON: {"status": "engaged"|"ignored"|"unclear", "reason": string}`;
+}
+
+/**
+ * Parse LLM JSON response into classification result.
+ */
+export function parseClassificationResponse(text: string): ClassificationResult {
+  try {
+    const cleaned = text.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    const validStatuses: ReactionStatus[] = ["engaged", "ignored", "unclear"];
+    const status = validStatuses.includes(parsed.status) ? parsed.status : "unclear";
+    return {
+      status,
+      reason: typeof parsed.reason === "string" ? parsed.reason : "no reason provided",
+    };
+  } catch {
+    return { status: "unclear", reason: "failed to parse LLM response" };
+  }
+}
+
+/**
+ * Orchestrator: scan all pending reactions, do deterministic transcript search,
+ * classify via LLM, and record results on the ReactionTracker.
+ */
+export async function scanPendingReactions(deps: ScanDeps): Promise<void> {
+  const { api, reactions } = deps;
+
+  const pending = reactions.getPending();
+  if (pending.length === 0) {
+    api.logger.info("reaction-scanner: no pending reactions to classify");
+    return;
+  }
+
+  api.logger.info(`reaction-scanner: scanning ${pending.length} pending reaction(s)`);
+
+  // Fetch session messages once (limit 200) to search through
+  let messages: Array<{ role: string; content: unknown; timestamp?: number }> = [];
+  try {
+    const { messages: fetched } = await api.runtime.subagent.getSessionMessages({
+      sessionKey: "main",
+      limit: 200,
+    });
+    messages = fetched;
+  } catch (err) {
+    api.logger.error(
+      `reaction-scanner: failed to fetch session messages: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return;
+  }
+
+  for (const reaction of pending) {
+    try {
+      // Step 1: Deterministic search
+      const match = findPushInMessages(messages, reaction.pushedAt, reaction.messageSummary);
+      if (!match) {
+        api.logger.info(
+          `reaction-scanner: no transcript match for ${reaction.subscriptionId} at ${reaction.pushedAt} — skipping`,
+        );
+        continue;
+      }
+
+      // Step 2: Build prompt
+      const pushText = extractText(
+        messages[match.pushIndex].content,
+      );
+      const prompt = buildClassificationPrompt(pushText, match.subsequentMessages);
+
+      // Step 3: LLM classification via subagent
+      const sessionKey = `betterclaw-classify-${reaction.subscriptionId}-${Math.floor(reaction.pushedAt)}`;
+      let classificationResult: ClassificationResult = { status: "unclear", reason: "classification not attempted" };
+
+      try {
+        // Clean up any stale session first
+        try { await api.runtime.subagent.deleteSession({ sessionKey }); } catch { /* ignore */ }
+
+        const { runId } = await api.runtime.subagent.run({
+          sessionKey,
+          message: prompt,
+          deliver: false,
+          idempotencyKey: `classify-${reaction.subscriptionId}-${Math.floor(reaction.pushedAt)}`,
+        });
+
+        await api.runtime.subagent.waitForRun({ runId, timeoutMs: 30000 });
+
+        const { messages: classifyMessages } = await api.runtime.subagent.getSessionMessages({
+          sessionKey,
+          limit: 5,
+        });
+
+        const lastAssistant = classifyMessages.filter((m: any) => m.role === "assistant").pop();
+        if (lastAssistant) {
+          const content = extractText(lastAssistant.content);
+          if (content) {
+            classificationResult = parseClassificationResponse(content);
+          }
+        }
+      } finally {
+        try { await api.runtime.subagent.deleteSession({ sessionKey }); } catch { /* ignore */ }
+      }
+
+      // Step 4: Record classification using compound key
+      reactions.classify(
+        reaction.subscriptionId,
+        reaction.pushedAt,
+        classificationResult.status,
+        classificationResult.reason,
+      );
+
+      api.logger.info(
+        `reaction-scanner: classified ${reaction.subscriptionId} as "${classificationResult.status}" — ${classificationResult.reason}`,
+      );
+    } catch (err) {
+      api.logger.error(
+        `reaction-scanner: error classifying ${reaction.subscriptionId}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+
+  // Persist updated reactions
+  try {
+    await reactions.save();
+  } catch (err) {
+    api.logger.error(
+      `reaction-scanner: failed to save reactions: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}

package/src/reactions.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ReactionEntry } from "./types.js";
+import type { ReactionEntry, ReactionStatus } from "./types.js";
 
 export class ReactionTracker {
   private reactions: ReactionEntry[] = [];
@@ -10,21 +10,43 @@ export class ReactionTracker {
     this.filePath = path.join(stateDir, "push-reactions.jsonl");
   }
 
-  recordPush(entry: Omit<ReactionEntry, "engaged" | "checkedAt">): void {
-    this.reactions.push({ ...entry, engaged: null });
+  recordPush(entry: { subscriptionId: string; source: string; pushedAt: number; messageSummary: string }): void {
+    this.reactions.push({
+      ...entry,
+      status: "pending",
+    });
   }
 
-  markEngaged(idempotencyKey: string, engaged: boolean): void {
-    const entry = this.reactions.find((r) => r.idempotencyKey === idempotencyKey);
+  /** Classify a reaction by matching on subscriptionId + pushedAt compound key */
+  classify(subscriptionId: string, pushedAt: number, status: ReactionStatus, reason: string): void {
+    const entry = this.reactions.find(
+      (r) => r.subscriptionId === subscriptionId && r.pushedAt === pushedAt && r.status === "pending"
+    );
     if (entry) {
-      entry.engaged = engaged;
-      entry.checkedAt = Date.now() / 1000;
+      entry.status = status;
+      entry.classifiedAt = Date.now() / 1000;
+      entry.classificationReason = reason;
     }
   }
 
-  getRecent(hours: number): ReactionEntry[] {
+  /** Get pending (unclassified) reactions; optionally filtered to the last N hours */
+  getPending(hours?: number): ReactionEntry[] {
+    const pending = this.reactions.filter((r) => r.status === "pending");
+    if (hours === undefined) {
+      return pending;
+    }
+    const cutoff = Date.now() / 1000 - hours * 3600;
+    return pending.filter((r) => r.pushedAt >= cutoff);
+  }
+
+  getRecent(_hours?: number): ReactionEntry[] {
+    return [...this.reactions];
+  }
+
+  /** Get classified reactions for learner input */
+  getClassified(hours: number = 24): ReactionEntry[] {
     const cutoff = Date.now() / 1000 - hours * 3600;
-    return this.reactions.filter((r) => r.pushedAt >= cutoff);
+    return this.reactions.filter((r) => r.status !== "pending" && r.pushedAt >= cutoff);
   }
 
   async save(): Promise<void> {
@@ -49,7 +71,6 @@ export class ReactionTracker {
     }
   }
 
-  /** Rotate: keep only last 30 days */
   rotate(): void {
     const cutoff = Date.now() / 1000 - 30 * 86400;
     this.reactions = this.reactions.filter((r) => r.pushedAt >= cutoff);

package/src/tools/check-tier.ts

@@ -0,0 +1,63 @@
+import { Type } from "@sinclair/typebox";
+import type { ContextManager } from "../context.js";
+
+export interface CheckTierState {
+  pingReceived: boolean;
+  calibrating: boolean;
+  calibrationEndsAt?: number;
+}
+
+export function createCheckTierTool(ctx: ContextManager, getState: () => CheckTierState) {
+  return {
+    name: "check_tier",
+    label: "Check Device Tier",
+    description:
+      "Check the user's BetterClaw subscription tier and get instructions for how to access their device data. Call this first before accessing device data, or use your cached tier if still valid.",
+    parameters: Type.Object({}),
+    async execute(_id: string, _params: Record<string, unknown>) {
+      const state = getState();
+
+      if (!state.pingReceived) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              tier: "unknown",
+              dataPath: "Tier not yet determined — the device hasn't connected. Try again shortly.",
+              cacheUntil: Math.floor(Date.now() / 1000) + 60,
+              cacheInstruction: "Re-check in about a minute.",
+            }, null, 2),
+          }],
+        };
+      }
+
+      const runtime = ctx.getRuntimeState();
+      const cacheUntil = Math.floor(Date.now() / 1000) + 86400;
+
+      const isPremium = runtime.tier === "premium" || runtime.tier === "premium+";
+
+      const dataPath = isPremium
+        ? "Use node commands for current device readings: location.get, device.battery, health.steps, health.heartrate, health.hrv, health.sleep, health.distance, health.restinghr, health.workouts, health.summary, geofence.list. Use get_context for patterns, trends, history, and broad situational awareness — its device snapshot may not be perfectly recent but is useful for the big picture."
+        : "Use get_context for all device data. This is a cached snapshot from the last time the user had BetterClaw open — check timestamps for freshness. You cannot query fresh data on free tier.";
+
+      const cacheInstruction = `Save your tier and data path to your memory. Re-check after cacheUntil (${new Date(cacheUntil * 1000).toISOString()}). Until then, use the cached tier to decide how to access device data.`;
+
+      const result: Record<string, unknown> = {
+        tier: runtime.tier,
+        dataPath,
+        cacheUntil,
+        cacheInstruction,
+      };
+
+      if (state.calibrating) {
+        result.calibrating = true;
+        result.calibrationEndsAt = state.calibrationEndsAt;
+        result.calibrationNote = "BetterClaw's smart filtering is still calibrating — it needs a few days to learn your preferences. Events are being tracked but filtering is in rules-only mode.";
+      }
+
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
+      };
+    },
+  };
+}

package/src/tools/get-context.ts

@@ -1,4 +1,3 @@
-import { Type } from "@sinclair/typebox";
 import type { ContextManager } from "../context.js";
 import { loadTriageProfile } from "../learner.js";
 
@@ -7,47 +6,47 @@ export function createGetContextTool(ctx: ContextManager, stateDir?: string) {
     name: "get_context",
     label: "Get Device Context",
     description:
-      "Get the current physical context of the user's iPhone — battery, location, health metrics, activity zone, patterns, and trends. Call this when you need to know about the user's physical state.",
-    parameters: Type.Object({
-      include: Type.Optional(
-        Type.Array(Type.String(), {
-          description: "Sections to include. Omit for all. Options: device, activity, patterns, meta",
-        }),
-      ),
-    }),
-    async execute(_id: string, params: Record<string, unknown>) {
-      const sections =
-        Array.isArray(params.include) && params.include.every((s) => typeof s === "string")
-          ? (params.include as string[])
-          : ["device", "activity", "patterns", "meta"];
-
+      "Get BetterClaw context — patterns, trends, activity zone, event history, and cached device snapshots with staleness indicators. On premium, node commands return fresher data for current readings. On free, this includes the latest device snapshot.",
+    parameters: {},
+    async execute(_id: string, _params: Record<string, unknown>) {
       const state = ctx.get();
       const runtime = ctx.getRuntimeState();
       const patterns = await ctx.readPatterns();
+      const dataAge = ctx.getDataAge();
+
+      const isPremium = runtime.tier === "premium" || runtime.tier === "premium+";
 
       const result: Record<string, unknown> = {
-        tier: runtime.tier,
+        tierHint: {
+          tier: runtime.tier,
+          note: isPremium
+            ? "Node commands available for fresh readings (location.get, device.battery, health.*)"
+            : "This is the only data source on free tier — check dataAgeSeconds for freshness",
+        },
         smartMode: runtime.smartMode,
       };
 
-      if (sections.includes("device")) {
-        result.device = {
-          battery: state.device.battery ? { ...state.device.battery, updatedAt: ctx.getTimestamp("battery") } : null,
-          location: state.device.location ? { ...state.device.location, updatedAt: ctx.getTimestamp("location") } : null,
-          health: state.device.health ? { ...state.device.health, updatedAt: ctx.getTimestamp("health") } : null,
-        };
-      }
-      if (sections.includes("activity")) {
-        result.activity = { ...state.activity, updatedAt: ctx.getTimestamp("activity") };
-      }
-      if (sections.includes("patterns") && patterns) result.patterns = patterns;
-      if (sections.includes("meta")) {
-        result.meta = {
-          ...state.meta,
-          lastSnapshotAt: ctx.getTimestamp("lastSnapshot"),
-          lastAnalysisAt: patterns?.computedAt,
-        };
-      }
+      result.device = {
+        battery: state.device.battery
+          ? { ...state.device.battery, updatedAt: ctx.getTimestamp("battery"), dataAgeSeconds: dataAge.battery }
+          : null,
+        location: state.device.location
+          ? { ...state.device.location, updatedAt: ctx.getTimestamp("location"), dataAgeSeconds: dataAge.location }
+          : null,
+        health: state.device.health
+          ? { ...state.device.health, updatedAt: ctx.getTimestamp("health"), dataAgeSeconds: dataAge.health }
+          : null,
+      };
+
+      result.activity = { ...state.activity, updatedAt: ctx.getTimestamp("activity") };
+
+      if (patterns) result.patterns = patterns;
+
+      result.meta = {
+        ...state.meta,
+        lastSnapshotAt: ctx.getTimestamp("lastSnapshot"),
+        lastAnalysisAt: patterns?.computedAt,
+      };
 
       const profile = stateDir ? await loadTriageProfile(stateDir) : null;
       result.triageProfile = profile ? { summary: profile.summary, computedAt: profile.computedAt } : null;

package/src/triage.ts

@@ -11,6 +11,7 @@ export function buildTriagePrompt(
   event: DeviceEvent,
   context: ContextManager,
   profile: TriageProfile | null,
+  budget?: { budgetUsed: number; budgetTotal: number },
 ): string {
   const ctx = context.get();
   const battery = ctx.device.battery;
@@ -33,12 +34,16 @@ export function buildTriagePrompt(
     .filter(Boolean)
     .join("\n");
 
+  const budgetSection = budget
+    ? `## Push Budget\n${budget.budgetUsed} of ${budget.budgetTotal} pushes used today — be selective.`
+    : "";
+
   return `You are an event triage system for a personal assistant. Decide whether this device event should be pushed as a notification to the user.
 
 ${profileSection}
 
 ${contextSection}
-
+${budgetSection ? `\n${budgetSection}` : ""}
 ## Event
 - Subscription: ${event.subscriptionId}
 - Source: ${event.source}
@@ -60,7 +65,7 @@ export function parseTriageResponse(text: string): TriageResult {
       priority: ["low", "normal", "high"].includes(parsed.priority) ? parsed.priority : undefined,
     };
   } catch {
-    return { push: true, reason: "failed to parse triage response" };
+    return { push: false, reason: "failed to parse triage response — defaulting to drop" };
   }
 }
 
@@ -68,15 +73,19 @@ export async function triageEvent(
   event: DeviceEvent,
   context: ContextManager,
   profile: TriageProfile | null,
-  config: { triageModel: string; triageApiBase?: string },
+  config: { triageModel: string; triageApiBase?: string; budgetUsed?: number; budgetTotal?: number },
   resolveApiKey: () => Promise<string | undefined>,
 ): Promise<TriageResult> {
-  const prompt = buildTriagePrompt(event, context, profile);
+  const prompt = buildTriagePrompt(event, context, profile,
+    config.budgetUsed != null && config.budgetTotal != null
+      ? { budgetUsed: config.budgetUsed, budgetTotal: config.budgetTotal }
+      : undefined
+  );
 
   try {
     const apiKey = await resolveApiKey();
     if (!apiKey) {
-      return { push: true, reason: "no API key for triage — defaulting to push" };
+      return { push: false, reason: "no API key for triage — defaulting to drop" };
     }
 
     const baseUrl = config.triageApiBase ?? "https://api.openai.com/v1";
@@ -116,7 +125,7 @@ export async function triageEvent(
     });
 
     if (!response.ok) {
-      return { push: true, reason: `triage API error: ${response.status}` };
+      return { push: false, reason: `triage API error: ${response.status} — defaulting to drop` };
     }
 
     const data = (await response.json()) as {
@@ -124,11 +133,11 @@ export async function triageEvent(
     };
     const content = data.choices?.[0]?.message?.content;
     if (!content) {
-      return { push: true, reason: "empty triage response" };
+      return { push: false, reason: "empty triage response — defaulting to drop" };
     }
 
     return parseTriageResponse(content);
   } catch (err) {
-    return { push: true, reason: `triage call failed: ${err}` };
+    return { push: false, reason: `triage call failed: ${err} — defaulting to drop` };
   }
 }

package/src/types.ts

@@ -76,7 +76,7 @@ export type FilterDecision =
 
 export interface EventLogEntry {
   event: DeviceEvent;
-  decision: "push" | "drop" | "stored";
+  decision: "push" | "drop" | "stored" | "free_stored";
   reason: string;
   timestamp: number;
 }
@@ -114,7 +114,6 @@ export interface Patterns {
     dropRate7d: number;
     topSources: string[];
   };
-  triggerCooldowns: Record<string, number>;
   computedAt: number;
 }
 
@@ -129,28 +128,27 @@ export interface PluginConfig {
   analysisHour: number;
   deduplicationCooldowns: Record<string, number>;
   defaultCooldown: number;
+  calibrationDays: number;
 }
 
 // Triage profile produced by daily learning agent
 export interface TriageProfile {
-  eventPreferences: Record<string, "push" | "drop" | "context-dependent">;
-  lifeContext: string;
+  summary: string;              // 1-2 sentence description of what the user cares about
   interruptionTolerance: "low" | "normal" | "high";
-  timePreferences: { quietHoursStart?: number; quietHoursEnd?: number; activeStart?: number; activeEnd?: number };
-  sensitivityThresholds: Record<string, number>;
-  locationRules: Record<string, "push" | "drop" | "context-dependent">;
-  summary: string;
-  computedAt: number;
+  computedAt: number;           // epoch seconds
 }
 
 // Reaction tracking for pushed events
+export type ReactionStatus = "pending" | "engaged" | "ignored" | "unclear";
+
 export interface ReactionEntry {
-  idempotencyKey: string;
   subscriptionId: string;
   source: string;
   pushedAt: number;
-  engaged: boolean | null; // null = not yet determined
-  checkedAt?: number;
+  messageSummary: string;       // first ~100 chars of the pushed message
+  status: ReactionStatus;
+  classifiedAt?: number;        // epoch when LLM classified
+  classificationReason?: string; // one-line reason from classifier
 }
 
 // Per-device config from betterclaw.config RPC

package/openclaw-plugin-sdk.md

@@ -1,38 +0,0 @@
-# OpenClaw Plugin SDK — What Plugins Can and Cannot Do
-
-## No LLM/Agent Access from Plugins
-
-Plugins **cannot** invoke LLMs or spawn agent sessions. This was discovered through deep investigation of the OpenClaw source code and plugin SDK.
-
-### What we tried
-- `runEmbeddedPiAgent` — an internal OpenClaw function used by the core agent. Both betteremail and betterclaw plugins tried to import it via `openclaw/agents/pi-embedded`. This **does not work** because it's not exported in the plugin SDK.
-
-### Why it doesn't work
-- The plugin SDK (`openclaw/plugin-sdk`) only exports a limited surface:
-  - `OpenClawPluginApi` — the `api` object passed to `register()`
-  - `openclaw/plugin-sdk/llm-task` — exists as an export path but provides no agent invocation
-- `openclaw/agents/*` is **not an exported path** — the import fails at runtime via Jiti (TypeScript loader)
-- `runEmbeddedPiAgent` is internal to OpenClaw's agent system and intentionally not exposed to plugins
-- The betterclaw plugin has the **exact same bug** — it also imports `runEmbeddedPiAgent` and has never successfully run its judgment layer
-
-### What plugins CAN do
-- `api.registerTool()` — expose tools to the agent (with optional `{ optional: true }` flag)
-- `api.registerService()` — run background services (polling loops, etc.)
-- `api.registerCommand()` — add `/commands` to the chat UI
-- `api.runtime.system.runCommandWithTimeout()` — run shell commands (including `gog`, `openclaw` CLI)
-- `api.runtime.state.resolveStateDir()` — get persistent state directory
-- `api.pluginConfig` — read plugin config from openclaw.yaml
-- `api.logger` — structured logging
-
-### What plugins CANNOT do
-- Invoke LLMs or create agent sessions
-- Import internal OpenClaw modules outside the plugin SDK exports
-- Access `runEmbeddedPiAgent` or any agent runtime internals
-- Run embedded "sub-agents" for classification or judgment
-
-### The solution we adopted
-Instead of classifying emails in the plugin, we removed the classifier entirely and made the plugin a **pure stateful memory layer**. All emails enter the digest, and the agent triages them during cron-triggered sessions with full context (memory, skills, user preferences). This is actually better because:
-1. The agent has full context for triage decisions
-2. No separate LLM invocation cost
-3. Simpler architecture — the plugin just tracks state
-4. Cron job runs in isolated session, only notifies main session when something matters

package/src/triggers.ts

@@ -1,232 +0,0 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import type { ContextManager } from "./context.js";
-import type { DeviceContext, Patterns, PluginConfig } from "./types.js";
-
-const ONE_HOUR_MS = 60 * 60 * 1000;
-
-interface TriggerResult {
-  id: string;
-  message: string;
-  priority: "low" | "normal" | "high";
-}
-
-type TriggerCheck = (ctx: DeviceContext, patterns: Patterns) => TriggerResult | null;
-
-const TRIGGER_COOLDOWNS: Record<string, number> = {
-  "low-battery-away": 4 * 3600,
-  "unusual-inactivity": 6 * 3600,
-  "sleep-deficit": 24 * 3600,
-  "routine-deviation": 4 * 3600,
-  "health-weekly-digest": 7 * 86400,
-};
-
-const triggers: Array<{ id: string; schedule: "hourly" | "daily" | "weekly"; check: TriggerCheck }> = [
-  {
-    id: "low-battery-away",
-    schedule: "hourly",
-    check: (ctx, patterns) => {
-      const battery = ctx.device.battery;
-      if (!battery || battery.level >= 0.3) return null;
-      if (ctx.activity.currentZone === "Home") return null;
-
-      const drain = patterns.batteryPatterns.avgDrainPerHour ?? 0.04;
-      const hoursRemaining = drain > 0 ? Math.round(battery.level / drain) : 0;
-
-      return {
-        id: "low-battery-away",
-        message: `🔋 Battery at ${Math.round(battery.level * 100)}%, draining ~${Math.round(drain * 100)}%/hr. You're away from home — estimated ${hoursRemaining}h remaining. Consider charging.`,
-        priority: battery.level < 0.15 ? "high" : "normal",
-      };
-    },
-  },
-  {
-    id: "unusual-inactivity",
-    schedule: "hourly",
-    check: (ctx, patterns) => {
-      const hour = new Date().getHours();
-      if (hour < 12) return null;
-
-      const steps = ctx.device.health?.stepsToday;
-      const avg = patterns.healthTrends.stepsAvg7d;
-      if (steps == null || avg == null) return null;
-
-      const expectedByNow = avg * (hour / 24);
-      if (steps >= expectedByNow * 0.5) return null;
-
-      return {
-        id: "unusual-inactivity",
-        message: `🚶 It's ${hour}:00 and you've done ${Math.round(steps).toLocaleString()} steps (usually ~${Math.round(expectedByNow).toLocaleString()} by now). Everything okay?`,
-        priority: "low",
-      };
-    },
-  },
-  {
-    id: "sleep-deficit",
-    schedule: "daily",
-    check: (ctx, patterns) => {
-      const hour = new Date().getHours();
-      if (hour < 7 || hour > 10) return null;
-
-      const sleep = ctx.device.health?.sleepDurationSeconds;
-      const avg = patterns.healthTrends.sleepAvg7d;
-      if (sleep == null || avg == null) return null;
-
-      const deficit = avg - sleep;
-      if (deficit < 3600) return null;
-
-      const sleepH = Math.floor(sleep / 3600);
-      const sleepM = Math.round((sleep % 3600) / 60);
-      const avgH = Math.floor(avg / 3600);
-      const avgM = Math.round((avg % 3600) / 60);
-
-      return {
-        id: "sleep-deficit",
-        message: `😴 You slept ${sleepH}h${sleepM}m last night (your average is ${avgH}h${avgM}m). Might want to take it easy today.`,
-        priority: "low",
-      };
-    },
-  },
-  {
-    id: "routine-deviation",
-    schedule: "hourly",
-    check: (ctx, patterns) => {
-      const now = new Date();
-      const day = now.getDay();
-      const isWeekday = day >= 1 && day <= 5;
-      if (!isWeekday) return null;
-
-      const hour = now.getHours() + now.getMinutes() / 60;
-      const routines = patterns.locationRoutines.weekday;
-
-      for (const routine of routines) {
-        if (!routine.typicalLeave) continue;
-        const [h, m] = routine.typicalLeave.split(":").map(Number);
-        const typicalLeaveHour = h + m / 60;
-
-        if (
-          ctx.activity.currentZone === routine.zone &&
-          hour > typicalLeaveHour + 1.5
-        ) {
-          return {
-            id: "routine-deviation",
-            message: `📅 It's ${now.getHours()}:${String(now.getMinutes()).padStart(2, "0")} on ${["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][day]} and you haven't left ${routine.zone} (usually leave at ${routine.typicalLeave}). Just noting in case.`,
-            priority: "low",
-          };
-        }
-      }
-
-      return null;
-    },
-  },
-  {
-    id: "health-weekly-digest",
-    schedule: "weekly",
-    check: (ctx, patterns) => {
-      if (new Date().getDay() !== 0) return null;
-      const hour = new Date().getHours();
-      if (hour < 9 || hour > 11) return null;
-
-      const trends = patterns.healthTrends;
-      const stats = patterns.eventStats;
-
-      const parts: string[] = [];
-      if (trends.stepsAvg7d != null) {
-        const trend = trends.stepsTrend ? ` (${trends.stepsTrend})` : "";
-        parts.push(`Avg steps: ${Math.round(trends.stepsAvg7d).toLocaleString()}/day${trend}`);
-      }
-      if (trends.sleepAvg7d != null) {
-        const h = Math.floor(trends.sleepAvg7d / 3600);
-        const m = Math.round((trends.sleepAvg7d % 3600) / 60);
-        parts.push(`Avg sleep: ${h}h${m}m`);
-      }
-      if (trends.restingHrAvg7d != null) {
-        parts.push(`Resting HR: ${Math.round(trends.restingHrAvg7d)}bpm`);
-      }
-      parts.push(`Events: ${stats.eventsPerDay7d.toFixed(1)}/day, ${Math.round(stats.dropRate7d * 100)}% filtered`);
-
-      return {
-        id: "health-weekly-digest",
-        message: `📊 Weekly health digest\n\n${parts.join("\n")}`,
-        priority: "low",
-      };
-    },
-  },
-];
-
-export class ProactiveEngine {
-  private context: ContextManager;
-  private api: OpenClawPluginApi;
-  private config: PluginConfig;
-  private interval: ReturnType<typeof setInterval> | null = null;
-
-  constructor(context: ContextManager, api: OpenClawPluginApi, config: PluginConfig) {
-    this.context = context;
-    this.api = api;
-    this.config = config;
-  }
-
-  startSchedule(): void {
-    if (!this.config.proactiveEnabled) return;
-
-    this.interval = setInterval(() => {
-      void this.checkAll().catch((err) => {
-        this.api.logger.error(`betterclaw: proactive check failed: ${err}`);
-      });
-    }, ONE_HOUR_MS);
-    this.interval.unref?.();
-
-    // Run initial check after 5 minutes (let context populate)
-    setTimeout(() => {
-      void this.checkAll().catch(() => {});
-    }, 5 * 60 * 1000).unref?.();
-  }
-
-  stopSchedule(): void {
-    if (this.interval) {
-      clearInterval(this.interval);
-      this.interval = null;
-    }
-  }
-
-  async checkAll(): Promise<void> {
-    if (!this.context.getRuntimeState().smartMode) {
-      return;
-    }
-    const deviceConfig = this.context.getDeviceConfig();
-    if (deviceConfig.proactiveEnabled === false) {
-      return;
-    }
-    const ctx = this.context.get();
-    const patterns = (await this.context.readPatterns()) ?? (await import("./patterns.js")).emptyPatterns();
-
-    for (const trigger of triggers) {
-      const lastFired = patterns.triggerCooldowns[trigger.id] ?? 0;
-      const cooldown = TRIGGER_COOLDOWNS[trigger.id] ?? 3600;
-      if (Date.now() / 1000 - lastFired < cooldown) continue;
-
-      const result = trigger.check(ctx, patterns);
-      if (!result) continue;
-
-      this.api.logger.info(`betterclaw: proactive trigger fired: ${trigger.id}`);
-
-      // Write cooldown BEFORE push to prevent runaway retries on failure
-      patterns.triggerCooldowns[trigger.id] = Date.now() / 1000;
-      await this.context.writePatterns(patterns);
-
-      const message = `[BetterClaw proactive insight — combined signal analysis]\n\n${result.message}`;
-
-      try {
-        await this.api.runtime.subagent.run({
-          sessionKey: "main",
-          message,
-          deliver: true,
-          idempotencyKey: `trigger-${trigger.id}-${Math.floor(Date.now() / 1000)}`,
-        });
-      } catch (err) {
-        this.api.logger.error(
-          `betterclaw: trigger push failed: ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
-    }
-  }
-}