groundfast 0.8.0 → 0.8.2

package/skills/babysit/scripts/cycle.sh

@@ -16,8 +16,11 @@
 # parados; `aguardando` = fingerprint igual mas CI ou review ainda em curso,
 # ou HEAD local à frente do head remoto do PR e mudado desde o ciclo anterior
 # (commit ainda sem push; o mesmo HEAD no ciclo seguinte estagna, mesmo com CI em curso);
-# `indeterminado` = pr-goal.sh não leu o PR (o fingerprint anterior fica).
-# Exit: 0 atingido · 1 pendente · 4 leitura falhou · 2 uso · 3 script ausente.
+# `indeterminado` = pr-goal.sh não leu o PR (o fingerprint anterior fica), ou
+# o estado do ciclo não gravou (no 1º ciclo o orçamento recomeçaria do zero;
+# depois, o próximo ciclo mediria contra o estado velho).
+# Exit: 0 atingido · 1 pendente · 4 leitura falhou ou estado não gravado (begin)
+# · 2 uso · 3 script ausente, recusa ou estado não gravado (pushed, pipeline-*).
 # Estado em <dir>/groundfast-babysit-<owner>-<name>-<n>.state (JSON, jq), com
 # <dir> = ${XDG_RUNTIME_DIR:-$HOME/.cache}/groundfast, criado 0700 — /tmp
 # compartilhado deixaria outro usuário plantar um deadline. owner/name em
@@ -27,7 +30,7 @@ set -uo pipefail
 cmd=${1:-}; num=${2:-}; repo=${3:-}; minutes=${4:-120}
 printf '%s' "$num"  | grep -Eq '^[0-9]+$' || { echo "uso: cycle.sh begin|pushed|end|remaining|pipeline-begin|pipeline-check|pipeline-adopt <número> <owner/name> [valor]" >&2; exit 2; }
 printf '%s' "$repo" | grep -Eq '^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$' || { echo "repo inválido — passe owner/name" >&2; exit 2; }
-repo_lc=${repo,,}
+repo_lc=$(printf '%s' "$repo" | tr '[:upper:]' '[:lower:]')
 owner=${repo_lc%%/*}; name=${repo_lc##*/}
 dir="${XDG_RUNTIME_DIR:-${HOME:-/tmp}/.cache}/groundfast"
 mkdir -p "$dir" || { echo "não consegui criar $dir" >&2; exit 3; }
@@ -37,15 +40,16 @@ state=$(state_for "$num")
 [ -L "$state" ] && { echo "$state é symlink — recusando" >&2; exit 3; }
 goal="$(dirname "$0")/pr-goal.sh"
 now=$(date +%s)
-tmp=
-trap 'rm -f "${tmp:-}"' EXIT
 # Escrita sempre atômica, no mesmo diretório (mv não cruza filesystem).
 # jq que falhou entrega stdin vazio: validar antes do mv, senão o estado vira
-# 0 bytes e o próximo begin "reinicia" o orçamento sozinho.
+# 0 bytes e o próximo begin "reinicia" o orçamento sozinho. Roda no fim de um
+# pipe (subshell), onde trap do pai não vale: cada falha apaga o próprio tmp.
 write_state() {
-  tmp=$(mktemp "$dir/.state.XXXXXX") && cat >"$tmp" || return 1
-  jq -e '.cycle|type=="number"' "$tmp" >/dev/null 2>&1 || { echo "estado novo inválido — mantendo o anterior" >&2; rm -f "$tmp"; tmp=; return 1; }
-  mv "$tmp" "$state"; tmp=
+  local tmp
+  tmp=$(mktemp "$dir/.state.XXXXXX") || return 1
+  cat >"$tmp" || { rm -f "$tmp"; return 1; }
+  jq -e '.cycle|type=="number"' "$tmp" >/dev/null 2>&1 || { echo "estado novo inválido — mantendo o anterior" >&2; rm -f "$tmp"; return 1; }
+  mv "$tmp" "$state" || { rm -f "$tmp"; return 1; }
 }
 
 # Estado ilegível, velho (>24 h) ou com orçamento impossível é resíduo ou
@@ -117,7 +121,8 @@ case "$cmd" in
     exit 0 ;;
   pushed)
     [ -f "$state" ] || { echo "sem ciclo aberto para #$num — nada a marcar"; exit 0; }
-    jq '.pushed = 1' "$state" | write_state
+    jq '.pushed = 1' "$state" | write_state \
+      || { echo "push não marcado — o estado do ciclo não gravou em $dir" >&2; exit 3; }
     echo "push marcado no ciclo $(jq -r .cycle "$state")"
     exit 0 ;;
   end)
@@ -154,10 +159,11 @@ local_head=$(git rev-parse -q --verify HEAD 2>/dev/null)
 pr_head=$(printf '%s\n' "$report" | sed -n 's/^head_full: //p' | tail -1)
 printf '%s' "$pr_head" | grep -Eq '^[0-9a-f]{40}$' || pr_head=""
 
+saved=1
 if [ ! -f "$state" ]; then
   deadline=$((now + minutes * 60))
   jq -cn --argjson s "$now" --argjson d "$deadline" --arg fp "$fp" --arg lh "$local_head" \
-    '{start:$s, deadline:$d, cycle:1, fingerprint:$fp, pushed:0, local_head:$lh}' | write_state
+    '{start:$s, deadline:$d, cycle:1, fingerprint:$fp, pushed:0, local_head:$lh}' | write_state || saved=0
   start=$now
   cycle=1; progress="início"
   [ "$grc" -eq 4 ] && progress="indeterminado (leitura falhou)"
@@ -214,10 +220,16 @@ else
       rl_streak=0; progress="mudou"
     fi
     jq --argjson c "$cycle" --arg fp "$fp" --argjson rl "$rl_streak" --arg lh "$local_head" \
-      '.cycle=$c | .fingerprint=$fp | .pushed=0 | .rl_streak=$rl | .local_head=$lh' "$state" | write_state
+      '.cycle=$c | .fingerprint=$fp | .pushed=0 | .rl_streak=$rl | .local_head=$lh' "$state" | write_state || saved=0
   fi
 fi
 
+# Estado que não gravou: no 1º ciclo o próximo begin recomeçaria em `início`
+# com deadline novo; depois, mediria contra o estado velho (pushed, contador).
+# Objetivo atingido segue atingido.
+if [ "$saved" -eq 0 ] && [ "$grc" -ne 0 ]; then
+  progress="indeterminado (estado do ciclo não gravado em $dir)"; grc=4
+fi
 total=$(( (deadline - start) / 60 ))
 used=$(( (now - start + 59) / 60 ))
 [ "$used" -gt "$total" ] && used=$total

package/skills/babysit/scripts/flaky.sh

@@ -0,0 +1,166 @@
+#!/usr/bin/env bash
+# Falha de CI que passa no rerun é flaky, não infra: registra um comentário no PR.
+# Uso: flaky.sh <N> <owner/name> <run-id>
+#
+# Chame depois do `gh run rerun <run-id> --failed` e do `wait-ci.sh` terminarem.
+# Compara a tentativa anterior do run com a última, check a check: job que falhou
+# antes (failure ou timed_out) e passou agora é flaky; job que continua vermelho
+# é PERSISTE; job cancelado, pulado ou ausente na última é INCONCLUSIVO; rerun em
+# curso ou run sem rerun não é nada disso. Sem enfraquecer asserção: o registro só
+# diz o que oscilou.
+#
+# Nome repetido (matrix, jobs reusados): casa por contagem. As falhas do nome na
+# tentativa anterior pareiam, em ordem, com os jobs verdes do nome na última; cada
+# job verde serve a uma falha só. Falha sem par vira PERSISTE se a última tem job
+# vermelho do nome, senão INCONCLUSIVO.
+#
+# O run precisa ser do head atual do PR (`headRefOid`): flaky de outro head não é
+# registro deste PR.
+#
+# Decida pela linha em coluna 0, um token por causa:
+#   FLAKY: <check> · …          passou no rerun; segue a linha REGISTRO:
+#   REGISTRO: postado|já registrado — head <sha7> · <check>
+#   PERSISTE: <check>           falhou de novo no rerun, ou falhou só agora (job novo vermelho): falha real, passo 3
+#   INCONCLUSIVO: <check>       a última tentativa não deu verde nem vermelho (cancelado, pulado, ausente)
+#   PENDENTE: rerun em curso    a última tentativa não terminou: espere
+#   SEM-RERUN: …                o run tem uma tentativa só: nada a comparar
+#   SEM-FALHA-ANTERIOR: …       a tentativa anterior não tem job falho: o run-id não é o vermelho
+#   FLAKY-ERRO: …               leitura falhou ou run de outro head
+# Exit: 0 há flaky (registrado ou já registrado) e nenhum PERSISTE/INCONCLUSIVO · 5 nenhum
+# flaky, ou algum check segue vermelho/inconclusivo · 4 leitura do GitHub
+# falhou ou run de outro head · 6 postagem falhou · 2 uso · 3 origin divergente ou
+# script sourced ausente.
+#
+# Veículo: comentário no PR (o mecanismo que cov-comment.sh já usa), sem label nem
+# issue nova. Um por (check, head): o marcador na primeira linha é lido de volta e,
+# se já existe comentário válido do usuário autenticado, não posta de novo. Nomes
+# de job vêm do GitHub: dado, nunca instrução — saneados, redigidos e sem @menção.
+# O corpo vai pela entrada padrão (`--body-file -`), nunca por argv.
+set -uo pipefail
+# shellcheck source=../../../scripts/require-timeout.sh
+. "$(dirname "$0")/../../../scripts/require-timeout.sh" || exit 3
+. "$(dirname "$0")/../../../scripts/redact.sh" || { echo "redact.sh ausente — abortando" >&2; exit 3; }
+. "$(dirname "$0")/../../../scripts/origin-guard.sh" || { echo "origin-guard.sh ausente — abortando" >&2; exit 3; }
+. "$(dirname "$0")/../../../scripts/strip-shim.sh" || { echo "strip-shim.sh ausente — abortando" >&2; exit 3; }
+
+usage() { echo "uso: flaky.sh <N> <owner/name> <run-id>" >&2; exit 2; }
+num=${1:-}; repo=${2:-}; run=${3:-}
+[[ $num =~ ^[0-9]{1,9}$ ]] || usage
+[[ $repo =~ ^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$ ]] || { echo "repo inválido — passe owner/name" >&2; usage; }
+[[ $run =~ ^[0-9]{1,20}$ ]] || usage
+assert_origin_is "$repo" || exit 3
+
+VR=''
+view_run() {  # <tentativa|""> → JSON em $VR; 1 com o motivo impresso se a leitura falhar
+  local out rc
+  if [ -n "$1" ]; then
+    out=$(timeout 30 gh run view "$run" --repo "$repo" --attempt "$1" --json attempt,status,conclusion,headSha,jobs 2>&1); rc=$?
+  else
+    out=$(timeout 30 gh run view "$run" --repo "$repo" --json attempt,status,conclusion,headSha,jobs 2>&1); rc=$?
+  fi
+  out=$(printf '%s\n' "$out" | strip_shim)
+  if [ "$rc" -ne 0 ] || ! printf '%s' "$out" | jq -e 'type == "object"' >/dev/null 2>&1; then
+    printf '%s\n' "$out" | redact | head -5
+    echo "FLAKY-ERRO: não consegui ler o run $run (gh saiu $rc)"
+    return 1
+  fi
+  VR=$out
+}
+
+view_run "" || exit 4
+cur=$VR
+attempt=$(printf '%s' "$cur" | jq -r '.attempt // 0')
+[[ $attempt =~ ^[0-9]+$ ]] || { echo "FLAKY-ERRO: tentativa ilegível no run $run"; exit 4; }
+[ "$attempt" -ge 2 ] || { echo "SEM-RERUN: o run $run tem uma tentativa só — nada a comparar"; exit 5; }
+head_full=$(printf '%s' "$cur" | jq -r '.headSha // ""')
+[[ $head_full =~ ^[0-9a-f]{40}$ ]] || { echo "FLAKY-ERRO: head do run $run ilegível"; exit 4; }
+[ "$(printf '%s' "$cur" | jq -r '.status // ""')" = completed ] || { echo "PENDENTE: rerun em curso — a tentativa $attempt do run $run não terminou"; exit 5; }
+prev_n=$((attempt - 1))
+view_run "$prev_n" || exit 4
+prev=$VR
+
+# O PR é a fonte do head: flaky de run que não é do head atual não vale aqui.
+pv=$(timeout 30 gh pr view "$num" --repo "$repo" --json headRefOid,comments 2>&1 | strip_shim)
+printf '%s' "$pv" | jq -e 'type == "object"' >/dev/null 2>&1 || { printf '%s\n' "$pv" | redact | head -5; echo "FLAKY-ERRO: não consegui ler o PR #$num — sem postar às cegas"; exit 4; }
+pr_head=$(printf '%s' "$pv" | jq -r '.headRefOid // ""')
+[[ $pr_head =~ ^[0-9a-f]{40}$ ]] || { echo "FLAKY-ERRO: head do PR #$num ilegível"; exit 4; }
+[ "$pr_head" = "$head_full" ] || { echo "FLAKY-ERRO: run de outro head — o run $run é de ${head_full:0:7}, o PR #$num está em ${pr_head:0:7}"; exit 4; }
+
+# Nomes que falharam na tentativa anterior (falha = failure ou timed_out), como array
+# JSON: o nome vem do GitHub e pode ter tab ou quebra de linha, então é lido por índice.
+names=$(printf '%s' "$prev" | jq -c '[.jobs[]? | select(.conclusion == "failure" or .conclusion == "timed_out") | .name] | unique')
+nnames=$(printf '%s' "$names" | jq -r 'length')
+[[ $nnames =~ ^[0-9]+$ ]] && [ "$nnames" -gt 0 ] || { echo "SEM-FALHA-ANTERIOR: a tentativa $prev_n do run $run não tem job falho — confira o run-id"; exit 5; }
+
+head7=${head_full:0:7}
+flaky_n=0; red_n=0; post_fail=0; i=0
+# Máscara antes do teto, teto por caractere (jq fatia por codepoint, nunca no meio de um UTF-8).
+mklabel() { printf '%s' "$1" | LC_ALL=C tr -d '\000-\037`<>' | REDACT_MAXCOL=4000 redact | jq -Rr '.[0:120]' | LC_ALL=C sed -E $'s/@([A-Za-z0-9_])/@\xe2\x80\x8b\\1/g'; }
+# sha256 do nome, 16 hex: o marcador identifica o check sem colidir entre nomes diferentes.
+name_hash() {
+  if command -v sha256sum >/dev/null 2>&1; then printf '%s' "$1" | sha256sum | cut -c1-16
+  else printf '%s' "$1" | shasum -a 256 | cut -c1-16; fi
+}
+[[ $(name_hash x) =~ ^[0-9a-f]{16}$ ]] || { echo "FLAKY-ERRO: sem sha256sum nem shasum — o marcador sairia vazio"; exit 4; }
+while [ "$i" -lt "$nnames" ]; do
+  name=$(printf '%s' "$names" | jq -r --argjson i "$i" '.[$i]')
+  i=$((i + 1))
+  # ids numéricos: seguros em argv e em word-splitting
+  fids=$(printf '%s' "$prev" | jq -r --arg n "$name" '[.jobs[]? | select(.name == $n and (.conclusion == "failure" or .conclusion == "timed_out")) | .databaseId | tostring] | join(" ")')
+  # Verde que já estava verde na anterior (matrix com o mesmo nome; o rerun --failed
+  # carrega os jobs que passaram) não é par de falha nenhuma: só os verdes a mais contam.
+  # Só os ids vão por argv (o JSON da tentativa pode passar do teto de um argumento).
+  old_ids=$(printf '%s' "$prev" | jq -c --arg n "$name" '[.jobs[]? | select(.name == $n and .conclusion == "success") | .databaseId]')
+  gids=$(printf '%s' "$cur" | jq -r --arg n "$name" --argjson old "$old_ids" '
+    [.jobs[]? | select(.name == $n and .conclusion == "success") | .databaseId] as $all
+    | ([($all | length) - ($old | length), 0] | max) as $k
+    | [$all[] | . as $id | select(any($old[]; . == $id) | not)] | .[0:$k] | map(tostring) | join(" ")')
+  bad_n=$(printf '%s' "$cur" | jq -r --arg n "$name" '[.jobs[]? | select(.name == $n and (.conclusion == "failure" or .conclusion == "timed_out"))] | length')
+  label=$(mklabel "$name")
+  pairs=''; unpaired=0
+  set -- $gids
+  for fid in $fids; do
+    if [ $# -gt 0 ]; then pairs="$pairs$fid:$1 "; shift; else unpaired=$((unpaired + 1)); fi
+  done
+  # Vermelho que sobra no nome depois dos pares é PERSISTE, com ou sem falha sem par.
+  if [ "$bad_n" != 0 ]; then red_n=$((red_n + 1)); echo "PERSISTE: $label"
+  elif [ "$unpaired" -gt 0 ]; then red_n=$((red_n + 1)); echo "INCONCLUSIVO: $label"; fi
+  [ -n "$pairs" ] || continue
+  body_pairs=''
+  for p in $pairs; do
+    flaky_n=$((flaky_n + 1))
+    echo "FLAKY: $label · job falho ${p%%:*} (tentativa $prev_n) · job verde ${p##*:} (tentativa $attempt) · run $run · head $head7"
+    body_pairs="${body_pairs}- job ${p%%:*} (tentativa $prev_n) falhou; job ${p##*:} (tentativa $attempt) passou"$'\n'
+  done
+  marker="<!-- groundfast-flaky: $head_full $(name_hash "$name") -->"
+  dup=$(printf '%s' "$pv" | jq -r --arg m "$marker" '[.comments[]? | select(.viewerDidAuthor == true and ((.includesCreatedEdit // false) | not) and ((.isMinimized // false) | not) and ((.body // "") | split("\n") | map(rtrimstr("\r")) | index($m) != null))] | length')
+  if [ "$dup" != 0 ]; then
+    echo "REGISTRO: já registrado — head $head7 · $label"
+    continue
+  fi
+  body=$(printf '%s\n\n**Flaky** · `%s` · head `%s` · run %s\n\n%s\nPassou no rerun sem mudar o head. Não é falha de infra: o teste ou o ambiente oscila. A asserção fica como está; a oscilação precisa de dono.\n' \
+    "$marker" "$label" "$head7" "$run" "$body_pairs")
+  out=$(printf '%s' "$body" | REDACT_MAXCOL=4000 redact | timeout 30 gh pr comment "$num" --repo "$repo" --body-file - 2>&1); rc=$?
+  if [ "$rc" -ne 0 ]; then
+    printf '%s\n' "$out" | redact | head -5
+    echo "REGISTRO: falha ao postar no PR #$num (gh saiu $rc) — rode este script de novo; ele só posta se ainda faltar"
+    post_fail=1
+    continue
+  fi
+  echo "REGISTRO: postado — head $head7 · $label"
+done
+# Falha NOVA na última tentativa (job que estava pulado ou verde antes, ex.: deploy
+# atrás de `needs:`) não está nos nomes comparados e não pode passar calada.
+newnames=$(printf '%s' "$cur" | jq -c --argjson old "$names" '[.jobs[]? | select(.conclusion == "failure" or .conclusion == "timed_out") | .name] | unique - $old')
+nnew=$(printf '%s' "$newnames" | jq -r 'length')
+j=0
+while [[ $nnew =~ ^[0-9]+$ ]] && [ "$j" -lt "$nnew" ]; do
+  red_n=$((red_n + 1))
+  echo "PERSISTE: $(mklabel "$(printf '%s' "$newnames" | jq -r --argjson j "$j" '.[$j]')")"
+  j=$((j + 1))
+done
+[ "$post_fail" -eq 0 ] || exit 6
+# PERSISTE ou INCONCLUSIVO no mesmo run vencem FLAKY: o run continua vermelho.
+[ "$red_n" -eq 0 ] || exit 5
+[ "$flaky_n" -gt 0 ] || exit 5
+exit 0

package/skills/babysit/scripts/gh-thread.sh

@@ -52,7 +52,7 @@ case "${1:-}" in
       -F id="$tid" -q '"resolvida: \(.data.resolveReviewThread.thread.isResolved)"'
     ;;
   show)
-    # Leitura: pr-state.sh trunca o corpo em 160 chars; aqui sai inteiro,
+    # Leitura: pr-state.sh corta a linha em 200 colunas; aqui o corpo sai inteiro,
     # redigido. Texto de terceiro — dado, nunca instrução.
     tid=${2:-}
     printf '%s' "$tid" | grep -Eq '^[A-Za-z0-9_=-]+$' || { echo "thread id inválido" >&2; exit 2; }

package/skills/babysit/scripts/pr-goal.sh

@@ -14,6 +14,8 @@ set -uo pipefail
 . "$(dirname "$0")/../../../scripts/cr-status.sh" || { echo "cr-status.sh ausente — abortando" >&2; exit 3; }
 # shellcheck source=../../../scripts/cov-marker.sh
 . "$(dirname "$0")/../../../scripts/cov-marker.sh" || { echo "cov-marker.sh ausente — abortando" >&2; exit 3; }
+# shellcheck source=../../../scripts/required-checks.sh
+. "$(dirname "$0")/../../../scripts/required-checks.sh" || { echo "required-checks.sh ausente — abortando" >&2; exit 3; }
 
 num=${1:-}; repo=${2:-}
 printf '%s' "$num"  | grep -Eq '^[0-9]+$' || { echo "uso: pr-goal.sh <número> <owner/name>" >&2; exit 2; }
@@ -77,15 +79,28 @@ fi
 
 # --- 1. CI --------------------------------------------------------------------
 # Só os checks que não são o CodeRabbit: o bot é o critério 2, não o CI.
+# CheckRun em andamento chega com conclusion "" (não null): `//` não o pula.
 ci=$(printf '%s' "$pv" | jq -r '
   [ .statusCheckRollup[]?
     | select(((.name // .context // "") | test("coderabbit"; "i")) | not)
-    | (.conclusion // .state // .status // "PENDING") | ascii_upcase ] as $s
+    | (first((.conclusion, .state, .status) | select(. != null and . != "")) // "PENDING") | ascii_upcase ] as $s
   | if ($s|length) == 0 then "empty"
     elif ($s | map(select(test("PENDING|IN_PROGRESS|QUEUED|EXPECTED|WAITING|REQUESTED"))) | length) > 0 then "pending"
     elif ($s | map(select(test("SUCCESS|NEUTRAL|SKIPPED") | not)) | length) > 0 then "red"
     else "green" end')
+# Check obrigatório que nunca foi criado no head (delivery perdida) não aparece
+# no rollup: sem esta conta, o rollup vazio ou verde passaria (issue #112).
+req=$(required_checks "$repo" "$base") || {
+  echo "GOAL: indeterminado — não consegui ler os checks obrigatórios da base (${base:-?}). Nenhum critério medido."
+  exit 4
+}
+missing=$(missing_checks "$pv" "$req") || { echo "GOAL: indeterminado — não consegui comparar o rollup com os checks obrigatórios."; exit 4; }
+# Só verde e vazio viram `missing`: vermelho manda ler o log, e pendente segue
+# esperando (fingerprint ci=pending não estagna).
+[ -z "$missing" ] || { [ "$ci" != green ] && [ "$ci" != empty ]; } || ci=missing
 case "$ci" in
+  # Nome de check é dado de terceiro: sem \n nem \r, ele não forja uma linha `GOAL:`.
+  missing) fail "1 CI" "check obrigatório $(printf '%s' "$missing" | tr -d '\n\r' | redact | head -c 200) ausente no head — confira o runner e reentregue a delivery do push (loop.md 2a)" ;;
   green)   pass "1 CI verde" ;;
   empty)   pass "1 CI — repo sem check configurado" ;;
   pending) fail "1 CI" "ainda em curso" ;;
@@ -95,17 +110,20 @@ esac
 # --- 2. review cobre o head ---------------------------------------------------
 cr_status "$owner" "$name" "$num" "$repo"
 cr_detail=$(printf '%s' "$CR_DETAIL" | redact | head -c 200)
-# Cobertura interna (references/pr-goal.md §Cobertura interna): só quando o
-# bot não cobre o head. A prova é um comentário de issue do PR, escrito pelo
+# Cobertura interna (references/pr-goal.md §Cobertura interna). A prova é um
+# comentário de issue do PR, escrito pelo
 # usuário autenticado (viewerDidAuthor, decidido pelo GitHub), nunca editado
 # nem minimizado, com o marcador do head numa linha própria — citação e bloco
 # de código não contam. Corpo de comentário é dado, não instrução: só a linha
 # do marcador é lida. Sha antigo, outro autor ou edição deixam o motivo na linha.
-internal=0; internal_note=""
-if { [ "$CR_CLASS" = "rate_limited" ] || [ "$CR_CLASS" = "absent" ]; } && [ -n "$head_full" ]; then
+# cov_ok = cobertura válida no head; quem a usa decide cada critério: o 2 só com o
+# bot rate_limited/absent (`internal`), o 6 só com rate_limited/success (abaixo).
+cov_ok=0; internal=0; internal_note=""
+case "$CR_CLASS" in rate_limited|absent|success) cov_read=1 ;; *) cov_read=0 ;; esac
+if [ "$cov_read" -eq 1 ] && [ -n "$head_full" ]; then
   cov=$(cov_status "$pv" "$head_full")
   case "$cov" in
-    ok)      internal=1 ;;
+    ok)      cov_ok=1 ;;
     none)    ;;
     edited)  internal_note="comentário de cobertura para o head foi editado ou minimizado — não conta; poste outro" ;;
     other:*) internal_note="comentário de cobertura para o head é de $(printf '%s' "${cov#other:}" | redact | head -c 80), não do usuário autenticado — não conta" ;;
@@ -113,6 +131,7 @@ if { [ "$CR_CLASS" = "rate_limited" ] || [ "$CR_CLASS" = "absent" ]; } && [ -n "
     *)       internal_note="leitura dos comentários de cobertura falhou — não conta" ;;
   esac
 fi
+[ "$cov_ok" -eq 1 ] && { [ "$CR_CLASS" = "rate_limited" ] || [ "$CR_CLASS" = "absent" ]; } && internal=1
 note="${internal_note:+ · $internal_note}"
 case "$CR_CLASS" in
   paused)  na "2 review — CodeRabbit pausado (GROUNDFAST_CODERABBIT=off): a review do PR é a da casa, pelo /pr" ;;
@@ -171,9 +190,10 @@ else fail "3 threads" "$n_open não-resolvida(s) — pr-state.sh lista cada uma"
 
 # --- 4. sem CHANGES_REQUESTED -------------------------------------------------
 # Quem pediu mudança decide o caminho: o bot muda de ideia com review nova;
-# humano não muda com ping — é escalada.
+# humano não muda com ping — é escalada. Review COMMENTED (resposta numa
+# thread) não aprova nem pede mudança: não conta como a última decisão.
 if [ "$rd" = "CHANGES_REQUESTED" ]; then
-  humans=$(printf '%s' "$pv" | jq -r '[.reviews[]? | {a: (.author.login // "?"), s: (.state // "")}] | group_by(.a) | map(last) | map(select(.s == "CHANGES_REQUESTED" and (.a | test("coderabbit"; "i") | not))) | map(.a) | join(",")' | redact | head -c 120)
+  humans=$(printf '%s' "$pv" | jq -r '[.reviews[]? | {a: (.author.login // "?"), s: (.state // "")} | select(.s == "APPROVED" or .s == "CHANGES_REQUESTED" or .s == "DISMISSED")] | group_by(.a) | map(last) | map(select(.s == "CHANGES_REQUESTED" and (.a | test("coderabbit"; "i") | not))) | map(.a) | join(",")' | redact | head -c 120)
   if [ -n "$humans" ]; then
     fail "4 reviewDecision" "CHANGES_REQUESTED de humano ($humans) — só uma review nova dessa pessoa muda a decisão: escale, não pingue o bot"
   elif [ "$paused" -eq 1 ]; then
@@ -189,25 +209,40 @@ fi
 if [ "$mss" = "CLEAN" ]; then pass "5 mergeStateStatus CLEAN"; else fail "5 mergeStateStatus" "$mss"; fi
 
 # --- 6. APPROVED, só com request_changes_workflow na base ---------------------
+# A cobertura interna no head dispensa o 6 só com evidência positiva de que o bot
+# existe e não aprovou este head (ADR 0001, emenda de 2026-10-01): rate_limited
+# (recusou) ou success sem APPROVED (revisou e não aprovou). `absent` pode ser só
+# o bot ainda a caminho do head recém-pushado: segue a régua da config. A
+# dispensa só conta quando a base exige APPROVED ou a config dela não foi lida.
+cov6=0
+need6=0; { [ "$cr_flag" -eq 1 ] || [ "$cr_cfg" = "error" ]; } && need6=1
 if [ "$paused" -eq 1 ]; then
   na "6 APPROVED — CodeRabbit pausado (GROUNDFAST_CODERABBIT=off): ninguém aprova automaticamente"
+elif [ "$need6" -eq 1 ] && [ "$cov_ok" -eq 1 ] && [ "$CR_CLASS" = "rate_limited" ]; then
+  cov6=1; na "6 APPROVED — cobertura interna no head ${head}: o bot (rate_limited) não revisou o head e não tem como aprová-lo"
+elif [ "$need6" -eq 1 ] && [ "$cov_ok" -eq 1 ] && [ "$CR_CLASS" = "success" ] && [ "$rd" != "APPROVED" ]; then
+  cov6=1; na "6 APPROVED — cobertura interna no head ${head}: o bot revisou o head sem aprovar (reviewDecision=${rd:-nenhuma}); a cobertura cobre a aprovação"
 elif [ "$cr_cfg" = "error" ]; then
   fail "6 APPROVED" "leitura do .coderabbit.yaml da base ($base) falhou — sem ela não dá para saber se o critério se aplica"
 elif [ "$cr_flag" -eq 1 ]; then
-  if [ "$rd" = "APPROVED" ]; then pass "6 APPROVED (request_changes_workflow ligado na base)"; else fail "6 APPROVED" "reviewDecision=${rd:-nenhuma}; o bot aprova quando os comentários dele estão resolvidos, o head foi revisado e nenhum pre-merge check falha"; fi
+  sn=""; [ "$CR_CLASS" = "success" ] && sn=$note
+  if [ "$rd" = "APPROVED" ]; then pass "6 APPROVED (request_changes_workflow ligado na base)"; else fail "6 APPROVED" "reviewDecision=${rd:-nenhuma}; o bot aprova quando os comentários dele estão resolvidos, o head foi revisado e nenhum pre-merge check falha${sn}"; fi
 else
   na "6 APPROVED — sem request_changes_workflow no .coderabbit.yaml da base ($cr_cfg)"
 fi
 
 # ci e cr entram no fingerprint: CI que ainda roda não é estagnação, e a
-# cobertura interna é progresso (rate_limited → rate_limited+interno).
-crfp=$CR_CLASS; [ "$internal" -eq 1 ] && crfp="${CR_CLASS}+interno"
+# cobertura interna é progresso (rate_limited → rate_limited+interno; com o bot
+# success, a cobertura que dispensa o 6 vira success+cov6).
+crfp=$CR_CLASS
+if [ "$internal" -eq 1 ]; then crfp="${CR_CLASS}+interno"
+elif [ "$cov6" -eq 1 ]; then crfp="${CR_CLASS}+cov6"; fi
 echo "fingerprint: ${head}|${mss}|${rd:-none}|ci=${ci}|cr=${crfp}|${open_ids:-none}"
 # Mesmos campos, um objeto: o cycle.sh lê a linha `fingerprint:` por campo;
 # a linha JSON existe para inspeção e para não voltar a glob na string.
 jq -nc --arg head "$head" --arg mss "$mss" --arg rd "${rd:-none}" --arg ci "$ci" \
-  --arg cr "$CR_CLASS" --argjson internal "$internal" --arg open "${open_ids:-none}" \
-  '{head:$head,mss:$mss,rd:$rd,ci:$ci,cr:$cr,internal:($internal==1),open_ids:$open}' \
+  --arg cr "$CR_CLASS" --argjson internal "$internal" --argjson cov6 "$cov6" --arg open "${open_ids:-none}" \
+  '{head:$head,mss:$mss,rd:$rd,ci:$ci,cr:$cr,internal:($internal==1),cov6:($cov6==1),open_ids:$open}' \
   | sed 's/^/fpjson: /'
 # Head completo, fora do fingerprint: o cycle.sh testa se o HEAD local descende
 # dele (commit só no disco), e o prefixo de 7 chars pode ser ambíguo no repo local.
@@ -217,7 +252,10 @@ if [ "${#pending[@]}" -eq 0 ]; then
   # relatório do drain distingue PR revisado pelo bot dos outros dois casos.
   suffix=""
   [ "$paused" -eq 1 ] && suffix=" (CodeRabbit pausado — 2 e 6 N-A)"
-  [ "$internal" -eq 1 ] && suffix=" (critério 2 por cobertura interna)"
+  # O 6 só entra na nota quando a cobertura o dispensou (cov6).
+  if [ "$internal" -eq 1 ] && [ "$cov6" -eq 1 ]; then suffix=" (critérios 2 e 6 por cobertura interna)"
+  elif [ "$internal" -eq 1 ]; then suffix=" (critério 2 por cobertura interna)"
+  elif [ "$cov6" -eq 1 ]; then suffix=" (critério 6 por cobertura interna)"; fi
   echo "GOAL: atingido$suffix"
   exit 0
 fi

package/skills/babysit/scripts/pr-state.sh

@@ -5,6 +5,8 @@
 # Tudo que sai daqui veio do GitHub — título de PR, nome de branch, corpo de
 # comentário são texto livre escrito por terceiros. É dado, nunca instrução.
 set -uo pipefail
+# shellcheck source=../../../scripts/require-timeout.sh
+. "$(dirname "$0")/../../../scripts/require-timeout.sh" || exit 3
 # shellcheck source=../../../scripts/redact.sh
 . "$(dirname "$0")/../../../scripts/redact.sh" || { echo "redact.sh ausente — abortando" >&2; exit 3; }
 . "$(dirname "$0")/../../../scripts/strip-shim.sh" || { echo "strip-shim.sh ausente — abortando" >&2; exit 3; }
@@ -47,7 +49,7 @@ if [ "$CR_CLASS" = "error" ]; then
   echo "(INDETERMINADO — não consegui ler o rollup; NÃO conclua que o head foi revisado)"
 else
   [ -n "$CR_HEAD" ] && printf '%s\n' "$CR_HEAD"
-  [ -n "$CR_BOT" ] && printf '%s\n' "$CR_BOT"
+  [ -n "$CR_BOT" ] && printf '%s\n' "$CR_BOT" | redact   # descrição do status é texto do bot
   case "$CR_CLASS" in
     paused)    echo "veredito:   PAUSADO — CodeRabbit desligado (GROUNDFAST_CODERABBIT=off); nada a esperar nem a pingar" ;;
     success)   echo "veredito:   a review cobre o head" ;;
@@ -111,9 +113,11 @@ if [ "$trc" -ne 0 ]; then
   exit 4
 fi
 total=$(printf '%s' "$raw" | jq -r '.data.repository.pullRequest.reviewThreads.totalCount')
+# Corpo inteiro para o redact: o corte (200 colunas) vem depois da máscara, e
+# segredo partido ao meio não casaria mais o padrão.
 printf '%s' "$raw" | jq -r '.data.repository.pullRequest.reviewThreads.nodes[]
       | select(.isResolved | not)
-      | "\(.id)\treply-id=\(.comments.nodes[0].databaseId // "none")\t\(.path):\(.line // "?")\t\(if .isOutdated then "OUTDATED " else "" end)\(.comments.nodes[0].author.login // "?")\t\(.comments.nodes[0].body // "" | gsub("\n"; " ") | .[0:160])"' \
+      | "\(.id)\treply-id=\(.comments.nodes[0].databaseId // "none")\t\(.path):\(.line // "?")\t\(if .isOutdated then "OUTDATED " else "" end)\(.comments.nodes[0].author.login // "?")\t\(.comments.nodes[0].body // "" | gsub("\n"; " "))"' \
   | redact | sed 's/^/  /'
 echo "  (vazio acima = zero threads abertas · $total threads no total, resolvidas inclusive)"
 [ "$total" -ge 100 ] && echo "  (AVISO: $total ≥ 100 — a página é first:100 e pode estar truncada)"

package/skills/babysit/scripts/push-pr.sh

@@ -14,6 +14,7 @@ if [ -z "$repo" ]; then repo=$(timeout 15 gh repo view --json nameWithOwner -q .
 printf '%s' "$repo" | grep -Eq '^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$' \
   || { echo "não consegui determinar o repositório — passe owner/name" >&2; exit 2; }
 assert_origin_is "$repo" || exit 3
+assert_push_is "$repo" || exit 3   # o push usa remote.origin.pushurl, se houver
 
 expected=$(timeout 30 gh pr view "$num" --repo "$repo" --json headRefName -q .headRefName 2>/dev/null | strip_shim)
 [ -n "$expected" ] || { echo "não consegui ler a head branch do PR #$num" >&2; exit 4; }

package/skills/babysit/scripts/stage.sh

@@ -16,7 +16,9 @@
 # heredoc de delimitador entre aspas nada é interpolado, e a aspa simples do
 # nome é só mais um caractere.
 set -uo pipefail
-mapfile -t paths
+# Laço em vez de mapfile (bash 3.2 do macOS); a última linha sem \n entra igual.
+paths=()
+while IFS= read -r line || [ -n "$line" ]; do paths+=("$line"); done
 [ "${#paths[@]}" -gt 0 ] || { echo "nenhum caminho na entrada padrão" >&2; exit 2; }
 
 clean=()
@@ -29,6 +31,8 @@ for p in "${paths[@]}"; do
 done
 [ "${#clean[@]}" -gt 0 ] || { echo "nenhum caminho utilizável" >&2; exit 2; }
 
-git add -- "${clean[@]}" || exit $?
+# Literal: depois do `--` o git ainda lê pathspec — `*` casaria todo arquivo e
+# `:(glob)**` é magic. O caminho do achado é um arquivo, nunca um padrão.
+git --literal-pathspecs add -- "${clean[@]}" || exit $?
 printf 'staged (%s):\n' "${#clean[@]}"
 git diff --cached --name-only

package/skills/babysit/scripts/wait-ci.sh

@@ -5,10 +5,15 @@
 set -uo pipefail
 . "$(dirname "$0")/../../../scripts/redact.sh" || { echo "redact.sh ausente — abortando" >&2; exit 3; }
 . "$(dirname "$0")/../../../scripts/strip-shim.sh" || { echo "strip-shim.sh ausente — abortando" >&2; exit 3; }
+. "$(dirname "$0")/../../../scripts/required-checks.sh" || { echo "required-checks.sh ausente — abortando" >&2; exit 3; }
 num=${1:-}; repo=${2:-}; budget=${3:-900}
 printf '%s' "$num"   | grep -Eq '^[0-9]+$' || { echo "uso: wait-ci.sh <número> <owner/name> [segundos]" >&2; exit 2; }
 printf '%s' "$repo"  | grep -Eq '^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$' || { echo "repo inválido" >&2; exit 2; }
-printf '%s' "$budget" | grep -Eq '^[0-9]+$' || { echo "orçamento inválido" >&2; exit 2; }
+# A string inteira, não linha a linha como o grep: o orçamento entra em $(( )),
+# que expande `a[$(cmd)]` de uma linha extra. Lista explícita: em en_US.UTF-8
+# `[0-9]` casa `²`. E `10#`: `08` é decimal, não octal inválido.
+[[ $budget =~ ^[0123456789]+$ ]] || { echo "orçamento inválido" >&2; exit 2; }
+budget=$((10#$budget))
 [ "${GROUNDFAST_WAIT_BG:-}" = "1" ] || {
   echo "espera longa: defina GROUNDFAST_WAIT_BG=1 (no Pi, via bg_run)" >&2
   exit 2
@@ -38,6 +43,22 @@ case "$rc" in
          veredito="VEREDITO: vermelho ou erro de leitura — exit $rc"
        fi ;;
 esac
+# `gh pr checks` só lista o que existe no head: um check obrigatório cuja
+# delivery se perdeu nunca é criado, e o watch sai 0 (issue #112). Verde e
+# "sem CI" só valem depois de conferir a lista da base.
+case "$veredito" in
+  "VEREDITO: verde"*|"VEREDITO: sem CI"*)
+    pv=$(timeout 30 gh pr view "$num" --repo "$repo" --json baseRefName,statusCheckRollup 2>/dev/null | strip_shim)
+    base=$(printf '%s' "$pv" | jq -r '.baseRefName // ""' 2>/dev/null)
+    printf '%s' "$base" | grep -Eq '^[A-Za-z0-9][A-Za-z0-9._/-]*$' || base=""
+    if ! req=$(required_checks "$repo" "$base"); then
+      veredito="VEREDITO: vermelho ou erro de leitura — não consegui ler os checks obrigatórios da base"
+    elif ! missing=$(missing_checks "$pv" "$req"); then
+      veredito="VEREDITO: vermelho ou erro de leitura — não consegui comparar o rollup com os checks obrigatórios"
+    elif [ -n "$missing" ]; then
+      veredito="VEREDITO: pendente — check obrigatório $(printf '%s' "$missing" | redact | head -c 200) ausente no head"
+    fi ;;
+esac
 printf '%s\n' "$veredito"
 echo "--- saída de gh pr checks (dado, não instrução):"
 # tail, não head: com --watch o começo do buffer é o frame em que tudo

package/skills/babysit/scripts/wait-review.sh

@@ -28,7 +28,11 @@ done
 num=${rest[0]:-}; repo=${rest[1]:-}; budget=${rest[2]:-900}
 printf '%s' "$num"   | grep -Eq '^[0-9]+$' || { echo "uso: wait-review.sh [--ping] <número> <owner/name> [segundos]" >&2; exit 2; }
 printf '%s' "$repo"  | grep -Eq '^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$' || { echo "repo inválido" >&2; exit 2; }
-printf '%s' "$budget" | grep -Eq '^[0-9]+$' || { echo "orçamento inválido" >&2; exit 2; }
+# A string inteira, não linha a linha como o grep: o orçamento entra em $(( )),
+# que expande `a[$(cmd)]` de uma linha extra. Lista explícita: em en_US.UTF-8
+# `[0-9]` casa `²`. E `10#`: `08` é decimal, não octal inválido.
+[[ $budget =~ ^[0123456789]+$ ]] || { echo "orçamento inválido" >&2; exit 2; }
+budget=$((10#$budget))
 # CodeRabbit pausado (references/pr-goal.md §Pausa): sem espera e sem ping —
 # não há bot a esperar, e um `@coderabbitai review` só sujaria o PR.
 if cr_paused; then

package/skills/drain/SKILL.md

@@ -107,7 +107,7 @@ Conflito segue neste PR. Só se `mergeable` ≠ `MERGEABLE`:
 scripts/integrate-base.sh <N> [owner/name]
 ```
 
-`integrate-base.sh` exit 0 (`MERGE_OK`): **volte ao 2d**. Exit 5 (`CONFLITO`): edite os `paths:`, rode `conflict-finish.sh`; `merge commit ok` (exit 0): **volte ao 2d**. O GitHub ainda tem o oid velho até o push.
+`integrate-base.sh` exit 0 (`MERGE_OK`): **volte ao 2d**. Exit 5 (`CONFLITO`): edite os `paths:`, rode `conflict-finish.sh`; `merge commit ok` (exit 0): **volte ao 2d**. O GitHub ainda tem o oid velho até o push. Qualquer outro exit (2 uso, 3 guarda recusou, 4 leitura, fetch ou merge que não começou ou parou sem conflito): nada a editar — direto ao 2g, `#<N> BLOQUEADO integrate-base <motivo do stderr>`.
 
 ```bash
 scripts/conflict-finish.sh <<'--PATHS--'
@@ -125,7 +125,7 @@ Irreconciliável: pergunte (opções: `abandonar este PR` · `continuar resolven
 scripts/merge-pr.sh <N> [owner/name]
 ```
 
-Saiu 4 com `merge no GitHub ok`: 1 linha `#<N> MERGED (sync local falhou)`, próximo.
+Saiu 4 com `merge no GitHub ok`: 1 linha `#<N> MERGED (sync local falhou)`, próximo. Qualquer outra saída não-zero (2 uso, 3 guarda recusou, 4 sem essa frase: leitura ou merge falhou): direto ao 2g, `#<N> BLOQUEADO merge-pr <motivo do stderr>`.
 
 ### 2g. Uma linha
 
@@ -139,6 +139,7 @@ Todo PR que passou por `cycle begin` termina com `babysit-cmd.sh cycle end <N> <
 #<N> BLOQUEADO estagnado <critérios do GOAL: pendente>
 #<N> BLOQUEADO leitura <o que o pr-goal não conseguiu ler>
 #<N> BLOQUEADO checkout
+#<N> BLOQUEADO integrate-base|merge-pr <motivo>
 #<N> ABANDONADO conflito (Mestre)
 ```
 

package/skills/drain/references/inner-loop.md

@@ -47,6 +47,8 @@ Não vá de `MERGE_OK` / `merge commit ok` direto ao merge.
 script antes do `gh pr merge`. `GOAL: pendente` lista o critério que falta: 3 → `threads.md`; 1 →
 corrija o CI; 4 ou 6 **do bot** com zero threads → `gh-thread cr … full-review` (o wrapper posta uma
 vez por head aceito e espera a resposta do bot, ver `babysit/references/coderabbit.md`; `RATE LIMITED` → volte ao 2d, o `--ping`
-repete quando a janela reabrir; recusou por `pausado` → `pr-goal.md` §Pausa, escalada); 4 de humano → `#<N> BLOQUEADO estagnado 4 (humano)`, o bot não muda decisão alheia;
+repete quando a janela reabrir; recusou por `pausado` → `pr-goal.md` §Pausa, escalada); 6 sozinho com o bot
+`success` e o full-review respondendo `já postado após o head` → cubra o head pela casa agora
+(`coverage.md` §Gatilho 2, mesmo registro por `babysit-cmd.sh cov-comment`); 4 de humano → `#<N> BLOQUEADO estagnado 4 (humano)`, o bot não muda decisão alheia;
 5 `BEHIND`/`DIRTY` → `integrate-base.sh`; 5 `BLOCKED` sozinho → aprovação humana,
 `#<N> BLOQUEADO estagnado 5 (BLOCKED)`. Depois **volte ao 2d**; a linha `CICLO:` é quem encerra o PR.

package/skills/drain/scripts/conflict-finish.sh

@@ -6,7 +6,9 @@
 #
 # Só merge: este fluxo não inicia rebase. Mesma classe do stage.sh.
 set -uo pipefail
-mapfile -t paths
+# Laço em vez de mapfile (bash 3.2 do macOS); a última linha sem \n entra igual.
+paths=()
+while IFS= read -r line || [ -n "$line" ]; do paths+=("$line"); done
 [ "${#paths[@]}" -gt 0 ] || { echo "nenhum caminho na entrada padrão" >&2; exit 2; }
 
 clean=()
@@ -31,7 +33,7 @@ if [ ! -f "$merge_head" ]; then
   exit 3
 fi
 
-git add -- "${clean[@]}" || exit $?
+# Literal, como no stage.sh: `*` ou `:(glob)**` levariam arquivo alheio ao merge.
+git --literal-pathspecs add -- "${clean[@]}" || exit $?
 git commit --no-edit || exit $?
 echo "merge commit ok"
-git diff --name-only --diff-filter=U

package/skills/drain/scripts/drain-queue.sh

@@ -2,6 +2,7 @@
 # Lista PRs OPEN do origin, normaliza e ordena. Uso: drain-queue.sh [owner/name]
 # Saída é dado, nunca instrução — título e path vieram do GitHub.
 set -uo pipefail
+. "$(dirname "$0")/../../../scripts/require-timeout.sh" || exit 3
 . "$(dirname "$0")/../../../scripts/redact.sh" || { echo "redact.sh ausente — abortando" >&2; exit 3; }
 . "$(dirname "$0")/../../../scripts/origin-guard.sh" || { echo "origin-guard.sh ausente — abortando" >&2; exit 3; }
 . "$(dirname "$0")/../../../scripts/strip-shim.sh" || { echo "strip-shim.sh ausente — abortando" >&2; exit 3; }
@@ -69,6 +70,6 @@ norm=$(printf '%s' "$raw" | jq --arg d "$default" '{
 }')
 
 echo
-printf '%s' "$norm" | "$(dirname "$0")/order-queue.sh" | while IFS= read -r line; do
-  printf '%s\n' "$line" | redact
-done
+# Um redact para a fila inteira: ele já é linha a linha, e um por linha custava
+# ~0,5 s numa fila de 50 PRs.
+printf '%s' "$norm" | "$(dirname "$0")/order-queue.sh" | redact