crewly 1.6.1 → 1.6.3

package/config/roles/orchestrator/prompt.md

@@ -734,6 +734,22 @@ bash {{ORCHESTRATOR_SKILLS_PATH}}/reply-slack/execute.sh '{"channelId":"C0123","
 
 **You are the project manager. The user should not have to ask "what happened?" — you should tell them before they need to ask.**
 
+## V3 Intelligent Decomposition Pipeline (MANDATORY)
+
+To ensure tasks are specific and context-aware (avoiding generic "Plan/Execute/Review" blocks), you MUST follow this decomposition pipeline for every user goal or complex request:
+
+1.  **Analyze Intent**: Use your LLM judgment to determine if the user's message is a **Request** (short-term, specific) or a **Mission** (long-term goal, OKR).
+2.  **Create Entity**:
+    - For Missions: Call `create-mission`.
+    - For Requests: Call `create-request`.
+3.  **Perform Intelligent Decomposition**:
+    - **NEVER** let the system create mindless WorkItems.
+    - If you created a **Mission**: IMMEDIATELY call `decompose-mission` (orchestrator skill). The skill will prompt you for a detailed breakdown. Provide specific, executable tasks with clear descriptions, types, and roles.
+    - If you created a **Request**: If it's complex (L2/L3), call `break-down-request` (agent skill) to generate specific WorkItems.
+4.  **Confirm to User**: Report the created tasks to the user, explaining the plan.
+
+**Rule**: A user message like "Build a login page" should result in 5-8 specific WorkItems (e.g., "Design login UI", "Implement auth API", "Write integration tests", etc.), NOT 3 generic ones.
+
 ---
 
 ## IMPORTANT: Session Management

package/config/skills/agent/core/get-my-active-work/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: Get My Active Work
+description: Retrieve the live Request + WorkItem briefing for your session. Use this when the startup briefing is stale or truncated.
+natural_language_description: Show me the active Requests and WorkItems I am currently on the hook for, plus anything that auto-resolved in the last 30 minutes.
+version: 1.0.0
+category: state-recovery
+skillType: claude-skill
+assignableRoles:
+  - developer
+  - qa
+  - tpm
+  - designer
+  - frontend-developer
+  - backend-developer
+  - fullstack-dev
+  - qa-engineer
+  - product-manager
+  - architect
+  - generalist
+  - sales
+  - support
+  - team-lead
+  - team_lead
+  - orchestrator
+triggers:
+  - get my active work
+  - active work
+  - what am I on the hook for
+  - refresh state
+tags:
+  - state
+  - recovery
+  - request
+  - workitem
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 15000
+---
+
+# Get My Active Work
+
+Returns the authoritative live state — open Requests you are on the hook for,
+in-flight WorkItems targeted at you (or claimed by you), pending reviews where
+you are the verifier, outbound delegations you issued, and recently
+auto-resolved items from the last 30 minutes.
+
+This is the **freshness escape hatch** for the recovery protocol:
+
+- The same briefing is auto-injected into your system prompt at session
+  registration — you don't normally need to call this skill on startup.
+- Call this skill mid-session if (a) the briefing was truncated (more than
+  the 45-item cap had to be dropped), or (b) the snapshot is stale (>5
+  minutes since registration, especially after long-running tasks).
+
+State is the source of truth. Memory is supplementary. If the briefing shows
+something your memory disagrees with, **trust the state** — investigate the
+divergence rather than override it.
+
+## Parameters
+
+| Flag | JSON Field | Required | Description |
+|------|-----------|----------|-------------|
+| `--session` / `-s` | `sessionName` | Yes | Your agent session name |
+| `--role` / `-r` | `role` | No | Agent role (default `developer`; orchestrator gets 3× cap) |
+| `--format` / `-f` | `format` | No | `json` (default) or `markdown` |
+| `--window` / `-w` | `recentlyResolvedWindowMs` | No | Window for recently auto-resolved items in ms (default `1800000` / 30min) |
+
+## Examples — CLI Flags (preferred)
+
+```bash
+# Default JSON briefing
+bash config/skills/agent/core/get-my-active-work/execute.sh --session dev-1
+
+# Markdown rendering — pipe straight into your context
+bash config/skills/agent/core/get-my-active-work/execute.sh --session dev-1 --format markdown
+
+# Orchestrator system-wide briefing
+bash config/skills/agent/core/get-my-active-work/execute.sh --session crewly-orc --role orchestrator
+```
+
+## Output
+
+JSON (default): `{ success: true, data: ActiveWorkBriefing }`. The shape is:
+
+```jsonc
+{
+  "openRequests": [{ "id": "req-abc", "title": "...", "status": "running", "priority": "high", "ageHours": 2.1 }],
+  "activeWorkItems": [{ "id": "wi-123", "title": "...", "status": "running", "ageHours": 0.5, "requestId": "req-abc" }],
+  "pendingReviews": [{ "id": "wi-456", "title": "...", "ageHours": 1.0, "claimedBy": "dev-x" }],
+  "outboundDelegations": [{ "id": "wi-789", "title": "...", "status": "running", "target": "dev-leo" }],
+  "recentlyAutoResolved": [{ "id": "wi-old", "title": "...", "resolvedAt": "...", "resolvedReason": "sla_close_run" }],
+  "truncated": false,
+  "totalCounts": { "requests": 12, "workItems": 47 }
+}
+```
+
+When `--format markdown` is set, the response is `text/markdown` rendering of
+the briefing — append it directly to your working context.

package/config/skills/agent/core/get-my-active-work/execute.sh

@@ -0,0 +1,122 @@
+#!/bin/bash
+# get-my-active-work — fetch the live Request + WorkItem briefing for this
+# agent. Backs the recovery protocol's Step 1.5 freshness escape hatch:
+# the startup briefing is already injected at registration time, but a
+# long-running session can call this skill to refresh after the snapshot
+# ages out (e.g. >5min after registration).
+#
+# Mirrors the get-my-tasks skill argument shape for consistency.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  # CLI flags (preferred — avoids shell escaping issues)
+  bash execute.sh --session dev-1
+  bash execute.sh --session dev-1 --role developer --format markdown
+
+  # Legacy JSON argument (backward compatible)
+  bash execute.sh '{"sessionName":"dev-1","role":"developer"}'
+
+Options:
+  --session  | -s   Agent session name (required)
+  --role     | -r   Agent role (default: developer; orchestrator gets 3x cap)
+  --format   | -f   "json" (default) or "markdown"
+  --window   | -w   Recently-resolved window in milliseconds (default: 1800000 / 30min)
+  --json     | -j   Raw JSON payload (same as legacy)
+  --help     | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+SESSION_NAME=""
+ROLE=""
+FORMAT=""
+WINDOW_MS=""
+
+# Detect legacy JSON argument as the first parameter
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --session|-s)
+      SESSION_NAME="$2"
+      shift 2
+      ;;
+    --role|-r)
+      ROLE="$2"
+      shift 2
+      ;;
+    --format|-f)
+      FORMAT="$2"
+      shift 2
+      ;;
+    --window|-w)
+      WINDOW_MS="$2"
+      shift 2
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      print_usage
+      exit 0
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"
+        shift
+      else
+        error_exit "Unknown argument: $1. Use --help for usage."
+      fi
+      ;;
+  esac
+done
+
+# If nothing provided yet but stdin has data, read it as JSON
+if [ -z "$INPUT_JSON" ] && [ -z "$SESSION_NAME" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  fi
+fi
+
+# Parse JSON input if provided (backward compatible)
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$SESSION_NAME" ] && SESSION_NAME=$(printf '%s' "$INPUT" | jq -r '.sessionName // empty')
+  [ -z "$ROLE" ]         && ROLE=$(printf '%s'         "$INPUT" | jq -r '.role         // empty')
+  [ -z "$FORMAT" ]       && FORMAT=$(printf '%s'       "$INPUT" | jq -r '.format       // empty')
+  [ -z "$WINDOW_MS" ]    && WINDOW_MS=$(printf '%s'    "$INPUT" | jq -r '(.recentlyResolvedWindowMs // empty) | tostring')
+  # `jq` returns the literal string "null" when the field is missing — coerce.
+  [ "$WINDOW_MS" = "null" ] && WINDOW_MS=""
+fi
+
+require_param "sessionName (--session)" "$SESSION_NAME"
+
+# Defaults for optional knobs
+[ -z "$ROLE" ]   && ROLE="developer"
+[ -z "$FORMAT" ] && FORMAT="json"
+
+# URL-encode the session name and build the query string
+ENCODED_SESSION=$(printf '%s' "$SESSION_NAME" | jq -sRr @uri)
+ENCODED_ROLE=$(printf '%s'    "$ROLE"         | jq -sRr @uri)
+ENCODED_FORMAT=$(printf '%s'  "$FORMAT"       | jq -sRr @uri)
+
+QUERY="role=${ENCODED_ROLE}&format=${ENCODED_FORMAT}"
+if [ -n "$WINDOW_MS" ]; then
+  ENCODED_WINDOW=$(printf '%s' "$WINDOW_MS" | jq -sRr @uri)
+  QUERY="${QUERY}&recentlyResolvedWindowMs=${ENCODED_WINDOW}"
+fi
+
+api_call GET "/v3/agents/${ENCODED_SESSION}/active-work?${QUERY}"

package/config/skills/agent/core/record-learning/SKILL.md

@@ -50,6 +50,35 @@ Record a learning or insight gained during task execution. These learnings are s
 | `--learning` / `-l` | `learning` | Yes | The learning or insight (or pipe via stdin) |
 | `--learning-file` | — | No | Read learning from a file path |
 
+---
+
+## Mandated Format: Karpathy-lite (Entity-Centric)
+
+To support future automated knowledge synthesis, all new learnings MUST follow the **Entity-Centric** format. This moves from "logging what happened" to "building a compounding wiki."
+
+### Formatting Rules:
+1. **Entity First**: Start with the primary entity (concept, file, function, or component) in brackets: `[[Entity Name]]`.
+2. **Concise**: 1-3 sentences maximum. No fluff.
+3. **Linked**: Reference related entities or components.
+4. **Sourced**: Reference the specific Task ID, PR, or Log line where this was learned.
+
+### Examples:
+
+**✅ CORRECT (Entity-Centric):**
+> `[[Fts5IndexService]] SQLite FTS5 rank is a negative double (more-negative = more-relevant). Invert to 100 - rank for score consistency. Learned during PR #320.`
+
+**✅ CORRECT (Component Relationship):**
+> `[[LearningReferenceModule]] injects memory usage instructions via PromptAssemblyService. Related to [[record-learning]] skill. Ref: backend/src/services/ai/prompt-modules/index.ts.`
+
+**❌ INCORRECT (Log-style):**
+> `I fixed a bug today in the FTS5 service where the ranking was inverted. It took me 2 hours because I didn't know SQLite's sign convention.`
+
+### Why this format
+
+The `LearningReferenceModule` (prompt-layer) and the LEARN-1 auto-record subscriber both join learnings on entity references. Free-form prose breaks that join. The `[[Entity]]` bracket convention also matches the cross-doc linking pattern used elsewhere in the project (mirrors Obsidian/Roam-style backlinks for future synthesis tooling).
+
+---
+
 ## Examples — CLI Flags (preferred)
 
 ```bash

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

@@ -0,0 +1,41 @@
+# reply-channel
+
+Send an agent-authored message back to a chat channel. Used by the chat MVP
+dispatch loop: when an agent receives a `[CHAT:<channelId>] ...` prompt from
+the user, it processes the request, then calls this skill to publish its
+reply into the same channel.
+
+## When to invoke
+
+After you receive a message that begins with `[CHAT:<channelId>]` from the
+dispatch runtime. The reply must be written to the same channel so the
+user's chat UI sees it.
+
+## Invocation
+
+```bash
+bash config/skills/agent/core/reply-channel/execute.sh \
+  --channel <channelId> \
+  --content "your reply text" \
+  [--cmid <clientMessageId>]
+```
+
+Or with JSON:
+
+```bash
+bash config/skills/agent/core/reply-channel/execute.sh \
+  '{"channelId":"chan-1","content":"hello back","clientMessageId":"cmid-abc"}'
+```
+
+## Environment
+
+- `CREWLY_SESSION_NAME` — your agent session id. Auto-set in agent sessions.
+  The skill attaches it as `X-Agent-Session` so the backend routes the
+  reply as `senderType:"agent"`.
+- `CREWLY_API_URL` — defaults to `http://localhost:8787`.
+
+## Success / failure
+
+On success prints `{"success":true, "messageId":"..."}` to stdout.
+On failure prints `{"success":false, "error":"..."}` to stdout and exits
+with a non-zero code.

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

@@ -0,0 +1,165 @@
+#!/bin/bash
+# reply-channel — post an agent-authored reply to a chat channel.
+# Used by the Chat MVP dispatch loop: the runtime hands the agent a prompt
+# prefixed `[CHAT:<channelId>]`; the agent processes it, then invokes this
+# skill to write its reply back to the channel.
+#
+# The shared `api_call` helper attaches `X-Agent-Session: $CREWLY_SESSION_NAME`
+# automatically, which the chat-v2 controller uses to route the message as
+# `senderType:"agent"` instead of `user`.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  # CLI flags (preferred)
+  bash execute.sh --channel <channelId> --content "reply text" [--cmid <clientMessageId>]
+
+  # Content from stdin
+  echo "multi-line reply" | bash execute.sh --channel chan-1
+
+  # JSON
+  bash execute.sh '{"channelId":"chan-1","content":"hi","clientMessageId":"cmid-abc"}'
+
+Options:
+  --channel   | -c   Target channel id (required)
+  --content   | -m   Reply text (required unless piped via stdin)
+  --content-file     Read reply text from a file path
+  --cmid             Optional client-message-id for idempotency
+  --json      | -j   Raw JSON payload
+  --help      | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+CHANNEL_ID=""
+CONTENT=""
+CMID=""
+
+# Detect legacy JSON argument as $1
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --channel|-c)
+      CHANNEL_ID="$2"
+      shift 2
+      ;;
+    --content|-m)
+      CONTENT="$2"
+      shift 2
+      ;;
+    --content-file)
+      CONTENT="$(cat "$2")"
+      shift 2
+      ;;
+    --cmid)
+      CMID="$2"
+      shift 2
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      print_usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      print_usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+# Fall back to stdin when --content and legacy JSON are both missing
+if [ -z "$CONTENT" ] && [ -z "$INPUT_JSON" ] && [ ! -t 0 ]; then
+  CONTENT="$(cat)"
+fi
+
+# When given JSON, extract fields via python (portable — awk/sed + json is fragile)
+if [ -n "$INPUT_JSON" ]; then
+  if command -v python3 >/dev/null 2>&1; then
+    EXTRACTED=$(python3 - <<PY
+import json, sys
+try:
+    d = json.loads('''$INPUT_JSON''')
+except Exception as e:
+    print('PARSE_ERROR:' + str(e))
+    sys.exit(0)
+print('CHANNEL=' + str(d.get('channelId', '')))
+print('CMID=' + str(d.get('clientMessageId', '')))
+# content is multi-line safe — use base64
+import base64
+c = d.get('content', '')
+print('CONTENT_B64=' + base64.b64encode(c.encode('utf-8')).decode('ascii'))
+PY
+)
+    if echo "$EXTRACTED" | grep -q '^PARSE_ERROR'; then
+      echo '{"success":false,"error":"invalid JSON payload"}' >&2
+      exit 2
+    fi
+    while IFS= read -r line; do
+      case "$line" in
+        CHANNEL=*) [ -z "$CHANNEL_ID" ] && CHANNEL_ID="${line#CHANNEL=}";;
+        CMID=*) [ -z "$CMID" ] && CMID="${line#CMID=}";;
+        CONTENT_B64=*) [ -z "$CONTENT" ] && CONTENT="$(echo "${line#CONTENT_B64=}" | base64 -d 2>/dev/null)";;
+      esac
+    done <<< "$EXTRACTED"
+  else
+    echo '{"success":false,"error":"python3 required to parse JSON payload"}' >&2
+    exit 2
+  fi
+fi
+
+if [ -z "$CHANNEL_ID" ]; then
+  echo '{"success":false,"error":"--channel is required"}' >&2
+  exit 2
+fi
+
+if [ -z "$CONTENT" ]; then
+  echo '{"success":false,"error":"--content is required (or pipe via stdin)"}' >&2
+  exit 2
+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" python3 -c '
+import os, json
+p = {"content": os.environ["CONTENT"], "contentType": "markdown"}
+cmid = os.environ.get("CMID", "")
+if cmid:
+    p["clientMessageId"] = cmid
+print(json.dumps(p))
+')
+
+ENDPOINT="/chat/channels/${CHANNEL_ID}/messages"
+
+if RESPONSE=$(api_call POST "$ENDPOINT" "$BODY" 2>&1); then
+  # Successful 2xx — surface the message id
+  MESSAGE_ID=$(echo "$RESPONSE" | python3 -c '
+import json,sys
+try:
+    d=json.load(sys.stdin)
+    print((d.get("data") or {}).get("id",""))
+except Exception:
+    pass
+' 2>/dev/null || echo "")
+  if [ -n "$MESSAGE_ID" ]; then
+    echo "{\"success\":true,\"messageId\":\"$MESSAGE_ID\",\"channelId\":\"$CHANNEL_ID\"}"
+  else
+    # Success code but unexpected body — still return success with raw response
+    echo "{\"success\":true,\"channelId\":\"$CHANNEL_ID\",\"raw\":$(echo "$RESPONSE" | python3 -c 'import json,sys;print(json.dumps(sys.stdin.read()))')}"
+  fi
+  exit 0
+else
+  echo "{\"success\":false,\"error\":$(echo "$RESPONSE" | python3 -c 'import json,sys;print(json.dumps(sys.stdin.read()))')}"
+  exit 1
+fi

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

@@ -0,0 +1,148 @@
+#!/bin/bash
+# Co-located bash test for reply-channel skill.
+# Runs a tiny python HTTP stub to capture the outgoing request, then
+# asserts both the URL and the JSON body match the documented contract.
+#
+# Usage: bash execute.test.sh  (exit 0 on pass)
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKILL="${SCRIPT_DIR}/execute.sh"
+
+if [ ! -x "$SKILL" ]; then
+  echo "FAIL: skill not executable at $SKILL" >&2
+  exit 1
+fi
+
+PASS=0
+FAIL=0
+PORT=18787
+
+# --- Start stub backend on a fixed test port ---
+# Env MUST be exported BEFORE the python fork so the child inherits.
+STUB_LOG="$(mktemp)"
+export STUB_LOG
+export STUB_PORT="${PORT}"
+
+python3 -u <<'PY' >/tmp/reply-channel-stub.log 2>&1 &
+from http.server import BaseHTTPRequestHandler, HTTPServer
+import json, os, sys
+
+LOG_PATH = os.environ['STUB_LOG']
+PORT = int(os.environ['STUB_PORT'])
+
+class H(BaseHTTPRequestHandler):
+    def do_POST(self):
+        length = int(self.headers.get('content-length', '0'))
+        body = self.rfile.read(length).decode('utf-8') if length else ''
+        log = {
+            'path': self.path,
+            'body': body,
+            'agentSession': self.headers.get('x-agent-session', ''),
+            'contentType': self.headers.get('content-type', ''),
+        }
+        with open(LOG_PATH, 'w') as f:
+            f.write(json.dumps(log))
+        self.send_response(201)
+        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'))
+    def log_message(self, *a, **k):
+        pass
+
+srv = HTTPServer(('127.0.0.1', PORT), H)
+srv.serve_forever()
+PY
+STUB_PID=$!
+
+cleanup() { kill "$STUB_PID" >/dev/null 2>&1 || true; rm -f "$STUB_LOG" || true; }
+trap cleanup EXIT
+
+# Wait until the port actually accepts a connection (up to ~3s). This is
+# more reliable than a fixed sleep on slower boxes.
+for i in $(seq 1 30); do
+  if curl -s -o /dev/null -m 0.2 "http://127.0.0.1:${PORT}/__probe__" 2>/dev/null; then
+    break
+  fi
+  sleep 0.1
+done
+
+assert_contains() {
+  local name="$1" haystack="$2" needle="$3"
+  if echo "$haystack" | grep -q -- "$needle"; then
+    PASS=$((PASS + 1))
+    echo "  ✓ $name"
+  else
+    FAIL=$((FAIL + 1))
+    echo "  ✗ $name (wanted: $needle)"
+    echo "    in: $haystack"
+  fi
+}
+
+run_skill() {
+  CREWLY_API_URL="http://127.0.0.1:${PORT}" \
+  CREWLY_SESSION_NAME="crewly-product-sam-TEST" \
+  bash "$SKILL" "$@"
+}
+
+# --- Test 1: flag form, single-line content ---
+echo "test 1: --channel + --content"
+: > "$STUB_LOG"
+OUT=$(run_skill --channel chan-xyz --content "hello from agent" 2>&1 || true)
+LOG=$(cat "$STUB_LOG" 2>/dev/null || echo '{}')
+assert_contains "success echoed" "$OUT" '"success":true'
+assert_contains "messageId echoed" "$OUT" 'm-stub-123'
+assert_contains "path targets /api/chat/channels/:id/messages" "$LOG" '/api/chat/channels/chan-xyz/messages'
+assert_contains "body carries content" "$LOG" 'hello from agent'
+assert_contains "body contentType markdown" "$LOG" 'markdown'
+assert_contains "X-Agent-Session header present" "$LOG" 'crewly-product-sam-TEST'
+
+# --- Test 2: JSON argument form ---
+echo "test 2: JSON payload"
+: > "$STUB_LOG"
+OUT=$(run_skill '{"channelId":"chan-xyz","content":"via json","clientMessageId":"cmid-123"}' 2>&1 || true)
+LOG=$(cat "$STUB_LOG" 2>/dev/null || echo '{}')
+assert_contains "success echoed (json form)" "$OUT" '"success":true'
+assert_contains "body has content (json form)" "$LOG" 'via json'
+assert_contains "body includes clientMessageId" "$LOG" 'cmid-123'
+
+# --- Test 3: multiline content via stdin ---
+echo "test 3: stdin pipe"
+: > "$STUB_LOG"
+OUT=$(printf 'line one\nline two\n' | run_skill --channel chan-xyz 2>&1 || true)
+LOG=$(cat "$STUB_LOG" 2>/dev/null || echo '{}')
+assert_contains "success echoed (stdin form)" "$OUT" '"success":true'
+assert_contains "body contains line one" "$LOG" 'line one'
+assert_contains "body contains line two" "$LOG" 'line two'
+
+# --- Test 4: missing --channel errors out ---
+echo "test 4: missing channel"
+if OUT=$(run_skill --content "no channel" 2>&1); then
+  FAIL=$((FAIL + 1))
+  echo "  ✗ expected non-zero exit when --channel missing"
+else
+  PASS=$((PASS + 1))
+  echo "  ✓ non-zero exit when --channel missing"
+fi
+assert_contains "error surfaces" "$OUT" '--channel is required'
+
+# --- Test 5: missing content errors out ---
+echo "test 5: missing content"
+if OUT=$(run_skill --channel chan-xyz 2>&1 </dev/null); then
+  FAIL=$((FAIL + 1))
+  echo "  ✗ expected non-zero exit when --content missing"
+else
+  PASS=$((PASS + 1))
+  echo "  ✓ non-zero exit when --content missing"
+fi
+assert_contains "content-required error surfaces" "$OUT" '--content is required'
+
+echo
+echo "========================================"
+echo "reply-channel skill: PASS=$PASS  FAIL=$FAIL"
+echo "========================================"
+if [ "$FAIL" -gt 0 ]; then
+  echo "--- stub server log ---"
+  cat /tmp/reply-channel-stub.log 2>/dev/null | tail -40
+  exit 1
+fi
+exit 0