@iamoberlin/chorus 1.1.4

package/src/daemon.ts

@@ -0,0 +1,287 @@
+/**
+ * CHORUS Daemon
+ *
+ * Autonomous attention loop that monitors senses,
+ * filters for salience, and invokes cognition when needed.
+ */
+
+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 { recordExecution, type ChoirExecution } from "./metrics.js";
+
+export interface DaemonConfig {
+  enabled: boolean;
+  senses: {
+    inbox: boolean;
+    purposes: boolean;
+    time: boolean;
+  };
+  thinkThreshold: number;    // Minimum priority to invoke cognition
+  pollIntervalMs: number;    // How often to poll senses
+  minSleepMs: number;        // Minimum sleep between cycles
+  maxSleepMs: number;        // Maximum sleep (night/idle)
+  quietHoursStart: number;   // Hour to start quiet mode (e.g., 23)
+  quietHoursEnd: number;     // Hour to end quiet mode (e.g., 7)
+}
+
+export const DEFAULT_DAEMON_CONFIG: DaemonConfig = {
+  enabled: true,
+  senses: {
+    inbox: true,
+    purposes: true,
+    time: true,
+  },
+  thinkThreshold: 55,
+  pollIntervalMs: 5 * 60 * 1000,  // 5 minutes
+  minSleepMs: 30 * 1000,          // 30 seconds
+  maxSleepMs: 10 * 60 * 1000,     // 10 minutes
+  quietHoursStart: 23,
+  quietHoursEnd: 7,
+};
+
+interface AttentionItem extends Signal {
+  salienceScore: number;
+  rulesApplied: string[];
+}
+
+export function createDaemon(
+  config: DaemonConfig,
+  log: PluginLogger,
+  api: any  // OpenClawPluginApi
+) {
+  const filter = new SalienceFilter([], config.thinkThreshold);
+  const attentionQueue: AttentionItem[] = [];
+  const cleanupFns: (() => void)[] = [];
+  
+  let pollInterval: NodeJS.Timeout | null = null;
+  let running = false;
+
+  // Get enabled senses
+  function getEnabledSenses(): Sense[] {
+    return ALL_SENSES.filter(sense => {
+      if (sense.id === "inbox" && !config.senses.inbox) return false;
+      if (sense.id === "purposes" && !config.senses.purposes) return false;
+      if (sense.id === "time" && !config.senses.time) return false;
+      return true;
+    });
+  }
+
+  // Process a signal through salience filter
+  function processSignal(signal: Signal): void {
+    const result = filter.evaluate(signal);
+    
+    log.debug(
+      `[daemon] Signal: "${signal.content.slice(0, 50)}..." ` +
+      `(${signal.priority} → ${result.finalPriority}, rules: ${result.rulesApplied.join(",")})`
+    );
+
+    if (result.shouldAttend) {
+      attentionQueue.push({
+        ...signal,
+        salienceScore: result.finalPriority,
+        rulesApplied: result.rulesApplied,
+      });
+      
+      log.info(
+        `[daemon] 👁️ Queued: "${signal.content.slice(0, 60)}..." (priority: ${result.finalPriority})`
+      );
+    }
+  }
+
+  // Poll all senses
+  async function pollSenses(): Promise<void> {
+    for (const sense of getEnabledSenses()) {
+      if (sense.poll) {
+        try {
+          const signals = await sense.poll();
+          for (const signal of signals) {
+            processSignal(signal);
+          }
+        } catch (err) {
+          log.error(`[daemon] Sense ${sense.id} poll failed: ${err}`);
+        }
+      }
+    }
+  }
+
+  // Start watchers for event-based senses
+  function startWatchers(): void {
+    for (const sense of getEnabledSenses()) {
+      if (sense.watch) {
+        try {
+          const cleanup = sense.watch(processSignal);
+          cleanupFns.push(cleanup);
+          log.info(`[daemon] 👁️ Watching: ${sense.description}`);
+        } catch (err) {
+          log.error(`[daemon] Sense ${sense.id} watch failed: ${err}`);
+        }
+      }
+    }
+  }
+
+  // Process the highest priority item in queue
+  async function processQueue(): Promise<void> {
+    if (attentionQueue.length === 0) return;
+
+    // Sort by salience score (highest first)
+    attentionQueue.sort((a, b) => b.salienceScore - a.salienceScore);
+    
+    const item = attentionQueue.shift()!;
+    const startTime = Date.now();
+
+    log.info(`[daemon] 🧠 Attending: "${item.content.slice(0, 80)}..." (priority: ${item.salienceScore})`);
+
+    // Build prompt for cognition
+    const prompt = buildAttentionPrompt(item);
+
+    const execution: ChoirExecution = {
+      choirId: "daemon",
+      timestamp: new Date().toISOString(),
+      durationMs: 0,
+      success: false,
+      outputLength: 0,
+    };
+
+    try {
+      const result = await api.runAgentTurn?.({
+        sessionLabel: "chorus:daemon",
+        message: prompt,
+        isolated: true,
+        timeoutSeconds: 180,
+      });
+
+      execution.durationMs = Date.now() - startTime;
+      execution.success = true;
+      execution.outputLength = result?.response?.length || 0;
+      execution.tokensUsed = result?.meta?.tokensUsed;
+
+      log.info(`[daemon] ✓ Completed in ${(execution.durationMs / 1000).toFixed(1)}s`);
+
+    } catch (err) {
+      execution.durationMs = Date.now() - startTime;
+      execution.success = false;
+      execution.error = String(err);
+      log.error(`[daemon] ✗ Failed: ${err}`);
+    }
+
+    // Record metrics
+    recordExecution(execution);
+  }
+
+  function buildAttentionPrompt(item: AttentionItem): string {
+    const parts = [
+      "## DAEMON ATTENTION SIGNAL",
+      "",
+      `**Source:** ${item.source}`,
+      `**Priority:** ${item.salienceScore}/100`,
+      `**Time:** ${item.timestamp.toISOString()}`,
+      "",
+      "**Content:**",
+      item.content,
+      "",
+    ];
+
+    if (item.metadata && Object.keys(item.metadata).length > 0) {
+      parts.push("**Metadata:**");
+      parts.push("```json");
+      parts.push(JSON.stringify(item.metadata, null, 2));
+      parts.push("```");
+      parts.push("");
+    }
+
+    parts.push("---");
+    parts.push("");
+    parts.push("Evaluate this signal. Determine if action is needed.");
+    parts.push("");
+    parts.push("If action needed:");
+    parts.push("- Take the action directly (update files, send messages, etc.)");
+    parts.push("- Log what you did in today's memory file");
+    parts.push("");
+    parts.push("If no action needed:");
+    parts.push("- Briefly explain why and move on");
+    parts.push("");
+    parts.push("Be concise. This is autonomous processing, not a conversation.");
+
+    return parts.join("\n");
+  }
+
+  // Calculate adaptive sleep time
+  function calculateSleepTime(): number {
+    const hour = new Date().getHours();
+    const isQuietHours = hour >= config.quietHoursStart || hour < config.quietHoursEnd;
+
+    // Check queue pressure
+    const queuePressure = attentionQueue.length > 0
+      ? Math.max(...attentionQueue.map(i => i.salienceScore))
+      : 0;
+
+    if (queuePressure > 80) return config.minSleepMs;
+    if (queuePressure > 60) return config.minSleepMs * 2;
+    if (isQuietHours) return config.maxSleepMs;
+    
+    return config.pollIntervalMs;
+  }
+
+  // Main daemon service
+  return {
+    id: "chorus-daemon",
+
+    start: () => {
+      if (!config.enabled) {
+        log.info("[daemon] Disabled in config");
+        return;
+      }
+
+      running = true;
+      log.info("[daemon] 🌅 Daemon starting...");
+
+      // Start event watchers
+      startWatchers();
+
+      // Initial poll
+      pollSenses().catch(err => log.error(`[daemon] Initial poll failed: ${err}`));
+
+      // Periodic polling
+      pollInterval = setInterval(async () => {
+        if (!running) return;
+
+        try {
+          await pollSenses();
+          await processQueue();
+        } catch (err) {
+          log.error(`[daemon] Cycle error: ${err}`);
+        }
+      }, config.pollIntervalMs);
+
+      log.info(`[daemon] 👁️ Active — polling every ${config.pollIntervalMs / 1000}s, threshold: ${config.thinkThreshold}`);
+    },
+
+    stop: () => {
+      running = false;
+      log.info("[daemon] Stopping...");
+
+      if (pollInterval) {
+        clearInterval(pollInterval);
+        pollInterval = null;
+      }
+
+      for (const cleanup of cleanupFns) {
+        try {
+          cleanup();
+        } catch {}
+      }
+      cleanupFns.length = 0;
+
+      attentionQueue.length = 0;
+      log.info("[daemon] Stopped");
+    },
+
+    // Expose for CLI
+    getQueueSize: () => attentionQueue.length,
+    getQueue: () => [...attentionQueue],
+    forceProcess: () => processQueue(),
+    forcePoll: () => pollSenses(),
+  };
+}

package/src/metrics.ts

@@ -0,0 +1,241 @@
+/**
+ * CHORUS Metrics System
+ *
+ * Tracks quantitative and qualitative metrics for choir executions.
+ * Persists to ~/.chorus/metrics.json
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export interface ChoirExecution {
+  choirId: string;
+  timestamp: string;
+  durationMs: number;
+  tokensUsed?: number;
+  success: boolean;
+  error?: string;
+  outputLength: number;
+  findings?: number; // For research choirs
+  alerts?: number; // For monitoring choirs
+  improvements?: string[]; // For RSI (Virtues)
+}
+
+export interface DailyMetrics {
+  date: string;
+  executions: ChoirExecution[];
+  summary: {
+    totalRuns: number;
+    successfulRuns: number;
+    failedRuns: number;
+    totalDurationMs: number;
+    totalTokens: number;
+    totalFindings: number;
+    totalAlerts: number;
+    improvements: string[];
+    costEstimateUsd: number;
+  };
+  qualityScore?: number; // 1-5, set manually or by review
+  notes?: string;
+}
+
+export interface MetricsStore {
+  version: number;
+  days: Record<string, DailyMetrics>;
+  totals: {
+    allTimeRuns: number;
+    allTimeSuccesses: number;
+    allTimeFindings: number;
+    allTimeAlerts: number;
+    allTimeImprovements: number;
+  };
+}
+
+const METRICS_DIR = join(homedir(), ".chorus");
+const METRICS_FILE = join(METRICS_DIR, "metrics.json");
+const COST_PER_1K_TOKENS = 0.003; // Approximate for Claude Sonnet
+
+function ensureMetricsDir(): void {
+  if (!existsSync(METRICS_DIR)) {
+    mkdirSync(METRICS_DIR, { recursive: true });
+  }
+}
+
+function loadMetrics(): MetricsStore {
+  ensureMetricsDir();
+  if (existsSync(METRICS_FILE)) {
+    try {
+      return JSON.parse(readFileSync(METRICS_FILE, "utf-8"));
+    } catch {
+      // Corrupted file, start fresh
+    }
+  }
+  return {
+    version: 1,
+    days: {},
+    totals: {
+      allTimeRuns: 0,
+      allTimeSuccesses: 0,
+      allTimeFindings: 0,
+      allTimeAlerts: 0,
+      allTimeImprovements: 0,
+    },
+  };
+}
+
+function saveMetrics(store: MetricsStore): void {
+  ensureMetricsDir();
+  writeFileSync(METRICS_FILE, JSON.stringify(store, null, 2));
+}
+
+function getDateKey(date: Date = new Date()): string {
+  return date.toISOString().split("T")[0];
+}
+
+function getOrCreateDay(store: MetricsStore, dateKey: string): DailyMetrics {
+  if (!store.days[dateKey]) {
+    store.days[dateKey] = {
+      date: dateKey,
+      executions: [],
+      summary: {
+        totalRuns: 0,
+        successfulRuns: 0,
+        failedRuns: 0,
+        totalDurationMs: 0,
+        totalTokens: 0,
+        totalFindings: 0,
+        totalAlerts: 0,
+        improvements: [],
+        costEstimateUsd: 0,
+      },
+    };
+  }
+  return store.days[dateKey];
+}
+
+function updateDaySummary(day: DailyMetrics): void {
+  const execs = day.executions;
+  day.summary = {
+    totalRuns: execs.length,
+    successfulRuns: execs.filter((e) => e.success).length,
+    failedRuns: execs.filter((e) => !e.success).length,
+    totalDurationMs: execs.reduce((sum, e) => sum + e.durationMs, 0),
+    totalTokens: execs.reduce((sum, e) => sum + (e.tokensUsed || 0), 0),
+    totalFindings: execs.reduce((sum, e) => sum + (e.findings || 0), 0),
+    totalAlerts: execs.reduce((sum, e) => sum + (e.alerts || 0), 0),
+    improvements: execs.flatMap((e) => e.improvements || []),
+    costEstimateUsd: execs.reduce((sum, e) => sum + ((e.tokensUsed || 0) / 1000) * COST_PER_1K_TOKENS, 0),
+  };
+}
+
+export function recordExecution(execution: ChoirExecution): void {
+  const store = loadMetrics();
+  const dateKey = getDateKey(new Date(execution.timestamp));
+  const day = getOrCreateDay(store, dateKey);
+
+  day.executions.push(execution);
+  updateDaySummary(day);
+
+  // Update totals
+  store.totals.allTimeRuns++;
+  if (execution.success) store.totals.allTimeSuccesses++;
+  store.totals.allTimeFindings += execution.findings || 0;
+  store.totals.allTimeAlerts += execution.alerts || 0;
+  store.totals.allTimeImprovements += (execution.improvements || []).length;
+
+  saveMetrics(store);
+}
+
+export function getTodayMetrics(): DailyMetrics | null {
+  const store = loadMetrics();
+  return store.days[getDateKey()] || null;
+}
+
+export function getMetricsForDate(date: string): DailyMetrics | null {
+  const store = loadMetrics();
+  return store.days[date] || null;
+}
+
+export function getRecentMetrics(days: number = 7): DailyMetrics[] {
+  const store = loadMetrics();
+  const result: DailyMetrics[] = [];
+  const now = new Date();
+
+  for (let i = 0; i < days; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    const key = getDateKey(d);
+    if (store.days[key]) {
+      result.push(store.days[key]);
+    }
+  }
+
+  return result;
+}
+
+export function getTotals(): MetricsStore["totals"] {
+  return loadMetrics().totals;
+}
+
+export function setQualityScore(date: string, score: number, notes?: string): void {
+  const store = loadMetrics();
+  const day = store.days[date];
+  if (day) {
+    day.qualityScore = Math.max(1, Math.min(5, score));
+    if (notes) day.notes = notes;
+    saveMetrics(store);
+  }
+}
+
+export function formatMetricsSummary(metrics: DailyMetrics): string {
+  const s = metrics.summary;
+  const successRate = s.totalRuns > 0 ? ((s.successfulRuns / s.totalRuns) * 100).toFixed(0) : "0";
+  const avgDuration = s.totalRuns > 0 ? (s.totalDurationMs / s.totalRuns / 1000).toFixed(1) : "0";
+
+  return `
+📊 CHORUS Metrics — ${metrics.date}
+${"═".repeat(40)}
+
+Executions:     ${s.totalRuns} runs (${successRate}% success)
+Duration:       ${(s.totalDurationMs / 1000).toFixed(0)}s total, ${avgDuration}s avg
+Tokens:         ${s.totalTokens.toLocaleString()} (~$${s.costEstimateUsd.toFixed(2)})
+Findings:       ${s.totalFindings}
+Alerts:         ${s.totalAlerts}
+Improvements:   ${s.improvements.length > 0 ? s.improvements.join(", ") : "none"}
+Quality Score:  ${metrics.qualityScore ? `${metrics.qualityScore}/5` : "not rated"}
+${metrics.notes ? `Notes:          ${metrics.notes}` : ""}
+`.trim();
+}
+
+export function formatWeeklySummary(): string {
+  const recent = getRecentMetrics(7);
+  const totals = getTotals();
+
+  if (recent.length === 0) {
+    return "No metrics recorded yet.";
+  }
+
+  const weekRuns = recent.reduce((sum, d) => sum + d.summary.totalRuns, 0);
+  const weekSuccesses = recent.reduce((sum, d) => sum + d.summary.successfulRuns, 0);
+  const weekFindings = recent.reduce((sum, d) => sum + d.summary.totalFindings, 0);
+  const weekCost = recent.reduce((sum, d) => sum + d.summary.costEstimateUsd, 0);
+  const avgQuality = recent.filter((d) => d.qualityScore).reduce((sum, d) => sum + (d.qualityScore || 0), 0) / 
+    (recent.filter((d) => d.qualityScore).length || 1);
+
+  return `
+📊 CHORUS Weekly Summary
+${"═".repeat(40)}
+
+Last 7 Days:
+  Runs:         ${weekRuns} (${((weekSuccesses / weekRuns) * 100).toFixed(0)}% success)
+  Findings:     ${weekFindings}
+  Cost:         ~$${weekCost.toFixed(2)}
+  Avg Quality:  ${avgQuality > 0 ? `${avgQuality.toFixed(1)}/5` : "not rated"}
+
+All Time:
+  Total Runs:   ${totals.allTimeRuns.toLocaleString()}
+  Findings:     ${totals.allTimeFindings}
+  Improvements: ${totals.allTimeImprovements}
+`.trim();
+}