crewly 1.2.3 → 1.2.6

package/config/skills/team-leader/aggregate-results/execute.sh

@@ -0,0 +1,168 @@
+#!/bin/bash
+# Aggregate results from worker sub-tasks into a structured markdown report.
+# Fetches task data from the task-management API and compiles a report.
+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 '{\"teamId\":\"team-123\",\"objective\":\"Build auth module\",\"reportType\":\"final\",\"taskPaths\":[\"/path/to/task1.md\",\"/path/to/task2.md\"],\"projectPath\":\"/path/to/project\"}'"
+
+TEAM_ID=$(echo "$INPUT" | jq -r '.teamId // empty')
+OBJECTIVE=$(echo "$INPUT" | jq -r '.objective // "Objective not specified"')
+REPORT_TYPE=$(echo "$INPUT" | jq -r '.reportType // "final"')
+TASK_PATHS=$(echo "$INPUT" | jq -c '.taskPaths // []')
+PROJECT_PATH=$(echo "$INPUT" | jq -r '.projectPath // empty')
+INCLUDE_VERIFICATION=$(echo "$INPUT" | jq -r '.includeVerification // "true"')
+
+# Collect task data
+TASK_RESULTS="[]"
+SUCCESS_COUNT=0
+FAILURE_COUNT=0
+BLOCKED_COUNT=0
+PENDING_COUNT=0
+
+TASK_COUNT=$(echo "$TASK_PATHS" | jq 'length')
+
+# If task paths provided, read each task
+if [ "$TASK_COUNT" -gt 0 ]; then
+  for i in $(seq 0 $((TASK_COUNT - 1))); do
+    TASK_PATH=$(echo "$TASK_PATHS" | jq -r ".[$i]")
+    READ_BODY=$(jq -n --arg taskPath "$TASK_PATH" '{taskPath: $taskPath}')
+    TASK_DATA=$(api_call POST "/task-management/read-task" "$READ_BODY" 2>/dev/null || echo '{}')
+
+    TASK_STATUS=$(echo "$TASK_DATA" | jq -r '.data.metadata.status // "unknown"' 2>/dev/null || echo "unknown")
+    TASK_TITLE=$(echo "$TASK_DATA" | jq -r '.data.metadata.title // .data.metadata.task // "Untitled"' 2>/dev/null || echo "Untitled")
+    TASK_ASSIGNEE=$(echo "$TASK_DATA" | jq -r '.data.metadata.assignedTo // "unassigned"' 2>/dev/null || echo "unassigned")
+    TASK_SUMMARY=$(echo "$TASK_DATA" | jq -r '.data.metadata.summary // ""' 2>/dev/null || true)
+
+    case "$TASK_STATUS" in
+      done|completed) SUCCESS_COUNT=$((SUCCESS_COUNT + 1)) ;;
+      blocked) BLOCKED_COUNT=$((BLOCKED_COUNT + 1)) ;;
+      failed) FAILURE_COUNT=$((FAILURE_COUNT + 1)) ;;
+      *) PENDING_COUNT=$((PENDING_COUNT + 1)) ;;
+    esac
+
+    TASK_RESULTS=$(echo "$TASK_RESULTS" | jq \
+      --arg title "$TASK_TITLE" \
+      --arg status "$TASK_STATUS" \
+      --arg assignee "$TASK_ASSIGNEE" \
+      --arg summary "$TASK_SUMMARY" \
+      --arg path "$TASK_PATH" \
+      '. + [{title: $title, status: $status, assignee: $assignee, summary: $summary, path: $path}]')
+  done
+fi
+
+# If no task paths but teamId provided, get team progress
+if [ "$TASK_COUNT" = "0" ] && [ -n "$PROJECT_PATH" ]; then
+  PROGRESS_DATA=$(api_call GET "/task-management/team-progress?projectPath=${PROJECT_PATH}" 2>/dev/null || echo '{}')
+  # Extract counts from team progress if available
+  SUCCESS_COUNT=$(echo "$PROGRESS_DATA" | jq -r '.data.done // 0' 2>/dev/null || echo "0")
+  FAILURE_COUNT=$(echo "$PROGRESS_DATA" | jq -r '.data.failed // 0' 2>/dev/null || echo "0")
+  BLOCKED_COUNT=$(echo "$PROGRESS_DATA" | jq -r '.data.blocked // 0' 2>/dev/null || echo "0")
+  PENDING_COUNT=$(echo "$PROGRESS_DATA" | jq -r '.data.open // 0' 2>/dev/null || echo "0")
+fi
+
+TOTAL=$((SUCCESS_COUNT + FAILURE_COUNT + BLOCKED_COUNT + PENDING_COUNT))
+
+# Generate the report
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+REPORT_TITLE=""
+case "$REPORT_TYPE" in
+  milestone) REPORT_TITLE="Milestone Report" ;;
+  daily) REPORT_TITLE="Daily Progress Report" ;;
+  final) REPORT_TITLE="Final Completion Report" ;;
+  *) REPORT_TITLE="Progress Report" ;;
+esac
+
+# Build markdown report
+REPORT="[TL_REPORT]
+
+# ${REPORT_TITLE}
+
+**Objective**: ${OBJECTIVE}
+**Report Type**: ${REPORT_TYPE}
+**Generated**: ${TIMESTAMP}
+**Team**: ${TEAM_ID:-N/A}
+
+## Summary
+
+| Metric | Count |
+|--------|-------|
+| Total Tasks | ${TOTAL} |
+| Completed | ${SUCCESS_COUNT} |
+| Failed | ${FAILURE_COUNT} |
+| Blocked | ${BLOCKED_COUNT} |
+| Pending | ${PENDING_COUNT} |
+
+**Completion Rate**: $([ "$TOTAL" -gt 0 ] && echo "$((SUCCESS_COUNT * 100 / TOTAL))%" || echo "N/A")
+"
+
+# Add individual task details if available
+RESULT_COUNT=$(echo "$TASK_RESULTS" | jq 'length')
+if [ "$RESULT_COUNT" -gt 0 ]; then
+  REPORT="${REPORT}
+## Task Details
+"
+  for i in $(seq 0 $((RESULT_COUNT - 1))); do
+    T_TITLE=$(echo "$TASK_RESULTS" | jq -r ".[$i].title")
+    T_STATUS=$(echo "$TASK_RESULTS" | jq -r ".[$i].status")
+    T_ASSIGNEE=$(echo "$TASK_RESULTS" | jq -r ".[$i].assignee")
+    T_SUMMARY=$(echo "$TASK_RESULTS" | jq -r ".[$i].summary")
+
+    # Status emoji
+    case "$T_STATUS" in
+      done|completed) STATUS_MARK="DONE" ;;
+      blocked) STATUS_MARK="BLOCKED" ;;
+      failed) STATUS_MARK="FAILED" ;;
+      *) STATUS_MARK="PENDING" ;;
+    esac
+
+    REPORT="${REPORT}
+### [${STATUS_MARK}] ${T_TITLE}
+- **Assignee**: ${T_ASSIGNEE}
+- **Status**: ${T_STATUS}
+$([ -n "$T_SUMMARY" ] && echo "- **Summary**: ${T_SUMMARY}" || true)
+"
+  done
+fi
+
+# Add action items for non-complete items
+if [ "$FAILURE_COUNT" -gt 0 ] || [ "$BLOCKED_COUNT" -gt 0 ]; then
+  REPORT="${REPORT}
+## Action Items
+
+$([ "$FAILURE_COUNT" -gt 0 ] && echo "- ${FAILURE_COUNT} task(s) failed — review via handle-failure skill" || true)
+$([ "$BLOCKED_COUNT" -gt 0 ] && echo "- ${BLOCKED_COUNT} task(s) blocked — escalate to Orchestrator if unresolvable" || true)
+"
+fi
+
+# Write report to temp file for reliable output
+REPORT_FILE="/tmp/tl-report-${TEAM_ID:-unknown}-$(date +%s).md"
+echo "$REPORT" > "$REPORT_FILE"
+
+# Output JSON result
+jq -n \
+  --arg reportType "$REPORT_TYPE" \
+  --arg objective "$OBJECTIVE" \
+  --arg reportFile "$REPORT_FILE" \
+  --arg timestamp "$TIMESTAMP" \
+  --arg total "$TOTAL" \
+  --arg success "$SUCCESS_COUNT" \
+  --arg failed "$FAILURE_COUNT" \
+  --arg blocked "$BLOCKED_COUNT" \
+  --arg pending "$PENDING_COUNT" \
+  '{
+    success: true,
+    reportType: $reportType,
+    objective: $objective,
+    reportFile: $reportFile,
+    timestamp: $timestamp,
+    stats: {
+      total: ($total | tonumber),
+      completed: ($success | tonumber),
+      failed: ($failed | tonumber),
+      blocked: ($blocked | tonumber),
+      pending: ($pending | tonumber)
+    }
+  }'

package/config/skills/team-leader/aggregate-results/instructions.md

@@ -0,0 +1,89 @@
+# Aggregate Results
+
+Compiles results from all worker sub-tasks into a structured markdown report for the Orchestrator. Supports milestone, daily, and final report types.
+
+## When to Use
+
+- When all sub-tasks for an objective are completed
+- For periodic progress reports (daily/weekly)
+- When the Orchestrator requests a status update
+- Before escalating issues that affect overall objective completion
+
+## Usage
+
+```bash
+bash {{SKILLS_PATH}}/team-leader/aggregate-results/execute.sh '{"teamId":"team-123","objective":"Build auth module","reportType":"final","taskPaths":["/project/.crewly/tasks/m1/done/task1.md","/project/.crewly/tasks/m1/done/task2.md"],"projectPath":"/path/to/project"}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `teamId` | No | Team ID for report labeling |
+| `objective` | No | High-level objective being reported on |
+| `reportType` | No | Report type: `milestone`, `daily`, `final` (default: `final`) |
+| `taskPaths` | No | Array of task file paths to include |
+| `projectPath` | No | Project path (used for team-progress API fallback) |
+| `includeVerification` | No | Include verification results (default: `true`) |
+
+## Report Types
+
+| Type | Use Case | Typical Content |
+|------|----------|----------------|
+| `milestone` | End of a project milestone | Summary of all milestone tasks |
+| `daily` | Daily standup reporting | Today's progress, blockers |
+| `final` | Objective fully completed | Complete results, all deliverables |
+
+## Output
+
+### JSON Response
+```json
+{
+  "success": true,
+  "reportType": "final",
+  "objective": "Build auth module",
+  "reportFile": "/tmp/tl-report-team-123-1709769600.md",
+  "timestamp": "2026-03-06T12:00:00Z",
+  "stats": {
+    "total": 5,
+    "completed": 4,
+    "failed": 1,
+    "blocked": 0,
+    "pending": 0
+  }
+}
+```
+
+### Markdown Report Format
+
+The report is written to `reportFile` and follows the `[TL_REPORT]` tag convention:
+
+```markdown
+[TL_REPORT]
+# Final Completion Report
+**Objective**: Build auth module
+...
+## Summary
+| Metric | Count |
+|--------|-------|
+| Total Tasks | 5 |
+...
+## Task Details
+### [DONE] Implement JWT service
+...
+## Action Items
+- 1 task(s) failed — review via handle-failure skill
+```
+
+## Sending the Report
+
+After generating the report, send it to the Orchestrator:
+```bash
+bash {{SKILLS_PATH}}/agent/core/report-status/execute.sh '{"sessionName":"tl-session","status":"done","summary":"Objective complete: 4/5 tasks passed. Report at /tmp/tl-report-team-123.md"}'
+```
+
+## Related Skills
+
+- `decompose-goal` — Original task creation
+- `verify-output` — Task verification results
+- `handle-failure` — Failed task handling

package/config/skills/team-leader/aggregate-results/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "tl-aggregate-results",
+  "name": "Aggregate Results",
+  "description": "Compile results from all worker sub-tasks into a structured markdown report for the Orchestrator. Supports milestone, daily, and final report types.",
+  "category": "reporting",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 30000
+    }
+  },
+  "assignableRoles": ["team-leader"],
+  "triggers": ["aggregate results", "compile report", "summarize tasks", "generate report"],
+  "tags": ["reporting", "aggregation", "summary", "management"],
+  "version": "1.0.0"
+}

package/config/skills/team-leader/decompose-goal/execute.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# Decompose a high-level objective into worker-level sub-tasks.
+# Creates task files in the project's .crewly/tasks/ directory via task-management API.
+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 '{\"objective\":\"Build auth module\",\"projectPath\":\"/path/to/project\",\"tasks\":[{\"title\":\"...\",\"description\":\"...\",\"requiredRole\":\"developer\",\"acceptanceCriteria\":\"...\",\"priority\":\"high\"}]}'"
+
+OBJECTIVE=$(echo "$INPUT" | jq -r '.objective // empty')
+PROJECT_PATH=$(echo "$INPUT" | jq -r '.projectPath // empty')
+TASKS=$(echo "$INPUT" | jq -c '.tasks // empty')
+MILESTONE=$(echo "$INPUT" | jq -r '.milestone // "delegated"')
+require_param "objective" "$OBJECTIVE"
+require_param "tasks" "$TASKS"
+
+# Validate tasks array is non-empty
+TASK_COUNT=$(echo "$TASKS" | jq 'length')
+if [ "$TASK_COUNT" = "0" ]; then
+  error_exit "tasks array must contain at least one task"
+fi
+
+CREATED_TASKS="[]"
+ERRORS="[]"
+
+# Create each sub-task via the task-management API
+for i in $(seq 0 $((TASK_COUNT - 1))); do
+  TASK_TITLE=$(echo "$TASKS" | jq -r ".[$i].title // empty")
+  TASK_DESC=$(echo "$TASKS" | jq -r ".[$i].description // empty")
+  TASK_ROLE=$(echo "$TASKS" | jq -r ".[$i].requiredRole // \"developer\"")
+  TASK_CRITERIA=$(echo "$TASKS" | jq -r ".[$i].acceptanceCriteria // empty")
+  TASK_PRIORITY=$(echo "$TASKS" | jq -r ".[$i].priority // \"normal\"")
+
+  if [ -z "$TASK_TITLE" ] || [ -z "$TASK_DESC" ]; then
+    ERRORS=$(echo "$ERRORS" | jq --arg idx "$i" --arg msg "Task $i missing title or description" '. + [$msg]')
+    continue
+  fi
+
+  # Build task description with acceptance criteria
+  FULL_DESC="${TASK_DESC}"
+  [ -n "$TASK_CRITERIA" ] && FULL_DESC="${FULL_DESC}\n\n## Acceptance Criteria\n${TASK_CRITERIA}"
+  FULL_DESC="${FULL_DESC}\n\n## Context\nParent objective: ${OBJECTIVE}\nRequired role: ${TASK_ROLE}"
+
+  CREATE_BODY=$(jq -n \
+    --arg projectPath "${PROJECT_PATH}" \
+    --arg task "$FULL_DESC" \
+    --arg priority "$TASK_PRIORITY" \
+    --arg milestone "$MILESTONE" \
+    --arg title "$TASK_TITLE" \
+    '{projectPath: $projectPath, task: $task, priority: $priority, milestone: $milestone, title: $title}')
+
+  CREATE_RESULT=$(api_call POST "/task-management/create" "$CREATE_BODY" 2>/dev/null || echo '{"error":"Failed to create task"}')
+  TASK_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)
+
+  if [ -n "$TASK_PATH" ]; then
+    CREATED_TASKS=$(echo "$CREATED_TASKS" | jq \
+      --arg title "$TASK_TITLE" \
+      --arg role "$TASK_ROLE" \
+      --arg path "$TASK_PATH" \
+      --arg id "$TASK_ID" \
+      --arg priority "$TASK_PRIORITY" \
+      '. + [{title: $title, requiredRole: $role, taskPath: $path, taskId: $id, priority: $priority}]')
+  else
+    ERRORS=$(echo "$ERRORS" | jq --arg msg "Failed to create task: ${TASK_TITLE}" '. + [$msg]')
+  fi
+done
+
+# Output result
+CREATED_COUNT=$(echo "$CREATED_TASKS" | jq 'length')
+ERROR_COUNT=$(echo "$ERRORS" | jq 'length')
+
+jq -n \
+  --arg objective "$OBJECTIVE" \
+  --argjson tasks "$CREATED_TASKS" \
+  --argjson errors "$ERRORS" \
+  --arg totalCreated "$CREATED_COUNT" \
+  --arg totalErrors "$ERROR_COUNT" \
+  '{
+    success: (($totalErrors | tonumber) == 0),
+    objective: $objective,
+    tasksCreated: ($totalCreated | tonumber),
+    tasks: $tasks,
+    errors: $errors
+  }'

package/config/skills/team-leader/decompose-goal/instructions.md

@@ -0,0 +1,84 @@
+# Decompose Goal
+
+Breaks down a high-level objective from the Orchestrator into specific, actionable sub-tasks for workers. Each sub-task is created as a task file in the project's `.crewly/tasks/` directory.
+
+## When to Use
+
+- When the Orchestrator sends you a new objective
+- When an existing task is too large for a single worker
+- When a task needs to be split across multiple roles
+
+## Usage
+
+```bash
+bash {{SKILLS_PATH}}/team-leader/decompose-goal/execute.sh '$(cat /tmp/decompose.json)'
+```
+
+Where `/tmp/decompose.json` contains:
+
+```json
+{
+  "objective": "Build user authentication module",
+  "projectPath": "/path/to/project",
+  "milestone": "m2_auth",
+  "tasks": [
+    {
+      "title": "Implement JWT token service",
+      "description": "Create a service that generates and validates JWT tokens for user sessions",
+      "requiredRole": "backend-developer",
+      "acceptanceCriteria": "- JWT generation works\n- Token validation works\n- Tests pass with 80%+ coverage",
+      "priority": "high"
+    },
+    {
+      "title": "Build login form component",
+      "description": "Create a React login form with email/password fields and validation",
+      "requiredRole": "frontend-developer",
+      "acceptanceCriteria": "- Form renders correctly\n- Client-side validation works\n- Accessible (ARIA labels)",
+      "priority": "high"
+    }
+  ]
+}
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `objective` | Yes | The high-level objective being decomposed |
+| `projectPath` | No | Project path for task file creation |
+| `milestone` | No | Milestone folder name (default: `delegated`) |
+| `tasks` | Yes | Array of sub-task objects |
+| `tasks[].title` | Yes | Sub-task title |
+| `tasks[].description` | Yes | Detailed task description |
+| `tasks[].requiredRole` | No | Role best suited for this task (default: `developer`) |
+| `tasks[].acceptanceCriteria` | No | Criteria for task verification |
+| `tasks[].priority` | No | Task priority: `low`, `normal`, `high` (default: `normal`) |
+
+## Output
+
+```json
+{
+  "success": true,
+  "objective": "Build user authentication module",
+  "tasksCreated": 2,
+  "tasks": [
+    { "title": "Implement JWT token service", "requiredRole": "backend-developer", "taskPath": "/project/.crewly/tasks/...", "taskId": "abc123", "priority": "high" },
+    { "title": "Build login form component", "requiredRole": "frontend-developer", "taskPath": "/project/.crewly/tasks/...", "taskId": "def456", "priority": "high" }
+  ],
+  "errors": []
+}
+```
+
+## Best Practices
+
+1. **Be specific**: Each sub-task should be completable by a single worker in one session
+2. **Include acceptance criteria**: Workers need clear success metrics
+3. **Match roles**: Set `requiredRole` to help with delegation
+4. **Order matters**: List tasks in dependency order when possible
+5. **Don't over-split**: 2-5 sub-tasks per objective is typical
+
+## Related Skills
+
+- `delegate-task` — Assign created tasks to specific workers
+- `verify-output` — Verify completed task output
+- `aggregate-results` — Summarize all task results

package/config/skills/team-leader/decompose-goal/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "tl-decompose-goal",
+  "name": "Decompose Goal",
+  "description": "Break down a high-level objective from the Orchestrator into specific, actionable sub-tasks for workers. Creates task files in the project's .crewly/tasks/ directory.",
+  "category": "management",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 30000
+    }
+  },
+  "assignableRoles": ["team-leader"],
+  "triggers": ["decompose goal", "break down objective", "create subtasks", "split task"],
+  "tags": ["goal", "decomposition", "planning", "management"],
+  "version": "1.0.0"
+}

package/config/skills/team-leader/delegate-task/execute.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+# Delegate a task to a worker within this Team Leader's subordinate scope.
+# Validates hierarchy (worker.parentMemberId == TL.memberId) before delegation.
+# Reuses the orchestrator delegate-task delivery and monitoring logic.
+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\":\"worker-session\",\"task\":\"implement feature X\",\"priority\":\"high\",\"teamId\":\"team-123\",\"tlMemberId\":\"tl-member-id\",\"projectPath\":\"/path/to/project\"}'"
+
+TO=$(echo "$INPUT" | jq -r '.to // empty')
+TASK=$(echo "$INPUT" | jq -r '.task // empty')
+PRIORITY=$(echo "$INPUT" | jq -r '.priority // "normal"')
+CONTEXT=$(echo "$INPUT" | jq -r '.context // empty')
+PROJECT_PATH=$(echo "$INPUT" | jq -r '.projectPath // empty')
+TEAM_ID=$(echo "$INPUT" | jq -r '.teamId // empty')
+TL_MEMBER_ID=$(echo "$INPUT" | jq -r '.tlMemberId // empty')
+require_param "to" "$TO"
+require_param "task" "$TASK"
+
+# Resolve Crewly root from this script path:
+# config/skills/team-leader/delegate-task/execute.sh -> project root
+CREWLY_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
+
+# Validate hierarchy: check that target worker belongs to this TL
+if [ -n "$TEAM_ID" ] && [ -n "$TL_MEMBER_ID" ]; then
+  # Fetch team data to validate hierarchy
+  TEAM_DATA=$(api_call GET "/teams/${TEAM_ID}" 2>/dev/null || echo '{}')
+  TEAM_SUCCESS=$(echo "$TEAM_DATA" | jq -r '.success // false' 2>/dev/null || echo "false")
+
+  if [ "$TEAM_SUCCESS" = "true" ]; then
+    # Find the target worker by session name and check parentMemberId
+    WORKER_PARENT=$(echo "$TEAM_DATA" | jq -r --arg session "$TO" \
+      '.data.members[] | select(.sessionName == $session) | .parentMemberId // empty' 2>/dev/null || true)
+
+    if [ -n "$WORKER_PARENT" ] && [ "$WORKER_PARENT" != "$TL_MEMBER_ID" ]; then
+      error_exit "Hierarchy violation: worker ${TO} (parentMemberId=${WORKER_PARENT}) is not a subordinate of TL ${TL_MEMBER_ID}"
+    fi
+  fi
+fi
+
+# Resolve skill paths to absolute paths
+resolve_skill_paths() {
+  local input="$1"
+  perl -pe '
+    my $root = $ENV{"CREWLY_ROOT"};
+    s{\bbash\s+config/skills/}{bash $root/config/skills/}g;
+    s{(?<![A-Za-z0-9_./-])config/skills/}{$root/config/skills/}g;
+  ' <<< "$input"
+}
+
+TASK="$(CREWLY_ROOT="$CREWLY_ROOT" resolve_skill_paths "$TASK")"
+if [ -n "$CONTEXT" ]; then
+  CONTEXT="$(CREWLY_ROOT="$CREWLY_ROOT" resolve_skill_paths "$CONTEXT")"
+fi
+
+# Build a structured task message from Team Leader
+TASK_MESSAGE="New task from Team Leader (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>\"}'"
+
+# Deliver the task message with fallback strategy
+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
+  FORCE_BODY=$(jq -n --arg message "$TASK_MESSAGE" '{message: $message, force: true}')
+  api_call POST "/terminal/${TO}/deliver" "$FORCE_BODY" || {
+    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
+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)
+fi
+
+# Set up idle event subscription for TL monitoring
+MONITOR_IDLE=$(echo "$INPUT" | jq -r 'if .monitor.idleEvent == null then true else .monitor.idleEvent end')
+MONITOR_FALLBACK_MINUTES=$(echo "$INPUT" | jq -r 'if .monitor.fallbackCheckMinutes == null then 5 else .monitor.fallbackCheckMinutes end')
+
+COLLECTED_SCHEDULE_IDS="[]"
+COLLECTED_SUBSCRIPTION_IDS="[]"
+
+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
+
+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 "TL 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
+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/team-leader/delegate-task/instructions.md

@@ -0,0 +1,55 @@
+# Delegate Task (TL Version)
+
+Assigns a task to a worker within the Team Leader's subordinate scope. Validates hierarchy before delegation — the target worker's `parentMemberId` must match the TL's `memberId`.
+
+## When to Use
+
+- After `decompose-goal` creates sub-tasks
+- When `handle-failure` decides to `reassign` a task
+- When a new worker needs to be given work
+
+## Usage
+
+```bash
+bash {{SKILLS_PATH}}/team-leader/delegate-task/execute.sh '{"to":"worker-session","task":"Implement login form","priority":"high","teamId":"team-123","tlMemberId":"tl-member-id","projectPath":"/path/to/project"}'
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `to` | Yes | Target worker's PTY session name |
+| `task` | Yes | Task description (skill paths auto-resolved to absolute) |
+| `priority` | No | Task priority: `low`, `normal`, `high` (default: `normal`) |
+| `context` | No | Additional context for the worker |
+| `teamId` | No | Team ID for hierarchy validation |
+| `tlMemberId` | No | TL's member ID for hierarchy validation |
+| `projectPath` | No | Project path; creates task file in `.crewly/tasks/` |
+| `monitor` | No | Auto-monitoring config (same as orchestrator delegate-task) |
+
+## Hierarchy Validation
+
+When `teamId` and `tlMemberId` are provided, the script fetches team data and validates:
+- The target worker exists in the team
+- The worker's `parentMemberId` matches the TL's `memberId`
+
+If validation fails, delegation is rejected with a hierarchy violation error.
+
+## Differences from Orchestrator delegate-task
+
+| Aspect | Orchestrator | Team Leader |
+|--------|-------------|-------------|
+| Scope | Any agent in any team | Only subordinates |
+| Message prefix | "New task from orchestrator" | "New task from Team Leader" |
+| Hierarchy check | None | Validates parentMemberId |
+| Monitoring subscriber | Orchestrator session | TL session |
+
+## Output
+
+JSON confirmation of task delivery, same format as orchestrator delegate-task.
+
+## Related Skills
+
+- `decompose-goal` — Create sub-tasks before delegating
+- `verify-output` — Verify completed task output
+- `handle-failure` — Handle delegation failures