crewly 1.1.2 → 1.2.0

package/config/skills/orchestrator/delegate-task/execute.sh

@@ -1,11 +1,13 @@
 #!/bin/bash
-# Delegate a task to an agent with a structured task template
+# Delegate a task to an agent with a structured task template.
+# Optionally sets up auto-monitoring (idle event subscription + fallback schedule)
+# that will be cleaned up automatically when the task completes.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../_common/lib.sh"
 
 INPUT="${1:-}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"to\":\"agent-session\",\"task\":\"implement feature X\",\"priority\":\"high\",\"projectPath\":\"/path/to/project\"}'"
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"to\":\"agent-session\",\"task\":\"implement feature X\",\"priority\":\"high\",\"projectPath\":\"/path/to/project\",\"monitor\":{\"idleEvent\":true,\"fallbackCheckMinutes\":5}}'"
 
 TO=$(echo "$INPUT" | jq -r '.to // empty')
 TASK=$(echo "$INPUT" | jq -r '.task // empty')
@@ -15,6 +17,10 @@ PROJECT_PATH=$(echo "$INPUT" | jq -r '.projectPath // empty')
 require_param "to" "$TO"
 require_param "task" "$TASK"
 
+# Monitor parameters (optional)
+MONITOR_IDLE=$(echo "$INPUT" | jq -r '.monitor.idleEvent // false')
+MONITOR_FALLBACK_MINUTES=$(echo "$INPUT" | jq -r '.monitor.fallbackCheckMinutes // 0')
+
 # Resolve Crewly root from this script path:
 # config/skills/orchestrator/delegate-task/execute.sh -> project root
 CREWLY_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
@@ -40,10 +46,14 @@ TASK_MESSAGE="[TASK] Priority: ${PRIORITY}\n\n${TASK}"
 [ -n "$CONTEXT" ] && TASK_MESSAGE="${TASK_MESSAGE}\n\nContext: ${CONTEXT}"
 TASK_MESSAGE="${TASK_MESSAGE}\n\nWhen done, report back using: bash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{\"sessionName\":\"${TO}\",\"status\":\"done\",\"summary\":\"<brief summary>\"}'"
 
-BODY=$(jq -n --arg message "$TASK_MESSAGE" '{message: $message}')
+# waitTimeout matches EVENT_DELIVERY_CONSTANTS.AGENT_READY_TIMEOUT (120000ms)
+BODY=$(jq -n --arg message "$TASK_MESSAGE" '{message: $message, waitForReady: true, waitTimeout: 120000}')
 
 api_call POST "/terminal/${TO}/deliver" "$BODY"
 
+# Track the task file path from create response for monitoring linkage
+TASK_FILE_PATH=""
+
 # Create task file in project's .crewly/tasks/ directory
 if [ -n "$PROJECT_PATH" ]; then
   CREATE_BODY=$(jq -n \
@@ -53,5 +63,54 @@ if [ -n "$PROJECT_PATH" ]; then
     --arg sessionName "$TO" \
     --arg milestone "delegated" \
     '{projectPath: $projectPath, task: $task, priority: $priority, sessionName: $sessionName, milestone: $milestone}')
-  api_call POST "/task-management/create" "$CREATE_BODY" || true
+  CREATE_RESULT=$(api_call POST "/task-management/create" "$CREATE_BODY" 2>/dev/null || true)
+  TASK_FILE_PATH=$(echo "$CREATE_RESULT" | jq -r '.taskPath // empty' 2>/dev/null || true)
+fi
+
+# --- Auto-monitoring setup ---
+# Collect IDs for monitoring cleanup linkage
+COLLECTED_SCHEDULE_IDS="[]"
+COLLECTED_SUBSCRIPTION_IDS="[]"
+
+# Set up idle event subscription if requested
+if [ "$MONITOR_IDLE" = "true" ]; then
+  SUBSCRIBER_SESSION="${CREWLY_SESSION_NAME:-crewly-orc}"
+  SUB_BODY=$(jq -n \
+    --arg eventType "agent:idle" \
+    --arg sessionName "$TO" \
+    --arg subscriber "$SUBSCRIBER_SESSION" \
+    '{eventType: $eventType, filter: {sessionName: $sessionName}, subscriberSession: $subscriber, oneShot: true, ttlMinutes: 120}')
+  SUB_RESULT=$(api_call POST "/events/subscribe" "$SUB_BODY" 2>/dev/null || true)
+  SUB_ID=$(echo "$SUB_RESULT" | jq -r '.data.id // empty' 2>/dev/null || true)
+  if [ -n "$SUB_ID" ]; then
+    COLLECTED_SUBSCRIPTION_IDS=$(echo "$COLLECTED_SUBSCRIPTION_IDS" | jq --arg id "$SUB_ID" '. + [$id]')
+  fi
+fi
+
+# Set up fallback recurring schedule if requested
+if [ "$MONITOR_FALLBACK_MINUTES" != "0" ] && [ -n "$MONITOR_FALLBACK_MINUTES" ]; then
+  SCHEDULE_TARGET="${CREWLY_SESSION_NAME:-crewly-orc}"
+  SCHED_BODY=$(jq -n \
+    --arg target "$SCHEDULE_TARGET" \
+    --arg minutes "$MONITOR_FALLBACK_MINUTES" \
+    --arg message "[CHECK] Review progress of ${TO} — task: ${TASK:0:100}" \
+    '{targetSession: $target, minutes: ($minutes | tonumber), intervalMinutes: ($minutes | tonumber), message: $message, isRecurring: true}')
+  SCHED_RESULT=$(api_call POST "/schedule" "$SCHED_BODY" 2>/dev/null || true)
+  SCHED_ID=$(echo "$SCHED_RESULT" | jq -r '.checkId // .data.checkId // empty' 2>/dev/null || true)
+  if [ -n "$SCHED_ID" ]; then
+    COLLECTED_SCHEDULE_IDS=$(echo "$COLLECTED_SCHEDULE_IDS" | jq --arg id "$SCHED_ID" '. + [$id]')
+  fi
+fi
+
+# Store monitoring IDs for auto-cleanup if we have any
+HAS_SCHEDULE_IDS=$(echo "$COLLECTED_SCHEDULE_IDS" | jq 'length > 0')
+HAS_SUBSCRIPTION_IDS=$(echo "$COLLECTED_SUBSCRIPTION_IDS" | jq 'length > 0')
+
+if [ "$HAS_SCHEDULE_IDS" = "true" ] || [ "$HAS_SUBSCRIPTION_IDS" = "true" ]; then
+  MONITOR_BODY=$(jq -n \
+    --arg sessionName "$TO" \
+    --argjson scheduleIds "$COLLECTED_SCHEDULE_IDS" \
+    --argjson subscriptionIds "$COLLECTED_SUBSCRIPTION_IDS" \
+    '{sessionName: $sessionName, scheduleIds: $scheduleIds, subscriptionIds: $subscriptionIds}')
+  api_call POST "/task-management/add-monitoring" "$MONITOR_BODY" 2>/dev/null || true
 fi

package/config/skills/orchestrator/delegate-task/instructions.md

@@ -3,12 +3,20 @@
 Sends a structured task assignment to an agent. When a `projectPath` is provided, also creates a task MD file in the project's `.crewly/tasks/delegated/in_progress/` directory for tracking.
 The script auto-resolves `config/skills/...` references to absolute paths so delegated tasks remain runnable from any working directory.
 
+When the optional `monitor` block is provided, the skill automatically sets up idle event subscriptions and/or fallback schedule checks. These are linked to the task and will be **automatically cleaned up** when the task is completed via `report-status` or `complete-task`.
+
 ## Usage
 
 ```bash
 bash config/skills/orchestrator/delegate-task/execute.sh '{"to":"agent-joe","task":"Implement the login form","priority":"high","context":"Use React hooks","projectPath":"/path/to/project"}'
 ```
 
+### With auto-monitoring
+
+```bash
+bash config/skills/orchestrator/delegate-task/execute.sh '{"to":"agent-joe","task":"Implement the login form","priority":"high","projectPath":"/path/to/project","monitor":{"idleEvent":true,"fallbackCheckMinutes":5}}'
+```
+
 ## Parameters
 
 | Parameter | Required | Description |
@@ -18,7 +26,59 @@ bash config/skills/orchestrator/delegate-task/execute.sh '{"to":"agent-joe","tas
 | `priority` | No | Task priority: `low`, `normal`, `high` (default: `normal`) |
 | `context` | No | Additional context for the task |
 | `projectPath` | No | Project path; when provided, creates a task MD file in `.crewly/tasks/` |
+| `monitor` | No | Auto-monitoring configuration (see below) |
+| `monitor.idleEvent` | No | If `true`, subscribes to `agent:idle` event for the target agent (default: `false`) |
+| `monitor.fallbackCheckMinutes` | No | If > 0, sets up a recurring fallback check every N minutes (default: `0` = disabled) |
+
+## Examples
+
+### Example 1: Basic delegation (no monitoring)
+```bash
+bash config/skills/orchestrator/delegate-task/execute.sh '{"to":"agent-joe","task":"Fix the login bug","priority":"high"}'
+```
+
+### Example 2: Delegation with full monitoring
+```bash
+bash config/skills/orchestrator/delegate-task/execute.sh '{"to":"agent-joe","task":"Implement user auth","priority":"high","projectPath":"/path/to/project","monitor":{"idleEvent":true,"fallbackCheckMinutes":5}}'
+```
+This will:
+1. Send the task to agent-joe's terminal
+2. Create a task file in the project
+3. Subscribe to `agent:idle` for agent-joe (auto-notifies when agent goes idle)
+4. Schedule a recurring check every 5 minutes (auto-reminds orchestrator to check progress)
+5. Link all monitoring IDs to the task for auto-cleanup on completion
+
+### Example 3: Delegation with idle monitoring only
+```bash
+bash config/skills/orchestrator/delegate-task/execute.sh '{"to":"agent-sam","task":"Write unit tests","priority":"normal","monitor":{"idleEvent":true}}'
+```
 
 ## Output
 
 JSON confirmation of task delivery. When `projectPath` is provided, also returns the created task file path.
+
+## Auto-Cleanup
+
+When the agent completes the task (via `report-status` with `status: done` or `complete-task`), all linked monitoring is automatically cleaned up:
+- Scheduled checks are cancelled
+- Event subscriptions are unsubscribed
+
+No manual cleanup needed.
+
+## Error Handling
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `Missing required parameter: to` | `to` not provided | Include target session name |
+| `Missing required parameter: task` | `task` not provided | Include task description |
+| `curl failed with exit code N` | Backend not running | Start the Crewly backend |
+
+Monitoring setup failures are non-fatal — if subscribe-event or schedule-check fails, the task is still delegated successfully.
+
+## Related Skills
+
+- `assign-task` — for formal task tracking in the management system (file-based kanban)
+- `send-message` — for simple messages without task structure
+- `subscribe-event` — manual event subscription (auto-handled when using `monitor`)
+- `schedule-check` — manual schedule creation (auto-handled when using `monitor`)
+- `report-status` — agent reports completion, triggers auto-cleanup

package/config/skills/orchestrator/delegate-task/skill.json

@@ -1,7 +1,7 @@
 {
   "id": "orc-delegate-task",
   "name": "Delegate Task",
-  "description": "Send a structured task assignment to an agent with priority and context.",
+  "description": "Send a structured task assignment to an agent with priority, context, and optional auto-monitoring. When monitor is provided, automatically subscribes to idle events and schedules fallback checks that are cleaned up on task completion. For formal task tracking, use assign-task instead. For simple messages, use send-message.",
   "category": "management",
   "skillType": "claude-skill",
   "promptFile": "instructions.md",
@@ -14,7 +14,7 @@
     }
   },
   "assignableRoles": ["orchestrator"],
-  "triggers": ["delegate task", "assign work", "task agent"],
-  "tags": ["task", "delegation", "management"],
-  "version": "1.0.0"
+  "triggers": ["delegate task", "assign work", "task agent", "delegate with monitoring", "send task to agent"],
+  "tags": ["task", "delegation", "management", "monitoring"],
+  "version": "2.0.0"
 }

package/config/skills/orchestrator/reply-slack/execute.sh

@@ -120,6 +120,8 @@ if [ -n "$INPUT_JSON" ]; then
   TEXT=${TEXT:-$(echo "$INPUT_JSON" | jq -r '.text // empty')}
   THREAD_TS=${THREAD_TS:-$(echo "$INPUT_JSON" | jq -r '.threadTs // empty')}
   CONVERSATION_ID=${CONVERSATION_ID:-$(echo "$INPUT_JSON" | jq -r '.conversationId // empty')}
+  FILE_PATH=${FILE_PATH:-$(echo "$INPUT_JSON" | jq -r '.file // .filePath // empty')}
+  IMAGE_PATH=${IMAGE_PATH:-$(echo "$INPUT_JSON" | jq -r '.image // .imagePath // empty')}
 fi
 
 require_param "channelId" "$CHANNEL_ID"

package/config/skills/orchestrator/send-key/execute.sh

@@ -1,17 +1,30 @@
 #!/bin/bash
-# Send a key to an agent's terminal session
+# Send a key or key sequence to an agent's terminal session
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../_common/lib.sh"
 
 INPUT="${1:-""}"
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"sessionName\":\"agent-session\",\"key\":\"Enter\"}'"
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"sessionName\":\"agent-session\",\"key\":\"Enter\"}' or '{\"sessionName\":\"...\",\"keys\":[\"Down\",\"Down\",\"Enter\"]}'"
 
 SESSION_NAME=$(echo "$INPUT" | jq -r '.sessionName // empty')
 KEY=$(echo "$INPUT" | jq -r '.key // empty')
+KEYS=$(echo "$INPUT" | jq -r '.keys // empty')
 require_param "sessionName" "$SESSION_NAME"
-require_param "key" "$KEY"
 
-BODY=$(jq -n --arg key "$KEY" '{key: $key}')
-
-api_call POST "/terminal/${SESSION_NAME}/key" "$BODY"
+# Support both single key and key sequence
+if [ -n "$KEY" ]; then
+  BODY=$(jq -n --arg key "$KEY" '{key: $key}')
+  api_call POST "/terminal/${SESSION_NAME}/key" "$BODY"
+elif [ "$KEYS" != "" ] && [ "$KEYS" != "null" ]; then
+  KEY_COUNT=$(echo "$INPUT" | jq '.keys | length')
+  for (( i=0; i<KEY_COUNT; i++ )); do
+    CURRENT_KEY=$(echo "$INPUT" | jq -r ".keys[$i]")
+    BODY=$(jq -n --arg key "$CURRENT_KEY" '{key: $key}')
+    api_call POST "/terminal/${SESSION_NAME}/key" "$BODY"
+    # Small delay between keys to allow processing
+    [ "$i" -lt "$((KEY_COUNT - 1))" ] && sleep 0.3
+  done
+else
+  error_exit "Either 'key' (single) or 'keys' (array) parameter is required"
+fi

package/config/skills/orchestrator/send-key/instructions.md

@@ -0,0 +1,44 @@
+# Send Key
+
+Sends a keyboard key or key sequence to an agent's terminal session. Useful for navigating interactive prompts, accepting plan mode, dismissing dialogs, or sending control sequences.
+
+## Usage
+
+### Single key
+```bash
+bash config/skills/orchestrator/send-key/execute.sh '{"sessionName":"agent-joe","key":"Enter"}'
+```
+
+### Key sequence
+```bash
+bash config/skills/orchestrator/send-key/execute.sh '{"sessionName":"agent-joe","keys":["Down","Down","Enter"]}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `sessionName` | Yes | The target agent's PTY session name |
+| `key` | One of `key`/`keys` | A single key to send |
+| `keys` | One of `key`/`keys` | An array of keys to send in sequence (300ms delay between each) |
+
+## Supported Keys
+
+| Key | Description |
+|-----|-------------|
+| `Enter` / `Return` | Submit / confirm |
+| `Escape` | Cancel / dismiss |
+| `Tab` | Tab key |
+| `Backspace` | Delete character before cursor |
+| `Delete` | Delete character after cursor |
+| `Up` / `Down` / `Left` / `Right` | Arrow keys |
+| `Home` / `End` | Jump to start/end of line |
+| `PageUp` / `PageDown` | Scroll page |
+| `C-c` | Ctrl+C (interrupt) |
+| `C-d` | Ctrl+D (EOF) |
+| `C-z` | Ctrl+Z (suspend) |
+| `C-l` | Ctrl+L (clear screen) |
+
+## Output
+
+JSON confirmation of delivery for each key sent.

package/config/skills/orchestrator/send-key/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "orc-send-key",
+  "name": "Send Key",
+  "description": "Send a keyboard key or key sequence to an agent's terminal session.",
+  "category": "system",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 30000
+    }
+  },
+  "assignableRoles": ["orchestrator"],
+  "triggers": ["send key", "press key", "key press", "send enter"],
+  "tags": ["system", "terminal", "key", "input"],
+  "version": "1.0.0"
+}

package/config/skills/orchestrator/send-message/execute.sh

@@ -9,9 +9,17 @@ INPUT="${1:-}"
 
 SESSION_NAME=$(echo "$INPUT" | jq -r '.sessionName // empty')
 MESSAGE=$(echo "$INPUT" | jq -r '.message // empty')
+FORCE=$(echo "$INPUT" | jq -r '.force // empty')
 require_param "sessionName" "$SESSION_NAME"
 require_param "message" "$MESSAGE"
 
-BODY=$(jq -n --arg message "$MESSAGE" '{message: $message}')
+# force=true: write directly to PTY without waiting for agent prompt.
+# Use when the agent is busy and you need immediate delivery.
+if [ "$FORCE" = "true" ]; then
+  BODY=$(jq -n --arg message "$MESSAGE" '{message: $message, force: true}')
+else
+  # waitTimeout matches EVENT_DELIVERY_CONSTANTS.AGENT_READY_TIMEOUT (120000ms)
+  BODY=$(jq -n --arg message "$MESSAGE" '{message: $message, waitForReady: true, waitTimeout: 120000}')
+fi
 
 api_call POST "/terminal/${SESSION_NAME}/deliver" "$BODY"

package/config/skills/registry.json

@@ -4,6 +4,49 @@
   "cdnBaseUrl": "https://raw.githubusercontent.com/stevehuang0115/crewly/main",
   "source": "github",
   "items": [
+    {
+      "id": "ai-studio",
+      "type": "skill",
+      "name": "AI Studio App Builder",
+      "description": "Use Chrome to build React apps on Google AI Studio (aistudio.google.com). Navigate to the Build page, input prompts, and generate interactive prototypes.",
+      "author": "Crewly Team",
+      "version": "1.0.0",
+      "category": "automation",
+      "tags": [
+        "ai-studio",
+        "google",
+        "gemini",
+        "react",
+        "prototype",
+        "chrome"
+      ],
+      "license": "MIT",
+      "downloads": 0,
+      "rating": 0,
+      "createdAt": "2026-02-27T00:00:00.000Z",
+      "updatedAt": "2026-02-27T00:00:00.000Z",
+      "source": "config/skills/agent/marketplace/ai-studio",
+      "assets": {
+        "archive": "config/skills/agent/marketplace/ai-studio",
+        "checksum": "",
+        "sizeBytes": 3000
+      },
+      "metadata": {
+        "skillType": "claude-skill",
+        "assignableRoles": [],
+        "triggers": [
+          "ai studio",
+          "google ai studio",
+          "build app",
+          "react prototype",
+          "gemini app"
+        ],
+        "files": [
+          "skill.json",
+          "instructions.md"
+        ]
+      }
+    },
     {
       "id": "bug-triage",
       "type": "skill",
@@ -87,6 +130,10 @@
           "click",
           "fill form",
           "navigate"
+        ],
+        "files": [
+          "skill.json",
+          "instructions.md"
         ]
       }
     },
@@ -529,6 +576,57 @@
           "nano banana",
           "gemini image",
           "ai image"
+        ],
+        "files": [
+          "skill.json",
+          "generate.sh",
+          "instructions.md"
+        ]
+      }
+    },
+    {
+      "id": "notebooklm",
+      "type": "skill",
+      "name": "NotebookLM",
+      "description": "Interact with Google NotebookLM to create notebooks, add sources, and generate audio overviews. Requires NotebookLM MCP server to be configured.",
+      "author": "Crewly Team",
+      "version": "0.1.0",
+      "category": "research",
+      "tags": [
+        "notebooklm",
+        "research",
+        "audio",
+        "notebook",
+        "google",
+        "mcp"
+      ],
+      "license": "MIT",
+      "downloads": 0,
+      "rating": 0,
+      "createdAt": "2026-02-28T00:00:00.000Z",
+      "updatedAt": "2026-02-28T00:00:00.000Z",
+      "source": "config/skills/agent/marketplace/notebooklm",
+      "assets": {
+        "archive": "config/skills/agent/marketplace/notebooklm",
+        "checksum": "",
+        "sizeBytes": 5000
+      },
+      "metadata": {
+        "skillType": "mcp-skill",
+        "assignableRoles": [
+          "researcher",
+          "developer",
+          "generalist",
+          "fullstack-dev",
+          "qa",
+          "qa-engineer"
+        ],
+        "triggers": [
+          "notebooklm",
+          "notebook lm",
+          "create notebook",
+          "audio overview",
+          "research notebook"
         ]
       }
     },
@@ -572,6 +670,10 @@
           "fill form",
           "navigate",
           "headless"
+        ],
+        "files": [
+          "skill.json",
+          "instructions.md"
         ]
       }
     },
@@ -799,6 +901,160 @@
         ]
       }
     },
+    {
+      "id": "browse-stealth",
+      "type": "skill",
+      "name": "Stealth Browser (Patchright + CDP)",
+      "description": "Anti-detection browser automation using Patchright (Playwright fork) connected to a real Chrome instance via CDP. Bypasses navigator.webdriver checks, fingerprint anomalies, and headless detection used by platforms like 小红书, X/Twitter, and LinkedIn.",
+      "author": "Crewly Team",
+      "version": "1.0.0",
+      "category": "automation",
+      "tags": [
+        "browser",
+        "stealth",
+        "patchright",
+        "cdp",
+        "anti-detection",
+        "automation"
+      ],
+      "license": "MIT",
+      "downloads": 0,
+      "rating": 0,
+      "createdAt": "2026-02-28T00:00:00.000Z",
+      "updatedAt": "2026-02-28T00:00:00.000Z",
+      "source": "config/skills/agent/browse-stealth",
+      "assets": {
+        "archive": "config/skills/agent/browse-stealth",
+        "checksum": "",
+        "sizeBytes": 20000
+      },
+      "metadata": {
+        "skillType": "claude-skill",
+        "assignableRoles": [
+          "developer",
+          "qa",
+          "qa-engineer",
+          "fullstack-dev",
+          "backend-developer",
+          "frontend-developer",
+          "generalist",
+          "ops",
+          "content-strategist"
+        ],
+        "triggers": [
+          "stealth browse",
+          "browse stealth",
+          "anti-detection",
+          "xiaohongshu",
+          "rednote browse",
+          "patchright",
+          "cdp browse",
+          "stealth scrape"
+        ],
+        "files": [
+          "skill.json",
+          "execute.sh",
+          "instructions.md",
+          "launch-chrome-cdp.sh",
+          "stealth-browse.py"
+        ]
+      }
+    },
+    {
+      "id": "remotion-video",
+      "type": "skill",
+      "name": "Remotion Video Generator",
+      "description": "Generate motion graphic videos programmatically using Remotion and React. Supports template-based video creation with customizable text, colors, images, and transitions. Renders to MP4 locally.",
+      "author": "Crewly Team",
+      "version": "1.0.0",
+      "category": "content",
+      "tags": [
+        "video",
+        "remotion",
+        "react",
+        "motion-graphics",
+        "animation",
+        "mp4",
+        "content"
+      ],
+      "license": "MIT",
+      "downloads": 0,
+      "rating": 0,
+      "createdAt": "2026-02-28T00:00:00.000Z",
+      "updatedAt": "2026-02-28T00:00:00.000Z",
+      "source": "config/skills/agent/marketplace/remotion-video",
+      "assets": {
+        "archive": "config/skills/agent/marketplace/remotion-video",
+        "checksum": "",
+        "sizeBytes": 25000
+      },
+      "metadata": {
+        "skillType": "claude-skill",
+        "assignableRoles": [
+          "developer",
+          "designer",
+          "content",
+          "generalist",
+          "product-manager"
+        ],
+        "triggers": [
+          "create video",
+          "generate video",
+          "motion graphics",
+          "remotion",
+          "launch video",
+          "promo video",
+          "video animation"
+        ]
+      }
+    },
+    {
+      "id": "gemini-video",
+      "type": "skill",
+      "name": "Gemini Video Understanding",
+      "description": "Analyze videos using Google's Gemini API. Supports YouTube URLs (direct analysis) and local video files (upload via Files API). Produces summaries, key points, transcript highlights, and Q&A.",
+      "author": "Crewly Team",
+      "version": "1.0.0",
+      "category": "content",
+      "tags": [
+        "video",
+        "analysis",
+        "youtube",
+        "gemini",
+        "ai",
+        "content",
+        "summary"
+      ],
+      "license": "MIT",
+      "downloads": 0,
+      "rating": 0,
+      "createdAt": "2026-02-28T00:00:00.000Z",
+      "updatedAt": "2026-02-28T00:00:00.000Z",
+      "source": "config/skills/agent/marketplace/gemini-video",
+      "assets": {
+        "archive": "config/skills/agent/marketplace/gemini-video",
+        "checksum": "",
+        "sizeBytes": 8500
+      },
+      "metadata": {
+        "skillType": "claude-skill",
+        "assignableRoles": [
+          "developer",
+          "researcher",
+          "content",
+          "product-manager",
+          "generalist"
+        ],
+        "triggers": [
+          "analyze video",
+          "video summary",
+          "youtube analysis",
+          "video understanding",
+          "gemini video",
+          "watch video"
+        ]
+      }
+    },
     {
       "id": "test-runner",
       "type": "skill",