ll-skills 2.0.2 → 3.0.0

package/scripts/smoke-test.sh

@@ -1,10 +1,29 @@
 #!/usr/bin/env bash
 # Smoke test do ll-skills: gate estático, hooks, helper, instalador, preâmbulo,
 # poda de skills antigas e uninstall. Tudo num CLAUDE_CONFIG_DIR isolado.
+# Uso: smoke-test.sh [--only <seção>]   (sem argumento roda tudo)
+# As seções são os blocos numerados (1, 2, 3, 4, 4b, 4c, 4d, 5..10), lint-orquestrador,
+# goal-autonomo, evals-auto, lint-scratch e no-talk; os blocos numerados montam estado uns para
+# os outros, então --only puxa o pré-requisito de quem não roda sozinho (ver prereq abaixo).
 set -euo pipefail
 cd "$(dirname "$0")/.."
 ROOT="$PWD"
 
+ONLY=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --only) ONLY="${2:-}"; shift 2 ;;
+    *) echo "uso: smoke-test.sh [--only <seção>]" >&2; exit 2 ;;
+  esac
+done
+# Pré-requisitos: a seção 4 usa o $EMPTY que a 2 monta e o $FIX que a 3 monta, a 6 lê o
+# CLAUDE_CONFIG_DIR e o log que a 5 monta, e a 8 desinstala o que a 5 instalou e o preâmbulo que a 6
+# escreve. --only puxa essas seções antes da pedida.
+prereq() { case "$1" in 4) echo "2 3" ;; 6) echo "5" ;; 8) echo "5 6" ;; *) echo "" ;; esac; }
+RUN=""
+[ -z "$ONLY" ] || RUN=" $(prereq "$ONLY") $ONLY "
+section() { [ -z "$ONLY" ] || case "$RUN" in *" $1 "*) return 0 ;; *) return 1 ;; esac; }
+
 TMP="$(mktemp -d)"
 trap 'rm -rf "$TMP"' EXIT
 
@@ -12,11 +31,13 @@ N=0
 check() { N=$((N + 1)); if ! eval "$2"; then echo "FALHOU: $1"; exit 1; fi; }
 
 HELPER="node $ROOT/scripts/ll-tools.js"
+AUTO="node $ROOT/skills/ll-auto/scripts/ll-auto.js"
 region() { awk '/^\/\/ <ll-shared:state>$/,/^\/\/ <\/ll-shared:state>$/' "$1"; }
 
 # ---------------------------------------------------------------------------
 # 1. gate estático
 # ---------------------------------------------------------------------------
+if section 1; then
 for f in bin/*.js hooks/*.js scripts/*.js; do node --check "$f"; done
 
 check "helper ≤700 linhas"            '[ "$(wc -l < scripts/ll-tools.js)" -le 700 ]'
@@ -30,10 +51,12 @@ region scripts/ll-tools.js > "$TMP/shared-tools.txt"
 region hooks/ll-state.js   > "$TMP/shared-hook.txt"
 check "região ll-shared:state existe"    '[ -s "$TMP/shared-tools.txt" ] && [ -s "$TMP/shared-hook.txt" ]'
 check "região ll-shared:state idêntica"  'cmp -s "$TMP/shared-tools.txt" "$TMP/shared-hook.txt"'
+fi
 
 # ---------------------------------------------------------------------------
 # 2. hooks silenciosos fora de um projeto
 # ---------------------------------------------------------------------------
+if section 2; then
 EMPTY="$TMP/empty"
 mkdir -p "$EMPTY"
 cp -R scripts/fixtures/empty/. "$EMPTY/"
@@ -56,10 +79,12 @@ for h in ll-state.js ll-precompact.js; do
   check "$h <300 ms no vazio"             '[ "$(cat "$TMP/hook.ms")" -lt 300 ]'
 done
 check "hooks não criaram arquivos no vazio" '[ "$(find "$EMPTY" | wc -l)" -eq "$BEFORE_FILES" ]'
+fi
 
 # ---------------------------------------------------------------------------
 # 3. hooks no fixture
 # ---------------------------------------------------------------------------
+if section 3; then
 FIX="$TMP/fix"
 bash scripts/fixtures/git-history.sh "$FIX" > /dev/null
 
@@ -88,10 +113,12 @@ check "precompact avisa a sessão"    'grep -q "compaction marked in PROGRESS.md
 check "precompact inseriu 1 linha"   '[ "$(grep -c "^- \[compaction" "$FIX/PROGRESS.md")" -eq "$((C0 + 1))" ]'
 check "linha nova fica acima do epílogo" \
   'grep -n "^## Epilogue" "$FIX/PROGRESS.md" | head -1 | cut -d: -f1 | xargs -I{} sh -c "sed -n \"\$(({} - 2))p\" \"$FIX/PROGRESS.md\"" | grep -q "^- \[compaction .* manual "'
+fi
 
 # ---------------------------------------------------------------------------
 # 4. os 12 comandos do helper
 # ---------------------------------------------------------------------------
+if section 4; then
 cd "$FIX"
 $HELPER waves phases/07/PLAN.md --json > "$TMP/waves.json"
 check "waves: 4 ondas"                'grep -q "\"wave\":4" "$TMP/waves.json"'
@@ -103,14 +130,24 @@ $HELPER tdd-gate M1 --json > "$TMP/tdd1.json"
 check "tdd-gate M1 passa"             'grep -q "\"tdd\":\"pass\"" "$TMP/tdd1.json"'
 check "tdd-gate M1 ignora M10"        '! grep -q "M10" "$TMP/tdd1.json"'
 check "tdd-gate M2 reprova"           '$HELPER tdd-gate M2 --json | grep -q "\"tdd\":\"fail\""'
+check "tdd-gate acha o id entre posicionais" '$HELPER tdd-gate phases/07/PLAN.md M1 --json | grep -q "\"tdd\":\"pass\""'
 
 check "spot-check M1 passa"           '$HELPER spot-check M1 --files src/a.ts,test/a.test.ts --json | grep -q "\"verdict\":\"pass\""'
 check "state: fase 07, 1/3"           '$HELPER state --json | grep -q "\"total\":3,\"passed\":1"'
 check "ledger: 1 FRESH 1 STALE 1 UNKNOWN" '$HELPER ledger --json | grep -q "\"FRESH\":1,\"STALE\":1,\"UNKNOWN\":1"'
 check "epilogue 07 aponta a fase 8"   '$HELPER epilogue 07 --json | grep -q "\"next_command\":\"ll-implement 8\""'
 check "phase-stats: 5 dias com trabalho" '$HELPER phase-stats --json | grep -q "\"days_with_work\":5"'
+check "phase-stats: fase 07 com questions/owner_prompts" \
+  '$HELPER phase-stats --json | grep -q "\"phase\":\"07\"" && $HELPER phase-stats --json | grep -q "\"questions\":3" && $HELPER phase-stats --json | grep -q "\"owner_prompts\":2"'
+check "phase-stats: targets presente"   '$HELPER phase-stats --json | grep -q "\"targets\""'
+mkdir -p "$TMP/ep" && awk '/^## Epilogue — phase 07/{print "## Epilogue — phase 06 — 2026-09-08"; print "passed: M1 · left: none"; print ""} {print}' PROGRESS.md | sed 's/· amendments 1 · verification:/· amendments 1 (M3) · verification:/' > "$TMP/ep/PROGRESS.md"
+$HELPER phase-stats --cwd "$TMP/ep" --json > "$TMP/ep.json"
+check "phase-stats: epílogo sem linha de contagem não rouba a da fase seguinte" 'grep -q "\"phase\":\"06\",\"count_line\":false" "$TMP/ep.json"'
+check "phase-stats: parêntese após amendments é aceito" 'grep -q "\"amendments\":1,\"verdict\":\"APPROVED\",\"verification\":\"phases/07/VERIFICATION.md\"" "$TMP/ep.json"'
+check "epilogue 07 humano traz targets" '$HELPER epilogue 07 | grep -q "targets:"'
 check "plan-lint reprova o PLAN"      '$HELPER plan-lint phases/07/PLAN.md --json | grep -q "\"verdict\":\"fail\""'
 check "plan-lint acusa acceptance-missing em M6" '$HELPER plan-lint phases/07/PLAN.md --json | grep -q "acceptance-missing"'
+check "plan-lint aceita o número da fase"  '$HELPER plan-lint 7 --json | grep -q "\"verdict\":\"fail\"" && $HELPER waves 07 --json | grep -q "\"waves\""'
 
 cp PROGRESS.md "$TMP/progress-before"
 $HELPER passes M2 true --json > "$TMP/passes.json"
@@ -118,6 +155,9 @@ check "passes M2 true grava"          'grep -q "\"passes\":true" "$TMP/passes.js
 check "passes muda exatamente 2 linhas" \
   '[ "$(diff "$TMP/progress-before" PROGRESS.md | grep -c "^[<>]")" -eq 2 ]'
 check "passes M9 cria a linha"        '$HELPER passes M9 true --json | grep -q "\"created\":true"'
+mkdir -p "$TMP/emptymap" && sed 's/^milestones:$/milestones: {}/' "$TMP/progress-before" | awk '/^milestones: \{\}$/{print; skip=1; next} skip && /^  (M[0-9]+|G-[0-9]+):/{next} {skip=0; print}' > "$TMP/emptymap/PROGRESS.md"
+check "passes com milestones: {} cria a entrada" \
+  '$HELPER passes M1 true --cwd "$TMP/emptymap" --json | grep -q "\"created\":true" && grep -q "^milestones:$" "$TMP/emptymap/PROGRESS.md" && grep -q "^  M1: {" "$TMP/emptymap/PROGRESS.md"'
 
 check "dec-reserve 2 → 0042/0043"     '$HELPER dec-reserve 2 --json | grep -q "\"DEC-0042\",\"DEC-0043\""'
 check "dec-reserve 2 → 0044/0045"     '$HELPER dec-reserve 2 --json | grep -q "\"DEC-0044\",\"DEC-0045\""'
@@ -145,10 +185,12 @@ for cmd in waves tdd-gate spot-check state ledger backlog-reconcile epilogue pha
     "$HELPER $cmd M1 > \"$TMP/r.out\" 2>/dev/null; [ \$? -eq 0 ] && grep -q '\"ok\":false' \"$TMP/r.out\""
 done
 cd "$ROOT"
+fi
 
 # ---------------------------------------------------------------------------
 # 4b. nested state root (PROGRESS.md/phases/ under docs/state/, sources at git top)
 # ---------------------------------------------------------------------------
+if section 4b; then
 NEST="$TMP/nest"
 bash scripts/fixtures/git-history.sh "$NEST" > /dev/null
 mkdir -p "$NEST/docs/state"
@@ -166,6 +208,19 @@ check "nested state: git_top aponta ao topo do git" \
 check "nested ledger: FRESH/STALE/UNKNOWN iguais ao topo" \
   '$HELPER ledger --cwd "$NEST/docs/state" --json | grep -q "\"FRESH\":1,\"STALE\":1,\"UNKNOWN\":1"'
 
+printf '{"cwd":"%s","source":"compact"}' "$NEST" | node hooks/ll-state.js > "$TMP/nest-hook.json"
+check "nested hook ll-state acha o PROGRESS em docs/state" 'grep -q "post-compaction" "$TMP/nest-hook.json" && grep -q "milestones [0-9]/3" "$TMP/nest-hook.json"'
+printf '{"cwd":"%s","trigger":"auto"}' "$NEST" | node hooks/ll-precompact.js > "$TMP/nest-pre.out"
+check "nested hook precompact carimba docs/state/PROGRESS.md" 'grep -q "compaction marked" "$TMP/nest-pre.out" && grep -q "^- \[compaction " "$NEST/docs/state/PROGRESS.md"'
+mkdir -p "$NEST/docs/other" && printf '# other progress\n\nno state block here\n' > "$NEST/docs/other/PROGRESS.md" && touch "$NEST/docs/other/PROGRESS.md"
+printf '{"cwd":"%s","source":"compact"}' "$NEST" | node hooks/ll-state.js > "$TMP/nest-hook2.json"
+check "nested hook: entre vários PROGRESS.md escolhe o que tem bloco ll-state" 'grep -q "milestones [0-9]/3" "$TMP/nest-hook2.json"'
+rm -rf "$NEST/docs/other"
+mkdir -p "$NEST/docs/fixtures/project" && cp "$NEST/docs/state/PROGRESS.md" "$NEST/docs/fixtures/project/PROGRESS.md" && mv "$NEST/docs/state" "$TMP/state-aside"
+check "hook ignora PROGRESS.md dentro de fixtures/" '[ -z "$(printf "{\"cwd\":\"%s\",\"source\":\"startup\"}" "$NEST" | node hooks/ll-state.js)" ]'
+mv "$TMP/state-aside" "$NEST/docs/state"
+rm -rf "$NEST/docs/fixtures"
+
 $HELPER backlog-reconcile --run --cwd "$NEST/docs/state" --json > "$TMP/nest-backlog.json"
 check "nested backlog-reconcile fecha B-014 (comando roda no topo do git)" \
   'grep -q "\"closed\":\[\"B-014\"\]" "$TMP/nest-backlog.json"'
@@ -181,10 +236,96 @@ check "state do topo reporta git_top correto" \
 $HELPER spot-check M1 --files src/a.ts,test/a.test.ts --cwd "$NEST" --json > "$TMP/nest-top-spot.json"
 check "spot-check do topo acha a raiz deslocada" \
   'grep -q "\"verdict\":\"pass\"" "$TMP/nest-top-spot.json"'
+fi
+
+# ---------------------------------------------------------------------------
+# 4c. helper ll-auto: detect
+# ---------------------------------------------------------------------------
+if section 4c; then
+# ids e status exatos de um detect --json: renomear um status ou perder um estágio reprova
+auto_ids() { node -e 'const o=JSON.parse(require("fs").readFileSync(process.argv[1],"utf8"));console.log(o.stages.map((s)=>s.id).join(","))' "$1"; }
+auto_status_set() { node -e 'const o=JSON.parse(require("fs").readFileSync(process.argv[1],"utf8"));console.log([...new Set(o.stages.map((s)=>s.status))].sort().join(","))' "$1"; }
+check "ll-auto detect: fixture project → decide done, 07 half" \
+  '$AUTO detect --cwd "$ROOT/scripts/fixtures/project" --json > "$TMP/auto-project.json" \
+   && grep -q "\"id\":\"decide\",\"status\":\"done\"" "$TMP/auto-project.json" \
+   && grep -q "\"id\":\"phase-07\",\"status\":\"half\"" "$TMP/auto-project.json"'
+check "ll-auto detect: fixture empty → os 4 estágios exatos, todos todo" \
+  '$AUTO detect --cwd "$ROOT/scripts/fixtures/empty" --json > "$TMP/auto-empty.json" \
+   && [ "$(auto_ids "$TMP/auto-empty.json")" = "research,brainstorm,decide,close" ] \
+   && [ "$(auto_status_set "$TMP/auto-empty.json")" = "todo" ]'
+check "ll-auto detect: sem ROADMAP.md as fases saem da tabela do §8 do PLAN" \
+  '$AUTO detect --cwd "$ROOT/scripts/fixtures/auto-noroadmap" --json > "$TMP/auto-noroadmap.json" \
+   && [ "$(auto_ids "$TMP/auto-noroadmap.json")" = "research,brainstorm,decide,phase-01,phase-02,verify-01,verify-02,close" ] \
+   && grep -q "\"id\":\"phase-01\",\"status\":\"done\"" "$TMP/auto-noroadmap.json" \
+   && grep -q "\"id\":\"phase-02\",\"status\":\"todo\"" "$TMP/auto-noroadmap.json"'
+check "ll-auto detect: DELIVERY.md + epílogo da última fase → close done" \
+  '$AUTO detect --cwd "$ROOT/scripts/fixtures/auto-closed" --json > "$TMP/auto-closed.json" \
+   && grep -q "\"id\":\"close\",\"status\":\"done\",\"evidence\":\"docs/DELIVERY.md + epilogue for phase 02\"" "$TMP/auto-closed.json" \
+   && grep -q "\"id\":\"phase-02\",\"status\":\"done\"" "$TMP/auto-closed.json" \
+   && [ "$(auto_status_set "$TMP/auto-closed.json")" = "done,todo" ]'
+check "ll-auto detect: diretório inexistente → ok:false e exit 0" \
+  '$AUTO detect --cwd /nonexistent --json > "$TMP/auto-nodir.json" 2>/dev/null; [ $? -eq 0 ] \
+   && grep -q "\"ok\":false" "$TMP/auto-nodir.json" && grep -q "not a directory" "$TMP/auto-nodir.json"'
+check "ll-auto detect --json é JSON válido" \
+  '$AUTO detect --cwd "$ROOT/scripts/fixtures/project" --json \
+   | node -e "JSON.parse(require(\"fs\").readFileSync(0,\"utf8\"))"'
+fi
+
+# ---------------------------------------------------------------------------
+# 4d. helper ll-auto: roteiro, next-cmd, report, auto-md
+# ---------------------------------------------------------------------------
+if section 4d; then
+check "ll-auto roteiro: --verify all → 07, verify-07, 08, verify-08, close" \
+  '$AUTO roteiro --cwd "$ROOT/scripts/fixtures/project" --flags "--verify all" --json > "$TMP/auto-verify-all.json" \
+   && grep -q "\"stage\":\"phase-07\".*\"stage\":\"verify-07\".*\"stage\":\"phase-08\".*\"stage\":\"verify-08\".*\"stage\":\"close\"" "$TMP/auto-verify-all.json" \
+   && ! grep -qE "\"stage\":\"(research|brainstorm|decide|phase-05|phase-06)\"" "$TMP/auto-verify-all.json"'
+check "ll-auto roteiro: --only 8 corta o close e as outras fases" \
+  '$AUTO roteiro --cwd "$ROOT/scripts/fixtures/project" --flags "--only 8" --json > "$TMP/auto-only8.json" \
+   && grep -q "\"stage\":\"phase-08\",\"command\":\"ll-implement 08 --no-talk\"" "$TMP/auto-only8.json" \
+   && ! grep -qE "\"stage\":\"(phase-07|close)\"" "$TMP/auto-only8.json"'
+check "ll-auto roteiro: repo vazio sem objetivo pede o objetivo" \
+  '$AUTO roteiro --cwd "$ROOT/scripts/fixtures/empty" --flags "" --json > "$TMP/auto-vazio.json" \
+   && grep -q "\"needs_objective\":true" "$TMP/auto-vazio.json" \
+   && grep -q "\"roteiro\":\[\]" "$TMP/auto-vazio.json"'
+check "ll-auto roteiro: repo vazio com objetivo → research, brainstorm, decide, close" \
+  '$AUTO roteiro --cwd "$ROOT/scripts/fixtures/empty" --objective "um objetivo" \
+     --flags "--research --brainstorm" --json > "$TMP/auto-vazio2.json" \
+   && grep -q "\"stage\":\"research\".*\"stage\":\"brainstorm\".*\"stage\":\"decide\".*\"stage\":\"close\"" "$TMP/auto-vazio2.json" \
+   && grep -q "\"needs_objective\":false" "$TMP/auto-vazio2.json"'
+check "ll-auto roteiro: --interactive --redo phase-05 --pause-at 8" \
+  '$AUTO roteiro --cwd "$ROOT/scripts/fixtures/project" \
+     --flags "--interactive --redo phase-05 --pause-at 8" --json > "$TMP/auto-redo.json" \
+   && grep -q "\"stage\":\"phase-05\",\"command\":\"ll-implement 05\",\"status\":\"done\"" "$TMP/auto-redo.json" \
+   && ! grep -q "ll-implement 05 --no-talk" "$TMP/auto-redo.json" \
+   && grep -q "\"stage\":\"phase-08\",\"command\":\"ll-implement 08\",\"status\":\"todo\",\"pause_after\":true" "$TMP/auto-redo.json"'
+check "ll-auto roteiro: epílogo que pede ll-verify 01 insere verify-01 sem --verify all" \
+  '$AUTO roteiro --cwd "$ROOT/scripts/fixtures/auto-verify-next" --flags "" --json > "$TMP/auto-vnext.json" \
+   && grep -q "\"stage\":\"phase-01\",\"command\":\"ll-implement 01 --no-talk\".*\"stage\":\"verify-01\",\"command\":\"ll-verify 01\"" "$TMP/auto-vnext.json" \
+   && $AUTO roteiro --cwd "$ROOT/scripts/fixtures/project" --flags "" --json > "$TMP/auto-noverify.json" \
+   && ! grep -q "\"stage\":\"verify-" "$TMP/auto-noverify.json"'
+check "ll-auto next-cmd: o epílogo da fixture aponta ll-implement 8" \
+  '[ "$($AUTO next-cmd "$ROOT/scripts/fixtures/project/PROGRESS.md")" = "ll-implement 8" ]'
+check "ll-auto next-cmd: arquivo sem ▶ Next → saída vazia, exit 0" \
+  '[ -z "$($AUTO next-cmd "$ROOT/scripts/fixtures/project/ROADMAP.md")" ]'
+check "ll-auto report: só o DEC com a marca de decidido sozinho" \
+  '$AUTO report --cwd "$ROOT/scripts/fixtures/auto-decisions" --json > "$TMP/auto-report.json" \
+   && grep -q "DEC-0001-taken-alone.md" "$TMP/auto-report.json" \
+   && ! grep -q "DEC-0002-owner.md" "$TMP/auto-report.json"'
+check "ll-auto auto-md: as cinco seções, o objetivo e as flags" \
+  '$AUTO auto-md --cwd "$ROOT/scripts/fixtures/project" --objective "um objetivo" --flags "--only 8" \
+     > "$TMP/auto-md.txt" \
+   && grep -q "^## Objective" "$TMP/auto-md.txt" && grep -q "^## Flags" "$TMP/auto-md.txt" \
+   && grep -q "^## Roteiro" "$TMP/auto-md.txt" && grep -q "^## Decisions taken alone" "$TMP/auto-md.txt" \
+   && grep -q "^## Log" "$TMP/auto-md.txt" \
+   && grep -q "^um objetivo$" "$TMP/auto-md.txt" && grep -q -e "^--only 8$" "$TMP/auto-md.txt" \
+   && grep -q "^| # | stage | command | status | evidence |$" "$TMP/auto-md.txt" \
+   && grep -q "^| 1 | phase-08 | ll-implement 08 --no-talk | todo |" "$TMP/auto-md.txt"'
+fi
 
 # ---------------------------------------------------------------------------
 # 5. instalador
 # ---------------------------------------------------------------------------
+if section 5; then
 export CLAUDE_CONFIG_DIR="$TMP/cfg" XDG_CACHE_HOME="$TMP/cache"
 mkdir -p "$CLAUDE_CONFIG_DIR"
 
@@ -208,7 +349,7 @@ echo '{"version":"0.0.1","files":{"skills/ll-antiga/SKILL.md":"a","skills/alheia
 
 node bin/install.js < /dev/null > "$TMP/install1.log"
 
-check "11 skills ll-* instaladas"     '[ "$(ls "$CLAUDE_CONFIG_DIR/skills" | grep -c "^ll-")" -eq 11 ]'
+check "12 skills ll-* instaladas"     '[ "$(ls "$CLAUDE_CONFIG_DIR/skills" | grep -c "^ll-")" -eq 12 ]'
 for s in ll-brainstorm ll-research ll-decide ll-goal ll-implement ll-verify ll-close ll-resume ll-refine ll-oncall ll-update; do
   check "skill $s instalada"          '[ -f "$CLAUDE_CONFIG_DIR/skills/'"$s"'/SKILL.md" ]'
 done
@@ -240,6 +381,11 @@ for s in ll-implement ll-verify ll-close; do
     '[ "$(sha256sum "$CLAUDE_CONFIG_DIR/skills/'"$s"'/scripts/ll-tools.js" | cut -d" " -f1)" = "$SHA_SRC" ]'
 done
 
+SHA_AUTO_SRC="$(sha256sum skills/ll-auto/scripts/ll-auto.js | cut -d" " -f1)"
+check "ll-auto.js instalado executável"    '[ -x "$CLAUDE_CONFIG_DIR/skills/ll-auto/scripts/ll-auto.js" ]'
+check "ll-auto.js instalado com sha idêntico" \
+  '[ "$(sha256sum "$CLAUDE_CONFIG_DIR/skills/ll-auto/scripts/ll-auto.js" | cut -d" " -f1)" = "$SHA_AUTO_SRC" ]'
+
 cp "$CLAUDE_CONFIG_DIR/settings.json" "$TMP/s1.json"
 node bin/install.js < /dev/null > /dev/null
 check "segunda instalação sem diff no settings" 'cmp -s "$CLAUDE_CONFIG_DIR/settings.json" "$TMP/s1.json"'
@@ -260,10 +406,12 @@ mkdir -p "$XDG_CACHE_HOME/ll-skills"
 V="$(cat "$CLAUDE_CONFIG_DIR/ll-skills/VERSION")"
 printf '{"checked":%s,"installed":"%s","latest":"99.0.0","update_available":true,"method":"npm"}' "$(date +%s)" "$V" > "$XDG_CACHE_HOME/ll-skills/update-check.json"
 check "leitor avisa versão nova" 'node "$CLAUDE_CONFIG_DIR/hooks/ll-skills-check-update.js" | grep -q "/ll-update"'
+fi
 
 # ---------------------------------------------------------------------------
 # 6. preâmbulo
 # ---------------------------------------------------------------------------
+if section 6; then
 check "não-TTY sem --yes não escreve CLAUDE.md" '[ ! -e "$CLAUDE_CONFIG_DIR/CLAUDE.md" ]'
 check "não-TTY imprime o diff e a dica --yes"   'grep -q -- "--yes" "$TMP/install1.log"'
 
@@ -284,10 +432,12 @@ sed -i 's/^## Skills$/## Skills MEXIDO A MAO/' "$CMD"
 node bin/install.js --yes < /dev/null > /dev/null
 check "corpo alterado à mão é restaurado" 'cmp -s "$CMD" "$TMP/claudemd-1"'
 check "backup .ll-skills.bak existe"      '[ -f "$CMD.ll-skills.bak" ]'
+fi
 
 # ---------------------------------------------------------------------------
 # 7. poda das skills 1.x (com e sem manifesto)
 # ---------------------------------------------------------------------------
+if section 7; then
 LEGACY_SKILLS="ll-atualizar ll-decidir-antes ll-desarmar ll-orquestrar ll-pesquisar ll-pesquisar-mercado ll-verificar-entrega ll-voltar-do-futuro"
 CFG_L="$TMP/cfg-legacy"
 seed_legacy() {
@@ -318,10 +468,12 @@ assert_pruned "com manifesto"
 seed_legacy   # agora o manifesto atual (2.x) não lista nada disso: só KNOWN_LEGACY resolve
 CLAUDE_CONFIG_DIR="$CFG_L" node bin/install.js --no-preamble < /dev/null > /dev/null
 assert_pruned "sem manifesto"
+fi
 
 # ---------------------------------------------------------------------------
 # 8. uninstall
 # ---------------------------------------------------------------------------
+if section 8; then
 node bin/install.js --uninstall < /dev/null > /dev/null
 check "uninstall removeu skills"      '[ -z "$(ls "$CLAUDE_CONFIG_DIR/skills" | grep "^ll-" || true)" ]'
 check "uninstall removeu as cópias do helper" '[ ! -e "$CLAUDE_CONFIG_DIR/skills/ll-implement" ]'
@@ -331,10 +483,237 @@ check "uninstall removeu o check-update" '! grep -q "ll-skills-check-update" "$C
 check "uninstall preservou alheios"   'grep -q "echo alheio" "$CLAUDE_CONFIG_DIR/settings.json" && [ -f "$CLAUDE_CONFIG_DIR/skills/alheia/SKILL.md" ]'
 check "uninstall removeu o preâmbulo" '! grep -q "ll-skills:preamble" "$CMD"'
 check "uninstall preservou as sentinelas" 'grep -q "SENTINEL-TOP" "$CMD" && grep -q "SENTINEL-BOTTOM" "$CMD"'
+fi
 
+# ---------------------------------------------------------------------------
+# 9. lint dos prompts (uma checagem por regra de scripts/lint-prompts.sh)
+# ---------------------------------------------------------------------------
+if section 9; then
+lint() { # lint <n>: roda uma regra e só imprime a saída quando ela falha
+  bash "$ROOT/scripts/lint-prompts.sh" --rule "$1" > "$TMP/lint-$1.txt" 2>&1 \
+    || { cat "$TMP/lint-$1.txt"; return 1; }
+}
+
+check "lint 1: frontmatter das skills"  'lint 1'
+check "lint 2: frontmatter dos agentes" 'lint 2'
+check "lint 3: tetos de linhas"         'lint 3'
+printf '[{"unpackedSize":999999999}]' > "$TMP/pack-list-big.json"
+check "lint 3: honra LL_PACK_JSON na forma lista (npm ≤ 11) e reprova no teto sintético" \
+  '! LL_PACK_JSON="$TMP/pack-list-big.json" bash "$ROOT/scripts/lint-prompts.sh" --rule 3 > "$TMP/lint-pack-list.out" 2>&1; \
+   grep -q "unpackedSize 999999999 bytes, ceiling 921600" "$TMP/lint-pack-list.out"'
+printf '{"ll-skills":{"unpackedSize":999999999}}' > "$TMP/pack-object-big.json"
+check "lint 3: honra LL_PACK_JSON na forma objeto (npm 12) e reprova no teto sintético" \
+  '! LL_PACK_JSON="$TMP/pack-object-big.json" bash "$ROOT/scripts/lint-prompts.sh" --rule 3 > "$TMP/lint-pack-object.out" 2>&1; \
+   grep -q "unpackedSize 999999999 bytes, ceiling 921600" "$TMP/lint-pack-object.out"'
+check "lint 4: forma das SKILL.md"      'lint 4'
+check "lint 5: strings proibidas"       'lint 5'
+check "lint 6: cópias idênticas"        'lint 6'
+check "lint 7: idioma"                  'lint 7'
+check "lint 8: lista privada"           'lint 8'
+fi
+
+# 10. lint de contrato entre as peças (uma checagem por regra de scripts/lint-contract.cjs)
+if section 10; then
+contract() { node "$ROOT/scripts/lint-contract.cjs" --rule "$1" >/dev/null 2>&1; }
+check "contrato 1: references citadas existem e são citadas"  'contract 1'
+check "contrato 2: comandos do helper definidos e citados"     'contract 2'
+check "contrato 3: agentes, modelos e campos do brief"         'contract 3'
+check "contrato 4: vocabulário de veredito e estados"          'contract 4'
+check "contrato 5: arquivos de estado nas tabelas de entregáveis" 'contract 5'
+check "contrato 6: alvos do ▶ Next existem"                    'contract 6'
+check "contrato 7: instalador × pacote"                        'contract 7'
+
+# regra 6 contra as fixtures da gramática do ▶ Next (bad falha, good passa, raiz sem skills falha)
+contract_root() { node "$ROOT/scripts/lint-contract.cjs" --rule 6 --root "$1" >/dev/null 2>&1; }
+contract_fails() { node "$ROOT/scripts/lint-contract.cjs" --rule 6 --root "$1" 2>/dev/null | grep -c "^FAIL 6 " || true; }
+check "contrato 6: next-bad falha"        '! contract_root scripts/fixtures/next-bad'
+# a contagem é fixa: afrouxar uma das formas rejeitadas reprova aqui, não só o exit
+check "contrato 6: next-bad com 6 FAIL"   '[ "$(contract_fails scripts/fixtures/next-bad)" -eq 6 ]'
+check "contrato 6: duas skills diferentes num ▶ Next fora de parêntese reprovam" \
+  'node "$ROOT/scripts/lint-contract.cjs" --rule 6 --root scripts/fixtures/next-bad > "$TMP/next-bad.out" 2>/dev/null; \
+   grep -q "lists alternatives outside a parenthetical —ll-bad or ll-nope" "$TMP/next-bad.out"'
+check "contrato 6: next-good passa"       'contract_root scripts/fixtures/next-good'
+check "contrato 6: raiz sem skills falha" '! contract_root scripts/fixtures/empty'
 
 # --- optional private word list (never shipped): LL_FORBIDDEN_FILE=<path> enables the check
 if [ -n "${LL_FORBIDDEN_FILE:-}" ] && [ -f "$LL_FORBIDDEN_FILE" ]; then
   check "no private terms in tracked files" '! git ls-files | grep -v "^\.gitignore$" | xargs grep -n -i -w -E -f "$LL_FORBIDDEN_FILE" 2>/dev/null | grep -q .'
 fi
+fi
+
+# ---------------------------------------------------------------------------
+# lint-orquestrador. as exceções de ll-auto valem só para ll-auto
+# ---------------------------------------------------------------------------
+if section lint-orquestrador; then
+cd "$ROOT"
+SCR="$TMP/lint-scratch"
+mkdir -p "$SCR"
+git ls-files -z | xargs -0 cp --parents -t "$SCR"
+git -C "$SCR" init -q
+git -C "$SCR" add -A
+mkdir -p "$SCR/skills/ll-fake"
+cat > "$SCR/skills/ll-fake/SKILL.md" <<'FAKE'
+---
+name: ll-fake
+description: Pretends to be an orchestrator so the lint can prove the ll-auto exceptions do not leak to any other skill on the tree.
+argument-hint: "[--flag]"
+disable-model-invocation: true
+allowed-tools: Bash(${CLAUDE_SKILL_DIR}/scripts/ll-auto.js *)
+---
+
+# Fake
+
+## Deliverables
+
+| File | Role | Mutability |
+|---|---|---|
+| `docs/FAKE.md` | nothing | never |
+
+## Flow
+
+/ll-research x
+
+## Completion criterion
+
+▶ Next — /clear, then ll-resume
+FAKE
+git -C "$SCR" add -A
+lint_scr() { bash "$SCR/scripts/lint-prompts.sh" --rule "$1" > "$TMP/scr-rule$1.out" 2>&1; }
+lint_real() { bash "$ROOT/scripts/lint-prompts.sh" --rule "$1" >/dev/null 2>&1; }
+
+check "orquestrador: skills/ll-auto/SKILL.md existe" '[ -f "$ROOT/skills/ll-auto/SKILL.md" ]'
+check "orquestrador: regra 1 reprova o allowed-tools do ll-auto em outra skill" \
+  '! lint_scr 1 && grep -q "^FAIL 1 .*skills/ll-fake/SKILL.md: allowed-tools" "$TMP/scr-rule1.out"'
+check "orquestrador: regra 5 reprova a linha /ll- em outra skill" \
+  '! lint_scr 5 && grep -q "^FAIL 5 .*skills/ll-fake/SKILL.md: line .* invokes a skill as a command" "$TMP/scr-rule5.out"'
+check "orquestrador: regras 1 e 5 passam na árvore real (com ll-auto)" \
+  'lint_real 1 && lint_real 5'
+fi
+
+# ---------------------------------------------------------------------------
+# goal-autonomo. o modo --autonomous do ll-goal: hint, template e exemplo
+# ---------------------------------------------------------------------------
+if section goal-autonomo; then
+cd "$ROOT"
+GOAL_SKILL="skills/ll-goal/SKILL.md"
+GOAL_TPL="skills/ll-goal/references/goal-template.md"
+# primeiro bloco cercado sob "## Autonomous example", sem as cercas
+goal_example() { awk '/^## Autonomous example$/{f=1;next} f&&/^```/{if(b){exit}b=1;next} f&&b' "$GOAL_TPL"; }
+
+check "ll-goal argument-hint aceita --autonomous" \
+  'sed -n "/^argument-hint:/p" "$GOAL_SKILL" | grep -q -- "--autonomous"'
+check "goal-template cita ll-auto --auto-decision" \
+  '[ "$(grep -c "ll-auto --auto-decision" "$GOAL_TPL")" -ge 1 ]'
+check "exemplo autônomo entre 500 e 4000 bytes" \
+  'n=$(goal_example | wc -c); [ "$n" -ge 500 ] && [ "$n" -le 4000 ]'
+check "goal-template ≤ 150 linhas" \
+  '[ "$(wc -l < "$GOAL_TPL")" -le 150 ]'
+fi
+
+# ---------------------------------------------------------------------------
+# evals-auto. os asserts dos casos autônomos provados offline, sem nenhuma chamada paga
+# ---------------------------------------------------------------------------
+if section evals-auto; then
+cd "$ROOT"
+EV="$TMP/evals-auto"
+mkdir -p "$EV"
+# a resposta errada: não carrega nenhuma linha que os asserts exigem
+printf 'I ran nothing and wrote nothing.\n' > "$EV/wrong.txt"
+
+# a captura limpa: um evento assistant de texto (para o no_tool_use varrer algo) e o result.
+CAP_CLEAN='[{"type":"assistant","message":{"role":"assistant","content":[{"type":"text","text":"Rodei o dry run e nao escrevi nada."}]}},{"type":"result","subtype":"success","is_error":false,"result":""}]'
+# a mesma captura com uma chamada de skill por tool_use: o assert tem de reprovar.
+CAP_SKILL='[{"type":"assistant","message":{"role":"assistant","content":[{"type":"tool_use","id":"t1","name":"Skill","input":{"command":"ll-implement"}}]}},{"type":"result","subtype":"success","is_error":false,"result":""}]'
+
+# uma árvore de trabalho limpa por chamada (os asserts leem `git status --porcelain` dela)
+auto_assert() { # auto_assert <caso> <arquivo de resposta> [captura]
+  local w="$EV/$1"
+  rm -rf "$w"; mkdir -p "$w"
+  git -C "$w" init -q -b main
+  printf '%s' "${3:-$CAP_CLEAN}" > "$w/out.json"
+  bash "$ROOT/scripts/evals/cases/$1/assert.sh" "$w" "$w/out.json" "$2" > "$EV/$1.log" 2>&1
+}
+
+check "a captura offline tem ao menos um evento assistant" \
+  'node -e "const a=JSON.parse(process.argv[1]);process.exit(a.filter(e=>e.type===\"assistant\").length?0:1)" "$CAP_CLEAN"'
+
+check "assert auto-dry-run aceita a resposta boa" \
+  'auto_assert auto-dry-run "$ROOT/scripts/fixtures/evals-auto/auto-dry-run/pass.txt"'
+check "assert auto-dry-run rejeita resposta errada" \
+  '! auto_assert auto-dry-run "$EV/wrong.txt"'
+check "assert auto-empty-repo aceita a resposta boa" \
+  'auto_assert auto-empty-repo "$ROOT/scripts/fixtures/evals-auto/auto-empty-repo/pass.txt"'
+check "assert auto-empty-repo rejeita resposta errada" \
+  '! auto_assert auto-empty-repo "$EV/wrong.txt"'
+# o no_tool_use não é vazio: uma captura com tool_use Skill reprova o mesmo assert
+check "assert auto-dry-run rejeita captura com tool_use Skill" \
+  '! auto_assert auto-dry-run "$ROOT/scripts/fixtures/evals-auto/auto-dry-run/pass.txt" "$CAP_SKILL"'
+check "assert auto-empty-repo rejeita captura com tool_use Skill" \
+  '! auto_assert auto-empty-repo "$ROOT/scripts/fixtures/evals-auto/auto-empty-repo/pass.txt" "$CAP_SKILL"'
+
+# goal-autonomous: o assert espera docs/GOAL.md já no lugar (um `ll-goal --autonomous` real
+# escreve e comita o arquivo antes de imprimir o texto colável), não só o out.json do harness.
+goal_autonomous_assert() { # goal_autonomous_assert <arquivo de resposta> [captura]
+  local w="$EV/goal-autonomous"
+  rm -rf "$w"; mkdir -p "$w/docs"
+  git -C "$w" init -q -b main
+  printf 'mode: autonomous\nphase: all\n' > "$w/docs/GOAL.md"
+  git -C "$w" add -A && git -C "$w" -c user.email=t@t -c user.name=t commit -q -m "docs: GOAL.md"
+  printf '%s' "${2:-$CAP_CLEAN}" > "$w/out.json"
+  bash "$ROOT/scripts/evals/cases/goal-autonomous/assert.sh" "$w" "$w/out.json" "$1" > "$EV/goal-autonomous.log" 2>&1
+}
+check "assert goal-autonomous aceita a resposta boa" \
+  'goal_autonomous_assert "$ROOT/scripts/fixtures/evals-auto/goal-autonomous/pass.txt"'
+check "assert goal-autonomous rejeita resposta vazia" \
+  '! goal_autonomous_assert "$EV/wrong.txt"'
+echo "evals-auto: goal-autonomous pair asserted"
+fi
+
+# ---------------------------------------------------------------------------
+# lint-scratch. a regra 1 do lint-prompts contra SKILL.md ruins, numa árvore de rascunho
+# ---------------------------------------------------------------------------
+if section lint-scratch; then
+cd "$ROOT"
+LSCR="$TMP/lint-bad-scratch"
+mkdir -p "$LSCR"
+git ls-files -z | xargs -0 cp --parents -t "$LSCR"
+git -C "$LSCR" init -q
+mkdir -p "$LSCR/skills/ll-fake"
+# lint_bad <caso> <trecho esperado no FAIL>: planta a fixture como skills/ll-fake e roda a regra 1
+lint_bad() {
+  cp "$ROOT/scripts/fixtures/lint-bad/$1/SKILL.md" "$LSCR/skills/ll-fake/SKILL.md"
+  git -C "$LSCR" add -A
+  bash "$LSCR/scripts/lint-prompts.sh" --rule 1 > "$TMP/lint-bad-$1.out" 2>&1 && return 1
+  grep -q "^FAIL 1 .*skills/ll-fake/SKILL.md: $2" "$TMP/lint-bad-$1.out"
+}
+check "lint 1: descrição dobrada (>) em mais de uma linha reprova" \
+  'lint_bad folded-description "description is not one line"'
+check "lint 1: disable-model-invocation: false reprova" \
+  'lint_bad model-invocation-false "disable-model-invocation: true missing"'
+# sem a fixture a mesma árvore passa: o FAIL vem da SKILL.md ruim, não da cópia
+rm -rf "$LSCR/skills/ll-fake"
+git -C "$LSCR" add -A
+check "lint 1: a árvore de rascunho sem a fixture passa" \
+  'bash "$LSCR/scripts/lint-prompts.sh" --rule 1 > "$TMP/lint-bad-clean.out" 2>&1'
+fi
+
+# ---------------------------------------------------------------------------
+# no-talk. o modo silencioso continua declarado no argument-hint de quem o implementa
+# ---------------------------------------------------------------------------
+if section no-talk; then
+cd "$ROOT"
+hint_has_no_talk() { # hint_has_no_talk <SKILL.md>
+  sed -n '/^argument-hint:/p' "$1" > "$TMP/hint.txt"
+  grep -q -- "--no-talk" "$TMP/hint.txt"
+}
+for s in ll-decide ll-close; do
+  check "argument-hint de $s declara --no-talk" 'hint_has_no_talk "skills/'"$s"'/SKILL.md"'
+done
+# a checagem não é vazia: sem a flag na linha, ela reprova
+NT="$TMP/no-talk"
+mkdir -p "$NT"
+sed 's/ \[--no-talk\]//' skills/ll-decide/SKILL.md > "$NT/SKILL.md"
+check "a checagem reprova quando --no-talk some do hint" '! hint_has_no_talk "$NT/SKILL.md"'
+fi
+
 echo "smoke test OK — $N checks"

package/skills/ll-auto/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: ll-auto
+description: Drives the whole cycle from the state on disk — research, brainstorm, decide, phases, verifications, close — following each stage's own skill in place with the flags it was given, and reports at the end every decision it took alone.
+argument-hint: "[\"<objective>\"] [--research] [--brainstorm] [--interactive] [--auto-decision] [--pause-at <stage|N>] [--from N] [--to N] [--only N] [--verify all] [--redo <stage>] [--dry-run] [--resume]"
+disable-model-invocation: true
+allowed-tools: Bash(${CLAUDE_SKILL_DIR}/scripts/ll-auto.js *)
+---
+
+# Auto
+
+Current state: !`${CLAUDE_SKILL_DIR}/scripts/ll-auto.js detect`
+
+One invocation, the cycle the repository still owes: the helper reads the state from disk, the flags cut it into a roteiro, and this session walks the roteiro stage by stage, following each stage's own skill as a workflow file. `docs/AUTO.md` carries the run: objective, flags, the roteiro table and one log line per transition, so a compaction or a stop never loses the position. The run starts from the middle when the middle is what exists.
+
+Four boundaries hold for the whole run:
+- **The Skill tool is never called.** A stage runs by reading `${CLAUDE_CONFIG_DIR:-$HOME/.claude}/skills/<skill>/SKILL.md` with `Read` (falling back to `skills/<skill>/SKILL.md` in the package tree when this repository is the one running) and following its Flow in place with the stage's arguments. Every skill is locked, this one included; the lock is not worked around, it is honoured by reading the instructions instead of invoking them.
+- **Only this skill follows another skill.** The exception exists because the owner typed the command, and it lasts only for this invocation. No stage started here starts a further `ll-auto`.
+- **No spending ceiling, ever.** Never stop, throttle or shorten a stage to save tokens or money, never announce a budget, never ask whether to continue for cost. The run ends when the roteiro ends, a pause flag says so, or nothing can move without the owner.
+- **No question of its own.** The run never opens `AskUserQuestion`. The only questions the owner sees are the ones a stage asks while running under `--interactive`. When something is missing, the run prints the command that would complete it and stops.
+
+Reply to the owner in Portuguese; every file written is in English.
+
+## Deliverables
+
+| File | Role | Mutability |
+|---|---|---|
+| `docs/AUTO.md` | the run: objective, flags, roteiro table, decisions taken alone, log | rewritten by this skill on every transition; the roteiro rows only through `auto-md` and the log append-only |
+| `docs/research-*/SUMMARY.md`, `docs/decide/`, `PLAN.md`, `ROADMAP.md`, `PROGRESS.md`, `phases/NN/`, `decisions/`, `BACKLOG.md`, `VERIFICATION.md`, `docs/DELIVERY.md` | whatever each stage writes, by the rules of that stage's own skill | owned by the stage skill; this skill writes none of them directly |
+
+## Flow
+
+Helper: `${CLAUDE_SKILL_DIR}/scripts/ll-auto.js`, written `ll-auto.js` below. Read commands exit 0 and answer `{"ok":false,"reason":…}` on a broken input. Commands: `detect`, `roteiro`, `next-cmd`, `report`, `auto-md`.
+
+### 0. State, flags and roteiro
+
+`ll-auto.js detect --json` gives the stage table above; `ll-auto.js roteiro --flags "<the arguments>" --objective "<objective>" --json` turns it into the ordered list of stages to run, with a command and a status per entry. `references/stages.md` holds the detection rules, the command per stage and the flag table.
+
+Three stops before any work:
+- `needs_objective: true` (no research, no `docs/decide/OPENING.md`, no `PLAN.md`, and no objective in the arguments) — print exactly two lines and stop, with no question: `Nada encontrado neste repositório: sem pesquisa, OPENING.md nem PLAN.md.` and the command to complete, `/ll-auto "<objetivo>" [--research] [--brainstorm]`.
+- `--dry-run` — print the stage table from `detect` (one line per stage, as the helper prints it) and the roteiro table, then stop, before writing `docs/AUTO.md`.
+- an empty roteiro with an objective present — say the cycle has nothing left and hand over.
+
+`--resume`, or a plain invocation in a repository that already has `docs/AUTO.md`, reads the flags from that file's `## Flags` section and continues from the first row that is not `done`.
+
+### 1. Open the run
+
+Write `docs/AUTO.md` with `ll-auto.js auto-md --objective "<objective>" --flags "<the arguments>"`, redirected to the file. Print the roteiro table to the owner in one screen: this is the plan of the run and the last moment before it starts.
+
+### 2. One stage at a time
+
+For every roteiro entry, in order:
+1. Mark the row `running` in `docs/AUTO.md` and append the log line `<date> <stage> running`.
+2. Read that stage's `SKILL.md` at the path of boundary 1 and follow its Flow in place, with the entry's command as its arguments. The stage owns its files, its questions and its own ▶ Next line; that line is read, not pasted to the owner, and never starts another skill from here.
+3. Run `ll-auto.js detect --json` again. Mark the row `done` when the stage's own status turned `done`, `half` when it did not, and append the log line with the evidence the helper gives.
+4. List the `decisions/*.md` in state `WAITING` and apply `references/run.md`: without `--auto-decision` skip the stages that depend on them and stop when nothing else can run; with `--auto-decision` resolve each to its recommended option and continue.
+5. When the entry carries `pause_after: true` (`--pause-at`), stop here with `▶ Next — /clear, then ll-auto --resume`.
+
+A stage that fails inside its own skill ends the run at that row, marked with its status and its last line in the log; the roteiro below it stays `todo`.
+
+### 3. Close the run
+
+`ll-auto.js report --json` lists every `decisions/*.md` carrying `[decided by absence — revisable]`. Print that list as the end-of-run block, one line per file with its title, and write the same block into the `## Decisions taken alone` section of `docs/AUTO.md`. Then the count line and the handover. The end block, verbatim, is in `references/run.md`.
+
+## Completion criterion
+
+Every roteiro row is `done`, `skipped` or `waiting` in `docs/AUTO.md`, each with a log line carrying the evidence `detect` gave after the stage; the decisions taken alone are listed both in the conversation and in the file; nothing was decided outside `--auto-decision`; no question was asked by this skill. What the run did not reach is named with the command that would close it.
+The run's last count line, printed and written to `docs/AUTO.md`:
+`stages done X/Y · decisions taken alone N · waiting for the owner K · flags: <the arguments>`
+▶ Next — /clear, then ll-resume
+
+## References
+
+- `references/stages.md` — the detection table, the command per stage and the flag table; step 0.
+- `references/run.md` — the `docs/AUTO.md` template, the WAITING handling and the end-of-run block; steps 1, 2 and 3.