groundfast 0.7.7

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

@@ -0,0 +1,344 @@
+#!/usr/bin/env bash
+# Metadados de cobertura da sessão explícita. Sem corpo de mensagem.
+set -euo pipefail
+
+abs=${1:-}
+host=${2:-}
+leaf=${3:-}
+
+empty="path_len=0 human=0 assistant=0 tool=0 other=0 compaction=false branch_summary=false leaf=- session=-"
+
+if [ -z "$abs" ]; then
+  # A env do Pi não decide por um host que o chamador já declarou: adotar o
+  # arquivo dele com o parser do Claude só produz `session_id_mismatch`.
+  if [ -n "${PI_SESSION_FILE:-}" ] && { [ -z "$host" ] || [ "$host" = pi ]; }; then
+    abs=$PI_SESSION_FILE
+    host=${host:-pi}
+  elif [ "$host" = pi ]; then
+    # Simétrico ao guard acima: host `pi` declarado e sem arquivo do Pi não
+    # herda o transcript do Claude que a env aponta. O `host` continuaria `pi`,
+    # e o parser leria `id`/`parentId` num arquivo que traz `uuid`/`parentUuid`
+    # — cobertura errada com cara de medida, em vez de ausência declarada.
+    echo "coverage=unavailable $empty reasons=pi_session_file_unset"
+    exit 0
+  else
+    sid=${CLAUDE_CODE_SESSION_ID:-${CLAUDE_SESSION_ID:-}}
+    case ${sid:-} in
+      '') ;;
+      *[!A-Za-z0-9-]*)
+        echo "coverage=unavailable $empty reasons=invalid_session_id"
+        exit 0
+        ;;
+      *)
+        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
+        if [ -z "$abs" ]; then
+          echo "coverage=unavailable $empty reasons=session_file_not_found"
+          exit 0
+        fi
+        ;;
+    esac
+  fi
+fi
+
+if [ -z "$abs" ]; then
+  echo "coverage=unavailable $empty reasons=no_explicit_session"
+  exit 0
+fi
+
+# `-e` e não `-f`: um FIFO ou diretório existe, e chamá-lo de ausente mandaria
+# procurar o arquivo errado. Quem o recusa com o motivo certo é o parser, que
+# valida o descritor que abriu e devolve `not_regular_file`.
+if [ ! -e "$abs" ]; then
+  echo "coverage=unavailable $empty reasons=explicit_path_missing"
+  exit 0
+fi
+
+case ${host:-} in
+  pi|claude) ;;
+  '')
+    echo "coverage=unavailable $empty reasons=host_unspecified"
+    exit 0
+    ;;
+  *)
+    echo "coverage=unavailable $empty reasons=unsupported_host"
+    exit 0
+    ;;
+esac
+
+if ! command -v python3 >/dev/null 2>&1; then
+  echo "coverage=unavailable $empty reasons=no_python3"
+  exit 0
+fi
+
+# O stderr fica fora: o passo 1 do wrap lê esta saída como uma linha de dado,
+# e um traceback ao lado dela é ruído que o modelo tenta interpretar. Jogar a
+# evidência fora, porém, deixaria `python3_failed` cobrindo interpretador
+# quebrado, stdlib faltando e bug introduzido neste parser com o mesmo token —
+# e nenhum deles com uma linha de causa em lugar nenhum.
+# Duplicar o fd, não reabrir `/dev/stderr`: quando o stderr do chamador é um
+# arquivo de log, `2>/dev/stderr` o reabre com O_TRUNC e come o que já estava
+# escrito — some justamente a evidência que o knob existe para dar.
+exec 4>&2
+[ -n "${GROUNDFAST_WRAP_DEBUG:-}" ] || exec 4>/dev/null
+line=$(python3 - "$abs" "$host" "$leaf" 2>&4 <<'PY'
+import errno, json, os, stat, sys
+
+path, host, leaf_arg = sys.argv[1], sys.argv[2], sys.argv[3]
+
+
+def tok(value):
+    """Token que veio do transcript. O transcript é dado, não formato: um id
+    com espaço ou quebra de linha injetaria chaves numa linha que o modelo lê
+    como verdade, inclusive um segundo `coverage=`."""
+    text = "" if value is None else str(value)
+    if not text:
+        return "-"
+    ok = all(c.isalnum() or c in "._:-" for c in text)
+    return text if ok and len(text) <= 80 else "invalid"
+
+
+def out(coverage, reasons, path_len=0, human=0, assistant=0, tool=0, other=0,
+        compaction=False, branch_summary=False, leaf="-", session="-"):
+    if not isinstance(reasons, str):
+        reasons = ",".join(reasons)
+    print(
+        "coverage={} path_len={} human={} assistant={} tool={} other={} "
+        "compaction={} branch_summary={} leaf={} session={} reasons={}".format(
+            coverage, path_len, human, assistant, tool, other,
+            str(compaction).lower(), str(branch_summary).lower(),
+            tok(leaf), tok(session), reasons))
+
+
+def bail(reason, **k):
+    out("unavailable", reason, **k)
+    raise SystemExit
+
+
+# Um descritor só, aberto antes de qualquer teste e validado por `fstat`: com
+# `stat` seguido de `open` quem escreve no diretório troca a entrada entre os
+# dois, e o que passou nos testes não é o que foi lido. `O_NOFOLLOW` recusa o
+# link no próprio open (ELOOP), e `O_NONBLOCK` impede que um FIFO no lugar do
+# transcript pendure o helper — o `fstat` abaixo o recusa como não-regular.
+try:
+    fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+except OSError as e:
+    # O motivo do link é o mesmo, o errno não: Linux devolve ELOOP e os BSDs
+    # (macOS entre eles) devolvem EMLINK. Só o Linux aqui deixaria o Mac
+    # chamar link de `unreadable` e mandar procurar permissão ou disco.
+    link = e.errno in (errno.ELOOP, errno.EMLINK)
+    bail("symlink_not_followed" if link else "unreadable")
+
+try:
+    st = os.fstat(fd)
+except OSError:
+    bail("unreadable")
+if not stat.S_ISREG(st.st_mode):
+    bail("not_regular_file")
+if st.st_mode & 0o002:
+    bail("world_writable")
+if st.st_size > 32 * 1024 * 1024:
+    bail("oversize_bytes")
+
+by = {}
+sessions = set()
+session = None
+last = None
+last_prompt_leaf = None
+n = 0
+duplicate_ids = False
+bad_line = False
+
+# O mesmo descritor validado acima: reabrir pelo caminho reabriria a janela.
+try:
+    fh = os.fdopen(fd, encoding="utf-8", errors="replace")
+except OSError:
+    bail("unreadable")
+
+with fh:
+    for line in fh:
+        n += 1
+        if n > 100_000:
+            bail("oversize_lines")
+        line = line.strip()
+        if not line:
+            continue
+        if bad_line:
+            # Linha inválida seguida de outra linha: não é cauda em escrita.
+            bail("malformed_json")
+        try:
+            e = json.loads(line)
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            bad_line = True
+            continue
+        if not isinstance(e, dict):
+            # Linha válida como JSON e inútil como registro (`"texto"`, `[1]`):
+            # é cauda estranha, não motivo para perder o arquivo inteiro.
+            bad_line = True
+            continue
+        if host == "pi":
+            if e.get("type") == "session" and session is None:
+                session = e.get("id")
+                continue
+            i = e.get("id")
+            if not i:
+                continue
+            role = (e.get("message") or {}).get("role")
+            tool_name = (e.get("message") or {}).get("toolName")
+            kind = "other"
+            t = e.get("type")
+            if t == "compaction":
+                kind = "compaction"
+            elif t == "branch_summary":
+                kind = "branch"
+            elif t == "message":
+                if role == "user" or (role == "toolResult" and tool_name == "ask_user"):
+                    kind = "human"
+                elif role == "assistant":
+                    kind = "assistant"
+                elif role in ("toolResult", "bashExecution"):
+                    kind = "tool"
+            parent = e.get("parentId")
+        else:
+            t = e.get("type")
+            if t == "last-prompt":
+                last_prompt_leaf = e.get("leafUuid")
+                if e.get("sessionId"):
+                    sessions.add(e["sessionId"])
+                continue
+            # Antes do guard de uuid: uma linha sem uuid (summary, snapshot)
+            # também carrega sessionId e também precisa bater com o arquivo.
+            if e.get("sessionId"):
+                sessions.add(e["sessionId"])
+            i = e.get("uuid")
+            if not i:
+                continue
+            kind = {"user": "human", "assistant": "assistant",
+                    "attachment": "tool", "progress": "tool"}.get(t, "other")
+            parent = e.get("parentUuid")
+            if t == "system" and e.get("subtype") == "compact_boundary":
+                # O boundary zera `parentUuid` e guarda o elo em
+                # `logicalParentUuid`: sem segui-lo, o `path_len` para no
+                # boundary e perde o histórico anterior. Só vale elo para
+                # trás: às vezes ele aponta uma entrada gravada depois, que
+                # desce do próprio boundary, e segui-lo acusaria `cycle`.
+                kind = "compaction"
+                logical = e.get("logicalParentUuid")
+                if isinstance(logical, str) and logical in by:
+                    parent = parent or logical
+        if i in by:
+            duplicate_ids = True
+        by[i] = {"parent": parent, "kind": kind}
+        last = i
+
+leaf = leaf_arg
+leaf_inferred = False
+if not leaf:
+    # No Claude a folha é declarada pelo host em `last-prompt`; no Pi ela é
+    # deduzida da ordem do arquivo, que não é ciente de ramo.
+    if host == "pi":
+        leaf = last
+        leaf_inferred = bool(leaf)
+    else:
+        leaf = last_prompt_leaf
+
+stem = os.path.splitext(os.path.basename(path))[0]
+# Todo sessionId do arquivo precisa bater com o nome dele: dois transcripts
+# concatenados passariam se só o primeiro fosse conferido.
+if host == "claude":
+    session = sorted(sessions)[0] if sessions else None
+    if not sessions:
+        # Arquivo vazio, ou formato do host mudou e o campo saiu. Dizer
+        # "divergente" mandaria procurar adulteração onde houve drift.
+        bail("no_session_id_in_file", leaf=leaf)
+    if len(sessions) > 1 or stem not in sessions:
+        bail("session_id_mismatch", leaf=leaf, session=session)
+if not leaf:
+    bail("no_explicit_leaf", session=session)
+if leaf not in by:
+    bail("leaf_not_in_file", leaf=leaf, session=session)
+
+seen = set()
+cur = leaf
+path_len = human = assistant = tool = other = 0
+compaction = branch = False
+coverage = "complete"
+reasons = []
+
+while cur:
+    if cur in seen:
+        coverage = "partial"
+        reasons.append("cycle")
+        break
+    seen.add(cur)
+    e = by.get(cur)
+    if e is None:
+        coverage = "partial"
+        reasons.append("missing_parent")
+        break
+    path_len += 1
+    kind = e["kind"]
+    if kind == "human":
+        human += 1
+    elif kind == "assistant":
+        assistant += 1
+    elif kind == "tool":
+        tool += 1
+    elif kind == "compaction":
+        compaction = True
+    elif kind == "branch":
+        branch = True
+    else:
+        other += 1
+    cur = e["parent"]
+
+if bad_line:
+    coverage = "partial"
+    reasons.append("truncated_tail")
+if duplicate_ids:
+    coverage = "partial"
+    reasons.append("duplicate_ids")
+if compaction:
+    coverage = "partial"
+    reasons.append("compaction_present_history_still_in_file")
+if branch:
+    reasons.append("abandoned_branch_summary_on_path")
+if leaf_inferred:
+    reasons.append("leaf_inferred_from_file_order")
+    if branch:
+        coverage = "partial"
+    if path_len < len(by):
+        # A folha veio da ordem do arquivo, que não é ciente de ramo: o que
+        # ficou fora da cadeia é história real que ninguém mediu.
+        coverage = "partial"
+        reasons.append("entries_outside_path")
+
+out(coverage, reasons, path_len=path_len, human=human, assistant=assistant,
+    tool=tool, other=other, compaction=compaction, branch_summary=branch,
+    leaf=leaf, session=session)
+PY
+) || line=
+if [ -z "$line" ]; then
+  echo "coverage=unavailable $empty reasons=python3_failed"
+  exit 0
+fi
+# Um python3 que sai 0 falando outra coisa (wrapper, sitecustomize, aviso de
+# módulo) não é medição: sem a forma do contrato, degrade como qualquer falha.
+line=${line%%$'\n'*}
+case $line in
+  'coverage=complete '*|'coverage=partial '*|'coverage=unavailable '*) ;;
+  *)
+    echo "coverage=unavailable $empty reasons=python3_bad_output"
+    exit 0
+    ;;
+esac
+printf '%s\n' "$line"

package/skills/wrap/scripts/tasks.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# Ledger de tasks append-only, last-wins por id.
+#
+# O arquivo é um evento por linha: mudar o estado de uma task é acrescentar uma
+# linha nova com o mesmo id, nunca editar a antiga. A view corrente é a última
+# linha de cada id. Tudo o que precisa de jq mora aqui: manter essas queries no
+# corpo da skill custa contexto em toda invocação e erra sozinho.
+#
+# Uso:
+#   tasks.sh next-id [arquivo]      próximo id livre (T<n>)
+#   tasks.sh current [arquivo]      view corrente, uma linha JSON por task
+#   tasks.sh open    [arquivo]      só as abertas, já formatadas para o handoff
+#   tasks.sh append  [arquivo]      lê linhas JSON do stdin, valida e apenda
+set -uo pipefail
+
+STATES='open doing blocked done dropped'
+cmd=${1:-}
+file=${2:-tasks.jsonl}
+
+die() { echo "erro: $*" >&2; exit 1; }
+
+command -v jq >/dev/null 2>&1 || die "jq não encontrado no PATH"
+[ -n "$cmd" ] || die "uso: tasks.sh {next-id|current|open|append} [arquivo]"
+
+# next-id e append funcionam com o arquivo ainda inexistente: o primeiro wrap
+# de um repo cria o ledger.
+case "$cmd" in
+  next-id|append) [ -e "$file" ] || : >"$file" ;;
+  *)              [ -e "$file" ] || die "$file não existe" ;;
+esac
+
+view() { jq -s 'map(select(type == "object" and has("id"))) | group_by(.id) | map(last)' "$file"; }
+
+case "$cmd" in
+  next-id)
+    # Sem o guarda, um ledger com linha corrompida faria o jq falhar em stderr,
+    # $n vir vazio e $((n + 1)) devolver T1 — a task nova sobrescreveria a T1
+    # existente, porque a view é last-wins por id.
+    n=$(jq -rs '[ .[] | .id? | select(type == "string") | ltrimstr("T") | tonumber? ] | max // 0' "$file") \
+      || die "$file não é JSONL válido — rode: jq -c . $file"
+    [[ $n =~ ^[0-9]+$ ]] || die "não consegui derivar o maior id de $file (li '$n')"
+    echo "T$((n + 1))"
+    ;;
+
+  current)
+    view | jq -c '.[]'
+    ;;
+
+  open)
+    view | jq -r '.[] | select(.state != "done" and .state != "dropped")
+                      | "- \(.id) [\(.state)] \(.title)"'
+    ;;
+
+  append)
+    tmp=$(mktemp) || die "mktemp falhou"
+    trap 'rm -f "$tmp"' EXIT
+    cat >"$tmp"
+    [ -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
+      line=$((line + 1))
+      [ -n "${l//[[:space:]]/}" ] || continue
+      printf '%s' "$l" | jq -e . >/dev/null 2>&1 || die "linha $line não é JSON válido"
+      id=$(printf '%s' "$l" | jq -r '.id // empty')
+      st=$(printf '%s' "$l" | jq -r '.state // empty')
+      ti=$(printf '%s' "$l" | jq -r '.title // empty')
+      up=$(printf '%s' "$l" | jq -r '.updated // empty')
+      [[ $id =~ ^T[0-9]+$ ]]            || die "linha $line: id '$id' fora do formato T<n>"
+      [ -n "$ti" ]                      || die "linha $line: title vazio"
+      [[ $up =~ ^[0-9]{4}(-[0-9]{2}){2}$ ]] || die "linha $line: updated '$up' fora de YYYY-MM-DD"
+      case " $STATES " in *" $st "*) ;; *) die "linha $line: state '$st' fora de: $STATES" ;; esac
+    done <"$tmp"
+
+    # 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"
+    ;;
+
+  *) die "subcomando desconhecido: $cmd" ;;
+esac

package/skills/wrap/scripts/verify.sh

@@ -0,0 +1,204 @@
+#!/usr/bin/env bash
+# Verifica o que o wrap acabou de escrever. Evidência, não vibe.
+#
+# Uso: verify.sh [worktree-principal]
+# Imprime uma linha PASS/FAIL/SKIP por check e sai 1 se houver qualquer FAIL.
+set -uo pipefail
+
+root=${1:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}
+mem_root="$HOME/.claude/projects"
+here=$(cd "$(dirname "$0")" && pwd -P)
+fails=0
+
+pass() { echo "PASS  $*"; }
+fail() { echo "FAIL  $*"; fails=$((fails + 1)); }
+skip() { echo "SKIP  $*"; }
+
+# A regra do arquivo de instruções vive num lugar só — learn-file.sh — e o
+# repo-state.sh nomeia o alvo pela mesma função. Os checks 4, 4b e 4c usam os
+# predicados dele; sem o script, ou com CLAUDE.md/AGENTS.md ilegível, eles não
+# têm como decidir e dizem isso em vez de fabricar um SKIP. O 4b só precisa do
+# script (conta bullets no que o git guarda), então sobrevive ao arquivo ilegível.
+rule=ausente
+# shellcheck source=./learn-file.sh
+if [ -f "$here/learn-file.sh" ] && [ -r "$here/learn-file.sh" ] && . "$here/learn-file.sh"; then
+  if bad=$(learn_unreadable "$root"); then
+    rule=ilegivel
+    fail "$bad existe em $root mas não é arquivo regular legível — checks 4 e 4c não têm como decidir"
+  else
+    rule=ok
+  fi
+else
+  fail "learn-file.sh ausente em $here — checks 4, 4b e 4c não rodam (cópia instalada sem os scripts novos?)"
+fi
+
+# 1 — os três arquivos da tríade existem onde deviam
+missing=
+for f in HANDOFF.md tasks.jsonl memory.md; do
+  [ -f "$root/$f" ] || missing="$missing $f"
+done
+[ -z "$missing" ] && pass "tríade presente em $root" || fail "ausente em $root:$missing"
+
+# 2 — o ledger é JSONL válido linha a linha
+if [ -f "$root/tasks.jsonl" ]; then
+  if jq -c . "$root/tasks.jsonl" >/dev/null 2>&1; then
+    pass "tasks.jsonl é JSONL válido ($(wc -l <"$root/tasks.jsonl" | tr -d ' ') eventos)"
+  else
+    fail "tasks.jsonl tem linha inválida — rode: jq -c . $root/tasks.jsonl"
+  fi
+else
+  fail "tasks.jsonl não existe"
+fi
+
+# 2b — memory.md é visão corrente: exatamente as três seções, nesta ordem, sem
+# bloco datado apendado (o formato antigo virava 130 linhas lidas em toda sessão).
+if [ -f "$root/memory.md" ]; then
+  hdrs=$(grep '^## ' "$root/memory.md")
+  expected=$'## Decisões negativas — NÃO reverter sem evidência nova\n## Fonte de verdade\n## Processo que funcionou'
+  undated=$(grep -nE '^- ' "$root/memory.md" | grep -vE '\([^()]*[0-9]{4}-[0-9]{2}-[0-9]{2}\)$' | head -3 | cut -d: -f1 | tr '\n' ' ')
+  if [ "$hdrs" != "$expected" ]; then
+    fail "memory.md fora do formato (3 seções fixas, sem bloco datado) — veja: grep '^## ' $root/memory.md"
+  elif [ -n "$undated" ]; then
+    fail "memory.md: bullet sem (YYYY-MM-DD) no fim — linhas $undated"
+  else
+    pass "memory.md no formato de visão corrente (3 seções fixas, bullets datados)"
+  fi
+fi
+
+# 3 — a última seção do handoff é a próxima ação, e ela tem conteúdo
+if [ -f "$root/HANDOFF.md" ]; then
+  last=$(grep -n '^## ' "$root/HANDOFF.md" | tail -1)
+  if printf '%s' "$last" | grep -q 'Próxima ação física'; then
+    n=${last%%:*}
+    body=$(tail -n "+$((n + 1))" "$root/HANDOFF.md" | tr -d '[:space:]')
+    [ -n "$body" ] && pass "HANDOFF.md termina em '## Próxima ação física' preenchida" \
+                   || fail "'## Próxima ação física' está vazia"
+  else
+    fail "última seção do HANDOFF.md não é '## Próxima ação física'"
+  fi
+else
+  fail "HANDOFF.md não existe"
+fi
+
+# 4 — teto de 12 bullets por seção de aprendizado. Contamos nos dois arquivos
+# (quem julga onde a seção deve viver é o 4c), fora de code block, como o
+# learn-file.sh.
+if [ "$rule" != ok ]; then
+  skip "check 4 não avaliado (ver FAIL acima)"
+elif [ -f "$root/CLAUDE.md" ] || [ -f "$root/AGENTS.md" ]; then
+  over=
+  achou=
+  for lf in CLAUDE.md AGENTS.md; do
+    [ -f "$root/$lf" ] || continue
+    for sec in 'Learned User Preferences' 'Learned Workspace Facts'; do
+      unfenced "$root/$lf" | grep -E "^## $sec[[:space:]]*\$" >/dev/null || continue
+      achou=1
+      c=$(unfenced "$root/$lf" | awk -v h="^## $sec[[:space:]]*\$" '$0 ~ h {f=1; next} /^## /{f=0} f && /^- /{n++} END{print n+0}')
+      [ "$c" -gt 12 ] && over="$over $lf:$sec=$c"
+    done
+  done
+  if [ -z "$achou" ]; then
+    skip "nenhuma seção de aprendizado em CLAUDE.md/AGENTS.md — nada a checar"
+  else
+    [ -z "$over" ] && pass "seções de aprendizado dentro do teto de 12 bullets" \
+                   || fail "seção acima do teto:$over"
+  fi
+else
+  skip "repo sem CLAUDE.md nem AGENTS.md — nada a checar"
+fi
+
+# 4b — o commit de learnings não é balde: no máximo 3 bullets líquidos novos
+# nas seções Learned por commit, somando CLAUDE.md e AGENTS.md — mover a seção
+# de um arquivo para o outro (o que o 4c pede) dá zero líquido, e bullet novo
+# conta onde quer que caia. O bullet de retomada, que o passo 8 garante uma
+# vez, fica fora da conta. Conteúdo não é verificável por script; volume é.
+# Só o HEAD conta: o commit B é o último do ritual, e um B antigo em HEAD~1
+# não é deste wrap.
+count_learned() { # <conteúdo na stdin> — bullets nas duas seções canônicas, fora de code block, sem o de retomada
+  unfenced | awk -v h="$LEARNED_HEADING" '$0 ~ h {f=1; next}
+       /^## /{f=0} f && /^- / && index($0, "Início de sessão: ler HANDOFF.md") == 0 {n++} END{print n+0}'
+}
+if [ "$rule" = ausente ]; then
+  skip "check 4b não avaliado (ver FAIL acima)"
+elif git -C "$root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  if git -C "$root" log -1 --format=%s 2>/dev/null | grep -q '^chore(wrap): learnings'; then
+    net=0
+    for lf in CLAUDE.md AGENTS.md; do
+      after=$(git -C "$root" show "HEAD:$lf" 2>/dev/null | count_learned)
+      before=$(git -C "$root" show "HEAD^:$lf" 2>/dev/null | count_learned)
+      net=$((net + after - before))
+    done
+    [ "$net" -le 3 ] && pass "commit de learnings adicionou $net bullet(s) líquido(s) nas seções Learned (teto 3)" \
+                     || fail "commit de learnings adicionou $net bullets nas seções Learned (teto 3) — sinal de balde"
+  else
+    skip "HEAD não é commit de learnings — nada a checar"
+  fi
+fi
+
+# 4c — Learned num arquivo só: o alvo que learn-file.sh nomeia. Seção Learned
+# no outro arquivo é o drift da issue #12 — o Pi lê AGENTS.md antes de
+# CLAUDE.md e o Codex só AGENTS.md, então o que fica no CLAUDE.md de uma linha
+# nunca chega a eles.
+if [ "$rule" != ok ]; then
+  skip "check 4c não avaliado (ver FAIL acima)"
+elif [ ! -f "$root/CLAUDE.md" ] && [ ! -f "$root/AGENTS.md" ]; then
+  skip "repo sem CLAUDE.md nem AGENTS.md — o alvo seria $(learn_target "$root")"
+else
+  alvo=$(learn_target "$root")
+  case "$alvo" in CLAUDE.md) outro=AGENTS.md ;; *) outro=CLAUDE.md ;; esac
+  if learned "$root/$outro"; then
+    fail "seção Learned em $outro — o alvo é $alvo, mova para lá"
+  elif learned "$root/$alvo"; then
+    pass "seções Learned num arquivo só ($alvo)"
+  else
+    skip "nenhuma seção Learned em CLAUDE.md/AGENTS.md — nada a checar (alvo: $alvo)"
+  fi
+fi
+
+# 5 — a memória nativa tem ponteiro para este projeto.
+# O diretório de memória é nomeado pelo cwd da sessão, não pelo repo, então o
+# 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.
+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
+  pass "memória nativa tem ponteiro para $root"
+else
+  fail "nenhum arquivo em $mem_root/*/memory menciona $root"
+fi
+
+# 6 e 7 — o commit pegou a tríade, e só ela
+if git -C "$root" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  # O wrap pula o commit de propósito durante rebase/merge/cherry-pick. Julgar o
+  # HEAD nesse caso reprovaria um commit alheio e empurraria o modelo a commitar
+  # no meio da operação — o oposto do que a skill manda.
+  subject=$(git -C "$root" log -1 --format=%s 2>/dev/null)
+  case "$subject" in
+    "chore(wrap): "*)
+      dirty=$(git -C "$root" status --porcelain -- HANDOFF.md tasks.jsonl memory.md 2>/dev/null)
+      [ -z "$dirty" ] && pass "tríade commitada (git status limpo nos três paths)" \
+                      || fail "tríade não commitada: $(printf '%s' "$dirty" | tr '\n' ' ')"
+
+      files=$(git -C "$root" show --pretty=format: --name-only HEAD 2>/dev/null | grep -v '^$')
+      # AGENTS.md entra porque é onde o commit B grava os aprendizados no repo
+      # cujo CLAUDE.md só faz `@AGENTS.md` — sem ele o passo 8 reprova sozinho.
+      # docs/ inteiro, README, CHANGELOG e CONTEXT entram porque o passo 2 manda
+      # atualizar as docs vivas que o trabalho tocou, e o commit A as leva. O que
+      # a regra continua rejeitando é o que importa: path de código no commit do
+      # wrap significa trabalho não commitado indo junto por engano.
+      unexpected=$(printf '%s\n' "$files" | grep -vE '^(HANDOFF\.md|tasks\.jsonl|memory\.md|CLAUDE\.md|AGENTS\.md|README\.md|CHANGELOG\.md|CONTEXT\.md|docs/)' || true)
+      [ -z "$unexpected" ] && pass "commit do wrap toca só os paths dele" \
+                           || fail "commit do wrap tem paths inesperados: $(printf '%s' "$unexpected" | tr '\n' ' ')"
+      ;;
+    *)
+      skip "HEAD não é um commit do wrap — commit pulado (operação em curso?) ou ainda não feito"
+      ;;
+  esac
+else
+  skip "fora de repositório git — checks de commit não se aplicam"
+fi
+
+echo
+[ "$fails" -eq 0 ] && echo "resultado: tudo verde" || echo "resultado: $fails FAIL"
+exit $((fails > 0))