crewly 1.5.18 → 1.5.20

package/config/skills/orchestrator/design-team/execute.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+# Design and create a team from a natural language description.
+# The runtime does the reasoning — this skill provides context.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../_common/lib.sh"
+
+# --- Input parsing ---
+DESCRIPTION=""
+PROJECT_PATH=""
+INPUT_JSON=""
+
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --description|-d) DESCRIPTION="$2";    shift 2 ;;
+    --project-path|-p) PROJECT_PATH="$2";  shift 2 ;;
+    --json|-j) INPUT_JSON="$2";            shift 2 ;;
+    --help|-h)
+      echo "Usage: execute.sh --description 'Build a frontend team' [--project-path /path]"
+      exit 0 ;;
+    *) shift ;;
+  esac
+done
+
+if [[ -n "$INPUT_JSON" ]]; then
+  [[ -z "$DESCRIPTION" ]] && DESCRIPTION=$(echo "$INPUT_JSON" | jq -r '.description // empty' 2>/dev/null || true)
+  [[ -z "$PROJECT_PATH" ]] && PROJECT_PATH=$(echo "$INPUT_JSON" | jq -r '.projectPath // empty' 2>/dev/null || true)
+fi
+
+require_param "description" "$DESCRIPTION"
+
+# --- Load available templates ---
+TEMPLATES_DATA=$(api_call GET "/templates" 2>/dev/null || echo '{"data":[]}')
+TEMPLATES=$(echo "$TEMPLATES_DATA" | jq -r '
+  .data // [] | map(
+    "- " + .id + ": " + .name + " (" + (.category // "custom") + ", " + (.roles | length | tostring) + " roles)"
+  ) | join("\n")
+' 2>/dev/null || echo "No templates available")
+
+# --- Load available roles ---
+ROLES_DIR="${SCRIPT_DIR}/../../../roles"
+ROLES=""
+if [ -d "$ROLES_DIR" ]; then
+  for role_dir in "$ROLES_DIR"/*/; do
+    role_name=$(basename "$role_dir")
+    if [ -f "${role_dir}role.json" ]; then
+      role_desc=$(jq -r '.displayName // .name // "'$role_name'"' "${role_dir}role.json" 2>/dev/null || echo "$role_name")
+      ROLES="${ROLES}\n- ${role_name}: ${role_desc}"
+    fi
+  done
+fi
+
+# --- Load existing teams ---
+TEAMS_DATA=$(api_call GET "/teams" 2>/dev/null || echo '{"data":[]}')
+EXISTING_TEAMS=$(echo "$TEAMS_DATA" | jq -r '
+  .data // [] | map(
+    "- " + .name + " (" + (.members | length | tostring) + " members)"
+  ) | join("\n")
+' 2>/dev/null || echo "No existing teams")
+
+# --- Output context for the runtime ---
+cat << DESIGN_PROMPT
+
+## Team Design Request
+
+Design a team based on this description:
+**"${DESCRIPTION}"**
+
+### Available Templates
+${TEMPLATES}
+
+### Available Roles
+${ROLES:-No role definitions found}
+
+### Existing Teams (avoid duplicates)
+${EXISTING_TEAMS}
+
+### Instructions
+
+Design the team and output a valid JSON config. Consider:
+1. **Team size** — How many members? What roles?
+2. **Hierarchy** — Does this team need a TL? (teams > 2 people usually do)
+3. **Ownership** — What domains and deliverables does this team own?
+4. **Service contract** — What tasks does this team accept/avoid?
+5. **Job titles** — Give each member a specific job title and description
+
+If an existing template closely matches, reference it. Otherwise design from scratch.
+
+Output JSON:
+\`\`\`json
+{
+  "name": "Team Name",
+  "description": "What this team does",
+  "hierarchical": true,
+  "mission": "Team mission statement",
+  "ownershipScope": {
+    "domains": ["frontend"],
+    "deliverables": ["feature_delivery", "ui_quality"]
+  },
+  "serviceContract": {
+    "accepts": ["frontend features", "UI bugfixes", "component library maintenance"],
+    "avoids": ["backend API changes", "database migrations"],
+    "expectedOutput": ["PR with tests", "Storybook documentation"]
+  },
+  "members": [
+    {
+      "name": "Sam",
+      "role": "team-leader",
+      "jobTitle": "Frontend Tech Lead",
+      "jobDescription": "Owns frontend quality and architecture decisions",
+      "ownershipScope": { "domains": ["frontend"], "deliverables": ["quality"] },
+      "responsibilityType": "quality_owner",
+      "autonomyLevel": "bounded",
+      "canDelegate": true
+    },
+    {
+      "name": "Leo",
+      "role": "developer",
+      "jobTitle": "Frontend Developer",
+      "jobDescription": "Implements UI features and components",
+      "ownershipScope": { "domains": ["frontend"], "areas": ["checkout-flow"] },
+      "autonomyLevel": "directed"
+    }
+  ]${PROJECT_PATH:+,
+  "projectPath": "${PROJECT_PATH}"}
+}
+\`\`\`
+
+After generating the JSON, create the team:
+\`\`\`bash
+curl -s -X POST "${CREWLY_API_URL}/api/teams" \\
+  -H "Content-Type: application/json" \\
+  -d '<YOUR_JSON_OUTPUT>'
+\`\`\`
+
+Then confirm to the user: "Team created: [name] with [N] members. [list roles]. Ready to assign a project."
+
+DESIGN_PROMPT
+
+echo '{"success":true,"message":"Team design context provided to runtime"}'

package/config/skills/orchestrator/measure-kr/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: Measure Key Result
+description: Execute a measurement for a Key Result and submit the value. For KRs with skill_output measurement source, the runtime follows the measurementConfig instructions to collect the metric.
+version: 1.0.0
+category: planning
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+  - team-leader
+triggers:
+  - measure kr
+  - check key result
+  - measure metric
+tags:
+  - mission
+  - okr
+  - measurement
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 30000
+---
+
+# Measure Key Result
+
+Measures a Key Result value and submits it to the tracking service.
+For `skill_output` KRs, the runtime follows the `measurementConfig`
+instructions to collect the actual metric value.
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/measure-kr/execute.sh \
+  --mission-id <uuid> \
+  --kr-id <uuid> \
+  --project-path /path/to/project
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `--mission-id` | Yes | UUID of the parent Mission |
+| `--kr-id` | Yes | UUID of the Key Result to measure |
+| `--project-path` | Yes | Project root path |

package/config/skills/orchestrator/measure-kr/execute.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+# Measure a Key Result and submit the value.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../_common/lib.sh"
+
+# --- Input parsing ---
+MISSION_ID=""
+KR_ID=""
+PROJECT_PATH=""
+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 ;;
+    --kr-id|-k)        KR_ID="$2";          shift 2 ;;
+    --project-path|-p) PROJECT_PATH="$2";    shift 2 ;;
+    --json|-j)         INPUT_JSON="$2";      shift 2 ;;
+    --help|-h)
+      echo "Usage: execute.sh --mission-id <uuid> --kr-id <uuid> --project-path /path"
+      exit 0 ;;
+    *) shift ;;
+  esac
+done
+
+if [[ -n "$INPUT_JSON" ]]; then
+  [[ -z "$MISSION_ID" ]] && MISSION_ID=$(echo "$INPUT_JSON" | jq -r '.missionId // empty' 2>/dev/null || true)
+  [[ -z "$KR_ID" ]] && KR_ID=$(echo "$INPUT_JSON" | jq -r '.krId // empty' 2>/dev/null || true)
+  [[ -z "$PROJECT_PATH" ]] && PROJECT_PATH=$(echo "$INPUT_JSON" | jq -r '.projectPath // empty' 2>/dev/null || true)
+fi
+
+require_param "mission-id" "$MISSION_ID"
+require_param "kr-id" "$KR_ID"
+require_param "project-path" "$PROJECT_PATH"
+
+# --- Load KR data ---
+KR_DATA=$(api_call GET "/missions/${MISSION_ID}/key-results/${KR_ID}" 2>/dev/null) || {
+  echo '{"success":false,"error":"Failed to load Key Result"}' >&2
+  exit 1
+}
+
+KR=$(echo "$KR_DATA" | jq -r '.data // empty')
+TITLE=$(echo "$KR" | jq -r '.title // "Unknown KR"')
+UNIT=$(echo "$KR" | jq -r '.unit // ""')
+BASELINE=$(echo "$KR" | jq -r '.baseline // 0')
+TARGET=$(echo "$KR" | jq -r '.target // 0')
+CURRENT=$(echo "$KR" | jq -r '.current // 0')
+SOURCE=$(echo "$KR" | jq -r '.measurementSource // "manual"')
+CONFIG=$(echo "$KR" | jq -r '.measurementConfig // {} | tostring')
+
+# --- Output measurement context ---
+cat << MEASURE_PROMPT
+
+## Key Result Measurement
+
+### KR: ${TITLE}
+- Current: ${CURRENT} ${UNIT}
+- Baseline: ${BASELINE} ${UNIT}
+- Target: ${TARGET} ${UNIT}
+- Measurement Source: ${SOURCE}
+- Config: ${CONFIG}
+
+### Instructions
+Measure the current value for this Key Result.
+
+$(if [[ "$SOURCE" == "skill_output" ]]; then
+  echo "Follow the measurement config above to collect the metric."
+  echo "For example: run tests, check API latency, count deployments, etc."
+else
+  echo "Determine the current metric value based on the project state."
+fi)
+
+After measuring, submit the value:
+\`\`\`bash
+curl -s -X POST "${CREWLY_API_URL}/api/missions/${MISSION_ID}/key-results/${KR_ID}/measure" \\
+  -H "Content-Type: application/json" \\
+  -d '{"value": <MEASURED_VALUE>, "source": "measure-kr-skill", "note": "Brief description of how measured"}'
+\`\`\`
+
+MEASURE_PROMPT
+
+echo '{"success":true,"message":"Measurement context provided","missionId":"'"${MISSION_ID}"'","krId":"'"${KR_ID}"'"}'

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

@@ -0,0 +1,61 @@
+---
+name: Review Mission OKR
+description: Execute an OKR review cycle — aggregate KR + task progress, reason about strategy effectiveness, and submit a review decision (continue, adjust, replan, or cancel).
+version: 1.0.0
+category: planning
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+triggers:
+  - review mission
+  - okr review
+  - check mission progress
+  - mission review
+tags:
+  - mission
+  - okr
+  - review
+  - autonomous
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 60000
+---
+
+# Review Mission OKR
+
+Executes a periodic OKR review for a Mission. Aggregates Key Result progress
+and task completion data, then asks the runtime to reason about whether the
+current strategy is effective and what action to take next.
+
+## Usage
+
+```bash
+bash config/skills/orchestrator/review-mission/execute.sh \
+  --mission-id <uuid> \
+  --project-path /path/to/project
+```
+
+## Parameters
+
+| Parameter | Required | Description |
+|-----------|----------|-------------|
+| `--mission-id` | Yes | UUID of the Mission to review |
+| `--project-path` | Yes | Absolute path to the project root |
+
+## Review Decision Output
+
+The runtime should produce a JSON ReviewDecision:
+
+```json
+{
+  "action": "continue | adjust_strategy | replan_phase | add_tasks | cancel_mission",
+  "newStrategy": "Updated strategy text (if adjusting)",
+  "learnings": ["What we learned from this review cycle"],
+  "krUpdates": [{"krId": "...", "newTarget": 150, "note": "Revised after measurement"}]
+}
+```
+
+The skill submits this to `POST /api/missions/:id/review-decision`.

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

@@ -0,0 +1,127 @@
+#!/bin/bash
+# Review a Mission's OKR progress and decide next action.
+# 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=""
+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 ;;
+    --json|-j)         INPUT_JSON="$2";      shift 2 ;;
+    --help|-h)
+      echo "Usage: execute.sh --mission-id <uuid> --project-path /path"
+      exit 0 ;;
+    *) shift ;;
+  esac
+done
+
+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)
+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')
+OBJECTIVE=$(echo "$MISSION" | jq -r '.objective // "No objective"')
+STRATEGY=$(echo "$MISSION" | jq -r '.currentStrategy // "No strategy"')
+LEARNINGS=$(echo "$MISSION" | jq -r '.learnings // [] | join("\n- ")')
+LAST_REVIEW=$(echo "$MISSION" | jq -r '.lastReviewSummary // "No previous review"')
+
+# --- Load OKR Summary ---
+OKR_SUMMARY=$(api_call GET "/missions/${MISSION_ID}/okr-summary" 2>/dev/null || echo '{"data":{}}')
+OKR_DATA=$(echo "$OKR_SUMMARY" | jq -r '.data // {}')
+
+# --- Load Task Progress ---
+PROGRESS=$(api_call GET "/missions/${MISSION_ID}/progress" 2>/dev/null || echo '{"data":{}}')
+PROGRESS_DATA=$(echo "$PROGRESS" | jq -r '.data // {}')
+
+# --- Load Key Results ---
+KR_LIST=$(api_call GET "/missions/${MISSION_ID}/key-results" 2>/dev/null || echo '{"data":[]}')
+KR_DETAILS=$(echo "$KR_LIST" | jq -r '.data // [] | map(
+  "- \(.title): \(.current)\(.unit) / \(.target)\(.unit) [\(.status)] (\(if .baseline > .target then "lower is better" else "higher is better" end))"
+) | join("\n")' 2>/dev/null || echo "No KR data")
+
+# --- Output review context for the runtime ---
+cat << REVIEW_PROMPT
+
+## OKR Review — Mission ${MISSION_ID}
+
+### Objective
+${OBJECTIVE}
+
+### Current Strategy
+${STRATEGY}
+
+### Key Results Progress
+${KR_DETAILS:-No key results defined}
+
+### OKR Summary
+- Overall Progress: $(echo "$OKR_DATA" | jq -r '.overallProgress // 0')%
+- Achieved: $(echo "$OKR_DATA" | jq -r '.achieved // 0') / $(echo "$OKR_DATA" | jq -r '.totalKRs // 0')
+- On Track: $(echo "$OKR_DATA" | jq -r '.onTrack // 0')
+- At Risk: $(echo "$OKR_DATA" | jq -r '.atRisk // 0')
+- Off Track: $(echo "$OKR_DATA" | jq -r '.offTrack // 0')
+- System Recommendation: $(echo "$OKR_DATA" | jq -r '.recommendation // "N/A"')
+
+### Task Progress
+- Total: $(echo "$PROGRESS_DATA" | jq -r '.totalTasks // 0')
+- Completed: $(echo "$PROGRESS_DATA" | jq -r '.completedTasks // 0')
+- Running: $(echo "$PROGRESS_DATA" | jq -r '.runningTasks // 0')
+- Blocked: $(echo "$PROGRESS_DATA" | jq -r '.blockedTasks // 0')
+- Failed: $(echo "$PROGRESS_DATA" | jq -r '.failedTasks // 0')
+
+### Previous Review
+${LAST_REVIEW}
+
+### Learnings So Far
+${LEARNINGS:-None recorded}
+
+### Instructions
+Based on the KR progress and task status above, decide the next action:
+
+1. **continue** — KRs are progressing well, keep current strategy
+2. **adjust_strategy** — KRs are slipping; propose a modified strategy
+3. **replan_phase** — Strategy is fundamentally not working; cancel remaining tasks and redesign
+4. **add_tasks** — Strategy is working but missing tasks needed
+5. **cancel_mission** — Mission is no longer viable
+
+Output a valid JSON ReviewDecision:
+\`\`\`json
+{
+  "action": "continue",
+  "newStrategy": "optional new strategy text",
+  "learnings": ["what we learned"],
+  "krUpdates": []
+}
+\`\`\`
+
+After generating the decision, submit it:
+\`\`\`bash
+curl -s -X POST "${CREWLY_API_URL}/api/missions/${MISSION_ID}/review-decision" \\
+  -H "Content-Type: application/json" \\
+  -d '<YOUR_JSON_OUTPUT>'
+\`\`\`
+
+REVIEW_PROMPT
+
+echo '{"success":true,"message":"Review context provided to runtime","missionId":"'"${MISSION_ID}"'"}'

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

@@ -1,21 +1,18 @@
 #!/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=$(read_json_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\"}'"
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"teamId\":\"team-123\",\"objective\":\"...\",\"taskPaths\":[\"...\"]}'"
 
 TEAM_ID=$(printf '%s' "$INPUT" | jq -r '.teamId // empty')
 OBJECTIVE=$(printf '%s' "$INPUT" | jq -r '.objective // "Objective not specified"')
 REPORT_TYPE=$(printf '%s' "$INPUT" | jq -r '.reportType // "final"')
 TASK_PATHS=$(printf '%s' "$INPUT" | jq -c '.taskPaths // []')
 PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
-INCLUDE_VERIFICATION=$(printf '%s' "$INPUT" | jq -r '.includeVerification // "true"')
 
-# Collect task data
 TASK_RESULTS="[]"
 SUCCESS_COUNT=0
 FAILURE_COUNT=0
@@ -24,17 +21,23 @@ 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)
+    
+    if [ -f "$TASK_PATH" ]; then
+      CONTENT=$(cat "$TASK_PATH")
+      # Parse title
+      TASK_TITLE=$(echo "$CONTENT" | grep "^# " | head -1 | sed 's/^# //' | xargs || echo "Untitled")
+      # Parse status
+      TASK_STATUS=$(echo "$CONTENT" | grep -oE "\*\*Status\*\*: .*" | head -1 | cut -d: -f2 | xargs | tr '[:upper:]' '[:lower:]' || echo "unknown")
+      # Parse assignee
+      TASK_ASSIGNEE=$(echo "$CONTENT" | grep -oE "\*\*Assigned to\*\*: .*" | head -1 | cut -d: -f2 | xargs || echo "unassigned")
+    else
+      TASK_TITLE="Missing File"
+      TASK_STATUS="unknown"
+      TASK_ASSIGNEE="n/a"
+    fi
 
     case "$TASK_STATUS" in
       done|completed) SUCCESS_COUNT=$((SUCCESS_COUNT + 1)) ;;
@@ -47,41 +50,20 @@ if [ "$TASK_COUNT" -gt 0 ]; then
       --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}]')
+      '. + [{title: $title, status: $status, assignee: $assignee, 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_TITLE="Final Completion Report"
+
 REPORT="[TL_REPORT]
 
 # ${REPORT_TITLE}
 
 **Objective**: ${OBJECTIVE}
-**Report Type**: ${REPORT_TYPE}
 **Generated**: ${TIMESTAMP}
 **Team**: ${TEAM_ID:-N/A}
 
@@ -95,22 +77,17 @@ REPORT="[TL_REPORT]
 | Blocked | ${BLOCKED_COUNT} |
 | Pending | ${PENDING_COUNT} |
 
-**Completion Rate**: $([ "$TOTAL" -gt 0 ] && echo "$((SUCCESS_COUNT * 100 / TOTAL))%" || echo "N/A")
-"
+**Completion Rate**: $([ "$TOTAL" -gt 0 ] && echo "$((SUCCESS_COUNT * 100 / TOTAL))%" || echo "0%")
 
-# 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
+
+RESULT_COUNT=$(echo "$TASK_RESULTS" | jq 'length')
+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" ;;
@@ -122,47 +99,21 @@ if [ "$RESULT_COUNT" -gt 0 ]; then
 ### [${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
+done
 
-# 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" \
+  --arg total "$TOTAL" \
   '{
     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)
+      completed: ($success | tonumber)
     }
   }'

package/config/skills/team-leader/delegate-task/SKILL.md

@@ -78,6 +78,16 @@ When `teamId` and `tlMemberId` are provided, the script fetches team data and va
 
 If validation fails, delegation is rejected with a hierarchy violation error.
 
+## Auto-Start Offline Workers
+
+If the target worker is offline (delivery fails), the skill automatically:
+1. Looks up the worker's `memberId` from team data
+2. Calls `POST /teams/:teamId/members/:memberId/start` to boot the worker
+3. Waits 10 seconds for the agent to initialize
+4. Retries task delivery
+
+This requires `--team` to be provided. Without team context, offline workers cannot be auto-started.
+
 ## Differences from Orchestrator delegate-task
 
 | Aspect | Orchestrator | Team Leader |