crewly 1.13.0 → 1.14.0

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

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

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

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

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

@@ -36,9 +36,15 @@ user's chat UI sees it.
 bash config/skills/agent/core/reply-channel/execute.sh \
   --channel <channelId> \
   --content "your reply text" \
+  [--thread <messageId>] \
   [--cmid <clientMessageId>]
 ```
 
+`--thread` replies inside an existing thread. When the prompt you received
+came from a **Slack team channel** it names the thread id
+(`--thread <id>`); pass it through so your reply shows up in the same Slack
+thread, under your own name.
+
 Or with JSON:
 
 ```bash

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

@@ -15,7 +15,7 @@ print_usage() {
   cat <<'EOF_USAGE'
 Usage:
   # CLI flags (preferred)
-  bash execute.sh --channel <channelId> --content "reply text" [--cmid <clientMessageId>]
+  bash execute.sh --channel <channelId> --content "reply text" [--thread <messageId>] [--cmid <clientMessageId>]
 
   # Content from stdin
   echo "multi-line reply" | bash execute.sh --channel chan-1
@@ -27,6 +27,8 @@ 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
+  --thread    | -t   Thread root message id — reply inside that thread
+                     (Slack team channels: keeps the reply in the same Slack thread)
   --cmid             Optional client-message-id for idempotency
   --json      | -j   Raw JSON payload
   --help      | -h   Show this help
@@ -37,6 +39,7 @@ INPUT_JSON=""
 CHANNEL_ID=""
 CONTENT=""
 CMID=""
+THREAD_ID=""
 
 # Detect legacy JSON argument as $1
 if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
@@ -62,6 +65,10 @@ while [[ $# -gt 0 ]]; do
       CMID="$2"
       shift 2
       ;;
+    --thread|-t)
+      THREAD_ID="$2"
+      shift 2
+      ;;
     --json|-j)
       INPUT_JSON="$2"
       shift 2
@@ -95,6 +102,7 @@ except Exception as e:
     sys.exit(0)
 print('CHANNEL=' + str(d.get('channelId', '')))
 print('CMID=' + str(d.get('clientMessageId', '')))
+print('THREAD=' + str(d.get('threadId', '')))
 # content is multi-line safe — use base64
 import base64
 c = d.get('content', '')
@@ -109,6 +117,7 @@ PY
       case "$line" in
         CHANNEL=*) [ -z "$CHANNEL_ID" ] && CHANNEL_ID="${line#CHANNEL=}";;
         CMID=*) [ -z "$CMID" ] && CMID="${line#CMID=}";;
+        THREAD=*) [ -z "$THREAD_ID" ] && THREAD_ID="${line#THREAD=}";;
         CONTENT_B64=*) [ -z "$CONTENT" ] && CONTENT="$(echo "${line#CONTENT_B64=}" | base64 -d 2>/dev/null)";;
       esac
     done <<< "$EXTRACTED"
@@ -131,12 +140,15 @@ 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 '
+BODY=$(CONTENT="$CONTENT" CMID="$CMID" THREAD_ID="$THREAD_ID" python3 -c '
 import os, json
 p = {"content": os.environ["CONTENT"], "contentType": "markdown"}
 cmid = os.environ.get("CMID", "")
 if cmid:
     p["clientMessageId"] = cmid
+thread = os.environ.get("THREAD_ID", "")
+if thread:
+    p["threadId"] = thread
 print(json.dumps(p))
 ')
 

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

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

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

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

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

@@ -0,0 +1,126 @@
+---
+name: slack-post
+description: Start a Slack conversation yourself — post to a channel or DM a person, under your own Slack identity. Use it to raise something proactively, not to answer a message you were already sent (that is reply-channel).
+version: 1.0.0
+category: communication
+skillType: claude-skill
+assignableRoles:
+  - team-leader
+  - tpm
+  - developer
+  - frontend-developer
+  - backend-developer
+  - fullstack-dev
+  - qa
+  - qa-engineer
+  - designer
+  - product-manager
+  - architect
+  - generalist
+  - sales
+  - support
+  - marketing
+triggers:
+  - slack post
+  - message slack
+  - dm on slack
+  - tell the team on slack
+tags:
+  - communication
+  - slack
+  - proactive
+execution:
+  type: script
+  script:
+    file: execute.sh
+    interpreter: bash
+    timeoutMs: 20000
+---
+
+# slack-post
+
+Send a Slack message on your own initiative. If you have a Slack identity of
+your own, the message comes from your bot user, so a DM is a real conversation
+between that person and you. Otherwise it goes out through the shared Crewly
+bot carrying your name and icon.
+
+## When to use
+
+- Something you found needs a human's attention now, and nobody asked you.
+- You finished long-running work and the person who wanted it is not in the
+  thread any more.
+- You need one specific person, so a DM beats the team channel.
+
+**Do not use it to answer a message you were handed.** A prompt that starts
+with `[CHAT:<channelId>]` is answered with `reply-channel`, which keeps your
+reply in the same Slack thread.
+
+## Invocation
+
+```bash
+bash config/skills/agent/core/slack-post/execute.sh \
+  --target "#general" \
+  --text "Deploy finished, staging is on 1.4.2."
+```
+
+```bash
+# DM a person by handle
+bash config/skills/agent/core/slack-post/execute.sh --target "@steve" --text "..."
+
+# Reply inside an existing Slack thread
+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
+echo "..." | bash .../execute.sh --target "@steve"
+```
+
+## Target syntax
+
+| Target | Goes to |
+|---|---|
+| `#general` or `general` | that channel |
+| `C0123ABCD` | that channel by id |
+| `D0123ABCD` | an already-open DM |
+| `@steve` | a DM with that person |
+| `U0123ABCD` | a DM with that user id |
+
+Slack ids are upper-case and channel names are lower-case, which is how the
+two are told apart. Write ids exactly as Slack shows them.
+
+## Options
+
+| Flag | Short | Description |
+|---|---|---|
+| `--target` | `-c` | Channel or person (required) |
+| `--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 |
+| `--json` | `-j` | Raw JSON payload |
+
+## Environment
+
+- `CREWLY_SESSION_NAME` — your agent session, attached automatically. The post
+  is sent under that agent's identity, so this must be set.
+- `CREWLY_API_URL` — defaults to `http://localhost:8787`.
+
+## Output
+
+On success, JSON on stdout:
+
+```json
+{"success":true,"channelId":"C-GEN","messageTs":"1712345678.000200","kind":"channel","postedAs":"agent"}
+```
+
+`postedAs` is `agent` when your own Slack bot sent it, `crewly` when the shared
+bot did.
+
+## Failures worth knowing
+
+| Message contains | What to do |
+|---|---|
+| `No Slack channel named` | check the name, or the bot cannot see it (private channel needs an invite) |
+| `No Slack user matches` | the handle is wrong; ask for the exact Slack handle |
+| `invite ... into the channel` | a private channel the bot is not in; ask a human to invite it |
+| `reinstall the app` | the Slack app is missing a scope; tell the owner |
+| `Slack is not connected` | Slack is not configured on this install; stop, do not retry |

package/config/skills/agent/core/slack-post/execute.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# slack-post — send a Slack message on the agent's own initiative.
+#
+# Posts to a channel or opens a DM, under the calling agent's Slack identity
+# (its own bot user when it has one). The shared `api_call` helper attaches
+# `X-Agent-Session: $CREWLY_SESSION_NAME`, which the backend uses to pick that
+# identity — without it the request is refused.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  bash execute.sh --target <#channel|@user|C…|D…|U…> --text "message" [--thread <ts>]
+
+  echo "message" | bash execute.sh --target "#general"
+  bash execute.sh --target "@steve" --text-file /tmp/report.md
+  bash execute.sh '{"target":"#general","text":"hi","threadTs":"100.1"}'
+
+Options:
+  --target    | -c   Channel or person (required)
+  --text      | -m   Message text (required unless piped or --text-file)
+  --text-file        Read the message text from a file
+  --thread    | -t   Slack thread timestamp to reply inside
+  --json      | -j   Raw JSON payload
+  --help      | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+TARGET=""
+TEXT=""
+THREAD_TS=""
+
+# Legacy JSON as the first positional argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --target|-c) TARGET="$2"; shift 2 ;;
+    --text|-m) TEXT="$2"; shift 2 ;;
+    --text-file) TEXT="$(cat "$2")"; shift 2 ;;
+    --thread|-t) THREAD_TS="$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 for the body
+if [ -z "$TEXT" ] && [ -z "$INPUT_JSON" ] && [ ! -t 0 ]; then
+  TEXT="$(cat)"
+fi
+
+if [ -n "$INPUT_JSON" ]; then
+  EXTRACTED=$(INPUT_JSON="$INPUT_JSON" python3 -c '
+import base64, json, os, sys
+try:
+    d = json.loads(os.environ["INPUT_JSON"])
+except Exception as e:
+    print("PARSE_ERROR:" + str(e)); sys.exit(0)
+print("TARGET=" + str(d.get("target", "")))
+print("THREAD=" + str(d.get("threadTs", d.get("thread", ""))))
+print("TEXT_B64=" + base64.b64encode(str(d.get("text", "")).encode("utf-8")).decode("ascii"))
+')
+  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
+      TARGET=*) [ -z "$TARGET" ] && TARGET="${line#TARGET=}" ;;
+      THREAD=*) [ -z "$THREAD_TS" ] && THREAD_TS="${line#THREAD=}" ;;
+      TEXT_B64=*) [ -z "$TEXT" ] && TEXT="$(echo "${line#TEXT_B64=}" | base64 -d 2>/dev/null)" ;;
+    esac
+  done <<< "$EXTRACTED"
+fi
+
+if [ -z "$TARGET" ]; then
+  echo '{"success":false,"error":"--target is required (#channel, @user, or a Slack id)"}' >&2
+  exit 2
+fi
+if [ -z "$TEXT" ]; then
+  echo '{"success":false,"error":"--text is required (or pipe it via stdin)"}' >&2
+  exit 2
+fi
+if [ -z "${CREWLY_SESSION_NAME:-}" ]; then
+  echo '{"success":false,"error":"CREWLY_SESSION_NAME is unset — the post needs an agent identity"}' >&2
+  exit 2
+fi
+
+# Convert literal \n to real newlines, matching the other comm skills
+_NL=$'\n'; TEXT="${TEXT//\\n/$_NL}"
+
+BODY=$(TARGET="$TARGET" TEXT="$TEXT" THREAD_TS="$THREAD_TS" python3 -c '
+import json, os
+p = {"target": os.environ["TARGET"], "text": os.environ["TEXT"]}
+ts = os.environ.get("THREAD_TS", "")
+if ts:
+    p["threadTs"] = ts
+print(json.dumps(p))
+')
+
+if RESPONSE=$(api_call POST "/slack/post" "$BODY" 2>&1); then
+  echo "$RESPONSE" | python3 -c '
+import json, sys
+try:
+    d = json.load(sys.stdin).get("data") or {}
+except Exception:
+    print("{\"success\":true}"); raise SystemExit(0)
+print(json.dumps({
+    "success": True,
+    "channelId": d.get("channelId", ""),
+    "messageTs": d.get("messageTs", ""),
+    "kind": d.get("kind", ""),
+    "postedAs": d.get("postedAs", ""),
+}))
+'
+  exit 0
+else
+  echo "{\"success\":false,\"error\":$(echo "$RESPONSE" | python3 -c 'import json,sys;print(json.dumps(sys.stdin.read()))')}"
+  exit 1
+fi