@iamoberlin/chorus 2.2.0 → 2.3.0

package/src/config.ts

@@ -20,6 +20,22 @@ export interface ChorusConfig {
     dailyRunCap: number;
     defaultFrequency: number;
     defaultMaxFrequency: number;
+    researchTimeoutMs: number;
+    checkIntervalMs: number;
+  };
+  daemon: {
+    enabled: boolean;
+    senses: {
+      inbox: boolean;
+      purposes: boolean;
+      time: boolean;
+    };
+    thinkThreshold: number;
+    pollIntervalMs: number;
+    minSleepMs: number;
+    maxSleepMs: number;
+    quietHoursStart: number;
+    quietHoursEnd: number;
   };
   prayers: {
     enabled: boolean;
@@ -45,6 +61,23 @@ export interface ChorusPluginConfig {
     dailyRunCap?: number;
     defaultFrequency?: number;
     defaultMaxFrequency?: number;
+    researchTimeoutMs?: number;
+    checkIntervalMs?: number;
+  };
+  /** Daemon config */
+  daemon?: {
+    enabled?: boolean;
+    senses?: {
+      inbox?: boolean;
+      purposes?: boolean;
+      time?: boolean;
+    };
+    thinkThreshold?: number;
+    pollIntervalMs?: number;
+    minSleepMs?: number;
+    maxSleepMs?: number;
+    quietHoursStart?: number;
+    quietHoursEnd?: number;
   };
   /** On-chain prayer config */
   prayers?: {
@@ -72,6 +105,22 @@ const DEFAULT_CONFIG: ChorusConfig = {
     dailyRunCap: 50,
     defaultFrequency: 6,
     defaultMaxFrequency: 24,
+    researchTimeoutMs: 300000,
+    checkIntervalMs: 60000,
+  },
+  daemon: {
+    enabled: true,
+    senses: {
+      inbox: true,
+      purposes: true,
+      time: true,
+    },
+    thinkThreshold: 55,
+    pollIntervalMs: 5 * 60 * 1000,
+    minSleepMs: 30 * 1000,
+    maxSleepMs: 10 * 60 * 1000,
+    quietHoursStart: 23,
+    quietHoursEnd: 7,
   },
   prayers: {
     enabled: true,
@@ -146,6 +195,48 @@ export function loadChorusConfig(pluginConfig?: ChorusPluginConfig): ChorusConfi
     if (pluginConfig.purposeResearch.defaultMaxFrequency !== undefined) {
       config.purposeResearch.defaultMaxFrequency = pluginConfig.purposeResearch.defaultMaxFrequency;
     }
+    if (pluginConfig.purposeResearch.researchTimeoutMs !== undefined) {
+      config.purposeResearch.researchTimeoutMs = pluginConfig.purposeResearch.researchTimeoutMs;
+    }
+    if (pluginConfig.purposeResearch.checkIntervalMs !== undefined) {
+      config.purposeResearch.checkIntervalMs = pluginConfig.purposeResearch.checkIntervalMs;
+    }
+  }
+
+  // Daemon
+  if (pluginConfig.daemon) {
+    if (pluginConfig.daemon.enabled !== undefined) {
+      config.daemon.enabled = pluginConfig.daemon.enabled;
+    }
+    if (pluginConfig.daemon.senses) {
+      if (pluginConfig.daemon.senses.inbox !== undefined) {
+        config.daemon.senses.inbox = pluginConfig.daemon.senses.inbox;
+      }
+      if (pluginConfig.daemon.senses.purposes !== undefined) {
+        config.daemon.senses.purposes = pluginConfig.daemon.senses.purposes;
+      }
+      if (pluginConfig.daemon.senses.time !== undefined) {
+        config.daemon.senses.time = pluginConfig.daemon.senses.time;
+      }
+    }
+    if (pluginConfig.daemon.thinkThreshold !== undefined) {
+      config.daemon.thinkThreshold = pluginConfig.daemon.thinkThreshold;
+    }
+    if (pluginConfig.daemon.pollIntervalMs !== undefined) {
+      config.daemon.pollIntervalMs = pluginConfig.daemon.pollIntervalMs;
+    }
+    if (pluginConfig.daemon.minSleepMs !== undefined) {
+      config.daemon.minSleepMs = pluginConfig.daemon.minSleepMs;
+    }
+    if (pluginConfig.daemon.maxSleepMs !== undefined) {
+      config.daemon.maxSleepMs = pluginConfig.daemon.maxSleepMs;
+    }
+    if (pluginConfig.daemon.quietHoursStart !== undefined) {
+      config.daemon.quietHoursStart = pluginConfig.daemon.quietHoursStart;
+    }
+    if (pluginConfig.daemon.quietHoursEnd !== undefined) {
+      config.daemon.quietHoursEnd = pluginConfig.daemon.quietHoursEnd;
+    }
   }
 
   return config;

package/src/daemon.ts

@@ -8,7 +8,7 @@
 import type { PluginLogger } from "openclaw/plugin-sdk";
 import type { Signal, Sense } from "./senses.js";
 import { ALL_SENSES } from "./senses.js";
-import { SalienceFilter, defaultFilter } from "./salience.js";
+import { SalienceFilter } from "./salience.js";
 import { recordExecution, type ChoirExecution } from "./metrics.js";
 
 export interface DaemonConfig {
@@ -55,7 +55,7 @@ export function createDaemon(
   const attentionQueue: AttentionItem[] = [];
   const cleanupFns: (() => void)[] = [];
   
-  let pollInterval: NodeJS.Timeout | null = null;
+  let cycleTimer: NodeJS.Timeout | null = null;
   let running = false;
 
   // Get enabled senses
@@ -146,7 +146,7 @@ export function createDaemon(
 
     try {
       const result = await api.runAgentTurn?.({
-        sessionLabel: "chorus:daemon",
+        sessionLabel: "chorus-daemon",
         message: prompt,
         isolated: true,
         timeoutSeconds: 180,
@@ -240,11 +240,7 @@ export function createDaemon(
       // Start event watchers
       startWatchers();
 
-      // Initial poll
-      pollSenses().catch(err => log.error(`[daemon] Initial poll failed: ${err}`));
-
-      // Periodic polling
-      pollInterval = setInterval(async () => {
+      const runCycle = async (): Promise<void> => {
         if (!running) return;
 
         try {
@@ -253,18 +249,27 @@ export function createDaemon(
         } catch (err) {
           log.error(`[daemon] Cycle error: ${err}`);
         }
-      }, config.pollIntervalMs);
 
-      log.info(`[daemon] 👁️ Active — polling every ${config.pollIntervalMs / 1000}s, threshold: ${config.thinkThreshold}`);
+        if (!running) return;
+        cycleTimer = setTimeout(() => {
+          runCycle().catch(err => log.error(`[daemon] Cycle scheduler error: ${err}`));
+        }, calculateSleepTime());
+      };
+
+      runCycle().catch(err => log.error(`[daemon] Initial cycle failed: ${err}`));
+
+      log.info(
+        `[daemon] 👁️ Active — adaptive sleep ${config.minSleepMs / 1000}s..${config.maxSleepMs / 1000}s, threshold: ${config.thinkThreshold}`
+      );
     },
 
     stop: () => {
       running = false;
       log.info("[daemon] Stopping...");
 
-      if (pollInterval) {
-        clearInterval(pollInterval);
-        pollInterval = null;
+      if (cycleTimer) {
+        clearTimeout(cycleTimer);
+        cycleTimer = null;
       }
 
       for (const cleanup of cleanupFns) {

package/src/delivery.ts

@@ -0,0 +1,96 @@
+import { spawn } from "child_process";
+
+interface DeliverableChoir {
+  name: string;
+  delivers?: boolean;
+}
+
+interface LoggerLike {
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+}
+
+function toPlainTextIfNeeded(text: string, channel?: string): string {
+  let deliveryText = text.slice(0, 4000);
+  if (channel !== "imessage") return deliveryText;
+
+  return deliveryText
+    .replace(/\*\*(.+?)\*\*/g, "$1")
+    .replace(/\*(.+?)\*/g, "$1")
+    .replace(/__(.+?)__/g, "$1")
+    .replace(/_(.+?)_/g, "$1")
+    .replace(/`(.+?)`/g, "$1")
+    .replace(/```[\s\S]*?```/g, "")
+    .replace(/^#{1,6}\s+/gm, "")
+    .replace(/^\s*[-*+]\s+/gm, "• ")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+}
+
+function resolveDeliveryTarget(api: any): { target?: string; channel?: string } {
+  const channels = api?.config?.channels as Record<string, any> | undefined;
+  if (!channels) return {};
+
+  for (const [channel, cfg] of Object.entries(channels)) {
+    if (cfg?.enabled && cfg?.allowFrom?.[0]) {
+      return { target: cfg.allowFrom[0], channel };
+    }
+  }
+
+  return {};
+}
+
+export async function deliverChoirOutput(
+  api: any,
+  choir: DeliverableChoir,
+  text: string,
+  log?: LoggerLike
+): Promise<void> {
+  if (!choir.delivers || !text || text === "HEARTBEAT_OK" || text === "NO_REPLY") return;
+
+  const { target, channel } = resolveDeliveryTarget(api);
+  if (!target) {
+    log?.warn?.(`[chorus] ⚠ No delivery target found in OpenClaw config for ${choir.name}`);
+    return;
+  }
+
+  const args = [
+    "message", "send",
+    "--target", target,
+    "--message", toPlainTextIfNeeded(text, channel),
+  ];
+  if (channel) args.push("--channel", channel);
+
+  await new Promise<void>((resolve) => {
+    try {
+      const child = spawn("openclaw", args, { stdio: ["ignore", "pipe", "pipe"] });
+      let stderr = "";
+      child.stderr.on("data", (d: Buffer) => {
+        if (stderr.length < 1024) stderr += d.toString();
+      });
+
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+      }, 30000);
+
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          log?.info?.(`[chorus] 📨 ${choir.name} output delivered via ${channel || "default"}`);
+        } else {
+          const err = stderr.trim().slice(0, 160);
+          log?.warn?.(`[chorus] ⚠ ${choir.name} delivery failed${err ? `: ${err}` : ""}`);
+        }
+        resolve();
+      });
+
+      child.on("error", (err: any) => {
+        clearTimeout(timer);
+        log?.warn?.(`[chorus] ⚠ ${choir.name} delivery error: ${(err?.message || "").slice(0, 160)}`);
+        resolve();
+      });
+    } catch (err: any) {
+      log?.warn?.(`[chorus] ⚠ ${choir.name} delivery error: ${(err?.message || "").slice(0, 160)}`);
+      resolve();
+    }
+  });
+}

package/src/economics.ts

@@ -0,0 +1,166 @@
+/**
+ * CHORUS Attention Economics — Phase 1: Observe
+ *
+ * Tracks inference cost and value signals per choir/purpose.
+ * No frequency adjustments yet — just measurement.
+ *
+ * Cost: captured from each choir run (tokens × model rate)
+ * Value: attributed from downstream outcomes (calibration wins, alerts acted on, etc.)
+ */
+
+import { existsSync, appendFileSync, readFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const ECONOMICS_DIR = join(homedir(), ".chorus", "economics");
+
+// Model cost rates (USD per 1K tokens)
+const MODEL_RATES: Record<string, { input: number; output: number }> = {
+  "claude-sonnet-4": { input: 0.003, output: 0.015 },
+  "claude-opus-4": { input: 0.015, output: 0.075 },
+  "claude-haiku-3.5": { input: 0.0008, output: 0.004 },
+  default: { input: 0.003, output: 0.015 }, // assume sonnet
+};
+
+// ── Cost Tracking ────────────────────────────────────────────
+
+export interface RunCost {
+  choirId: string;
+  purposeId?: string;
+  timestamp: string;
+  inputTokens: number;
+  outputTokens: number;
+  model: string;
+  inferenceMs: number;
+  costUsd: number;
+}
+
+function ensureDir(): void {
+  if (!existsSync(ECONOMICS_DIR)) {
+    mkdirSync(ECONOMICS_DIR, { recursive: true });
+  }
+}
+
+export function recordCost(cost: RunCost): void {
+  ensureDir();
+  const line = JSON.stringify(cost) + "\n";
+  appendFileSync(join(ECONOMICS_DIR, "costs.jsonl"), line);
+}
+
+export function estimateCost(
+  inputTokens: number,
+  outputTokens: number,
+  model: string = "default"
+): number {
+  const rate = MODEL_RATES[model] || MODEL_RATES.default;
+  return (inputTokens / 1000) * rate.input + (outputTokens / 1000) * rate.output;
+}
+
+// ── Value Tracking ───────────────────────────────────────────
+
+export type ValueKind =
+  | "thesis_win"       // calibration record: prediction correct
+  | "thesis_save"      // powers caught a flaw → loss avoided
+  | "config_improve"   // virtues change → measurable improvement
+  | "alert_acted"      // archangels alert → human acted
+  | "pnl_attribution"  // research led to profitable trade
+  | "knowledge_cited"; // cherubim insight reused in later decision
+
+export interface ValueEvent {
+  choirId: string;
+  purposeId?: string;
+  timestamp: string;
+  kind: ValueKind;
+  estimatedValueUsd: number;
+  evidence: string;
+}
+
+export function recordValue(event: ValueEvent): void {
+  ensureDir();
+  const line = JSON.stringify(event) + "\n";
+  appendFileSync(join(ECONOMICS_DIR, "value.jsonl"), line);
+}
+
+// ── ROI Calculation ──────────────────────────────────────────
+
+interface ChoirROI {
+  choirId: string;
+  windowDays: number;
+  totalCostUsd: number;
+  totalValueUsd: number;
+  roi: number; // value / cost, or Infinity if cost is 0
+  runCount: number;
+  costPerRun: number;
+}
+
+function readJsonl<T>(filename: string): T[] {
+  const path = join(ECONOMICS_DIR, filename);
+  if (!existsSync(path)) return [];
+  try {
+    return readFileSync(path, "utf-8")
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+export function calculateROI(choirId: string, windowDays: number = 7): ChoirROI {
+  const cutoff = Date.now() - windowDays * 86400000;
+
+  const costs = readJsonl<RunCost>("costs.jsonl").filter(
+    (c) => c.choirId === choirId && new Date(c.timestamp).getTime() > cutoff
+  );
+
+  const values = readJsonl<ValueEvent>("value.jsonl").filter(
+    (v) => v.choirId === choirId && new Date(v.timestamp).getTime() > cutoff
+  );
+
+  const totalCost = costs.reduce((sum, c) => sum + c.costUsd, 0);
+  const totalValue = values.reduce((sum, v) => sum + v.estimatedValueUsd, 0);
+
+  return {
+    choirId,
+    windowDays,
+    totalCostUsd: totalCost,
+    totalValueUsd: totalValue,
+    roi: totalCost > 0 ? totalValue / totalCost : values.length > 0 ? Infinity : 0,
+    runCount: costs.length,
+    costPerRun: costs.length > 0 ? totalCost / costs.length : 0,
+  };
+}
+
+export function calculateAllROI(windowDays: number = 7): ChoirROI[] {
+  const choirIds = [
+    "seraphim", "cherubim", "thrones",
+    "dominions", "virtues", "powers",
+    "principalities", "archangels", "angels",
+  ];
+  return choirIds.map((id) => calculateROI(id, windowDays));
+}
+
+// ── Summary ──────────────────────────────────────────────────
+
+export function formatEconomicsSummary(windowDays: number = 7): string {
+  const allROI = calculateAllROI(windowDays);
+  const totalCost = allROI.reduce((s, r) => s + r.totalCostUsd, 0);
+  const totalValue = allROI.reduce((s, r) => s + r.totalValueUsd, 0);
+  const totalRuns = allROI.reduce((s, r) => s + r.runCount, 0);
+
+  const lines = [
+    `Attention Economics — ${windowDays}d window`,
+    "=".repeat(50),
+    "",
+    `Total: ${totalRuns} runs | $${totalCost.toFixed(2)} cost | $${totalValue.toFixed(2)} value | ROI ${totalCost > 0 ? (totalValue / totalCost).toFixed(1) : "N/A"}x`,
+    "",
+    "Per Choir:",
+    ...allROI.map((r) => {
+      const roi = r.totalCostUsd > 0 ? `${r.roi.toFixed(1)}x` : "N/A";
+      return `  ${r.choirId.padEnd(16)} ${r.runCount.toString().padStart(3)} runs  $${r.totalCostUsd.toFixed(2).padStart(6)} cost  $${r.totalValueUsd.toFixed(2).padStart(8)} value  ${roi.padStart(6)} ROI`;
+    }),
+  ];
+
+  return lines.join("\n");
+}

package/src/prayers/solana.ts

@@ -27,7 +27,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 // Program ID (deployed to devnet)
-export const PROGRAM_ID = new PublicKey("DZuj1ZcX4H6THBSgW4GhKA7SbZNXtPDE5xPkW2jN53PQ");
+export const PROGRAM_ID = new PublicKey("Af61jGnh2AceK3E8FAxCh9j7Jt6JWtJz6PUtbciDjVJS");
 
 // Max plaintext size that fits in a Solana transaction after encryption overhead
 // Encrypted blob = plaintext + 40 bytes (24 nonce + 16 Poly1305 tag)

package/src/purpose-research.ts

@@ -35,6 +35,9 @@ export const DEFAULT_PURPOSE_RESEARCH_CONFIG: PurposeResearchConfig = {
   checkIntervalMs: 60000,
 };
 
+// Guard: purposes currently running research (prevents duplicate triggers)
+const runningPurposes = new Set<string>();
+
 interface DailyRunTracker {
   date: string;
   count: number;
@@ -71,6 +74,36 @@ function countAlerts(output: string): number {
   return 1;
 }
 
+function extractTextFromApiResult(result: any): string {
+  if (!result) return "";
+  const payloadText = (result.payloads || [])
+    .map((p: any) => p?.text || "")
+    .filter((t: string) => Boolean(t))
+    .pop();
+  return payloadText || result.text || result.result?.text || result.response || result.content || "";
+}
+
+function extractTextFromCliStdout(stdout: string): string {
+  if (!stdout) return "";
+
+  // Find the last top-level JSON object to skip any log noise before payload.
+  for (let i = stdout.length - 1; i >= 0; i--) {
+    if (stdout[i] !== "{") continue;
+    try {
+      const parsed = JSON.parse(stdout.slice(i));
+      const payloadText = (parsed.result?.payloads || [])
+        .map((p: any) => p?.text || "")
+        .filter((t: string) => Boolean(t))
+        .pop();
+      return payloadText || parsed.result?.text || parsed.text || parsed.response || parsed.content || "";
+    } catch {
+      // Keep scanning backward for valid JSON.
+    }
+  }
+
+  return "";
+}
+
 const STATE_DIR = join(homedir(), ".chorus");
 const STATE_FILE = join(STATE_DIR, "research-state.json");
 
@@ -160,6 +193,8 @@ export function createPurposeResearchScheduler(
     if (purpose.progress >= 100) return false;
     if (purpose.research?.enabled === false) return false;
     if (!purpose.criteria?.length && !purpose.research?.domains?.length) return false;
+    // Guard: skip if already running (prevents duplicate triggers while agent is executing)
+    if (runningPurposes.has(purpose.id)) return false;
 
     const lastRun = purpose.research?.lastRun ?? 0;
     const frequency = calculateFrequency(purpose);
@@ -214,33 +249,43 @@ PURPOSE RESEARCH: ${purpose.name}
 You are researching for the following purpose:
 ${purpose.description || purpose.name}
 
-Search domains: ${domains}
+YOU HAVE FULL TOOL ACCESS. Use exec to run shell commands, web_search to search the web, web_fetch to read URLs. If criteria below include "run:" commands, EXECUTE THEM — do not just describe what you would do.
+
+Working directory: ${WORKSPACE_PATH}
 
-Success criteria to inform research:
+Criteria (follow these — if they say "run:", actually run the command):
 ${criteria}
 
 Tasks:
-1. Search for recent developments relevant to this purpose
-2. Assess impact on purpose progress or timeline
-3. Flag anything that challenges or validates current assumptions
-4. Note actionable insights
+1. EXECUTE any commands specified in criteria above
+2. Use web_search for at least 2 queries on recent developments
+3. Assess impact on purpose progress or timeline
+4. Surface actionable insights with measurable specifics (metrics, thresholds, dates)
 
 Alert threshold: ${alertThreshold}
 ${alertGuidance[alertThreshold]}
 
 Output format:
-- FINDINGS: Key discoveries (bullet points)
+- EXECUTED: Commands run and their results (summarized)
+- FINDINGS: Key discoveries (bullet points with numbers)
 - IMPACT: How this affects the purpose (progress/timeline/risk)
 - ALERTS: Anything requiring immediate attention (or "none")
 - NEXT: What to research next time
 
-Your output will be saved automatically. Focus on the research content.
+Your output will be saved automatically. Focus on actionable content, not analysis of what you could do.
 
-CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
+CRITICAL: If sending alerts to plain-text channels, use PLAIN TEXT ONLY (no markdown).
 `.trim();
   }
 
-  async function runResearch(purpose: Purpose): Promise<void> {
+  async function runResearch(purpose: Purpose): Promise<boolean> {
+    // Guard: prevent concurrent runs of the same purpose
+    if (runningPurposes.has(purpose.id)) {
+      log.debug(`[purpose-research] ⏭️ "${purpose.name}" already running, skipping`);
+      return false;
+    }
+    runningPurposes.add(purpose.id);
+
     const startTime = Date.now();
     log.info(`[purpose-research] 🔬 Running research for "${purpose.name}"`);
 
@@ -261,12 +306,16 @@ CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
       if (typeof api.runAgentTurn === "function") {
         try {
           result = await api.runAgentTurn({
-            sessionLabel: `chorus:purpose:${purpose.id}`,
+            sessionLabel: `chorus-purpose-${purpose.id}`,
             message: prompt,
             isolated: true,
             timeoutSeconds: config.researchTimeoutMs / 1000,
           });
-          output = result?.response || "";
+          output = extractTextFromApiResult(result);
+          if (!output.trim()) {
+            log.debug(`[purpose-research] API returned empty output, falling back to CLI for "${purpose.name}"`);
+            result = null;
+          }
         } catch (apiErr) {
           log.debug(`[purpose-research] API runAgentTurn failed, falling back to CLI: ${apiErr}`);
           result = null;
@@ -279,7 +328,7 @@ CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
         result = await new Promise<any>((resolve) => {
           const child = spawn("openclaw", [
             "agent",
-            "--session-id", `chorus:purpose:${purpose.id}`,
+            "--session-id", `chorus-purpose-${purpose.id}`,
             "--message", prompt,
             "--json",
           ], { stdio: ['pipe', 'pipe', 'pipe'] });
@@ -296,16 +345,15 @@ CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
         });
 
         if (result.status === 0 && result.stdout) {
-          try {
-            const json = JSON.parse(result.stdout);
-            output = json.result?.payloads?.[0]?.text || json.response || "";
-          } catch {
-            output = result.stdout;
-          }
+          output = extractTextFromCliStdout(result.stdout);
         } else if (result.stderr) {
           log.error(`[purpose-research] CLI error: ${result.stderr}`);
         }
       }
+
+      if (!output.trim()) {
+        throw new Error("No research output produced");
+      }
       execution.durationMs = Date.now() - startTime;
       execution.success = true;
       execution.outputLength = output.length;
@@ -343,16 +391,19 @@ CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
           runCount: (purpose.research?.runCount ?? 0) + 1,
         },
       });
+      dailyRuns.count++;
+      persistState();
+      return true;
     } catch (err) {
       execution.durationMs = Date.now() - startTime;
       execution.success = false;
       execution.error = String(err);
       log.error(`[purpose-research] ✗ "${purpose.name}" failed: ${err}`);
+      return false;
+    } finally {
+      runningPurposes.delete(purpose.id);
+      recordExecution(execution);
     }
-
-    recordExecution(execution);
-    dailyRuns.count++;
-    persistState();
   }
 
   async function checkAndRun(): Promise<void> {
@@ -442,7 +493,10 @@ CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
       const purposes = await loadPurposes();
       const purpose = purposes.find((p) => p.id === purposeId);
       if (!purpose) throw new Error(`Purpose "${purposeId}" not found`);
-      await runResearch(purpose);
+      const success = await runResearch(purpose);
+      if (!success) {
+        throw new Error(`Research run failed for "${purposeId}"`);
+      }
     },
 
     getStatus: () => {