crewly 1.5.18 → 1.5.19

package/config/skills/agent/core/break-down-request/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: Break Down Request
+description: "Decompose a V3 Request into specific, actionable WorkItems based on semantic understanding of the task."
+version: 1.0.0
+category: task-management
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+  - team-leader
+  - architect
+  - product-manager
+  - developer
+  - backend-developer
+  - frontend-developer
+  - fullstack-dev
+triggers:
+  - break down request
+  - decompose request
+  - split request into tasks
+tags:
+  - v3
+  - request
+  - decomposition
+  - work-items
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 30000
+---
+
+# Break Down Request
+
+Decompose a V3 Request (L2 or L3) into specific, actionable WorkItems in the TaskPool. Use your LLM understanding to create meaningful task breakdowns -- do NOT use generic templates.
+
+## WHEN to use this skill
+
+Call this skill **after** creating an L2+ Request via the `create-request` skill. The orchestrator should:
+
+1. Analyze the user's actual request
+2. Determine the specific steps needed
+3. Call this skill with a tailored list of tasks
+
+**DO NOT** use generic decomposition. Every breakdown should be specific to what the user asked for.
+
+## How to decompose
+
+Think about the request like a senior engineer would:
+- What are the concrete steps to accomplish this?
+- What order should they happen in?
+- Who is best suited for each step?
+- Are there any review or validation steps needed?
+
+## Task Types
+
+| Type | When to use |
+|------|-------------|
+| delegate | Work that should be assigned to an agent for execution |
+| check | Validation or verification step (tests pass, build succeeds) |
+| notify | Inform someone of a status change or result |
+| review | Code review, design review, or approval step |
+
+## Parameters
+
+| Flag | Required | Description |
+|------|----------|-------------|
+| `--request-id` | Yes | The Request ID to decompose (from create-request output) |
+| `--tasks` | Yes | JSON array of task objects (use --file for complex JSON) |
+
+### Task Object Structure
+
+Each task in the `--tasks` array should have:
+
+```json
+{
+  "title": "Create team V3-QA-Team",
+  "description": "Create a new QA team named V3-QA-Team with testing focus",
+  "type": "delegate",
+  "priority": "normal",
+  "target": "orchestrator"
+}
+```
+
+| Field | Required | Values | Description |
+|-------|----------|--------|-------------|
+| title | Yes | string | Concise task title |
+| description | Yes | string | Detailed instructions |
+| type | Yes | delegate, check, notify, review | Task execution type |
+| priority | No | low, normal, high, urgent | Default: normal |
+| target | No | string | Target agent/role (e.g., "backend-developer", "qa-engineer") |
+
+## Examples
+
+### Example 1: "Create a QA team with 3 members and a project"
+
+```bash
+bash execute.sh --request-id "req_abc123" --tasks '[
+  {"title": "Create team V3-QA-Team", "description": "Create a new team named V3-QA-Team focused on quality assurance", "type": "delegate", "priority": "high", "target": "orchestrator"},
+  {"title": "Add member TestLead-Quinn", "description": "Add a test lead named Quinn to V3-QA-Team with role qa-engineer", "type": "delegate", "target": "orchestrator"},
+  {"title": "Add member FE-Tester-Aria", "description": "Add a frontend tester named Aria to V3-QA-Team with role qa-engineer", "type": "delegate", "target": "orchestrator"},
+  {"title": "Add member BE-Tester-Kai", "description": "Add a backend tester named Kai to V3-QA-Team with role qa-engineer", "type": "delegate", "target": "orchestrator"},
+  {"title": "Create QA project", "description": "Create a project for V3-QA-Team to track their testing work", "type": "delegate", "target": "orchestrator"},
+  {"title": "Verify team setup", "description": "Check that all 3 members are added and the project is linked", "type": "check", "target": "orchestrator"}
+]'
+```
+
+### Example 2: "Build OAuth2 authentication" (using --file for complex JSON)
+
+```bash
+cat > /tmp/crewly_input.json << 'CREWLY_EOF'
+{"requestId": "req_def456", "tasks": [
+  {"title": "Design OAuth2 flow", "description": "Design the OAuth2 authorization code flow with Google and GitHub providers", "type": "delegate", "priority": "high", "target": "architect"},
+  {"title": "Implement OAuth2 routes", "description": "Create Express routes for /auth/google, /auth/github, /auth/callback", "type": "delegate", "priority": "high", "target": "backend-developer"},
+  {"title": "Implement token management", "description": "Build JWT token generation, refresh, and validation logic", "type": "delegate", "priority": "high", "target": "backend-developer"},
+  {"title": "Write auth tests", "description": "Write unit and integration tests for OAuth2 flow with mocked providers", "type": "delegate", "target": "qa-engineer"},
+  {"title": "Review auth implementation", "description": "Security review of the OAuth2 implementation", "type": "review", "target": "architect"}
+]}
+CREWLY_EOF
+bash execute.sh --file /tmp/crewly_input.json
+```
+
+## Output
+
+JSON summary of created WorkItems:
+- `workItemIds` -- Array of created WorkItem IDs
+- `requestId` -- The parent Request ID
+- `count` -- Number of WorkItems created

package/config/skills/agent/core/break-down-request/execute.sh

@@ -0,0 +1,200 @@
+#!/bin/bash
+# Break down a V3 Request into specific, actionable WorkItems in the TaskPool.
+# Each task is added as a WorkItem, then linked back to the parent Request.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  # CLI flags (preferred)
+  bash execute.sh --request-id "req_abc123" --tasks '[{"title":"Task 1","description":"Do thing","type":"delegate"}]'
+
+  # Using --file for complex JSON (avoids shell escaping issues)
+  bash execute.sh --file /tmp/crewly_input.json
+
+  # Legacy JSON (backward compatible)
+  bash execute.sh '{"requestId":"req_abc123","tasks":[...]}'
+
+Options:
+  --request-id         | -r   The Request ID to decompose (required)
+  --tasks                     JSON array of task objects (required)
+  --json               | -j   Raw JSON payload (same as legacy)
+  --help               | -h   Show this help
+
+Task object fields:
+  title        (required)  Concise task title
+  description  (required)  Detailed instructions
+  type         (required)  delegate | check | notify | review
+  priority     (optional)  low | normal | high | urgent (default: normal)
+  target       (optional)  Target agent session name or role
+EOF_USAGE
+}
+
+INPUT_JSON=""
+REQUEST_ID=""
+TASKS_JSON=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --request-id|-r)
+      REQUEST_ID="$2"
+      shift 2
+      ;;
+    --tasks)
+      TASKS_JSON="$2"
+      shift 2
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      print_usage
+      exit 0
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"
+        shift
+      else
+        error_exit "Unknown argument: $1. Use --help for usage."
+      fi
+      ;;
+  esac
+done
+
+# Read from stdin if no input yet
+if [ -z "$INPUT_JSON" ] && [ -z "$REQUEST_ID" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  fi
+fi
+
+# Parse JSON if provided
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$REQUEST_ID" ] && REQUEST_ID=$(printf '%s' "$INPUT" | jq -r '.requestId // empty')
+  [ -z "$TASKS_JSON" ] && TASKS_JSON=$(printf '%s' "$INPUT" | jq -c '.tasks // empty')
+fi
+
+# Validate required parameters
+require_param "request-id (--request-id)" "$REQUEST_ID"
+require_param "tasks (--tasks)" "$TASKS_JSON"
+
+# Validate tasks is a JSON array
+TASK_COUNT=$(printf '%s' "$TASKS_JSON" | jq 'length' 2>/dev/null || echo "0")
+if [ "$TASK_COUNT" = "0" ]; then
+  error_exit "tasks must be a non-empty JSON array of task objects"
+fi
+
+# Validate each task has required fields
+for i in $(seq 0 $((TASK_COUNT - 1))); do
+  TASK_TITLE=$(printf '%s' "$TASKS_JSON" | jq -r ".[$i].title // empty")
+  TASK_DESC=$(printf '%s' "$TASKS_JSON" | jq -r ".[$i].description // empty")
+  TASK_TYPE=$(printf '%s' "$TASKS_JSON" | jq -r ".[$i].type // empty")
+
+  if [ -z "$TASK_TITLE" ]; then
+    error_exit "Task at index $i is missing required field: title"
+  fi
+  if [ -z "$TASK_DESC" ]; then
+    error_exit "Task at index $i is missing required field: description"
+  fi
+  if [ -z "$TASK_TYPE" ]; then
+    error_exit "Task at index $i is missing required field: type"
+  fi
+
+  # Validate type
+  case "$TASK_TYPE" in
+    delegate|check|notify|review) ;;
+    *) error_exit "Task at index $i has invalid type: $TASK_TYPE. Must be one of: delegate, check, notify, review." ;;
+  esac
+done
+
+# Create WorkItems for each task
+WORK_ITEM_IDS="[]"
+CREATED=0
+FAILED=0
+
+for i in $(seq 0 $((TASK_COUNT - 1))); do
+  TASK_TITLE=$(printf '%s' "$TASKS_JSON" | jq -r ".[$i].title")
+  TASK_DESC=$(printf '%s' "$TASKS_JSON" | jq -r ".[$i].description")
+  TASK_TYPE=$(printf '%s' "$TASKS_JSON" | jq -r ".[$i].type")
+  TASK_PRIORITY=$(printf '%s' "$TASKS_JSON" | jq -r ".[$i].priority // \"normal\"")
+  TASK_TARGET=$(printf '%s' "$TASKS_JSON" | jq -r ".[$i].target // \"unassigned\"")
+
+  # Generate a unique ID for the WorkItem
+  WORK_ITEM_ID="wi_$(date +%s%N | cut -c1-13)_${i}"
+
+  # Build WorkItem body matching the expected format for POST /task-pool/add
+  WI_BODY=$(jq -n \
+    --arg id "$WORK_ITEM_ID" \
+    --arg type "$TASK_TYPE" \
+    --arg owner "orchestrator" \
+    --arg target "$TASK_TARGET" \
+    --arg title "$TASK_TITLE" \
+    --arg description "$TASK_DESC" \
+    --arg status "queued" \
+    --arg requestId "$REQUEST_ID" \
+    --arg createdAt "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" \
+    '{
+      id: $id,
+      type: $type,
+      owner: $owner,
+      target: $target,
+      title: $title,
+      description: $description,
+      status: $status,
+      requestId: $requestId,
+      createdAt: $createdAt,
+      retryCount: 0,
+      maxRetries: 3,
+      inputTokens: 0,
+      outputTokens: 0,
+      cost: 0
+    }')
+
+  # Add to the task pool
+  if RESULT=$(api_call POST "/task-pool/add" "$WI_BODY" 2>&1); then
+    WORK_ITEM_IDS=$(printf '%s' "$WORK_ITEM_IDS" | jq --arg wid "$WORK_ITEM_ID" '. + [$wid]')
+    CREATED=$((CREATED + 1))
+  else
+    echo "[warn] Failed to create WorkItem for task '$TASK_TITLE': $RESULT" >&2
+    FAILED=$((FAILED + 1))
+  fi
+done
+
+# Link all created WorkItem IDs to the parent Request
+if [ "$CREATED" -gt 0 ]; then
+  LINK_BODY=$(printf '%s' "$WORK_ITEM_IDS" | jq '{workItemIds: .}')
+  api_call PUT "/requests/$REQUEST_ID" "$LINK_BODY" >/dev/null 2>&1 || \
+    echo "[warn] Failed to link WorkItems to Request $REQUEST_ID (non-fatal)" >&2
+fi
+
+# Output summary
+jq -n \
+  --arg requestId "$REQUEST_ID" \
+  --argjson workItemIds "$WORK_ITEM_IDS" \
+  --argjson created "$CREATED" \
+  --argjson failed "$FAILED" \
+  --argjson total "$TASK_COUNT" \
+  '{
+    success: true,
+    requestId: $requestId,
+    workItemIds: $workItemIds,
+    count: $created,
+    failed: $failed,
+    total: $total
+  }'

package/config/skills/agent/core/claim-heartbeat/execute.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+# =============================================================================
+# claim-heartbeat — Send heartbeat for an active Task Pool claim
+#
+# Agents call this every 2 minutes while working on a claimed task.
+# The heartbeat proves liveness to the Reconciler and prevents the claim
+# from being revoked due to lease expiry.
+#
+# Usage:
+#   bash execute.sh '{"claimId":"claim-abc","sessionName":"agent-1"}'
+#
+# Parameters:
+#   claimId      (required) — The active claim ID to heartbeat
+#   sessionName  (required) — Agent session name (must match claim owner)
+#
+# Returns:
+#   Success: { success: true, claim: {...} }
+#   Error:   { success: false, reason: "..." }
+# =============================================================================
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+INPUT=$(read_json_input "${1:-}")
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"claimId\":\"claim-abc\",\"sessionName\":\"agent-1\"}'"
+
+CLAIM_ID=$(printf '%s' "$INPUT" | jq -r '.claimId // empty')
+SESSION_NAME=$(printf '%s' "$INPUT" | jq -r '.sessionName // empty')
+require_param "claimId" "$CLAIM_ID"
+require_param "sessionName" "$SESSION_NAME"
+
+# ---------------------------------------------------------------------------
+# Send heartbeat to Task Pool API
+# ---------------------------------------------------------------------------
+
+BODY=$(jq -n \
+  --arg claimId "$CLAIM_ID" \
+  --arg agentId "$SESSION_NAME" \
+  '{claimId: $claimId, agentId: $agentId}')
+
+RESPONSE=$(api_call POST "/task-pool/heartbeat" "$BODY" 2>&1) || {
+  # Parse error response
+  ERROR_MSG=$(printf '%s' "$RESPONSE" | jq -r '.error // .message // "Unknown error"' 2>/dev/null || echo "$RESPONSE")
+  jq -n --arg reason "$ERROR_MSG" '{success: false, reason: $reason}'
+  exit 0
+}
+
+# Extract result
+SUCCESS=$(printf '%s' "$RESPONSE" | jq -r '.success // false')
+CLAIM_OBJ=$(printf '%s' "$RESPONSE" | jq -c '.data.claim // .data // null')
+
+if [ "$SUCCESS" = "true" ]; then
+  jq -n --argjson claim "$CLAIM_OBJ" '{success: true, claim: $claim}'
+else
+  REASON=$(printf '%s' "$RESPONSE" | jq -r '.error // .message // "Heartbeat rejected"')
+  jq -n --arg reason "$REASON" '{success: false, reason: $reason}'
+fi

package/config/skills/agent/core/claim-heartbeat/execute.test.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+# =============================================================================
+# Tests for claim-heartbeat skill
+#
+# Verifies parameter validation, API call construction, and output format.
+# Uses mock api_call to simulate backend responses without a running server.
+# =============================================================================
+set -eo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PASS=0
+FAIL=0
+ERRORS=""
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+assert_eq() {
+  local test_name="$1" expected="$2" actual="$3"
+  if [ "$expected" = "$actual" ]; then
+    PASS=$((PASS + 1))
+    echo "  ✓ ${test_name}"
+  else
+    FAIL=$((FAIL + 1))
+    ERRORS="${ERRORS}\n  ✗ ${test_name}\n    expected: ${expected}\n    actual:   ${actual}"
+    echo "  ✗ ${test_name}"
+    echo "    expected: ${expected}"
+    echo "    actual:   ${actual}"
+  fi
+}
+
+assert_contains() {
+  local test_name="$1" needle="$2" haystack="$3"
+  if printf '%s' "$haystack" | grep -q "$needle"; then
+    PASS=$((PASS + 1))
+    echo "  ✓ ${test_name}"
+  else
+    FAIL=$((FAIL + 1))
+    ERRORS="${ERRORS}\n  ✗ ${test_name}\n    expected to contain: ${needle}\n    actual: ${haystack}"
+    echo "  ✗ ${test_name}"
+    echo "    expected to contain: ${needle}"
+  fi
+}
+
+# ---------------------------------------------------------------------------
+# Test: Missing required params
+# ---------------------------------------------------------------------------
+
+echo "=== claim-heartbeat tests ==="
+
+echo ""
+echo "--- Missing parameters ---"
+
+# Test missing claimId
+OUTPUT=$(bash "$SCRIPT_DIR/execute.sh" '{"sessionName":"agent-1"}' 2>&1) || true
+assert_contains "Missing claimId returns error" "claimId" "$OUTPUT"
+
+# Test missing sessionName
+OUTPUT=$(bash "$SCRIPT_DIR/execute.sh" '{"claimId":"claim-1"}' 2>&1) || true
+assert_contains "Missing sessionName returns error" "sessionName" "$OUTPUT"
+
+# Test empty input
+OUTPUT=$(bash "$SCRIPT_DIR/execute.sh" '' 2>&1) || true
+assert_contains "Empty input returns usage error" "Usage" "$OUTPUT"
+
+# ---------------------------------------------------------------------------
+# Test: Mock successful heartbeat
+# ---------------------------------------------------------------------------
+
+echo ""
+echo "--- Mock API responses ---"
+
+# Create a temp script that mocks the api_call
+MOCK_DIR=$(mktemp -d)
+cat > "$MOCK_DIR/mock_heartbeat.sh" << 'MOCK_EOF'
+#!/bin/bash
+# Override api_call to return mock responses
+api_call() {
+  local method="$1" endpoint="$2" body="$3"
+  if [ "$method" = "POST" ] && [[ "$endpoint" == *"/task-pool/heartbeat"* ]]; then
+    echo '{"success": true, "data": {"claim": {"id": "claim-abc", "status": "active", "lastHeartbeatAt": "2026-04-05T10:00:00Z"}}}'
+    return 0
+  fi
+  return 1
+}
+
+# Source the common lib first, then override api_call
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../../../_common/lib.sh"
+# Re-define api_call after sourcing (override)
+api_call() {
+  echo '{"success": true, "data": {"claim": {"id": "claim-abc", "status": "active", "lastHeartbeatAt": "2026-04-05T10:00:00Z"}}}'
+  return 0
+}
+
+INPUT='{"claimId":"claim-abc","sessionName":"agent-1"}'
+CLAIM_ID="claim-abc"
+SESSION_NAME="agent-1"
+
+BODY=$(jq -n --arg claimId "$CLAIM_ID" --arg agentId "$SESSION_NAME" '{claimId: $claimId, agentId: $agentId}')
+RESPONSE=$(api_call POST "/task-pool/heartbeat" "$BODY")
+SUCCESS=$(printf '%s' "$RESPONSE" | jq -r '.success // false')
+CLAIM_OBJ=$(printf '%s' "$RESPONSE" | jq -c '.data.claim // null')
+
+if [ "$SUCCESS" = "true" ]; then
+  jq -n --argjson claim "$CLAIM_OBJ" '{success: true, claim: $claim}'
+else
+  jq -n '{success: false, reason: "test failure"}'
+fi
+MOCK_EOF
+
+chmod +x "$MOCK_DIR/mock_heartbeat.sh"
+OUTPUT=$(bash "$MOCK_DIR/mock_heartbeat.sh" 2>&1) || true
+
+assert_contains "Successful heartbeat returns success" '"success": true' "$OUTPUT"
+assert_contains "Successful heartbeat returns claim" '"claim"' "$OUTPUT"
+
+rm -rf "$MOCK_DIR"
+
+# ---------------------------------------------------------------------------
+# Summary
+# ---------------------------------------------------------------------------
+
+echo ""
+echo "=== Results: ${PASS} passed, ${FAIL} failed ==="
+if [ $FAIL -gt 0 ]; then
+  echo -e "\nFailures:${ERRORS}"
+  exit 1
+fi

package/config/skills/agent/core/create-intent-tasks/execute.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# Create intent tasks from orchestrator LLM analysis of a user message.
+# Calls POST /api/intent-tasks/batch with structured task data.
+#
+# The orchestrator analyzes the user's message, extracts actionable tasks,
+# and calls this skill to persist them in the intent task system.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  bash execute.sh '{"originalMessage":"user message","tasks":[{"intent":"task description","level":"L1","category":"code_change"}]}'
+
+Parameters:
+  originalMessage  - The original user message (required)
+  tasks            - Array of task objects (required, at least 1)
+    intent         - Clear task description in imperative form (required)
+    level          - Complexity: "L0" (simple), "L1" (standard), "L2" (complex)
+    category       - One of: query, code_change, debugging, deployment,
+                     research, review, planning, communication, other
+
+Example:
+  bash execute.sh '{
+    "originalMessage": "Fix the login bug and deploy to staging",
+    "tasks": [
+      {"intent": "Fix the login bug on the settings page", "level": "L1", "category": "debugging"},
+      {"intent": "Deploy the fix to staging environment", "level": "L1", "category": "deployment"}
+    ]
+  }'
+EOF_USAGE
+}
+
+# ---------------------------------------------------------------------------
+# Parse arguments
+# ---------------------------------------------------------------------------
+if [ $# -eq 0 ] || [[ "${1:-}" == "--help" ]] || [[ "${1:-}" == "-h" ]]; then
+  print_usage
+  exit 0
+fi
+
+JSON_INPUT=$(read_json_input "$1")
+
+ORIGINAL_MESSAGE=$(echo "$JSON_INPUT" | jq -r '.originalMessage // empty')
+TASKS=$(echo "$JSON_INPUT" | jq -c '.tasks // []')
+TASK_COUNT=$(echo "$TASKS" | jq 'length')
+
+if [ -z "$ORIGINAL_MESSAGE" ]; then
+  echo '{"success":false,"error":"originalMessage is required"}'
+  exit 1
+fi
+
+if [ "$TASK_COUNT" -eq 0 ]; then
+  echo '{"success":false,"error":"tasks array must contain at least one task"}'
+  exit 1
+fi
+
+# ---------------------------------------------------------------------------
+# Build JSON body for batch create
+# ---------------------------------------------------------------------------
+BODY=$(jq -n \
+  --arg msg "$ORIGINAL_MESSAGE" \
+  --argjson tasks "$TASKS" \
+  '{originalMessage: $msg, tasks: $tasks}')
+
+# ---------------------------------------------------------------------------
+# Call backend API
+# ---------------------------------------------------------------------------
+CREWLY_PORT="${CREWLY_PORT:-8787}"
+API_URL="${CREWLY_API_URL:-http://localhost:${CREWLY_PORT}}"
+
+RESPONSE=$(curl -s -w "\n%{http_code}" \
+  -X POST \
+  -H "Content-Type: application/json" \
+  -d "$BODY" \
+  "${API_URL}/api/intent-tasks/batch" 2>&1) || {
+  echo "{\"success\":false,\"error\":\"Failed to connect to backend at ${API_URL}\"}"
+  exit 1
+}
+
+# Split response body and HTTP status code
+HTTP_CODE=$(echo "$RESPONSE" | tail -1)
+BODY_RESPONSE=$(echo "$RESPONSE" | sed '$d')
+
+if [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
+  # Extract task count from response for a clean summary
+  CREATED_COUNT=$(echo "$BODY_RESPONSE" | jq '.data | length' 2>/dev/null || echo "$TASK_COUNT")
+  echo "{\"success\":true,\"created\":${CREATED_COUNT},\"data\":$(echo "$BODY_RESPONSE" | jq -c '.data' 2>/dev/null || echo '[]')}"
+else
+  echo "{\"success\":false,\"error\":\"HTTP ${HTTP_CODE}\",\"body\":$(echo "$BODY_RESPONSE" | jq -c '.' 2>/dev/null || echo "\"$BODY_RESPONSE\"")}"
+  exit 1
+fi

package/config/skills/agent/core/create-mission/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: Create Mission
+description: "Create a new Mission with objective, success criteria, and strategy."
+version: 1.0.0
+category: task-management
+skillType: claude-skill
+assignableRoles:
+  - developer
+  - qa
+  - tpm
+  - designer
+  - frontend-developer
+  - backend-developer
+  - fullstack-dev
+  - qa-engineer
+  - product-manager
+  - architect
+  - generalist
+triggers:
+  - create mission
+  - new mission
+  - define mission
+  - set objective
+tags:
+  - mission
+  - objective
+  - strategy
+  - planning
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 30000
+---
+
+# Create Mission
+
+Create a new Mission via the `/api/missions` endpoint. Missions define high-level objectives with success criteria and strategy, enabling team leads and agents to autonomously set goals.
+
+## Parameters
+
+| Flag | JSON Field | Required | Description |
+|------|-----------|----------|-------------|
+| `--objective` / `-o` | `objective` | Yes | The mission objective (what to achieve) |
+| `--owner-team-id` / `-t` | `ownerTeamId` | Yes | Team ID that owns this mission |
+| `--success-criteria` / `-c` | `successCriteria` | Yes | JSON array of success criteria strings |
+| `--strategy` / `-s` | `currentStrategy` | Yes | Description of the current strategy |
+| `--cadence` | `cadence` | No | Cadence string (e.g. `daily`, `weekly`) |
+| `--policy` | `policy` | No | JSON object for mission policy overrides |
+
+## Examples — CLI Flags (preferred)
+
+```bash
+# Create a basic mission
+bash execute.sh --objective "Deliver V3 architecture" \
+  --owner-team-id "817a1aeb-b04e-45dd-bdbc-be5cbc4345f1" \
+  --success-criteria '["All V3 services implemented","100% test coverage","Zero regressions"]' \
+  --strategy "Incremental migration with parallel V2 support"
+
+# Create with cadence and policy
+bash execute.sh --objective "Weekly code quality audit" \
+  --owner-team-id "team-123" \
+  --success-criteria '["All critical issues resolved","Test coverage above 80%"]' \
+  --strategy "Automated scanning with manual review" \
+  --cadence "weekly" \
+  --policy '{"maxBudget":1000,"autoEscalate":true}'
+```
+
+## Examples — Legacy JSON (backward compatible)
+
+```bash
+bash execute.sh '{"objective":"Ship V3","ownerTeamId":"team-123","successCriteria":["All services migrated"],"currentStrategy":"Incremental migration"}'
+```
+
+## Output
+
+JSON response from the missions API with the created Mission object, including its generated ID, status, and policy.