crewly 1.2.3 → 1.2.4

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

package/config/skills/team-leader/delegate-task/skill.json

@@ -0,0 +1,20 @@
+{
+  "id": "tl-delegate-task",
+  "name": "Delegate Task (TL)",
+  "description": "Assign a task to a worker within the Team Leader's subordinate scope. Validates that the target worker's parentMemberId matches the TL's memberId before delegation. Includes auto-monitoring setup.",
+  "category": "management",
+  "skillType": "claude-skill",
+  "promptFile": "instructions.md",
+  "execution": {
+    "type": "script",
+    "script": {
+      "file": "execute.sh",
+      "interpreter": "bash",
+      "timeoutMs": 30000
+    }
+  },
+  "assignableRoles": ["team-leader"],
+  "triggers": ["delegate task", "assign to worker", "send task to worker", "delegate to subordinate"],
+  "tags": ["task", "delegation", "management", "hierarchy"],
+  "version": "1.0.0"
+}

package/config/skills/team-leader/handle-failure/execute.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+# Decide the next action when a worker task fails.
+# Decision logic: retry (retries < 2) → reassign (skill mismatch) → escalate (resource/permission)
+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 '{\"workerId\":\"worker-1\",\"workerSession\":\"worker-session\",\"teamId\":\"team-123\",\"failureInfo\":{\"error\":\"tests failed\",\"failedSteps\":[\"tests\"],\"retries\":0,\"failureType\":\"verification\"},\"requiredRole\":\"developer\"}'"
+
+WORKER_ID=$(echo "$INPUT" | jq -r '.workerId // empty')
+WORKER_SESSION=$(echo "$INPUT" | jq -r '.workerSession // empty')
+TEAM_ID=$(echo "$INPUT" | jq -r '.teamId // empty')
+REQUIRED_ROLE=$(echo "$INPUT" | jq -r '.requiredRole // empty')
+TASK_DESCRIPTION=$(echo "$INPUT" | jq -r '.taskDescription // empty')
+
+# Failure info
+RETRIES=$(echo "$INPUT" | jq -r '.failureInfo.retries // 0')
+FAILURE_TYPE=$(echo "$INPUT" | jq -r '.failureInfo.failureType // "unknown"')
+ERROR_MSG=$(echo "$INPUT" | jq -r '.failureInfo.error // "Unknown error"')
+FAILED_STEPS=$(echo "$INPUT" | jq -c '.failureInfo.failedSteps // []')
+
+require_param "workerId" "$WORKER_ID"
+
+# Decision logic
+ACTION=""
+NEXT_WORKER_ID=""
+NEXT_WORKER_SESSION=""
+INSTRUCTIONS=""
+
+# Rule 1: If retries < 2 and failure is recoverable → retry
+if [ "$RETRIES" -lt 2 ]; then
+  case "$FAILURE_TYPE" in
+    verification|format|test_failure)
+      ACTION="retry"
+      INSTRUCTIONS="Retry attempt $((RETRIES + 1))/2. Previous failure: ${ERROR_MSG}. Please fix the issues in the failed steps and try again."
+      ;;
+    pty_error|session_error)
+      ACTION="retry"
+      INSTRUCTIONS="Session error detected. Retrying after recovery. Previous error: ${ERROR_MSG}"
+      ;;
+    skill_mismatch)
+      # Skill mismatch goes directly to reassign
+      ACTION="reassign"
+      INSTRUCTIONS="Task requires skills that ${WORKER_ID} does not have."
+      ;;
+    resource_error|permission_error|budget_error)
+      # Resource/permission issues escalate immediately
+      ACTION="escalate"
+      INSTRUCTIONS="Resource or permission issue cannot be resolved at TL level: ${ERROR_MSG}"
+      ;;
+    *)
+      # Unknown failure types: retry if under limit
+      ACTION="retry"
+      INSTRUCTIONS="Retry attempt $((RETRIES + 1))/2. Error: ${ERROR_MSG}. Please investigate and try a different approach."
+      ;;
+  esac
+else
+  # Rule 2: Retries exhausted → try reassign, then escalate
+  ACTION="reassign"
+  INSTRUCTIONS="Worker ${WORKER_ID} failed after ${RETRIES} retries. Reassigning to another worker."
+fi
+
+# If action is reassign, find an alternative worker
+if [ "$ACTION" = "reassign" ] && [ -n "$TEAM_ID" ]; then
+  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 another worker with matching role, excluding the failed worker
+    if [ -n "$REQUIRED_ROLE" ]; then
+      ALT_WORKER=$(echo "$TEAM_DATA" | jq -r --arg role "$REQUIRED_ROLE" --arg excludeId "$WORKER_ID" \
+        '[.data.members[] | select(.role == $role and .id != $excludeId and .agentStatus == "active")] | first | .id // empty' 2>/dev/null || true)
+      ALT_SESSION=$(echo "$TEAM_DATA" | jq -r --arg role "$REQUIRED_ROLE" --arg excludeId "$WORKER_ID" \
+        '[.data.members[] | select(.role == $role and .id != $excludeId and .agentStatus == "active")] | first | .sessionName // empty' 2>/dev/null || true)
+    else
+      # No specific role required, find any active non-leader worker
+      ALT_WORKER=$(echo "$TEAM_DATA" | jq -r --arg excludeId "$WORKER_ID" \
+        '[.data.members[] | select(.id != $excludeId and .role != "team-leader" and .agentStatus == "active")] | first | .id // empty' 2>/dev/null || true)
+      ALT_SESSION=$(echo "$TEAM_DATA" | jq -r --arg excludeId "$WORKER_ID" \
+        '[.data.members[] | select(.id != $excludeId and .role != "team-leader" and .agentStatus == "active")] | first | .sessionName // empty' 2>/dev/null || true)
+    fi
+
+    if [ -n "$ALT_WORKER" ]; then
+      NEXT_WORKER_ID="$ALT_WORKER"
+      NEXT_WORKER_SESSION="$ALT_SESSION"
+      INSTRUCTIONS="Reassigning from ${WORKER_ID} to ${ALT_WORKER}. Previous worker failed after ${RETRIES} retries: ${ERROR_MSG}"
+    else
+      # No alternative worker found → escalate
+      ACTION="escalate"
+      INSTRUCTIONS="No alternative worker available for reassignment. Original worker ${WORKER_ID} failed after ${RETRIES} retries: ${ERROR_MSG}. Escalating to Orchestrator."
+    fi
+  else
+    # Cannot fetch team data → escalate
+    ACTION="escalate"
+    INSTRUCTIONS="Cannot validate team members for reassignment. Escalating to Orchestrator. Error: ${ERROR_MSG}"
+  fi
+fi
+
+# Output decision
+jq -n \
+  --arg action "$ACTION" \
+  --arg nextWorkerId "$NEXT_WORKER_ID" \
+  --arg nextWorkerSession "$NEXT_WORKER_SESSION" \
+  --arg instructions "$INSTRUCTIONS" \
+  --arg originalWorkerId "$WORKER_ID" \
+  --arg failureType "$FAILURE_TYPE" \
+  --arg retries "$RETRIES" \
+  '{
+    action: $action,
+    nextWorkerId: (if $nextWorkerId != "" then $nextWorkerId else null end),
+    nextWorkerSession: (if $nextWorkerSession != "" then $nextWorkerSession else null end),
+    instructions: $instructions,
+    context: {
+      originalWorkerId: $originalWorkerId,
+      failureType: $failureType,
+      retriesSoFar: ($retries | tonumber)
+    }
+  }'