@better_openclaw/betterclaw 1.4.0 → 2.0.0

package/src/index.ts

@@ -1,42 +1,39 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import type { PluginConfig } from "./types.js";
+import type { PluginConfig, DeviceConfig } from "./types.js";
 import { ContextManager } from "./context.js";
 import { createGetContextTool } from "./tools/get-context.js";
 import { EventLog } from "./events.js";
 import { RulesEngine } from "./filter.js";
-import { JudgmentLayer } from "./judgment.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 { loadTriageProfile, runLearner } from "./learner.js";
+import { ReactionTracker } from "./reactions.js";
+import * as os from "node:os";
+import * as path from "node:path";
 
 export type { PluginConfig } from "./types.js";
 
 const DEFAULT_CONFIG: PluginConfig = {
-  llmModel: "openai/gpt-4o-mini",
+  triageModel: "openai/gpt-4o-mini",
+  triageApiBase: undefined,
   pushBudgetPerDay: 10,
   patternWindowDays: 14,
   proactiveEnabled: true,
+  analysisHour: 5,
 };
 
 function resolveConfig(raw: Record<string, unknown> | undefined): PluginConfig {
+  const cfg = raw ?? {};
   return {
-    llmModel:
-      typeof raw?.llmModel === "string" && raw.llmModel.trim()
-        ? raw.llmModel.trim()
-        : DEFAULT_CONFIG.llmModel,
-    pushBudgetPerDay:
-      typeof raw?.pushBudgetPerDay === "number" && raw.pushBudgetPerDay > 0
-        ? raw.pushBudgetPerDay
-        : DEFAULT_CONFIG.pushBudgetPerDay,
-    patternWindowDays:
-      typeof raw?.patternWindowDays === "number" && raw.patternWindowDays > 0
-        ? raw.patternWindowDays
-        : DEFAULT_CONFIG.patternWindowDays,
-    proactiveEnabled:
-      typeof raw?.proactiveEnabled === "boolean"
-        ? raw.proactiveEnabled
-        : DEFAULT_CONFIG.proactiveEnabled,
+    triageModel: (cfg.triageModel as string) ?? (cfg.llmModel as string) ?? "openai/gpt-4o-mini",
+    triageApiBase: (cfg.triageApiBase as string) ?? undefined,
+    pushBudgetPerDay: typeof cfg.pushBudgetPerDay === "number" && cfg.pushBudgetPerDay > 0 ? cfg.pushBudgetPerDay : 10,
+    patternWindowDays: typeof cfg.patternWindowDays === "number" && cfg.patternWindowDays > 0 ? cfg.patternWindowDays : 14,
+    proactiveEnabled: typeof cfg.proactiveEnabled === "boolean" ? cfg.proactiveEnabled : true,
+    analysisHour: typeof cfg.analysisHour === "number" ? Math.max(0, Math.min(23, cfg.analysisHour)) : 5,
   };
 }
 
@@ -48,15 +45,15 @@ export default {
     const config = resolveConfig(api.pluginConfig as Record<string, unknown> | undefined);
     const stateDir = api.runtime.state.resolveStateDir();
 
-    api.logger.info(`betterclaw plugin loaded (model=${config.llmModel}, budget=${config.pushBudgetPerDay})`);
+    api.logger.info(`betterclaw plugin loaded (model=${config.triageModel}, budget=${config.pushBudgetPerDay})`);
 
     // Context manager (load synchronously — file read deferred to first access)
     const ctxManager = new ContextManager(stateDir);
 
-    // Event log, rules engine, judgment layer
+    // Event log, rules engine, reaction tracker
     const eventLog = new EventLog(stateDir);
     const rules = new RulesEngine(config.pushBudgetPerDay);
-    const judgment = new JudgmentLayer(api, config);
+    const reactionTracker = new ReactionTracker(stateDir);
 
     // Pipeline dependencies
     const pipelineDeps: PipelineDeps = {
@@ -65,108 +62,192 @@ export default {
       context: ctxManager,
       events: eventLog,
       rules,
-      judgment,
+      reactions: reactionTracker,
+      stateDir,
     };
 
+    const pluginVersion = "2.0.0";
+
     // Track whether async init has completed
     let initialized = false;
     const initPromise = (async () => {
       try {
         await ctxManager.load();
-        const recentEvents = await eventLog.readSince(Date.now() / 1000 - 86400);
-        rules.restoreCooldowns(
-          recentEvents
-            .filter((e) => e.decision === "push")
-            .map((e) => ({ subscriptionId: e.event.subscriptionId, firedAt: e.event.firedAt })),
-        );
         initialized = true;
-        api.logger.info("betterclaw: async init complete");
       } catch (err) {
-        api.logger.error(`betterclaw: init failed: ${err instanceof Error ? err.message : String(err)}`);
+        api.logger.error(`betterclaw: context init failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        await reactionTracker.load();
+      } catch (err) {
+        api.logger.warn(`betterclaw: reaction tracker load failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (initialized) {
+        try {
+          const recentEvents = await eventLog.readSince(Date.now() / 1000 - 86400);
+          rules.restoreCooldowns(
+            recentEvents
+              .filter((e) => e.decision === "push")
+              .map((e) => ({ subscriptionId: e.event.subscriptionId, firedAt: e.event.firedAt })),
+          );
+          api.logger.info("betterclaw: async init complete");
+        } catch (err) {
+          api.logger.error(`betterclaw: cooldown restore failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
       }
     })();
 
     // Ping health check
-    api.registerGatewayMethod("betterclaw.ping", ({ respond }) => {
-      respond(true, { ok: true, version: "1.0.0", initialized });
+    api.registerGatewayMethod("betterclaw.ping", ({ params, respond }) => {
+      const validTiers: Array<"free" | "premium" | "premium+"> = ["free", "premium", "premium+"];
+      const rawTier = (params as Record<string, unknown>)?.tier as string;
+      const tier = validTiers.includes(rawTier as any) ? (rawTier as "free" | "premium" | "premium+") : "free";
+      const smartMode = (params as Record<string, unknown>)?.smartMode === true;
+
+      ctxManager.setRuntimeState({ tier, smartMode });
+
+      const meta = ctxManager.get().meta;
+      const effectiveBudget = ctxManager.getDeviceConfig().pushBudgetPerDay ?? config.pushBudgetPerDay;
+      respond(true, {
+        ok: true,
+        version: pluginVersion,
+        initialized,
+        pushesToday: meta.pushesToday,
+        budgetRemaining: Math.max(0, effectiveBudget - meta.pushesToday),
+      });
+    });
+
+    // Config RPC — update per-device settings at runtime
+    api.registerGatewayMethod("betterclaw.config", async ({ params, respond }) => {
+      // Note: config save runs outside the event queue. Concurrent saves with processEvent
+      // could race on context.json. Accepted risk — config changes are user-initiated and infrequent.
+      try {
+        const update = params as Record<string, unknown>;
+        const deviceConfig: DeviceConfig = {};
+
+        if (typeof update.pushBudgetPerDay === "number") {
+          deviceConfig.pushBudgetPerDay = update.pushBudgetPerDay;
+        }
+        if (typeof update.proactiveEnabled === "boolean") {
+          deviceConfig.proactiveEnabled = update.proactiveEnabled;
+        }
+
+        ctxManager.setDeviceConfig(deviceConfig);
+        await ctxManager.save();
+        respond(true, { applied: true });
+      } catch (err) {
+        api.logger.error(`betterclaw.config error: ${err instanceof Error ? err.message : String(err)}`);
+        respond(false, undefined, { code: "INTERNAL_ERROR", message: "config update failed" });
+      }
     });
 
     // Context RPC — returns activity, trends, and recent decisions for iOS Context tab
     api.registerGatewayMethod("betterclaw.context", async ({ respond }) => {
-      if (!initialized) await initPromise;
-
-      const state = ctxManager.get();
-      const patterns = await ctxManager.readPatterns();
-      const recentEntries = await eventLog.readRecent(20);
-
-      const activity = {
-        currentZone: state.activity.currentZone,
-        zoneEnteredAt: state.activity.zoneEnteredAt,
-        lastTransition: state.activity.lastTransition,
-        isStationary: state.activity.isStationary,
-        stationarySince: state.activity.stationarySince,
-      };
-
-      const trends = patterns
-        ? {
-            stepsAvg7d: patterns.healthTrends.stepsAvg7d,
-            stepsTrend: patterns.healthTrends.stepsTrend,
-            sleepAvg7d: patterns.healthTrends.sleepAvg7d,
-            sleepTrend: patterns.healthTrends.sleepTrend,
-            restingHrAvg7d: patterns.healthTrends.restingHrAvg7d,
-            restingHrTrend: patterns.healthTrends.restingHrTrend,
-            eventsPerDay7d: patterns.eventStats.eventsPerDay7d,
-            pushesPerDay7d: patterns.eventStats.pushesPerDay7d,
-            dropRate7d: patterns.eventStats.dropRate7d,
-          }
-        : null;
-
-      const decisions = recentEntries.map((e) => ({
-        source: e.event.source,
-        title: e.event.subscriptionId,
-        decision: e.decision,
-        reason: e.reason,
-        timestamp: e.timestamp,
-      }));
-
-      const meta = {
-        pushesToday: state.meta.pushesToday,
-        pushBudgetPerDay: config.pushBudgetPerDay,
-        eventsToday: state.meta.eventsToday,
-      };
-
-      const routines = patterns
-        ? {
-            weekday: patterns.locationRoutines.weekday,
-            weekend: patterns.locationRoutines.weekend,
-          }
-        : null;
+      try {
+        if (!initialized) await initPromise;
 
-      respond(true, { activity, trends, decisions, meta, routines });
+        const state = ctxManager.get();
+        const runtime = ctxManager.getRuntimeState();
+        const timestamps = {
+          battery: ctxManager.getTimestamp("battery") ?? null,
+          location: ctxManager.getTimestamp("location") ?? null,
+          health: ctxManager.getTimestamp("health") ?? null,
+          activity: ctxManager.getTimestamp("activity") ?? null,
+          lastSnapshot: ctxManager.getTimestamp("lastSnapshot") ?? null,
+        };
+        const patterns = await ctxManager.readPatterns();
+        const recentEntries = await eventLog.readRecent(20);
+        const profile = await loadTriageProfile(stateDir);
+
+        const activity = {
+          currentZone: state.activity.currentZone,
+          zoneEnteredAt: state.activity.zoneEnteredAt,
+          lastTransition: state.activity.lastTransition,
+          isStationary: state.activity.isStationary,
+          stationarySince: state.activity.stationarySince,
+        };
+
+        const trends = patterns
+          ? {
+              stepsAvg7d: patterns.healthTrends.stepsAvg7d,
+              stepsTrend: patterns.healthTrends.stepsTrend,
+              sleepAvg7d: patterns.healthTrends.sleepAvg7d,
+              sleepTrend: patterns.healthTrends.sleepTrend,
+              restingHrAvg7d: patterns.healthTrends.restingHrAvg7d,
+              restingHrTrend: patterns.healthTrends.restingHrTrend,
+              eventsPerDay7d: patterns.eventStats.eventsPerDay7d,
+              pushesPerDay7d: patterns.eventStats.pushesPerDay7d,
+              dropRate7d: patterns.eventStats.dropRate7d,
+            }
+          : null;
+
+        const decisions = recentEntries.map((e) => ({
+          source: e.event.source,
+          title: e.event.subscriptionId,
+          decision: e.decision,
+          reason: e.reason,
+          timestamp: e.timestamp,
+        }));
+
+        const meta = {
+          pushesToday: state.meta.pushesToday,
+          pushBudgetPerDay: config.pushBudgetPerDay,
+          eventsToday: state.meta.eventsToday,
+          lastSnapshotAt: timestamps.lastSnapshot,
+          lastAnalysisAt: patterns?.computedAt,
+        };
+
+        const routines = patterns
+          ? {
+              weekday: patterns.locationRoutines.weekday,
+              weekend: patterns.locationRoutines.weekend,
+            }
+          : null;
+
+        respond(true, {
+          tier: runtime.tier,
+          smartMode: runtime.smartMode,
+          activity,
+          trends,
+          decisions,
+          meta,
+          routines,
+          timestamps,
+          triageProfile: profile ? { summary: profile.summary, computedAt: profile.computedAt } : null,
+        });
+      } catch (err) {
+        api.logger.error(`betterclaw.context error: ${err instanceof Error ? err.message : String(err)}`);
+        respond(false, undefined, { code: "INTERNAL_ERROR", message: "context fetch failed" });
+      }
     });
 
     // Snapshot RPC — bulk-apply device state for Smart Mode catch-up
     api.registerGatewayMethod("betterclaw.snapshot", async ({ params, respond }) => {
-      if (!initialized) await initPromise;
-
-      const snapshot = params as {
-        battery?: { level: number; state: string; isLowPowerMode: boolean };
-        location?: { latitude: number; longitude: number };
-        health?: {
-          stepsToday?: number; distanceMeters?: number; heartRateAvg?: number;
-          restingHeartRate?: number; hrv?: number; activeEnergyKcal?: number;
-          sleepDurationSeconds?: number;
+      try {
+        if (!initialized) await initPromise;
+
+        const snapshot = params as {
+          battery?: { level: number; state: string; isLowPowerMode: boolean };
+          location?: { latitude: number; longitude: number };
+          health?: {
+            stepsToday?: number; distanceMeters?: number; heartRateAvg?: number;
+            restingHeartRate?: number; hrv?: number; activeEnergyKcal?: number;
+            sleepDurationSeconds?: number;
+          };
+          geofence?: { type: string; zoneName: string; latitude: number; longitude: number };
         };
-        geofence?: { type: string; zoneName: string; latitude: number; longitude: number };
-      };
 
-      ctxManager.applySnapshot(snapshot);
-      await ctxManager.save();
-      respond(true, { applied: true });
+        ctxManager.applySnapshot(snapshot);
+        await ctxManager.save();
+        respond(true, { applied: true });
+      } catch (err) {
+        api.logger.error(`betterclaw.snapshot error: ${err instanceof Error ? err.message : String(err)}`);
+        respond(false, undefined, { code: "INTERNAL_ERROR", message: "snapshot apply failed" });
+      }
     });
 
     // Agent tool
-    api.registerTool(createGetContextTool(ctxManager), { optional: true });
+    api.registerTool(createGetContextTool(ctxManager, stateDir), { optional: true });
 
     // Auto-reply command
     api.registerCommand({
@@ -201,6 +282,9 @@ export default {
       },
     });
 
+    // Sequential event queue — prevents budget races
+    let eventQueue: Promise<void> = Promise.resolve();
+
     // Event intake RPC
     api.registerGatewayMethod("betterclaw.event", async ({ params, respond }) => {
       try {
@@ -223,9 +307,14 @@ export default {
         }
 
         respond(true, { accepted: true });
-        await processEvent(pipelineDeps, event);
+
+        // Sequential processing — prevents budget races
+        eventQueue = eventQueue.then(() => processEvent(pipelineDeps, event)).catch((err) => {
+          api.logger.error(`event processing failed: ${err}`);
+        });
       } catch (err) {
         api.logger.error(`betterclaw.event handler error: ${err instanceof Error ? err.message : String(err)}`);
+        respond(false, undefined, { code: "INTERNAL_ERROR", message: "event processing failed" });
       }
     });
 
@@ -237,7 +326,24 @@ export default {
     api.registerService({
       id: "betterclaw-engine",
       start: () => {
-        patternEngine.startSchedule();
+        patternEngine.startSchedule(config.analysisHour, async () => {
+          // Run learner after patterns (only if smartMode ON)
+          if (ctxManager.getRuntimeState().smartMode) {
+            try {
+              await runLearner({
+                stateDir,
+                workspaceDir: path.join(os.homedir(), ".openclaw", "workspace"),
+                context: ctxManager,
+                events: eventLog,
+                reactions: reactionTracker,
+                api,
+              });
+              api.logger.info("betterclaw: daily learner completed");
+            } catch (err) {
+              api.logger.error(`betterclaw: daily learner failed: ${err}`);
+            }
+          }
+        });
         proactiveEngine.startSchedule();
         api.logger.info("betterclaw: background services started");
       },
@@ -247,5 +353,52 @@ export default {
         api.logger.info("betterclaw: background services stopped");
       },
     });
+
+    // CLI setup command
+    api.registerCli(
+      ({ program }) => {
+        const cmd = program.command("betterclaw").description("BetterClaw plugin management");
+
+        cmd
+          .command("setup")
+          .description("Configure gateway allowedCommands for BetterClaw")
+          .option("--dry-run", "Preview changes without writing")
+          .action(async (opts: { dryRun?: boolean }) => {
+            try {
+              const currentConfig = await api.runtime.config.loadConfig();
+              const existing: string[] =
+                (currentConfig as any)?.gateway?.nodes?.allowCommands ?? [];
+              const merged = mergeAllowCommands(existing, BETTERCLAW_COMMANDS);
+              const added = merged.length - existing.length;
+
+              if (opts.dryRun) {
+                console.log(`[dry-run] Would set ${merged.length} allowedCommands (${added} new)`);
+                if (added > 0) {
+                  const newCmds = merged.filter((c) => !existing.includes(c));
+                  console.log(`New commands: ${newCmds.join(", ")}`);
+                }
+                return;
+              }
+
+              if (added === 0) {
+                console.log(`All ${BETTERCLAW_COMMANDS.length} BetterClaw commands already configured.`);
+                return;
+              }
+
+              const configObj = { ...currentConfig } as any;
+              configObj.gateway = configObj.gateway ?? {};
+              configObj.gateway.nodes = configObj.gateway.nodes ?? {};
+              configObj.gateway.nodes.allowCommands = merged;
+              await api.runtime.config.writeConfigFile(configObj);
+
+              console.log(`Added ${added} new commands (${merged.length} total). Restart gateway to apply.`);
+            } catch (err) {
+              console.error(`Failed to update config: ${err}`);
+              process.exit(1);
+            }
+          });
+      },
+      { commands: ["betterclaw"] },
+    );
   },
 };

package/src/learner.ts

@@ -0,0 +1,205 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { EventLogEntry, TriageProfile, ReactionEntry } from "./types.js";
+import type { EventLog } from "./events.js";
+import type { ContextManager } from "./context.js";
+import type { ReactionTracker } from "./reactions.js";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+export async function readMemorySummary(workspaceDir: string, date: Date): Promise<string | null> {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const dateStr = `${y}-${m}-${d}`;
+  const memoryPath = path.join(workspaceDir, "memory", `${dateStr}.md`);
+  try {
+    return await fs.readFile(memoryPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+export interface LearnerInput {
+  memorySummary: string | null;
+  recentEvents: EventLogEntry[];
+  reactions: ReactionEntry[];
+  previousProfile: TriageProfile | null;
+  patternsJson: string;
+}
+
+export function buildLearnerPrompt(input: LearnerInput): string {
+  const { memorySummary, recentEvents, reactions, previousProfile, patternsJson } = input;
+
+  const memorySection = memorySummary
+    ? `## Today's Activity (from agent memory)\n\n${memorySummary}`
+    : "## Today's Activity\nNo memory summary available for today.";
+
+  const eventsSection = recentEvents.length > 0
+    ? `## Recent Events (last 24h)\n\n${recentEvents
+        .map((e) => `- [${e.decision}] ${e.event.source} (${e.event.subscriptionId}): ${e.reason}`)
+        .join("\n")}`
+    : "## Recent Events\nNo events in the last 24 hours.";
+
+  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}`;
+        })
+        .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\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.
+
+${memorySection}
+
+${eventsSection}
+
+${reactionsSection}
+
+## Computed Patterns
+${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
+
+Respond with ONLY the JSON object, no markdown fences.`;
+}
+
+export function parseTriageProfile(text: string): TriageProfile | null {
+  try {
+    const cleaned = text.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    if (!parsed.summary || !parsed.interruptionTolerance) return null;
+    const validTolerances = ["low", "normal", "high"];
+    return {
+      eventPreferences: parsed.eventPreferences ?? {},
+      lifeContext: parsed.lifeContext ?? "",
+      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 {
+    return null;
+  }
+}
+
+export async function loadTriageProfile(stateDir: string): Promise<TriageProfile | null> {
+  try {
+    const content = await fs.readFile(path.join(stateDir, "triage-profile.json"), "utf-8");
+    return parseTriageProfile(content);
+  } catch {
+    return null;
+  }
+}
+
+export async function saveTriageProfile(stateDir: string, profile: TriageProfile): Promise<void> {
+  await fs.mkdir(stateDir, { recursive: true });
+  await fs.writeFile(path.join(stateDir, "triage-profile.json"), JSON.stringify(profile, null, 2), "utf-8");
+}
+
+export interface RunLearnerDeps {
+  stateDir: string;
+  workspaceDir: string;
+  context: ContextManager;
+  events: EventLog;
+  reactions: ReactionTracker;
+  api: OpenClawPluginApi;
+}
+
+export async function runLearner(deps: RunLearnerDeps): Promise<void> {
+  const { stateDir, workspaceDir, context, events, reactions, api } = deps;
+
+  // 1. Read yesterday's memory summary (learner runs at 5am, today's barely exists)
+  const yesterday = new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  const memorySummary = await readMemorySummary(workspaceDir, yesterday)
+    ?? await readMemorySummary(workspaceDir, new Date());
+
+  // 2. Read last 24h events
+  const recentEvents = await events.readSince(Date.now() / 1000 - 86400);
+
+  // 3. Get recent reactions
+  const recentReactions = reactions.getRecent(24);
+
+  // 4. Load previous profile
+  const previousProfile = await loadTriageProfile(stateDir);
+
+  // 5. Read patterns for context
+  const patterns = await context.readPatterns();
+  const patternsJson = JSON.stringify(patterns ?? {});
+
+  // 6. Build prompt (include JSON-only instruction since extraSystemPrompt is not a valid SDK param)
+  const prompt = buildLearnerPrompt({
+    memorySummary,
+    recentEvents,
+    reactions: recentReactions,
+    previousProfile,
+    patternsJson,
+  }) + "\n\nIMPORTANT: Respond with ONLY a JSON triage profile object. Do NOT call any tools.";
+
+  // 7. Clean up any stale session from previous failed run
+  try { await api.runtime.subagent.deleteSession({ sessionKey: "betterclaw-learn" }); } catch { /* ignore */ }
+
+  // 8. Run subagent with try/finally for session cleanup
+  let newProfile: TriageProfile | null = null;
+  try {
+    const { runId } = await api.runtime.subagent.run({
+      sessionKey: "betterclaw-learn",
+      message: prompt,
+      deliver: false,
+      idempotencyKey: `betterclaw-learn-${Date.now()}`,
+    });
+
+    // 9. Wait for completion
+    await api.runtime.subagent.waitForRun({ runId, timeoutMs: 60000 });
+
+    // 10. Read response
+    const messages = await api.runtime.subagent.getSessionMessages({
+      sessionKey: "betterclaw-learn",
+      limit: 5,
+    });
+
+    // 11. Parse last assistant message — handle both string and content-block formats
+    const lastAssistant = messages.filter((m: any) => m.role === "assistant").pop();
+    if (lastAssistant) {
+      const content = typeof lastAssistant.content === "string"
+        ? lastAssistant.content
+        : Array.isArray(lastAssistant.content)
+          ? lastAssistant.content.filter((b: any) => b.type === "text").map((b: any) => b.text).join("")
+          : null;
+      if (content) {
+        newProfile = parseTriageProfile(content);
+      }
+    }
+  } finally {
+    // 12. Always delete session
+    try { await api.runtime.subagent.deleteSession({ sessionKey: "betterclaw-learn" }); } catch { /* ignore */ }
+  }
+
+  // 13. Save if valid
+  if (newProfile) {
+    await saveTriageProfile(stateDir, newProfile);
+  }
+
+  // 14. Rotate old reactions
+  reactions.rotate();
+  await reactions.save();
+}