crewly 1.5.18 → 1.5.20

package/config/skills/agent/core/create-mission/execute.sh

@@ -0,0 +1,141 @@
+#!/bin/bash
+# Create a new Mission via the mission API.
+# Allows TLs and agents to define high-level objectives with success criteria.
+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 --objective "Ship V3 architecture" --owner-team-id team-123 \
+    --success-criteria '["All services migrated","Tests passing"]' \
+    --strategy "Incremental migration with feature flags"
+
+  # Legacy JSON (backward compatible)
+  bash execute.sh '{"objective":"Ship V3","ownerTeamId":"team-123","successCriteria":["Done"],"currentStrategy":"Incremental"}'
+
+Options:
+  --objective       | -o   Mission objective (required)
+  --owner-team-id   | -t   Team ID that owns this mission (required)
+  --success-criteria| -c   JSON array of success criteria strings (required)
+  --strategy        | -s   Current strategy description (required)
+  --cadence               Cadence string, e.g. "daily", "weekly" (optional)
+  --policy                JSON object for mission policy overrides (optional)
+  --json            | -j   Raw JSON payload (same as legacy)
+  --help            | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+OBJECTIVE=""
+OWNER_TEAM_ID=""
+SUCCESS_CRITERIA=""
+STRATEGY=""
+CADENCE=""
+POLICY=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --objective|-o)
+      OBJECTIVE="$2"
+      shift 2
+      ;;
+    --owner-team-id|-t)
+      OWNER_TEAM_ID="$2"
+      shift 2
+      ;;
+    --success-criteria|-c)
+      SUCCESS_CRITERIA="$2"
+      shift 2
+      ;;
+    --strategy|-s)
+      STRATEGY="$2"
+      shift 2
+      ;;
+    --cadence)
+      CADENCE="$2"
+      shift 2
+      ;;
+    --policy)
+      POLICY="$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 "$OBJECTIVE" ] && [ ! -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 "$OBJECTIVE" ] && OBJECTIVE=$(printf '%s' "$INPUT" | jq -r '.objective // empty')
+  [ -z "$OWNER_TEAM_ID" ] && OWNER_TEAM_ID=$(printf '%s' "$INPUT" | jq -r '.ownerTeamId // empty')
+  [ -z "$SUCCESS_CRITERIA" ] && SUCCESS_CRITERIA=$(printf '%s' "$INPUT" | jq -c '.successCriteria // empty')
+  [ -z "$STRATEGY" ] && STRATEGY=$(printf '%s' "$INPUT" | jq -r '.currentStrategy // .strategy // empty')
+  [ -z "$CADENCE" ] && CADENCE=$(printf '%s' "$INPUT" | jq -r '.cadence // empty')
+  [ -z "$POLICY" ] && POLICY=$(printf '%s' "$INPUT" | jq -c '.policy // empty')
+fi
+
+require_param "objective (--objective)" "$OBJECTIVE"
+require_param "ownerTeamId (--owner-team-id)" "$OWNER_TEAM_ID"
+require_param "successCriteria (--success-criteria)" "$SUCCESS_CRITERIA"
+require_param "currentStrategy (--strategy)" "$STRATEGY"
+
+# Validate successCriteria is a JSON array
+if ! printf '%s' "$SUCCESS_CRITERIA" | jq -e 'type == "array"' >/dev/null 2>&1; then
+  error_exit "successCriteria must be a JSON array of strings, e.g. '[\"criterion 1\",\"criterion 2\"]'"
+fi
+
+# Build the request body
+BODY=$(jq -n \
+  --arg objective "$OBJECTIVE" \
+  --arg ownerTeamId "$OWNER_TEAM_ID" \
+  --argjson successCriteria "$SUCCESS_CRITERIA" \
+  --arg currentStrategy "$STRATEGY" \
+  '{objective: $objective, ownerTeamId: $ownerTeamId, successCriteria: $successCriteria, currentStrategy: $currentStrategy}')
+
+# Attach optional cadence
+if [ -n "$CADENCE" ] && [ "$CADENCE" != "" ]; then
+  BODY=$(printf '%s' "$BODY" | jq --arg cadence "$CADENCE" '. + {cadence: $cadence}')
+fi
+
+# Attach optional policy
+if [ -n "$POLICY" ] && [ "$POLICY" != "" ]; then
+  BODY=$(printf '%s' "$BODY" | jq --argjson policy "$POLICY" '. + {policy: $policy}')
+fi
+
+api_call POST "/missions" "$BODY"

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

@@ -0,0 +1,132 @@
+---
+name: Create Request
+description: "Create a V3 Request from a user message that the orchestrator has determined to be actionable work."
+version: 1.0.0
+category: task-management
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+  - team-leader
+  - developer
+  - qa
+  - tpm
+  - designer
+  - frontend-developer
+  - backend-developer
+  - fullstack-dev
+  - qa-engineer
+  - product-manager
+  - architect
+  - generalist
+triggers:
+  - create request
+  - log request
+  - new request
+  - track request
+tags:
+  - v3
+  - request
+  - tracking
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 15000
+---
+
+# Create Request
+
+Create a V3 Request entity to track actionable user work. This skill is called by the orchestrator (or any agent with semantic understanding) after determining that a user message represents real, actionable work.
+
+## WHEN to use this skill
+
+Only call this skill when you determine a user message represents **actionable work**. Use your judgment as an LLM to classify intent.
+
+**DO create a Request for:**
+- "Build a login page with OAuth2" (code_change, L2)
+- "Fix the broken test in auth.service.test.ts" (debugging, L1)
+- "Deploy the staging environment" (deployment, L1)
+- "Create a QA team with 3 members" (team_management, L2)
+- "What endpoints does the auth service expose?" (query, L1)
+- "Plan the migration to PostgreSQL" (planning, L2)
+
+**DO NOT create a Request for:**
+- "Hello" / "Hi team" (greeting)
+- "Thanks!" / "Got it" / "OK" (acknowledgment)
+- "How are you?" (small talk)
+- "." / "k" / "yes" (filler)
+- "Sounds good, let's proceed" (confirmation of prior work -- no new work)
+
+## Intent Levels
+
+Use these to classify the complexity of the request:
+
+| Level | Meaning | Example |
+|-------|---------|---------|
+| L0 | Not actionable -- should NOT call this skill | "Thanks!", "Hello" |
+| L1 | Simple, single-step task | "Fix the typo in README.md" |
+| L2 | Multi-step, needs coordination or decomposition | "Build a new auth system with OAuth2 and tests" |
+| L3 | Large project, should trigger Mission creation | "Rewrite the entire backend in Go with full test coverage" |
+
+## Intent Categories
+
+| Category | When to use |
+|----------|-------------|
+| communication | Sending messages, notifications, status updates |
+| query | Questions, lookups, information retrieval |
+| code_change | Writing, modifying, or refactoring code |
+| planning | Architecture decisions, roadmap work, design |
+| debugging | Bug fixes, investigation, troubleshooting |
+| deployment | Deploy, release, environment management |
+| team_management | Creating teams, adding members, role changes |
+| other | Anything that does not fit the above |
+
+## Parameters
+
+| Flag | Required | Default | Description |
+|------|----------|---------|-------------|
+| `--title` | Yes | -- | Concise title summarizing the request |
+| `--description` | Yes | -- | Full description of what the user asked for |
+| `--intent-level` | Yes | -- | L0, L1, L2, or L3 |
+| `--intent-category` | Yes | -- | communication, query, code_change, planning, debugging, deployment, team_management, other |
+| `--priority` | No | normal | low, normal, high, urgent |
+| `--source-message-id` | No | -- | Original message ID (for dedup) |
+| `--needs-mission` | No | false | Whether this L3 request should trigger Mission creation |
+
+## Examples -- CLI Flags (preferred)
+
+```bash
+# Simple bug fix
+bash execute.sh --title "Fix auth test failure" \
+  --description "The test in auth.service.test.ts is failing due to a missing mock" \
+  --intent-level L1 --intent-category debugging \
+  --source-message-id "msg_abc123"
+
+# Complex multi-step request
+bash execute.sh --title "Build OAuth2 authentication system" \
+  --description "Create a complete OAuth2 auth system with Google and GitHub providers, including tests and documentation" \
+  --intent-level L2 --intent-category code_change \
+  --priority high --source-message-id "msg_def456"
+
+# Large project needing Mission
+bash execute.sh --title "Rewrite backend in Go" \
+  --description "Full backend rewrite from Node.js to Go with all existing functionality preserved" \
+  --intent-level L3 --intent-category code_change \
+  --priority high --needs-mission true --source-message-id "msg_ghi789"
+```
+
+## Examples -- Legacy JSON (backward compatible)
+
+```bash
+bash execute.sh '{"title":"Fix auth test","description":"Fix failing test","intentLevel":"L1","intentCategory":"debugging"}'
+```
+
+## Output
+
+JSON response with the created Request object including:
+- `id` -- Unique Request ID
+- `title` -- The title provided
+- `status` -- "open" (initial status)
+- `intentLevel` -- The classified intent level
+- `intentCategory` -- The classified intent category

package/config/skills/agent/core/create-request/execute.sh

@@ -0,0 +1,176 @@
+#!/bin/bash
+# Create a V3 Request from a user message determined to be actionable work.
+# The orchestrator (with LLM understanding) decides WHEN to call this skill.
+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 --title "Fix auth test" --description "Fix the failing test" \
+    --intent-level L1 --intent-category debugging --source-message-id "msg_abc123"
+
+  # Legacy JSON (backward compatible)
+  bash execute.sh '{"title":"Fix auth test","description":"Fix failing test","intentLevel":"L1","intentCategory":"debugging"}'
+
+Options:
+  --title              | -t   Concise title for the request (required)
+  --description        | -d   Full description of the request (required)
+  --intent-level             L0, L1, L2, or L3 (required)
+  --intent-category          communication, query, code_change, planning, debugging, deployment, team_management, other (required)
+  --priority                 low, normal, high, urgent (optional, default: normal)
+  --source-message-id        Original message ID for dedup (optional)
+  --needs-mission            true/false — trigger Mission creation (optional, default: false)
+  --json               | -j  Raw JSON payload (same as legacy)
+  --help               | -h  Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+TITLE=""
+DESCRIPTION=""
+INTENT_LEVEL=""
+INTENT_CATEGORY=""
+PRIORITY=""
+SOURCE_MESSAGE_ID=""
+NEEDS_MISSION=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --title|-t)
+      TITLE="$2"
+      shift 2
+      ;;
+    --description|-d)
+      DESCRIPTION="$2"
+      shift 2
+      ;;
+    --intent-level)
+      INTENT_LEVEL="$2"
+      shift 2
+      ;;
+    --intent-category)
+      INTENT_CATEGORY="$2"
+      shift 2
+      ;;
+    --priority)
+      PRIORITY="$2"
+      shift 2
+      ;;
+    --source-message-id)
+      SOURCE_MESSAGE_ID="$2"
+      shift 2
+      ;;
+    --needs-mission)
+      NEEDS_MISSION="$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 "$TITLE" ] && [ ! -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 "$TITLE" ] && TITLE=$(printf '%s' "$INPUT" | jq -r '.title // empty')
+  [ -z "$DESCRIPTION" ] && DESCRIPTION=$(printf '%s' "$INPUT" | jq -r '.description // empty')
+  [ -z "$INTENT_LEVEL" ] && INTENT_LEVEL=$(printf '%s' "$INPUT" | jq -r '.intentLevel // empty')
+  [ -z "$INTENT_CATEGORY" ] && INTENT_CATEGORY=$(printf '%s' "$INPUT" | jq -r '.intentCategory // empty')
+  [ -z "$PRIORITY" ] && PRIORITY=$(printf '%s' "$INPUT" | jq -r '.priority // empty')
+  [ -z "$SOURCE_MESSAGE_ID" ] && SOURCE_MESSAGE_ID=$(printf '%s' "$INPUT" | jq -r '.sourceMessageId // empty')
+  [ -z "$NEEDS_MISSION" ] && NEEDS_MISSION=$(printf '%s' "$INPUT" | jq -r '.needsMission // empty')
+fi
+
+# Validate required parameters
+require_param "title (--title)" "$TITLE"
+require_param "description (--description)" "$DESCRIPTION"
+require_param "intent-level (--intent-level)" "$INTENT_LEVEL"
+require_param "intent-category (--intent-category)" "$INTENT_CATEGORY"
+
+# Validate intent-level
+case "$INTENT_LEVEL" in
+  L0|L1|L2|L3) ;;
+  *) error_exit "Invalid --intent-level: $INTENT_LEVEL. Must be L0, L1, L2, or L3." ;;
+esac
+
+# Validate intent-category
+case "$INTENT_CATEGORY" in
+  communication|query|code_change|planning|debugging|deployment|team_management|other) ;;
+  *) error_exit "Invalid --intent-category: $INTENT_CATEGORY. Must be one of: communication, query, code_change, planning, debugging, deployment, team_management, other." ;;
+esac
+
+# Validate priority if provided
+if [ -n "$PRIORITY" ]; then
+  case "$PRIORITY" in
+    low|normal|high|urgent) ;;
+    *) error_exit "Invalid --priority: $PRIORITY. Must be one of: low, normal, high, urgent." ;;
+  esac
+fi
+
+# Build the request body
+BODY=$(jq -n \
+  --arg title "$TITLE" \
+  --arg description "$DESCRIPTION" \
+  --arg intentLevel "$INTENT_LEVEL" \
+  --arg intentCategory "$INTENT_CATEGORY" \
+  '{title: $title, description: $description, intentLevel: $intentLevel, intentCategory: $intentCategory}')
+
+# Add optional fields
+if [ -n "$PRIORITY" ]; then
+  BODY=$(printf '%s' "$BODY" | jq --arg p "$PRIORITY" '. + {priority: $p}')
+fi
+
+if [ -n "$SOURCE_MESSAGE_ID" ]; then
+  BODY=$(printf '%s' "$BODY" | jq --arg sid "$SOURCE_MESSAGE_ID" '. + {sourceConversationItemId: $sid}')
+fi
+
+# Call the API to create the Request
+RESULT=$(api_call POST "/requests" "$BODY")
+
+# If needs-mission is true, log it in the output for the orchestrator to act on
+if [ "$NEEDS_MISSION" = "true" ]; then
+  # Extract the request ID from the response and append the needsMission flag
+  REQUEST_ID=$(printf '%s' "$RESULT" | jq -r '.data.id // empty')
+  if [ -n "$REQUEST_ID" ]; then
+    printf '%s' "$RESULT" | jq --arg rid "$REQUEST_ID" '.needsMission = true | .requestId = $rid'
+  else
+    printf '%s' "$RESULT" | jq '.needsMission = true'
+  fi
+else
+  printf '%s' "$RESULT"
+fi

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

@@ -0,0 +1,76 @@
+---
+name: Create Task
+description: "Create a new task via the task-management API for autonomous work decomposition."
+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 task
+  - new task
+  - add task
+  - decompose task
+  - sub-task
+tags:
+  - task
+  - management
+  - decomposition
+  - delegation
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 30000
+---
+
+# Create Task
+
+Create a new task via the `/api/task-management/create` endpoint. This allows team leads and agents to autonomously decompose their work into sub-tasks without requiring orchestrator intervention.
+
+## Parameters
+
+| Flag | JSON Field | Required | Description |
+|------|-----------|----------|-------------|
+| `--project-path` / `-p` | `projectPath` | Yes | Absolute path to the project root |
+| `--task` / `-t` | `task` | Yes | Task description |
+| `--priority` | `priority` | No | Priority: `low`, `medium` (default), `high`, `critical` |
+| `--milestone` / `-m` | `milestone` | No | Milestone/sprint name (default: `delegated`) |
+| `--session` / `-s` | `sessionName` | No | Session to assign the task to (open if omitted) |
+| `--output-schema` | `outputSchema` | No | JSON object defining expected output schema |
+
+## Examples — CLI Flags (preferred)
+
+```bash
+# Create an open task
+bash execute.sh --project-path /path/to/project --task "Implement login API endpoint"
+
+# Create and assign to a specific agent
+bash execute.sh --project-path /path/to/project --task "Write unit tests for auth service" \
+  --priority high --milestone sprint-2 --session dev-max
+
+# Create with output schema
+bash execute.sh --project-path /path/to/project --task "Generate API report" \
+  --output-schema '{"type":"object","properties":{"report":{"type":"string"}}}'
+```
+
+## Examples — Legacy JSON (backward compatible)
+
+```bash
+bash execute.sh '{"projectPath":"/path/to/project","task":"Implement login API","priority":"high","milestone":"sprint-1"}'
+```
+
+## Output
+
+JSON response from the task-management API confirming task creation, including the task file path and metadata.

package/config/skills/agent/core/create-task/execute.sh

@@ -0,0 +1,134 @@
+#!/bin/bash
+# Create a new task via the task-management API.
+# Allows TLs and agents to autonomously decompose work into sub-tasks.
+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 --project-path /path/to/project --task "Implement login API" \
+    --priority high --milestone sprint-1 --session dev-1
+
+  # Legacy JSON (backward compatible)
+  bash execute.sh '{"projectPath":"/path/to/project","task":"Implement login API","priority":"high"}'
+
+Options:
+  --project-path | -p   Absolute path to the project root (required)
+  --task         | -t   Task description (required)
+  --priority            Priority level: low, medium, high, critical (default: medium)
+  --milestone    | -m   Milestone/sprint name (default: delegated)
+  --session      | -s   Session to assign the task to (optional; if omitted, task is open)
+  --output-schema       JSON string defining expected output schema (optional)
+  --json         | -j   Raw JSON payload (same as legacy)
+  --help         | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+PROJECT_PATH=""
+TASK=""
+PRIORITY=""
+MILESTONE=""
+SESSION_NAME=""
+OUTPUT_SCHEMA=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --project-path|-p)
+      PROJECT_PATH="$2"
+      shift 2
+      ;;
+    --task|-t)
+      TASK="$2"
+      shift 2
+      ;;
+    --priority)
+      PRIORITY="$2"
+      shift 2
+      ;;
+    --milestone|-m)
+      MILESTONE="$2"
+      shift 2
+      ;;
+    --session|-s)
+      SESSION_NAME="$2"
+      shift 2
+      ;;
+    --output-schema)
+      OUTPUT_SCHEMA="$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 "$TASK" ] && [ ! -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 "$PROJECT_PATH" ] && PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
+  [ -z "$TASK" ] && TASK=$(printf '%s' "$INPUT" | jq -r '.task // empty')
+  [ -z "$PRIORITY" ] && PRIORITY=$(printf '%s' "$INPUT" | jq -r '.priority // empty')
+  [ -z "$MILESTONE" ] && MILESTONE=$(printf '%s' "$INPUT" | jq -r '.milestone // empty')
+  [ -z "$SESSION_NAME" ] && SESSION_NAME=$(printf '%s' "$INPUT" | jq -r '.sessionName // empty')
+  [ -z "$OUTPUT_SCHEMA" ] && OUTPUT_SCHEMA=$(printf '%s' "$INPUT" | jq -c '.outputSchema // empty')
+fi
+
+# Apply defaults
+PRIORITY="${PRIORITY:-medium}"
+MILESTONE="${MILESTONE:-delegated}"
+
+require_param "projectPath (--project-path)" "$PROJECT_PATH"
+require_param "task (--task)" "$TASK"
+
+# Build the request body
+BODY=$(jq -n \
+  --arg projectPath "$PROJECT_PATH" \
+  --arg task "$TASK" \
+  --arg priority "$PRIORITY" \
+  --arg milestone "$MILESTONE" \
+  --arg sessionName "$SESSION_NAME" \
+  '{projectPath: $projectPath, task: $task, priority: $priority, milestone: $milestone} +
+   (if $sessionName != "" then {sessionName: $sessionName} else {} end)')
+
+# Attach outputSchema if provided
+if [ -n "$OUTPUT_SCHEMA" ] && [ "$OUTPUT_SCHEMA" != "" ]; then
+  BODY=$(printf '%s' "$BODY" | jq --argjson schema "$OUTPUT_SCHEMA" '. + {outputSchema: $schema}')
+fi
+
+api_call POST "/task-management/create" "$BODY"