crewly 1.20.105 → 1.20.107

package/config/skills/agent/remote-browser/execute.test.sh

@@ -318,6 +318,26 @@ assert_contains "first request had stale tabId:100" "$first_body" '"tabId":100'
   || pass "cache purged on 404"
 scenario_teardown
 
+# Scenario 6b: an explicit --tab-id that 404s is NOT retried on another tab
+scenario_init "scenario 6b: explicit --tab-id 404 fails without retry"
+mkdir -p "${RUNTIME_DIR}/agent-6b"
+echo "55" > "${RUNTIME_DIR}/agent-6b/browser-tab-id"
+queue_response '404|{"id":"x","success":false,"error":"Tab 100 no longer exists. Bind a new tab instead of reusing this tabId.","code":"tab_not_found"}'
+queue_response '{"success":true,"data":{"text":"some other tab"}}'
+start_stub
+export CREWLY_SESSION_NAME="agent-6b"
+set +e
+"$SKILL" --action read-text --tab-id 100 > /dev/null 2>&1
+rc=$?
+set -e
+total_reqs=$(wc -l < "$LOG_FILE")
+assert_eq "stub received exactly 1 request" "1" "$(printf '%s' "$total_reqs" | tr -d ' ')"
+[ "$rc" -ne 0 ] && pass "explicit --tab-id 404 exits non-zero" || fail "explicit --tab-id 404 exits non-zero" "rc=$rc"
+[ -f "${RUNTIME_DIR}/agent-6b/browser-tab-id" ] \
+  && pass "cached tab left alone for an explicit --tab-id failure" \
+  || fail "cached tab left alone" "cache was purged"
+scenario_teardown
+
 # Scenario 7: bind-tab with --active sends active:true
 scenario_init "scenario 7: bind-tab --active forwards foreground flag"
 queue_response '{"success":true,"data":{"tabId":7}}'
@@ -468,6 +488,48 @@ total_reqs=$(wc -l < "$LOG_FILE" | tr -d ' ')
 assert_eq "stub received 0 requests" "0" "$total_reqs"
 scenario_teardown
 
+# The goal header is sent as b64:<base64 of UTF-8>; decode it for comparison.
+decode_goal() {
+  case "$1" in
+    b64:*) printf '%s' "${1#b64:}" | base64 --decode 2>/dev/null || printf '%s' "${1#b64:}" | base64 -D ;;
+    *) printf 'NOT-B64:%s' "$1" ;;
+  esac
+}
+
+# Scenario 20: --goal forwards the X-Agent-Goal header (takeover banner)
+scenario_init "scenario 20: --goal forwards X-Agent-Goal"
+queue_response '{"success":true,"data":{}}'
+start_stub
+unset CREWLY_SESSION_NAME
+unset CREWLY_AGENT_GOAL 2>/dev/null || true
+"$SKILL" --action navigate --url https://x.com --goal "Verify DMARC setup" > /dev/null 2>&1 || true
+assert_eq "X-Agent-Goal from --goal" "Verify DMARC setup" "$(decode_goal "$(request_field 0 headers.X-Agent-Goal)")"
+scenario_teardown
+
+# Scenario 21: CREWLY_AGENT_GOAL env auto-forwards; --goal overrides it
+scenario_init "scenario 21: CREWLY_AGENT_GOAL auto-forwards + --goal override"
+queue_response '{"success":true,"data":{}}'
+queue_response '{"success":true,"data":{}}'
+start_stub
+unset CREWLY_SESSION_NAME
+export CREWLY_AGENT_GOAL="Goal from env"
+"$SKILL" --action navigate --url https://x.com > /dev/null 2>&1 || true
+assert_eq "auto X-Agent-Goal from env" "Goal from env" "$(decode_goal "$(request_field 0 headers.X-Agent-Goal)")"
+"$SKILL" --action navigate --url https://y.com --goal "Override goal" > /dev/null 2>&1 || true
+assert_eq "--goal overrides env" "Override goal" "$(decode_goal "$(request_field 1 headers.X-Agent-Goal)")"
+unset CREWLY_AGENT_GOAL
+scenario_teardown
+
+# Scenario 22: a non-ASCII goal survives the header (base64-encoded)
+scenario_init "scenario 22: non-ASCII --goal round-trips"
+queue_response '{"success":true,"data":{}}'
+start_stub
+unset CREWLY_SESSION_NAME
+unset CREWLY_AGENT_GOAL 2>/dev/null || true
+"$SKILL" --action navigate --url https://x.com --goal "核对 DMARC 设置" > /dev/null 2>&1 || true
+assert_eq "non-ASCII goal decoded" "核对 DMARC 设置" "$(decode_goal "$(request_field 0 headers.X-Agent-Goal)")"
+scenario_teardown
+
 # ---------------------------------------------------------------------------
 # Summary
 # ---------------------------------------------------------------------------

package/config/skills/agent/screenshot-compare/execute.sh

@@ -50,7 +50,7 @@ fi
 # ── API key resolution ─────────────────────────────────────────────────────────
 if [ -z "${GEMINI_API_KEY:-}" ]; then
   # Try loading from settings via Crewly API
-  GEMINI_API_KEY=$(curl -sf "http://localhost:8787/api/settings" 2>/dev/null | jq -r '.data.apiKeys.global.gemini // empty' 2>/dev/null || true)
+  GEMINI_API_KEY=$(curl -sf "${CREWLY_API_URL:-http://localhost:${WEB_PORT:-8787}}/api/settings" 2>/dev/null | jq -r '.data.apiKeys.global.gemini // empty' 2>/dev/null || true)
 fi
 
 if [ -z "${GEMINI_API_KEY:-}" ]; then

package/config/skills/agent/transcribe-audio/SKILL.md

@@ -99,7 +99,7 @@ downstream consumers have a stable shape).
   - If the binary or model is missing, the skill falls back to OpenAI (or reports a clear hint when `engine:"local"` is forced).
 - **OpenAI engine** — needs an OpenAI API key. Resolution order:
   1. `OPENAI_API_KEY` environment variable (injected by Crewly secrets).
-  2. Crewly Settings → API Keys (`GET http://localhost:8787/api/settings` → `data.apiKeys.global.openai`).
+  2. Crewly Settings → API Keys (`GET $CREWLY_API_URL/api/settings` → `data.apiKeys.global.openai`).
   No key is ever hard-coded.
 
 ## Notes

package/config/skills/agent/transcribe-audio/execute.sh

@@ -24,7 +24,7 @@ FLOPOST_WHISPER_DIR="${HOME}/.flopost/whisper"
 WHISPER_CACHE_DIR="${HOME}/.cache/whisper-models"
 OPENAI_TRANSCRIBE_URL="https://api.openai.com/v1/audio/transcriptions"
 OPENAI_MODEL="whisper-1"
-SETTINGS_URL="http://localhost:8787/api/settings"
+SETTINGS_URL="${CREWLY_API_URL:-http://localhost:${WEB_PORT:-8787}}/api/settings"
 
 err_json() { printf '{"success":false,"error":%s}\n' "$(printf '%s' "$1" | jq -Rsa .)"; exit 1; }
 

package/config/skills/agent/transcribe-audio/instructions.md

@@ -81,7 +81,7 @@ downstream consumers have a stable shape).
   - If the binary or model is missing, the skill falls back to OpenAI (or reports a clear hint when `engine:"local"` is forced).
 - **OpenAI engine** — needs an OpenAI API key. Resolution order:
   1. `OPENAI_API_KEY` environment variable (injected by Crewly secrets).
-  2. Crewly Settings → API Keys (`GET http://localhost:8787/api/settings` → `data.apiKeys.global.openai`).
+  2. Crewly Settings → API Keys (`GET $CREWLY_API_URL/api/settings` → `data.apiKeys.global.openai`).
   No key is ever hard-coded.
 
 ## Notes

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

@@ -46,7 +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) |
+| `--request-id` / `-R` | `requestId` | No | Ticket (Request) this work is for — the id or `TKT-123` from the `[TICKET:TKT-123 <id>]` line of the message you are acting on. Links the WorkItem into `Request.workItemIds[]`. Omit it and the WorkItem is still linked when your current turn has exactly one ticket |
 | `--fallback-minutes` | — | No | Minutes until the ONE §3.0 fallback check fires for this delegation (default `120` ≈ 2× a TL milestone ETA). `0` disables it. Not cancelled on completion — keep it at 2× ETA, never a poll interval |
 
 ## Usage — CLI Flags (preferred)

package/config/skills/orchestrator/get-tasks/SKILL.md

@@ -50,4 +50,10 @@ The whole pool can be several MB.
 
 ## Output
 
-JSON with team task progress including assigned, completed, and blocked tasks.
+`{ success, stats, examined, matched, shown, workItems, hint }`.
+
+- `stats` — the pool's `/task-pool/stats` aggregate (totals by type/status).
+- `examined` — number of pool rows fetched before filtering (the whole pool).
+- `matched` / `shown` — rows that passed the filters, and how many of them are listed (`limit`).
+- `workItems` — the compact items described above.
+- If the item list could not be fetched or was not a list, the skill prints `success:false` with an `error` and exits 1 — an unknown list is never reported as an empty one.

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

@@ -23,19 +23,28 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../_common/lib.sh"
 
 INPUT=$(read_json_input "${1:-}" 2>/dev/null || echo '{}')
+# No argument and no stdin gives an empty string, not '{}'. Without this
+# default LIMIT came out empty, `--argjson limit ""` failed, and a bare
+# `get-tasks` reported "could not read the task pool".
+[ -n "${INPUT//[[:space:]]/}" ] || INPUT='{}'
 
 PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
 STATUS=$(printf '%s' "$INPUT" | jq -r '.status // empty')
 ALL=$(printf '%s' "$INPUT" | jq -r '.all // false')
-LIMIT=$(printf '%s' "$INPUT" | jq -r '.limit // 50')
+LIMIT=$(printf '%s' "$INPUT" | jq -r '(.limit // 50) | tonumber? // 50')
 TARGET=$(printf '%s' "$INPUT" | jq -r '.target // empty')
 
 STATS=$(api_call GET "/task-pool/stats" 2>/dev/null || echo '{"data":{}}')
 
-# The item list goes through a pipe, never argv, however large the pool is,
-# and bypasses the skill output cap — it is filtered down below, and a
-# truncation envelope in its place would read as "no work items".
-CREWLY_SKILL_MAX_OUTPUT_BYTES=0 api_call GET "/task-pool/items" 2>/dev/null \
+# The item list goes through a pipe, never argv, however large the pool is.
+# api_call_full bypasses the skill output cap (or reads the parked body); it
+# fails rather than hand back a truncation envelope that would read as "no
+# work items". An unknown list is reported as success:false and exit 1.
+if ! ITEMS=$(api_call_full GET "/task-pool/items" 2>/dev/null); then
+  ITEMS='{"data":null}'
+fi
+
+OUT=$(printf '%s' "$ITEMS" \
   | jq -c \
       --argjson stats "$STATS" \
       --arg projectPath "$PROJECT_PATH" \
@@ -45,26 +54,40 @@ CREWLY_SKILL_MAX_OUTPUT_BYTES=0 api_call GET "/task-pool/items" 2>/dev/null \
       --argjson limit "$LIMIT" \
       '
       def finished: ["done","verified","cancelled","failed","rejected"];
-      (.data // .workItems // []) as $items
-      | ($items
-          | map(select(
-              ($status == "" or (.status as $s | ($status | split(",") | index($s)) != null))
-              and ($all == "true" or $status != "" or ((.status as $s | finished | index($s)) == null))
-              and ($target == "" or .target == $target)
-            ))
-          | sort_by(.createdAt) | reverse) as $matched
-      | {
-          success: true,
-          projectPath: (if $projectPath == "" then null else $projectPath end),
-          stats: ($stats.data // $stats),
-          matched: ($matched | length),
-          shown: ([$matched | length, $limit] | min),
-          workItems: ($matched[:$limit] | map({
-            id, title, status, target,
-            createdAt,
-            blockedReason: (.blockedReason // null)
-          })),
-          hint: "Compact view: open items only, newest first. Finished ones: {\"all\":true}. One agent: {\"target\":\"<session>\"}."
-        }
-      ' \
-  || echo '{"success":false,"error":"could not read the task pool"}'
+      (.data // .workItems) as $raw
+      | if ($raw | type) != "array" then
+          {
+            success: false,
+            projectPath: (if $projectPath == "" then null else $projectPath end),
+            stats: ($stats.data // $stats),
+            examined: 0,
+            error: "GET /task-pool/items failed or did not return a list; workItems is UNKNOWN, not empty"
+          }
+        else
+          $raw as $items
+          | ($items
+              | map(select(
+                  ($status == "" or (.status as $s | ($status | split(",") | index($s)) != null))
+                  and ($all == "true" or $status != "" or ((.status as $s | finished | index($s)) == null))
+                  and ($target == "" or .target == $target)
+                ))
+              | sort_by(.createdAt) | reverse) as $matched
+          | {
+              success: true,
+              projectPath: (if $projectPath == "" then null else $projectPath end),
+              stats: ($stats.data // $stats),
+              examined: ($items | length),
+              matched: ($matched | length),
+              shown: ([$matched | length, $limit] | min),
+              workItems: ($matched[:$limit] | map({
+                id, title, status, target,
+                createdAt,
+                blockedReason: (.blockedReason // null)
+              })),
+              hint: "Compact view: open items only, newest first. Finished ones: {\"all\":true}. One agent: {\"target\":\"<session>\"}."
+            }
+        end
+      ') || OUT='{"success":false,"examined":0,"error":"could not read the task pool"}'
+printf '%s\n' "$OUT"
+# Exit non-zero when the item list is unknown, so callers cannot mistake it for empty.
+printf '%s' "$OUT" | jq -e '.success' >/dev/null

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

@@ -0,0 +1,67 @@
+#!/bin/bash
+# Tests for get-tasks — run with: bash execute.test.sh
+#
+# The pool is fetched whole (3.5 MB / 760 rows on a busy install) and reduced
+# here, so the skill must (a) report how many rows it examined, (b) print only
+# non-terminal items in compact form, and (c) fail loudly — never print
+# workItems: [] — when the list is unknown.
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PASS=0; FAIL=0
+check() { local name="$1"; local got="$2"; local want="$3"; if [ "$got" = "$want" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $name"; echo "  want: $want"; echo "  got:  $got"; fi; }
+
+TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT
+mkdir -p "$TMP/skills/orchestrator/get-tasks" "$TMP/skills/orchestrator/_common"
+cp "$HERE/execute.sh" "$TMP/skills/orchestrator/get-tasks/execute.sh"
+# Real lib.sh plus an api_call double, so the real api_call_full is exercised.
+REAL_LIB="$(cd "$HERE/../../_common" && pwd)/lib.sh"
+cat > "$TMP/skills/orchestrator/_common/lib.sh" <<'STUB'
+source "$REAL_LIB"
+api_call() {
+  case "$2" in
+    /task-pool/stats) printf '{"success":true,"data":{"total":4,"byStatus":{"verified":2,"running":1,"queued":1}}}' ;;
+    /task-pool/items) printf '%s' "$MOCK_ITEMS" ;;
+  esac
+}
+STUB
+
+run() {
+  CODE=0
+  OUT=$(env -u CREWLY_SESSION_NAME REAL_LIB="$REAL_LIB" MOCK_ITEMS="$1" bash "$TMP/skills/orchestrator/get-tasks/execute.sh" 2>/dev/null) || CODE=$?
+}
+
+ITEMS='{"success":true,"data":[
+ {"id":"w-1","type":"delegate","status":"verified","owner":"team_lead","target":"a","title":"old","briefMarkdown":"huge","createdAt":"t1"},
+ {"id":"w-2","type":"delegate","status":"running","owner":"team_lead","target":"b","title":"'"$(printf 'x%.0s' $(seq 1 200))"'","briefMarkdown":"huge","createdAt":"t2","startedAt":"t3"},
+ {"id":"w-3","type":"review","status":"queued","owner":"orchestrator","target":"c","title":"pending review","createdAt":"t4"},
+ {"id":"w-4","type":"delegate","status":"cancelled","owner":"team_lead","target":"d","title":"gone","createdAt":"t5"}]}'
+
+run "$ITEMS"
+check "exit 0" "$CODE" "0"
+check "success" "$(printf '%s' "$OUT" | jq -r '.success')" "true"
+check "examined = every row before filtering" "$(printf '%s' "$OUT" | jq -r '.examined')" "4"
+check "only open items are listed, newest first" "$(printf '%s' "$OUT" | jq -r '.workItems | map(.id) | join(",")')" "w-3,w-2"
+check "matched counts the open items" "$(printf '%s' "$OUT" | jq -r '.matched')" "2"
+check "items are compacted (no briefMarkdown)" "$(printf '%s' "$OUT" | jq -r '.workItems[0] | has("briefMarkdown")')" "false"
+check "stats passed through" "$(printf '%s' "$OUT" | jq -r '.stats.byStatus.running')" "1"
+check "no error field on success" "$(printf '%s' "$OUT" | jq -r 'has("error")')" "false"
+
+# A truncated envelope (parked file missing) must be an error, not an empty pool.
+run '{"truncated":true,"bytes":3487577,"file":"'"$TMP"'/nope.json","head":"","hint":"x"}'
+check "envelope -> exit 1" "$CODE" "1"
+check "envelope -> success:false" "$(printf '%s' "$OUT" | jq -r '.success')" "false"
+check "envelope -> examined 0, not a fake count" "$(printf '%s' "$OUT" | jq -r '.examined')" "0"
+check "envelope -> error says UNKNOWN" "$(printf '%s' "$OUT" | jq -r '.error' | grep -c UNKNOWN)" "1"
+
+# A body whose .data is not an array is likewise unknown.
+run '{"success":true,"data":{"oops":1}}'
+check "non-array -> exit 1" "$CODE" "1"
+check "non-array -> success:false with error" "$(printf '%s' "$OUT" | jq -r '.success, (.error|type)' | paste -sd, -)" "false,string"
+
+# An empty pool is a legitimate zero: success, examined 0, exit 0.
+run '{"success":true,"data":[]}'
+check "empty pool -> exit 0" "$CODE" "0"
+check "empty pool -> success with examined 0" "$(printf '%s' "$OUT" | jq -r '"\(.success)/\(.examined)/\(.workItems|length)"')" "true/0/0"
+
+echo "=== Results: $PASS passed, $FAIL failed ==="
+[ "$FAIL" -eq 0 ]

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

@@ -11,8 +11,8 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "$SCRIPT_DIR/../../_common/lib.sh"
 
 # Collect status from multiple endpoints (each call updates heartbeat via middleware)
-teams_response=$(api_call GET "/teams" 2>/dev/null) || teams_response='{"error":"unavailable"}'
-projects_response=$(api_call GET "/projects" 2>/dev/null) || projects_response='{"error":"unavailable"}'
+teams_response=$(api_call_full GET "/teams" 2>/dev/null) || teams_response='{"error":"unavailable"}'
+projects_response=$(api_call_full GET "/projects" 2>/dev/null) || projects_response='{"error":"unavailable"}'
 queue_response=$(api_call GET "/messaging/queue/status" 2>/dev/null) || queue_response='{"error":"unavailable"}'
 
 # Parse helpers:

package/config/skills/orchestrator/list-missions/execute.sh

@@ -13,7 +13,7 @@ for arg in "$@"; do
   esac
 done
 
-RAW=$(api_call GET "/missions") || exit 1
+RAW=$(api_call_full GET "/missions") || exit 1
 if [ "$FULL" = "true" ]; then printf '%s\n' "$RAW"; exit 0; fi
 
 printf '%s' "$RAW" | jq --arg pending "$PENDING" '

package/config/skills/orchestrator/list-missions/execute.test.sh

@@ -6,28 +6,55 @@ PASS=0; FAIL=0
 check() { local name="$1"; local got="$2"; local want="$3"; if [ "$got" = "$want" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $name"; echo "  want: $want"; echo "  got:  $got"; fi; }
 
 TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT
-# Stand-in for api_call: a shell function defined in a wrapper lib.
 mkdir -p "$TMP/skills/orchestrator/list-missions" "$TMP/skills/orchestrator/_common"
 cp "$HERE/execute.sh" "$TMP/skills/orchestrator/list-missions/execute.sh"
-cat > "$TMP/skills/orchestrator/_common/lib.sh" <<'EOF'
-api_call() {
-  cat <<'JSON'
-{"success":true,"data":[
+# The wrapper lib is the REAL lib.sh plus an api_call double, so the real
+# api_call_full is what the skill exercises (a passthrough stub would let an
+# envelope crash jq on both the fixed and the unfixed skill, guarding nothing).
+# The double returns $MOCK_RESPONSE when set, else the canned missions.
+REAL_LIB="$(cd "$HERE/../../_common" && pwd)/lib.sh"
+MISSIONS='{"success":true,"data":[
  {"id":"m-company","level":"company","objective":"Q4 stable delivery","status":"active","approval":{"state":"approved"},"keyResults":[]},
  {"id":"m-team","level":"team","objective":"Portal team flow","status":"active","approval":{"state":"pending_approval"},"parentMissionId":"m-company",
   "keyResults":[{"id":"k1","title":"KR1 review backlog","current":3,"target":2,"unit":"tickets","status":"on_track","measurementSource":"skill_output","measurements":[]}]}
-]}
-JSON
+]}'
+cat > "$TMP/skills/orchestrator/_common/lib.sh" <<'STUB'
+source "$REAL_LIB"
+api_call() { printf '%s' "${MOCK_RESPONSE:-$MISSIONS}"; }
+STUB
+export REAL_LIB MISSIONS
+
+run() {  # run [skill args...] -> CODE, OUT (stdout), ERR (stderr)
+  CODE=0
+  OUT=$(env -u CREWLY_SESSION_NAME bash "$TMP/skills/orchestrator/list-missions/execute.sh" "$@" 2>"$TMP/err") || CODE=$?
+  ERR=$(cat "$TMP/err")
 }
-EOF
-OUT=$(bash "$TMP/skills/orchestrator/list-missions/execute.sh")
+
+run
 check "count" "$(printf '%s' "$OUT" | jq '.count')" "2"
 check "pending count" "$(printf '%s' "$OUT" | jq '.pendingApproval')" "1"
 check "approval defaulted for legacy" "$(printf '%s' "$OUT" | jq -r '.missions[0].approval')" "approved"
 check "KR compacted" "$(printf '%s' "$OUT" | jq -c '.missions[1].keyResults[0]')" '{"title":"KR1 review backlog","current":3,"target":2,"unit":"tickets","status":"on_track","measurementSource":"skill_output"}'
-OUT=$(bash "$TMP/skills/orchestrator/list-missions/execute.sh" --pending)
+run --pending
 check "--pending filters" "$(printf '%s' "$OUT" | jq -r '.missions | map(.id) | join(",")')" "m-team"
-OUT=$(bash "$TMP/skills/orchestrator/list-missions/execute.sh" --full)
+run --full
 check "--full is raw" "$(printf '%s' "$OUT" | jq -r '.success')" "true"
+
+# --- Truncated envelope: the skill must not turn it into "no missions" -------
+# What api_call hands back when GET /missions is over the output cap. With the
+# parked file unreadable there is no way to get the rows: exit 1, print
+# nothing a caller could mistake for a list, and say why (explicit error field).
+ENVELOPE='{"truncated":true,"bytes":70000,"file":"'"$TMP"'/nonexistent.json","head":"{\"success\":true,\"data\":[{","hint":"pass --full or read the file"}'
+MOCK_RESPONSE="$ENVELOPE" run
+check "envelope, unreadable file -> exit 1 (not a jq crash, not 0)" "$CODE" "1"
+check "envelope, unreadable file -> no rows on stdout" "$OUT" ""
+check "envelope, unreadable file -> explicit truncated error on stderr" "$(printf '%s' "$ERR" | grep -c '"truncated":true')" "1"
+
+# With the parked file readable, the real rows are recovered from it.
+printf '%s' "$MISSIONS" > "$TMP/parked.json"
+MOCK_RESPONSE='{"truncated":true,"bytes":70000,"file":"'"$TMP"'/parked.json","head":"","hint":"x"}' run
+check "envelope, readable file -> exit 0" "$CODE" "0"
+check "envelope, readable file -> rows recovered from the parked file" "$(printf '%s' "$OUT" | jq -r '.count')" "2"
+
 echo "=== Results: $PASS passed, $FAIL failed ==="
 [ "$FAIL" -eq 0 ]

package/config/skills/team-leader/decompose-goal/SKILL.md

@@ -73,6 +73,7 @@ Where `/tmp/decompose.json` contains:
 | `objective` | Yes | The high-level objective being decomposed |
 | `projectPath` | No | Project path for task file creation |
 | `milestone` | No | Milestone folder name (default: `delegated`) |
+| `requestId` (or `--request-id <id>` after the JSON) | No | Ticket this work is for: the id (or `TKT-123`) from the `[TICKET:TKT-123 <id>]` line of the message you are acting on. Omit it and the task is still linked when your current turn has exactly one ticket; applied to every sub-task |
 | `tasks` | Yes | Array of sub-task objects |
 | `tasks[].title` | Yes | Sub-task title |
 | `tasks[].description` | Yes | Detailed task description |

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

@@ -9,13 +9,27 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../_common/lib.sh"
 
+# `--request-id <id|TKT-123>` links every sub-task to the ticket they are for
+# (the [TICKET:TKT-123 <id>] line of the message being worked on). Also
+# accepted as `"requestId"` in the JSON.
+REQUEST_ID=""
+POSITIONAL=()
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --request-id|-R) REQUEST_ID="${2:-}"; shift 2 ;;
+    *) POSITIONAL+=("$1"); shift ;;
+  esac
+done
+set -- "${POSITIONAL[@]+"${POSITIONAL[@]}"}"
+
 INPUT=$(read_json_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\"}]}'"
+[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"objective\":\"Build auth module\",\"projectPath\":\"/path/to/project\",\"requestId\":\"<ticket id, optional>\",\"tasks\":[{\"title\":\"...\",\"description\":\"...\",\"requiredRole\":\"developer\",\"acceptanceCriteria\":\"...\",\"priority\":\"high\"}]}' [--request-id <id>]"
 
 OBJECTIVE=$(printf '%s' "$INPUT" | jq -r '.objective // empty')
 PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
 TASKS=$(printf '%s' "$INPUT" | jq -c '.tasks // empty')
 MILESTONE=$(printf '%s' "$INPUT" | jq -r '.milestone // "delegated"')
+[ -z "$REQUEST_ID" ] && REQUEST_ID=$(printf '%s' "$INPUT" | jq -r '.requestId // empty')
 require_param "objective" "$OBJECTIVE"
 require_param "tasks" "$TASKS"
 
@@ -68,13 +82,14 @@ Required role: ${TASK_ROLE}"
     --arg milestone "$MILESTONE" \
     --arg role "$TASK_ROLE" \
     --arg priority "$TASK_PRIORITY" \
+    --arg requestId "$REQUEST_ID" \
     '{
       title: $title,
       type: "delegate",
       owner: "system",
       briefMarkdown: $brief,
       metadata: { projectPath: $projectPath, milestone: $milestone, requiredRole: $role, priority: $priority }
-    }')
+    } + (if $requestId != "" then {requestId: $requestId} else {} end)')
 
   # No envelope: addItem reads req.body directly as the CreateWorkItemInput.
   CREATE_BODY="$WORK_ITEM"

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

@@ -47,6 +47,7 @@ Assigns a task to a worker within the Team Leader's subordinate scope. Validates
 | `--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-id` / `-R` | `requestId` | No | Ticket this work is for: the id (or `TKT-123`) from the `[TICKET:TKT-123 <id>]` line of the message you are acting on. Omit it and the task is still linked when your current turn has exactly one ticket |
 
 ## Request Contract check
 

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

@@ -16,6 +16,7 @@ PROJECT_PATH=""
 TEAM_ID=""
 TL_MEMBER_ID=""
 FROM_SESSION=""
+REQUEST_ID=""
 
 # Detect legacy JSON argument
 if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
@@ -34,9 +35,10 @@ while [[ $# -gt 0 ]]; do
     --team|-g)     TEAM_ID="$2";        shift 2 ;;
     --tl-member)   TL_MEMBER_ID="$2";   shift 2 ;;
     --from)        FROM_SESSION="$2";   shift 2 ;;
+    --request-id|-R) REQUEST_ID="$2";   shift 2 ;;
     --json|-j)     INPUT_JSON="$2";     shift 2 ;;
     --help|-h)
-      echo "Usage: execute.sh --to worker-session --task 'implement feature' --priority high --project /path [--team teamId] [--tl-member memberId]"
+      echo "Usage: execute.sh --to worker-session --task 'implement feature' --priority high --project /path [--team teamId] [--tl-member memberId] [--request-id <ticket id from the [TICKET:TKT-123 <id>] line>]"
       exit 0
       ;;
     --)            shift; break ;;
@@ -72,6 +74,7 @@ if [ -n "$INPUT_JSON" ]; then
   [ -z "$TEAM_ID" ] && TEAM_ID=$(printf '%s' "$INPUT" | jq -r '.teamId // empty')
   [ -z "$TL_MEMBER_ID" ] && TL_MEMBER_ID=$(printf '%s' "$INPUT" | jq -r '.tlMemberId // empty')
   [ -z "$FROM_SESSION" ] && FROM_SESSION=$(printf '%s' "$INPUT" | jq -r '.fromSession // empty')
+  [ -z "$REQUEST_ID" ] && REQUEST_ID=$(printf '%s' "$INPUT" | jq -r '.requestId // empty')
 fi
 
 require_param "to (--to)" "$TO"
@@ -208,7 +211,8 @@ POOL_BODY=$(jq -n \
   --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))}')
+  --arg requestId "${REQUEST_ID:-}" \
+  '{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)')
 
 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)