groundfast 0.8.0 → 0.8.2

package/skills/tidy/scripts/orphans.sh

@@ -12,6 +12,8 @@ set -uo pipefail
 
 # shellcheck source=../../../scripts/redact.sh
 . "$(dirname "$0")/../../../scripts/redact.sh"
+# shellcheck source=../../../scripts/strip-shim.sh
+. "$(dirname "$0")/../../../scripts/strip-shim.sh"
 
 git rev-parse --is-inside-work-tree >/dev/null 2>&1 || { echo "(fora de um repositório git)"; exit 0; }
 
@@ -36,19 +38,25 @@ git worktree list --porcelain | sed -n 's/^worktree //p' | while IFS= read -r wt
   ahead=$(git -C "$wt" rev-list --count '@{upstream}..HEAD' 2>/dev/null || echo '?')
   if [ -z "$clean" ] && [ -n "$track" ] && [ "$ahead" = "0" ]; then
     cls=AUTO; why="tree limpa e ${br:-HEAD} já pushada em $track"
+    rm='git worktree remove'
   else
     cls=GATE
     why="${clean:+conteúdo local não salvo (inclui ignorados)}${clean:+; }${track:-sem upstream}${track:+, $ahead commit(s) não pushado(s)}"
+    # GATE aprovado descarta conteúdo local: sem --force o git recusa (rc 128).
+    rm='git worktree remove --force'
   fi
   printf '%s %s @%s — %s\n' "$cls" "$wt" "$sha" "$why" | redact
-  printf '     remover: git worktree remove %q\n' "$wt" | redact
+  printf '     remover: %s %q\n' "$rm" "$wt" | redact
   printf '     recuperar: git worktree add %q %q\n' "$wt" "${br:-$sha}" | redact
 done
 echo
 
 echo "## Branches locais"
-git for-each-ref --format='%(refname:short)|%(objectname:short)|%(upstream:short)|%(upstream:track)' refs/heads |
-while IFS='|' read -r br sha up track; do
+gh_err=$(mktemp); trap 'rm -f "$gh_err"' EXIT
+# Tab separa os campos: `|` é legal em nome de branch (`a|b` viraria a branch
+# `a`, e o `remover:` apontaria para outra), tab não é. Campo vazio só no fim.
+git for-each-ref --format='%(refname:short)%09%(objectname:short)%09%(upstream:short)%09%(upstream:track)' refs/heads |
+while IFS=$'\t' read -r br sha up track; do
   [ "$br" = "$head_branch" ] && continue
   git worktree list --porcelain | grep -qxF -- "branch refs/heads/$br" && continue
 
@@ -56,20 +64,31 @@ while IFS='|' read -r br sha up track; do
   if [ -n "$up" ]; then
     why="upstream $up${track:+ $track}"
     if [ "$gh_ok" -eq 1 ]; then
-      st=$(gh pr view "$br" --json state --jq .state 2>/dev/null)
+      pr=$(gh pr view "$br" --json state,headRefOid,number --jq '"\(.state) \(.headRefOid) \(.number)"' 2>"$gh_err" | strip_shim)
+      read -r st merged prnum <<<"$pr"
       case "$st" in
         MERGED)
-          # Merged só basta se não houver commit local à frente do upstream:
-          # `branch -D` sobre uma branch ahead deixa esses commits só no reflog.
-          case "$track" in
-            *ahead*) why="PR MERGED, mas $track — há commit local não pushado" ;;
-            *)       cls=AUTO; why="PR MERGED no remote e nada à frente de $up" ;;
-          esac
+          # Merged só basta se todo commit local está no head que o PR mergeou:
+          # `branch -D` deixa o resto só no reflog. O track não serve de prova —
+          # com --delete-branch o upstream fica [gone] e o ahead some da conta.
+          if ! [[ $merged =~ ^[0-9a-f]{40}$ ]] || ! git cat-file -e "$merged^{commit}" 2>/dev/null; then
+            why="PR MERGED, mas o head mergeado não está neste clone — nada confirma o local"
+            [[ $prnum =~ ^[1-9][0-9]*$ ]] && why="$why; confirme com: git fetch origin refs/pull/$prnum/head"
+          elif git merge-base --is-ancestor "refs/heads/$br" "$merged"; then
+            cls=AUTO; why="PR MERGED e todo commit local está no head mergeado (${merged:0:7})"
+          else
+            why="PR MERGED, mas há commit local fora do head mergeado${track:+ ($track)}"
+          fi
           ;;
         # CLOSED é PR fechado SEM merge: trabalho rejeitado ou abandonado, cujo
         # único registro pode ser esta branch. O remote não confirma nada.
         CLOSED) why="PR CLOSED sem merge — o trabalho não foi para lugar nenhum" ;;
-        "")     why="$why; sem PR encontrado" ;;
+        # Falha de rede ou de API não é "sem PR": o motivo diz qual das duas foi.
+        # O shim do mise pode pôr o banner no stderr também; -a e LC_ALL=C: byte
+        # fora de UTF-8 faria o grep ver binário e apagar o motivo.
+        "") errs=$(strip_shim <"$gh_err")
+            if printf '%s\n' "$errs" | grep -q '^no pull requests found'; then why="$why; sem PR encontrado"
+            else why="$why; gh falhou ao consultar o PR: $(printf '%s\n' "${errs:-sem stderr}" | LC_ALL=C grep -a -m1 . | REDACT_MAXCOL=120 redact)"; fi ;;
         *)      why="$why; PR $st — ainda aberto" ;;
       esac
     fi
@@ -82,9 +101,11 @@ echo
 
 echo "## Stash"
 # Stash nunca é AUTO: depois do drop, a recuperação depende do reflog, que expira.
-git stash list --format='%gd|%H|%cr|%gs' | while IFS='|' read -r ref sha age subj; do
+# O remover: é por sha (drop-stash.sh relê a pilha), então a ordem não importa.
+git stash list --format='%gd|%H|%cr|%gs' |
+while IFS='|' read -r ref sha age subj; do
   printf 'GATE %s @%s — %s — %s\n' "$ref" "${sha:0:7}" "$age" "$subj" | redact
-  printf '     remover: git stash drop %s\n' "$ref" | redact
+  printf '     remover: scripts/drop-stash.sh %s\n' "$sha" | redact
   printf '     recuperar: git stash apply %s\n' "$sha" | redact
 done
 exit 0

package/skills/wrap/scripts/repo-state.sh

@@ -56,7 +56,11 @@ done
 
 echo
 echo "## Working tree"
-git status --porcelain 2>/dev/null | head -40 | body "(limpo)"
+all=$(git status --porcelain 2>/dev/null)
+printf '%s' "$all" | head -40 | body "(limpo)"
+# O corte é dito: o passo 2 separa as mudanças desta sessão das alheias por aqui.
+extra=$(( $(printf '%s\n' "$all" | wc -l) - 40 ))
+[ "$extra" -gt 0 ] && echo "(+$extra linha(s) fora do corte — git status --porcelain mostra todas)"
 
 echo
 echo "## Diff vs HEAD (linhas por arquivo)"
@@ -106,5 +110,5 @@ fi
 
 echo
 echo "## Plan files da sessão (7 dias)"
-find "$HOME/.claude/plans" -maxdepth 1 -name '*.md' -mtime -7 2>/dev/null | head -10 | body "(nenhum)"
+find "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/plans" -maxdepth 1 -name '*.md' -mtime -7 2>/dev/null | head -10 | body "(nenhum)"
 exit 0

package/skills/wrap/scripts/session-cover.sh

@@ -32,15 +32,14 @@ if [ -z "$abs" ]; then
       *)
         host=${host:-claude}
         base=${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd -P)}
-        for slug in \
-          "$(printf '%s' "$base" | sed 's#^/##; s#/#-#g')" \
-          "$(printf '%s' "$base" | sed 's#^/##; s#[/._]#-#g')"
-        do
-          cand="$HOME/.claude/projects/-$slug/$sid.jsonl"
-          [ -f "$cand" ] || continue
-          abs=$cand
-          break
-        done
+        # O Claude Code grava em ${CLAUDE_CONFIG_DIR:-~/.claude}/projects/<slug>,
+        # com cada unidade UTF-16 fora de [a-zA-Z0-9] trocada por `-`. Acima de
+        # 200 caracteres ele soma um hash ao slug, e a busca não acha: sai
+        # not_found. O sed reproduz a regra para texto BMP em locale UTF-8; fora
+        # do BMP (emoji) ou em C/POSIX a contagem de `-` diverge e sai not_found.
+        slug=$(printf '%s' "$base" | sed 's/[^0-9ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]/-/g')
+        cand="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/projects/$slug/$sid.jsonl"
+        [ -f "$cand" ] && abs=$cand
         if [ -z "$abs" ]; then
           echo "coverage=unavailable $empty reasons=session_file_not_found"
           exit 0

package/skills/wrap/scripts/tasks.sh

@@ -58,12 +58,18 @@ case "$cmd" in
     [ -s "$tmp" ] || die "stdin vazio — nada para apender"
 
     # Valida TODAS as linhas antes de escrever uma: um append parcial deixaria
-    # o ledger num estado que a próxima sessão não sabe interpretar.
-    line=0
-    while IFS= read -r l; do
+    # o ledger num estado que a próxima sessão não sabe interpretar. O `|| [ -n ]`
+    # entrega a última linha sem `\n`, que o `jq -c` abaixo apenda do mesmo jeito.
+    line=0; added=0
+    while IFS= read -r l || [ -n "$l" ]; do
       line=$((line + 1))
       [ -n "${l//[[:space:]]/}" ] || continue
+      added=$((added + 1))   # linha em branco não vira evento no `jq -c` abaixo
       printf '%s' "$l" | jq -e . >/dev/null 2>&1 || die "linha $line não é JSON válido"
+      # Um objeto por linha: com dois valores, o `jq -c` abaixo gravaria os dois
+      # e só o primeiro passaria pelos campos.
+      printf '%s' "$l" | jq -se 'length == 1 and (.[0] | type == "object")' >/dev/null 2>&1 \
+        || die "linha $line: mais de um valor JSON, ou valor que não é objeto"
       id=$(printf '%s' "$l" | jq -r '.id // empty')
       st=$(printf '%s' "$l" | jq -r '.state // empty')
       ti=$(printf '%s' "$l" | jq -r '.title // empty')
@@ -76,7 +82,7 @@ case "$cmd" in
 
     # Compacta para uma linha por evento — o formato do ledger é JSONL.
     jq -c . <"$tmp" >>"$file" || die "append falhou"
-    echo "ok: $line linha(s) apendada(s) em $file"
+    echo "ok: $added linha(s) apendada(s) em $file"
     ;;
 
   *) die "subcomando desconhecido: $cmd" ;;

package/skills/wrap/scripts/verify.sh

@@ -6,7 +6,7 @@
 set -uo pipefail
 
 root=${1:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}
-mem_root="$HOME/.claude/projects"
+mem_root="${CLAUDE_CONFIG_DIR:-$HOME/.claude}/projects"
 here=$(cd "$(dirname "$0")" && pwd -P)
 fails=0
 
@@ -160,9 +160,24 @@ fi
 # slug não é derivável daqui: procuramos o caminho do projeto em todos eles.
 # No CI o runner é efêmero e não tem memória nativa, e o check mede o ritual
 # local. Variável própria, não `CI`: uma sessão local com `CI` exportado não pula.
+# Caminho inteiro, não prefixo: `/x/repo-site` não é ponteiro de `/x/repo`. O
+# caractere depois do caminho não pode continuar o nome (`/` é subcaminho e vale);
+# `.` só continua quando vem seguido de nome (`/x/repo.bak`), não no fim da frase.
+mentions_root() {
+  local f
+  while IFS= read -r f; do
+    ROOT=$root awk '{ s = $0; r = ENVIRON["ROOT"]
+      while ((i = index(s, r)) > 0) {
+        c = substr(s, i + length(r), 1); n = substr(s, i + length(r) + 1, 1)
+        if (c !~ /[A-Za-z0-9_-]/ && !(c == "." && n ~ /[A-Za-z0-9_-]/)) { found = 1; exit }
+        s = substr(s, i + 1)
+      } } END { exit !found }' "$f" && return 0
+  done < <(grep -rlF -- "$root" "$mem_root"/*/memory 2>/dev/null)
+  return 1
+}
 if [ "${GROUNDFAST_CI-}" = 1 ]; then
   skip "memória nativa não se aplica no CI (GROUNDFAST_CI=1)"
-elif [ -d "$mem_root" ] && grep -rqlF -- "$root" "$mem_root"/*/memory 2>/dev/null; then
+elif [ -d "$mem_root" ] && mentions_root; then
   pass "memória nativa tem ponteiro para $root"
 else
   fail "nenhum arquivo em $mem_root/*/memory menciona $root"