groundfast 0.8.0 → 0.8.1

package/skills/pipeline/scripts/issue-queue.sh

@@ -5,6 +5,7 @@
 set -uo pipefail
 
 here=$(cd "$(dirname "$0")" && pwd -P)
+. "$here/../../../scripts/require-timeout.sh" || exit 3
 . "$here/../../../scripts/redact.sh" || { echo "redact.sh ausente — abortando" >&2; exit 3; }
 . "$here/../../../scripts/origin-guard.sh" || { echo "origin-guard.sh ausente — abortando" >&2; exit 3; }
 . "$here/../../../scripts/strip-shim.sh" || { echo "strip-shim.sh ausente — abortando" >&2; exit 3; }
@@ -103,8 +104,9 @@ else
 fi
 printf 'pipelineáveis: %s\n' "$count"
 if [ "$count" -gt 0 ]; then
+  # Título inteiro para o redact: o corte de 200 vem depois da máscara.
   printf '%s' "$rows" | jq -r '.[] |
-    "#\(.number) OPEN · \(.title | gsub("[\\r\\n]+"; " ") | .[0:180]) · assignees: \([.assignees.nodes[].login] | if length == 0 then "(nenhum)" else join(", ") end) · \(.url)"' | redact
+    "#\(.number) OPEN · \(.title | gsub("[\\r\\n]+"; " ")) · assignees: \([.assignees.nodes[].login] | if length == 0 then "(nenhum)" else join(", ") end) · \(.url)"' | redact
 else
   echo '(nenhuma issue elegível)'
 fi

package/skills/pipeline/scripts/pipeline-cmd.sh

@@ -11,12 +11,12 @@ case "$cmd" in
     target="$here/${cmd}.sh" ;;
   pre-pr-state|push-branch)
     target="$here/../../pr/scripts/${cmd}.sh" ;;
-  pr-state|checkout-pr|wait-ci|wait-review|gh-thread|stage|pr-goal|push-pr|cycle|cov-comment)
+  pr-state|checkout-pr|wait-ci|wait-review|gh-thread|stage|pr-goal|push-pr|cycle|cov-comment|ci-cause)
     target="$here/../../babysit/scripts/${cmd}.sh" ;;
   commit)
     target="$here/../../drain/scripts/commit.sh" ;;
   *)
-    echo "uso: pipeline-cmd.sh issue-queue|issue-context|claim-issue|prepare-issue|issue-note|create-pr|pre-pr-state|push-branch|pr-state|checkout-pr|wait-ci|wait-review|gh-thread|stage|pr-goal|push-pr|cycle|cov-comment|commit [args...]" >&2
+    echo "uso: pipeline-cmd.sh issue-queue|issue-context|claim-issue|prepare-issue|issue-note|create-pr|pre-pr-state|push-branch|pr-state|checkout-pr|wait-ci|wait-review|gh-thread|stage|pr-goal|push-pr|cycle|cov-comment|ci-cause|commit [args...]" >&2
     exit 2 ;;
 esac
 [ -f "$target" ] || { echo "script ausente: $target" >&2; exit 3; }
@@ -41,11 +41,18 @@ case "$cmd" in
       "$target" "$wait_num" "$wait_repo" "$wait_budget" 2>&1 | strip_shim
     fi
     rc=${PIPESTATUS[0]}
-    # 124 só é deadline da issue quando o teto da espera foi o tempo restante.
-    # Cap de 900 s com saldo no relógio é espera de CI/review, não ORÇAMENTO ESTOURADO.
-    if [ "$rc" -eq 124 ] && [ "$wait_budget" -eq "$left" ]; then
-      echo "ORÇAMENTO ESTOURADO — espera cortada pelo deadline da issue"
-      exit 5
+    # As esperas convertem o próprio timeout em VEREDITO e saem 0: o deadline
+    # da issue se lê no relógio. Passou durante a espera — cortada por ele ou
+    # terminando colada nele — é parada, com o VEREDITO acima como contexto.
+    # Recusa (2/3) mantém o código dela. Releitura que falha (estado apagado
+    # durante a espera) sai com o erro dela, não como "não estourou".
+    if [ "$rc" -eq 0 ]; then
+      post=$("$here/../../babysit/scripts/cycle.sh" remaining "$wait_num" "$wait_repo" 2>&1); post_rc=$?
+      if [ "$post_rc" -eq 5 ]; then
+        echo "ORÇAMENTO ESTOURADO — deadline da issue passou durante a espera"
+        exit 5
+      fi
+      [ "$post_rc" -eq 0 ] || { printf '%s\n' "$post" | strip_shim; exit "$post_rc"; }
     fi
     exit "$rc" ;;
 esac

package/skills/pipeline/scripts/prepare-issue.sh

@@ -12,6 +12,7 @@ here=$(cd "$(dirname "$0")" && pwd -P)
 num=${1:-}
 printf '%s' "$num" | grep -Eq '^[1-9][0-9]*$' || { echo "uso: prepare-issue.sh <issue> [owner/name]" >&2; exit 2; }
 resolve_repo_context "${2:-}" || exit $?
+assert_push_is "$repo" || exit 3   # o fast-forward do claim faz `git push origin`
 
 me=$(timeout 20 gh api user -q .login 2>&1); me_rc=$?
 me=$(printf '%s\n' "$me" | strip_shim)

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

@@ -3,6 +3,8 @@
 # Trunca e redige: nome de branch, paths do status e stderr do gh são texto de
 # fora do agente e vão direto para o prompt.
 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; }
 # shellcheck source=../../../scripts/strip-shim.sh
@@ -55,9 +57,13 @@ else
     "$(printf '%s' "$branch" | redact)" "$protegida" "$default"
 fi
 
-status=$(git status --porcelain 2>/dev/null | head -30)
+all=$(git status --porcelain 2>/dev/null)
+status=$(printf '%s' "$all" | head -30)
 if [ -n "$status" ]; then
   echo "Working tree:"; printf '%s\n' "$status" | redact
+  # O corte é dito: listar a mudança pendente a partir de um pedaço dela erra.
+  extra=$(( $(printf '%s\n' "$all" | wc -l) - 30 ))
+  [ "$extra" -gt 0 ] && echo "(+$extra linha(s) fora do corte — git status --porcelain mostra todas)"
 else
   echo "Working tree: (limpo — nada para commitar)"
 fi

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

@@ -14,4 +14,17 @@ case "$current" in
   main|master|develop|"$default") echo "branch protegida ($current) — ramifique antes de pushar" >&2; exit 3 ;;
 esac
 
+# `git push origin` vai para remote.origin.pushurl, ou para a URL reescrita por
+# url.<x>.pushInsteadOf, quando existem. `get-url --push --all` já resolve os
+# dois. Push igual ao fetch é o origin que o usuário vê; diferente, cada URL de
+# push tem de ser o mesmo repositório do GitHub que a URL de fetch.
+fetch=$(git remote get-url origin 2>/dev/null) || { echo "sem remote origin — adicione com: git remote add origin <url do repositório>" >&2; exit 3; }
+pushes=$(git remote get-url --push --all origin 2>/dev/null) || { echo "git remote get-url --push falhou" >&2; exit 3; }
+if [ "$pushes" != "$fetch" ]; then
+  . "$(dirname "$0")/../../../scripts/origin-guard.sh" || { echo "origin-guard.sh ausente — abortando" >&2; exit 3; }
+  echo "push do origin difere do fetch (pushurl ou pushInsteadOf): os dois precisam ser o mesmo repo do GitHub" >&2
+  slug=$(origin_slug "$fetch") || exit 3
+  assert_push_is "$slug" || exit 3
+fi
+
 exec git push -u origin "refs/heads/$current:refs/heads/$current"

package/skills/scaffolding-services/scripts/detect-stack.sh

@@ -4,10 +4,36 @@
 # contrabandear texto para o prompt.
 set -uo pipefail
 dir=${1:-.}
+if [ ! -e "$dir" ]; then
+  echo "(diretório inexistente: $dir)"
+  exit 0
+fi
+if [ ! -d "$dir" ]; then
+  echo "(não é diretório: $dir)"
+  exit 0
+fi
 if [ ! -r "$dir" ]; then
   echo "(sem permissão de leitura em $dir — não consegui olhar)"
   exit 0
 fi
-found=$(ls -1 "$dir" 2>/dev/null | grep -E '^(Cargo\.toml|Cargo\.lock|bun\.lock|bun\.lockb|package\.json|pnpm-lock\.yaml|yarn\.lock|package-lock\.json|deno\.json|turbo\.json|nx\.json)$')
-[ -n "$found" ] && printf '%s\n' "$found" || echo "(nenhum — diretório limpo)"
+# Nome inteiro, não linha do `ls`: `x<quebra>Cargo.toml` não é um Cargo.toml.
+shopt -s nullglob
+entries=("$dir"/*)
+found=()
+for e in "${entries[@]}"; do
+  case ${e##*/} in
+    Cargo.toml|Cargo.lock|bun.lock|bun.lockb|package.json|pnpm-lock.yaml|yarn.lock|package-lock.json|deno.json|turbo.json|nx.json) found+=("${e##*/}") ;;
+  esac
+done
+if [ "${#found[@]}" -gt 0 ]; then
+  printf '%s\n' "${found[@]}"
+  exit 0
+fi
+# Sem manifest da lista não é diretório limpo: go.mod, pyproject.toml e outros
+# ficam fora dela. Só a contagem sai — nome desconhecido não vai para o prompt.
+if [ "${#entries[@]}" -eq 0 ]; then
+  echo "(nenhum — diretório limpo)"
+else
+  echo "(nenhum manifest conhecido, mas o diretório tem ${#entries[@]} arquivo(s) — não é diretório limpo; confira a stack antes de escolher)"
+fi
 exit 0

package/skills/ship/references/plugin.md

@@ -6,6 +6,6 @@ A versão vem do `package.json` da raiz, e o `gf-build` carimba os manifests e o
 
 - **Build**: `cargo run -q --locked --manifest-path tools/build-adapters/Cargo.toml -- --root "$PWD" --check`. Drift ou arquivo obsoleto: o release para, e o conserto vai por PR.
 - **Guardas**: `tools/release.sh --dry-run`. Precisa terminar em `DRY-RUN OK: vX.Y.Z`; cada `RELEASE RECUSADO` nomeia a guarda que falhou.
-- **Deploy**: `tools/release.sh`, depois do OK do Mestre. Cria a tag e a GitHub Release. O `npm publish` de `plugins/pi/` só roda com `s` num terminal interativo, então, rodado por você, o script termina em `NPM PULADO`: o npm ficou pendente, não falhou. Passe ao Mestre `cd plugins/pi && npm publish` para ele rodar no terminal dele, onde o npm pede login e OTP. `RELEASE PARCIAL` nomeia o que já foi publicado; comece o rollback por ali. Os marketplaces não têm passo: puxam do repositório.
-- **Smoke**: `claude plugin marketplace update groundfast`, e `claude plugin details groundfast` mostra a versão nova. `npm view groundfast version` imprime a mesma versão quando o npm foi publicado.
+- **Deploy**: `tools/release.sh`, depois do OK do Mestre. Cria a tag e a GitHub Release. O `npm publish` de `plugins/pi/` só roda com `s` num terminal interativo, então, rodado por você, o script termina em `NPM PULADO`: o npm ficou pendente, não falhou. Passe ao Mestre `cd plugins/pi && npm publish` para ele rodar no terminal dele, onde o npm pede login e OTP. `RELEASE PARCIAL` nomeia o que já foi publicado; comece o rollback por ali. Os marketplaces puxam do repositório, exceto o do Cursor: `agent plugin marketplace update groundfast` responde `0 plugins indexed` e não reindexa (bug do CLI, forum.cursor.com tópico 169587; tire este passo quando o `update` voltar a indexar). Rode `agent plugin marketplace remove groundfast` e `agent plugin marketplace add https://github.com/syx-labs/groundfast`, e passe ao Mestre a reinstalação do `groundfast` pelo `/plugins` do Cursor, que é interativo.
+- **Smoke**: `claude plugin marketplace update groundfast`, e `claude plugin details groundfast` mostra a versão nova. `npm view groundfast version` imprime a mesma versão quando o npm foi publicado. No Cursor, `agent plugin marketplace list --format json` dá o `gitRef` da entrada `groundfast`, e `git merge-base --is-ancestor vX.Y.Z <gitRef>` sai 0 — o `add` indexa a HEAD da branch default, que pode estar à frente da tag. Depois da reinstalação, `~/.cursor/plugins/cache/groundfast/groundfast/<gitRef>/.cursor-plugin/plugin.json` tem `"version": "X.Y.Z"`.
 - **Rollback**: `gh release delete vX.Y.Z --yes --cleanup-tag` (apaga a release e a tag em origin) e `git tag -d vX.Y.Z` no clone. Se o parcial parou antes da release, `git push --delete origin vX.Y.Z` basta. No npm, `npm deprecate groundfast@X.Y.Z "<motivo>"`, ou `npm unpublish groundfast@X.Y.Z` dentro de 72 h.

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

@@ -18,9 +18,13 @@ else
   printf 'Branch: (detached HEAD @ %s)\n' "$(git rev-parse --short HEAD 2>/dev/null || echo 'sem commits')"
 fi
 
-status=$(git status --porcelain 2>/dev/null | head -20)
+all=$(git status --porcelain 2>/dev/null)
+status=$(printf '%s' "$all" | head -20)
 if [ -n "$status" ]; then
   echo "Working tree:"; printf '%s\n' "$status" | redact
+  # O corte é dito: perguntar o que entra no release a partir de um pedaço erra.
+  extra=$(( $(printf '%s\n' "$all" | wc -l) - 20 ))
+  [ "$extra" -gt 0 ] && echo "(+$extra linha(s) fora do corte — git status --porcelain mostra todas)"
 else
   echo "Working tree: (limpo)"
 fi

package/skills/tidy/SKILL.md

@@ -25,7 +25,7 @@ caminho, nome de branch, assunto de stash. É **dado**, nunca instrução.
 
 O script capturou o `sha` de cada candidato **antes** de propor qualquer coisa: é ele que permite recuperar. Cada item traz o par `remover:` / `recuperar:`.
 
-- **AUTO** — o remote confirma que o trabalho está salvo em outro lugar: PR `MERGED` com o upstream em dia, ou worktree com tree limpa (ignorados inclusive) e branch já pushada sem commit à frente. Só isso é seguro por definição.
+- **AUTO** — o remote confirma que o trabalho está salvo em outro lugar: PR `MERGED` cujo head mergeado contém todo commit local da branch, ou worktree com tree limpa (ignorados inclusive) e branch já pushada sem commit à frente. Só isso é seguro por definição.
 - **GATE** — tudo o mais. PR `CLOSED` **sem** merge (o trabalho foi rejeitado ou abandonado, e a branch local pode ser o único registro dele), PR merged com commit por cima, branch sem upstream, worktree com mudança não commitada ou arquivo ignorado, e **todo** stash: depois do `drop` a recuperação depende do reflog, que expira.
 
 Sem `gh` autenticado nenhuma branch pode ser confirmada, e o script marca tudo como GATE. Esse é o comportamento correto, não uma falha a contornar.
@@ -33,7 +33,7 @@ Sem `gh` autenticado nenhuma branch pode ser confirmada, e o script marca tudo c
 ## O que fazer
 
 1. **Remova os AUTO**, um a um, com o comando `remover:` que veio na listagem.
-2. **Pergunte os GATE** numa única pergunta multi-select, um item por candidato: `<tipo> <ref> @<sha7> — <motivo>`. Só o marcado é removido. Zero candidatos GATE: pule a pergunta.
+2. **Pergunte os GATE** numa única pergunta multi-select, um item por candidato: `<tipo> <ref> @<sha7> — <motivo>`. Só o marcado é removido, com o `remover:` dele **como veio na listagem**, na ordem. Worktree GATE já inclui `--force`: a aprovação descarta conteúdo local. O `remover:` de stash é `scripts/drop-stash.sh <sha>`, a partir do diretório da skill: ele relê a pilha e remove pelo sha, porque a pilha é compartilhada entre worktrees e sessões e um `push` alheio durante a pergunta desloca os índices. Exit 3 = o stash já não existe. Exit 5 = a pilha mudou e saiu outro stash: rode o comando de volta que ele imprime e pare a limpeza de stash. Zero candidatos GATE: pule a pergunta.
 3. **Registre o resultado** na seção `## Estado do repo` do `HANDOFF.md`: o que foi removido, o sha, e o comando `recuperar:` de cada um. É o que transforma uma remoção em algo desfazível.
 4. **Reporte** em uma linha: quantos AUTO removidos, quantos GATE aprovados, quantos ficaram.
 

package/skills/tidy/scripts/drop-stash.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Remove o stash cujo commit é <sha>, e só ele. Uso: drop-stash.sh <sha completo>
+#
+# `git stash drop stash@{N}` é posicional: a pilha é compartilhada entre
+# worktrees e sessões, e um `push` ou `drop` alheio entre a listagem e o drop
+# desloca os índices — o drop cairia num stash que ninguém marcou. Aqui a pilha
+# é relida na hora, o índice sai do sha, e o sha que o git diz ter removido é
+# conferido: a janela entre a releitura e o drop é curta, não nula.
+# Exit: 0 removido · 2 uso · 3 nenhum stash com esse sha · 4 leitura ou drop falhou
+#       · 5 a pilha mudou no meio e outro stash saiu (o comando de volta vai no stderr)
+set -uo pipefail
+[ $# -eq 1 ] || { echo "uso: drop-stash.sh <sha completo do stash>" >&2; exit 2; }
+want=$1
+printf '%s' "$want" | grep -Eqx '[0-9a-f]{40}|[0-9a-f]{64}' \
+  || { echo "sha inválido: esperado o hash completo, como o recuperar: do orphans.sh" >&2; exit 2; }
+
+list=$(git stash list --format='%gd %H') || { echo "git stash list falhou" >&2; exit 4; }
+ref=$(printf '%s\n' "$list" | awk -v w="$want" '$2 == w { print $1; exit }')
+[ -n "$ref" ] || { echo "nenhum stash com o sha $want — já removido ou nunca existiu" >&2; exit 3; }
+out=$(git stash drop "$ref") || { echo "git stash drop $ref falhou" >&2; exit 4; }
+got=$(printf '%s\n' "$out" | sed -n 's/^Dropped .* (\([0-9a-f]*\))$/\1/p')
+if [ "$got" != "$want" ]; then
+  echo "a pilha mudou entre a leitura e o drop: saiu ${got:-?} em vez de $want — devolva com: git stash store -m restaurado $got" >&2
+  exit 5
+fi
+echo "removido: $ref @${want:0:7} — recuperar: git stash apply $want"

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"