crewly 1.5.17 → 1.5.19

package/config/skills/agent/v3/plan-request/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: Plan Request
+description: "Analyze a user request and get a list of proposed ProjectTasks via the V3 Request Plan API."
+version: 1.0.0
+category: planning
+skillType: claude-skill
+assignableRoles:
+  - developer
+  - qa
+  - tpm
+  - designer
+  - frontend-developer
+  - backend-developer
+  - fullstack-dev
+  - qa-engineer
+  - product-manager
+  - architect
+  - generalist
+triggers:
+  - plan request
+  - decompose request
+  - analyze request
+  - plan tasks
+tags:
+  - v3
+  - request
+  - planning
+  - decomposition
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 30000
+---
+
+# Plan Request
+
+Analyze a user request message and get a list of proposed ProjectTasks via the `POST /api/requests/plan` endpoint. This allows agents (orchestrator or sub-agents) to decompose a user request into structured, actionable tasks.
+
+## Parameters
+
+| Flag | JSON Field | Required | Description |
+|------|-----------|----------|-------------|
+| `--message` / `-m` | `message` | Yes | The user request message to decompose |
+| `--max-tasks` | `options.maxTasks` | No | Maximum number of tasks to generate |
+| `--default-priority` | `options.defaultPriority` | No | Default priority for tasks: `high`, `medium`, `low` |
+
+## Examples — CLI Flags (preferred)
+
+```bash
+# Basic plan
+bash execute.sh --message "Build a new authentication system with OAuth2 support"
+
+# Plan with options
+bash execute.sh --message "Fix all failing tests in the auth module" \
+  --max-tasks 10 --default-priority high
+```
+
+## Examples — Legacy JSON (backward compatible)
+
+```bash
+bash execute.sh '{"message":"Build a search feature","options":{"maxTasks":5,"defaultPriority":"medium"}}'
+```
+
+## Output
+
+JSON response with a `RequestPlan` containing:
+- `message` — The original user message
+- `tasks` — Array of proposed tasks with title, description, acceptance criteria, and priority
+- `reasoning` — Human-readable explanation of the decomposition
+- `strategy` — Which planning strategy was applied (`build`, `fix`, `generic`, `none`)

package/config/skills/agent/v3/plan-request/execute.sh

@@ -0,0 +1,116 @@
+#!/bin/bash
+# Plan a user request into proposed ProjectTasks via the V3 Request Plan API.
+# Allows agents to decompose a user message into structured, actionable 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 --message "Build a new auth system with OAuth2 support"
+  bash execute.sh --message "Fix failing tests" --max-tasks 10 --default-priority high
+
+  # Legacy JSON (backward compatible)
+  bash execute.sh '{"message":"Build a search feature","options":{"maxTasks":5,"defaultPriority":"medium"}}'
+
+Options:
+  --message          | -m   The user request message to decompose (required)
+  --max-tasks              Maximum number of tasks to generate (optional)
+  --default-priority       Default priority: high, medium, low (optional)
+  --json             | -j   Raw JSON payload (same as legacy)
+  --help             | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+MESSAGE=""
+MAX_TASKS=""
+DEFAULT_PRIORITY=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --message|-m)
+      MESSAGE="$2"
+      shift 2
+      ;;
+    --max-tasks)
+      MAX_TASKS="$2"
+      shift 2
+      ;;
+    --default-priority)
+      DEFAULT_PRIORITY="$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 "$MESSAGE" ] && [ ! -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 "$MESSAGE" ] && MESSAGE=$(printf '%s' "$INPUT" | jq -r '.message // empty')
+  [ -z "$MAX_TASKS" ] && MAX_TASKS=$(printf '%s' "$INPUT" | jq -r '.options.maxTasks // empty')
+  [ -z "$DEFAULT_PRIORITY" ] && DEFAULT_PRIORITY=$(printf '%s' "$INPUT" | jq -r '.options.defaultPriority // empty')
+fi
+
+require_param "message (--message)" "$MESSAGE"
+
+# Build the request body
+BODY=$(jq -n --arg message "$MESSAGE" '{message: $message}')
+
+# Build options object if any option is provided
+OPTIONS_PARTS=()
+if [ -n "$MAX_TASKS" ] && [ "$MAX_TASKS" != "" ]; then
+  OPTIONS_PARTS+=("maxTasks")
+fi
+if [ -n "$DEFAULT_PRIORITY" ] && [ "$DEFAULT_PRIORITY" != "" ]; then
+  OPTIONS_PARTS+=("defaultPriority")
+fi
+
+if [ ${#OPTIONS_PARTS[@]} -gt 0 ]; then
+  OPTIONS=$(jq -n '{}')
+  if [ -n "$MAX_TASKS" ] && [ "$MAX_TASKS" != "" ]; then
+    OPTIONS=$(printf '%s' "$OPTIONS" | jq --argjson mt "$MAX_TASKS" '. + {maxTasks: $mt}')
+  fi
+  if [ -n "$DEFAULT_PRIORITY" ] && [ "$DEFAULT_PRIORITY" != "" ]; then
+    OPTIONS=$(printf '%s' "$OPTIONS" | jq --arg dp "$DEFAULT_PRIORITY" '. + {defaultPriority: $dp}')
+  fi
+  BODY=$(printf '%s' "$BODY" | jq --argjson options "$OPTIONS" '. + {options: $options}')
+fi
+
+api_call POST "/requests/plan" "$BODY"

package/config/skills/orchestrator/decompose-mission/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: Decompose Mission
+description: Break a Mission (OKR/objective) into concrete, executable tasks with dependencies. The runtime does the thinking — this skill provides context (Mission objective, team capabilities, success criteria) and collects the structured output. Supports progressive decomposition (Phase N only).
+version: 1.0.0
+category: planning
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+  - team-leader
+triggers:
+  - decompose mission
+  - break down objective
+  - plan mission tasks
+  - mission decomposition
+tags:
+  - mission
+  - planning
+  - decomposition
+  - autonomous
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 60000
+---
+
+# Decompose Mission
+
+Decomposes a Mission objective into concrete, executable tasks (WorkItems) with
+dependency relationships. The agent runtime does the thinking — this skill
+assembles context and submits the structured result to the backend.
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/decompose-mission/execute.sh \
+  --mission-id <uuid> \
+  --project-path /path/to/project \
+  [--phase <number>]
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `--mission-id` | Yes | UUID of the Mission to decompose |
+| `--project-path` | Yes | Absolute path to the project root |
+| `--phase` | No | Phase number to decompose (default: 1). Use for progressive decomposition. |
+
+## Output
+
+The skill instructs the runtime to output JSON matching:
+
+```json
+{
+  "phases": [
+    {
+      "phaseNumber": 1,
+      "name": "Phase name",
+      "tasks": [
+        {
+          "title": "Task title",
+          "description": "What to do",
+          "type": "delegate",
+          "priority": "high",
+          "suggestedRole": "developer",
+          "estimatedMinutes": 60,
+          "dependsOn": []
+        }
+      ]
+    }
+  ]
+}
+```
+
+The skill then POSTs this to `POST /api/missions/:id/decompose` which creates
+WorkItems in the TaskPool with appropriate `_blockedBy` metadata.

package/config/skills/orchestrator/decompose-mission/execute.sh

@@ -0,0 +1,138 @@
+#!/bin/bash
+# Decompose a Mission into concrete tasks with dependencies.
+# The runtime does the thinking — this skill provides context and collects output.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../_common/lib.sh"
+
+# --- Input parsing ---
+MISSION_ID=""
+PROJECT_PATH=""
+PHASE="1"
+INPUT_JSON=""
+
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --mission-id|-m)   MISSION_ID="$2";     shift 2 ;;
+    --project-path|-p) PROJECT_PATH="$2";    shift 2 ;;
+    --phase)           PHASE="$2";           shift 2 ;;
+    --json|-j)         INPUT_JSON="$2";      shift 2 ;;
+    --help|-h)
+      echo "Usage: execute.sh --mission-id <uuid> --project-path /path [--phase 1]"
+      exit 0 ;;
+    *) shift ;;
+  esac
+done
+
+# Legacy JSON fallback
+if [[ -n "$INPUT_JSON" ]]; then
+  [[ -z "$MISSION_ID" ]] && MISSION_ID=$(echo "$INPUT_JSON" | jq -r '.missionId // .["mission-id"] // empty' 2>/dev/null || true)
+  [[ -z "$PROJECT_PATH" ]] && PROJECT_PATH=$(echo "$INPUT_JSON" | jq -r '.projectPath // .["project-path"] // empty' 2>/dev/null || true)
+  [[ "$PHASE" == "1" ]] && PHASE=$(echo "$INPUT_JSON" | jq -r '.phase // "1"' 2>/dev/null || echo "1")
+fi
+
+require_param "mission-id" "$MISSION_ID"
+require_param "project-path" "$PROJECT_PATH"
+
+# --- Load Mission data ---
+MISSION_DATA=$(api_call GET "/missions/${MISSION_ID}" 2>/dev/null) || {
+  echo '{"success":false,"error":"Failed to load mission"}' >&2
+  exit 1
+}
+
+MISSION=$(echo "$MISSION_DATA" | jq -r '.data // empty')
+if [[ -z "$MISSION" || "$MISSION" == "null" ]]; then
+  echo '{"success":false,"error":"Mission not found"}' >&2
+  exit 1
+fi
+
+OBJECTIVE=$(echo "$MISSION" | jq -r '.objective // "No objective"')
+CRITERIA=$(echo "$MISSION" | jq -r '.successCriteria // [] | join("; ")')
+STRATEGY=$(echo "$MISSION" | jq -r '.currentStrategy // "No strategy set"')
+POLICY_LEVEL=$(echo "$MISSION" | jq -r '.policy.maxParallelExecutions // 3')
+
+# --- Load team data ---
+TEAM_ID=$(echo "$MISSION" | jq -r '.ownerTeamId // empty')
+TEAM_INFO=""
+if [[ -n "$TEAM_ID" ]]; then
+  TEAM_DATA=$(api_call GET "/teams/${TEAM_ID}" 2>/dev/null || true)
+  if [[ -n "$TEAM_DATA" ]]; then
+    TEAM_INFO=$(echo "$TEAM_DATA" | jq -r '
+      .data.members // [] | map(
+        "- \(.name // .sessionName) (\(.role // "developer"))"
+      ) | join("\n")
+    ' 2>/dev/null || echo "Team data unavailable")
+  fi
+fi
+
+# --- Output decomposition context for the runtime ---
+# The runtime (Claude Code / Gemini CLI) will read this and produce
+# the structured task breakdown. We output this as the skill result
+# which becomes the context for the agent.
+
+cat << DECOMPOSE_PROMPT
+
+## Mission Decomposition Request — Phase ${PHASE}
+
+### Objective
+${OBJECTIVE}
+
+### Success Criteria
+${CRITERIA}
+
+### Current Strategy
+${STRATEGY}
+
+### Available Team
+${TEAM_INFO:-No team info available}
+
+### Constraints
+- Max parallel tasks: ${POLICY_LEVEL}
+- Each task should be completable by one agent in 30 minutes to 2 hours
+- Phase ${PHASE}: provide full detail with concrete, actionable tasks
+- Later phases: provide only outlines (will be refined when this phase completes)
+
+### Instructions
+Break this mission into concrete tasks for Phase ${PHASE}. For each task specify:
+- title: clear, actionable task name
+- description: what needs to be done (2-3 sentences)
+- type: "delegate" (for agent work) or "review" (for verification)
+- priority: "critical" | "high" | "medium" | "low"
+- suggestedRole: "developer" | "qa" | "designer" | "architect"
+- estimatedMinutes: expected duration (30-120)
+- dependsOn: array of task titles this depends on (empty if independent)
+
+Output a valid JSON object matching this schema:
+\`\`\`json
+{
+  "missionId": "${MISSION_ID}",
+  "phase": ${PHASE},
+  "tasks": [
+    {
+      "title": "Task title",
+      "description": "What to do",
+      "type": "delegate",
+      "priority": "high",
+      "suggestedRole": "developer",
+      "estimatedMinutes": 60,
+      "dependsOn": []
+    }
+  ]
+}
+\`\`\`
+
+After generating the JSON, call the following to submit the decomposition:
+\`\`\`bash
+curl -s -X POST "${CREWLY_API_URL}/api/missions/${MISSION_ID}/decompose" \\
+  -H "Content-Type: application/json" \\
+  -d '<YOUR_JSON_OUTPUT>'
+\`\`\`
+
+DECOMPOSE_PROMPT
+
+echo '{"success":true,"message":"Decomposition context provided to runtime","missionId":"'"${MISSION_ID}"'","phase":'"${PHASE}"'}'

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

@@ -1,6 +1,6 @@
 ---
 name: Delegate Task
-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.
+description: Create a WorkItem in the TaskPool targeting a specific agent. The Reconciler will automatically wake the agent and deliver the task when resources are available. No direct agent start or auto-monitoring — the Reconciler handles lifecycle, retries, and resource control.
 version: 2.0.0
 category: management
 skillType: claude-skill
@@ -27,10 +27,11 @@ execution:
 
 # Delegate Task
 
-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.
+Creates a WorkItem in the TaskPool targeting a specific agent. The Reconciler automatically detects the queued item, wakes the agent (respecting `maxConcurrentAgents` and memory limits), and the auto-claim service delivers the task.
+
 The script auto-resolves `config/skills/...` references to absolute paths so delegated tasks remain runnable from any working directory.
 
-**Monitoring is enabled by default** — idle event subscriptions and recurring fallback checks (every 5 minutes) are automatically set up for every delegation. These are linked to the task and will be **automatically cleaned up** when the task is completed via `report-status` or `complete-task`. To disable monitoring, explicitly pass `"monitor": {"idleEvent": false, "fallbackCheckMinutes": 0}`.
+**No auto-monitoring** — the Reconciler handles stuck/unclaimed WorkItem detection, agent lifecycle, and retries. No recurring checks or idle subscriptions are created.
 
 ## Parameters
 

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

@@ -101,6 +101,8 @@ if [ "$TASK_TYPE" = "technical" ] && [ -n "$TEAM_ID" ]; then
 fi
 
 # Structured message parameters (for hierarchical teams)
+# Default INPUT to empty JSON if not set (when using --flag mode)
+INPUT="${INPUT:-{}}"
 TITLE=$(printf '%s' "$INPUT" | jq -r '.title // empty')
 PARENT_TASK_ID=$(printf '%s' "$INPUT" | jq -r '.parentTaskId // empty')
 EXPECTED_ARTIFACTS=$(printf '%s' "$INPUT" | jq -c '.expectedArtifacts // empty')
@@ -108,12 +110,6 @@ CONTEXT_FILES=$(printf '%s' "$INPUT" | jq -c '.contextFiles // empty')
 DEADLINE_HINT=$(printf '%s' "$INPUT" | jq -r '.deadlineHint // empty')
 USE_STRUCTURED=$(printf '%s' "$INPUT" | jq -r '.structured // "false"')
 
-# Monitor parameters — enabled by default to ensure proactive progress notifications.
-# Use explicit null-check so that `false` / `0` are respected as opt-out values,
-# while omitted fields default to enabled (idleEvent=true, fallbackCheckMinutes=5).
-MONITOR_IDLE=$(printf '%s' "$INPUT" | jq -r 'if .monitor.idleEvent == null then true else .monitor.idleEvent end')
-MONITOR_FALLBACK_MINUTES=$(printf '%s' "$INPUT" | jq -r 'if .monitor.fallbackCheckMinutes == null then 5 else .monitor.fallbackCheckMinutes end')
-
 # Resolve Crewly root from this script path:
 # config/skills/orchestrator/delegate-task/execute.sh -> project root
 CREWLY_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
@@ -171,96 +167,46 @@ else
   TASK_MESSAGE="${TASK_MESSAGE}\n\nBefore reporting done, persist key findings using: bash ${CREWLY_ROOT}/config/skills/agent/core/remember/execute.sh '{\"agentId\":\"${TO}\",\"content\":\"<key findings>\",\"category\":\"pattern\",\"scope\":\"project\",\"projectPath\":\"${PROJECT_PATH}\"}'"
 fi
 
-# Deliver the task message with fallback strategy:
-# 1. Try reliable delivery with waitForReady (15s timeout)
-# 2. If agent not ready, fall back to force mode (direct PTY write)
-# 3. If both fail, output error to stdout (so orchestrator can see it) and exit 1
-BODY=$(jq -n --arg message "$TASK_MESSAGE" '{message: $message, waitForReady: true, waitTimeout: 15000}')
-
-DELIVER_OK=true
-api_call POST "/terminal/${TO}/deliver" "$BODY" || DELIVER_OK=false
-
-if [ "$DELIVER_OK" = "false" ]; then
-  # Agent not ready or session not found — retry with force mode (direct PTY write)
-  FORCE_BODY=$(jq -n --arg message "$TASK_MESSAGE" '{message: $message, force: true}')
-  api_call POST "/terminal/${TO}/deliver" "$FORCE_BODY" || {
-    # Both delivery attempts failed — output error to stdout for orchestrator visibility
-    echo '{"error":"Failed to deliver task to '"$TO"'. Session may not exist or agent is not running."}'
-    exit 1
-  }
-fi
-
-# Track the task file path and task ID from create response for monitoring linkage
-TASK_FILE_PATH=""
-TASK_ID=""
-
-# Create task file in project's .crewly/tasks/ directory
-if [ -n "$PROJECT_PATH" ]; then
-  CREATE_BODY=$(jq -n \
-    --arg projectPath "$PROJECT_PATH" \
-    --arg task "$TASK" \
-    --arg priority "$PRIORITY" \
-    --arg sessionName "$TO" \
-    --arg milestone "delegated" \
-    '{projectPath: $projectPath, task: $task, priority: $priority, sessionName: $sessionName, milestone: $milestone}')
-  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)
-  TASK_ID=$(echo "$CREATE_RESULT" | jq -r '.taskId // empty' 2>/dev/null || true)
-
-  # Deliver a follow-up message with complete-task instructions now that taskPath is known (#137).
-  # This ensures agents call complete-task with the exact path, not just report-status.
-  if [ -n "$TASK_FILE_PATH" ]; then
-    COMPLETE_INSTR="After finishing and calling report-status, also run: bash ${CREWLY_ROOT}/config/skills/agent/core/complete-task/execute.sh '{\"absoluteTaskPath\":\"${TASK_FILE_PATH}\",\"sessionName\":\"${TO}\",\"summary\":\"<brief summary>\"}'"
-    FOLLOWUP_BODY=$(jq -n --arg message "$COMPLETE_INSTR" '{message: $message, force: true}')
-    api_call POST "/terminal/${TO}/deliver" "$FOLLOWUP_BODY" 2>/dev/null || true
-  fi
-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
+# --- Create WorkItem in TaskPool ---
+# The Reconciler will detect the queued WorkItem, wake the target agent,
+# and the auto-claim service will deliver the task. No direct PTY delivery
+# or auto-monitoring needed — the Reconciler handles lifecycle and retries.
+
+# Map priority to WorkItem format
+WI_PRIORITY="medium"
+case "$PRIORITY" in
+  critical|urgent) WI_PRIORITY="critical" ;;
+  high)            WI_PRIORITY="high" ;;
+  low)             WI_PRIORITY="low" ;;
+  *)               WI_PRIORITY="medium" ;;
+esac
+
+WI_TITLE="${TITLE:-$(echo "$TASK" | head -c 200)}"
+
+POOL_BODY=$(jq -n \
+  --arg type "delegate" \
+  --arg owner "orchestrator" \
+  --arg target "$TO" \
+  --arg title "$WI_TITLE" \
+  --arg description "$TASK_MESSAGE" \
+  --arg priority "$WI_PRIORITY" \
+  --arg projectPath "${PROJECT_PATH:-}" \
+  '{type: $type, owner: $owner, target: $target, title: $title, description: $description, priority: $priority} + (if $projectPath != "" then {projectPath: $projectPath} else {} end)')
+
+POOL_RESULT=$(api_call POST "/pool/add" "$POOL_BODY" 2>/dev/null || echo '{"success":false}')
+POOL_OK=$(echo "$POOL_RESULT" | jq -r '.success // "false"' 2>/dev/null)
+WI_ID=$(echo "$POOL_RESULT" | jq -r '.data.id // .workItemId // empty' 2>/dev/null || true)
+
+if [ "$POOL_OK" != "true" ]; then
+  echo "{\"error\":\"Failed to create WorkItem in TaskPool\",\"details\":$(echo "$POOL_RESULT" | jq -c . 2>/dev/null || echo '{}')}"
+  exit 1
 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 "Progress check: review ${TO} status — task: ${TASK:0:100}" \
-    --arg taskId "$TASK_ID" \
-    '{targetSession: $target, minutes: ($minutes | tonumber), intervalMinutes: ($minutes | tonumber), message: $message, isRecurring: true} + (if $taskId != "" then {taskId: $taskId} else {} end)' 2>/dev/null) || true
-  [ -n "$SCHED_BODY" ] && 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
+# Output result
+jq -n \
+  --arg success "true" \
+  --arg workItemId "${WI_ID:-}" \
+  --arg target "$TO" \
+  --arg priority "$WI_PRIORITY" \
+  --arg title "$WI_TITLE" \
+  '{success: true, workItemId: $workItemId, target: $target, priority: $priority, title: $title, message: "WorkItem created in TaskPool. Reconciler will wake the agent when resources are available."}'

package/config/skills/orchestrator/design-team/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: Design Team
+description: "Create a new team from a natural language description. The runtime analyzes the request, selects or designs the appropriate team structure (roles, hierarchy, ownership, service contract), and outputs a structured team config that the backend uses to create the team."
+version: 1.0.0
+category: management
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+triggers:
+  - design team
+  - create team
+  - build team
+  - set up a team
+  - new team for
+tags:
+  - team
+  - organization
+  - design
+  - creation
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 30000
+---
+
+# Design Team
+
+Creates a team from a natural language description (e.g., "帮我建一个做前端的团队，3个人").
+The runtime does the reasoning — this skill provides context (available templates, roles, existing teams)
+and collects the structured output.
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/design-team/execute.sh \
+  --description "Build a frontend team with 3 people" \
+  --project-path /path/to/project
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `--description` | Yes | Natural language team description |
+| `--project-path` | No | Project path to assign |
+
+## Output
+
+Runtime generates a team config JSON, then submits via API to create the team.