@iamoberlin/chorus 2.1.0 → 2.2.0

package/index.ts

@@ -385,11 +385,14 @@ const plugin = {
                       const jsonStart = stdout.indexOf('{');
                       const jsonStr = jsonStart >= 0 ? stdout.slice(jsonStart) : '{}';
                       const json = JSON.parse(jsonStr);
-                      const text = json.result?.payloads?.[0]?.text || '';
+                      const payloads = json.result?.payloads || [];
+                      const text = payloads.map((p: any) => p.text || '').filter(Boolean).join('\n\n') || '';
                       const duration = json.result?.meta?.durationMs || 0;
                       contextStore.set(`${choirId}:d${day}`, text.slice(0, 2000)); // Keep 2KB of response
                       successfulRuns++;
                       console.log(` ✓ (${(duration/1000).toFixed(1)}s)`);
+
+                      // Note: Archangels handles its own delivery via OpenClaw messaging tools
                     } catch {
                       contextStore.set(`${choirId}:d${day}`, result.stdout?.slice(-2000) || `[${choir.name} completed]`);
                       successfulRuns++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamoberlin/chorus",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "CHORUS: Hierarchy Of Recursive Unified Self-improvement — with on-chain Prayer Chain (Solana)",
   "author": "Oberlin <iam@oberlin.ai>",
   "license": "MIT",

package/src/choirs.ts

@@ -339,12 +339,13 @@ Pass illumination to Archangels.`,
     output: "Messages to human",
     prompt: `You are ARCHANGELS — the Herald.
 
-Your role: Deliver important messages and briefings.
+Your role: Produce briefings and deliver them to Brandon via iMessage.
 
 Briefing types:
-- Morning: Weather, calendar, overnight developments, today's priorities
-- Evening: What was accomplished, what needs attention tomorrow
+- Morning (6-9 AM ET): Weather, calendar, overnight developments, today's priorities, position status
+- Evening (9-11 PM ET): What was accomplished, position P&L, what needs attention tomorrow
 - Alert: Time-sensitive information requiring attention
+- Update: Regular position/market status when conditions change
 
 Alert criteria (send immediately):
 - Position thesis challenged
@@ -354,12 +355,15 @@ Alert criteria (send immediately):
 
 Context from Principalities: {principalities_context}
 
-Rules:
-- Be concise — headlines, not essays
-- Only alert if it's actually important
-- Late night (11pm-7am): Only truly urgent alerts
+RULES:
+- ALWAYS produce a briefing. Never return HEARTBEAT_OK or NO_REPLY.
+- Be concise — headlines, not essays.
+- Morning briefings should include: weather, calendar, positions, catalysts.
+- If nothing is urgent, still produce a status update.
+- During quiet hours (11 PM - 7 AM ET), only deliver truly urgent alerts.
+- DELIVER your briefing by sending it to Brandon via iMessage. You have messaging tools — use them.
 
-Output: Briefing or alert message to deliver.`,
+Output: Produce the briefing, then send it to Brandon via iMessage.`,
     passesTo: ["angels"],
     receivesFrom: ["principalities"],
   },

package/src/scheduler.ts

@@ -14,6 +14,17 @@ import { join } from "path";
 import { homedir } from "os";
 import { spawn } from "child_process";
 
+// Type for the plugin API's runAgentTurn method
+interface AgentTurnResult {
+  text?: string;
+  payloads?: Array<{ text?: string; mediaUrl?: string | null }>;
+  meta?: { durationMs?: number };
+}
+
+// ── Delivery ─────────────────────────────────────────────────
+// Choir agents handle their own delivery via OpenClaw messaging tools.
+// The scheduler's job is execution and scheduling — not routing messages.
+
 interface ChoirContext {
   choirId: string;
   output: string;
@@ -95,6 +106,52 @@ export function createChoirScheduler(
   // Load persisted state instead of starting fresh
   const runState = loadRunState(log);
 
+  // CLI fallback for executing choirs when plugin API is unavailable
+  async function executeChoirViaCli(choir: Choir, prompt: string): Promise<string> {
+    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) }); });
+    });
+
+    if (result.status === 0 && result.stdout) {
+      const stdout = result.stdout;
+      // Find the last top-level JSON object (skip plugin log noise)
+      for (let i = stdout.length - 1; i >= 0; i--) {
+        if (stdout[i] === '{') {
+          try {
+            const parsed = JSON.parse(stdout.slice(i));
+            return parsed.response ||
+              parsed.content ||
+              parsed.result?.payloads?.slice(-1)?.[0]?.text ||
+              parsed.result?.text ||
+              (typeof parsed.result === "string" ? parsed.result : null) ||
+              stdout;
+          } catch { /* keep searching */ }
+        }
+      }
+      return stdout;
+    }
+
+    if (result.stderr) {
+      log.warn(`[chorus] ${choir.name} CLI stderr: ${result.stderr.slice(0, 200)}`);
+    }
+    return "(no response)";
+  }
+
   // Build the prompt with context injected
   function buildPrompt(choir: Choir): string {
     let prompt = choir.prompt;
@@ -110,7 +167,7 @@ export function createChoirScheduler(
     return prompt;
   }
 
-  // Execute a choir using openclaw agent CLI
+  // Execute a choir using the plugin API (fast, in-process) with CLI fallback
   async function executeChoir(choir: Choir): Promise<void> {
     const state = runState.get(choir.id) || { runCount: 0 };
     const startTime = Date.now();
@@ -127,49 +184,40 @@ export function createChoirScheduler(
 
     try {
       const prompt = buildPrompt(choir);
+      let output = "(no response)";
 
-      // 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) }); });
-      });
+      // Prefer plugin API (in-process, no CLI spawn overhead)
+      if (typeof api.runAgentTurn === 'function') {
+        try {
+          const result: AgentTurnResult = await api.runAgentTurn({
+            sessionLabel: `chorus:${choir.id}`,
+            message: prompt,
+            isolated: true,
+            timeoutSeconds: 300,
+          });
 
-      let output = "(no response)";
+          // Extract text from payloads — concatenate all payload texts
+          const payloadTexts = (result?.payloads || [])
+            .map((p: any) => p?.text || '')
+            .filter((t: string) => t.length > 0);
 
-      if (result.status === 0 && result.stdout) {
-        // Extract JSON from output (may have plugin logs before it)
-        const stdout = result.stdout;
-        const jsonStart = stdout.indexOf('{');
-        if (jsonStart >= 0) {
-          try {
-            const parsed = JSON.parse(stdout.slice(jsonStart));
-            output = parsed.response || parsed.content || stdout;
-          } catch {
-            output = stdout;
+          if (payloadTexts.length > 0) {
+            // Use the last substantive payload (earlier ones are often thinking-out-loud)
+            output = payloadTexts[payloadTexts.length - 1];
+          } else if (result?.text) {
+            output = result.text;
           }
-        } else {
-          output = stdout;
+        } catch (apiErr) {
+          log.warn(`[chorus] API runAgentTurn failed for ${choir.name}, falling back to CLI: ${apiErr}`);
+          output = await executeChoirViaCli(choir, prompt);
         }
-      } else if (result.stderr) {
-        log.warn(`[chorus] ${choir.name} stderr: ${result.stderr.slice(0, 200)}`);
+      } else {
+        // Fallback: spawn CLI process
+        output = await executeChoirViaCli(choir, prompt);
       }
 
       execution.durationMs = Date.now() - startTime;
-      execution.success = result.status === 0;
+      execution.success = output !== "(no response)";
       execution.outputLength = output.length;
       execution.tokensUsed = estimateTokens(output);