crewly 1.6.4 → 1.7.0

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

@@ -1,11 +1,35 @@
 #!/bin/bash
-# Assign a task to an agent via the task management system
+# Assign / reassign a WorkItem's target agent via the V3 task-pool.
+#
+# V3-only as of spec 2026-05-06-task-management-v1-deprecation.md. Replaces
+# `POST /task-management/assign`, which moved a `.md` file between agent
+# task directories. Now a single `target` field flip on the WorkItem.
+#
+# Input shape:
+#   { "workItemId": "abc-123", "target": "agent-session", "reason"?: "..." }
+#
+# Backwards-compat: `taskId` accepted as alias for `workItemId`,
+# `assignee` accepted as alias for `target`.
+
 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 '{\"taskId\":\"...\",\"assignee\":\"agent-session\"}'"
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"workItemId\":\"abc-123\",\"target\":\"agent-session\"}'"
+
+WORK_ITEM_ID=$(printf '%s' "$INPUT" | jq -r '.workItemId // .taskId // empty')
+NEW_TARGET=$(printf '%s' "$INPUT" | jq -r '.target // .assignee // empty')
+REASON=$(printf '%s' "$INPUT" | jq -r '.reason // "Assigned via orchestrator"')
+FROM_AGENT=$(printf '%s' "$INPUT" | jq -r '.from // .fromAgent // "orchestrator"')
+
+require_param "workItemId" "$WORK_ITEM_ID"
+require_param "target" "$NEW_TARGET"
+
+BODY=$(jq -n \
+  --arg newTarget "$NEW_TARGET" \
+  --arg fromAgent "$FROM_AGENT" \
+  --arg reason "$REASON" \
+  '{newTarget: $newTarget, fromAgent: $fromAgent, reason: $reason}')
 
-# Pass the full input as the request body
-api_call POST "/task-management/assign" "$INPUT"
+api_call POST "/task-pool/items/${WORK_ITEM_ID}/handoff" "$BODY"

package/config/skills/orchestrator/cancel-all-schedules/SKILL.md

@@ -1,6 +1,20 @@
 ---
 name: cancel-all-schedules
-description: Cancel all active scheduled checks. Optionally filter by session or age.
+description: Cancel all active scheduled checks, optionally filtered by session or age (nuclear cleanup).
+version: 1.0.0
+category: scheduling
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+tags:
+  - schedule
+  - cleanup
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 15000
 ---
 
 # cancel-all-schedules

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

@@ -1,11 +1,52 @@
 #!/bin/bash
-# Mark a task as complete via the task management system
-# Passes through all input fields including optional 'output' for schema validation
+# Mark a WorkItem complete via the V3 task-pool.
+#
+# V3-only as of spec 2026-05-06-task-management-v1-deprecation.md. Replaces
+# the v1 `/task-management/complete` endpoint. Optional `output` is stored
+# on the WorkItem (replaces `<taskId>.output.json`) before completion.
+#
+# Input shape:
+#   { "workItemId": "abc-123", "summary": "...", "output"?: { ... } }
+#
+# Backwards-compat: a `taskId` field is accepted as alias for `workItemId`.
+
 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 '{\"taskId\":\"...\",\"result\":\"success\"}'"
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"workItemId\":\"abc-123\",\"summary\":\"Done\"}'"
+
+WORK_ITEM_ID=$(printf '%s' "$INPUT" | jq -r '.workItemId // .taskId // empty')
+SUMMARY=$(printf '%s' "$INPUT" | jq -r '.summary // .result // empty')
+OUTPUT=$(printf '%s' "$INPUT" | jq -c '.output // empty')
+# Hygiene #4: agentId is required by the controller's completeItem validator.
+# Orchestrator-driven completions default to "crewly-orc" but accept an
+# explicit override (some flows complete on behalf of the agent that ran the
+# work — pass that session name instead).
+AGENT_ID=$(printf '%s' "$INPUT" | jq -r '.agentId // .sessionName // "crewly-orc"')
+
+require_param "workItemId" "$WORK_ITEM_ID"
+
+# Persist structured output on the WorkItem before completing, so that
+# `verify-output` can read it back via `GET /task-pool/items/:id`.
+if [ -n "$OUTPUT" ] && [ "$OUTPUT" != "null" ] && [ "$OUTPUT" != "" ]; then
+  OUTPUT_BODY=$(jq -n --argjson output "$OUTPUT" '{output: $output}')
+  api_call POST "/task-pool/items/${WORK_ITEM_ID}/output" "$OUTPUT_BODY" >/dev/null 2>&1 || true
+fi
+
+# Hygiene #4: emit canonical body shape `{agentId, result:{summary}}`
+# required by /api/task-pool/complete (task-pool.controller.ts `completeItem`).
+# Prior shape `{summary}` 400'd with `agentId is required` + `summary
+# required in body.result`. The controller enforces non-empty summary, so
+# bail early here too rather than send `{agentId, result:{}}` and let the
+# server reject it.
+if [ -z "$SUMMARY" ]; then
+  error_exit "summary is required (controller enforces non-empty body.result.summary)"
+fi
+COMPLETE_BODY=$(jq -n \
+  --arg agentId "$AGENT_ID" \
+  --arg summary "$SUMMARY" \
+  '{agentId: $agentId, result: {summary: $summary}}')
 
-api_call POST "/task-management/complete" "$INPUT"
+api_call POST "/task-pool/complete/${WORK_ITEM_ID}" "$COMPLETE_BODY"

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

@@ -46,6 +46,7 @@ The script auto-resolves `config/skills/...` references to absolute paths so del
 | `--team` / `-g` | `teamId` | No | Team ID for cross-team validation |
 | `--task-type` | `taskType` | No | Task type: `general`, `technical` (default: `general`) |
 | `--force-cross-team` | `forceCrossTeam` | No | Allow cross-team delegation |
+| `--request-id` / `-R` | `requestId` | No | Parent V3 Request ID; tags the resulting WorkItem so `Request.workItemIds[]` is populated by the SLA subscriber (Pipeline-#4 fix) |
 | `monitor` (JSON only) | `monitor` | No | Auto-monitoring config (see below) |
 
 ## Usage — CLI Flags (preferred)

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

@@ -16,6 +16,7 @@ PROJECT_PATH=""
 TASK_TYPE="general"
 TEAM_ID=""
 FORCE_CROSS_TEAM="false"
+REQUEST_ID=""
 
 # Detect legacy JSON argument
 if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
@@ -33,6 +34,7 @@ while [[ $# -gt 0 ]]; do
     --project|-p)    PROJECT_PATH="$2";     shift 2 ;;
     --task-type)     TASK_TYPE="$2";        shift 2 ;;
     --team|-g)       TEAM_ID="$2";          shift 2 ;;
+    --request-id|-R) REQUEST_ID="$2";       shift 2 ;;
     --force-cross-team) FORCE_CROSS_TEAM="true"; shift ;;
     --json|-j)       INPUT_JSON="$2";       shift 2 ;;
     --help|-h)
@@ -71,11 +73,38 @@ if [ -n "$INPUT_JSON" ]; then
   [ "$TASK_TYPE" = "general" ] && { TT=$(printf '%s' "$INPUT" | jq -r '.taskType // empty'); [ -n "$TT" ] && TASK_TYPE="$TT"; }
   [ -z "$TEAM_ID" ] && TEAM_ID=$(printf '%s' "$INPUT" | jq -r '.teamId // empty')
   [ "$FORCE_CROSS_TEAM" = "false" ] && FORCE_CROSS_TEAM=$(printf '%s' "$INPUT" | jq -r '.forceCrossTeam // "false"')
+  [ -z "$REQUEST_ID" ] && REQUEST_ID=$(printf '%s' "$INPUT" | jq -r '.requestId // empty')
 fi
 
 require_param "to (--to)" "$TO"
 require_param "task (--task)" "$TASK"
 
+# Request Contract check (P0-3): non-fatal warning when the delegated brief
+# is missing Goal / Expected Outcome / Eval Criteria markers. TLs and workers
+# downstream are entitled to push back per the Brief Reception Protocol when
+# these are absent. Spec:
+# .crewly/specs/2026-05-03-agent-improvement-p0-execution.md §"Fix P0-3".
+warn_missing_request_contract() {
+  local task="$1"
+  local missing=()
+  if ! echo "$task" | grep -qiE '(^|[^a-zA-Z])(\*\*)?(goal|objective)(:|s?\b)'; then
+    missing+=("Goal")
+  fi
+  if ! echo "$task" | grep -qiE '(^|[^a-zA-Z])(\*\*)?(expected )?outcome(:|s?\b)'; then
+    missing+=("Outcome")
+  fi
+  if ! echo "$task" | grep -qiE '(^|[^a-zA-Z])(\*\*)?(eval|evaluation criteria|acceptance criteria)(:|s?\b)'; then
+    missing+=("Eval")
+  fi
+  if [ ${#missing[@]} -gt 0 ]; then
+    local list
+    list=$(IFS=, ; echo "${missing[*]}")
+    echo "{\"warning\":\"Request Contract incomplete: brief is missing markers for: ${list}. Per P0-3 spec, every delegated subtask MUST include Goal + Expected Outcome + Eval Criteria. TLs and workers may push back via the Brief Reception Protocol. Source: .crewly/specs/2026-05-03-agent-improvement-p0-execution.md §Fix P0-3.\"}" >&2
+  fi
+}
+
+warn_missing_request_contract "$TASK"
+
 # #180: Validate target agent belongs to the specified team
 if [ -n "$TEAM_ID" ] && [ "$FORCE_CROSS_TEAM" != "true" ]; then
   TEAM_DATA=$(api_call GET "/teams/${TEAM_ID}" 2>/dev/null || echo '{}')
@@ -183,17 +212,27 @@ esac
 
 WI_TITLE="${TITLE:-$(echo "$TASK" | head -c 200)}"
 
+# Per spec 2026-05-06-task-management-v1-deprecation.md, the long-form task
+# body now travels with the WorkItem (`briefMarkdown` field) instead of being
+# written to a `.crewly/tasks/delegated/*.md` file. `description` keeps the
+# legacy short-summary semantics (callers truncate to 500 chars); the full
+# brief lives in `briefMarkdown`.
 POOL_BODY=$(jq -n \
   --arg type "delegate" \
   --arg owner "orchestrator" \
   --arg target "$TO" \
   --arg title "$WI_TITLE" \
   --arg description "$TASK_MESSAGE" \
+  --arg briefMarkdown "$TASK" \
   --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)')
+  --arg requestId "${REQUEST_ID:-}" \
+  '{type: $type, owner: $owner, target: $target, title: $title, description: $description, briefMarkdown: $briefMarkdown, priority: $priority} + (if $projectPath != "" then {projectPath: $projectPath} else {} end) + (if $requestId != "" then {requestId: $requestId} else {} end)')
 
-POOL_RESULT=$(api_call POST "/pool/add" "$POOL_BODY" 2>/dev/null || echo '{"success":false}')
+# Pipeline-#4 fix (spec 2026-05-05-request-decompose-pipeline-gap.md, Patch B):
+# Route is /api/task-pool/add (not /api/pool/add — that endpoint does not exist
+# and previously returned 404, silently swallowed by the || fallback below).
+POOL_RESULT=$(api_call POST "/task-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)
 

package/config/skills/orchestrator/get-tasks/execute.sh

@@ -1,27 +1,31 @@
 #!/bin/bash
-# Get task progress and overview for the team
+# Get pool stats + active items for the team.
+#
+# V3-only as of spec 2026-05-06-task-management-v1-deprecation.md. Replaces
+# `GET /task-management/team-progress` (which aggregated `.md` files in
+# `.crewly/tasks/`). The V3 task-pool's `/stats` and `/items` endpoints
+# expose the same aggregate state on the WorkItem schema.
+
 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 '{\"projectPath\":\"/path/to/project\"}'"
+INPUT=$(read_json_input "${1:-}" 2>/dev/null || echo '{}')
 
+# `projectPath` is no longer required — V3 pool is a single global file —
+# but if supplied, it is forwarded as a filter for callers expecting it.
 PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
-require_param "projectPath" "$PROJECT_PATH"
-
-# URL-encode the project path
-urlencode() {
-    local length="${#1}"
-    for (( i = 0; i < length; i++ )); do
-        local c="${1:i:1}"
-        case $c in
-            [a-zA-Z0-9.~_-]) printf "$c" ;;
-            *) printf '%%%02X' "'$c" ;;
-        esac
-done
-}
 
-ENCODED_PATH=$(urlencode "$PROJECT_PATH")
+STATS=$(api_call GET "/task-pool/stats" 2>/dev/null || echo '{"data":{}}')
+ITEMS=$(api_call GET "/task-pool/items" 2>/dev/null || echo '{"data":[]}')
 
-api_call GET "/task-management/team-progress?projectPath=${ENCODED_PATH}"
+jq -n \
+  --argjson stats "$STATS" \
+  --argjson items "$ITEMS" \
+  --arg projectPath "$PROJECT_PATH" \
+  '{
+    success: true,
+    projectPath: (if $projectPath == "" then null else $projectPath end),
+    stats: ($stats.data // $stats),
+    workItems: ($items.data // $items.workItems // [])
+  }'

package/config/skills/orchestrator/heartbeat/execute.sh

@@ -15,13 +15,55 @@ teams_response=$(api_call GET "/teams" 2>/dev/null) || teams_response='{"error":
 projects_response=$(api_call GET "/projects" 2>/dev/null) || projects_response='{"error":"unavailable"}'
 queue_response=$(api_call GET "/messaging/queue/status" 2>/dev/null) || queue_response='{"error":"unavailable"}'
 
-# Count teams and projects
-team_count=$(echo "$teams_response" | python3 -c "import sys,json; d=json.load(sys.stdin); print(len(d.get('teams',d)) if isinstance(d,dict) else len(d))" 2>/dev/null || echo "?")
-project_count=$(echo "$projects_response" | python3 -c "import sys,json; d=json.load(sys.stdin); print(len(d.get('projects',d)) if isinstance(d,dict) else len(d))" 2>/dev/null || echo "?")
+# Parse helpers:
+# - strict=False tolerates embedded control chars (e.g. raw \n in agent system-prompt strings)
+# - All three endpoints wrap payload as {success, data}; drill into .data, falling back to the
+#   raw dict for older shapes.
+# - On parse failure / missing field, emit valid JSON (null or 0) — never an unquoted '?'.
 
-# Extract queue status
-queue_pending=$(echo "$queue_response" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('pendingCount',d.get('pending','?')))" 2>/dev/null || echo "?")
-queue_processing=$(echo "$queue_response" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('processingCount',d.get('processing','?')))" 2>/dev/null || echo "?")
+count_data() {
+    # Count elements in the .data array (or fall back to the raw response).
+    python3 -c "
+import sys, json
+try:
+    d = json.loads(sys.stdin.read(), strict=False)
+except Exception:
+    print(0); sys.exit(0)
+payload = d.get('data', d) if isinstance(d, dict) else d
+print(len(payload) if isinstance(payload, (list, dict)) else 0)
+" 2>/dev/null || echo 0
+}
+
+team_count=$(echo "$teams_response" | count_data)
+project_count=$(echo "$projects_response" | count_data)
+
+# Queue: pendingCount (int) and isProcessing (bool, mapped to 0/1).
+queue_pending=$(echo "$queue_response" | python3 -c "
+import sys, json
+try:
+    d = json.loads(sys.stdin.read(), strict=False)
+    payload = d.get('data', d) if isinstance(d, dict) else d
+    v = payload.get('pendingCount', payload.get('pending', 0)) if isinstance(payload, dict) else 0
+    print(int(v) if v is not None else 0)
+except Exception:
+    print(0)
+" 2>/dev/null || echo 0)
+
+queue_processing=$(echo "$queue_response" | python3 -c "
+import sys, json
+try:
+    d = json.loads(sys.stdin.read(), strict=False)
+    payload = d.get('data', d) if isinstance(d, dict) else d
+    if isinstance(payload, dict):
+        v = payload.get('processingCount')
+        if v is None:
+            v = 1 if payload.get('isProcessing') else 0
+        print(int(v))
+    else:
+        print(0)
+except Exception:
+    print(0)
+" 2>/dev/null || echo 0)
 
 cat <<EOF
 {

package/config/skills/orchestrator/list-schedules/SKILL.md

@@ -1,6 +1,20 @@
 ---
 name: list-schedules
-description: List all active scheduled checks. Optionally filter by session name.
+description: List all active scheduled checks (one-time and recurring), optionally filtered by session name.
+version: 1.0.0
+category: scheduling
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+tags:
+  - schedule
+  - audit
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 15000
 ---
 
 # list-schedules

package/config/skills/orchestrator/update-team-member/SKILL.md

@@ -1,3 +1,23 @@
+---
+name: update-team-member
+description: Update a team member's properties — name, role, runtimeType, systemPrompt — via the team membership API.
+version: 1.0.0
+category: team
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+tags:
+  - team
+  - member
+  - admin
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 15000
+---
+
 # update-team-member
 
 Update a team member's properties including name, role, runtimeType, systemPrompt, and other attributes.

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

@@ -1,6 +1,10 @@
 #!/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.
+# Decompose a high-level objective into worker-level WorkItems.
+#
+# V3-only as of spec 2026-05-06-task-management-v1-deprecation.md. Each
+# sub-task becomes a V3 WorkItem in the task-pool via `POST /task-pool/add`.
+# The legacy v1 `/task-management/create` endpoint that wrote `.md` files
+# is gone.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../_common/lib.sh"
@@ -37,33 +41,60 @@ for i in $(seq 0 $((TASK_COUNT - 1))); do
     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}"
+  # Compose the brief markdown for the WorkItem.
+  BRIEF="${TASK_DESC}"
+  [ -n "$TASK_CRITERIA" ] && BRIEF="${BRIEF}
 
-  CREATE_BODY=$(jq -n \
-    --arg projectPath "${PROJECT_PATH}" \
-    --arg task "$FULL_DESC" \
-    --arg priority "$TASK_PRIORITY" \
-    --arg milestone "$MILESTONE" \
+## Acceptance Criteria
+${TASK_CRITERIA}"
+  BRIEF="${BRIEF}
+
+## Context
+Parent objective: ${OBJECTIVE}
+Required role: ${TASK_ROLE}"
+
+  case "$TASK_PRIORITY" in
+    critical) PRIORITY_NUM=1 ;;
+    high)     PRIORITY_NUM=2 ;;
+    normal|medium) PRIORITY_NUM=3 ;;
+    low)      PRIORITY_NUM=4 ;;
+    *)        PRIORITY_NUM=3 ;;
+  esac
+
+  WI_ID="task-$(date +%s%N | cut -c1-13)-${i}-$$"
+
+  WORK_ITEM=$(jq -n \
+    --arg id "$WI_ID" \
     --arg title "$TASK_TITLE" \
-    '{projectPath: $projectPath, task: $task, priority: $priority, milestone: $milestone, title: $title}')
+    --arg brief "$BRIEF" \
+    --arg projectPath "$PROJECT_PATH" \
+    --arg milestone "$MILESTONE" \
+    --arg role "$TASK_ROLE" \
+    --argjson priority "$PRIORITY_NUM" \
+    '{
+      id: $id,
+      title: $title,
+      type: "delegate",
+      owner: "system",
+      priority: $priority,
+      status: "queued",
+      briefMarkdown: $brief,
+      metadata: { projectPath: $projectPath, milestone: $milestone, requiredRole: $role }
+    }')
 
-  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)
+  CREATE_BODY=$(jq -n --argjson workItem "$WORK_ITEM" '{workItem: $workItem}')
+  CREATE_RESULT=$(api_call POST "/task-pool/add" "$CREATE_BODY" 2>/dev/null || echo '{"error":"Failed to create WorkItem"}')
+  CREATED_ID=$(echo "$CREATE_RESULT" | jq -r '.data.id // .workItem.id // empty' 2>/dev/null || true)
 
-  if [ -n "$TASK_PATH" ]; then
+  if [ -n "$CREATED_ID" ]; then
     CREATED_TASKS=$(echo "$CREATED_TASKS" | jq \
       --arg title "$TASK_TITLE" \
       --arg role "$TASK_ROLE" \
-      --arg path "$TASK_PATH" \
-      --arg id "$TASK_ID" \
+      --arg id "$CREATED_ID" \
       --arg priority "$TASK_PRIORITY" \
-      '. + [{title: $title, requiredRole: $role, taskPath: $path, taskId: $id, priority: $priority}]')
+      '. + [{title: $title, requiredRole: $role, workItemId: $id, priority: $priority}]')
   else
-    ERRORS=$(echo "$ERRORS" | jq --arg msg "Failed to create task: ${TASK_TITLE}" '. + [$msg]')
+    ERRORS=$(echo "$ERRORS" | jq --arg msg "Failed to create WorkItem: ${TASK_TITLE}" '. + [$msg]')
   fi
 done
 

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

@@ -77,6 +77,36 @@ fi
 require_param "to (--to)" "$TO"
 require_param "task (--task)" "$TASK"
 
+# Request Contract check (P0-3): non-fatal warning when the delegated brief
+# is missing Goal / Expected Outcome / Eval Criteria markers. Workers are
+# entitled to push back per the Brief Reception Protocol when these are
+# absent. Spec: .crewly/specs/2026-05-03-agent-improvement-p0-execution.md
+# §"Fix P0-3".
+warn_missing_request_contract() {
+  local task="$1"
+  local missing=()
+  # Goal: the standalone word "Goal" (with optional ** markdown). Also
+  # accept "Objective" as a synonym some upstream callers use.
+  if ! echo "$task" | grep -qiE '(^|[^a-zA-Z])(\*\*)?(goal|objective)(:|s?\b)'; then
+    missing+=("Goal")
+  fi
+  # Outcome: "Outcome" or "Expected Outcome".
+  if ! echo "$task" | grep -qiE '(^|[^a-zA-Z])(\*\*)?(expected )?outcome(:|s?\b)'; then
+    missing+=("Outcome")
+  fi
+  # Eval: "Eval", "Eval Criteria", "Acceptance Criteria", "Evaluation Criteria".
+  if ! echo "$task" | grep -qiE '(^|[^a-zA-Z])(\*\*)?(eval|evaluation criteria|acceptance criteria)(:|s?\b)'; then
+    missing+=("Eval")
+  fi
+  if [ ${#missing[@]} -gt 0 ]; then
+    local list
+    list=$(IFS=, ; echo "${missing[*]}")
+    echo "{\"warning\":\"Request Contract incomplete: brief is missing markers for: ${list}. Per P0-3 spec, every delegated subtask MUST include Goal + Expected Outcome + Eval Criteria. Workers may push back via the Brief Reception Protocol. Source: .crewly/specs/2026-05-03-agent-improvement-p0-execution.md §Fix P0-3.\"}" >&2
+  fi
+}
+
+warn_missing_request_contract "$TASK"
+
 # Resolve Crewly root from this script path:
 # config/skills/team-leader/delegate-task/execute.sh -> project root
 CREWLY_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
@@ -169,22 +199,39 @@ if [ "$DELIVER_OK" = "false" ]; then
   }
 fi
 
-# Track the task file path and task ID from create response
-TASK_FILE_PATH=""
+# V3-only producer (spec 2026-05-06-task-management-v1-deprecation.md):
+# We no longer write a `.crewly/tasks/delegated/*.md` file via the legacy
+# `/task-management/create` endpoint. Instead the long-form brief travels
+# on the WorkItem itself (`briefMarkdown` field) and the WI is the sole
+# durable record of this delegation.
 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)
+case "$PRIORITY" in
+  critical|urgent) WI_PRIORITY="critical" ;;
+  high)            WI_PRIORITY="high" ;;
+  low)             WI_PRIORITY="low" ;;
+  *)               WI_PRIORITY="medium" ;;
+esac
+
+WI_TITLE="$(echo "$TASK" | head -c 200)"
+
+POOL_BODY=$(jq -n \
+  --arg type "delegate" \
+  --arg owner "team_lead" \
+  --arg target "$TO" \
+  --arg title "$WI_TITLE" \
+  --arg description "$TASK_MESSAGE" \
+  --arg briefMarkdown "$TASK" \
+  --arg priority "$WI_PRIORITY" \
+  --arg projectPath "${PROJECT_PATH:-}" \
+  '{type: $type, owner: $owner, target: $target, title: $title, description: $description, briefMarkdown: $briefMarkdown, priority: $priority} + (if $projectPath != "" then {projectPath: $projectPath} else {} end)')
+
+POOL_RESULT=$(api_call POST "/task-pool/add" "$POOL_BODY" 2>/dev/null || echo '{"success":false}')
+POOL_OK=$(echo "$POOL_RESULT" | jq -r '.success // "false"' 2>/dev/null)
+TASK_ID=$(echo "$POOL_RESULT" | jq -r '.data.id // .workItemId // empty' 2>/dev/null || true)
+
+if [ "$POOL_OK" != "true" ]; then
+  echo "{\"warning\":\"Failed to create WorkItem in TaskPool — task delivered to terminal but no durable record\",\"details\":$(echo "$POOL_RESULT" | jq -c . 2>/dev/null || echo '{}')}" >&2
 fi
 
 # Set up idle event subscription for TL monitoring
@@ -230,15 +277,9 @@ if [ "$MONITOR_FALLBACK_MINUTES" != "0" ] && [ -n "$MONITOR_FALLBACK_MINUTES" ]
   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
+# Monitoring-id bookkeeping (cron/subscription cleanup) used to flow through
+# `/task-management/add-monitoring`, which is gone as of spec
+# 2026-05-06-task-management-v1-deprecation.md. Cron and subscription
+# lifecycles are owned by `/cron/*` and `/subscriptions/*` respectively;
+# the WI itself carries no association beyond `target`. No-op here.
+: