@iamoberlin/chorus 1.3.4 → 1.3.6

package/index.ts

@@ -8,6 +8,9 @@
 
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { spawnSync } from "child_process";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 import { loadChorusConfig, type ChorusPluginConfig } from "./src/config.js";
 import { createSecurityHooks } from "./src/security.js";
 import { createChoirScheduler } from "./src/scheduler.js";
@@ -38,7 +41,37 @@ import {
 import * as prayers from "./src/prayers/prayers.js";
 import * as prayerStore from "./src/prayers/store.js";
 
-const VERSION = "1.3.4"; // Restore --message flag (required by openclaw agent CLI)
+const VERSION = "1.3.5"; // Vision now updates run-state.json
+
+// Run state persistence for Vision mode
+const CHORUS_DIR = join(homedir(), ".chorus");
+const RUN_STATE_PATH = join(CHORUS_DIR, "run-state.json");
+
+function updateRunState(choirId: string, output: string): void {
+  try {
+    if (!existsSync(CHORUS_DIR)) {
+      mkdirSync(CHORUS_DIR, { recursive: true });
+    }
+    
+    let state: Record<string, any> = {};
+    if (existsSync(RUN_STATE_PATH)) {
+      try {
+        state = JSON.parse(readFileSync(RUN_STATE_PATH, "utf-8"));
+      } catch { /* start fresh */ }
+    }
+    
+    const existing = state[choirId] || { runCount: 0 };
+    state[choirId] = {
+      lastRun: new Date().toISOString(),
+      lastOutput: output.slice(0, 500),
+      runCount: (existing.runCount || 0) + 1,
+    };
+    
+    writeFileSync(RUN_STATE_PATH, JSON.stringify(state, null, 2));
+  } catch (err) {
+    // Silent fail — don't break Vision for state issues
+  }
+}
 
 const plugin = {
   id: "chorus",
@@ -382,10 +415,13 @@ const plugin = {
                       const text = json.result?.payloads?.[0]?.text || '';
                       const duration = json.result?.meta?.durationMs || 0;
                       contextStore.set(`${choirId}:d${day}`, text.slice(0, 2000)); // Keep 2KB of response
+                      updateRunState(choirId, text); // Update scheduler state
                       successfulRuns++;
                       console.log(` ✓ (${(duration/1000).toFixed(1)}s)`);
                     } catch {
-                      contextStore.set(`${choirId}:d${day}`, result.stdout?.slice(-2000) || `[${choir.name} completed]`);
+                      const output = result.stdout?.slice(-2000) || `[${choir.name} completed]`;
+                      contextStore.set(`${choirId}:d${day}`, output);
+                      updateRunState(choirId, output); // Update scheduler state
                       successfulRuns++;
                       console.log(` ✓`);
                     }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "chorus",
   "name": "CHORUS",
   "description": "CHORUS: Hierarchy Of Recursive Unified Self-improvement",
-  "version": "1.3.4",
+  "version": "1.1.3",
   "author": "Oberlin",
   "homepage": "https://chorus.oberlin.ai",
   "repository": "https://github.com/iamoberlin/chorus",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamoberlin/chorus",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "description": "CHORUS: Hierarchy Of Recursive Unified Self-improvement — with Prayer Requests social network",
   "author": "Oberlin <iam@oberlin.ai>",
   "license": "MIT",

package/src/choirs.ts

@@ -413,12 +413,19 @@ export function getChoir(id: string): Choir | undefined {
   return CHOIRS[id];
 }
 
+// Global minimum interval to prevent over-triggering during rapid restarts or testing
+// Even if a choir's config says 0 or very short, enforce at least this many minutes
+const MIN_INTERVAL_MINUTES = 30;
+
 // Check if a choir should run based on its interval
 export function shouldRunChoir(choir: Choir, now: Date, lastRun?: Date): boolean {
   if (!lastRun) return true;
 
   const minutesSinceLastRun = (now.getTime() - lastRun.getTime()) / 1000 / 60;
-  return minutesSinceLastRun >= choir.intervalMinutes;
+  
+  // Enforce both the choir's configured interval AND the global minimum
+  const effectiveInterval = Math.max(choir.intervalMinutes, MIN_INTERVAL_MINUTES);
+  return minutesSinceLastRun >= effectiveInterval;
 }
 
 // Get human-readable frequency

package/src/purpose-research.ts

@@ -11,7 +11,7 @@ import { recordExecution, type ChoirExecution } from "./metrics.js";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { spawn } from "child_process";
+import { spawnSync } from "child_process";
 
 // Workspace path for research output
 const WORKSPACE_PATH = process.env.OPENCLAW_WORKSPACE || join(homedir(), ".openclaw", "workspace");
@@ -274,25 +274,17 @@ CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
       }
 
       if (!result) {
-        // CLI fallback - use stdin to avoid arg length limits (async to avoid blocking event loop)
+        // CLI fallback - use stdin to avoid arg length limits
         log.debug(`[purpose-research] Using CLI fallback for "${purpose.name}"`);
-        result = await new Promise<any>((resolve) => {
-          const child = spawn("openclaw", [
-            "agent",
-            "--session-id", `chorus:purpose:${purpose.id}`,
-            "--message", prompt,
-            "--json",
-          ], { stdio: ['pipe', 'pipe', 'pipe'] });
-
-          let stdout = '';
-          let stderr = '';
-          const maxBuffer = 1024 * 1024;
-          child.stdout.on('data', (d: Buffer) => { if (stdout.length < maxBuffer) stdout += d.toString(); });
-          child.stderr.on('data', (d: Buffer) => { if (stderr.length < maxBuffer) stderr += d.toString(); });
-
-          const timer = setTimeout(() => { child.kill('SIGTERM'); }, config.researchTimeoutMs);
-          child.on('close', (code) => { clearTimeout(timer); resolve({ status: code, stdout, stderr }); });
-          child.on('error', (err) => { clearTimeout(timer); resolve({ status: 1, stdout: '', stderr: String(err) }); });
+        result = spawnSync("openclaw", [
+          "agent",
+          "--session-id", `chorus:purpose:${purpose.id}`,
+          "--json",
+        ], {
+          input: prompt,
+          encoding: "utf-8",
+          timeout: config.researchTimeoutMs,
+          maxBuffer: 1024 * 1024, // 1MB
         });
 
         if (result.status === 0 && result.stdout) {

package/src/scheduler.ts

@@ -12,7 +12,7 @@ import { recordExecution, type ChoirExecution } from "./metrics.js";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { spawn } from "child_process";
+import { spawnSync } from "child_process";
 
 interface ChoirContext {
   choirId: string;
@@ -128,28 +128,20 @@ export function createChoirScheduler(
     try {
       const prompt = buildPrompt(choir);
 
-      // Use openclaw agent CLI (async to avoid blocking event loop)
-      const result = await new Promise<{ status: number | null; stdout: string; stderr: string }>((resolve) => {
-        const child = spawn('openclaw', [
-          'agent',
-          '--session-id', `chorus:${choir.id}`,
-          '--message', prompt,
-          '--json',
-        ], { stdio: ['pipe', 'pipe', 'pipe'] });
-
-        let stdout = '';
-        let stderr = '';
-        const maxBuffer = 1024 * 1024;
-        child.stdout.on('data', (d: Buffer) => { if (stdout.length < maxBuffer) stdout += d.toString(); });
-        child.stderr.on('data', (d: Buffer) => { if (stderr.length < maxBuffer) stderr += d.toString(); });
-
-        const timer = setTimeout(() => { child.kill('SIGTERM'); }, 300000); // 5 min
-        child.on('close', (code) => { clearTimeout(timer); resolve({ status: code, stdout, stderr }); });
-        child.on('error', (err) => { clearTimeout(timer); resolve({ status: 1, stdout: '', stderr: String(err) }); });
+      // Use openclaw agent CLI (same as Vision mode)
+      const result = spawnSync('openclaw', [
+        'agent',
+        '--session-id', `chorus:${choir.id}`,
+        '--message', prompt,
+        '--json',
+      ], {
+        encoding: 'utf-8',
+        timeout: 300000, // 5 min
+        maxBuffer: 1024 * 1024, // 1MB
       });
 
       let output = "(no response)";
-
+      
       if (result.status === 0 && result.stdout) {
         // Extract JSON from output (may have plugin logs before it)
         const stdout = result.stdout;