@better_openclaw/betterclaw 2.2.2 → 3.0.1

package/README.md

@@ -19,34 +19,30 @@
 
 This is the server-side plugin for [BetterClaw](https://betterclaw.app), an iOS app that connects your iPhone's sensors to your [OpenClaw](https://openclaw.dev) AI agent. The app streams device events (location, battery, health, geofences) to your gateway — this plugin decides what to do with them.
 
-The plugin is the **sole event gateway** for all tiers. Smart mode controls filtering depth: OFF = passive context store, ON = full pipeline with rules, LLM triage, and proactive insights.
+The plugin differentiates between **free** and **premium** tiers:
 
-```
-  BetterClaw iOS App          This Plugin (on gateway)              Agent
- ──────────────────          ────────────────────────             ────────
-                                       │
-  battery ──────▶  ┌───────────────────┼───────────────────┐
-  location ─────▶  │  Rules Engine     │  Context Store     │
-  health ───────▶  │  LLM Triage       │  Pattern Engine    │ ──▶  filtered events
-  geofence ─────▶  │  Daily Learner    │  Proactive Triggers│      + full context
-                   └───────────────────┼───────────────────┘
-                                       │
-                                 proactive insights
-                              (low battery + away from
-                               home, sleep deficit, etc.)
-```
+- **Free** — passive context store. The agent can pull device snapshots via `get_context`, but no events are pushed proactively.
+- **Premium** — full smart mode pipeline with rules-based filtering, LLM triage, engagement tracking, and a daily learner that adapts to your preferences.
+
+<p align="center">
+  <picture>
+    <img src=".github/architecture.svg" alt="BetterClaw Plugin Architecture" width="500" />
+  </picture>
+</p>
 
 ## Features
 
-- **Tier-Aware Smart Mode** — Smart mode ON = full pipeline (rules → triage → push). Smart mode OFF = passive store (context updated, no filtering or pushing). Synced via periodic heartbeat from iOS.
-- **Two-Layer LLM Triage** — Daily learner builds a personalized triage profile from OpenClaw memory summaries + event reactions. Per-event cheap LLM call with structured output for ambiguous events.
-- **Smart Filtering** — Per-source dedup, cooldown windows, and a configurable daily push budget prevent event spam
-- **Device Context** — Rolling state snapshot with per-field timestamps: battery, GPS, zone occupancy, health metrics, activity classification
-- **Pattern Recognition** — Daily analysis computes location routines, health trends (7d/30d baselines), and event frequency stats
-- **Proactive Insights** — Combined-signal triggers: low battery away from home, unusual inactivity, sleep deficit, routine deviations, weekly digest
-- **Per-Device Config** — iOS app can override push budget and proactive settings at runtime via RPC
-- **Agent Tool** — `get_context` tool lets your agent read the full device snapshot, tier, smart mode status, and triage profile on demand
-- **CLI Setup** — `openclaw betterclaw setup` configures gateway allowedCommands automatically
+- **Tier-Aware Routing** — `check_tier` tool tells the agent whether to use node commands (premium, fresh data) or `get_context` (free, cached snapshots). Includes a 24h cache TTL so the agent doesn't re-check every turn.
+- **Free = Pull-Only** — Events are stored for context but never triaged or pushed. `get_context` with staleness indicators (`dataAgeSeconds`) is the only data source.
+- **Premium Smart Mode** — Rules engine + LLM triage with fail-closed error handling and budget-aware prompts. Daily push budget prevents event spam.
+- **Engagement Tracking** — Deterministic transcript scanner finds pushed messages by timestamp, then an LLM classifies user engagement as `engaged`, `ignored`, or `unclear`. Feeds into the learner.
+- **Adaptive Learner** — Daily subagent builds a simplified triage profile (`summary` + `interruptionTolerance`) from event history, engagement data, and workspace memory.
+- **Calibration Period** — First 3 days after install, triage runs in rules-only mode while the system collects engagement data. Skipped automatically for users upgrading from v2.
+- **Device Context** — Rolling state snapshot with per-field timestamps and `dataAgeSeconds`: battery, GPS, zone occupancy, health metrics, activity classification.
+- **Pattern Recognition** — Daily analysis computes location routines, health trends (7d/30d baselines), and event frequency stats.
+- **Per-Device Config** — iOS app can override push budget at runtime via RPC.
+- **Agent Tools** — `check_tier` for routing decisions, `get_context` for patterns/trends/cached state.
+- **CLI Setup** — `openclaw betterclaw setup` configures gateway allowedCommands automatically.
 
 ## Requirements
 
@@ -74,8 +70,8 @@ Add to your `openclaw.json`:
           "triageModel": "openai/gpt-4o-mini",
           "pushBudgetPerDay": 10,
           "patternWindowDays": 14,
-          "proactiveEnabled": true,
-          "analysisHour": 5
+          "analysisHour": 5,
+          "calibrationDays": 3
         }
       }
     }
@@ -89,14 +85,14 @@ All config keys are optional — defaults are shown above.
 
 | Key | Default | Description |
 |-----|---------|-------------|
-| `triageModel` | `openai/gpt-4o-mini` | Model for per-event triage (supports `provider/model` format) |
-| `triageApiBase` | — | Optional base URL for OpenAI-compatible endpoint (e.g., Ollama) |
+| `triageModel` | `openai/gpt-4o-mini` | Model for per-event triage and engagement classification |
+| `triageApiBase` | -- | Optional base URL for OpenAI-compatible endpoint (e.g., Ollama) |
 | `pushBudgetPerDay` | `10` | Max events forwarded to the agent per day |
 | `patternWindowDays` | `14` | Days of event history used for pattern computation |
-| `proactiveEnabled` | `true` | Enable proactive combined-signal insights |
 | `analysisHour` | `5` | Hour (0-23, system timezone) for daily pattern + learner analysis |
+| `calibrationDays` | `3` | Days of rules-only triage before learner profile kicks in |
 
-> **Migration:** `llmModel` still works as a deprecated alias for `triageModel`.
+> **Migration from v2:** `llmModel` still works as a deprecated alias for `triageModel`. `proactiveEnabled` is ignored (proactive triggers removed in v3).
 
 ## How It Works
 
@@ -104,26 +100,33 @@ All config keys are optional — defaults are shown above.
 
 Every device event from the BetterClaw app goes through the plugin:
 
-1. **Context Update** — Device context store is always updated with the latest sensor data.
-2. **Smart Mode Check** — If smart mode is OFF, the event is stored and processing stops. If ON, continues.
-3. **Rules Engine** — Checks dedup, cooldown timers, and daily budget. Critical events (geofence, low battery) always push. Obvious spam is dropped.
-4. **LLM Triage** — Ambiguous events get a cheap LLM call with the personalized triage profile for a push/drop decision.
-5. **Agent Injection** — Events that pass are injected into the agent's main session with formatted context.
+<p align="center">
+  <picture>
+    <img src=".github/pipeline.svg" alt="Event Pipeline" width="350" />
+  </picture>
+</p>
 
 ### Background Services
 
-- **Pattern Engine + Daily Learner** (daily at `analysisHour`) — Computes location routines, health trends, event stats. Then runs a subagent turn to build a personalized triage profile from OpenClaw memory summaries and notification reaction data.
-- **Proactive Engine** (hourly) — Evaluates combined-signal conditions and fires insights when thresholds are met.
+- **Pattern Engine + Reaction Scanner + Learner** (daily at `analysisHour`) — Computes location routines, health trends, event stats. Then scans session transcripts for engagement with past pushes (deterministic timestamp search + LLM classification). Finally runs a subagent to build a personalized triage profile from engagement data and workspace memory.
+
+### Agent Tools
+
+| Tool | Purpose |
+|------|---------|
+| `check_tier` | Returns tier + routing instructions + cache TTL. No device data. Call first. |
+| `get_context` | Returns patterns, trends, zone state, cached device snapshots with `dataAgeSeconds`. |
 
 ### Gateway RPCs
 
 | RPC | Direction | Purpose |
 |-----|-----------|---------|
-| `betterclaw.event` | iOS → plugin | Send a device event for processing |
-| `betterclaw.ping` | iOS → plugin | Heartbeat: sync tier + smartMode, get budget info |
-| `betterclaw.config` | iOS → plugin | Per-device settings override |
-| `betterclaw.context` | iOS → plugin | Full context for iOS Context tab |
-| `betterclaw.snapshot` | iOS → plugin | Bulk device state catch-up |
+| `betterclaw.event` | iOS -> plugin | Send a device event for processing |
+| `betterclaw.ping` | iOS -> plugin | Heartbeat: sync tier + smartMode, init calibration |
+| `betterclaw.config` | iOS -> plugin | Per-device settings override |
+| `betterclaw.context` | iOS -> plugin | Full context for iOS Context tab (includes `calibrating` flag) |
+| `betterclaw.snapshot` | iOS -> plugin | Bulk device state catch-up |
+| `betterclaw.learn` | iOS -> plugin | Trigger on-demand triage profile learning |
 
 ## Commands
 
@@ -135,9 +138,10 @@ Every device event from the BetterClaw app goes through the plugin:
 
 | Plugin | BetterClaw iOS | OpenClaw |
 |--------|----------------|----------|
+| 3.x    | 2.x+           | 2025.12+ |
 | 2.x    | 2.x+           | 2025.12+ |
 | 1.x    | 1.x            | 2025.12+ |
 
 ## License
 
-[AGPL-3.0](LICENSE) — Free to use, modify, and self-host. Derivative works must remain open source.
+[AGPL-3.0](LICENSE) -- Free to use, modify, and self-host. Derivative works must remain open source.

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.1",
   "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,8 +362,17 @@ export default {
       }
     });
 
-    // Agent tool
-    api.registerTool(createGetContextTool(ctxManager, stateDir), { optional: true });
+    // Agent tools
+    api.registerTool(
+      createCheckTierTool(ctxManager, () => ({
+        pingReceived,
+        calibrating: isCalibrating(),
+        calibrationEndsAt: calibrationStartedAt
+          ? calibrationStartedAt + config.calibrationDays * 86400
+          : undefined,
+      })),
+    );
+    api.registerTool(createGetContextTool(ctxManager, stateDir));
 
     // Auto-reply command
     api.registerCommand({
@@ -405,17 +443,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 +475,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 {