crewly 1.12.1 → 1.13.1

package/config/skills/agent/core/get-team-norms/execute.sh

@@ -14,6 +14,76 @@ TRIGGER=$(printf '%s' "$INPUT" | jq -r '.trigger // empty')
 TEAM_ID=$(printf '%s' "$INPUT" | jq -r '.teamId // empty')
 SESSION_NAME=$(printf '%s' "$INPUT" | jq -r '.sessionName // empty')
 
+# ---------------------------------------------------------------------------
+# Trigger matching
+# ---------------------------------------------------------------------------
+#
+# `trigger:` frontmatter is a COMMA-SEPARATED LIST, not a single value —
+# 6 of the 7 norms in the live runtime store lists such as
+# "escalation,delegation,blocker". Comparing the caller's trigger to that
+# raw string with `=` only matched when the caller happened to pass the
+# entire list verbatim, so trigger-filtered retrieval returned nothing for
+# essentially every norm and agents concluded no norms existed.
+#
+# Matching is done on whole TOKENS, deliberately not on substrings:
+# `lead` must not match `inbound_lead`, and `sale` must not match `sales`.
+# Both pairs exist in the current norms, so a substring fix would silently
+# return the wrong norms rather than none — a worse failure, because it
+# looks like it works.
+#
+# Tokens may contain internal spaces (e.g. "mutation check"), so only
+# leading/trailing whitespace is trimmed; internal spacing is preserved.
+# Comparison is case-insensitive.
+
+# Normalise a comma-separated trigger list into one trimmed, lowercase
+# token per line, dropping empties.
+#
+# $1 - Raw comma-separated trigger string (may be empty)
+normalize_trigger_tokens() {
+  printf '%s' "${1:-}" \
+    | tr ',' '\n' \
+    | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' \
+    | tr '[:upper:]' '[:lower:]' \
+    | sed '/^$/d'
+}
+
+# Decide whether a norm's stored trigger list satisfies the caller's query.
+#
+# An empty query matches everything (no filtering requested). Otherwise the
+# two token sets must intersect: a norm matches when it declares ANY of the
+# triggers the caller asked about.
+#
+# $1 - Stored `trigger:` frontmatter value
+# $2 - Caller-supplied trigger query
+# Returns 0 when the norm should be included, 1 when it should be skipped.
+trigger_matches() {
+  local stored_raw="${1:-}"
+  local query_raw="${2:-}"
+  local stored_tokens query_tokens q_token s_token
+
+  [ -z "$query_raw" ] && return 0
+
+  query_tokens=$(normalize_trigger_tokens "$query_raw")
+  [ -z "$query_tokens" ] && return 0
+
+  stored_tokens=$(normalize_trigger_tokens "$stored_raw")
+  [ -z "$stored_tokens" ] && return 1
+
+  while IFS= read -r q_token; do
+    [ -z "$q_token" ] && continue
+    while IFS= read -r s_token; do
+      [ -z "$s_token" ] && continue
+      [ "$q_token" = "$s_token" ] && return 0
+    done <<EOF
+$stored_tokens
+EOF
+  done <<EOF
+$query_tokens
+EOF
+
+  return 1
+}
+
 # Resolve teamId: explicit param > lookup by sessionName > CREWLY_SESSION_NAME env
 resolve_team_id() {
   local session="${1:-${CREWLY_SESSION_NAME:-}}"
@@ -81,8 +151,9 @@ for file in "$NORMS_DIR"/*.md; do
   FM_UPDATED_BY=$(echo "$FRONTMATTER" | sed -n 's/^updatedBy: *//p' | head -1)
   FM_UPDATED_AT=$(echo "$FRONTMATTER" | sed -n 's/^updatedAt: *//p' | head -1)
 
-  # If trigger filter is set, skip non-matching norms
-  if [ -n "$TRIGGER" ] && [ "$FM_TRIGGER" != "$TRIGGER" ]; then
+  # If a trigger filter is set, skip norms that declare none of its tokens.
+  # `trigger:` is a comma-separated list; see trigger_matches above.
+  if ! trigger_matches "$FM_TRIGGER" "$TRIGGER"; then
     continue
   fi
 

package/config/skills/agent/core/handoff-task/execute.sh

@@ -128,7 +128,7 @@ fi
 cat >> "$HANDOFF_MSG_FILE" << FOOTER_EOF
 
 ---
-When done, report back using: bash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{"sessionName":"${TO}","status":"done","summary":"<brief summary>","projectPath":"${PROJECT_PATH}"}'
+When done, report back with report-status, passing the workItemId from your [CREWLY-DISPATCH] notice (or from get-my-tasks) so the right WorkItem is closed: bash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{"sessionName":"${TO}","workItemId":"<your WorkItem id>","status":"done","summary":"<brief summary>","projectPath":"${PROJECT_PATH}"}'
 FOOTER_EOF
 
 HANDOFF_MESSAGE=$(cat "$HANDOFF_MSG_FILE")
@@ -141,6 +141,13 @@ echo "Delivering handoff context to ${TO}..." >&2
 deliver_result=$(api_call POST "/terminal/${TO}/write" "$DELIVER_BODY" 2>/dev/null) || {
   # Retry with deliver endpoint (agent may need wake-up)
   DELIVER_BODY_V2=$(jq -n --arg message "$HANDOFF_MESSAGE" \
+    # waitTimeout 15000, matching delegate-task's initial attempt. Handoff
+    # targets a worker expected to be already running, so the same fail-fast
+    # budget applies.
+    #
+    # ORIGIN NOT ESTABLISHED (WI dae79289): no delivery constant carries this
+    # value, so there is nothing to mirror. Documented, deliberately not
+    # changed.
     '{message: $message, waitForReady: true, waitTimeout: 15000}')
   deliver_result=$(api_call POST "/terminal/${TO}/deliver" "$DELIVER_BODY_V2" 2>/dev/null) || {
     deliver_result='{"error":"delivery failed — target agent may be offline"}'

package/config/skills/agent/core/report-status/SKILL.md

@@ -56,6 +56,32 @@ When `status` is `done` and a `taskPath` is provided, the task file is automatic
 | `--task-id` | `taskId` | No | Task ID (for structured StatusReport format) |
 | `--progress` | `progress` | No | Progress percentage 0-100 |
 | `--structured` | `structured` | No | Use structured StatusReport format |
+| `--work-item-id` / `--wi-id` | `workItemId` | **Pass this when `status=done`** | Which WorkItem to complete. See below — without it the skill infers, and refuses when the choice is ambiguous |
+
+## This skill COMPLETES a WorkItem, not just reports
+
+When `status=done`, this skill closes a WorkItem in the task pool as a side
+effect. That is a surprising amount of authority for something named
+`report-status`, and the name/behaviour mismatch is exactly why nobody
+anticipated it silently closing the wrong item. It is not renamed here only
+because too many callers reference it.
+
+**Pass `workItemId` whenever you report done.** Resolution order:
+
+1. **`workItemId` given** — that item is completed. Always prefer this.
+2. **Omitted, exactly one WorkItem running for your session** — that one is
+   completed, and the resolved id is echoed so you can see what closed.
+3. **Omitted, more than one running** — the skill **refuses** and names the
+   candidates. It will not guess.
+
+Case 3 exists because guessing destroyed real work: on 2026-08-21 the skill
+completed an arbitrary first running item, silently closing a queued WorkItem
+nobody had started while the agent was reporting a different one done. Nothing
+failed, and the false completion spawned a verify WorkItem for a delivery that
+had never happened.
+
+If the completion itself fails, the skill says so explicitly — a reported
+status never implies the WorkItem actually closed.
 
 ## Examples — CLI Flags (preferred)
 

package/config/skills/agent/core/report-status/execute.sh

@@ -235,17 +235,41 @@ api_call POST "/chat/agent-response" "$BODY"
 # `/task-management/complete{-by-session}` endpoints.
 #
 # Resolution order for which WorkItem to complete:
-#   1. `workItemId` in input (preferred — explicit reference)
-#   2. The agent's currently-running WI fetched from the pool
+#   1. `workItemId` in input — explicit, always wins. PASS THIS.
+#   2. Exactly one running WI for this session — inferred, and the resolved id
+#      is echoed so the caller can see what was closed.
+#   3. More than one running WI — REFUSED. The candidates are named and the
+#      caller must pass `workItemId`.
+#
+# Why (3) refuses instead of guessing: this block used to complete
+# `.data[0].id`, an arbitrary first running item. On 2026-08-21 that silently
+# closed WorkItem 7db3b00c — a queued piece of work nobody had started — while
+# the agent was reporting a DIFFERENT WI done. Nothing failed. The false
+# completion then spawned a verify WorkItem asking the orchestrator to verify a
+# delivery that had never happened, so one silent mis-close also consumed
+# downstream verification attention on fiction.
+#
+# Inferring from a single running claim is safe and stays. Inferring from
+# several is a coin flip on which real work gets destroyed.
 #
 # The legacy `taskPath` input is still accepted for backwards compatibility
 # but no longer drives the API call.
 if [ "$STATUS" = "done" ]; then
   TARGET_WI_ID="${WORK_ITEM_ID:-}"
+  WI_RESOLUTION="explicit"
+
   if [ -z "$TARGET_WI_ID" ]; then
-    # Fall back: query pool for this session's running WIs and complete the first match.
     POOL_RESP=$(api_call GET "/task-pool/items?status=running&target=${SESSION_NAME}" 2>/dev/null || echo '{}')
-    TARGET_WI_ID=$(echo "$POOL_RESP" | jq -r '.workItems[0].id // .data[0].id // empty' 2>/dev/null || true)
+    RUNNING_IDS=$(printf '%s' "$POOL_RESP" | jq -r '((.workItems // .data // []) | map(.id)) | .[]' 2>/dev/null || true)
+    RUNNING_COUNT=$(printf '%s' "$RUNNING_IDS" | grep -c . || true)
+
+    if [ "$RUNNING_COUNT" -gt 1 ]; then
+      CANDIDATES=$(printf '%s' "$RUNNING_IDS" | tr '\n' ' ')
+      error_exit "report-status refuses to guess which WorkItem to complete: ${RUNNING_COUNT} are running for ${SESSION_NAME} (${CANDIDATES}). Pass workItemId explicitly. Completing an arbitrary one silently closes work nobody did — and a false completion cascades into a verify WorkItem for a delivery that never happened."
+    fi
+
+    TARGET_WI_ID=$(printf '%s' "$RUNNING_IDS" | head -1)
+    WI_RESOLUTION="inferred"
   fi
 
   if [ -n "$TARGET_WI_ID" ]; then
@@ -258,7 +282,18 @@ if [ "$STATUS" = "done" ]; then
       --arg agentId "$SESSION_NAME" \
       --arg summary "$SUMMARY" \
       '{agentId: $agentId, result: {summary: $summary}}')
-    api_call POST "/task-pool/complete/${TARGET_WI_ID}" "$COMPLETE_BODY" || true
+    # No `|| true`. A swallowed failure here is the inverse of the bug above:
+    # report-status would announce success while the WorkItem stayed open, and
+    # that is equally invisible. Report what actually happened either way.
+    if COMPLETE_RESULT=$(api_call POST "/task-pool/complete/${TARGET_WI_ID}" "$COMPLETE_BODY" 2>&1); then
+      # Echo the resolved id even on the happy path. Silent-but-correct is how
+      # this class hides — the caller must be able to see WHICH item closed.
+      jq -n --arg id "$TARGET_WI_ID" --arg how "$WI_RESOLUTION" \
+        '{completedWorkItem: $id, resolvedBy: $how}' >&2
+    else
+      jq -n --arg id "$TARGET_WI_ID" --arg err "$COMPLETE_RESULT" \
+        '{warning: "status reported, but completing the WorkItem FAILED — it is still open", workItemId: $id, error: $err}' >&2
+    fi
   fi
 fi
 

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

@@ -41,7 +41,7 @@ The script auto-resolves `config/skills/...` references to absolute paths so del
 | `--task` / `-T` | `task` | Yes | Task description (or pipe via stdin) |
 | `--task-file` | — | No | Read task description from a file path |
 | `--priority` / `-P` | `priority` | No | Priority: `low`, `normal`, `high` (default: `normal`) |
-| `--context` / `-c` | `context` | No | Additional context for the task |
+| `--context` / `-c` | `context` | No | Additional context for the task. Scanned for the Request Contract alongside `--task` |
 | `--project` / `-p` | `projectPath` | No | Project path; creates task file in `.crewly/tasks/` |
 | `--team` / `-g` | `teamId` | No | Team ID for cross-team validation |
 | `--task-type` | `taskType` | No | Task type: `general`, `technical` (default: `general`) |

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

@@ -95,26 +95,51 @@ require_param "task (--task)" "$TASK"
 # 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".
+#
+# Scans the WHOLE delegated brief, not just `--task`. The Request Contract can
+# legitimately live in `--task`, in `--context`, or be split across the two,
+# and delegators routinely put the long-form G/O/E in `--context` while
+# `--task` carries the one-line ask. `--context` is delivered to the target
+# (see the TASK_MESSAGE assembly below), so a contract written there does
+# reach the recipient — it was simply not being looked at here. Scanning only
+# `--task` therefore warned "Request Contract incomplete" at briefs whose
+# contract was fully present, just in the other field.
+#
+# That false positive is corrosive rather than cosmetic: this warning is the
+# signal TLs and workers use to decide whether to push back under the Brief
+# Reception Protocol, so crying wolf trains them to ignore a real one.
+#
+# The check is NOT weakened — a marker genuinely absent from BOTH fields
+# still warns, and the missing-field list is still per-marker.
+#
+# Mirrors the same fix in config/skills/team-leader/delegate-task/execute.sh.
+#
+# $1 = task, $2 = context (either may be empty).
 warn_missing_request_contract() {
-  local task="$1"
+  # Join with a newline rather than concatenating: the patterns below anchor
+  # on `^`, which grep evaluates per line, and a seam newline also prevents a
+  # task ending in "go" plus a context starting "al:" from fabricating a
+  # spurious "goal:" match across the boundary.
+  local brief
+  brief="$(printf '%s\n%s' "${1:-}" "${2:-}")"
   local missing=()
-  if ! echo "$task" | grep -qiE '(^|[^a-zA-Z])(\*\*)?(goal|objective)(:|s?\b)'; then
+  if ! echo "$brief" | 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
+  if ! echo "$brief" | 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
+  if ! echo "$brief" | 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
+    echo "{\"warning\":\"Request Contract incomplete: brief is missing markers for: ${list}. Neither the task nor the context field carries them. 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"
+warn_missing_request_contract "$TASK" "$CONTEXT"
 
 # #180: Validate target agent belongs to the specified team
 if [ -n "$TEAM_ID" ] && [ "$FORCE_CROSS_TEAM" != "true" ]; then
@@ -141,8 +166,17 @@ if [ "$TASK_TYPE" = "technical" ] && [ -n "$TEAM_ID" ]; then
 fi
 
 # Structured message parameters (for hierarchical teams)
-# Default INPUT to empty JSON if not set (when using --flag mode)
-INPUT="${INPUT:-{}}"
+# Default INPUT to empty JSON if not set (when using --flag mode).
+#
+# NOT `${INPUT:-{}}` — bash ends the expansion at the FIRST `}`, so that form
+# means "default to `{`" followed by a literal `}`. It is correct only when
+# INPUT is unset (yielding `{}`); when INPUT holds real JSON it appends a
+# stray `}` and every subsequent `jq` call dies with
+# "parse error: Unmatched '}'". That silently broke the entire JSON-input mode
+# of this skill while --flag mode kept working.
+if [ -z "${INPUT:-}" ]; then
+  INPUT='{}'
+fi
 TITLE=$(printf '%s' "$INPUT" | jq -r '.title // empty')
 PARENT_TASK_ID=$(printf '%s' "$INPUT" | jq -r '.parentTaskId // empty')
 EXPECTED_ARTIFACTS=$(printf '%s' "$INPUT" | jq -c '.expectedArtifacts // empty')
@@ -197,13 +231,13 @@ if [ "$USE_STRUCTURED" = "true" ] && [ -n "$TITLE" ]; then
 
   [ -n "$CONTEXT" ] && TASK_MESSAGE="${TASK_MESSAGE}\n\nAdditional context: ${CONTEXT}"
   [ -n "$DEADLINE_HINT" ] && TASK_MESSAGE="${TASK_MESSAGE}\n\n**Deadline hint**: ${DEADLINE_HINT}"
-  TASK_MESSAGE="${TASK_MESSAGE}\n\n---\nWhen done, report back using: bash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{\"sessionName\":\"${TO}\",\"status\":\"done\",\"summary\":\"<brief summary>\",\"projectPath\":\"${PROJECT_PATH}\"}'"
+  TASK_MESSAGE="${TASK_MESSAGE}\n\n---\nWhen done, report back with report-status, passing the workItemId from your [CREWLY-DISPATCH] notice (or from get-my-tasks) so the right WorkItem is closed: bash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{\"sessionName\":\"${TO}\",\"workItemId\":\"<your WorkItem id>\",\"status\":\"done\",\"summary\":\"<brief summary>\",\"projectPath\":\"${PROJECT_PATH}\"}'"
   TASK_MESSAGE="${TASK_MESSAGE}\n\nBefore reporting done, persist key findings using: bash ${CREWLY_ROOT}/config/skills/agent/core/remember/execute.sh '{\"agentId\":\"${TO}\",\"content\":\"<key findings>\",\"category\":\"pattern\",\"scope\":\"project\",\"projectPath\":\"${PROJECT_PATH}\"}'"
 else
   # Legacy free-text format (backwards compatible)
   TASK_MESSAGE="New task from orchestrator (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>\",\"projectPath\":\"${PROJECT_PATH}\"}'"
+  TASK_MESSAGE="${TASK_MESSAGE}\n\nWhen done, report back with report-status, passing the workItemId from your [CREWLY-DISPATCH] notice (or from get-my-tasks) so the right WorkItem is closed: bash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{\"sessionName\":\"${TO}\",\"workItemId\":\"<your WorkItem id>\",\"status\":\"done\",\"summary\":\"<brief summary>\",\"projectPath\":\"${PROJECT_PATH}\"}'"
   TASK_MESSAGE="${TASK_MESSAGE}\n\nBefore reporting done, persist key findings using: bash ${CREWLY_ROOT}/config/skills/agent/core/remember/execute.sh '{\"agentId\":\"${TO}\",\"content\":\"<key findings>\",\"category\":\"pattern\",\"scope\":\"project\",\"projectPath\":\"${PROJECT_PATH}\"}'"
 fi
 
@@ -238,7 +272,7 @@ POOL_BODY=$(jq -n \
   --arg priority "$WI_PRIORITY" \
   --arg projectPath "${PROJECT_PATH:-}" \
   --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)')
+  '{type: $type, owner: $owner, target: $target, title: $title, description: $description, briefMarkdown: $briefMarkdown, metadata: ({priority: $priority} + (if $projectPath != "" then {projectPath: $projectPath} else {} end))} + (if $requestId != "" then {requestId: $requestId} else {} end)')
 
 # 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

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

@@ -1,7 +1,17 @@
 #!/bin/bash
 # Tests for ORC delegate-task execute.sh
 #
-# Focused on the auto-claim transition added 2026-05-20 — the skill must
+# Covers two things:
+#   1. the auto-claim transition (Tests 1-6), and
+#   2. the Request Contract checker (Test 7), which scans BOTH `--task` and
+#      `--context` — see the note above Test 7.
+#
+# Note the harness runs a COPY of the real execute.sh under a stubbed
+# api_call, so production logic is exercised verbatim; no part of the skill
+# is reimplemented here. Keep it that way — a hand-copied mirror of skill
+# logic silently stops tracking the skill.
+#
+# Tests 1-6 are focused on the auto-claim transition added 2026-05-20 — the skill must
 # call POST /task-pool/claim immediately after POST /task-pool/add succeeds,
 # so the WI transitions queued → running at dispatch time and doesn't rot
 # in queued waiting for a pull that may never come (the 2026-05-20
@@ -196,6 +206,148 @@ OUT=$(CALL_LOG="$CALL_LOG" CREWLY_ROOT=/tmp/crewly-test \
 
 assert_output_contains "result reports custom fallbackMinutes=120" '"fallbackMinutes": 120' "$OUT"
 
+# ---------------------------------------------------------------------------
+# Test 7: Request Contract checker scans --task AND --context
+#
+# The checker used to read only `--task`. This skill has its own `--context`
+# flag and delivers it to the target, so an orchestrator that put the
+# long-form Goal / Expected Outcome / Eval Criteria in `--context` was told
+# the contract was "incomplete" while every marker was in fact present. That
+# false positive is what the Brief Reception Protocol keys off, so it has to
+# be right in both directions: silent when the contract is present anywhere,
+# and still loud when a marker is in neither field.
+# ---------------------------------------------------------------------------
+echo ""
+echo "=== ORC delegate-task — Request Contract checker ==="
+
+CTX_FULL="**Goal:** Ship the importer. **Expected Outcome:** CSVs land in prod. **Eval Criteria:** all tests green."
+
+# 7a: contract entirely in --context — must NOT warn
+> "$CALL_LOG"
+OUT=$(CALL_LOG="$CALL_LOG" CREWLY_ROOT=/tmp/crewly-test \
+  bash "${SKILL_PARENT}/delegate-task/execute.sh" \
+  --to crewly-test-bob \
+  --task "build the importer" \
+  --context "$CTX_FULL" \
+  2>&1 || true)
+if echo "$OUT" | grep -q "Request Contract incomplete"; then
+  echo "  FAIL: contract present in --context was still reported incomplete: $OUT"
+  FAIL=$((FAIL + 1))
+else
+  echo "  PASS: contract in --context suppresses the warning"
+  PASS=$((PASS + 1))
+fi
+
+# 7b: contract split across --task and --context — must NOT warn
+> "$CALL_LOG"
+OUT=$(CALL_LOG="$CALL_LOG" CREWLY_ROOT=/tmp/crewly-test \
+  bash "${SKILL_PARENT}/delegate-task/execute.sh" \
+  --to crewly-test-bob \
+  --task "**Goal:** ship the importer" \
+  --context "**Expected Outcome:** CSVs land in prod. **Eval Criteria:** all tests green." \
+  2>&1 || true)
+if echo "$OUT" | grep -q "Request Contract incomplete"; then
+  echo "  FAIL: split contract was reported incomplete: $OUT"
+  FAIL=$((FAIL + 1))
+else
+  echo "  PASS: contract split across --task and --context suppresses the warning"
+  PASS=$((PASS + 1))
+fi
+
+# 7c: contract entirely in --task, no --context — must NOT warn (no regression)
+> "$CALL_LOG"
+OUT=$(CALL_LOG="$CALL_LOG" CREWLY_ROOT=/tmp/crewly-test \
+  bash "${SKILL_PARENT}/delegate-task/execute.sh" \
+  --to crewly-test-bob \
+  --task "$CTX_FULL" \
+  2>&1 || true)
+if echo "$OUT" | grep -q "Request Contract incomplete"; then
+  echo "  FAIL: contract in --task alone was reported incomplete: $OUT"
+  FAIL=$((FAIL + 1))
+else
+  echo "  PASS: contract in --task alone still suppresses the warning"
+  PASS=$((PASS + 1))
+fi
+
+# 7d: one marker absent from BOTH — check is not weakened
+> "$CALL_LOG"
+OUT=$(CALL_LOG="$CALL_LOG" CREWLY_ROOT=/tmp/crewly-test \
+  bash "${SKILL_PARENT}/delegate-task/execute.sh" \
+  --to crewly-test-bob \
+  --task "**Goal:** ship it" \
+  --context "**Expected Outcome:** it ships." \
+  2>&1 || true)
+if echo "$OUT" | grep -q "Request Contract incomplete" && echo "$OUT" | grep -q "Eval"; then
+  echo "  PASS: still warns for the one marker absent from both fields"
+  PASS=$((PASS + 1))
+else
+  echo "  FAIL: expected an Eval-missing warning, got: $OUT"
+  FAIL=$((FAIL + 1))
+fi
+
+# 7e: nothing anywhere — all three still named
+> "$CALL_LOG"
+OUT=$(CALL_LOG="$CALL_LOG" CREWLY_ROOT=/tmp/crewly-test \
+  bash "${SKILL_PARENT}/delegate-task/execute.sh" \
+  --to crewly-test-bob \
+  --task "just do the thing" \
+  --context "here is some background prose" \
+  2>&1 || true)
+if echo "$OUT" | grep -q "Request Contract incomplete" && \
+   echo "$OUT" | grep -q "Goal" && \
+   echo "$OUT" | grep -q "Outcome" && \
+   echo "$OUT" | grep -q "Eval"; then
+  echo "  PASS: all three markers reported missing"
+  PASS=$((PASS + 1))
+else
+  echo "  FAIL: expected all three named, got: $OUT"
+  FAIL=$((FAIL + 1))
+fi
+
+# 7f: warning stays non-fatal — dispatch still happens
+> "$CALL_LOG"
+OUT=$(CALL_LOG="$CALL_LOG" CREWLY_ROOT=/tmp/crewly-test \
+  bash "${SKILL_PARENT}/delegate-task/execute.sh" \
+  --to crewly-test-bob \
+  --task "unstructured task" \
+  2>&1 || true)
+assert_log_contains "dispatch proceeds despite an incomplete contract" "POST /task-pool/add"
+
+# 7g: markers are not fabricated across the task/context seam
+> "$CALL_LOG"
+OUT=$(CALL_LOG="$CALL_LOG" CREWLY_ROOT=/tmp/crewly-test \
+  bash "${SKILL_PARENT}/delegate-task/execute.sh" \
+  --to crewly-test-bob \
+  --task "please go" \
+  --context "al: nothing here. Expected Outcome: y. Eval Criteria: z." \
+  2>&1 || true)
+if echo "$OUT" | grep -q "Request Contract incomplete" && echo "$OUT" | grep -q "Goal"; then
+  echo "  PASS: seam does not fabricate a Goal marker"
+  PASS=$((PASS + 1))
+else
+  echo "  FAIL: 'go'+'al:' across the seam was accepted as a Goal marker: $OUT"
+  FAIL=$((FAIL + 1))
+fi
+
+# 7h: source-level guard on the production call site. The scenarios above run
+# a copy of execute.sh, but pin the call line explicitly so reverting it to
+# the task-only form fails loudly even if a future refactor moves the checker.
+SRC=$(cat "$SCRIPT_DIR/execute.sh")
+if printf '%s' "$SRC" | grep -q -- 'warn_missing_request_contract "$TASK" "$CONTEXT"'; then
+  echo "  PASS: call site passes \$TASK and \$CONTEXT"
+  PASS=$((PASS + 1))
+else
+  echo "  FAIL: execute.sh does not call warn_missing_request_contract with both fields"
+  FAIL=$((FAIL + 1))
+fi
+if printf '%s' "$SRC" | grep -qE '^warn_missing_request_contract "\$TASK"$'; then
+  echo "  FAIL: execute.sh still has a task-only call to the contract checker"
+  FAIL=$((FAIL + 1))
+else
+  echo "  PASS: no task-only call to the contract checker remains"
+  PASS=$((PASS + 1))
+fi
+
 # --- Summary ---
 echo ""
 echo "=== Results: $PASS passed, $FAIL failed ==="

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

@@ -105,7 +105,7 @@ The report is written to `reportFile` and follows the `[TL_REPORT]` tag conventi
 
 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"}'
+bash {{SKILLS_PATH}}/agent/core/report-status/execute.sh '{"sessionName":"tl-session","workItemId":"<your WorkItem id>","status":"done","summary":"Objective complete: 4/5 tasks passed. Report at /tmp/tl-report-team-123.md"}'
 ```
 
 ## Related Skills

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

@@ -53,36 +53,31 @@ ${TASK_CRITERIA}"
 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}-$$"
 
+  # Minimal CreateWorkItemInput — no client-side `id`/`status`.
+  #
+  # A body carrying `id` and `status` but no `createdAt` fails the endpoint's
+  # `isLegacyFullShape` check, so it silently takes the MINIMAL path and the
+  # server generates its own uuid anyway. The old client id was never
+  # referenced after creation, so there is nothing to preserve: commit to the
+  # minimal shape rather than sending two-thirds of the legacy one.
   WORK_ITEM=$(jq -n \
-    --arg id "$WI_ID" \
     --arg title "$TASK_TITLE" \
     --arg brief "$BRIEF" \
     --arg projectPath "$PROJECT_PATH" \
     --arg milestone "$MILESTONE" \
     --arg role "$TASK_ROLE" \
-    --argjson priority "$PRIORITY_NUM" \
+    --arg priority "$TASK_PRIORITY" \
     '{
-      id: $id,
       title: $title,
       type: "delegate",
       owner: "system",
-      priority: $priority,
-      status: "queued",
       briefMarkdown: $brief,
-      metadata: { projectPath: $projectPath, milestone: $milestone, requiredRole: $role }
+      metadata: { projectPath: $projectPath, milestone: $milestone, requiredRole: $role, priority: $priority }
     }')
 
-  CREATE_BODY=$(jq -n --argjson workItem "$WORK_ITEM" '{workItem: $workItem}')
+  # No envelope: addItem reads req.body directly as the CreateWorkItemInput.
+  CREATE_BODY="$WORK_ITEM"
   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)
 

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

@@ -42,12 +42,25 @@ Assigns a task to a worker within the Team Leader's subordinate scope. Validates
 | `--task` / `-T` | `task` | Yes | Task description (or pipe via stdin) |
 | `--task-file` | — | No | Read task description from a file path |
 | `--priority` / `-P` | `priority` | No | Priority: `low`, `normal`, `high` (default: `normal`) |
-| `--context` / `-c` | `context` | No | Additional context for the worker |
+| `--context` / `-c` | `context` | No | Additional context for the worker. Scanned for the Request Contract alongside `--task` |
 | `--project` / `-p` | `projectPath` | No | Project path; creates task file in `.crewly/tasks/` |
 | `--team` / `-g` | `teamId` | No | Team ID for hierarchy validation |
 | `--tl-member` | `tlMemberId` | No | TL's member ID for hierarchy validation |
 | `--from` | `fromSession` | No | Delegating TL's session name (for monitoring) |
 
+## Request Contract check
+
+Before delegating, the skill scans the brief for Goal, Expected Outcome, and
+Eval Criteria markers, and emits a non-fatal warning on stderr naming any that
+are missing. Workers use that warning to decide whether to push back under the
+Brief Reception Protocol.
+
+`--task` and `--context` are scanned **together**, so the contract may live in
+either field or be split across both. A marker absent from both still warns.
+
+Recognised synonyms: `Objective` for Goal; `Acceptance Criteria` or
+`Evaluation Criteria` for Eval Criteria.
+
 ## Usage — CLI Flags (preferred)
 
 ```bash