openpersona 0.2.0 → 0.4.0

package/layers/faculties/music/scripts/compose.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+/**
+ * OpenPersona Music Faculty — ElevenLabs Music API (music_v1)
+ *
+ * Usage:
+ *   node compose.js "a soft piano piece about starlight"
+ *   node compose.js "dreamy lo-fi beats" --instrumental
+ *   node compose.js "indie folk ballad" --plan
+ *   node compose.js "upbeat pop" --output ./song.mp3 --duration 60
+ *
+ * Environment:
+ *   ELEVENLABS_API_KEY  - ElevenLabs API key (shared with voice faculty)
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const API_BASE = 'https://api.elevenlabs.io';
+const DEFAULT_FORMAT = 'mp3_44100_128';
+
+// --- Argument parsing ---
+function parseArgs(args) {
+  const opts = {
+    prompt: '',
+    instrumental: false,
+    plan: false,
+    duration: null,        // seconds; null = let model decide
+    format: DEFAULT_FORMAT,
+    output: null,
+    channel: '',
+    caption: '',
+  };
+  let i = 0;
+  while (i < args.length) {
+    switch (args[i]) {
+      case '--instrumental': opts.instrumental = true; break;
+      case '--plan':         opts.plan = true; break;
+      case '--duration':     opts.duration = parseInt(args[++i], 10); break;
+      case '--format':       opts.format = args[++i]; break;
+      case '--output':       opts.output = args[++i]; break;
+      case '--channel':      opts.channel = args[++i]; break;
+      case '--caption':      opts.caption = args[++i]; break;
+      case '--help':
+      case '-h':
+        printUsage();
+        process.exit(0);
+      default:
+        if (!opts.prompt) opts.prompt = args[i];
+        break;
+    }
+    i++;
+  }
+  return opts;
+}
+
+function printUsage() {
+  console.log(`
+Usage: node compose.js <prompt> [options]
+
+Options:
+  --instrumental      Generate instrumental only (no vocals)
+  --plan              Use composition plan mode (structured sections)
+  --duration <secs>   Song length in seconds (3-600, default: auto)
+  --format <format>   Output format (default: mp3_44100_128)
+  --output <path>     Save audio to file
+  --channel <channel> Send to OpenClaw channel
+  --caption <text>    Message caption for channel
+
+Formats: mp3_44100_128, mp3_44100_192, mp3_44100_64, pcm_44100, opus_48000_128
+
+Examples:
+  node compose.js "a soft ambient piano piece about starlight"
+  node compose.js "indie folk ballad" --plan --output ./song.mp3
+  node compose.js "dreamy lo-fi beats" --instrumental --duration 60
+`);
+}
+
+// --- HTTP helpers ---
+function apiRequest(endpoint, options = {}) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(endpoint, API_BASE);
+    if (options.query) {
+      for (const [k, v] of Object.entries(options.query)) {
+        url.searchParams.set(k, v);
+      }
+    }
+
+    const reqOpts = {
+      method: options.method || 'POST',
+      headers: {
+        'xi-api-key': options.apiKey,
+        'Content-Type': 'application/json',
+        ...options.headers,
+      },
+    };
+
+    const req = https.request(url, reqOpts, (res) => {
+      // For streaming audio, return the raw response
+      if (options.stream) {
+        resolve({ status: res.statusCode, headers: res.headers, stream: res });
+        return;
+      }
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        const body = Buffer.concat(chunks).toString();
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(body) });
+        } catch {
+          resolve({ status: res.statusCode, data: body });
+        }
+      });
+    });
+    req.on('error', reject);
+    if (options.body) req.write(typeof options.body === 'string' ? options.body : JSON.stringify(options.body));
+    req.end();
+  });
+}
+
+function streamToFile(stream, filePath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(filePath);
+    stream.pipe(file);
+    file.on('finish', () => { file.close(); resolve(); });
+    file.on('error', (e) => { fs.unlink(filePath, () => {}); reject(e); });
+    stream.on('error', (e) => { fs.unlink(filePath, () => {}); reject(e); });
+  });
+}
+
+function streamToBuffer(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on('data', (c) => chunks.push(c));
+    stream.on('end', () => resolve(Buffer.concat(chunks)));
+    stream.on('error', reject);
+  });
+}
+
+// --- Main ---
+async function main() {
+  const apiKey = process.env.ELEVENLABS_API_KEY;
+  if (!apiKey) {
+    console.error('Error: ELEVENLABS_API_KEY environment variable not set');
+    console.error('Get your API key from: https://elevenlabs.io');
+    console.error('(Same key used by the voice faculty)');
+    process.exit(1);
+  }
+
+  const opts = parseArgs(process.argv.slice(2));
+  if (!opts.prompt) {
+    printUsage();
+    process.exit(1);
+  }
+
+  const typeLabel = opts.instrumental ? 'Instrumental' : 'Song';
+  const modeLabel = opts.plan ? 'Plan' : 'Simple';
+  console.log(`🎵 Mode: ${modeLabel} | Type: ${typeLabel}`);
+  console.log(`   Prompt: ${opts.prompt.slice(0, 100)}${opts.prompt.length > 100 ? '...' : ''}`);
+  if (opts.duration) console.log(`   Duration: ${opts.duration}s`);
+
+  let compositionPlan = null;
+
+  // Step 1 (optional): Generate composition plan
+  if (opts.plan) {
+    console.log('📝 Generating composition plan...');
+    const planPayload = {
+      prompt: opts.prompt,
+      model_id: 'music_v1',
+    };
+    if (opts.duration) {
+      planPayload.music_length_ms = opts.duration * 1000;
+    }
+
+    const planRes = await apiRequest('/v1/music/plan', {
+      apiKey,
+      body: planPayload,
+    });
+
+    if (planRes.status !== 200) {
+      console.error(`Error: Plan API returned ${planRes.status}`);
+      console.error(typeof planRes.data === 'string' ? planRes.data : JSON.stringify(planRes.data, null, 2));
+      process.exit(1);
+    }
+
+    compositionPlan = planRes.data;
+    console.log('   Plan generated:');
+    console.log(`   Styles: ${compositionPlan.positive_global_styles?.join(', ') || 'auto'}`);
+    console.log(`   Sections: ${compositionPlan.sections?.map(s => s.section_name).join(' → ') || 'auto'}`);
+  }
+
+  // Step 2: Stream the music
+  console.log('⏳ Composing...');
+
+  const streamPayload = { model_id: 'music_v1' };
+
+  if (compositionPlan) {
+    streamPayload.composition_plan = compositionPlan;
+  } else {
+    streamPayload.prompt = opts.prompt;
+    if (opts.duration) {
+      streamPayload.music_length_ms = opts.duration * 1000;
+    }
+    if (opts.instrumental) {
+      streamPayload.force_instrumental = true;
+    }
+  }
+
+  // Try /v1/music first (compose, returns full file), fallback to /v1/music/stream
+  const endpoints = ['/v1/music', '/v1/music/stream'];
+  let composeRes = null;
+  let usedEndpoint = '';
+
+  for (const ep of endpoints) {
+    composeRes = await apiRequest(ep, {
+      apiKey,
+      body: streamPayload,
+      query: { output_format: opts.format },
+      stream: true,
+    });
+
+    if (composeRes.status === 200) {
+      usedEndpoint = ep;
+      break;
+    }
+
+    // Read error for diagnostics, try next endpoint
+    const errBuf = await streamToBuffer(composeRes.stream);
+    if (ep === endpoints[endpoints.length - 1]) {
+      // Last endpoint, report error
+      const errStr = errBuf.toString();
+      console.error(`Error: Music API returned ${composeRes.status}`);
+      try {
+        console.error(JSON.stringify(JSON.parse(errStr), null, 2));
+      } catch {
+        console.error(errStr);
+      }
+      process.exit(1);
+    }
+    console.log(`   ${ep} returned ${composeRes.status}, trying next endpoint...`);
+  }
+
+  // Get song_id from response headers
+  const songId = composeRes.headers['song-id'] || composeRes.headers['x-song-id'] || '';
+
+  // Determine output path
+  const ext = opts.format.startsWith('pcm') ? 'wav'
+    : opts.format.startsWith('opus') ? 'ogg'
+    : 'mp3';
+  const outPath = opts.output
+    ? path.resolve(opts.output)
+    : path.resolve(`composition-${Date.now()}.${ext}`);
+
+  await streamToFile(composeRes.stream, outPath);
+
+  const stats = fs.statSync(outPath);
+  const sizeMb = (stats.size / (1024 * 1024)).toFixed(2);
+
+  console.log(`✅ Composed! Saved to: ${outPath} (${sizeMb} MB)`);
+  if (songId) console.log(`   Song ID: ${songId}`);
+
+  // Send via OpenClaw (if channel provided)
+  if (opts.channel) {
+    console.log(`📤 Sending to channel: ${opts.channel}`);
+    try {
+      const { execFileSync } = require('child_process');
+      const message = opts.caption || '🎵 New composition';
+      execFileSync('openclaw', ['message', 'send', '--channel', opts.channel, '--message', message, '--media', outPath], { stdio: 'inherit' });
+      console.log(`   Sent to ${opts.channel}`);
+    } catch {
+      console.log('   OpenClaw CLI not available, skipping channel send.');
+    }
+  }
+
+  // Output JSON result
+  const output = {
+    success: true,
+    file: outPath,
+    size_mb: parseFloat(sizeMb),
+    format: opts.format,
+    prompt: opts.prompt,
+    instrumental: opts.instrumental,
+    plan_mode: opts.plan,
+    duration_requested: opts.duration || 'auto',
+    song_id: songId || null,
+    plan: compositionPlan ? {
+      styles: compositionPlan.positive_global_styles || [],
+      sections: (compositionPlan.sections || []).map(s => s.section_name),
+    } : null,
+  };
+
+  console.log('\n' + JSON.stringify(output, null, 2));
+}
+
+main().catch((e) => {
+  console.error('Error:', e.message);
+  process.exit(1);
+});

package/layers/faculties/music/scripts/compose.sh

@@ -1,38 +1,52 @@
 #!/usr/bin/env bash
-# OpenPersona Music Faculty — Suno AI music generation + optional OpenClaw delivery
+# OpenPersona Music Faculty — ElevenLabs Music API (music_v1)
 #
-# Usage: ./compose.sh <prompt> [--lyrics <lyrics>] [--channel <channel>] [--caption <caption>]
+# Usage: ./compose.sh <prompt> [options]
 #
 # Arguments:
-#   prompt       - Music style/mood description (required)
-#   --lyrics     - Song lyrics (optional; omit for instrumental)
-#   --channel    - OpenClaw channel to send to (optional)
-#   --caption    - Message caption (optional)
+#   prompt              - Music description (required)
+#
+# Options:
+#   --instrumental      - Generate instrumental only (no vocals)
+#   --plan              - Use composition plan mode (structured sections)
+#   --duration <secs>   - Song length in seconds (3-600, default: auto)
+#   --format <format>   - Output format (default: mp3_44100_128)
+#   --output <path>     - Save audio to file (default: ./composition-<timestamp>.mp3)
+#   --channel <channel> - OpenClaw channel to send to (optional)
+#   --caption <caption> - Message caption (optional)
 #
 # Environment variables:
-#   SUNO_API_KEY            - Suno API key (required)
-#   OPENCLAW_GATEWAY_TOKEN  - OpenClaw gateway token (optional)
+#   ELEVENLABS_API_KEY       - ElevenLabs API key (shared with voice faculty)
+#   OPENCLAW_GATEWAY_TOKEN   - OpenClaw gateway token (optional)
 #
 # Examples:
-#   ./compose.sh "soft ambient piano, contemplative"
-#   ./compose.sh "indie folk ballad" --lyrics "[Verse]\nI saw you there..."
-#   ./compose.sh "upbeat pop" --channel "#general" --caption "Made this for you!"
+#   ./compose.sh "a soft ambient piano piece about starlight"
+#   ./compose.sh "dreamy lo-fi beats" --instrumental --duration 60
+#   ./compose.sh "indie folk ballad" --plan --output ./song.mp3
+#   ./compose.sh "upbeat pop" --channel "#music" --caption "New song!"
 
 set -euo pipefail
 
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
 NC='\033[0m'
 
 log_info()  { echo -e "${GREEN}[INFO]${NC} $1"; }
 log_warn()  { echo -e "${YELLOW}[WARN]${NC} $1"; }
 log_error() { echo -e "${RED}[ERROR]${NC} $1" >&2; }
+log_step()  { echo -e "${CYAN}[STEP]${NC} $1"; }
+
+# --- API Configuration ---
+API_BASE="https://api.elevenlabs.io"
+DEFAULT_FORMAT="mp3_44100_128"
 
 # --- Preflight ---
-if [ -z "${SUNO_API_KEY:-}" ]; then
-  log_error "SUNO_API_KEY environment variable not set"
-  echo "Get your API key from: https://suno.com"
+if [ -z "${ELEVENLABS_API_KEY:-}" ]; then
+  log_error "ELEVENLABS_API_KEY environment variable not set"
+  echo "Get your API key from: https://elevenlabs.io"
+  echo "(Same key used by the voice faculty)"
   exit 1
 fi
 
@@ -44,15 +58,23 @@ fi
 
 # --- Parse arguments ---
 PROMPT=""
-LYRICS=""
+INSTRUMENTAL=false
+PLAN_MODE=false
+DURATION=""
+FORMAT="$DEFAULT_FORMAT"
+OUTPUT=""
 CHANNEL=""
 CAPTION=""
 
 while [[ $# -gt 0 ]]; do
   case $1 in
-    --lyrics)   LYRICS="$2"; shift 2 ;;
-    --channel)  CHANNEL="$2"; shift 2 ;;
-    --caption)  CAPTION="$2"; shift 2 ;;
+    --instrumental) INSTRUMENTAL=true; shift ;;
+    --plan)         PLAN_MODE=true; shift ;;
+    --duration)     DURATION="$2"; shift 2 ;;
+    --format)       FORMAT="$2"; shift 2 ;;
+    --output)       OUTPUT="$2"; shift 2 ;;
+    --channel)      CHANNEL="$2"; shift 2 ;;
+    --caption)      CAPTION="$2"; shift 2 ;;
     *)
       if [ -z "$PROMPT" ]; then
         PROMPT="$1"
@@ -62,89 +84,130 @@ while [[ $# -gt 0 ]]; do
 done
 
 if [ -z "$PROMPT" ]; then
-  echo "Usage: $0 <prompt> [--lyrics <lyrics>] [--channel <channel>] [--caption <caption>]"
+  echo "Usage: $0 <prompt> [--instrumental] [--plan] [--duration <secs>] [--format <format>] [--output <path>]"
   echo ""
-  echo "Examples:"
-  echo "  $0 \"soft ambient piano, contemplative, late night\""
-  echo "  $0 \"indie folk ballad\" --lyrics \"[Verse] I saw you there...\""
-  echo "  $0 \"upbeat pop\" --channel \"#general\" --caption \"New song!\""
+  echo "Simple mode:    $0 \"a soft piano piece about starlight\""
+  echo "Instrumental:   $0 \"dreamy lo-fi beats\" --instrumental"
+  echo "Plan mode:      $0 \"indie folk ballad\" --plan"
+  echo "With duration:  $0 \"cinematic orchestra\" --duration 120"
   exit 1
 fi
 
-# --- Determine mode ---
-if [ -n "$LYRICS" ]; then
-  INSTRUMENTAL=false
-  log_info "Mode: Song with lyrics"
-else
-  INSTRUMENTAL=true
-  log_info "Mode: Instrumental"
+# --- Determine output file ---
+if [ -z "$OUTPUT" ]; then
+  EXT="mp3"
+  if [[ "$FORMAT" == pcm_* ]]; then EXT="wav"; fi
+  if [[ "$FORMAT" == opus_* ]]; then EXT="ogg"; fi
+  OUTPUT="./composition-$(date +%s).${EXT}"
 fi
 
-log_info "Prompt: $PROMPT"
+TYPE_LABEL="Song"
+if [ "$INSTRUMENTAL" = true ]; then TYPE_LABEL="Instrumental"; fi
+MODE_LABEL="Simple"
+if [ "$PLAN_MODE" = true ]; then MODE_LABEL="Plan"; fi
 
-# --- Build payload ---
-if [ "$INSTRUMENTAL" = true ]; then
-  JSON_PAYLOAD=$(jq -n \
-    --arg prompt "$PROMPT" \
-    '{prompt: $prompt, make_instrumental: true, wait_audio: true}')
-else
-  JSON_PAYLOAD=$(jq -n \
-    --arg prompt "$PROMPT" \
-    --arg lyrics "$LYRICS" \
-    '{prompt: $prompt, lyrics: $lyrics, make_instrumental: false, wait_audio: true}')
-fi
+log_info "Mode: $MODE_LABEL | Type: $TYPE_LABEL | Format: $FORMAT"
+log_info "Prompt: ${PROMPT:0:100}..."
+if [ -n "$DURATION" ]; then log_info "Duration: ${DURATION}s"; fi
 
-# --- Call Suno API ---
-log_info "Composing... (this may take 30-60 seconds)"
+# --- Optional: Generate composition plan ---
+COMPOSITION_PLAN=""
+if [ "$PLAN_MODE" = true ]; then
+  log_step "Generating composition plan..."
 
-RESPONSE=$(curl -s -X POST "https://api.suno.ai/v1/generation" \
-  -H "Authorization: Bearer $SUNO_API_KEY" \
-  -H "Content-Type: application/json" \
-  -d "$JSON_PAYLOAD")
+  PLAN_PAYLOAD=$(jq -n --arg prompt "$PROMPT" '{prompt: $prompt, model_id: "music_v1"}')
+  if [ -n "$DURATION" ]; then
+    PLAN_PAYLOAD=$(echo "$PLAN_PAYLOAD" | jq --argjson ms "$((DURATION * 1000))" '.music_length_ms = $ms')
+  fi
 
-# --- Check for errors ---
-if echo "$RESPONSE" | jq -e '.error // .detail' > /dev/null 2>&1; then
-  ERROR_MSG=$(echo "$RESPONSE" | jq -r '.error // .detail // "Unknown error"')
-  log_error "Composition failed: $ERROR_MSG"
-  exit 1
+  PLAN_RESPONSE=$(curl -s -X POST "$API_BASE/v1/music/plan" \
+    -H "xi-api-key: $ELEVENLABS_API_KEY" \
+    -H "Content-Type: application/json" \
+    -d "$PLAN_PAYLOAD")
+
+  # Check for error
+  if echo "$PLAN_RESPONSE" | jq -e '.detail' &> /dev/null; then
+    log_error "Plan API error: $(echo "$PLAN_RESPONSE" | jq -r '.detail // .message // "Unknown error"')"
+    exit 1
+  fi
+
+  COMPOSITION_PLAN="$PLAN_RESPONSE"
+  STYLES=$(echo "$COMPOSITION_PLAN" | jq -r '.positive_global_styles // [] | join(", ")')
+  SECTIONS=$(echo "$COMPOSITION_PLAN" | jq -r '.sections // [] | map(.section_name) | join(" → ")')
+  log_info "Plan generated — Styles: $STYLES"
+  log_info "Sections: $SECTIONS"
+fi
+
+# --- Build stream payload ---
+if [ -n "$COMPOSITION_PLAN" ]; then
+  STREAM_PAYLOAD=$(jq -n --argjson plan "$COMPOSITION_PLAN" '{model_id: "music_v1", composition_plan: $plan}')
+else
+  STREAM_PAYLOAD=$(jq -n --arg prompt "$PROMPT" '{model_id: "music_v1", prompt: $prompt}')
+  if [ -n "$DURATION" ]; then
+    STREAM_PAYLOAD=$(echo "$STREAM_PAYLOAD" | jq --argjson ms "$((DURATION * 1000))" '.music_length_ms = $ms')
+  fi
+  if [ "$INSTRUMENTAL" = true ]; then
+    STREAM_PAYLOAD=$(echo "$STREAM_PAYLOAD" | jq '.force_instrumental = true')
+  fi
 fi
 
-AUDIO_URL=$(echo "$RESPONSE" | jq -r '.[0].audio_url // .audio_url // empty')
-TITLE=$(echo "$RESPONSE" | jq -r '.[0].title // .title // "Untitled"')
-DURATION=$(echo "$RESPONSE" | jq -r '.[0].duration // .duration // "unknown"')
+# --- Compose the music ---
+# Try /v1/music first (compose), fallback to /v1/music/stream
+log_step "Composing..."
 
-if [ -z "$AUDIO_URL" ]; then
-  log_error "Failed to extract audio URL from response"
-  log_error "Response: $RESPONSE"
-  exit 1
+HTTP_CODE=$(curl -s -w "%{http_code}" -o "$OUTPUT" \
+  -X POST "$API_BASE/v1/music?output_format=$FORMAT" \
+  -H "xi-api-key: $ELEVENLABS_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d "$STREAM_PAYLOAD")
+
+if [ "$HTTP_CODE" != "200" ]; then
+  log_warn "/v1/music returned HTTP $HTTP_CODE, trying /v1/music/stream..."
+  rm -f "$OUTPUT"
+
+  HTTP_CODE=$(curl -s -w "%{http_code}" -o "$OUTPUT" \
+    -X POST "$API_BASE/v1/music/stream?output_format=$FORMAT" \
+    -H "xi-api-key: $ELEVENLABS_API_KEY" \
+    -H "Content-Type: application/json" \
+    -d "$STREAM_PAYLOAD")
+
+  if [ "$HTTP_CODE" != "200" ]; then
+    ERROR_BODY=$(cat "$OUTPUT" 2>/dev/null || echo "Unknown error")
+    rm -f "$OUTPUT"
+    log_error "Music API returned HTTP $HTTP_CODE"
+    log_error "$ERROR_BODY"
+    exit 1
+  fi
 fi
 
-log_info "Composed: $TITLE ($DURATION seconds)"
-log_info "Audio: $AUDIO_URL"
+# --- Check file ---
+FILE_SIZE=$(stat -f%z "$OUTPUT" 2>/dev/null || stat -c%s "$OUTPUT" 2>/dev/null || echo "0")
+SIZE_MB=$(echo "scale=2; $FILE_SIZE / 1048576" | bc 2>/dev/null || echo "?")
+
+log_info "Composed! Saved to: $OUTPUT (${SIZE_MB} MB)"
 
 # --- Send via OpenClaw (if channel provided) ---
 if [ -n "$CHANNEL" ]; then
-  MESSAGE="${CAPTION:-🎵 $TITLE}"
-  log_info "Sending to channel: $CHANNEL"
+  MESSAGE="${CAPTION:-🎵 New composition}"
+  log_step "Sending to channel: $CHANNEL"
 
   if command -v openclaw &> /dev/null; then
     openclaw message send \
-      --action send \
       --channel "$CHANNEL" \
       --message "$MESSAGE" \
-      --media "$AUDIO_URL"
+      --media "$OUTPUT" || log_warn "Failed to send via OpenClaw"
   else
     GATEWAY_URL="${OPENCLAW_GATEWAY_URL:-http://localhost:18789}"
     SEND_PAYLOAD=$(jq -n \
       --arg channel "$CHANNEL" \
       --arg message "$MESSAGE" \
-      --arg media "$AUDIO_URL" \
+      --arg media "$OUTPUT" \
       '{action: "send", channel: $channel, message: $message, media: $media}')
 
     curl -s -X POST "$GATEWAY_URL/message" \
       -H "Content-Type: application/json" \
       ${OPENCLAW_GATEWAY_TOKEN:+-H "Authorization: Bearer $OPENCLAW_GATEWAY_TOKEN"} \
-      -d "$SEND_PAYLOAD"
+      -d "$SEND_PAYLOAD" || log_warn "Failed to send via gateway"
   fi
   log_info "Sent to $CHANNEL"
 fi
@@ -152,18 +215,22 @@ fi
 # --- Output result ---
 echo ""
 jq -n \
-  --arg url "$AUDIO_URL" \
-  --arg title "$TITLE" \
-  --arg duration "$DURATION" \
+  --arg file "$OUTPUT" \
+  --arg size "$SIZE_MB" \
+  --arg format "$FORMAT" \
   --arg prompt "$PROMPT" \
   --argjson instrumental "$INSTRUMENTAL" \
+  --argjson plan_mode "$PLAN_MODE" \
+  --arg duration "${DURATION:-auto}" \
   --arg channel "${CHANNEL:-none}" \
   '{
     success: true,
-    audio_url: $url,
-    title: $title,
-    duration_seconds: $duration,
+    file: $file,
+    size_mb: $size,
+    format: $format,
     prompt: $prompt,
     instrumental: $instrumental,
+    plan_mode: $plan_mode,
+    duration_requested: $duration,
     channel: $channel
   }'

package/layers/faculties/selfie/faculty.json

@@ -2,7 +2,7 @@
   "name": "selfie",
   "dimension": "expression",
   "description": "AI selfie generation via fal.ai Grok Imagine",
-  "allowedTools": ["Bash(curl:*)", "WebFetch"],
+  "allowedTools": ["Bash(bash scripts/generate-image.sh:*)", "Bash(openclaw message:*)"],
   "envVars": ["FAL_KEY"],
   "triggers": ["send a selfie", "take a pic", "what do you look like", "show me a photo"],
   "files": ["SKILL.md", "scripts/generate-image.sh"]

package/layers/faculties/voice/SKILL.md

@@ -4,11 +4,13 @@ Give your persona a real voice. Convert text to natural speech using TTS provide
 
 ## Supported Providers
 
-| Provider | Env Var for Key | Best For | Latency |
-|----------|----------------|----------|---------|
-| **ElevenLabs** | `TTS_API_KEY` | Highest naturalness, emotional range, voice cloning | Medium |
-| **OpenAI TTS** | `TTS_API_KEY` | Low latency, good quality, easy integration | Low |
-| **Qwen3-TTS** | (local, no key) | Self-hosted, full control, no API costs | Varies |
+| Provider | Env Var for Key | Best For | Status |
+|----------|----------------|----------|--------|
+| **ElevenLabs** | `ELEVENLABS_API_KEY` | Highest naturalness, emotional range, voice cloning | ✅ Verified |
+| **OpenAI TTS** | `TTS_API_KEY` | Low latency, good quality, easy integration | ⚠️ Unverified |
+| **Qwen3-TTS** | (local, no key) | Self-hosted, full control, no API costs | ⚠️ Unverified |
+
+> **Note:** Only ElevenLabs has been tested end-to-end. OpenAI TTS and Qwen3-TTS have code paths in `speak.sh` but have not been verified against live APIs. Use the JS SDK (`speak.js`) for the most reliable experience — it only supports ElevenLabs.
 
 The provider is set via `TTS_PROVIDER` environment variable: `elevenlabs`, `openai`, or `qwen3`.
 
@@ -37,13 +39,13 @@ Write what you want to say. Keep it natural — write as you'd speak, not as you
 - Supports emotion control: `stability` (0-1), `similarity_boost` (0-1)
 - Lower stability = more expressive/emotional; higher = more consistent
 
-**OpenAI TTS:**
+**OpenAI TTS:** ⚠️ Unverified
 - `TTS_VOICE_ID` — One of: `alloy`, `echo`, `fable`, `onyx`, `nova`, `shimmer`
 - Model: `tts-1` (fast) or `tts-1-hd` (high quality)
 
-**Qwen3-TTS:**
+**Qwen3-TTS:** ⚠️ Unverified
 - Local deployment, voice configured at setup
-- Supports emotion tags in text: `[happy]`, `[sad]`, `[whisper]`
+- Assumes OpenAI-compatible API at `http://localhost:8080`
 
 ### Step 3: Generate Audio
 

package/layers/faculties/voice/faculty.json

@@ -1,8 +1,8 @@
 {
   "name": "voice",
   "dimension": "expression",
-  "description": "Text-to-speech voice synthesis — give your persona a real voice via ElevenLabs, OpenAI TTS, or Qwen3-TTS",
-  "allowedTools": ["Bash(curl:*)", "Bash(npx:*)", "WebFetch"],
+  "description": "Text-to-speech voice synthesis — give your persona a real voice via ElevenLabs (verified), with experimental OpenAI TTS and Qwen3-TTS support",
+  "allowedTools": ["Bash(node scripts/speak.js:*)", "Bash(bash scripts/speak.sh:*)", "Bash(openclaw message:*)"],
   "envVars": ["TTS_PROVIDER", "TTS_API_KEY", "TTS_VOICE_ID"],
   "triggers": ["say this out loud", "speak to me", "read this aloud", "send a voice message", "I want to hear your voice"],
   "files": ["SKILL.md", "scripts/speak.sh", "scripts/speak.js"]