@mmerterden/multi-agent-pipeline 16.3.0 → 16.4.0

package/CHANGELOG.md

@@ -16,6 +16,116 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ## [Unreleased]
 
+## [16.4.0] - 2026-08-24
+
+Two default changes are worth reading before upgrading. `/multi-agent:analysis`
+no longer overwrites a Jira issue's description - it posts a comment unless you
+explicitly choose the description, which is then backed up first. And Phase 6
+gained a blocking gate: a plan step that never reached a terminal status stops
+the commit instead of surfacing in the Phase 7 report afterwards. Both are
+corrections to behaviour that lost work quietly; neither changes a command name
+or an option.
+
+Four ideas taken from github/spec-kit, obra/superpowers, karpathy/llm-council and yamadashy/repomix after auditing all five candidate repos against this pipeline at source level. Most of what those projects do the pipeline already had (spec-kit's constitution is `analysis/locked.md`, its `/analyze` is `validate-analysis-doc.mjs`, repomix's packed digest is `repo-map.mjs`, its offload pattern is Phase 4 Step 1.9, its secretlint pass is Gate 4 before any reviewer runs, serena's memories are the learnings ledger). These are the four gaps that were real.
+
+### Fixed
+
+- **The triage model could recognise its own findings.** On Claude Code the reviewers are Fable + Sonnet and triage is Fable; on Copilot CLI the reviewers include Opus and triage is Opus. Step 3.2 handed that model a list labelled "Reviewer 1 + Reviewer 2", and the Step 2.5 rebuttal round showed each reviewer "the OTHER reviewers'" findings by attribution - so the judge was marking its own homework, and the word "anonym" appeared nowhere in the pipeline. `scripts/anonymize-findings.mjs` now strips every identity key, relabels findings `Source A/B/C`, and orders them with a PRNG seeded from `taskId:iteration` after a stable content sort, so reviewer completion order cannot leak through position and `/multi-agent:resume` reproduces the same input. The label map is written to a separate file and never enters a prompt. Pattern source: llm-council `backend/council.py` stage 2; the delta is deliberate, since llm-council anonymizes only its peer-ranking step and lets its chairman see names - our triage is chairman AND panel member.
+- **An unfinished plan could reach commit.** Phase 4 answers whether the diff is correct, Step 1.45 covers the planned tests, and the criteria manifest's denominator is rule IDs. Nothing covered the plan's own steps: the `[done]` / `[pending]` rollup is rendered in Phase 7, after the commit. `scripts/plan-coverage-gate.mjs` runs as Phase 6 Step 0a and fails when a step never reached a terminal status, when a skip or failure carries no reason, or when an analysis Section 14 row tagged `Add new` names a file that is not in the tree. Pattern source: spec-kit `converge` - current state rather than a diff, and a clean run stays quiet. Not copied: spec-kit appends remediation tasks to `tasks.md`; rewriting an approved plan is a Phase 2 decision, not a gate's.
+
+### Added
+
+- **Test baseline (`prefs.global.testBaseline`, default off).** Phase 4 Gate 3 had no way to tell an inherited red suite from one this run broke, so it blocked on someone else's bug or the dev agent "fixed" tests it never touched (`shadow-git.sh init` snapshots files, not test results). Phase 0 Step 7.6 now runs the same command Gate 3 uses, time-capped, and records `state.baseline.tests` with one of three statuses: `green`, `red` with the failing set, `red` with an empty set plus the log path when the output cannot be parsed into names, or `unknown`. Gate 3 subtracts a known failing set, refuses to either pass or silently block on an unparseable red, and leaves today's behaviour untouched when there is no baseline. Pattern source: superpowers `using-git-worktrees` Step 3, extended from ask-the-user to a stored set.
+- **`smoke-triage-anonymity.sh` (17 assertions), `smoke-plan-coverage.sh` (15), `smoke-test-baseline.sh` (13).** Each proves the behaviour, not the prose: identity keys really are stripped, no model name survives in the payload, the same seed reproduces the order and a different seed does not, reviewer order does not change finding order, per-reviewer metrics degrade to `unavailable` instead of inventing a zero, every unaccounted todo shape is caught, Reuse/Modify rows and template placeholders are not counted against the tree, and no doc collapses baseline `unknown` into `green`.
+
+### Changed
+
+- **`reviewIterations[].reviewers` is typed.** It was `{"type": "array"}` with no item schema, so nothing said a reviewer entry names its model. Now `model`, `findings[]` and `roundCount` are declared, with nothing required: a run written before this shape still validates and surfaces as `unknown` rather than being folded into a named model.
+- **`run-metrics.mjs` reports signal-to-noise per reviewer.** `acceptedRatio` pooled every reviewer together, so "which model is worth dispatching" had no answer. With the anonymization map present, accepted findings are attributed back per model; without it the raw counts still land and `perReviewerAttribution` says `unavailable`. Pattern source: llm-council `calculate_aggregate_rankings`.
+- **`smoke-gate-wiring.sh` matches the property, not the section title.** It grepped for the literal heading "3.0 Merge the deterministic findings in" and reported a wiring break when that section was retitled, while the wiring was intact. It now checks that 3.0 merges, that 3.1 reads the merged count, and that anonymization precedes the merge - relabelling gate findings as reviewer findings would cost triage the difference between a fact and a raw signal.
+- **`total_max_tokens` 56600 -> 57600.** Three new phase-doc contracts cost about 1000 tokens after trimming the drafts by 500. Every individual phase stays inside its own max and `phase-0-init` is back under its warn line; only the aggregate needed the same incremental bump the last three feature commits made.
+
+### Fixed (same release, found by reviewing the four items above)
+
+- **`run-metrics` understated a reviewer on a mixed-map run.** `attributed` was a
+  single global flag, so an iteration with no label map still added its findings
+  to the per-reviewer denominator while being unable to contribute a numerator. A
+  resumed run that upgraded mid-flight read as noise the reviewer was never
+  credited for. The denominator is now the attributable raw count,
+  `rawAttributable` is reported next to `rawFindings`,
+  `mappedIterations` says how many iterations carried a map, and
+  `acceptedUnattributed` counts every accepted finding that resolves to no
+  reviewer - a deterministic-gate finding, which carries no `foundBy` by design,
+  or anything from an iteration that had no map - so
+  `acceptedAll === sum(perReviewer.accepted) + acceptedUnattributed` holds.
+- **`anonymizationMap` was referenced but never declared.** Phase 4 Step 3.0
+  writes it and `run-metrics.mjs` reads it, yet it appeared nowhere in
+  `agent-state.schema.json` - it validated only because the iteration object
+  allows extra keys. That is the same declared-but-undeclared shape the typed
+  `reviewers` entry was added to close. Now declared with `seed` and
+  `labelToModel`.
+- **`anonymize-findings.mjs` documented an exit code it could not reach.** The
+  header promised `64 usage`, but the TTY guard was lost when the file was
+  rewritten, so a bare invocation blocked on stdin forever and 64 was
+  unreachable. Restored, and verified through a pty rather than a pipe.
+- **`plan-coverage-gate.mjs` could skip a real Section 14 row.** A header-row
+  filter matched `^(dosya|file)\b` against the PATH column, so a promised file
+  under a `File/` directory left the denominator silently. The filter was
+  redundant anyway - the header's tag cell already fails the `Add new` test - so
+  it is gone, with a fixture row proving it.
+- **Two gate assertions claimed more than their code.**
+  `smoke-triage-anonymity.sh` said "no model name appears anywhere in the
+  payload" when the guarantee is structural (no identity FIELD survives; free
+  text is deliberately not scrubbed, because that would mangle a finding about
+  `ClaudeService.swift`), and the limit is now stated in both the gate and the
+  script header. `smoke-gate-wiring.sh` matched a section title instead of the
+  property and reported a wiring break on a retitled but intact section.
+
+### Fixed (review round 2)
+
+- **The Section 14 file check was wired to a variable nothing sets.** Phase 6
+  passed `${ANALYSIS_DOC:+--analysis "$ANALYSIS_DOC"}`, and `ANALYSIS_DOC` is
+  defined nowhere in the pipeline - so in practice that half of the gate never
+  ran. The real location is `state.analysis.docPath[]`, an array with one entry
+  per platform (Phase 1 Step 4), and `--analysis` is now repeatable so every
+  platform's promised files enter one denominator instead of the first one
+  standing in for the run.
+- **A plan with zero steps passed.** `todos: []` reported `0/0 steps accounted
+  for` and exited 0, so a Phase 2 that produced nothing - or a state whose todos
+  were cleared - read as a fully delivered plan. An empty plan is now exit 2,
+  the same as a missing one.
+- **A malformed reviewer dispatch vanished.** A reviewer whose `findings` came
+  back as an object contributed nothing and said nothing, so triage adjudicated
+  a smaller panel than actually ran. The anonymizer now warns on stderr and
+  records the loss in the map under `malformed`, named by label.
+- **A residual that anonymization does not remove is written down.** With two
+  reviewers the label set is `{Source A, Source B}` and the triage model is one
+  of them, so it keeps a 50% prior on which findings are its own. The value is
+  that nothing tells it; llm-council's four-model council has a stronger version
+  of the same property.
+
+### Not adopted, with reasons
+
+- **tree-sitter symbol extraction (repomix `--compress`).** `repo-map.mjs` extracts declarations by regex and tree-sitter would be more accurate, but `package.json` has `"dependencies": {}` and that zero-runtime-dependency property is deliberate. If accuracy is wanted, LSP is the compatible route.
+- **serena-style symbol-level reuse detection.** Locked 11's `Reuse existing X (file:line)` rows rest on regex and would benefit, but it means rewriting the Phase 1b collector, and serena was only read at README level. Separate work.
+- **Per-task `verification` field (superpowers).** Not a failure class, overlaps the coverage gate above, and touches schema plus plan approval plus the Phase 3 evidence chain - the widest blast radius of the five candidates.
+- **spec-kit `extensions.yml` hooks.** A HookExecutor layer above the existing `prefs` flags, for one maintainer.
+
+### Fixed - Jira channel
+
+- **`/multi-agent:analysis` overwrote the Jira issue description.** The Jira output target was a bare `PUT /rest/api/2/issue/{key}` on the `description` field: one write, no read first, no backup, no preview. An issue whose description held the reporter's own requirement text lost it silently - the picker asked which issue, never what would happen to it. Publishing now goes through `lib/jira-publish.sh`, and the destination question has three answers with **Comment pre-selected** (a comment cannot destroy anything, and it is what an unattended run gets). The description path reads the current value first, writes it to `~/.claude/logs/multi-agent/jira-backups/<KEY>-description-<stamp>.txt` and reports the path, appends below a `----` rule by default, and exits 3 rather than replacing a non-empty field unless the user's explicit "Description - replace" answer supplies `--confirm-overwrite`. The body is escaped by `jira-wiki-escape.mjs` on both paths, and the bearer token is passed through a curl `-K` config so it never reaches argv.
+
+- **A Jira comment showed a smiley nobody typed.** The body referenced the Swift selector `login(source:input:)`, whose trailing `:)` Jira's wiki renderer turns into an emoticon image at render time. `channels/jira.md` had carried an "Emoticon escaping (required)" table with all 21 sequences for releases, and its own text said the table "is applied by the model, by hand" - so on a long body it was skipped, silently. The escape is now `pipeline/scripts/jira-wiki-escape.mjs`: it backslash-escapes each documented sequence, skips `{code}` / `{noformat}` blocks, reaches inside `{{monospace}}` (Jira parses emoticons there too), and is idempotent. `--check` is the inverse, for a pre-POST assertion. Wired into all nine Jira comment/description write sites (channels adapter, analysis description PUT, generate-issue create, wiki-to-Jira triad, readiness review, create-jira).
+
+### Added - Jira channel
+
+- **`smoke-jira-publish.sh`** - 20 assertions over the safe-write contract, driven by a curl stub so nothing touches the network: comment is the default target, the description path GETs before it writes, the backup exists even on the refused path, a blind replace is refused, a confirmed one writes only the new body, an empty description needs no ceremony, `--dry-run` sends nothing, and the token never appears in argv. It also holds `analysis/render.md` to the contract, so the bare description PUT cannot come back in prose.
+
+### Changed - Jira channel
+
+- **`smoke-channel-glyphs.sh` section 3 tests behavior instead of prose.** It used to grep `channels/jira.md` for the escaping table and pass - the table was present, and nothing applied it. It now runs the program: the exact selector that caused the bug, the monospace case, the code-block skip, idempotency, both `--check` exit codes, and a table-to-program tie that reads the 21 sequences out of the doc rather than retyping them, so the doc and the program cannot drift apart in either direction. It also asserts every known Jira write site routes through the escape, which is how a new write site that skips it gets caught.
+- **`pipeline/scripts/README.md` counts recounted from the filesystem** - the header said 148 shell + 45 `.mjs` and the smoke heading said 118 files; the tree holds 186 shell, 58 `.mjs`, 151 smokes.
+
 ## [16.3.0] - 2026-08-24
 
 Three defects the 16.2.0 review named but did not close, plus one it caused.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "16.3.0",
+  "version": "16.4.0",
   "description": "8-phase AI development pipeline with full orchestration on Claude Code, Copilot CLI and Codex CLI. Analysis, planning, TDD, CLI-aware parallel review with consensus surfacing + Fable triage, default-FAIL evidence gates, secret + intent guards, per-phase cost ledger, persistent learnings memory, wiki generation, commit automation. Token-preserving uninstall.",
   "type": "module",
   "main": "index.js",

package/pipeline/commands/multi-agent/analysis/SKILL.md

@@ -50,7 +50,7 @@ Full contract: `$HOME/.claude/multi-agent-refs/analysis/synthesis.md`. Pass A bu
 
 ### Phases 3, 3.5, 4, 5 - Render, publish, report
 
-Full contract: `$HOME/.claude/multi-agent-refs/analysis/render.md`. Renders one markdown file per platform, runs the **required** `ai-common-toolkit:humanizer` pass, gates on `validate-analysis-doc.mjs`, asks for the output destination, dispatches to Local / Confluence / Jira, then reports and stops. The humanizer pass and the validator are required in every mode; a document that skipped either is not shippable.
+Full contract: `$HOME/.claude/multi-agent-refs/analysis/render.md`. Renders one markdown file per platform, runs the **required** `ai-common-toolkit:humanizer` pass, gates on `validate-analysis-doc.mjs`, asks for the output destination, dispatches to Local / Confluence / Jira (a Jira issue receives a comment unless the user explicitly asks for the description, which is never overwritten without a backup and a confirmation), then reports and stops. The humanizer pass and the validator are required in every mode; a document that skipped either is not shippable.
 
 ### Resume contract
 
@@ -106,6 +106,7 @@ When `phase == "cancelled_at_pass_b_preview"`:
 | `$HOME/.claude/rules/tdd.md` | Section 15 test naming |
 | `$HOME/.claude/multi-agent-refs/analysis-template.md` | Template master copy + language matrix (v3 - 23 sections) |
 | `$HOME/.claude/multi-agent-refs/conventions-defaults.md` | Pass B fallback defaults (4 platforms x 7 pattern groups) - applied when convention confidence is none AND standards binding is silent |
+| `$HOME/.claude/lib/jira-publish.sh` | Phase 4 Jira write: comment by default, description only on explicit choice - reads the current description first, backs it up, appends below a rule, refuses a non-empty replace without `--confirm-overwrite` |
 | `$HOME/.claude/scripts/validate-analysis-doc.mjs` | Phase 4 pre-dispatch gate: deterministic check of the emitted per-platform doc (front-matter, never-omitted sections, humanizer punctuation, Full-mode BR traceability) |
 | a project-supplied Confluence-embedded API-table parser (optional) | Parse endpoints from a Confluence page's Request Path / Service Name / Response Body table columns |
 | `~/<project>-Standards.md` | Canonical home-dir standards reference (auto-detected at Q5 option 2; exact filename from `prefs.projects[<project>].standardsFile`) |

package/pipeline/commands/multi-agent/channels/SKILL.md

@@ -369,7 +369,7 @@ Aggregated Markdown from Step 5 → PR description. GitHub uses `gh pr edit --bo
 Full contract: [`$HOME/.claude/multi-agent-refs/channels/pr.md`]($HOME/.claude/multi-agent-refs/channels/pr.md)  -  Bitbucket payload assembly snippet, version-mismatch retry, `--ready` promotion, multi-repo cross-link block.
 
 #### Adapter: Jira comment
-Body converted to Jira wiki markup (`### ...` → `*...*`, `- [ ] ...` → `# ...`, `` `x` `` → `{{x}}`, tables to `||h||h|| |c|c|`); first line is the PR URL. POST `/rest/api/2/issue/{id}/comment` via heredoc + `jq --rawfile` + `curl --data-binary @file`. Token resolved from `keychainMapping.jira`.
+Body converted to Jira wiki markup (`### ...` → `*...*`, `- [ ] ...` → `# ...`, `` `x` `` → `{{x}}`, tables to `||h||h|| |c|c|`); first line is the PR URL. The converted body then goes through `node "$HOME/.claude/scripts/jira-wiki-escape.mjs"` (required, not optional  -  Jira renders `:)` `(x)` `(!)` `(/)` as emoticon images, and a Swift selector like `login(source:input:)` ends in `:)`). POST `/rest/api/2/issue/{id}/comment` via heredoc + `jq --rawfile` + `curl --data-binary @file`, from the escaped file. Token resolved from `keychainMapping.jira`.
 
 Full contract: [`$HOME/.claude/multi-agent-refs/channels/jira.md`]($HOME/.claude/multi-agent-refs/channels/jira.md)  -  full conversion table, multi-repo PR-list prepend, Wiki→Jira triad interaction.
 

package/pipeline/commands/multi-agent/prune-logs/SKILL.md

@@ -20,6 +20,13 @@ Unlike `/multi-agent:purge` (which wipes worktrees, branches, logs, and state
 together), this only removes log dirs and leaves your worktrees and branches
 untouched.
 
+Not in scope: `~/.claude/logs/multi-agent-toolkit/`, the sibling directory where
+`multi-agent-toolkit-mcp` saves tool outputs too large to return inline. That
+directory prunes itself at write time (newest 50 files, 7 days), because an
+MCP-only user has no pipeline installed and "some other tool cleans it" would
+mean nobody does. Mentioned here so the files are not a mystery when you come
+looking for what is using space under `logs/`.
+
 ## Steps
 
 1. **Preview (dry-run)**  -  run the pruner with no `--yes`, forwarding any

package/pipeline/lib/jira-publish.sh

@@ -0,0 +1,173 @@
+#!/usr/bin/env bash
+#
+# jira-publish.sh
+#
+# Publishes an analysis / report body to a Jira issue without destroying what
+# is already there. Spec: refs/analysis/render.md (Phase 4 Jira target) and
+# refs/channels/jira.md (transport + emoticon escaping).
+#
+# Why this exists: the analysis Jira target used to PUT the description field
+# directly, so an issue whose description held the analyst's original
+# requirement text lost it with no preview, no backup and no undo. A comment
+# cannot destroy anything, so `comment` is the default target; writing the
+# description is opt-in, always backed up first, appends by default, and
+# refuses to replace a non-empty description without an explicit confirmation.
+#
+# Usage:
+#   jira-publish.sh --issue KEY --body-file FILE
+#                   [--target comment|description]   (default: comment)
+#                   [--mode append|replace]          (description only, default: append)
+#                   [--confirm-overwrite]            (required for mode=replace on a non-empty field)
+#                   [--backup-dir DIR]
+#                   [--dry-run]
+#
+# Resolution:
+#   host    JIRA_HOST, else prefs .global.hosts.jira
+#   token   JIRA_TOKEN, else credential-store.sh get <prefs .global.keychainMapping.jira>
+#   The token never reaches argv or a log: it is passed to curl through a -K
+#   config on process substitution, the same idiom as post-pr-review.sh.
+#
+# Every body is run through scripts/jira-wiki-escape.mjs before it is sent, so
+# Jira cannot manufacture an emoticon out of a Swift selector or a table cell.
+#
+# Exit codes:
+#   0  published (or, with --dry-run, previewed)
+#   3  refused: replace would destroy a non-empty description and no
+#      --confirm-overwrite was given. The backup is already on disk.
+#   4  host or token could not be resolved
+#   5  a Jira API call failed
+#  64  usage error
+
+set -euo pipefail
+
+SELF_DIR="$(cd "$(dirname "$0")" && pwd)"
+PREFS="${MULTI_AGENT_PREFS:-$HOME/.claude/multi-agent-preferences.json}"
+CURL="${JIRA_PUBLISH_CURL:-curl}"
+
+ISSUE=""
+BODY_FILE=""
+TARGET="comment"
+MODE="append"
+CONFIRM=0
+DRY_RUN=0
+BACKUP_DIR="${JIRA_BACKUP_DIR:-$HOME/.claude/logs/multi-agent/jira-backups}"
+
+die() { echo "$1" >&2; exit "${2:-64}"; }
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --issue) ISSUE="${2:-}"; shift 2 ;;
+    --body-file) BODY_FILE="${2:-}"; shift 2 ;;
+    --target) TARGET="${2:-}"; shift 2 ;;
+    --mode) MODE="${2:-}"; shift 2 ;;
+    --backup-dir) BACKUP_DIR="${2:-}"; shift 2 ;;
+    --confirm-overwrite) CONFIRM=1; shift ;;
+    --dry-run) DRY_RUN=1; shift ;;
+    -h|--help) sed -n '2,40p' "$0"; exit 0 ;;
+    *) die "unknown argument: $1" ;;
+  esac
+done
+
+[ -n "$ISSUE" ] || die "usage: jira-publish.sh --issue KEY --body-file FILE [--target comment|description]"
+[ -n "$BODY_FILE" ] || die "usage: jira-publish.sh --issue KEY --body-file FILE [--target comment|description]"
+[ -f "$BODY_FILE" ] || die "body file not found: $BODY_FILE"
+case "$TARGET" in comment|description) ;; *) die "--target must be comment or description, got: $TARGET" ;; esac
+case "$MODE" in append|replace) ;; *) die "--mode must be append or replace, got: $MODE" ;; esac
+
+ESCAPER=""
+for cand in "$SELF_DIR/../scripts/jira-wiki-escape.mjs" "$HOME/.claude/scripts/jira-wiki-escape.mjs"; do
+  [ -f "$cand" ] && { ESCAPER="$cand"; break; }
+done
+[ -n "$ESCAPER" ] || die "jira-wiki-escape.mjs not found next to lib/ or in ~/.claude/scripts" 4
+
+HOST="${JIRA_HOST:-}"
+if [ -z "$HOST" ] && [ -f "$PREFS" ]; then
+  HOST=$(jq -r '.global.hosts.jira // empty' "$PREFS" 2>/dev/null || echo "")
+fi
+[ -n "$HOST" ] || die "no Jira host: set JIRA_HOST or prefs .global.hosts.jira" 4
+HOST="${HOST#https://}"; HOST="${HOST#http://}"; HOST="${HOST%/}"
+
+TOKEN="${JIRA_TOKEN:-}"
+if [ -z "$TOKEN" ]; then
+  key="${JIRA_TOKEN_KEY:-}"
+  if [ -z "$key" ] && [ -f "$PREFS" ]; then
+    key=$(jq -r '.global.keychainMapping.jira // empty' "$PREFS" 2>/dev/null || echo "")
+  fi
+  [ -n "$key" ] || die "no Jira token: set JIRA_TOKEN or map prefs .global.keychainMapping.jira" 4
+  TOKEN=$("$SELF_DIR/credential-store.sh" get "$key" 2>/dev/null || echo "")
+  [ -n "$TOKEN" ] || die "Jira token not in the credential store under: $key" 4
+fi
+
+auth_cfg() { printf 'header = "Authorization: Bearer %s"\n' "$1"; }
+api() { "$CURL" -sS -m 30 -K <(auth_cfg "$TOKEN") -H "Content-Type: application/json" "$@"; }
+
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+
+node "$ESCAPER" "$BODY_FILE" > "$WORK/new.txt"
+
+if [ "$TARGET" = "comment" ]; then
+  if [ "$DRY_RUN" = "1" ]; then
+    echo "dry-run: would POST a comment to $ISSUE ($(wc -l < "$WORK/new.txt" | tr -d ' ') lines)"
+    cat "$WORK/new.txt"
+    exit 0
+  fi
+  jq -n --rawfile body "$WORK/new.txt" '{body: $body}' > "$WORK/payload.json"
+  http=$(api -o "$WORK/resp.json" -w '%{http_code}' -X POST \
+    --data-binary @"$WORK/payload.json" \
+    "https://$HOST/rest/api/2/issue/$ISSUE/comment") || http="000"
+  case "$http" in
+    20*) echo "comment posted to $ISSUE (nothing was overwritten)" ;;
+    *) echo "Jira comment POST failed with HTTP $http" >&2; sed -n '1,5p' "$WORK/resp.json" >&2; exit 5 ;;
+  esac
+  exit 0
+fi
+
+# --- description: read before write ------------------------------------------
+http=$(api -o "$WORK/issue.json" -w '%{http_code}' \
+  "https://$HOST/rest/api/2/issue/$ISSUE?fields=description") || http="000"
+case "$http" in
+  200) ;;
+  *) echo "could not read the current description of $ISSUE (HTTP $http)" >&2; exit 5 ;;
+esac
+jq -r '.fields.description // ""' "$WORK/issue.json" > "$WORK/existing.txt"
+
+existing_bytes=$(wc -c < "$WORK/existing.txt" | tr -d ' ')
+existing_lines=$(grep -c . "$WORK/existing.txt" || true)
+
+mkdir -p "$BACKUP_DIR"
+STAMP=$(date +%Y%m%dT%H%M%S)
+BACKUP="$BACKUP_DIR/$ISSUE-description-$STAMP.txt"
+cp "$WORK/existing.txt" "$BACKUP"
+echo "existing description backed up: $BACKUP ($existing_lines non-empty line(s))"
+
+if [ "$existing_bytes" -le 1 ]; then
+  cp "$WORK/new.txt" "$WORK/final.txt"
+  RESULT="written into an empty description"
+elif [ "$MODE" = "append" ]; then
+  { cat "$WORK/existing.txt"; printf '\n\n----\n\n'; cat "$WORK/new.txt"; } > "$WORK/final.txt"
+  RESULT="appended below the existing description"
+else
+  if [ "$CONFIRM" != "1" ]; then
+    echo "REFUSED: --mode replace would discard $existing_lines non-empty line(s) already in the description of $ISSUE." >&2
+    echo "The current text is saved at $BACKUP. Re-run with --mode append to keep it, or add --confirm-overwrite to replace it deliberately." >&2
+    exit 3
+  fi
+  cp "$WORK/new.txt" "$WORK/final.txt"
+  RESULT="replaced the existing description (backup above)"
+fi
+
+if [ "$DRY_RUN" = "1" ]; then
+  echo "dry-run: would PUT the description of $ISSUE - $RESULT"
+  cat "$WORK/final.txt"
+  exit 0
+fi
+
+jq -n --rawfile body "$WORK/final.txt" '{fields: {description: $body}}' > "$WORK/payload.json"
+http=$(api -o "$WORK/resp.json" -w '%{http_code}' -X PUT \
+  --data-binary @"$WORK/payload.json" \
+  "https://$HOST/rest/api/2/issue/$ISSUE") || http="000"
+case "$http" in
+  20*) echo "description of $ISSUE updated - $RESULT" ;;
+  *) echo "Jira description PUT failed with HTTP $http" >&2; sed -n '1,5p' "$WORK/resp.json" >&2; exit 5 ;;
+esac

package/pipeline/multi-agent-refs/analysis/render.md

@@ -41,12 +41,29 @@ options:
   - label: "Local file"
     description: "analysis/<feature>-<platform>.md in each selected repo's working tree"
   - label: "Confluence page"
-  - label: "Jira description"
+  - label: "Jira issue"
+    description: <localized: "As a comment by default; writing the description is a separate, explicit choice">
 ```
 
 Conditional follow-ups:
 - If `Confluence` selected: ask `header="Parent page"`, free-text via Other for the parent page key or URL. One Confluence page per platform is created under this parent, each titled `<Feature> - <Platform>`.
-- If `Jira` selected: if Step 5 Q4 produced Jira IDs, AskUserQuestion (single-select) to pick which one; otherwise ask via Other. Per Locked decision 9 + design choice "single description with platform separators", the chosen issue receives one combined description body holding all per-platform sections under `h2. Platform: <X>` separators (wiki markup  -  the description field does not render Markdown; conversion happens at dispatch, see Phase 4).
+- If `Jira` selected: if Step 5 Q4 produced Jira IDs, AskUserQuestion (single-select) to pick which one; otherwise ask via Other. Per Locked decision 9 + design choice "single description with platform separators", the chosen issue receives one combined body holding all per-platform sections under `h2. Platform: <X>` separators (wiki markup  -  neither the comment nor the description field renders Markdown; conversion happens at dispatch, see Phase 4).
+
+  Then ask **where in the issue it goes**, because two of the three answers can destroy text somebody else wrote:
+
+  ```
+  header: "Jira write"
+  question: <localized: "Where should the analysis go on {ISSUE-KEY}?">
+  options:
+    - label: "Comment"
+      description: <localized: "Added as a new comment. Nothing existing is touched.">   # pre-selected
+    - label: "Description - append"
+      description: <localized: "Kept below the current description, separated by a rule.">
+    - label: "Description - replace"
+      description: <localized: "Replaces the current description. Its text is backed up first and the run tells you what was there.">
+  ```
+
+  `Comment` is pre-selected and is the default on any non-answer, including autopilot. The description of an issue is often the analyst's original requirement text, and an analysis run is not a reason to lose it. Result: `state.analysisSpec.outputs.jira = { key, target: "comment"|"description", mode: "append"|"replace" }`.
 
 Result: `state.analysisSpec.outputs.requested[]`.
 
@@ -68,7 +85,7 @@ Iterate `state.analysisSpec.outputs.requested`. For each target:
 |--------|--------|
 | Local | For each per-platform draft, `cp /tmp/analysis-<feature-slug>-<ts>/<feature>-<platform>.md` into `analysis/<feature>-<platform>.md` in the matching repo's working tree. When multiple repos exist for the same platform, the file is duplicated into each and the dispatch report lists every destination. **No commit.** |
 | Confluence | Re-humanize each per-platform draft with `formal-stakeholder` tone. One Confluence page per platform under the chosen parent, titled `<Feature> - <Platform>`. Cross-link siblings inside each page via `<ac:link><ri:page ri:content-title="<Feature> - <OtherPlatform>"/></ac:link>`. Markdown -> storage XML via `$HOME/.claude/multi-agent-refs/channels/confluence.md`. Re-emit on existing pages uses PUT with version bump. |
-| Jira | Re-humanize the combined body with `informal-technical` tone. Concatenate per-platform drafts under `h2. Platform: iOS`, `h2. Platform: Android`, `h2. Platform: Backend`, `h2. Platform: Frontend` separators (in the order platforms were selected), then run the whole body through the markdown → Jira wiki conversion table in `$HOME/.claude/multi-agent-refs/channels/jira.md`  -  the `description` field renders wiki markup, so raw `##`/`**`/backticks arrive as literal text. Write with `PUT /rest/api/2/issue/{key}` body `{"fields": {"description": <converted body>}}` (`channels/jira.md` documents only the comment POST; the description update is this PUT). Same rawfile + `--data-binary` transport rules. |
+| Jira | Re-humanize the combined body with `informal-technical` tone. Concatenate per-platform drafts under `h2. Platform: iOS`, `h2. Platform: Android`, `h2. Platform: Backend`, `h2. Platform: Frontend` separators (in the order platforms were selected), then run the whole body through the markdown → Jira wiki conversion table in `$HOME/.claude/multi-agent-refs/channels/jira.md`  -  both the comment body and the `description` field render wiki markup, so raw `##`/`**`/backticks arrive as literal text. Write the converted body to a file and publish it with `$HOME/.claude/lib/jira-publish.sh`, never with a hand-rolled `curl`: <br><br>`bash "$HOME/.claude/lib/jira-publish.sh" --issue "$KEY" --body-file "$F" --target comment` <br>`bash "$HOME/.claude/lib/jira-publish.sh" --issue "$KEY" --body-file "$F" --target description --mode append` <br><br>The script owns the parts that are easy to get wrong: it runs `jira-wiki-escape.mjs` on the body, resolves host + token without putting either in argv, and on the description path it GETs the current value, writes it to a backup under `~/.claude/logs/multi-agent/jira-backups/` and reports the path, appends below a `----` rule by default, and **refuses with exit 3** when `--mode replace` would discard a non-empty description unless `--confirm-overwrite` is passed. Exit 3 is reported to the user with the backup path, never retried with the flag added automatically  -  only the user's explicit "Description - replace" answer from Phase 3.5 supplies it. `--dry-run` previews the exact final body without writing. |
 
 **Output capture**: fill `state.analysisSpec.outputs.localPaths[]` (one entry per per-platform-per-repo write), `outputs.confluencePageUrls[]` (one entry per platform), `outputs.jiraIssueKey` (single string).
 

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

@@ -55,7 +55,8 @@ The links are pulled from `agent-state.json.contextLinks[]` (see Phase 0 link ex
 3. Run the assembled body through the `humanizer` skill (see Hard rules below).
 4. Apply Cross-link injection (PR URL on line 1).
 5. Run Wiki markup conversion.
-6. POST.
+6. Run the emoticon escape program on the converted body (see *Emoticon escaping*).
+7. POST.
 ```
 
 ## Wiki markup conversion
@@ -79,7 +80,16 @@ The `\|` sequences in the two link/table rows are this table's own escape for a
 
 ### Emoticon escaping (required)
 
-Jira's wiki renderer turns ASCII sequences into emoticon images. This is not something the pipeline writes; Jira manufactures it at render time, which is why a comment can show a smiley nobody typed. Escape every sequence below with a leading backslash before POST:
+Jira's wiki renderer turns ASCII sequences into emoticon images. This is not something the pipeline writes; Jira manufactures it at render time, which is why a comment can show a smiley nobody typed. The escape is a program, not a habit  -  run the converted body through it and POST the output:
+
+```bash
+node "$HOME/.claude/scripts/jira-wiki-escape.mjs" /tmp/channels-$TASK_ID-jira.txt \
+  > /tmp/channels-$TASK_ID-jira-escaped.txt
+```
+
+It prefixes a backslash to each sequence below, skips `{code}` / `{noformat}` blocks, and is idempotent, so running it twice is harmless. `--check` is the inverse: it exits 1 and prints `line: sequence` for every unescaped hit, which is what a gate or a pre-POST assertion calls.
+
+The sequences it covers:
 
 | Sequence | Renders as | Escaped |
 |---|---|---|
@@ -91,13 +101,17 @@ Jira's wiki renderer turns ASCII sequences into emoticon images. This is not som
 | `(on)` `(off)` | lightbulb icons | `\(on)` `\(off)` |
 | `(*)` `(*r)` `(*g)` `(*b)` `(*y)` | star icons | `\(*)` `\(*r)` ... |
 
-The parenthesised forms are the ones that actually bite: `(x)` in a comparison table, `(!)` in a caution note, and `(/)` in a path fragment are ordinary technical prose, and each becomes an image. Apply the escape AFTER the markdown conversion above and BEFORE the POST, and skip it inside `{code}` / `{noformat}` blocks, where Jira does not expand emoticons anyway.
+The parenthesised forms are the ones that actually bite: `(x)` in a comparison table, `(!)` in a caution note, and `(/)` in a path fragment are ordinary technical prose, and each becomes an image. The face forms bite through code: a Swift selector like `login(source:input:)` ends in `:)`, and the comment renders a smiley in the middle of a file reference.
+
+The program runs AFTER the markdown conversion above and BEFORE the POST. Order is load-bearing in both directions: run it earlier and the conversion re-introduces sequences behind it; skip it and `{{...}}` monospace does not save you, because Jira parses emoticons inside monospace too.
+
+Do not hand-apply this table. It was hand-applied for several releases and a smiley reached a ticket anyway  -  a long comment gives the eye no reason to stop on the `:)` at the end of a selector.
 
 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.
+There is no markdown→Jira-wiki converter program in the pipeline (`lib/` ships `md2confluence-v3.py` for Confluence only, and `scripts/jira-wiki-escape.mjs` covers the emoticon step alone). This conversion table is applied by the model, by hand, which is exactly why it has to be complete.
 
 ## Cross-link injection
 
@@ -128,10 +142,12 @@ Authorization: Bearer $JIRA_TOKEN
 Content-Type: application/json
 ```
 
-Body assembled with `jq --rawfile` + `curl --data-binary @file`:
+Body assembled with `jq --rawfile` + `curl --data-binary @file`, from the escaped file that *Emoticon escaping* produced:
 
 ```bash
-jq -n --rawfile body /tmp/channels-$TASK_ID-jira.txt '{body: $body}' \
+node "$HOME/.claude/scripts/jira-wiki-escape.mjs" --check /tmp/channels-$TASK_ID-jira-escaped.txt \
+  || { echo "unescaped Jira emoticon in the body - do not POST" >&2; exit 1; }
+jq -n --rawfile body /tmp/channels-$TASK_ID-jira-escaped.txt '{body: $body}' \
   > /tmp/channels-$TASK_ID-jira-payload.json
 curl -s -X POST -H "Authorization: Bearer $JIRA_TOKEN" \
      -H "Content-Type: application/json" \
@@ -141,6 +157,17 @@ curl -s -X POST -H "Authorization: Bearer $JIRA_TOKEN" \
 
 The dispatch summary line includes the comment URL with `?focusedCommentId=...` so the user can paste it into Slack/Teams.
 
+### Writing the issue description (not a comment)
+
+A comment is additive; the `description` field is not. Replacing it destroys whatever was there, which is usually the reporter's own text. There is no hand-rolled `PUT /rest/api/2/issue/{key}` anywhere in the pipeline and there must not be one: the only supported path is
+
+```bash
+bash "$HOME/.claude/lib/jira-publish.sh" --issue "$KEY" --body-file "$F" \
+  --target description --mode append
+```
+
+which escapes the body, GETs the current description, saves it under `~/.claude/logs/multi-agent/jira-backups/`, appends below a `----` rule, and exits 3 rather than replacing a non-empty field without `--confirm-overwrite`. The same script posts comments (`--target comment`), which is what an unattended run should choose when it is not sure. Contract and gate: `analysis/render.md` Phase 4 and `scripts/smoke-jira-publish.sh`.
+
 ## Wiki → Jira auto-link triad
 
 When the **Wiki** adapter writes pages on the same run AND `prefs.global.wikiToJiraComment === true`, the Wiki adapter also posts a humanizer-passed Jira comment summarizing wiki pages (component name + variant count + wiki URL). That secondary comment is independent of this adapter  -  both can coexist on the same issue. Full contract: `$HOME/.claude/multi-agent-refs/issue-jira-triad.md`.

package/pipeline/multi-agent-refs/generate-issue.md

@@ -201,7 +201,9 @@ This gate has no bypass. No flag, mode, or preference suppresses it.
 ### [10/12] Create
 
 ```bash
-jq -n --rawfile desc /tmp/generate-issue-$$.txt \
+node "$HOME/.claude/scripts/jira-wiki-escape.mjs" /tmp/generate-issue-$$.txt \
+  > /tmp/generate-issue-$$-escaped.txt
+jq -n --rawfile desc /tmp/generate-issue-$$-escaped.txt \
   --arg key "$PROJECT_KEY" --arg type "$ISSUE_TYPE" --arg summary "$SUMMARY" \
   '{fields: {project: {key: $key}, issuetype: {name: $type}, summary: $summary, description: $desc}}' \
   > /tmp/generate-issue-$$-payload.json

package/pipeline/multi-agent-refs/issue-jira-triad.md

@@ -66,7 +66,7 @@ Flow:
 
 1. Emit `→ posting wiki summary to Jira {jiraId}`.
 2. Read the first N lines of the primary wiki markdown file (the component's overview page  -  one of `writtenPaths[0]`).
-3. Render as Jira comment: title line (`h3. Component docs  -  {componentName}`) + an overview paragraph + a link to the full page (wiki URL, if the adapter returned `pushedRemote`). The overview lines come from a Markdown file  -  convert them via the `channels/jira.md` table before POST, exactly like the title line already is.
+3. Render as Jira comment: title line (`h3. Component docs  -  {componentName}`) + an overview paragraph + a link to the full page (wiki URL, if the adapter returned `pushedRemote`). The overview lines come from a Markdown file  -  convert them via the `channels/jira.md` table before POST, exactly like the title line already is, then run the whole body through `node "$HOME/.claude/scripts/jira-wiki-escape.mjs"` per that file's *Emoticon escaping* section.
 4. **Run through the humanizer skill**  -  same policy as Step 4 Confluence: user-facing content must read naturally.
 5. `POST {jira.baseUrl}/rest/api/2/issue/{jiraId}/comment`.
 6. Log: `Phase 7: wiki summary posted to Jira {jiraId}`.

package/pipeline/multi-agent-refs/payload-contracts.md

@@ -31,7 +31,7 @@ Language is not the only axis an external payload has. Every surface also has a
 |---|---|---|---|
 | PR description (GitHub / Bitbucket / GitLab) | **Markdown**, no conversion | none  -  post the assembled markdown verbatim | `channels/pr.md` |
 | GitHub issue body + comment | **Markdown**, no conversion | none | `channels/issue-comment.md` |
-| Jira comment + issue description | **Jira wiki markup** | the table in `channels/jira.md`, applied by the model  -  no program exists | `channels/jira.md` |
+| Jira comment + issue description | **Jira wiki markup** | the table in `channels/jira.md`, applied by the model; the emoticon escape that follows it is a program, `scripts/jira-wiki-escape.mjs`, and is required before every POST/PUT; description writes go through `lib/jira-publish.sh`, which backs the field up and refuses a blind replace | `channels/jira.md` |
 | Confluence page body | **storage format** (XHTML) | `lib/md2confluence-v3.py` | `channels/confluence.md` |
 | Wiki pages (`.md` files in a git repo) | **Markdown** | none | `channels/wiki.md` |
 | Commit message | plain text | none | `rules/git-conventions.md` |

package/pipeline/multi-agent-refs/phases/phase-0-init.md

@@ -561,6 +561,19 @@ ASK_CHOICE_DEFAULT="$DEPTH_RECOMMENDATION" \
 
 Log: `Phase 0 Step 7.5: depth = {full|short} (recommended {full|short}, source {user|autopilot|default})`
 
+#### Step 7.6  -  Test baseline (opt-in, `prefs.global.testBaseline.enabled`, default `false`)
+
+Phase 4 Gate 3 cannot tell an inherited red suite from one this run broke, so it blocks on someone else's bug or the agent "fixes" tests it never touched. Runs after Step 6, only when the stack has a test command; skipped in analysis mode.
+
+```bash
+BASELINE_LOG="$WORKTREE/.baseline-test.log"
+timeout "${prefs_testBaseline_timeoutSeconds:-600}" <same-test-command-as-Phase-4-Gate-3> 2>&1 | tee "$BASELINE_LOG"
+```
+
+Persist `state.baseline.tests` with `command`, `capturedAt`, `logPath` and exactly one status: `green` (passed), `red` + `failing[]` (failed, names parsed), `red` + empty `failing[]` (failed, names unparseable), `unknown` (no test command, `timeout` fired, or flag off). Folding `unknown` into `green` would let a skipped baseline read as a clean tree, which is the failure this record exists to prevent.
+
+Log: `Phase 0 Step 7.6: test baseline = {green|red|unknown} ({N} pre-existing failures)`
+
 #### Step 8  -  Clarification (opt-in, runs AFTER maturity, BEFORE Phase 1)
 
 **Gated by `prefs.global.clarifyAmbiguous.enabled`** (default: `false`). When enabled and `state.maturity.status != "blocker"`:

package/pipeline/multi-agent-refs/phases/phase-4-review.md

@@ -34,11 +34,22 @@ node $HOME/.claude/scripts/evidence-gate.mjs --claim test  --status passed --evi
 
 This prevents a false "it built" claim with no log behind it. On exit 1, treat the gate as failed (do NOT proceed to AI review) and surface the gate's `reason`.
 
+**Inherited failures (when `state.baseline.tests` exists).** Phase 0 Step 7.6 recorded whether the suite was already red, so Gate 3 blocks on what this work broke, not what it walked into:
+
+| baseline status | Gate 3 |
+|---|---|
+| `green` | unchanged; every failure is this run's |
+| `red` + `failing[]` | subtract those ids. Nothing left -> pass, logged `test:pass (inherited {N})`. A NEW failure still blocks. |
+| `red`, empty `failing[]` | do NOT pass and do NOT silently block: report `test:inherited-red (not attributable, <logPath>)` and ask. Inventing a set here masks regressions. |
+| `unknown` / absent | unchanged from today |
+
+The subtraction never widens: match on identifier only, and when identifiers cannot be compared fall to the `not attributable` row.
+
 **Gate results:**
 
 - All pass (including the evidence gate) -> proceed to AI review
 - Any fail -> fix immediately, re-run gates (no AI review until clean)
-  Log: "Phase 4: Gates  -  build:{pass/fail} lint:{pass/fail} test:{pass/fail} secrets:{clean/found} evidence:{ok/unverified}"
+  Log: "Phase 4: Gates  -  build:{pass/fail} lint:{pass/fail} test:{pass/fail/inherited-red} secrets:{clean/found} evidence:{ok/unverified}"
 
 ##### Gate 5  -  Fortify SSC findings (runs when `state.contextLinks[]` contains a `fortify` entry, or when `prefs.global.fortify.alwaysCheck === true`)
 
@@ -374,7 +385,7 @@ Exit 0 = valid. Exit 2 = contradiction (approved=true with blocking findings)  -
 1. Compute disagreement: reviewers agree iff all return `approved=true` with no `blocking` findings, OR all return `approved=false` with overlapping `blocking` findings. Anything else is disagreement.
 2. Agreement → skip the rebuttal round, go straight to Step 3 triage.
 3. Disagreement → one rebuttal round:
-   - For each reviewer, re-prompt with: (a) their original output, (b) the OTHER reviewers' blocker findings verbatim, (c) instruction: *"Given the opposing arguments, keep / withdraw / modify each of your findings. You may also newly agree with a finding you previously missed. Return the SAME JSON schema  -  this is a revision, not a new review."*
+   - For each reviewer, re-prompt with: (a) their original output, (b) the OTHER reviewers' blocker findings **anonymized** through `node $HOME/.claude/scripts/anonymize-findings.mjs` (labels `Source A/B/C`, no model name, order deterministic per `taskId:iteration`), (c) instruction: *"Given the opposing arguments, keep / withdraw / modify each of your findings. You may also newly agree with a finding you previously missed. Return the SAME JSON schema  -  this is a revision, not a new review."*
    - Launch all reviewers in parallel (same CLI-aware set as Step 2).
    - Max one round. Results replace the original outputs.
 4. Proceed to Step 3 triage with the round-2 outputs.
@@ -393,15 +404,27 @@ Optional: when `ai-analyst-toolkit` is enabled and a finding blames a third-part
 
 Opt-in empirical layer: when `prefs.global.verifyByTest.enabled` is `true`, accepted blocking findings additionally go through Step 3.7 (verify-by-test), which tries to reproduce each one with a minimal failing test before the Phase 3 rework loop fires. Full wiring: `$HOME/.claude/multi-agent-refs/features/verify-by-test.md`.
 
-##### 3.0 Merge the deterministic findings in
+##### 3.0 Anonymize the reviewer findings, then merge the deterministic ones
+
+**Anonymize first (required).** On both CLIs the triage model is also a reviewer (Fable on Claude Code, Opus on Copilot), and a judge that can see which findings are its own is marking its own homework:
 
-Append the Step 1.76 test-integrity findings to the reviewer findings before counting, so they are adjudicated like any reviewer finding rather than resolved by triage never seeing them:
+```bash
+ANON=$(jq -n --argjson r "$REVIEWERS_JSON" --arg t "$TASK_ID" --argjson i "$ITERATION" \
+        '{taskId: $t, iteration: $i, reviewers: $r}' \
+      | node "$HOME/.claude/scripts/anonymize-findings.mjs" --map "/tmp/review-$TASK_ID-$ITERATION-map.json")
+```
+
+`$REVIEWERS_JSON` is `state.reviewIterations[i].reviewers`. Findings come back with `foundBy: "Source A|B|C"` and every identity key removed. Persist the map to `state.reviewIterations[i].anonymizationMap` for Phase 7 per-reviewer telemetry, and **never put the map in a prompt**.
+
+Then append the Step 1.76 test-integrity findings, so they are adjudicated rather than never seen:
 
 ```bash
 MERGED=$(jq -s '.[0] + (.[1].findings // [])' \
-  <(printf '%s' "$REVIEWER_FINDINGS_JSON") <(printf '%s' "${TEST_INTEGRITY_JSON:-{\}}"))
+  <(printf '%s' "$ANON") <(printf '%s' "${TEST_INTEGRITY_JSON:-{\}}"))
 ```
 
+Deterministic findings keep `tag: test_integrity` and carry no `foundBy`: a reviewer finding may be a hallucination, a gate finding is a fact.
+
 ##### 3.1 Short-circuit: no findings
 
 If **merged** findings `length === 0`, **skip triage**: write empty result `{"accepted": [], "deferred": [], "rejected": [], "approved": true}`, log, proceed to Phase 5. Note this is the merged count from 3.0: a run with zero reviewer findings but a non-empty test-integrity set must NOT short-circuit.
@@ -410,7 +433,7 @@ If **merged** findings `length === 0`, **skip triage**: write empty result `{"ac
 
 Launch **1 Agent** (subagent_type: `general-purpose`, model: `fable` on Claude Code / `opus` on Copilot CLI) with:
 
-- Raw findings from Reviewer 1 + Reviewer 2 (merged JSON)
+- The anonymized merged findings from 3.0 (`Source A/B/C` labels; no model name anywhere in the prompt)
 - Task scope (Phase 1 analysis summary + Phase 2 plan)
 - Full diff being reviewed
 - **Prior-art context (advisory)**  -  per raw finding, `triage-memory.mjs query --top <prefs.global.priorArtEnrichment.topN>` (default 3). Pass `--top`: without it the script falls back to `memoryRecall.maxResults`, a different concern, and `topN` silently does nothing. Off when `priorArtEnrichment.enabled = false`.