@cxi-lmai/ci-agent-platform 3.0.0 → 3.1.0

package/payload/ci-templates/scripts/metrics-snapshot.sh

@@ -0,0 +1,377 @@
+#!/bin/bash
+# Aggregates one window of pipeline metrics into a single JSON snapshot.
+#
+# Two record kinds share the metrics directory. An invocation record carries an
+# `event` ending in `_invocation` plus the token and cost fields of one agent
+# call, and every other record is a custom pipeline event. Older runners
+# appended custom events to events.jsonl, which is still read when present.
+#
+# Inputs:
+#   - artifacts of pipelines finished inside the window, fetched through the
+#     platform abstraction, skipped entirely when OFFLINE=true
+#   - records written by this run's own jobs, under PIPE_METRICS_DIR
+#
+# Environment:
+#   PIPE_METRICS_WINDOW_DAYS     days of history to aggregate
+#   PIPE_METRICS_OUTPUT_DIR      directory the snapshot is written to
+#   PIPE_METRICS_COMMIT_REPO     "true" also commits the snapshot to the target branch
+#   PIPE_METRICS_REVIEW_AGENTS   comma-separated agents counted as code review
+#   PIPE_METRICS_DEFECT_*        commit subjects that mark a post-merge defect
+#   PIPE_METRICS_SNAPSHOT_DATE   overrides the snapshot date, default today UTC
+#   OFFLINE                      "true" skips every platform call
+#   PIPE_METRICS_RAW_DIR         OFFLINE only, directory of pre-staged records
+#   PIPE_METRICS_MRS_FILE        OFFLINE only, JSON array of merge requests
+#
+# Writes PIPE_METRICS_OUTPUT_DIR/<date>.json. The snapshot is a job artifact;
+# committing it back to the repository is opt-in because a project may refuse
+# generated data on its integration branch.
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=lib/pipeline-common.sh
+source "$SCRIPT_DIR/lib/pipeline-common.sh"
+pipe_defaults
+
+SNAPSHOT_DATE="${PIPE_METRICS_SNAPSHOT_DATE:-$(date -u +%Y-%m-%d)}"
+mkdir -p "$PIPE_METRICS_OUTPUT_DIR"
+
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+
+RAW_DIR="$TMP/raw"
+mkdir -p "$RAW_DIR"
+MRS_FILE="$TMP/mrs.json"
+echo '[]' > "$MRS_FILE"
+
+# Escape a configured marker so it can be used inside a regular expression.
+re_escape() { printf '%s' "$1" | sed 's/[][\\.^$*+?(){}|]/\\&/g'; }
+
+# Artifact archives are read with whichever extractor the runner image has.
+# Only JSON members are unpacked, at any depth: a pipeline's other artifacts
+# (build output, test reports, packaged binaries) share these archives, and
+# unpacking them wholesale would both cost time and feed foreign documents into
+# the aggregation. Depth-independence is required because the two forges lay
+# their archives out differently: job archives keep repository-relative paths,
+# while uploaded-artifact archives are rooted at the uploaded directory itself.
+# collect_records applies the record-shape filter that decides what counts.
+metrics_extract() {
+  local zip="$1" dest="$2"
+  if command -v unzip >/dev/null 2>&1; then
+    unzip -o -q "$zip" '*.json' '*.jsonl' -d "$dest" 2>/dev/null || true
+  elif command -v python3 >/dev/null 2>&1; then
+    python3 -c 'import sys, zipfile
+try:
+    with zipfile.ZipFile(sys.argv[1]) as archive:
+        wanted = [m for m in archive.namelist()
+                  if not m.endswith("/") and (m.endswith(".json") or m.endswith(".jsonl"))]
+        archive.extractall(sys.argv[2], wanted)
+except Exception:
+    pass' "$zip" "$dest" || true
+  else
+    pipe_log "WARNING: no unzip and no python3, cannot read artifact $zip"
+  fi
+}
+
+# ---------------------------------------------------------------------------
+# Phase 1: collect the window's records
+# ---------------------------------------------------------------------------
+
+if [ "${OFFLINE:-false}" = "true" ]; then
+  if [ -n "${PIPE_METRICS_RAW_DIR:-}" ] && [ -d "${PIPE_METRICS_RAW_DIR}" ]; then
+    RAW_DIR="$PIPE_METRICS_RAW_DIR"
+  fi
+  if [ -n "${PIPE_METRICS_MRS_FILE:-}" ] && [ -s "${PIPE_METRICS_MRS_FILE}" ]; then
+    MRS_FILE="$PIPE_METRICS_MRS_FILE"
+  fi
+  pipe_log "Offline mode: reading staged records from $RAW_DIR"
+else
+  SINCE=$(date -u -d "$PIPE_METRICS_WINDOW_DAYS days ago" '+%Y-%m-%dT%H:%M:%SZ')
+  pipe_log "Collecting pipelines finished since $SINCE"
+
+  PIPELINES=$(platform_completed_pipelines "$PIPE_METRICS_WINDOW_DAYS" || echo '[]')
+  pipe_log "Found $(printf '%s' "$PIPELINES" | jq -r 'length') pipeline(s)"
+
+  while read -r PIPELINE_ID; do
+    [ -n "$PIPELINE_ID" ] || continue
+    ARTIFACTS=$(platform_pipeline_artifacts "$PIPELINE_ID" || echo '[]')
+    while read -r JOB_ID; do
+      [ -n "$JOB_ID" ] || continue
+      ZIP="$TMP/$PIPELINE_ID-$JOB_ID.zip"
+      # One unreadable job must not abort the whole aggregation.
+      if platform_download_artifact "$JOB_ID" "$ZIP"; then
+        DEST="$RAW_DIR/$PIPELINE_ID-$JOB_ID"
+        mkdir -p "$DEST"
+        metrics_extract "$ZIP" "$DEST"
+      else
+        pipe_log "WARNING: artifacts for job $JOB_ID are unavailable, skipping"
+      fi
+      rm -f "$ZIP"
+    done < <(printf '%s' "$ARTIFACTS" | jq -r '.[] | select(.artifact_available) | .job_id')
+  done < <(printf '%s' "$PIPELINES" | jq -r '.[].id')
+
+  if ! platform_merge_requests_updated_since "$SINCE" > "$MRS_FILE"; then
+    pipe_log "WARNING: merge request list unavailable, continuing without it"
+    echo '[]' > "$MRS_FILE"
+  fi
+  platform_resolve_bot_user || true
+fi
+
+SEARCH_DIRS=("$RAW_DIR")
+if [ -d "$PIPE_METRICS_DIR" ] && [ "$PIPE_METRICS_DIR" != "$RAW_DIR" ]; then
+  SEARCH_DIRS+=("$PIPE_METRICS_DIR")
+fi
+
+# ---------------------------------------------------------------------------
+# Phase 2 and 3: invocation records and custom events
+# ---------------------------------------------------------------------------
+
+# One record file that is truncated, or that is not a record at all, must cost
+# only itself: parse each file on its own and skip the ones that do not read as
+# a JSON object. Slurping every file in one pass would turn a single unreadable
+# file into an empty, silently wrong snapshot.
+#
+# A job that consumes an upstream job's artifacts republishes the records it
+# received, so the same record can arrive under several per-job directories.
+# Record file names are unique per record, so identical duplicates are
+# byte-identical and collapse on their content.
+# A record is a JSON object carrying a string `agent` and a string `event`.
+# Anything else found next to the records, for example a project manifest that
+# a collected artifact happened to contain, is not a record and is ignored.
+IS_RECORD='(type == "object") and ((.agent | type) == "string") and ((.event | type) == "string")'
+
+collect_records() { # $1 = jq predicate selecting the record kind
+  local file
+  {
+    while IFS= read -r -d '' file; do
+      jq -c "select($IS_RECORD) | select($1)" "$file" 2>/dev/null || true
+    done < <(find "${SEARCH_DIRS[@]}" -type f -name '*.json' -print0 2>/dev/null)
+  } | jq -s -c 'unique_by(tojson)' 2>/dev/null || echo '[]'
+}
+
+INVOCATIONS=$(collect_records '(.event // "") | endswith("_invocation")')
+EVENT_FILES=$(collect_records '((.event // "") | endswith("_invocation")) | not')
+EVENT_LINES=$({
+  while IFS= read -r -d '' file; do
+    jq -c "select($IS_RECORD)" "$file" 2>/dev/null || true
+  done < <(find "${SEARCH_DIRS[@]}" -type f -name 'events.jsonl' -print0 2>/dev/null)
+} | jq -s -c 'unique_by(tojson)' 2>/dev/null || echo '[]')
+EVENTS=$(jq -nc --argjson a "$EVENT_FILES" --argjson b "$EVENT_LINES" '($a + $b) | unique_by(tojson)')
+
+pipe_log "Collected $(printf '%s' "$INVOCATIONS" | jq -r 'length') invocation record(s)"
+pipe_log "Collected $(printf '%s' "$EVENTS" | jq -r 'length') event(s)"
+
+# ---------------------------------------------------------------------------
+# Phase 4: merge request view with defect detection
+# ---------------------------------------------------------------------------
+
+RE_REVERT=$(re_escape "$PIPE_METRICS_DEFECT_REVERT")
+RE_REGRESSION=$(re_escape "$PIPE_METRICS_DEFECT_REGRESSION")
+RE_REINTRODUCE=$(re_escape "$PIPE_METRICS_DEFECT_REINTRODUCE")
+
+MRS_VIEW=$(jq -c \
+  --arg revert "$RE_REVERT" \
+  --arg regression "$RE_REGRESSION" \
+  --arg reintroduce "$RE_REINTRODUCE" \
+  '[.[] | . as $mr | ($mr.description // "") as $body | {
+      iid: $mr.iid,
+      title: ($mr.title // ""),
+      state: ($mr.state // ""),
+      author: ($mr.author // ""),
+      labels: ($mr.labels // []),
+      created_at: ($mr.created_at // ""),
+      merged_at: $mr.merged_at,
+      description: $body,
+      defect_type: (
+        if   ($body | test($revert; "i"))      then "revert"
+        elif ($body | test($regression; "i"))  then "regression-fix"
+        elif ($body | test($reintroduce; "i")) then "reintroduces"
+        else null end
+      ),
+      references: [
+        $body
+        | scan("(?:" + $revert + "|" + $regression + "|" + $reintroduce + ")[[:space:]]*[!#]?([0-9]+)"; "i")[]?
+        | select(. != null)
+        | tonumber
+      ]
+    }]' "$MRS_FILE")
+
+pipe_log "Processed $(printf '%s' "$MRS_VIEW" | jq -r 'length') merge request(s)"
+
+# ---------------------------------------------------------------------------
+# Phase 5: cost and tokens per agent
+# ---------------------------------------------------------------------------
+
+BY_AGENT=$(printf '%s' "$INVOCATIONS" | jq -c '
+  group_by(.agent)
+  | map({
+      key: (.[0].agent // "unknown"),
+      value: {
+        count:          length,
+        cost_usd:       (map(.total_cost_usd          // 0) | add // 0),
+        input_tokens:   (map(.input_tokens            // 0) | add // 0),
+        output_tokens:  (map(.output_tokens           // 0) | add // 0),
+        cache_read:     (map(.cache_read_tokens       // 0) | add // 0),
+        cache_creation: (map(.cache_creation_tokens   // 0) | add // 0)
+      }
+    })
+  | from_entries')
+
+# ---------------------------------------------------------------------------
+# Phase 5b: split each agent's cost by the author of the change it acted on
+#
+# Review jobs run on bot and human merge requests alike, so the cost of the
+# autonomous loop is only separable when each invocation is attributed to the
+# author of the merge request it reviewed. Invocations without a merge request
+# are "none", and a merge request outside this window is "unknown".
+# ---------------------------------------------------------------------------
+
+AUTHOR_TAG='
+  ($mrs[0] | map({key: (.iid | tostring), value: .author}) | from_entries) as $authors
+  | map(. + {author_type: (
+      if (.mr_iid == null) then "none"
+      else ($authors[(.mr_iid | tostring)] // null) as $author
+        | if   $author == null    then "unknown"
+          elif $author == $bot    then "bot"
+          else                         "human" end
+      end)})'
+
+BY_AGENT_AUTHOR=$(printf '%s' "$INVOCATIONS" | jq -c \
+  --argjson mrs "[$MRS_VIEW]" --arg bot "${PIPE_BOT_USER:-}" "
+  $AUTHOR_TAG
+  | group_by(.agent)
+  | map({
+      key: (.[0].agent // \"unknown\"),
+      value: (group_by(.author_type) | map({
+        key: .[0].author_type,
+        value: {
+          count:          length,
+          cost_usd:       (map(.total_cost_usd        // 0) | add // 0),
+          input_tokens:   (map(.input_tokens          // 0) | add // 0),
+          output_tokens:  (map(.output_tokens         // 0) | add // 0),
+          cache_read:     (map(.cache_read_tokens     // 0) | add // 0),
+          cache_creation: (map(.cache_creation_tokens // 0) | add // 0)
+        }
+      }) | from_entries)
+    })
+  | from_entries")
+
+REVIEW_COST_BY_AUTHOR=$(printf '%s' "$INVOCATIONS" | jq -c \
+  --argjson mrs "[$MRS_VIEW]" --arg bot "${PIPE_BOT_USER:-}" \
+  --arg review_agents "$PIPE_METRICS_REVIEW_AGENTS" "
+  (\$review_agents | split(\",\") | map(select(length > 0))) as \$reviewers
+  | $AUTHOR_TAG
+  | map(select((.agent // \"\") | IN(\$reviewers[])))
+  | {
+      bot:     (map(select(.author_type == \"bot\")     | .total_cost_usd // 0) | add // 0),
+      human:   (map(select(.author_type == \"human\")   | .total_cost_usd // 0) | add // 0),
+      unknown: (map(select(.author_type == \"unknown\") | .total_cost_usd // 0) | add // 0)
+    }")
+
+# ---------------------------------------------------------------------------
+# Phase 6: escalation failure categories
+# ---------------------------------------------------------------------------
+
+FAILURE_CATEGORIES=$(printf '%s' "$EVENTS" | jq -c '
+  [.[] | select(.event == "dev_stuck") | (.failure_category // .category // "other")]
+  | group_by(.)
+  | map({key: .[0], value: length})
+  | from_entries')
+
+# ---------------------------------------------------------------------------
+# Phase 6b: post-merge defects counted from commit subjects
+#
+# The three subjects are conventions, not guesses: they are configured in the
+# project's pipeline config so the aggregator and the humans writing commits
+# agree. Offline runs have no repository history to scan.
+# ---------------------------------------------------------------------------
+
+count_subject() { # $1 = escaped subject prefix, stdin = commit messages
+  local matches
+  matches=$(grep -cE "^$1" || true)
+  printf '%s' "${matches:-0}"
+}
+
+if [ "${OFFLINE:-false}" = "true" ]; then
+  POST_MERGE_DEFECTS='{"reverts":0,"fixes":0,"reintroduces":0}'
+else
+  GIT_LOG_FILE="$TMP/commit-subjects.txt"
+  git log --since="$SINCE" --format=%B > "$GIT_LOG_FILE" 2>/dev/null || : > "$GIT_LOG_FILE"
+  DEFECT_REVERTS=$(count_subject "$RE_REVERT" < "$GIT_LOG_FILE")
+  DEFECT_FIXES=$(count_subject "$RE_REGRESSION" < "$GIT_LOG_FILE")
+  DEFECT_REINTRODUCES=$(count_subject "$RE_REINTRODUCE" < "$GIT_LOG_FILE")
+  pipe_log "Post-merge defects: reverts=$DEFECT_REVERTS fixes=$DEFECT_FIXES reintroduces=$DEFECT_REINTRODUCES"
+  POST_MERGE_DEFECTS=$(jq -nc \
+    --argjson reverts "$DEFECT_REVERTS" \
+    --argjson fixes "$DEFECT_FIXES" \
+    --argjson reintroduces "$DEFECT_REINTRODUCES" \
+    '{reverts: $reverts, fixes: $fixes, reintroduces: $reintroduces}')
+fi
+
+# ---------------------------------------------------------------------------
+# Phase 7: write the snapshot
+# ---------------------------------------------------------------------------
+
+OUT_FILE="$PIPE_METRICS_OUTPUT_DIR/$SNAPSHOT_DATE.json"
+jq -n \
+  --arg     date                  "$SNAPSHOT_DATE" \
+  --arg     bot                   "${PIPE_BOT_USER:-}" \
+  --argjson invocations           "$INVOCATIONS" \
+  --argjson events                "$EVENTS" \
+  --argjson mrs                   "$MRS_VIEW" \
+  --argjson by_agent              "$BY_AGENT" \
+  --argjson by_agent_author       "$BY_AGENT_AUTHOR" \
+  --argjson review_cost_by_author "$REVIEW_COST_BY_AUTHOR" \
+  --argjson failure_categories    "$FAILURE_CATEGORIES" \
+  --argjson post_merge_defects    "$POST_MERGE_DEFECTS" \
+  '{
+    date:        $date,
+    invocations: $invocations,
+    events:      $events,
+    mrs:         $mrs,
+    totals: {
+      cost_usd:               ($invocations | map(.total_cost_usd        // 0) | add // 0),
+      input_tokens:           ($invocations | map(.input_tokens          // 0) | add // 0),
+      output_tokens:          ($invocations | map(.output_tokens         // 0) | add // 0),
+      cache_read_tokens:      ($invocations | map(.cache_read_tokens     // 0) | add // 0),
+      cache_creation_tokens:  ($invocations | map(.cache_creation_tokens // 0) | add // 0),
+      operations_count:       ($invocations | length),
+      merged_mrs:             ($mrs | map(select(.state == "merged")) | length),
+      bot_mrs:                ($mrs | map(select($bot != "" and .author == $bot)) | length),
+      defect_references:      ($mrs | map(.references | length) | add // 0),
+      orchestrator_decisions: ($events | map(select(.event == "orchestrator_decision")) | length),
+      review_rounds:          ($events | map(select(.event == "review_findings")) | length),
+      dev_stuck:              ($events | map(select(.event == "dev_stuck")) | length)
+    },
+    by_agent:              $by_agent,
+    by_agent_author:       $by_agent_author,
+    review_cost_by_author: $review_cost_by_author,
+    failure_categories:    $failure_categories,
+    post_merge_defects:    $post_merge_defects
+  }' > "$OUT_FILE"
+
+pipe_log "Wrote $OUT_FILE"
+
+# ---------------------------------------------------------------------------
+# Phase 8: commit the snapshot, only when the project opted in
+# ---------------------------------------------------------------------------
+
+if [ "${OFFLINE:-false}" != "true" ] && [ "$PIPE_METRICS_COMMIT_REPO" = "true" ]; then
+  # The snapshot is written on whatever ref the schedule ran, so it is untracked
+  # there. Move it aside before switching: if the target branch already carries a
+  # snapshot for this date, git would refuse to overwrite an untracked file and
+  # the job would fail with a git error instead of reaching the no-op branch.
+  pipe_git_identity
+  git fetch origin "$PIPE_TARGET_BRANCH"
+  cp "$OUT_FILE" "$TMP/snapshot.json"
+  git checkout -f -B "$PIPE_TARGET_BRANCH" "origin/$PIPE_TARGET_BRANCH"
+  mkdir -p "$PIPE_METRICS_OUTPUT_DIR"
+  cp "$TMP/snapshot.json" "$OUT_FILE"
+  git add "$OUT_FILE"
+  if git diff --cached --quiet; then
+    pipe_log "Snapshot already current, nothing to commit"
+  else
+    # [skip ci] keeps a data commit from starting another pipeline.
+    git commit -m "chore(metrics): snapshot $SNAPSHOT_DATE [skip ci]"
+    git push origin "$PIPE_TARGET_BRANCH"
+    pipe_log "Pushed snapshot to $PIPE_TARGET_BRANCH"
+  fi
+fi

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

@@ -119,12 +119,18 @@ while IFS= read -r ISSUE; do
 
   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
+  pipe_run_agent 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
+    if pipe_is_credit_exhaustion_files "$PIPE_AGENT_STDERR" "$TRIAGE_JSON"; then
+      pipe_failure_log_notice_files "triage of issue #$IID" "triage this issue by hand" \
+        "$PIPE_AGENT_STDERR" "$TRIAGE_JSON" | while IFS= read -r line; do pipe_log "$line"; done
+      pipe_log "  model credit exhausted; aborting triage batch"
+      break
+    fi
     pipe_log "  no usable triage output for #$IID, skipping"
     continue
   fi
@@ -140,26 +146,30 @@ while IFS= read -r ISSUE; do
       ;;
 
     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."
+      QUESTION_FILE="$PIPE_CONTEXT_DIR/triage-question.md"
+      jq -r '.question // "Please provide more detail before this issue can be implemented."' "$TRIAGE_JSON" > "$QUESTION_FILE"
+      COMMENT_FILE="$PIPE_CONTEXT_DIR/triage-clarification.md"
+      {
+        printf '🤖 **The pipeline needs clarification before implementing:**\n\n'
+        cat "$QUESTION_FILE"
+        printf '\n\nPut the complete spec in the issue **description**, not in a comment: the pipeline reads only the description.\n'
+      } > "$COMMENT_FILE"
+      issue_comment_file "$IID" "$COMMENT_FILE"
       issue_set_labels "$IID" "$PIPE_LABEL_BLOCKER" "$PIPE_LABEL_READY"
-      emit_decision_metric "$IID" clarification-needed ask "$QUESTION"
+      emit_decision_metric "$IID" clarification-needed ask "Clarification requested"
       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\`."
+      SUGGEST_FILE="$PIPE_CONTEXT_DIR/triage-suggestion.md"
+      jq -r '.suggestion // "Please split this issue into smaller pieces."' "$TRIAGE_JSON" > "$SUGGEST_FILE"
+      COMMENT_FILE="$PIPE_CONTEXT_DIR/triage-decomposition-suggestion.md"
+      {
+        printf '**This issue is clear but too large for a single agent session.**\n\nSuggested decomposition:\n\n'
+        cat "$SUGGEST_FILE"
+        printf '\n\nPlease split it into smaller issues and label each `%s`.\n' "$PIPE_LABEL_READY"
+      } > "$COMMENT_FILE"
+      issue_comment_file "$IID" "$COMMENT_FILE"
       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"
@@ -167,13 +177,14 @@ Please split it into smaller issues and label each \`$PIPE_LABEL_READY\`."
 
     decompose)
       # Re-validate deterministically before mutating the platform.
-      if ! pipe_validate_decomposition "$(cat "$TRIAGE_JSON")"; then
+      if ! pipe_validate_decomposition_file "$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\`."
+        COMMENT_FILE="$PIPE_CONTEXT_DIR/triage-decomposition-rejected.md"
+        {
+          printf '**This issue is too large and automatic decomposition did not produce a valid split.**\n\nReason: %s\n\n' "$DECOMP_REJECT_REASON"
+          printf 'Please split it manually into smaller issues and label each `%s`.\n' "$PIPE_LABEL_READY"
+        } > "$COMMENT_FILE"
+        issue_comment_file "$IID" "$COMMENT_FILE"
         issue_set_labels "$IID" "$PIPE_LABEL_BLOCKER" "$PIPE_LABEL_READY"
         emit_decision_metric "$IID" clarification-needed ask "Decomposition rejected by gate"
         continue
@@ -181,7 +192,8 @@ Please split it manually into smaller issues and label each \`$PIPE_LABEL_READY\
 
       CONFIDENCE=$(pipe_get_env "$TRIAGE_ENV" TRIAGE_CONFIDENCE)
       CONFIDENCE=${CONFIDENCE:-$(jq -r '.confidence // "low"' "$TRIAGE_JSON")}
-      REASON=$(jq -r '.reason // ""' "$TRIAGE_JSON")
+      REASON_FILE="$PIPE_CONTEXT_DIR/triage-reason.md"
+      jq -r '.reason // ""' "$TRIAGE_JSON" > "$REASON_FILE"
       SUB_COUNT=$(jq '.sub_issues | length' "$TRIAGE_JSON")
       pipe_log "  decomposing #$IID into $SUB_COUNT sub-issues (confidence=$CONFIDENCE)"
 
@@ -189,11 +201,14 @@ Please split it manually into smaller issues and label each \`$PIPE_LABEL_READY\
       declare -A KEY_TO_IID=()
       CREATED=()
       FAILED=false
+      SUB_INDEX=0
       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')
+        SUB_KEY=$(printf '%s' "$SUB" | jq -r '.key')
+        SUB_TITLE=$(printf '%s' "$SUB" | jq -r '.title')
+        SUB_SPEC_FILE="$PIPE_CONTEXT_DIR/sub-issue-${SUB_INDEX}.md"
+        printf '%s' "$SUB" | jq -r '.spec_markdown' > "$SUB_SPEC_FILE"
+        SUB_INDEX=$((SUB_INDEX + 1))
+        HAS_DEPS=$(printf '%s' "$SUB" | jq '(.depends_on // []) | length > 0')
         if [ "$CONFIDENCE" = "high" ] && [ "$HAS_DEPS" = "false" ]; then
           SUB_LABEL="$PIPE_LABEL_READY"
         elif [ "$CONFIDENCE" = "low" ]; then
@@ -201,7 +216,7 @@ Please split it manually into smaller issues and label each \`$PIPE_LABEL_READY\
         else
           SUB_LABEL="$PIPE_LABEL_BLOCKED"
         fi
-        NEW_IID=$(issue_create "$SUB_TITLE" "$SUB_SPEC" "$SUB_LABEL")
+        NEW_IID=$(issue_create_file "$SUB_TITLE" "$SUB_SPEC_FILE" "$SUB_LABEL")
         if [ -z "$NEW_IID" ]; then
           pipe_log "  ERROR: failed to create sub-issue for key '$SUB_KEY'"
           FAILED=true
@@ -214,7 +229,10 @@ Please split it manually into smaller issues and label each \`$PIPE_LABEL_READY\
 
       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."
+        COMMENT_FILE="$PIPE_CONTEXT_DIR/triage-decomposition-partial.md"
+        printf '**Auto-decomposition partially failed.** Created so far: %s. Relabeled `%s` to prevent re-decomposition. Please finish manually.\n' \
+          "${CHILD_LIST:-none}" "$PIPE_LABEL_BLOCKER" > "$COMMENT_FILE"
+        issue_comment_file "$IID" "$COMMENT_FILE"
         issue_set_labels "$IID" "$PIPE_LABEL_BLOCKER" "$PIPE_LABEL_READY"
         unset KEY_TO_IID
         continue
@@ -238,15 +256,15 @@ Please split it manually into smaller issues and label each \`$PIPE_LABEL_READY\
       # 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 -->"
+      COMMENT_FILE="$PIPE_CONTEXT_DIR/triage-decomposed.md"
+      {
+        printf '**Auto-decomposed by the pipeline** (confidence: `%s`).\n\nReason: ' "$CONFIDENCE"
+        cat "$REASON_FILE"
+        printf '\n\nSplit into %s sub-issues: %s\n\n' "$SUB_COUNT" "$CHILD_LIST"
+        printf 'Sub-issues with prerequisites are labeled `%s` and are promoted automatically when their blockers close. This parent closes automatically when all children close.\n\n' "$PIPE_LABEL_BLOCKED"
+        printf '<!-- pipe-children: %s -->\n' "$CHILD_LIST"
+      } > "$COMMENT_FILE"
+      issue_comment_file "$IID" "$COMMENT_FILE"
       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}')"
 

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

@@ -38,7 +38,17 @@ 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
+  pipe_run_agent postmortem "/postmortem-mr" "Agent,Read,Write,Edit,Glob,Grep,Bash" "$PIPE_MODEL_TRIAGE" < /dev/null
+  if [ ! -s "$PIPE_CONTEXT_DIR/postmortem.md" ]; then
+    if [ -s "$PIPE_AGENT_STDERR" ]; then
+      pipe_failure_notice_files "postmortem diagnosis" "investigate this failure by hand" \
+        "$PIPE_AGENT_STDERR" > "$PIPE_CONTEXT_DIR/postmortem.md"
+      if pipe_is_credit_exhaustion_files "$PIPE_AGENT_STDERR"; then
+        platform_post_comment_file "$PIPE_CONTEXT_DIR/postmortem.md"
+        exit 0
+      fi
+    fi
+  fi
 fi
 
 # Apply the runner side: labels, comment, metric.

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

@@ -40,7 +40,7 @@ echo "$NOTES" | jq -r --arg u "${PIPE_BOT_USER:-}" --arg m "$REVIEW_MARKER" \
 # 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
+pipe_run_agent 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"
@@ -59,26 +59,37 @@ 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"
+  local dismissed_file comment_file
+  dismissed_file="$PIPE_CONTEXT_DIR/review-dismissed.md"
+  jq -er '.dismissed // [] | map("- **" + .finding + "**: " + .reason) | join("\n") | select(length > 0)' \
+    "$PIPE_RESULT_REVIEWFIX" > "$dismissed_file" 2>/dev/null || true
+  [ -s "$dismissed_file" ] || return 0
+  comment_file="$PIPE_CONTEXT_DIR/review-dismissed-comment.md"
+  {
+    printf '**Review findings dismissed**\n\nThe auto-fix agent determined the following findings were false positives and require no code change:\n\n'
+    cat "$dismissed_file"
+  } > "$comment_file"
+  platform_post_comment_file "$comment_file"
 }
 
 # 7. Act on the outcome.
 if [ "$RF_ESCALATE" = "true" ]; then
   pipe_log "Skill signalled escalation"
+  if pipe_is_credit_exhaustion_files "$PIPE_AGENT_STDERR"; then
+    COMMENT_FILE="$PIPE_CONTEXT_DIR/review-fix-credit-exhausted.md"
+    pipe_failure_notice_files "review fixes" "resolve the review findings by hand" \
+      "$PIPE_AGENT_STDERR" > "$COMMENT_FILE"
+    platform_post_comment_file "$COMMENT_FILE"
+    exit 0
+  fi
   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."
+    COMMENT_FILE="$PIPE_CONTEXT_DIR/review-fix-applied.md"
+    printf '**Auto-fix applied (attempt %s/%s)**\n\nFixes committed for confirmed bugs from the code review. A new pipeline will run to verify and re-review the changes.\n' \
+      "$ATTEMPT" "$PIPE_FIX_LOOP_CAP" > "$COMMENT_FILE"
+    platform_post_comment_file "$COMMENT_FILE"
     post_dismissed
   fi
 elif [ "$RF_CHANGED" = "false" ]; then