wizz-method 2.18.0 → 2.19.0

package/src/skills-lib/wizz-video-styles/references/styles/ui-morph.md

@@ -0,0 +1,68 @@
+# UI morph: one shape, many UI states (twoclipping, verbove, AnnaCher)
+
+Measured on 6 shorts (en) in: dev / AI / build in public (EN), product / SaaS / marketing / business / law.
+
+## Measured
+
+| Metric | Value |
+|---|---|
+| Reach (views) | max 1,164,424 · median 2,786 |
+| Cuts per 10 s | min 0.0 · median 0.0 · max 0.0 |
+| Median scene length | 17.05 s |
+| Music bed (continuous / faint / none) | 4 / 0 / 2 |
+| Cuts with a sound effect on them | 0/0 |
+
+Cuts come from scene detection (it undercounts overlays and cards); music and SFX from an audio heuristic that classifies type, never names the sound ([../research-method.md](../research-method.md)).
+
+## Material it needs
+
+The product's real screens or a list of 8 to 12 UI states that tell its story (button, loader, player, slider, toggle, tabs, chart, ⌘K, toast), one accent colour and a track around 120 BPM. Nobody on camera, no footage: everything is drawn in code (HyperFrames).
+
+## When it fits
+
+App and SaaS launches, a feature announcement, a product promo for the site or the store page, a portfolio piece. Strong on X and LinkedIn with a product audience; it shows the product working instead of describing it. Weak for teaching step by step or for anything that needs a face.
+
+## Recipe
+
+**Look**
+
+- One shape on screen the whole time, never cut: it becomes button, loader, player, slider, toggle, tabs, chart, ⌘K and toast, changing size, corners and colour (the same language as the iPhone Dynamic Island).
+- Warm light grey canvas (#EDEBE6), components in black and white, at most one accent colour; a dark variant (navy with one yellow) for a product film.
+- Real UI and real data: the product's own labels and numbers, never lorem ipsum or generic components.
+- A cursor drives every change with real clicks and drags; the camera zooms so each state fills the frame.
+
+**Palette:** Warm grey #EDEBE6 or beige #E6E2DA, black #111, white, plus ONE accent (orange, peach or yellow) used only where the eye must go. Dark variant: #0B1020 base, one yellow accent.
+
+**Typography:** One UI sans (Inter, Geist or the product's own font) in regular and semibold; mono only for a URL or a code line. No display fonts.
+
+**Motion**
+
+- Every state grows out of the previous one by a spring (size, corner radius, colour), with at most one small overshoot; content swaps with a short blur.
+- Something happens on every beat; the state changes land on the downbeats of the beat grid (scripts/beat_grid.py), not on a hand-counted 120 BPM.
+- Build it as a pure function of time (seek(t)): closed-form springs, no CSS transitions or timers, so every frame renders the same. HyperFrames does this natively.
+- The last frame equals the first, so the piece loops.
+
+**Captions:** None. The text is the interface's own (button labels, track title, chart numbers). A single short line at most, in the UI font, when the product needs one sentence.
+
+**Hook (0 to 3 s):** The first state already on screen at 0 s (a button or the brand pill) and the cursor arriving on the first beat. No logo intro, no title card.
+
+**CTA:** The shape returns to the first state or closes on the brand pill with the URL in small mono under it, held 1 to 2 s.
+
+**Music:** The track is the whole soundtrack: a continuous bed in 4 of 6 measured pieces, around -14 LUFS. Pick an electronic or lo-fi track with a clear kick so the beat grid is reliable.
+
+**SFX:** Sparse and tied to UI events: a soft click on a press, a low tick on a snap. The measured pieces range from none to a hit on most state changes; never whooshes on every move.
+
+## Do not
+
+- Cutting between screens: the moment it cuts it becomes a screen recording, not this style.
+- Bouncy easing, particles, glow, gradients on the UI chrome, icons with uneven stroke, dead time, template look.
+- Generic components instead of the product's real UI and numbers.
+- Shipping square or 16:9: every measured piece is 1:1 or 16:9; recompose for 9:16 with the shape in the upper-middle and nothing in the bottom 20 %.
+
+## Watch before editing
+
+- [zero](https://x.com/twoclipping/status/2103273003555402193) · 1,164,424 views
+- [Martijn Verbove](https://x.com/verbove/status/2103483957266268381) · 17,438 views
+- [Daniel Haida](https://x.com/daniel_haida/status/2104139720829636937) · 3,968 views
+- [Anna Chernikova](https://x.com/AnnaCher___/status/2103571096549433425) · 1,605 views
+- [Nez](https://x.com/nezbuilds/status/2103487427365294391) · 519 views

package/src/skills-lib/wizz-video-styles/scripts/analyze.sh

@@ -1,12 +1,25 @@
 #!/usr/bin/env bash
-# Measures one public YouTube short: download (720p), cuts (scene detection),
+# Measures one public short: download (720p), cuts (scene detection),
 # audio (music bed, SFX type heuristic, loudness) and a 16-frame contact sheet.
-# Usage: analyze.sh <youtube_id> <out_dir>  →  <out_dir>/<id>.json + <id>-sheet.png
+# Usage: analyze.sh <youtube_id|url> <out_dir>  →  <out_dir>/<id>.json + <id>-sheet.png
+# A URL (an X post, any page yt-dlp reads) is measured the same way; its id is
+# x-<author>-<status> for X and a sanitised slug otherwise (2026-10-15: the
+# code-generated UI pieces of the ui-morph style live on X, not on YouTube).
 # The .mp4 is deleted at the end; read the contact sheet before describing the look.
 set -euo pipefail
-[ $# -eq 2 ] || { echo "uso: analyze.sh <youtube_id> <out_dir>" >&2; exit 2; }
+[ $# -eq 2 ] || { echo "uso: analyze.sh <youtube_id|url> <out_dir>" >&2; exit 2; }
 id="$1"; out="$2"
-[[ "$id" =~ ^[A-Za-z0-9_-]{11}$ ]] || { echo "id inválido: $id" >&2; exit 2; }
+if [[ "$id" =~ ^https?:// ]]; then
+  url="$id"
+  if [[ "$url" =~ (x|twitter)\.com/([A-Za-z0-9_]+)/status/([0-9]+) ]]; then
+    id="x-${BASH_REMATCH[2]}-${BASH_REMATCH[3]}"
+  else
+    id=$(printf '%s' "$url" | sed -E 's#^https?://##; s#[^A-Za-z0-9_-]+#-#g' | cut -c1-60)
+  fi
+else
+  [[ "$id" =~ ^[A-Za-z0-9_-]{11}$ ]] || { echo "id inválido: $id" >&2; exit 2; }
+  url="https://www.youtube.com/shorts/$id"
+fi
 mkdir -p "$out"; cd "$out"
 f="./$id"  # prefixo ./ : ID que começa com hífen não vira opção do ffmpeg
 # .part: a first download that fails (HTTP 403) leaves it behind before the android fallback runs.
@@ -15,12 +28,11 @@ trap 'rm -f "$f.wav" "$f.mp4" "$f".*.part' EXIT
 PY="${VIDEO_STYLES_PY:-python3}"
 "$PY" -c "import librosa, numpy" 2>/dev/null || { echo "precisa de librosa e numpy: pip install librosa numpy (ou VIDEO_STYLES_PY=/caminho/do/python)" >&2; exit 2; }
 for bin in yt-dlp ffmpeg ffprobe; do command -v "$bin" >/dev/null || { echo "falta $bin no PATH" >&2; exit 2; }; done
-url="https://www.youtube.com/shorts/$id"
 fmt="bv*[height<=1280][ext=mp4]+ba[ext=m4a]/b[ext=mp4]/b"
 # When YouTube answers "confirm you're not a bot", the android player client usually still works (no cookies used).
 [ -f "$f.mp4" ] || yt-dlp -q --no-warnings -f "$fmt" --merge-output-format mp4 -o "$f.mp4" "$url" \
   || yt-dlp -q --no-warnings --extractor-args "youtube:player_client=android" -f "$fmt" --merge-output-format mp4 -o "$f.mp4" "$url"
-meta_fmt="%(view_count)s|%(like_count)s|%(channel)s|%(upload_date)s|%(title)s"
+meta_fmt="%(view_count)s|%(like_count)s|%(channel,uploader)s|%(upload_date)s|%(title)s"
 yt-dlp -q --no-warnings --skip-download --print "$meta_fmt" "$url" > "$f.meta" \
   || yt-dlp -q --no-warnings --skip-download --extractor-args "youtube:player_client=android" --print "$meta_fmt" "$url" > "$f.meta" \
   || echo "NA|NA|NA|NA|NA" > "$f.meta"
@@ -32,9 +44,9 @@ lufs=$(ffmpeg -i "$f.mp4" -af ebur128 -f null - 2>&1 | grep -E "^\s+I:" | tail -
 d=$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$f.mp4")
 step=$(python3 -c "print(max(1.0, $d/16))")
 ffmpeg -loglevel error -y -i "$f.mp4" -vf "fps=1/$step,scale=200:-1,tile=8x2" -frames:v 1 "$f-sheet.png"
-"$PY" - "$id" "$lufs" <<'PY'
+"$PY" - "$id" "$lufs" "$url" <<'PY'
 import librosa, numpy as np, json, sys
-id, lufs = sys.argv[1], sys.argv[2]
+id, lufs, url = sys.argv[1], sys.argv[2], sys.argv[3]
 y, sr = librosa.load(f"{id}.wav", sr=22050); dur = len(y)/sr
 cuts = [float(x) for x in open(f"{id}.cuts").read().split()]
 H, P = librosa.effects.hpss(y, margin=2.0)
@@ -58,7 +70,7 @@ on_cut = sum(1 for c in cuts if any(abs(t-c) < 0.15 for t,_ in events))
 shots = np.diff([0]+cuts+[dur]) if dur else np.array([0])
 bed = float(np.percentile(rh,15)/(np.percentile(rh,95)+1e-9))
 meta = open(f"{id}.meta").read().strip().split("|", 4)
-json.dump({"id": id, "url": f"https://www.youtube.com/shorts/{id}", "views": meta[0], "likes": meta[1], "channel": meta[2], "upload_date": meta[3], "title": meta[4],
+json.dump({"id": id, "url": url, "views": meta[0], "likes": meta[1], "channel": meta[2], "upload_date": meta[3], "title": meta[4],
   "duration_s": round(dur,1), "cuts": len(cuts), "cuts_per_10s": round(len(cuts)/dur*10,2), "shot_median_s": round(float(np.median(shots)),2), "shot_mean_s": round(float(shots.mean()),2),
   "music_bed_ratio": round(bed,3), "music_bed_guess": "continua" if bed > 0.13 else ("fraca" if bed > 0.07 else "sem"),
   "sfx_counts": kinds, "sfx_per_10s": round(sum(kinds.values())/dur*10,2), "sfx_on_cuts": f"{on_cut}/{len(cuts)}", "sfx_events": events[:40],

package/src/skills-lib/wizz-video-styles/scripts/references.mjs

@@ -31,6 +31,7 @@ const HISTORY_REL = path.join('_wizz-output', 'video-styles', 'historico.json');
 // tour, macro...) have no entry: a code-generated video is not a reference for them.
 const GENERATED = {
   'tipografia-cinetica': { categories: ['motion', 'explainer', '3d'], match: /lyric|music video|kinetic typograph|\bMV\b/i },
+  'ui-morph': { categories: ['motion', 'explainer', '3d', 'interactive'], match: /UI states|one shape|morph|UI moments|product film|inside the app/i },
   'motion-editorial': { categories: ['motion', 'explainer'], match: /\bUI\b|product|launch|saas|\bapp\b|logo|promo|brand/i },
   'explicador-animado': { categories: ['explainer'], match: /./ },
   'quadro-branco': { categories: ['explainer', 'motion'], match: /whiteboard|hand-drawn|sketch|doodle/i },

package/src/skills-lib/wizz-web-security/SKILL.md

@@ -32,7 +32,7 @@ The ones that show up most in an audit, with the direct fix. Use as a quick tria
 
 > The first four (SQLi, IDOR, mass assignment, and permissive RLS) are **stop-the-line**: if it shows up, fix it before anything else.
 >
-> For a full adversarial audit (hunting with exploit proof + a prioritized plan), use the `security-audit-pentest` skill. This skill here is for **fixing** a specific finding from the table.
+> For a full adversarial audit (hunting with exploit proof + a prioritized plan), use the `wizz-security-audit-pentest` skill. This skill here is for **fixing** a specific finding from the table.
 
 ## References (load on demand)
 

package/tools/fetch-assets.mjs

@@ -39,7 +39,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 
-export const ASSETS_BASE = 'https://wizz-assets.junior-aec.workers.dev';
+export const ASSETS_BASE = 'https://assets.wizzcomms.com';
 
 // Fonte única dos bundles conhecidos. `dest` é relativo ao root do pacote
 // (repo em dev, node_modules/wizz-method quando instalado via npm — a mesma

package/tools/hooks/README.md

@@ -4,29 +4,33 @@ Os hooks do Claude Code usados pelo Wizz Method vivem AQUI e são instalados em
 `~/.claude/hooks/` via `npm run sync:global`. Nunca edite a cópia global direto:
 ela é substituída no próximo sync.
 
-| Hook                            | Evento             | O que faz                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| ------------------------------- | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `wizz-router-enforce.js`        | UserPromptSubmit   | Gate `isTrivial()` + injeção curta: em projeto Wizz (`_wizz/`) manda delegar direto ao maestro/agente da área (sem router); fora, manda pro `wizz-router`.                                                                                                                                                                                                                                                                          |
-| `session-rules.js`              | SessionStart       | Duas coisas num processo só: injeta as regras de comunicação 1x por sessão (antes era por prompt) e resolve a FEATURE ATIVA sozinho (branch git > `_wizz/bmm/config.yaml` > nada), para ninguém precisar invocar `wizz-set-feature`. Branch de tronco e de release não viram feature. Fora de projeto Wizz e sem branch de feature a linha não é emitida (custo zero); dentro de projeto Wizz sem feature sai o lembrete curto "o primeiro pedido nomeado define uma", e sem `layout:` o lembrete de propor um. A feature também é o `tema` da memória.                                                       |
-| `security-defensive-context.js` | PreToolUse (Skill) | Metodologia defensiva/escopada ao invocar skills de segurança. Genérico por projeto (v2).                                                                                                                                                                                                                                                                                                                                           |
-| `wizz-artifact-guard.js`        | PostToolUse (Write) | Avisa (nunca bloqueia) artefato escrito fora da subpasta da feature ativa, artefato de feature sem feature ativa, frontmatter faltando em `<tipo>-<slug>.md`, e arquivo solto na raiz fora do `layout:`, com o comando que move. Fail-open sem `_wizz/` ou config. |
-| `rtk-rewrite.sh`                | PreToolUse (Bash)  | Reescreve comandos de shell via `rtk rewrite` (token economy). Fork local do hook gerado pelo instalador upstream do rtk, com 3 patches (auditoria 2026-07-07, C4/RT1; e 2026-09-11, RT-H3): reescrita linha a linha em comando multi-linha (o binário só reescrevia a 1ª linha), timeout interno por linha (`RTK_HOOK_TIMEOUT`, default 3s) que não depende do `timeout`/`gtimeout` do GNU coreutils, e cache do version-guard (`RTK_CACHE_TTL_SECONDS`, default 1h, em `${XDG_CACHE_HOME:-$HOME/.cache}/wizz/rtk-version`) pra não rodar `rtk --version` a cada `Bash` tool call da sessão. Requer `rtk` + `jq` no PATH; fail-open em ambos (e no cache: ilegível/corrompido/expirado recomputa em silêncio). |
+| Hook                            | Evento                   | O que faz                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| ------------------------------- | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `wizz-router-enforce.js`        | UserPromptSubmit         | Gate `isTrivial()` + injeção curta: em projeto Wizz (`_wizz/`) manda delegar direto ao maestro/agente da área (sem router); fora, manda pro `wizz-router`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `session-rules.js`              | SessionStart             | Duas coisas num processo só: injeta as regras de comunicação 1x por sessão (antes era por prompt) e resolve a FEATURE ATIVA sozinho (branch git > `_wizz/bmm/config.yaml` > nada), para ninguém precisar invocar `wizz-set-feature`. Branch de tronco e de release não viram feature. Fora de projeto Wizz e sem branch de feature a linha não é emitida (custo zero); dentro de projeto Wizz sem feature sai o lembrete curto "o primeiro pedido nomeado define uma", e sem `layout:` o lembrete de propor um. A feature também é o `tema` da memória.                                                                                                                                                         |
+| `security-defensive-context.js` | PreToolUse (Skill)       | Metodologia defensiva/escopada ao invocar skills de segurança. Genérico por projeto (v2).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `wizz-artifact-guard.js`        | PostToolUse (Write/Edit) | Avisa (nunca bloqueia) artefato escrito fora da subpasta da feature ativa, artefato de feature sem feature ativa, frontmatter faltando em `<tipo>-<slug>.md`, e arquivo solto na raiz fora do `layout:`, com o comando que move. Fail-open sem `_wizz/` ou config.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `wizz-close-reminder.js`        | Stop                     | Aviso ao usuário (`systemMessage`, nunca `decision: block`) quando a feature ativa está `implementado`/`no-ar` e o checklist de fechamento do `wizz-feature.js` tem pendência (ou está no ar e segue ativa). Sem subprocesso, sai cedo fora de projeto Wizz e com feature em andamento, não repete o mesmo aviso na sessão, fail-open.                                                                                                                                                                                                                                                                                                                                                                          |
+| `rtk-rewrite.sh`                | PreToolUse (Bash)        | Reescreve comandos de shell via `rtk rewrite` (token economy). Fork local do hook gerado pelo instalador upstream do rtk, com 3 patches (auditoria 2026-07-07, C4/RT1; e 2026-09-11, RT-H3): reescrita linha a linha em comando multi-linha (o binário só reescrevia a 1ª linha), timeout interno por linha (`RTK_HOOK_TIMEOUT`, default 3s) que não depende do `timeout`/`gtimeout` do GNU coreutils, e cache do version-guard (`RTK_CACHE_TTL_SECONDS`, default 1h, em `${XDG_CACHE_HOME:-$HOME/.cache}/wizz/rtk-version`) pra não rodar `rtk --version` a cada `Bash` tool call da sessão. Requer `rtk` + `jq` no PATH; fail-open em ambos (e no cache: ilegível/corrompido/expirado recomputa em silêncio). |
+| `rtk-rewrite.js`                | PreToolUse (Bash)        | Versão Node do `rtk-rewrite.sh`, registrada no lugar dele só no Windows (sem bash e jq garantidos lá), desde 2026-10-15. Mesmo contrato: guard de multi-linha, linha a linha, timeout por linha, piso 0.23.0, fail-open. Sem o cache de versão. `node test/test-rtk-hook-node.js` exige a mesma saída dos dois contra o mesmo `rtk` fake. |
 
 Arquivos de apoio (copiados junto, NUNCA registrados em settings.json; o doctor cobra a presença):
 
-| Arquivo | O que é |
-| --- | --- |
-| `wizz-feature-lib.js` | Funções puras de feature, git, config, pastas de artefato e frontmatter. Usada por todos os hooks acima. |
-| `wizz-layout-lib.js` | O que pode ficar na raiz e para onde vai o resto (tipos `codigo`, `scripts`, `dados`, `docs`, `midia`, `arquivo`). |
-| `wizz-feature.js` | CLI do ciclo de vida da feature: `resolver`, `definir`, `artefato`, `decidir`, `status`, `verificar`, `encerrar`, `listar`. É o passo verificável que router/maestro rodam antes de despachar. |
-| `wizz-arrumar.js` | CLI de arrumação: `layout [--gravar]`, `planejar`, `aplicar` (manifesto .tsv + referências + testes antes/depois + `desfazer.sh`), `mover`, `desfazer`. |
+| Arquivo               | O que é                                                                                                                                                                                                                                                                                                                       |
+| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `wizz-feature-lib.js` | Funções puras de feature, git, config, pastas de artefato e frontmatter. Usada por todos os hooks acima.                                                                                                                                                                                                                      |
+| `wizz-layout-lib.js`  | O que pode ficar na raiz e para onde vai o resto (tipos `codigo`, `scripts`, `dados`, `docs`, `midia`, `arquivo`).                                                                                                                                                                                                            |
+| `wizz-cerebro-lib.js` | Grava o fechamento no Cérebro (`encerrar --cerebro`): acha o vault e `projetos/<projeto>.md`, atualiza a linha da feature e a `Última sessão` do bloco Estado e põe 1 linha em Sessões (teto 15; as antigas vão para `_index/cerebro-archive.md`, lido só por grep). Idempotente, fail-open.                                  |
+| `wizz-debug-lib.js`   | Diagnóstico opt-in dos hooks: com `WIZZ_DEBUG=1` cada erro engolido vira 1 linha em stderr e é anexada a `~/.claude/wizz-debug.log` (`WIZZ_DEBUG_FILE` troca o caminho). Sem a variável: zero saída, zero disco. Os hooks seguem fail-open (exit 0). O `wizz doctor` roda cada hook com esse modo ligado (check `hooks-run`). |
+| `wizz-feature.js`     | CLI do ciclo de vida da feature: `resolver`, `definir`, `artefato`, `decidir`, `status`, `verificar`, `encerrar [--cerebro]`, `listar`. É o passo verificável que router/maestro rodam antes de despachar.                                                                                                                    |
+| `wizz-arrumar.js`     | CLI de arrumação: `layout [--gravar]`, `planejar`, `aplicar` (manifesto .tsv + referências + testes antes/depois + `desfazer.sh`), `mover`, `desfazer`.                                                                                                                                                                       |
 
 Regra completa em `src/modules/wizz/_shared/organizacao.md` (2026-10-02, caso Spider). `session-rules.js` passou a lembrar "nenhuma feature ativa" e "projeto sem layout" dentro de projeto Wizz, e `wizz-router-enforce.js` acrescenta 1 linha de feature por prompt em projeto Wizz.
 
 Removidos em 2026-07 (arquivados em `~/.claude/hooks-archive/`):
 `no-narration-enforce.js` (absorvido pelo session-rules) e `vault-reminder.js`.
 
-Testes: `npm run test:organizacao` (CLIs de feature e arrumação, guard, lembretes nos cenários sem git / main / branch), `npm run eval:feature` (hooks reais + CLI + estado final; `--llm` mede a obediência do modelo), `npm run test:hooks` (isTrivial + contexto por modo), `npm run test:feature-context` (resolução da feature ativa: tronco não vira feature, branch ganha do config, silêncio quando não há feature) e `node test/test-rtk-hook.js` (rewrite básico + multi-linha do `rtk-rewrite.sh`, smoke test que exercita o binário `rtk` real quando disponível, e o cache do version-guard: criado na 1ª chamada e reusado na 2ª, TTL expirado força recompute, path do binário mudou invalida, cache corrompido não quebra e se auto-cura).
+Testes: `node test/test-feature-close.js` (`encerrar --cerebro` e o lembrete do Stop), `npm run test:organizacao` (CLIs de feature e arrumação, guard, lembretes nos cenários sem git / main / branch), `npm run eval:feature` (hooks reais + CLI + estado final; `--llm` mede a obediência do modelo), `npm run test:hooks` (isTrivial + contexto por modo), `npm run test:feature-context` (resolução da feature ativa: tronco não vira feature, branch ganha do config, silêncio quando não há feature) e `node test/test-rtk-hook.js` (rewrite básico + multi-linha do `rtk-rewrite.sh`, smoke test que exercita o binário `rtk` real quando disponível, e o cache do version-guard: criado na 1ª chamada e reusado na 2ª, TTL expirado força recompute, path do binário mudou invalida, cache corrompido não quebra e se auto-cura).
 Evals de roteamento: `node evals/routing/run-routing-eval.mjs [--llm]`.
 
 Drift repo ↔ global: `npm run sync:check` compara hash de cada hook (e skill) entre o repo e `~/.claude`, sem escrever nada — é lembrete (fail-open), não gate; roda no fim do `npm test`. Achou drift? `npm run sync:global` atualiza `~/.claude`.

package/tools/hooks/rtk-rewrite.js

@@ -0,0 +1,95 @@
+// rtk-rewrite.js — PreToolUse (Bash): reescreve o comando via `rtk rewrite`.
+//
+// Versão Node do rtk-rewrite.sh para o Windows (2026-10-15), onde não há bash
+// nem jq garantidos. O installer registra este arquivo em win32 e o .sh nos
+// outros sistemas (hooks-settings.js), então o comportamento tem de ser o
+// mesmo; test/test-rtk-hook-node.js roda os dois contra o mesmo rtk fake.
+//
+// Mesmo contrato do .sh:
+//   - sem rtk no PATH, ou rtk abaixo de 0.23.0: sai 0 sem tocar o comando;
+//   - comando multi-linha com heredoc, continuação `\` ou aspas abertas numa
+//     linha passa intacto (reescrever corromperia o corpo do heredoc);
+//   - cada linha vai sozinha para `rtk rewrite`, com timeout (RTK_HOOK_TIMEOUT,
+//     3 s); exit 0 ou 3 com saída = linha nova, qualquer outra coisa = original;
+//   - nada mudou: stdout vazio. Mudou: hookSpecificOutput com updatedInput.
+// Fail-open em tudo: erro aqui nunca bloqueia o Bash.
+//
+// Sem o cache de versão do .sh: `rtk --version` de um binário nativo custa
+// poucos ms, e no Windows não há `command -v` para chavear o cache pelo path.
+
+const { spawnSync } = require('node:child_process');
+
+const TIMEOUT_MS = (Number(process.env.RTK_HOOK_TIMEOUT) || 3) * 1000;
+const FLOOR = [0, 23];
+
+function rtkVersionOk() {
+  const res = spawnSync('rtk', ['--version'], { encoding: 'utf8', timeout: TIMEOUT_MS, windowsHide: true });
+  if (res.error || res.status !== 0) {
+    process.stderr.write('[rtk] WARNING: rtk is not installed or not in PATH. Hook cannot rewrite commands.\n');
+    return false;
+  }
+  const match = /v?(\d+)\.(\d+)\.(\d+)/.exec(res.stdout || '');
+  if (!match) return true;
+  const [major, minor] = [Number(match[1]), Number(match[2])];
+  if (major === FLOOR[0] && minor < FLOOR[1]) {
+    process.stderr.write(
+      `[rtk] WARNING: rtk ${match[1]}.${match[2]}.${match[3]} is too old (need >= 0.23.0). Upgrade: cargo install rtk\n`,
+    );
+    return false;
+  }
+  return true;
+}
+
+// Heredoc, continuação ou aspas desbalanceadas numa linha: não dá para
+// reescrever linha a linha sem quebrar o comando.
+function multilineUnsafe(cmd) {
+  if (cmd.includes('<<')) return true;
+  return cmd.split('\n').some((line) => {
+    if (line.endsWith('\\')) return true;
+    const count = (ch) => line.split(ch).length - 1;
+    return count('"') % 2 !== 0 || count("'") % 2 !== 0;
+  });
+}
+
+function rewriteOne(line) {
+  if (!line) return line;
+  const res = spawnSync('rtk', ['rewrite', line], { encoding: 'utf8', timeout: TIMEOUT_MS, windowsHide: true });
+  // Como o $(...) do .sh: a saída perde só as quebras de linha do fim.
+  const out = (res.stdout || '').replace(/\n+$/, '');
+  return !res.error && (res.status === 0 || res.status === 3) && out ? out : line;
+}
+
+function main(raw) {
+  const input = JSON.parse(raw);
+  const toolInput = input && typeof input.tool_input === 'object' && input.tool_input ? input.tool_input : {};
+  const cmd = typeof toolInput.command === 'string' ? toolInput.command : '';
+  if (!cmd) return;
+  if (cmd.includes('\n') && multilineUnsafe(cmd)) return;
+  if (!rtkVersionOk()) return;
+
+  const rewritten = cmd.includes('\n') ? cmd.split('\n').map(rewriteOne).join('\n') : rewriteOne(cmd);
+  if (rewritten === cmd) return;
+
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'allow',
+        permissionDecisionReason: 'RTK auto-rewrite',
+        updatedInput: { ...toolInput, command: rewritten },
+      },
+    }) + '\n',
+  );
+}
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => (raw += chunk));
+process.stdin.on('end', () => {
+  try {
+    main(raw);
+  } catch {
+    // fail-open: JSON quebrado ou erro inesperado deixa o comando como veio
+  }
+  process.exit(0);
+});

package/tools/hooks/security-defensive-context.js

@@ -28,6 +28,21 @@ const SECURITY_SKILLS = new Set([
   'code-review:code-review',
 ]);
 
+// Diagnóstico opt-in (WIZZ_DEBUG=1). Lib ausente numa cópia parcial: ainda avisa em stderr.
+let debug = (hook, phase, err) => {
+  if (process.env.WIZZ_DEBUG !== '1') return;
+  try {
+    process.stderr.write(`[wizz-debug] ${hook} ${phase}: ${(err && err.message) || err}\n`);
+  } catch {
+    // stderr fechado
+  }
+};
+try {
+  ({ debug } = require('./wizz-debug-lib.js'));
+} catch (error) {
+  debug('security-defensive-context', 'require wizz-debug-lib', error);
+}
+
 const DEFENSIVE_CONTEXT =
   'Metodologia de revisao de seguranca (defensiva, escopada):\n\n' +
   '1. ESCOPO: trabalhe por arquivo ou dimensao concreta de cada vez (ex: validacao ' +
@@ -63,8 +78,9 @@ process.stdin.on('end', () => {
       );
     }
     // Para qualquer outra skill/tool: sai silenciosamente sem output
-  } catch {
+  } catch (error) {
     // Parse error: sai silenciosamente, nao bloqueia nada
+    debug('security-defensive-context', 'parse payload', error);
   }
   process.exit(0);
 });

package/tools/hooks/session-rules.js

@@ -45,11 +45,27 @@ const RULES =
 // Feature, git e config moram em wizz-feature-lib.js (mesma pasta: o installer
 // e o sync:global copiam tools/hooks/ inteiro). Se a lib faltar numa cópia
 // manual parcial, a regra de comunicação continua saindo e a feature cala.
+// Diagnóstico opt-in (WIZZ_DEBUG=1). Lib ausente numa cópia parcial: ainda avisa em stderr.
+let debug = (hook, phase, err) => {
+  if (process.env.WIZZ_DEBUG !== '1') return;
+  try {
+    process.stderr.write(`[wizz-debug] ${hook} ${phase}: ${(err && err.message) || err}\n`);
+  } catch {
+    // stderr fechado
+  }
+};
+try {
+  ({ debug } = require('./wizz-debug-lib.js'));
+} catch (error) {
+  debug('session-rules', 'require wizz-debug-lib', error);
+}
+
 let lib = null;
 try {
   lib = require('./wizz-feature-lib.js');
-} catch {
+} catch (error) {
   lib = null;
+  debug('session-rules', 'require wizz-feature-lib', error);
 }
 
 const HOOK_CMD = 'node _wizz/hooks/wizz-feature.js';
@@ -246,22 +262,25 @@ function finish(raw) {
   try {
     const payload = JSON.parse(raw || '{}');
     if (payload && typeof payload.cwd === 'string' && payload.cwd) cwd = payload.cwd;
-  } catch {
+  } catch (error) {
     // payload ausente ou inválido: cai no cwd do processo
+    debug('session-rules', 'parse payload', error);
   }
 
   try {
     const feature = buildFeatureContext(cwd);
     if (feature) context += `\n\n${feature}`;
-  } catch {
+  } catch (error) {
     // resolução de feature NUNCA derruba as regras de comunicação
+    debug('session-rules', 'buildFeatureContext', error);
   }
 
   try {
     const ceiling = buildMemoryCeilingContext(cwd);
     if (ceiling) context += `\n\n${ceiling}`;
-  } catch {
+  } catch (error) {
     // teto da memória é aviso, não gate: erro aqui não afeta o resto
+    debug('session-rules', 'buildMemoryCeilingContext', error);
   }
 
   try {
@@ -273,8 +292,9 @@ function finish(raw) {
         },
       }),
     );
-  } catch {
+  } catch (error) {
     // nunca bloquear
+    debug('session-rules', 'write stdout', error);
   }
   process.exit(0);
 }

package/tools/hooks/wizz-arrumar.js

@@ -14,8 +14,10 @@
 //   mover <origem> <destino> atalho de um arquivo (manifesto de uma linha + aplicar)
 //   desfazer <pasta-da-arrumacao>
 //
-// Opções de aplicar/mover: --testes "<comando>", --refs <dir,dir> (ex.: pasta
-// da auto-memória), --manter (não desfaz sozinho se os testes quebrarem).
+// Opções de aplicar/mover: --testes "<comando>" (só runner conhecido: npm/pnpm/
+// yarn/bun test, npx vitest|jest, pytest, go/cargo/make test; sem valor = script
+// test do package.json; outro comando exige --testes-livre), --refs <dir,dir>
+// (ex.: pasta da auto-memória), --manter (não desfaz sozinho se os testes quebrarem).
 // Cada execução fica em `<arquivo>/arrumacao/<data>-<hora>/`.
 
 const fs = require('node:fs');
@@ -76,7 +78,7 @@ function parseArgs(argv) {
     if (a.startsWith('--')) {
       const key = a.slice(2);
       const next = argv[i + 1];
-      if (next !== undefined && !next.startsWith('--')) {
+      if (key !== 'testes-livre' && next !== undefined && !next.startsWith('--')) {
         opts[key] = next;
         i++;
       } else opts[key] = true;
@@ -237,17 +239,116 @@ function rewriteRefs(text, moves, fileDir) {
 
 // ── aplicar / desfazer ──────────────────────────────────────────────────
 
-function runTests(root, cmd) {
-  if (!cmd || cmd === true) return null;
-  const r = spawnSync(cmd, { cwd: root, shell: true, encoding: 'utf8', timeout: 10 * 60 * 1000 });
-  return { ok: r.status === 0, code: r.status, tail: `${r.stdout || ''}${r.stderr || ''}`.trim().split('\n').slice(-5).join('\n') };
+// ── comando de testes: allowlist, sem shell ─────────────────────────────
+//
+// `--testes` não executa string arbitrária: o comando é cortado em argv (sem
+// shell) e só roda se for de um runner conhecido. `--testes` sem valor usa o
+// script `test` do package.json. Qualquer outra coisa exige `--testes-livre`,
+// que imprime o que vai rodar e usa o shell (o dono assumiu o comando).
+
+const SHELL_META = /[;&|<>$`()\n\r\\]/;
+const PM = new Set(['npm', 'pnpm', 'yarn', 'bun']);
+const TEST_SCRIPT = /^test(?:[:\w.-]*)$/;
+
+/** Corta em argv respeitando aspas simples/duplas. null = não dá para cortar com segurança. */
+function splitArgv(text) {
+  if (SHELL_META.test(text)) return null;
+  const argv = [];
+  let cur = '';
+  let quote = '';
+  let has = false;
+  for (const ch of text) {
+    if (quote) {
+      if (ch === quote) quote = '';
+      else cur += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+      has = true;
+    } else if (/\s/.test(ch)) {
+      if (has || cur) argv.push(cur);
+      cur = '';
+      has = false;
+    } else {
+      cur += ch;
+      has = true;
+    }
+  }
+  if (quote) return null;
+  if (has || cur) argv.push(cur);
+  return argv;
+}
+
+/** O argv é de um runner de testes conhecido? */
+function isAllowedTestArgv(argv) {
+  const [bin, a, b] = argv;
+  if (!bin) return false;
+  if (PM.has(bin)) return a === 'test' || (a === 'run' && TEST_SCRIPT.test(b || ''));
+  if (bin === 'npx') return a === 'vitest' || a === 'jest';
+  if (bin === 'pytest') return true;
+  if (bin === 'python' || bin === 'python3') return a === '-m' && (b === 'pytest' || b === 'unittest');
+  if (bin === 'go' || bin === 'cargo' || bin === 'make') return a === 'test';
+  return false;
+}
+
+/**
+ * Resolve o que `--testes` vai rodar.
+ * @returns {{none: true}|{argv: string[], shell: false, display: string}|{shellCmd: string, shell: true, display: string}|{error: string}}
+ */
+function resolveTestCommand(root, opts) {
+  const raw = opts.testes;
+  if (!raw) return { none: true };
+  let text = raw;
+  if (raw === true) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+      if (!pkg.scripts || typeof pkg.scripts.test !== 'string') throw new Error('sem script test');
+    } catch {
+      return {
+        error: '--testes sem comando pede o script "test" do package.json, e ele não existe aqui. Passe o comando ou use --testes-livre.',
+      };
+    }
+    text = 'npm test';
+  }
+  const argv = splitArgv(text);
+  if (argv && isAllowedTestArgv(argv)) return { argv, shell: false, display: argv.join(' ') };
+  if (opts['testes-livre']) return { shellCmd: text, shell: true, display: text };
+  return {
+    error:
+      `Comando de testes fora da lista: "${text}". Aceitos: npm/pnpm/yarn/bun test ou run test*, npx vitest|jest, pytest, ` +
+      'python -m pytest|unittest, go test, cargo test, make test (sem ; & | < > $ ` ou parênteses). ' +
+      'Para rodar outro comando, repita com --testes-livre.',
+  };
+}
+
+function runTests(root, resolved) {
+  if (!resolved || resolved.none) return null;
+  process.stderr.write(`Rodando testes${resolved.shell ? ' (livre, via shell)' : ''}: ${resolved.display}\n`);
+  const timeout = 10 * 60 * 1000;
+  const r = resolved.shell
+    ? spawnSync(resolved.shellCmd, { cwd: root, shell: true, encoding: 'utf8', timeout })
+    : spawnSync(resolved.argv[0], resolved.argv.slice(1), { cwd: root, shell: false, encoding: 'utf8', timeout });
+  const out = `${r.stdout || ''}${r.stderr || ''}${r.error ? r.error.message : ''}`;
+  return { ok: r.status === 0, code: r.status, tail: out.trim().split('\n').slice(-5).join('\n') };
 }
 
 function shQuote(s) {
   return `'${String(s).replaceAll("'", String.raw`'\''`)}'`;
 }
 
-function writeUndoScript(runDir, root, moves, edits) {
+// Desfazer em qualquer sistema: `node wizz-arrumar.js desfazer <pasta>` (Node
+// puro, função undo abaixo). O script ao lado é atalho: desfazer.sh fora do
+// Windows; no Windows, sem bash garantido, um desfazer.cmd que chama o Node.
+function undoCommand(root, runDir) {
+  const q = (p) => `"${p}"`;
+  return `node ${q(__filename)} desfazer ${q(path.relative(root, runDir))}`;
+}
+
+function writeUndoScript(runDir, root, moves, edits, platform = process.platform) {
+  if (platform === 'win32') {
+    const file = path.join(runDir, 'desfazer.cmd');
+    fs.writeFileSync(file, ['@echo off', `cd /d "${root}"`, undoCommand(root, runDir), ''].join('\r\n'));
+    return file;
+  }
   const lines = [
     '#!/usr/bin/env bash',
     `# Desfaz a arrumação de ${path.basename(runDir)}: restaura os arquivos editados e devolve os moves.`,
@@ -305,12 +406,14 @@ function applyMoves(root, moves, opts) {
   const config = lib.readConfig(root);
   const problems = validateMoves(root, moves);
   if (problems.length > 0) return { ok: false, code: 2, line: `Nada foi movido: ${problems.join('; ')}.` };
+  const testCommand = resolveTestCommand(root, opts);
+  if (testCommand.error) return { ok: false, code: 2, line: `Nada foi movido: ${testCommand.error}` };
 
   const runDir = path.join(archiveDir(root, config.layout), stamp());
   fs.mkdirSync(runDir, { recursive: true });
   writeManifest(path.join(runDir, 'manifesto.tsv'), moves);
 
-  const before = runTests(root, opts.testes);
+  const before = runTests(root, testCommand);
 
   // Referências: projeto inteiro + pastas extras (auto-memória, Cérebro).
   const extra = typeof opts.refs === 'string' ? opts.refs.split(',').map((d) => path.resolve(root, d.trim())) : [];
@@ -348,7 +451,7 @@ function applyMoves(root, moves, opts) {
     fs.renameSync(path.join(root, m.origem), to);
   }
   const undoFile = writeUndoScript(runDir, root, moves, edits);
-  const after = runTests(root, opts.testes);
+  const after = runTests(root, testCommand);
   const relRun = path.relative(root, runDir);
 
   if (before && after && before.ok && !after.ok && !opts.manter) {
@@ -365,7 +468,7 @@ function applyMoves(root, moves, opts) {
   return {
     ok: !after || after.ok || !before?.ok,
     code: 0,
-    line: `Movi ${moves.length} arquivo(s) e atualizei referências em ${edits.length}.${testes} Desfazer: ${path.relative(root, undoFile)}.`,
+    line: `Movi ${moves.length} arquivo(s) e atualizei referências em ${edits.length}.${testes} Desfazer: ${undoCommand(root, runDir)} (ou ${path.relative(root, undoFile)}).`,
   };
 }
 
@@ -415,4 +518,15 @@ if (require.main === module) {
   process.exit(result.code ?? (result.ok ? 0 : 1));
 }
 
-module.exports = { run, rewriteRefs, readManifest, planMoves, undo };
+module.exports = {
+  run,
+  splitArgv,
+  isAllowedTestArgv,
+  resolveTestCommand,
+  rewriteRefs,
+  readManifest,
+  planMoves,
+  undo,
+  writeUndoScript,
+  undoCommand,
+};