crewly 1.20.364 → 1.20.366

package/config/roles/team-leader/prompt.md

@@ -120,6 +120,8 @@ Tickets marked *worker-created — review first* were filed by a team member: ch
 
 **Owner requests from Slack.** When the owner asks you something in Slack that a member can do, delegate it with `--thread <key>` (the key from `[SLACK-THREAD:<key>]`; in the Crewly chat, `--conversation <id>`). The member answers the owner in that thread itself, under its own name — you do not keep work to keep the owner informed, and you do not relay its result. A short "Sage is on it" from you is enough. Work you delegate on your own initiative gets no `--thread`: its result comes back to you, nothing reaches the owner, and you decide what the owner hears.
 
+**A new deliverable gets a new thread.** One thread holds one topic. When a finished deliverable is not what its thread is about (the owner asked for a PDF in a thread that held earlier videos), post it with `reply --new-thread "<title>"` and leave one line with the link in the old thread, so the owner never reads one deliverable as the answer to another.
+
 **Team work the orchestrator delegated for the owner: you report it.** When work the orchestrator handed your team for the owner is finished, you tell the owner — in your team channel, as yourself, not in the orchestrator's thread (the orchestrator does not relay it). You get an `[OWNER REPORT DUE]` message saying so. Post one or two plain lines in the owner's language: what the owner approved, the outcome with its link, and the link to the thread the approval came from — `reply --work-item <id> "<message>"`. No ticket ids, no status lines. When you hand such work to a member, the member does not post it to the owner; you do.
 
 **Execution nudge.** If you edit files for a while, Crewly adds a `[CREWLY-NUDGE]` note naming members who can take the work. Delegate, or record why you keep it (`--no-member-fits`).

package/config/skills/agent/core/attach-file/SKILL.md

@@ -47,6 +47,8 @@ backend resolves the Slack channel, the thread and your bot identity from it.
 | `--title` | no | Title shown above the file in Slack |
 | `--comment` | no | A line of text posted with the file |
 | `--thread` | no | The thread the file belongs to: the `[SLACK-THREAD:<key>]` key from your prompt, or the id `reply-channel` takes. **Pass it** when you have more than one thread going — without it the file follows the answer you just posted, else the oldest thread still waiting on you. |
+| `--work-item` | no | The work item the file delivers (the id in your `[CREWLY-DISPATCH]`). The file goes into the thread that work came from — use it when the work was delegated to you from a conversation you are not in. No `--channel` needed. |
+| `--ticket` / `--to` | no | The ticket, or the message id from your prompt, the file answers. No `--channel` needed. |
 
 ## When to use it
 
@@ -76,6 +78,11 @@ it to the owner if they ask why the name differs.
 
 ## Failures
 
+`{"success":false,"code":"thread_unresolved","error":"File NOT sent: …"}` —
+Crewly could not tell which thread the file answers. The file is **never**
+posted at the channel's top level instead: run it again with `--work-item <id>`
+(from your `[CREWLY-DISPATCH]`), `--to <message id>` or `--ticket <id>`.
+
 `{"success":false,"error":"not_a_slack_channel"}` — that chat channel is not
 mirrored to Slack. Nothing to attach to; reply with text.
 

package/config/skills/agent/core/attach-file/execute.sh

@@ -7,13 +7,14 @@
 #
 # Usage: execute.sh --channel <chatChannelId> --path <file> [--name <n>]
 #                   [--title <t>] [--comment <c>] [--thread <messageId>]
+#                   [--work-item <id>] [--ticket <id>] [--to <messageId>]
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=/dev/null
 source "$SCRIPT_DIR/../../../_common/lib.sh"
 
-CHANNEL=""; FILE_PATH=""; NAME=""; TITLE=""; COMMENT=""; THREAD=""; TICKET=""; TO=""
+CHANNEL=""; FILE_PATH=""; NAME=""; TITLE=""; COMMENT=""; THREAD=""; TICKET=""; TO=""; WORK_ITEM=""
 
 usage() {
   cat <<'USAGE'
@@ -27,6 +28,7 @@ attach-file — send a file into your Slack channel
   --thread <id>    The thread the file belongs to ([SLACK-THREAD:<key>] key, or a chat thread id)
   --ticket <id>    The ticket the file is for (TKT-187 / CE-7) — Crewly finds its thread (no --channel needed)
   --to <id>        The message the file answers (from your prompt) — no --channel needed
+  --work-item <id> The work item the file delivers ([CREWLY-DISPATCH] id) — Crewly posts it in that work's thread (no --channel needed)
 USAGE
 }
 
@@ -40,13 +42,14 @@ while [ $# -gt 0 ]; do
     --thread|-t)  THREAD="${2:-}"; shift 2 ;;
     --ticket)     TICKET="${2:-}"; shift 2 ;;
     --to)         TO="${2:-}"; shift 2 ;;
+    --work-item|--workitem) WORK_ITEM="${2:-}"; shift 2 ;;
     -h|--help)    usage; exit 0 ;;
     *) unknown_arg_exit "$1" ;;
   esac
 done
 
-if { [ -z "$CHANNEL" ] && [ -z "$TICKET" ] && [ -z "$TO" ]; } || [ -z "$FILE_PATH" ]; then
-  echo '{"error":"Missing required parameter: --path, and --channel (or --ticket / --to)"}' >&2
+if { [ -z "$CHANNEL" ] && [ -z "$TICKET" ] && [ -z "$TO" ] && [ -z "$WORK_ITEM" ]; } || [ -z "$FILE_PATH" ]; then
+  echo '{"error":"Missing required parameter: --path, and --channel (or --work-item / --ticket / --to)"}' >&2
   usage >&2
   exit 1
 fi
@@ -65,10 +68,12 @@ BODY=$(jq -cn \
   --arg threadId "$THREAD" \
   --arg ticket "$TICKET" \
   --arg to "$TO" \
+  --arg workItemId "$WORK_ITEM" \
   '{filePath: $filePath}
    + (if $channelId != "" then {channelId: $channelId} else {} end)
    + (if $ticket   != "" then {ticket: $ticket}     else {} end)
    + (if $to       != "" then {to: $to}             else {} end)
+   + (if $workItemId != "" then {workItemId: $workItemId} else {} end)
    + (if $filename != "" then {filename: $filename} else {} end)
    + (if $title    != "" then {title: $title}       else {} end)
    + (if $comment  != "" then {comment: $comment}   else {} end)

package/config/skills/agent/core/complete-task/SKILL.md

@@ -62,14 +62,16 @@ Resolution order:
 1. `workItemId`, if you pass it — always wins.
 2. Otherwise, ONLY when you named no task (no `workItemId`, no `taskId`): a lookup of the WorkItem currently `running` against your
    `sessionName` (`GET /api/task-pool/items?status=running&target=<session>`).
+   It is used only when exactly ONE item is running. With several, the skill
+   refuses (non-zero exit) and lists their ids: pass `workItemId` with one.
 3. If you passed `taskId` without `workItemId`, the skill
    refuses (non-zero exit): it never substitutes your running item for an id you named.
 4. If nothing resolves, the skill exits non-zero with an error naming the
    session it searched. It never reports success without completing something.
 
 Pass `workItemId` whenever you know it — the lookup in step 2 depends on the
-pool state at that instant and cannot disambiguate two concurrently running
-items for one session.
+pool state at that instant, and with two running items it refuses rather
+than guess.
 
 ## Evidence contract (#873)
 

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

@@ -138,9 +138,17 @@ fi
 if [ -z "$WORK_ITEM_ID" ] && [ -n "$TASK_ID" ]; then
   error_exit "Nothing was completed: you passed taskId '${TASK_ID}' but no 'workItemId', and this skill does not guess which WorkItem you meant. Pass 'workItemId' (find it with GET /api/task-pool/items?target=${SESSION_NAME}) and call again."
 fi
+# The pool lookup only stands in for an explicit id when exactly ONE WorkItem
+# is running: with several, picking the first closed the wrong one and sent
+# its result to the wrong place (message-routing audit 2026-10-18).
 if [ -z "$WORK_ITEM_ID" ]; then
   POOL_RESP=$(api_call_full GET "/task-pool/items?status=running&target=${SESSION_NAME}" 2>/dev/null || echo '{}')
-  WORK_ITEM_ID=$(echo "$POOL_RESP" | jq -r '.workItems[0].id // .data[0].id // empty' 2>/dev/null || true)
+  RUNNING_IDS=$(echo "$POOL_RESP" | jq -r '(.workItems // .data // [])[]?.id // empty' 2>/dev/null || true)
+  RUNNING_COUNT=$(printf '%s\n' "$RUNNING_IDS" | grep -c . || true)
+  if [ "${RUNNING_COUNT:-0}" -gt 1 ]; then
+    error_exit "Nothing was completed: ${RUNNING_COUNT} WorkItems are running for '${SESSION_NAME}' ($(printf '%s' "$RUNNING_IDS" | tr '\n' ' ' | sed 's/ *$//')) and this skill does not guess which one you finished. Pass 'workItemId' with one of them and call again."
+  fi
+  WORK_ITEM_ID=$(printf '%s\n' "$RUNNING_IDS" | head -n1)
 fi
 
 # Neither an explicit `workItemId` nor the pool lookup produced a target.

package/config/skills/agent/core/complete-task/explicit-id.test.sh

@@ -10,6 +10,8 @@ check() {
 
 PORT=18854
 STUB_LOG="$(mktemp)"; export STUB_LOG; export STUB_PORT="$PORT"
+STUB_RUNNING="$(mktemp)"; export STUB_RUNNING
+echo 'wi-running' > "$STUB_RUNNING"
 : > "$STUB_LOG"
 python3 -u <<'PY' >/dev/null 2>&1 &
 from http.server import BaseHTTPRequestHandler, HTTPServer
@@ -23,7 +25,8 @@ class H(BaseHTTPRequestHandler):
         open(LOG, 'a').write(self.command + ' ' + self.path + '\n')
     def do_GET(self):
         self.note()
-        return self.reply(200, {'workItems': [{'id': 'wi-running'}]})
+        ids = [l.strip() for l in open(os.environ['STUB_RUNNING']) if l.strip()]
+        return self.reply(200, {'workItems': [{'id': i} for i in ids]})
     def do_POST(self):
         n = int(self.headers.get('content-length', '0')); self.rfile.read(n)
         self.note()
@@ -33,7 +36,7 @@ HTTPServer(('127.0.0.1', PORT), H).serve_forever()
 PY
 STUB_PID=$!
 disown "$STUB_PID" 2>/dev/null || true
-trap 'kill "$STUB_PID" >/dev/null 2>&1; rm -f "$STUB_LOG"' EXIT
+trap 'kill "$STUB_PID" >/dev/null 2>&1; rm -f "$STUB_LOG" "$STUB_RUNNING"' EXIT
 for i in $(seq 1 30); do curl -s -o /dev/null -m 0.2 "http://127.0.0.1:${PORT}/" 2>/dev/null && break; sleep 0.1; done
 
 run() { CREWLY_SESSION_NAME=dev-1 CREWLY_API_URL="http://127.0.0.1:${PORT}" bash "$EXEC" "$1" 2>&1; echo "exit=$?"; }
@@ -52,5 +55,13 @@ check "explicit workItemId: completes exactly that one" "$(grep -v heartbeat "$S
 run '{"sessionName":"dev-1","summary":"done"}' >/dev/null
 check "no id at all: running-item lookup still works" "$(tail -1 "$STUB_LOG")" "POST /api/task-pool/complete/wi-running"
 
+# Several running items: no `[0]` pick (message-routing audit 2026-10-18).
+printf 'wi-a\nwi-b\n' > "$STUB_RUNNING"
+: > "$STUB_LOG"
+OUT=$(run '{"sessionName":"dev-1","summary":"done"}')
+check "two running, no id: refused" "$(printf '%s' "$OUT" | grep -c 'exit=1')" "1"
+check "two running, no id: lists both ids" "$(printf '%s' "$OUT" | grep -c 'wi-a wi-b')" "1"
+check "two running, no id: nothing completed" "$(grep -c 'POST /api/task-pool/complete' "$STUB_LOG")" "0"
+
 echo "complete-task: $PASS passed, $FAIL failed"
 [ "$FAIL" -eq 0 ]

package/config/skills/agent/core/create-task/SKILL.md

@@ -52,6 +52,8 @@ Create a new task via the `/api/task-management/create` endpoint. This allows te
 | `--owner` | `owner` | No | Responsible role: `orchestrator`, `team_lead`, `agent` (default), `system`. A role, not a session name — use `--session` for the session |
 | `--description` / `-d` | `description` | No | Short summary of the task |
 | `--brief` | `briefMarkdown` | No | Long-form brief in markdown. Inline text, or `@/path/to/file.md`. Max 16384 bytes |
+| `--thread` | `thread` | No | Owner thread the task answers: the Slack thread key from your prompt. A task you assign to yourself inherits no owner thread from your last turn — name it here when the owner should get its result |
+| `--conversation` | `conversation` | No | Owner conversation the task answers (chat-v2 id) |
 | `--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 |
 
 ### Always attach a brief

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

@@ -32,6 +32,10 @@ Options:
                         Should carry Goal + Expected Outcome + Eval Criteria. Max 16384 bytes.
   --request-id   | -R   Ticket this task is for: the id (or TKT-123) from the
                         [TICKET:TKT-123 <id>] line of the message you are working on
+  --thread             Owner thread the task answers (Slack thread key from your
+                        prompt). A task you assign to yourself inherits no owner
+                        thread: name it here, or its result goes nowhere public
+  --conversation       Owner conversation the task answers (chat-v2 id)
   --json         | -j   Raw JSON payload (same as legacy)
   --help         | -h   Show this help
 EOF_USAGE
@@ -48,6 +52,8 @@ OWNER=""
 DESCRIPTION=""
 BRIEF=""
 REQUEST_ID=""
+OWNER_THREAD=""
+OWNER_CONVERSATION=""
 
 # Detect legacy JSON argument
 if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
@@ -97,6 +103,14 @@ while [[ $# -gt 0 ]]; do
       REQUEST_ID="$2"
       shift 2
       ;;
+    --thread)
+      OWNER_THREAD="$2"
+      shift 2
+      ;;
+    --conversation)
+      OWNER_CONVERSATION="$2"
+      shift 2
+      ;;
     --json|-j)
       INPUT_JSON="$2"
       shift 2
@@ -141,6 +155,8 @@ if [ -n "$INPUT_JSON" ]; then
   [ -z "$DESCRIPTION" ] && DESCRIPTION=$(printf '%s' "$INPUT" | jq -r '.description // empty')
   [ -z "$BRIEF" ] && BRIEF=$(printf '%s' "$INPUT" | jq -r '.briefMarkdown // .brief // empty')
   [ -z "$REQUEST_ID" ] && REQUEST_ID=$(printf '%s' "$INPUT" | jq -r '.requestId // empty')
+  [ -z "$OWNER_THREAD" ] && OWNER_THREAD=$(printf '%s' "$INPUT" | jq -r '.thread // .ownerThread // empty')
+  [ -z "$OWNER_CONVERSATION" ] && OWNER_CONVERSATION=$(printf '%s' "$INPUT" | jq -r '.conversation // .conversationId // .ownerConversation // empty')
 fi
 
 # Apply defaults
@@ -212,12 +228,16 @@ WORK_ITEM=$(jq -n \
   --arg description "$DESCRIPTION" \
   --arg briefMarkdown "$BRIEF" \
   --arg requestId "$REQUEST_ID" \
+  --arg ownerThread "$OWNER_THREAD" \
+  --arg ownerConversation "$OWNER_CONVERSATION" \
   '{
     title: $title,
     type: "delegate",
     owner: $owner,
     target: (if $target == "" then null else $target end),
-    metadata: { projectPath: $projectPath, milestone: $milestone, priority: $priority }
+    metadata: ({ projectPath: $projectPath, milestone: $milestone, priority: $priority }
+      + (if $ownerThread != "" then {ownerThread: $ownerThread} else {} end)
+      + (if $ownerConversation != "" then {ownerConversation: $ownerConversation} else {} end))
   }
   + (if $description != "" then {description: $description} else {} end)
   + (if $briefMarkdown != "" then {briefMarkdown: $briefMarkdown} else {} end)
@@ -228,4 +248,10 @@ if [ -n "$OUTPUT_SCHEMA" ] && [ "$OUTPUT_SCHEMA" != "" ]; then
   WORK_ITEM=$(printf '%s' "$WORK_ITEM" | jq --argjson schema "$OUTPUT_SCHEMA" '.metadata += {outputSchema: $schema}')
 fi
 
+# A task with no owner place answers no owner thread: say so (message-routing
+# audit 2026-10-18: a self-assigned task no longer borrows your last one).
+if [ -z "$OWNER_THREAD" ] && [ -z "$OWNER_CONVERSATION" ] && [ -z "$REQUEST_ID" ]; then
+  echo "Note: no --thread / --conversation given — this task answers no owner thread unless it is delegated from your current work. Pass --thread <key> to tie it to the owner's request." >&2
+fi
+
 api_call POST "/task-pool/add" "$WORK_ITEM"

package/config/skills/agent/core/create-task/execute.test.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+# Tests for create-task carrying the owner place it is given (--thread / --conversation)
+# and saying so when it is given none (message-routing audit 2026-10-18) — run with: bash execute.test.sh
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+EXEC="$HERE/execute.sh"
+PASS=0; FAIL=0
+check() {
+  if [ "$2" = "$3" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1"; echo "  want: $3"; echo "  got:  $2"; fi
+}
+
+PORT=18856
+STUB_LOG="$(mktemp)"; export STUB_LOG; export STUB_PORT="$PORT"
+STUB_BODIES="$(mktemp)"; export STUB_BODIES
+STUB_RUNNING="$(mktemp)"; export STUB_RUNNING
+python3 -u <<'PY' >/dev/null 2>&1 &
+from http.server import BaseHTTPRequestHandler, HTTPServer
+import json, os
+LOG = os.environ['STUB_LOG']; PORT = int(os.environ['STUB_PORT'])
+class H(BaseHTTPRequestHandler):
+    def reply(self, code, obj):
+        self.send_response(code); self.send_header('Content-Type', 'application/json'); self.end_headers()
+        self.wfile.write(json.dumps(obj).encode())
+    def note(self, body=''):
+        open(LOG, 'a').write(self.command + ' ' + self.path + '\n')
+        if body:
+            try: body = json.dumps(json.loads(body), separators=(',', ':'))
+            except Exception: body = body.replace('\n', ' ')
+            open(os.environ['STUB_BODIES'], 'a').write(self.path + ' ' + body + '\n')
+    def do_GET(self):
+        self.note()
+        ids = [l.strip() for l in open(os.environ['STUB_RUNNING']) if l.strip()]
+        return self.reply(200, {'workItems': [{'id': i} for i in ids]})
+    def do_POST(self):
+        n = int(self.headers.get('content-length', '0')); body = self.rfile.read(n).decode()
+        self.note(body)
+        return self.reply(200, {'success': True})
+    def log_message(self, *a, **k): pass
+HTTPServer(('127.0.0.1', PORT), H).serve_forever()
+PY
+STUB_PID=$!
+disown "$STUB_PID" 2>/dev/null || true
+trap 'kill "$STUB_PID" >/dev/null 2>&1; rm -f "$STUB_LOG" "$STUB_BODIES" "$STUB_RUNNING"' EXIT
+for i in $(seq 1 30); do curl -s -o /dev/null -m 0.2 "http://127.0.0.1:${PORT}/" 2>/dev/null && break; sleep 0.1; done
+
+run() { CREWLY_SESSION_NAME=dev-1 CREWLY_API_URL="http://127.0.0.1:${PORT}" bash "$EXEC" "$1" 2>&1; echo "exit=$?"; }
+reset() { : > "$STUB_LOG"; : > "$STUB_BODIES"; }
+
+: > "$STUB_RUNNING"
+
+reset
+OUT=$(run '{"projectPath":"/tmp/p","task":"Write the report","sessionName":"dev-1","thread":"C0A:1.2"}')
+check "--thread: stored as metadata.ownerThread" "$(grep '/task-pool/add' "$STUB_BODIES" | grep -c '"ownerThread":"C0A:1.2"')" "1"
+check "--thread: no note" "$(printf '%s' "$OUT" | grep -c 'answers no owner thread')" "0"
+
+reset
+CREWLY_SESSION_NAME=dev-1 CREWLY_API_URL="http://127.0.0.1:${PORT}" bash "$EXEC" --project-path /tmp/p --task "Write it" --session dev-1 --conversation room-1 >/dev/null 2>&1
+check "--conversation flag: stored as metadata.ownerConversation" "$(grep '/task-pool/add' "$STUB_BODIES" | grep -c '"ownerConversation":"room-1"')" "1"
+
+reset
+OUT=$(run '{"projectPath":"/tmp/p","task":"Write the report","sessionName":"dev-1"}')
+check "no owner place: still created" "$(grep -c 'POST /api/task-pool/add' "$STUB_LOG")" "1"
+check "no owner place: says it answers no owner thread" "$(printf '%s' "$OUT" | grep -c 'answers no owner thread')" "1"
+check "no owner place: no owner fields sent" "$(grep '/task-pool/add' "$STUB_BODIES" | grep -c 'ownerThread\|ownerConversation')" "0"
+
+echo "create-task: $PASS passed, $FAIL failed"
+[ "$FAIL" -eq 0 ]

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

@@ -54,10 +54,17 @@ CREWLY_ROOT="$(cd "${SCRIPT_DIR}/../../../.." && pwd)"
 TIMESTAMP="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 
 # --- Step 0: Resolve target WorkItem if not supplied ---
-# Resolve order: explicit workItemId > the agent's currently-running claim.
+# Resolve order: explicit workItemId > the agent's ONE running claim. With
+# several running, the first one was handed over (and its owner thread with
+# it) — this skill no longer guesses (message-routing audit 2026-10-18).
 if [ -z "$WORK_ITEM_ID" ]; then
   POOL_RESP=$(api_call_full GET "/task-pool/items?status=running&target=${SESSION_NAME}" 2>/dev/null || echo '{}')
-  WORK_ITEM_ID=$(echo "$POOL_RESP" | jq -r '.workItems[0].id // .data[0].id // empty' 2>/dev/null || true)
+  RUNNING_IDS=$(echo "$POOL_RESP" | jq -r '(.workItems // .data // [])[]?.id // empty' 2>/dev/null || true)
+  RUNNING_COUNT=$(printf '%s\n' "$RUNNING_IDS" | grep -c . || true)
+  if [ "${RUNNING_COUNT:-0}" -gt 1 ]; then
+    error_exit "Nothing was handed off: ${RUNNING_COUNT} WorkItems are running for '${SESSION_NAME}' ($(printf '%s' "$RUNNING_IDS" | tr '\n' ' ' | sed 's/ *$//')) and this skill does not guess which one you mean. Pass 'workItemId' with one of them and call again."
+  fi
+  WORK_ITEM_ID=$(printf '%s\n' "$RUNNING_IDS" | head -n1)
 fi
 
 # --- Step 1: Fission guard check (rate limit before handoff) ---
@@ -101,7 +108,7 @@ HANDOFF_MSG_FILE=$(mktemp)
 trap 'rm -f "$HANDOFF_MSG_FILE"' EXIT
 
 cat > "$HANDOFF_MSG_FILE" << MSG_EOF
-[TASK HANDOFF] from ${SESSION_NAME}
+[TASK HANDOFF] from ${SESSION_NAME}${WORK_ITEM_ID:+ — WorkItem: ${WORK_ITEM_ID} {route: work-item ${WORK_ITEM_ID}}}
 
 ## Reason for Handoff
 ${REASON}
@@ -157,8 +164,8 @@ deliver_result=$(api_call POST "/terminal/${TO}/write" "$DELIVER_BODY" 2>/dev/nu
 
 # --- Step 4: Notify orchestrator/TL about the handoff ---
 NOTIFY_MSG="[HANDOFF] ${SESSION_NAME} → ${TO}: ${REASON}"
-NOTIFY_BODY=$(jq -n --arg content "$NOTIFY_MSG" --arg senderName "$SESSION_NAME" \
-  '{content: $content, senderName: $senderName, senderType: "agent"}')
+NOTIFY_BODY=$(jq -n --arg content "$NOTIFY_MSG" --arg senderName "$SESSION_NAME" --arg workItemId "${WORK_ITEM_ID:-}" \
+  '{content: $content, senderName: $senderName, senderType: "agent"} + (if $workItemId == "" then {} else {workItemId: $workItemId} end)')
 api_call POST "/chat/agent-response" "$NOTIFY_BODY" >/dev/null 2>&1 || true
 
 # --- Step 5: Output result as safe JSON ---

package/config/skills/agent/core/handoff-task/explicit-id.test.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+# Tests for handoff-task naming its WorkItem and never guessing among several
+# running ones (message-routing audit 2026-10-18) — run with: bash explicit-id.test.sh
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+EXEC="$HERE/execute.sh"
+PASS=0; FAIL=0
+check() {
+  if [ "$2" = "$3" ]; then PASS=$((PASS+1)); else FAIL=$((FAIL+1)); echo "FAIL: $1"; echo "  want: $3"; echo "  got:  $2"; fi
+}
+
+PORT=18855
+STUB_LOG="$(mktemp)"; export STUB_LOG; export STUB_PORT="$PORT"
+STUB_BODIES="$(mktemp)"; export STUB_BODIES
+STUB_RUNNING="$(mktemp)"; export STUB_RUNNING
+python3 -u <<'PY' >/dev/null 2>&1 &
+from http.server import BaseHTTPRequestHandler, HTTPServer
+import json, os
+LOG = os.environ['STUB_LOG']; PORT = int(os.environ['STUB_PORT'])
+class H(BaseHTTPRequestHandler):
+    def reply(self, code, obj):
+        self.send_response(code); self.send_header('Content-Type', 'application/json'); self.end_headers()
+        self.wfile.write(json.dumps(obj).encode())
+    def note(self, body=''):
+        open(LOG, 'a').write(self.command + ' ' + self.path + '\n')
+        if body:
+            try: body = json.dumps(json.loads(body), separators=(',', ':'))
+            except Exception: body = body.replace('\n', ' ')
+            open(os.environ['STUB_BODIES'], 'a').write(self.path + ' ' + body + '\n')
+    def do_GET(self):
+        self.note()
+        ids = [l.strip() for l in open(os.environ['STUB_RUNNING']) if l.strip()]
+        return self.reply(200, {'workItems': [{'id': i} for i in ids]})
+    def do_POST(self):
+        n = int(self.headers.get('content-length', '0')); body = self.rfile.read(n).decode()
+        self.note(body)
+        return self.reply(200, {'success': True})
+    def log_message(self, *a, **k): pass
+HTTPServer(('127.0.0.1', PORT), H).serve_forever()
+PY
+STUB_PID=$!
+disown "$STUB_PID" 2>/dev/null || true
+trap 'kill "$STUB_PID" >/dev/null 2>&1; rm -f "$STUB_LOG" "$STUB_BODIES" "$STUB_RUNNING"' EXIT
+for i in $(seq 1 30); do curl -s -o /dev/null -m 0.2 "http://127.0.0.1:${PORT}/" 2>/dev/null && break; sleep 0.1; done
+
+run() { CREWLY_SESSION_NAME=dev-1 CREWLY_API_URL="http://127.0.0.1:${PORT}" bash "$EXEC" "$1" 2>&1; echo "exit=$?"; }
+reset() { : > "$STUB_LOG"; : > "$STUB_BODIES"; }
+
+# Several running items and no id: refused, nothing handed over.
+printf 'wi-a\nwi-b\n' > "$STUB_RUNNING"; reset
+OUT=$(run '{"sessionName":"dev-1","to":"dev-2","reason":"swap"}')
+check "two running, no id: refused" "$(printf '%s' "$OUT" | grep -c 'exit=1')" "1"
+check "two running, no id: lists both ids" "$(printf '%s' "$OUT" | grep -c 'wi-a wi-b')" "1"
+check "two running, no id: nothing delivered" "$(grep -c '/terminal/' "$STUB_LOG")" "0"
+
+# An explicit id: the hand-over text carries it and its route; the notice names it.
+reset
+run '{"sessionName":"dev-1","to":"dev-2","reason":"swap","workItemId":"wi-b"}' >/dev/null
+check "explicit id: hand-over names the WorkItem and its route" \
+  "$(grep '/terminal/dev-2' "$STUB_BODIES" | grep -c 'WorkItem: wi-b {route: work-item wi-b}')" "1"
+check "explicit id: [HANDOFF] notice carries the workItemId" \
+  "$(grep '/chat/agent-response' "$STUB_BODIES" | grep -c '"workItemId":"wi-b"')" "1"
+
+# One running item, no id: that one is used.
+printf 'wi-only\n' > "$STUB_RUNNING"; reset
+run '{"sessionName":"dev-1","to":"dev-2","reason":"swap"}' >/dev/null
+check "one running, no id: hands over that one" "$(grep -c 'POST /api/task-pool/items/wi-only/handoff' "$STUB_LOG")" "1"
+
+echo "handoff-task: $PASS passed, $FAIL failed"
+[ "$FAIL" -eq 0 ]

package/config/skills/agent/core/reply/SKILL.md

@@ -51,6 +51,7 @@ work came from:
 | Your current work | Where the answer goes |
 |---|---|
 | a message from the owner | that conversation / Slack thread (DM, channel thread, Crewly chat / portal) |
+| a message from another agent (`[MESSAGE from <name> … send-message --to <session>]`) | back to that agent, agent-to-agent — never the owner's thread |
 | a project ticket | the ticket's thread in your team channel (started on the first post) |
 | a scheduled / triggered task | the trigger's destination, else a NEW top-level post in your team channel |
 | nothing in particular | a new top-level post in your team channel |
@@ -79,8 +80,15 @@ bash config/skills/agent/core/reply/execute.sh --decision D-12 "Going with optio
 Order the harness uses: the message you name → the ticket's thread (request
 ticket `TKT-…` or project ticket like `CE-7`) → the work item's origin → ids
 you passed (only if they name a conversation you are in, and a thread key's
-channel matches) → what the harness last prompted you about → where your
-current turn came from → your DM with the owner.
+channel matches) → the agent whose message is the latest thing you got →
+what the harness last prompted you about → where your current turn came
+from → your DM with the owner.
+
+When a bare reply could mean two places — another agent's message came in
+but you also owe the owner an answer, or a dispatch arrived after the
+owner's message — nothing is sent: you get `success: false` and both
+commands (`send-message --to <agent> …` or `reply --conversation <id> …`).
+Run the one you mean.
 
 To start a new topic yourself:
 

package/config/skills/agent/core/reply-channel/SKILL.md

@@ -56,6 +56,11 @@ a `[SLACK-THREAD:<key>]` tag in your prompt — the reply lands in exactly that
 thread. Answer each thread in its own thread; never bundle answers for
 different threads into one message.
 
+In a Slack team channel a post with no `--thread` is refused
+(`409 thread_required`): it is never put at the channel's top level by
+itself. Pass the thread from your prompt; use `send-message` to reach a
+colleague; pass `--new-thread` only for a deliberate new top-level post.
+
 To post in a **Crewly channel** you are a member of (a room shared with
 agents of other teams — `list-channels` shows yours), pass its name with a
 `#`, or its id:
@@ -155,6 +160,18 @@ On failure prints `{"success":false, "error":"..."}` to stdout and exits
 with a non-zero code.
 
 
+## Messages from other agents do not go in the owner's thread
+
+A message from another agent arrives as `[MESSAGE from <name> (<team>) — a
+colleague, not the owner. Answer with send-message --to <session>; …]`.
+Answer it with `send-message --to <session>`. Agents never talk to each
+other in the owner's thread: a post into it that only @-mentions agents is
+not posted. It is delivered privately to the agents it @-mentions (the
+skill prints `"posted":false,"deliveredPrivately":true,"to":[…]`), or, when
+that is not possible, refused (`409 agent_mention_in_owner_thread`) with the
+send-message command to run instead. Post in the owner's thread only your
+final answer to the owner, without the @-mention.
+
 ## What not to put in a channel
 
 A team channel is public — everyone in the workspace can read it. When your

package/config/skills/agent/core/reply-channel/execute.sh

@@ -40,6 +40,9 @@ Options:
                      "<you> is working on it…" in the Slack thread, which your
                      real reply then replaces. Use it when a message was only
                      passed to you to judge, and you have decided to answer.
+  --new-thread       A deliberate new top-level post in a Slack team room. Without
+                     --thread or --new-thread such a post is refused there
+                     (409 thread_required), never put at the top level silently.
   --adds-new         Post even though the agent chosen to answer the owner
                      already replied in this thread -- when you have something
                      new, or when you were asked (without it such a post is
@@ -66,6 +69,7 @@ WORKING=""
 HANDOFF=""
 MESSAGE_REF=""
 ADDS_NEW=""
+NEW_THREAD=""
 FILES_JSON="[]"
 
 # Detect legacy JSON argument as $1
@@ -92,6 +96,10 @@ while [[ $# -gt 0 ]]; do
       ADDS_NEW="1"
       shift
       ;;
+    --new-thread)
+      NEW_THREAD="1"
+      shift
+      ;;
     --handoff)
       HANDOFF="$2"
       shift 2
@@ -252,7 +260,7 @@ fi
 # Build JSON body. Export CONTENT/CMID so python can read them safely without
 # quoting the values through the shell (avoids escaping hell for multi-line
 # content with quotes, backslashes, backticks, etc.).
-BODY=$(CONTENT="$CONTENT" CMID="$CMID" THREAD_ID="$THREAD_ID" INTERIM="${INTERIM:-}" ADDS_NEW="$ADDS_NEW" FILES_JSON="$FILES_JSON" PROJECT_PATH="${CREWLY_PROJECT_PATH:-$PWD}" python3 -c '
+BODY=$(CONTENT="$CONTENT" CMID="$CMID" THREAD_ID="$THREAD_ID" INTERIM="${INTERIM:-}" ADDS_NEW="$ADDS_NEW" NEW_THREAD="$NEW_THREAD" FILES_JSON="$FILES_JSON" PROJECT_PATH="${CREWLY_PROJECT_PATH:-$PWD}" python3 -c '
 import os, json
 p = {"content": os.environ["CONTENT"], "contentType": "markdown"}
 files = json.loads(os.environ.get("FILES_JSON", "[]"))
@@ -264,6 +272,8 @@ if os.environ.get("INTERIM"):
     p["interim"] = True
 if os.environ.get("ADDS_NEW"):
     p["addsNew"] = True
+if os.environ.get("NEW_THREAD"):
+    p["newThread"] = True
 cmid = os.environ.get("CMID", "")
 if cmid:
     p["clientMessageId"] = cmid
@@ -285,7 +295,12 @@ try:
 except Exception:
     print(json.dumps({"success": True, "channelId": os.environ["CHANNEL_ID"], "raw": raw}, separators=(",", ":")))
     raise SystemExit(0)
-mid = (d.get("data") or {}).get("id", "")
+data = d.get("data") or {}
+if data.get("deliveredPrivately"):
+    # R6: an agents-only post never lands in the owner thread; it went to the agents.
+    print(json.dumps({"success": True, "posted": False, "deliveredPrivately": True, "to": data.get("to", []), "note": data.get("note", "")}, separators=(",", ":"), ensure_ascii=False))
+    raise SystemExit(0)
+mid = data.get("id", "")
 out = {"success": True}
 if mid:
     out["messageId"] = mid

package/config/skills/agent/core/reply-channel/execute.test.sh

@@ -42,10 +42,16 @@ class H(BaseHTTPRequestHandler):
         }
         with open(LOG_PATH, 'w') as f:
             f.write(json.dumps(log))
-        self.send_response(201)
+        if '@Atlas' in body:
+            # R6: an agents-only post in an owner thread goes to the agent privately.
+            self.send_response(200)
+            reply = {'success': True, 'data': {'deliveredPrivately': True, 'to': ['tt-atlas-1'], 'note': 'Not posted in the owner thread'}}
+        else:
+            self.send_response(201)
+            reply = {'success': True, 'data': {'id': 'm-stub-123', 'channelId': 'chan-xyz'}}
         self.send_header('Content-Type', 'application/json')
         self.end_headers()
-        self.wfile.write(json.dumps({'success': True, 'data': {'id': 'm-stub-123', 'channelId': 'chan-xyz'}}).encode('utf-8'))
+        self.wfile.write(json.dumps(reply).encode('utf-8'))
     def do_GET(self):
         # Channel lookup by name (reply-channel --channel '#name').
         if self.path.startswith('/api/channels/%23tech-brief'):
@@ -198,6 +204,13 @@ else
   PASS=$((PASS + 1)); echo "  ✓ a plain reply carries no files list"
 fi
 
+echo "test: an agents-only post delivered privately says it was not posted (R6)"
+: > "$STUB_LOG"
+OUT=$(run_skill --channel chan-xyz --content "@Atlas the numbers" 2>&1 || true)
+assert_contains "reports posted:false" "$OUT" '"posted":false'
+assert_contains "reports deliveredPrivately" "$OUT" '"deliveredPrivately":true'
+assert_contains "names the agent it went to" "$OUT" 'tt-atlas-1'
+
 echo
 echo "========================================"
 echo "reply-channel skill: PASS=$PASS  FAIL=$FAIL"

package/config/skills/agent/core/send-message/SKILL.md

@@ -87,6 +87,20 @@ recipient has hit its daily token cap: the message waits and is delivered
 automatically when the cap resets at midnight or the owner boosts it. Do not
 resend a queued message.
 
+## What the recipient sees
+
+Your message arrives with one header line naming you and how to answer:
+
+```
+[MESSAGE from Atlas (Think Tank) — a colleague, not the owner. Answer with send-message --to think-tank-atlas-b4e166f6; do not post it in an owner thread.]
+Thanks. Two things. …
+```
+
+When you receive such a message, answer it with `send-message --to <that
+session>` (a bare `reply` also goes back to that agent). Never answer it in
+the owner's thread with `reply-channel "@Name …"`: the owner would read a
+conversation that is not for them, and the harness refuses that post.
+
 ## Paused teams
 
 The owner can pause a team temporarily (specs/2026-10-04-team-pause.md). A

package/config/skills/agent/core/slack-post/SKILL.md

@@ -59,7 +59,7 @@ reply in the same Slack thread.
 
 ```bash
 bash config/skills/agent/core/slack-post/execute.sh \
-  --target "#general" \
+  --target "#general" --new-topic \
   --text "Deploy finished, staging is on 1.4.2."
 ```
 
@@ -71,7 +71,7 @@ bash config/skills/agent/core/slack-post/execute.sh --target "@steve" --text "..
 bash config/skills/agent/core/slack-post/execute.sh --target C0123ABCD --thread 1712345678.000100 --text "..."
 
 # Long text from a file, or piped
-bash .../execute.sh --target "#general" --text-file /tmp/report.md
+bash .../execute.sh --target "#general" --new-topic --text-file /tmp/report.md
 echo "..." | bash .../execute.sh --target "@steve"
 ```
 
@@ -111,7 +111,7 @@ two are told apart. Write ids exactly as Slack shows them.
 | `--text` | `-m` | Message text (required unless piped or `--text-file`) |
 | `--text-file` | | Read the text from a file |
 | `--thread` | `-t` | Slack thread timestamp to reply inside, or the `[SLACK-THREAD:<key>]` key from your prompt |
-| `--new-topic` | | A new top-level message. Use it for scheduled output (a briefing, a triage summary): without it, a post into a conversation where you still owe an answer from the last 30 minutes goes into that thread as the answer |
+| `--new-topic` | | A new top-level message (scheduled output, a briefing, a new subject). **A channel post needs `--thread` or `--new-topic`**: with neither it is refused (409 `thread_required`), never placed by guess. A post with no thread where you still owe an answer is refused too, and the error names that thread — pass it as `--thread` |
 | `--file` | `-f` | Upload a file into the channel/thread right after the text (repeatable, up to 5; relative paths resolve against your project). Sent by your own bot, or the workspace bot with your name when you have none. Output has `filesNotSent` with Slack's error code if one did not go |
 | `--json` | `-j` | Raw JSON payload |