@mmerterden/multi-agent-pipeline 14.2.1 → 15.0.0

package/pipeline/lib/parse-complaints.sh

@@ -0,0 +1,306 @@
+#!/bin/bash
+#
+# parse-complaints.sh
+# Normalize a batch of customer complaints into the uniform JSON list the
+# /multi-agent:complaint-analysis command consumes. Accepts a file export
+# (csv / xlsx / txt / json) or pasted free text on stdin, extracts any
+# transaction / conversation ids embedded in the text, and redacts common
+# PII shapes before anything leaves this script. The raw input is never
+# copied into pipeline state - only the redacted view is.
+#
+# Input forms (exactly one source is required):
+#   ./parse-complaints.sh --file <path> [--format csv|xlsx|txt|json|auto]
+#   ./parse-complaints.sh --stdin [--format text]
+#
+# Options:
+#   --no-redact   keep complaint text verbatim (debugging only; the skill
+#                 never passes this flag)
+#
+# Column mapping (file formats, case-insensitive header match):
+#   trxId   <- trxId | trx | transaction id / transaction_id / transactionId
+#   convId  <- convId | conversationId | x-conversationId
+#   date    <- date | created | createdAt | timestamp
+#   platformHint <- platform | channel | os | device
+#   text    <- comment | complaint | text | description | message, else the
+#              longest text column
+#
+# Free-text mode splits on blank lines (or numbered bullets when the paste is
+# one block) and pre-fills ids per block using the same label set as
+# context-link-extractor.sh GRAYLOG_RE (x-conversationId | conversationId |
+# convId | trxId | trx | transaction id).
+#
+# Redaction (default ON, applied after id extraction so ids survive):
+#   email                              -> [REDACTED:email]
+#   13-19 digit card-like runs         -> [REDACTED:card]
+#   11 digit national-id-like numbers  -> [REDACTED:national-id]
+#   9+ digit phone-like runs           -> [REDACTED:phone]
+#   6-char PNR-like tokens (A-Z0-9 mix)-> [REDACTED:pnr]
+#
+# Output (stdout, single JSON object):
+#   {
+#     "parsedAt": "<ISO8601>",
+#     "source": "<path>"|"stdin",
+#     "format": "csv|xlsx|txt|json|text",
+#     "complaints": [
+#       { "id": "C-01", "text": "...", "trxId": "..."|null,
+#         "convId": "..."|null, "date": "..."|null,
+#         "platformHint": "..."|null }
+#     ],
+#     "redacted": <bool>, "degraded": <bool>, "degradeReason": "..."|null
+#   }
+#
+# Exit codes:
+#   0  success
+#   4  bad usage (no source, unknown flag, unreadable file)
+#   5  format degrade (xlsx requested but openpyxl is not installed; the
+#      degraded JSON on stdout tells the user to export as CSV and re-run)
+
+set -euo pipefail
+
+FILE=""
+USE_STDIN="false"
+FORMAT="auto"
+REDACT="true"
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --file)      FILE="$2"; shift 2 ;;
+    --stdin)     USE_STDIN="true"; shift ;;
+    --format)    FORMAT="$2"; shift 2 ;;
+    --no-redact) REDACT="false"; shift ;;
+    -h|--help)
+      echo "usage: $0 --file <path> [--format csv|xlsx|txt|json|auto] [--no-redact] | --stdin [--format text]" >&2
+      exit 4 ;;
+    *)
+      echo "ERR: unexpected arg $1" >&2; exit 4 ;;
+  esac
+done
+
+if [ -z "$FILE" ] && [ "$USE_STDIN" != "true" ]; then
+  echo "ERR: no source (pass --file <path> or --stdin)" >&2
+  exit 4
+fi
+if [ -n "$FILE" ] && [ "$USE_STDIN" = "true" ]; then
+  echo "ERR: pass either --file or --stdin, not both" >&2
+  exit 4
+fi
+if [ -n "$FILE" ] && [ ! -r "$FILE" ]; then
+  echo "ERR: file not readable: $FILE" >&2
+  exit 4
+fi
+
+if [ "$FORMAT" = "auto" ]; then
+  if [ "$USE_STDIN" = "true" ]; then
+    FORMAT="text"
+  else
+    case "$FILE" in
+      *.csv)  FORMAT="csv" ;;
+      *.xlsx) FORMAT="xlsx" ;;
+      *.json) FORMAT="json" ;;
+      *.txt|*.md) FORMAT="txt" ;;
+      *)
+        echo "ERR: cannot infer format from extension; pass --format" >&2
+        exit 4 ;;
+    esac
+  fi
+fi
+
+case "$FORMAT" in
+  csv|xlsx|txt|json|text) : ;;
+  *) echo "ERR: unknown format $FORMAT" >&2; exit 4 ;;
+esac
+
+STDIN_PAYLOAD=""
+if [ "$USE_STDIN" = "true" ]; then
+  STDIN_PAYLOAD=$(cat)
+fi
+
+PC_FILE="$FILE" PC_FORMAT="$FORMAT" PC_REDACT="$REDACT" PC_STDIN="$STDIN_PAYLOAD" \
+python3 - <<'PY'
+import csv, datetime, io, json, os, re, sys
+
+fmt = os.environ["PC_FORMAT"]
+path = os.environ.get("PC_FILE") or ""
+redact_on = os.environ.get("PC_REDACT") == "true"
+
+# Same label set as context-link-extractor.sh GRAYLOG_RE.
+ID_LABEL = re.compile(
+    r"(?P<label>x-conversationId|conversationId|convId|trxId|trx|transaction[ _-]?id)"
+    r"\s*[:=#]?\s*(?P<value>[A-Za-z0-9][A-Za-z0-9._-]{5,63})",
+    re.IGNORECASE,
+)
+
+def extract_ids(text):
+    trx, conv = None, None
+    for m in ID_LABEL.finditer(text or ""):
+        label = m.group("label").lower()
+        value = m.group("value")
+        if "conv" in label:
+            conv = conv or value
+        else:
+            trx = trx or value
+    return trx, conv
+
+# Order matters: card (13-19 digits, separators allowed) before national-id
+# (exactly 11) before phone (9+); a 16-digit card must not survive as a
+# "phone". PNR-like runs last so redacted placeholders are not re-matched.
+REDACTIONS = [
+    (re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"), "[REDACTED:email]"),
+    (re.compile(r"\b\d(?:[ -]?\d){12,18}\b"), "[REDACTED:card]"),
+    (re.compile(r"\b\d{11}\b"), "[REDACTED:national-id]"),
+    (re.compile(r"(?<![\w.-])\+?\d(?:[ ()-]?\d){8,14}\b"), "[REDACTED:phone]"),
+    (re.compile(r"\b(?=[A-Z0-9]{6}\b)(?=[A-Z0-9]*[A-Z])(?=[A-Z0-9]*\d)[A-Z0-9]{6}\b"), "[REDACTED:pnr]"),
+]
+
+def redact(text):
+    if not redact_on:
+        return text
+    for rx, repl in REDACTIONS:
+        text = rx.sub(repl, text)
+    return text
+
+TEXT_KEYS = ("comment", "complaint", "text", "description", "message", "yorum", "sikayet")
+TRX_KEYS = re.compile(r"^(trxid|trx|transaction[ _-]?id)$", re.IGNORECASE)
+CONV_KEYS = re.compile(r"^(convid|conversationid|x-conversationid)$", re.IGNORECASE)
+DATE_KEYS = re.compile(r"^(date|created|createdat|timestamp)$", re.IGNORECASE)
+PLATFORM_KEYS = re.compile(r"^(platform|channel|os|device)$", re.IGNORECASE)
+
+def row_to_complaint(row):
+    text_val, trx, conv, date, platform = None, None, None, None, None
+    longest = ""
+    for key, raw in row.items():
+        if key is None or raw is None:
+            continue
+        val = str(raw).strip()
+        if not val:
+            continue
+        k = str(key).strip()
+        if TRX_KEYS.match(k):
+            trx = val
+        elif CONV_KEYS.match(k):
+            conv = val
+        elif DATE_KEYS.match(k):
+            date = val
+        elif PLATFORM_KEYS.match(k):
+            platform = val
+        elif k.lower() in TEXT_KEYS:
+            text_val = val
+        elif len(val) > len(longest):
+            longest = val
+    text = text_val or longest
+    if not text:
+        return None
+    found_trx, found_conv = extract_ids(text)
+    return {
+        "text": text,
+        "trxId": trx or found_trx,
+        "convId": conv or found_conv,
+        "date": date,
+        "platformHint": platform,
+    }
+
+def blocks_from_text(payload):
+    payload = payload.strip()
+    if not payload:
+        return []
+    blocks = [b.strip() for b in re.split(r"\n\s*\n", payload) if b.strip()]
+    if len(blocks) == 1 and re.search(r"^\s*(?:\d+[.)]|-)\s+", payload, re.MULTILINE):
+        blocks = [
+            b.strip()
+            for b in re.split(r"^\s*(?:\d+[.)]|-)\s+", payload, flags=re.MULTILINE)
+            if b.strip()
+        ]
+    return blocks
+
+degraded = False
+degrade_reason = None
+raw_complaints = []
+
+if fmt == "text":
+    for block in blocks_from_text(os.environ.get("PC_STDIN") or ""):
+        trx, conv = extract_ids(block)
+        raw_complaints.append(
+            {"text": block, "trxId": trx, "convId": conv, "date": None, "platformHint": None}
+        )
+elif fmt == "txt":
+    with open(path, encoding="utf-8-sig", errors="replace") as f:
+        payload = f.read()
+    for block in blocks_from_text(payload):
+        trx, conv = extract_ids(block)
+        raw_complaints.append(
+            {"text": block, "trxId": trx, "convId": conv, "date": None, "platformHint": None}
+        )
+elif fmt == "csv":
+    with open(path, encoding="utf-8-sig", errors="replace", newline="") as f:
+        sample = f.read(4096)
+        f.seek(0)
+        try:
+            dialect = csv.Sniffer().sniff(sample, delimiters=",;\t")
+        except csv.Error:
+            dialect = csv.excel
+        for row in csv.DictReader(f, dialect=dialect):
+            c = row_to_complaint(row)
+            if c:
+                raw_complaints.append(c)
+elif fmt == "json":
+    with open(path, encoding="utf-8-sig") as f:
+        data = json.load(f)
+    if isinstance(data, dict):
+        data = data.get("complaints") or data.get("items") or []
+    if not isinstance(data, list):
+        data = []
+    for row in data:
+        if isinstance(row, str):
+            trx, conv = extract_ids(row)
+            raw_complaints.append(
+                {"text": row.strip(), "trxId": trx, "convId": conv, "date": None, "platformHint": None}
+            )
+        elif isinstance(row, dict):
+            c = row_to_complaint(row)
+            if c:
+                raw_complaints.append(c)
+elif fmt == "xlsx":
+    try:
+        import openpyxl
+    except ImportError:
+        degraded = True
+        degrade_reason = "openpyxl not installed; export the sheet as CSV and re-run with --format csv"
+    if not degraded:
+        wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
+        ws = wb.active
+        rows = ws.iter_rows(values_only=True)
+        header = next(rows, None)
+        if header:
+            keys = [str(h).strip() if h is not None else "" for h in header]
+            for values in rows:
+                row = {k: v for k, v in zip(keys, values) if k}
+                c = row_to_complaint(row)
+                if c:
+                    raw_complaints.append(c)
+        wb.close()
+
+complaints = []
+for i, c in enumerate(raw_complaints, start=1):
+    complaints.append(
+        {
+            "id": "C-%02d" % i,
+            "text": redact(c["text"]),
+            "trxId": c["trxId"],
+            "convId": c["convId"],
+            "date": c["date"],
+            "platformHint": (c["platformHint"] or None) and str(c["platformHint"]).strip().lower(),
+        }
+    )
+
+result = {
+    "parsedAt": datetime.datetime.utcnow().isoformat() + "Z",
+    "source": path or "stdin",
+    "format": fmt,
+    "complaints": complaints,
+    "redacted": redact_on,
+    "degraded": degraded,
+    "degradeReason": degrade_reason,
+}
+print(json.dumps(result, ensure_ascii=False))
+sys.exit(5 if degraded else 0)
+PY

package/pipeline/lib/plan-todos.sh

@@ -45,8 +45,11 @@ usage() {
 resolve_state() {
   local task_id="$1"
   local found=""
-  for dir in "$HOME"/.claude/projects/*; do
-    local candidate="$dir/state/$task_id/agent-state.json"
+  # multi-repo-pipeline.sh writes agent-state.json under a per-project
+  # directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/) - not the
+  # ~/.claude/projects/*/state/ path this used to glob, which no writer in
+  # the pipeline ever populates.
+  for candidate in "$HOME"/.claude/logs/multi-agent/*/"$task_id"/agent-state.json; do
     if [ -f "$candidate" ]; then
       found="$candidate"
       break

package/pipeline/lib/post-pr-review.sh

@@ -45,10 +45,12 @@ if [ -z "$TASK_ID" ]; then
   exit 64
 fi
 
-# Resolve agent-state.json (matches phase-tracker convention).
+# Resolve agent-state.json. multi-repo-pipeline.sh writes it under a
+# per-project directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/)
+# - not the ~/.claude/projects/*/state/ path this used to glob, which no
+# writer in the pipeline ever populates.
 AGENT_STATE=""
-for dir in "$HOME"/.claude/projects/*; do
-  candidate="$dir/state/$TASK_ID/agent-state.json"
+for candidate in "$HOME"/.claude/logs/multi-agent/*/"$TASK_ID"/agent-state.json; do
   if [ -f "$candidate" ]; then
     AGENT_STATE="$candidate"
     break
@@ -302,11 +304,11 @@ post_bitbucket_server() {
 
   # Resolve credential keys from prefs.keychainMapping  -  never hardcode.
   prefs="$HOME/.claude/multi-agent-preferences.json"
-  user_key=$(jq -r '.keychainMapping.bitbucket_user // empty' "$prefs" 2>/dev/null || true)
-  token_key=$(jq -r '.keychainMapping.bitbucket_token // empty' "$prefs" 2>/dev/null || true)
+  user_key=$(jq -r '.global.keychainMapping.bitbucket_user // empty' "$prefs" 2>/dev/null || true)
+  token_key=$(jq -r '.global.keychainMapping.bitbucket_token // empty' "$prefs" 2>/dev/null || true)
 
   if [ -z "$user_key" ] || [ -z "$token_key" ]; then
-    echo "post-pr-review: keychainMapping.bitbucket_user / .bitbucket_token unset in $prefs" >&2
+    echo "post-pr-review: global.keychainMapping.bitbucket_user / .bitbucket_token unset in $prefs" >&2
     return 4
   fi
 

package/pipeline/lib/shadow-git.sh

@@ -222,19 +222,60 @@ do_prune() {
     rm -rf "$sd"
     printf 'shadow-git: pruned shadow repo for %s\n' "$task_id" >&2
   else
-    # Trim history (truncate to last N snapshots within the window). For now,
-    # implement as "rewind to oldest commit within window".
     [ ! -d "$sd/.git" ] && { err "no shadow for $task_id"; exit 1; }
+    # Retention never touches a real work-tree: this used to run
+    # `reset --hard` with --work-tree=$(pwd), silently rewriting whatever
+    # directory prune happened to be invoked from, and it kept the OLDEST
+    # commit inside the window while discarding every newer one - backwards
+    # for a "keep the last N days" policy. Every git call below is
+    # git-dir-only plumbing (log/rev-parse/commit-tree/update-ref/gc - no
+    # checkout, no reset, no clean); the one --work-tree `sg` still wants
+    # points at $sd itself, which prune already owns.
+    local branch
+    branch=$(sg "$sd" "$sd" symbolic-ref --short HEAD)
     local cutoff_epoch
     cutoff_epoch=$(($(date +%s) - older * 86400))
-    local keep_sha
-    keep_sha=$(sg "$sd" "$(pwd)" log --pretty='%H %ct' | awk -v c="$cutoff_epoch" '$2 >= c {print $1}' | tail -1)
-    if [ -n "$keep_sha" ]; then
-      printf 'shadow-git: oldest snapshot kept within window: %s\n' "$keep_sha" >&2
-      # Hard-reset history to that snapshot. (Conservative: GC unreachable.)
-      sg "$sd" "$(pwd)" reset --hard --quiet "$keep_sha" || true
-      sg "$sd" "$(pwd)" gc --prune=now --quiet 2>/dev/null || true
+    # Commits strictly within the window, oldest first: what survives.
+    local keep_shas
+    keep_shas=$(sg "$sd" "$sd" log --reverse --pretty='%H %ct' "$branch" \
+      | awk -v c="$cutoff_epoch" '$2 >= c {print $1}')
+    if [ -z "$keep_shas" ]; then
+      printf 'shadow-git: no snapshot for %s is within %s day(s); nothing pruned\n' "$task_id" "$older" >&2
+      return 0
     fi
+    # Replay the surviving commits onto a fresh chain (oldest becomes the new
+    # root) so everything older than the cutoff becomes unreachable and
+    # gc-able, while every kept snapshot's tree/message/author/committer date
+    # is preserved exactly (committer date matters: it's what the NEXT prune
+    # run's cutoff math reads, so it must stay the original snapshot time,
+    # not "now").
+    local prev="" sha tree msg adate cdate aname aemail cname cemail
+    while IFS= read -r sha; do
+      [ -z "$sha" ] && continue
+      tree=$(sg "$sd" "$sd" rev-parse "$sha^{tree}")
+      msg=$(sg "$sd" "$sd" log -1 --format=%B "$sha")
+      adate=$(sg "$sd" "$sd" log -1 --format=%ad --date=raw "$sha")
+      cdate=$(sg "$sd" "$sd" log -1 --format=%cd --date=raw "$sha")
+      aname=$(sg "$sd" "$sd" log -1 --format=%an "$sha")
+      aemail=$(sg "$sd" "$sd" log -1 --format=%ae "$sha")
+      cname=$(sg "$sd" "$sd" log -1 --format=%cn "$sha")
+      cemail=$(sg "$sd" "$sd" log -1 --format=%ce "$sha")
+      if [ -n "$prev" ]; then
+        prev=$(printf '%s' "$msg" \
+          | GIT_AUTHOR_NAME="$aname" GIT_AUTHOR_EMAIL="$aemail" GIT_AUTHOR_DATE="$adate" \
+            GIT_COMMITTER_NAME="$cname" GIT_COMMITTER_EMAIL="$cemail" GIT_COMMITTER_DATE="$cdate" \
+            git --git-dir="$sd/.git" commit-tree "$tree" -p "$prev")
+      else
+        prev=$(printf '%s' "$msg" \
+          | GIT_AUTHOR_NAME="$aname" GIT_AUTHOR_EMAIL="$aemail" GIT_AUTHOR_DATE="$adate" \
+            GIT_COMMITTER_NAME="$cname" GIT_COMMITTER_EMAIL="$cemail" GIT_COMMITTER_DATE="$cdate" \
+            git --git-dir="$sd/.git" commit-tree "$tree")
+      fi
+    done <<<"$keep_shas"
+    git --git-dir="$sd/.git" update-ref "refs/heads/$branch" "$prev"
+    sg "$sd" "$sd" gc --prune=now --quiet 2>/dev/null || true
+    printf 'shadow-git: pruned snapshots older than %s day(s) for %s (kept %s)\n' \
+      "$older" "$task_id" "$(printf '%s\n' "$keep_shas" | wc -l | tr -d ' ')" >&2
   fi
 }
 

package/pipeline/lib/submodule-detector.sh

@@ -168,10 +168,17 @@ case "$MODE" in
       echo "[]"
       exit 0
     fi
+    # emit_json already prints a valid "[]" on empty/unparseable stdin (a
+    # failed `gh api` call, under pipefail, still runs it through the rest of
+    # this pipe with empty input) - the `|| echo "[]"` fallback used to ALSO
+    # fire on the pipeline's own (gh api's) non-zero exit, printing a SECOND
+    # "[]" line and leaving invalid double-JSON on stdout. `|| true` keeps
+    # the local-mode contract (unreachable submodule data -> empty list,
+    # exit 0, never a hard error) without re-printing anything.
     gh api "repos/$TARGET/contents/.gitmodules" \
         --jq '.content' 2>/dev/null \
       | tr -d '\n' \
       | base64 --decode 2>/dev/null \
-      | emit_json || echo "[]"
+      | emit_json || true
     ;;
 esac

package/pipeline/multi-agent-refs/_input-parser.md

@@ -6,7 +6,7 @@ description: "Internal  -  input type detection for multi-agent dispatcher."
 
 The top-level `multi-agent` command classifies user arguments per the rules below.
 
-> **Language**: Schema reference only  -  no user-facing text. Picker `label` + `header` always English (`promptLanguage` is locked to `"en"`); `question` + `description` follow `outputLanguage` per the `rules.md` matrix. Commit/PR/Jira payloads stay English.
+> **Language**: Schema reference only  -  no user-facing text. Picker `label` + `header` always English (`promptLanguage` is locked to `"en"`); `question` + `description` follow `outputLanguage` per the `rules.md` matrix. Commit messages, branch names and PR titles stay English; PR/Jira/Confluence **bodies** follow `outputLanguage`.
 
 ## Type Table
 

package/pipeline/multi-agent-refs/channels/confluence.md

@@ -116,11 +116,14 @@ Auto-suggested as `"{jiraId}  -  {taskTitle}"`  -  user can edit at the prompt.
 | Inline `code` | `<code>code</code>` |
 | Links `[t](u)` | `<a href="u">t</a>` |
 | Lists | `<ul><li>...</li></ul>` / `<ol><li>...</li></ol>` |
+| ` ```mermaid ` fences | `ac:name="mermaid"` macro (`md2confluence-v3.py` implements it, with a numbered-list fallback when the space lacks the plugin)  -  not the generic code macro |
 
 Body is run through humanizer before XML conversion  -  Confluence tone is the most formal of the four channels (target audience: stakeholders, PMs, designers).
 
 ## POST contract
 
+The paths below are relative to the API base, which depends on the Confluence flavor  -  resolve it the way `lib/fetch-confluence.sh` already does: hosts matching `*atlassian.net` (Cloud) use `https://<host>/wiki/rest/api`, everything else (Server / Data Center) uses `https://<host>/rest/api`. On Cloud the un-prefixed form 404s on every call. (Cloud also serves a v2 API at `/wiki/api/v2` with ADF bodies; this adapter stays on v1 + storage format, which both flavors accept.)
+
 ```
 POST /rest/api/content
 {

package/pipeline/multi-agent-refs/channels/issue-comment.md

@@ -43,7 +43,7 @@ The template (this doc) is English because `promptLanguage="en"` is locked. At w
 <one line per repo touched; never collapse multiple repos into one>
 
 ### Acceptance Criteria
-- [<x|·>] <AC text  -  `x` if delivered, `·` if intentionally deferred (with `(deferred: <reason>)` suffix)>
+- [<x| >] <AC text  -  `x` if delivered, space if intentionally deferred (with `(deferred: <reason>)` suffix)>
 <one bullet per AC item from the issue body, or per implicit AC if the issue had none>
 
 ### Build & Test
@@ -65,7 +65,7 @@ Ref: #<issueNumber>
 - **`title`**  -  always wraps the component or task name in backticks. No emoji.
 - **`summary`**  -  1-3 paragraphs, **why** before **what**. No bullet lists in the summary block  -  those belong in `acceptance_criteria`.
 - **`prs_branches`**  -  every repo the run touched gets exactly ONE line. If the PR was deferred, write the branch + commit SHA explicitly so the reader can `gh pr create` from there. Never collapse multiple repos into one line.
-- **`acceptance_criteria`**  -  copy from the issue body verbatim when an `### Acceptance Criteria` section exists. If the section is `_No response_`, the agent enumerates the implicit ACs it satisfied during Phase 1/3. `[x]` only when delivered and verified; `[·]` for deferred (with reason in parens).
+- **`acceptance_criteria`**  -  copy from the issue body verbatim when an `### Acceptance Criteria` section exists. If the section is `_No response_`, the agent enumerates the implicit ACs it satisfied during Phase 1/3. `[x]` only when delivered and verified; `[ ]` for deferred, with the reason in parens  -  GitHub's task-list syntax accepts only `[ ]` and `[x]`, any other marker (a `·` was used here once) renders as literal bracket text instead of a checkbox, and the `(deferred: <reason>)` suffix is what distinguishes deferred from merely unchecked.
 - **`build_and_test`**  -  required. If a build failure was pre-existing, the line includes the baseline SHA where the failure was reproduced (per `feedback_build_baseline_proof.md`).
 - **`figma_extras`**  -  emitted only when `state.taskType == "component"` and the figma sub-pipeline ran.
 - **`next_steps`**  -  empty list is fine; the section header itself stays. Empty signals "fully complete, no follow-ups".

package/pipeline/multi-agent-refs/channels/jira.md

@@ -64,14 +64,25 @@ Body markdown is rewritten to Jira wiki markup before POST:
 
 | Markdown | Jira wiki |
 |---|---|
-| `### Heading` | `*Heading*` |
+| `## Heading` | `h2. Heading` |
+| `### Heading` | `h3. Heading` |
+| `**bold**` | `*bold*` |
+| `1. item` / `2. item` | `# item` (Jira does not render `1.` as an ordered list) |
+| `- item` | `* item` |
 | `- [ ] task` / `- [x] task` | `# task` (numbered list  -  Jira renders TODO checkboxes inconsistently) |
 | `` `code` `` | `{{code}}` |
-| Tables (` | h | h | / | --- | --- |`) | `||h||h||` then `|c|c|` rows |
+| `[text](url)` | `[text\|url]` |
+| Tables (`\| h \| h \|` / `\| --- \| --- \|`) | `\|\|h\|\|h\|\|` then `\|c\|c\|` rows |
 | Code fences ` ```lang ` | `{code:lang} ... {code}` |
 
+The `\|` sequences in the two link/table rows are this table's own escape for a literal pipe  -  the emitted Jira markup carries `|`, never `\|`.
+
 Lines outside these patterns pass through verbatim. Multi-paragraph blocks are joined with one blank line.
 
+Every row above is load-bearing, including the ones that look cosmetic. The table must cover each construct the section templates in this file actually emit  -  `##` for the three required headings, `**Given**` / `**When**` / `**Then**` in the test-scenario skeleton, and `1.`-numbered scenarios. A missing row does not degrade gracefully: the "pass through verbatim" fallback POSTs `## Test Senaryoları` and `**Given**` as literal text, so the comment renders with visible `##` and stray asterisks. Single `*bold*` in Markdown means *italic* in Jira wiki  -  never map `**bold**` to `*bold*` by dropping one asterisk mechanically without checking the source was bold, not italic.
+
+There is no markdown→Jira-wiki converter program in the pipeline (`lib/` ships `md2confluence-v3.py` for Confluence only). This table is applied by the model, by hand, which is exactly why it has to be complete.
+
 ## Cross-link injection
 
 The adapter prepends the linked PR URL on the **first line** so reviewers can jump to the PR with one click:

package/pipeline/multi-agent-refs/channels/pr-review-actions.md

@@ -78,7 +78,7 @@ If a finding's `line` falls outside the diff (review of unchanged code), the anc
 | Provider | Approve | Needs Work / Request Changes |
 |---|---|---|
 | GitHub | `gh pr review <N> --approve` | `gh pr review <N> --request-changes --body "<empty>"` |
-| Bitbucket Server | `PUT /pull-requests/{id}/participants/{userSlug}` body `{"status":"APPROVED"}` | `PUT /pull-requests/{id}/participants/{userSlug}` body `{"status":"NEEDS_WORK"}` |
+| Bitbucket Server | `PUT /rest/api/1.0/projects/{key}/repos/{slug}/pull-requests/{id}/participants/{userSlug}` body `{"status":"APPROVED"}` | same path, body `{"status":"NEEDS_WORK"}` |
 
 The Bitbucket needs-work pattern keeps the user as REVIEWER role; status flip is the visible "Request changes" signal in the UI.
 

package/pipeline/multi-agent-refs/channels/pr.md

@@ -75,6 +75,22 @@ Never use `Closes #N`, `Fixes #N`, `Resolves PROJ-X`. Issues require 4-approval
 5. Dispatch per the Behaviour-by-remote table.
 ```
 
+## Markup dialect (per surface, not per pipeline)
+
+The PR body is **Markdown** on every supported remote  -  GitHub, Bitbucket Server, and GitLab all render Markdown in the description field. Emit the assembled markdown verbatim; there is no conversion step on this adapter.
+
+Jira wiki markup in a PR body is a defect, not a style choice. The Jira adapter's conversion table (`channels/jira.md` "Wiki markup conversion") applies to the **Jira comment only** and must never be reached from here. Concretely, in a PR body:
+
+| Never in a PR body | Renders as | Use instead |
+|---|---|---|
+| `h2. Title` / `h3. Title` | literal text `h2. Title` | `## Title` / `### Title` |
+| `{{identifier}}` | literal braces `{{identifier}}` | `` `identifier` `` |
+| `# item` for a numbered list | an H1 heading, one giant line per item | `1. item` |
+| `{code:swift} ... {code}` | literal braces | fenced ` ```swift ` block |
+| `*bold*` | italic in Markdown, not bold | `**bold**` |
+
+The two adapters run in the same phase over the same source markdown, so the failure mode is a converter applied to the wrong target: the Jira comment is correct and the PR body ships raw wiki markup. Assemble once in markdown, then convert **only** on the Jira branch.
+
 ## Behaviour by remote
 
 | Remote | API | Reviewer handling |
@@ -106,6 +122,10 @@ curl -s -X PUT -u "$BB_USER:$BB_TOKEN" -H "Content-Type: application/json" \
      --data-binary @/tmp/channels-$TASK_ID-pr-payload.json "$PR_URL"
 ```
 
+Verify after every PUT: refetch the PR and compare `reviewers | length` against the pre-PUT count. A drop means the payload lost the field  -  repair immediately.
+
+`POST /pull-requests/{id}/participants` is **repair-only**, never the primary path. It accepts one user per call, so restoring N reviewers writes N separate "added 1 reviewer" rows into the PR activity feed, and Bitbucket activity entries cannot be deleted. A PR that opened with 22 reviewers in one clean create call and then shows 22 individual re-adds is a visible, permanent record of a dropped-reviewer PUT. Carry `reviewers` through the payload above instead.
+
 ## Multi-repo cross-links
 
 When `state.projects[].length > 1`, `channels-multi-repo.sh render-pr <state> <body> <repoName>` prepends a `## Related PRs` block:

package/pipeline/multi-agent-refs/channels/wiki.md

@@ -34,9 +34,9 @@ The selected scope routes to a platform skill:
 
 | Platform | Skill | Notes |
 |---|---|---|
-| iOS / SwiftUI | `ai-ios-engineering-toolkit:figma-component-wiki` | Reads `Configuration` + `+Modifiers` from the source, captures Figma screenshots via MCP / REST, runs Snapshot tests for iOS dark/light/RTL. |
-| Android / Compose | `ai-android-engineering-toolkit:figma-component-wiki` | Reads Compose composables + previews, runs Paparazzi screenshots if available, otherwise generates from layout inspector. |
-| Generic | `ai-ios-engineering-toolkit:figma-component-wiki` (fallback) | Used when `state.platform` is unknown (fallback path  -  typically a flag). |
+| iOS / SwiftUI | `ai-ios-toolkit:figma-component-wiki` | Reads `Configuration` + `+Modifiers` from the source, captures Figma screenshots via MCP / REST, runs Snapshot tests for iOS dark/light/RTL. |
+| Android / Compose | `ai-android-toolkit:figma-component-wiki` | Reads Compose composables + previews, runs Paparazzi screenshots if available, otherwise generates from layout inspector. |
+| Generic | `ai-ios-toolkit:figma-component-wiki` (fallback) | Used when `state.platform` is unknown (fallback path  -  typically a flag). |
 
 Full per-skill contract: `$HOME/.claude/multi-agent-refs/wiki-capture.md`.
 
@@ -62,6 +62,6 @@ Adapter implementation chooses the right git push target + commit message format
 - Wiki adapter is the **only** channel allowed to skip silently when its precondition gate fails. PR / Jira / Confluence always run when selected.
 - Per the `figma-pipeline.md` rules, every component wiki page must include a variant matrix, accessibility identifiers, analytics events, and 3-layer test summary.
 - Screenshots cover light/dark + LTR/RTL  -  wiki adapter refuses to commit if any quadrant is missing.
-- Body content language follows `prefs.global.outputLanguage`. Code identifiers, file paths, type names, design token names, and wiki markup stay verbatim across languages. The template (this doc) is English because `promptLanguage="en"` is locked.
+- Body content language follows `prefs.global.outputLanguage`. Code identifiers, file paths, type names, design token names, and Markdown formatting stay verbatim across languages (wiki pages are `.md` files  -  "wiki markup" in this doc set means Jira's dialect, which never appears here). The template (this doc) is English because `promptLanguage="en"` is locked.
 - No decorative/emotive emoji or smileys (😊 🙂 🎉 👍 🚀 ✨) in the page prose. Only functional/structural marks a fixed template defines are allowed.
 - Autopilot always pauses at the channels menu (per `phase-7-report.md` autopilot contract)  -  even in autopilot mode the user gets to confirm wiki scope.