@cxi-lmai/ci-agent-platform 3.0.0

package/payload/ci-templates/scripts/orchestrate.sh

@@ -0,0 +1,294 @@
+#!/bin/bash
+# Runner for the `orchestrate` job (issue -> code loop, orchestrator side).
+# Ensures the lifecycle labels, runs the release poll (promote unblocked issues,
+# close finished decomposed parents), then triages each ready issue by calling
+# the /triage-issue skill and acting on its decision: queue the coder, ask for
+# clarification, or decompose into sub-issues. Finally it fires the queued coder
+# pipelines. All reasoning is in the skill; this script does token and git work.
+#
+# Generalized from a single-project original: labels and branches
+# come from PIPE_ variables, the triage/decompose prompts moved into the skill,
+# and the platform calls go through lib/issue-loop.sh (GitLab + GitHub).
+set -e
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=lib/pipeline-common.sh
+source "$SCRIPT_DIR/lib/pipeline-common.sh"
+# shellcheck source=lib/issue-loop.sh
+source "$SCRIPT_DIR/lib/issue-loop.sh"
+pipe_defaults
+
+pipe_sanitize_branch() {
+  # lowercase, collapse non-alphanumerics to single hyphens, trim, cap at 100.
+  echo "$1" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-+//; s/-+$//' | cut -c1-100
+}
+
+# --- 1. Ensure the lifecycle labels exist (idempotent) ----------------------
+pipe_log "Ensuring lifecycle labels"
+issue_ensure_label "$PIPE_LABEL_READY"      "#2ECC71" "Issue is ready for the autonomous pipeline (the single human action)"
+issue_ensure_label "$PIPE_LABEL_WIP"        "#3498DB" "Pipeline is implementing this issue"
+issue_ensure_label "$PIPE_LABEL_BLOCKER"    "#E67E22" "Needs clarification before work can proceed"
+issue_ensure_label "$PIPE_LABEL_STUCK"      "#B60205" "Automation exhausted, human intervention required"
+issue_ensure_label "$PIPE_LABEL_DECOMPOSED" "#8E44AD" "Split into child sub-issues, auto-closed when all children close"
+issue_ensure_label "$PIPE_LABEL_BLOCKED"    "#95A5A6" "Waiting on a prerequisite issue before work begins"
+
+# --- 2. Release poll --------------------------------------------------------
+# 2a. Promote blocked issues whose blockers are all closed.
+pipe_log "Release poll: promoting unblocked issues"
+BLOCKED=$(issues_by_label "$PIPE_LABEL_BLOCKED")
+while IFS= read -r IID; do
+  [ -z "$IID" ] && continue
+  OPEN=$(issue_blockers_open_count "$IID")
+  if [ "${OPEN:-1}" = "0" ]; then
+    pipe_log "  #$IID unblocked, promoting to $PIPE_LABEL_READY"
+    issue_set_labels "$IID" "$PIPE_LABEL_READY" "$PIPE_LABEL_BLOCKED"
+  else
+    pipe_log "  #$IID still has $OPEN open blocker(s), skipping"
+  fi
+done < <(echo "$BLOCKED" | jq -r '.[].iid' 2>/dev/null || true)
+
+# 2b. Close decomposed parents whose children are all closed.
+pipe_log "Release poll: closing completed decomposed parents"
+DECOMPOSED=$(issues_by_label "$PIPE_LABEL_DECOMPOSED")
+while IFS= read -r IID; do
+  [ -z "$IID" ] && continue
+  read -r TOTAL OPEN <<< "$(issue_children_state "$IID")"
+  if [ "${TOTAL:-0}" -gt 0 ] && [ "${OPEN:-1}" = "0" ]; then
+    pipe_log "  #$IID all children closed, closing parent"
+    issue_close "$IID"
+  else
+    pipe_log "  #$IID has ${OPEN:-?} of ${TOTAL:-?} children open, skipping"
+  fi
+done < <(echo "$DECOMPOSED" | jq -r '.[].iid' 2>/dev/null || true)
+
+# 2c. Janitor: a merged MR/PR closes its issue, but nothing removes the wip
+# label from it. Strip lifecycle labels from closed issues so the issue board
+# stays clean.
+pipe_log "Release poll: stripping lifecycle labels from closed issues"
+for JANITOR_LABEL in "$PIPE_LABEL_WIP" "$PIPE_LABEL_READY"; do
+  while IFS= read -r IID; do
+    [ -z "$IID" ] && continue
+    pipe_log "  #$IID is closed, removing $JANITOR_LABEL"
+    issue_set_labels "$IID" "" "$JANITOR_LABEL"
+  done < <(issues_closed_by_label "$JANITOR_LABEL" | jq -r '.[].iid' 2>/dev/null || true)
+done
+
+# --- 3. Triage ready issues -------------------------------------------------
+READY=$(issues_by_label "$PIPE_LABEL_READY")
+COUNT=$(echo "$READY" | jq 'length' 2>/dev/null || echo 0)
+pipe_log "Found $COUNT ready issue(s)"
+[ "$COUNT" = "0" ] && { pipe_log "Nothing to do"; exit 0; }
+
+QUEUE=()   # "IID:BRANCH" entries to trigger, capped at PIPE_CODER_CAP
+
+emit_decision_metric() {
+  # $1=iid $2=verdict $3=decision_type $4=reason (+ optional $5 extra jq object)
+  pipe_metric_event orchestrator orchestrator_decision \
+    "$(jq -n --argjson i "$1" --arg v "$2" --arg dt "$3" --arg r "$4" --argjson x "${5:-{\}}" \
+        '{issue_iid: $i, verdict: $v, decision_type: $dt, reason: $r} + $x')"
+}
+
+while IFS= read -r ISSUE; do
+  [ "${#QUEUE[@]}" -ge "$PIPE_CODER_CAP" ] && { pipe_log "Coder cap ($PIPE_CODER_CAP) reached, deferring the rest"; break; }
+
+  IID=$(echo "$ISSUE" | jq -r '.iid')
+  TITLE=$(echo "$ISSUE" | jq -r '.title')
+  DESC=$(echo "$ISSUE" | jq -r '.description // "(no description)"' | head -c 32000)
+  pipe_log "--- Triaging #$IID: $TITLE"
+
+  # Comments arrive newest-first from issue_notes (both platforms). Cap the
+  # volume so a long discussion cannot crowd out the description, and mark the
+  # cut visibly instead of dropping the tail silently. Newest-first ordering
+  # keeps the most relevant comment above the line when the cap is hit.
+  COMMENTS=$(issue_notes "$IID")
+  PIPE_COMMENTS_MAX="${PIPE_COMMENTS_MAX:-12000}"
+  if [ "${#COMMENTS}" -gt "$PIPE_COMMENTS_MAX" ]; then
+    COMMENTS="$(printf '%s' "$COMMENTS" | head -c "$PIPE_COMMENTS_MAX")
+[... older comments truncated ...]"
+  fi
+
+  # Build the context file the skill reads. No API access inside the skill.
+  {
+    echo "# Issue #$IID"
+    echo
+    echo "Title: $TITLE"
+    echo
+    echo "## Description"
+    echo "$DESC"
+    [ -n "$COMMENTS" ] && { echo; echo "## Comments"; echo "$COMMENTS"; }
+  } > "$PIPE_CONTEXT_DIR/issue-context.md"
+
+  export PIPE_ISSUE_IID="$IID"
+  rm -f "$PIPE_CONTEXT_DIR/triage.env" "$PIPE_CONTEXT_DIR/triage.json"
+  pipe_run_claude orchestrator "/triage-issue" "Agent,Read,Write,Edit,Glob,Grep,Bash" "$PIPE_MODEL_TRIAGE" < /dev/null
+
+  TRIAGE_ENV="$PIPE_CONTEXT_DIR/triage.env"
+  TRIAGE_JSON="$PIPE_CONTEXT_DIR/triage.json"
+  DECISION=$(pipe_get_env "$TRIAGE_ENV" TRIAGE_DECISION)
+  if [ -z "$DECISION" ] || [ ! -s "$TRIAGE_JSON" ]; then
+    pipe_log "  no usable triage output for #$IID, skipping"
+    continue
+  fi
+
+  case "$DECISION" in
+    implement)
+      BRANCH=$(pipe_get_env "$TRIAGE_ENV" TRIAGE_BRANCH)
+      BRANCH=$(pipe_sanitize_branch "${BRANCH:-$IID-$TITLE}")
+      [ -z "$BRANCH" ] && BRANCH=$(pipe_sanitize_branch "$IID-issue")
+      QUEUE+=("$IID:$BRANCH")
+      emit_decision_metric "$IID" actionable implement "Issue is right-sized for one coder session"
+      pipe_log "  queued #$IID on branch $BRANCH"
+      ;;
+
+    ask)
+      QUESTION=$(jq -r '.question // "Please provide more detail before this issue can be implemented."' "$TRIAGE_JSON")
+      issue_comment "$IID" "🤖 **The pipeline needs clarification before implementing:**
+
+$QUESTION
+
+Put the complete spec in the issue **description**, not in a comment: the pipeline reads only the description."
+      issue_set_labels "$IID" "$PIPE_LABEL_BLOCKER" "$PIPE_LABEL_READY"
+      emit_decision_metric "$IID" clarification-needed ask "$QUESTION"
+      pipe_log "  asked for clarification on #$IID"
+      ;;
+
+    decompose_failed)
+      SUGGEST=$(jq -r '.suggestion // "Please split this issue into smaller pieces."' "$TRIAGE_JSON")
+      issue_comment "$IID" "**This issue is clear but too large for a single agent session.**
+
+Suggested decomposition:
+
+$SUGGEST
+
+Please split it into smaller issues and label each \`$PIPE_LABEL_READY\`."
+      issue_set_labels "$IID" "$PIPE_LABEL_BLOCKER" "$PIPE_LABEL_READY"
+      emit_decision_metric "$IID" clarification-needed ask "Too large; decomposition suggested"
+      pipe_log "  posted decomposition suggestion for #$IID"
+      ;;
+
+    decompose)
+      # Re-validate deterministically before mutating the platform.
+      if ! pipe_validate_decomposition "$(cat "$TRIAGE_JSON")"; then
+        pipe_log "  decomposition failed the gate: $DECOMP_REJECT_REASON"
+        issue_comment "$IID" "**This issue is too large and automatic decomposition did not produce a valid split.**
+
+Reason: $DECOMP_REJECT_REASON
+
+Please split it manually into smaller issues and label each \`$PIPE_LABEL_READY\`."
+        issue_set_labels "$IID" "$PIPE_LABEL_BLOCKER" "$PIPE_LABEL_READY"
+        emit_decision_metric "$IID" clarification-needed ask "Decomposition rejected by gate"
+        continue
+      fi
+
+      CONFIDENCE=$(pipe_get_env "$TRIAGE_ENV" TRIAGE_CONFIDENCE)
+      CONFIDENCE=${CONFIDENCE:-$(jq -r '.confidence // "low"' "$TRIAGE_JSON")}
+      REASON=$(jq -r '.reason // ""' "$TRIAGE_JSON")
+      SUB_COUNT=$(jq '.sub_issues | length' "$TRIAGE_JSON")
+      pipe_log "  decomposing #$IID into $SUB_COUNT sub-issues (confidence=$CONFIDENCE)"
+
+      # Create sub-issues, mapping key -> new IID.
+      declare -A KEY_TO_IID=()
+      CREATED=()
+      FAILED=false
+      while IFS= read -r SUB; do
+        SUB_KEY=$(echo "$SUB" | jq -r '.key')
+        SUB_TITLE=$(echo "$SUB" | jq -r '.title')
+        SUB_SPEC=$(echo "$SUB" | jq -r '.spec_markdown')
+        HAS_DEPS=$(echo "$SUB" | jq '(.depends_on // []) | length > 0')
+        if [ "$CONFIDENCE" = "high" ] && [ "$HAS_DEPS" = "false" ]; then
+          SUB_LABEL="$PIPE_LABEL_READY"
+        elif [ "$CONFIDENCE" = "low" ]; then
+          SUB_LABEL="$PIPE_LABEL_BLOCKER"
+        else
+          SUB_LABEL="$PIPE_LABEL_BLOCKED"
+        fi
+        NEW_IID=$(issue_create "$SUB_TITLE" "$SUB_SPEC" "$SUB_LABEL")
+        if [ -z "$NEW_IID" ]; then
+          pipe_log "  ERROR: failed to create sub-issue for key '$SUB_KEY'"
+          FAILED=true
+          break
+        fi
+        KEY_TO_IID["$SUB_KEY"]="$NEW_IID"
+        CREATED+=("$NEW_IID")
+        pipe_log "  created #$NEW_IID ($SUB_LABEL): $SUB_TITLE"
+      done < <(jq -c '.sub_issues[]' "$TRIAGE_JSON")
+
+      if [ "$FAILED" = "true" ]; then
+        CHILD_LIST=$(printf '#%s ' "${CREATED[@]:-}")
+        issue_comment "$IID" "**Auto-decomposition partially failed.** Created so far: ${CHILD_LIST:-none}. Relabeled \`$PIPE_LABEL_BLOCKER\` to prevent re-decomposition. Please finish manually."
+        issue_set_labels "$IID" "$PIPE_LABEL_BLOCKER" "$PIPE_LABEL_READY"
+        unset KEY_TO_IID
+        continue
+      fi
+
+      # Blocking links. GitLab uses native links. GitHub appends the resolved
+      # "Blocked by #N" relationship to the dependent issue body now that local
+      # decomposition keys have real platform issue numbers.
+      while IFS= read -r SUB; do
+        SUB_KEY=$(echo "$SUB" | jq -r '.key')
+        BLOCKED_IID="${KEY_TO_IID[$SUB_KEY]:-}"
+        [ -z "$BLOCKED_IID" ] && continue
+        while IFS= read -r DEP_KEY; do
+          [ -z "$DEP_KEY" ] && continue
+          BLOCKING_IID="${KEY_TO_IID[$DEP_KEY]:-}"
+          [ -n "$BLOCKING_IID" ] && issue_link_blocked_by "$BLOCKED_IID" "$BLOCKING_IID"
+        done < <(echo "$SUB" | jq -r '(.depends_on // [])[]' 2>/dev/null || true)
+      done < <(jq -c '.sub_issues[]' "$TRIAGE_JSON")
+
+      # Relabel parent and comment (embed a machine marker listing the children,
+      # so the GitHub release poll can find them without native links).
+      CHILD_LIST=$(printf '#%s ' "${CREATED[@]}")
+      issue_set_labels "$IID" "$PIPE_LABEL_DECOMPOSED" "$PIPE_LABEL_READY"
+      issue_comment "$IID" "**Auto-decomposed by the pipeline** (confidence: \`$CONFIDENCE\`).
+
+Reason: $REASON
+
+Split into $SUB_COUNT sub-issues: $CHILD_LIST
+
+Sub-issues with prerequisites are labeled \`$PIPE_LABEL_BLOCKED\` and are promoted automatically when their blockers close. This parent closes automatically when all children close.
+
+<!-- pipe-children: $CHILD_LIST -->"
+      emit_decision_metric "$IID" actionable decompose "Decomposed into $SUB_COUNT sub-issues (confidence: $CONFIDENCE)" \
+        "$(jq -n --argjson sc "$SUB_COUNT" --arg conf "$CONFIDENCE" '{sub_issue_count: $sc, confidence: $conf}')"
+
+      # Queue high-confidence, unblocked children for the coder.
+      if [ "$CONFIDENCE" = "high" ]; then
+        while IFS= read -r SUB; do
+          [ "${#QUEUE[@]}" -ge "$PIPE_CODER_CAP" ] && break
+          HAS_DEPS=$(echo "$SUB" | jq '(.depends_on // []) | length > 0')
+          [ "$HAS_DEPS" = "true" ] && continue
+          SUB_KEY=$(echo "$SUB" | jq -r '.key')
+          SUB_IID="${KEY_TO_IID[$SUB_KEY]:-}"
+          [ -z "$SUB_IID" ] && continue
+          SUB_TITLE=$(echo "$SUB" | jq -r '.title')
+          QUEUE+=("$SUB_IID:$(pipe_sanitize_branch "$SUB_IID-$SUB_TITLE")")
+          pipe_log "  queued child #$SUB_IID"
+        done < <(jq -c '.sub_issues[]' "$TRIAGE_JSON")
+      fi
+      unset KEY_TO_IID
+      ;;
+
+    *)
+      pipe_log "  unknown decision '$DECISION' for #$IID, skipping"
+      ;;
+  esac
+done < <(echo "$READY" | jq -c '.[]')
+
+# --- 4. Trigger the queued coder pipelines ----------------------------------
+[ "${#QUEUE[@]}" -eq 0 ] && { pipe_log "No issues queued for the coder"; exit 0; }
+pipe_log "Triggering ${#QUEUE[@]} coder run(s)"
+for ITEM in "${QUEUE[@]}"; do
+  IID="${ITEM%%:*}"
+  BRANCH="${ITEM#*:}"
+  # Atomic claim: relabel ready -> wip first, so a concurrent orchestrator does
+  # not double-trigger. Revert on trigger failure.
+  if issue_set_labels "$IID" "$PIPE_LABEL_WIP" "$PIPE_LABEL_READY"; then
+    if code_trigger "$IID" "$BRANCH"; then
+      pipe_log "  triggered coder for #$IID on $BRANCH"
+    else
+      pipe_log "  ERROR: trigger failed for #$IID, reverting label"
+      issue_set_labels "$IID" "$PIPE_LABEL_READY" "$PIPE_LABEL_WIP"
+    fi
+  else
+    pipe_log "  ERROR: could not claim #$IID, skipping to avoid a double trigger"
+  fi
+done

package/payload/ci-templates/scripts/postmortem.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# Runner for a standalone escalation / diagnose step. The fix skills run the
+# postmortem flow inline when they hit their cap, so the fix-job runners only
+# call pipe_apply_escalation. This script exists for the other callers named in
+# the audit (for example a deploy-fix job) that want a fresh diagnostic as a
+# separate step. It prepares the input, runs /postmortem-mr, then applies labels
+# and posts the comment.
+#
+# The caller sets the failure context via env vars before invoking:
+#   DIAGNOSE_ERROR    original failure text (test failures, review body, deploy json)
+#   DIAGNOSE_GIT_LOG  git log of the fix attempts (oneline)
+#   DIAGNOSE_CONTEXT  which loop got stuck (e.g. "deploy-fix")
+set -e
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=lib/pipeline-common.sh
+source "$SCRIPT_DIR/lib/pipeline-common.sh"
+pipe_defaults
+
+# Prepare the input file the skill reads, unless the caller already did.
+if [ ! -f "$PIPE_CONTEXT_DIR/postmortem-input.md" ]; then
+  META=$(platform_mr_meta)
+  {
+    echo "# Postmortem input"
+    echo
+    echo "MR/PR: !${PIPE_MR_IID:-} $(echo "$META" | jq -r '.title // ""')"
+    echo "Context: ${DIAGNOSE_CONTEXT:-unknown}"
+    echo
+    echo "## Changed files"
+    git diff --name-only "origin/$PIPE_TARGET_BRANCH..HEAD" 2>/dev/null | head -30 || true
+    echo
+    echo "## Fix attempts"
+    echo "${DIAGNOSE_GIT_LOG:-$(git log "origin/$PIPE_TARGET_BRANCH..HEAD" --oneline 2>/dev/null || true)}"
+    echo
+    echo "## Original failure"
+    echo "${DIAGNOSE_ERROR:-}"
+  } > "$PIPE_CONTEXT_DIR/postmortem-input.md"
+fi
+
+# Run the postmortem skill unless a prior inline flow already produced the marker.
+if [ ! -f "$PIPE_CONTEXT_DIR/postmortem.env" ]; then
+  pipe_run_claude postmortem "/postmortem-mr" "Agent,Read,Write,Edit,Glob,Grep,Bash" "$PIPE_MODEL_TRIAGE" < /dev/null
+fi
+
+# Apply the runner side: labels, comment, metric.
+pipe_apply_escalation "" "${DIAGNOSE_CONTEXT:-unknown}"

package/payload/ci-templates/scripts/review-fix.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+# Runner for the `review-fix` job. Runs on failure after `review` on a wip MR/PR.
+# Fetches the latest review comment, runs the /fix-review-findings skill, then
+# pushes the fix commit and posts the applied/dismissed comments, or escalates.
+# The skill does the cap check, the coder delegation, and the verdict marker.
+set -e
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=lib/pipeline-common.sh
+source "$SCRIPT_DIR/lib/pipeline-common.sh"
+pipe_defaults
+
+REVIEW_MARKER="${PIPE_REVIEW_MARKER:-**Automated Code Review**}"
+
+# 1. Gate: only run when review flagged fixable bugs. REVIEW_HAS_BUGS is a
+#    runtime dotenv value from the review job, so rules cannot pre-evaluate it.
+if [ "${REVIEW_HAS_BUGS:-false}" != "true" ]; then
+  pipe_log "No fixable bugs flagged by review, skipping"
+  exit 0
+fi
+
+# 2. Gate: only fix wip MRs/PRs.
+LABELS=$(platform_mr_labels)
+if ! echo "$LABELS" | grep -q "$PIPE_LABEL_WIP"; then
+  pipe_log "Not a $PIPE_LABEL_WIP MR/PR, skipping review-fix"
+  exit 0
+fi
+
+# 3. Git identity and real source-branch checkout.
+pipe_git_identity
+pipe_checkout_source
+FIX_COUNT_BEFORE=$(pipe_count_fix_commits "$PIPE_COMMIT_REVIEWFIX")
+
+# 4. Fetch the latest bot review comment into the file the skill reads.
+platform_resolve_bot_user
+NOTES=$(platform_notes)
+echo "$NOTES" | jq -r --arg u "${PIPE_BOT_USER:-}" --arg m "$REVIEW_MARKER" \
+  '[.[] | select(.author == $u and (.body | startswith($m)))] | last | .body // "(no review found)"' \
+  > "$PIPE_CONTEXT_DIR/review-body.md"
+
+# 5. Run the fix skill. It caps, gathers prior fix diffs, delegates to the coder,
+#    verifies, writes the result JSON, and the review-fix.env marker. On cap it
+#    runs the shared postmortem flow (writing postmortem.md + postmortem.env).
+pipe_run_claude coder "/fix-review-findings" "Agent,Read,Write,Edit,Glob,Grep,Bash" "$PIPE_MODEL_CODE" < /dev/null
+
+# 6. Read the marker the skill wrote.
+RF_ENV="$PIPE_CONTEXT_DIR/review-fix.env"
+RF_ESCALATE=$(pipe_get_env "$RF_ENV" RF_ESCALATE);   RF_ESCALATE=${RF_ESCALATE:-false}
+RF_CHANGED=$(pipe_get_env "$RF_ENV" RF_CHANGED);     RF_CHANGED=${RF_CHANGED:-false}
+RF_APPLIED=$(pipe_get_env "$RF_ENV" RF_APPLIED);     RF_APPLIED=${RF_APPLIED:-0}
+RF_DISMISSED=$(pipe_get_env "$RF_ENV" RF_DISMISSED); RF_DISMISSED=${RF_DISMISSED:-0}
+CATEGORY=$(pipe_get_env "$RF_ENV" FAILURE_CATEGORY)
+
+# Verify a commit actually landed this run before pushing.
+FIX_COUNT_AFTER=$(pipe_count_fix_commits "$PIPE_COMMIT_REVIEWFIX")
+COMMIT_MADE=false
+[ "$FIX_COUNT_AFTER" -gt "$FIX_COUNT_BEFORE" ] && COMMIT_MADE=true
+
+pipe_metric_event review-fix review_findings_applied \
+  "$(jq -n --argjson a "${RF_APPLIED:-0}" --argjson d "${RF_DISMISSED:-0}" '{applied: $a, dismissed: $d}')"
+
+post_dismissed() {
+  local dj
+  dj=$(jq -r '.dismissed // [] | map("- **" + .finding + "**: " + .reason) | join("\n")' "$PIPE_RESULT_REVIEWFIX" 2>/dev/null || true)
+  [ -z "$dj" ] && return 0
+  platform_post_comment "**Review findings dismissed**
+
+The auto-fix agent determined the following findings were false positives and require no code change:
+
+$dj"
+}
+
+# 7. Act on the outcome.
+if [ "$RF_ESCALATE" = "true" ]; then
+  pipe_log "Skill signalled escalation"
+  pipe_apply_escalation "$CATEGORY" "review-fix"
+elif [ "$COMMIT_MADE" = "true" ]; then
+  if pipe_rebase_and_push; then
+    ATTEMPT=$((FIX_COUNT_BEFORE + 1))
+    platform_post_comment "**Auto-fix applied (attempt ${ATTEMPT}/${PIPE_FIX_LOOP_CAP})**
+
+Fixes committed for confirmed bugs from the code review. A new pipeline will run to verify and re-review the changes."
+    post_dismissed
+  fi
+elif [ "$RF_CHANGED" = "false" ]; then
+  pipe_log "Agent determined the findings are false positives"
+  post_dismissed
+else
+  pipe_log "No commit and no result, escalating"
+  pipe_apply_escalation "$CATEGORY" "review-fix-no-progress"
+fi

package/payload/ci-templates/scripts/review.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# Runner for the `review` job. Prepares the MR/PR context from the platform API,
+# computes the diff base, runs the /review-mr skill, posts the merged review as a
+# comment, emits metrics, and gates the pipeline. All reasoning is in the skill.
+set -e
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=lib/pipeline-common.sh
+source "$SCRIPT_DIR/lib/pipeline-common.sh"
+pipe_defaults
+
+REVIEW_MARKER="${PIPE_REVIEW_MARKER:-**Automated Code Review**}"
+
+# 1. Fetch MR/PR meta and build the context file the skill reads (token work).
+META=$(platform_mr_meta)
+MR_TITLE=$(echo "$META" | jq -r '.title // ""')
+MR_DESC=$(echo "$META"  | jq -r '.description // ""')
+
+# Linked issues referenced in the description (e.g. "Closes #42").
+LINKED_ISSUES=$(printf '%s' "$MR_DESC" | grep -oE '#[0-9]+' | grep -oE '[0-9]+' | sort -u || true)
+ISSUES_CONTEXT=""
+for IID in $LINKED_ISSUES; do
+  ISSUE=$(platform_issue "$IID")
+  ISSUES_CONTEXT="$ISSUES_CONTEXT
+Issue #$(echo "$ISSUE" | jq -r '.iid'): $(echo "$ISSUE" | jq -r '.title')
+$(echo "$ISSUE" | jq -r '.description')"
+done
+
+# Previous bot review comment and previous auto-fix activity, for context.
+platform_resolve_bot_user
+NOTES=$(platform_notes)
+PREV_REVIEW=$(echo "$NOTES" | jq -r --arg u "${PIPE_BOT_USER:-}" --arg m "$REVIEW_MARKER" \
+  '[.[] | select(.author == $u and (.body | startswith($m)))] | last | .body // ""' 2>/dev/null || true)
+PRIOR_FIX=$(echo "$NOTES" | jq -r --arg u "${PIPE_BOT_USER:-}" \
+  '[.[] | select(.author == $u and ((.body | startswith("**Auto-fix applied")) or (.body | startswith("**Review findings dismissed"))))] | map(.body) | join("\n\n---\n\n")' 2>/dev/null || true)
+
+# 2. Compute the diff base and incremental flag (platform plumbing over API + git).
+platform_compute_diff_base
+pipe_log "diff base=$PIPE_DIFF_BASE incremental=$PIPE_IS_INCREMENTAL head=$PIPE_HEAD_SHA"
+
+# 3. Write the context file the skill reads. No API access inside the skill.
+{
+  echo "# MR/PR context"
+  echo
+  echo "Title: $MR_TITLE"
+  echo
+  echo "## Description"
+  echo "$MR_DESC"
+  [ -n "$ISSUES_CONTEXT" ] && { echo; echo "## Linked issues"; echo "$ISSUES_CONTEXT"; }
+  [ -n "$PREV_REVIEW" ]    && { echo; echo "## Previous review comment"; echo "$PREV_REVIEW"; }
+  [ -n "$PRIOR_FIX" ]      && { echo; echo "## Previous auto-fix activity"; echo "$PRIOR_FIX"; }
+} > "$PIPE_CONTEXT_DIR/mr-context.md"
+
+# 4. Run the review skill. It builds the diff, runs the reviewers, writes the
+#    merged body to $PIPE_RESULT_REVIEW and the verdict to review.env.
+pipe_run_claude review "/review-mr" "Agent,Read,Write,Edit,Glob,Grep,Bash" "$PIPE_MODEL_REVIEW" < /dev/null
+
+# 5. Read the verdict the skill wrote (drives the status emoji), then post
+#    the review comment (token work). The emoji goes after the marker line,
+#    never before it: the marker prefix is how review.sh and review-fix.sh
+#    find previous bot comments.
+REVIEW_ENV="$PIPE_CONTEXT_DIR/review.env"
+REVIEW_HAS_BUGS=$(pipe_get_env "$REVIEW_ENV" REVIEW_HAS_BUGS); REVIEW_HAS_BUGS=${REVIEW_HAS_BUGS:-false}
+REVIEW_STATUS=$(pipe_get_env "$REVIEW_ENV" REVIEW_STATUS); REVIEW_STATUS=${REVIEW_STATUS:-clean}
+FINDINGS_TOTAL=$(pipe_get_env "$REVIEW_ENV" REVIEW_FINDINGS_TOTAL); FINDINGS_TOTAL=${FINDINGS_TOTAL:-0}
+
+if [ -s "$PIPE_RESULT_REVIEW" ]; then
+  VERDICT_EMOJI="✅"
+  [ "$REVIEW_HAS_BUGS" = "true" ] && VERDICT_EMOJI="❌"
+  BODY="$REVIEW_MARKER
+
+$VERDICT_EMOJI $(cat "$PIPE_RESULT_REVIEW")"
+else
+  BODY="$REVIEW_MARKER
+
+⚠️ Review generation failed. Check the CI job log for details."
+fi
+platform_post_comment "$BODY"
+
+# 6. Emit metrics.
+pipe_metric_event code-reviewer review_findings \
+  "$(jq -n --argjson t "${FINDINGS_TOTAL:-0}" --arg s "$REVIEW_STATUS" \
+      --argjson b "$([ "$REVIEW_HAS_BUGS" = "true" ] && echo true || echo false)" \
+      --argjson inc "$([ "${PIPE_IS_INCREMENTAL:-false}" = "true" ] && echo true || echo false)" \
+      '{findings_total: $t, status: $s, has_fixable_bugs: $b, is_incremental: $inc}')"
+
+# 7. Gate. review.env is exported so the fix job can read REVIEW_HAS_BUGS at
+#    runtime. On GitLab the job exits non-zero to block the pipeline. On GitHub
+#    the workflow step owns the gate (it reads the output first), so it sets
+#    PIPE_NO_GATE=1 and this script leaves the exit to the workflow.
+if [ "$REVIEW_HAS_BUGS" = "true" ]; then
+  pipe_log "Review found confirmed bugs"
+  [ "${PIPE_NO_GATE:-0}" = "1" ] || exit 1
+fi

package/payload/ci-templates/scripts/test-fix.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# Runner for the `test-fix` job. Runs on failure after the project's test stage
+# on a wip MR/PR. Runs the /fix-tests skill (which picks the case, caps, and
+# delegates), then pushes the fix commit or escalates. The project test job and
+# its artifacts stay in the project; this job only consumes them.
+set -e
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=lib/pipeline-common.sh
+source "$SCRIPT_DIR/lib/pipeline-common.sh"
+pipe_defaults
+
+# 1. Gate: only fix wip MRs/PRs.
+LABELS=$(platform_mr_labels)
+if ! echo "$LABELS" | grep -q "$PIPE_LABEL_WIP"; then
+  pipe_log "Not a $PIPE_LABEL_WIP MR/PR, skipping test-fix"
+  exit 0
+fi
+
+# 2. Git identity and real source-branch checkout.
+pipe_git_identity
+pipe_checkout_source
+TESTFIX_BEFORE=$(pipe_count_fix_commits "$PIPE_COMMIT_TESTFIX")
+COVERAGE_BEFORE=$(pipe_count_fix_commits "$PIPE_COMMIT_COVERAGE")
+
+# 3. Run the fix skill. It reads the test reports / coverage signal, picks the
+#    case (tests | coverage | compile | none), caps, delegates to test-fix or
+#    test-writer, verifies, and writes fix-tests.env. On cap it runs the shared
+#    postmortem flow (writing postmortem.md + postmortem.env).
+pipe_run_claude test-fix "/fix-tests" "Agent,Read,Write,Edit,Glob,Grep,Bash" "$PIPE_MODEL_CODE" < /dev/null
+
+# 4. Read the marker the skill wrote.
+FT_ENV="$PIPE_CONTEXT_DIR/fix-tests.env"
+FIX_BRANCH=$(pipe_get_env "$FT_ENV" FIX_BRANCH);       FIX_BRANCH=${FIX_BRANCH:-none}
+FIX_ESCALATE=$(pipe_get_env "$FT_ENV" FIX_ESCALATE);   FIX_ESCALATE=${FIX_ESCALATE:-false}
+CATEGORY=$(pipe_get_env "$FT_ENV" FAILURE_CATEGORY)
+
+# Verify a commit landed (either the test-fix or the coverage subject).
+if [ "$FIX_BRANCH" = "coverage" ]; then
+  AFTER=$(pipe_count_fix_commits "$PIPE_COMMIT_COVERAGE"); BEFORE=$COVERAGE_BEFORE
+else
+  AFTER=$(pipe_count_fix_commits "$PIPE_COMMIT_TESTFIX"); BEFORE=$TESTFIX_BEFORE
+fi
+COMMIT_MADE=false
+[ "${AFTER:-0}" -gt "${BEFORE:-0}" ] && COMMIT_MADE=true
+
+# 5. Act on the outcome.
+if [ "$FIX_ESCALATE" = "true" ]; then
+  pipe_log "Skill signalled escalation"
+  pipe_apply_escalation "$CATEGORY" "test-fix"
+elif [ "$FIX_BRANCH" = "none" ]; then
+  pipe_log "Nothing to fix (false-alarm trigger)"
+elif [ "$COMMIT_MADE" = "true" ]; then
+  if pipe_rebase_and_push; then
+    pipe_log "Pushed $FIX_BRANCH fix commit, a new pipeline will run"
+  fi
+else
+  pipe_log "Agent made no new commit, nothing to push"
+fi

package/payload/skills/fix-review-findings/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: fix-review-findings
+description: Fix the confirmed bugs from an automated code review of a merge request or pull request. Reads the latest review comment and any prior fix attempts, respects the fix-loop cap, delegates the fix to the coder agent, verifies, and commits without pushing. Records applied fixes and dismissed false positives for the pipeline. Use this when a review flagged fixable bugs and CI asks to fix them.
+---
+
+# fix-review-findings
+
+Generic replacement for `review-fix.sh`. The CI job runs `claude "/fix-review-findings"` after a review that flagged fixable bugs. This skill drives the fix. The runner keeps checkout, rebase, push, and the label and comment API calls.
+
+## Step 1: read the project configuration
+
+Read `$PIPE_CONFIG_PATH` (default `.claude/pipeline-config.md`). You need the Git & Platform section, the Build & Tests section, the Documentation Map, and the Suppressions path. If the file is missing, say so on the first line and continue generically.
+
+## Step 2: inputs
+
+- `$PIPE_CONTEXT_DIR/review-body.md`: the latest bot review comment, fetched by the job with the platform token. These are the findings to act on.
+- `$PIPE_VERIFY_CMD`: verification command (compile plus unit tests) to run after a fix.
+- `$PIPE_FIX_LOOP_CAP` (default `2`): maximum consecutive review-fix commits before escalating.
+- `$PIPE_COMMIT_REVIEWFIX`: exact commit subject for a review fix. Its recurrence drives the cap count.
+- `$PIPE_TARGET_BRANCH`: the branch the MR/PR targets, used as the base for the commit-history walk.
+- `$PIPE_RESULT_REVIEWFIX` (default `$PIPE_CONTEXT_DIR/review-fix-result.json`): where the coder writes its structured result.
+- `$PIPE_CONTEXT_DIR` (default `build/pipeline`): where you write the result marker.
+
+## Step 3: cap check
+
+Count consecutive commits from the branch tip back toward `$PIPE_TARGET_BRANCH` whose subject matches `$PIPE_COMMIT_REVIEWFIX`, using local git:
+
+```
+git log "origin/$PIPE_TARGET_BRANCH"..HEAD --format="%s"
+```
+
+Stop at the first non-matching subject. If the count is at or above `$PIPE_FIX_LOOP_CAP`, do not attempt another fix. Escalate: follow the postmortem-mr flow (spawn the `postmortem` agent with the review body as the failure text, the fix-attempt git log, and the changed files, then read `failure_category`). Write the marker with `RF_ESCALATE=true` and the `FAILURE_CATEGORY`, and stop.
+
+## Step 4: gather prior attempts
+
+If the count from step 3 is above zero, this is a retry. Collect the diffs of the earlier review-fix commits so the coder does not repeat a failed approach:
+
+```
+git log "origin/$PIPE_TARGET_BRANCH"..HEAD --grep="$PIPE_COMMIT_REVIEWFIX" -p
+```
+
+## Step 5: delegate to the coder
+
+Spawn the `coder` agent (Agent tool, `subagent_type: coder`). Pass it:
+
+- the review findings from `$PIPE_CONTEXT_DIR/review-body.md`,
+- the prior fix diffs from step 4, if any, with the instruction not to repeat those approaches,
+- these constraints:
+  - fix only the confirmed bugs and security issues in the review, not style notes, nitpicks, or "potential" items,
+  - do not rewrite the feature, target the specific defects,
+  - before fixing each finding, read the source and verify the claim is accurate,
+  - for a finding that is a false positive or an intentional deviation, do not change code. Record it in the Suppressions file (per the coder's own protocol) so it is not re-raised.
+- the exact commit subject `$PIPE_COMMIT_REVIEWFIX` for any commit, because the cap counter matches on it,
+- the instruction to write `$PIPE_RESULT_REVIEWFIX` in this shape and not to run `git push`:
+
+```json
+{"changed": true, "fixes": ["description of each fix"], "dismissed": [{"finding": "brief quote", "reason": "why it is a false positive"}]}
+```
+
+Set `changed` to `false` with an empty `fixes` list when no code changed.
+
+## Step 6: verify
+
+Run `$PIPE_VERIFY_CMD`. Do not leave a non-compiling state for the push.
+
+## Step 7: emit the result marker
+
+Read `$PIPE_RESULT_REVIEWFIX` and write `$PIPE_CONTEXT_DIR/review-fix.env` as dotenv:
+
+```
+RF_COMMIT_MADE=true|false
+RF_CHANGED=true|false
+RF_APPLIED=<count of fixes>
+RF_DISMISSED=<count of dismissed>
+RF_ESCALATE=true|false
+FAILURE_CATEGORY=<category or empty>
+```
+
+Set `RF_COMMIT_MADE=true` only when the consecutive-commit count grew during this run. The job pushes when a commit was made, posts the applied-fix and dismissed-finding comments from the result JSON, and escalates the labels when a commit was made but no result was produced, or when `RF_ESCALATE=true`.