crewly 1.13.0 → 1.14.0

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/orchestrator/get-team-status/SKILL.md

@@ -34,7 +34,11 @@ bash config/skills/orchestrator/get-team-status/execute.sh
 
 ## Parameters
 
-None required.
+None required. Output is **compact by default** (team id/name/projectIds and
+each member's name, sessionName, role, runtimeType, agentStatus,
+workingStatus, readyAt). Pass `--full` (or `'{"full":true}'`) for the raw
+`/teams` payload including system prompts — it is large, so only ask for it
+when you need a specific field.
 
 ## Output
 

package/config/skills/orchestrator/get-team-status/execute.sh

@@ -1,7 +1,33 @@
 #!/bin/bash
-# Get status of all teams and their agents
+# Get status of all teams and their agents.
+#
+# Compact by default (2026-09-16): the raw /teams payload carries every
+# member's system prompt, and on a workspace with a few teams that is ~50 KB
+# per call — all of which stays in the orchestrator's context for the rest of
+# the session. Pass --full (or {"full":true}) when a specific field is needed.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../_common/lib.sh"
 
-api_call GET "/teams"
+FULL="false"
+for arg in "$@"; do
+  case "$arg" in
+    --full) FULL="true" ;;
+    \{*) printf '%s' "$arg" | jq -e '.full == true' >/dev/null 2>&1 && FULL="true" ;;
+  esac
+done
+
+RAW=$(api_call GET "/teams")
+
+if [ "$FULL" = "true" ]; then
+  printf '%s\n' "$RAW"
+  exit 0
+fi
+
+printf '%s' "$RAW" | jq '
+  def compact_member: {name, sessionName, role, runtimeType, agentStatus, workingStatus, readyAt};
+  def compact_team: {id, name, projectIds, memberCount: ((.members // []) | length), members: [(.members // [])[] | compact_member]};
+  if type == "array" then map(compact_team)
+  elif (.data | type) == "array" then .data |= map(compact_team)
+  elif .members then compact_team
+  else . end'

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

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

@@ -82,30 +82,49 @@ require_param "task (--task)" "$TASK"
 # 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. Scanning only `--task` warned
+# "Request Contract incomplete" at briefs whose contract was fully present,
+# just in the other field. That false positive is corrosive: this warning is
+# the signal 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.
+#
+# $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=()
   # 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
+  if ! echo "$brief" | 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
+  if ! echo "$brief" | 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
+  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. 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. 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"
 
 # Resolve Crewly root from this script path:
 # config/skills/team-leader/delegate-task/execute.sh -> project root
@@ -144,13 +163,80 @@ if [ -n "$CONTEXT" ]; then
 fi
 
 # Build a structured task message from Team Leader
-TASK_MESSAGE="New task from Team Leader (priority: ${PRIORITY}):\n\n**[REQUIRED] When done, you MUST:** (1) Output a text summary of your work, findings, and any issues. (2) Call report-status:\nbash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{\"sessionName\":\"${TO}\",\"status\":\"done\",\"summary\":\"<brief summary>\",\"projectPath\":\"${PROJECT_PATH}\"}'\n\n---\n\n${TASK}"
+TASK_MESSAGE="New task from Team Leader (priority: ${PRIORITY}):\n\n**[REQUIRED] When done, you MUST:** (1) Output a text summary of your work, findings, and any issues. (2) Call report-status, passing the workItemId from your [CREWLY-DISPATCH] notice (or from get-my-tasks) so the right WorkItem is closed:\nbash ${CREWLY_ROOT}/config/skills/agent/core/report-status/execute.sh '{\"sessionName\":\"${TO}\",\"workItemId\":\"<your WorkItem id>\",\"status\":\"done\",\"summary\":\"<brief summary>\",\"projectPath\":\"${PROJECT_PATH}\"}'\n\n---\n\n${TASK}"
 [ -n "$CONTEXT" ] && TASK_MESSAGE="${TASK_MESSAGE}\n\nContext: ${CONTEXT}"
 
+# 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.
+#
+# ORDERING (WI 65578471): the WorkItem is created BEFORE delivery is
+# attempted, and that order is load-bearing. Previously the pool-add ran
+# only after delivery succeeded, so a delivery failure exited the script
+# with NO RECORD ANYWHERE — not in the pool, not targeted, nothing for a
+# reconciler or a human to find. Every other orphan class in this system
+# at least left a WorkItem behind; this one left the intent with no system
+# of record at all.
+#
+# On a delivery failure the WI is deliberately left `queued` with its
+# `target` set, plus an explicit `[UNDELIVERED]` note (see below). That
+# state is chosen, not incidental:
+#   - `queued` + `target` is recoverable — the wake gate admits a worker
+#     for a queued WI targeting them, so the task can still be delivered.
+#   - `queued` is NOT `running`, so it never masquerades as in-flight work.
+#   - the note makes an undelivered item distinguishable from a normally
+#     queued one, so a silent nothing is not traded for a silent something.
+TASK_ID=""
+
+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, metadata: ({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
+  # Unchanged from before the reorder: warn and still attempt delivery.
+  # Aborting here instead would be a behavioural change beyond this WI's
+  # scope, so it is deliberately NOT made. The residual gap (record
+  # creation fails, task delivered anyway) is reported, not silently
+  # fixed — it is the mirror of the bug fixed here and wants its own call.
+  echo "{\"warning\":\"Failed to create WorkItem in TaskPool — delivering anyway, so this task will have no durable record\",\"details\":$(echo "$POOL_RESULT" | jq -c . 2>/dev/null || echo '{}')}" >&2
+fi
+
 # Deliver the task message with fallback strategy:
 # 1. Try normal delivery (waitForReady)
 # 2. If fails, try force delivery
 # 3. If still fails, auto-start the worker then retry
+# waitTimeout 15000: the INITIAL attempt against a worker expected to be
+# already running, so it fails fast and lets the fallback ladder below take
+# over. The retry after auto-start uses 30000 — see the note there; the two
+# values differ deliberately and must not be normalised to one number.
+#
+# ORIGIN NOT ESTABLISHED (WI dae79289): 15000 matches no delivery-related
+# constant. Seven constants share the value, none of them about terminal
+# delivery, so there is nothing here that this literal can honestly be said
+# to mirror. Left exactly as-is rather than attached to a plausible-looking
+# constant that does not actually govern it.
 BODY=$(jq -n --arg message "$TASK_MESSAGE" '{message: $message, waitForReady: true, waitTimeout: 15000}')
 
 DELIVER_OK=true
@@ -183,6 +269,16 @@ if [ "$DELIVER_OK" = "false" ]; then
           echo '{"info":"Worker '"$TO"' start triggered — retrying delivery in 10s..."}' >&2
           sleep 10
           # Retry delivery after agent boots
+          # waitTimeout 30000, double the initial 15000 above. This retry
+          # follows an auto-start, so the worker is booting from cold and
+          # legitimately needs longer to reach a prompt than one that was
+          # expected to be up already. The asymmetry is the point: it is not
+          # drift between two copies of the same call.
+          #
+          # ORIGIN NOT ESTABLISHED (WI dae79289): the value coincides with
+          # EVENT_DELIVERY_CONSTANTS.TOTAL_DELIVERY_TIMEOUT, but coincidence
+          # of value is not evidence of relationship — eleven constants share
+          # 30000. Not claimed as a mirror.
           RETRY_BODY=$(jq -n --arg message "$TASK_MESSAGE" '{message: $message, waitForReady: true, waitTimeout: 30000}')
           api_call POST "/terminal/${TO}/deliver" "$RETRY_BODY" && STARTED=true || {
             # Final fallback: force deliver
@@ -193,46 +289,27 @@ if [ "$DELIVER_OK" = "false" ]; then
     fi
 
     if [ "$STARTED" = "false" ]; then
-      echo '{"error":"Failed to deliver task to '"$TO"'. Worker is offline and could not be auto-started. Ensure the worker is a team member with a valid session.","to":"'"$TO"'","teamId":"'"$TEAM_ID"'"}'
+      # WI 65578471 — delivery failed, but the WorkItem already exists
+      # (created above, deliberately, before delivery was attempted). Mark
+      # it explicitly so an undelivered item is never mistaken for a
+      # normally queued one, then fail loudly. The WI stays `queued` with
+      # its `target`, which is the recoverable state: the worker can still
+      # be woken for it and re-delivery can be retried.
+      #
+      # Best-effort: a failure to annotate must not swallow the delivery
+      # error, which is the more important signal.
+      if [ -n "$TASK_ID" ]; then
+        NOTE_AUTHOR="${CREWLY_SESSION_NAME:-${FROM_SESSION:-team-leader}}"
+        NOTE_BODY=$(jq -n --arg author "$NOTE_AUTHOR" --arg note "[UNDELIVERED] Delivery to ${TO} failed — worker offline and could not be auto-started. WorkItem left queued and targeted for re-delivery." \
+          '{author: $author, note: $note}')
+        api_call POST "/task-pool/items/${TASK_ID}/notes" "$NOTE_BODY" >/dev/null 2>&1 || true
+      fi
+      echo '{"error":"Failed to deliver task to '"$TO"'. Worker is offline and could not be auto-started. Ensure the worker is a team member with a valid session.","to":"'"$TO"'","teamId":"'"$TEAM_ID"'","workItemId":"'"$TASK_ID"'","workItemState":"queued+targeted, marked [UNDELIVERED] — re-delivery can be retried"}'
       exit 1
     fi
   }
 fi
 
-# 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=""
-
-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
 MONITOR_IDLE=$(printf '%s' "$INPUT" | jq -r 'if .monitor.idleEvent == null then true else .monitor.idleEvent end')
@@ -251,11 +328,23 @@ if [ -z "$RESOLVED_SESSION" ]; then
 fi
 
 if [ "$MONITOR_IDLE" = "true" ] && [ -n "$RESOLVED_SESSION" ]; then
+  # ttlMinutes is deliberately OMITTED so the server default applies.
+  #
+  # This used to hardcode `ttlMinutes: 120`, silently capping every delegation
+  # subscription at 2h against a system default of 8h
+  # (EVENT_BUS_CONSTANTS.DEFAULT_SUBSCRIPTION_TTL_MINUTES = 480, applied by
+  # event-bus.service.ts via `input.ttlMinutes ?? DEFAULT`). A subscription
+  # that expires 6h early stops the TL ever being woken for a long-running
+  # delegation — the same failure shape as a lease lapsing under an agent that
+  # is simply heads-down.
+  #
+  # Omitting beats re-hardcoding 480: the constant stays the single source of
+  # truth and the skill cannot drift from it again.
   SUB_BODY=$(jq -n \
     --arg eventType "agent:idle" \
     --arg sessionName "$TO" \
     --arg subscriber "$RESOLVED_SESSION" \
-    '{eventType: $eventType, filter: {sessionName: $sessionName}, subscriberSession: $subscriber, oneShot: true, ttlMinutes: 120}')
+    '{eventType: $eventType, filter: {sessionName: $sessionName}, subscriberSession: $subscriber, oneShot: true}')
   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