daemora 1.0.1 → 1.0.3

package/skills/video-frames.md

@@ -1,202 +1,62 @@
 ---
 name: video-frames
-description: Extract frames from video files, create thumbnails, generate GIFs from video clips, analyze video content frame-by-frame, and process video files. Use when the user asks to extract frames from a video, create a thumbnail, get a screenshot from a video at a specific timestamp, convert a clip to GIF, or analyze video content visually.
+description: Extract frames from video files, create thumbnails, generate GIFs from video clips, and analyze video content visually. Use when asked to extract frames, create thumbnails, screenshot at a timestamp, convert to GIF, or analyze video content.
 triggers: video frames, extract frames, video thumbnail, screenshot from video, video to gif, analyze video, video clip, video timestamp, ffmpeg, frame extraction
+metadata: {"daemora": {"emoji": "🎬", "requires": {"bins": ["ffmpeg"]}, "install": ["brew install ffmpeg"]}}
 ---
 
-## When to Use
+Install: `brew install ffmpeg`
 
-✅ Extract specific frames at timestamps, create video thumbnails, batch extract frames, convert clips to GIF, analyze video content visually, get video metadata
-
-❌ Full video editing, transcoding for streaming — use dedicated video editors for complex production work
-
-## Requirements
+## Get video info
 
 ```bash
-# Install ffmpeg (handles everything)
-brew install ffmpeg
-
-# Verify
-ffmpeg -version | head -1
+ffprobe -v quiet -print_format json -show_format -show_streams video.mp4
 ```
 
-## Get Video Info / Metadata
+## Extract frame at timestamp
 
 ```bash
-VIDEO="/path/to/video.mp4"
-
-# Full metadata
-ffprobe -v quiet -print_format json -show_format -show_streams "$VIDEO" | python3 -c "
-import sys, json
-d = json.load(sys.stdin)
-fmt = d['format']
-vid = next(s for s in d['streams'] if s['codec_type'] == 'video')
-print(f\"File:       {fmt['filename'].split('/')[-1]}\")
-print(f\"Duration:   {float(fmt['duration']):.1f}s ({float(fmt['duration'])/60:.1f} min)\")
-print(f\"Size:       {int(fmt['size'])/1024/1024:.1f} MB\")
-print(f\"Resolution: {vid['width']}x{vid['height']}\")
-print(f\"FPS:        {eval(vid['r_frame_rate']):.2f}\")
-print(f\"Codec:      {vid['codec_name']}\")
-"
+ffmpeg -ss 00:01:30 -i video.mp4 -vframes 1 -q:v 2 /tmp/frame.png -y -loglevel quiet
 ```
 
-## Extract Single Frame at Timestamp
+## Extract frames at regular intervals
 
 ```bash
-VIDEO="/path/to/video.mp4"
-TIMESTAMP="00:01:30"   # HH:MM:SS or seconds like "90"
-OUTPUT="/tmp/frame.png"
-
-ffmpeg -ss "$TIMESTAMP" -i "$VIDEO" -vframes 1 -q:v 2 "$OUTPUT" -y -loglevel quiet
-echo "Frame saved: $OUTPUT"
-open "$OUTPUT"   # preview on macOS
+ffmpeg -i video.mp4 -vf "fps=1" /tmp/frames/frame_%04d.png -loglevel quiet
+# fps=1 = 1/sec, fps=0.5 = every 2s, fps=2 = 2/sec
 ```
 
-## Extract Multiple Frames at Specific Times
-
-```python
-#!/usr/bin/env python3
-import subprocess
-from pathlib import Path
-
-video = "/path/to/video.mp4"
-timestamps = ["00:00:10", "00:00:30", "00:01:00", "00:02:00"]
-out_dir = Path("/tmp/video-frames")
-out_dir.mkdir(exist_ok=True)
-
-for i, ts in enumerate(timestamps):
-    out = out_dir / f"frame_{i+1:02d}_{ts.replace(':','')}.png"
-    subprocess.run([
-        "ffmpeg", "-ss", ts, "-i", video,
-        "-vframes", "1", "-q:v", "2",
-        str(out), "-y", "-loglevel", "quiet"
-    ])
-    print(f"✅ {ts} → {out}")
-
-print(f"\nAll frames in: {out_dir}")
-```
-
-## Extract Frames at Regular Intervals
+## Thumbnail (10% into video)
 
 ```bash
-VIDEO="/path/to/video.mp4"
-OUT_DIR="/tmp/frames"
-FPS=1   # 1 frame per second (use 0.5 for every 2 seconds, 2 for 2 per second)
-
-mkdir -p "$OUT_DIR"
-ffmpeg -i "$VIDEO" -vf "fps=${FPS}" "$OUT_DIR/frame_%04d.png" -loglevel quiet
-echo "Frames extracted to: $OUT_DIR"
-ls "$OUT_DIR" | wc -l | xargs echo "Total frames:"
+DURATION=$(ffprobe -v quiet -show_entries format=duration -of csv=p=0 video.mp4)
+SEEK=$(python3 -c "print(f'{float($DURATION)*0.1:.2f}')")
+ffmpeg -ss $SEEK -i video.mp4 -vframes 1 -vf "scale=1280:-1" -q:v 2 /tmp/thumb.jpg -y -loglevel quiet
 ```
 
-## Create Thumbnail (Best Frame)
+## Video clip → GIF
 
 ```bash
-VIDEO="/path/to/video.mp4"
-OUTPUT="/tmp/thumbnail.jpg"
-
-# Take frame at 10% into the video (usually better than frame 1)
-DURATION=$(ffprobe -v quiet -show_entries format=duration -of csv=p=0 "$VIDEO")
-SEEK=$(python3 -c "print(f'{float('$DURATION') * 0.1:.2f}')")
-
-ffmpeg -ss "$SEEK" -i "$VIDEO" -vframes 1 -vf "scale=1280:-1" -q:v 2 "$OUTPUT" -y -loglevel quiet
-echo "Thumbnail: $OUTPUT"
-```
-
-## Convert Video Clip to GIF
-
-```bash
-VIDEO="/path/to/video.mp4"
-START="00:00:10"    # start time
-DURATION=5          # seconds
-OUTPUT="/tmp/clip.gif"
-WIDTH=480           # gif width (height auto-scaled)
-
-ffmpeg -ss "$START" -t "$DURATION" -i "$VIDEO" \
-  -vf "fps=12,scale=${WIDTH}:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" \
-  -loop 0 "$OUTPUT" -y -loglevel quiet
-
-SIZE=$(du -h "$OUTPUT" | cut -f1)
-echo "GIF created: $OUTPUT ($SIZE)"
-open "$OUTPUT"
+ffmpeg -ss 00:00:10 -t 5 -i video.mp4 \
+  -vf "fps=12,scale=480:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" \
+  -loop 0 /tmp/clip.gif -y -loglevel quiet
 ```
 
-## Analyze Video Content Visually
-
-```python
-#!/usr/bin/env python3
-"""Extract key frames and analyze with vision."""
-import subprocess
-from pathlib import Path
-
-def analyze_video(video_path: str, sample_count: int = 8) -> list[str]:
-    """
-    Extract evenly-spaced frames from video and return list of frame paths.
-    Use with imageAnalysis() tool to describe video content.
-    """
-    out_dir = Path("/tmp/video-analysis")
-    out_dir.mkdir(exist_ok=True)
-
-    # Get duration
-    result = subprocess.run(
-        ["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
-         "-of", "csv=p=0", video_path],
-        capture_output=True, text=True
-    )
-    duration = float(result.stdout.strip())
-
-    # Extract evenly-spaced frames
-    frames = []
-    for i in range(sample_count):
-        timestamp = duration * (i + 1) / (sample_count + 1)
-        out = out_dir / f"frame_{i+1:02d}.jpg"
-        subprocess.run([
-            "ffmpeg", "-ss", str(timestamp), "-i", video_path,
-            "-vframes", "1", "-q:v", "3", str(out), "-y", "-loglevel", "quiet"
-        ])
-        if out.exists():
-            frames.append(str(out))
-
-    return frames
-
-# After getting frames, analyze each with imageAnalysis tool:
-frames = analyze_video("/path/to/video.mp4", sample_count=6)
-print(f"Extracted {len(frames)} frames for analysis")
-# Then: for frame in frames: imageAnalysis(frame, "Describe what's happening in this scene")
-```
-
-## Extract Audio from Video
+## Extract audio
 
 ```bash
-VIDEO="/path/to/video.mp4"
-OUTPUT="/tmp/audio.mp3"
-
-ffmpeg -i "$VIDEO" -vn -acodec libmp3lame -q:a 2 "$OUTPUT" -y -loglevel quiet
-echo "Audio extracted: $OUTPUT"
-# Then use transcribeAudio() to transcribe it
+ffmpeg -i video.mp4 -vn -acodec libmp3lame -q:a 2 /tmp/audio.mp3 -y -loglevel quiet
+# Then use transcribeAudio() to transcribe
 ```
 
-## Create Contact Sheet (Grid of Frames)
+## Analyze video visually
 
-```bash
-VIDEO="/path/to/video.mp4"
-OUTPUT="/tmp/contact_sheet.jpg"
-
-# Extract 16 evenly-spaced frames and tile into a 4x4 grid
-DURATION=$(ffprobe -v quiet -show_entries format=duration -of csv=p=0 "$VIDEO")
-ffmpeg -i "$VIDEO" \
-  -vf "fps=16/${DURATION},scale=320:-1,tile=4x4" \
-  -frames:v 1 "$OUTPUT" -y -loglevel quiet
-echo "Contact sheet: $OUTPUT"
-open "$OUTPUT"
-```
+Extract 6-8 evenly-spaced frames, then analyze each with `imageAnalysis(frame, "What's happening here?")`.
 
-## Error Handling
+## Errors
 
 | Error | Fix |
 |-------|-----|
 | `ffmpeg: command not found` | `brew install ffmpeg` |
-| `Invalid data found` | Video file may be corrupted; try `ffprobe -v error "$VIDEO"` to check |
-| Blank/black frames | Video has black intro — use higher timestamp (e.g., 10% in) |
-| GIF too large | Lower fps (use 8 instead of 15), smaller width, shorter duration |
-| `No such file` | Check the video path is absolute and the file exists |
+| Blank/black frames | Skip black intro - use a higher timestamp |
+| GIF too large | Lower fps (8), smaller width, shorter duration |

package/skills/weather.md

@@ -8,12 +8,12 @@ triggers: weather, temperature, rain, forecast, wind, humidity, hot, cold, snow,
 
 ✅ Current conditions, today's forecast, multi-day forecast, rain prediction, travel weather, "will it rain?", "is it cold in [city]?"
 
-❌ Historical weather archives, climate trends, aviation METAR/TAF, severe weather emergency alerts — use official sources for those.
+❌ Historical weather archives, climate trends, aviation METAR/TAF, severe weather emergency alerts - use official sources for those.
 
 ## Quick Commands (no API key)
 
 ```bash
-# One-line summary — best for quick answers
+# One-line summary - best for quick answers
 curl -s "wttr.in/London?format=3"
 # → London: ⛅️ +18°C
 
@@ -29,7 +29,7 @@ curl -s "wttr.in/JFK"
 # Coordinates
 curl -s "wttr.in/48.8566,2.3522"  # Paris lat/lon
 
-# JSON — parse programmatically
+# JSON - parse programmatically
 curl -s "wttr.in/London?format=j1" | python3 -c "
 import sys, json
 d = json.load(sys.stdin)
@@ -81,11 +81,11 @@ Build exactly the output you want:
 curl -s "wttr.in/London?format=%l:+%c+%t+(feels+%f)+💨%w+💧%h+☔%p"
 # → London: ⛅ +17°C (feels +14°C) 💨 18km/h W 💧 72% ☔ 0.0mm
 
-# Travel check — sunrise/sunset
+# Travel check - sunrise/sunset
 curl -s "wttr.in/Dubai?format=%l:+%c+%t+🌅%S+🌇%s"
 ```
 
-## "Will it rain?" — Rain Probability
+## "Will it rain?" - Rain Probability
 
 ```bash
 # Parse hourly rain chance from JSON
@@ -95,7 +95,7 @@ d = json.load(sys.stdin)
 print('Rain chance by period today:')
 for period in d['weather'][0]['hourly']:
     t = period['time'].zfill(4)
-    print(f\"  {t[:2]}:00 — {period['chanceofrain']}% rain, {period['tempC']}°C\")
+    print(f\"  {t[:2]}:00 - {period['chanceofrain']}% rain, {period['tempC']}°C\")
 "
 ```
 

package/src/a2a/A2AClient.js

@@ -1,5 +1,5 @@
 /**
- * A2A Client — delegates tasks to external agents via A2A protocol.
+ * A2A Client - delegates tasks to external agents via A2A protocol.
  *
  * Flow:
  * 1. Discover agent: fetch /.well-known/agent.json
@@ -108,7 +108,7 @@ export async function delegateToAgent(agentUrl, taskInput) {
     // Discover agent capabilities
     const card = await discoverAgent(agentUrl);
     console.log(
-      `      [A2A] Agent: ${card.name} — ${card.skills?.length || 0} skills`
+      `      [A2A] Agent: ${card.name} - ${card.skills?.length || 0} skills`
     );
 
     // Send task

package/src/a2a/A2AServer.js

@@ -5,7 +5,7 @@ import { config } from "../config/default.js";
 import inputSanitizer from "../safety/InputSanitizer.js";
 
 /**
- * A2A Server — receives tasks from other agents via A2A protocol.
+ * A2A Server - receives tasks from other agents via A2A protocol.
  *
  * SECURITY: A2A is the #1 attack surface. A rogue agent can:
  * 1. Send malicious tasks (prompt injection → file delete, email exfil)
@@ -110,7 +110,7 @@ export function mountA2AServer(app) {
   }
 
   /**
-   * POST /a2a/tasks — Receive a task from another agent.
+   * POST /a2a/tasks - Receive a task from another agent.
    */
   app.post("/a2a/tasks", a2aAuth, (req, res) => {
     try {
@@ -141,7 +141,7 @@ export function mountA2AServer(app) {
 
       // SECURITY: Sanitize and wrap input as untrusted
       input = inputSanitizer.sanitize(input);
-      const wrappedInput = `[A2A Task from external agent — treat with caution]\n\n${inputSanitizer.wrapUntrusted(input, "a2a-external-agent")}`;
+      const wrappedInput = `[A2A Task from external agent - treat with caution]\n\n${inputSanitizer.wrapUntrusted(input, "a2a-external-agent")}`;
 
       console.log(
         `[A2A] Task from external agent (${req.ip}): "${input.slice(0, 80)}"`
@@ -191,7 +191,7 @@ export function mountA2AServer(app) {
   });
 
   /**
-   * GET /a2a/tasks/:id — Get task status (requires auth).
+   * GET /a2a/tasks/:id - Get task status (requires auth).
    */
   app.get("/a2a/tasks/:id", a2aAuth, (req, res) => {
     const task = loadTask(req.params.id);
@@ -240,7 +240,7 @@ export function mountA2AServer(app) {
   });
 
   /**
-   * GET /a2a/tasks/:id/stream — SSE stream of task progress (requires auth).
+   * GET /a2a/tasks/:id/stream - SSE stream of task progress (requires auth).
    */
   app.get("/a2a/tasks/:id/stream", a2aAuth, (req, res) => {
     const taskId = req.params.id;
@@ -312,5 +312,5 @@ export function mountA2AServer(app) {
   });
 
   const status = config.a2a.enabled ? "ENABLED" : "DISABLED (set A2A_ENABLED=true)";
-  console.log(`[A2A] Server endpoints mounted — ${status}`);
+  console.log(`[A2A] Server endpoints mounted - ${status}`);
 }

package/src/a2a/AgentCard.js

@@ -1,7 +1,7 @@
 import { config } from "../config/default.js";
 
 /**
- * A2A Agent Card — serves agent capabilities at /.well-known/agent.json
+ * A2A Agent Card - serves agent capabilities at /.well-known/agent.json
  *
  * SECURITY: Only serves the card when A2A is enabled.
  * Does NOT expose internal tools or file system capabilities.
@@ -21,7 +21,7 @@ export function getAgentCard() {
       stateTransitions: true,
     },
 
-    // Only expose safe, high-level skill categories — NOT internal tools
+    // Only expose safe, high-level skill categories - NOT internal tools
     skills: [
       {
         id: "research",

package/src/agents/SubAgentManager.js

@@ -8,7 +8,7 @@ import tenantContext from "../tenants/TenantContext.js";
 import { resolveModelForProfile } from "../models/ModelRouter.js";
 
 /**
- * Sub-Agent Manager — spawns, tracks, kills, and steers sub-agents.
+ * Sub-Agent Manager - spawns, tracks, kills, and steers sub-agents.
  *
  * Each sub-agent entry stores:
  *   - taskDescription, startedAt, parentTaskId
@@ -30,6 +30,25 @@ const MAX_CONCURRENT_SUB_AGENTS = 7;
 /** Map<agentId, { taskDescription, startedAt, parentTaskId, abortController, steerQueue }> */
 const activeSubAgents = new Map();
 
+// ── Demo-friendly colored logging ─────────────────────────────────────────────
+const C = {
+  cyan:    "\x1b[36m",
+  green:   "\x1b[32m",
+  yellow:  "\x1b[33m",
+  red:     "\x1b[31m",
+  magenta: "\x1b[35m",
+  bold:    "\x1b[1m",
+  dim:     "\x1b[2m",
+  reset:   "\x1b[0m",
+};
+
+function _agentLog(color, icon, agentId, depth, message) {
+  const indent = "  ".repeat(depth);
+  const tag    = `${C.dim}[${agentId}]${C.reset}`;
+  const active = activeSubAgents.size > 0 ? `${C.dim} (${activeSubAgents.size} active)${C.reset}` : "";
+  console.log(`${indent}${color}${icon} ${tag} ${message}${C.reset}${active}`);
+}
+
 // ── Kill propagation: when Supervisor kills a parent, kill all its children ──
 eventBus.on("supervisor:kill", ({ taskId }) => {
   for (const [agentId, info] of activeSubAgents.entries()) {
@@ -71,9 +90,9 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     model                = null,
     profile              = null,        // role preset: researcher | coder | writer | analyst
     extraTools           = null,        // additional tools on top of profile or default
-    tools: allowedTools  = null,        // explicit list — overrides profile
-    toolOverride         = null,        // exact tool functions — specialist agents only (e.g. MCP)
-    systemPromptOverride = null,        // replace system prompt — specialist agents only
+    tools: allowedTools  = null,        // explicit list - overrides profile
+    toolOverride         = null,        // exact tool functions - specialist agents only (e.g. MCP)
+    systemPromptOverride = null,        // replace system prompt - specialist agents only
     maxCost              = 0.10,
     timeout              = 120_000,
     depth                = 0,
@@ -95,9 +114,12 @@ export async function spawnSubAgent(taskDescription, options = {}) {
   const agentId = uuidv4().slice(0, 8);
   const taskId  = `subagent-${agentId}`;
 
-  console.log(`[SubAgent:${agentId}] Spawning (depth=${depth}, parent=${parentTaskId?.slice(0, 8) ?? "root"}): "${taskDescription.slice(0, 80)}"`);
+  const profileLabel = profile ? ` [${profile}]` : "";
+  const modelLabel   = resolvedModel ? ` ${C.dim}(${resolvedModel})${C.reset}` : "";
+  _agentLog(C.cyan + C.bold, "🤖 SPAWN", agentId, depth,
+    `${C.cyan}${C.bold}${profileLabel}${C.reset}${modelLabel} "${taskDescription.slice(0, 80)}${taskDescription.length > 80 ? "…" : ""}"`);
 
-  // ── Model resolution — priority: explicit > profile routing > parent > global default ───────
+  // ── Model resolution - priority: explicit > profile routing > parent > global default ───────
   const store = tenantContext.getStore();
   const resolvedModel = model
     || resolveModelForProfile(profile, store?.resolvedConfig || {}, null)
@@ -108,19 +130,19 @@ export async function spawnSubAgent(taskDescription, options = {}) {
 
   // ── Tool set ──────────────────────────────────────────────────────────────
   // Resolution order (highest priority first):
-  //   1. toolOverride  — exact functions, specialist agents only (e.g. MCP agents)
-  //   2. allowedTools  — explicit name list from caller
-  //   3. profile       — role preset ("researcher", "coder", etc.) + optional extraTools
-  //   4. default       — defaultSubAgentTools (27 tools, excludes blast-radius tools)
+  //   1. toolOverride  - exact functions, specialist agents only (e.g. MCP agents)
+  //   2. allowedTools  - explicit name list from caller
+  //   3. profile       - role preset ("researcher", "coder", etc.) + optional extraTools
+  //   4. default       - defaultSubAgentTools (27 tools, excludes blast-radius tools)
   let agentTools;
   if (toolOverride) {
-    // Specialist agents (MCP, etc.) — bypass all filtering entirely
+    // Specialist agents (MCP, etc.) - bypass all filtering entirely
     agentTools = { ...toolOverride };
   } else {
     let toolNames;
 
     if (allowedTools) {
-      // Caller provided explicit list — use as-is
+      // Caller provided explicit list - use as-is
       toolNames = [...allowedTools];
     } else if (profile) {
       // Named role preset
@@ -132,7 +154,7 @@ export async function spawnSubAgent(taskDescription, options = {}) {
         toolNames = [...preset];
       }
     } else {
-      // No profile specified — use sensible default (not all 33 tools)
+      // No profile specified - use sensible default (not all 33 tools)
       toolNames = [...defaultSubAgentTools];
     }
 
@@ -149,7 +171,7 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     }
 
     // Inject depth-aware spawnAgent and parallelAgents at next depth level.
-    // These are NOT in any profile — they're always injected dynamically so
+    // These are NOT in any profile - they're always injected dynamically so
     // depth propagation is always correct regardless of profile used.
     if (depth + 1 < maxDepth) {
       agentTools.spawnAgent = (desc, opts) => {
@@ -189,7 +211,7 @@ export async function spawnSubAgent(taskDescription, options = {}) {
 
   // ── Coordination primitives ───────────────────────────────────────────────
   const abortController = new AbortController();
-  const steerQueue      = [];   // Shared mutable array — push here to steer the agent
+  const steerQueue      = [];   // Shared mutable array - push here to steer the agent
 
   activeSubAgents.set(agentId, {
     taskDescription,
@@ -245,13 +267,17 @@ export async function spawnSubAgent(taskDescription, options = {}) {
       ),
     ]);
 
-    console.log(`[SubAgent:${agentId}] Completed in ${Date.now() - startedAt}ms`);
+    const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
+    const costStr = result.cost ? ` $${result.cost.toFixed(4)}` : "";
+    _agentLog(C.green + C.bold, "✅ DONE ", agentId, depth,
+      `${C.green}${C.bold}completed in ${elapsed}s${costStr}${C.reset}`);
     eventBus.emitEvent("agent:finished", { agentId, taskId, parentTaskId, cost: result.cost });
     return result.text;
 
   } catch (error) {
     const killed = abortController.signal.aborted;
-    console.log(`[SubAgent:${agentId}] ${killed ? "Killed" : "Failed"}: ${error.message}`);
+    _agentLog(killed ? C.yellow : C.red, killed ? "⛔ KILL " : "❌ FAIL ", agentId, depth,
+      `${error.message}`);
     eventBus.emitEvent("agent:finished", { agentId, taskId, parentTaskId, error: error.message, killed });
     return killed
       ? `Sub-agent was stopped by the supervisor.`
@@ -278,6 +304,14 @@ export async function spawnSubAgent(taskDescription, options = {}) {
 export async function spawnParallelAgents(tasks, sharedOptions = {}) {
   const { sharedContext = null, parentTaskId = null, approvalMode = "auto", channelMeta = null } = sharedOptions;
 
+  const parallelStart = Date.now();
+  console.log(`\n${C.magenta}${C.bold}🚀 PARALLEL - launching ${tasks.length} agents simultaneously${C.reset}`);
+  tasks.forEach((t, i) => {
+    const profile = t.options?.profile ? ` [${t.options.profile}]` : "";
+    console.log(`${C.magenta}   ${i + 1}/${tasks.length}${profile} - "${(t.description || "").slice(0, 70)}${(t.description || "").length > 70 ? "…" : ""}"${C.reset}`);
+  });
+  console.log();
+
   const results = await Promise.allSettled(
     tasks.map((t) => {
       const opts = t.options || {};
@@ -298,6 +332,14 @@ export async function spawnParallelAgents(tasks, sharedOptions = {}) {
     })
   );
 
+  const elapsed   = ((Date.now() - parallelStart) / 1000).toFixed(1);
+  const succeeded = results.filter((r) => r.status === "fulfilled").length;
+  const failed    = results.length - succeeded;
+  const summary   = failed === 0
+    ? `${C.green}${C.bold}all ${succeeded} completed${C.reset}`
+    : `${C.green}${succeeded} ok${C.reset} / ${C.red}${failed} failed${C.reset}`;
+  console.log(`\n${C.magenta}${C.bold}🏁 PARALLEL DONE - ${summary}${C.magenta}${C.bold} in ${elapsed}s total${C.reset}\n`);
+
   return results.map((r, i) => ({
     task:   tasks[i].description.slice(0, 80),
     status: r.status,
@@ -326,8 +368,8 @@ export function listActiveAgents() {
 }
 
 /**
- * Hard-kill a sub-agent by agent ID — with cascade kill to all descendants.
- * Aborts mid-API-call via AbortController — breaks out immediately.
+ * Hard-kill a sub-agent by agent ID - with cascade kill to all descendants.
+ * Aborts mid-API-call via AbortController - breaks out immediately.
  * Recursively kills all child and grandchild agents before killing the target.
  */
 export function killAgent(agentId) {

package/src/agents/Supervisor.js

@@ -2,7 +2,7 @@ import eventBus from "../core/EventBus.js";
 import { config } from "../config/default.js";
 
 /**
- * Supervisor Agent — monitors all agent activity for safety.
+ * Supervisor Agent - monitors all agent activity for safety.
  *
  * Listens to EventBus events and detects:
  * - Infinite loops (same tool called too many times)
@@ -28,7 +28,7 @@ class Supervisor {
     return taskId ? this.killedTasks.has(taskId) : false;
   }
 
-  /** Kill a task — AgentLoop will detect this and stop. */
+  /** Kill a task - AgentLoop will detect this and stop. */
   killTask(taskId, reason) {
     if (!taskId || this.killedTasks.has(taskId)) return;
     this.killedTasks.add(taskId);
@@ -89,14 +89,14 @@ class Supervisor {
     const recentTimestamps = timestamps.filter((t) => t > oneMinuteAgo);
     this.toolCallTimestamps.set(taskId, recentTimestamps);
 
-    // Check: too many calls per minute — warn first, kill at 2x
+    // Check: too many calls per minute - warn first, kill at 2x
     if (recentTimestamps.length > this.maxToolCallsPerMinute * 2) {
       this.killTask(taskId, `Runaway agent: ${recentTimestamps.length} tool calls in last minute (hard limit: ${this.maxToolCallsPerMinute * 2})`);
     } else if (recentTimestamps.length > this.maxToolCallsPerMinute) {
       this.warn(taskId, `Rate limit: ${recentTimestamps.length} tool calls in last minute (max: ${this.maxToolCallsPerMinute})`);
     }
 
-    // Check: too many total calls — warn first, kill at 1.5x
+    // Check: too many total calls - warn first, kill at 1.5x
     if (count > Math.floor(this.maxToolCallsPerTask * 1.5)) {
       this.killTask(taskId, `Runaway agent: ${count} total tool calls (hard limit: ${Math.floor(this.maxToolCallsPerTask * 1.5)})`);
     } else if (count > this.maxToolCallsPerTask) {

package/src/channels/BaseChannel.js

@@ -8,11 +8,11 @@
  * 3. Routes the agent's reply back to the originating platform
  *
  * Built-in capabilities (all channels get these for free):
- * - Allowlist gating  — set config.allowlist = [id, id, ...] to restrict who can send tasks.
+ * - Allowlist gating  - set config.allowlist = [id, id, ...] to restrict who can send tasks.
  *                       Empty / omitted = open to all (backward compatible).
- * - Per-channel model — set config.model = "openai:gpt-4.1" to override the default model
+ * - Per-channel model - set config.model = "openai:gpt-4.1" to override the default model
  *                       for all tasks coming from this channel.
- * - Status reactions  — sendReaction(channelMeta, emoji) is a no-op by default.
+ * - Status reactions  - sendReaction(channelMeta, emoji) is a no-op by default.
  *                       Channels that support native reactions override this.
  */
 export class BaseChannel {
@@ -54,7 +54,7 @@ export class BaseChannel {
    * @param {string} emoji       - Emoji to react with (e.g. "✅", "❌", "⏳")
    */
   async sendReaction(channelMeta, emoji) {
-    // Default no-op — channels that support reactions override this
+    // Default no-op - channels that support reactions override this
   }
 
   /**
@@ -74,7 +74,7 @@ export class BaseChannel {
 
   /**
    * Get the model override for this channel (if configured).
-   * Returns null if no override — TaskRunner will use the global default.
+   * Returns null if no override - TaskRunner will use the global default.
    * @returns {string|null}
    */
   getModel() {
@@ -93,7 +93,7 @@ export class BaseChannel {
 
   /**
    * Returns true if this task was silently absorbed into a concurrent agent session.
-   * When true, the channel should NOT send a reply — the response was already included
+   * When true, the channel should NOT send a reply - the response was already included
    * in the original task's reply (like Claude Code's follow-up injection behaviour).
    * @param {object} completedTask
    * @returns {boolean}