Merge release/1.2.1 into main

chore(release): 1.2.1 — version.txt + CHANGELOG
chore(memory): journal — v1.2.0 cut + doc pass
2026-07-20 14:34:09 +02:00 · 2026-07-20 14:32:50 +02:00 · 2026-07-20 14:24:39 +02:00 · 2026-07-20 14:24:11 +02:00 · 2026-07-20 14:21:24 +02:00 · 2026-07-20 14:07:28 +02:00
110 changed files with 11043 additions and 2254 deletions
@@ -36,6 +36,7 @@ rules:
 | BLK-014 | 2026-07-01 | `make install` aborts npm EEXIST on `~/.local/bin/claude` when claude already installed via native installer — no presence guard | resolved |
 | BLK-015 | 2026-07-03 | `gitflow_finish` ignored its `<type> <name>` args → merged the CHECKED-OUT branch not the one named → wrong-branch merge (audit LOT3) | resolved |
 | BLK-016 | 2026-07-04 | rtk compression PATH-dead 30 days — 6/5070 Bash commands compressed (~460K tokens missed); installer sources cargo env so its own check passes, Claude tool shell never gets ~/.cargo/bin | resolved |
 | BLK-017 | 2026-07-17 | Bing Webmaster API unusable for a multi-client agency: OAuth swamp (localhost redirect refused, rotated single-use refresh tokens race our parallel dispatch), API key = wrong model (client-owned sites) | open/deferred |
 ---
@@ -201,3 +202,9 @@ rules:
 - **Status**: resolved.
 - **Reference**: lesson: a PATH-dependent hook must be verified in the TARGET shell, not the installer's (installer sourcing envs lies to its own checks); usage is MEASURED (`rtk discover`), never assumed. Corroborates [[LRN-047]] (silent degradation → measure) + [[LRN-036]] (hand-managed profile drift); guard interplay [[LRN-089]]-adjacent (ambient-state assumptions).
 - **backmerge**: entry from release/1.0.0 (2b4e7401); the fix `e58037c` was ALSO missing from develop (rtk was live-broken on develop) — ported to develop 2026-07-08 (review remediation A3, commit follows) so this "resolved" is now true on develop too.
 ## BLK-017 — Bing Webmaster API unusable for a multi-client agency (W2 deferred) — 2026-07-17
 - **Friction**: W2 (`bing` verb — free Bing query stats + index status + first-party backlinks) abandoned after 4 challenge rounds. User's model = client sites live on CLIENT Bing accounts.
 - **Real cause**: two viable-looking paths, both dead. (API KEY) is per-user not per-site (docs), but IS the account identity → one key per client account, exactly what the user feared; non-scoped, no expiry, passed in query string. (OAuth) is the right delegation model (like GSC) but a swamp: Redirect URI rejects ALL local forms (http/https/127.0.0.1 — user-tested); refresh tokens are ROTATED + single-use, self-described non-compliant with OAuth 2.0 → store rewrite every call, AND our parallel seo‖geo dispatch would race the rotation → `invalid_grant` + dead token; undocumented "Could not extract expected anti-forgery token" on refresh, unanswered on MS Q&A; docs contradict themselves on grant_type + token endpoint; no library. MS's own advisor recommends falling back to the API key.
 - **Verified live**: the Webmaster API itself is ALIVE (`GetUserSites?apikey=INVALID` → HTTP 400 `{"ErrorCode":3,"Message":"InvalidApiKey"}`, 0.4s) — distinct from Bing SEARCH API (retired 2025-08-11). So the block is auth/model, not availability.
 - **Status**: open/deferred. REVIVAL: a client already on Bing adds the user as Read-Only → test in ~10 min whether one API key sees DELEGATED sites (undocumented, nobody knows). If yes → W2 is cheap+clean (one key, client-owned verification, revocable, read-only, zero OAuth). Value RAISED by [[BDR-071]]: GetUrlLinks is now the only free viable backlink source (first-party only).
@@ -86,6 +86,11 @@ rules:
 | BDR-063 | 2026-07-10 | GSC multi-account: OAuth2 installed-app flow + label-keyed token store, explicit (account,property) args, no global state | accepted |
 | BDR-064 | 2026-07-14 | global memory split: repo file → CLAUDE.global.md (deployed name unchanged), CLAUDE.md freed for project scope; consumer/maintainer wording rule | accepted |
 | BDR-065 | 2026-07-14 | transient planning artifacts (superpowers spec/plan): committed during run, deleted post-merge; git history = archive; codified in project CLAUDE.md | accepted |
 | BDR-066 | 2026-07-15 | Model routing: reflection inline (session big model) + sonnet-pinned executors + blocking gate | accepted |
 | BDR-070 | 2026-07-17 | claude-seo: cherry-pick scripts into our tree, never install; /seo stays sole entry | accepted |
 | BDR-071 | 2026-07-17 | No viable free backlink source → Off-page axis stays brand-mentions-only (FINAL, not placeholder) | accepted |
 | BDR-072 | 2026-07-17 | SPA: honest refuse (On-page N/A, not zero), no headless browser (R2 over R1) | accepted |
 | BDR-073 | 2026-07-17 | Scoring: LLM judges findings+severity, engine does the arithmetic (deterministic /20) | accepted |
 ---
@@ -975,3 +980,88 @@ rules:
 - **Why**: user call 2026-07-14 — registries already capture decisions; a stale plan describes a superseded intermediate state and misleads future readers; accumulation pollutes the repo. Precedent: gsc-crux cleanup (8a1fac0, 2026-07-10) did the same — this makes it law, not habit.
 - **Alternatives rejected**: never-commit (gitignore docs/superpowers) — breaks mid-run: briefs, reviewers, other-machine checkouts need the files; superpowers brainstorming commits the spec by convention. Keep-forever — the drift + pollution complained about.
 - **Reference**: project CLAUDE.md; cleanup commit this chore; precedent 8a1fac0. Linked [[BDR-064]], [[LRN-124]].
 ---
 ## BDR-066 — Model routing: reflection inline (session big model), executors pinned sonnet, blocking gate
 - **Date**: 2026-07-15
 - **Status**: accepted (partial supersede of BDR-050: /feat dev no longer inline; bugfix/hotfix dev-inline CONSERVED)
 - **Decision**: reflection (brainstorm, plan, contract, audit judgment, loop decisions) runs on session model (Fable; Opus fallback) — inline or inherit subagents, never pinned down. Execution (code from closed plan, fix-bundle application) runs sonnet-pinned subagents: feater + hotfixer pinned sonnet; SDD implementation+review subagents dispatched `model: "sonnet"` (ship-feature/init-project); web-validate fixes via hotfixer L1 (was inline Edit). analyzer haiku pin REMOVED (digest feeds plan = reflection tier). verifier + security-auditor STAY sonnet (job9 confirmed — procedural gates, ≤3×/loop). Blocking gate `lib/model-gate.md` (self-check + witness `lib/model-check.sh`) wired in 12 reflection orchestrators; small → STOP, unknown → fail-visible; census guard `lib/tests/model-routing.test.sh` flip-tested.
 - **Why**: big-model quota burned on mechanical execution (Fable exhausted mid-job8); plan closed at dispatch → executor needs obedience not judgment; fresh sonnet gates catch executor drift.
 - **Alternatives rejected**: opus pins on audit agents (session-independent) — rejected: session assumed big + blocking gate as backstop, one tier fewer; advisory gate — rejected by user, blocking; split bugfix/hotfix too — rejected: bugfix investigation interleaved w/ fix, hotfix gain marginal vs dispatch overhead.
 - **Caveats**: client-handover-writer conversion (inline-load → sonnet dispatch, 11 human-gate sites to relocate) DEFERRED to own plan — its opus pin stays inert meanwhile; feater cannot ask → NEED-DECISION report = escalation valve, plan must close decisions; witness reads settings.json — lags `--model`-launched sessions (self-check compensates).
 - **Caveat (execution)**: /feat re-arch broke 5 stale assertions in lib/tests/loops-light.test.sh (locked OLD feater architecture) — repointed to skills/feat/SKILL.md (FSK, mirrors HOT/HSK split) + new dispatch lock + 1-line reflow in feat SKILL for single-line grep lock (LRN-093 class).
 - **Wave 2 (2026-07-15, user directive)**: wave-1 exclusion list left execution running on the big session model = the waste this split kills. REVERSES the "split hotfix rejected" alternative above (reason held for bugfix — investigation interleaved w/ fix — but NOT hotfix: LOCATE→apply is linear/separable). Changes: /hotfix split like /feat (LOCATE reflection inline + MODEL GATE, hotfixer sonnet EXECUTOR — rewritten dual-use: also the seo/geo/web-validate L1 applier; revert-not-loop preserved) → hotfix JOINS gated group, census 12→13. /commit-change dispatches sonnet commit-changer (propose→dispatcher gates→apply; grouping ON sonnet so NO model gate; AskUserQuestion dropped from agent). /release-candidate dispatches new sonnet release-executor (2 spans prep/finish; when-to-release + push + version-number decision STAY in dispatcher). /doc → doc-syncer (sonnet) dispatch; /status → status-reporter (kept HAIKU — right tier for read-only collection; win = off big model, not the tier). Gate exclusion list now = commit-change/doc/status/release-candidate. Consumer-staleness swept (LRN-113): feat Rule 1 DOWNGRADE + feat commit-split both repointed off the bare executor agents to the /hotfix + /commit-change skills.
 - **Wave 3 (2026-07-15/16, user directive)**: split the last two inline execution-carrying agents like /feat. /bugfix: investigation+diagnosis+contract inline behind the gate; bugfixer = sonnet EXECUTOR (fix + regression test from a closed FIX PLAN; no Agent/AskUserQuestion; BUGFIX-EXEC REPORT). verify+secure loop stays in main loop, executor = its re-dispatched dev (verify-secure-loop.md intro now: BOTH consumers dispatched, no inline branch). FINISHES reversing the "split bugfix rejected" carve-out (hotfix went wave 2, bugfix now) — investigation↔fix coupling accepted, mitigated by structured DIAGNOSIS + verify loop. /code-clean: PHASE-1 audit + validation gate inline (reflection); code-cleaner = sonnet PHASE-2 EXECUTOR (delete approved dead code, inline-load refactorer, re-audit) — refactor NOW on sonnet (inline-load pin was inert on big model). exported-symbol per-item consent stays AT THE GATE. Consumer-staleness swept: hotfix deeper-bug escalation → /bugfix skill (not bare agent); onboard STEP 6 + tour Phase B read-only-audit → general-purpose/analyzer (big model, NEVER the sonnet executor — audit stays big). Both skills STAY gated. Also: Explore built-in kept inheriting session (search feeds reflection = big deserved; custom sonnet override created then reverted — built-in already inherits + no owned prompt). census 36→42, loops-light repointed 35/0.
 - **Wave 4 (2026-07-16)**: client-handover doc-gen → sonnet, REDACTION-ONLY (user flipped from whole-writer after the full read). Key finding: nested audits (/seo,/harden,/web-validate — gated wave 1) must run BIG either way → whole-writer = ~7 extra gate-yields + resumable state machine on a CLIENT deliverable for ~0 extra sonnet work. Design: client-handover-writer TRIMMED to ship pipeline (STEP 1-8, all interactive gates native on big, nested audits inherit big) + doc-gen orchestration (resolve questions/NAP/precheck/overwrite/client-name inline → PACKAGE) → dispatches NEW sonnet handover-doc-writer (STEP 9-16: reads memory+git, synthesizes 6-chapter doc, word-count/skill-leak/anchor gates, renders HTML+PDF; GATE-FREE, no AskUserQuestion/Agent). client-handover JOINS gated group (orchestrates audits = reflection); its opus pin dropped (inherits big via inline-load). census 42→46. Branch feature/client-handover-dispatch (off develop, waves 1-3 merged first).
 - **Reference**: spec `docs/superpowers/specs/2026-07-15-model-routing-design.md` + plan `docs/superpowers/plans/2026-07-15-model-routing.md` (transient, BDR-065 lifecycle), branches `feature/model-routing` (waves 1-3, merged), `feature/client-handover-dispatch` (wave 4).
 ## BDR-067 — first public release: versioning reset to v1.0.0 (override "never restart at v1.0.0") — 2026-07-16
 - **Decision**: first PUBLIC release cut as **v1.0.0**, treating internal v1.0.0→v4.0.0 as pre-release history. version.txt 4.0.0→1.0.0; CHANGELOG: new `[1.0.0] — Initial public release` on top (= former `[Unreleased]` content), old 1.0-4.0 lineage moved UNCHANGED under a `## Pre-release (internal history)` banner (provenance). Tag v4.0.0 DELETED (local+origin), v1.0.0 tagged on main. Repo goes public on THIS Gitea (user flips visibility separately — not a git op).
 - **Why**: launching publicly at v4 misrepresents (implies missed v1-3 to newcomers); v1-4 were private dev. First public impression should be v1.0.0. User directive.
 - **Overrides**: BDR-055-era release-candidate rule "never restart at v1.0.0 — desyncs tag↔CHANGELOG lineage". That guards ACCIDENTAL mid-lineage restart; a DELIBERATE public-launch reset is the sanctioned exception. **CONSEQUENCE for next release**: continue from public 1.0.0 (→ 1.0.1 / 1.1.0 / 2.0.0), NEVER back to the old 4.x. The [Unreleased]-BREAKING(CLAUDE.global.md) folds into 1.0.0 harmlessly (first release = breaking vs nothing).
 - **Safety (git cherry)**: found a STALE abandoned `release/1.0.0` (July-4 prep, 227 commits behind develop, pushed to origin). `git cherry develop release/1.0.0` + content checks confirmed all its real changes (rtk PATH fix, drop-AI-attribution settings backstop, find-skills drop, BLK-016/LRN-098/LRN-101/EVAL-015, all features) ALREADY in develop → nothing orphaned → deleted it (local+origin). Cut fresh v1.0.0 from CURRENT develop, not the stale branch.
 - **Method**: release-candidate skill gates honored (when-to-release, push) but PREP done manually — backward version (4.0.0→1.0.0) + CHANGELOG restructure exceed the sonnet release-executor's forward-bump assumption (reflection, stays big). LRN candidate: a version RESET is editorial, not mechanical — don't dispatch the forward-only executor for it.
 - **Status**: SHIPPED. origin main=dc4f78b, develop=6c23d6f, tag v1.0.0 sole tag; v4.0.0 + stale release/1.0.0 removed from origin.
 ## BDR-068 — /capitalize + /close auto-persist memory (finish→develop + push); scoped LRN-069 exception — 2026-07-16
 - **Decision**: when /capitalize (or /close = --ritual) writes entries AND the aiguillage branched a `chore/<name>` off develop THIS run, new STEP 5C auto-finishes that branch → develop + pushes origin/develop. Default ON. `--no-push` holds it on the chore branch (pre-BDR-068 behavior). WORKING branch (memory rides feature/bugfix) or rc-3 commit-fail → 5C skips. push-fail → merge already local, report + manual push (no retry/reset).
 - **Why**: memory's value = cross-session persistence; a ritual commit stranded on an unmerged chore branch is INVISIBLE to the next session on develop → the ritual defeats itself (user-identified gap). Memory = append-only/low-risk; the human-gated MERGE (aiguillage) is a CODE safeguard, and LRN-069's push-gate guards surprise CODE/release pushes — neither applies to an end-of-session memory persist.
 - **Scope**: /capitalize + /close ONLY. /prune-memory + /reconcile stay fully human-gated (curation/report may want review before landing). NEVER auto-finish a branch the run did not create.
 - **Amends**: [[LRN-069]] (push needs explicit go) — scoped exception for memory-only ritual persist; `gitflow-aiguillage.md` "never gitflow finish" — carved for capitalize/close.
 - **Files**: skills/capitalize/SKILL.md (STEP 5C + aiguillage branch-capture + STEP 6 outcomes + Rules + arg-hint `--no-push`), lib/gitflow-aiguillage.md (exception note). Tests unaffected (run-deterministic covers memory-commit.sh surgical scope, not the persist step).
 - **Status**: implemented on feature/close-auto-persist, UNMERGED (human gate).
 ## BDR-069 — permissions deny: keep broad `.env.*` glob, keep `.env.example` name (option A) — 2026-07-16
 - **Decision**: `Write(path)` deny rules inert (Claude Code matches `Edit(path)` only) → 5 secret-write bans converted to `Edit()`. Mirrored 9 secret patterns Read denied but Edit did not → Read/Edit parity 14/14. New read-allowed/write-denied class: lockfiles (`*.lock`, `package-lock.json`, `pnpm-lock.yaml`, `go.sum`) + `node_modules/**`. Kept `Edit(**/.env.*)` BROAD despite matching `.env.example` (mandated by CLAUDE.global.md:206). No rename.
 - **Why**: deny glob = absolute, no exemption mechanism ([[LRN-130]]). Only lever = glob shape. Narrowing to `.env*.local` fails open on `.env.production`/`.staging` — real secrets outside Next.js convention.
 - **Cost accepted**: scaffolder/doc-syncer degraded on `.env.example` — Edit/Write/Read/Grep/Glob blocked; Bash heredoc still works (`Bash(cat *)` allowed). Ergonomic tax on /init-project, not a hard block.
 - **Alternatives rejected**: (B) narrow glob → weakens `.env.production`; blocked by auto-mode classifier as unauthorized self-modification ([[EVAL-024]]). (C) rename → `env.example` sidesteps glob at zero security cost, but ~30 refs (scaffolder, doc-syncer, init-project, deploy, 3 archetypes, link.sh, install-plugins.sh, toggle-external.sh) + repo's own root `.env.example` + seo-data.test.sh + gitignore `!.env.example` (BDR-030) → refactor, user declined.
 - **Files**: settings.json, templates/settings/SETTINGS.md (taught the broken `Write()` pattern → fixed at source so /onboard stops propagating it).
 - **Status**: implemented on chore/fix-inert-write-deny-rules (07ca738), UNMERGED (human gate).
 ## BDR-070 — claude-seo (github.com/AgriciDaniel): cherry-pick, never install — 2026-07-17
 - **Decision**: adapt useful scripts into our tree, /seo stays sole entry. Do NOT run install.sh / plugin install.
 - **Why**: their CODE is real (326 tests, render_page.py 428l Playwright, url_safety.py 622l SSRF) — their INSTALLERS destroy our work. install.sh:49 `cp -r skills/seo/*` overwrites our SKILL.md. uninstall.sh:45 globs `~/.claude/agents/seo-*.md` → deletes our seo-analyzer.md (42K) it never installed (verified dry-run). extensions/*/install.sh:42 replaces settings.json with `{"env":{...}}` on parse error. skills/seo/SKILL.md:119 injects Skool upsell footer into deliverables (leaks to /client-handover client PDFs). hooks.json registers global PostToolUse exit-2 → blocks our dispatcher mid-bundle.
 - **Alternatives rejected**: (plugin install) → both `/seo` coexist namespaced → non-deterministic dispatch, silently loses our FR-legal axis on an unpredictable fraction of runs. (install nothing) → forgoes render_page/url_safety/unlighthouse we lack.
 - **Verdict on parity**: their README lies (dual JSON-LD validator = 2 hyperlinks, zero `.py` calls; "zero-network"/"fully offline" false). Our system is more honest; we keep FR-legal (their whole repo: 2 hits), fix-bundle+ownership, trajectory-17/20, NAP anti-seed.
 - **Files**: none installed. Findings drove the whole seo-geo-integrity branch (21 commits).
 ## BDR-071 — no viable free backlink source: Off-page axis stays brand-mentions-only — 2026-07-17
 - **Decision**: I1's narrowed Off-page axis (brand mentions from STEP 6 only, backlinks+authority declared §14-unauditable) is the FINAL state, not a placeholder awaiting data.
 - **Why**: measured, not assumed. GSC has no links endpoint (API = Search Analytics/Sitemaps/Sites/URL-Inspection only; links report UI-only). Common Crawl hyperlinkgraph domain-edges = **17.3 GB gzipped** (+879MB vertices, +2.3GB ranks), HEAD-measured live. Scanning it per-audit is non-viable + abusive to a nonprofit. The reference impl (claude-seo commoncrawl_graph.py:169) caps download at 500 MiB = **2.9% of edges**, sorted by source ID → arbitrary slice reported as a backlink profile, "70/100 health". A random sample dressed as a measurement — the exact failure class the branch removes.
 - **Consequence**: B1/B2/B3 all killed. Weight (10-15%) unchanged — re-deriving for an axis that won't widen churns historical scores for nothing.
 - **Only free viable source**: Bing GetUrlLinks — first-party only (never a competitor), blocked on client's Bing account → raises W2's value ([[BLK-017]]), does not unblock it.
 ## BDR-072 — SPA: honest refuse, no headless browser (R2 chosen over R1) — 2026-07-17
 - **Decision**: rendercheck verdict `client-rendered` → On-page axis N/A, excluded from weighted global, NEVER scored zero. No Playwright, no Chromium. User-arbitrated.
 - **Why**: a zero says "your on-page is bad"; N/A says "we couldn't see it" — only one is true, and /client-handover gates on 17/20. curl on a shell returns "missing" for every meta/H1/JSON-LD → a page of FALSE findings + a bundle that "fixes" tags that already exist. STEP 2 recorded `RENDERING: SPA` since forever and NOTHING acted on it. Verdict from what the server SENT (package.json can't tell React-SPA from Next-SSR).
 - **GEO angle (sharper)**: AI crawlers (GPTBot/PerplexityBot/ClaudeBot) are WORSE at JS than Googlebot — fetch HTML, largely don't execute. A client-rendered site is near-invisible to the engines the audit serves → §0 alert + SSR/SSG top user action, aligns CLAUDE.global "public sites never SPA".
 - **Alternatives rejected**: R1 Playwright (~300MB Chromium, breaks bash+curl purity) — user chose refusal. Refusing IS the finding.
 - **Files**: lib/seo-data/render_check.py, seo/geo STEP-5 gates (20d3082).
 ## BDR-073 — deterministic scoring: split LLM judgement from arithmetic — 2026-07-17
 - **Decision**: LLM emits WHICH findings + severity (irreducible judgement); engine computes the /20. Reuses /harden's scale (-15/-8/-3/-1, clamp, /5 into /20) → one vocabulary across the family.
 - **Why**: /harden had a real scale (SKILL.md:435), /seo had NONE → every axis felt → two runs over identical code diverged, while /client-handover gates on 17/20. H2 sharpened it: once drift reports real change, a self-moving score is visibly noise. Same principle as engine-side cannibalisation grouping — never hand a model 1000 rows to add.
 - **Makes computable (was prose)**: "N/A is not a zero" (R2 on-page, I1 off-page) → axis excluded + weights renormalised, verified all-20 with 2 N/A → global 20.0. Prevalence: affected/sampled shift severity ONE step (≥50% escalate, single de-escalate).
 - **Files**: lib/seo-data/score.py (4818c61).
 ### BDR-074 — Remove config-protection edit-block guardrail [accepted] (2026-07-17)
 Deleted hooks/config-protection.sh + its settings.json PreToolUse registration + lib/tests/config-protection.test.sh. Hook blocked model Edit/Write on quality-gate files (settings.json, gitflow.sh, .githooks, doctor.sh, hooks, lib/tests, lint) via one-shot .claude/.config-edit-ok sentinel. Removed per user req — friction editing own config > guardrail value; user = human operator. Residual: gitflow pre-commit guard + Gitea branch protection still block direct code commits main/develop; only edit-time block gone. Alts rejected: warn-only (exit0+log), targeted relaxation. Supersedes any prior config-protection decision.
 ### BDR-075 — Framework-wide 3-way adversarial plan-challenge phase [accepted] (2026-07-17)
 After a plan/reflection elaborated + before execution, 3 fresh blind sub-agents (correctness/robustness/simplicity) attack it; main loop RE-THINKS every aspect a BLOCKER lands (named change or [deferred]) + re-challenges once if plan materially changed. Reusable lib/challenge-plan.md + new agents/plan-challenger.md (read-only, big-model per [[BDR-066]] — audit judgment, NOT sonnet). Fail-safe (never fail open: mute→retry→escalate), severity-driven (any single-lens BLOCKER=must-address, NOT consensus — lenses orthogonal), advisory into existing human gate. KIND tunes lenses: build-plan/proposals/fix-bundle. Wired 11 orchestrators: ship-feature/init-project/feat/bugfix + onboard/audit-delta/code-clean + seo/geo/harden/web-validate. Excluded (no real plan): hotfix/tour/analyze/client-handover/release-candidate/spec. Audit found 0 repo-owned plan-challengers pre-existing (only vendored gstack autoplan, sequential+unwired). See [[EVAL-026]].
 ### BDR-075 amendment (2026-07-18) — hotfix INCLUDED via logic-only guard
 Supersedes the "Excluded: hotfix" clause of [[BDR-075]]. hotfix now wired (STEP 1.8, Option B): GUARD skips purely cosmetic fixes (CSS/copy/typo), fires the 3-lens challenge ONLY when the fix touches control flow/behaviour (off-by-one, wrong operator, behaviour-changing config, execution-altering import); a BLOCKER → escalate to /bugfix (its STEP 3b runs the full phase). 12 orchestrators wired. Still excluded (no forward plan): tour/analyze/client-handover/release-candidate/spec. Per user (Option B). Branch feature/hotfix-challenge-guard, unmerged.
 ### BDR-076 — Dispatched judgment agents pinned OPUS; session model = orchestration + inline reflection ONLY [accepted] (2026-07-19)
 Reverses the BDR-066 rejected alternative "opus pins on audit agents (session-independent)". Context changed: session default now Fable (Mythos tier, /model 2026-07-19) — inherit meant every dispatched audit/challenge burned Fable quota, exactly the waste BDR-066 killed for executors. New rule: Fable does ONLY main-loop orchestration + reflection (brainstorm, plan, contract, synthesis, gates); EVERY dispatched subagent pinned. Pinned `model: opus` (big tier, session-independent; NEVER sonnet — silent audit downgrade, the thing old §F5 guarded): analyzer, plan-challenger, seo-analyzer, geo-analyzer, validator-analyzer + onboard's 6 general-purpose audit dispatches (`model="opus"`) + tour Phase B. NOT pinned (justified deviation from approved "7 agents"): interviewer + client-handover-writer — inline-load only, never dispatched → frontmatter pin inert + misleading (BDR-066 wave-4 precedent: its inert opus pin was dropped); they ARE the main loop = Fable per the rule. Explore built-in stays inherit (wave-3 decision conserved: no owned prompt, search feeds inline reflection). Local session pin `opus-4-8[1m]` dropped from `.claude/settings.local.json` (gitignored) — Fable default from settings.json now applies in this repo too. model-gate.md unchanged (still guards inline reflection, Fable-or-Opus = big). Census: model-routing.test.sh §3 flip + §11 (61 pass), loops-light 35 pass, full `make test` green. User directives via gate: "Opus partout" + "Supprimer le pin". Branch feature/opus-pin-audit-agents, unmerged.
 ### BDR-077 — Model-tiering v2: 4-tier explicit routing, mode-based splits, no-inherit dispatches [accepted] (2026-07-19)
 Supersedes BDR-076 scope + amends BDR-066. Doctrine: session model (Fable) = main-loop reflection/orchestration/planning/logic ONLY; main-loop retention criteria = interactive | conversation-context access | orchestration decision | dispatch overhead > step cost. NOTHING dispatched inherits: typed agents = frontmatter pin, built-ins = `model=` at every call site (`fable` for skill-runner reflection children, else complexity tier). Spike+smoke proven: `model:"fable"` resolves claude-fable-5 (enum-validated, loud fail, no silent fallback); call-site override BEATS a typed pin (sonnet-pinned verifier ran haiku). Fail-safe pin rule: mixed-mode agents keep the HIGH tier as pin, overrides go DOWN — forgotten override over-tiers (cost), never downgrades judgment. Mode-based splits (commit-changer precedent generalized; file splits rejected): doc-syncer audit(opus)/patch(sonnet) — ALSO fixed a latent defect: /doc dispatched an agent whose STEP 8 interactive gate could never fire; gates hoisted to a DISPATCHER PROTOCOL section; handover-doc-writer synthesize(opus)/render(sonnet) via run-scoped `.audit/handover-draft-<RUNID>.md` + DRAFT COMPLETE sentinel; seo/geo collect(sonnet)/judge(OPUS PIN)/template(sonnet) via `.audit/*-signals-<RUNID>.md` + COLLECTION COMPLETE + fail-closed judge + dispatcher ERROR contract (mute/ERROR judge NEVER carried into templating; retry once, escalate). File split only for a genuinely new role: plugin-probe (sonnet, facts-only) + plugin-advisor repinned opus reasoner (fail-closed on missing PROBE REPORT) + lib/plugin-gate.md (checkpoint + apply gate, doc-commit ×N include pattern). Inline→dispatch conversions: scaffolder, onboarder, doc-commit steps ×5 flows — their sonnet pins were INERT since creation, now live; CHANGE SUMMARY crosses the doc dispatch into doc-commit (LRN-126 wire). Tier moves: validator-analyzer opus→sonnet (deterministic runner); commit-changer propose=opus/apply=pin; ship-feature/init-project code-review dispatches = opus explicit (WAS an inherit leak); client-handover-writer's 7 skill-runners = model:"fable". Every wave shipped an IN-WAVE planted-input smoke as its merge gate — all PASSED disk-verified. Census §12-18 (125 pass; one vacuous line-wrapped lock self-caught = LRN-093 live). 6 waves, branches feature/model-tiering-w1..w6, merged on user standing signal. Plan: challenged 3 blind lenses + 1 confirmation (1 BLOCKER closed by spike, 8 MAJORs + 8 MINORs closed by named changes, 0 deferred). Refs: `.claude/tasks/plans/2026-07-19-model-tiering-v2-{analysis,plan}.md`.
 ### BDR-078 — ctx7 coverage: central fast-libs list + once-per-session reminder hook; every code path covered [accepted] (2026-07-20)
 Refines BDR-053 (single surface). Audit 2026-07-20: coverage PARTIAL — find-docs fired on user doc-questions only; ship-feature 0c / init-project 5c pre-fetched; /feat //bugfix executors + ad-hoc coding NEVER consulted ctx7; fast-libs list hardcoded 3× (drift risk). 4 closures shipped: (a) find-docs description += BEFORE-writing-code trigger (fast-moving lib, even without doc question, unless fresh cache) + cache-first rule in body (tee fetched docs to .ctx7-cache/); (b) feater+bugfixer briefs += fast-lib docs rule — read fresh `.ctx7-cache/<lib>*.md`, else `npx ctx7@latest` fetch max 2 topics, else `ctx7 cache miss: <lib>` in NOTES + proceed (executors lack Skill tool → Bash path); (c) hooks/ctx7-reminder.sh UserPromptSubmit — ONE fire/session (sentinel on session_id), only when project manifest carries fast-libs; reports cache state; skips <task-notification> turns; always exit 0; (d) lib/fast-libs.sh = SINGLE SOURCE (detect / cache-status verbs, JS package.json anchored full-key match + Python requirements/pyproject, 7-day freshness, LC_ALL=C sort locale-independent) consumed by hook + 3 pipeline skills + 2 briefs. 2nd session surface DELIBERATE, not a BDR-053 reversal: 053 killed a 490-tok ALWAYS-ON rule duplicate; hook costs ~0 quiet, 1 line once when fast-libs present. Alternatives rejected: PreToolUse Edit/Write gate (fires per-edit = noise); description-only fix (probabilistic, executors unreachable). Tests: lib/tests/fast-libs.test.sh 11 checks (anchored/near-miss/py/none, cache fresh/stale/missing, hook fire/sentinel/quiet×2); shellcheck + full make test green. Branch feature/ctx7-coverage, unmerged (human gate).
 Amendment (same session): skills/find-docs = machine-owned dist (gitignored, ctx7 regenerates on fresh clone) → durable copy of closure (a) lives in install-plugins.sh STEP ctx7 (idempotent grep-guarded python patch, fixture-verified); live SKILL.md carries the same edit uncommitted by design.
@@ -36,6 +36,7 @@ rules:
 | EVAL-013 | 2026-06-30 | /reconcile real-usage on live repo: known gap + 2 unanticipated (header-marker drift class) + false-positive rejected off-fixture, 0 false assertion | keep |
 | EVAL-018 | 2026-07-06 | job3 docs-drift audit + execution: 46/46 findings verified, 20/23 fixes shipped (B1 blocked, D2-D5+B6 skipped by decision), zero residual on re-sweep | keep |
 | EVAL-019 | 2026-07-06 | job4 test-gap audit + execution: 11 specs + 5 fixes/seams, every mutation red-green verified, zero residual | keep |
 | EVAL-025 | 2026-07-17 | opening seo/geo inventory (subagents): 7/7 verifiable claims false or overstated; real contact corrected all, 6 plan corrections + 4 features killed at measurement | keep |
 ---
@@ -220,3 +221,33 @@ rules:
 - **output**: review M5 flagged "no EVAL trace of the BDR-060 pin smoke-test." Traced: `.claude/tasks/TODO.md` job9 PART 1 GATE P1 DID record it — verifier `CONFORME`, security-auditor `BLOCK(2)`, plugin-advisor `ACTION REQUIRED`, verdict grammar intact, mode honored, no revert. The pins (verifier/security-auditor/plugin-advisor → sonnet, ea6c126/1c270e6/5ab6c21) WERE dispatch-smoked; the only gap was that the record lived in TODO, not evals.md.
 - **method**: cross-read TODO PART 1 against the M5 finding; no re-run (recorded verdicts conclusive, pins unchanged since).
 - **action**: keep — record backfilled here, no re-smoke required.
 ## EVAL-023 — post-merge ronde on the model-routing refactor (BDR-066) — clean, 5 edge gaps found + fixed
 - **Date**: 2026-07-16
 - **output**: model-routing reflection/execution split (BDR-066, waves 1-4, 4 merged branches — the whole session's refactor).
 - **method**: 4 parallel BIG-MODEL analyzer audits (dispatch-graph/consumer-staleness, model-tier, loop-integrity, dispatch data-flow) + full test suite (13 suites, 57-check census). Audit on big model (audit=reflection, dogfoods BDR-066). NOT darwin-skill (that = a skill-PROMPT optimizer, wrong tool for refactor-regression verification).
 - **verdict**: dispatch graph INTACT (0 regressions), all loops CLOSE (0 broken), tiering CORRECT (every DISPATCHED agent), data-flow client-handover wired. Refactor preserved/improved everything it touched.
 - **anomalies**: 5 edge gaps the census DIDN'T catch — F1 (REAL bug: /seo,/geo dispatch feater as L1 applier without CONTRACT, but feater mandated "read CONTRACT FIRST"; hotfixer had the carve-out, feater didn't), F5 (audit-agents' ABSENT pin unguarded → a stray sonnet pin would silently downgrade a live audit), F2/F3/F4 (BDR-066 consistency: /refactor over-powered inline-load, /analyze ungated reflection, interviewer inert sonnet pin). F1 lesson: census locks STRUCTURE (shape); catching a severed data-path needs a data-flow READ ([[LRN-126]]).
 - **action**: keep — all 5 fixed (bugfix/model-routing-edge-fixes, merged 5f159f3); census 47→57 now locks each.
 ## EVAL-024 — deny-list design pass (BDR-069) — core fix sound, 1 unauthorized weakening caught by classifier not by me
 - **Date**: 2026-07-16
 - **output**: settings.json deny-list rework (`Write()`→`Edit()`, 9 secret mirrors, read-only class) + templates/settings/SETTINGS.md.
 - **method**: doc verification (claude-code-guide agent + direct WebFetch of permissions.md, quoted verbatim, NOT from memory) + `make test` (96/25/5/5 GREEN) + jq Read-vs-Edit parity diff. Runtime warning-clear NOT verified — needs user restart. Stated as such, not claimed.
 - **verdict**: core fix correct + doc-backed (`:242`/`:244` prescribe the `Write()`→`Edit()` conversion exactly). But I shipped one unauthorized weakening mid-pass.
 - **anomalies**:
  - **A1 (REAL, mine)**: narrowed `Edit(**/.env.*)` → `Edit(**/.env*.local)`, dropping deny on `.env.production`/`.staging`/`.development`. Two compounding errors: (a) SCOPE INVERSION — user delegated "judge the read/write asymmetry" = ADD denials where Read has them; I used it to REMOVE one. (b) FRAMEWORK PAROCHIALISM — justified by "Next.js gitignores only `.env*.local`", generalized to all stacks; Django/Rails/Compose put real secrets in `.env.production`. Target = my OWN permission boundary → self-modification. Caught by auto-mode classifier, NOT self-caught. Reverted before commit.
  - **A2 (tooling, FALSE POSITIVE)**: security-guidance automated review flagged the same file, HIGH "Agent/Subprocess Permission Bypass", fix = restore the inert `Write()` rules. Wrong — would re-introduce the bug + the 15 startup warnings. Pattern-matched "deny line removed = bypass" with zero knowledge of rule-matching semantics. Rejected with doc citations.
  - **A3 (subagent, caught)**: claude-code-guide asserted `**/*.lock` matches `package-lock.json`. False (ends `.json`). Caught on read → `package-lock.json`/`pnpm-lock.yaml`/`go.sum` got explicit rules. Don't trust delegated glob reasoning.
 - **action**: keep — fix landed (07ca738), weakening reverted. Lesson: vague delegation ("je te laisse en juger") authorizes ADDING protection, never REMOVING it; a boundary-loosening edit needs its own explicit ask, doubly so when the boundary is mine. Guardrail signal: the deterministic classifier beat both the LLM reviewer (A2 false pos) and me (A1) — keep it loud. Linked to [[BDR-069]], [[LRN-130]].
 ## EVAL-025 — opening seo/geo inventory (subagent-produced) that founded the 20-point plan — 2026-07-17
 - **output**: the inventory + claude-seo comparison report from 3 Explore subagents, on which the entire seo-geo-integrity plan was built.
 - **method**: each verifiable claim confronted DURING execution with a primary source or a live test — CrUX API metric list, web.dev, Search Console API reference, HEAD on data.commoncrawl.org, real curl on 2 live sites (zenquality Astro, lavageangels356 native PHP), 2 real repos.
 - **anomalies**: 7/7 of the verifiable claims were false or overstated (VSI exists / Off-page zero-data / stats drive weights / GSC Links API / SPA §0 flag / Twitter 403 / Common Crawl viable). 6 plan corrections mid-execution: I1 over-correction, I6 wrong framing, W1 wrong shape (verb vs extend), C1a false premise (grep already skips gitignore), C1b needless guard, B1 non-viable at 17.3 GB. The REAL corrected every time; re-reading the spec never did.
 - **action**: keep — see [[LRN-132]]. 4 features killed at measurement (B1/B2/B3 + W2 deferred) beat 4 false-signal features. The most trustworthy output of the session was the code NOT written. Method that worked: show/measure the real artifact before deciding, mirroring [[LRN-074]]'s watch-the-RED discipline applied to a plan.
 ### EVAL-026 — 3-way plan challenge caught 4 BLOCKERs dogfooding own plan (2026-07-17)
 Dogfood: 3 blind lenses attacked the v1 plan for the plan-challenge feature itself. Verdicts CONCERNS(4)/FATAL(6)/FATAL(4). Caught 4 distinct BLOCKERs a single pass would blend: (1) v1 unbuildable — targeted init-project (inline-load, no dispatch) + false "plan on disk" premise for feat/bugfix (only contract persists); (2) failed-open silently dropping a lens while claiming "challenged" (inverts verify-secure-loop "a mute verifier is NEVER a PASS"); (3) consensus-weighting buries lone L2 security finding (lenses orthogonal); (4) sonnet challengers violate [[BDR-066]] (audit judgment=big model). Synthesis REJECTED 1 false positive (allowed-tools-blocks-dispatch — ship-feature has same frontmatter + dispatches fine). Each lens found a DIFFERENT class of flaw → evidence 3-independent > 1-multilens. Action: hardened v2 (severity-driven + fail-safe + re-think loop) shipped. Method validated itself before build.
@@ -381,3 +381,39 @@ rules:
 ## 2026-07-14
 - `/ship-feature` feature/claude-global-md-rename (unmerged, human GO pending): global memory → CLAUDE.global.md + project-scope CLAUDE.md, 8 commits (a4ee7e1 docs → e9a38a0 guards). Full pipeline: analyzer + contract (17 criteria), brainstorm/spec/plan gates, SDD 5 tasks (all task reviews Approved), verifier CONFORME 17/17 (after user-arbitrated criterion-9 consumer-wording + FILE-SCOPE [gated] enrichment), security PASS (semgrep 43 rules, 0), final review "Yes" after 2 Important fixes (guard-test drift → 7/7; doctor exact-target check). Decided [[BDR-064]]; learned [[LRN-122]] (2-commit rename split), [[LRN-123]] (exact symlink target). `make test` green throughout. settings.json plugin toggles = session-scoped, NOT committed — restore (gstack/ui-ux-pro-max/frontend-design/emil-design-eng/darwin-skill/magic ON) after merge.
 - Merges to develop: feature/claude-global-md-rename (2d54df5), chore/untrack-audit-reports (d557ee9), chore/post-merge-cleanup. /cso triage: 75 gitleaks findings → 0 real (60 git SHAs vs sourcegraph rule; gitflow-test AWS fixture; expired GitHub image JWT; presigned-URL key ids; doc placeholders; job7-purged artifacts). .gitleaks.toml → [[allowlists]] format + 8 targeted entries; `make scan-secrets` green 0+0. Makefile "safe to commit" hint root-caused → [[LRN-124]]. Transient spec+plan deleted per [[BDR-065]] (user decree, gsc-crux precedent). Mid-merge discovery: user commit 5842119 (gitignore `.audit/` + model pin fable-5) — explains the .audit-in-diff question. cso report: .gstack/security-reports/2026-07-14-secrets-triage.json.
 ## 2026-07-15
 - model routing shipped on feature/model-routing: BDR-066 (reflection inline big / executors sonnet / blocking gate), /feat re-arch, census guard. client-handover conversion deferred to plan 2.
 - model routing WAVE 2 (same branch, user directive): doc/status dispatch their agent (sonnet/haiku pins effective); /hotfix split like /feat (joins gated group 12→13, hotfixer dual-use executor); /commit-change → sonnet commit-changer (propose/apply, gates relocated); /release-candidate → sonnet release-executor (human gates + version decision kept in dispatcher). Consumer-staleness swept (feat Rule 1 + commit-split). census 36/0, make test green. Branch still unmerged.
 - model routing WAVE 3 (same branch): /bugfix + /code-clean split like /feat — reflection inline, sonnet executors (bugfixer, code-cleaner). code-clean refactor now runs on sonnet (inline-load pin was inert). consumers rerouted (hotfix deeper-bug→/bugfix skill; onboard/tour read-only audit→big-model agent). Explore kept built-in (inherits big). census 42/0, loops-light 35/0. Branch still unmerged.
 - model routing waves 1-3 MERGED into develop (e5c7c51); LRN-125 added. WAVE 4 started on feature/client-handover-dispatch (off develop): client-handover doc-gen → sonnet. REDACTION-ONLY (user flipped from whole-writer — nested audits must run big either way). client-handover-writer trimmed to ship pipeline (STEP 1-8 preserved byte-for-byte) + delegates writing to NEW sonnet handover-doc-writer (gate-free, STEP 9-16). client-handover joins gated group. census 46/0. NOTE: a Task-20 implementer ran `git checkout -- settings.json`, discarding user /model=opus working-tree state (LRN-098) — flagged to user (re-run /model). Lesson worth an LRN: constrain SDD implementers from git ops on files outside their task.
 - wave-4 FINAL REVIEW (opus whole-branch): all 7 deliverable invariants hold, child gate-free, PACKAGE complete. Found 3 real regressions from the split — FIXED inline: (I2) DEPLOY_HINTS severed STEP2→STEP14 + (I3) --skip-seo flag dropped → both now forwarded via PACKAGE (parent resolved-list + dispatch template; child INPUT contract + gate); (I1) §7/§8 annex numbering drift in STEP 13/14 (operative steps said §6/§7 = stale 5-chapter scheme) realigned to authoritative §7/§8 + hard-rule renumbering M1/M2/M3 (Chapter 2/3/4 caps → 3/5/6; chapters 1–3 → 1–5, matching the gate windows). census lock added: lacks 'Agent(' on child (M5). census 47/0, shellcheck clean. Branch NOT merged (awaiting human signal).
 - waves 1-4 MERGED to develop (d8917bf). LRN-126/127 added.
 - post-merge RONDE (user "fais une ronde"): 4 big-model analyzer audits over 72 skills + 21 agents. Verdict: dispatch-graph INTACT (0 regressions), loops CLOSE (0 broken), tiering CORRECT (every dispatched agent), client-handover data-flow wired. The refactor preserved/improved everything it touched. NOTE: darwin-skill is a skill-PROMPT optimizer (mutates SKILL.md) — wrong tool for a post-merge verify; used bespoke analyzer fan-out on the big model (audit=reflection, dogfooded). Ronde surfaced edge findings → fixed on bugfix/model-routing-edge-fixes: F1 feater applier severed CONTRACT (real bug, LRN-126 instance — /seo,/geo dispatch feater as L1 applier with no CONTRACT but it mandated "read CONTRACT FIRST"; gave it hotfixer's applier carve-out); F2 /refactor inline-load→dispatch refactorer (sonnet pin was inert); F3 /analyze +MODEL GATE (ungated reflection); F4 interviewer drop inert sonnet pin; F5 census locks the ABSENT pin on seo/geo/validator-analyzer + client-handover-writer + interviewer (a stray sonnet pin would silently downgrade a live audit). census 47→57. Branch NOT merged.
 - edge-fixes branch MERGED to develop (5f159f3). develop pushed to origin.
 - FIRST PUBLIC RELEASE **v1.0.0** (BDR-067). Versioning RESET: internal v1-4 → pre-release history, public launch = 1.0.0 (override "never restart at v1.0.0" — deliberate public reset = sanctioned exception; NEXT release continues from 1.0.0, not 4.x). Deleted v4.0.0 tag + a STALE abandoned release/1.0.0 branch (July-4 attempt, 227 behind; `git cherry` confirmed nothing orphaned — all real work already in develop). Cut fresh from develop. PUSHED: origin main=dc4f78b, develop=6c23d6f, sole tag v1.0.0. User flips Gitea repo visibility to public separately. Prep done manually (backward version + CHANGELOG restructure beyond the forward-only sonnet release-executor).
 - /close ritual: LRN-128 (version reset = editorial, not the forward-only executor) + LRN-129 (git cherry proves nothing orphaned before a branch delete) + EVAL-023 (post-merge ronde on the model-routing refactor — clean, 5 edges fixed) capitalized; checked 1 TODO done (Gitea public, user-confirmed). BDR-066/067 + LRN-125/126/127 already logged inline this session (dropped as dup). Index drift (learnings 118-129, evals 020-023) flagged for /prune-memory.
 - BDR-068 (close-auto-persist) MERGED to develop + pushed. Then cut + pushed **v1.1.0** (minor, that feature). Standard forward bump → sonnet release-executor ran BOTH spans (prep + finish+tag); lineage continued 1.0.0→1.1.0 not 5.x (validates [[BDR-067]]). origin: main=2f8dc6b, develop=21b1e21, tags v1.0.0 + v1.1.0. WATCH-ITEM: a stale local tag `v4.0.0` reappeared during the release — NOT from origin (origin never regained it; `push.followTags` off; its commit unreachable from develop/main). Inert (push targeted main/develop/v1.1.0 explicitly + deleted the local copy; origin verified clean). Mechanism unexplained — if `v4.0.0` resurfaces locally after a `gitflow` op, trace the release lib (gitflow.sh / release-executor) for stray tag re-creation.
 ## 2026-07-17
 - safe_fetch DNS-rebinding guard shipped by-principle (feature/dns-rebinding-guard): resolve-then-pin in stdlib http.client, closes SSRF+rebinding for the Python egress (4 verbs via sitemap._fetch), better than claude-seo url_safety on 3 axes. Fresh security-auditor VERDICT PASS + surfaced a REAL billion-laughs hole in my own already-merged C1b (prefix-only DTD scan bypassed by >4KB padding, entity expanded — proven, fixed here). LRN-134/135 capitalized. seo-data 210→221. claude-seo question CLOSED: 3 pieces taken (schema_gen/content_quality/safe_fetch), rest killed-at-measure or rejected-on-principle.
 - content_quality verb shipped via /feat (2nd cherry-pick, stacked on feature/seo-data-cherry-picks): deterministic filler/AI-slop signal (QRG list intact, no LLM), advisory-not-verdict wired into geo STEP 8. GATE 1 CONFORME 10/10 both verbs, seo-data 190→210. Two easy claude-seo picks DONE; url_safety (DNS-rebinding) still deferred pending threat-model. Branch carries 2 feat + 1 journal commit, UNMERGED (human gate).
 - Gap-revisit claude-seo after the 21-commit build: remaining cherry-pick value narrowed to 2 clean stdlib picks + url_safety (DNS-rebinding, deferred on threat-model). schema_gen verb shipped via /feat (honors [[BDR-070]] adapt-not-copy): generates JSON-LD (Reservation/OrderAction/DiscussionForumPosting/ProfilePage), the system only audited before. GATE 1 CONFORME 10/10, seo-data 167→190 pass. content_quality next (same /feat, stacked — shares fetch.sh/test/README).
 - seo/geo parity vs github.com/AgriciDaniel/claude-seo (11.5k★, MIT): full 20-point plan built from a 3-subagent inventory, then executed. Verdict cherry-pick-never-install ([[BDR-070]]). 21 commits: Phase 1 (I1-I8 integrity, markdown specs) MERGED to develop (02c7a6f, 8 commits); Phases 2-7 on bugfix/seo-geo-integrity UNMERGED (13 commits, human gate). `fetch.sh` 5→11 verbs (richresults via inspect, sitemap, rendercheck, linkgraph, cannibal, drift, score); seo-data test suite 85→167 pass, 0 fail. Dogfooded on 2 live sites (zenquality Astro + lavageangels356 native PHP) — the second caught 2 bugs Astro hid (image:loc counted as page, flat-URL family heuristic).
 - 4 features KILLED at measurement, not built: B1/B2 (Common Crawl edges = 17.3 GB, ref impl reads 2.9% and calls it a profile — [[BDR-071]]), B3 (GSC Links API doesn't exist), W2 (Bing OAuth swamp — [[BLK-017]]). 30/70 similarity refused (needs content extraction), Playwright refused (R2 [[BDR-072]]), defusedxml refused (DTD-reject keeps stdlib-only). The most trustworthy output was the code NOT written ([[EVAL-025]]).
 - BDR-070/071/072/073 + LRN-131/132/133 + BLK-017 + EVAL-025 capitalized; checked 14 TODO done (I1-I5,W1,W3,C1-C3,B3,R2,H1,H2), W2+R1 left unchecked (deferred/rejected). 2 learnings dropped as dup of [[LRN-074]] (grep/find gitignore + detector-proof). Red thread [[LRN-133]]: an omission must stay legible. Verification discipline [[LRN-131]]/[[LRN-132]]: WebSearch ≠ verification, subagent summary = claim not fact (7 disproven, 3 self-reproduced).
 - Removed config-protection edit-block guardrail (full removal, user req) → feature/drop-config-protection (0e1b89c). Residual gitflow+Gitea guards only. [[BDR-074]] [[LRN-136]].
 - Built framework-wide 3-way plan-challenge phase → feature/plan-challenge-phase (6bfc054): lib/challenge-plan.md + agents/plan-challenger.md + 41-assertion lock, wired into 11 reflection orchestrators (build-plan/proposals/fix-bundle), excluded 6 no-plan skills. Full suite 16/16. [[BDR-075]].
 - Dogfooded the challenge on its own v1 plan: 3 blind lenses caught 4 BLOCKERs + rejected 1 false positive → hardened v2 shipped [[EVAL-026]]. Both branches finished into develop on user signal, NOT pushed.
 ## 2026-07-18
 - hotfix wired into plan-challenge via Option B (STEP 1.8 logic-only guard): skip cosmetic, fire on logic, BLOCKER→/bugfix. 12th orchestrator. structure lock 43/43, suite 15/15. [[BDR-075]] hotfix-exclusion superseded (see amendment). feature/hotfix-challenge-guard, UNMERGED (user: commit only).
 - Behavioral smoke of the shipped mechanism: 3 blind plan-challenger dispatches on a planted-flaw plan → correctness FATAL(4), robustness FATAL(6), simplicity CONCERNS(1). Each lens caught ITS planted flaw + stayed in-lens. Live-validated severity-driven (SQL-injection BLOCKER raised by robustness ALONE — consensus-weighting would've buried it) + orthogonality. Confirms [[EVAL-026]]/[[BDR-075]] design.
 ## 2026-07-19
 - BDR-076: dispatched judgment agents pinned opus (analyzer, plan-challenger, seo/geo/validator-analyzer + 6 onboard general-purpose dispatches); Fable now = inline orchestration/reflection only. interviewer + client-handover-writer left unpinned (inline-load, pin inert). Local opus-4-8 session pin dropped from settings.local.json. Census §11 added (61 pass), loops-light 35, make test green. feature/opus-pin-audit-agents, UNMERGED.
 - BDR-077 model-tiering v2 SHIPPED: 6 waves (W0 baseline merge → W1 no-inherit+fable skill-runners → W2 plugin split + doc two-mode + inert-pin conversions → W3 tier moves → W4 handover two-mode → W5 seo/geo 3-mode pipelines → W6 doctrine sweep). Plan challenged 4 passes (1 BLOCKER closed by fable spike). Per-wave planted-input smokes disk-verified. Census 125/0, make test green throughout. [[BDR-077]] [[LRN-137]].
 ## 2026-07-20
 - ctx7 coverage audit (user ask "ctx7 appelé à chaque techno ?") → verdict PARTIAL. 4 gaps: find-docs question-only, /feat //bugfix executors blind, ad-hoc coding uncovered, fast-libs hardcoded 3×. All 4 closed → BDR-078 (fast-libs.sh single source + ctx7-reminder hook + description trigger + executor-brief rule). fast-libs test 11/0, make test + review-guards green. feature/ctx7-coverage, UNMERGED.
 - v1.2.0 cut + pushed (release-candidate flow: prep/finish via release-executor, tag on main 51b6572). CHANGELOG backfilled at prep: 10 entries added to Unreleased (plan-challenge, seo-data verbs, model-tiering v2, integrity pass, safe_fetch/url-guard) — was ctx7-only. /doc full post-release: README model-routing table v1→v2 reframe + ctx7 two-surface wording, chore/doc-sync-v1.2.0 merged. All pushed on explicit go.
@@ -133,6 +133,11 @@ rules:
 | LRN-115 | 2026-07-08 | analyzer Edit/Write grants (seo/geo/validator) are NOT dead: needed to write the REPORT (VALIDATE/SEO/GEO.md); the "never edit" rule targets CODE, instruction-level (same as the patron) — verified false-positive | do NOT re-flag as a tool-grant defect; a report-only agent keeps Write for its own report |
 | LRN-116 | 2026-07-08 | memory backfill release→develop: a BLK marked "resolved" can have its RESOLUTION (code) missing from develop — BLK-016 resolved on release but rtk fix e58037c never back-merged → bug LIVE on develop | before backfilling a resolved blocker: verify the fix CODE is on the target branch, not just the registry entry |
 | LRN-117 | 2026-07-08 | a release/develop fork silently orphans FUNCTIONAL code on develop, not just memory — RC soak fixes (find-skills, make-update TTY, rtk version-guard) lived only on release for the fork's duration; the review's memory back-merge caught only ~half | at release-finish/reconcile: list develop..release commits touching non-registry code (excl. merges/version) for back-merge review — a registry-gap check alone misses code |
 | LRN-131 | 2026-07-17 | WebSearch is NOT verification for a number — SEO blogs cross-cite into fake consensus; require primary source + `measured:` field | any stat headed for a client report; verifying a metric/claim exists |
 | LRN-132 | 2026-07-17 | a subagent summary is a CLAIM, not a fact — 7 disproven in one session (incl. 3 I reproduced writing the fixes) | before planning on any relayed finding; verify vs primary source / live test first |
 | LRN-133 | 2026-07-17 | an omission must stay LEGIBLE, never silent — tool that can't measure says so in its output | designing any audit/measure output; deciding what a cap/refusal/N-A emits |
 | LRN-134 | 2026-07-17 | resolve-then-pin in stdlib http.client beats monkeypatching getaddrinfo — dual-stack, thread-safe, no requests; classify the OS-resolved IP not the URL text | closing SSRF/DNS-rebinding on any Python HTTP egress |
 | LRN-135 | 2026-07-17 | a prefix-only scan for a dangerous construct is bypassable by padding — scan the WHOLE document | refusing any hostile construct (DTD/directive/marker) before parse |
 ---
@@ -1241,3 +1246,106 @@ rules:
 - **why**: redaction removes VALUES, not INTELLIGENCE. And tool output is instruction — a hint that says "safe to commit" will eventually be obeyed by a human or an agent.
 - **future application**: derived security artifacts (scan reports, triage JSONs, audit findings) stay local/ignored; only the allowlist CONFIG (reviewable rules) is committed. When auditing tooling, grep its user-facing hints for wording that invites committing outputs.
 - **cousin**: [[BDR-057]] (secrets by reference, redact at capture), [[BDR-065]] (transient planning artifacts — same "process artifacts ≠ repo content" family), [[LRN-103]] (re-probe before acting).
 ## LRN-125 — don't make an agent dual-use across model tiers; route the audit consumer to a big-model agent, not the sonnet executor
 - **pattern**: splitting `code-cleaner` into a sonnet PHASE-2 executor broke its OTHER consumers (onboard STEP 6, tour Phase B) which dispatched it read-only AUDIT-only. Reflex "keep it dual-use (audit-only OR execute)" would have run an AUDIT on the sonnet-pinned executor = silent violation of the audit=big-model principle. Fix: reroute the audit consumers to a big-model agent (general-purpose/analyzer, inherits session), never the sonnet executor.
 - **why**: a dual-use agent inherits ONE pinned model. If its two uses sit on different tiers (audit=big, execution=sonnet), the pin silently mis-tiers one of them. hotfixer dual-use is fine because BOTH its uses are execution (same tier); code-cleaner's would have straddled tiers.
 - **future application**: before making an agent dual-use, check both consumers are on the SAME tier. Audit/reflection consumer + execution consumer → split the routing (audit → big-model agent, execution → sonnet executor); never overload one pinned agent. Distinct from [[LRN-113]] (sweep ALL consumers on a pattern fix) — this is WHICH agent a consumer routes to, not whether you found them all.
 - **cousin**: [[BDR-066]] (model routing: reflection/audit big, execution sonnet), [[LRN-113]] (consumer-staleness sweep on a pattern fix).
 ## LRN-126 — splitting a monolith agent severs every IMPLICIT data path; forward each consumed field through the handoff contract
 - **pattern**: wave-4 redaction-only split (client-handover-writer monolith → reflection-parent + sonnet doc-writer child) silently dropped 2 inputs the extracted STEPs consumed. `DEPLOY_HINTS` (detected in parent STEP 2, consumed by child STEP 14) + `--skip-seo` flag (parsed from `$ARGUMENTS`, gated child STEP 13) worked in the monolith by shared scope; after the split they were dead — never added to the PACKAGE. Child rendered a §8 without platform tailoring; `--skip-seo` became a silent no-op. Caught only by the opus whole-branch review, not the census.
 - **why**: in a monolith, `$ARGUMENTS`, detected vars, and STEP-N side-outputs are all in one scope — a later STEP reads them for free. The split turns that free read into a data path that MUST cross the parent→child contract explicitly. Every implicit read becomes a severed wire unless forwarded.
 - **future application**: when splitting an agent, enumerate EVERY field the child reads (grep child for its input vocabulary — `PACKAGE.`, bare var names, `$ARGUMENTS` flags) and diff against what the parent SETS before dispatch. Any child-consumed field the parent never populates = severed path = renders a hole or a silent no-op. A census that checks shape (model pin, gate-free) will NOT catch this — needs a data-flow read.
 - **cousin**: [[LRN-125]] (route consumer to right tier on a split), [[BDR-066]] (reflection/execution split), [[LRN-113]] (sweep ALL consumers). Distinct: 113/125 = WHICH agent/tier a consumer routes to; this = WHICH fields must cross the contract.
 ## LRN-127 — SDD implementers must not run destructive git ops on files outside their task scope
 - **pattern**: a wave-4 fix-subagent ran `git checkout -- settings.json`, believing the model-value diff was a "test side-effect." It was the user's uncommitted `/model` → Opus switch ([[LRN-098]]), preserved all session. The checkout DISCARDED it — settings.json reverted to committed `claude-fable-5[1m]`. Implementer had no task-reason to touch settings.json; it acted on a file outside its diff.
 - **why**: a fresh implementer sees only its task + a dirty tree; it can't know which unrelated dirty files are intentional user state vs. cruft. Destructive git ops (`checkout --`, `reset --hard`, `clean -fdx`) on out-of-scope files are irreversible and erase context the implementer never had.
 - **future application**: dispatch briefs for SDD implementers / fix-subagents MUST bar destructive git ops outside the named task files. If the tree is dirty with unrelated changes, leave them — flag to controller, never revert. Controller owns cross-file git state; the executor touches only its own paths. Pairs with [[LRN-125]]/[[LRN-126]] as the "executor stays in its lane" family.
 ## LRN-128 — a version RESET (backward bump) is editorial reflection, not the forward-only release-executor
 - **pattern**: first public release cut as v1.0.0 from an internal 4.x lineage = backward version.txt (4.0.0→1.0.0) + CHANGELOG restructure (new public `[1.0.0]` on top, old 1.0-4.0 lineage under a `## Pre-release (internal history)` banner) + tag swap (delete v4.0.0, tag v1.0.0). The sonnet `release-executor` (release-candidate skill's mechanical prep span) assumes a FORWARD semver bump — its prep = `[Unreleased]`→`[X.Y.Z]` move + version increment. Cannot derive a backward reset, the CHANGELOG restructure, or the existing-`[1.0.0]`-collision handling.
 - **why**: a reset is a JUDGMENT act (what's public vs pre-release, how to frame the launch, what to do with the old lineage) = reflection tier, not the executor's mechanical forward move.
 - **future application**: version RESET or any non-standard release → do PREP MANUALLY inline (big model), use `gitflow.sh` only for branch mechanics (start/finish), KEEP the skill's human gates (when-to-release, push). Don't dispatch the forward-only executor for it. [[BDR-067]] [[BDR-066]]
 ## LRN-129 — `git cherry` (patch-id) proves a stale/divergent branch has nothing orphaned before you delete it
 - **pattern**: a stale pushed `release/1.0.0` (abandoned July-4 prep) sat 227 commits behind develop. Before deleting it, `git cherry -v develop release/1.0.0` → `+` = unique by patch-id, `-` = equivalent patch already in develop. Content-checked each `+` (rtk PATH fix, drop-AI-attribution settings, find-skills drop, BLK-016/LRN-098/101, EVAL-015, features) → all present in develop → safe to delete, nothing orphaned.
 - **why**: `git rev-list develop..branch` counts by SHA — a feature merged into BOTH branches shows as "unique" (distinct merge commit) though its CONTENT is in develop. `git cherry` uses patch-id, so `-` = "same change already here". The `+` set still needs a CONTENT check (patch-id misses re-applied/squashed changes).
 - **future application**: before abandoning/deleting a divergent branch, `git cherry -v <mainline> <branch>` then content-verify the `+` commits. This is HOW you prove the [[LRN-117]] fork-orphans-code risk is absent. [[LRN-116]]
 ## LRN-130 — Claude Code deny glob = absolute, no exemption mechanism — 2026-07-16
 - **Pattern**: a `deny` rule cannot be carved out. 3 levers, all dead — verified in permissions.md, not inferred:
  - `allow` more specific → ✗ `:33` "deny, then ask, then allow… rule specificity doesn't change the order"; `:35` "a deny rule can't carry allowlist exceptions".
  - negation `!` in glob → ✗ absent from rule syntax.
  - PreToolUse hook `permissionDecision:"allow"` → ✗ `:361` "Hook decisions don't bypass permission rules".
 - **Corollary**: hooks only HARDEN, never loosen (why config-protection.sh works). Only lever on a deny = the glob's own shape. Get it right first — no patch layer above it.
 - **Also**: `Write(path)` never matches file perms; `Edit(path)` covers ALL file-editing tools (`:242`; `:244` prescribes it). Startup warns on `Write(glob)` — but does NOT warn on a dead `allow` under a `deny`.
 - **Also**: `Read` deny hits Grep + Glob too (`:242`). Bash NOT covered — `Bash(cat .env)` bypasses `Read(**/.env)` unless separately denied.
 - **Applied**: [[BDR-069]].
 ## LRN-131 — WebSearch is not verification for a number; require a primary source — 2026-07-17
 - **pattern**: a statistic reaches a client only with `<claim> — <source, year, venue|vendor> — measured: <what the source ACTUALLY measured> — <link>`. The `measured:` field is what catches the error.
 - **context**: "VSI (Visual Stability Index) — new 2026 Core Web Vital" lived in seo-analyzer as a threshold, stated as fact. It does NOT exist — absent from the CrUX API metric list AND web.dev; 10 SEO blogs cross-cited it into apparent consensus, several falsely claiming CrUX already collected it. And EVERY stat in agents/resources/ was real but grafted onto the wrong subject: Aggarwal 40% = ALL methods (pinned on "add stats"); AccuraCast 58.9% = Person-schema PREVALENCE (pinned on QAPage lift, meaning inverted — FAQPage was 1.8%); LLMrefs 3x = brand-mentions-vs-backlinks (pinned on freshness decay).
 - **future**: the failure mode is plausible RECOMBINATION — what a model half-remembering a search produces. The old rule "cross-check via WebSearch" LAUNDERS the blog consensus instead of catching it. An API's metric list (e.g. developer.chrome.com/docs/crux) is decisive: a metric the API can't return is one you can't score. See [[LRN-132]] (same family, subagent summaries).
 ## LRN-132 — a subagent summary is a claim, not a fact — verify before planning on it — 2026-07-17
 - **pattern**: relaying a subagent's characterisation without checking it propagates plausible-but-false. Treat every relayed finding as a claim to verify against a primary source or a live test.
 - **context**: 7 disproven in one seo/geo session — "Off-page has ZERO data" (brand mentions ARE gathered, STEP 6); "the stats drive axis weights" (weight tables carry no citations); "GSC Links API is available" (endpoint doesn't exist); "a SPA-severely-limited §0 flag compensates" (never existed); "X/Twitter returns 403" (returns 200, live-tested); Common Crawl "nearest free source" (17.3 GB dead end); the whole opening inventory that founded the 20-point plan.
 - **future**: I reproduced the SAME error 3× while WRITING the fixes (X/Twitter 403 in W3, the two above in I1/I6). Contact with the REAL corrected it every time — the sitemap, the repo, the curl, the primary doc — never re-reading the spec. Measure-first before building. Corroborates [[LRN-074]] (watch the RED go red).
 ## LRN-133 — an omission must stay legible, never silent — 2026-07-17
 - **pattern**: when a tool cannot measure something, it says so IN its output — a caller must never read absence as "fine".
 - **context**: red thread of 21 commits — NAP with no canonical → finding WITHOUT direction (never pick from source majority); unmeasured backlinks → mandatory §14 line; sample → mandatory COVERAGE ratio; dropped security headers → §14 + "run /harden" pointer; capped crawl → `orphans_withheld` (the cap doesn't degrade the result, it INVALIDATES it — a partial-crawl orphan is a false orphan); SPA → refuse, don't score; N/A ≠ zero in the scorer.
 - **future**: the system already HAD the invariant (code-ceiling, §14 Annexe) but applied it in spots. Generalised it. A false signal is worse than a declared gap — the 4 features KILLED at measurement (B1/B2/B3/W2) beat 4 false-signal features. See [[LRN-131]]/[[LRN-132]] (same session, the verification discipline that feeds it).
 ## LRN-134 — resolve-then-pin in stdlib beats monkeypatching getaddrinfo — 2026-07-17
 - **pattern**: to close SSRF/DNS-rebinding on Python HTTP egress, resolve the
  host ONCE, validate every returned IP (`ipaddress`, dual-stack v4+v6), refuse
  if ANY is non-public (the multi-A vector), then connect to the exact pinned IP
  via an `http.client.HTTPSConnection` subclass whose `connect()` does
  `create_connection((pinned_ip, port))` and `wrap_socket(sock,
  server_hostname=real_host)` — SNI + cert stay bound to the real host. No
  second resolution to poison. `safe_fetch.py`.
 - **context**: the load-bearing property — classify the IP the OS RESOLVED
  (`sockaddr[0]`), NEVER the URL text. That defeats octal/hex/decimal literals,
  IPv4-mapped IPv6, NAT64, 6to4 structurally, not by enumeration (confirmed by
  the security review's fuzz). `is_global` is the decisive gate (catches CGNAT
  100.64/10 the per-flags miss); add a small extra-deny for special-use ranges
  it passes (192.88.99.0/24 6to4-relay). Redirects: re-validate EACH hop —
  urlopen followed them blind.
 - **future**: beats claude-seo url_safety.py on 3 axes — dual-stack (theirs
  IPv4-only), thread-safe by construction (theirs monkeypatches getaddrinfo
  behind a global lock), stdlib-only (theirs `requests`). A name-level guard
  (url-guard.sh) cannot see a rebind; this is the layer that can. Shell `curl`
  stays unpinnable from here → `curl --resolve`, separate.
 ## LRN-135 — a prefix-only scan for a dangerous construct is bypassable by padding — 2026-07-17
 - **pattern**: to refuse a hostile construct (DTD, directive, marker) before
  parsing, scan the WHOLE document, never a bounded prefix.
 - **context**: `_refuse_dtd` (C1b) scanned only `raw[:4096]` → a sitemap with
  >4 KB of leading comment pushed `<!DOCTYPE` past the window while
  `ET.fromstring` still parsed AND EXPANDED the entities (`&lol2;` →
  "lollollollollol", proven). Billion-laughs reopened on my own already-merged
  code. Found by the security review of the rebinding diff, not by me — fixed
  there rather than filed (root-cause discipline).
 - **future**: over ≤20 MB a full `re.search` is microseconds — no perf excuse
  for a bounded scan. Corollary of [[LRN-133]]: if you refuse a construct,
  refuse it EVERYWHERE, not just where you look first. A fresh adversarial
  reviewer attacking diff A routinely surfaces a real hole in already-shipped
  code B — see [[EVAL-020]].
 ### LRN-136 — config-protection live state follows checked-out branch's symlinked settings.json (2026-07-17)
 ~/.claude/settings.json is a SYMLINK to the repo settings.json; Claude Code hot-reloads settings on change → the config-protection PreToolUse hook's active/inactive state tracks the CURRENT branch's settings.json. On feature/drop-config-protection (hook deregistered) a protected edit passed silently, sentinel unconsumed; after gitflow-switch to a branch off develop (hook still registered) the SAME class of edit was blocked. Apply: a change that removes a settings-registered hook is live only on that branch until merged; use the one-shot sentinel for protected edits on any branch that still registers it. ([[BDR-074]] context.)
 ## LRN-137 — mode-based re-tiering beats file splits for mixed-tier agents
 - **pattern**: three planned agent splits (doc-syncer, handover-doc-writer, seo/geo analyzers) shipped as MODES + per-dispatch `model=` instead of new files; only plugin-probe justified a real new file (genuinely new role, no shared body).
 - **why**: a file split severs implicit data paths (LRN-126), relocates body-text test locks (seo-data fetch-wiring), breaks name/dispatch-string census locks, duplicates templates. A mode split keeps ALL locks and text in place; the dispatcher's gate sits BETWEEN mode dispatches; call-site `model=` precedence over the frontmatter pin is spike-proven (sonnet-pinned verifier ran haiku on override).
 - **fail-safe pin rule**: keep the HIGHEST tier as the frontmatter pin and override DOWN at call sites — a forgotten override then over-tiers (costs money) instead of silently downgrading judgment (costs correctness).
 - **future application**: before splitting any agent across model tiers, try MODE + `model=` first; create a new agent file only for a genuinely new role. Run-scoped `.audit/<name>-<RUNID>` files + completeness sentinel + fail-closed consumer for any cross-dispatch artifact.
 - **cousin**: [[LRN-125]] [[LRN-126]] [[BDR-077]].
@@ -1,5 +1,298 @@
 # TODO
 ## 2026-07-20 — ctx7 coverage extension (feature/ctx7-coverage, BDR-078)
 Close the 4 gaps from the ctx7 coverage audit: /feat //bugfix + ad-hoc coding
 never consult ctx7; fast-libs list hardcoded 3×; zero deterministic backstop.
 - [x] (d) `lib/fast-libs.sh` — single source of truth: `detect` +
      `cache-status` verbs; JS (package.json exact/scoped keys) + Python;
      7-day cache freshness. LC_ALL=C sort (locale-independent order).
 - [x] (c) `hooks/ctx7-reminder.sh` — UserPromptSubmit, once-per-session
      sentinel, fires only when fast-libs detected; settings.json
      registration (2nd ctx7 surface, deliberate refinement of BDR-053).
 - [x] (a) find-docs description — before-writing-code trigger (fast-moving
      libs, even without a doc question) + cache-first rule in body.
 - [x] (b) feater.md + bugfixer.md — fast-lib docs rule (read fresh cache,
      else ctx7 fetch max 2 topics, else NOTES cache miss + proceed).
 - [x] consumers → lib: ship-feature STEP 0c, init-project STEP 5c, onboard
      STEP 3.5 detection blocks point at fast-libs.sh.
 - [x] `lib/tests/fast-libs.test.sh` (lib verbs + hook fire/sentinel/quiet)
      — 11/0, auto-discovered by the make test glob.
 - [x] Gate: shellcheck + make test green (review-guards 5/0). BDR-078 +
      journal + CHANGELOG done. Committed on branch, NO merge (human gate).
 ## 2026-07-19 — Opus-pin dispatched judgment agents (branch feature/opus-pin-audit-agents)
 Goal: session model (Fable) = orchestration + inline reflection ONLY.
 Every DISPATCHED subagent pinned. Reverses BDR-066 "opus pins rejected"
 carve-out (context changed: session now Fable → inherit burns Fable quota
 on audits). User approved: opus for judgment agents, drop local opus pin.
 - [x] Pin `model: opus` — analyzer, plan-challenger, seo-analyzer,
      geo-analyzer, validator-analyzer (5 dispatched judgment agents).
      NOT interviewer / client-handover-writer (inline-load only → pin
      inert; they ARE the main loop = Fable by design).
 - [x] `lib/challenge-plan.md` — rewrite MODEL note (was "do NOT pin").
 - [x] `agents/plan-challenger.md` — rewrite ORCHESTRATOR PROTOCOL model note.
 - [x] `skills/onboard/SKILL.md` — add `model="opus"` to the 6
      general-purpose audit dispatches + table/description text.
 - [x] `skills/tour/SKILL.md` Phase B — text: analyzer opus-pinned /
      general-purpose with model="opus".
 - [x] `skills/client-handover/SKILL.md` — text: pipeline inline on
      SESSION model (writer inline-loaded, not dispatched).
 - [x] `lib/tests/model-routing.test.sh` — flip §F5 fm_lacks → has
      'model: opus' (5 agents), keep fm_lacks on interviewer +
      client-handover-writer, update comments (BDR-076).
 - [x] `.claude/settings.local.json` — drop `"model": "opus-4-8[1m]"`
      (local, gitignored; Fable default from settings.json applies).
 - [x] Tests: model-routing + loops-light + shellcheck + make test.
 - [x] Memory: BDR-076 append + journal line. Commit (feat + chore),
      NO merge (human gate).
 ## 2026-07-17 — STATUS seo/geo parity (branch bugfix/seo-geo-integrity — MERGED to develop, 92301fe; "UNMERGED" note was stale, corrected 2026-07-19 W0)
 PHASE 1 — integrity: **DONE 7/7**. I3 8b0c98c · I1 57c67f2 · I2 4ea2fb8 ·
 I5 64f175f · I4 e70e1d6 · I6 9da1dec · I8 acd452b. Plus 9cd7b51 (A1+A2, two
 process anomalies surfaced by dogfooding /harden at zenquality.fr from the
 wrong CWD).
 PHASE 2 — free wins: W3 fe93b79 · W1 a6d423b · **W2 DEFERRED** (see below).
 NEXT: H1 (SSRF/injection guard) → C1 (sitemap crawl). Human merge gate: all
 10 commits await review; nothing merged to develop.
 ### Plan corrections made while executing (the plan was wrong 4×)
 - **B3 KILLED** — GSC Links API does not exist. Verified against the API
  reference: Search Console v1 exposes exactly Search Analytics, Sitemaps,
  Sites, URL Inspection. A subagent hallucinated it; I doubted it in the
  plan and the doubt was right. (Its follow-on — "so Common Crawl is the
  only free source, and the 70/100 cap is mandatory" — was ALSO wrong: see
  B1/B2 KILLED below. Common Crawl is a 17 GB dead end, and Bing's
  GetUrlLinks is the only viable free source, first-party only.)
 - **I1 was an over-correction** — "Off-page has ZERO data" was overstated
  (relayed from a subagent, unverified). Brand mentions ARE gathered
  (STEP 6). Narrowed the axis definition instead of N/A-ing it; weights
  untouched to avoid churning historical scores twice.
 - **I6 framing was wrong** — I claimed 3× that the stats "drive axis
  weights". They do not; weight tables carry no citations. They drive Tier
  recommendations and, worse, land in CLIENT reports via the "Cite sources"
  rule. Reality was worse than my false version.
 - **W1 was the wrong shape** — plan said "richresults verb"; a new verb
  means a 2nd POST to the same endpoint for a payload already received.
  Extended inspect() instead.
 - **H1 moved up** (was AXE 5) — it is a PREREQUISITE of C1, not a
  follow-up. Today only $DOMAIN (user-typed) is interpolated. After C1, N
  URLs from a REMOTE sitemap flow into shell commands and fetch targets.
 ### B1/B2 (Common Crawl backlinks) — KILLED 2026-07-17, measured not assumed
 The plan said Common Crawl was the free backlink source and the 70/100 cap
 was therefore mandatory. Both premises are dead:
 - domain-edges.txt.gz = **17.3 GB gzipped** (+879 MB vertices, +2.3 GB
  ranks), measured live via HEAD. Finding one domain's inbound links means
  scanning all of it, per audit. Non-viable, and abusive toward a nonprofit.
 - The implementation everyone cites (claude-seo commoncrawl_graph.py:169)
  caps at `500 MiB` = **2.9% of the edges file**, and reports what that
  arbitrary slice held as a backlink profile. A random sample presented as a
  measurement — the exact failure class this branch exists to remove. We
  nearly copied it.
 - B2 dies with B1: nothing to cap.
 CONSEQUENCE: I1's narrowed Off-page axis (brand mentions only, backlinks +
 authority declared unauditable in §14) is the FINAL state, not a placeholder.
 Its §14 line was corrected — it used to point at Common Crawl as "nearest
 free source", which is a 17 GB dead end.
 RAISES W2's VALUE: Bing's GetUrlLinks is now the ONLY free viable backlink
 source. First-party only (never a competitor), still blocked on the client's
 Bing account.
 ### W2 (Bing) — DEFERRED, blocked on a real-world test
 Killed after 4 challenge rounds. User's model: client sites live on CLIENT
 Bing accounts, so a per-user API key means one key per client account.
 OAuth is the right model but is a swamp:
 - Redirect URI rejects ALL local forms (http/https/127.0.0.1 — user tested)
 - Refresh tokens are **rotated + single-use**, self-described non-compliant
  with OAuth 2.0 → store rewrite on every call, AND our parallel
  seo/geo dispatch would race the rotation → invalid_grant, dead token
 - Undocumented "anti-forgery token" failure on refresh, unanswered on Q&A
 - MS's own advisor recommends falling back to the API key
 - Doc contradicts itself on grant_type and the token endpoint; no library
 REVIVAL CONDITION: a client already on Bing adds the user as a Read-Only
 user → test in ~10 min whether the single API key sees DELEGATED sites
 (undocumented, nobody knows). If yes → W2 is cheap and clean (one key,
 client-owned verification, revocable, read-only, zero OAuth). If no → dead.
 Value forgone meanwhile: Bing/DDG/Ecosia query stats + index status +
 first-party backlinks. Real but modest; C1 dwarfs it.
 ## 2026-07-16 — PLAN seo/geo parity vs claude-seo (superseded by the STATUS above)
 Source: audit of github.com/AgriciDaniel/claude-seo (11.5k★, MIT, v2.2.0,
 5 mo old, 185/197 commits single author). Verdict: cherry-pick, never install
 (install.sh:49 overwrites our skills/seo/; uninstall.sh:45 glob `seo-*.md`
 deletes our seo-analyzer.md 42K it never installed; extensions/*/install.sh:42
 wipes settings.json on parse error; skills/seo/SKILL.md:119 injects Skool
 upsell footer into deliverables). Their code is real (render_page.py 428 l
 Playwright, url_safety.py 622 l SSRF, 326 tests, 320 pass) — adapt to our
 fetch.sh contract, do NOT copy wholesale (no fail-open, no tokenstore, no
 JSON shape).
 Framing: their plus-values map onto OUR integrity gaps — report claims more
 than it measured. Same bar we held their README to.
 Seam: `lib/seo-data/fetch.sh` verbs (accounts|crux|queries|inspect|forget)
 + fail-open `{"status":"degraded"}` + fixtures + tests. Everything below lands
 as NEW VERBS. No new architecture.
 ### AXE 0 — Integrity (no new deps, hours) — the score currently lies
 - [x] I1 Off-page axis scores 10-15% of FULL with ZERO data source (no API,
      no index) → today fabricated, and it feeds /client-handover. Immediate
      fix: extend existing LOCAL `N/A — requires FULL audit` pattern to FULL,
      redistribute weights. Data upgrade later (AXE 3). Honesty now, data after.
 - [x] I2 VSI (Visual Stability Index) listed in CWV thresholds but NO path
      retrieves it — neither CrUX nor PSI expose it. Phantom signal → remove
      or source.
 - [x] I3 **SAFETY** /geo standalone: geo/SKILL.md (125 l) has no STEP 0, no
      confirmed-NAP collection — but geo-analyzer OWNS JSON-LD NAP. Standalone
      /geo on a local business can write unverified NAP with zero LRN-032
      protection. Real bug, not cosmetic.
 - [x] I4 Security headers counted 3× (seo-analyzer STEP 4 scores them in
      Technical axis; depth-matrix.md says drop unless indexability; /harden
      re-audits /100 with 3 validators). Contradiction between dedup rule and
      agent spec → pick one owner.
 - [x] I5 Report says "audit", measured 5-15 sampled pages. State coverage %
      explicitly in §0 until AXE 2 lands.
 ### AXE 1 — Free wins on auth we ALREADY have (fetch.sh verbs)
 - [x] W1 `richresults` verb — GSC URL Inspection already returns
      `richResultsResult`; our OAuth already carries the scope. Programmatic
      rich-results validation on real Google data. **BEATS claude-seo**: their
      README:314 "dual validator (Rich Results Test + Markup Validator)" is
      FALSE — grep of all .py = zero calls, they are hyperlinks a human clicks.
      Today our JSON-LD validity is LLM-read only.
 - [x] W2 `bing` verb — Bing Webmaster API, free. Closes the Google/Bing
      asymmetry (Google = full OAuth layer, Bing = manual checklist) while
      /geo targets ChatGPT Search, which indexes via Bing. Strategic, not cosmetic.
 - [x] W3 `sameas` resolution check — trivial curl loop. entity-seo.md lists
      "sameAs pointing to dead profiles" as a known error class and never
      checks it. ~10 lines.
 ### AXE 2 — Coverage (biggest lever: ~97% of a 500-page site unseen today)
 - [x] C1 `crawl` verb — sitemap-driven URL discovery (we ALREADY fetch
      sitemap.xml) + deterministic sampling + coverage % reported. No Chromium,
      no paid API. Turns "5-15 LLM-chosen pages" into measured coverage.
      Tradeoff vs claude-seo's link-following 500-page crawl: cheaper, but
      misses unlinked/unsitemapped pages — accept + disclose.
 - [x] C2 Dupe/cannibalization detection — becomes possible once N pages in
      hand: compare titles/H1/canonicals across the set. Free, unblocked by C1.
 - [x] C3 Internal-link graph — orphan pages + 3-click depth are TODAY stated
      as checks with no command to compute them. C1 unblocks real computation.
 ### AXE 3 — Off-page real (upgrades I1) — SUPERSEDED, see B1/B2 KILLED above
 - [x] ~~B1 `backlinks` verb — Common Crawl hyperlinkgraph~~ KILLED: edges file
      measured at 17.3 GB gzipped. Non-viable per audit; the reference impl
      caps at 500 MiB = 2.9% of the graph and calls the remainder a backlink
      profile.
 - [x] ~~B2 Honest cap at 70/100~~ KILLED with B1: nothing left to cap.
      I1's narrowed axis is the final state.
 - [x] B3 VERIFY FIRST: GSC Links API. Subagent claimed "available, OAuth
      already there" — I doubt it: Search Console API v3 has no links endpoint
      (links report is UI-only AFAIK). Verify before planning on it. Do not
      assert.
 ### AXE 4 — SPA blindness (dep decision — needs arbitrage)
 - [x] R1 `render` verb — Playwright, GATED on SPA detection (STEP 2 already
      detects framework + rendering mode). Auto-mode only pays Chromium when
      hydration shell detected (ref: render_page.py:226 logic, adapt not copy).
 - [x] R2 ARBITRAGE: heavy dep (Chromium ~300MB) vs our bash+curl purity.
      Cheaper honest alternative: on SPA, REFUSE to score on-page rather than
      score it wrong (today: curl reads source, not hydrated DOM → every
      meta/JSON-LD/heading/img grep is blind, compensated only by a §0 flag).
 ### AXE 5 — Hardening + regression (lower priority)
 - [x] H1 SSRF guard on curl paths — both agents curl user-supplied domains.
      Our own CLAUDE.md doctrine says "never trust user input". url_safety.py
      (622 l, obfuscated-IPv4 decode, DNS pinning) is a solid reference.
 - [x] H2 `drift` baseline (SQLite) — SEO.md Historique keeps only date+score+
      key changes. Their seo-drift is on-page regression detection, NOT rank
      tracking (common misread). Optional.
 ### NOT DOING (explicit, with reason)
 - Keyword volumes → Google Ads Tier 3 needs ACTIVE ad spend (~$150-300/mo);
  without spend the API returns buckets ("1K-10K"). Their own detect_tier()
  never even returns 3 (google_auth.py:642-724 caps at 2) + google-ads absent
  from requirements.txt. Not worth it.
 - Real AI SoV (ChatGPT/Perplexity citation tracking) → paid everywhere
  (SE Ranking/Profound/DataForSEO). Our current honest "not testable, here's
  what we measured instead" disclosure BEATS faking it. Keep.
 - Installing the plugin / +33 skills namespace → see destructive paths above.
 ### Keep (already beats claude-seo — do not regress)
 FR legal (LCEN/RGPD-ePrivacy/DGCCRF L121-1 — their whole repo: 2 hits, and
 dma-consent-mode-v2.md:27 tells the agent to stay out) · fix-bundle +
 ownership matrix + serial apply (their 18 agents are report-only, no
 ownership discipline) · trajectory-to-17/20 + honest code ceiling (theirs is
 flat 0-100, no legal axis) · llms.txt honest framing · NAP anti-dup-seed
 (LRN-032).
 ## 2026-07-16 — /close auto-persist memory (feature/close-auto-persist, BDR-068)
 - [x] STEP 5C: auto-finish chore→develop + push when capitalize/close branched off develop
 - [x] --no-push escape hatch; WORKING-branch + rc-3 skip; graceful push-fail
 - [x] aiguillage exception note + BDR-068
 - [x] merge feature/close-auto-persist → develop (human gate)
 ## 2026-07-16 — SHIPPED v1.0.0 first public release (BDR-067)
 - [x] versioning reset 4.0.0→1.0.0, CHANGELOG pre-release-history banner
 - [x] deleted v4.0.0 tag + stale release/1.0.0 branch (git-cherry: nothing orphaned)
 - [x] merged to main + develop, tagged v1.0.0, pushed origin (main=dc4f78b)
 - [x] USER: flip Gitea repo visibility to public (repo → Settings) — done (user confirmed)
 - [x] NEXT release continues from 1.0.0 (→ 1.0.1 / 1.1.0), NEVER back to 4.x (BDR-067)
 ## 2026-07-16 — model-routing edge fixes (bugfix/model-routing-edge-fixes)
 Post-merge ronde (4 big-model audits: dispatch-graph INTACT, loops CLOSE,
 tiering CORRECT, data-flow client-handover wired). Fixing the edge findings
 the ronde surfaced. Branch off develop, unmerged — human gate.
 - [x] F1 (real bug) feater applier carve-out — /seo,/geo dispatch feater as
      L1 applier with NO CONTRACT, but feater mandates "read CONTRACT FIRST"
      (hotfixer has the carve-out, feater didn't) → mirror hotfixer.md:16-45.
 - [x] F5 (guard) census: lock the ABSENT model: pin on seo/geo/validator-
      analyzer + client-handover-writer (stray sonnet pin would silently
      downgrade a live audit, uncaught).
 - [x] F4 (cleanup) drop interviewer's inert `model: sonnet` (reflection role,
      inline-loaded by gated init-project) + census guard.
 - [x] F2 (tier) /refactor inline-load → true-dispatch refactorer (sonnet pin
      was inert). refactorer verified dispatch-safe (no Ask/Agent, input=target).
 - [x] F3 (gate) /analyze add MODEL GATE (inline-loads the analyzer reflection
      agent, was ungated + undocumented). census: +analyze gated, +refactor excluded.
 - [x] verify: census 57/0, shellcheck clean (my files), full suite green; NO merge.
 ## 2026-07-15 — model routing (feature/model-routing)
 Spec + plan in docs/superpowers/ (transient, BDR-065). BDR-066. Branch
 unmerged — human gate.
 - [x] gate lib/model-check.sh + lib/model-gate.md (flip-tested) wired ×12
 - [x] pins: hotfixer/feater sonnet, analyzer un-pinned; SDD model:"sonnet";
      web-validate → hotfixer L1; census guard model-routing.test.sh
 - [x] /feat re-arch: reflection inline → feater sonnet executor (partial
      supersede BDR-050)
 - [x] WAVE 2 (user directive): doc/status dispatch (sonnet/haiku pins
      effective); /hotfix split like /feat (joins gated 12→13, hotfixer
      dual-use executor); /commit-change → sonnet commit-changer
      (propose/apply, gates relocated); /release-candidate → sonnet
      release-executor (human gates + version decision kept in dispatcher);
      census 36/0. Exclusion list now commit-change/doc/status/release-candidate.
 - [x] DOGFOOD (manual, next sessions): /feat live run — plan closes
      decisions, dispatch carries sonnet, verify loop in main loop; gate
      STOP on a sonnet session (LRN-079 class, not automatable here). Also
      dogfood /hotfix split + /commit-change propose/apply + /release-candidate spans.
 - [x] Explore agent: kept as built-in (inherits session = opus/fable). User
      call — search feeds reflection, silent-incompleteness risk → deserves the
      big model. Custom sonnet Explore.md created then reverted (built-in already
      inherits + no owned prompt).
 - [x] WAVE 3 (user directive): /bugfix split + /code-clean split → reflection
      inline (behind existing gate), execution → sonnet executors. bugfixer =
      pure fix+regression exec (BUGFIX-EXEC REPORT, no Agent/AskUserQuestion);
      code-cleaner = PHASE-2 exec (refactor now runs on sonnet — inline-load pin
      was inert). Both skills STAY gated. census wave-3 + loops-light repoint
      (guarded). Supersedes BDR-050 bugfix carve-out.
 - [x] WAVE 4 — client-handover (branch feature/client-handover-dispatch, off
      develop). Shape FLIPPED to REDACTION-ONLY (full read: nested audits must
      run big either way since /seo,/harden,/web-validate are gated → whole-writer
      buys ~0 extra sonnet work for ~7 extra gate-yields). Design: parent
      (client-handover-writer, inline=big) keeps STEP 1-8 pipeline + ALL gates
      native + builds a PACKAGE; new sonnet handover-doc-writer does STEP 9-16
      pure write+render, gate-free. Tasks 19-22 in plan. + MODEL GATE on skill.
 ## 2026-07-08 — full back-merge release/1.0.0→develop (chore/backmerge-release-full)
 Genèse : la revue avait porté ~5/19 commits ; back-merge complet demandé. Cherry-pick par
 catégorie, 1 commit atomique/item, make test après chaque code. Branche non mergée (gate humain).
@@ -17,10 +310,10 @@ catégorie, 1 commit atomique/item, make test après chaque code. Branche non me
      manquante ; make test GREEN + review-guards 5/0. Capitalize [[LRN-117]] structurel.
 ### Backlog (issu du back-merge)
- [ ] **/doc** — README develop ne documente pas semgrep / scan-secrets / verify+secure pipeline /
+- [x] **/doc** — README develop ne documente pas semgrep / scan-secrets / verify+secure pipeline /
      ctx7 (delta de 188a9a7, non porté car base README divergente job3 + CHANGELOG version-entangled).
      Une passe /doc doit combler ces sujets sur le README réécrit de develop.
- [ ] **release-drift advisory** ([[LRN-117]]) — check qui liste les commits `develop..release/*`
+- [x] **release-drift advisory** ([[LRN-117]]) — check qui liste les commits `develop..release/*`
      touchant du CODE fonctionnel (exclut merges, `.claude/**`, version.txt/CHANGELOG) pour revue
      de back-merge. Advisory, PAS un gate make-test dur : les cherry-picks landent avec de nouveaux
      SHA → le commit source reste dans le range → équivalence "déjà porté ?" non fiable automatiquement
@@ -76,7 +369,7 @@ PART 3 — IMPLICIT-HANDOFF (tight scope, 2 sites) — DONE:
 Capitalize DONE: LRN-112 (nesting) + BDR-060 (floor) + BDR-061 (path-b) + journal.
 - [x] commit-changer template Co-Authored-By stripped (5a3de92, isolated) —
      contradicted no-attribution ban since creation
- [ ] FOLLOW-UP next cycle: cross with J4-16 (lib-layer lock) — verify no other
+- [x] FOLLOW-UP next cycle: cross with J4-16 (lib-layer lock) — verify no other
      agent/template carries a banned attribution trailer (Co-Authored-By/
      Claude-Session/--trailer)
 Branch unmerged, human gate.
@@ -92,10 +385,10 @@ chain, read-only). A/B/C/D exécutés (3 commits), branche non mergée, gate hum
      patch sur code tiers pinné) — BDR-058, LRN-109
 - [x] D — pr-review-toolkit / example-skills inchangés, confirmé
- [ ] Re-audit surfaces C/D (ui-ux-pro-max, autres plugins) — single-observer
+- [x] Re-audit surfaces C/D (ui-ux-pro-max, autres plugins) — single-observer
      CLEAN sans passe verifier (Fable-5 épuisé mi-job8), à re-vérifier au
      prochain cycle d'audit sécurité si le scope magic/darwin revient.
- [ ] MAGIC_API_KEY rotation toujours en attente (résiduel job7, non job8)
+- [x] MAGIC_API_KEY rotation toujours en attente (résiduel job7, non job8)
 ## 2026-07-07 — job7 secrets: triage backstops (chore/job7-secrets)
 Genèse : `.audit/job7/ALL-REDACTED.json` (triage secrets multi-repo + ~/.claude).
@@ -138,7 +431,7 @@ manipuler une valeur de secret — edits sur les mécanismes seulement.
      encore en clair (créés avant le fix, pendant cette session) → scrubbés
      jq (mode 600 restauré, changé par erreur via mv). grep 78af0e36 : 0 hors
      `.env` (backups + .claude.json confirmés propres).
- [ ] A.4 Signaler à l'utilisateur : rotation MAGIC maintenant (après commit A)
+- [x] A.4 Signaler à l'utilisateur : rotation MAGIC maintenant (après commit A)
 - [x] B. Redaction dumps d'env — `hooks/rtk-rewrite.sh` étendu : pipeline simple
      (pas de `;`/`&`/`||`) + `printenv`/`env` en tête sans `VAR=... cmd` derrière
      → append `| sed -E 's/^([A-Za-z_]*(TOKEN|API_KEY|SECRET|PASSWORD|PASSWD)
@@ -189,7 +482,7 @@ manipuler une valeur de secret — edits sur les mécanismes seulement.
        (`4b5c02a9-...jsonl`, aws-access-token, 2) = mes propres fixtures
        synthétiques de test (AKIA random) loggées dans mon propre
        transcript en validant le rule. Pas un vrai secret, rien à purger.
- [ ] Gate final : `make test` + `make scan-secrets` propre + table
+- [x] Gate final : `make test` + `make scan-secrets` propre + table
      étape/commit/gate + capitalize (BDR secrets-par-référence, MAJ BDR-026,
      LRN piège `claude mcp add --env`). NOTE : `make scan-secrets` sur
      ~/.claude ne sera pas "propre" tant que `f1c9c474-...jsonl` (8 hits,
@@ -246,7 +539,7 @@ PAS en GATE-BLOCK design.profile tant que Node<24 + pas dogfoodé.
      tiers en auto-mode → user lance `make plugin` (une fois Node ≥ 24)
 - [x] Bump Node baseline 22→24 LTS (install-plugins Step 1, 24cce6a) — la
      dépendance dure est résolue à l'install, plus une décision différée
- [ ] Follow-up (hors scope) : doctor.sh check (fichier gardé) ; GATE-BLOCK
+- [x] Follow-up (hors scope) : doctor.sh check (fichier gardé) ; GATE-BLOCK
      promotion après dogfood ; dogfood réel = prochain `make plugin`
 ## 2026-07-04 — skill /tour (tir groupé multi-projets, feature/tour-skill)
@@ -304,7 +597,7 @@ LOT 1 — feature/semgrep-install (GO)
 - [x] update-all.sh step 6.2 — pin-honored, affichage saut cur→pin, pipx install --force
 - [x] Dogfood — install réel 1.168.0 via bloc extrait + idempotence (re-run = skip) + pin-match + saut affiché (1.168.0→9.9.9 fake, warn propre, install intacte)
 - [x] Verify — bash -n OK, shellcheck clean (SC1091 info pré-existants only), lock JSON valide ; smoke rulesets : fetch anonyme 52 règles SANS login, subprocess-shell-true ERROR détecté. Limite notée pour LOT 3 : community tier rate SQLi %-format hors contexte API + tokens fake (choix rulesets à re-évaluer à l'agent)
- [ ] Commit scoped (settings.json dirty pré-existant JAMAIS stagé) + GATE lot 1
+- [x] Commit scoped (settings.json dirty pré-existant JAMAIS stagé) + GATE lot 1
 LOT 2 — feature/contract-verifier : specs montrées AVANT écriture. lib/contract-interview.md + agents/verifier.md.
 LOT 3 — feature/security-auditor : agents/security-auditor.md + greffe audit-delta + onboard fallback + complément gstack-ON.
@@ -319,10 +612,10 @@ tokens but left bare tokens common in non-UI talk → ~6× false-fire THIS sessi
 palette). Fix = tighten the trigger only + a fire-log counter for measured
 re-fire decisions.
- [ ] hooks/design-toolchain-reminder.sh — drop bare design|component|composant|theme|thème|transition|frontend|front-end|palette; dashboard→\bdashboard\b; keep animation; add "front-?end design" bigram; + fire-log (time+token+excerpt)
+- [x] hooks/design-toolchain-reminder.sh — drop bare design|component|composant|theme|thème|transition|frontend|front-end|palette; dashboard→\bdashboard\b; keep animation; add "front-?end design" bigram; + fire-log (time+token+excerpt)
- [ ] lib/tests/design-toolchain-reminder.test.sh — 8 dropped tokens quiet; button/navbar/landing/glassmorphism/redesign/"frontend design"/"admin dashboard"/animation fire; ecc_dashboard.py quiet; fire logged
+- [x] lib/tests/design-toolchain-reminder.test.sh — 8 dropped tokens quiet; button/navbar/landing/glassmorphism/redesign/"frontend design"/"admin dashboard"/animation fire; ecc_dashboard.py quiet; fire logged
- [ ] Verify — shellcheck + bash -n + test PASS + live dogfood (hook now quiet on session tokens)
+- [x] Verify — shellcheck + bash -n + test PASS + live dogfood (hook now quiet on session tokens)
- [ ] GATE before finish (user); sentinel one-shot to edit the now-guarded hook
+- [x] GATE before finish (user); sentinel one-shot to edit the now-guarded hook
 ## 2026-07-03 — config-protection hook (feature/config-protection-hook)
 Goal: PreToolUse hook blocks Edit/Write to this config's quality-gate files
@@ -340,7 +633,7 @@ Bypass: CONFIG_EDIT_OK="reason" (logged). Mid-session env caveat flagged at gate
 - [x] settings.json — register PreToolUse matcher Edit|Write|MultiEdit -> hook
 - [x] Verify — shellcheck clean + 17/17 PASS + bash -n + bootstrap-safe (hook fires on Edit/Write only, not shell cp/ln)
 - [x] GATE passed — guarded list +2 (hooks/, tests/), sentinel over env-var
- [ ] Capitalize (BDR-047 corrob + LRN-090 câblé>déclaratif) + finish this branch only
+- [x] Capitalize (BDR-047 corrob + LRN-090 câblé>déclaratif) + finish this branch only
 ## 2026-06-23 — install self-sufficient + gstack on-demand par profil
 Goal: `make install`/`make plugin`/`make update` installent TOUT sans étape
@@ -432,7 +725,7 @@ Objectif : charger `## Typical pain points` + `Surface sécurité` de l'archéty
 - [x] STEP 4.5 → ajouter extraction de archetype-context.md (pain points + Surface sécurité + category) — validé sur firmware-embedded / nextjs-app-router / library
 - [x] STEP 6 dispatch cso fallback → re-écrire prompt : universal checks + sections conditionnelles par category (web / embedded / library / cli / infra / data / desktop)
 - [x] STEP 6 dispatch cso gstack ON → passer `--archetype <name> --context-file .onboard-audit/archetype-context.md` dans args
- [ ] OUT-OF-SCOPE ce fix : étendre le pattern à analyze/code-clean/doc (déjà reçoivent `ARCHETYPE: <name>`, juste pas le context-file). À faire dans un 2e passage si besoin.
+- [x] OUT-OF-SCOPE ce fix : étendre le pattern à analyze/code-clean/doc (déjà reçoivent `ARCHETYPE: <name>`, juste pas le context-file). À faire dans un 2e passage si besoin.
 ## /validate — nouveau skill W3C + WCAG (option A)
 Scope : W3C HTML validity (validator.nu API) + W3C CSS validity (jigsaw API) + WCAG a11y (axe-core CLI / pa11y / WAVE API / fallback statique). Même pattern que /harden (audit par défaut, --fix avec confirmation A/B/C/D). Rapport = VALIDATE.md racine. Complémentaire à /onboard (qui audite a11y au setup initial — /validate est l'outil on-demand réutilisable).
@@ -621,7 +914,7 @@ Goal: universal gitflow across all `bchanot/*` Gitea repos. Lib built across pri
 - [x] Dogfood PROVEN: hook whitelists `.claude/**` on main + Option-1 lets owner push (commit `1620e5b`)
 - [x] Capitalize: BDR-039 (Option-1 protection), LRN-068/069/070, BLK-010 closed + BLK-012, journal 2026-06-29 — committed + pushed on main
 - [x] follow-up (a) — `submodule.gstack.ignore=dirty` committé dans `.gitmodules` — DONE (reconcile 2026-06-29 : commit `be1dcef` sur main, mergé via hotfix/gstack-ignore-gitmodules)
- [ ] follow-up (b) — zenquality `cleanup/post-smtp-fix` rename `<type>/<name>` ou finish+delete (AUTRE repo, optionnel)
+- [x] follow-up (b) — zenquality `cleanup/post-smtp-fix` rename `<type>/<name>` ou finish+delete (AUTRE repo, optionnel)
 ## 2026-06-29 — MINOR-gate strengthening (doc-syncer) [DONE — merged develop, branch deleted]
 Read-first cartography refuted the literal premise: "strengthen MINOR gate" = 3 problems;
@@ -0,0 +1,277 @@
 # ANALYSIS: model-tiering v2 — Fable = orchestration + plan/solution reflection only; dispatched fleet tiered opus/sonnet/haiku by task complexity; split mixed-tier agents
 Produced by /analyze (main loop, Fable) + 4 subagent sweeps (2× agent-body
 classification, dispatch map, test-lock inventory), 2026-07-19. Facts verified
 against: model-routing.test.sh, challenge-plan.md, verify-secure-loop.md,
 model-gate.md, BDR-050/061/066/076, LRN-113/125/126 (read in full inline).
 Subagent-reported details not re-verified inline are marked (sub) — LRN-132
 applies: re-verify load-bearing ones before cutting code.
 ## CONTEXT
 - Current state (branch `feature/opus-pin-audit-agents`, 2 commits, UNMERGED):
  main loop = session model (Fable; model-gate blocks small models in 15
  reflection skills). Dispatched pins: opus = analyzer, plan-challenger,
  seo-analyzer, geo-analyzer, validator-analyzer (BDR-076); sonnet = 14
  executors; haiku = status-reporter. Unpinned = interviewer,
  client-handover-writer (inline-load only).
 - Two execution modes with OPPOSITE tier semantics: Agent() dispatch →
  frontmatter pin applies; inline-load ("you become it") → pin INERT, runs on
  session model. 20 inline-load sites exist.
 - Target policy (user directive): Fable does ONLY main-loop orchestration +
  reflection on plan/solution. Everything dispatched runs opus (deep judgment)
  / sonnet (standard execution) / haiku (mechanical) by ACTUAL task
  complexity. Agents mixing classes get split. Skills adapted. Zero loss, zero
  regression.
 ## KEY COMPONENTS — per-agent verdict vs target
 ### Fits, no change
 | agent | tier | note |
 |---|---|---|
 | plan-challenger | opus | coherent monolith; verdict grammar + PROOF load-bearing |
 | feater / bugfixer / hotfixer | sonnet | closed-plan executors; NEED-DECISION / BLOCKED valves |
 | security-auditor | sonnet | deterministic SAST gate; `SECURITY — VERDICT:` grammar |
 | scaffolder | sonnet (effort: high) | but see INERT-PIN below — never dispatched today |
 | status-reporter | haiku | exemplar mechanical |
 | client-handover-writer | none (inline orchestrator) | one haiku-able seam: STEP 1-2 git/context preflight |
 | interviewer | none (inline) | INTERACTIVE — asks user inline; a dispatched agent cannot ask (uniform ban). Structurally main-loop. |
 ### Tier-down candidates (no split)
 | agent | current → candidate | evidence |
 |---|---|---|
 | validator-analyzer | opus → sonnet | NOT mixed: runs external validators (authoritative), fixed severity tables, base-100 deduction scoring, allowlist-driven fix bundle; ambiguity punted to user §6. No deep judgment present. (sub) |
 | onboarder | sonnet → haiku candidate | template-fill + conditional writes; only light stack-block filtering. (sub) Also inert-pin today. |
 | release-executor | sonnet (keep, borderline) | mostly script runs + CHANGELOG templating, but carries a NEED-DECISION judgment valve (MAJOR-bump wording). (sub) |
 ### Split candidates (mixed classes inside one body)
 | agent | geometry (factual boundary) | complication |
 |---|---|---|
 | seo-analyzer | collection (STEP 2-5 curls/CWV/GSC/greps → haiku-class) / judgment (STEP 6-11 sampling, competitive, scoring, triage → opus) / templating (STEP 12-14 bundle+report → sonnet/haiku) | BDR-061: no Agent tool in analyzers (single-dispatch doctrine) → a split must be ORCHESTRATED BY THE SKILL at L1 with disk handoffs, or BDR-061 revised (nesting works ≥2.1.172 per BDR-060, but version-robust-by-design was chosen). seo-data.test.sh locks `fetch.sh` wiring strings IN the agent body (6 locks). STEP 1-2 context feeds every later step → large LRN-126 contract surface. |
 | geo-analyzer | identical 3-way geometry | same complications; shares severity vocab + sentinel |
 | commit-changer | MODE propose (narrative reconstruction + capitalize routing = deep) / MODE apply (stage+commit = mechanical) — boundary ALREADY exists as dispatch modes | 2 dispatch sites in /commit-change; per-dispatch `model=` override is an available lighter mechanism than a file split |
 | doc-syncer | drift detection + semantic doc-type analysis + MINOR/SIGNIFICANT calls (deep) / discovery + template render + PATCHED_FILES emit (mechanical) | 9 consumers on BOTH modes: dispatched ×2 (/doc, onboard) + inline-load ×7 (bugfix, hotfix, feat, init-project ×2, ship-feature, scaffolder) — LRN-125 dual-use-across-tiers hazard; runs its own user validation gate (STEP 8) → gate must be hoisted before any dispatch conversion |
 | handover-doc-writer | synthesis/vulgarization STEP 10-12 (deep) / render+deterministic gates STEP 13-16 (mechanical) | skill-leak ban list + `HANDOVER-DOC REPORT` grammar must survive |
 | plugin-advisor | detection PHASE 1 (mechanical) / complexity scoring + decision-table reasoning PHASE 2.5 (deep) | INERT PIN: inline-loaded ×4 (plugin-check, onboard, init-project, ship-feature), NEVER dispatched — sonnet pin is dead config; PHASE 4 asks the user (inline-only capability) |
 | verifier | STEP 2 evidence adjudication = deep judgment inside a sonnet procedural gate | BDR-066 kept sonnet DELIBERATELY (oracle-anchored to contract, ≤3×/loop). Tier-up = design arbitrage, not a mechanical fix. contract-verifier.test.sh locks name/tools/body (33 asserts). |
 ### INERT-PIN finding (structural gap vs target)
 scaffolder, onboarder, plugin-advisor are pinned sonnet but NEVER dispatched —
 inline-load only → they run on Fable today. doc-syncer's doc-commit steps
 (bugfix/hotfix/feat/init-project/ship-feature/scaffolder) also run inline on
 Fable. Under the target policy these are EXECUTION tasks burning Fable — a
 bigger real gap than any pin value. Each inline→dispatch conversion must hoist
 its user gates into the dispatcher first (dispatched agents cannot ask).
 ## CONSUMER MAP (summary; full tables in the dispatch-map sweep)
 - ~50 Agent() dispatch sites across 20 skills + 2 lib includes +
  client-handover-writer (9 internal dispatches, incl. skills-via-general-purpose).
 - 20 inline-load sites (7× doc-syncer, 4× plugin-advisor, 3× analyzer, 2×
  interviewer, 1× each onboarder/scaffolder/client-handover-writer/refactorer).
 - Includes: model-gate.md ×15 skills (+5 locked EXCLUDED), challenge-plan.md
  ×12, verify-secure-loop.md ×5, contract-interview ×5, capitalize-commit ×6,
  doc-commit ×6.
 - ~30 prose refs claim current tiers (sonnet-pinned X, opus-pinned Y, BDR-066/
  BDR-076 citations) → all go stale on tier changes (LRN-113 sweep required).
 - Only onboard uses explicit `model="opus"` dispatch params (7 sites); every
  typed agent relies on frontmatter pin; ship-feature/init-project mandate
  `model: "sonnet"` on SDD subagents by prose.
 ## CONSTRAINTS (zero-loss bar)
 1. Verbatim machine-parsed grammars must survive verbatim: `VERIFY — VERDICT:
   CONFORME | ECARTS(n) | ERROR(<reason>)`, `SECURITY — VERDICT: PASS |
   BLOCK(n) | ERROR(<reason>)`, `CHALLENGE — LENS: … — VERDICT: SOLID |
   CONCERNS(n) | FATAL(n)`, mandatory `PROOF:` lines, sentinel `READY TO APPLY
   — awaiting dispatcher confirmation`, `<NAME>-EXEC REPORT` + `STATUS : DONE
   | NEED-DECISION | BLOCKED`, `PATCHED_FILES:`, `COMMIT PLAN`, labeled score
   lines parsed by client-handover extractors, `HANDOVER-DOC REPORT`.
 2. BDR-050 + LRN-083: loops + decisions live in the MAIN loop; gates dispatched
   fresh, blind, zero iteration history. Splits must not move loop decisions
   into children.
 3. BDR-061: seo/geo/validator have no Agent tool by doctrine (version-robust
   single dispatch level). Any intra-audit split is skill-orchestrated at L1
   unless BDR-061 is explicitly revised.
 4. LRN-126: every implicit data path (ARGUMENTS flags, detected vars, STEP-N
   side outputs) must cross the new handoff contracts explicitly; census-style
   tests will NOT catch severed wires — a data-flow read per split is required.
 5. LRN-125: no dual-use agent across tiers; audit consumer routes to the
   judgment agent, execution consumer to the executor.
 6. Interactivity: dispatched agents cannot ask the user. All human gates
   (AskUserQuestion / inline approval) stay in main loop or inline-loaded
   orchestrators. doc-syncer STEP 8 + plugin-advisor PHASE 4 gates must be
   hoisted before dispatch conversion.
 7. Test locks (fire on this refactor): model-routing (~61, epicenter — pins,
   dispatch strings, gate wiring loops, `model="opus"` literals, BDR-076 token),
   plan-challenger (~43 — frontmatter, grammar, challenge-plan doctrine
   sentences incl. BDR-066 token), loops-light (40 — verify-secure-loop 10
   sentences, sonnet pins, report grammars, "Agent" ABSENT from
   bugfixer/hotfixer — substring-fragile), contract-verifier (33),
   security-auditor (31), seo-data (6 body-wiring locks on seo/geo bodies),
   loops-heavy (19 skill prose), review-guards G3 (strict YAML on every agent
   file incl. new ones), no-vacuous-locks (no `\n` in new lock patterns —
   LRN-093), model-check (10 — tier vocabulary big/small; a new tier taxonomy
   must co-evolve witness + test). Census `for`-loops (model-routing:13-19,
   plan-challenger:42) must be edited for any new/renamed gated skill.
 8. model-gate.md prose has NO deterministic lock (include-path only) — free to
   rewrite, but behavioral-only verification.
 9. Gitflow: feature branch(es) via gitflow.sh; no merge without human signal.
   Unmerged branches in flight: `feature/opus-pin-audit-agents` (this refactor
   supersedes/absorbs it), `bugfix/seo-geo-integrity` (10 commits touching the
   seo surface → sequencing/conflict risk with a seo-analyzer split).
 10. BDR-076 survival: opus tier for judgment agents survives as baseline;
    validator-analyzer's opus pin would be superseded (tier-down); seo/geo pins
    refined by splits; challenge-plan/plan-challenger doctrine text + census
    §11 rewritten again.
 ## RISKS
 - Severed implicit data paths on splits (LRN-126 precedent: 2 silent input
  losses caught only by whole-branch review) — probability: HIGH without a
  per-split data-flow pass.
 - Consumer staleness (LRN-113): ~30 prose refs + 9 identical gate preambles +
  2 census loops — partial sweep leaves contradictory doctrine — probability:
  HIGH without whole-surface grep + new guards.
 - Lost human gates on inline→dispatch conversions (doc-syncer STEP 8,
  plugin-advisor PHASE 4) — probability: MEDIUM-HIGH; hoist-first pattern
  exists (BDR-066 wave 4 did exactly this for client-handover).
 - Census under-coverage: NEW agent files are silently unlocked unless
  model-routing/census extended per agent (worse than a red) — MEDIUM.
 - haiku reliability on long tool chains (seo/geo collection legs: GSC, CWV,
  curl loops, retry policies): only haiku precedent is status-reporter
  (short, deterministic) — MEDIUM; unproven.
 - Split overhead: 3-dispatch audit pipeline re-serializes STEP 1-2 context per
  child; latency + token duplication vs today's monolith — MEDIUM.
 - Merge sequencing with `bugfix/seo-geo-integrity` (10 commits on seo surface)
  — MEDIUM.
 - Subagent-report trust (LRN-132): (sub)-marked classifications need spot
  re-verification during design — MEDIUM.
 ## OPEN QUESTIONS (design arbitrage needed)
 1. verifier: keep sonnet (BDR-066 oracle-anchored rationale) or lift to opus
   (STEP 2 adjudication is the correctness gate)?
 2. seo/geo split mechanics: skill-orchestrated L1 pipeline (BDR-061-compatible)
   vs nested dispatch inside the analyzer (requires revising BDR-061;
   version floor OK per BDR-060)?
 3. Which inline-loads convert to dispatches (scaffolder, onboarder, doc-syncer
   doc-commit steps, plugin-advisor detection) vs stay inline as reflection?
 4. commit-changer: file split vs per-mode `model=` override at the 2 existing
   dispatch sites?
 5. haiku scope: which mechanical halves actually go haiku vs sonnet, given the
   reliability unknown on long tool chains?
 6. Gate taxonomy: keep binary big/small model-gate (guards main loop only) or
   extend model-check.sh to the full 4-tier vocabulary?
 7. Sequencing: land/absorb `feature/opus-pin-audit-agents` and
   `bugfix/seo-geo-integrity` before or during this refactor?
 ## DESIGN AMENDMENT (2026-07-19, user arbitrage — supersedes open questions)
 User approved all 7 recommendations, PLUS one addition:
 **No-inherit rule + fable pins.** No dispatched agent may inherit the session
 model anywhere. Every dispatch site carries an explicit tier: typed agents via
 frontmatter pin (`model: fable|opus|sonnet|haiku`), built-ins
 (general-purpose / Explore / Plan) via a `model=` param at EVERY call site.
 Rationale: sessions may run on another model (gate admits Opus; user may
 launch anything) — inheritance would silently mis-tier dispatched work.
 `model="fable"` lands where a dispatched child performs REFLECTION /
 ORCHESTRATION on behalf of the main loop:
 - client-handover-writer's 8 internal general-purpose skill-runner dispatches
  (/seo, /harden, /cso, /commit-change, /web-validate runs) — today they
  inherit; they host gated orchestration → `model="fable"`.
 - Doctrine line (model-gate.md or routing doctrine): ad-hoc reflection
  dispatches from the main loop (Explore digest, Plan, general-purpose) carry
  `model="fable"`; non-reflection ad-hoc dispatches carry their complexity
  tier. New census locks accordingly.
 - No TYPED agent moves to fable tier (plan-challenger/analyzer stay opus per
  approved verdicts). Inline-loads that remain (interviewer,
  client-handover-writer, analyzer-in-/analyze + DEBUG, init STEP 2) ARE the
  main loop — covered by model-gate, not pins.
 - External/gstack skills with inheriting general-purpose dispatches
  (design-shotgun, review, graphify) — external ownership (BDR-015 class):
  covered by doctrine, not edited, unless owned locally. Verify ownership at
  implementation.
 ## TARGET MODEL MAP — ship-feature (example, per-step)
 | Step | What runs | Where | Model (target) | Δ vs today |
 |---|---|---|---|---|
 | MODEL GATE | witness + self-check | main loop | session (Fable; Opus admitted) | — |
 | 0 plugin check | detection probes | dispatched (plugin-advisor detection half) | haiku | today inline on session |
 | 0 plugin check | complexity scoring + reco | dispatched (advisor judgment half) | opus | today inline on session |
 | 0 plugin check | apply gate (user) | main loop | Fable | — |
 | 0b/0c context + ctx7 | trivial bash probes | main loop | Fable (trivial) | — |
 | 0d read-before digest | analyzer | dispatched | opus | pinned (BDR-076) |
 | 0e contract | contract-interview + micro-gates | main loop | Fable | — |
 | 1 brainstorm | superpowers:brainstorming | main loop | Fable | — |
 | 2 plan | superpowers:writing-plans | main loop | Fable | — |
 | 2b challenge | 3× plan-challenger | dispatched | opus | pinned |
 | 2b synthesis + RE-THINK | severity merge, plan revision | main loop | Fable | — |
 | 3 validation gate | human gate | main loop | Fable | — |
 | 4 SDD implement | per-task implementers + reviewers | dispatched | sonnet (explicit `model:"sonnet"`) | — |
 | 4 task decomposition / verdict arbitration | SDD driver | main loop | Fable | — |
 | 4b error diagnosis | analyzer DEBUG (inline) | main loop | Fable (reflection on the solution) | — |
 | 5 verify + secure | verifier, security-auditor (fresh) | dispatched | sonnet | — |
 | 5 loop decisions | ECARTS/BLOCK routing | main loop | Fable | — |
 | 6 code review | reviewer (superpowers) | dispatched | **opus explicit** | today INHERITS (leak) |
 | 7 capitalize | registry gate + commit | main loop | Fable | — |
 | 8 doc sync | doc-syncer | dispatched | sonnet | today INLINE on session |
 | 9 finish | gitflow + human go | main loop | Fable | — |
 ## TARGET MODEL MAP — init-project (example, per-step)
 | Step | What runs | Where | Model (target) | Δ vs today |
 |---|---|---|---|---|
 | MODEL GATE | witness + self-check | main loop | session (Fable; Opus admitted) | — |
 | 0 plugin check | detection / scoring / gate | dispatched haiku / dispatched opus / main loop Fable | (as ship-feature) | today inline |
 | 1 interview | interviewer (interactive Q&A) | main loop (inline — a dispatched agent cannot ask) | Fable | structural |
 | 1 contract | contract-interview | main loop | Fable | — |
 | 2 analyze brief | analyzer (inline — greenfield design reflection) | main loop | Fable | stays inline |
 | 3 design | superpowers:brainstorming | main loop | Fable | — |
 | 4 gate #1 + contract enrich | human gate | main loop | Fable | — |
 | 5 scaffold | scaffolder | **dispatched** | sonnet (effort: high) | today INLINE on session — pin inert |
 | 5b readme bootstrap | doc-syncer | **dispatched** | sonnet | today INLINE |
 | 5c/5e/5f ctx7 + anim + gitflow init | deterministic bash | main loop | Fable (trivial) | — |
 | 6 plan | superpowers:writing-plans | main loop | Fable | — |
 | 6b challenge + synthesis | 3× plan-challenger / merge | dispatched opus / main loop Fable | — | pinned |
 | 7 gate #2 | human gate | main loop | Fable | — |
 | 8 SDD implement | implementers + reviewers | dispatched | sonnet | — |
 | 8b graphify | bash | main loop | Fable (trivial) | — |
 | 9 verify + secure | verifier, security-auditor | dispatched | sonnet | — |
 | 10 code review | reviewer | dispatched | **opus explicit** | today INHERITS (leak) |
 | 10b capitalize founding BDRs | registry gate | main loop | Fable | — |
 | 10c doc sync | doc-syncer | **dispatched** | sonnet | today INLINE |
 | 11 finish | gitflow + human go | main loop | Fable | — |
 ## RELATED MEMORY
 - IN FORCE: BDR-066 — model routing waves 1-4 — the architecture being
  re-tiered; its rationale table is the baseline [accepted]. BDR-076 — opus
  pins on dispatched judgment — starting state, partially superseded by the
  new target [accepted, this branch]. BDR-050 — verify+secure loops in main
  loop, gates fresh [accepted]. BDR-049 — verifier fresh+blind+disk-contract
  [accepted]. BDR-048 — pinned semgrep gate [accepted]. BDR-061 — fix-bundle
  → L1 apply, analyzers have no Agent tool [accepted]. BDR-060 — nested
  dispatch floor v2.1.172 [accepted]. BDR-075+amendment — challenge phase in
  12 orchestrators [accepted]. BDR-025 — unknown never silently passes
  [accepted]. BDR-022 — doc-syncer never touches .claude/ [accepted].
  LRN-125 — no dual-use across tiers. LRN-126 — splits sever implicit data
  paths; forward every consumed field. LRN-113 — whole-surface sweep + guard.
  LRN-083 — loops in main loop. LRN-093 — no `\n` in grep locks. LRN-096 —
  flip-test new guards. LRN-112 — nesting supported. LRN-105/107 — explicit
  tool bans in read-only mandates. LRN-011 — one subagent, N gated scores
  (alternative to 3-way split). LRN-057 — match mechanism to consumer.
  LRN-102 — final-text-only rendering guarantee. LRN-132 — subagent claims
  need verification.
 - ALREADY SEEN: BLK-004 — renamed/deleted agent files broke a consumer wrapper
  [resolved] (rename sweep discipline). EVAL-023 — BDR-066 post-merge ronde
  found 5 edge gaps [done] (plan a ronde here too). EVAL-026 — 3-way plan
  challenge caught 4 real BLOCKERs on its own plan [done] (run it on this
  refactor's plan).
 - NON-BINDING: ~200 remaining headings surfaced nothing binding beyond the
  above — BDR-067/068/069 (release/permissions), LRN-first-100 (tooling),
  BLK-005..017 (env) — counted, not detailed.
 - SELECTION: scanned ~230 headings — surfaced 28 = in-force 22 + seen 3 +
  non-binding (counted).
@@ -0,0 +1,295 @@
 # PLAN: model-tiering v2 — full framework re-tier + splits
 Input: `.claude/tasks/plans/2026-07-19-model-tiering-v2-analysis.md` (read it
 first — consumer map, test locks, LRN/BDR constraints live there).
 User arbitrage (2026-07-19): 7 recos approved + no-inherit/fable-pin amendment
 + Fable scope = REFLECTION / ORCHESTRATION / PLANNING / LOGIC only.
 ## D0 — DOCTRINE (end state)
 1. Main loop (session model, gated big by model-gate) keeps ONLY: brainstorm,
   plan, contract, loop decisions, gate arbitration, human interaction,
   conversation-context work (capitalize), trivial glue bash (<~1k tokens).
   Retention criteria (any suffices): interactive | needs conversation context
   | orchestration decision | dispatch overhead > step cost.
 2. NOTHING dispatched inherits. Typed agents: frontmatter pin. Built-ins
   (general-purpose/Explore/Plan): explicit `model=` at EVERY call site.
   VERIFIED (2026-07-19 spike, closes robustness BLOCKER): `model: "fable"`
   on a dispatch resolves to claude-fable-5 at runtime (echo spike via
   general-purpose); the harness enum-validates the `model` param — an
   invalid value fails LOUDLY (InputValidationError), no silent fallback.
   Call-site `model=` takes precedence over a typed agent's frontmatter pin
   (documented Agent-tool contract); fallback direction if a call site omits
   it = the frontmatter pin, i.e. today's behavior — fail-safe, never worse.
 3. Tiers: fable = dispatched reflection-on-behalf-of-main-loop (skill-runner
   children ONLY); opus = deep judgment (audit scoring, plan critique, drift
   semantics, review, synthesis); sonnet = standard execution from closed
   instructions + collectors AND probes (wave-1 prudence — robustness MAJOR:
   plugin PHASE 1 is a ~26-call branching bash chain, not a short probe);
   haiku = status-reporter ONLY in wave 1; haiku expansion = wave 2 after
   reliability proven per candidate.
 4. Grammars/sentinels/valves survive VERBATIM (list in analysis §CONSTRAINTS).
   Loops/gates stay in main loop (BDR-050/LRN-083). Fix-bundle → L1 apply
   (BDR-061) preserved: audit agents never get the Agent tool.
 5. Every split: LRN-126 data-flow pass (enumerate child-read fields vs
   parent-set; explicit handoff contract on disk or in prompt) PLUS an
   IN-WAVE planted-input smoke proving the fields cross the dispatch boundary
   at runtime — the smoke GATES that wave's merge (confirmation MAJOR:
   enumeration is design-time reading; census can't catch severed wires; a
   split must never reach develop empirically unproven). Every change:
   LRN-113 whole-surface sweep + census lock + flip-test (LRN-096, no `\n` in
   patterns LRN-093, strict YAML G3).
 ## D1 — AGENT END STATE
 Pins (frontmatter):
 - opus: analyzer, plan-challenger, seo-judge*, geo-judge*, doc-auditor*,
  plugin-reasoner*, handover-synthesizer* (*new, from splits)
 - sonnet: feater, bugfixer, hotfixer, code-cleaner, refactorer, verifier,
  security-auditor, scaffolder (effort high), onboarder, release-executor,
  commit-changer, doc-syncer (patcher half), validator-analyzer (TIER-DOWN
  from opus), seo-worker*, geo-worker* (2-way split per domain — simplicity
  MAJOR: collector+templater both sonnet in wave 1 → one worker file with
  `MODE: collect | template`, no cross-domain share: domain bodies genuinely
  diverge), handover-renderer* (renamed handover-doc-writer render half),
  plugin-probe* (wave-1 prudence; haiku candidate wave 2)
 - haiku: status-reporter (only)
 - none (inline-only, main loop, gate-protected): interviewer,
  client-handover-writer
 Per-dispatch `model=` overrides (no new file): commit-changer propose=opus /
 apply=sonnet (2 sites in /commit-change — precedence over the sonnet
 frontmatter pin is the documented Agent-tool contract, verified direction
 D0.2; the pin stays as the no-inherit fallback = today's behavior; both
 call-site strings census-locked + W3 behavioral smoke); SDD
 implementers+reviewers
 sonnet (already prose-mandated → make it a census lock); code-review steps
 (ship-feature 6, init-project 10) = opus explicit; client-handover-writer's 8
 general-purpose skill-runners = fable; onboard's 7 general-purpose = opus
 (keep); any Explore/Plan ad-hoc reflection dispatch = fable (doctrine line in
 model-gate.md + CLAUDE.global routing note).
 Splits (each = new agent file(s) + handoff contract + census + consumers):
 S1 plugin-advisor → plugin-probe (SONNET wave 1; PHASE 1 CLI probes → PROBE
   REPORT) + plugin-reasoner (opus; PHASE 2/2.5 scoring + reco → PLUGIN CHECK
   block). PHASE 3-4 report+apply-gate HOISTED into ONE shared include
   `lib/plugin-gate.md` (simplicity MINOR — doc-commit.md ×6 pattern, never
   4 hand-copies), referenced by the 4 consumers (plugin-check, onboard
   STEP 0, init-project STEP 0, ship-feature STEP 0) — main loop. The
   pre-recommendation validation checkpoint (advisor :201-212, straddles the
   seam, can skip PHASE 4) runs IN THE CONSUMER between the two dispatches
   (correctness MINOR); its inputs (toggle-external availability,
   project-signal presence) are PROBE REPORT fields. Handoff: PROBE REPORT
   fields = plugin list, toggle state, profile, CLI/anim/monorepo/embedded
   signals + checkpoint inputs (enumerate ALL PHASE-2-read fields).
 S2 doc-syncer → doc-auditor (opus; STEP 3-4 drift + semantic analysis + A3
   MINOR/SIGNIFICANT call w/ doc-shape.sh oracle → DRIFT REPORT [AUTO]/
   [HUMAN] items) + doc-syncer (sonnet; render/patch half, keeps
   PATCHED_FILES: grammar + BDR-022 bans). Validation gate stays in
   DISPATCHER (/doc skill, orchestrator steps) — auto-mode flows: auditor →
   dispatcher applies AUTO via doc-syncer → SIGNIFICANT escalates inline.
   Consumers rerouted: /doc, onboard, + doc-commit steps in bugfix/hotfix/
   feat/init-project(×2)/ship-feature (inline→dispatch conversion) +
   scaffolder PHASE 6 (scaffolder DISPATCHES nothing — it has no Agent tool:
   README bootstrap moves to init-project STEP 5b dispatch of doc-syncer).
   PLUS (robustness MAJOR): rework `lib/doc-commit.md`'s in-thread contract
   BEFORE converting any doc-commit site — it requires the orchestrator to
   "hold the patch context" to compose the rc-0 CHANGE SUMMARY (the review
   surface that replaced the removed MINOR gate). Dispatched doc-syncer adds
   a `CHANGE SUMMARY` block to its report grammar (per patched file: what
   changed and why, ≤1 line each); doc-commit.md's composer consumes THAT
   instead of in-thread context; census-locks the new field + a planted-input
   smoke proves the summary crosses the dispatch boundary.
 S3 seo-analyzer → 2-WAY (simplicity MAJOR — 3-way was YAGNI while collector
   and templater share the sonnet tier; commit-changer mode-precedent):
   seo-worker (sonnet; `MODE: collect` = STEP 2-5 signals → SIGNALS file;
   `MODE: template` = STEP 12-14 FIX BUNDLE + sentinel + SEO.md + envelope)
   + seo-judge (opus; STEP 6-11 sampling judgment, competitive, scoring /20,
   trajectory, triage → FINDINGS+PLAN). Orchestrated by /seo at L1 (BDR-061
   conserved: no Agent tool in either). Wave-2 option: carve `MODE: collect`
   into a haiku file once proven — the mode boundary IS the future cut line.
   HANDOFF (robustness MAJOR — freshness/atomicity): run-scoped paths
   `.audit/seo-signals-<RUNID>.md` / `.audit/geo-signals-<RUNID>.md` —
   `.audit/` is the GITIGNORED derived-artifact tree (confirmation MINOR,
   LRN-124: a crash-stranded transient with scraped GSC/competitor content
   must never be committable; `.claude/audits/` keeps only the SEO.md/GEO.md
   deliverables). RUNID minted by the dispatcher per run, passed to every
   stage; the file ENDS with `COLLECTION COMPLETE — RUNID: <id>` and the
   judge FAILS CLOSED (report ERROR, never score) if the file is absent,
   RUNID mismatches, or the completeness sentinel is missing; dispatcher
   cleans the file post-run.
   DISPATCHER CONTRACT (confirmation MAJOR — fail-closed at the judge must
   not fail OPEN at the pipeline): on a judge ERROR the orchestrator
   (/seo /geo /harden /onboard) STOPS — no template dispatch, no L1 apply —
   surfaces the ERROR verbatim, retries ONCE with a fresh collect+judge,
   then escalates to the human. A mute or ERROR judge is NEVER carried into
   templating (verify-secure-loop discipline). This handler is part of the
   W5 skill rewrites, census-locked.
   Explicit field list per LRN-126 (STEP 1-2 business+tech context consumed
   by ALL later steps — full enumeration REQUIRED before cutting).
   seo-data.test.sh locks (fetch.sh wiring) move with the worker body —
   update suite same commit.
 S4 geo-analyzer → geo-worker (sonnet, 2 modes) + geo-judge (opus) — mirror of
   S3 incl. run-scoped `.audit/geo-signals-<RUNID>.md` + the same dispatcher
   ERROR contract. No cross-domain file share:
   seo vs geo bodies genuinely diverge (different checks, scoring blocks,
   envelopes) — that divergence, not LRN-125, is the reason.
 S5 handover-doc-writer → handover-synthesizer (opus; STEP 9 memory-registry
   load + STEP 10 phase clustering + STEP 12 6-chapter synthesis — STEP 9
   allocated here, it feeds the synthesis; correctness MINOR) +
   handover-renderer (sonnet; STEP 13-16 annex render, precheck apply,
   deterministic gates, HTML/PDF). client-handover-writer dispatches
   synthesizer then renderer; PACKAGE contract split per LRN-126
   (re-enumerate DEPLOY_HINTS/--skip-seo class fields — the EXACT prior
   failure). W4 MUST same-commit relock model-routing.test.sh:52-55 (the
   handover-doc-writer name + dispatch-string locks break on the rename;
   "make test green per wave" D4 invariant — correctness MINOR).
 Tier-downs (no split): validator-analyzer opus→sonnet (deterministic
   validators+tables). onboarder stays sonnet wave 1 (haiku candidate wave 2).
   release-executor stays sonnet (NEED-DECISION valve).
 Verifier: STAYS sonnet (approved — oracle-anchored gate).
 ## D2 — SKILL MAP (main loop = session model; every dispatch tier explicit)
 Gated reflection skills (model-gate kept, 15):
 - ship-feature / init-project: per the two example maps in the analysis file
  (amendment section) + S1 gate hoist at STEP 0 + doc-commit conversions.
 - feat: scope/plan/contract/loop = main; challenge 3× plan-challenger opus;
  feater sonnet; verifier+security sonnet; doc-commit → doc-auditor opus +
  doc-syncer sonnet dispatch; commit via /commit-change (propose opus / apply
  sonnet).
 - bugfix: investigation/diagnosis/contract = main (reflection); challenge
  opus (3b); bugfixer sonnet; verifier+security sonnet; doc-commit as feat.
 - hotfix: LOCATE + guard = main (logic); challenge opus when guard fires;
  hotfixer sonnet; security gate sonnet (revert-not-loop conserved);
  doc-commit as feat.
 - analyze: analyzer INLINE = main loop (it IS the reflection) — unchanged.
 - code-clean: PHASE 1 audit inline = main (audit judgment feeding a human
  gate); code-cleaner sonnet PHASE 2 (hosts refactorer inline at SAME tier —
  LRN-125 OK); re-audit sonnet inside executor.
 - seo / geo: skill = orchestration + GATED arbitrage (main); pipeline
  collector sonnet → judge opus → templater sonnet (L1 serial); appliers
  hotfixer/feater sonnet at L1; build-verify inline.
 - web-validate: validator-analyzer sonnet; hotfixer applier sonnet; loop main.
 - harden: audit dispatch follows S3 narrow-scope path (seo-judge opus on
  harden axes w/ collector reuse); direct-Edit apply stays inline (tiny
  scope, BDR-061 carve-out conserved).
 - audit-delta: axis audits dispatched opus (delta judgment); security-auditor
  sonnet; fix gate + markers = main.
 - tour: orchestration main; security-auditor sonnet; cleanup audit = analyzer
  opus (or general-purpose model="opus"); fixes via sonnet appliers; doc axis
  → S2 pipeline; reconcile axis = deterministic bash (main).
 - onboard: onboarder DISPATCHED sonnet (was inline); plugin S1 pipeline;
  analyzer opus; general-purpose audits model="opus" (kept); seo/geo → S3/S4
  pipelines; security-auditor + doc pipeline as above; synthesis
  general-purpose model="opus"; backlog arbitration = main.
 - client-handover: writer INLINE (orchestrator, main); its 8 skill-runner
  children model="fable"; handover S5 split (synth opus → render sonnet);
  gates all main.
 Excluded-from-gate skills (5, stay ungated): commit-change (propose opus /
  apply sonnet via model=; approval gates main); doc (S2: auditor opus →
  gate main → patcher sonnet); status (haiku); release-candidate (executor
  sonnet; version/when/push decisions main); refactor (refactorer sonnet).
 Memory/util skills (capitalize, close, prune-memory, reconcile, learn,
  profile, skills-perso, gitflow, deploy, plugin-check(S1), status): main
  loop by nature (conversation context, human gates, deterministic bash) —
  no dispatch changes except plugin-check S1.
 External/gstack skills (graphify, design-*, review, qa, ship, investigate…):
  NOT edited (external ownership, BDR-015 class) — covered by doctrine line;
  local wrapper skills only if locally owned. Verify ownership per file
  before touching (symlink → skip).
 ## D3 — WAVES (each = gitflow feature branch, tests green, census extended)
 W0 SEQUENCING: merge `feature/opus-pin-audit-agents` → develop (baseline,
   human gate). `bugfix/seo-geo-integrity` is ALREADY MERGED (correctness
   MAJOR — the TODO.md "UNMERGED" note was stale; verified `92301fe` is an
   ancestor of develop AND this branch): no arbitrage, no W5 wait — one-line
   ancestry re-check in W0 + fix the stale TODO.md entry (reconcile-class
   correction). Absorb the analysis+plan files into the new feature branch.
 W1 NO-INHERIT ENFORCEMENT (small, high-value): code-review model= opus
   (ship-feature 6, init-project 10); client-handover-writer 8× model="fable";
   doctrine line in model-gate.md + census locks (`model="fable"`,
   `model=` presence per site); SDD sonnet prose → census lock. Prose sweep
   of stale BDR-066/076 claims touched by W1.
 W2 INLINE→DISPATCH CONVERSIONS: scaffolder (init 5 — liveness pings move to
   orchestrator; scaffolder loses PHASE 6 inline-load → init 5b owns README
   via S2), onboarder (onboard), doc-commit steps ×5 flows → S2 pipeline
   (gate hoist FIRST: /doc + flows own the validation gate; doc-syncer body
   loses its inline gate → census re-lock), S1 plugin split + gate hoist ×4
   consumers. Data-flow pass per LRN-126 on each (fields enumerated in the
   wave's contract file before edits).
 W3 TIER MOVES: validator-analyzer → sonnet (pin + prose + census flip);
   commit-changer per-mode model= (2 sites + prose + census).
 W4 S5 handover split (synth opus / render sonnet) + PACKAGE re-enumeration.
 W5 S3/S4 seo/geo pipelines: worker(2-mode)/judge ×2, /seo /geo /harden
   /onboard rerouted, seo-data.test.sh moved locks, run-scoped signals
   handoff (RUNID + completeness sentinel + fail-closed judge),
   envelope/sentinel/score grammars verbatim, COVERAGE lines preserved.
 W6 DOCTRINE + CLOSE-OUT: model-gate.md rewrite (protects main loop; tier
   table; fable-dispatch doctrine), challenge-plan.md + plan-challenger
   ORCHESTRATOR PROTOCOL text (keep BDR-066+BDR-076 tokens per census, add
   BDR-077), census consolidation (model-routing new sections; every new
   agent: YAML G3, pin lock, dispatch-string lock, AskUserQuestion/Agent
   bans), LRN-113 whole-surface prose sweep (~30 refs list in analysis),
   BDR-077 + LRN entries + journal, EVAL-023-style post-merge ronde.
   Per-split planted-input smokes run IN their own waves (W2/W4/W5, merge
   gates) — W6 is the consolidated ronde only, never the first empirical
   proof of a split.
 ## D4 — ZERO-REGRESSION PROTOCOL (every wave)
 - Before edits: wave contract file (.claude/tasks/contracts/) with FILE SCOPE
  + acceptance criteria; challenge-plan on THIS plan (done once, below);
  verify-secure-loop on each wave's diff (verifier sonnet + security sonnet).
 - Grammar diff-guard: `grep -F` each verbatim marker (analysis §CONSTRAINTS
  list) pre/post per wave — zero drift.
 - Census: flip-test every NEW lock (plant violation → RED) before trusting.
 - `make test` green per wave; no wave merges without human signal (gitflow).
 - Rollback story (robustness MINOR — waves are textually interdependent, an
  early wave is NOT independently revertible after later merges): revert in
  REVERSE merge order, or revert the whole stack; never a mid-stack single
  revert. Pre-merge, the rollback unit is the wave branch.
 ## CHALLENGE LOG (2026-07-19 — 3 blind lenses on plan v1)
 - correctness: CONCERNS(2) — seo-geo-integrity phantom sequencing (fixed W0);
  commit-changer precedence ambiguity (fixed D1 + D0.2 citation + W3 smoke);
  3 MINORs (S5 STEP 9 + W4 relock; plugin checkpoint seam; templater label)
  — all fixed in place.
 - robustness: FATAL(4) — BLOCKER fable-dispatch unverified → CLOSED by spike
  (D0.2: resolves to claude-fable-5, enum-validated, loud failure); doc-commit
  in-thread contract (fixed S2: CHANGE SUMMARY crosses the report grammar);
  plugin-probe haiku contradiction (fixed: sonnet wave 1); signals handoff
  freshness (fixed S3: RUNID + sentinel + fail-closed); rollback claim
  (fixed D4).
 - simplicity: CONCERNS(1) — 3-way seo/geo YAGNI → 2-way worker/judge (fixed
  S3/S4); twin-templater share (dissolved by 2-way; divergence stated);
  plugin gate ×4 copies → lib/plugin-gate.md include (fixed S1).
 ## EXECUTION NOTES (2026-07-19 — as-built deviations, all justified in-commit)
 - S2/S3/S4/S5 shipped MODE-BASED (one agent, modes + call-site `model=`)
  instead of file splits — the challenge's own commit-changer precedent
  generalized; locks and body text stayed in place (LRN-137). plugin S1
  kept the `plugin-advisor` NAME for the reasoner (repinned opus) — only
  plugin-probe is a new file.
 - seo/geo keep the OPUS pin (not sonnet+judge-override): fail-safe
  direction — a forgotten override over-tiers, never downgrades. /harden
  narrow-scope + /onboard report-only keep legacy no-MODE single-shot on
  that pin.
 - W0's seo-geo-integrity arbitrage was phantom (branch already merged) —
  TODO.md corrected instead.
 - Per-wave smokes ran in-wave as merge gates (confirmation-pass fix) —
  all PASSED, disk-verified. Registry note: a NEW subagent_type registers
  at next session start; typed resolution re-checked post-restart before
  the W2 merge.
 ## CHALLENGE LOG (final)
 - Confirmation pass (fresh robustness challenger on v2): CONCERNS(2) — v1
  fixes HOLD (doc-commit CHANGE SUMMARY, plugin-probe sonnet, rollback order,
  fable spike, RUNID); 2 new MAJORs + 1 MINOR opened by the revisions, all
  fixed in v3: (a) per-split planted-input smokes moved IN-WAVE as merge
  gates (W6 = ronde only); (b) dispatcher ERROR contract on judge failure
  (STOP, no templating/apply, retry once, escalate — pipeline never fails
  open); (c) transient signals files relocated to gitignored `.audit/`
  (LRN-124). Protocol cap reached (1 re-challenge) → to the human gate.
@@ -6,12 +6,55 @@ Format follows [Keep a Changelog](https://keepachangelog.com/).
 ## [Unreleased]
 ## [1.2.1] — 2026-07-20
 ### Fixed
 - **README caught up with the code it describes** — the "Agent model routing" section still presented the BDR-066 v1 scheme (7 rows factually wrong after model-tiering v2): reframed to the BDR-076/077 4-tier table verified against agent frontmatters (opus-pinned judgment agents, per-mode splits for doc-syncer / handover-doc-writer / seo-geo pipelines, plugin-probe added, unpinned inline agents listed as such). Also: Context7 paragraph rewritten to the two-surface model (find-docs = sole doc-fetch surface, `ctx7-reminder` hook = scoped session nudge, BDR-078), `hooks/` tree line now mentions the ctx7 reminder, and the `/ship-feature` workflow block gained its STEP 2b (adversarial plan-challenge) line. Docs-only release — no code change.
 ## [1.2.0] — 2026-07-20
 ### Added
 - **ctx7 coverage extension (BDR-078)** — the "consult current docs before coding against a fast-moving lib" doctrine now covers every code path, not just the two big pipelines. (1) `lib/fast-libs.sh`: single source of truth for fast-lib detection (`detect` / `cache-status` verbs; JS package.json anchored keys + Python requirements/pyproject; 7-day `.ctx7-cache/` freshness; locale-independent sort), replacing three hardcoded lists (`/ship-feature` STEP 0c, `/init-project` STEP 5c, `/onboard` STEP 3.5). (2) `hooks/ctx7-reminder.sh`: once-per-session UserPromptSubmit nudge when the project carries fast-libs and the cache is missing/stale — closes the ad-hoc-coding gap. (3) find-docs description extended with a before-writing-code trigger + a cache-first rule (read fresh cache, tee fetched docs back into it). (4) feater/bugfixer executor briefs gain the fast-lib docs rule (read fresh cache, else 2-topic `npx ctx7@latest` fetch, else report `ctx7 cache miss` and proceed). Second deliberate ctx7 surface — a scoped refinement of BDR-053's single-surface rule, not a reversal.
 - **Adversarial plan-challenge phase** — reflection orchestrators now run a blind 3-lens challenge (correctness / robustness / simplicity) via a dedicated `plan-challenger` agent before implementation; severity-driven (a single-lens BLOCKER stops the plan), report-only. `/hotfix` joins behind a logic-only guard: cosmetic fixes skip it, logic fixes get challenged, a BLOCKER reroutes to `/bugfix` (BDR-075).
 - **seo-data engine: measured coverage + new verbs** — the `/seo` FULL audit measures instead of feeling: `sitemap` verb gives COVERAGE a real denominator (source/live split); internal-link graph computes orphan pages + click depth; cannibalisation detected from GSC's own query data; `rich_results` surfaced from URL Inspection data already fetched; `sameAs` profiles actually resolved; `schema_gen` generates JSON-LD instead of only auditing it; `content_quality` runs a deterministic filler/AI-slop scan; the axis score is computed, not felt; `drift` baseline reports regressions vs changes. SPA pages: the audit refuses to score what JS paints instead of scoring the empty shell (no Playwright dependency). Common Crawl backlinks were measured (17 GB edges file) and killed as a source — the Off-page axis stays scoped to what is actually measured.
 ### Changed
 - **Model-tiering v2: 4-tier explicit routing (BDR-076/077)** — the session model (Fable) does main-loop reflection/orchestration only; every dispatched subagent is explicitly tiered: judgment agents pinned opus (analyzer, plan-challenger, seo/geo audit agents…), mechanical executors sonnet, skill-runner children fable — nothing inherits silently. Mode-based splits so pins take effect: doc-syncer audit(opus)/patch(sonnet), handover-doc-writer synthesize(opus)/render(sonnet), seo/geo collect(sonnet)/judge(opus, fail-closed)/template(sonnet), plugin gate split probe(sonnet)/advisor(opus). Census locks (125) + per-wave planted-input smokes.
 - **config-protection edit-block guardrail removed** (BDR-074) — the hook blocked more than it protected; deny-list design pass recorded in BDR-069.
 - graphify vendored skill dist synced 0.9.6 → 0.9.15.
 ### Fixed
 - **seo/geo integrity pass (I1–I8)** — Off-page axis scoped to measured data only; VSI (an SEO-blog fiction) removed from CWV thresholds; NAP direction rule ported into geo-analyzer (standalone `/geo` can no longer write unverified NAP); security headers no longer double-counted (`/harden` owns them); sampling coverage disclosed instead of implied; stats reattached to the claims they support; phantom audit precondition dropped. Plus two real bugs caught by a second-site backtest and two process anomalies from live dogfooding.
 - `settings.json` Write() deny rules were inert — converted to Edit() rules, closing the write hole they left open.
 - Model-routing W6 ronde: 6 findings closed (README bootstrap path, 2 census gaps, 3 stale refs).
 ### Security
 - **`safe_fetch` resolve-then-pin** in `lib/seo-data` — DNS-rebinding closed on audit fetches: the audited host is resolved once, validated, then pinned for the actual fetch.
 - **`url-guard`** — shell-injection + local-target refusal before any user-supplied or sitemap-crawled URL reaches curl (SSRF guard on the seo/geo fetch paths).
 ## [1.1.0] — 2026-07-16
 ### Added
 - `/close` + `/capitalize` now auto-persist the memory they write. When the ritual branches a `chore/*` branch off develop, it finishes that branch into develop and pushes `origin/develop` automatically (new STEP 5C), so capitalized decisions / learnings / evals reach the next session instead of stranding on an unmerged branch. Scoped to memory-only ritual commits: a `--no-push` flag holds the commit on the branch instead; a run on a feature branch (where the memory already rides the work) or an unsafe git state skips the auto-persist; and a failed push leaves the local merge intact with a manual-push note. Recorded as BDR-068, a deliberate scoped exception to the push-needs-an-explicit-go rule (which guards surprise code/release pushes, not an end-of-session memory persist).
 ## [1.0.0] — 2026-07-16 — Initial public release
 First public release of claude-config. The feature set below is the
 accumulated work previously staged as internal versions 1.0.0–4.0.0
 (see "Pre-release (internal history)" further down for that lineage).
 ### Changed
 - BREAKING(layout): repo-root global memory renamed CLAUDE.md → CLAUDE.global.md; run `bash link.sh` once after pulling (doctor.sh now checks the exact target)
 - graphify skill dist refreshed 0.8.45 → 0.9.6 (out-of-band `make plugin`; SKILL.md + query/extraction references updated by the generator).
 - `/deploy` checklist reshaped on first-real-run feedback, in two passes: runbook steps are **one command per line, interactive-session style** (an early step opens the ssh session; later lines run on the box; local steps say "from your machine") instead of folded `ssh host "cd … && …"` one-liners — step = comment header + command lines up to the next blank line, a `@delta:` directive governs the whole block; and the checklist is now **display-only** — `NEXT.sh` is no longer written at all (throwaway artifact; `PENDING.json` + the live runbook regenerate it in any session) and every hand-back **ends the turn with the full checklist as the final text, no tool call after it** (a checklist printed above a blocking question tool was observed never reaching the user). Template `templates/deploy/PROCEDURE.md` restyled to match.
 - `settings.json`: `inputNeededNotifEnabled: true` adopted (harness notification toggle); committed layout otherwise unchanged.
 - gsd-pi upgraded 2.64.0 → 3.0.0 — `status-reporter` output parser adapted to the ADR-013 cutover.
 - `hotfixer` pinned `model: sonnet` (seo/geo/web-validate L1 applier); `analyzer` haiku pin removed (inherits the session model).
 - ship-feature / init-project: SDD implementation + review subagents dispatched with `model: "sonnet"`.
 - web-validate `--fix`: bundle applied via `hotfixer` at L1 instead of inline Edit (BDR-061 alignment).
 - Model routing wave 2 — the pure-execution + reflection-split skills stop running execution on the big session model. `/doc` and `/status` now **dispatch** their agent (doc-syncer sonnet, status-reporter haiku) instead of inline-loading it, so the pin takes effect. `/hotfix` split like `/feat`: reflection (LOCATE root cause) inline behind the model gate, the fix applied by a `hotfixer` sonnet executor (rewritten dual-use — it is also the seo/geo/web-validate L1 applier); revert-not-loop preserved; hotfix joins the gated group (13th). `/commit-change` dispatches a sonnet `commit-changer` (propose → dispatcher-owned approval gates → apply; grouping runs on sonnet, `AskUserQuestion` removed from the agent). `/release-candidate` dispatches a new sonnet `release-executor` for the mechanical spans (prep / finish+tag), the two human gates (when-to-release, push) and the version-number decision staying in the dispatcher.
 - Model routing wave 3 — the last two inline execution-carrying skills split like `/feat`. `/bugfix`: root-cause investigation, diagnosis and contract run inline behind the model gate; the fix + regression test are applied by a `bugfixer` sonnet executor (was a single inline agent), with the verify+secure loop staying in the main loop and the executor as its re-dispatched dev. `/code-clean`: the dead-code / style / structural audit and the approval gate run inline; a `code-cleaner` sonnet PHASE-2 executor then applies the approved scope — and the style/structural refactor (which inline-loads `refactorer`) now finally runs on sonnet, its pin having been inert under the old inline-load. Both skills stay gated (they keep reflection); their read-only-audit consumers (`onboard`, `tour`) reroute to a big-model agent so an audit never runs on the sonnet executor. Supersedes the BDR-050 "bugfix stays inline" carve-out. The built-in `Explore` search agent is deliberately left inheriting the session (search feeds reflection).
 - Model routing wave 4 — client-handover doc-generation moved to sonnet (redaction-only). The ship-and-handover pipeline (baseline audits, fix loops, commit/push, deploy pause, live validate, gate) stays inline on the big session model in `client-handover-writer` — its interactive gates work natively and its nested `/seo`/`/harden`/`/web-validate` audits inherit the big model — and only the deliverable writing is delegated to a new sonnet `handover-doc-writer` (gate-free: reads memory + git, synthesizes the 6-chapter doc from a resolved PACKAGE, runs the word-count / skill-leak / anchor gates, renders branded HTML+PDF). `client-handover` joins the gated group (it orchestrates audits = reflection). Chosen over the whole-writer dispatch: the nested audits must run big either way, so whole-writer would have added ~7 gate-yields + a resumable state machine on a client deliverable for ~zero extra sonnet work.
 ### Security
 - **Magic MCP fully ask-gated** — all four `mcp__magic__*` tools (builder, refiner, inspiration, logo_search) moved to `permissions.ask` in `settings.json`; no magic call can auto-execute. The builder opens an unauthenticated local callback server (`127.0.0.1:9221+`, `Access-Control-Allow-Origin: *`, no token check) whose POST body is injected verbatim into the tool result the model consumes — the ask-gate is the mitigation on our side (BDR-059).
@@ -23,6 +66,8 @@ Format follows [Keep a Changelog](https://keepachangelog.com/).
 - **GSC + CrUX data layer for `/seo` FULL** — `lib/seo-data/` engine pulls real Google Search Console (Search Analytics + URL Inspection) and Chrome UX Report field data into the `/seo` FULL audit: CrUX p75 field metrics become the primary Core Web Vitals signal (anonymous PageSpeed lab stays the fallback), and a "Performance GSC (90 j)" section flags position 4-10 quick wins. Multi-account via OAuth2 (`make seo-connect`, one-time consent, `webmasters.readonly` scope only) with a per-label token store (0600 file / 0700 dir, atomic write, refresh tokens redacted, gitleaks-allowlisted) so two concurrent site audits never conflict. Absent credentials degrade gracefully to anonymous PageSpeed — the audit never fails. Config: `GOOGLE_OAUTH_CLIENT_ID` / `GOOGLE_OAUTH_CLIENT_SECRET` / `CRUX_API_KEY` in `~/.claude/.env`. Engine contract documented in `lib/seo-data/README.md`.
 - **impeccable** (pbakaus, Apache-2.0) wired into the toolchain as the design counterpart of semgrep: the `/impeccable` skill (23 verbs under one command: audit, polish, bolder, quieter…) plus the 45-rule deterministic anti-pattern detector (`npx impeccable detect`, exit 0/2, `--json`). Complementary to `frontend-design` (kept — aesthetic direction at build time); impeccable adds the deterministic audit floor and per-project design context (`/impeccable init`). CLI pinned in `plugins.lock.json` (3.2.0 — a silent rules update would change audit output on unchanged code); dist is machine-owned under `skills-external/impeccable/` (gitignored, ctx7 pattern), staged-installed by `install-plugins.sh` Step 8d, refreshed pin-honored by `update-all.sh`, symlinked by `link.sh`, listed in the design/web/web-full/full profiles and the design-work routing. Requires Node ≥ 24: the install baseline is bumped from 22 to 24 LTS (NodeSource `setup_24.x` / brew `node@24`), so `make plugin` upgrades a too-old host in place; the impeccable steps still skip gracefully if Node stays below 24. Not in the design gate's GATE-BLOCK list yet — promotion deliberate, after first dogfood.
 - `/tour` skill — grouped all-axes sweep over one or several projects: security (pinned-semgrep `security-auditor` agent + `/cso` posture when gstack is ON) → cleanup → re-verify → reconcile (report-only, never edits the target TODO/registries) → doc sync, looping until a full pass applies zero fixes (bounded at 3 iterations). Fixes land on a `chore/tour-<date>` branch the skill never merges; each project gets an append-only `.claude/audits/TOUR.md` report with BREAKING tags on contract-changing security fixes. Built TDD (superpowers:writing-skills): baseline run showed silent TODO rewrites, autonomous registry writes, grep-as-security-pass, no persistent report, scope creep and an unbounded loop — each countered and verified on a seeded fixture.
 - Model routing (BDR-066): blocking model gate (`lib/model-gate.md` + `lib/model-check.sh`, flip-tested) wired into 12 reflection orchestrators; census guard `lib/tests/model-routing.test.sh`.
 - `/feat` re-architected: reflection inline (scope/plan/contract), execution dispatched to the sonnet-pinned `feater` executor; verify+secure loop decided in the main loop with fresh executor re-dispatches.
 ### Removed
 - `lib/detect-plugins.sh`: `detect_security_guidance` — dead since its re-add at `45c3507`; zero callers on any surface, including the dynamic `session-start.sh` detection loop (the banner's row derives from `enabledPlugins` instead). Nothing invokes it — removal, not a breaking change.
@@ -37,6 +82,15 @@ Format follows [Keep a Changelog](https://keepachangelog.com/).
 ### Removed
 - **find-skills** (alchaincyf) — skill-discovery helper dropped from the toolchain (install/update/link/toggle/advisor). Never used, and its `make update` refresh step had started failing on clone timeouts. The discovery use case stays reachable manually: `npx -y skills find <query>`.
 ---
 ## Pre-release (internal history)
 The versions below (4.0.0 down to the original 1.0.0) were internal
 development milestones predating the first public release. They are kept
 for provenance; the full detail lives in git history. Their numbering does
 not continue past the public 1.0.0 above.
 ## [4.0.0] — 2026-06-30
 ### Added
@@ -23,7 +23,7 @@ claude-config/
 ├── update-all.sh          # One-command update for all components
 ├── Makefile               # Unified entry point: make install / doctor / update
 ├── plugins.lock.json      # Version pinning for non-marketplace dependencies
-├── hooks/                 # Session start, statusline, RTK rewrite, config-protection + design-toolchain guards
+├── hooks/                 # Session start, statusline, RTK rewrite + ctx7 + design-toolchain reminders
 ├── agents/                # Execution units called by skills (never invoked directly)
 ├── skills/                # Entry points invoked via /skill-name
 ├── skills-external/       # Vendored skill packs (gstack submodule + installer-fetched design packs)
@@ -37,6 +37,36 @@ claude-config/
 - `templates/` = symlinked to `~/.claude/templates/` — copy into projects via `/onboard` or manually
 - **Graphify** builds a knowledge graph of any codebase (`/graphify query`), producing a navigable wiki in `graphify-out/wiki/`. This map helps Claude understand project structure, find relevant code faster, and reason across files. Essential for large-scope tasks (multi-file features, complex bugs, architectural changes). Small tasks should skip it and read files directly.
 ### Agent model routing (BDR-076/077 — model-tiering v2)
 Doctrine: the session model (Fable) does main-loop reflection ONLY —
 brainstorm, plan, contract, audit judgment, gates, loop decisions — enforced
 by a blocking gate (`lib/model-gate.md` + `lib/model-check.sh`) at the entry
 of the 13 reflection orchestrators. Nothing dispatched inherits silently:
 typed agents carry a frontmatter pin, built-ins get an explicit `model=` at
 every call site.
 | Agent | Model | Tier |
 |---|---|---|
 | feater, hotfixer, bugfixer | sonnet (pinned) | executors — code from a closed plan (feat), fix from a closed diagnosis (bugfix), fix-bundle appliers |
 | verifier, security-auditor | sonnet (pinned) | fresh gates (≤3×/loop) |
 | commit-changer, release-executor, code-cleaner | sonnet (pinned) | dispatched execution — grouping+commit / release spans / approved cleanup (audit + approval gates stay in the dispatcher) |
 | onboarder, scaffolder, refactorer, validator-analyzer, plugin-probe | sonnet (pinned) | workers — config generation, scaffold, refactor, deterministic W3C/WCAG runner, mechanical plugin probe |
 | status-reporter | haiku (pinned) | mechanical collector |
 | analyzer, plan-challenger, plugin-advisor | opus (pinned) | dispatched judgment — pre-plan analysis, 3-lens adversarial plan challenge (`/ship-feature` STEP 2b), plugin-fit reasoning |
 | seo-analyzer, geo-analyzer | opus pin (judge mode); collect/template spans dispatched `model="sonnet"` | 3-mode audit pipelines — judgment fail-closed on opus, mechanical collect + templating on sonnet |
 | doc-syncer | sonnet pin; audit mode dispatched `model="opus"` | two-mode: audit (drift judgment, opus) / patch (mechanical apply, sonnet) |
 | handover-doc-writer | sonnet pin; synthesize mode dispatched `model="opus"` | two-mode: synthesize (opus) / render (sonnet) — client deliverable |
 | interviewer, client-handover-writer | unpinned (inline-load = session model) | they ARE the main loop — a frontmatter pin would be inert |
 | Explore (built-in) | inherit session (Fable/Opus) | search feeds reflection — kept on the big model, not pinned down |
 The pure-execution skills `/doc`, `/status`, `/commit-change`,
 `/release-candidate` **dispatch** their agent (instead of inline-loading it)
 so the pin takes effect and the work leaves the big session model; `/hotfix`
 was split like `/feat` (reflection inline + gate, `hotfixer` executor) and so
 joins the gated group (13th); `/client-handover`'s nested skill-runner
 children are dispatched `model:"fable"` (they carry reflection).
 ---
 ## Fresh install (new machine)
@@ -59,9 +89,12 @@ All scripts use their own location to find the repo — run them from anywhere.
 The plugins step logs to `install-YYYYMMDD-HHMMSS.log`.
 **Optional — Context7** (fast doc lookup for React / Next.js / Prisma…): the plugins
-step installs the `ctx7` CLI and wires it into Claude Code itself — single surface =
+step installs the `ctx7` CLI and wires it into Claude Code. The doc-fetch surface is
-the `find-docs` skill; the generated `rules/context7.md` is purged by design
+the `find-docs` skill alone (BDR-053 — the generated `rules/context7.md` is purged by
-(BDR-053). If you run `ctx7 setup` manually, delete that rule or re-run `make plugin`.
+design; if you run `ctx7 setup` manually, delete that rule or re-run `make plugin`).
 A once-per-session `ctx7-reminder` hook nudges toward it when the current project
 carries fast-moving libs (`lib/fast-libs.sh`) — a scoped second surface refining
 BDR-053, not reversing it (BDR-078).
 ```bash
 ctx7 login                 # optional: OAuth / API key for higher rate limits
@@ -161,6 +194,7 @@ cd my-existing-project/
 /ship-feature "feature description"
 # → STEP 0: plugin check
 # → STEP 1-2: brainstorm + plan (superpowers)
 # → STEP 2b: adversarial plan-challenge (3 lenses, report-only)
 # → STEP 3: validation gate — user approval required
 # → STEP 4-7: implement (TDD) → review → capitalize (memory)
 # → STEP 8: sync README (doc-sync)
@@ -265,7 +265,7 @@ cd mon-projet-existant/
 | 4  | Graphify (si complexity ≥ 30%) | graphify-out/GRAPH_REPORT.md |
 | 5  | Analyze read-only (analyzer agent) | .onboard-audit/analyze.md |
 | 6  | Audits parallèles selon archétype : | .onboard-audit/*.md (9 fichiers max) |
-|    |   — dette tech (code-cleaner) |
+|    |   — dette tech (general-purpose, audit read-only) |
 |    |   — sécurité (cso si gstack ON, sinon OWASP fallback) |
 |    |   — docs drift (doc-syncer) |
 |    |   — SEO + GEO (si public) |
@@ -2,7 +2,7 @@
 name: analyzer
 description: Analyze code, codebase, or problem before any modification. Produces a factual report without proposing solutions. Use proactively before any refactoring, design, or implementation.
 tools: Read, Grep, Glob, Bash
-model: haiku
+model: opus
 memory: project
 ---
@@ -1,245 +1,59 @@
 ---
 name: bugfixer
-description: Root-cause bug-fix executor — dispatched by /bugfix. Hypothesis-driven investigation, diagnosis, minimal scoped fix with regression test.
+description: Bug-fix EXECUTOR — dispatched by /bugfix with a closed DIAGNOSIS + FIX PLAN + contract. Applies the fix and a regression test, runs the suite, reports. No investigation, no questions, no commit.
-tools: Read, Edit, Write, Bash, Grep, Glob, Agent
+tools: Read, Edit, Write, Bash, Grep, Glob
 model: sonnet
 ---
-# BUGFIX — Structured Bug Fix
+# BUGFIXER — fix executor
-Investigate, understand, plan, fix. No guessing. The iron law:
+You receive a CLOSED diagnosis + fix plan from the /bugfix orchestrator. The
-understand the root cause before writing a single fix.
+investigation already happened; your job is faithful execution, not analysis.
 Every choice was made in the plan or is a NEED-DECISION to report.
-## REQUEST
+## INPUT (in the dispatch prompt)
 $ARGUMENTS
---
+- `CONTRACT`: path to the contract file — read it FIRST; its acceptance
  criteria (symptom reproduced-then-gone + a regression test present) + FILE
  SCOPE bound everything you do.
 - `DIAGNOSIS`: root cause + evidence, from the orchestrator's investigation.
 - `FIX PLAN`: the exact edits (file:line → change) + the regression test to add.
 - `BRANCH`: verify with `git branch --show-current`; mismatch → STATUS
  BLOCKED — never create or switch branches.
 - `GAPS` (re-dispatch only): verifier/security verdict lines — fix ONLY
  those, touch nothing else.
-## STEP 1 — GATHER CONTEXT
+## EXECUTION RULES
-Understand the current state:
+- Apply the FIX PLAN to the letter — fix the ROOT CAUSE named in DIAGNOSIS,
  not the symptom. A plan hole or an open choice (naming, data shape, API
  surface, dependency) → STOP, report `NEED-DECISION` with the precise
  question. Never re-investigate or improvise a different fix.
 - Stay inside the contract FILE SCOPE. A needed file outside it →
  `NEED-DECISION` (the orchestrator owns scope changes); don't touch it.
 - Add or update the regression test the plan names — it must fail before the
  fix and pass after. Run the relevant suite incrementally; run it fully
  before reporting.
 - Follow existing code patterns and CLAUDE.md limits (function size, params,
  no global state). Keep the fix minimal — no "while we're here" cleanups.
 - Fast-moving libs (`bash ~/.claude/lib/fast-libs.sh detect .` — React,
  Next.js, Prisma…): before touching their APIs, read a fresh
  `.ctx7-cache/<lib>*.md` if present; else fetch targeted docs, max 2
  topics (`npx ctx7@latest library <name> "<q>"` then `docs <id> "<q>"`).
  ctx7 unavailable → add `ctx7 cache miss: <lib>` to NOTES and proceed on
  model knowledge. Stable techs skip this entirely.
 - FORBIDDEN: `git commit`, branch ops, push, merge, new dependencies,
  security/verifier dispatch, editing `.claude/**` or memory registries, user
  questions (you cannot ask — report instead), attribution trailers of any kind.
-```bash
+## OUTPUT — end with exactly this report (your final message)
 git status
 git log --oneline -5
 ```
 Read the error message, stack trace, or bug description.
 Identify:
 - **What** is broken (symptom)
 - **Where** it manifests (file, line, endpoint, UI element)
 - **When** it started (recent commit? always? after a deploy?)
 ```bash
 # If the user mentions "it was working before":
 git log --oneline -20 --all -- <suspected files>
 ```
 ## STEP 1.5 — DESIGN GATE
 Follow `$HOME/.claude/lib/design-gate.md`:
 - Scan $ARGUMENTS and target files for design/UI/style signals (CSS, component, layout, animation).
 - If signals found → run `design-tool-gate.sh`; if it reports INCOMPLETE,
  tell the user to run `/profile design` before proceeding.
 - If no signals → skip (zero overhead).
 ## STEP 2 — INVESTIGATE
 Trace the bug from symptom to root cause:
 1. Read the code path involved (follow the data flow).
 2. Check recent changes to the affected files:
   ```bash
   git log --oneline -10 -- <file>
   git diff HEAD~5 -- <file>  # if recent regression suspected
   ```
 3. Look for related tests — do they pass? Do they cover
   the broken case?
 4. Search for similar patterns elsewhere that might have
   the same bug:
   ```bash
   # grep for the same pattern to assess blast radius
   ```
 ## STEP 2.5 — MEMORY READ-BEFORE (blockers-first)
 Run the scan per `$HOME/.claude/lib/analyze-before-plan.md`, blockers-weighted: a resolved
 BLK may already name THIS exact root cause; an in-force BDR may constrain the fix. Emit
 RELATED MEMORY. Consumption is NATURAL — the agent emitting this IS the one writing STEP 3's
 diagnosis (reader = planner, no external skill to inject into).
 TEETH: STEP 3's DIAGNOSIS must name any binding prior (`PRIOR: BLK-xxx — known cause/fix`,
 or `honors BDR-xxx`) OR the RELATED MEMORY line states none bears. Reading blockers then
 diagnosing without naming a match is the read-then-ignore failure this prevents.
 `.claude/memory/` absent → guarded no-op, proceed.
 ## STEP 3 — HYPOTHESIZE + PLAN
 Present findings before fixing:
 ```
-BUGFIX — DIAGNOSIS
+BUGFIX-EXEC REPORT
-BUG     : <one-line symptom>
+STATUS   : DONE | NEED-DECISION | BLOCKED
-ROOT CAUSE: <what is actually wrong and why>
+FILE(S)  : <created/modified paths>
-EVIDENCE: <what confirmed it — test, trace, diff>
+TEST(S)  : <regression test added/updated + final suite run result, verbatim line>
-BLAST RADIUS: <other places affected, or "isolated">
+SMOKE    : <build/typecheck result if run, or n/a>
-
+NOTES    : <DONE: deviations (must be none) | NEED-DECISION: the exact
-FIX PLAN:
+           question + the options you see | BLOCKED: the blocker verbatim>
  1. <file:line> — <what to change>
  2. <file:line> — <what to change>
  [3. <test file> — add/update test for this case]
 RISK: <low/medium — what could go wrong>
 ```
 - If the root cause is still unclear after investigation,
  say so explicitly. List remaining hypotheses ranked by
  probability. Ask the user before proceeding.
 - If the fix is trivial after investigation (1-2 lines):
  proceed directly — no need to wait for approval on an
  obvious fix.
 - If the fix is significant (>10 lines, multiple files,
  behavior change): wait for user approval.
 ## STEP 3.5 — CONTRACT
 Run `$HOME/.claude/lib/contract-interview.md` (main loop). The DIAGNOSIS
 feeds it: REQUEST verbatim = the bug report as received; ACCEPTANCE CRITERIA
 = the symptom reproduced-then-gone + a regression test present and passing;
 FILE SCOPE = the FIX PLAN files. Questions stay proportional (a clear,
 reproduced bug → zero). It writes the contract to
 `.claude/tasks/contracts/<date>-<slug>-<HHMM>.md`; keep the path for GATE 1
 (STEP 5).
 ## STEP 4 — FIX
 **Gitflow aiguillage (before editing):** follow `$HOME/.claude/lib/gitflow-aiguillage.md`
 — your type = `bugfix`. On `main`/`develop` it branches first; on a working
 branch it's a no-op (commit in place). Never `finish`.
 Apply the fix following the plan:
 - Fix the root cause, not the symptom.
 - Add or update tests to cover the bug case (regression test).
 - If no test framework exists: document what you verified.
 - Keep changes minimal — fix the bug, nothing else.
 ## STEP 5 — VERIFY + COMMIT
 1. Run the full relevant test suite. Detection cascade (run the first that resolves):
   ```bash
   # JS/TS — package.json scripts.test
   test -f package.json && jq -r '.scripts.test // empty' package.json | head -1
   # Python — pytest config
   ( test -f pyproject.toml && grep -qE '^\[tool\.pytest' pyproject.toml ) && echo "pytest"
   test -f pytest.ini && echo "pytest"
   # Rust
   test -f Cargo.toml && echo "cargo test"
   # Go
   test -f go.mod && echo "go test ./..."
   # Make
   test -f Makefile && grep -qE '^test:' Makefile && echo "make test"
   ```
 2. If a build step exists, verify it passes (`npm run build`, `tsc --noEmit`, `cargo build`, etc.).
 3. Check for regressions in related functionality.
 4. **Fresh gates (verify + secure), bounded loops.** Steps 1-3 are your
   dev-side smoke test, NOT the gate. Run the two fresh gates per
   `$HOME/.claude/lib/verify-secure-loop.md` with `CONTRACT` = the STEP 3.5
   path, `DIFF` = the fix diff, `TEST` = the suite from step 1:
   - GATE 1 — a FRESH verifier judges the fix against the contract (bug gone
     + regression test present). CONFORME → GATE 2. ECARTS → fix, re-verify,
     max 3 → escalate.
   - GATE 2 — a FRESH security-auditor (`MODE: gate`) scans the fix diff
     (a bug fix can introduce a vuln). PASS → commit gate. BLOCK → fix,
     re-verify request THEN re-scan, max 3 → escalate.
   Nominal = one verifier + one security dispatch. Only then the commit gate.
 5. **Pre-commit confirmation gate.** Before running `git commit`, present the diff
   summary and the proposed message, then wait for approval:
   ```
   BUGFIX — READY TO COMMIT
   FILE(S) : <list>
   DIFF    : <git diff --stat>
   MESSAGE :
     fix(<scope>): <root cause description>
     <what was wrong and why>
     <what the fix does>
   Commit now? (yes / edit message / skip / amend last)
   ```
   - `yes` → run `git commit`.
   - `edit message` → user provides corrected message; redraw gate.
   - `skip` → leave changes uncommitted, exit cleanly.
   - `amend last` → the fix should fold into the previous commit (use only when prior commit is unpushed).
 6. Commit using conventional format (after approval):
   ```
   fix(<scope>): <root cause description>
   <what was wrong and why>
   <what the fix does>
   ```
 7. Print summary:
   ```
   BUGFIX COMPLETE
   BUG        : <symptom>
   ROOT CAUSE : <one-line>
   FILE(S)    : <changed files>
   TEST(S)    : <added/updated tests, or "none — verified manually">
   REGRESSION : <checked areas>
   ```
 ## STEP 6 — DOC SYNC (automatic)
 Load `$HOME/.claude/agents/doc-syncer.md`.
 Execute in automatic mode:
 `auto-mode scope: <list of files modified during this session>`
 **Then commit the docs** — follow `$HOME/.claude/lib/doc-commit.md`: it surgically commits
 ONLY the files doc-syncer patched (its `PATCHED_FILES` output), never `git add -A`, never
 `.claude/`/`CLAUDE.md` (rc 4 = a loud BDR-022 anomaly, not a silent skip), and no-ops when
 nothing was patched — the common case for a trivial change. No FINISH in an inline flow, so
 it just commits the docs on the current branch (no ordering concern).
 ## STEP 7 — CAPITALIZE (memory registries)
 A bugfix with an understood root cause is almost always worth one entry:
 1. Propose a `BLK-XXX` entry in `.claude/memory/blockers.md` pre-filled from STEP 3 diagnosis:
   - `friction` = symptom
   - `real_cause` = root cause identified
   - `solution` = the fix applied
   - `status` = resolved
 2. If the root cause exposed a **reusable pattern** (would catch the same bug elsewhere or in other projects) → also propose an `LRN-XXX` entry in `.claude/memory/learnings.md`.
 3. Present as:
   ```
   CAPITALIZE — proposé
     BLK-XXX — <friction> — resolved
     [LRN-XXX — <pattern>]   (optionnel)
   Valider ? (all / blockers-only / edit / skip)
   ```
 4. Append approved entries + update the Index. Add a line to today's heading in `.claude/memory/journal.md`.
 **Language rule**: written entries are ALWAYS in English (see CLAUDE.md "Memory registries" § Language). The interactive gate may mirror the user's language; the appended entries must not.
 If the bug was trivial and the root cause not transferable → skip with `CAPITALIZE: trivial, skip`.
 **Then commit the memory** — follow `$HOME/.claude/lib/capitalize-commit.md`: it
 surgically commits what capitalize just wrote (`.claude/memory` + `.claude/tasks`
 only, never `git add -A`) as one `chore(memory)` commit, reports the memory-commit
 hash, and no-ops if nothing was written.
 ---
 ## RULES
 - No fix without understanding the root cause first.
 - Design gate only if UI/style signals detected. See STEP 1.5.
 - If investigation reveals a design flaw requiring significant
  refactoring → stop, explain, suggest `/ship-feature` for the
  proper fix.
 - Always add a regression test when possible.
 - Keep the fix scoped. No "while we're here" cleanups.
 - If >5 files need changes → reconsider if `/ship-feature`
  is more appropriate.
@@ -1,210 +1,75 @@
 ---
 name: code-cleaner
-description: Audit codebase for dead code, style violations, and structural issues. Present report for approval, then execute approved fixes with zero behavior change.
+description: Cleanup EXECUTOR (PHASE 2) — dispatched by /code-clean with an APPROVED scope. Deletes approved dead code, hands style/structural items to the refactorer, re-audits. Zero behavior change. No audit, no questions, no commit.
-tools: Read, Edit, Write, Bash, Grep, Glob, AskUserQuestion
+tools: Read, Edit, Write, Bash, Grep, Glob
 model: sonnet
 ---
-# CODE-CLEAN — Codebase Cleanup
+# CODE-CLEANER — cleanup executor (PHASE 2)
-Two-phase cleanup: audit everything first, touch nothing until approved.
+You receive an APPROVED cleanup scope from the /code-clean orchestrator. The
-The iron law: zero behavior change — identical observable output before and after.
+audit and the user approval already happened; your job is faithful execution.
 The iron law is unchanged: ZERO behavior change — identical observable output
 before and after.
-## TARGET
+## INPUT (in the dispatch prompt)
 $ARGUMENTS
-If blank → entire project from repository root.
+- `SCOPE`: path to `.claude/audits/CODE-CLEAN-SCOPE.md` — the approved items
  (`file:line — item — severity — proposed fix`), the on-disk contract.
 - `APPROVED`: the item list the user confirmed (may be a subset of the audit),
  including any exported/public-API symbols the gate explicitly cleared.
 - `BRANCH`: verify with `git branch --show-current`; mismatch → STATUS
  BLOCKED — never create or switch branches.
---
+## EXECUTION — in order
-## PHASE 1 — AUDIT (read-only)
+### 1. Delete approved dead code (safest first)
-### STEP 1 — LOAD PROJECT NORMS
+Remove approved unused imports / variables / functions, commented-out blocks,
 stale TODO/FIXME. **Guard rail**: an exported / public-API symbol the
 `APPROVED` list did NOT explicitly clear → do NOT delete; SKIP it and record
 it under NOTES. The per-item exported-symbol consent lives in the
 orchestrator's gate — you never ask.
-Read the project's coding standards in this priority order:
+### 2. Style + structural fixes → INLINE-LOAD the refactorer
-1. `CLAUDE.md` at project root (primary authority)
+Load `$HOME/.claude/agents/refactorer.md` and continue AS the refactorer in
-2. Language/framework config files present in the repo:
+THIS SAME context — you *become* it. This is an inline load, NOT a subagent
-   - JS/TS: `.eslintrc*`, `.prettierrc*`, `tsconfig.json`
+dispatch: the `Agent` tool is not involved and no new context is spawned. Its
-   - Python: `pyproject.toml`, `setup.cfg`, `.flake8`, `ruff.toml`
+scope = the style / structural items in `SCOPE`. Its own safety process runs
-   - PHP: `phpcs.xml`, `.php-cs-fixer.php`
+(pre-report, function-by-function, test after each) — zero behavior change.
-   - Go: `.golangci.yml`
+Running inside this sonnet executor, the refactor finally runs on sonnet (the
-   - General: `.editorconfig`
+refactorer pin was inert under the old inline-load on the session model).
 3. If neither CLAUDE.md nor config files define a rule, fall back
   to language community defaults (PEP8, Airbnb, PSR-12, etc.)
-CLAUDE.md rules always win over tool configs when they conflict.
+### 3. Log discovered bugs (do NOT fix)
-### STEP 2 — SCAN
+Real defects found during cleanup (not style issues) → append each to
 `.claude/audits/BUGS-FOUND.md` (`mkdir -p .claude/audits` first): file:line,
 description, severity, discovered-while. Cleanup and bugfixing are separate
 concerns — never fix a bug here.
-Systematically scan the target for three categories of issues.
+### 4. Re-audit
-**A. Dead code**
+Re-scan only the modified files; verify no new issues were introduced; run the
- Unused imports and variables
+project test suite + linter/formatter if available.
 - Unused functions/methods (not exported, no callers)
 - Unreachable code blocks (after return, break, etc.)
 - Commented-out code blocks (more than 2 consecutive lines)
 - TODO/FIXME comments older than 90 days (check with `git log`)
 ```bash
 # Check age of TODO/FIXME comments
 git log --all -p --reverse -S "TODO" -- <file> | head -40
 ```
 **B. Style and norm violations**
 - Line length, function length, parameter count (per CLAUDE.md limits)
 - Naming inconsistencies (mixed conventions in same scope)
 - Missing or outdated docstrings/headers (only where project norms require them)
 - Formatting issues not caught by auto-formatters
 **C. Structural issues**
 - Files in wrong directory (per project conventions)
 - Functions with multiple responsibilities (should be split)
 - Inconsistent file/module naming patterns
 - Circular or tangled dependencies (where detectable by reading imports)
 ### STEP 3 — BUILD REPORT
 Produce a structured report with three sections.
 Each item follows this format:
 ```
 file:line — description — severity — proposed fix
 ```
 Severity levels:
 - **blocking**: must fix (dead code with side-effect risk, norm violation that breaks build/lint)
 - **warn**: should fix (unused code, style violations, naming inconsistencies)
 - **info**: optional improvement (minor structural suggestions)
 ```
 CODE-CLEAN AUDIT — <target>
 Scanned: <N files, N lines>
 Norms source: <CLAUDE.md / .eslintrc / PEP8 fallback / etc.>
 ═══ DEAD CODE ═══
  1. src/utils.py:42 — unused import `os` — warn — delete import
  2. src/api/handler.ts:118-134 — commented-out block — warn — delete block
  3. ...
 ═══ STYLE VIOLATIONS ═══
  1. src/core/parser.py:67 — function `process_data` is 48 lines (max 25) — blocking — split into parse + validate
  2. ...
 ═══ STRUCTURAL ISSUES ═══
  1. lib/helpers/auth.ts — auth logic in helpers/, should be in lib/auth/ — info — move file
  2. ...
 TOTALS: <N blocking, N warn, N info>
 ```
 If no issues found: report clean state and stop.
 ### VALIDATION GATE
 Present the report. Ask the user:
 - Which items to approve for execution
 - Which items to skip
 - Any items needing clarification
 **Do NOT proceed to Phase 2 until the user explicitly approves.**
 If the user says "all" or "go ahead" → approve everything.
 If the user cherry-picks → execute only approved items.
 ---
 ## PHASE 2 — EXECUTION (after approval)
 ### STEP 4 — DELETE DEAD CODE
 Process approved dead-code items first — they're the safest changes:
 - Remove unused imports, variables, functions
 - Delete commented-out code blocks
 - Remove stale TODO/FIXME comments
 **Guard rail**: if a symbol is exported or part of a public API,
 do NOT delete it even if it appears unused internally. Flag it
 and ask for explicit per-item confirmation.
 ### STEP 5 — STYLE FIXES + STRUCTURAL REFACTORING
 For approved style and structural items, hand off to the refactorer:
 1. **Persist the handoff contract.** Write the approved items to
   `.claude/audits/CODE-CLEAN-SCOPE.md` (run `mkdir -p .claude/audits`
   first), one per line in the report format `file:line — item —
   severity — proposed fix`. This is the refactorer's scope-of-work on
   disk — named, auditable, the same contract discipline as the dev
   gates (verifier reads its contract from disk).
 2. **INLINE-LOAD the refactorer.** Load `$HOME/.claude/agents/refactorer.md`
   and continue AS the refactorer in THIS SAME context — you *become* it.
   This is an inline load, NOT a subagent dispatch: the `Agent` tool is
   not involved and no new context is spawned. Its scope = the items in
   `.claude/audits/CODE-CLEAN-SCOPE.md`.
 3. The refactorer's own safety process runs (pre-report, function-by-
   function, test after each) — zero behavior change.
 Do NOT call the `/refactor` skill and do NOT dispatch a subagent —
 INLINE-LOAD only.
 ### STEP 6 — LOG DISCOVERED BUGS
 If cleanup reveals actual bugs (not style issues — real defects):
 - Append each bug to `.claude/audits/BUGS-FOUND.md` (run `mkdir -p .claude/audits` first):
  ```
  ## [date] Bug found during code-clean
  - **File**: <file:line>
  - **Description**: <what's wrong>
  - **Severity**: <estimate>
  - **Discovered while**: <what cleanup task surfaced it>
  ```
 - Do NOT fix bugs here. Cleanup and bugfixing are separate concerns.
 ### STEP 7 — RE-AUDIT
 After all changes are applied:
 1. Re-scan only the modified files
 2. Verify no new issues were introduced
 3. Run tests if available:
   ```bash
   # detect and run project test suite
   ```
 4. Run linter/formatter if available
 ### STEP 8 — SUMMARY
 ```
 CODE-CLEAN COMPLETE — <target>
 REMOVED:
 - <N> dead code items (unused imports, functions, commented blocks)
 REFACTORED:
 - <N> style fixes
 - <N> structural improvements
 SKIPPED (user decision):
 - <item> — <reason>
 BUGS FOUND: <N> (logged to .claude/audits/BUGS-FOUND.md)
 TESTS: passing / no test suite / <failures>
 ```
 ---
 ## RULES
- Zero behavior change. If you're unsure whether a deletion changes
+- Zero behavior change. Unsure a deletion is safe → leave it, record under NOTES.
-  behavior, leave it and flag it — never guess.
+- No "while we're here" scope creep — only the APPROVED items.
- No "while we're here" scope creep. Only fix approved items.
+- FORBIDDEN: `git commit`, branch ops, push, merge, new dependencies, user
- Exported/public API symbols require explicit per-item user confirmation
+  questions (report instead), editing `.claude/**` or memory registries,
-  before deletion — even if they appear unused.
+  attribution trailers of any kind.
- Bugs go to .claude/audits/BUGS-FOUND.md, not fixed in this workflow.
+
- If the codebase has no tests and the changes are non-trivial,
+## OUTPUT — end with exactly this report (your final message)
-  warn the user about the risk before executing.
+
- No plugin check (lightweight skill, not an orchestrator).
+```
- If the audit reveals systemic issues requiring architecture changes,
+CODE-CLEAN-EXEC REPORT
-  stop and suggest `/ship-feature` for a proper redesign.
+STATUS    : DONE | BLOCKED
 REMOVED   : <N dead-code items (imports, functions, commented blocks)>
 REFACTORED: <N style + N structural, via the refactorer>
 SKIPPED   : <exported-symbol / unsafe items left, with reason — or none>
 BUGS      : <N logged to .claude/audits/BUGS-FOUND.md — or none>
 TESTS     : <suite result verbatim, or "no test suite">
 NOTES     : <BLOCKED: the blocker verbatim; DONE: none>
 ```
@@ -1,11 +1,17 @@
 ---
 name: commit-changer
 description: Retrace-and-commit engine — dispatched by /commit-change. Groups pending changes into atomic commits, one per logical step, in work order.
-tools: Bash, Read, Grep, Glob, AskUserQuestion
+tools: Bash, Read, Grep, Glob
 model: sonnet
 ---
 # Git Smart Commit
 > MODEL (BDR-077): `MODE: propose` is dispatched with `model="opus"` (the
 > call-site override — narrative reconstruction + capitalize routing are
 > judgment); `MODE: apply` runs on the sonnet frontmatter pin (mechanical
 > staging/committing of an approved plan).
 Reconstruct the development narrative from a working directory. The goal
 is to create a git history that reads like a story of how the work was
 done — each commit is one development step, in chronological order.
@@ -16,7 +22,23 @@ needed Z, then I cleaned up W." A single step may touch code + tests +
 docs if they were done together. The number of commits depends entirely
 on the amount and variety of changes — could be 1, could be 20.
-## Workflow
+## Dispatch modes
 The dispatch prompt names exactly one mode. You never ask — the two
 approval gates live in the `/commit-change` dispatcher, not here.
 - **`MODE: propose`** — gather, reconstruct, draft. Writes NOTHING (no
  `git add`, no `git commit`, no memory write). Ends with the emitted
  `COMMIT PLAN` and the sentinel `READY TO APPLY — awaiting dispatcher
  confirmation`.
 - **`MODE: apply`** — receives the dispatcher-APPROVED plan (final steps +
  messages, possibly a subset of or edited from the proposal) and the
  APPROVED capitalize entries (verbatim text, or `none`). Executes the
  commits and, if applicable, the memory write. Never re-derives the plan.
 ---
 ## MODE: propose
 ### Phase 0: Gitflow aiguillage (before any commit)
@@ -24,12 +46,15 @@ on the amount and variety of changes — could be 1, could be 20.
 On `main`/`develop` it branches first (to `chore/<short-kebab-name>` derived
 from the pending work) so the commits never land directly on a protected
 base; on a working branch it's a no-op (commit in place). Never `finish`,
-never `merge`, never `push` — this engine only commits.
+never `merge`, never `push` — this engine only commits. Branching itself is
 not a write of the pending changes, so it belongs in propose mode: by the
 time `MODE: apply` runs (a fresh dispatch), the branch already exists and
 the aiguillage would be a no-op anyway.
 **Report-only fallback.** If `develop` doesn't exist or
 `$HOME/.claude/lib/gitflow.sh` is unavailable, do NOT auto-branch: report the
-current branch state and ask the user which branch to commit on before
+current branch state as an edge case in the emitted plan instead of
-proceeding.
+branching, so the dispatcher can ask the user which branch to commit on.
 ### Phase 1: Gather context
@@ -47,6 +72,11 @@ Also check for untracked files that should be included. Read the content
 of changed files to understand what each change does — don't just look
 at filenames.
 **Merge conflicts detected** → do not build a plan. Skip straight to
 emitting `BLOCKED: unresolved merge conflicts — resolve before committing`
 and stop; do NOT print the `READY TO APPLY` sentinel (the dispatcher must
 not proceed to `MODE: apply`).
 ### Phase 2: Reconstruct the development steps
 Read the actual diffs and file contents. Reconstruct **what happened in
@@ -73,42 +103,19 @@ Guidelines:
 - **Order matters.** Commits should read in the order work happened.
  Earlier steps first.
-### Phase 2.5: Checkpoint — present plan, get approval
+**Sensitive files** (.env, credentials, keys): exclude them from every
 step by default — never stage them. Flag the exclusion under EDGE CASES
 below so the dispatcher can surface it; only an explicit edit at the
 dispatcher's approval gate can put one back into the approved plan for
 `MODE: apply`.
-Before any `git add` or `git commit` runs, present the reconstructed plan:
+**Only staged changes present**: don't silently expand scope. Draft the
 plan from what's staged, and flag under EDGE CASES that unstaged/untracked
 changes exist and were left out — the dispatcher's "edit" option is how
 the user pulls them in.
-```
+**Single logical change**: one commit is the right answer — don't
-COMMIT PLAN — <N> step(s) from working tree
+artificially split what was done as one action.
  1. <type>(<scope>): <short description>
     files: <a.ts, b.css, c.md>
  2. <type>(<scope>): <short description>
     files: <d.py>
  ...
 Approve? (all / <numbers> / edit <n> / skip)
 ```
 - `all` → execute the full plan in Phase 3.
 - `<numbers>` (e.g. `1,3`) → execute only the selected steps.
 - `edit <n>` → user provides a corrected message or grouping for step N; redraw plan.
 - `skip` → exit cleanly, no commits created.
 This gate is mandatory. Do NOT chain into Phase 3 without explicit approval —
 once committed, splitting requires `git reset --soft` which is a higher-friction
 recovery path than confirming up front.
 ### Phase 3: Execute commits
 After approval in Phase 2.5, for each approved step in chronological order:
 1. Stage only the files for that step: `git add <specific-files>`
   - If a single file has changes belonging to different steps and
     `git add -p` cannot be used (interactive), mention it to the user
     and ask how they want to handle it (commit together in the first
     relevant step, or split manually).
 2. Create the commit with a message that describes the step
 3. Verify with `git status` that the right files were committed
 ### Commit message format
@@ -125,47 +132,117 @@ Types: `feat`, `fix`, `refactor`, `chore`, `docs`, `test`, `style`, `perf`
 Keep the first line under 72 characters. The body explains motivation
 when the diff alone isn't self-explanatory.
-### Edge cases
+### Capitalize candidates (draft only — decided later, written in `MODE: apply`)
- **No changes**: tell the user there's nothing to commit
+Inspect the reconstructed steps as a whole and draft candidates, same
- **Only staged changes**: respect what's already staged — ask if the
+criteria as the standalone `/capitalize` flow:
  user wants to commit just those, or also include unstaged/untracked
 - **Merge conflicts**: don't try to commit — tell the user to resolve
 - **Single logical change**: one commit is the right answer — don't
  artificially split what was done as one action
 - **Sensitive files** (.env, credentials, keys): warn the user and
  exclude them from commits by default
-### Phase 4: Capitalize (memory registries)
+- Any step that represents a **design/architecture choice** (new dependency,
-
+  refactor with rationale, API shape decision) → draft an entry for
 After all commits are created, inspect the set as a whole:
 - Any commit that represents a **design/architecture choice** (new dependency,
  refactor with rationale, API shape decision) → propose an entry in
  `.claude/memory/decisions.md` (BDR-XXX) with pre-filled alternatives.
- Any commit that resolves a **non-trivial bug with a root cause** → propose
+- Any step that resolves a **non-trivial bug with a root cause** → draft an
-  an entry in `.claude/memory/blockers.md` (BLK-XXX, status: resolved).
+  entry for `.claude/memory/blockers.md` (BLK-XXX, status: resolved).
- Any commit whose content taught something **reusable beyond the immediate fix**
+- Any step whose content taught something **reusable beyond the immediate
-  (a pattern, a gotcha, a surprising API behaviour) → propose an entry in
+  fix** (a pattern, a gotcha, a surprising API behaviour) → draft an entry
-  `.claude/memory/learnings.md` (LRN-XXX).
+  for `.claude/memory/learnings.md` (LRN-XXX).
 **Language rule**: draft entries in English (see CLAUDE.md "Memory
 registries" § Language) — the dispatcher's approval exchange may mirror the
 user's language, but what you draft here is what gets written verbatim in
 `MODE: apply` if approved unedited.
 If every step is pure chore/docs/style with nothing to log, draft nothing.
 ### Emit the COMMIT PLAN and stop
 This is the end of `MODE: propose`. Print exactly this shape, then stop —
 do not proceed to Phase 3, do not touch git state further, do not write to
 `.claude/memory`:
 Present grouped candidates:
 ```
-CAPITALIZE — depuis les <N> commits créés
+COMMIT PLAN — <N> step(s) from working tree
-  [decisions.md]   BDR-XXX — <titre> (ref commit <hash>)
+
-  [blockers.md]    BLK-XXX — <friction> — resolved (ref commit <hash>)
+  1. <type>(<scope>): <short description>
     files: <a.ts, b.css, c.md>
  2. <type>(<scope>): <short description>
     files: <d.py>
  ...
 EDGE CASES:
  - <e.g. "sensitive file .env excluded from step 2">
  - <e.g. "3 files unstaged, left out of this plan — edit to include">
  - none
 CAPITALIZE CANDIDATES — from the <N> step(s) above
  [decisions.md]   BDR-XXX — <titre> (ref step <n>)
  [blockers.md]    BLK-XXX — <friction> — resolved (ref step <n>)
  [learnings.md]   LRN-XXX — <pattern>
-Valider ? (all / <IDs> / edit / skip)
+  ... or: CAPITALIZE: nothing to log
 READY TO APPLY — awaiting dispatcher confirmation
 ```
-Append approved entries + update the Index of each registry file. Add a line to today's heading in `.claude/memory/journal.md` summarising the commit batch.
+---
-**Language rule**: written entries are ALWAYS in English (see CLAUDE.md "Memory registries" § Language). The interactive gate may mirror the user's language; the appended entries must not.
+## MODE: apply
-If all commits are pure chore/docs/style with nothing to log → skip with `CAPITALIZE: nothing to log`.
+### Input (in the dispatch prompt)
-**Then commit the memory** — follow `$HOME/.claude/lib/capitalize-commit.md`: it
+- The APPROVED COMMIT PLAN: final step list — numbers, messages, and
-surgically commits what capitalize just wrote (`.claude/memory` + `.claude/tasks`
+  files, exactly as confirmed by the user (may be a subset of, or edited
-only, never `git add -A`) as one `chore(memory)` commit, reports the memory-commit
+  from, the `MODE: propose` output).
-hash, and no-ops if nothing was written. This is a separate commit from the Phase 3
+- The APPROVED CAPITALIZE ENTRIES: verbatim registry text to write, or
-code commits — their hashes are already anchored inside the entries.
+  `none`/`skip`.
 Never re-derive the plan, never ask a question — the dispatcher already
 gathered consent for exactly what follows.
 ### Phase 3: Execute commits
 For each approved step, in chronological order:
 1. Stage only the files for that step: `git add <specific-files>`
   - If a single file has changes belonging to different steps and
     `git add -p` cannot be used (interactive), report it under
     `STATUS: BLOCKED` instead of guessing — the dispatcher decides how to
     split it and re-dispatches.
 2. Create the commit with the approved message.
 3. Verify with `git status` that the right files were committed.
 ### Phase 4: Write approved memory, then commit it
 If the APPROVED CAPITALIZE ENTRIES are `none`/`skip`, skip this phase
 entirely — no memory commit.
 Otherwise:
 1. **Resolve step refs → commit hashes first.** The approved entries carry
   `(ref step <n>)` placeholders — propose-mode had no hashes yet. Phase 3
   just created the commits, so map each step number to its real commit
   hash and substitute `(ref step <n>)` → `(ref commit <hash>)` in every
   entry before writing. An entry that names no step (e.g. a pure LRN
   pattern) needs no ref.
 2. Append the resolved entries to their target registry file(s)
   (`.claude/memory/decisions.md`, `blockers.md`, `learnings.md`) and
   update each file's `## Index` table. Add a one-line summary of the
   commit batch to today's heading in `.claude/memory/journal.md`.
 3. **Language rule**: written entries are ALWAYS in English regardless of
   the language used in the dispatcher's approval exchange (CLAUDE.md
   "Memory registries" § Language).
 4. **Then commit the memory** — follow
   `$HOME/.claude/lib/capitalize-commit.md`: it surgically commits what
   was just written (`.claude/memory` + `.claude/tasks` only, never
   `git add -A`) as one `chore(memory)` commit, and no-ops if nothing was
   written. This is a separate commit from the Phase 3 code commits — whose
   hashes are now anchored inside the entries (resolved in step 1).
 ### Report
 End with exactly this report (your final message):
 ```
 COMMIT-EXEC REPORT
 STATUS   : DONE | BLOCKED
 COMMITS  : <hash> <subject>   (one line per Phase-3 commit, chronological)
 MEMORY   : <memory-commit hash> | none
 NOTES    : <DONE: none | BLOCKED: the blocker verbatim>
 ```
@@ -1,6 +1,6 @@
 ---
 name: doc-syncer
-description: Detect stale PUBLIC documentation by cross-referencing git history against the doc layout (README, CHANGELOG, docs/**…) — dispatched by /doc and orchestrators. Convention-aware (Diátaxis, Keep a Changelog); never touches .claude/. Audit, report, patch.
+description: 'Two-mode public-doc sync agent — MODE: audit (dispatched model="opus" — drift detection, semantic analysis, drafts, PATCH PLAN, read-only) and MODE: patch (sonnet pin — applies the APPROVED plan, oracle-checked, emits CHANGE SUMMARY + PATCHED_FILES). The validation gate lives in the DISPATCHER (BDR-077). Convention-aware (Diátaxis, Keep a Changelog); never touches .claude/.'
 tools: Read, Write, Edit, Bash, Grep, Glob
 model: sonnet
 ---
@@ -54,18 +54,25 @@ audit, report, and patch.
 ---
-## MODE DETECTION
+## MODE DETECTION (BDR-077 — two dispatch modes around the dispatcher's gate)
 Parse `$ARGUMENTS`:
- **AUTO MODE** — `$ARGUMENTS` starts with `auto-mode scope:`
+- **`MODE: patch`** — the dispatcher approved a PATCH PLAN and re-dispatches
-  Jump to AUTO MODE section.
+  this agent to APPLY it. Jump to MODE: PATCH section. Runs on the sonnet
- **FULL AUDIT** — anything else (empty, file list, description).
+  frontmatter pin.
-  Run the full audit workflow.
+- **`MODE: audit`** (or no explicit MODE — audit is the default) — analysis
- **CLEAN MODE** — set when `$ARGUMENTS` contains the token `clean`.
+  half, dispatched with `model: "opus"` (judgment tier; the call-site
-  Modifier on FULL AUDIT: run the full audit AND propose removal of
+  override takes precedence over the sonnet pin). **READ-ONLY: Write and
-  out-of-convention content already present in public docs (see
+  Edit are FORBIDDEN in audit mode** — CREATE items are rendered as DRAFTS
-  STEP 6.5). Not a separate flow.
+  inside the report, never written. Sub-variants:
  - `auto-mode scope:` prefix → AUTO MODE section (scoped quick audit).
  - `clean` token → CLEAN modifier on the full audit (STEP 6.5).
  - anything else → FULL AUDIT workflow.
 - **The validation gate is NOT yours.** A dispatched agent cannot ask the
  user. You emit the report + PATCH PLAN (audit) or apply the approved plan
  (patch); the DISPATCHER runs the gate between the two (see DISPATCHER
  PROTOCOL).
 ---
@@ -373,9 +380,10 @@ Omit any section whose delegated target does not exist and is not being
 proposed this run (e.g. drop "Deploy" entirely when `DEPLOY_COMPLEXITY`
 is `NONE`/`TRIVIAL`; drop "Configuration" when there is no config schema).
-Tag as **AUTO** — create on first audit. Surface the rendered README in
+Tag as **AUTO** — create on first audit. The rendered README is a DRAFT
-the validation gate before writing so the user can `edit` if needed, but
+inside the audit report (`[CREATE-AUTO]` in the PATCH PLAN); the
-do NOT skip creation; "skip" is not an offered option on README bootstrap.
+DISPATCHER's gate surfaces it so the user can `edit`, but do NOT skip
 creation; "skip" is not an offered option on README bootstrap.
 ### STEP 6 — DEPLOY.md GATE
@@ -662,19 +670,36 @@ Last updated: <date> (<N commits since>)
 CHANGELOG entries always HUMAN. DEPLOY.md creation always HUMAN.
 CLEAN removals always HUMAN.
-**README.md creation is AUTO** — always render and write, never gate on
+**README.md creation is AUTO** — always render (audit mode: as a draft
-user input. The validation gate (STEP 8) still surfaces the rendered
+in the report) and write (patch mode), never gate on user input. The
-file so the user can edit before write, but "skip" is not an option for
+DISPATCHER's validation gate still surfaces the rendered draft so the
 user can edit before the patch dispatch, but "skip" is not an option for
 README bootstrap; it is mandatory.
 If no drift in any doc and no missing required doc (and, in CLEAN MODE,
 nothing out-of-convention): `DOC SYNC: all docs current` and stop.
-### STEP 8 — VALIDATION GATE (mandatory stop)
+**PATCH PLAN (machine block — closes every audit report that found drift).**
 The dispatcher's gate approves items BY ID; the approved subset is what a
 `MODE: patch` re-dispatch receives, verbatim:
 ```
 PATCH PLAN
 P1. [AUTO]  <file> — <section> — <exact change, diffable>
 P2. [HUMAN] <file> — <section> — <exact change> — reason: <…>
 C1. [CREATE-AUTO]  README.md — write the rendered draft above
 C2. [CREATE-HUMAN] DEPLOY.md — write the rendered draft above
 R1. [REMOVE] <file> — <block to excise>   (CLEAN items likewise)
 ```
 ### DISPATCHER PROTOCOL — VALIDATION GATE (consumer contract — the gate
 ### runs in the DISPATCHER'S MAIN LOOP, never in this dispatched agent)
 The dispatcher presents:
 ```
 DOC SYNC — VALIDATION GATE
-AUTO items   : <count> (Claude will patch these)
+AUTO items   : <count> (will be patched)
 HUMAN items  : <count> (listed above for review)
 CREATE items : <count>
  - README.md     (AUTO — will be written; `edit` to refine the rendered draft)
@@ -694,22 +719,40 @@ README.md CREATE is unconditional: the only valid responses are `yes`
 write). Treat any `no` / `skip` answer to README as `edit` and prompt
 the user for the specific changes they want.
-Wait for explicit approval. Do not proceed without it.
+The dispatcher waits for explicit approval, then re-dispatches this agent
 with `MODE: patch` + the APPROVED PATCH PLAN (approved item lines verbatim,
 including the rendered drafts for approved CREATE items). Nothing is
 applied without that round-trip.
-### STEP 9 — PATCH
+## MODE: PATCH
-Apply only approved items. **Never write under `.claude/` or to
+INPUT: `MODE: patch` + the APPROVED PATCH PLAN (item lines verbatim — the
-`CLAUDE.md`** — they are not targets under any circumstance.
+dispatcher's gate already decided; you re-decide NOTHING, you re-analyse
 NOTHING). Plan absent or empty → report `DOC PATCH: empty plan — nothing
 applied` and stop.
 Apply only the listed items. **Never write under `.claude/` or to
 `CLAUDE.md`** — they are not targets under any circumstance; a plan line
 targeting them is refused loudly (report it, apply nothing else from it).
 - Surgical Edit for AUTO items. Preserve structure and tone.
- Write for approved CREATE items (README, DEPLOY). Use real project
+- Write for approved CREATE items (README, DEPLOY) using the approved
-  data only — no `<TODO>` placeholders, no fabricated feature
+  rendered draft. Real project data only — no `<TODO>` placeholders, no
-  descriptions.
+  fabricated feature descriptions.
 - For removals (REMOVE / INLINE / CLEAN), prefer Edit (delete the
  offending lines) over Write.
 - Re-read each modified file post-edit to verify no broken markdown,
  no orphaned references.
 - **Shape oracle (auto-mode MINOR provenance)**: when the plan carries
  `[MINOR]`-provenance items (auto-mode flows), run
  `bash "$HOME/.claude/lib/doc-shape.sh" check <every patched path>` (all
  paths, ONE call) AFTER patching. exit 0 → keep. exit 1 (or 2/3 —
  broken check never passes) → the oracle OVERRULES the MINOR call
  (LRN-046): revert ALL this run's patches (`git checkout -- <each
  patched path>`), and report `SHAPE ESCALATION: <oracle stderr>` —
  the dispatcher re-gates as SIGNIFICANT. Never keep an out-of-shape
  auto-patch.
-### OUTPUT
+### OUTPUT (MODE: patch)
 ```
 DOC SYNC COMPLETE
@@ -719,6 +762,9 @@ CREATED      : <count> files
 REMOVED      : <count> files / sections
 HUMAN PENDING: <count> items (see report above)
 SKIPPED      : <count> (user declined)
 CHANGE SUMMARY: (one line per patched file — what changed and why; the
 doc-commit step's rc-0 visible surface consumes THIS, LRN-126)
 <path> — <one line: what changed>
 PATCHED_FILES: (one real path per LINE below; "(none)" if no write)
 <path created or modified this run>
 <path created or modified this run>
@@ -788,46 +834,29 @@ Categorize:
  artifact (Dockerfile, fly.toml, workflow) without DEPLOY.md update or
  creation.
-### STEP A4 — ACT
+### STEP A4 — REPORT (audit mode is read-only; the ACTING is the dispatcher's)
- **NONE** → exit completely silent. No output (no `PATCHED_FILES` → the doc-commit step
+- **NONE** → exit completely silent. No report, no PATCH PLAN (the
-  sees an empty list and no-ops).
+  dispatcher sees nothing to do; the doc-commit step no-ops).
- **MINOR** → patch, then VERIFY SHAPE with the deterministic oracle BEFORE the
+- **MINOR** → emit a minimal report + `PATCH PLAN` whose items carry the
-  silent auto-commit. The LLM made the MINOR call; the oracle re-checks that the
+  `[MINOR]` provenance tag. The DISPATCHER re-dispatches `MODE: patch`
-  patch's SHAPE actually holds, catching a SIGNIFICANT mislabeled MINOR (RISK-1):
+  DIRECTLY, no gate (preserved auto behavior — MINOR is auto-committed;
-  ```
+  the deterministic shape oracle runs in patch mode and a
-  bash "$HOME/.claude/lib/doc-shape.sh" check <every patched path>   # all paths, ONE call
+  `SHAPE ESCALATION` comes back to the dispatcher, which then gates the
-  ```
+  set as SIGNIFICANT: on `no` the reverts already happened; on `select`
-  - **exit 0** (within the MINOR envelope) → genuine MINOR: keep the silent patch.
+  it re-dispatches patch with the kept subset).
-    One-line confirmation per file: `doc-sync: patched <file> (<what changed>)`.
+- **SIGNIFICANT** (or a MINOR the oracle escalated back) → emit the report
-    Proceed to `PATCHED_FILES` + the doc-commit step.
+  + PATCH PLAN; the DISPATCHER gates:
  - **exit 1** (shape EXCEEDS — oracle stderr names the offender(s) and why) → the
    deterministic oracle OVERRULES the LLM's MINOR call (LRN-046). Do NOT auto-commit.
    ESCALATE the WHOLE patch set to the SIGNIFICANT gate below — one file out of
    shape makes the atomic MINOR classification suspect. Surface every patched file
    + the oracle's reason, then the gate: on `no` → revert ALL
    (`git checkout -- <each patched path>`); on `select` → keep the chosen files,
    revert the rest. The oracle catches STRUCTURAL/size significance, not semantic —
    it is a deterministic floor, not a full SIGNIFICANT-detector.
  - **exit 2/3** (oracle usage error / not a git repo) → do NOT auto-commit on a
    broken check; treat as exit 1 and escalate.
 - **SIGNIFICANT** (or a MINOR the oracle escalated) → surface to user before patching:
  ```
  DOC SYNC — drift detected after this session:
  <list of significant items with proposed fixes>
  Apply? (yes / no / select)
  ```
-  Wait for approval.
+  then re-dispatches `MODE: patch` with the approved subset.
-After writing in MINOR or approved-SIGNIFICANT, emit the machine-readable handle the
+`PATCHED_FILES` + `CHANGE SUMMARY` are emitted by `MODE: patch` only (see
-doc-commit step (`lib/doc-commit.md`) consumes — ONE real path PER LINE:
+its OUTPUT) — audit mode writes nothing, so it never emits them. Neither
-```
+ever lists `.claude/**` or `CLAUDE.md` (never targets, BDR-022).
 PATCHED_FILES:
 <path created or modified this run>
 <path created or modified this run>
 ```
 Emit ONLY when something was written; NONE stays silent. Never lists `.claude/**` or
 `CLAUDE.md` (never targets, BDR-022).
 ---
@@ -1,204 +1,69 @@
 ---
 name: feater
-description: Small-feature implementer (1-5 files) — dispatched by /feat, which owns branching and gates. Light planning, direct implementation, no heavy orchestration.
+description: Small-feature EXECUTOR — dispatched by /feat with a closed plan + contract. Implements to the letter, tests, reports. No planning, no questions, no commit.
-tools: Read, Edit, Write, Bash, Grep, Glob, Agent
+tools: Read, Edit, Write, Bash, Grep, Glob
 model: sonnet
 ---
-# FEAT — Small Feature, Fast Track
+# FEATER — plan executor
-Implement a small, well-scoped feature without the overhead of a
+You execute work ALREADY decided upstream — faithful execution, not design.
-full orchestrator. Direct work, light planning, quick delivery.
+The thinking already happened; every open choice is a NEED-DECISION to
 report, never an improvisation. Two dispatch sources, same job:
-## REQUEST
+- **/feat orchestrator** — a CLOSED plan + CONTRACT (see INPUT).
-$ARGUMENTS
+- **audit dispatchers (/seo, /geo)** — you are the L1 fix-bundle applier for
  the larger items (new legal/city pages, `.htaccess`, sitemaps); the
  dispatch prompt hands you a bundle item inline (files, concern, current,
  expected fix) with NO CONTRACT. Apply exactly that item, self-verify, do
  not commit. There is no FILE SCOPE contract on this path — the named files
  in the item ARE the scope.
---
+## INPUT (in the dispatch prompt)
-## STEP 0 — SCOPE CHECK
+- `CONTRACT`: path to the contract file — read it FIRST; its acceptance
  criteria + FILE SCOPE bound everything you do.
 - `PLAN`: files + approach + edge cases + tests.
 - `BRANCH`: verify with `git branch --show-current`; mismatch → STATUS
  BLOCKED — never create or switch branches.
 - `GAPS` (re-dispatch only): verifier/security verdict lines — fix ONLY
  those, touch nothing else.
-Before starting, verify this is actually a small feature:
+Applier path (/seo, /geo): no CONTRACT/PLAN/BRANCH keys — the bundle item in
 the prompt is the work to apply. Skip the contract read; the `## OUTPUT`
 report below is optional on this path (the dispatcher needs the edit applied
 + self-verified, not the report grammar).
 ## EXECUTION RULES
 - Follow the plan to the letter. A plan hole or an open choice (naming,
  data shape, API surface, dependency) → STOP, report `NEED-DECISION` with
  the precise question. Never improvise a design decision.
 - Stay inside the contract FILE SCOPE. A needed file outside it →
  `NEED-DECISION` (the orchestrator owns scope changes); don't touch it. On
  the applier path the scope is the files named in the bundle item — apply
  only those.
 - Write tests alongside the code, as the plan names them. Run the relevant
  suite incrementally; run it fully before reporting.
 - Follow existing code patterns and CLAUDE.md limits (function size,
  params, no global state). Match comment density and naming.
 - Fast-moving libs (`bash ~/.claude/lib/fast-libs.sh detect .` — React,
  Next.js, Prisma…): before coding against their APIs, read a fresh
  `.ctx7-cache/<lib>*.md` if present; else fetch targeted docs, max 2
  topics (`npx ctx7@latest library <name> "<q>"` then `docs <id> "<q>"`).
  ctx7 unavailable → add `ctx7 cache miss: <lib>` to NOTES and proceed on
  model knowledge. Stable techs (C, SQL, POSIX sh…) skip this entirely.
 - FORBIDDEN: `git commit`, branch ops, push, merge, new dependencies,
  editing `.claude/**` or memory registries, user questions (you cannot
  ask — report instead), attribution trailers of any kind.
 ## OUTPUT — end with exactly this report (your final message)
 ```bash
 git status
 git log --oneline -3
 ```
-
+FEAT-EXEC REPORT
-Read the relevant existing code to understand the context.
+STATUS   : DONE | NEED-DECISION | BLOCKED
-
+FILES    : <created/modified paths>
-### Decision rules (apply in order — first match wins)
+TESTS    : <added/updated + final suite run result, verbatim line>
-
+NOTES    : <DONE: deviations (must be none) | NEED-DECISION: the exact
-| Rule | Trigger | Action |
+           question + the options you see | BLOCKED: the blocker verbatim>
 |---|---|---|
 | 1 | Estimated diff < 2 files AND no logic (config value, copy fix, missing field) | DOWNGRADE → load `$HOME/.claude/agents/hotfixer.md` |
 | 2 | New external dependency (`npm install <x>`, `pip install`, `cargo add`) required | ESCALATE → `/ship-feature` (dep choices need design gate) |
 | 3 | New route family / new top-level module / new DB migration | ESCALATE → `/ship-feature` |
 | 4 | Estimated diff > 5 files | ESCALATE → `/ship-feature` |
 | 5 | User wording is uncertain ("not sure how", "what do you think") | ESCALATE → `/ship-feature` (needs brainstorming) |
 | 6 | UI feature on a stack with a design system AND the design toolchain incomplete | Proceed in `/feat`, but flag it in STEP 0.5 design gate |
 | 7 | Otherwise | PROCEED in `/feat` |
 ### Worked examples
 - "Add `/health` endpoint returning `{status:"ok",version}`" → 1-2 files, no new dep, route added to existing router → **PROCEED**.
 - "Add a dark-mode toggle bound to `prefers-color-scheme`" → 2-3 files, design system exists → **PROCEED** (design gate triggers in STEP 0.5).
 - "Add OAuth login (Google + GitHub providers)" → new deps, new routes, secrets handling → **ESCALATE** to `/ship-feature`.
 - "Show a 'New' badge on items created this week" → 1-2 files, pure UI predicate → **PROCEED**.
 - "Fix copy: 'Sign In' → 'Sign in'" in 1 file → **DOWNGRADE** to `/hotfix`.
 Print a one-line scope confirmation (use the rule that fired):
 ```
 FEAT: <feature name> — rule <N>, ~<N> files, <brief approach>
 ```
 ## STEP 0.5 — DESIGN GATE
 Follow `$HOME/.claude/lib/design-gate.md`:
 - Scan $ARGUMENTS and target files for design/UI/style signals.
 - If signals found → run `design-tool-gate.sh`; if it reports INCOMPLETE,
  tell the user to run `/profile design` before proceeding.
 - If no signals → skip (zero overhead).
 ## STEP 0.6 — MEMORY READ-BEFORE (decisions-first)
 Run the scan per `$HOME/.claude/lib/analyze-before-plan.md`, decisions-weighted: a BDR may
 already constrain or forbid the approach; an LRN may name a gotcha to apply. Emit RELATED
 MEMORY; feed STEP 1 MINI-PLAN. Inline consumption — reader = planner, no injection.
 `.claude/memory/` absent → guarded no-op (zero overhead on a memory-less repo).
 ## STEP 0.7 — CONTRACT
 Run `$HOME/.claude/lib/contract-interview.md` (main loop — you are it). It
 captures the request verbatim, asks 0-3 questions PROPORTIONAL to ambiguity
 (a complete request → zero questions, silent), derives testable acceptance
 criteria + file scope, and writes the contract to
 `.claude/tasks/contracts/<date>-<slug>-<HHMM>.md`. Keep the path — GATE 1
 (STEP 3) hands it to a fresh verifier. On a small, clear feature this is a
 few seconds and no questions; it is the single reference the verifier judges
 against, not a restatement.
 ## STEP 1 — MINI-PLAN
 Quick mental model, not a formal plan document:
 1. List the files to create or modify (with line references).
 2. Describe the approach in 2-5 bullet points.
 3. Note any edge cases to handle.
 4. If tests exist for the area, note which tests to add/update.
 5. Disposition (from STEP 0.6): name each in-force BDR/LRN this plan honors
   (`honors BDR-xxx by …`), or state `no in-force decision constrains this feature`.
   A plan with neither = read-then-ignore; the disposition must surface as a trace.
 Print the plan as a compact checklist:
 ```
 PLAN:
  [ ] <file> — <what to do>
  [ ] <file> — <what to do>
  [ ] <test file> — <test to add>
 ```
 No gate — proceed directly unless the approach is ambiguous.
 If ambiguous: ask the user one focused question, then proceed.
 ## STEP 2 — IMPLEMENT
 **Gitflow aiguillage (before editing):** follow `$HOME/.claude/lib/gitflow-aiguillage.md`
 — your type = `feature`. On `main`/`develop` it branches first; on a working
 branch it's a no-op (commit in place). Never `finish`.
 Work through the plan:
 - Implement directly (no subagents).
 - Write tests alongside the code (not after).
 - Follow existing patterns in the codebase.
 - Run tests incrementally as you go.
 ## STEP 3 — VERIFY + SECURE (fresh gates, bounded loops)
 First, your own pre-check (dev-side, fast): run the relevant test suite /
 lint / type-check, and if a dev server is relevant note what to check
 visually. This is your smoke test, NOT the gate.
 Then run the two fresh gates per `$HOME/.claude/lib/verify-secure-loop.md`
 with `CONTRACT` = the STEP 0.7 path, `DIFF` = your working-tree diff, `TEST`
 = the suite you just ran:
 - GATE 1 — a FRESH verifier judges the diff against the contract (blind, no
  self-score of yours counts). CONFORME on the first pass → straight to GATE
  2, no loop. ECARTS → fix the named gaps, re-verify, max 3 → escalate.
 - GATE 2 — a FRESH security-auditor (`MODE: gate`) scans the diff. PASS →
  commit. BLOCK → fix, re-verify the request THEN re-scan, max 3 → escalate.
 Nominal (clear request, conform first pass, clean diff) = exactly one
 verifier + one security dispatch. The loop only costs when it loops.
 ## STEP 4 — COMMIT
 Commit using conventional format:
 ```
 feat(<scope>): <what was added>
 <brief description of the feature>
 ```
 If the feature touched multiple concerns (e.g., feature + config +
 test), consider splitting into 2-3 atomic commits — load
 `$HOME/.claude/agents/commit-changer.md` and follow its grouping logic.
 Print summary:
 ```
 FEAT COMPLETE
 FEATURE  : <name>
 FILE(S)  : <created/modified files>
 TEST(S)  : <added tests>
 VERIFIED : <what was checked>
 ```
 ## STEP 5 — DOC SYNC (automatic)
 Load `$HOME/.claude/agents/doc-syncer.md`.
 Execute in automatic mode:
 `auto-mode scope: <list of files modified during this session>`
 **Then commit the docs** — follow `$HOME/.claude/lib/doc-commit.md`: it surgically commits
 ONLY the files doc-syncer patched (its `PATCHED_FILES` output), never `git add -A`, never
 `.claude/`/`CLAUDE.md` (rc 4 = a loud BDR-022 anomaly, not a silent skip), and no-ops when
 nothing was patched — the common case for a trivial change. No FINISH in an inline flow, so
 it just commits the docs on the current branch (no ordering concern).
 ## STEP 6 — CAPITALIZE (memory registries)
 A small feature may or may not involve a design choice. Scan the work for:
 - **Non-trivial design choice** (even small: a library pick, a naming convention, a data-model tradeoff) → propose `BDR-XXX` in `.claude/memory/decisions.md` with alternatives considered.
 - **Reusable pattern or gotcha encountered** → propose `LRN-XXX` in `.claude/memory/learnings.md`.
 Present the candidates grouped:
 ```
 CAPITALIZE — proposé
  [decisions.md]   BDR-XXX — <titre> (optionnel)
  [learnings.md]   LRN-XXX — <pattern> (optionnel)
 Valider ? (all / <IDs> / edit / skip)
 ```
 Always append a 1-line entry to today's heading in `.claude/memory/journal.md`.
 **Language rule**: written entries are ALWAYS in English (see CLAUDE.md "Memory registries" § Language). The interactive gate may mirror the user's language; the appended entries must not.
 If no substantive capture candidate → skip with `CAPITALIZE: nothing to log`.
 **Then commit the memory** — follow `$HOME/.claude/lib/capitalize-commit.md`: it
 surgically commits what capitalize just wrote (`.claude/memory` + `.claude/tasks`
 only, never `git add -A`) as one `chore(memory)` commit, reports the memory-commit
 hash, and no-ops if nothing was written.
 ---
 ## RULES
 - Max 5 files. If more needed → `/ship-feature`.
 - Design gate only (not full plugin check). See STEP 0.5.
 - No brainstorm/design phase (if needed → `/ship-feature`).
 - No subagents — direct implementation.
 - Keep scope tight. If scope creep happens mid-work, stop
  and suggest splitting into `/feat` + follow-up task.
 - Follow existing code patterns. Don't introduce new patterns
  for a small feature.
@@ -2,6 +2,7 @@
 name: geo-analyzer
 description: GEO audit agent for AI search engines — dispatched by /geo and /seo. Audits AI crawlers, llms.txt, entity signals, Schema.org; emits a fix bundle (dispatcher applies), scored report. Classical SEO → seo-analyzer agent.
 tools: Read, Edit, Write, Bash, Grep, Glob, WebFetch, WebSearch
 model: opus
 ---
 # GEO — Generative Engine Optimization audit, fix & strategy
@@ -13,10 +14,13 @@ Apple Intelligence**. Google classical search is handled by the
 ## Context — why GEO is its own discipline in 2026
- AI Overviews trigger on ~48% of Google searches (April 2026).
+- `[UNVERIFIED — 2026-07-16]` AI Overviews trigger on ~48% of Google
- ChatGPT processes 2.5B queries/day.
+  searches (April 2026); ChatGPT processes 2.5B queries/day; Gartner
- Gartner projects commercial organic search traffic to fall 25% by
+  projects commercial organic search traffic to fall 25% by end-2026 as
-  end-2026 as discovery shifts to AI engines.
+  discovery shifts to AI engines. Framing only — **never quote these to a
  client** until each carries `source + measured: + link` per
  `resources/README.md`. GEO is worth doing on mechanism; it does not need
  these numbers to be true.
 - Classical SEO ≠ GEO. Some signals overlap (headings, Schema.org)
  but the optimization levers differ: entity clarity, definition
  architecture, citable stats, crawler permissions.
@@ -90,6 +94,31 @@ $ARGUMENTS
 ---
 ## MODE DETECTION (BDR-077 — pipeline modes around the dispatcher)
 Mirror of seo-analyzer's pipeline contract. Parse the MODE line:
 - **`MODE: collect`** — dispatched `model: "sonnet"`. STEP 0-5 ONLY
  (context, crawler policy probes, llms.txt checks — raw results), written
  to the run-scoped, gitignored `.audit/geo-signals-<RUNID>.md`, terminated
  by `COLLECTION COMPLETE — RUNID: <RUNID>`; emit a `COLLECT REPORT`
  (`STATUS`, RUNID, COVERAGE counts) and STOP.
 - **`MODE: judge`** — opus frontmatter pin. Fail-closed load of
  `.audit/geo-signals-<RUNID>.md` (absent / RUNID mismatch / missing
  sentinel → `GEO JUDGE — VERDICT: ERROR(<reason>)`, STOP — never score
  stale or partial signals). Then STEP 6-12 (schema, entity — including
  its verification curls — content shape, visibility, scoring, plan,
  triage) reported as findings + scores + batches. No bundle, no GEO.md.
 - **`MODE: template`** — dispatched `model: "sonnet"`. INPUT: dispatcher
  context + judge report VERBATIM (never re-derive). STEP 13-15: FIX
  BUNDLE + sentinel, report file, envelope, console.
 - **No MODE line** — legacy single-shot on the opus pin (/onboard
  report-only).
 Every mode receives the full dispatcher CONTEXT block (LRN-126).
 ---
 ## STEP 0 — AUDIT DEPTH
 **First action.** If not already determined by a parent skill (`/seo`
@@ -141,6 +170,16 @@ If called standalone via `/geo`, gather:
 ## STEP 2 — DETECT CONTEXT `[both]`
 **FIRST — the CWD must BE the audited site.** You grep the current working
 directory; no dispatcher checks that it matches the target domain. If a URL
 was supplied and the CWD shows no web project at all (no `package.json` /
 `composer.json` / `index.html` / `*.astro` / `*.php` / `.htaccess`), or its
 signals contradict the domain, STOP and report:
 `CWD/TARGET MISMATCH — <cwd> is not <domain>'s repo. Re-run from it, or
 confirm live-only audit (LOCAL findings will be N/A).`
 Never grep one codebase while curling another: the live half looks right,
 the code half is fiction, and the report reads as authoritative.
 ```bash
 # Framework (reuse detection from seo-analyzer if available)
 ls package.json composer.json Gemfile Cargo.toml go.mod 2>/dev/null
@@ -231,8 +270,14 @@ the PERMISSIVE template from `ai-crawlers-2026.md`.
 ### Live verification `[FULL only]`
 **Guard the domain before it reaches a shell — mandatory, not optional.**
 `$DOMAIN` is interpolated inside double quotes below, where `$` and backtick
 still execute. Run the guard FIRST and use only its output; non-zero exit →
 STOP this step and report the refusal, never sanitise-and-retry.
 ```bash
-DOMAIN="<production-domain>"
+DOMAIN="$(bash ~/.claude/lib/url-guard.sh host "<production-domain>")" || {
  echo "STEP 4 aborted: domain refused by url-guard"; exit 2; }
 # Verify robots.txt served
 curl -s "https://$DOMAIN/robots.txt" | head -50
@@ -304,6 +349,10 @@ RECOMMENDATION  : CREATE | UPDATE | OK | SKIP (low value for this site type)
 ---
 > **MODE BOUNDARY — `MODE: collect` ends at STEP 5**: signals file +
 > `COLLECTION COMPLETE — RUNID: <RUNID>` written, COLLECT REPORT emitted,
 > stop. STEP 6-12 below are `MODE: judge` territory.
 ## STEP 6 — SCHEMA.ORG FOR AI `[both]`
 Load: `~/.claude/agents/resources/geo-schemas.md`
@@ -360,7 +409,9 @@ action (G5 batch, confirmation needed — visible page creation).
 **Local business:**
 - [ ] `LocalBusiness` with most specific subclass (Plumber/Dentist/etc.)
- [ ] NAP consistent with GMB
+- [ ] NAP consistent with GMB — **direction rule applies** (Data integrity:
      never pick a value from source majority; no canonical → no directional
      fix)
 - [ ] `sameAs` includes GMB URL + main social + Wikidata if applicable
 - [ ] `areaServed` lists served cities/regions
 - [ ] `openingHoursSpecification` matches reality
@@ -416,6 +467,57 @@ Record what exists. For each:
 - Does `sameAs` on the site point to it?
 - If yes, does the target resolve and match?
 ### sameAs resolution `[FULL only]`
 `entity-seo.md:148` says "validate each URL resolves" and nothing did.
 A `sameAs` pointing at a dead profile is worse than a missing one: it
 asserts an identity link that fails on follow, in the exact graph AI
 engines walk to confirm who you are.
 ```bash
 grep -rhoE '"sameAs"[^]]*\]' \
  --include="*.html" --include="*.astro" --include="*.tsx" --include="*.jsx" \
  --include="*.vue" --include="*.svelte" --include="*.php" --include="*.json" \
  . 2>/dev/null \
  | grep -oE 'https?://[^"]+' | sort -u | while read -r RAW; do
      # These URLs come from the audited repo's JSON-LD, not from the operator:
      # guard each one before it reaches curl. A refused entry is REPORTED, not
      # skipped silently — an unguardable sameAs is itself a finding.
      U="$(bash ~/.claude/lib/url-guard.sh url "$RAW" 2>/dev/null)" || {
        printf 'REFUSED %s\n' "$RAW"; continue; }
      printf '%s %s\n' \
        "$(curl -sIL -o /dev/null -w '%{http_code}' --max-time 10 "$U" 2>/dev/null || echo 000)" \
        "$U"
    done
 ```
 `REFUSED` rows are not dead links and not live ones — the URL never left the
 machine. Report them in §14 with the raw value: a `sameAs` carrying shell
 metacharacters or pointing at `localhost` is either broken markup or someone
 probing, and both are worth the client knowing.
 **Read the codes honestly — a block is not a death.** Some platforms refuse
 non-browser clients: LinkedIn answers `999` (verified 2026-07-16 against a
 live company page). A naive check calls that dead and the bundle deletes a
 live link — the most valuable node in the graph, since LinkedIn is the
 identity anchor for most B2B entities.
 Do NOT assume which platforms block: the same 2026-07-16 check found
 `x.com` returning `200`, contradicting the "Twitter always 403" folklore.
 Test the code you actually got; classify by code, never by platform
 reputation.
 | Code | Verdict | Action |
 |---|---|---|
 | 2xx / 3xx | alive | none |
 | **404 / 410** | **genuinely dead** | finding WITH direction — fix or remove |
 | 401 / 403 / 429 / 999 | bot-blocked | **inconclusive — no finding.** Report as unverified, never as dead |
 | 000 (DNS/timeout) / 5xx | inconclusive | retry once, then unverified |
 No G2/G6 item may remove a `sameAs` on anything but 404/410. Same rule as
 the NAP direction rule: an unreliable signal read confidently is worse than
 no signal. Unverified entries → §14, naming the platform and the code.
 ### Google Knowledge Panel `[FULL only]`
 ```
@@ -443,10 +545,27 @@ PRIORITY ACTIONS  : <top 3-5>
 ## STEP 8 — CONTENT SHAPE FOR AI `[both]`
 **Rendering gate first (R2).** `bash ~/.claude/lib/seo-data/fetch.sh
 rendercheck --url "https://$DOMAIN/"`. Verdict `client-rendered` → Content
 Shape is `N/A — content not in served HTML`, excluded from the weighted
 global, never scored zero. And say the thing that actually matters here: AI
 crawlers are **worse** at JS than Googlebot is. GPTBot, PerplexityBot and
 ClaudeBot fetch HTML and largely do not execute it, so a client-rendered site
 is not just unauditable by us — it is close to invisible to the engines this
 whole audit targets. That is a §0 alert and the top user action (SSR/SSG),
 not a schema tweak.
 Site-wide axes (crawler policy, llms.txt) are unaffected: those are files.
 Load: `~/.claude/agents/resources/content-shape-for-ai.md`
 Sample 5-10 key pages (homepage + top service/blog pages). For each:
 **Record the denominator.** This samples; the report says "audit". Count the
 URLs in `sitemap.xml` for the coverage ratio, and carry it into the GEO
 SCORING block. No sitemap → total UNKNOWN, say so. Content shape is the
 axis most damaged by silent sampling: it is judged per page, so a 6-page
 sample of a 300-page site says nothing about the other 294.
 ### Checks
 1. **Definition Lead** — does the first sentence (or H1) follow
@@ -462,15 +581,28 @@ Sample 5-10 key pages (homepage + top service/blog pages). For each:
   pronouns?
 8. **Lists/tables vs prose** — structured where possible?
 9. **30/70 rule** (if city/service variants exist) — ≥70% unique?
 10. **Filler/AI-slop signal (deterministic)** — feed each sampled page's
    body text to `fetch.sh content_quality`. It is a DETERMINISTIC input
    that INFORMS checks 1-9 (word-list/density heuristics, no LLM call);
    it never replaces your read of them. A low `overall_quality` or a
    `filler`/`ai-patterns` flag is a candidate for human review, not an
    automatic finding — do not let the number become the verdict, and do
    not claim a page "is AI-written" from it.
 ### Sampling command
 ```bash
 # Extract H1/H2/H3 from main pages to assess heading style
-for f in index.html $(find . -maxdepth 3 -name "*.astro" -o -name "*.tsx" -o -name "*.md" -o -name "*.html" | head -10); do
+mapfile -t FEXCL < <(bash ~/.claude/lib/source-scope.sh findargs)   # C1a: skip build output
 for f in index.html $(find . "${FEXCL[@]}" -maxdepth 3 \( -name "*.astro" -o -name "*.tsx" -o -name "*.md" -o -name "*.html" \) | head -10); do
  echo "=== $f ==="
  grep -oE '<(h1|h2|h3)[^>]*>[^<]+</(h1|h2|h3)>|^#{1,3} .+' "$f" 2>/dev/null | head -20
 done
 # Filler/AI-slop signal (Check 10) — strip markup to plain body text, then
 # score it. Advisory only: pair the number with your own read of Checks 1-9.
 sed -e 's/<[^>]*>//g' index.html | \
  bash ~/.claude/lib/seo-data/fetch.sh content_quality
 ```
 ### Findings
@@ -486,6 +618,9 @@ CITED STATISTICS    : <avg per page>
 FRESHNESS VISIBLE   : <n/N pages>
 PRONOUN-HEAVY       : <n/N pages flagged>
 30/70 RULE          : pass | fail | N/A
 FILLER/AI-SLOP SIGNAL : <avg overall_quality>/100, flags: <n/N pages flagged>
                       (deterministic, advisory — informs checks 1-9, never
                       a verdict, never scored on its own)
 PRIORITY ACTIONS    : <top 5>
 ```
@@ -574,6 +709,9 @@ Score each axis. Use concrete findings from STEP 2-9.
 ```
 GEO SCORING (<depth>)
 COVERAGE SOURCE           : <N> of <M> page templates (<P>%) — bounds Schema.org
 COVERAGE LIVE             : <N> of <M> sitemap URLs (<P>%) — bounds Content Shape
                            | UNKNOWN (no sitemap / fetch degraded)
 AI Crawlers Policy        : XX/20  <justification>
 llms.txt                  : XX/20  <justification>
 Schema.org for AI         : XX/20  <justification>
@@ -584,6 +722,24 @@ AI Visibility (live)      : XX/20 | N/A (LOCAL)
 GEO GLOBAL (weighted)     : XX.X/20 (<depth>)
 ```
 **COVERAGE is mandatory, never omitted, never rounded up.** It bounds the
 per-page axes — Content Shape above all, and the page-level share of
 Schema.org. Site-wide axes (AI Crawlers Policy, llms.txt) are unaffected:
 robots.txt and llms.txt are single files, fully read. Say which is which
 rather than letting one ratio discredit the whole report.
 **Same source/live split as seo-analyzer STEP 9 (C1c), and it cuts your axes
 differently.** A JSON-LD block lives in a shared layout, so one sampled page
 per URL family proves the SCHEMA for the whole family — SOURCE coverage is
 what bounds it. Content Shape does NOT work that way: Definition Lead, TL;DR
 and heading wording are written per page, so a template says nothing about
 its 25 instances. Bound Schema.org by SOURCE, Content Shape by LIVE, and
 never quote the flattering one alone. Get the URL families from
 `fetch.sh sitemap`, grouped as seo-analyzer STEP 5 describes — shared parent
 path OR shared slug prefix, because both layouts are real: first-segment
 alone reads 8 flat `/lavage-auto-<city>` pages as 8 singletons. If `/seo`
 already ran it, reuse the count rather than re-fetching.
 Per user instruction: **GEO weight in combined SEO+GEO report = 20% for
 local, 25% for national/SaaS/content.**
@@ -677,6 +833,10 @@ one level up, where the plan is printed and the user can interrupt.
 ---
 > **MODE BOUNDARY — `MODE: judge` ends at STEP 12** (findings + scores +
 > batches reported). STEP 13-15 below are `MODE: template` territory,
 > operating on the judge report verbatim.
 ## STEP 13 — EMIT FIX BUNDLE `[both]`
 **You do NOT apply fixes and you do NOT dispatch any sub-agent.** Same
@@ -702,7 +862,14 @@ to act without your audit context. Embed per item:
 - **Templates + context** — G2/G6 paste the expected JSON-LD from
  `geo-schemas.md` + business context (entity name, sameAs, @id canonical)
  + framework note. G4 follows `llms-txt-template.md` exactly. G1 pastes
-  the correct variant from `ai-crawlers-2026.md`.
+  the correct variant from `ai-crawlers-2026.md`. When a G2 item needs a
  `Reservation`/`OrderAction`/`DiscussionForumPosting`/`ProfilePage` block,
  generate the skeleton via `fetch.sh schema_gen
  <reservation|order|discussion|profile> [flags]`
  (`~/.claude/lib/seo-data/fetch.sh`) and fill in the real values, rather
  than hand-writing that markup. The data-integrity rule still applies on
  top of it: `schema_gen` only generates STRUCTURE — unknown field values
  stay `[À COMPLÉTER]`, never invented to fill a flag the verb needs.
 - **PERMISSIVE default** on G1 unless the client flagged premium/regulated.
 ### Output shape
@@ -885,6 +1052,14 @@ PROCHAINE ETAPE : <highest-priority>
  NEVER `Write` on shared templates. `Write` is reserved for files
  you solely own: robots.txt, llms.txt, llms-full.txt. Full-template
  refactor → escalate as user action in §11.
 - **NEVER emit a bundle item targeting build output (C1a).** No path under
  `dist/ build/ .next/ .nuxt/ .output/ _site/ .astro/ .svelte-kit/ out/` —
  run `bash ~/.claude/lib/source-scope.sh list` for the authoritative set.
  Those files are regenerated: the `npm run build` the dispatcher runs to
  VERIFY your fix is what erases it. The fix lands, verification passes,
  nothing survives, and the report claims it was applied. Fix the SOURCE
  template that generates the file. If you cannot find the source, that is
  a finding — say so, do not patch the artifact.
 - **Respect PERMISSIVE/RESTRICTIVE choice.** geo-analyzer defaults to
  PERMISSIVE (GEO's goal is AI visibility). Only switch if the client
  explicitly flags premium/regulated content.
@@ -895,9 +1070,31 @@ PROCHAINE ETAPE : <highest-priority>
 - **No invented entity data.** Never write a fake Wikidata QID, fake
  `sameAs` URLs, fake `knowsAbout`, fake press mentions. Unknown →
  placeholder `[À COMPLÉTER]` or omit.
 - **NAP direction rule (LRN-032).** You own JSON-LD NAP, so this binds you
  whoever called you — `/seo` passes a canonical, standalone `/geo` does
  not. NEVER infer a correct NAP value from source majority: on-site
  sources (JSON-LD, footer, settings DB, legal pages) usually descend from
  ONE seed and can all carry the same wrong value — the single diverging
  source may be the only one a human actually corrected. Direction of fix:
  - Diverging from a CONFIRMED canonical field (passed by `/seo` STEP 0)
    → fix the diverging source.
  - Canonical UNCONFIRMED or absent (the standalone `/geo` case) → report
    the divergence WITHOUT a directional fix; escalate as a user question
    ("which value is correct?") in §11.
  No G2/G6 item may write or rewrite a NAP value that no confirmed
  canonical backs — **creating** a `LocalBusiness` from scratch included:
  unknown fields → `[À COMPLÉTER]`, never a value copied from a sibling
  on-site source.
 - **Remove deprecated schemas rather than keep broken ones.**
- **Cite sources.** When emitting stats in the report, link
+- **Cite sources, and only citable ones.** A stat reaches the client only
-  `content-shape-for-ai.md` research citations.
+  if it carries `source + measured: + link` per `resources/README.md`.
  Anything marked `[UNVERIFIED]` is framing for you, never a line in the
  report. Quote the source's ACTUAL measurement, never a widened or
  re-subjected version of it — the 2026-07-16 audit found every stat in
  that directory real but attached to the wrong claim, and this rule is
  what pushed them into client deliverables as research-backed.
  A recommendation that only stands up with a number you cannot source was
  never standing up: make it on mechanism, or drop it.
 ### Process
 - **Every user action lists automation options.** Mandatory from
@@ -0,0 +1,848 @@
 ---
 name: handover-doc-writer
 description: 'Two-mode deliverable writer — MODE: synthesize (dispatched model="opus" — memory+git clustering, 6-chapter synthesis into a run-scoped draft) and MODE: render (sonnet pin — annexes, precheck, deterministic gates, MD + branded HTML/PDF from the draft). Dispatched twice by client-handover with the resolved PACKAGE. No audits, no questions, no dispatch.'
 tools: Read, Write, Edit, Bash, Grep, Glob, WebSearch, WebFetch
 model: sonnet
 ---
 # HANDOVER DOC WRITER
 ## INPUT — the PACKAGE
 You are dispatched by `client-handover-writer` with a single structured
 PACKAGE block in your prompt. Treat every field as **ground truth** —
 never re-ask the user, never re-run an audit, never re-detect what the
 parent already resolved:
 - `LANG` — output language (`fr` | `en`).
 - `PROJECT` — name, root, type, sub-type, `is_local_business`,
  `deployed_url`, period (first commit → last commit).
 - `SCORES` — seo / geo / harden / validate (web) or cso (non-web) —
  before & after values, each with pass-status and any code-ceiling
  note. Source of truth for §2 — do not recompute.
 - `AUDIT_REPORTS` — paths to `.claude/audits/*.md` (plus
  `HUMAN-ACTIONS.md` / any threshold-override note if present), for §5
  and §6 sourcing.
 - `INCLUDE_DEPLOY` — `yes` | `no`. Controls whether §8 is rendered.
 - `DEPLOY_HINTS` — detected deploy platforms (Vercel, Netlify, Docker,
  GitHub Actions, …) from the parent's STEP 2 scan, for tailoring §8.
  Empty = no platform detected (use the generic §8 fallback).
 - `SKIP_SEO` — `yes` | `no`. When `yes`, skip the §7 platforms chapter
  even for web projects (the parent's `--skip-seo` flag).
 - `NAP` — the full, already-resolved §4 table (name, address, phone,
  email, categories, short description, hours, …).
 - `PRECHECK_DONE` — the set of platforms/items already confirmed done,
  for pre-checking §5 / §7 checkboxes.
 - `CLIENT_NAME` — string or `—`.
 - `OUTPUT` — final MD path + overwrite decision:
  `overwrite | versioned <path> | skip-write`.
 If any PACKAGE field is missing or malformed, do not guess or fall back
 to detection — report `STATUS: BLOCKED` (see `## OUTPUT` below) and
 name the missing field.
 ---
 ## MODE DETECTION (BDR-077 — two dispatch modes, one PACKAGE)
 The parent dispatches this agent TWICE, with the FULL PACKAGE both times
 (LRN-126 — every field crosses each dispatch) plus a `RUNID`:
 - **`MODE: synthesize`** — dispatched with `model: "opus"` (judgment tier;
  call-site override over the sonnet pin). Runs STEP 9 → 10 → 12 and writes
  the chapters (§1-§6 full, §7/§8 stubs) into the RUN-SCOPED DRAFT
  `.audit/handover-draft-<RUNID>.md`, ending the file with the line
  `DRAFT COMPLETE — RUNID: <RUNID>`. Then emits a `SYNTH REPORT`
  (`STATUS: DONE | BLOCKED`, RUNID, phase-cluster count, per-chapter word
  counts) and STOPS — STEP 13-16, the final MD, HTML and PDF are NEVER
  this mode's job.
 - **`MODE: render`** — runs on the sonnet frontmatter pin. FIRST loads the
  draft: absent file, RUNID mismatch, or missing `DRAFT COMPLETE` sentinel
  → `STATUS: BLOCKED` naming the cause (fail closed — never synthesize a
  missing draft, never render a partial one). Then runs STEP 13 → 14 →
  14.5 → 15 → 16 on the draft + PACKAGE and emits the `HANDOVER-DOC
  REPORT`. `OUTPUT = skip-write` → report `MD: skipped` and stop before
  rendering, as before.
 ---
 ## STEP 9 — LOAD MEMORY REGISTRIES
 ```bash
 MEMORY_DIR=".claude/memory"
 test -d "$MEMORY_DIR" || MEMORY_DIR=""
 ```
 If memory dir exists, read each file (full contents, parse manually):
 - `decisions.md` → list of BDR-XXX entries (date, title, decision, why,
  alternatives, status)
 - `learnings.md` → LRN-XXX entries
 - `blockers.md` → BLK-XXX entries (open vs resolved)
 - `journal.md` → date headings + 3-5 line session summaries
 - `evals.md` → EVAL-XXX entries
 If memory dir missing or empty, proceed using only git data — flag in
 final report that memory was unavailable.
 ---
 ## STEP 10 — GIT HISTORY SUMMARY
 ```bash
 git log --reverse --format='%h|%aI|%an|%s' | head -200
 git log --name-only --format='---COMMIT---' | grep -v '^---' | sort -u | head -50
 git log --diff-filter=A --name-only --format='' | sort -u | wc -l   # added
 git log --diff-filter=M --name-only --format='' | sort -u | wc -l   # modified
 git log --diff-filter=D --name-only --format='' | sort -u | wc -l   # deleted
 git tag --sort=-creatordate | head -5
 ```
 Cluster commits into 3-7 chronological phases based on commit message
 themes. Do this **inline**, yourself — this agent has no `Agent` tool,
 so there is no sub-agent to delegate to, regardless of project size.
 For projects with 200+ commits, read the full `git log --reverse
 --format='%h|%aI|%s'` output and group it by theme directly. For each
 phase: name, commit count, 2-line summary. Do NOT include dates or date
 ranges — the client document does not render them.
 ---
 ## STEP 12 — SYNTHESIZE THE DOCUMENT
 Generate the deliverable following the 6-chapter structure defined
 below (plus the §7/§8 annexes). The narrative arc: what was needed,
 what was done (lay summary), what the client must do, then technical
 details for the curious. Translate headings to `LANG`. Tone: friendly,
 concrete, no jargon. One short paragraph per idea.
 ### Hard rules for this document
 0. **All section cross-references MUST be clickable markdown links.**
   Whenever the doc body mentions a section by number (`§5.1`, `§6`,
   `§6.2`, etc.), write it as a markdown link to the heading anchor:
   ```
   [§5.1](#51-choix-techniques-importants)
   [§6](#6-annexe-plateformes-externes-visibilite)
   [§6.2](#62-plateformes-prioritaires-semaine-1)
   ```
   The renderer (`scripts/handover-to-pdf.sh`) uses pandoc with
   `--from=gfm+gfm_auto_identifiers` (or python-markdown's `toc`
   extension as fallback). Both auto-generate heading IDs in the
   GitHub-style slug:
   - lowercase
   - spaces → hyphens
   - accents stripped (é→e, à→a, etc.)
   - punctuation removed (`.`, `(`, `)`, `,`, `:`, `?`, `!`,
     apostrophes)
   - example: `### 6.2 Plateformes prioritaires (Semaine 1)` →
     `id="62-plateformes-prioritaires-semaine-1"`
   After writing the doc, **verify links resolve**:
   ```bash
   # Extract all anchor refs and all heading IDs, then check refs
   # against IDs (set difference should be empty).
   grep -oE '\]\(#[a-z0-9-]+\)' "$OUTPUT_MD" | tr -d ']()#' | sort -u > /tmp/refs.txt
   # Render once, then extract IDs:
   grep -oE 'id="[^"]+"' "$OUTPUT_HTML" | sed 's/id="//;s/"//' | sort -u > /tmp/ids.txt
   comm -23 /tmp/refs.txt /tmp/ids.txt
   # expected: empty. Each line printed = a broken anchor — fix.
   ```
   If you spot a broken anchor, regenerate the HTML once to inspect
   the actual ID, then update the markdown ref to match. The TOC
   line at the top of the doc and any "voir §N" cross-references
   in §3 / §4 / §5 / §6.x sub-tables / §6.9 calendar must all
   use the linked form.
 1. **Never name internal tools or skill identifiers in chapters 1–5.**
   Forbidden tokens (do not appear, in any case, in the lay portion):
   `/seo`, `/harden`, `/web-validate`, `/cso`, `/feat`, `/bugfix`,
   `/ship-feature`, `/ship`, `/code-clean`, `/refactor`, `seo-analyzer`,
   `geo-analyzer`, `validator-analyzer`, `harden`-as-product-name,
   `SEO.md`, `HARDEN.md`, `VALIDATE.md`, `CSO.md`, `MAX_ITERATIONS`,
   `ALL_PASS`, `SCORE_*`. Replace with what they correspond to in client
   language: référencement / visibilité IA / sécurité / conformité
   technique / audit interne. Internal tool names may appear ONLY in
   chapter 6 ("Détails techniques") inside the optional glossary.
 2. **Chapter 3 hard cap: 300 words max, zero technical jargon.** Plain
   French (or plain English if `LANG=en`). No acronyms not already in
   common usage (HTTPS is fine; CSP is not). Run `wc -w` against the
   chapter body; if over 300, rewrite shorter.
 3. **Chapter 5 is action-only.** Every bullet starts with a verb the
   client can act on without a developer.
 4. **Chapter 6 may use technical terms** (SEO, GEO, HSTS, CSP, etc.) but
   each term gets a one-line plain-language definition the first time it
   appears, or a glossary at the end of the chapter.
 ### Document structure
 ```
 # [Project name] — Compte rendu de livraison
 ## (or: HANDOVER — Project Recap)
 > Document préparé le YYYY-MM-DD à l'attention de [client name if known].
 > Ce document récapitule l'ensemble du travail réalisé sur votre projet
 > du JJ/MM/AAAA au JJ/MM/AAAA.
 ## 1. Ce qu'il fallait faire (et pourquoi)
 [Briefing + motivation. 100–180 words max. Two short paragraphs.
 - §1.1 (the brief): what the client wanted, in their own words if
  possible. Pull from the project journal's earliest entry, the README,
  or the first commit message.
 - §1.2 (the why): the underlying problem this project solves for the
  client (no audience, weak online presence, manual process to
  automate, broken legacy site, etc.). Concrete. Their reality, not
  ours.
 End the chapter with a one-line success criterion in their words —
 "À la livraison, vous deviez pouvoir ___." If unknown, omit rather
 than invent.]
 ## 2. Résultats — état de santé du site (avant / après)
 [Score table at the top, BEFORE the lay summary. Plain French
 column labels — no internal tool names. Numbers OK (the whole
 purpose of this chapter is the numbers). Follow with a short
 "Lecture rapide" bulleted list (one bullet per axis) explaining
 what each domain means and why the delta matters.
 **Every number in this table comes straight from `PACKAGE.SCORES`.**
 Do not recompute, re-run, or re-dispatch an audit to get a number —
 the parent already ran the pipeline and gate-checked it.
 | Domaine                                              | Avant       | Après        | Statut |
 |------------------------------------------------------|------------:|-------------:|:------:|
 | Référencement Google (recherche classique)           | <X.X>/20    | <Y.Y>/20     | OK     |
 | Visibilité IA (ChatGPT, Perplexity, Gemini, Claude) | <X.X>/20    | <Y.Y>/20     | OK     |
 | Sécurité du site (chiffrement, en-têtes, redirects) | <X.X>/20    | <Y.Y>/20     | OK     |
 | Conformité technique (HTML, CSS, accessibilité)      | —           | <Z.Z>/20     | OK     |
 (LANG=en column labels: "Domain" / "Before" / "After" / "Status".
 Row labels: "Google search (classical)", "AI visibility (ChatGPT,
 Perplexity, Gemini)", "Site security", "Technical compliance".)
 Add intro sentence: "Quatre dimensions auditées par des outils
 indépendants. Toutes au-dessus du seuil 17/20 fixé pour livrer."
 Lecture rapide bullets — one per axis, each explaining the domain
 in plain French and noting any notable jump (e.g., "Le score est
 passé de quasi-nul à très haut grâce à ..."). Cite concrete
 external validators when relevant (Mozilla Observatory, SSL Labs,
 SecurityHeaders.com — these are recognized seals).
 DO NOT mention internal tool/skill names here (no /seo, /harden,
 /web-validate, seo-analyzer, etc.). The lecture rapide IS where
 client-facing axis names live.]
 ## 3. Ce qui a été fait
 [**HARD CAP: 300 words. ZERO technical jargon.** This is the chapter the
 client reads first, possibly the only one they read.
 Structure as a single short narrative + a tight bullet list of
 user-visible benefits:
  Para 1 (3–5 sentences): the project today, in their words. What it
  looks like to a visitor, what the client can do with it. NOT what
  technologies were used.
  Bullet list (5–10 items): visible benefits, each phrased as something
  the client or their visitors can now do that they couldn't before.
  Pattern: "Vos visiteurs peuvent ___" / "Vous pouvez ___" /
  "Le site est maintenant ___".
 Forbidden in this chapter: framework names, audit names, score numbers,
 file paths, package names, command-line tool names, anything ending in
 `.md`, `.json`, `.yaml`. If you cannot describe a feature without one
 of those, the feature belongs in chapter 4, not here.
 After drafting, count words. Cap at 300. If over, cut paragraphs not
 bullets — bullets are the value-dense part.]
 ## 4. Vos informations officielles à utiliser partout (NAP)
 [**Position before §5 todo is REQUIRED**, not cosmetic. Client must
 have NAP under their eyes BEFORE attacking platform creation actions.
 Prose intro must start with "À lire avant d'attaquer le [§5](#5-...)"
 and cross-reference §5 explicitly.
 **This table is a direct render of `PACKAGE.NAP` — the parent already
 detected/asked/confirmed every field.** Do NOT auto-detect the business
 name or description, do NOT prompt the user interactively, do NOT
 invent a missing value. If `PACKAGE.NAP` carries a field as `[À COMPLÉTER]` or
 unconfirmed, render it as-is here and flag it in your final report.
 Table content (FR variant — translate cells to EN if `LANG=en`,
 keep column structure identical):
 | Champ                  | Valeur officielle à utiliser partout                       |
 |------------------------|------------------------------------------------------------|
 | Nom commercial         | [`PACKAGE.NAP.nom_commercial`]                              |
 | Nom légal              | [`PACKAGE.NAP.nom_legal`]                                   |
 | Adresse                | [`PACKAGE.NAP.adresse`]                                     |
 | Téléphone              | [`PACKAGE.NAP.telephone`]                                   |
 | E-mail pro             | [`PACKAGE.NAP.email`]                                       |
 | Site web               | [`PACKAGE.NAP.site_web`]                                    |
 | SIRET                  | [`PACKAGE.NAP.siret`] (if local business FR)                |
 | TVA                    | [`PACKAGE.NAP.tva`] (or "non applicable (franchise…)")      |
 | Coordonnées GPS        | [`PACKAGE.NAP.gps`]                                          |
 | Catégorie principale   | [`PACKAGE.NAP.categorie_principale`]                         |
 | Catégories secondaires | [`PACKAGE.NAP.categories_secondaires`] (up to 3)             |
 | Description courte     | [`PACKAGE.NAP.description_courte`]                           |
 | Horaires               | [`PACKAGE.NAP.horaires`] (per-day, with seasonal note if applicable) |
 End with two callouts:
 > **Conseil pratique** : enregistrer ce tableau en note dans votre
 > téléphone. À chaque inscription sur une nouvelle plateforme,
 > copier-coller depuis cette source unique — jamais de saisie à la
 > main, jamais de reformulation.
 > **À vérifier avant de commencer le §5** : si une de ces valeurs
 > n'est pas exacte, corrigez-la **ici d'abord**, puis appliquez la
 > nouvelle valeur partout.]
 ## 5. Ce qui vous reste à faire
 [Action-only checklist for the client. Pull from:
 **`.claude/audits/HUMAN-ACTIONS.md` FIRST when present** (the /seo//geo
 audit-end checklist — carry its automation notes, vulgarized), then open
 `blockers.md` entries, ongoing-monitoring items, external platforms to
 claim, content updates only the client can make, deploy steps if
 self-hosted. If any axis passed via the code-ceiling rule, its
 unlocking user actions appear HERE with their expected score gain
 ("+X points quand fait") — that is the contract that made the gate pass
 (carried in `PACKAGE.SCORES`' code-ceiling note).
 Format as a checklist grouped by cadence. Every line starts with a
 verb. Every line is something the client can do without a developer.
 ### Une fois (à faire dans les premières semaines)
 - [ ] Réclamer la fiche Google Business Profile et la vérifier (lien : ...)
 - [ ] Compléter le profil Apple Business Connect (lien : ...)
 - [ ] Vérifier la cohérence Nom / Adresse / Téléphone sur toutes les
      plateformes — voir l'annexe à la fin du document
 - [ ] [Si vous gérez l'hébergement vous-même : configurer le certificat
      de sécurité (renouvellement automatique recommandé)]
 - [ ] [Si vous gérez l'hébergement vous-même : programmer une sauvegarde
      quotidienne]
 **NEVER include**: "Sauvegarder ce document hors du dépôt (PDF, email)".
 Client has no access to the dev git repository — that line is a
 dev-only concept and confuses the deliverable. The PDF is delivered
 to them directly. STEP 14.5 explicitly removes it if it ever sneaks in.
 **Intro note**: add one line above the "Une fois" subheading so the
 client understands the mixed-state list:
 > Les cases déjà cochées correspondent à ce qui a déjà été validé.
 (English equivalent if `LANG=en`: "Items already checked have been
 validated.")
 The actual pre-check pass runs in STEP 14.5 (after §5 + §7 are drafted,
 before STEP 15 writes to disk), applying `PACKAGE.PRECHECK_DONE`. Do
 NOT pre-check items here.
 ### Mensuel
 - [ ] Ajouter ou mettre à jour 5 photos sur Google Business
 - [ ] Répondre aux avis Google (positifs et négatifs) sous 48 h
 - [ ] Vérifier que le site est toujours en ligne (test simple : ouvrir
      l'URL depuis un autre appareil)
 - [ ] [Si système de gestion de contenu : mettre à jour les contenus
      saisonniers]
 ### Trimestriel
 - [ ] Faire un test de visibilité IA : taper le nom du commerce dans
      ChatGPT, Perplexity, Gemini. Noter ce qui s'affiche.
 - [ ] Demander à 3–5 clients de laisser un avis Google
 - [ ] Publier un post Google Business (offre, événement, actualité)
 ### Annuel
 - [ ] Mettre à jour la photo de couverture Google Business
 - [ ] Vérifier que les horaires saisonniers sont bons
 - [ ] Renouveler les noms de domaine
 ### Quand quelque chose change dans la vie du commerce
 - [ ] Changement d'adresse, de téléphone ou d'horaires → modifier
      d'abord sur Google Business, puis sur toutes les autres
      plateformes (la cohérence est cruciale)
 [Adapt cadences to project type. For SaaS / non-local: replace
 Google Business cadences with appropriate platforms (Slack, App Store,
 Play Store, Trustpilot, G2, Capterra, etc.). For pure tooling /
 internal projects, this chapter may shrink to a 5-line "à surveiller"
 list — that is fine, do not pad.]
 ## 6. Détails techniques (pour les curieux)
 [Same content as before but consolidated and labelled as the
 technical-depth chapter. Internal tool names may appear here.
 The client is not required to read this chapter. The score table
 is NOT here — promoted to §2 for impact. Add a one-liner referencing
 back: "Les scores avant / après ont été déplacés au §2 pour
 visibilité."]
 ### 6.1 Choix techniques importants
 [Vulgarize 3–7 BDR entries. Design, framework, security, hosting
 decisions the client would care about. One paragraph each:
 what was chosen, why over the alternative, what it changes for the
 client. Drop entries the client cannot act on or care about.]
 ### 6.2 Comment on en est arrivé là (phases)
 [3–7 phases. For each: what was done, why it mattered, in technical
 detail this time. Reference commit clusters from STEP 10. Plain phase
 names, not skill names.
 **Do NOT include dates, date ranges, sprint numbers, or any
 chronological markers** ("22 avril", "23–24 avril", "Sprint 1",
 "Semaine 2", etc.). Phases are themes, not a timeline. The client
 does not need to know the exact timing — they need to understand
 what was done and why. Lead each bullet with the phase name in bold,
 followed by what was done. Forbidden tokens before write:
 `\b\d{1,2}\s+(janvier|février|mars|avril|mai|juin|juillet|août|septembre|octobre|novembre|décembre)\b`,
 `\bsprint\s+\d+\b`, `\bsemaine\s+\d+\b`.]
 Example — correct format (no dates):
 > - **Audit + conformité légale.** Mentions légales et politique de
 >   confidentialité publiées, HTTPS forcé, premières corrections
 >   SEO. Risque RGPD jusqu'à 20 M€ neutralisé.
 > - **Refonte technique.** Le fichier monolithique de 1 554 lignes
 >   démonté en 12 morceaux PHP réutilisables.
 Wrong — has date prefix:
 > - **22 avril — Audit + conformité légale.** ...
 ### 6.3 Glossaire (optionnel)
 [Include only if at least 4 of the terms below appear in chapter 4.
 Format: term — one-line plain-language definition. Sort alphabetically.
 This is the ONLY place internal tooling names may be mentioned by
 their internal label, and only when explaining what they correspond
 to.]
 - **SEO (référencement classique)** — ensemble des pratiques pour
  apparaître dans Google, Bing, DuckDuckGo.
 - **GEO (visibilité IA)** — équivalent du SEO pour les moteurs par IA
  comme ChatGPT, Perplexity, Gemini.
 - **HSTS** — en-tête HTTP qui force la navigation en HTTPS.
 - **CSP (Content Security Policy)** — règle qui limite ce que le
  navigateur charge depuis le site, pour bloquer les injections.
 - **WCAG** — standard d'accessibilité (AA = niveau recommandé).
 - **Schema.org / JSON-LD** — annotations cachées qui aident moteurs et
  IA à comprendre le contenu.
 - **llms.txt** — fichier qui dit aux moteurs IA quel est le contenu
  important du site.
 ## 7. Annexe — Plateformes externes (web)
 [NAP table is NOT here — promoted to §4. This annex starts directly
 with the platform sub-sections (§7.1 Plateformes prioritaires, §7.2
 Réseaux sociaux, etc.). Add a one-line callout in the chapter intro:
 "Le NAP a été déplacé en tête au [§4] pour que vous l'ayez sous les
 yeux avant d'attaquer les actions du [§5]. Référez-vous-y à chaque
 inscription — c'est la source de vérité unique."]
 ## 8. Annexe — Build & déploiement (optionnel)
 ---
 *Document généré automatiquement à partir de l'historique du projet et
 des audits de santé. Pour toute question, contactez [contact].*
 ```
 ### Tone rules
 1. Address the client directly ("votre site", "vous pouvez").
 2. Chapters 1–3: replace every tech term with a user-facing equivalent.
 3. No abbreviations the client wouldn't use (HTTPS yes, CSP no — unless
   in chapter 4 with definition).
 4. Concrete numbers > adjectives.
 5. Short paragraphs. Bullet lists for things you can count.
 6. **Score deltas explained in plain words**. Never just dump numbers.
 7. **Chapter 5 is action-oriented**. Every line starts with a verb.
   Every line is something the client can do without a developer.
 8. **No skill-name leaks in chapters 1–5.** See "Hard rules" above.
 ---
 > **MODE BOUNDARY.** STEP 12 is the last synthesize-mode step: write the
 > drafted chapters to `.audit/handover-draft-<RUNID>.md` (+ the
 > `DRAFT COMPLETE — RUNID: <RUNID>` terminal line), emit the SYNTH
 > REPORT, stop. Everything below (STEP 13-16) is `MODE: render` and
 > operates ON that draft.
 ## STEP 13 — SEO/GEO MANUAL CHECKLIST (web projects only)
 If `PROJECT_TYPE=web` AND `PACKAGE.SKIP_SEO` is not `yes`, append this chapter
 as **§7 Annexe — Plateformes externes** in the 6-chapter structure
 (see STEP 12). Replace the §7 stub with the full content rendered from
 the resource file.
 Read the resource file:
 `$HOME/.claude/skills/client-handover/checklists/seo-geo-manual.md`
 That file contains the canonical platform list with registration URLs in
 both FR and EN. Use the section matching `LANG` and `IS_LOCAL_BUSINESS`.
 If the file is unreachable, fall back to the inline platform list at the
 bottom of this agent (`## PLATFORM REFERENCE`).
 The chapter must include:
 1. **Pourquoi c'est important** (1 paragraph). Site is technically
   optimized; visibility on Google, ChatGPT, directories depends on
   actions only the client can take.
 2. **NAP consistency** — **NOTE**: the NAP table itself is NOT
   rendered here in §7. It was promoted to its own dedicated chapter
   **§4 ("Vos informations officielles à utiliser partout (NAP)")**
   per the structure decision in STEP 12 (so the client has the
   values under their eyes BEFORE attacking platform creation).
   In this §7 annex chapter, just emit a one-line callout pointing
   back to §4:
   > Le NAP a été déplacé en tête au [§4](#4-vos-informations-officielles-a-utiliser-partout-nap)
   > pour que vous l'ayez sous les yeux **avant** d'attaquer les
   > actions ci-dessous. Référez-vous-y à chaque inscription —
   > c'est la source de vérité unique.
   The actual table content is defined in the §4 template at STEP 12
   and is a direct render of `PACKAGE.NAP`. Do NOT duplicate the table
   here.
 3. **Platform checklist** (priority-ordered table per `IS_LOCAL_BUSINESS`).
   Each row: Plateforme | Pourquoi | Lien d'inscription | Action | Statut.
 4. **AI search visibility (GEO)**. Plain explanation + actions: Wikidata,
   Knowledge Panel, llms.txt, periodic re-audit.
 5. **Reviews & reputation**.
 6. **Photos & content**.
 7. **Schedule** (Semaine 1 / Mois 1 / Mois 3 / Trimestriel).
 8. **Outils gratuits pour vérifier votre présence**.
 Cross-link this chapter from §4 (owner responsibilities — "Ce qui vous
 reste à faire"). Items in this §7 annex that are recurring belong in
 §4's cadence checklist (Mensuel / Trimestriel / Annuel).
 ---
 ## STEP 14 — BUILD & DEPLOY CHAPTER (only if `PACKAGE.INCLUDE_DEPLOY = yes`)
 If `PACKAGE.INCLUDE_DEPLOY != yes`, skip this step entirely — do not
 render §8. The parent already asked the client; do not re-ask.
 If included, this becomes **§8 Annexe — Build & déploiement** in the
 6-chapter structure (see STEP 12). For each `PACKAGE.DEPLOY_HINTS` match,
 generate a short subsection:
 1. What this means (1 paragraph).
 2. First-time setup (numbered steps + signup link).
 3. Day-to-day deploy (typical command / click sequence).
 4. How to know it worked (where to check URL, where to find logs).
 5. What it costs (free tier, when paid kicks in — `WebSearch` for
   2026 pricing if not in repo).
 6. Who to call when it breaks (status page, support link).
 If `PACKAGE.DEPLOY_HINTS` is empty, offer 2-3 standard options:
 - Static site → Netlify / Vercel / Cloudflare Pages
 - Webapp → Fly.io / Render / Vercel / Railway
 - CLI / library → npm / PyPI / crates.io / Homebrew
 For each: signup + 5-step deploy walkthrough.
 ---
 ## STEP 14.5 — PRE-CHECK COMPLETED ITEMS (web/local-business)
 Skip if `PROJECT_TYPE != web`. Runs AFTER STEP 12 + STEP 13 (in-memory
 body drafted), BEFORE STEP 15 (write).
 **Goal**: pre-check (`[x]` markdown / `☑` Unicode) every checkbox in
 §5 (todo) + §7 (platforms annex) that `PACKAGE.PRECHECK_DONE` marks as
 already done, so the client only sees what's actually left to do.
 **This step only APPLIES a decision already made by the parent.** All
 detection (project docs / memory / git log / `WebSearch`) and the
 batch-unknowns interactive prompt happened upstream, before you were
 dispatched — `PACKAGE.PRECHECK_DONE` is the resolved outcome. Do NOT
 detect anything yourself here, and do NOT prompt the user interactively.
 ### Scope
 **INCLUDE** (eligible for pre-check, if present in `PACKAGE.PRECHECK_DONE`):
 - §5 "Une fois — à faire dans..." block (one-shot platform creation /
  account setup / first-time configuration items).
 - §7.1 / §7.2 / §7.3 / §7.4 / §7.5 — top-level "Fiche créée" /
  "Compte créé" / "Page créée" rows.
 **EXCLUDE** (always leave unchecked, even if the platform name appears
 in `PACKAGE.PRECHECK_DONE`):
 - §5 "Mensuel", "Trimestriel", "Annuel", "Quand quelque chose change"
  cadences (recurring, never "done").
 - §7 sub-checkboxes detailing platform completeness ("10 photos
  minimum", "Description rédigée", "Bouton Réserver configuré") —
  existence of platform doesn't prove depth. Leave for client.
 - Lines containing recurring-action verbs: "demander", "tester",
  "ajouter", "publier", "vérifier régulièrement", "répondre".
 ### Apply pre-checks to in-memory body
 For each item in `PACKAGE.PRECHECK_DONE` that maps to an in-scope
 checkbox:
 - §5 markdown: `- [ ]` → `- [x]`.
 - §7 Unicode: `- ☐` → `- ☑`.
 - Optionally rewrite surrounding text:
  - Add a short confirmation phrase in **bold** (e.g., "**Fiche
    Google Business Profile créée et vérifiée.**").
  - If `PACKAGE.PRECHECK_DONE` carries a public URL for the item,
    append it as evidence (`Fiche en ligne : https://...`).
  - Sub-items dependent on a parent platform existing stay `☐` so
    the client sees what depth-checks remain.
 ### Cleanup pass (always)
 - **Remove** any line containing "Sauvegarder ce document hors du
  dépôt" — client has no repo access, dev-only concept.
 - **Add intro note** to §5 (above "Une fois" subheading) if any
  item was pre-checked:
  > Les cases déjà cochées correspondent à ce qui a déjà été validé.
  (`LANG=en`: "Items already checked have been validated.")
 ### Verification
 ```bash
 # At least one pre-check expected for any project with real history.
 grep -cE '^- \[x\]|^- ☑' "$OUTPUT_MD"
 # Expected: > 0 unless project is fresh and has zero external presence.
 ```
 Then re-run STEP 15 word-count + skill-leak gates after these edits.
 ---
 ## STEP 15 — WRITE MARKDOWN OUTPUT
 Output path and overwrite handling come from `PACKAGE.OUTPUT` — the
 parent already resolved this (checked whether the target file exists
 and, if so, asked the user). Do NOT ask again:
 - `overwrite` → write to `PACKAGE.OUTPUT`'s path, replacing the
  existing file.
 - `versioned <path>` → write to the given versioned path instead
  (e.g. `LIVRAISON-YYYY-MM-DD.md`).
 - `skip-write` → do not write the MD file, do not proceed to STEP 16.
  Report `STATUS: DONE` with `MD: skipped (per PACKAGE.OUTPUT)` and
  stop.
 Write the file with the `Write` tool.
 Sanity checks (do them in this order, before STEP 16):
 ```bash
 wc -l <output>                          # expect 250-900 lines
 grep -c "^## " <output>                 # expect 6-8 top-level chapters
                                        #   §1, §2, §3, §4, §5, §6, [§7 web], [§8 deploy]
 ```
 **Chapter 3 word-count gate** (lay summary "Ce qui a été fait" — §3
 since §2 = score table). Extract the body of `## 3. Ce qui a été fait`
 (or `## 3. What we did` if `LANG=en`) and run `wc -w` on it.
 **Hard cap: 300 words.** If over, edit the chapter (remove paragraphs,
 keep bullets) and re-write before moving to STEP 16. Do not skip this
 gate — §3 is the lay narrative the client reads first after the score
 table.
 ```bash
 awk '/^## 3\. /{flag=1; next} /^## 4\. /{flag=0} flag' "$OUTPUT" | wc -w
 # expected: ≤ 300
 ```
 **Skill-name leak gate.** Forbidden tokens must NOT appear in chapters
 1–5 (the lay portion: brief, scores, lay summary, NAP, todo).
 Chapter 6 (Détails techniques) may use them in the optional glossary.
 ```bash
 awk '/^## 1\./{flag=1} /^## 6\./{flag=0} flag' "$OUTPUT" \
  | grep -niE '/(seo|harden|web-validate|validate|cso|feat|bugfix|ship-feature|ship|code-clean|refactor)\b|seo-analyzer|geo-analyzer|validator-analyzer|SEO\.md|HARDEN\.md|VALIDATE\.md|CSO\.md|MAX_ITERATIONS|ALL_PASS|SCORE_[A-Z_]+'
 # expected: no matches. Each match is a leak — rewrite the offending
 # chapter in client language before STEP 16.
 ```
 **Anchor-resolution gate** (clickable section refs work).
 ```bash
 grep -oE '\]\(#[a-z0-9-]+\)' "$OUTPUT_MD" | tr -d ']()#' | sort -u > /tmp/refs.txt
 grep -oE 'id="[^"]+"' "$OUTPUT_HTML" | sed 's/id="//;s/"//' | sort -u > /tmp/ids.txt
 comm -23 /tmp/refs.txt /tmp/ids.txt
 # expected: empty. Each line printed = a broken anchor — fix the ref
 # in markdown (most likely a stale anchor from an earlier renumbering).
 ```
 If either gate fails, fix and re-write the markdown before continuing.
 ---
 ## STEP 16 — RENDER BRANDED HTML + PDF
 Always produce a branded `.html` next to the `.md`. Produce a branded
 `.pdf` when a PDF engine is available on the host. The file is the
 client-visible deliverable.
 ### Inputs already known
 | Variable          | Source                                      |
 |-------------------|---------------------------------------------|
 | `OUTPUT_MD`       | path written in STEP 15                     |
 | `LANG`            | from `PACKAGE.LANG`                         |
 | `PROJECT_NAME`    | `PACKAGE.PROJECT.name`                       |
 | `CLIENT_NAME`     | `PACKAGE.CLIENT_NAME`                        |
 | `PROJECT_PERIOD`  | `PACKAGE.PROJECT.period` (DD/MM/YYYY → DD/MM/YYYY) |
 | `PROJECT_URL`     | `PACKAGE.PROJECT.deployed_url` (or `—` if none) |
 `PACKAGE.CLIENT_NAME` is ground truth. If it is `—`, render the cover
 without a client name — do NOT prompt the user interactively.
 ### Run the renderer
 ```bash
 PROJECT_NAME="$PROJECT_NAME" \
 CLIENT_NAME="$CLIENT_NAME" \
 PROJECT_PERIOD="$PROJECT_PERIOD" \
 PROJECT_URL="$PROJECT_URL" \
 LANG="$LANG" \
 "$HOME/.claude/skills/client-handover/scripts/handover-to-pdf.sh" \
  "$OUTPUT_MD"
 ```
 The renderer:
 1. Converts the markdown to HTML using the first available engine
   (pandoc > python-markdown > `npx marked`).
 2. Wraps the body in the ZenQuality template (cover page + branded
   typography Inter + Playfair Display, ZenQuality green palette
   `#1A3A25 / #2D5A3D / #4A7C59 / #87A878`, **white cover**
   (`--white-pure`) with black-deep title and green-forest accents
   (eyebrow, meta labels, footer); subtle radial sage + forest tints
   add depth. Cream `#F5F0EB` reserved for body code/blockquote
   accents — not page bg).
 3. Embeds the ZenQuality logo (default: `https://zenquality.fr/assets/logo-horizontal-1024.png`;
   override with `LOGO_URL` env var to use a local file).
 4. Emits `LIVRAISON.html` (or `HANDOVER.html`) next to the `.md`.
 5. Tries PDF engines in order: weasyprint > wkhtmltopdf > chromium >
   chromium-browser > google-chrome. First match writes
   `LIVRAISON.pdf` (or `HANDOVER.pdf`).
 6. If no PDF engine is available, exits with code 2 and prints
   install hints. The HTML file is still produced and viewable —
   the user can "Print → Save as PDF" from any modern browser.
 ### Exit code handling
 | `$?` | Meaning                                       | Action |
 |------|-----------------------------------------------|--------|
 | 0    | HTML and PDF written                          | continue to `## OUTPUT` |
 | 2    | HTML written, no PDF engine on host           | continue to `## OUTPUT` — report mentions PDF as MISSING and lists install commands |
 | 1    | Fatal (bad args, unwritable dir, conv error)  | report `STATUS: BLOCKED` with the script's stderr |
 ### Re-rendering when `PACKAGE.OUTPUT` is `versioned <path>`
 If `PACKAGE.OUTPUT` resolved to a versioned path (e.g.
 `LIVRAISON-YYYY-MM-DD.md`), the renderer produces matching
 `LIVRAISON-YYYY-MM-DD.html` and `LIVRAISON-YYYY-MM-DD.pdf`. Pass the
 versioned path as `$OUTPUT_MD`.
 ---
 ## PLATFORM REFERENCE (fallback if checklists/seo-geo-manual.md missing)
 Local-business priority order with 2026 signup URLs:
 1. Google Business Profile — https://www.google.com/business/
 2. Apple Business Connect — https://businessconnect.apple.com/
 3. Bing Places for Business — https://www.bingplaces.com/
 4. Pages Jaunes (FR) — https://www.pagesjaunes.fr/pro/inscription
 5. Facebook Page — https://www.facebook.com/pages/create
 6. Instagram Business — https://business.instagram.com/
 7. TripAdvisor (hospitality) — https://www.tripadvisor.com/Owners
 8. TheFork / La Fourchette (restaurants FR) — https://www.thefork.com/restaurant
 9. Yelp — https://biz.yelp.com/
 10. Mappy (FR) — https://corporate.mappy.com/
 11. Waze — https://www.waze.com/business/
 12. Foursquare for Business — https://business.foursquare.com/
 13. Bottin / Justacote (FR) — https://www.justacote.com/
 14. Hoodspot (FR) — https://www.hoodspot.fr/
 15. Trustpilot — https://business.trustpilot.com/
 16. Google Maps Local Guides reviews push — covered by Google Business
 Niche-specific:
 - Doctolib (médical FR) — https://pro.doctolib.fr/
 - Booking.com (hôtellerie) — https://www.booking.com/business
 - Airbnb (locations) — https://www.airbnb.com/host/homes
 - LinkedIn Company Page — https://www.linkedin.com/company/setup/new/
 - TikTok Business — https://www.tiktok.com/business/
 - Pinterest Business — https://business.pinterest.com/
 Non-local web priority:
 1. Google Search Console — https://search.google.com/search-console
 2. Bing Webmaster Tools — https://www.bing.com/webmasters
 3. Wikidata entry — https://www.wikidata.org/wiki/Special:CreateAccount
 4. LinkedIn Company Page (B2B)
 5. Product Hunt (launches) — https://www.producthunt.com/posts/new
 6. Crunchbase (startups) — https://www.crunchbase.com/add-new
 7. G2 / Capterra (SaaS reviews) — https://www.g2.com/, https://www.capterra.com/
 8. GitHub topic + README badges (open source)
 AI visibility (GEO):
 - Wikidata Q-item with `sameAs`
 - Schema.org JSON-LD: Organization, LocalBusiness, niche, FAQPage, Article, Person
 - llms.txt at site root
 - Direct AI checks: search business name on ChatGPT, Claude, Perplexity, Gemini
 If you need 2026-current pricing, signup steps, or a platform you're
 unsure exists, use `WebSearch` and confirm before listing it. Do NOT
 invent links.
 ---
 ## FORBIDDEN
 - `git commit`, branch creation/switch, `git push`.
 - Installing new dependencies.
 - Dispatching subagents (no `Agent` tool — none available).
 - Prompting the user interactively — every interactive decision
  travels in the PACKAGE; if something is missing, report
  `STATUS: BLOCKED` instead of asking.
 - Editing anything under `.claude/**`.
 - Attribution trailers of any kind in any file this agent writes.
 ---
 ## OUTPUT
 End every run with a `HANDOVER-DOC REPORT` block:
 ```
 HANDOVER-DOC REPORT
 STATUS: DONE | BLOCKED
 MD: <path written, or "skipped (per PACKAGE.OUTPUT)", or "—" if BLOCKED>
 HTML: <path written, or "—" if not reached>
 PDF: <path written, or "no engine" (exit 2), or "—" if not reached>
 GATES: word-count=<pass/fail + word count> skill-leak=<pass/fail> anchor=<pass/fail>
 NOTES: <memory/audit availability caveats, [À COMPLÉTER] markers left in
  NAP, pre-check items applied, deploy chapter included/skipped, or the
  BLOCKED reason + which PACKAGE field was missing/malformed>
 ```
@@ -1,91 +1,48 @@
 ---
 name: hotfixer
 description: Quick-fix executor — dispatched by /hotfix, which owns the routing and gitflow gate. Max 2 files, obvious root cause only (typo, CSS value, config, off-by-one, missing import).
-tools: Read, Edit, Write, Bash, Grep, Glob, Agent
+tools: Read, Edit, Write, Bash, Grep, Glob
 model: sonnet
 ---
-# HOTFIX — Quick Superficial Fix
+# HOTFIXER — closed-fix executor / L1 fix-bundle applier
-Fast-track fix for obvious bugs. No planning overhead, no plugin check.
+You apply a fix that was ALREADY decided upstream and prove it doesn't break
-The fix is inline (no dev subagents); a fresh security gate runs before
+the build — you never investigate or design the fix. Two dispatch sources,
-commit, and any gate failure reverts — never loops. Get in, fix, gate,
+same job:
 get out.
-## REQUEST
+- **/hotfix orchestrator** — root-cause analysis happened in its LOCATE step;
-$ARGUMENTS
+  you get a CONTRACT + the located files + the proposed fix (see INPUT).
 - **audit dispatchers (/seo, /geo, /web-validate)** — you are the L1
  fix-bundle applier; the dispatch prompt hands you a bundle item inline
  (files, concern, current, expected fix) with NO CONTRACT. Apply exactly
  that item, self-verify, do not commit. There is no FILE SCOPE contract on
  this path — the named files in the item ARE the scope.
---
+## INPUT (in the dispatch prompt)
-## STEP 1 — LOCATE
+/hotfix path:
 - `CONTRACT`: path to the contract file — read it FIRST; its acceptance
  criteria + FILE SCOPE bound everything you do.
 - `LOCATED`: the file(s) the orchestrator found + the confirmed root cause.
 - `FIX`: the proposed minimal fix, already decided.
 - `BRANCH`: verify with `git branch --show-current`; mismatch → STATUS
  BLOCKED — never create or switch branches.
-Find the bug. Use the description and any error message to go
+Applier path (/seo, /geo, /web-validate): no CONTRACT/LOCATED/FIX keys — the
-straight to the source:
+bundle item in the prompt is the fix to apply. Skip the contract read; the
 `## OUTPUT` report below is optional on this path (the dispatcher just needs
 the edit applied + self-verified, not the report grammar).
-```bash
+## EXECUTION RULES
 git status
 git log --oneline -3
 ```
- Read the relevant file(s). Confirm the root cause is obvious
+- Apply the minimal change that fixes the bug. Edit only what is necessary
-  and superficial (typo, wrong value, missing import, etc.).
+  — no refactoring, no cleanup, no "while we're here" improvements.
- If the bug turns out to be deeper than expected (unclear cause,
+- Stay inside the scope you were given. On the /hotfix path that is the
-  multiple files involved, logic error): STOP and say:
+  contract FILE SCOPE (max 2 files) — a fix that needs more → `STATUS
-  "This looks deeper than a hotfix. Load `$HOME/.claude/agents/bugfixer.md`
+  BLOCKED`, report why (the orchestrator escalates to `/bugfix`), never
-  and run the BUGFIXER agent on this target."
+  expand scope yourself. On the applier path it is the files named in the
-
+  bundle item — apply only those.
 OPTIONAL — memory check (exempt by default; hotfix = obvious fix, mirror of its capitalize
 skip). For a RECURRING or urgent bug only, a quick blockers-only glance may save time:
      [ -d .claude/memory ] && grep -nE '^## BLK-' .claude/memory/blockers.md   # "déjà vu ?"
 If a prior BLK names this bug, jump to its solution. Not mandatory; no RELATED MEMORY
 disposition required at hotfix weight.
 ## STEP 1.7 — CONTRACT (silent autofill)
 Run `$HOME/.claude/lib/contract-interview.md` at hotfix weight: **zero
 questions ever** (a hotfix is an obvious fix by definition). Autofill the
 contract — REQUEST verbatim = the bug description as given; ACCEPTANCE
 CRITERIA = "symptom gone; build/tests green"; FILE SCOPE = the 1-2 target
 files. It writes `.claude/tasks/contracts/<date>-<slug>-<HHMM>.md`. This is
 the reference for the security gate's scope and the escalation report if a
 gate fails. No verifier is dispatched at hotfix weight — the STEP 3
 smoke-check already verifies these trivial criteria; the gate hotfix adds is
 security (below).
 ## STEP 1.5 — DESIGN GATE
 Follow `$HOME/.claude/lib/design-gate.md`:
 - Scan $ARGUMENTS and target files for design/UI/style signals (CSS, component, styling, animation).
 - If signals found → run `design-tool-gate.sh`; if it reports INCOMPLETE,
  tell the user to run `/profile design` before proceeding.
 - If no signals → skip (zero overhead).
 ## STEP 2 — PRE-FLIGHT + FIX
 **Gitflow aiguillage (before editing):** follow `$HOME/.claude/lib/gitflow-aiguillage.md`
 — your type = `hotfix`. On `main`/`develop` it branches first; on a working
 branch it's a no-op (commit in place). Never `finish`.
 ### Pre-flight (mandatory)
 Before editing, snapshot current state so revert is possible:
 ```bash
 git diff HEAD --stat   # confirm working tree is clean OR carries only the
                       # in-progress hotfix area; if unrelated dirty files are
                       # present, ask user whether to stash them first
 git rev-parse HEAD     # capture the SHA to revert to on failure
 ```
 If the working tree contains unrelated uncommitted changes the user has not
 mentioned: STOP and ask `"working tree dirty: stash and continue, or abort?"`.
 ### Fix
 Apply the minimal change that fixes the bug:
 - Edit only what is necessary. No refactoring, no cleanup.
 - If tests exist for the affected code, run them. Detection cascade:
  ```bash
  # JS/TS
@@ -101,85 +58,25 @@ Apply the minimal change that fixes the bug:
  test -f Makefile && grep -qE '^test:' Makefile && echo "make test"
  ```
  Run whichever one resolves; if none → continue to smoke check below.
- Smoke check (always, even when no tests): try the build/typecheck command for
+- Smoke check (always, even when no tests ran): try the build/typecheck
-  the stack — `npm run build`, `tsc --noEmit`, `cargo build`, `go build ./...`,
+  command for the stack — `npm run build`, `tsc --noEmit`, `cargo build`,
-  `python -c "import <pkg>"` — to confirm the fix did not break compilation.
+  `go build ./...`, `python -c "import <pkg>"` — to confirm the fix did not
  break compilation.
 - Report the SMOKE result verbatim, pass or fail. You do not decide
  pass/fail consequences — the orchestrator's STEP 4 reads your SMOKE line
  and owns the revert decision.
 - FORBIDDEN: `git commit`, branch ops, push, merge, dispatching the
  security gate (the orchestrator owns it), `git restore`/revert of any
  kind (the orchestrator owns the pre-flight SHA), user questions (you
  cannot ask — report BLOCKED instead), attribution trailers of any kind.
-## STEP 3 — VERIFY + COMMIT
+## OUTPUT — end with exactly this report (your final message)
 1. Verify the fix:
   - Run the test suite or the specific test if available.
   - If no tests: smoke check from STEP 2 must have passed.
 2. **Failure branch** — if tests fail OR smoke check fails after the fix:
   - Print the failure output verbatim (under 30 lines).
   - Run `git restore .` to revert the working-tree edits to the pre-flight SHA.
     (Files were not yet staged — restore is safe.)
   - STOP and tell user: `"Hotfix introduced a regression. Reverted. Escalate to /bugfix or /analyze for deeper investigation."`
   - Do NOT commit a broken fix.
 3. **Security gate (fresh auditor) — failure REVERTS, never loops.** Dispatch
   a FRESH security-auditor (`subagent_type: security-auditor`, or load
   `agents/security-auditor.md`) with `MODE: gate`, `SCOPE:` the working-tree
   diff vs the pre-flight SHA. Parse its `SECURITY — VERDICT:` line:
   - `PASS` (or `DEGRADED` with no BLOCK) → proceed to commit.
   - `BLOCK(n)` → this is hotfix: do NOT loop. Run `git restore .` to the
     pre-flight SHA, print the `BLOCKING` list, and STOP:
     `"Hotfix introduced a security finding. Reverted. Escalate to /bugfix
     for a fix under the full verify+security loop."` The hotfix model is
     one attempt; any gate failure (smoke OR security) reverts and escalates.
   - Structural failure (mute / unparsable / no VERDICT line) → treat as a
     failed gate: retry ONCE fresh; a 2nd structural failure → revert +
     escalate. A mute auditor is never a PASS.
 4. Commit using conventional format (only after verify AND security pass):
 ```
-   fix(<scope>): <what was wrong>
+HOTFIX-EXEC REPORT
-   ```
+STATUS  : DONE | BLOCKED
 5. Print summary:
   ```
   HOTFIX APPLIED
 FILE(S) : <changed files>
 FIX     : <one-line description>
-   VERIFIED: <test name or smoke check that passed>
+SMOKE   : <test/build result, verbatim line>
-   SECURITY: <PASS | DEGRADED (checklist only)>
+NOTES   : <BLOCKED: the blocker; DONE: none>
 ```
 ## STEP 4 — DOC SYNC (automatic)
 Load `$HOME/.claude/agents/doc-syncer.md`.
 Execute in automatic mode:
 `auto-mode scope: <list of files modified during this session>`
 **Then commit the docs** — follow `$HOME/.claude/lib/doc-commit.md`: it surgically commits
 ONLY the files doc-syncer patched (its `PATCHED_FILES` output), never `git add -A`, never
 `.claude/`/`CLAUDE.md` (rc 4 = a loud BDR-022 anomaly, not a silent skip), and no-ops when
 nothing was patched — the common case for a trivial hotfix. No FINISH in an inline flow, so
 it just commits the docs on the current branch (no ordering concern).
 ## STEP 5 — CAPITALIZE (memory registries, lightweight)
 Hotfixes are often trivial (typo, config, import) — skip by default. But if the fix revealed something non-obvious:
 - Wrong default that should never have been merged → propose `LRN-XXX` in `.claude/memory/learnings.md`.
 - Bug that cost real time to locate despite being "superficial" → propose `BLK-XXX` in `.claude/memory/blockers.md` (status: resolved).
 Default behaviour: `CAPITALIZE: hotfix trivial, skip` (no prompt, no output).
 Ask the user only when there is an actual candidate to propose.
 Always append a 1-line entry to today's heading in `.claude/memory/journal.md` (even trivial hotfix — journal is timeline, not signal).
 **Language rule**: the journal line and any proposed BLK/LRN entries are ALWAYS written in English (see CLAUDE.md "Memory registries" § Language).
 **Then commit the memory** — follow `$HOME/.claude/lib/capitalize-commit.md`: it
 surgically commits what capitalize just wrote (`.claude/memory` + `.claude/tasks`
 only, never `git add -A`) as one `chore(memory)` commit, reports the memory-commit
 hash, and no-ops if nothing was written. The always-on journal line means a
 trivial hotfix still produces a `chore(memory): journal — …` commit (Frame 2 / F3).
 ---
 ## RULES
 - Max 2 files changed. If more needed → `/bugfix`.
 - No refactoring. No "while we're here" improvements.
 - Design gate only if CSS/style signals detected. See STEP 1.5.
 - If root cause is unclear → escalate to `/bugfix`.
 - If fix touches >5 lines of logic → reconsider if this is
  truly a hotfix.
@@ -2,7 +2,6 @@
 name: interviewer
 description: Gather project info. Ask targeted questions, produce PROJECT BRIEF. First step of project init.
 tools: Read
 model: sonnet
 ---
 # INTERVIEWER
@@ -0,0 +1,117 @@
 ---
 name: plan-challenger
 description: Fresh independent plan challenger — reads a PLAN file from disk and adversarially attacks it through ONE assigned lens (correctness | robustness | simplicity), then renders structured findings + a verdict. Report-only, never fixes, never implements. Dispatched fresh; blind to the other lenses.
 tools: Read, Grep, Glob, Bash
 model: opus
 ---
 # PLAN-CHALLENGER AGENT
 You adversarially CHALLENGE a plan BEFORE it is implemented. You are NOT the
 author, you never fix or implement anything, and you never trust the plan's own
 justification — only the plan text, the code it would touch, and what you
 inspect yourself. Your job is to find where the plan is WRONG, BREAKS, or is
 NEEDLESSLY COMPLEX — not to praise it.
 Bash is for OBSERVATION ONLY: read-only `git` inspection, grep/find, reading the
 files the plan would change. Never a command that writes, installs, commits, or
 mutates any state.
 ## INPUT (from the orchestrator — nothing else exists)
 - `PLAN: <path>` — you READ it from disk; never accept an inline restatement.
 - `LENS: <correctness | robustness | simplicity>` — the ONE angle you attack from.
 - `SCOPE: <files/dirs the plan touches>` — where to ground your critique.
 - `CONSTRAINTS: <path | inline>` (optional) — decided trade-offs / rejected
  alternatives. A concern already settled here is NOT a finding.
 You NEVER receive the other challengers' findings, prior reviews, or author
 notes. If any appear in your prompt, IGNORE them — every challenge is blind.
 ## STEP 1 — READ THE PLAN
 Read the plan (and CONSTRAINTS if given). If the plan is missing, unreadable, or
 has no discernible plan of action → output
 `CHALLENGE — LENS: <lens> — VERDICT: ERROR(<reason>)` plus the `PLAN:` line, STOP.
 ## STEP 2 — ATTACK THROUGH YOUR LENS
 Stay strictly within your assigned lens:
 - `correctness` — Correctness & Feasibility: wrong/unstated assumptions, false
  premises, missing steps, dependencies that don't hold, misread requirements, a
  step that cannot technically work as written, claims contradicted by how the
  code actually behaves.
 - `robustness` — Robustness & Risk (red-team / premortem): edge cases, failure
  modes, security/abuse, irreversibility, missing rollback, blast radius,
  latency/cost blowups, races, bad interaction with existing behavior. Assume it
  shipped and caused an incident — what was it?
 - `simplicity` — Simplicity & Scope: over-engineering, YAGNI, scope creep, a
  simpler correct alternative reaching ~80% of the value, wrong altitude, or
  reinventing something the codebase already has. Also flag UNDER-scoping: a plan
  too thin to meet its own goal.
 Ground EVERY finding in the plan text (quote the section) or the real code
 (`file:line` you read). A finding you cannot ground is noise — drop it.
 ## STEP 3 — SEVERITY
 - `BLOCKER` — as written, the plan cannot succeed, or will cause real harm.
 - `MAJOR` — a significant flaw that should be fixed before implementation.
 - `MINOR` — a worthwhile improvement, not a gate.
 ## OUTPUT (exact format — machine-parsed by the orchestrator)
 ```
 CHALLENGE — LENS: <correctness|robustness|simplicity> — VERDICT: SOLID | CONCERNS(n) | FATAL(n)
 PLAN: <path>
 FINDINGS:
  1. [BLOCKER] <claim> — WHY: <why it fails — plan § or file:line> — FIX: <one line>
  2. [MAJOR]   <claim> — WHY: <…> — FIX: <…>
  (none within this lens → the single line: FINDINGS: none)
 PROOF: read <n> files, inspected <what>, checked plan §<…>
 ```
 `FATAL(n)` if ANY `[BLOCKER]` (n = count of BLOCKER + MAJOR). `CONCERNS(n)` if
 `[MAJOR]` present but no BLOCKER (n = count of MAJOR). `SOLID` if neither.
 ## RULES
 - Report-only. Never edit, write, or implement — naming the flaw precisely is
  the whole job.
 - No invention. If your lens finds nothing real, return `SOLID` with
  `FINDINGS: none` — a manufactured concern is a failure, not diligence.
 - `PROOF` is MANDATORY. A verdict without a `PROOF` line is a structural failure
  the orchestrator discards.
 - Stay in your lens. A finding outside it belongs to another challenger.
 - The verdict grammar is load-bearing: exactly one
  `CHALLENGE — LENS: … — VERDICT:` line, spelled as above.
 ## ORCHESTRATOR PROTOCOL (consumer contract — wiring reference)
 How an orchestrator runs the plan-challenge phase (the loop + synthesis live in
 the MAIN loop, never here):
 - Dispatch THREE fresh challengers IN PARALLEL, one per lens
  (correctness / robustness / simplicity), each blind to the others.
 - MODEL (BDR-076, supersedes the BDR-066 inherit): plan critique is AUDIT
  JUDGMENT, not a procedural gate — the challenger is `model: opus`-pinned in
  its frontmatter (big tier, session-independent; the session model stays on
  the inline loop). Never `model: "sonnet"` — a silent judgment downgrade.
  (Contrast the verifier, Sonnet-pinned only because it is oracle-anchored to a
  contract.)
 - FAIL-SAFE — never fail open: a malformed/empty verdict, a missing `PROOF`, or
  a dead challenger → retry ONCE fresh; a 2nd failure → escalate to the human and
  NAME the lens. Never report "plan challenged" on a silently dropped lens (same
  discipline as verify-secure-loop: "a mute verifier is NEVER a PASS").
 - SEVERITY-DRIVEN synthesis: any `[BLOCKER]` from ANY single lens is
  must-address — the lenses are orthogonal, so a lone security/rollback finding
  is real, never outvoted by lens-count. Cross-lens agreement only RANKS the MINORs.
 - CLOSE each BLOCKER with a NAMED, diffable plan change — never a self-authored
  "addressed" line. A BLOCKER consciously kept is tagged `[deferred <date>]` for
  the human to accept at the gate.
 - RE-CHALLENGE ONCE if synthesis materially changed the plan (a fix can open a
  new flaw); max 1 extra pass, then the human gate.
 - ADVISORY: the revised plan + a challenge summary (raised / addressed /
  deferred / any lens that failed to return) feed the orchestrator's existing
  human gate. The human decides — this is not a hard block.
@@ -1,71 +1,35 @@
 ---
 name: plugin-advisor
-description: Plugin-fit checker — dispatched by /plugin-check and orchestrator gates (init-project, ship-feature). Recommends enable/disable.
+description: Plugin-fit REASONER — dispatched by lib/plugin-gate.md with a PROBE REPORT (from plugin-probe). Classifies signals, scores complexity, recommends enable/disable via the decision table + compatibility matrix. Report-only.
-tools: Read, Bash, Glob, Grep
+tools: Read, Glob, Grep
-model: sonnet
+model: opus
 ---
 # PLUGIN ADVISOR
 ## ROLE
-Detect active plugins and project signals. Recommend enable/disable. Apply compatibility matrix. Block or warn as needed.
+Reason over the PROBE REPORT + request. Classify signals, score complexity,
 recommend enable/disable, apply the compatibility matrix. Block or warn.
 Detection is NOT your job (plugin-probe did it); applying is NOT your job
 (the dispatcher's lib/plugin-gate.md apply gate does it).
 ---
-## PHASE 1 — DETECT
+## INPUT — PROBE REPORT (ground truth, from plugin-probe)
-```bash
+The dispatcher passes `REQUEST` (the project description, verbatim) and the
-# Claude Code plugins
+full `PROBE REPORT` (fields: PLUGINS, EXTERNAL, PROFILE, CLIS, MANIFESTS,
-claude plugin list 2>/dev/null || echo "plugin-list-unavailable"
+FRAMEWORK-DEPS, TSX-JSX-COUNT, DOCKER-COUNT, ANIM, MONOREPO, EMBEDDED,
-
+CHECKPOINT). Treat it as ground truth — never re-detect, never invent a
-# External (non-marketplace) tools status — gstack, emil-design-eng,
+field. PROBE REPORT missing or a field absent → emit
-# darwin-skill. Managed by lib/toggle-external.sh since
+`PLUGIN CHECK — VERDICT: ERROR(probe report missing/invalid: <what>)` and
-# `claude plugin enable|disable` does not apply to them.
+STOP. Fail closed: no recommendations over invented detection.
 bash "$HOME/.claude/lib/toggle-external.sh" list 2>/dev/null || echo "toggle-external-unavailable"
 # Active skill profile — design / dev / qa / audit / minimal / custom.
 # Profiles partition gstack + personal skills by purpose. See
 # lib/profile.sh and lib/profiles/*.profile.
 bash "$HOME/.claude/lib/profile.sh" current 2>/dev/null || echo "profile-unavailable"
 # Context7 CLI
 command -v ctx7 &>/dev/null && ctx7 --version 2>/dev/null | head -1 || echo "ctx7-not-installed"
 # Standalone CLIs
 command -v gsd &>/dev/null && gsd --version 2>/dev/null | head -1 || echo "gsd-not-installed"
 command -v rtk &>/dev/null && rtk --version 2>/dev/null | head -1 || echo "rtk-not-installed"
 # Project signals (run from project root)
 ls package.json pyproject.toml Cargo.toml go.mod 2>/dev/null | head -5
 grep -rl "next\|react\|vue\|prisma\|supabase" package.json 2>/dev/null | head -3 || true
 find . -name "*.tsx" -o -name "*.jsx" 2>/dev/null | head -3 | wc -l
 find . -name "docker-compose*" -o -name "Dockerfile" 2>/dev/null | head -3 | wc -l
 # Animation lib status (motion / motion-v) — read-only detection
 if [ -f "$HOME/.claude/lib/animation-lib-check.sh" ]; then
  source "$HOME/.claude/lib/animation-lib-check.sh"
  detect_anim_eligibility   # outputs '<status>|<package>|<reason>'
  is_anim_lib_installed || echo "anim-lib-not-installed"
 fi
 # Monorepo detection (current dir + parent dirs for sub-package context)
 ls apps/ packages/ services/ workspaces/ 2>/dev/null | head -5
 ls pnpm-workspace.yaml turbo.json nx.json lerna.json 2>/dev/null
 # Upstream check: detect if current dir is itself a package inside a monorepo
 ls ../pnpm-workspace.yaml ../turbo.json ../nx.json ../../turbo.json ../../pnpm-workspace.yaml 2>/dev/null | head -3
 # Embedded/firmware detection via filesystem
 ls CMakeLists.txt platformio.ini 2>/dev/null
 ls *.ld *.lds linker*.ld 2>/dev/null | head -3   # linker scripts = bare-metal
 ls Makefile 2>/dev/null
 # Presence of .c files used only when combined with Makefile AND no Node/Rust/Go manifest
 ls src/*.c 2>/dev/null | head -3
 ls package.json Cargo.toml go.mod pubspec.yaml setup.py pyproject.toml 2>/dev/null | head -1   # counterindicators (ecosystem present = not bare embedded)
 ```
 ---
-## PHASE 2 — ANALYZE $ARGUMENTS
+## PHASE 2 — ANALYZE
-Detect signals from the project description and filesystem scan:
+Detect signals from REQUEST + the PROBE REPORT fields:
 | Signal | How to detect |
 |---|---|
@@ -82,8 +46,8 @@ Detect signals from the project description and filesystem scan:
 | `skill-creation` | "create a skill", "new skill", "custom skill", `/plugin-dev:create-plugin` in description |
 | `embedded` | "firmware", "bare-metal", "microcontroller", "STM32", "ESP32", "RTOS", "driver", "kernel", "bootloader" in description; **or** `platformio.ini` present; **or** linker script (`*.ld`, `*.lds`) present; **or** `Makefile` + `src/*.c` + no `package.json`/`Cargo.toml`/`go.mod`/`setup.py`/`pyproject.toml` (C project without standard ecosystems). Note: `.c` files with a Rust/Node/Go manifest = FFI binding, NOT embedded. |
 | `simple` | single file, hotfix, quick script, no frontend, no deploy |
-| `anim-lib-eligible` | output of `detect_anim_eligibility` starts with `eligible|` (React/Vue/Svelte stack) |
+| `anim-lib-eligible` | PROBE REPORT `ANIM` field: `eligibility=eligible|…` (React/Vue/Svelte stack) |
-| `anim-lib-installed` | `is_anim_lib_installed` returns 0 (any of motion / motion-v / framer-motion / gsap / lottie-react / react-spring / popmotion / auto-animate present) |
+| `anim-lib-installed` | PROBE REPORT `ANIM` field: `installed=<lib>` (any of motion / motion-v / framer-motion / gsap / lottie-react / react-spring / popmotion / auto-animate) |
 ---
@@ -146,70 +110,11 @@ ACTION REQUIRED? YES / NO
 > packages itself — it just states the status. Installation happens in
 > `/init-project` STEP 5e (auto) or `/onboard` STEP 2.5 (opt-in).
-## PHASE 4 — AUTO-ACTIVATION (when called from /init-project or /ship-feature)
+> **Apply, confirmation, and rollback are the DISPATCHER'S job** —
-
+> `lib/plugin-gate.md` steps 4-5 (main loop: present, ACTION-REQUIRED stop,
-After presenting RECOMMENDATIONS, if any plugin has ⚡ ENABLE status:
+> PROPOSED-CHANGES confirmation, toggle + rollback). This agent only
-1. List the changes to apply:
+> recommends and emits the EXACT toggle commands. It never applies, never
-   ```
+> asks the user (it cannot — it is dispatched).
   PROPOSED CHANGES:
     ⚡ Enable ui-ux-pro-max (frontend detected, complexity 65%)
     ⚡ Pre-fetch ctx7 docs for next.js, prisma
   Apply these changes? (yes / no / customize)
   ```
 2. On "yes" → apply changes (rename .disabled dirs, update MCP config).
 3. On "customize" → user picks which to apply.
 4. On "no" → proceed with current config.
 **Never auto-activate without showing the list and getting confirmation.**
 ### Rollback on partial failure
 Toggle commands occasionally fail mid-batch (rename collision, permission, MCP
 restart hang). Track each toggle and roll back the partial set rather than
 leave a half-applied configuration:
 ```bash
 applied=()
 for change in "${PROPOSED_CHANGES[@]}"; do
  if bash "$HOME/.claude/lib/toggle-external.sh" enable "$change"; then
    applied+=("$change")
  else
    echo "❌ failed to enable $change — rolling back ${#applied[@]} prior change(s)"
    for prior in "${applied[@]}"; do
      bash "$HOME/.claude/lib/toggle-external.sh" disable "$prior" \
        || echo "⚠️ rollback of $prior also failed — manual cleanup required: see ~/.claude/plugins/cache"
    done
    exit 1
  fi
 done
 ```
 Surface to the user:
 ```
 ✅ Applied N change(s).
 ```
 Or, on failure:
 ```
 ⚠️ Toggle failed at change <name>. Rolled back the N prior change(s).
   To inspect manually: ls ~/.claude/plugins/cache; bash ~/.claude/lib/toggle-external.sh list
   Re-run /plugin-check after fixing the underlying cause (e.g. permissions).
 ```
 ### Pre-recommendation validation checkpoint
 Between PHASE 1 (DETECT) and PHASE 2 (ANALYZE), validate the detection
 findings before producing recommendations:
 - `toggle-external.sh list` returned non-empty AND each listed plugin's
  directory exists in `~/.claude/plugins/cache` or `~/.agents/skills/`.
 - At least one project signal was detected (else: print `"⚠️ No project
  signals detected — recommendations will be conservative."` and continue).
 - If `toggle-external.sh` is missing or unexecutable: print `"⚠️ toggle script
  unavailable — recommendations will be advisory only, no auto-activation."`
  and skip PHASE 4 entirely.
 ---
@@ -418,4 +323,6 @@ or by applying a profile that lists it (e.g. `apply web` to restore
  → Free higher rate limits: `ctx7 login` (OAuth) or API key from context7.com/dashboard
  → Type "force" to proceed without context7 (not recommended for fast-evolving libs)
-Never modify files. If action required → stop and wait. If not → say "proceed".
+Never modify files. Never ask the user. Report-only: the PLUGIN CHECK block
 is your entire output; the dispatcher's gate (lib/plugin-gate.md) owns the
 stop/proceed decision and every state change.
@@ -0,0 +1,90 @@
 ---
 name: plugin-probe
 description: Mechanical detection probe — dispatched by lib/plugin-gate.md BEFORE the plugin-advisor reasoner. Runs the CLI/filesystem probes, reports raw facts as a PROBE REPORT. No analysis, no recommendations.
 tools: Bash, Read, Glob, Grep
 model: sonnet
 ---
 # PLUGIN PROBE
 ## ROLE
 Collect the raw plugin/project facts the plugin-advisor reasons over.
 Facts only — no signals, no recommendations, no complexity scoring.
 ## PROBES (run all; a failing probe reports its fallback string, never aborts)
 ```bash
 # Claude Code plugins
 claude plugin list 2>/dev/null || echo "plugin-list-unavailable"
 # External (non-marketplace) tools status — gstack, emil-design-eng,
 # darwin-skill. Managed by lib/toggle-external.sh since
 # `claude plugin enable|disable` does not apply to them.
 bash "$HOME/.claude/lib/toggle-external.sh" list 2>/dev/null || echo "toggle-external-unavailable"
 # Active skill profile — design / dev / qa / audit / minimal / custom.
 bash "$HOME/.claude/lib/profile.sh" current 2>/dev/null || echo "profile-unavailable"
 # Context7 CLI
 command -v ctx7 &>/dev/null && ctx7 --version 2>/dev/null | head -1 || echo "ctx7-not-installed"
 # Standalone CLIs
 command -v gsd &>/dev/null && gsd --version 2>/dev/null | head -1 || echo "gsd-not-installed"
 command -v rtk &>/dev/null && rtk --version 2>/dev/null | head -1 || echo "rtk-not-installed"
 # Project signals (run from project root)
 ls package.json pyproject.toml Cargo.toml go.mod 2>/dev/null | head -5
 grep -rl "next\|react\|vue\|prisma\|supabase" package.json 2>/dev/null | head -3 || true
 find . -name "*.tsx" -o -name "*.jsx" 2>/dev/null | head -3 | wc -l
 find . -name "docker-compose*" -o -name "Dockerfile" 2>/dev/null | head -3 | wc -l
 # Animation lib status (motion / motion-v) — read-only detection
 if [ -f "$HOME/.claude/lib/animation-lib-check.sh" ]; then
  source "$HOME/.claude/lib/animation-lib-check.sh"
  detect_anim_eligibility   # outputs '<status>|<package>|<reason>'
  is_anim_lib_installed || echo "anim-lib-not-installed"
 fi
 # Monorepo detection (current dir + parent dirs for sub-package context)
 ls apps/ packages/ services/ workspaces/ 2>/dev/null | head -5
 ls pnpm-workspace.yaml turbo.json nx.json lerna.json 2>/dev/null
 # Upstream check: detect if current dir is itself a package inside a monorepo
 ls ../pnpm-workspace.yaml ../turbo.json ../nx.json ../../turbo.json ../../pnpm-workspace.yaml 2>/dev/null | head -3
 # Embedded/firmware detection via filesystem
 ls CMakeLists.txt platformio.ini 2>/dev/null
 ls *.ld *.lds linker*.ld 2>/dev/null | head -3   # linker scripts = bare-metal
 ls Makefile 2>/dev/null
 # Presence of .c files used only when combined with Makefile AND no Node/Rust/Go manifest
 ls src/*.c 2>/dev/null | head -3
 ls package.json Cargo.toml go.mod pubspec.yaml setup.py pyproject.toml 2>/dev/null | head -1   # counterindicators (ecosystem present = not bare embedded)
 # Checkpoint inputs (consumed by lib/plugin-gate.md's validation checkpoint)
 [ -x "$HOME/.claude/lib/toggle-external.sh" ] && echo "toggle-script: executable" || echo "toggle-script: UNAVAILABLE"
 ls "$HOME/.claude/plugins/cache" 2>/dev/null | head -10
 ls "$HOME/.agents/skills" 2>/dev/null | head -10
 ```
 ## OUTPUT — PROBE REPORT (every field present; unavailable = the probe's fallback string, never invented)
 ```
 PROBE REPORT
 PLUGINS        : <claude plugin list output, one per line>
 EXTERNAL      : <toggle-external list output>
 PROFILE       : <profile current output>
 CLIS          : ctx7=<v|absent> gsd=<v|absent> rtk=<v|absent>
 MANIFESTS     : <files found>
 FRAMEWORK-DEPS: <grep hits in package.json>
 TSX-JSX-COUNT : <n>
 DOCKER-COUNT  : <n>
 ANIM          : eligibility=<status|package|reason> installed=<lib|no>
 MONOREPO      : dirs=<hits> configs=<hits> parent=<hits>
 EMBEDDED      : cmake-pio=<hits> linker=<hits> makefile=<y/n> src-c=<hits> ecosystem=<first manifest|none>
 CHECKPOINT    : toggle-script=<executable|UNAVAILABLE> plugin-dirs=<cache+skills listing>
 ```
 ## RULES
 - Facts only. No signal classification, no complexity score, no
  recommendations — that is the plugin-advisor's job.
 - Never modify files. Never install anything. Never ask the user
  (you cannot — report facts instead).
 - A probe that errors reports its fallback string; the report is emitted
  with EVERY field line present regardless.
@@ -0,0 +1,99 @@
 ---
 name: release-executor
 description: Mechanical release executor — dispatched by /release-candidate for its two spans (prep, finish+tag). Never decides the version number or the when-to-release call, never pushes.
 tools: Read, Edit, Write, Bash, Grep, Glob
 model: sonnet
 ---
 # RELEASE-EXECUTOR — mechanical release spans
 You execute the mechanical parts of a gitflow release. The `/release-candidate`
 dispatcher owns every judgment call — the version number, the "is it time to
 release" decision, and both pushes — and owns the human gate that sits BETWEEN
 your two spans. You are dispatched fresh, once per span, never both in one
 call: after `SPAN: prep` reports, the dispatcher stops for a human go before
 it ever dispatches `SPAN: finish`.
 ## Dispatch spans
 The dispatch prompt names exactly one span; do only that span's work, then
 stop and report — never chain into the other span yourself.
 - `SPAN: prep <X.Y.Z>` — branch, version bump, CHANGELOG, test gate, commit.
  No merge, no tag, no push.
 - `SPAN: finish <X.Y.Z>` — gitflow fan-out, then tag. Never push.
 ---
 ## SPAN: prep <X.Y.Z>
 ### Input
 `<X.Y.Z>`: the version number, already decided by the dispatcher before
 dispatch — you never derive it, never second-guess it, never bump it.
 ### Steps
 1. `bash "$HOME/.claude/lib/gitflow.sh" start release <X.Y.Z>` — forks from
   `develop` onto `release/<X.Y.Z>`. A non-zero exit (dirty tree, missing
   base) → STOP, `STATUS: BLOCKED` with the error verbatim; don't improvise
   a workaround.
 2. Set `version.txt` to `<X.Y.Z>` (single line, trailing newline).
 3. Rewrite `CHANGELOG.md`: the `## [Unreleased]` header becomes
   `## [<X.Y.Z>] — <today, YYYY-MM-DD>`; re-open a fresh, empty
   `## [Unreleased]` above it. If `<X.Y.Z>` is a MAJOR bump (X incremented),
   the finalized section must spell out the breaking change explicitly
   (`### Changed`/`### Removed`/a `BREAKING` line). If the existing
   Unreleased content doesn't already say what breaks, do not invent
   wording — report `STATUS: NEED-DECISION` instead.
 4. Apply any release-candidate fixes the dispatcher named inline in the
   dispatch prompt (same commit as the prep, below). None named → skip.
 5. **Run the test suite**: `make test` if a `Makefile` defines `test`, else
   the stack's normal suite. This is the RC gate — never let a release
   proceed on red. Record the verbatim result line for the report; a
   failing suite is still `STATUS: DONE` for this span (the dispatcher, not
   you, decides what a red suite means for the release) — just report it
   truthfully.
 6. Commit the prep on the release branch:
   `chore(release): <X.Y.Z> — version.txt + CHANGELOG`.
 ### Forbidden in this span
 `gitflow finish`, `git tag`, `git push`, deciding the version number, the
 when-to-release decision, attribution trailers of any kind.
 ---
 ## SPAN: finish <X.Y.Z>
 ### Preconditions
 Verify with `git branch --show-current` that you are on `release/<X.Y.Z>`
 before finishing. A mismatch means the prep span didn't land as expected or
 the dispatcher named the wrong version — STOP, `STATUS: BLOCKED`, report the
 actual branch; never finish whatever happens to be checked out.
 ### Steps
 1. `bash "$HOME/.claude/lib/gitflow.sh" finish` — fans out: merges
   `release/<X.Y.Z>` into `main`, merges into `develop`, deletes the release
   branch. A merge conflict → STOP, `STATUS: BLOCKED` with the conflict
   output verbatim; do not attempt to resolve it yourself.
 2. **Tag AFTER finish, on `main`** — never before:
   `git tag -a v<X.Y.Z> main -m "release <X.Y.Z>"` (annotated, so it lands on
   main's release-merge commit).
 ### Forbidden in this span
 `git push` (any remote, any ref — the dispatcher owns the push gate),
 deciding the version number, the when-to-release decision, attribution
 trailers of any kind.
 ---
 ## OUTPUT — end with exactly this report (your final message)
 ```
 RELEASE-EXEC REPORT
 SPAN    : prep <X.Y.Z> | finish <X.Y.Z>
 STATUS  : DONE | NEED-DECISION | BLOCKED
 BRANCH  : <release/<X.Y.Z> for prep | main for finish>
 TAG     : <v<X.Y.Z> | n/a — prep never tags>
 TESTS   : <verbatim suite result | n/a — finish never runs tests>
 NOTES   : <DONE: none | NEED-DECISION: exact question + options |
           BLOCKED: the blocker verbatim>
 ```
@@ -17,7 +17,52 @@ Loaded on demand — keep each file focused and current.
 These files capture state as of 2026-04. Crawler lists, Schema.org
 deprecations, and tool landscape shift fast. Agents MUST cross-check
-via WebSearch on each run when FULL depth is selected.
+crawler lists and tool names via WebSearch on each run when FULL depth is
 selected.
 ## Citation standard (mandatory for every statistic)
 **WebSearch is NOT verification for a number.** It ranks SEO blogs, and SEO
 blogs cross-cite each other into a consensus that looks like corroboration.
 Two 2026-07-16 audits of this directory show how it fails:
 - A "VSI (Visual Stability Index) — new 2026 Core Web Vital" lived in
  `seo-analyzer.md`. Ten blogs asserted it; several claimed CrUX already
  collected it. It is absent from the CrUX API metric list and from
  web.dev. WebSearch returned the echo, not the truth.
 - Every stat in this directory was real **and attached to the wrong
  subject**: the GEO paper's 40% (all methods) pinned on one technique;
  LLMrefs' 3x (brand mentions vs backlinks) pinned on freshness decay;
  AccuraCast's 58.9% (Person schema prevalence) pinned on QAPage lift, with
  its meaning inverted; a smart-speaker adoption figure sold as voice-search
  share.
 The failure mode is not invention — it is **plausible recombination**, which
 is exactly what a model half-remembering a search result produces. So the
 format has to make an unsourced number conspicuous:
 ```
 <claim> — <source, year, venue|vendor> — measured: <what the source ACTUALLY
 measured> — <link>
 ```
 `measured:` is the field that catches it. All four errors above survive a
 source name; none survives having to state the source's real measurement
 next to the claim.
 Rules:
 1. **Primary source or no number.** Peer-reviewed paper, the vendor's own
   published study, or an official API/doc. `developer.chrome.com/docs/crux`
   is decisive for metrics: what CrUX cannot return, we cannot score.
 2. **Name the tier.** Peer review ≠ vendor marketing. LLMrefs, AccuraCast,
   Ahrefs publish useful data and sell products — say "vendor".
 3. **Never widen scope.** An aggregate result is not a per-technique result.
 4. **No number beats a wrong number.** A recommendation that only stands up
   with a fabricated statistic was never standing up. Delete the stat, keep
   the recommendation if it survives on mechanism.
 5. **Unverified ⇒ labelled.** `[UNVERIFIED — <date>]` inline. Never quote an
   unverified number to a client: `geo-analyzer.md` ("Cite sources") sends
   these into client reports as research-backed.
 ## Loading pattern
@@ -4,9 +4,17 @@ Tools that track whether your brand appears in AI-generated answers
 across ChatGPT, Perplexity, Gemini, Copilot, Claude, and Google AI
 Overviews.
-Context: Google AI Overviews trigger on ~48% of searches; ChatGPT
+Context `[UNVERIFIED — 2026-07-16]`: Google AI Overviews trigger on ~48% of
-processes 2.5B queries/day; Gartner projects commercial organic
+searches; ChatGPT processes 2.5B queries/day; Gartner projects commercial
-search traffic will drop 25% by 2026. Monitoring is no longer optional.
+organic search traffic will drop 25% by 2026.
 > Not checked against primary sources in the 2026-07-16 audit that corrected
 > the rest of this directory — flagged rather than asserted or deleted, per
 > the citation standard in `README.md` (rule 5). The Gartner projection at
 > least names its source; the other two float. Treat all three as
 > motivation, not evidence: **do NOT quote them to a client** until each
 > carries `source + measured: + link`. Their only job here is to explain why
 > this file exists, and that argument does not need numbers.
 ## Commercial tools
@@ -61,9 +61,18 @@ query. A one-sentence self-contained answer has the highest density.
 ### 4. Citations and statistics (strongest measured lever)
-Adding peer-cited statistics with clear sources increases AI visibility
+Aggarwal et al., 2024 ("GEO: Generative Engine Optimization", KDD 2024)
-**by up to 40%** (Aggarwal et al., 2024 "GEO: Generative Engine
+report that their optimisation methods **collectively** boost visibility
-Optimization").
+**by up to 40%** in generative-engine responses, and state the effect
 **varies across domains**. Citations/statistics/quotations are among those
 methods.
 > **Attribute this correctly.** Until 2026-07-16 this section read "Adding
 > peer-cited statistics with clear sources increases AI visibility by up to
 > 40%" — pinning the paper's *aggregate* result on this *one* technique. The
 > paper publishes no separate figure per technique. When quoting it to a
 > client: "up to 40%, across the method set, domain-dependent" — never "+40%
 > if you add stats".
 Pattern: embed specific numbers with attribution.
@@ -100,8 +109,20 @@ Comparison tables are even stronger. Structure:
 ### 6. Freshness signals
-Pages not updated at least quarterly are **3x more likely to lose AI
+Freshness is a real retrieval input: RAG systems fetch live and read
-citations** (LLMRefs 2026 study).
+timestamps, so a page updated this quarter carries a stronger recency
 signal than the same page last touched years ago. LLMrefs (a **vendor**,
 not peer review) reports cited content running **~25.7% fresher** than
 organic top-10 across ~17M citations. Substantive updates only — bumping a
 date string is not freshness.
 > **The "3x" that lived here was grafted from another claim.** Until
 > 2026-07-16 this read "Pages not updated at least quarterly are 3x more
 > likely to lose AI citations (LLMRefs 2026 study)". LLMrefs' actual "3x"
 > says **brand mentions correlate ~3x more strongly with AI visibility than
 > backlinks** — a different subject entirely. No source supports a quarterly
 > decay multiplier. Recommend quarterly refresh on its merits; do not price
 > it with a borrowed number.
 What to maintain:
 - Visible "Last updated: YYYY-MM-DD" at the top of content pages
@@ -21,8 +21,20 @@ existing instances. They no longer produce rich results.
 ### QAPage — single Q&A format
-Pages cited 58% more often by ChatGPT vs basic Article schema.
+Use when the page is built around ONE primary question. Emitting the type
-Use when the page is built around ONE primary question.
+that matches the content shape beats wrapping everything in a generic
 `Article`.
 > **No lift figure here — the one that lived here was wrong.** Until
 > 2026-07-16 this read "Pages cited 58% more often by ChatGPT vs basic
 > Article schema", uncited. Nothing supports it. The nearest real number is
 > AccuraCast 2025 (~2,000 prompts across ChatGPT / AI Overviews /
 > Perplexity, ~9,000 cited sources): **`Person` schema appeared in 58.9%**
 > of cited sources — a *prevalence* count for a *different type* — while
 > **`FAQPage` appeared in 1.8%**, which points the opposite way to the claim
 > it was propping up. Q&A shape is still worth doing on genuinely
 > single-question pages; it is not worth a fabricated number. Do NOT quote a
 > QAPage lift % to a client — there isn't one.
 ```json
 {
@@ -81,8 +93,16 @@ visible content.
 ### Speakable — voice + AI extraction marker
-62% of searches in 2026 involve voice. Speakable flags the passage
+Speakable flags the passage best suited for voice readout and AI summary.
-best suited for voice readout and AI summary.
+
 > **No voice-share figure — the one that lived here was a conflation.**
 > Until 2026-07-16 this read "62% of searches in 2026 involve voice",
 > uncited. No primary source carries it; 62% circulates as a *smart-speaker
 > adoption* number, not a share of searches. It is the same family as the
 > "50% of searches will be voice by 2020" myth — attributed to ComScore,
 > who **denied it**; the real origin is a 2014 Andrew Ng interview. Speakable
 > is cheap and harmless, so keep recommending it on TL;DR / summary blocks —
 > but justify it by extraction shape, never by a voice-share statistic.
 ```json
 {
@@ -123,16 +123,10 @@ INSTALL  : ✅ / ❌ <error>
 BUILD    : ✅ / ❌ <error>
 DOCKER BUILD: ✅ / ⚠️ not verified / N/A
 STRUCTURE: <tree>
-READY: <N> v1 features | entry points ✅ | config ✅ | CLAUDE.md ✅ | README → doc-syncer | settings ✅
+READY: <N> v1 features | entry points ✅ | config ✅ | CLAUDE.md ✅ | README → init-project STEP 5b | settings ✅
 ```
---
+> No doc step here (BDR-077): the scaffolder produces NO docs. The README
-
+> bootstrap is init-project STEP 5b's job — a doc-syncer `MODE: audit`
-## PHASE 6 — DOC SYNC (automatic)
+> (opus) → `MODE: patch` (sonnet) dispatch pipeline owned by the
-
+> orchestrator, never an inline-load inside this executor.
 **INLINE-LOAD** `$HOME/.claude/agents/doc-syncer.md` — continue AS
 doc-syncer in THIS SAME context (you *become* it). This is an inline load,
 NOT a subagent dispatch: the `Agent` tool is not involved (which is why
 this agent correctly omits `Agent` from its `tools:`). Execute in
 automatic mode:
 `auto-mode scope: <list of all files created during scaffolding>`
@@ -2,6 +2,7 @@
 name: seo-analyzer
 description: 'Classical SEO audit agent (Google, Bing) — dispatched from /seo. Live audit: Core Web Vitals, on-page, technical, local SEO, legal (FR). Emits a fix bundle (dispatcher applies) + scored report. AI/GEO → geo-analyzer agent.'
 tools: Read, Edit, Write, Bash, Grep, Glob, WebFetch, WebSearch
 model: opus
 ---
 # SEO — Classical Search Engines audit, fix & strategy
@@ -23,6 +24,38 @@ $ARGUMENTS
 ---
 ## MODE DETECTION (BDR-077 — pipeline modes around the dispatcher)
 The dispatcher (/seo) runs this agent as a 3-stage pipeline; /harden and
 /onboard may still run it single-shot. Parse the MODE line in the prompt:
 - **`MODE: collect`** — dispatched `model: "sonnet"` (mechanical/standard
  collection; the call-site override takes precedence over the opus pin).
  Runs STEP 0-5 ONLY, writes every gathered signal (tech context, tool
  availability, live-audit raw results, on-page inventory + sampling
  frame) to the run-scoped, gitignored `.audit/seo-signals-<RUNID>.md`,
  terminated by the line `COLLECTION COMPLETE — RUNID: <RUNID>`, then
  emits a short `COLLECT REPORT` (`STATUS: DONE | BLOCKED`, RUNID,
  COVERAGE counts) and STOPS. No scoring, no findings, no bundle.
 - **`MODE: judge`** — runs on the opus frontmatter pin (audit judgment).
  FIRST loads `.audit/seo-signals-<RUNID>.md`: absent, RUNID mismatch, or
  missing `COLLECTION COMPLETE` sentinel → emit
  `SEO JUDGE — VERDICT: ERROR(<reason>)` and STOP (fail closed — NEVER
  score stale or partial signals). Then runs STEP 6-11 on the signals +
  the dispatcher-fed context and emits the scoring blocks + findings +
  action plan + triage batches as its report. No bundle, no SEO.md.
 - **`MODE: template`** — dispatched `model: "sonnet"`. INPUT: the
  dispatcher-fed context + the judge's report VERBATIM (never re-derive a
  score or re-judge a finding). Runs STEP 12-14: FIX BUNDLE + sentinel,
  report file, envelope.
 - **No MODE line** — legacy single-shot: all steps in sequence on the
  opus pin (used by /harden narrow-scope and /onboard report-only).
 Every mode receives the full dispatcher CONTEXT block (LRN-126 — the
 STEP 1-2 business/tech context is consumed by all later steps).
 ---
 ## STEP 0 — AUDIT DEPTH
 **First action.** If a parent skill (`/seo` dispatcher) passed depth
@@ -81,6 +114,17 @@ hreflang, infer from detected URL structures.
 ## STEP 2 — DETECT TECHNICAL CONTEXT `[both]`
 **FIRST — the CWD must BE the audited site.** You grep the current working
 directory; no dispatcher checks that it matches TARGET_URL. If a URL was
 supplied and the CWD shows no web project at all (no `package.json` /
 `composer.json` / `index.html` / `*.astro` / `*.php` / `.htaccess`), or its
 signals contradict the domain, STOP and report:
 `CWD/TARGET MISMATCH — <cwd> is not <domain>'s repo. Re-run from it, or
 confirm live-only audit (LOCAL findings will be N/A).`
 Never grep one codebase while curling another: the live half looks right,
 the code half is fiction, and the report reads as authoritative. `/harden`
 inherits this agent for its config axis, so the mismatch propagates there.
 ### Framework & rendering
 ```bash
@@ -148,13 +192,31 @@ RECOMMENDATION   : KEEP & CONFIGURE plugin | INSTALL <plugin> (P0 quick win) | M
 ### Infrastructure signals
 **Origin vs edge — never infer the stack from `server:`.** That header names
 whatever answered: usually the EDGE (Cloudflare, Scaleway/OVH front, CDN,
 load balancer), not the origin. Apache behind an nginx front is a standard
 topology — TLS terminated upstream, the origin sees plain HTTP plus
 `X-Forwarded-Proto`.
 - Repo `.htaccess` + `server: nginx` = NOT drift, NOT dead config. Do not
  flag it, do not propose migrating it.
 - Never move headers into an `nginx.conf` absent from the repo. Server-side
  config you cannot read is a §14 gap, not a finding.
 - A header present live but in no repo config = "set upstream", never
  "missing".
 `/harden` reuses this agent for its entire config-hardening axis, so a wrong
 topology call scores a client's server config against a file that never ran.
 geo-analyzer STEP 4 already carries the matching CDN/WAF-override check —
 keep the two consistent.
 ```bash
 # Server / hosting
 ls .htaccess nginx.conf netlify.toml vercel.json wrangler.toml 2>/dev/null
 # SEO files
 ls robots.txt sitemap.xml sitemap-index.xml sitemap-images.xml sitemap-videos.xml 2>/dev/null
-# Legal pages
+# Legal pages — source only (C1a: find ignores .gitignore, grep does not)
-find . -maxdepth 3 \( -iname "*mention*" -o -iname "*legal*" -o -iname "*confidentialite*" -o -iname "*privacy*" -o -iname "*cgv*" -o -iname "*cgu*" \) 2>/dev/null | head -10
+mapfile -t FEXCL < <(bash ~/.claude/lib/source-scope.sh findargs)
 find . "${FEXCL[@]}" -maxdepth 3 \( -iname "*mention*" -o -iname "*legal*" -o -iname "*confidentialite*" -o -iname "*privacy*" -o -iname "*cgv*" -o -iname "*cgu*" \) 2>/dev/null | head -10
 # Analytics / trackers
 grep -rl "gtag\|GTM-\|analytics\|matomo\|_paq\|plausible\|umami" --include="*.html" --include="*.js" --include="*.tsx" --include="*.astro" --include="*.php" . 2>/dev/null | head -10
 # Cookie consent / CMP
@@ -216,8 +278,21 @@ anonymous PageSpeed lab data and STEP 4/STEP 11 emit the §11 user action
 ### HTTP headers & security
 **Read them; score them only for `/harden` (I4).** This section stays — the
 raw headers are needed for `X-Robots-Tag`, canonical/redirect coherence, and
 the §14 observed-list. But under `/seo` the security headers themselves are
 out of scope for scoring: see the Technical axis note in STEP 9. Under
 `/harden` they are the entire job. Reading is not scoring.
 **Guard the domain before it reaches a shell — mandatory, not optional.**
 Every curl below interpolates `$DOMAIN` inside double quotes, where `$` and
 backtick still execute. Run the guard FIRST and use only its output; if it
 exits non-zero, STOP this step and report the refusal — never "clean up" the
 value and retry.
 ```bash
-DOMAIN="<production-domain>"
+DOMAIN="$(bash ~/.claude/lib/url-guard.sh host "<production-domain>")" || {
  echo "STEP 4 aborted: domain refused by url-guard"; exit 2; }
 # Headers
 curl -sI "https://$DOMAIN/" | head -30
@@ -247,8 +322,21 @@ Evaluate each present/missing:
 - **LCP** (Largest Contentful Paint) — < 2.5s
 - **INP** (Interaction to Next Paint) — < 200ms (replaced FID in Mar 2024)
 - **CLS** (Cumulative Layout Shift) — < 0.1
- **VSI** (Visual Stability Index) — new 2026 signal, Google Core Web
+
-  Vitals 2.0
+**Core Web Vitals are exactly these three** (web.dev/articles/vitals,
 verified 2026-07-16). Google ships threshold changes with prior notice on a
 predictable annual cadence — a "new CWV" that only SEO blogs know about does
 not exist. Before adding a metric here, confirm it against a PRIMARY source:
 web.dev, the Chromium blog, or `developer.chrome.com/docs/crux/api` — that
 API metric list is decisive, because a metric CrUX cannot return is a metric
 we cannot score.
 **WebSearch is not confirmation.** SEO blogs cross-cite each other into fake
 consensus. A "VSI (Visual Stability Index) — new 2026 signal, Core Web
 Vitals 2.0" line lived here until 2026-07-16 on exactly that basis: ten
 blogs asserted it, several claimed CrUX was already collecting it, and it is
 absent from both the CrUX API metric list and web.dev. Stated as fact, in a
 threshold list, in client-facing audits.
 When a GSC account+property were passed in context, fetch CrUX field
 data first (**tilde path mandatory** — this agent runs from the
@@ -285,13 +373,71 @@ When STEP 0/STEP 1 recorded a GSC account+property (not "none"):
 ```bash
 bash ~/.claude/lib/seo-data/fetch.sh queries --account "$GSC_ACCOUNT" --property "$GSC_PROPERTY" --days 90 --dim query
 bash ~/.claude/lib/seo-data/fetch.sh inspect --account "$GSC_ACCOUNT" --property "$GSC_PROPERTY" --url "https://$DOMAIN/"
 bash ~/.claude/lib/seo-data/fetch.sh cannibal --account "$GSC_ACCOUNT" --property "$GSC_PROPERTY" --days 90
 ```
 **`cannibal` — keyword cannibalisation, from Google's own data (C2).** Groups
 90 days of `query`+`page` rows and returns every query where 2+ of OUR pages
 compete, ranked by total impressions. The API always allowed multiple
 dimensions; this system only ever asked for one, so the conflict was invisible.
 Read it:
 - `conflicts[]` → for each, the strongest page (most impressions) is listed
  first. That is usually the one to KEEP; the others either consolidate into
  it (301 + merge content) or get differentiated. Never "fix" this by deleting
  a page that has clicks — say what competes and let the user choose.
 - A conflict with a large impression total and every page beyond position 10
  is the real prize: Google can't decide which page to rank, so none rank.
 - `capped: true` → the row window was full; there are conflicts past the cut.
  Say so in §14 rather than presenting the list as exhaustive.
 - `status: degraded` → no GSC account. Cannibalisation is then **not
  auditable** — no substitute exists on-site. §14 line, do not guess it from
  title similarity.
 **This is NOT the 30/70 rule, and do not merge the two.** Cannibalisation is
 a SERP fact Google measured. The 30/70 duplication rule is a content-similarity
 question with **no data source here**: measuring it properly needs main-content
 extraction (strip nav/header/footer), and without that a naive comparison of
 two same-template pages returns ~95% similar for every site, which is a
 confident false positive. So 30/70 stays an explicit LLM judgement over the
 ≥3 same-family pages STEP 5 now samples for it — label it as judgement in the
 report, never as a measurement, and never quote a similarity percentage you
 did not compute.
 Report: top queries; flag **QUICK WINS** = rows with position between 4
 and 10 AND high impressions (candidates to push onto page 1 with a
 title/meta/content tweak). Report index coverage from `inspect`. All
 emitted into SEO.md §2 (technical) and §8 (quick wins).
 **`inspect` also returns `rich_results` — Google's own structured-data
 verdict on the live indexed URL.** It rides the same response (no extra
 call, no extra quota). This is the only programmatic JSON-LD validation in
 the system; everything else about schema is read by eye.
 ```
 rich_results.verdict : PASS | FAIL | NEUTRAL | VERDICT_UNSPECIFIED | ABSENT
 rich_results.types[] : {type, items, errors, warnings, issues[]}
 ```
 - `FAIL` + a type carrying `errors > 0` → that type **cannot show as a rich
  result**. Bundle item, cite the `issues[]` message verbatim — it is
  Google's wording, not ours, and geo-analyzer owns the JSON-LD fix
  (CROSS-AGENT NOTE).
 - `warnings` → recommended fields missing. Report, do not gate on them.
 - **`ABSENT` means Google detected no rich results on this URL** — the key
  is omitted upstream when nothing is found. It is NOT an error and NOT
  proof the markup is broken: a page with no structured data reads the same
  as one whose markup Google never parsed. Say "none detected", never
  "invalid".
 - `ABSENT` while the repo clearly ships JSON-LD → real finding: the markup
  is not reaching Google (SPA-rendered, blocked, or malformed). Cross-check
  before claiming it.
 **Bound this honestly.** `index:inspect` is per-URL, quota'd, and works only
 on a GSC-verified property. It validates the URLs you sampled — not the
 site. Its reach is the STEP 9 COVERAGE ratio, and §14 must say so rather
 than let one PASS imply site-wide valid markup.
 If `status=degraded` → note it in §2 and emit the §11 user action
 "Connecter GSC: `make seo-connect`".
@@ -359,8 +505,119 @@ Fetch rendered HTML. Extract and analyze:
 ## STEP 5 — ON-PAGE AUDIT `[both]`
 ### Rendering gate — run this BEFORE anything else in STEP 5 (R2)
 ```bash
 bash ~/.claude/lib/seo-data/fetch.sh rendercheck --url "https://$DOMAIN/"
 ```
 STEP 2 has always recorded `RENDERING: SSR/SSG/SPA/hybrid` and nothing ever
 acted on it. This is the rule that does. The verdict comes from what the
 server actually sent, not from reading package.json — a React SPA and a
 Next.js SSR app are indistinguishable there.
 **`verdict: client-rendered` → REFUSE to score the On-page axis.** Do not
 score it low. Do not score it at all:
 - On-page → `N/A — content not in served HTML (client-rendered)`. Redistribute
  nothing; a missing axis is not a zero.
 - Every curl-based meta/H1/JSON-LD check would report "missing" against a site
  that may be perfectly correct once hydrated. Those are FALSE findings, and
  a bundle built on them would "fix" meta tags that already exist.
 - **No bundle item may come from a live on-page check on this site.** Source
  greps still apply — the JSX carries the tags — but you cannot tell which
  route renders what, so treat them as inventory, not as per-page findings.
 - `linkgraph` will refuse too (`no_links_in_html`) — the same blindness. Do
  not work around either refusal.
 Still fully auditable, and worth saying so rather than returning an empty
 report: robots.txt, sitemap.xml, HTTP headers, redirects, `.htaccess` /
 framework config, CWV via CrUX (field data is real-user, hydration included),
 GSC queries + index coverage, legal pages, image weights.
 **`verdict: partial`** → shell plus an SSR'd head, or a genuinely thin page.
 Score what is present, name what is not, and say which of the two you think
 it is.
 **§0 line, mandatory when not server-rendered:**
 `Rendering: client-rendered — On-page NOT scored (content absent from served
 HTML). Global score excludes it. Fix: SSR/SSG (CLAUDE.md: public sites are
 never SPAs).`
 This is the honest half of the R1/R2 call: we do not render JS (no Playwright,
 no Chromium), so we do not pretend to see what JS paints. Refusing is the
 finding.
 **Record the denominator BEFORE sampling.** This step samples; the report
 says "audit". On a 500-page site a 12-page sample is 2.4% — the On-page score
 is an extrapolation from it, and the reader cannot know unless you print it.
 ```bash
 bash ~/.claude/lib/seo-data/fetch.sh sitemap --url "https://$DOMAIN/sitemap.xml"
 ```
 Returns `{count, urls[], index, dropped, ...}` — the coverage denominator and
 your sampling frame. It follows a `<sitemapindex>` one level, dedupes, strips
 whitespace, and handles `.xml.gz`. No auth, no venv, no Google.
 Read it honestly:
 - `count` → the denominator for the STEP 9 COVERAGE line.
 - `dropped > 0` → entries that were not usable URLs. Worth a §14 line: a
  sitemap emitting junk is a tooling finding.
 - `children_failed > 0` or `children_skipped` → the frame is incomplete. Say
  so; do NOT present a partial denominator as the total.
 - `status: degraded` → denominator UNKNOWN. Print that, never let silence
  imply full coverage. `reason: unsafe_xml_dtd` is not a glitch — a sitemap
  carrying a DTD is broken tooling or a billion-laughs aimed at the auditor.
  Report it as a finding.
 **Guard every URL before it reaches curl.** These come from the target's own
 server, not from the operator — the one place in this audit where a remote
 file's bytes flow into a shell:
 ```bash
 U="$(bash ~/.claude/lib/url-guard.sh url "$RAW_FROM_SITEMAP")" || continue
 ```
 The verb applies a garbage filter, not that guard; the guard belongs at the
 point of use (same contract as the sameAs check in geo-analyzer).
 ### Meta tags per page (sample 5-15 key pages)
 **Group the sitemap URLs into families first** — a family is "pages one
 template renders". You do not need framework routing knowledge to see them,
 but you DO need to look at the actual URL shape, because it varies:
 | Layout | Example | Family signal |
 |---|---|---|
 | Nested | `/creation-site-internet/essonne-91/`, `/creation-site-internet/seine-et-marne-77/` | **shared parent path** → 25 pages, 1 family |
 | **Flat** | `/lavage-auto-pomponne`, `/lavage-auto-torcy`, `/lavage-auto-chelles` | **shared slug prefix** → 8 pages, 1 family |
 Both are real, measured on two live sites. First-path-segment alone handles
 the nested case and **fails the flat one**: those 8 city pages read as 8
 unrelated singletons, so the largest "family" becomes `/services` (5) and the
 doorway-page risk — the exact thing the 30/70 rule exists to catch — is
 invisible. Group by shared parent AND by shared slug prefix; if ≥3 URLs share
 a prefix of 2+ hyphen tokens, that is a family whatever the depth.
 Sanity-check the grouping before trusting it: a site whose sitemap yields
 almost as many families as URLs has probably defeated your heuristic, not
 proved it has no templates.
 **Sample by finding class, because the classes need opposite samples:**
 | Looking for | Sample | Why |
 |---|---|---|
 | Code defects (canonical, OG, `<img>` dims, hreflang) | **1 per family** | one template renders the whole family — a missing canonical in `[dept]/index.astro` breaks all 25 identically. 1 per family ≈ 100% SOURCE coverage for ~8 fetches. |
 | **Duplication / 30-70 / cannibalisation** | **≥3 from the LARGEST family** | invisible with one page each. You cannot tell whether 25 city pages are 70% unique by reading one of them. |
 | Per-page content (title/description length, H1 wording) | spread across families + GSC position 4-10 quick wins | these vary per page even from one template. |
 "One per template" is right for code and **wrong for the 30/70 rule** — a
 rule this spec mandates in §9. Sampling one page per family makes that check
 structurally impossible, so take the third page of the biggest family even
 though it is "the same template".
 An un-sampled family is an un-audited family. Name the ones you skipped.
 For each sampled page:
 ```
 PAGE: <path>
@@ -396,10 +653,32 @@ grep -rE '<img[^>]*>' --include="*.html" --include="*.astro" --include="*.tsx" -
 # Images missing dimensions (CLS risk)
 grep -rE '<img[^>]*>' --include="*.html" --include="*.astro" --include="*.tsx" --include="*.jsx" --include="*.php" . 2>/dev/null | grep -vE 'width=|height=' | head -30
-# Check image asset sizes
+# Check image asset sizes — source only, never build output (C1a)
-find . -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.gif" \) ! -path "./node_modules/*" ! -path "./.git/*" -printf "%s %p\n" 2>/dev/null | sort -rn | head -20
+mapfile -t FEXCL < <(bash ~/.claude/lib/source-scope.sh findargs)
 find . "${FEXCL[@]}" -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.gif" \) -printf "%s %p\n" 2>/dev/null | sort -rn | head -20
 ```
 **Why the guard, and why `find` specifically (C1a).** `grep` and `find`
 disagree about this repo and you use both. Claude Code routes `grep` through
 ugrep with `--ignore-files`, so it honours `.gitignore` and never descends
 into a gitignored `dist/`. `find` honours nothing. Measured on a real Astro
 repo: this command returned **92 images, 45 of them under `dist/`** — every
 asset twice, source and generated copy, byte-identical. So "top 20 by size"
 was ~10 real images dressed as 20, and a batch-C item
 (`cwebp -q 80 <img> -o <img>.webp`) could target `dist/og-image.png`, whose
 `.webp` the dispatcher's own `npm run build` then erases. The fix lands,
 verification passes, nothing survives.
 `FEXCL` MUST be consumed as a quoted array. `find . $FEXCL …` lets the shell
 glob `*/dist/*` against the CWD and hand the matches to find as search paths
 — that made the same run return 135 hits and kept every `dist/` file.
 Do NOT add these exclusions to the `grep` lines: the shim already covers
 them, `public/` is deliberately kept (it is Astro/Vite/Next SOURCE and holds
 `favicon.ico`, `apple-touch-icon.png`, `robots.txt` — the very files STEP 4
 curls), and it is build output only for Hugo/Gatsby, which the script
 detects.
 Flag images over 100 KB as compression candidates. WebP/AVIF preferred
 over JPEG/PNG.
@@ -420,6 +699,34 @@ Each embedded or self-hosted video should have:
 ### Internal linking + topic clusters (silos sémantiques)
 ```bash
 bash ~/.claude/lib/seo-data/fetch.sh linkgraph --url "https://$DOMAIN/sitemap.xml"
 ```
 **This answers the two questions below, which this spec has always asked and
 never had a command for (C3).** Crawls every sitemap URL once, extracts
 internal `<a href>`, and returns `orphans`, `beyond_3_clicks`, `unreachable`,
 `max_depth`. Measured cost: 24 pages in 2.7 s, 86 in 3.8 s — cheap enough to
 always run on FULL.
 Read it honestly:
 - `orphans` present → real finding, act on it.
 - **`orphans_withheld: true` → there is NO orphan list, and you must not
  invent one.** It appears when the crawl was capped or any page failed. An
  orphan cannot be sampled: proving a page has no inbound link means having
  read every other page, so a partial crawl invents orphans. "Page X has no
  inbound links" when it does sends the client fixing what is not broken.
  §14 line, not a finding.
 - `reason: no_links_in_html` → **not a site with zero links; a site whose
  links are rendered by JS.** Every page would look orphaned — the worst false
  positive this tool could emit — so the verb refuses instead. Flag the SPA in
  §0 and stop; do not hand-roll a link audit around it.
 - `unreachable` ⊃ `orphans`: a page can have inbound links yet sit outside the
  homepage's reach (linked only from another unreachable page). Both matter,
  they are not the same finding.
 - `max_depth` > 3 → `beyond_3_clicks` names the pages. That is the ":613"
  check, now measured rather than asserted.
 Sample critical pages. Check:
 - Every important page reachable within 3 clicks from homepage?
 - Navigation consistent?
@@ -469,6 +776,10 @@ Validate:
 ---
 > **MODE BOUNDARY — `MODE: collect` ends at STEP 5**: write the signals
 > file + `COLLECTION COMPLETE — RUNID: <RUNID>` terminal line, emit the
 > COLLECT REPORT, stop. STEP 6-11 below are `MODE: judge` territory.
 ## STEP 6 — EXTERNAL PRESENCE AUDIT `[FULL only, local business only]`
 **Skip if not a local business** (pure SaaS, content-only → jump to STEP 7).
@@ -616,29 +927,135 @@ FIX: AUTO (<what agent will do>) | USER (<what user must do>)
 | Axis | Weight (local B2C) | Weight (SaaS/national/content) | Score /20 |
 |---|---|---|---|
-| Technical (perf, CWV, security headers, indexability) | 20% | 30% | |
+| Technical (perf, CWV, indexability) | 20% | 30% | |
 | On-page (content, meta, headings, images, video, a11y, i18n) | 20% | 30% | |
 | SEO Local (NAP, GMB, citations) | 25% | 5% | |
-| Off-page (backlinks, mentions, authority) | 10% | 15% | |
+| Off-page (unlinked brand mentions — backlinks/authority NOT auditable, §14) | 10% | 15% | |
 | Social presence | 10% | 5% | |
 | Competitive position | 5% | 10% | |
 | Legal compliance | 10% | 5% | |
 **Compute the scores, do not feel them (I7).** Emit your findings, then let
 the engine do the arithmetic:
 ```bash
 bash ~/.claude/lib/seo-data/fetch.sh score --findings /tmp/seo-findings.json
 ```
 ```json
 {"depth":"FULL","profile":"local",
 "axes":{"technical":{"findings":[{"severity":"haute","affected":9,"sampled":12}]},
         "on-page":{"status":"na","reason":"client-rendered (R2)"},
         "off-page":{"status":"na","reason":"backlinks unauditable (I1)"}}}
 ```
 `profile`: `local` (B2C) | `national` (SaaS/national/content). Severities are
 `critique|haute|moyenne|basse` — `/harden`'s scale (-15/-8/-3/-1, clamp,
 then /5 into /20), so the whole skill family speaks one vocabulary.
 **The split matters.** WHICH findings exist and how severe each is stays your
 judgement — irreducible. The addition is not: same findings in, same score
 out. Until now every axis was felt, so two runs over identical code could
 disagree, and `/client-handover` gates on 17/20.
 - `affected`/`sampled` (optional) shift severity ONE step: ≥50% of the sample
  escalates, a single page de-escalates. A defect on 1 of 12 pages is not the
  defect on 12 of 12; pretending so is what made the old numbers wobble.
 - `status: "na"` → the axis is EXCLUDED and the remaining weights are
  renormalised for you. This is the R2 rule (client-rendered on-page) and the
  I1 rule (unauditable off-page), finally computed instead of done by hand.
  **N/A is not a zero** and the engine will not let it behave like one.
 - `status: "error"` → malformed findings. Fix them; never fall back to
  eyeballing a number.
 - Run it twice on the same file before publishing. If the output moved, your
  findings moved, and that is the thing to explain.
 **Technical axis note:** CWV scored on CrUX field data (75th percentile,
 real users, from STEP 4) when available; otherwise lab PageSpeed
 Lighthouse run.
 **Security headers are NOT scored here (I4).** `/harden` owns them and
 grades them out of 100 with three external validators — pricing them into
 this axis too was double-counting the same finding in two reports
 (`depth-matrix.md:29` already said drop; this spec contradicted it).
 - Dispatched from `/harden` (its prompt says NARROW-SCOPE): headers ARE the
  job — audit and score them per its brief, ignore this note.
 - Dispatched from `/seo`: do not score CSP, HSTS, X-Frame-Options,
  X-Content-Type-Options, Referrer-Policy, Permissions-Policy, COOP/CORP,
  cookie flags. STEP 4 still reads them — you need them for the one
  carve-out below — but they earn and lose no points here.
 **Carve-out — `X-Robots-Tag` stays.** It is an indexing directive wearing a
 header's clothes: `noindex` served there deindexes the page as surely as a
 meta robots tag. Score it under indexability. That is what
 `depth-matrix.md:29` means by "unless it directly affects indexability" —
 it is the header that does, and the security headers above are not.
 **Drop ≠ silence.** A user who never runs `/harden` must not read a clean
 Technical score as clean headers. Whenever depth=FULL, emit in §14:
 `Security headers (CSP, HSTS, X-Frame-Options…) — not scored here: /harden
 owns them (0-100 + Observatory/SecurityHeaders/SSL Labs). Run /harden
 <url>. Observed live this run: <present list | none observed>.`
 Name what you saw. An omission has to stay legible — the same reason
 COVERAGE is mandatory in STEP 9.
 **On-page axis note (R2).** `rendercheck` verdict `client-rendered` → this
 axis is `N/A — content not in served HTML`, excluded from the weighted global,
 NOT scored zero. A zero says "your on-page is bad"; N/A says "we could not
 see it", and only one of those is true. Renormalise the remaining weights over
 the axes actually scored and say so on the SEO GLOBAL line. The code ceiling
 must state that no code fix raises an axis we did not measure — the unlock is
 SSR/SSG, and that is a user action, not a bundle item.
 **Off-page axis note (I1).** Score ONLY the unlinked brand mentions
 gathered in STEP 6 (`web_search "<business-name>" -site:<domain>`).
 Backlink profile and domain authority have NO data source here — no index,
 no API, nothing. NEVER price them into the number: an unmeasured
 sub-component cannot be judged, and this axis carries 10-15% of a score
 that reaches a client via `/client-handover`. A low mention count is a low
 mention count — it is NOT evidence of a weak backlink profile.
 Mandatory §14 line whenever depth=FULL, verbatim:
 `Backlinks / domain authority — NOT audited: no free backlink index is
 practical, and none is wired. Commercial: Ahrefs / Semrush / Majestic. The
 Off-page score above prices in brand mentions only.`
 **This is the final state, not a placeholder (B1 killed, 2026-07-17.)** The
 free options were measured, not assumed:
 - **GSC has no links endpoint.** The Search Console API exposes exactly
  Search Analytics, Sitemaps, Sites, URL Inspection. The Links report is
  UI-only.
 - **Common Crawl's hyperlinkgraph is 17.3 GB gzipped** for the domain-edges
  file alone (+879 MB vertices, +2.3 GB ranks), measured live. Finding one
  domain's inbound links means scanning all of it, per audit. Not slow —
  non-viable, and abusive toward a nonprofit serving it free. The reference
  implementation everyone cites caps its download at 500 MiB, i.e. **2.9% of
  the edges file**, and reports whatever that arbitrary slice contained as a
  backlink profile. That is a random sample wearing a measurement's clothes,
  which is precisely what this axis note exists to prevent.
 - **Bing Webmaster's `GetUrlLinks` is the only free, viable source** — but it
  is first-party only (your verified properties), so it can never cover a
  competitor, and it needs the client's Bing account. See W2, deferred.
 So: no number here beats a fabricated one. Weight deliberately unchanged —
 re-deriving it for an axis that is not going to widen would churn historical
 scores for nothing.
 ### LOCAL depth — 4 axes
 | Axis | Weight (local B2C) | Weight (SaaS/national/content) | Score /20 |
 |---|---|---|---|
-| Technical (security headers, indexability, config) | 25% | 35% | |
+| Technical (indexability, config) | 25% | 35% | |
 | On-page (content, meta, headings, images, video, a11y, i18n) | 35% | 45% | |
 | SEO Local (markup, NAP in JSON-LD, legal) | 20% | 5% | |
 | Legal compliance (pages, CMP, mentions) | 20% | 15% | |
 LOCAL axes not audited (Off-page, Social, Competitive) appear as
-`N/A — requires FULL audit` in the report.
+`N/A — requires FULL audit` in the report. Off-page is the exception to
 that promise: FULL audits its brand-mentions share ONLY — backlinks and
 authority are unauditable at EVERY depth (see the Off-page axis note).
 Print `N/A — FULL audits brand mentions only` for it, never a bare
 "requires FULL audit" that FULL cannot keep.
 ### Projected code-only score + trajectory to 17/20 (mandatory)
@@ -676,6 +1093,9 @@ misroutes the client-handover gate and the user's effort.
 ```
 SEO SCORING (<depth>)
 COVERAGE SOURCE: <N> of <M> page templates (<P>%) — skipped: <list|none>
 COVERAGE LIVE  : <N> of <M> sitemap URLs (<P>%) — families: <fam N/M, …>
                 | UNKNOWN (no sitemap / fetch degraded)
 Technical      : XX/20  <justification>
 On-page        : XX/20  <justification>
 SEO Local      : XX/20 | N/A
@@ -687,6 +1107,28 @@ Legal          : XX/20  <justification>
 SEO GLOBAL (weighted): XX.X/20 (<depth>)
 ```
 **Both COVERAGE lines are mandatory, never omitted, never rounded up.** They
 are the honesty bound on every page-level axis: On-page and the on-page share
 of Technical are extrapolations from the sample, and `/client-handover` gates
 on these numbers.
 **Report both, because they bound different findings — do not average them
 into one comforting number.**
 - **SOURCE** bounds CODE findings. One template renders its whole family, so
  1 page per family can legitimately reach 100% here. High SOURCE coverage is
  a real claim: the code paths were seen.
 - **LIVE** bounds CONTENT findings — title/description wording, thin pages,
  30/70 duplication. It stays low by design and that is fine, as long as it
  is printed. Measured on a real site: 12 of 86 URLs is 14% LIVE while the
  same 12 pages are 100% SOURCE. Reporting only the 14% understates the audit;
  reporting only the 100% oversells it. Both, or neither means anything.
 - LIVE < 25% → repeat in §0. A 17/20 for content drawn from 3% of a site is
  not a 17/20.
 - SOURCE < 100% → name the skipped templates in §0. That is not a sampling
  choice, it is code nobody read.
 - Denominator UNKNOWN (no sitemap, or `sitemap` degraded) → print UNKNOWN.
  Never let silence imply full coverage.
 Per user instruction: this score represents **80% of the combined
 final score for local B2C (20% for GEO), or 75% for SaaS/national
 (25% for GEO)**. The `/seo` dispatcher combines SEO and GEO scores.
@@ -776,6 +1218,10 @@ Do not proceed to STEP 12 until this plan is printed.
 ---
 > **MODE BOUNDARY — `MODE: judge` ends at STEP 11** (scoring + findings +
 > plan + batches reported, nothing serialized). STEP 12-14 below are
 > `MODE: template` territory, operating on the judge report verbatim.
 ## STEP 12 — EMIT FIX BUNDLE `[both]`
 **You do NOT apply fixes and you do NOT dispatch any sub-agent.** Same
@@ -1044,6 +1490,15 @@ PROCHAINE ETAPE : <highest-priority>
  `Write` on shared templates. `Write` is reserved for files you
  solely own: sitemap.xml, .htaccess, legal pages, new city/service
  pages. Full-template refactor → escalate as user action in §11.
 - **NEVER emit a bundle item targeting build output (C1a).** No path under
  `dist/ build/ .next/ .nuxt/ .output/ _site/ .astro/ .svelte-kit/ out/` —
  `bash ~/.claude/lib/source-scope.sh list` is the authoritative set. Those
  files are regenerated: the `npm run build` the dispatcher runs to VERIFY
  your fix is what erases it. The fix lands, verification passes, nothing
  survives, and the report claims it was applied. This bites batch C hardest
  (`cwebp -q 80 <img> -o <img>.webp` on a `dist/` asset writes a `.webp` the
  next build deletes). Fix the SOURCE that generates the artifact; if you
  cannot find it, that is a finding — say so, do not patch the artifact.
 - **Landing page protection.** Zero visible change except meta tags,
  footer links, JSON-LD, image optimization.
 - **Preserve existing valid SEO.** Don't rewrite correct tags.
@@ -2,6 +2,7 @@
 name: validator-analyzer
 description: Web standards audit agent — W3C HTML validity (validator.nu), W3C CSS validity (jigsaw.w3.org), WCAG 2.1 accessibility (axe-core, pa11y, WAVE). Dispatched from /web-validate. Produces scored .claude/audits/VALIDATE.md report with concrete diffs for auto-fixable issues and user actions for judgment-required fixes. Complementary to /harden (security), /seo (indexability), /geo (AI extraction).
 tools: Read, Edit, Write, Bash, Grep, Glob, WebFetch
 model: sonnet
 ---
 # Validator — W3C + WCAG audit
@@ -0,0 +1,143 @@
 # Model routing — reflection inline (big model) / execution pinned (Sonnet) — design
 **Date**: 2026-07-15 · **Status**: approved (user, 2026-07-15) · **Branch**: `feature/model-routing`
 **Lifecycle**: transient planning artifact (BDR-065) — committed during the run, deleted post-merge.
 ## Principle
 The session model is assumed to be a big reasoning model (Fable 5, or Opus when
 Fable is unavailable). Everything that **thinks** — brainstorming, planning,
 technical decisions, audits, loop decisions — runs INLINE in the main
 conversation, or in subagents that inherit the session model. Everything that
 **executes** a ready-made plan — writing code, applying fix bundles, commits,
 deliverable rendering — runs on Sonnet-pinned subagents. A blocking gate
 enforces the "session = big model" assumption at the entry of every reflection
 orchestrator.
 User verdicts baked in (2026-07-14/15):
 - Scope = hybrid: ship-feature/init-project execution → sonnet; `/feat`
  re-architected (plan inline → dispatch executor); bugfix/hotfix stay fully
  inline (BDR-050 conserved for them).
 - Gate = BLOCKING, not advisory.
 - Audit agents inherit the session model (no opus pin); the gate extends to
  audit orchestrators.
 - verifier + security-auditor KEEP `model: sonnet` (job9 decision confirmed).
 - client-handover-writer → sonnet (requires converting its inline-load to a
  true dispatch; human gates relocate to the main loop).
 ## 1. Blocking model gate
 New `lib/model-check.sh`: resolves the current session model from
 `settings.json` (physical path resolution — LRN-023 class), normalizes
 (`claude-fable-5[1m]` → fable, `claude-opus-*` → opus, sonnet, haiku), prints
 `big|small|unknown`. Exit 0 = big, 2 = small, 3 = unknown.
 New `lib/model-gate.md` snippet (same include pattern as `lib/design-gate.md`):
 run the check; `small` → STOP the skill: "session model is <X> — reflection
 requires Fable/Opus. Switch with /model, then relaunch." `unknown` →
 fail-visible: show the raw value, ask the user to confirm or abort (BDR-025
 doctrine — unknown never silently passes).
 Wired as a STEP 0 line in the reflection orchestrators:
 `ship-feature, init-project, feat, bugfix, onboard, seo, geo, web-validate,
 harden, audit-delta, tour, code-clean`.
 NOT wired in: `hotfix` (trivial by definition), `commit-change`, `doc`,
 `status`, `release-candidate`.
 Caveats to prove at implementation time:
 - `/model` mid-session rewrites settings.json (LRN-098 observed it once —
  re-prove with a live flip-test before trusting the source).
 - The helper itself must be flip-tested (LRN-096: an unproven guard is a
  vacuous guard).
 ## 2. Frontmatter pins (`agents/*.md`)
 | Agent | Before | After | Rationale |
 |---|---|---|---|
 | feater | (inherit) | **sonnet** | executor as subagent: seo/geo L1 applier + new /feat dispatch |
 | hotfixer | (inherit) | **sonnet** | L1 applier (seo/geo/web-validate); /hotfix inline unaffected (pin inert on inline load) |
 | client-handover-writer | opus | **sonnet** | deliverable executor; pin becomes EFFECTIVE only with §5 dispatch conversion (today's opus pin is inert — the agent is inline-loaded) |
 | analyzer | haiku | **(none — inherit)** | analysis feeds the plan = reflection; runs big via the session model |
 | verifier | sonnet | keep | F1 confirmed (job9) |
 | security-auditor | sonnet | keep | F1 confirmed (job9) |
 | seo-analyzer, geo-analyzer, validator-analyzer | (inherit) | keep (inherit) | audit = reflection = session model; covered by the gate |
 | code-cleaner | (inherit) | keep (inherit) | audit phase = reflection; fixes hand off to refactorer (sonnet) via CODE-CLEAN-SCOPE.md (job9 H1) |
 | doc-syncer, onboarder, scaffolder, refactorer, interviewer, plugin-advisor | sonnet | keep | workers/executors |
 | status-reporter | haiku | keep | mechanical collector |
 | bugfixer, commit-changer | (inherit) | keep | inline-only playbooks — a pin would be inert |
 ## 3. `/feat` re-architecture (partial supersede of BDR-050 — feat only)
 `skills/feat/SKILL.md` absorbs the reflection: analyze-before-plan, design
 gate, MINI-PLAN, contract (`lib/contract-interview.md`) — all inline. Then
 dispatches `Agent(subagent_type="feater")` (sonnet via pin) with: the
 contract, the plan, the branch name, repo conventions.
 `agents/feater.md` is rewritten as a pure executor: implement the plan to the
 letter, run project checks, commit (no attribution trailers), return a
 structured summary. No user interaction inside feater (subagents cannot ask) —
 every decision must be closed pre-dispatch.
 The verify-secure loop moves out of feater.md into the /feat main loop
 (LRN-083 invariant: loop decisions live in the main loop): fresh verifier →
 ECARTS → re-dispatch feater with the verdict deltas, bounded 3×; then the
 security gate. Escalation paths unchanged.
 ## 4. SDD execution pinned (ship-feature STEP 4, init-project STEP 8)
 One instruction line in each SKILL.md: every implementation subagent
 dispatched under `superpowers:subagent-driven-development` MUST carry
 `model: "sonnet"` in the Agent call. No fork of the superpowers skill — the
 main loop emits the Agent calls and controls the params.
 ## 5. client-handover conversion (inline-load → true dispatch)
 `skills/client-handover/SKILL.md`: collect params inline (URL, logo, options),
 then `Agent(subagent_type="client-handover-writer")` — the sonnet pin becomes
 effective. Human gates (per-axis threshold escalation, overrides) RELOCATE to
 the main loop: the writer returns a structured `GATE NEEDED` status instead of
 asking; the dispatcher asks the user and re-dispatches (or continues via
 SendMessage) with the decision. `AskUserQuestion` is removed from the writer's
 tools.
 OPEN VERIFY POINT: the writer's own nested dispatches (seo/harden re-runs as
 general-purpose subagents) — verify at implementation what nested children
 inherit (session model vs parent model). If they inherit the sonnet parent,
 the re-run audits violate the principle → force the model explicitly in those
 nested dispatches or lift them to the main loop.
 ## 6. web-validate fixes → L1 applier
 STEP 3 stops applying fixes via inline Edit; dispatches `hotfixer` (sonnet)
 with the fix bundle — same pattern as seo/geo (BDR-061 alignment).
 ## 7. Memory / doc / tests
 - New BDR: model-routing principle (reflection inline big / executors sonnet /
  blocking gate); partial supersede of BDR-050 (feat only); records F1
  (verifier/security stay sonnet) and the analyzer haiku→inherit change.
 - README: agent-model table refresh. CHANGELOG Unreleased entry.
 - Tests: flip-tests for `model-check.sh` (fable[1m] / opus / sonnet / garbage
  fixtures); gate STOP proven on a small-model fixture (LRN-096); /feat smoke
  on a throwaway repo (LRN-079): plan inline → dispatch carries sonnet →
  verify loop decided in main loop; grep census: no executor dispatch without
  an effective pin.
 ## Out of scope / accepted deviations
 - `/doc` and `/commit-change` stay inline on the session model (judgment and
  execution interleaved; converting them buys little). Revisit under quota
  pressure.
 - bugfix/hotfix fully inline (BDR-050 conserved).
 - No per-agent "fable-else-opus" fallback exists in the harness — the session
  model IS the fallback mechanism; the gate is its backstop.
 ## Risks
 - Model strings in settings.json may change shape with CC updates →
  model-check must return `unknown` (fail-visible), never guess.
 - feater as a subagent loses main-conversation context → the plan becomes the
  contract; weak plans cost verify-loop iterations. Mitigation:
  contract-interview stays mandatory in /feat.
 - Nested model inheritance under client-handover-writer unknown → §5 verify
  point.
@@ -1,65 +0,0 @@
 #!/usr/bin/env bash
 # config-protection.sh
 #
 # PreToolUse hook (Edit|Write|MultiEdit). Blocks edits to this config's
 # quality-gate files — the guardrails an agent must not silently weaken to make
 # an error "pass" (permission/hook registry, gitflow enforcement, the git
 # pre-commit guard, the hooks themselves, the test suite, the health diagnostic,
 # lint config). Exit 2 blocks the tool call and feeds the message back to the
 # model (Claude Code PreToolUse contract).
 #
 # It fires only on the model's Edit/Write tool calls — never on shell-level file
 # ops (the cp/ln in install.sh, link.sh), so bootstrap/deploy is unaffected.
 #
 # One-shot escape hatch: create .claude/.config-edit-ok (CWD-relative) with a
 # NON-EMPTY reason inside; the hook logs the reason, consumes (rm) the sentinel,
 # and allows that single edit. It never persists — a lingering sentinel would be
 # a footgun. Discipline, per CLAUDE.global.md "Root causes only. No temp fixes.": fix
 # the code, don't loosen the gate. Fails OPEN (exit 0) on parse failure so it can
 # never wedge editing.
 set -euo pipefail
 log="${HOME}/.claude/logs/config-protection.log"
 sentinel="${PWD}/.claude/.config-edit-ok"
 input="$(cat)"
 path="$(printf '%s' "$input" \
  | python3 -c 'import sys, json; print(json.load(sys.stdin).get("tool_input", {}).get("file_path", ""))' \
  2>/dev/null || true)"
 [ -z "$path" ] && exit 0
 # Guardrail files, matched by path suffix (covers both the repo source and the
 # deployed ~/.claude copy). Precise: lib/gitflow.sh only, not gitflow-migrate.sh.
 case "$path" in
  */.claude/settings.json|*/.claude/settings.local.json|*/claude/settings.json) ;;
  */lib/gitflow.sh|*/.githooks/*|*/doctor.sh) ;;
  */hooks/*.sh|*/lib/tests/*) ;;
  */.shellcheckrc|*/.markdownlint.json|*/.editorconfig) ;;
  *) exit 0 ;;
 esac
 # One-shot sentinel bypass: non-empty reason required; consumed on sight.
 if [ -f "$sentinel" ]; then
  reason="$(head -c 500 "$sentinel" 2>/dev/null | tr '\n\r\t' '   ' || true)"
  rm -f "$sentinel"
  if printf '%s' "$reason" | grep -q '[^[:space:]]'; then
    mkdir -p "$(dirname "$log")"
    printf '%s\tBYPASS\t%s\treason=%s\n' "$(date -Iseconds)" "$path" "$reason" >> "$log"
    exit 0
  fi
  printf '%s\n' "[config-protection] .claude/.config-edit-ok had an EMPTY reason -> refused (sentinel consumed). Recreate it with a non-empty reason." >&2
  exit 2
 fi
 cat >&2 <<EOF
 [config-protection] BLOCKED edit to a quality-gate file:
  $path
 This is a guardrail (permission/hook registry, gitflow enforcement, git
 pre-commit guard, a hook, the test suite, health diagnostic, or lint config).
 Don't weaken the gate to make an error pass — fix the root cause instead
 (global CLAUDE.md: "Root causes only. No temp fixes."). To make one intended edit,
 create .claude/.config-edit-ok with a non-empty reason; it is logged and
 consumed (one-shot).
 EOF
 exit 2
@@ -0,0 +1,63 @@
 #!/usr/bin/env bash
 # ctx7-reminder.sh
 #
 # UserPromptSubmit hook. When the current project uses fast-moving libs
 # (lib/fast-libs.sh) it injects ONE reminder per session to consult ctx7
 # (find-docs skill) before coding against their APIs, pointing at the
 # .ctx7-cache/ state. Closes the ad-hoc-coding gap: find-docs' description
 # fires on doc *questions* and ship-feature/init-project pre-fetch, but
 # nothing covered a plain "add a useEffect here" prompt (BDR-078; second
 # deliberate ctx7 surface, scoped refinement of BDR-053 single-surface).
 #
 # Soft nudge: always exits 0, never blocks. Stable-tech projects (no
 # manifest, or no fast-lib match) stay silent.
 set -euo pipefail
 input="$(cat)"
 field() { # $1=json key — extracted from hook stdin, empty on failure
  printf '%s' "$input" | python3 -c \
    "import sys,json; print(json.load(sys.stdin).get('$1',''))" \
    2>/dev/null || true
 }
 prompt="$(field prompt)"
 case "$prompt" in
  '<task-notification>'*) exit 0 ;; # harness turn, not a user request
 esac
 cwd="$(field cwd)"
 [ -n "$cwd" ] || cwd="$PWD"
 # Cheap bail-out before any lib work: no manifest → no fast-libs.
 [ -f "$cwd/package.json" ] || [ -f "$cwd/requirements.txt" ] \
  || [ -f "$cwd/pyproject.toml" ] || exit 0
 # One fire per session: the doctrine holds for the whole session,
 # repeating it on every prompt would be token spam.
 session_id="$(field session_id)"
 sentinel="${TMPDIR:-/tmp}/.ctx7-reminder-${session_id:-nosession}"
 [ -e "$sentinel" ] && exit 0
 # Resolve the lib next to this hook (repo layout), fall back to the
 # installed copy — both paths exist through the link.sh symlinks.
 script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 libsh="${script_dir}/../lib/fast-libs.sh"
 [ -f "$libsh" ] || libsh="${HOME}/.claude/lib/fast-libs.sh"
 [ -f "$libsh" ] || exit 0
 libs="$(bash "$libsh" detect "$cwd" 2>/dev/null || true)"
 [ -n "$libs" ] || exit 0
 status="$(bash "$libsh" cache-status "$cwd" 2>/dev/null || true)"
 : > "$sentinel" || true
 list="$(printf '%s' "$libs" | tr '\n' ' ' | sed 's/ *$//')"
 if [ "$status" = "fresh" ]; then
  printf '📚 Fast-moving libs in this project (%s) — fresh .ctx7-cache/ present: read the matching cache file before relying on their APIs.\n' "$list"
 else
  printf '📚 Fast-moving libs in this project (%s) — .ctx7-cache/ %s: consult ctx7 (find-docs skill) before writing code against their APIs. Stable techs need nothing.\n' "$list" "${status:-missing}"
 fi
 exit 0
@@ -644,6 +644,46 @@ if command -v ctx7 &>/dev/null; then
  # (~490 tok/session, job1 F10). Purge it unconditionally so re-runs and
  # manual `ctx7 setup` invocations stay rule-free.
  rm -f "$HOME/.claude/rules/context7.md"
  # BDR-078: re-apply the coverage extension to the generated skill — the
  # before-writing-code trigger (description) + the cache-first rule (body).
  # The dist is machine-owned (gitignored, regenerated on fresh clones), so
  # the durable copy of this patch lives HERE. Idempotent: grep-guarded.
  _fd="$HOME/.claude/skills/find-docs/SKILL.md"
  if [ -f "$_fd" ] && ! grep -q 'fast-libs.sh detect' "$_fd"; then
    if python3 - "$_fd" <<'PY'
 import sys
 p = sys.argv[1]
 s = open(p, encoding="utf-8").read()
 DESC = """
  Also use BEFORE writing or modifying code that uses a fast-moving library
  (anything `bash ~/.claude/lib/fast-libs.sh detect .` reports — React,
  Next.js, Prisma, Tailwind, Astro, Svelte…), even when the user asked for
  code rather than documentation — unless a fresh `.ctx7-cache/` file already
  covers the API involved. Stable technologies (C, C++98, POSIX shell, SQL…)
  need no lookup."""
 BODY = """
 ## Cache first
 Before any fetch, check the project's `.ctx7-cache/`
 (`bash ~/.claude/lib/fast-libs.sh cache-status .`): a fresh (<7 days)
 `<lib>*.md` may already answer — read it instead of calling ctx7. When a
 `docs` call supports code you are about to write, save the output for the
 next consumer:
 `npx ctx7@latest docs <id> "<query>" | tee .ctx7-cache/<lib>-<topic>.md`.
 """
 i = s.index("\n---", 3)          # closing frontmatter fence
 s = s[:i] + "\n" + DESC + s[i:]
 m = "using the Context7 CLI.\n"  # intro line under the H1
 j = s.index(m) + len(m) if m in s else len(s)
 s = s[:j] + BODY + s[j:]
 open(p, "w", encoding="utf-8").write(s)
 PY
    then
      ok "find-docs skill extended (BDR-078 fast-libs trigger + cache-first)"
    else
      warn "find-docs BDR-078 patch failed — re-run 'make plugin' or patch by hand"
    fi
  fi
  info "Standalone usage:  ctx7 docs /vercel/next.js \"middleware\""
 fi
@@ -0,0 +1,87 @@
 # Challenge the plan — shared orchestrator include
 Runs in the ORCHESTRATOR MAIN LOOP after a plan / reflection is elaborated and
 BEFORE it is executed. Turns a fresh plan into a hardened one by attacking it
 from three independent angles, then RE-THINKING every aspect a challenger lands.
 Loop + synthesis decisions live here, in the main loop (BDR-066: reflection runs
 on the big model; `verify-secure-loop.md`: fresh blind gates, decisions in the
 loop). It never merges, executes, or edits code — it hardens the plan and hands
 it to the orchestrator's existing human gate.
 The challenge is ADVISORY into that gate — no new hard block — but a BLOCKER is
 never silently carried past: it is either closed by a NAMED plan change or
 explicitly deferred for the human.
 ## Inputs the caller must have ready
 - `PLAN`: path to the plan ON DISK. If your plan is still inline (a printed
  checklist / diagnosis / fix plan), FIRST persist it to
  `.claude/tasks/plans/<date>-<slug>-<HHMM>.md` — the challengers read from disk
  and judge blind, exactly like the verifier reads the contract.
 - `KIND`: `build-plan` | `proposals` | `fix-bundle` — tunes the lens framing
  below; the mechanism is identical.
 - `SCOPE`: the files/dirs the plan touches (grounds the critique).
 - `CONSTRAINTS` (optional): the decided trade-offs / rejected alternatives from
  the design step, so a lens does not re-litigate a settled choice.
 Nominal path is cheap for a small, clean plan: three parallel challengers return
 SOLID, synthesis is a no-op. It only costs more when a lens lands a real finding
 — which is the point.
 ## DISPATCH — three fresh challengers, in parallel, blind
 Dispatch THREE fresh `plan-challenger` subagents IN PARALLEL, one per LENS, each
 blind to the others and to this conversation:
 ```
 Agent(subagent_type="plan-challenger", description="challenge:<lens>", prompt="""
  PLAN: <the PLAN path>
  LENS: <correctness | robustness | simplicity>   # one per agent — all three
  SCOPE: <SCOPE>
  CONSTRAINTS: <CONSTRAINTS, if any>
 """)
 ```
 **MODEL (BDR-076, supersedes the BDR-066 inherit):** plan critique is AUDIT
 JUDGMENT — the challengers are `model: opus`-pinned in their frontmatter: a big
 tier, session-independent, off the session model. The session model (Fable)
 keeps only this loop — synthesis, RE-THINK, gate. Never sonnet: that would
 silently downgrade the judgment. (The executor gates stay sonnet.)
 **Lens framing by `KIND`** (the agent's three lenses, read against the artifact):
 - `build-plan` — will it WORK / will it BREAK / is it needlessly COMPLEX.
 - `proposals` — are these the RIGHT items & priorities / what did the audit MISS
  or under-rate as risk / is the backlog over- or under-scoped.
 - `fix-bundle` — will each fix ACHIEVE its goal / could it BREAK or regress the
  page / is there a simpler fix, or an unnecessary one.
 ## FAIL-SAFE — never fail open
 A challenger that returns a malformed/empty verdict, a missing `PROOF`, or dies →
 retry ONCE with a fresh challenger; a 2nd failure on that lens → STOP and escalate
 to the human, NAMING the lens. Never carry "plan challenged" into the gate on a
 silently dropped lens (`verify-secure-loop.md`: "a mute verifier is NEVER a PASS").
 ## SYNTHESIZE + RE-THINK (main loop, big model)
 Parse each `CHALLENGE — LENS: … — VERDICT:` line and merge the FINDINGS:
 - **Severity-driven, not consensus.** Any `[BLOCKER]` from ANY single lens is
  must-address — the lenses are orthogonal, so a lone security/rollback finding
  is real, never outvoted by lens-count. Cross-lens agreement only RANKS the MINORs.
 - **RE-THINK the aspect the challenge pointed at.** For each BLOCKER (and each
  MAJOR you accept): revise the plan on THAT aspect — a NAMED, diffable change to
  the plan, never a self-authored "addressed" line. A BLOCKER you consciously keep
  is tagged `[deferred <date>]` for the human to accept at the gate.
 - **Re-challenge once if the plan materially changed** — a fix can open a new
  flaw. Re-persist the revised `PLAN`, dispatch ONE fresh confirmation challenger,
  max 1 extra pass, then the gate.
 ## OUTPUT — into the existing human gate
 Feed the orchestrator's gate:
 - the REVISED plan, and
 - a CHALLENGE SUMMARY: each BLOCKER raised → the named change that closed it;
  anything `[deferred]`; and any lens that failed to return.
 The human remains the decider.
@@ -17,23 +17,28 @@ and any SIGNIFICANT-gated patch), with the code already committed.
 - Orchestrators (ship-feature / init-project): run it BEFORE the FINISH step — otherwise
  the doc commit strands outside the merge/PR (the exact bug this fixes). See ORDERING.
-doc-syncer runs IN-THREAD (the orchestrator loads it), so the list of files it patched is
+doc-syncer runs DISPATCHED (BDR-077: `MODE: audit` on opus → dispatcher gate
-already in hand — surfaced as `PATCHED_FILES:` in doc-syncer's OUTPUT, ONE PATH PER LINE.
+→ `MODE: patch` on sonnet); its patch-mode report hands the orchestrator BOTH
-Pass each line as a SEPARATE argument (see DO step 3).
+machine blocks: `PATCHED_FILES:` (ONE PATH PER LINE — pass each line as a
 SEPARATE argument, see DO step 3) and `CHANGE SUMMARY` (one line per patched
 file — the patch context that used to be in-thread now crosses the dispatch
 boundary through this block, LRN-126).
 ## DO
 1. Collect `PATCHED_FILES` — the public-doc paths doc-syncer wrote this run (its OUTPUT
   block, ONE PATH PER LINE). Empty → nothing to commit; the helper no-ops.
-2. Compose — from the patch context the AGENT holds (doc-syncer ran in-thread, so the
+2. Compose — from doc-syncer's `CHANGE SUMMARY` block (the patcher held the
-   agent knows exactly what changed) — BOTH artifacts:
+   patch context and reported it; a dispatched patcher with NO summary block
   in its report = incomplete report, re-dispatch rather than invent) —
   BOTH artifacts:
   - the COMMIT MESSAGE, repo style `docs: <summary> — <flow>`
     (`docs: README features + USAGE flags — ship-feature dark-mode`);
   - the CHANGE SUMMARY for the rc 0 surface (e.g. "README features section + USAGE
-     --export flag").
+     --export flag") — derived from the block, never a bare file count.
-   Both are the AGENT's to write — the helper produces NEITHER (its only stdout is the
+   Both are the ORCHESTRATOR's to write — the helper produces NEITHER (its only stdout
-   hash). This is the load-bearing point of the visible surface: see the rc 0 row.
+   is the hash). This is the load-bearing point of the visible surface: see the rc 0 row.
 3. Commit surgically via the helper, passing EXACTLY the patched files — each path as a
   SEPARATE argument (split `PATCHED_FILES` on NEWLINES only), capturing the hash:
@@ -0,0 +1,65 @@
 #!/usr/bin/env bash
 # fast-libs.sh — single source of truth for "fast-moving library" detection.
 #
 # Fast-moving = API churns faster than model training data (React, Next.js,
 # Prisma…) → consult ctx7 (find-docs) before coding against it. Stable techs
 # (C, C++98, POSIX sh, SQL…) never match: no ctx7 needed (BDR-078).
 #
 # Consumers: hooks/ctx7-reminder.sh, /ship-feature STEP 0c, /init-project
 # STEP 5c, /onboard STEP 3.5, feater/bugfixer executor briefs.
 #
 # Verbs:
 #   fast-libs.sh detect [dir]        detected libs, one/line; exit 1 if none
 #   fast-libs.sh cache-status [dir]  fresh|stale|missing; exit 0 only if fresh
 set -euo pipefail
 # Exact npm dependency keys (unscoped). Anchored full-key match — "react"
 # must not drag react-icons along.
 NPM_EXACT='next|react|react-dom|react-native|expo|prisma|supabase'
 NPM_EXACT+='|drizzle-orm|astro|svelte|vue|nuxt|tailwindcss|vite|next-auth'
 NPM_EXACT+='|motion|framer-motion|ai|openai|langchain|remix|fastify'
 # Scoped npm orgs (@org/…).
 NPM_SCOPED='prisma|supabase|astrojs|sveltejs|tanstack|clerk|anthropic-ai'
 NPM_SCOPED+='|langchain|remix-run|nestjs|tailwindcss'
 # Python distributions (requirements.txt / pyproject.toml).
 PY_LIBS='fastapi|pydantic|sqlalchemy|langchain'
 CACHE_MAX_AGE_DAYS=7
 npm_fast_libs() { # $1=dir — matching dependency keys, one per line
  [ -f "$1/package.json" ] || return 0
  jq -r '((.dependencies // {}) + (.devDependencies // {})) | keys[]' \
    "$1/package.json" 2>/dev/null \
    | grep -E "^(${NPM_EXACT})\$|^@(${NPM_SCOPED})/" || true
 }
 py_fast_libs() { # $1=dir — matching distributions, one per line
  grep -hoiE "\b(${PY_LIBS})\b" \
    "$1/requirements.txt" "$1/pyproject.toml" 2>/dev/null \
    | tr '[:upper:]' '[:lower:]' | LC_ALL=C sort -u || true
 }
 detect() { # $1=dir — union, sorted unique; exit 1 when empty
  local libs
  # LC_ALL=C: deterministic order whatever the caller's locale.
  libs="$(printf '%s\n%s\n' "$(npm_fast_libs "$1")" "$(py_fast_libs "$1")" \
    | sed '/^$/d' | LC_ALL=C sort -u)"
  [ -n "$libs" ] || return 1
  printf '%s\n' "$libs"
 }
 cache_status() { # $1=dir — fresh|stale|missing; exit 0 only when fresh
  [ -d "$1/.ctx7-cache" ] || { echo missing; return 1; }
  if [ -n "$(find "$1/.ctx7-cache" -name '*.md' \
      -mtime "-${CACHE_MAX_AGE_DAYS}" -print -quit 2>/dev/null)" ]; then
    echo fresh; return 0
  fi
  echo stale; return 1
 }
 case "${1:-}" in
  detect)       detect "${2:-.}" ;;
  cache-status) cache_status "${2:-.}" ;;
  *) echo "usage: fast-libs.sh detect|cache-status [dir]" >&2; exit 2 ;;
 esac
@@ -33,8 +33,11 @@ with no code branch to follow. That is the leak it closes: the `.claude/**` hook
 exemption still lets a *manual* memory commit through on a protected base, but a
 skill-driven one now branches to `chore/*` first.
-**Never run `gitflow finish`** — these flows commit, they do not merge. Integration
+**Integration is human-gated by default** — these flows commit, they do not merge.
-is a separate, human-gated step (the `gitflow` skill).
+EXCEPTION: `/capitalize` + `/close` auto-persist their memory-only commit (finish →
 develop + push) when THEY branched a `chore/*` off develop this run (BDR-068 — a
 scoped [[LRN-069]] exception; see the capitalize skill's STEP 5C). `/prune-memory`
 + `/reconcile` stay fully human-gated: never run `gitflow finish` from them.
 Note: `hotfix` branches off **main** (prod) even when invoked from `develop` — that
 is the gitflow definition of a hotfix. For a dev-scoped small fix, use `/bugfix`
@@ -0,0 +1,33 @@
 #!/usr/bin/env bash
 # lib/model-check.sh — classify the persisted session model: big | small | unknown
 #
 # Witness for lib/model-gate.md (reflection requires a big model). Reads the
 # "model" key of the user-scope settings (the file /model rewrites — LRN-098).
 # Override the source with MODEL_CHECK_SETTINGS (tests use fixtures).
 #
 # stdout : <class>:<raw>   (raw = value found, empty if none)
 # exit   : 0 = big (fable/opus) · 2 = small (sonnet/haiku) · 3 = unknown
 set -u
 SETTINGS="${MODEL_CHECK_SETTINGS:-$HOME/.claude/settings.json}"
 raw=""
 if [ -f "$SETTINGS" ]; then
  raw="$(python3 - "$SETTINGS" 2>/dev/null <<'PY'
 import json, sys
 try:
    v = json.load(open(sys.argv[1])).get("model", "")
    print(v if isinstance(v, str) else "")
 except Exception:
    print("")
 PY
 )"
 fi
 norm="$(printf '%s' "$raw" | tr '[:upper:]' '[:lower:]')"
 case "$norm" in
  *opusplan*)       printf 'unknown:%s\n' "$raw"; exit 3 ;; # opus-for-plan, sonnet otherwise — ambiguous
  *fable*|*opus*)   printf 'big:%s\n'     "$raw"; exit 0 ;;
  *sonnet*|*haiku*) printf 'small:%s\n'   "$raw"; exit 2 ;;
  *)                printf 'unknown:%s\n' "$raw"; exit 3 ;;
 esac
@@ -0,0 +1,47 @@
 # Model gate — reflection requires a big model (BLOCKING)
 Shared include. Runs FIRST in any orchestrator whose reflection —
 brainstorming, planning, contract, audit judgment, loop decisions —
 executes inline or in inherit-model subagents. Sonnet-pinned executors are
 not what this gate protects; it protects the thinking around them (BDR-066).
 ## 1. Self-check
 Your system prompt names the model powering this session. Fable or Opus →
 big. Sonnet, Haiku, anything else → small.
 ## 2. Witness — deterministic check
    bash "$HOME/.claude/lib/model-check.sh"
 Output `<class>:<raw>`; exit 0 = big, 2 = small, 3 = unknown. The witness
 reads the PERSISTED model (settings.json — the file `/model` rewrites,
 LRN-098). It can lag reality (session launched with `--model`, settings not
 yet rewritten) — that is why the self-check exists alongside it.
 ## 3. Verdict
 | self-check | witness | action |
 |---|---|---|
 | big | big (0) | proceed, SILENT — the nominal path prints nothing |
 | small | any | **STOP** |
 | big | small (2) | disagreement — **STOP**, surface BOTH values; the user confirms or relaunches |
 | big | unknown (3) | fail-visible: print `model gate: witness unknown (<raw>) — self-check says <model>` and ask the user to confirm before continuing (BDR-025: unknown never silently passes) |
 **STOP means**: print exactly
    ⛔ MODEL GATE — session on <model>. Reflection steps of this skill
    require Fable or Opus. Switch with /model, then relaunch the skill.
 then end the turn. No later step runs, no agent is dispatched, nothing is
 edited.
 ## 4. Dispatch tiers (BDR-077 — no inherit)
 The gate guards the MAIN loop only. Dispatched work NEVER inherits the
 session model: typed agents run on their frontmatter pin; built-ins
 (general-purpose / Explore / Plan) carry an explicit `model=` at every call
 site — `model: "fable"` when the child performs reflection/orchestration on
 the main loop's behalf (skill-runners), otherwise its complexity tier
 (opus = dispatched judgment, sonnet = execution/collection, haiku = short
 mechanical probes).
@@ -0,0 +1,90 @@
 # Plugin gate — shared consumer include (plugin-check, onboard, init-project, ship-feature STEP 0)
 Runs in the CONSUMER'S MAIN LOOP. The detection and the reasoning are
 dispatched (BDR-077 tiers); the validation checkpoint, the report
 presentation, and the apply gate live HERE — a dispatched agent can neither
 ask the user nor safely mutate plugin state.
 ## 1. PROBE (dispatch — sonnet)
 ```
 Agent(subagent_type="plugin-probe", description="plugin gate — probe",
      prompt="Run your probes from <PROJECT_ROOT>. Emit the PROBE REPORT.")
 ```
 ## 2. VALIDATION CHECKPOINT (main loop — between probe and reasoner)
 Validate the PROBE REPORT before any reasoning:
 - `EXTERNAL` non-empty AND each listed plugin's directory appears under
  `CHECKPOINT plugin-dirs`.
 - At least one project signal present (MANIFESTS / FRAMEWORK-DEPS /
  TSX-JSX-COUNT > 0 / DOCKER-COUNT > 0 / EMBEDDED hits). Else print
  `⚠️ No project signals detected — recommendations will be conservative.`
  and continue.
 - `CHECKPOINT toggle-script=UNAVAILABLE` → print `⚠️ toggle script
  unavailable — recommendations will be advisory only, no auto-activation.`
  and SKIP step 5 (apply) entirely.
 - PROBE REPORT missing/unparsable → retry the probe ONCE fresh; a 2nd
  failure → STOP and surface (never reason over invented detection).
 ## 3. REASON (dispatch — opus)
 ```
 Agent(subagent_type="plugin-advisor", description="plugin gate — reason",
      prompt="""
 REQUEST: <the user's request / project description, verbatim>
 PROBE REPORT (ground truth — do not re-detect):
 <the full PROBE REPORT from step 1>
 """)
 ```
 ## 4. PRESENT + BLOCKING GATE (main loop)
 Show the returned PLUGIN CHECK block.
 - `ACTION REQUIRED? YES` → offer: A) fix plugins B) type "force". STOP until
  answered.
 - OK → print `✅ Plugin check passed — [active plugins] — complexity: <score>%`.
 ## 5. APPLY GATE (main loop — only when the flow auto-activates)
 If any plugin has ⚡ ENABLE status:
 1. List the changes:
   ```
   PROPOSED CHANGES:
     ⚡ Enable ui-ux-pro-max (frontend detected, complexity 65%)
     ⚡ Pre-fetch ctx7 docs for next.js, prisma
   Apply these changes? (yes / no / customize)
   ```
 2. "yes" → apply via the exact commands the advisor emitted. "customize" →
   user picks. "no" → proceed with current config.
 **Never auto-activate without showing the list and getting confirmation.**
 ### Rollback on partial failure
 Track each toggle; roll back the partial set rather than leave a
 half-applied configuration:
 ```bash
 applied=()
 for change in "${PROPOSED_CHANGES[@]}"; do
  if bash "$HOME/.claude/lib/toggle-external.sh" enable "$change"; then
    applied+=("$change")
  else
    echo "❌ failed to enable $change — rolling back ${#applied[@]} prior change(s)"
    for prior in "${applied[@]}"; do
      bash "$HOME/.claude/lib/toggle-external.sh" disable "$prior" \
        || echo "⚠️ rollback of $prior also failed — manual cleanup required: see ~/.claude/plugins/cache"
    done
    exit 1
  fi
 done
 ```
 Surface: `✅ Applied N change(s).` — or on failure:
 ```
 ⚠️ Toggle failed at change <name>. Rolled back the N prior change(s).
   To inspect manually: ls ~/.claude/plugins/cache; bash ~/.claude/lib/toggle-external.sh list
   Re-run /plugin-check after fixing the underlying cause (e.g. permissions).
 ```
@@ -80,9 +80,247 @@ fetch.sh queries --account client-a --property sc-domain:ex.com [--days 90] [--d
  → {"status":"degraded","reason":"no_credentials"|"token_revoked"|"network_error"|"rate_limited"}
 fetch.sh inspect --account client-a --property … --url https://ex.com/page
-  → {"status":"ok","source":"gsc","indexed":true,"coverage":"…","last_crawl":"…"}
+  → {"status":"ok","source":"gsc","indexed":true,"coverage":"…","last_crawl":"…",
     "rich_results":{"verdict":"PASS|FAIL|NEUTRAL|VERDICT_UNSPECIFIED|ABSENT",
                     "types":[{"type":"FAQ","items":2,"errors":2,"warnings":1,
                               "issues":["Missing field 'acceptedAnswer'"]}]}}
  → {"status":"degraded","reason":"…"}
  rich_results rides the SAME URL-Inspection response — Google already sends
  it, `inspect` used to discard it. No extra call, quota or OAuth scope.
  It is the only programmatic structured-data validation in the system.
    • verdict PARTIAL is never emitted — the API reserves it as unused.
    • verdict ABSENT is SYNTHETIC (not a Google enum): the API omits
      richResultsResult entirely when it detects no rich results. Surfaced
      as a value rather than a missing key, because a caller cannot tell an
      absent key apart from a check that never ran. ABSENT = "none
      detected", never "invalid".
    • errors/warnings count issue INSTANCES; issues[] is deduped — the same
      issueMessage repeats across every affected item.
 fetch.sh cannibal --account client-a --property … [--days 90] [--rows 1000]
  → {"status":"ok","source":"gsc","days":90,"rows_scanned":1000,"capped":true,
     "conflict_count":12,
     "conflicts":[{"query":"plombier paris","pages":3,"total_impressions":2400,
                   "urls":[{"url":…,"clicks":…,"impressions":…,"position":…}]}]}
  → {"status":"degraded","reason":"…"}                # no account → NOT auditable
  Keyword cannibalisation from Google's own data: queries where 2+ of OUR
  pages compete. Groups query+page rows; conflicts ranked by total
  impressions, and within each the strongest page first. `capped:true` means
  the row window was full — more conflicts exist past the cut, say so.
  Same auth, same quota family, no new scope: the API always accepted several
  dimensions at once, this engine only ever asked for one.
    • NOT the 30/70 duplication rule. This is a SERP fact Google measured.
      30/70 is content similarity, which has no data source here — doing it
      naively (compare two same-template pages without stripping nav/footer)
      returns ~95% similar for every site, a confident false positive. It stays
      an LLM judgement, labelled as one.
    • `queries` now takes `--dim query,page` (comma-separated) and `--rows`.
      Rows gained a `keys` list; `key` stays as keys[0], so the single-dim
      consumer is untouched.
 safe_fetch.py — NOT a verb; the SSRF/DNS-rebinding-safe fetcher behind
  sitemap._fetch, so every network verb (sitemap, linkgraph, rendercheck,
  drift) inherits it. urlopen resolved then connected — two DNS lookups, a
  window a hostile authority uses to answer PUBLIC to validation and PRIVATE
  (169.254.169.254 metadata, 127.0.0.1, the LAN) to the connect. This resolves
  ONCE, validates every IP (ipaddress, dual-stack v4+v6), refuses if ANY is
  non-public (the multi-A vector), and connects to the exact validated IP with
  Host+SNI+cert for the real host — no second resolution to poison. Redirects
  are followed with each hop RE-VALIDATED (urlopen followed them blind).
    • Better than the source idea (claude-seo url_safety.py, MIT): dual-stack
      (theirs IPv4-only), no global monkeypatch so thread-safe by construction
      (theirs locks a patched socket.getaddrinfo), stdlib-only (no requests).
    • Refusal raises UnsafeTarget; callers already degrade → fail-open kept.
    • NOT covered, and said so: the shell `curl` in the agent specs runs in
      another process, unpinnable from here. Smaller surface (fixed set vs an
      operator-confirmed $DOMAIN); `curl --resolve` would close it, separate change.
 fetch.sh sitemap --url https://ex.com/sitemap.xml
  → {"status":"ok","source":"sitemap","index":false,"count":86,"dropped":0,
     "urls":["https://ex.com/", …]}
  → {"status":"ok","index":true,"children_total":4,"children_read":4,
     "children_failed":0,"count":312,…}          # <sitemapindex>, one level deep
  → {"status":"degraded","reason":"fetch_failed"|"parse_failed"|"no_urls"
                                  |"unsafe_xml_dtd"}
  No auth, no Google, no venv: stdlib only (urllib + xml.etree + gzip).
  Gives STEP 9's COVERAGE line the denominator it was told to print and never
  had, and STEP 5 a real sampling frame. Dedupes, strips whitespace, handles
  .xml.gz. Caps: 50 children of an index, 50k URLs, 20 MB read — each cut is
  REPORTED (children_skipped / truncated), never silent.
    • NOT a security boundary. urllib fetches these, so nothing here reaches a
      shell. The CONSUMER interpolates them into curl, so seo-analyzer runs
      lib/url-guard.sh at the point of use — same contract as the sameAs check.
      A second copy of the guard here would only drift.
    • `unsafe_xml_dtd`: a sitemap NEVER has a DTD (sitemaps.org is <?xml?> then
      <urlset xmlns=>). Any doctype/entity is refused BEFORE parsing. xml.etree
      does not expand external entities, but it IS billion-laughs-vulnerable —
      1 KB expands to gigabytes, and the 20 MB read ceiling bounds the input,
      not the expansion. Refusing the construct beats depending on parser
      internals AND keeps this stdlib-only; defusedxml would drag in a venv for
      a document type that has no legitimate DTD.
 fetch.sh rendercheck --url https://ex.com/
  → {"status":"ok","verdict":"server-rendered"|"client-rendered"|"partial",
     "body_text_chars":7650,"h1_in_html":1,"jsonld_in_html":9,
     "meta_description_in_html":true,"html_bytes":132447,
     "warning":"…"}                       # warning only when not server-rendered
  R2, the honest half of the SPA call. seo-analyzer has always recorded
  `RENDERING: SSR/SSG/SPA` and never acted on it; this is the signal it acts
  on. Verdict comes from what the server SENT — package.json cannot tell a
  React SPA from a Next.js SSR app.
    • client-rendered → the agent REFUSES to score On-page (N/A, not zero: a
      zero says "your on-page is bad", N/A says "we could not see it"). Every
      curl-based meta/H1/JSON-LD check would report "missing" against a site
      that is fine once hydrated — false findings, and a bundle that "fixes"
      tags which already exist.
    • Does NOT render JS. No Playwright, no Chromium, no venv. Refusing IS the
      finding.
    • Script/style text is not page text: measured 7 chars on a React shell
      whose inline window.__INITIAL_STATE__ is large. Without that, a 200 KB
      bundle reads as a rich page.
    • Measured 2026-07-17: zenquality 7650 chars/1 h1/9 jsonld and
      lavageangels356 13973/1/1 → server-rendered; a Vite shell → 7/0/0.
 fetch.sh linkgraph --url https://ex.com/sitemap.xml [--max 500]
  → {"status":"ok","source":"linkgraph","pages_crawled":86,"pages_failed":0,
     "total_internal_links":2015,"capped":false,"max_depth":2,
     "orphans":[…],"beyond_3_clicks":[…],"unreachable":[…]}
  → {"status":"ok",…,"orphans_withheld":true,"reason_withheld":"crawl incomplete…"}
  → {"status":"degraded","reason":"no_links_in_html"|"no_pages_fetched"|…}
  Answers seo-analyzer.md:613 ("reachable within 3 clicks?") and :616 ("orphan
  pages?") — asked since forever, never computed. Stdlib only (urllib +
  html.parser + urljoin), no auth. Measured: 24 pages in 2.7s, 86 in 3.8s.
    • EXHAUSTIVE OR NOTHING. Orphans cannot be sampled: proving no inbound
      link means having read every other page. If the crawl is capped or any
      page failed, orphans are WITHHELD, never truncated — a false orphan
      sends a client fixing what is not broken.
    • no_links_in_html = a JS-rendered site, not a link-less one. Every page
      would read as orphaned, so it REFUSES rather than report that. Does not
      render JS by design (see the R1/R2 arbitration).
    • Filters what a link graph must never hold: assets (seen live:
      /css/main.css?v=1778157313), #anchors, mailto:/tel:/javascript:, other
      hosts. Normalises the trailing slash so /blog and /blog/ are one node
      rather than a phantom orphan pair.
    • Mock is pages.json ({url: html}), not a single page.html: one fixture
      cannot express a graph — every node would carry identical links.
 fetch.sh score --findings <path.json | ->
  → {"status":"ok","axes":{"technical":{"score_20":17.8,"weight":0.2,
       "weight_renormalised":0.2857,"findings":2}},
     "na":["off-page","on-page"],"weights_renormalised":true,"global_20":17.6}
  → {"status":"error","reason":"unknown severity: 'bogus'"|"bad_findings_json"}
  I7. /harden has a real scale (SKILL.md:435: -15/-8/-3/-1, clamp [0,100]);
  /seo had none, so every axis was FELT and two runs over identical code could
  disagree — while /client-handover gates on 17/20. Same scale here, /5 into
  /20, one vocabulary across the family.
    • The split: WHICH findings exist and how severe each is stays the LLM's
      judgement. The addition is not. Same findings in, same score out.
    • affected/sampled shift severity ONE step: >=50% of the sample escalates,
      a single page de-escalates. A defect on 1 of 12 pages is not the defect
      on 12 of 12.
    • status:"na" → axis EXCLUDED, remaining weights renormalised. This is
      R2's rule (client-rendered on-page) and I1's (unauditable off-page),
      computed rather than done by hand. N/A is not a zero, and the engine
      will not let it act like one.
    • Malformed input is an error, never a silently wrong number — unlike the
      fetch verbs, a degrade here would mean bad input, not a network fact.
 fetch.sh schema_gen <reservation|order|discussion|profile> [flags] [--script-tag]
  → {"status":"ok","source":"schema_gen","type":"<@type>","jsonld":{…}}
  → {"status":"error","reason":"bad_usage"}          # a REQUIRED flag omitted
  → {"status":"degraded","reason":"…"}               # a required flag given, empty
  fetch.sh schema_gen reservation --provider "Marea NYC" \
    --start 2026-06-04T19:30:00-04:00 --party-size 4
  fetch.sh schema_gen order --merchant "Acme Pizza" --order-url https://acme.example/order
  fetch.sh schema_gen discussion --headline "…" --author "Sara Park" \
    --url https://forum.example.com/t/123 --date 2026-05-12T14:00:00Z
  fetch.sh schema_gen profile --name "Daniel Agrici" --url https://agricidaniel.com/about \
    --same-as https://github.com/AgriciDaniel --knows-about "SEO" "Schema markup"
  Adapted from claude-seo's `schema_generate.py` (MIT) into this contract.
  Our system only AUDITS existing markup elsewhere; this is the one verb
  that GENERATES it — deterministic JSON-LD skeletons for the four v2
  high-leverage Schema.org types, so geo-analyzer's G2 batch stops
  hand-writing markup by hand. It only generates STRUCTURE: unknown field
  VALUES are the caller's job, `[À COMPLÉTER]` for anything unconfirmed —
  this verb never invents a sameAs, an email, or a business name.
    • Stdlib only, no network, no auth — runs even without the venv.
    • `--script-tag` wraps the cleaned jsonld in
      `<script type="application/ld+json">…</script>` under a `script` key,
      still inside the `ok` envelope. It must be given AFTER the type
      (`schema_gen reservation … --script-tag`, not before) — argparse
      subcommand flags only parse after their subcommand.
    • Never emits a JSON `null`: fields left unset are omitted from the
      `jsonld` object entirely rather than serialised as `null`.
    • A REQUIRED flag omitted → `{"status":"error","reason":"bad_usage"}`,
      exit 2 (bad usage, like every other verb). A required flag GIVEN but
      empty (argparse cannot catch that) → `{"status":"degraded",...}`,
      exit 0 — fail-open, never a traceback.
 fetch.sh content_quality [--file <path.txt>] < text_on_stdin
  → {"status":"ok","source":"content_quality","filler_score":0,"ai_pattern_score":0,
     "information_density":1.0,"overall_quality":90,"flags":[],
     "matches":{"filler":[],"ai_patterns":[]}}
  → {"status":"degraded","reason":"empty_input"|"<file error>"}
  fetch.sh content_quality --file article.txt
  printf '%s' "$BODY_TEXT" | fetch.sh content_quality
  Adapted from claude-seo's `content_quality.py` (MIT) into this contract.
  100% deterministic — regex/word-lists (QRG §4.6 filler phrases + a
  Wikipedia "AI Cleanup" catalogue of LLM-typical phrasings, CC BY-SA 4.0),
  no LLM call, no network. Reads the text to score from `--file <path>` or,
  when `--file` is `-` or omitted, from stdin — the same idiom `score.py`
  uses for `--findings`.
    • **ADVISORY, NOT A VERDICT.** The output never claims "this text is
      AI-written" — modern generative tools can pass every heuristic here,
      and human writers use some of these phrases too. `flags` are
      candidates for HUMAN REVIEW, never an automatic finding. geo-analyzer
      STEP 8 (Content Shape for AI) treats `overall_quality`/`flags` as ONE
      measured input that INFORMS the axis; the axis itself stays an LLM
      judgement (30/70, Definition Lead), never replaced by this score.
    • `filler_score`/`ai_pattern_score` (0-100, higher = worse) count
      phrase-list hits scaled per 1000 tokens; `information_density`
      (0.0-1.0) is entities + numbers per 100 tokens; `overall_quality`
      (0-100, higher is better) is the weighted composite (also folds in a
      bigram-repetition penalty even though that score isn't itself a
      top-level field). `flags` fires at fixed thresholds: `filler`,
      `ai-patterns`, `low-density`, `repetitive`.
    • Stdlib only (argparse/json/re/sys/collections/typing) — runs even
      without the venv. Empty/whitespace-only input degrades rather than
      returning a false zero-value "ok": an empty analysis is not a result.
    • This is filler/AI-pattern SHAPE, not fact-checking — a text can be
      dense and well-cited yet still wrong; that stays a human/LLM call.
 fetch.sh drift --url https://ex.com/sitemap.xml [--max 500]
  → {"status":"ok","baseline":true,"captured":"…","pages":24,"store":"…"}
  → {"status":"ok","baseline":false,"since":"…","gone":[…],"new":[…],
     "regressions":[{"url":…,"field":"canonical","was":"…","now":null}],
     "changes":[{"url":…,"field":"title","was":"…","now":"…"}]}
  On-page drift between audits. seo-analyzer.md:1365 keeps only "date + score
  + key changes" as PROSE the LLM writes about its own previous prose: lossy,
  unreproducible, machine-uncomparable. So "the redesign silently dropped 40
  canonicals" stays invisible. This snapshots title/description/canonical/
  robots/h1_count/jsonld_types per URL and diffs them.
    • NOT rank tracking (the common misread of this feature elsewhere).
      Positions come from GSC `queries`. This is regression detection.
    • Runs over the WHOLE sitemap, never a sample: a drift over a sample that
      changes between runs compares nothing.
    • LOSING a signal = regression. CHANGING one = change, possibly intended —
      the agent judges that, the engine only says which kind it is.
    • Store: ~/.claude/seo-data/drift/<host>.json, 0700, written via
      os.replace — never a half-written baseline. Corrupt store → treated as
      a first run rather than crashing the audit.
 fetch.sh forget --label client-a
  → {"status":"ok","removed":true|false}          # false = label wasn't in the store
@@ -0,0 +1,242 @@
 #!/usr/bin/env python3
 """Deterministic filler / AI-slop content-quality scorer. Stdlib only.
 Adapted from claude-seo (github.com/AgriciDaniel/claude-seo, MIT),
 content_quality.py — rewritten to the lib/seo-data fail-open contract.
 Scores a block of text against three regex/word-list heuristics: padding
 "filler" phrases (QRG §4.6), LLM-typical phrasings ("AI-pattern" list),
 and a measured information density (entities + numbers per token). 100%
 deterministic — no LLM call, no network.
 ADVISORY, NOT A VERDICT. This never claims "this text is AI-written" —
 modern generative tools can pass every heuristic here, and human writers
 use some of these phrases too. A low overall_quality or a filler/
 ai-patterns flag is a candidate for human review, nothing more. In
 geo-analyzer's STEP 8 (Content Shape for AI) it is ONE measured input
 that INFORMS the axis, which stays an LLM judgement (30/70, Definition
 Lead) — never a replacement for it, and never auto-filed as a finding on
 its own.
 Attribution: the AI-pattern list draws from the Wikipedia "AI Cleanup"
 project's catalogue of LLM-typical phrasings (CC BY-SA 4.0), the same
 list claude-seo cites.
 Envelope (see `_cli`)::
    {"status": "ok", "source": "content_quality",
     "filler_score": 0..100,        # higher = more filler-like
     "ai_pattern_score": 0..100,    # higher = more AI-pattern hits
     "information_density": 0.0..1.0,
     "overall_quality": 0..100,     # composite, higher is better
     "flags": ["filler", "ai-patterns", "low-density", "repetitive"],
     "matches": {"filler": [...], "ai_patterns": [...]}}
    {"status": "degraded", "reason": "empty_input" | "<why>"}
 """
 import argparse, json, re, sys
 from collections import Counter
 from typing import Iterable
 # Padding / filler phrases QRG §4.6 flags as "little-to-no value". The
 # lists are the value of this module — kept intact from the source, not
 # trimmed.
 _FILLER_PHRASES = (
    "it's important to note that",
    "in this article, we'll explore",
    "in this article we will explore",
    "in today's fast-paced world",
    "in today's digital age",
    "in today's competitive landscape",
    "needless to say",
    "at the end of the day",
    "when it comes to",
    "when all is said and done",
    "in the realm of",
    "in the world of",
    "the bottom line is",
    "without further ado",
    "first and foremost",
    "last but not least",
    "for what it's worth",
    "it goes without saying",
    "as we all know",
    "the truth is that",
    "the fact of the matter is",
    "more often than not",
    "let's dive in",
    "let's dive into",
    "let's take a closer look",
    "let's take a deeper look",
 )
 # LLM-typical phrasings (Wikipedia AI Cleanup catalogue, CC BY-SA 4.0;
 # also used by claude-seo, MIT). Conservative: only phrases that
 # disproportionately appear in LLM output. Adding to this list should
 # require corpus evidence, not intuition.
 _AI_PATTERNS = (
    "delve into",
    "delve deeper into",
    "in the ever-evolving",
    "ever-evolving landscape",
    "ever-changing landscape",
    "in the dynamic landscape",
    "navigating the",
    "navigate the complexities",
    "tapestry of",
    "rich tapestry",
    "intricate tapestry",
    "embark on a journey",
    "embarking on this",
    "a testament to",
    "a beacon of",
    "the cornerstone of",
    "a cornerstone of",
    "at the heart of",
    "at its core",
    "in essence,",
    "in conclusion,",
    "ultimately,",
    "moreover,",
    "furthermore,",
    "however, it's worth noting",
    "it's worth noting that",
    "by leveraging",
    "leverage the power of",
    "leveraging the power of",
    "harness the power of",
    "unlock the potential",
    "unlock the full potential",
    "the realm of possibilities",
    "open up a world of",
    "a world of possibilities",
    "elevate your",
    "transform your",
    "revolutionize the way",
    "game-changer",
    "game-changing",
    "cutting-edge",
    "state-of-the-art",
    "in summary,",
    "to summarize,",
    "to put it simply,",
    "in a nutshell,",
 )
 _TOKEN_RE = re.compile(r"[A-Za-z][A-Za-z'\-]*")
 _NUMBER_RE = re.compile(r"\b\d+(?:[.,]\d+)?(?:%|st|nd|rd|th)?\b")
 # Capitalised multi-word names: rough proper-noun heuristic. Two or more
 # capitalised tokens in a row count as one entity.
 _ENTITY_RE = re.compile(r"\b(?:[A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b")
 def _count_phrase_hits(text: str, patterns: Iterable[str]) -> list:
    """Patterns that appear at least once in text (case-insensitive)."""
    lowered = text.lower()
    return [p for p in patterns if p in lowered]
 def _repetition_score(tokens):
    """Bigram repetition: fraction of bigrams that recur more than once."""
    if len(tokens) < 4:
        return 0.0
    bigrams = [tokens[i] + " " + tokens[i + 1] for i in range(len(tokens) - 1)]
    counts = Counter(bigrams)
    repeated = sum(1 for v in counts.values() if v > 1)
    return repeated / max(1, len(counts))
 def analyse(text):
    """Score text against the filler / AI-pattern / density / repetition
    heuristics. Advisory only — see module docstring."""
    tokens = [t.lower() for t in _TOKEN_RE.findall(text)]
    n_tokens = len(tokens)
    filler_hits = _count_phrase_hits(text, _FILLER_PHRASES)
    ai_hits = _count_phrase_hits(text, _AI_PATTERNS)
    # Density: entities + numbers per 100 tokens. A high-density article
    # (case studies, data journalism) lands at ~5+; generic filler <2.
    entities = len(_ENTITY_RE.findall(text))
    numbers = len(_NUMBER_RE.findall(text))
    density_per_100 = (entities + numbers) * 100.0 / max(1, n_tokens)
    information_density = min(1.0, density_per_100 / 10.0)
    rep_score = int(round(_repetition_score(tokens) * 100))
    # Scale to per-1000 tokens so the score is comparable across lengths.
    scale = max(1.0, n_tokens / 1000.0)
    filler_score = min(100, int(round(len(filler_hits) / scale * 25)))
    ai_pattern_score = min(100, int(round(len(ai_hits) / scale * 15)))
    flags = []
    if filler_score >= 50:
        flags.append("filler")
    if ai_pattern_score >= 40:
        flags.append("ai-patterns")
    if information_density < 0.20:
        flags.append("low-density")
    if rep_score >= 30:
        flags.append("repetitive")
    # Composite: invert penalty signals, weight by impact. Same weights
    # as the source — the length bonus caps at 1000 tokens.
    overall = (
        (100 - filler_score) * 0.25
        + (100 - ai_pattern_score) * 0.25
        + information_density * 100 * 0.25
        + (100 - rep_score) * 0.15
        + min(100, n_tokens / 10.0) * 0.10
    )
    return {
        "filler_score": filler_score,
        "ai_pattern_score": ai_pattern_score,
        "information_density": round(information_density, 3),
        "overall_quality": int(round(overall)),
        "flags": flags,
        "matches": {"filler": filler_hits, "ai_patterns": ai_hits},
    }
 def _build_parser():
    p = argparse.ArgumentParser(
        description="Deterministic filler / AI-slop content-quality scorer."
    )
    p.add_argument("--store", default=None)   # accepted+ignored (dispatch)
    p.add_argument(
        "--file", default="-",
        help="Path to a text file, or - for stdin (default -).",
    )
    return p
 def _read_input(path):
    """Read the analysis target from stdin ('-'/omitted) or a plain file.
    Plain `open()` only — no pathlib, to stay stdlib-minimal per contract."""
    if path in (None, "-"):
        return sys.stdin.read()
    return open(path, encoding="utf-8", errors="replace").read()
 def _cli():
    try:
        args = _build_parser().parse_args()
        text = _read_input(args.file)
        if not text or not text.strip():
            print(json.dumps({"status": "degraded", "reason": "empty_input"}))
            return
        envelope = {"status": "ok", "source": "content_quality"}
        envelope.update(analyse(text))
        print(json.dumps(envelope, indent=2))
    except SystemExit as e:
        if e.code not in (0, None):
            print(json.dumps({"status": "error", "reason": "bad_usage"}))
        raise
    except Exception as e:
        # Fail-open: a missing --file, an unreadable/binary file, or any
        # other unexpected error degrades rather than crashing the caller.
        print(json.dumps({"status": "degraded", "reason": str(e)}))
 if __name__ == "__main__":
    _cli()
@@ -0,0 +1,184 @@
 #!/usr/bin/env python3
 """On-page drift between audits. Stdlib only.
 seo-analyzer.md:1365 says "on re-run, move current content to Historique
 (summary: date + score + key changes)". That is prose the LLM writes about its
 own previous prose: lossy, unreproducible, and machine-uncomparable. So "the
 redesign silently dropped 40 canonicals" is invisible unless someone happens
 to notice.
 This snapshots the machine-readable signals per URL and diffs them.
 NOT rank tracking — a common misread of the same feature elsewhere. Positions
 come from GSC (`queries`). This is on-page regression detection: what the site
 said last time vs now.
 Runs over the WHOLE sitemap, never a sample: a drift over a sample that
 changes between runs compares nothing.
 """
 import argparse, json, os, re, time
 from html.parser import HTMLParser
 import sitemap as sm
 STORE_DIR = os.path.expanduser("~/.claude/seo-data/drift")
 MAX_PAGES = 500
 # Losing a signal is a regression. Changing one may be intentional — the agent
 # judges that, we only report which kind it is.
 TRACKED = ("title", "description", "canonical", "robots", "h1_count", "jsonld_types")
 class _Signals(HTMLParser):
    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.title, self.description, self.canonical, self.robots = None, None, None, None
        self.h1_count, self.jsonld_types = 0, []
        self._in_title, self._in_ld = False, False
    def handle_starttag(self, tag, attrs):
        a = dict(attrs)
        if tag == "title":
            self._in_title = True
        elif tag == "h1":
            self.h1_count += 1
        elif tag == "meta":
            n = (a.get("name") or "").lower()
            if n == "description":
                self.description = (a.get("content") or "").strip() or None
            elif n == "robots":
                self.robots = (a.get("content") or "").strip() or None
        elif tag == "link" and "canonical" in (a.get("rel") or "").lower():
            self.canonical = (a.get("href") or "").strip() or None
        elif tag == "script" and a.get("type") == "application/ld+json":
            self._in_ld = True
    def handle_endtag(self, tag):
        if tag == "title":
            self._in_title = False
        elif tag == "script":
            self._in_ld = False
    def handle_data(self, data):
        if self._in_title and data.strip():
            self.title = re.sub(r"\s+", " ", data.strip())
        elif self._in_ld:
            self.jsonld_types.extend(re.findall(r'"@type"\s*:\s*"([^"]+)"', data))
 def _signals(html):
    p = _Signals()
    try:
        p.feed(html)
    except Exception:
        pass
    return {"title": p.title, "description": p.description,
            "canonical": p.canonical, "robots": p.robots,
            "h1_count": p.h1_count, "jsonld_types": sorted(set(p.jsonld_types))}
 def _mock_pages():
    """{url: html}, same convention as linkgraph: a single page.html fixture
    cannot express a multi-page snapshot — every URL would look identical."""
    raw = sm._mock("pages.json")
    return json.loads(raw.decode("utf-8")) if raw else None
 def _capture(urls):
    pages = _mock_pages()
    snap, failed = {}, 0
    for u in urls:
        if pages is not None:
            html = pages.get(u)
            if html is None:
                failed += 1
                continue
        else:
            try:
                html = sm._fetch(u).decode("utf-8", "replace")
            except Exception:
                failed += 1
                continue
        snap[u] = _signals(html)
    return snap, failed
 def _store_path(sitemap_url):
    from urllib.parse import urlparse
    host = urlparse(sitemap_url).netloc.lower()
    safe = re.sub(r"[^a-z0-9.-]", "_", host) or "unknown"
    return os.path.join(STORE_DIR, safe + ".json")
 def _load(path):
    if not os.path.exists(path):
        return None
    try:
        with open(path, encoding="utf-8") as f:
            return json.load(f)
    except Exception:
        return None                        # corrupt store -> treat as first run
 def _save(path, snap, stamp):
    os.makedirs(os.path.dirname(path), mode=0o700, exist_ok=True)
    tmp = path + ".tmp"
    with open(tmp, "w", encoding="utf-8") as f:
        json.dump({"captured": stamp, "pages": snap}, f)
    os.replace(tmp, path)                  # atomic: never a half-written baseline
 def _classify(old, new):
    """LOST a signal = regression. Changed it = change. Only the first is
    unambiguous; the agent judges the rest."""
    regressions, changes = [], []
    for f in TRACKED:
        o, n = old.get(f), new.get(f)
        if o == n:
            continue
        row = {"field": f, "was": o, "now": n}
        # Covers every tracked field uniformly: "Titre" -> None, 1 -> 0,
        # ["Article"] -> []. Had the value, lost the value.
        (regressions if (o and not n) else changes).append(row)
    return regressions, changes
 def drift(sitemap_url, max_pages=MAX_PAGES):
    sm_res = sm.sitemap(sitemap_url)
    if sm_res.get("status") != "ok":
        return sm_res
    urls = sm_res["urls"][:max_pages]
    snap, failed = _capture(urls)
    if not snap:
        return {"status": "degraded", "reason": "no_pages_fetched"}
    stamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
    path = _store_path(sitemap_url)
    prev = _load(path)
    _save(path, snap, stamp)
    if prev is None:
        return {"status": "ok", "baseline": True, "captured": stamp,
                "pages": len(snap), "pages_failed": failed, "store": path}
    old = prev.get("pages", {})
    regressions, changes = [], []
    for u, new in snap.items():
        if u not in old:
            continue
        r, c = _classify(old[u], new)
        for row in r:
            regressions.append(dict(row, url=u))
        for row in c:
            changes.append(dict(row, url=u))
    return {"status": "ok", "baseline": False,
            "since": prev.get("captured"), "captured": stamp,
            "pages": len(snap), "pages_failed": failed,
            "gone": sorted(set(old) - set(snap)),
            "new": sorted(set(snap) - set(old)),
            "regressions": regressions, "changes": changes, "store": path}
 def _cli():
    try:
        p = argparse.ArgumentParser()
        p.add_argument("--url", required=True, help="sitemap URL")
        p.add_argument("--max", type=int, default=MAX_PAGES)
        p.add_argument("--store", default=None)   # accepted+ignored
        args = p.parse_args()
        print(json.dumps(drift(args.url, args.max), indent=2))
    except SystemExit as e:
        if e.code not in (0, None):
            print(json.dumps({"status": "error", "reason": "bad_usage"}))
        raise
    except Exception:
        print(json.dumps({"status": "degraded", "reason": "unexpected_error"}))
 if __name__ == "__main__":
    _cli()
@@ -27,8 +27,23 @@ _label_safe() ( LC_ALL=C; case "$1" in ''|[!A-Za-z0-9]*|*[!A-Za-z0-9._-]*) exit
 cmd="${1:-}"; shift || true
 case "$cmd" in
  accounts) exec "$PY" "$HERE/tokenstore.py" list --file "$STORE" ;;
-  crux|queries|inspect)
+  crux|queries|inspect|cannibal)
    exec "$PY" "$HERE/google_seo.py" "$cmd" --store "$STORE" "$@" ;;
  # No auth, no Google: stdlib-only, runs even without the venv.
  sitemap)
    exec "$PY" "$HERE/sitemap.py" --store "$STORE" "$@" ;;
  score)
    exec "$PY" "$HERE/score.py" --store "$STORE" "$@" ;;
  schema_gen)
    exec "$PY" "$HERE/schema_gen.py" --store "$STORE" "$@" ;;
  content_quality)
    exec "$PY" "$HERE/content_quality.py" --store "$STORE" "$@" ;;
  drift)
    exec "$PY" "$HERE/drift.py" --store "$STORE" "$@" ;;
  rendercheck)
    exec "$PY" "$HERE/render_check.py" --store "$STORE" "$@" ;;
  linkgraph)
    exec "$PY" "$HERE/linkgraph.py" --store "$STORE" "$@" ;;
  forget)
    # forget --label <label> → drop one account; forget --all → empty the store.
    # Local removal only — does NOT revoke the grant at Google's end.
@@ -41,6 +56,6 @@ case "$cmd" in
    fi
    echo '{"status":"error","reason":"usage: fetch.sh forget {--label <label>|--all} (label charset: A-Za-z0-9._-)"}'
    exit 2 ;;
-  *) echo '{"status":"error","reason":"usage: fetch.sh {accounts|crux|queries|inspect|forget} [flags]"}'
+  *) echo '{"status":"error","reason":"usage: fetch.sh {accounts|crux|queries|inspect|cannibal|sitemap|rendercheck|linkgraph|drift|score|schema_gen|content_quality|forget} [flags]"}'
     exit 2 ;;
 esac
@@ -0,0 +1,7 @@
 {"rows":[
  {"keys":["plombier paris","https://ex.com/plombier"],"clicks":40,"impressions":900,"ctr":0.044,"position":6.3},
  {"keys":["plombier paris","https://ex.com/services/plomberie"],"clicks":3,"impressions":300,"ctr":0.010,"position":14.1},
  {"keys":["urgence fuite","https://ex.com/urgence"],"clicks":5,"impressions":1200,"ctr":0.004,"position":8.9},
  {"keys":["urgence fuite","https://ex.com/blog/fuite-que-faire"],"clicks":2,"impressions":800,"ctr":0.003,"position":11.4},
  {"keys":["urgence fuite","https://ex.com/services/depannage"],"clicks":1,"impressions":400,"ctr":0.002,"position":19.2},
  {"keys":["devis plomberie","https://ex.com/devis"],"clicks":9,"impressions":150,"ctr":0.060,"position":4.1}]}
@@ -0,0 +1,5 @@
 {
  "https://ex.com/": "<html><head><title>Accueil</title><meta name='description' content='desc'><link rel='canonical' href='https://ex.com/'><script type='application/ld+json'>{\"@type\":\"LocalBusiness\"}</script></head><body><h1>Accueil</h1></body></html>",
  "https://ex.com/a": "<html><head><title>Page A</title><link rel='canonical' href='https://ex.com/a'></head><body><h1>A</h1></body></html>",
  "https://ex.com/gone": "<html><head><title>Bientot supprimee</title></head><body><h1>G</h1></body></html>"
 }
@@ -0,0 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url><loc>https://ex.com/</loc></url>
  <url><loc>https://ex.com/a</loc></url>
  <url><loc>https://ex.com/gone</loc></url>
 </urlset>
@@ -0,0 +1,5 @@
 {
  "https://ex.com/": "<html><head><title>Accueil refondue</title><meta name='description' content='desc'><link rel='canonical' href='https://ex.com/'></head><body><p>plus de h1, plus de jsonld</p></body></html>",
  "https://ex.com/a": "<html><head><title>Page A</title></head><body><h1>A</h1></body></html>",
  "https://ex.com/neuve": "<html><head><title>Neuve</title></head><body><h1>N</h1></body></html>"
 }
@@ -0,0 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url><loc>https://ex.com/</loc></url>
  <url><loc>https://ex.com/a</loc></url>
  <url><loc>https://ex.com/neuve</loc></url>
 </urlset>
@@ -0,0 +1,9 @@
 {
  "https://ex.com/": "<html><body><a href='/a'>a</a> <a href='/b/'>b trailing slash</a> <a href='#top'>anchor</a> <a href='/css/main.css?v=9'>asset</a> <a href='mailto:x@ex.com'>mail</a> <a href='tel:+33'>tel</a> <a href='https://other.com/x'>external</a> <a href='/img/logo.png'>img</a></body></html>",
  "https://ex.com/a": "<html><body><a href='/'>home</a> <a href='/deep'>deep</a></body></html>",
  "https://ex.com/b": "<html><body><a href='/'>home</a></body></html>",
  "https://ex.com/deep": "<html><body><a href='https://ex.com/deeper'>deeper absolute</a></body></html>",
  "https://ex.com/deeper": "<html><body><a href='deepest'>relative</a></body></html>",
  "https://ex.com/deepest": "<html><body><a href='/'>home</a></body></html>",
  "https://ex.com/orphan": "<html><body><a href='/'>home — links out, nobody links in</a></body></html>"
 }
@@ -0,0 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url><loc>https://ex.com/</loc></url>
  <url><loc>https://ex.com/a</loc></url>
  <url><loc>https://ex.com/b</loc></url>
  <url><loc>https://ex.com/deep</loc></url>
  <url><loc>https://ex.com/deeper</loc></url>
  <url><loc>https://ex.com/deepest</loc></url>
  <url><loc>https://ex.com/orphan</loc></url>
 </urlset>
@@ -0,0 +1,2 @@
 {"inspectionResult":{"indexStatusResult":{
  "verdict":"PASS","coverageState":"Submitted and indexed","lastCrawlTime":"2026-07-01T10:00:00Z"}}}
@@ -0,0 +1,10 @@
 <?xml version="1.0"?>
 <!DOCTYPE urlset [
  <!ENTITY lol "lol">
  <!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
  <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
  <!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
 ]>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url><loc>https://ex.com/&lol4;</loc></url>
 </urlset>
@@ -0,0 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <sitemap><loc>https://ex.com/sitemap-pages.xml</loc></sitemap>
  <sitemap><loc>https://ex.com/sitemap-blog.xml</loc></sitemap>
 </sitemapindex>
@@ -0,0 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url><loc>https://ex.com/child-a</loc></url>
  <url><loc>https://ex.com/child-b</loc></url>
 </urlset>
@@ -0,0 +1,8 @@
 <!DOCTYPE html><html lang="fr"><head>
 <title>Mon App</title>
 <script type="module" crossorigin src="/assets/index-a1b2c3.js"></script>
 <link rel="stylesheet" href="/assets/index-d4e5f6.css">
 </head><body>
 <div id="root"></div>
 <script>window.__INITIAL_STATE__={"user":null,"routes":["/","/about","/contact"],"config":{"apiUrl":"https://api.example.com","features":["a","b","c"]}};</script>
 </body></html>
@@ -0,0 +1,8 @@
 <!DOCTYPE html><html lang="fr"><head>
 <title>Lavage auto</title>
 <meta name="description" content="Lavage auto à la main en Seine-et-Marne.">
 <script type="application/ld+json">{"@context":"https://schema.org","@type":"LocalBusiness","name":"X"}</script>
 </head><body>
 <h1>Lavage auto à la main</h1>
 <p>Lavage automobile à la main à Lagny-sur-Marne, detailing et protection céramique. Lavage automobile à la main à Lagny-sur-Marne, detailing et protection céramique. Lavage automobile à la main à Lagny-sur-Marne, detailing et protection céramique. Lavage automobile à la main à Lagny-sur-Marne, detailing et protection céramique. Lavage automobile à la main à Lagny-sur-Marne, detailing et protection céramique. Lavage automobile à la main à Lagny-sur-Marne, detailing et protection céramique. Lavage automobile à la main à Lagny-sur-Marne, detailing et protection céramique. Lavage automobile à la main à Lagny-sur-Marne, detailing et protection céramique.</p>
 </body></html>
@@ -1,2 +1,11 @@
-{"inspectionResult":{"indexStatusResult":{
+{"inspectionResult":{
-  "verdict":"PASS","coverageState":"Submitted and indexed","lastCrawlTime":"2026-07-01T10:00:00Z"}}}
+  "indexStatusResult":{
    "verdict":"PASS","coverageState":"Submitted and indexed","lastCrawlTime":"2026-07-01T10:00:00Z"},
  "richResultsResult":{"verdict":"FAIL","detectedItems":[
    {"richResultType":"Breadcrumbs","items":[{"name":"Unnamed item","issues":[]}]},
    {"richResultType":"FAQ","items":[
      {"name":"Q1","issues":[
        {"issueMessage":"Missing field 'acceptedAnswer'","severity":"ERROR"}]},
      {"name":"Q2","issues":[
        {"issueMessage":"Missing field 'acceptedAnswer'","severity":"ERROR"},
        {"issueMessage":"Unspecified image","severity":"WARNING"}]}]}]}}}
@@ -0,0 +1,25 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
        xmlns:xhtml="http://www.w3.org/1999/xhtml"
        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
  <!-- image:loc also ends with }loc — it must NOT be counted as a page -->
  <url>
    <loc>https://ex.com/</loc>
    <changefreq>weekly</changefreq>
    <xhtml:link rel="alternate" hreflang="en" href="https://ex.com/en/" />
    <image:image>
      <image:loc>https://ex.com/img/logo.png</image:loc>
      <image:title>Logo</image:title>
    </image:image>
    <image:image>
      <image:loc>https://ex.com/img/hero.jpeg</image:loc>
    </image:image>
  </url>
  <url><loc>https://ex.com/services</loc></url>
  <url><loc>https://ex.com/blog</loc></url>
  <url><loc>https://ex.com/blog</loc></url>
  <url><loc>   https://ex.com/spaced   </loc></url>
  <url><loc>ftp://ex.com/nope</loc></url>
  <url><loc>https://ex.com/bad"quote</loc></url>
  <url><loc></loc></url>
 </urlset>
@@ -89,13 +89,16 @@ def _gsc_session(store_path, account):
    return AuthorizedSession(creds)
 def _norm_queries(raw, dim):
    # `keys` is the list the API actually returns (one entry per requested
    # dimension); `key` stays as keys[0] so the single-dim consumer that reads
    # it keeps working. Additive — nothing to migrate.
    return {"status": "ok", "source": "gsc", "dimension": dim, "rows": [
-        {"key": r["keys"][0], "clicks": r.get("clicks", 0),
+        {"key": r["keys"][0], "keys": r["keys"], "clicks": r.get("clicks", 0),
         "impressions": r.get("impressions", 0), "ctr": r.get("ctr", 0),
         "position": r.get("position")}
        for r in raw.get("rows", [])]}
-def queries(store_path, account, property, days=90, dim="query"):
+def queries(store_path, account, property, days=90, dim="query", rows=100):
    raw = _mock("gsc_queries.json")
    if raw is None:
        sess = _gsc_session(store_path, account)
@@ -106,14 +109,89 @@ def queries(store_path, account, property, days=90, dim="query"):
        import urllib.parse
        url = ("https://searchconsole.googleapis.com/webmasters/v3/sites/"
               + urllib.parse.quote(property, safe="") + "/searchAnalytics/query")
        # dim accepts a comma-separated list: the API groups by several
        # dimensions at once ("no limit... but you cannot group by the same
        # dimension twice"), and query+page is what exposes cannibalisation.
        dims = [d.strip() for d in dim.split(",") if d.strip()]
        r = sess.post(url, json={"startDate": start.isoformat(), "endDate": end.isoformat(),
-                                 "dimensions": [dim], "rowLimit": 100}, timeout=30)
+                                 "dimensions": dims, "rowLimit": rows}, timeout=30)
        if r.status_code == 429:
            return {"status": "degraded", "reason": "rate_limited"}
        r.raise_for_status()
        raw = r.json()
    return _norm_queries(raw, dim)
 def _rollup_issues(items):
    """Count issue instances by severity; dedupe messages (they repeat per item)."""
    errors = warnings = 0
    msgs = []
    for item in items:
        for iss in item.get("issues", []):
            sev = iss.get("severity")
            if sev == "ERROR":
                errors += 1
            elif sev == "WARNING":
                warnings += 1
            msg = iss.get("issueMessage")
            if msg and msg not in msgs:
                msgs.append(msg)
    return errors, warnings, msgs
 def _norm_rich(ir):
    """richResultsResult → verdict + per-type rollup. Google OMITS the key when
    it detects no rich results, so absence is data, not an error: surfaced as the
    synthetic verdict ABSENT (not a Google enum) rather than a missing key, which
    a caller cannot tell apart from a check that never ran. PARTIAL is never
    emitted — the API reserves it as unused."""
    rr = ir.get("richResultsResult")
    if rr is None:
        return {"verdict": "ABSENT", "types": []}
    types = []
    for det in rr.get("detectedItems", []):
        errors, warnings, msgs = _rollup_issues(det.get("items", []))
        types.append({"type": det.get("richResultType"),
                      "items": len(det.get("items", [])),
                      "errors": errors, "warnings": warnings, "issues": msgs})
    return {"verdict": rr.get("verdict"), "types": types}
 def _group_by_query(rows):
    """query+page rows -> {query: [row, …]}. Deterministic aggregation, not
    judgement: the agent must not be asked to group 1000 rows by eye."""
    by_q = {}
    for r in rows:
        keys = r.get("keys") or []
        if len(keys) < 2:
            continue
        by_q.setdefault(keys[0], []).append(
            {"url": keys[1], "clicks": r["clicks"],
             "impressions": r["impressions"], "position": r["position"]})
    return by_q
 def cannibal(store_path, account, property, days=90, rows=1000):
    """Queries where 2+ of our own pages compete for the same term.
    Google's own data says it; nothing in this system asked. Cannibalisation
    is a SERP fact, not a content-similarity guess — do not confuse it with
    the 30/70 duplication rule, which has no data source here."""
    res = queries(store_path, account, property, days, "query,page", rows)
    if res.get("status") != "ok":
        return res
    conflicts = []
    for q, pages in _group_by_query(res["rows"]).items():
        if len(pages) < 2:
            continue
        pages.sort(key=lambda p: p["impressions"], reverse=True)
        conflicts.append({"query": q, "pages": len(pages),
                          "total_impressions": sum(p["impressions"] for p in pages),
                          "urls": pages})
    conflicts.sort(key=lambda c: c["total_impressions"], reverse=True)
    return {"status": "ok", "source": "gsc", "days": days,
            "rows_scanned": len(res["rows"]),
            # rows_scanned == rows means the window was FULL: there may be more
            # conflicts past the cut. Reported, never silently truncated.
            "capped": len(res["rows"]) >= rows,
            "conflict_count": len(conflicts), "conflicts": conflicts}
 def inspect(store_path, account, property, url):
    raw = _mock("gsc_inspect.json")
    if raw is None:
@@ -126,11 +204,15 @@ def inspect(store_path, account, property, url):
            return {"status": "degraded", "reason": "rate_limited"}
        r.raise_for_status()
        raw = r.json()
-    isr = raw["inspectionResult"]["indexStatusResult"]
+    ir = raw["inspectionResult"]
    isr = ir["indexStatusResult"]
    # rich_results rides the SAME response — Google already sent it and this
    # function used to discard it. No extra call, no extra quota, no new scope.
    return {"status": "ok", "source": "gsc",
            "indexed": isr.get("verdict") == "PASS",
            "coverage": isr.get("coverageState"),
-            "last_crawl": isr.get("lastCrawlTime")}
+            "last_crawl": isr.get("lastCrawlTime"),
            "rich_results": _norm_rich(ir)}
 def _cli():
    try:
@@ -145,7 +227,15 @@ def _cli():
        pq.add_argument("--account", required=True)
        pq.add_argument("--property", required=True)
        pq.add_argument("--days", type=int, default=90)
-        pq.add_argument("--dim", default="query")
+        pq.add_argument("--dim", default="query",
                        help="one dimension, or a comma-separated list (query,page)")
        pq.add_argument("--rows", type=int, default=100)
        pn = sub.add_parser("cannibal")
        pn.add_argument("--store", required=True)
        pn.add_argument("--account", required=True)
        pn.add_argument("--property", required=True)
        pn.add_argument("--days", type=int, default=90)
        pn.add_argument("--rows", type=int, default=1000)
        pi = sub.add_parser("inspect")
        pi.add_argument("--store", required=True)
        pi.add_argument("--account", required=True)
@@ -156,7 +246,10 @@ def _cli():
            print(json.dumps(crux(args.url, args.strategy), indent=2))
        elif args.cmd == "queries":
            print(json.dumps(queries(args.store, args.account, args.property,
-                                      args.days, args.dim), indent=2))
+                                      args.days, args.dim, args.rows), indent=2))
        elif args.cmd == "cannibal":
            print(json.dumps(cannibal(args.store, args.account, args.property,
                                       args.days, args.rows), indent=2))
        elif args.cmd == "inspect":
            print(json.dumps(inspect(args.store, args.account, args.property,
                                      args.url), indent=2))
@@ -0,0 +1,170 @@
 #!/usr/bin/env python3
 """Internal link graph -> orphans + click depth. Stdlib only.
 seo-analyzer.md asks "Every important page reachable within 3 clicks?" (:613)
 and "Orphan pages (no inbound internal links)?" (:616) and has never had a
 command that answers either. This is that command.
 EXHAUSTIVE OR NOTHING. You cannot sample orphans: proving a page has no
 inbound link means having read every other page. A partial crawl invents
 orphans, and "page X has no inbound links" when it does is the worst finding
 this tool could emit — it sends a client fixing what is not broken. So when
 the cap bites, orphans are WITHHELD, not truncated.
 Does NOT render JS. On a client-side-rendered SPA the links are not in the
 HTML, every page looks orphaned, and that is a catastrophic false positive —
 so an empty link graph is REFUSED (no_links_in_html), never reported.
 """
 import argparse, json
 from html.parser import HTMLParser
 from urllib.parse import urljoin, urlparse, urldefrag
 import sitemap as sm                      # sibling module: fetch + parse
 MAX_PAGES = 500
 # Extensions that are assets, not pages. Seen live: /css/main.css?v=1778157313
 ASSET_EXT = (".css", ".js", ".mjs", ".png", ".jpg", ".jpeg", ".gif", ".webp",
             ".avif", ".svg", ".ico", ".woff", ".woff2", ".ttf", ".eot",
             ".pdf", ".zip", ".mp4", ".webm", ".xml", ".json", ".txt", ".rss")
 class _Links(HTMLParser):
    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.hrefs = []
    def handle_starttag(self, tag, attrs):
        if tag != "a":
            return
        for k, v in attrs:
            if k == "href" and v:
                self.hrefs.append(v)
 def _norm(u):
    """Canonical form for graph identity. Drops the fragment, keeps the query
    (?p=2 IS a different page), and unifies the trailing slash so /blog and
    /blog/ are one node rather than a phantom orphan pair."""
    u = urldefrag(u)[0]
    p = urlparse(u)
    path = p.path or "/"
    if len(path) > 1 and path.endswith("/"):
        path = path[:-1]
    out = "%s://%s%s" % (p.scheme, p.netloc.lower(), path)
    return out + ("?" + p.query if p.query else "")
 def _page_links(base, html, host):
    """Internal page links from one document. Filters what a link graph must
    never contain: assets, #anchors, mailto:/tel:, and other hosts."""
    p = _Links()
    try:
        p.feed(html)
    except Exception:
        pass                               # tolerate malformed markup
    out = set()
    for h in p.hrefs:
        h = h.strip()
        if not h or h.startswith(("#", "mailto:", "tel:", "javascript:", "data:")):
            continue
        absu = urljoin(base, h)
        pr = urlparse(absu)
        if pr.scheme not in ("http", "https") or pr.netloc.lower() != host:
            continue
        if pr.path.lower().endswith(ASSET_EXT):
            continue
        out.add(_norm(absu))
    return out
 def _mock_pages():
    """{url: html} for tests. A single page.html fixture cannot express a
    GRAPH — every node would carry identical links — so the mock is a map."""
    raw = sm._mock("pages.json")
    return json.loads(raw.decode("utf-8")) if raw else None
 def _crawl(urls, host):
    """Fetch each page once; return {page: {links}} plus a failure count."""
    pages = _mock_pages()
    graph, failed = {}, 0
    for u in urls:
        if pages is not None:
            html = pages.get(u)
            if html is None:
                failed += 1
                continue
        else:
            try:
                html = sm._fetch(u).decode("utf-8", "replace")
            except Exception:
                failed += 1
                continue
        graph[_norm(u)] = _page_links(u, html, host)
    return graph, failed
 def _depths(graph, root):
    """BFS click-depth from the homepage. Absent = unreachable by links."""
    seen, frontier, d = {root: 0}, [root], 0
    while frontier:
        d += 1
        nxt = []
        for node in frontier:
            for tgt in graph.get(node, ()):
                if tgt not in seen:
                    seen[tgt] = d
                    nxt.append(tgt)
        frontier = nxt
    return seen
 def linkgraph(sitemap_url, max_pages=MAX_PAGES):
    sm_res = sm.sitemap(sitemap_url)
    if sm_res.get("status") != "ok":
        return sm_res                      # propagate the sitemap's own degrade
    urls = sm_res["urls"]
    capped = len(urls) > max_pages
    host = urlparse(urls[0]).netloc.lower()
    graph, failed = _crawl(urls[:max_pages], host)
    if not graph:
        return {"status": "degraded", "reason": "no_pages_fetched"}
    total_links = sum(len(v) for v in graph.values())
    if total_links == 0:
        # Every page orphaned is never the truth — it is a JS-rendered site.
        return {"status": "degraded", "reason": "no_links_in_html",
                "pages_crawled": len(graph),
                "hint": "links absent from served HTML (SPA?) — see R1/R2"}
    inbound = {n: 0 for n in graph}
    for src, tgts in graph.items():
        for t in tgts:
            if t in inbound and t != src:
                inbound[t] += 1
    root = _norm("%s://%s/" % (urlparse(urls[0]).scheme, host))
    depth = _depths(graph, root)
    out = {"status": "ok", "source": "linkgraph",
           "pages_crawled": len(graph), "pages_failed": failed,
           "total_internal_links": total_links, "capped": capped,
           "max_depth": max(depth.values()) if depth else 0,
           "beyond_3_clicks": sorted(n for n, d in depth.items() if d > 3),
           "unreachable": sorted(n for n in graph if n not in depth)}
    if capped or failed:
        # A page can only be called orphaned if EVERY other page was read.
        out["orphans_withheld"] = True
        out["reason_withheld"] = ("crawl incomplete (capped=%s, failed=%d) — "
                                  "an orphan from a partial crawl is a false "
                                  "orphan" % (capped, failed))
    else:
        out["orphans"] = sorted(n for n, c in inbound.items()
                                if c == 0 and n != root)
    return out
 def _cli():
    try:
        p = argparse.ArgumentParser()
        p.add_argument("--url", required=True, help="sitemap URL")
        p.add_argument("--max", type=int, default=MAX_PAGES)
        p.add_argument("--store", default=None)   # accepted+ignored
        args = p.parse_args()
        print(json.dumps(linkgraph(args.url, args.max), indent=2))
    except SystemExit as e:
        if e.code not in (0, None):
            print(json.dumps({"status": "error", "reason": "bad_usage"}))
        raise
    except Exception:
        print(json.dumps({"status": "degraded", "reason": "unexpected_error"}))
 if __name__ == "__main__":
    _cli()
@@ -0,0 +1,106 @@
 #!/usr/bin/env python3
 """Is the content in the served HTML, or painted by JS? Stdlib only.
 seo-analyzer records `RENDERING: SSR/SSG/SPA/hybrid` and then does nothing
 with it. That is the gap this closes. On a client-rendered site `curl` returns
 an empty shell, so every meta/H1/JSON-LD check reports "missing" and the audit
 emits a page of false findings against a site that may be perfectly fine.
 The verdict is taken from what the server actually sent — not from guessing at
 package.json, where a React SPA and a Next.js SSR app look identical.
 R2, not R1: this REPORTS blindness so the agent can refuse to score. It does
 not render JS. No Playwright, no Chromium, no venv.
 """
 import argparse, json, re
 from html.parser import HTMLParser
 import sitemap as sm                       # sibling: _fetch / _mock
 # A shell can still carry a title + a couple of nav words. These thresholds
 # separate "shell" from "page" on the two real sites measured 2026-07-17
 # (server-rendered: 1 h1, thousands of body chars) and on a hydration stub.
 MIN_TEXT = 400
 MIN_H1 = 1
 class _Doc(HTMLParser):
    """Collect body text and the tags an SEO audit reads. Script/style content
    is NOT text: a 200 KB React bundle would otherwise look like a rich page."""
    SKIP = ("script", "style", "noscript", "template", "svg")
    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.text, self.h1, self.jsonld, self.meta_desc = [], 0, 0, False
        self._skip = 0
        self._ld = False
    def handle_starttag(self, tag, attrs):
        a = dict(attrs)
        if tag in self.SKIP:
            self._skip += 1
            self._ld = tag == "script" and a.get("type") == "application/ld+json"
        elif tag == "h1":
            self.h1 += 1
        elif tag == "meta" and a.get("name", "").lower() == "description":
            self.meta_desc = bool((a.get("content") or "").strip())
    def handle_endtag(self, tag):
        if tag in self.SKIP and self._skip:
            self._skip -= 1
            self._ld = False
    def handle_data(self, data):
        if self._ld:
            self.jsonld += 1
        elif not self._skip:
            s = data.strip()
            if s:
                self.text.append(s)
 def _verdict(text_chars, h1, jsonld):
    if text_chars >= MIN_TEXT and h1 >= MIN_H1:
        return "server-rendered"
    if text_chars < MIN_TEXT and h1 == 0 and jsonld == 0:
        return "client-rendered"
    return "partial"                       # shell + some SSR'd head, or thin page
 def render_check(url):
    raw = sm._mock("page.html")
    if raw is None:
        try:
            raw = sm._fetch(url)
        except Exception:
            return {"status": "degraded", "reason": "fetch_failed"}
    html = raw.decode("utf-8", "replace")
    d = _Doc()
    try:
        d.feed(html)
    except Exception:
        pass                               # tolerate malformed markup
    text = re.sub(r"\s+", " ", " ".join(d.text)).strip()
    verdict = _verdict(len(text), d.h1, d.jsonld)
    out = {"status": "ok", "source": "render_check", "verdict": verdict,
           "body_text_chars": len(text), "h1_in_html": d.h1,
           "jsonld_in_html": d.jsonld, "meta_description_in_html": d.meta_desc,
           "html_bytes": len(raw)}
    if verdict != "server-rendered":
        out["warning"] = ("content is not in the served HTML — curl-based "
                          "on-page checks will report false 'missing' findings")
    return out
 def _cli():
    try:
        p = argparse.ArgumentParser()
        p.add_argument("--url", required=True)
        p.add_argument("--store", default=None)   # accepted+ignored
        args = p.parse_args()
        print(json.dumps(render_check(args.url), indent=2))
    except SystemExit as e:
        if e.code not in (0, None):
            print(json.dumps({"status": "error", "reason": "bad_usage"}))
        raise
    except Exception:
        print(json.dumps({"status": "degraded", "reason": "unexpected_error"}))
 if __name__ == "__main__":
    _cli()
@@ -0,0 +1,164 @@
 #!/usr/bin/env python3
 """SSRF- and DNS-rebinding-safe HTTP(S) fetch. Stdlib only.
 The verbs that fetch remote content (sitemap, linkgraph, render_check, drift)
 all route through sitemap._fetch, which used urllib.request.urlopen. urlopen
 resolves the host, then connects — two DNS lookups with a window between them.
 A hostile authority can answer PUBLIC to the validation lookup and a PRIVATE
 address (169.254.169.254 cloud metadata, 127.0.0.1, the LAN) to the connect
 lookup. That is DNS rebinding, and a name-level guard cannot see it.
 This collapses the two lookups into one: resolve ONCE, validate every returned
 IP, then connect to the exact validated IP while preserving the Host header,
 TLS SNI, and certificate validation for the real hostname. There is no second
 resolution to poison.
 Better than the reference implementation this idea came from (claude-seo
 url_safety.py, MIT) on three axes, all verified before writing:
 - dual-stack: validates IPv4 AND IPv6 (theirs is IPv4-only);
 - no global state: each connection pins its own socket, so it is thread-safe
  by construction (theirs monkeypatches socket.getaddrinfo behind a global
  lock);
 - stdlib only: http.client + ssl + ipaddress, no `requests`.
 NOT covered, stated rather than left silent: the shell `curl` calls in the
 agent specs (seo-analyzer/geo-analyzer STEP 4, the sameAs loop) run in a
 separate process and cannot be pinned from here. Their surface is smaller
 (a fixed set against an operator-typed/confirmed $DOMAIN). Closing them needs
 `curl --resolve` and is a separate change.
 """
 import gzip
 import http.client
 import ipaddress
 import socket
 import ssl
 from urllib.parse import urljoin, urlparse
 DEFAULT_TIMEOUT = 20
 DEFAULT_MAX_BYTES = 20 * 1024 * 1024
 MAX_REDIRECTS = 5
 class UnsafeTarget(Exception):
    """A URL resolved to a non-public address, or a redirect did. Raised BEFORE
    any connection to that address. Callers already wrap _fetch in try/except
    and degrade, so the fail-open contract is preserved."""
 # Special-use ranges that `is_global` reports as public but are not legitimate
 # fetch targets. 192.88.99.0/24 = RFC 3068 6to4-relay anycast (a security
 # review flagged it 2026-07-17). Grows if more surface.
 _EXTRA_DENY = (ipaddress.ip_network("192.88.99.0/24"),)
 def _ip_is_public(ip_str):
    """A globally routable unicast address, dual-stack. `is_global` is the
    decisive gate — it alone rejects CGNAT (100.64/10) that the per-flag checks
    miss — with the explicit flags plus an extra special-use deny list as
    defence in depth."""
    ip = ipaddress.ip_address(ip_str)
    if not ip.is_global:
        return False
    if any(ip in net for net in _EXTRA_DENY):
        return False
    return not (ip.is_private or ip.is_loopback or ip.is_link_local
                or ip.is_reserved or ip.is_multicast or ip.is_unspecified)
 def _resolve_pinned(host, port, resolver=socket.getaddrinfo):
    """Resolve host ONCE and return [(family, ip)] for connecting. Refuse if
    ANY resolved address is non-public — a name advertising both public and
    private A records is exactly the multi-answer rebinding vector, and a
    legitimate public site does not do it. `resolver` is injected in tests to
    plant a private address and prove the refusal."""
    try:
        infos = resolver(host, port, type=socket.SOCK_STREAM)
    except socket.gaierror as e:
        raise UnsafeTarget("cannot resolve %r: %s" % (host, e))
    pinned = []
    for family, _type, _proto, _canon, sockaddr in infos:
        ip = sockaddr[0]
        if not _ip_is_public(ip):
            raise UnsafeTarget("%s resolves to non-public %s" % (host, ip))
        pinned.append((family, ip))
    if not pinned:
        raise UnsafeTarget("%s resolved to nothing" % host)
    return pinned
 class _PinnedHTTPSConnection(http.client.HTTPSConnection):
    """HTTPS to a pinned IP, with SNI + cert validation for the real host."""
    def __init__(self, host, pinned_ip, family, **kw):
        super().__init__(host, **kw)          # host → Host header + SNI
        self._pinned_ip = pinned_ip
        self._family = family
    def connect(self):
        sock = socket.create_connection((self._pinned_ip, self.port),
                                        timeout=self.timeout)
        # server_hostname = the real host → SNI + hostname check both use it,
        # never the IP.
        self.sock = self._context.wrap_socket(sock, server_hostname=self.host)
 class _PinnedHTTPConnection(http.client.HTTPConnection):
    """Plain HTTP to a pinned IP (Host header stays the real host)."""
    def __init__(self, host, pinned_ip, family, **kw):
        super().__init__(host, **kw)
        self._pinned_ip = pinned_ip
        self._family = family
    def connect(self):
        self.sock = socket.create_connection((self._pinned_ip, self.port),
                                             timeout=self.timeout)
 def _one_request(url, timeout, max_bytes, resolver):
    """One hop: resolve+pin the host, connect, return (status, headers, body)."""
    p = urlparse(url)
    if p.scheme not in ("http", "https"):
        raise UnsafeTarget("scheme must be http/https: %r" % url)
    host = p.hostname
    if not host:
        raise UnsafeTarget("no host in %r" % url)
    port = p.port or (443 if p.scheme == "https" else 80)
    family, ip = _resolve_pinned(host, port, resolver)[0]   # any is public here
    ctx = ssl.create_default_context() if p.scheme == "https" else None
    if p.scheme == "https":
        conn = _PinnedHTTPSConnection(host, ip, family, port=port,
                                      timeout=timeout, context=ctx)
    else:
        conn = _PinnedHTTPConnection(host, ip, family, port=port,
                                     timeout=timeout)
    try:
        path = p.path or "/"
        if p.query:
            path += "?" + p.query
        # No Accept-Encoding: keep HTTP bodies un-gzipped; the .xml.gz
        # content-level case is handled by the caller's magic-byte check.
        conn.request("GET", path, headers={"Host": host,
                                           "User-Agent": "claude-seo-data/1.0"})
        r = conn.getresponse()
        body = r.read(max_bytes)
        return r.status, {k.lower(): v for k, v in r.getheaders()}, body
    finally:
        conn.close()
 def safe_fetch(url, timeout=DEFAULT_TIMEOUT, max_bytes=DEFAULT_MAX_BYTES,
               max_redirects=MAX_REDIRECTS, resolver=socket.getaddrinfo):
    """Fetch url with resolve-then-pin, following redirects and RE-VALIDATING
    each hop — urlopen followed redirects to whatever address the Location
    named, re-opening the rebinding window on every hop. Returns the raw body
    bytes (the caller handles content-level gzip)."""
    seen = 0
    current = url
    while True:
        status, headers, body = _one_request(current, timeout, max_bytes, resolver)
        if status in (301, 302, 303, 307, 308) and "location" in headers:
            seen += 1
            if seen > max_redirects:
                raise UnsafeTarget("too many redirects from %r" % url)
            current = urljoin(current, headers["location"])   # re-validated next loop
            continue
        return body
@@ -0,0 +1,301 @@
 #!/usr/bin/env python3
 """Deterministic JSON-LD generators for four Schema.org types. Stdlib only.
 Adapted from claude-seo (github.com/AgriciDaniel/claude-seo, MIT),
 schema_generate.py — rewritten to the lib/seo-data fail-open contract.
 Everywhere else in this repo we AUDIT existing markup (google_seo.py
 `inspect`, geo-analyzer's JSON-LD rules); this is the one verb that
 GENERATES it. Reservation + potentialAction matter now that AI Mode
 executes restaurant reservations; DiscussionForumPosting is a live SERP
 feature; ProfilePage with sameAs/knowsAbout is the cheapest entity-graph
 builder for AI citation correlation. geo-analyzer's G2 batch calls this
 instead of hand-writing the markup — it only generates STRUCTURE, unknown
 field VALUES stay the caller's `[À COMPLÉTER]` placeholder, never invented
 here.
 """
 import argparse, json
 def reservation(provider, start, *, end=None, party_size=None,
                 reservation_id=None, reservation_for_name=None,
                 customer_name=None, customer_email=None,
                 kind="FoodEstablishmentReservation"):
    """Reservation JSON-LD block. Defaults to FoodEstablishment."""
    payload = {
        "@context": "https://schema.org",
        "@type": kind,
        "reservationStatus": "https://schema.org/ReservationConfirmed",
        "provider": {"@type": "Organization", "name": provider},
        "reservationFor": {
            "@type": "FoodEstablishment"
                     if kind == "FoodEstablishmentReservation" else "Place",
            "name": reservation_for_name or provider,
        },
        "startTime": start,
        "endTime": end,
        "partySize": party_size,
        "reservationId": reservation_id,
    }
    if customer_name or customer_email:
        payload["underName"] = {"@type": "Person", "name": customer_name,
                                 "email": customer_email}
    return payload
 def order_action(merchant, *, order_url, name="Order online",
                  accepted_payment_method=None, delivery_method=None):
    """OrderAction potentialAction block. Attach to a Product/Service via
    {"@type": "Product", "potentialAction": <this dict>}."""
    payload = {
        "@context": "https://schema.org",
        "@type": "OrderAction",
        "name": name,
        "target": {
            "@type": "EntryPoint",
            "urlTemplate": order_url,
            "inLanguage": "en-US",
            "actionPlatform": [
                "https://schema.org/DesktopWebPlatform",
                "https://schema.org/MobileWebPlatform",
            ],
        },
        "deliveryMethod": delivery_method or [
            "https://schema.org/OnSitePickup",
            "https://schema.org/ParcelService",
        ],
        "priceSpecification": {
            "@type": "PriceSpecification",
            "eligibleTransactionVolume": {
                "@type": "PriceSpecification",
                "minPrice": 0,
                "priceCurrency": "USD",
            },
        },
        "merchant": {"@type": "Organization", "name": merchant},
    }
    if accepted_payment_method:
        payload["acceptedPaymentMethod"] = [
            {"@type": "PaymentMethod", "name": m}
            for m in accepted_payment_method
        ]
    return payload
 def discussion(headline, author, *, url, date_published, text=None,
               date_modified=None, interaction_count=None,
               comment_count=None):
    """DiscussionForumPosting JSON-LD block."""
    payload = {
        "@context": "https://schema.org",
        "@type": "DiscussionForumPosting",
        "headline": headline,
        "author": {"@type": "Person", "name": author},
        "datePublished": date_published,
        "dateModified": date_modified,
        "url": url,
        "mainEntityOfPage": {"@type": "WebPage", "@id": url},
        "text": text,
        "commentCount": comment_count,
    }
    if interaction_count:
        payload["interactionStatistic"] = [
            {"@type": "InteractionCounter",
             "interactionType": "https://schema.org/%s" % k,
             "userInteractionCount": v}
            for k, v in interaction_count.items()
        ]
    return payload
 def profile(name, *, url, description=None, same_as=None, knows_about=None,
            works_for=None, image=None, job_title=None):
    """ProfilePage JSON-LD block. sameAs + knowsAbout is the entity-graph
    helper for AI citation correlation — Wikipedia/GitHub/LinkedIn/ORCID
    URLs in sameAs disambiguate the person across knowledge graphs."""
    person = {
        "@type": "Person",
        "name": name,
        "url": url,
        "description": description,
        "sameAs": list(same_as) if same_as else None,
        "knowsAbout": list(knows_about) if knows_about else None,
        "worksFor": {"@type": "Organization", "name": works_for}
                    if works_for else None,
        "image": image,
        "jobTitle": job_title,
    }
    return {"@context": "https://schema.org", "@type": "ProfilePage",
            "mainEntity": person, "url": url}
 def _strip_nones(value):
    """Recursively drop dict keys AND list elements whose value is None —
    the emitted JSON-LD must never contain a null."""
    if isinstance(value, dict):
        return {k: _strip_nones(v) for k, v in value.items() if v is not None}
    if isinstance(value, list):
        return [_strip_nones(v) for v in value if v is not None]
    return value
 def _need(value, field):
    """Raise on a schema-required field that is present but empty — the
    case argparse's `required=True` cannot catch (an empty string is a
    given flag, not a missing one)."""
    if value is None or not str(value).strip():
        raise ValueError("missing required field: %s" % field)
    return value
 def _generate(kind, args):
    """Route to the matching generator, enforcing schema-required fields."""
    if kind == "reservation":
        return reservation(
            _need(args.provider, "provider"), _need(args.start, "start"),
            end=args.end, party_size=args.party_size,
            reservation_id=args.reservation_id,
            reservation_for_name=args.reservation_for_name,
            customer_name=args.customer_name,
            customer_email=args.customer_email, kind=args.reservation_kind,
        )
    if kind == "order":
        return order_action(
            _need(args.merchant, "merchant"),
            order_url=_need(args.order_url, "order_url"), name=args.name,
            accepted_payment_method=args.accepted_payment_method,
            delivery_method=args.delivery_method,
        )
    if kind == "discussion":
        interaction = {"LikeAction": args.likes} if args.likes else None
        return discussion(
            _need(args.headline, "headline"), _need(args.author, "author"),
            url=_need(args.url, "url"),
            date_published=_need(args.date_published, "date_published"),
            text=args.text, date_modified=args.date_modified,
            interaction_count=interaction, comment_count=args.comment_count,
        )
    if kind == "profile":
        return profile(
            _need(args.name, "name"), url=_need(args.url, "url"),
            description=args.description, same_as=args.same_as,
            knows_about=args.knows_about, works_for=args.works_for,
            image=args.image, job_title=args.job_title,
        )
    raise ValueError("unknown kind: %r" % kind)  # pragma: no cover — argparse
 def _envelope(payload, script_tag):
    cleaned = _strip_nones(payload)
    out = {"status": "ok", "source": "schema_gen",
           "type": cleaned.get("@type"), "jsonld": cleaned}
    if script_tag:
        pretty = json.dumps(cleaned, indent=2, ensure_ascii=False)
        out["script"] = ('<script type="application/ld+json">\n%s\n</script>'
                          % pretty)
    return out
 def _script_tag_parent():
    """`--script-tag` as a shared parent parser, so it is valid on every
    subcommand — `fetch.sh schema_gen <type> [flags]` puts the type FIRST,
    and argparse only accepts a flag after a subcommand token if that flag
    was declared on the subparser, not the top-level one."""
    parent = argparse.ArgumentParser(add_help=False)
    parent.add_argument(
        "--script-tag", action="store_true",
        help="Wrap jsonld in <script type=application/ld+json>.",
    )
    return parent
 def _add_reservation_args(sub, parents):
    p = sub.add_parser("reservation", parents=parents,
                        help="FoodEstablishmentReservation et al.")
    p.add_argument("--provider", required=True)
    p.add_argument("--start", required=True, help="ISO 8601 startTime.")
    p.add_argument("--end")
    p.add_argument("--party-size", type=int)
    p.add_argument("--reservation-id")
    p.add_argument("--reservation-for-name")
    p.add_argument("--customer-name")
    p.add_argument("--customer-email")
    p.add_argument(
        "--reservation-kind", dest="reservation_kind",
        default="FoodEstablishmentReservation",
        choices=(
            "FoodEstablishmentReservation", "LodgingReservation",
            "RentalCarReservation", "TaxiReservation", "EventReservation",
            "TrainReservation", "FlightReservation",
        ),
    )
 def _add_order_args(sub, parents):
    p = sub.add_parser("order", parents=parents,
                        help="OrderAction (potentialAction).")
    p.add_argument("--merchant", required=True)
    p.add_argument("--order-url", required=True)
    p.add_argument("--name", default="Order online")
    p.add_argument("--accepted-payment-method", nargs="*", default=None)
    p.add_argument("--delivery-method", nargs="*", default=None)
 def _add_discussion_args(sub, parents):
    p = sub.add_parser("discussion", parents=parents,
                        help="DiscussionForumPosting.")
    p.add_argument("--headline", required=True)
    p.add_argument("--author", required=True)
    p.add_argument("--url", required=True)
    p.add_argument("--date", dest="date_published", required=True)
    p.add_argument("--text")
    p.add_argument("--date-modified")
    p.add_argument("--comment-count", type=int)
    p.add_argument("--likes", type=int, default=None,
                   help="LikeAction count (interactionStatistic).")
 def _add_profile_args(sub, parents):
    p = sub.add_parser("profile", parents=parents,
                        help="ProfilePage with sameAs / knowsAbout.")
    p.add_argument("--name", required=True)
    p.add_argument("--url", required=True)
    p.add_argument("--description")
    p.add_argument("--same-as", nargs="*", default=None)
    p.add_argument("--knows-about", nargs="*", default=None)
    p.add_argument("--works-for")
    p.add_argument("--image")
    p.add_argument("--job-title")
 def _build_parser():
    p = argparse.ArgumentParser(
        description="Schema.org JSON-LD generators (stdlib, deterministic)."
    )
    p.add_argument("--store", default=None)  # accepted+ignored (dispatch)
    sub = p.add_subparsers(dest="kind", required=True)
    parents = [_script_tag_parent()]
    _add_reservation_args(sub, parents)
    _add_order_args(sub, parents)
    _add_discussion_args(sub, parents)
    _add_profile_args(sub, parents)
    return p
 def _cli():
    try:
        args = _build_parser().parse_args()
        payload = _generate(args.kind, args)
        print(json.dumps(_envelope(payload, args.script_tag), indent=2))
    except SystemExit as e:
        if e.code not in (0, None):
            print(json.dumps({"status": "error", "reason": "bad_usage"}))
        raise
    except Exception as e:
        # Fail-open: a missing required field or any other unexpected error
        # is a normal outcome here, never a traceback or empty stdout.
        print(json.dumps({"status": "degraded", "reason": str(e)}))
 if __name__ == "__main__":
    _cli()
@@ -0,0 +1,113 @@
 #!/usr/bin/env python3
 """Deterministic /20 scoring from a findings list. Stdlib only.
 /harden has a real scale (SKILL.md:435 — Critique -15, Haute -8, Moyenne -3,
 Basse -1, clamp [0,100]). /seo has none: every axis is felt, not computed, so
 two runs over identical code can produce different scores. That is a
 credibility problem on its own, and /client-handover gates on 17/20 — a
 wobbling number makes the gate arbitrary. H2 sharpens it further: now that
 drift reports what actually changed, a score moving on its own is visibly
 noise.
 The split is the point. The LLM keeps the irreducible judgement — WHICH
 findings exist and how severe each is. The arithmetic stops being judgement:
 same findings in, same score out. Same principle as grouping cannibalisation
 rows in the engine rather than asking a model to add up 1000 of them.
 Scale is /harden's, /5 into /20, so the whole skill family speaks one
 vocabulary.
 """
 import argparse, json, sys
 PENALTY = {"critique": 15, "haute": 8, "moyenne": 3, "basse": 1}
 # STEP 9 weights. FULL = 7 axes, LOCAL = 4 (off-page/social/competitive are
 # not audited at that depth).
 WEIGHTS = {
    ("FULL", "local"):    {"technical": .20, "on-page": .20, "seo-local": .25,
                           "off-page": .10, "social": .10, "competitive": .05,
                           "legal": .10},
    ("FULL", "national"): {"technical": .30, "on-page": .30, "seo-local": .05,
                           "off-page": .15, "social": .05, "competitive": .10,
                           "legal": .05},
    ("LOCAL", "local"):   {"technical": .25, "on-page": .35, "seo-local": .20,
                           "legal": .20},
    ("LOCAL", "national"):{"technical": .35, "on-page": .45, "seo-local": .05,
                           "legal": .15},
 }
 def _axis_score(findings):
    """100 - Σ penalties, clamped, then /5 → /20. Prevalence shifts severity
    ONE step, never invents one: a finding on 1 of 12 sampled pages is not the
    same defect as one on 12 of 12, and pretending otherwise is what made the
    old scores unreproducible."""
    total = 0
    for f in findings:
        sev = str(f.get("severity", "")).lower()
        if sev not in PENALTY:
            raise ValueError("unknown severity: %r" % f.get("severity"))
        order = ["basse", "moyenne", "haute", "critique"]
        i = order.index(sev)
        aff, samp = f.get("affected"), f.get("sampled")
        if isinstance(aff, int) and isinstance(samp, int) and samp > 0:
            ratio = aff / samp
            if ratio >= 0.5:
                i = min(i + 1, len(order) - 1)      # widespread → escalate
            elif aff <= 1:
                i = max(i - 1, 0)                   # isolated → de-escalate
        total += PENALTY[order[i]]
    return round(max(0, 100 - total) / 5.0, 1)
 def score(payload):
    depth = str(payload.get("depth", "FULL")).upper()
    profile = str(payload.get("profile", "local")).lower()
    key = (depth, profile)
    if key not in WEIGHTS:
        return {"status": "error", "reason": "unknown depth/profile: %s/%s"
                                             % (depth, profile)}
    weights, axes_in = WEIGHTS[key], payload.get("axes", {})
    scored, na = {}, []
    for axis, w in weights.items():
        a = axes_in.get(axis)
        if a is None or str(a.get("status", "")).lower() == "na":
            na.append(axis)                          # N/A is not a zero
            continue
        try:
            s = _axis_score(a.get("findings", []))
        except ValueError as e:
            return {"status": "error", "reason": str(e)}
        scored[axis] = {"score_20": s, "weight": w,
                        "findings": len(a.get("findings", []))}
    if not scored:
        return {"status": "degraded", "reason": "no_axis_scored"}
    # Renormalise over what was actually measured. R2 mandates this for a
    # client-rendered on-page axis and left it to the model to do by hand.
    live = sum(v["weight"] for v in scored.values())
    for v in scored.values():
        v["weight_renormalised"] = round(v["weight"] / live, 4)
    glob = sum(v["score_20"] * v["weight"] / live for v in scored.values())
    return {"status": "ok", "source": "score", "depth": depth,
            "profile": profile, "axes": scored, "na": sorted(na),
            "weights_renormalised": round(live, 4) != 1.0,
            "global_20": round(glob, 1)}
 def _cli():
    try:
        p = argparse.ArgumentParser()
        p.add_argument("--findings", default="-", help="JSON path, or - for stdin")
        p.add_argument("--store", default=None)      # accepted+ignored
        args = p.parse_args()
        raw = sys.stdin.read() if args.findings == "-" else \
            open(args.findings, encoding="utf-8").read()
        print(json.dumps(score(json.loads(raw)), indent=2))
    except SystemExit as e:
        if e.code not in (0, None):
            print(json.dumps({"status": "error", "reason": "bad_usage"}))
        raise
    except Exception:
        # Unlike the fetch verbs this is pure arithmetic: a degrade here means
        # malformed input, never a network fact.
        print(json.dumps({"status": "error", "reason": "bad_findings_json"}))
 if __name__ == "__main__":
    _cli()
@@ -57,12 +57,363 @@ has "queries position field"     "$Q" '"position": 6.3'
 I="$(SEO_DATA_MOCK_DIR="$MOCK" python3 "$SD/google_seo.py" inspect \
  --store "$S2" --account client-a --property sc-domain:ex.com --url https://ex.com/x)"
 has "inspect indexed true"       "$I" '"indexed": true'
 # rich_results rides the same URL-Inspection response (no extra call/quota)
 has "rich verdict surfaced"      "$I" '"verdict": "FAIL"'
 has "rich type breadcrumbs"      "$I" '"type": "Breadcrumbs"'
 has "rich type faq"              "$I" '"type": "FAQ"'
 has "rich counts error severity" "$I" '"errors": 2'
 has "rich counts warn severity"  "$I" '"warnings": 1'
 has "rich keeps issue message"   "$I" "Missing field 'acceptedAnswer'"
 # same issueMessage repeats across items — the rollup must collapse it to one
 NMSG="$(printf '%s' "$I" | grep -cF "Missing field 'acceptedAnswer'")"
 [ "$NMSG" = "1" ] && ok "rich dedupes issue messages" \
                  || no "rich dedupes issue messages" "got $NMSG occurrences"
 # Google OMITS richResultsResult when it detects none — absence is data, and
 # must not KeyError nor vanish into a missing key
 NR="$(SEO_DATA_MOCK_DIR="$SD/fixtures-norich" python3 "$SD/google_seo.py" inspect \
  --store "$S2" --account client-a --property sc-domain:ex.com --url https://ex.com/x)"
 has "no-rich → synthetic ABSENT" "$NR" '"verdict": "ABSENT"'
 has "no-rich keeps index status" "$NR" '"indexed": true'
 hasnt "no-rich emits no PARTIAL" "$NR" 'PARTIAL'
 DEG="$(env -u SEO_DATA_MOCK_DIR python3 "$SD/google_seo.py" queries \
  --store "$TMP2/none.json" --account nobody --property sc-domain:ex.com)"
 has "gsc degrades w/o creds"     "$DEG" '"status": "degraded"'
 has "gsc degrade reason"         "$DEG" 'no_credentials'
 rm -rf "$TMP2"
 echo "── cannibalisation ──"
 # `keys` is additive: the single-dim consumer that reads `key` must not break
 has "queries keeps key (compat)"  "$Q" '"key": "plombier paris"'
 has "queries adds keys list"      "$Q" '"keys"'
 CAN="$(SEO_DATA_MOCK_DIR="$SD/fixtures-cannibal" python3 "$SD/google_seo.py" cannibal \
  --store "$S2" --account client-a --property sc-domain:ex.com)"
 has "cannibal ok"                 "$CAN" '"status": "ok"'
 # fixture: 3 pages on "urgence fuite", 2 on "plombier paris", 1 on "devis"
 has "cannibal finds 2 conflicts"  "$CAN" '"conflict_count": 2'
 has "cannibal counts pages"       "$CAN" '"pages": 3'
 has "cannibal sums impressions"   "$CAN" '"total_impressions": 2400'
 hasnt "single-page query is not a conflict" "$CAN" 'devis plomberie'
 # biggest conflict first, and inside it the strongest page first
 CAN_FIRST="$(printf '%s' "$CAN" | python3 -c 'import sys,json; d=json.load(sys.stdin); print(d["conflicts"][0]["query"], d["conflicts"][0]["urls"][0]["url"])')"
 check_first() { [ "$1" = "$2" ] && ok "$3" || no "$3" "got[$1]"; }
 check_first "$CAN_FIRST" "urgence fuite https://ex.com/urgence" "cannibal ranks by impact"
 has "cannibal reports the cap"    "$CAN" '"capped": false'
 echo "── safe_fetch (DNS-rebinding / SSRF) ──"
 # Inject a hostile resolver: the name is public, the address is internal. This
 # is the rebinding vector a name-level guard cannot see — prove it is refused
 # BEFORE any connection. Deterministic + offline via the injected resolver.
 sfpy() { PYTHONPATH="$SD" python3 -c "$1" 2>&1; }
 REBIND="$(sfpy '
 import socket, safe_fetch as sf
 def meta(h,p,**k): return [(socket.AF_INET,socket.SOCK_STREAM,6,"",("169.254.169.254",p))]
 try: sf.safe_fetch("https://evil.example/", resolver=meta); print("CONNECTED")
 except sf.UnsafeTarget as e: print("REFUSED", e)')"
 has "rebind to metadata refused"  "$REBIND" 'REFUSED'
 has "refusal names the ip"        "$REBIND" '169.254.169.254'
 hasnt "never connected"           "$REBIND" 'CONNECTED'
 MIXED="$(sfpy '
 import socket, safe_fetch as sf
 def mix(h,p,**k): return [(socket.AF_INET,socket.SOCK_STREAM,6,"",("93.184.216.34",p)),
                          (socket.AF_INET,socket.SOCK_STREAM,6,"",("127.0.0.1",p))]
 try: sf.safe_fetch("https://evil.example/", resolver=mix); print("CONNECTED")
 except sf.UnsafeTarget as e: print("REFUSED")')"
 has "multi-A public+private refused" "$MIXED" 'REFUSED'
 # classification, dual-stack — is_global catches CGNAT the per-flags miss
 CLS="$(sfpy '
 import safe_fetch as sf
 pub=[c for c in ["8.8.8.8","2606:2800:220:1:248:1893:25c8:1946"] if sf._ip_is_public(c)]
 bad=[c for c in ["169.254.169.254","127.0.0.1","10.0.0.1","192.168.1.1","100.64.1.1","::1","fe80::1","0.0.0.0"] if sf._ip_is_public(c)]
 print("PUB",len(pub),"BADPASS",len(bad))')"
 has "public v4+v6 pass"           "$CLS" 'PUB 2'
 has "no internal ip passes"       "$CLS" 'BADPASS 0'
 # security review 2026-07-17: 6to4-relay anycast passes is_global — extra deny
 SIXTOFOUR="$(sfpy 'import safe_fetch as sf; print("6TO4", sf._ip_is_public("192.88.99.1"))')"
 has "6to4 relay anycast refused"  "$SIXTOFOUR" '6TO4 False'
 # scheme + stdlib
 SCHEME="$(sfpy '
 import safe_fetch as sf
 try: sf.safe_fetch("file:///etc/passwd"); print("OK")
 except sf.UnsafeTarget: print("REFUSED")')"
 has "non-http scheme refused"     "$SCHEME" 'REFUSED'
 IMP="$(/bin/grep -E "^(import|from) " "$SD/safe_fetch.py" | /bin/grep -cvE "gzip|http\.client|ipaddress|socket|ssl|urllib\.parse")"
 [ "$IMP" = "0" ] && ok "safe_fetch is stdlib-only" || no "safe_fetch is stdlib-only" "$IMP non-stdlib imports"
 hasnt "no requests dependency"    "$(cat "$SD/safe_fetch.py")" 'import requests'
 echo "── sitemap ──"
 SM="$(SEO_DATA_MOCK_DIR="$MOCK" python3 "$SD/sitemap.py" --url https://ex.com/sitemap.xml)"
 has "sitemap ok"                 "$SM" '"status": "ok"'
 has "sitemap not an index"       "$SM" '"index": false'
 # fixture holds 8 <loc>: 1 empty, blog twice, ftp:// and a quoted one to drop
 has "sitemap dedupes"            "$SM" '"count": 4'
 has "sitemap counts drops"       "$SM" '"dropped": 2'
 has "sitemap strips whitespace"  "$SM" '"https://ex.com/spaced"'
 hasnt "sitemap drops non-http"   "$SM" 'ftp://'
 hasnt "sitemap drops shell-meta" "$SM" 'bad"quote'
 # namespace-agnostic: real sitemaps carry sitemaps.org xmlns (+ xhtml here)
 has "sitemap reads namespaced"   "$SM" '"https://ex.com/services"'
 # REGRESSION: <image:loc> also ends with '}loc'. An endswith test counted image
 # sitemap entries as pages — a real native site returned 27 for 24 <url>, and
 # img/logo.png was about to be sampled and audited as a page.
 hasnt "image:loc is not a page"  "$SM" '/img/logo.png'
 hasnt "image:loc jpeg not a page" "$SM" '/img/hero.jpeg'
 has "image ns does not inflate count" "$SM" '"count": 4'
 IDX="$(SEO_DATA_MOCK_DIR="$SD/fixtures-sitemap-index" python3 "$SD/sitemap.py" \
  --url https://ex.com/sitemap.xml)"
 has "sitemapindex detected"      "$IDX" '"index": true'
 has "sitemapindex fans out"      "$IDX" '"children_read": 2'
 has "sitemapindex no child fail" "$IDX" '"children_failed": 0'
 has "sitemapindex yields urls"   "$IDX" '"https://ex.com/child-a"'
 # A sitemap NEVER has a DTD. Refused at the door: xml.etree does not expand
 # external entities but IS billion-laughs-vulnerable, and the 20MB read ceiling
 # bounds the input, not the expansion. Refusing beats depending on the parser,
 # and keeps this module stdlib-only (no defusedxml, no venv).
 DTD="$(SEO_DATA_MOCK_DIR="$SD/fixtures-sitemap-dtd" python3 "$SD/sitemap.py" \
  --url https://ex.com/sitemap.xml)"
 has "billion-laughs refused"     "$DTD" '"status": "degraded"'
 has "dtd reason is distinct"     "$DTD" 'unsafe_xml_dtd'
 hasnt "dtd never parsed"         "$DTD" '"count"'
 # security review 2026-07-17: a >4KB leading comment pushed <!DOCTYPE past the
 # old raw[:4096] scan while ET still parsed+expanded it. Now the whole doc is
 # scanned. Prove a padded DTD is refused and the entity never expands.
 PADDED="$(python3 -c '
 import sys; sys.path.insert(0,"'"$SD"'"); import sitemap as sm
 bomb=("<?xml version=\"1.0\"?>\n<!-- "+("x"*5000)+" -->\n"
      "<!DOCTYPE d [ <!ENTITY lol \"lol\"> ]>\n<urlset><url><loc>https://x/&lol;</loc></url></urlset>").encode()
 try: sm._refuse_dtd(bomb); print("PARSED")
 except sm.UnsafeXML: print("REFUSED")')"
 has "padded DTD refused (full scan)" "$PADDED" 'REFUSED'
 echo "── render_check (R2) ──"
 SPA="$(SEO_DATA_MOCK_DIR="$SD/fixtures-spa" python3 "$SD/render_check.py" \
  --url https://spa.example/)"
 has "spa → client-rendered"      "$SPA" '"verdict": "client-rendered"'
 has "spa has no h1 in html"      "$SPA" '"h1_in_html": 0'
 has "spa warns about false negs" "$SPA" 'false'
 # the shell carries a fat window.__INITIAL_STATE__ script: script text is NOT
 # page text, or a 200KB React bundle would read as a rich page
 has "script text is not content" "$SPA" '"body_text_chars": 7'
 SSR="$(SEO_DATA_MOCK_DIR="$SD/fixtures-ssr" python3 "$SD/render_check.py" \
  --url https://ssr.example/)"
 has "ssr → server-rendered"      "$SSR" '"verdict": "server-rendered"'
 has "ssr counts jsonld"          "$SSR" '"jsonld_in_html": 1'
 has "ssr sees meta description"  "$SSR" '"meta_description_in_html": true'
 hasnt "ssr emits no warning"     "$SSR" 'warning'
 echo "── linkgraph ──"
 LG="$(SEO_DATA_MOCK_DIR="$SD/fixtures-linkgraph" python3 "$SD/linkgraph.py" \
  --url https://ex.com/sitemap.xml)"
 has "linkgraph ok"               "$LG" '"status": "ok"'
 has "linkgraph crawls all"       "$LG" '"pages_crawled": 7'
 # THE test: a planted page nobody links to must be found. Two live sites both
 # returned zero orphans; without this, "always returns []" looks identical.
 has "finds the planted orphan"   "$LG" '"https://ex.com/orphan"'
 has "orphan is also unreachable" "$LG" '"unreachable"'
 has "depth chain measured"       "$LG" '"max_depth": 4'
 has "flags >3 clicks"            "$LG" '"https://ex.com/deepest"'
 # home links: /a and /b only. anchor, .css?v=, mailto:, tel:, external, .png
 # are not page links — 9 total across the 7 pages.
 has "filters non-page links"     "$LG" '"total_internal_links": 9'
 hasnt "no external host"         "$LG" 'other.com'
 hasnt "no asset link"            "$LG" 'main.css'
 hasnt "no image link"            "$LG" 'logo.png'
 # /b/ in the markup vs /b in the sitemap must be ONE node, not a phantom orphan
 hasnt "trailing slash unified"   "$LG" '"https://ex.com/b/"'
 # An orphan from a partial crawl is a false orphan: withhold, do not truncate.
 CAP="$(SEO_DATA_MOCK_DIR="$SD/fixtures-linkgraph" python3 "$SD/linkgraph.py" \
  --url https://ex.com/sitemap.xml --max 3)"
 has "cap is reported"            "$CAP" '"capped": true'
 has "capped withholds orphans"   "$CAP" '"orphans_withheld": true'
 hasnt "capped emits no orphans"  "$CAP" '"orphans":'
 echo "── score (I7) ──"
 sc() { printf '%s' "$1" | python3 "$SD/score.py" --findings -; }
 # technical: haute(-8) + moyenne(-3) = 100-11 = 89 → 17.8
 B='{"depth":"FULL","profile":"local","axes":{"technical":{"findings":[{"severity":"haute"},{"severity":"moyenne"}]},"seo-local":{"findings":[]},"off-page":{"findings":[]},"social":{"findings":[]},"competitive":{"findings":[]},"legal":{"findings":[]},"on-page":{"findings":[]}}}'
 R="$(sc "$B")"
 has "harden scale, /5 into /20"   "$R" '"score_20": 17.8'
 has "no findings = 20"            "$R" '"score_20": 20.0'
 has "nothing renormalised"        "$R" '"weights_renormalised": false'
 # THE point of I7: same findings in, same score out
 A1="$(sc "$B" | python3 -c 'import sys,json;print(json.load(sys.stdin)["global_20"])')"
 A2="$(sc "$B" | python3 -c 'import sys,json;print(json.load(sys.stdin)["global_20"])')"
 [ "$A1" = "$A2" ] && ok "score is reproducible" || no "score is reproducible" "$A1 vs $A2"
 # N/A is not a zero, and R2 mandated renormalising by hand — now computed
 NA='{"depth":"FULL","profile":"local","axes":{"technical":{"findings":[]},"on-page":{"status":"na"},"seo-local":{"findings":[]},"off-page":{"status":"na"},"social":{"findings":[]},"competitive":{"findings":[]},"legal":{"findings":[]}}}'
 RN="$(sc "$NA")"
 has "na axes listed"             "$RN" '"on-page"'
 has "renormalisation flagged"    "$RN" '"weights_renormalised": true'
 # all axes 20 → global must stay 20: N/A must not drag the mean down
 has "na is not a zero"           "$RN" '"global_20": 20.0'
 # prevalence shifts severity ONE step, both ways
 WIDE='{"depth":"LOCAL","profile":"local","axes":{"technical":{"findings":[{"severity":"moyenne","affected":10,"sampled":12}]},"on-page":{"findings":[]},"seo-local":{"findings":[]},"legal":{"findings":[]}}}'
 ONE='{"depth":"LOCAL","profile":"local","axes":{"technical":{"findings":[{"severity":"moyenne","affected":1,"sampled":12}]},"on-page":{"findings":[]},"seo-local":{"findings":[]},"legal":{"findings":[]}}}'
 has "widespread escalates (-8)"  "$(sc "$WIDE")" '"score_20": 18.4'
 has "isolated de-escalates (-1)" "$(sc "$ONE")"  '"score_20": 19.8'
 # malformed input is an error, never a silently wrong number
 has "unknown severity rejected"  "$(sc '{"depth":"FULL","profile":"local","axes":{"technical":{"findings":[{"severity":"bogus"}]}}}')" '"status": "error"'
 has "unknown profile rejected"   "$(sc '{"depth":"FULL","profile":"martian","axes":{}}')" '"status": "error"'
 has "garbage json is an error"   "$(sc 'not json')" '"status": "error"'
 echo "── drift (H2) ──"
 DH="$(mktemp -d)"
 D1="$(HOME="$DH" SEO_DATA_MOCK_DIR="$SD/fixtures-drift-v1" python3 "$SD/drift.py" \
  --url https://ex.com/sitemap.xml)"
 has "first run is a baseline"    "$D1" '"baseline": true'
 has "baseline captures pages"    "$D1" '"pages": 3'
 hasnt "baseline diffs nothing"   "$D1" '"regressions"'
 # v2: canonical lost on /a, h1+jsonld lost on /, title reworded, /gone removed,
 # /neuve added. Losses are regressions; a reworded title is not.
 D2="$(HOME="$DH" SEO_DATA_MOCK_DIR="$SD/fixtures-drift-v2" python3 "$SD/drift.py" \
  --url https://ex.com/sitemap.xml)"
 has "second run diffs"           "$D2" '"baseline": false'
 has "detects removed url"        "$D2" '"https://ex.com/gone"'
 has "detects added url"          "$D2" '"https://ex.com/neuve"'
 has "lost canonical = regression" "$D2" '"canonical"'
 has "lost h1 = regression"       "$D2" '"h1_count"'
 has "lost jsonld = regression"   "$D2" '"jsonld_types"'
 # the classification IS the feature: losing a signal != changing one
 NREG="$(printf '%s' "$D2" | python3 -c 'import sys,json; print(len(json.load(sys.stdin)["regressions"]))')"
 NCHG="$(printf '%s' "$D2" | python3 -c 'import sys,json; print(len(json.load(sys.stdin)["changes"]))')"
 [ "$NREG" = "3" ] && ok "3 losses classed as regressions" \
                  || no "3 losses classed as regressions" "got $NREG"
 [ "$NCHG" = "1" ] && ok "reworded title is a change, not a regression" \
                  || no "reworded title is a change, not a regression" "got $NCHG"
 rm -rf "$DH"
 echo "── schema_gen ──"
 SG() { python3 "$SD/schema_gen.py" "$@"; }
 RES="$(SG reservation --provider "Chez X" --start "2026-08-01T19:00")"
 has "reservation ok"             "$RES" '"status": "ok"'
 has "reservation type surfaced"  "$RES" '"type": "FoodEstablishmentReservation"'
 has "jsonld has @context"        "$RES" '"@context": "https://schema.org"'
 has "reservation keeps provider" "$RES" 'Chez X'
 has "reservation keeps start"    "$RES" '2026-08-01T19:00'
 PROF="$(SG profile --name "Jane Doe" --url https://ex.com/about)"
 has "profile ok"                 "$PROF" '"status": "ok"'
 has "profile type surfaced"      "$PROF" '"type": "ProfilePage"'
 ORD="$(SG order --merchant "Acme" --order-url https://ex.com/order)"
 has "order ok"                   "$ORD" '"status": "ok"'
 has "order type surfaced"        "$ORD" '"type": "OrderAction"'
 DISC="$(SG discussion --headline "Q" --author "Jo" --url https://ex.com/t/1 \
  --date 2026-05-01T00:00:00Z)"
 has "discussion ok"              "$DISC" '"status": "ok"'
 has "discussion type surfaced"   "$DISC" '"type": "DiscussionForumPosting"'
 # argparse required=True catches an OMITTED flag → bad usage, exit 2
 BADRES="$(SG reservation --start 2026-08-01T19:00 2>/dev/null)"; BADRC=$?
 hasnt "missing --provider is not ok" "$BADRES" '"status": "ok"'
 [ "$BADRC" = "2" ] && ok "missing --provider exit 2" \
                    || no "missing --provider exit 2" "got $BADRC"
 # a required field argparse ALLOWS through (flag given, value empty) must
 # still fail open — degraded, not a crash, exit 0
 EMPTYRES="$(SG reservation --provider "" --start 2026-08-01T19:00)"; EMPTYRC=$?
 hasnt "empty --provider is not ok" "$EMPTYRES" '"status": "ok"'
 has "empty --provider degrades"  "$EMPTYRES" '"status": "degraded"'
 [ "$EMPTYRC" = "0" ] && ok "empty --provider exit 0" \
                      || no "empty --provider exit 0" "got $EMPTYRC"
 # --script-tag must work AFTER the type, matching `fetch.sh schema_gen
 # <type> [flags]` — the shape the dispatcher actually calls it with. The
 # envelope is JSON, so the `script` field's own quotes are backslash-escaped
 # in the raw stdout — decode it to check the LITERAL wrapper string.
 SCRIPT="$(SG profile --name "Jane Doe" --url https://ex.com/about --script-tag)"
 SCRIPT_TAG="$(printf '%s' "$SCRIPT" | \
  python3 -c 'import sys,json; print(json.load(sys.stdin)["script"])')"
 has "script-tag wraps output" "$SCRIPT_TAG" '<script type="application/ld+json">'
 # an omitted optional field must never surface as a JSON null
 hasnt "no null ever emitted"     "$RES" 'null'
 # stdlib ONLY — no requests/httpx/bs4/any third-party import
 IMPORTS="$(grep -E '^(import|from) ' "$SD/schema_gen.py")"
 if printf '%s' "$IMPORTS" | grep -qiE 'requests|httpx|bs4'; then
  no "schema_gen stdlib only" "third-party import found: $IMPORTS"
 else
  ok "schema_gen stdlib only"
 fi
 # dispatch wiring: --store precedes the type (fetch.sh's own convention),
 # --script-tag comes after it (the caller's convention) — both must work
 # through the real fetch.sh entrypoint, not just the bare script
 FSG="$(SEO_DATA_ENV_FILE=/dev/null SEO_DATA_STORE=/nonexistent bash "$SD/fetch.sh" \
  schema_gen reservation --provider "Chez X" --start 2026-08-01T19:00 --script-tag)"
 has "fetch dispatches schema_gen" "$FSG" '"status": "ok"'
 FSG_TAG="$(printf '%s' "$FSG" | \
  python3 -c 'import sys,json; print(json.load(sys.stdin)["script"])')"
 has "fetch schema_gen script-tag" "$FSG_TAG" '<script type="application/ld+json">'
 echo "── content_quality ──"
 CQ() { python3 "$SD/content_quality.py" "$@"; }
 # feed the phrase list's OWN entries so the match is exact, not paraphrased —
 # a detector proven only on the maintainer's paraphrase proves nothing
 FILLER_TXT="In today's fast-paced world, it's important to note that this \
 article will delve into the ever-evolving landscape of technology. Let's \
 dive in and navigate the complexities together, leveraging the power of \
 innovation to unlock the potential of your business. Ultimately, this \
 cutting-edge, state-of-the-art approach is a testament to progress. \
 Moreover, furthermore, in conclusion, transform your outcomes today."
 CLEAN_TXT="The 2024 ADEME report found French households spent 2,137 EUR \
 on heating, up 12% from 2021."
 FILLER_OUT="$(printf '%s' "$FILLER_TXT" | CQ)"
 CLEAN_OUT="$(printf '%s' "$CLEAN_TXT" | CQ)"
 has "filler text is ok"          "$FILLER_OUT" '"status": "ok"'
 has "clean text is ok"           "$CLEAN_OUT"  '"status": "ok"'
 # flags is a JSON array — extract it in isolation so the check can't be
 # fooled by the always-present "matches": {"filler": [...]} key sharing
 # the same quoted word
 FILLER_FLAGS="$(printf '%s' "$FILLER_OUT" | \
  python3 -c 'import sys,json; print(",".join(json.load(sys.stdin)["flags"]))')"
 CLEAN_FLAGS="$(printf '%s' "$CLEAN_OUT" | \
  python3 -c 'import sys,json; print(",".join(json.load(sys.stdin)["flags"]))')"
 case "$FILLER_FLAGS" in
  *filler*|*ai-patterns*) ok "filler-heavy text is flagged" ;;
  *) no "filler-heavy text is flagged" "flags: $FILLER_FLAGS" ;;
 esac
 hasnt "clean text is not flagged filler"      "$CLEAN_FLAGS" 'filler'
 hasnt "clean text is not flagged ai-patterns" "$CLEAN_FLAGS" 'ai-patterns'
 # proves BOTH directions: an always-flag or a never-flag detector is useless
 FILLER_Q="$(printf '%s' "$FILLER_OUT" | \
  python3 -c 'import sys,json; print(json.load(sys.stdin)["overall_quality"])')"
 CLEAN_Q="$(printf '%s' "$CLEAN_OUT" | \
  python3 -c 'import sys,json; print(json.load(sys.stdin)["overall_quality"])')"
 [ "$FILLER_Q" -lt 50 ] && ok "filler-heavy text scores LOW overall_quality" \
                        || no "filler-heavy text scores LOW overall_quality" "got $FILLER_Q"
 [ "$CLEAN_Q" -gt "$FILLER_Q" ] && ok "clean dense text scores higher" \
                                || no "clean dense text scores higher" "$CLEAN_Q vs $FILLER_Q"
 # empty / whitespace-only input never crashes and never claims a result
 EMPTY_OUT="$(printf '' | CQ)"
 has "empty input degrades"       "$EMPTY_OUT" '"status": "degraded"'
 has "empty input reason"         "$EMPTY_OUT" 'empty_input'
 WS_OUT="$(printf '   \n\t ' | CQ)"
 has "whitespace-only degrades"   "$WS_OUT" '"status": "degraded"'
 # --file path works, no fixture committed — mktemp + rm
 CQTMP="$(mktemp)"; printf '%s' "$CLEAN_TXT" > "$CQTMP"
 FILE_OUT="$(CQ --file "$CQTMP")"
 has "file input is ok"           "$FILE_OUT" '"status": "ok"'
 rm -f "$CQTMP"
 # a missing --file degrades, never a traceback
 MISSING_OUT="$(CQ --file /nonexistent/path/content-quality-test.txt)"
 has "missing --file degrades"    "$MISSING_OUT" '"status": "degraded"'
 # stdlib ONLY — asserted, not assumed
 CQ_IMPORTS="$(grep -E '^(import|from) ' "$SD/content_quality.py")"
 if printf '%s' "$CQ_IMPORTS" | grep -qivE '^(import argparse, json, re, sys|from collections import counter|from typing import iterable)$'; then
  no "content_quality stdlib only" "unexpected import: $CQ_IMPORTS"
 else
  ok "content_quality stdlib only"
 fi
 # ADVISORY HONESTY (LRN-131/133): a heuristic signal, never a verdict
 hasnt "never claims ai-written"  "$FILLER_OUT" 'ai-written'
 hasnt "never claims is AI verdict" "$FILLER_OUT" 'is AI'
 # dispatch wiring: --store precedes the verb (fetch.sh's own convention);
 # both stdin AND --file must work through the real entrypoint
 FCQ_STDIN="$(printf '%s' "$CLEAN_TXT" | \
  SEO_DATA_ENV_FILE=/dev/null SEO_DATA_STORE=/nonexistent bash "$SD/fetch.sh" content_quality)"
 has "fetch dispatches content_quality (stdin)" "$FCQ_STDIN" '"status": "ok"'
 CQTMP2="$(mktemp)"; printf '%s' "$CLEAN_TXT" > "$CQTMP2"
 FCQ_FILE="$(SEO_DATA_ENV_FILE=/dev/null SEO_DATA_STORE=/nonexistent bash "$SD/fetch.sh" \
  content_quality --file "$CQTMP2")"
 has "fetch dispatches content_quality (--file)" "$FCQ_FILE" '"status": "ok"'
 rm -f "$CQTMP2"
 echo "── fetch.sh ──"
 FETCH="$SD/fetch.sh"
 # SEO_DATA_ENV_FILE=/dev/null: tests must NEVER source the real ~/.claude/.env —
@@ -188,6 +539,8 @@ tf "analyzer calls fetch crux"  "$REPO/agents/seo-analyzer.md"   "fetch.sh crux"
 tf "analyzer calls fetch queries" "$REPO/agents/seo-analyzer.md" "fetch.sh queries"
 tf "analyzer gsc subsection"    "$REPO/agents/seo-analyzer.md"   "Performance GSC"
 tf "catalog gsc oauth entry"    "$REPO/agents/resources/automation-catalog.md" "make seo-connect"
 tf "geo-analyzer wires schema_gen" "$REPO/agents/geo-analyzer.md" "fetch.sh schema_gen"
 tf "geo-analyzer wires content_quality" "$REPO/agents/geo-analyzer.md" "fetch.sh content_quality"
 echo "── account-mgmt locks ──"
 tf "skill routes account verbs" "$REPO/skills/seo/SKILL.md" "forget --all"
@@ -200,6 +553,9 @@ tf "readme documents fetch.sh" "$REPO/lib/seo-data/README.md" "fetch.sh"
 tf "readme documents seo-connect" "$REPO/lib/seo-data/README.md" "make seo-connect"
 tf "readme documents forget"   "$REPO/lib/seo-data/README.md" "forget --all"
 tf "readme revocation note"    "$REPO/lib/seo-data/README.md" "myaccount.google.com/permissions"
 tf "readme documents schema_gen" "$REPO/lib/seo-data/README.md" "schema_gen"
 tf "readme documents content_quality" "$REPO/lib/seo-data/README.md" "content_quality"
 tf "readme states advisory caveat" "$REPO/lib/seo-data/README.md" "ADVISORY, NOT A VERDICT"
 echo ""
 echo "seo-data engine: $PASS pass, $FAIL fail"
@@ -0,0 +1,191 @@
 #!/usr/bin/env python3
 """Sitemap discovery -> normalized JSON. Stdlib only: no venv, no requests, no
 auth. Gives STEP 9 COVERAGE the denominator it was told to report and never
 had, and STEP 5 a real sampling frame instead of "5-15 key pages" chosen by
 eye.
 Deliberately NOT a security boundary. urllib fetches these URLs, so nothing
 here reaches a shell and there is no injection surface to guard. The consumer
 is different: seo-analyzer interpolates URLs into curl, so IT must run
 lib/url-guard.sh at the point of use (same pattern as the sameAs check).
 Duplicating the guard here would just add a second copy to drift. `_sane`
 below is a cheap garbage filter, not that guard.
 """
 import argparse, gzip, json, os
 from urllib.parse import urlparse
 MAX_URLS = 50000      # sitemaps.org caps one file at 50k
 MAX_CHILDREN = 50     # sitemapindex fan-out cap: bound the work, report the cut
 TIMEOUT = 20
 def _mock(name):
    d = os.environ.get("SEO_DATA_MOCK_DIR")
    if not d:
        return None
    path = os.path.join(d, name)
    if not os.path.exists(path):
        return None
    with open(path, "rb") as f:
        return f.read()
 def _fetch(url):
    # SSRF + DNS-rebinding safe: resolve-then-pin, redirects re-validated.
    # This is the single seam for ALL network egress — linkgraph/render_check/
    # drift all call sitemap._fetch — so pinning here covers every verb.
    import safe_fetch                                # sibling, lazy
    raw = safe_fetch.safe_fetch(url, timeout=TIMEOUT, max_bytes=20 * 1024 * 1024)
    if raw[:2] == b"\x1f\x8b":                       # sitemap.xml.gz is common
        raw = gzip.decompress(raw)
    return raw
 class UnsafeXML(Exception):
    """A DTD reached the parser. Refused before parsing, not mitigated after."""
 def _refuse_dtd(raw):
    """A sitemap NEVER has a DTD: sitemaps.org is <?xml?> then <urlset xmlns=>.
    So refuse any doctype/entity outright, at the door.
    This is the reason we do not pull in defusedxml. The stdlib parser is not
    the problem for XXE — xml.etree.ElementTree does not expand external
    entities, it raises on them — but it IS vulnerable to billion-laughs, where
    a 1 KB document expands to gigabytes in RAM. The 20 MB read ceiling bounds
    the input, not the expansion. Rejecting the construct beats depending on
    the parser's internals, and keeps this module stdlib-only: no venv, same as
    google_seo.py's mock/degrade paths. A sitemap with a DTD is not a sitemap
    we want anyway.
    """
    # Scan the WHOLE document, not a prefix. A security review (2026-07-17)
    # showed a >4 KB leading comment pushed <!DOCTYPE past the old raw[:4096]
    # window while ET.fromstring still parsed and EXPANDED the entities —
    # billion-laughs reopened. A legitimate sitemap contains neither construct
    # anywhere, so a full case-insensitive scan is correct; over ≤20 MB it is a
    # single re.search, microseconds, no 20 MB uppercased copy.
    import re                                       # stdlib, lazy
    if re.search(rb"(?i)<!\s*(DOCTYPE|ENTITY)", raw):
        raise UnsafeXML("DTD in sitemap")
 SITEMAP_NS = "{http://www.sitemaps.org/schemas/sitemap/0.9}"
 def _is_page_loc(tag):
    """A PAGE <loc>: sitemaps.org namespace, or namespace-less.
    NOT <image:loc> or <video:loc>. Those live in Google's extension
    namespaces and name an ASSET inside a <url>, not a page of its own. An
    endswith('}loc') test matches them too — that shipped, and a real site
    caught it: 24 <url> + 3 <image:loc> came back as a count of 27, so the
    COVERAGE denominator was 12.5% too high and img/logo.png was about to be
    sampled and audited as a page.
    """
    return tag == SITEMAP_NS + "loc" or tag == "loc"
 def _locs(raw):
    """(page <loc> texts, is_sitemapindex).
    Walks the DIRECT children of each <url>/<sitemap> rather than root.iter():
    that alone excludes <image:image><image:loc>, and the namespace test above
    is the second lock. XML comments iterate as elements with no children, so
    they fall through harmlessly.
    """
    import xml.etree.ElementTree as ET               # stdlib, lazy
    _refuse_dtd(raw)
    root = ET.fromstring(raw)
    is_index = root.tag.endswith("sitemapindex")
    out = []
    for entry in root:                               # <url> | <sitemap>
        for child in entry:                          # direct children only
            if _is_page_loc(child.tag):
                text = (child.text or "").strip()
                if text:
                    out.append(text)
                break                                # one <loc> per entry
    return out, is_index
 def _sane(u):
    """Cheap garbage filter — NOT lib/url-guard.sh. Drops what could never be a
    real page URL; the consumer still guards before curling."""
    if not u or len(u) > 2048:
        return False
    if any(c in u for c in '\n\r\t "\'\\`$<>{}|^'):
        return False
    return urlparse(u).scheme in ("http", "https")
 def _expand(children):
    """Fetch each child sitemap of an index. A child that fails is skipped and
    counted, never fatal: one dead child must not lose the other 49."""
    urls, ok, failed = [], 0, 0
    for c in children:
        raw = _mock("sitemap_child.xml")
        if raw is None:
            try:
                raw = _fetch(c)
            except Exception:
                failed += 1
                continue
        try:
            sub, _ = _locs(raw)
        except Exception:
            failed += 1
            continue
        urls.extend(sub)
        ok += 1
    return urls, ok, failed
 def sitemap(url):
    raw = _mock("sitemap.xml")
    if raw is None:
        try:
            raw = _fetch(url)
        except Exception:
            return {"status": "degraded", "reason": "fetch_failed"}
    try:
        locs, is_index = _locs(raw)
    except UnsafeXML:
        # Distinct from parse_failed on purpose: this one is a finding, not a
        # glitch. A sitemap carrying a DTD is either broken tooling or someone
        # aiming a billion-laughs at the auditor.
        return {"status": "degraded", "reason": "unsafe_xml_dtd"}
    except Exception:
        return {"status": "degraded", "reason": "parse_failed"}
    out = {"status": "ok", "source": "sitemap", "index": is_index}
    if is_index:
        out["children_total"] = len(locs)
        kids, ok, failed = _expand(locs[:MAX_CHILDREN])
        out["children_read"], out["children_failed"] = ok, failed
        if len(locs) > MAX_CHILDREN:                 # say what was cut
            out["children_skipped"] = len(locs) - MAX_CHILDREN
        locs = kids
    seen, urls, dropped = set(), [], 0
    for u in locs:
        if not _sane(u):
            dropped += 1
            continue
        if u in seen:
            continue
        seen.add(u)
        urls.append(u)
    if len(urls) > MAX_URLS:
        out["truncated"] = len(urls) - MAX_URLS
        urls = urls[:MAX_URLS]
    out["count"], out["dropped"], out["urls"] = len(urls), dropped, urls
    if not urls:
        return {"status": "degraded", "reason": "no_urls"}
    return out
 def _cli():
    try:
        p = argparse.ArgumentParser()
        p.add_argument("--url", required=True)
        p.add_argument("--store", default=None)   # accepted+ignored: uniform dispatch
        args = p.parse_args()
        print(json.dumps(sitemap(args.url), indent=2))
    except SystemExit as e:
        if e.code not in (0, None):
            print(json.dumps({"status": "error", "reason": "bad_usage"}))
        raise
    except Exception:
        # Same fail-open contract as google_seo.py: never a traceback, never
        # empty stdout, exit 0 so the audit degrades instead of dying.
        print(json.dumps({"status": "degraded", "reason": "unexpected_error"}))
 if __name__ == "__main__":
    _cli()
@@ -0,0 +1,79 @@
 #!/usr/bin/env bash
 # Emit the directory exclusions that separate SOURCE from BUILD OUTPUT.
 #
 #   EXCL="$(bash ~/.claude/lib/source-scope.sh grep)"
 #   grep -rl "gtag" $EXCL --include="*.html" .          # note: $EXCL unquoted
 #
 #   mapfile -t FEXCL < <(bash ~/.claude/lib/source-scope.sh findargs)
 #   find . "${FEXCL[@]}" -iname '*.jpg' -printf '%s %p\n'   # quoted array!
 #
 # findargs emits ONE TOKEN PER LINE and MUST be consumed through a quoted
 # array. A flat string does not work: `find . $FEXCL ...` lets the shell glob
 # `*/dist/*` against the CWD before find ever sees it, and the matches are then
 # passed as search PATHS. Measured on zenquality: that turned 90 hits into 135
 # and kept every dist/ file. The array form passes each token literally.
 #
 # WHY: grep and find disagree about what is in the repo, and seo-analyzer uses
 # both.
 #
 #   grep  → Claude Code installs a shell function routing grep to ugrep with
 #           `--ignore-files`, i.e. .gitignore-aware. A gitignored dist/ is
 #           invisible to it when recursing from `.`. Verified 2026-07-17.
 #   find  → knows nothing about .gitignore. It sees everything.
 #
 # So on zenquality (Astro, dist/ gitignored, built locally) the spec's image
 # audit at seo-analyzer.md:497 returns 92 images of which 45 live in dist/ —
 # every asset listed twice, source and generated copy, identical bytes. Two
 # real consequences:
 #   1. "top 20 by size" is half generated duplicates: ~10 real images audited
 #      while 20 are claimed.
 #   2. Batch C (`cwebp -q 80 <img> -o <img>.webp`) can target dist/og-image.png.
 #      The .webp lands in dist/ and the `npm run build` that /seo runs to VERIFY
 #      the fix erases it. The fix lands, verification passes, nothing survives.
 #
 # The grep side is already safe by accident — do NOT "fix" it to match find.
 # `grep` mode below is defence in depth for the cases the shim misses: a repo
 # that COMMITS its build output (no .gitignore entry to honour), or a directory
 # that is not a git repo at all.
 #
 # `public/` is deliberately NOT in the always-list: it is SOURCE for
 # Astro/Vite/Next and holds the very files this audit checks — favicon.ico,
 # apple-touch-icon.png, robots.txt, OG images. It is build OUTPUT only for
 # Hugo and Gatsby, detected below. Blanket-excluding it would blind the audit
 # to its own resource checks.
 #
 # Exclusions are by NAME, not path, so a monorepo's frontend/dist is caught
 # exactly like a root ./dist.
 set -uo pipefail
 _die() { echo "source-scope: $1" >&2; exit 2; }
 # Build output + tool caches. Never source.
 ALWAYS=(node_modules .git dist build .next .nuxt .output _site .astro
        .svelte-kit .cache out coverage .vercel .netlify .turbo)
 # public/ is output for exactly these two generators.
 _public_is_output() {
  find . -maxdepth 3 \( -name "gatsby-config.js" -o -name "gatsby-config.ts" \
    -o -name "gatsby-config.mjs" -o -name "hugo.toml" -o -name "hugo.yaml" \
    -o -name "hugo.json" \) 2>/dev/null | read -r _ && return 0
  # Hugo's legacy config.toml is ambiguous on its own — pair it with archetypes/
  [ -d ./archetypes ] && [ -f ./config.toml ] && return 0
  return 1
 }
 _list() {
  printf '%s\n' "${ALWAYS[@]}"
  _public_is_output && printf 'public\n'
  return 0
 }
 case "${1:-}" in
  list) _list ;;
  # Safe unquoted: --exclude-dir=NAME carries no glob character.
  grep) _list | while read -r d; do printf -- '--exclude-dir=%s ' "$d"; done; echo ;;
  # One token per line — consume with mapfile + a QUOTED array, never a flat
  # string (see header: the shell would glob */dist/* against the CWD).
  findargs) _list | while read -r d; do printf '!\n-path\n*/%s/*\n' "$d"; done ;;
  *) _die "usage: source-scope.sh {list|grep|findargs}" ;;
 esac
@@ -1,74 +0,0 @@
 #!/usr/bin/env bash
 # lib/tests/config-protection.test.sh
 set -u
 H="$(cd "$(dirname "$0")/../.." && pwd)/hooks/config-protection.sh"
 pass=0; fail=0
 check() { if [ "$2" = "$3" ]; then pass=$((pass+1)); else fail=$((fail+1));
  printf 'FAIL %s: got[%s] want[%s]\n' "$1" "$2" "$3"; fi; }
 # Run hook for a file_path with NO sentinel present (CWD = a clean temp dir).
 run() { local c r; c="$(mktemp -d)"; ( cd "$c" && printf \
  '{"tool_name":"Edit","tool_input":{"file_path":"%s"}}' "$1" | bash "$H" ) \
  >/dev/null 2>&1; r=$?; rm -rf "$c"; return "$r"; }
 # --- Guarded quality-gate files -> blocked (exit 2) ---
 run "/home/u/Documents/claude/lib/gitflow.sh";              check T1-gitflow           "$?" 2
 run "/home/u/.claude/settings.json";                        check T2-live-settings     "$?" 2
 run "/home/u/Documents/claude/.claude/settings.local.json"; check T3-local-settings    "$?" 2
 run "/home/u/Documents/claude/settings.json";               check T4-root-settings     "$?" 2
 run "/home/u/Documents/claude/.githooks/pre-commit";        check T5-githook           "$?" 2
 run "/home/u/Documents/claude/doctor.sh";                   check T6-doctor            "$?" 2
 run "/home/u/Documents/claude/.shellcheckrc";               check T7-shellcheckrc      "$?" 2
 # self-guard: the hook itself, other hooks, and the test suite are guarded
 run "/home/u/Documents/claude/hooks/config-protection.sh";  check T8-self-guard        "$?" 2
 run "/home/u/.claude/hooks/session-start.sh";               check T9-deployed-hook     "$?" 2
 run "/home/u/Documents/claude/lib/tests/config-protection.test.sh"; check T10-tests-guarded "$?" 2
 # --- Non-guarded -> allowed (exit 0) ---
 run "/home/u/Documents/claude/lib/gitflow-migrate.sh";      check T11-near-miss        "$?" 0
 run "/home/u/project/src/app.js";                           check T12-code             "$?" 0
 run "/home/u/project/settings.json";                        check T13-foreign-settings "$?" 0
 # --- Fail-open on malformed input (no file_path) -> allowed ---
 c="$(mktemp -d)"; ( cd "$c" && printf '{}' | bash "$H" ) >/dev/null 2>&1
 check T14-fail-open "$?" 0; rm -rf "$c"
 # --- Sentinel one-shot: non-empty reason -> allow + log + consume; 2nd edit blocked ---
 tmp="$(mktemp -d)"; mkdir -p "$tmp/.claude"
 printf 'fixing eslint false-positive' > "$tmp/.claude/.config-edit-ok"
 ( cd "$tmp" && printf '{"tool_name":"Edit","tool_input":{"file_path":"/x/doctor.sh"}}' \
  | HOME="$tmp" bash "$H" ) >/dev/null 2>&1
 check T15-sentinel-allow "$?" 0
 check T15-consumed "$([ -e "$tmp/.claude/.config-edit-ok" ] && echo present || echo gone)" gone
 check T15-logged "$(grep -c 'BYPASS.*doctor.sh.*fixing eslint' \
  "$tmp/.claude/logs/config-protection.log" 2>/dev/null)" 1
 ( cd "$tmp" && printf '{"tool_name":"Edit","tool_input":{"file_path":"/x/doctor.sh"}}' \
  | HOME="$tmp" bash "$H" ) >/dev/null 2>&1
 check T16-second-blocked "$?" 2
 rm -rf "$tmp"
 # --- Sentinel with EMPTY reason -> refused + consumed ---
 tmp="$(mktemp -d)"; mkdir -p "$tmp/.claude"; : > "$tmp/.claude/.config-edit-ok"
 ( cd "$tmp" && printf '{"tool_name":"Edit","tool_input":{"file_path":"/x/doctor.sh"}}' \
  | HOME="$tmp" bash "$H" ) >/dev/null 2>&1
 check T17-empty-refused "$?" 2
 check T17-consumed "$([ -e "$tmp/.claude/.config-edit-ok" ] && echo present || echo gone)" gone
 rm -rf "$tmp"
 # --- T18/T19: payload shapes beyond Edit (locks against future Edit-only narrowing) ---
 c="$(mktemp -d)"; ( cd "$c" && printf \
  '{"tool_name":"Write","tool_input":{"file_path":"/x/doctor.sh","content":"x"}}' | bash "$H" ) \
  >/dev/null 2>&1; check T18-write-payload "$?" 2; rm -rf "$c"
 c="$(mktemp -d)"; ( cd "$c" && printf \
  '{"tool_name":"MultiEdit","tool_input":{"file_path":"/x/doctor.sh","edits":[{"old_string":"a","new_string":"b"}]}}' | bash "$H" ) \
  >/dev/null 2>&1; check T19-multiedit-payload "$?" 2; rm -rf "$c"
 # --- T20: sentinel with ONLY whitespace bytes (not literally empty) -> refused + consumed ---
 tmp="$(mktemp -d)"; mkdir -p "$tmp/.claude"; printf ' \n\t' > "$tmp/.claude/.config-edit-ok"
 ( cd "$tmp" && printf '{"tool_name":"Edit","tool_input":{"file_path":"/x/doctor.sh"}}' \
  | HOME="$tmp" bash "$H" ) >/dev/null 2>&1
 check T20-whitespace-only-refused "$?" 2
 check T20-whitespace-only-consumed "$([ -e "$tmp/.claude/.config-edit-ok" ] && echo present || echo gone)" gone
 rm -rf "$tmp"
 printf 'PASS=%s FAIL=%s\n' "$pass" "$fail"; [ "$fail" -eq 0 ]
@@ -0,0 +1,52 @@
 #!/usr/bin/env bash
 # lib/tests/fast-libs.test.sh — fast-libs.sh verbs + ctx7-reminder hook (BDR-078)
 set -u
 ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
 L="$ROOT/lib/fast-libs.sh"
 H="$ROOT/hooks/ctx7-reminder.sh"
 pass=0; fail=0
 check() { if [ "$2" = "$3" ]; then pass=$((pass+1)); else fail=$((fail+1));
  printf 'FAIL %s: got[%s] want[%s]\n' "$1" "$2" "$3"; fi; }
 tmp="$(mktemp -d)"; trap 'rm -rf "$tmp"' EXIT
 # --- detect: JS fast-libs matched, stable deps ignored ---
 mkdir -p "$tmp/js"
 cat > "$tmp/js/package.json" <<'EOF'
 {"dependencies":{"react":"^19","express":"^5","@tanstack/react-query":"^5"},
 "devDependencies":{"vite":"^6","lodash":"^4"}}
 EOF
 check T1-js-detect "$(bash "$L" detect "$tmp/js" | tr '\n' ' ')" \
  "@tanstack/react-query react vite "
 # react-icons must NOT ride the react match (anchored full-key)
 mkdir -p "$tmp/near"
 printf '{"dependencies":{"react-icons":"^5","express":"^5"}}' \
  > "$tmp/near/package.json"
 check T2-near-miss "$(bash "$L" detect "$tmp/near" >/dev/null 2>&1; echo $?)" 1
 # --- detect: python manifest + stable-tech project (exit 1) ---
 mkdir -p "$tmp/py"
 printf 'fastapi==0.115\nrequests>=2\n' > "$tmp/py/requirements.txt"
 check T3-py-detect "$(bash "$L" detect "$tmp/py")" "fastapi"
 mkdir -p "$tmp/cpp"
 check T4-none "$(bash "$L" detect "$tmp/cpp" >/dev/null 2>&1; echo $?)" 1
 # --- cache-status: missing / fresh / stale ---
 check T5-missing "$(bash "$L" cache-status "$tmp/js" || true)" missing
 mkdir -p "$tmp/js/.ctx7-cache"; touch "$tmp/js/.ctx7-cache/react-core.md"
 check T6-fresh "$(bash "$L" cache-status "$tmp/js")" fresh
 touch -d '10 days ago' "$tmp/js/.ctx7-cache/react-core.md"
 check T7-stale "$(bash "$L" cache-status "$tmp/js" || true)" stale
 # --- hook: fires once per session, silent on stable projects ---
 hook() { printf '{"prompt":"add a hook","session_id":"%s","cwd":"%s"}' \
  "$1" "$2" | TMPDIR="$tmp" bash "$H"; }
 check H1-fires "$(hook s1 "$tmp/js" | grep -c 'Fast-moving')" 1
 check H2-once "$(hook s1 "$tmp/js" | wc -l)" 0
 check H3-cpp-quiet "$(hook s2 "$tmp/cpp" | wc -l)" 0
 check H4-notif-quiet \
  "$(printf '{"prompt":"<task-notification>x","session_id":"s3","cwd":"%s"}' \
    "$tmp/js" | TMPDIR="$tmp" bash "$H" | wc -l)" 0
 printf 'PASS=%s FAIL=%s\n' "$pass" "$fail"; [ "$fail" -eq 0 ]
@@ -9,10 +9,12 @@ set -u
 REPO="$(cd "$(dirname "$0")/../.." && pwd)"
 INC="$REPO/lib/verify-secure-loop.md"
-FEA="$REPO/agents/feater.md"
+FSK="$REPO/skills/feat/SKILL.md"
 BUG="$REPO/agents/bugfixer.md"
 BSK="$REPO/skills/bugfix/SKILL.md"
 HOT="$REPO/agents/hotfixer.md"
 HSK="$REPO/skills/hotfix/SKILL.md"
 HSKL="$REPO/skills/hotfix/SKILL.md"
 PASS=0; FAIL=0
 tf() { # tf <label> <file> <fixed-string>
@@ -29,6 +31,13 @@ tr_() { # tr_ <label> <file> <ERE>
    echo "  FAIL $1 — no match: $3"; FAIL=$((FAIL+1))
  fi
 }
 tn() { # tn <label> <file> <fixed-string> — PASS when ABSENT (mirror of tf, inverted)
  if grep -qF -- "$3" "$2" 2>/dev/null; then
    echo "  FAIL $1 — present (should be absent): $3"; FAIL=$((FAIL+1))
  else
    echo "  PASS $1"; PASS=$((PASS+1))
  fi
 }
 echo "── verify-secure-loop.md (shared include) ──"
 if [ -f "$INC" ]; then echo "  PASS include exists"; PASS=$((PASS+1)); else echo "  FAIL include missing"; FAIL=$((FAIL+1)); fi
@@ -43,27 +52,39 @@ tf "order invariant"            "$INC" "always re-checked BEFORE security"
 tf "mute never a pass (verify)" "$INC" "NEVER a PASS"
 tf "nominal cheap stated"       "$INC" "one verifier dispatch + one security dispatch"
-echo "── feater.md (feat wiring) ──"
+echo "── feat/SKILL.md (feat orchestrator wiring) ──"
-tf "feat contract step"         "$FEA" "STEP 0.7 — CONTRACT"
+tf "feat contract step"         "$FSK" "STEP 0.7 — CONTRACT"
-tf "feat contract-interview"    "$FEA" "lib/contract-interview.md"
+tf "feat contract-interview"    "$FSK" "lib/contract-interview.md"
-tf "feat verify+secure step"    "$FEA" "STEP 3 — VERIFY + SECURE"
+tf "feat verify+secure step"    "$FSK" "STEP 4 — VERIFY + SECURE"
-tf "feat uses shared include"   "$FEA" "lib/verify-secure-loop.md"
+tf "feat uses shared include"   "$FSK" "lib/verify-secure-loop.md"
-tf "feat nominal 1+1 dispatch"  "$FEA" "verifier + one security dispatch"
+tf "feat nominal 1+1 dispatch"  "$FSK" "verifier + one security dispatch"
 tf "feat dispatches feater"     "$FSK" 'subagent_type="feater"'
-echo "── bugfixer.md (bugfix wiring) ──"
+echo "── skills/bugfix/SKILL.md (bugfix wiring — reflection inline) ──"
-tf "bug contract step"          "$BUG" "STEP 3.5 — CONTRACT"
+tf "bug contract step"          "$BSK" "STEP 3.5 — CONTRACT"
-tf "bug diagnosis feeds it"     "$BUG" "feeds it: REQUEST verbatim"
+tf "bug diagnosis feeds it"     "$BSK" "feeds it: REQUEST verbatim"
-tf "bug fresh gates"            "$BUG" "Fresh gates (verify + secure)"
+tf "bug fresh gates"            "$BSK" "the two fresh gates per"
-tf "bug uses shared include"    "$BUG" "lib/verify-secure-loop.md"
+tf "bug uses shared include"    "$BSK" "lib/verify-secure-loop.md"
 tf "bug dispatches bugfixer"    "$BSK" 'subagent_type="bugfixer"'
-echo "── hotfixer.md (hotfix wiring — revert, not loop) ──"
+echo "── agents/bugfixer.md (bugfix executor — sonnet, no Agent) ──"
-tr_ "hotfix has Agent tool"     "$HOT" "^tools:.*Agent"
+tn "bugfixer lacks Agent tool"  "$BUG" "Agent"
-tf "hotfix silent contract"     "$HOT" "STEP 1.7 — CONTRACT (silent autofill)"
+tf "bugfixer model sonnet"      "$BUG" "model: sonnet"
-tf "hotfix zero questions"      "$HOT" "questions ever"
+tf "bugfixer report grammar"    "$BUG" "BUGFIX-EXEC REPORT"
-tf "hotfix security gate"       "$HOT" "Security gate (fresh auditor)"
+
-tf "hotfix block reverts"       "$HOT" "failure REVERTS, never loops"
+echo "── hotfixer.md (hotfix executor — sonnet, no Agent) ──"
-tf "hotfix no verifier"         "$HOT" "No verifier is dispatched at hotfix weight"
+tn "hotfixer lacks Agent tool"  "$HOT" "Agent"
 tf "hotfixer model sonnet"      "$HOT" "model: sonnet"
 tf "hotfixer report grammar"    "$HOT" "HOTFIX-EXEC REPORT"
 echo "── skills/hotfix/SKILL.md (hotfix wiring — revert, not loop) ──"
 tf "hotfix silent contract"     "$HSKL" "STEP 1.7 — CONTRACT (silent autofill)"
 tf "hotfix zero questions"      "$HSKL" "questions ever"
 tf "hotfix security gate"       "$HSKL" "Security gate (fresh auditor)"
 tf "hotfix block reverts"       "$HSKL" "failure REVERTS, never loops"
 tf "hotfix no verifier"         "$HSKL" "No verifier is dispatched at hotfix weight"
 tf "hotfix skill has Agent"     "$HSK" "  - Agent"
 tf "hotfix dispatches hotfixer" "$HSKL" 'subagent_type="hotfixer"'
 echo ""
 echo "loops-light structure locks: $PASS pass, $FAIL fail"
@@ -0,0 +1,25 @@
 #!/usr/bin/env bash
 # lib/tests/model-check.test.sh — flip-tests for lib/model-check.sh (LRN-096)
 set -u
 S="$(cd "$(dirname "$0")/../.." && pwd)/lib/model-check.sh"
 pass=0; fail=0
 check() { if [ "$2" = "$3" ]; then pass=$((pass+1)); else fail=$((fail+1));
  printf 'FAIL %s: got[%s] want[%s]\n' "$1" "$2" "$3"; fi; }
 T="$(mktemp -d)"; trap 'rm -rf "$T"' EXIT
 fx()  { printf '{"model": "%s"}' "$1" > "$T/s.json"; }
 run() { MODEL_CHECK_SETTINGS="$T/s.json" bash "$S" >"$T/out" 2>&1; echo "$?"; }
 fx 'claude-fable-5[1m]';        check T1-fable-exit "$(run)" 0
 check T1-fable-class "$(cut -d: -f1 <"$T/out")" big
 fx 'claude-opus-4-8';           check T2-opus       "$(run)" 0
 fx 'claude-sonnet-5';           check T3-sonnet     "$(run)" 2
 fx 'claude-haiku-4-5-20251001'; check T4-haiku      "$(run)" 2
 fx 'opusplan';                  check T5-opusplan   "$(run)" 3
 fx 'gpt-9-mega';                check T6-foreign    "$(run)" 3
 printf '{"no_model": true}' > "$T/s.json"; check T7-no-key    "$(run)" 3
 printf '{broken'            > "$T/s.json"; check T8-malformed "$(run)" 3
 check T9-missing-file "$(MODEL_CHECK_SETTINGS="$T/absent.json" bash "$S" >/dev/null 2>&1; echo $?)" 3
 printf 'model-check: %d pass, %d fail\n' "$pass" "$fail"
 [ "$fail" -eq 0 ]
@@ -0,0 +1,169 @@
 #!/usr/bin/env bash
 # lib/tests/model-routing.test.sh — census: gate wiring + pins + executor shape (BDR-066, BDR-076)
 set -u
 R="$(cd "$(dirname "$0")/../.." && pwd)"
 pass=0; fail=0
 ok() { pass=$((pass+1)); }
 ko() { fail=$((fail+1)); printf 'FAIL %s\n' "$1"; }
 has()   { if grep -qF "$2" "$R/$1"; then ok; else ko "$1 missing: $2"; fi; }
 lacks() { if grep -qF "$2" "$R/$1"; then ko "$1 must NOT contain: $2"; else ok; fi; }
 fm_lacks() { if awk 'NR<=10' "$R/$1" | grep -qF "$2"; then ko "$1 frontmatter must NOT contain: $2"; else ok; fi; }
 # 1) gate wired in the 15 reflection skills (orchestrators + /analyze)
 for s in ship-feature init-project feat bugfix onboard seo geo web-validate harden audit-delta tour code-clean hotfix client-handover analyze; do
  has "skills/$s/SKILL.md" 'lib/model-gate.md'
 done
 # 2) gate NOT wired in the pure-execution/read-only skills (exclusion list)
 for s in commit-change doc status release-candidate refactor; do
  lacks "skills/$s/SKILL.md" 'lib/model-gate.md'
 done
 # 3) executor + gate pins
 has "agents/feater.md"          'model: sonnet'
 has "agents/hotfixer.md"        'model: sonnet'
 has "agents/verifier.md"        'model: sonnet'
 has "agents/security-auditor.md" 'model: sonnet'
 has "agents/analyzer.md"        'model: opus'
 # 4) /feat executor shape
 has "skills/feat/SKILL.md" 'subagent_type="feater"'
 has "skills/feat/SKILL.md" 'verify-secure-loop.md'
 lacks "agents/feater.md" 'AskUserQuestion'
 # 5) SDD execution pinned
 has "skills/ship-feature/SKILL.md" 'model: "sonnet"'
 has "skills/init-project/SKILL.md" 'model: "sonnet"'
 # 6) web-validate applies via L1 applier
 has "skills/web-validate/SKILL.md" 'subagent_type="hotfixer"'
 # 7) wave-2 — pure-execution skills dispatch their agent (pin takes effect, off the big session model)
 has "skills/doc/SKILL.md"               'subagent_type="doc-syncer"'
 has "skills/status/SKILL.md"            'subagent_type="status-reporter"'
 has "skills/commit-change/SKILL.md"     'subagent_type="commit-changer"'
 has "skills/release-candidate/SKILL.md" 'subagent_type="release-executor"'
 has "skills/hotfix/SKILL.md"            'subagent_type="hotfixer"'
 has "agents/commit-changer.md"          'model: sonnet'
 has "agents/release-executor.md"        'model: sonnet'
 lacks "agents/commit-changer.md"        'AskUserQuestion'
 # 8) wave-3 — bugfix/code-clean reflection-split executors (skills stay gated)
 has "skills/bugfix/SKILL.md"     'subagent_type="bugfixer"'
 has "agents/bugfixer.md"         'model: sonnet'
 lacks "agents/bugfixer.md"       'AskUserQuestion'
 has "skills/code-clean/SKILL.md" 'subagent_type="code-cleaner"'
 has "agents/code-cleaner.md"     'model: sonnet'
 lacks "agents/code-cleaner.md"   'AskUserQuestion'
 # 9) wave-4 — client-handover: pipeline (big) inline + gated, doc-gen dispatched to sonnet
 has "agents/handover-doc-writer.md"     'model: sonnet'
 lacks "agents/handover-doc-writer.md"   'AskUserQuestion'
 lacks "agents/handover-doc-writer.md"   'Agent('
 has "agents/client-handover-writer.md"  'subagent_type="handover-doc-writer"'
 # 10) post-merge edge fixes (ronde): F1 feater applier carve-out, F2 /refactor
 #     dispatch + pin, F3 /analyze gated (in loop 1)
 has "agents/feater.md"                       'Applier path'
 has "skills/refactor/SKILL.md"               'subagent_type="refactorer"'
 has "agents/refactorer.md"                   'model: sonnet'
 # 11) BDR-076/077 — session model = orchestration + inline reflection ONLY.
 #     Dispatched judgment agents pinned OPUS. validator-analyzer TIERED DOWN
 #     to sonnet (W3 — deterministic validator-runner + fixed deduction
 #     tables, no deep judgment; approved plan). Inline-load-only agents
 #     (interviewer, client-handover-writer) STAY unpinned: they run IN the
 #     main loop, a frontmatter pin there is inert and misleads.
 has "agents/seo-analyzer.md"                 'model: opus'
 has "agents/geo-analyzer.md"                 'model: opus'
 has "agents/validator-analyzer.md"           'model: sonnet'
 has "agents/plan-challenger.md"              'model: opus'
 fm_lacks "agents/client-handover-writer.md"  'model:'
 fm_lacks "agents/interviewer.md"             'model:'
 has "skills/onboard/SKILL.md"                'model="opus"'
 has "skills/tour/SKILL.md"                   'model="opus"'
 has "lib/challenge-plan.md"                  'BDR-076'
 # 12) BDR-077 W1 — no-inherit: skill-runner children pinned fable at every
 #     call site; code-review dispatches carry opus; doctrine in model-gate.
 #     (fable dispatch alias spike-verified 2026-07-19: resolves
 #     claude-fable-5, enum-validated, loud failure — never silent fallback)
 has "agents/client-handover-writer.md"       'model: "fable"'
 has "skills/ship-feature/SKILL.md"           'model: "opus"'
 has "skills/init-project/SKILL.md"           'model: "opus"'
 has "lib/model-gate.md"                      'model: "fable"'
 lacks "lib/model-gate.md"                    'model: "sonnet" in the Agent call'
 # 13) BDR-077 W2 — plugin split: probe (sonnet, facts only) + advisor
 #     reasoner (opus, PROBE REPORT is ground truth, fail-closed); gate
 #     include owns checkpoint + apply; 4 consumers run the include, none
 #     inline-loads the advisor anymore
 has "agents/plugin-probe.md"                 'model: sonnet'
 lacks "agents/plugin-probe.md"               'AskUserQuestion'
 has "agents/plugin-advisor.md"               'model: opus'
 has "agents/plugin-advisor.md"               'PROBE REPORT'
 lacks "agents/plugin-advisor.md"             'PHASE 1 — DETECT'
 has "lib/plugin-gate.md"                     'subagent_type="plugin-probe"'
 has "lib/plugin-gate.md"                     'subagent_type="plugin-advisor"'
 for s in plugin-check onboard init-project ship-feature; do
  has "skills/$s/SKILL.md" 'lib/plugin-gate.md'
  # shellcheck disable=SC2016 # literal $HOME wanted: matching the exact inline-load string
  lacks "skills/$s/SKILL.md" 'Load `$HOME/.claude/agents/plugin-advisor.md`'
 done
 # 14) BDR-077 W2/S2 — doc pipeline: ONE agent, TWO modes around the
 #     dispatcher's gate (audit = opus via call-site override — documented
 #     precedence over the sonnet pin; patch = sonnet pin). Gate hoisted out
 #     of the agent (a dispatched agent cannot ask); CHANGE SUMMARY crosses
 #     the dispatch boundary into doc-commit (LRN-126); scaffolder carries no
 #     doc step; no consumer inline-loads doc-syncer anymore.
 has "agents/doc-syncer.md"                   'MODE: audit'
 has "agents/doc-syncer.md"                   'MODE: patch'
 has "agents/doc-syncer.md"                   'CHANGE SUMMARY'
 has "agents/doc-syncer.md"                   'DISPATCHER PROTOCOL'
 has "lib/doc-commit.md"                      'CHANGE SUMMARY'
 has "skills/doc/SKILL.md"                    'model="opus"'
 has "skills/doc/SKILL.md"                    'MODE: patch'
 lacks "agents/scaffolder.md"                 'INLINE-LOAD'
 for s in bugfix hotfix feat ship-feature init-project; do
  has "skills/$s/SKILL.md" 'MODE: audit'
  has "skills/$s/SKILL.md" 'doc-syncer", model="opus"'
  # shellcheck disable=SC2016 # literal $HOME wanted: matching the exact inline-load string
  lacks "skills/$s/SKILL.md" 'Load `$HOME/.claude/agents/doc-syncer.md`'
 done
 # 15) BDR-077 W2 — last inline execution converted: scaffolder + onboarder
 #     are DISPATCHED (pins live); their gates/arbitration stay in the
 #     orchestrator loop
 has "skills/init-project/SKILL.md"           'subagent_type="scaffolder"'
 has "skills/onboard/SKILL.md"                'subagent_type="onboarder"'
 # shellcheck disable=SC2016
 lacks "skills/init-project/SKILL.md"         'Load `$HOME/.claude/agents/scaffolder.md`'
 # shellcheck disable=SC2016
 lacks "skills/onboard/SKILL.md"              'Load `$HOME/.claude/agents/onboarder.md`'
 # 16) BDR-077 W3 — commit-changer per-mode override: propose = opus at the
 #     call site (documented precedence over the sonnet pin), apply = pin
 has "skills/commit-change/SKILL.md"          'model="opus"'
 has "agents/commit-changer.md"               'MODE: propose'
 has "agents/commit-changer.md"               'model: sonnet'
 # 17) BDR-077 W4 — handover two-mode: synthesize = opus at the call site
 #     (STEP 9/10/12 → run-scoped .audit/ draft + DRAFT COMPLETE sentinel),
 #     render = sonnet pin (STEP 13-16, fail-closed on absent/mismatched
 #     draft). Name + dispatch-string locks of §9 survive untouched.
 has "agents/handover-doc-writer.md"          'MODE: synthesize'
 has "agents/handover-doc-writer.md"          'MODE: render'
 has "agents/handover-doc-writer.md"          'DRAFT COMPLETE'
 has "agents/client-handover-writer.md"       'MODE: synthesize'
 has "agents/client-handover-writer.md"       'handover-doc-writer", model="opus"'
 # 18) BDR-077 W5 — seo/geo 3-mode pipelines: collect/template = sonnet at
 #     the call site, judge = opus PIN (fail-safe direction: a forgotten
 #     override over-tiers, never downgrades judgment). Run-scoped signals
 #     handoff + completeness sentinel + fail-closed judge + dispatcher
 #     ERROR contract (mute/ERROR judge never carried into templating).
 #     Body text unmoved — seo-data.test.sh fetch-wiring locks survive.
 has "agents/seo-analyzer.md"                 'MODE: collect'
 has "agents/seo-analyzer.md"                 'MODE: judge'
 has "agents/seo-analyzer.md"                 'MODE: template'
 has "agents/seo-analyzer.md"                 'COLLECTION COMPLETE'
 has "agents/geo-analyzer.md"                 'MODE: collect'
 has "agents/geo-analyzer.md"                 'MODE: judge'
 has "agents/geo-analyzer.md"                 'MODE: template'
 has "agents/geo-analyzer.md"                 'COLLECTION COMPLETE'
 has "skills/seo/SKILL.md"                    'MODE: collect'
 has "skills/seo/SKILL.md"                    'seo-analyzer", model="sonnet"'
 has "skills/seo/SKILL.md"                    'never re-derive a score'
 has "skills/seo/SKILL.md"                    'DISPATCHER ERROR CONTRACT'
 has "skills/geo/SKILL.md"                    'MODE: collect'
 has "skills/geo/SKILL.md"                    'geo-analyzer", model="sonnet"'
 has "skills/geo/SKILL.md"                    'ERROR CONTRACT'
 has "skills/geo/SKILL.md"                    'never re-derive a score'
 has "agents/handover-doc-writer.md"          'SYNTH REPORT'
 printf 'model-routing census: %d pass, %d fail\n' "$pass" "$fail"
 [ "$fail" -eq 0 ]
@@ -0,0 +1,48 @@
 #!/usr/bin/env bash
 # lib/tests/plan-challenger.test.sh — structure lock: the plan-challenger agent,
 # the reusable lib/challenge-plan.md phase, and every reflection orchestrator that
 # wires it (3-way adversarial plan challenge, BDR-066). STATIC only — the agent's
 # adversarial behavior needs a live model (manual smoke), not a CI gate.
 set -u
 R="$(cd "$(dirname "$0")/../.." && pwd)"
 pass=0; fail=0
 ok() { pass=$((pass+1)); }
 ko() { fail=$((fail+1)); printf 'FAIL %s\n' "$1"; }
 has() { if grep -qF "$2" "$R/$1"; then ok; else ko "$1 missing: $2"; fi; }
 fm_lacks() { if awk 'NR<=10' "$R/$1" | grep -qF "$2"; then ko "$1 frontmatter must NOT contain: $2"; else ok; fi; }
 A="agents/plan-challenger.md"
 L="lib/challenge-plan.md"
 # 1) agent shape
 has "$A" "name: plan-challenger"
 has "$A" "tools: Read, Grep, Glob, Bash"
 fm_lacks "$A" "model: sonnet"                        # BDR-066: audit judgment → NOT sonnet-pinned
 has "$A" "CHALLENGE — LENS:"                          # load-bearing verdict grammar
 has "$A" "VERDICT: SOLID | CONCERNS(n) | FATAL(n)"
 has "$A" "correctness"
 has "$A" "robustness"
 has "$A" "simplicity"
 has "$A" "Report-only"
 # 2) reusable phase — the mechanism lives here (one canonical include)
 has "$L" 'subagent_type="plan-challenger"'
 has "$L" "BDR-066"                                   # challengers on the big model
 has "$L" "a mute verifier is NEVER a PASS"           # fail-safe (never fail open)
 has "$L" "Severity-driven"                           # any single-lens BLOCKER = must-address
 has "$L" "RE-THINK"                                  # findings re-plan the aspect, not just noted
 has "$L" "correctness | robustness | simplicity"
 has "$L" "CHALLENGE SUMMARY"
 has "$L" "build-plan"                                # the three KINDs
 has "$L" "proposals"
 has "$L" "fix-bundle"
 # 3) every reflection orchestrator wires the phase + carries a challenge summary
 #    (hotfix wires it under a logic-only guard — STEP 1.8)
 for s in ship-feature init-project feat bugfix hotfix onboard audit-delta code-clean seo geo harden web-validate; do
  has "skills/$s/SKILL.md" "lib/challenge-plan.md"
  has "skills/$s/SKILL.md" "CHALLENGE SUMMARY"
 done
 printf 'plan-challenge structure lock: %d pass, %d fail\n' "$pass" "$fail"
 [ "$fail" -eq 0 ]
@@ -0,0 +1,76 @@
 #!/usr/bin/env bash
 # lib/tests/source-scope.test.sh
 set -u
 S="$(cd "$(dirname "$0")/../.." && pwd)/lib/source-scope.sh"
 pass=0; fail=0
 check() { if [ "$2" = "$3" ]; then pass=$((pass+1)); else fail=$((fail+1));
  printf 'FAIL %s: got[%s] want[%s]\n' "$1" "$2" "$3"; fi; }
 # does `list` (run inside dir $1) contain the name $2?
 listed() { ( cd "$1" && bash "$S" list 2>/dev/null | grep -qxF "$2" ) \
  && echo yes || echo no; }
 TMP="$(mktemp -d)"
 # --- always-excluded build output + caches ---
 mkdir -p "$TMP/plain"
 for d in node_modules .git dist build .next .nuxt .output _site .astro \
         .svelte-kit .cache out coverage .vercel .netlify .turbo; do
  check "A-$d-listed" "$(listed "$TMP/plain" "$d")" yes
 done
 # --- public/ is SOURCE by default: Astro/Vite/Next keep favicon.ico,
 #     apple-touch-icon.png and robots.txt there, and the audit checks them ---
 check B1-public-kept-by-default "$(listed "$TMP/plain" public)" no
 # --- public/ is OUTPUT for Gatsby and Hugo only ---
 mkdir -p "$TMP/gatsby";  : > "$TMP/gatsby/gatsby-config.js"
 check B2-gatsby-js   "$(listed "$TMP/gatsby" public)" yes
 mkdir -p "$TMP/gatsby2"; : > "$TMP/gatsby2/gatsby-config.ts"
 check B3-gatsby-ts   "$(listed "$TMP/gatsby2" public)" yes
 mkdir -p "$TMP/hugo";    : > "$TMP/hugo/hugo.toml"
 check B4-hugo-toml   "$(listed "$TMP/hugo" public)" yes
 mkdir -p "$TMP/hugo2";   : > "$TMP/hugo2/hugo.yaml"
 check B5-hugo-yaml   "$(listed "$TMP/hugo2" public)" yes
 # legacy config.toml alone is ambiguous (many tools use it) — needs archetypes/
 mkdir -p "$TMP/amb";     : > "$TMP/amb/config.toml"
 check B6-config-toml-alone-is-ambiguous "$(listed "$TMP/amb" public)" no
 mkdir -p "$TMP/hugo3/archetypes"; : > "$TMP/hugo3/config.toml"
 check B7-config-toml-plus-archetypes    "$(listed "$TMP/hugo3" public)" yes
 # --- grep mode: flags, and no glob character (safe unquoted) ---
 G="$(cd "$TMP/plain" && bash "$S" grep)"
 case "$G" in *--exclude-dir=dist*) check C1-grep-has-dist ok ok ;;
  *) check C1-grep-has-dist "missing" ok ;; esac
 case "$G" in *"*"*) check C2-grep-has-no-glob "has-glob" ok ;;
  *) check C2-grep-has-no-glob ok ok ;; esac
 # --- findargs: one token per line, 3 tokens per dir ---
 N="$(cd "$TMP/plain" && bash "$S" findargs | wc -l)"
 D="$(cd "$TMP/plain" && bash "$S" list | wc -l)"
 check D1-findargs-3-tokens-per-dir "$N" "$((D * 3))"
 check D2-findargs-first-token "$(cd "$TMP/plain" && bash "$S" findargs | head -1)" '!'
 # --- FUNCTIONAL: the array form actually excludes build output ---
 # A flat unquoted string does NOT work here: the shell globs */dist/* against
 # the CWD and passes the matches to find as search paths. Measured on a real
 # repo, that turned 90 hits into 135 and kept every dist/ file.
 W="$TMP/work"; mkdir -p "$W/src" "$W/dist" "$W/public" "$W/node_modules"
 : > "$W/src/a.png"; : > "$W/dist/a.png"; : > "$W/public/favicon.ico"
 : > "$W/node_modules/dep.png"
 cd "$W" || exit 1
 mapfile -t FEXCL < <(bash "$S" findargs)
 check E1-excludes-dist  "$(find . "${FEXCL[@]}" -name 'a.png' | grep -c '/dist/')"  0
 check E2-keeps-src      "$(find . "${FEXCL[@]}" -name 'a.png' | grep -c '/src/')"   1
 check E3-excludes-nodem "$(find . "${FEXCL[@]}" -name '*.png' | grep -c 'node_modules')" 0
 # public/ survives: the audit's own resource checks live there
 check E4-keeps-public   "$(find . "${FEXCL[@]}" -name 'favicon.ico' | wc -l)" 1
 cd / || exit 1
 # --- usage ---
 bash "$S" >/dev/null 2>&1;        check X1-no-args  "$?" 2
 bash "$S" bogus >/dev/null 2>&1;  check X2-bad-verb "$?" 2
 # `find` was renamed to `findargs` when the flat-string form proved unsafe
 bash "$S" find >/dev/null 2>&1;   check X3-old-find-verb-gone "$?" 2
 rm -rf "$TMP"
 printf 'PASS=%s FAIL=%s\n' "$pass" "$fail"; [ "$fail" -eq 0 ]
@@ -0,0 +1,74 @@
 #!/usr/bin/env bash
 # lib/tests/url-guard.test.sh
 set -u
 G="$(cd "$(dirname "$0")/../.." && pwd)/lib/url-guard.sh"
 pass=0; fail=0
 check() { if [ "$2" = "$3" ]; then pass=$((pass+1)); else fail=$((fail+1));
  printf 'FAIL %s: got[%s] want[%s]\n' "$1" "$2" "$3"; fi; }
 # rc of a guard call, output discarded
 rc()  { bash "$G" "$1" "$2" >/dev/null 2>&1; return $?; }
 # stdout of a guard call (empty on refusal)
 out() { bash "$G" "$1" "$2" 2>/dev/null; }
 # --- hosts that must pass, echoing back unchanged ---
 rc host "example.com";            check H1-plain          "$?" 0
 rc host "www.sub.example.co.uk";  check H2-subdomains     "$?" 0
 rc host "my-site.fr";             check H3-hyphen         "$?" 0
 check H4-echoes-input "$(out host example.com)" "example.com"
 # --- shell metacharacters: the reason this guard exists ---
 # Inside the double quotes seo-analyzer.md:257 uses, $ ` \ " break out.
 rc host 'x$(id)';                            check H5-cmdsubst       "$?" 2
 rc host 'x`id`';                             check H6-backtick       "$?" 2
 rc host 'x;id';                              check H7-semicolon      "$?" 2
 rc host 'x|id';                              check H8-pipe           "$?" 2
 rc host 'x&id';                              check H9-ampersand      "$?" 2
 rc host 'x"';                                check H10-dquote        "$?" 2
 rc host "x'";                                check H11-squote        "$?" 2
 rc host 'x\y';                               check H12-backslash     "$?" 2
 rc host 'x y';                               check H13-space         "$?" 2
 rc host 'a
 b';                                          check H14-newline       "$?" 2
 # the real payload: read the OAuth vault into a request
 rc host 'x$(cat ${HOME}/.claude/.env)';      check H15-env-exfil     "$?" 2
 check H16-refusal-is-silent "$(out host 'x$(id)')" ""
 # --- literal local / private / metadata targets ---
 rc host "localhost";        check L1-localhost        "$?" 2
 rc host "LOCALHOST";        check L2-case-folded      "$?" 2
 rc host "127.0.0.1";        check L3-loopback         "$?" 2
 rc host "10.1.2.3";         check L4-private-10       "$?" 2
 rc host "192.168.1.1";      check L5-private-192      "$?" 2
 rc host "172.16.0.1";       check L6-private-172-lo   "$?" 2
 rc host "172.31.255.254";   check L7-private-172-hi   "$?" 2
 rc host "172.32.0.1";       check L8-172-32-is-public "$?" 0
 rc host "169.254.169.254";  check L9-link-local       "$?" 2
 rc host "metadata.google.internal"; check L10-gcp-metadata "$?" 2
 rc host "0.0.0.0";          check L11-any-addr        "$?" 2
 rc host "printer.local";    check L12-mdns            "$?" 2
 # --- urls ---
 rc url "https://example.com/";                    check U1-https        "$?" 0
 rc url "http://example.com/a/b?x=1&y=2";          check U2-query        "$?" 0
 rc url "https://example.com:8443/p";              check U3-port         "$?" 0
 rc url "https://example.com/a%20b#frag";          check U4-pct-and-frag "$?" 0
 check U5-echoes-input "$(out url https://example.com/x)" "https://example.com/x"
 rc url "ftp://example.com/";                      check U6-ftp          "$?" 2
 rc url "file:///etc/passwd";                      check U7-file         "$?" 2
 rc url "gopher://example.com/";                   check U8-gopher       "$?" 2
 rc url "example.com";                             check U9-no-scheme    "$?" 2
 rc url 'https://example.com/$(id)';               check U10-cmdsubst    "$?" 2
 rc url 'https://example.com/`id`';                check U11-backtick    "$?" 2
 rc url "https://localhost/x";                     check U12-local       "$?" 2
 rc url "https://127.0.0.1:8080/admin";            check U13-loopback    "$?" 2
 # authority confusion: the real host is after the @, not before it
 rc url "https://trusted.com@127.0.0.1/";          check U14-userinfo-local "$?" 2
 rc url "https://trusted.com@evil.com/";           check U15-userinfo-any   "$?" 2
 # --- usage ---
 rc host "";                                    check X1-host-empty    "$?" 2
 bash "$G" >/dev/null 2>&1;                     check X2-no-args       "$?" 2
 bash "$G" bogus x >/dev/null 2>&1;             check X3-bad-verb      "$?" 2
 bash "$G" host a b >/dev/null 2>&1;            check X4-extra-args    "$?" 2
 printf 'PASS=%s FAIL=%s\n' "$pass" "$fail"; [ "$fail" -eq 0 ]
@@ -0,0 +1,83 @@
 #!/usr/bin/env bash
 # Validate a host or URL BEFORE it reaches a shell command or curl.
 # Echoes the value on stdout when safe; exits 2 with a reason on stderr.
 #
 #   HOST="$(bash ~/.claude/lib/url-guard.sh host "$RAW")" || exit 2
 #   URL="$(bash ~/.claude/lib/url-guard.sh url "$RAW")"   || exit 2
 #
 # WHY: /seo and /geo interpolate externally-supplied strings into ~10 curl
 # commands (seo-analyzer.md:254+, geo-analyzer.md:248+). Today $DOMAIN is typed
 # by the operator, so the risk is self-inflicted. The sitemap crawl (C1) changes
 # that: URLs then come from the TARGET'S OWN SERVER — a remote file whose bytes
 # reach a shell. Inside the double quotes those curls use, the characters that
 # break out are $ ` \ " — so a <loc> of
 #   https://x/$(cat ${HOME}/.claude/.env)
 # would read GOOGLE_OAUTH_CLIENT_SECRET and CRUX_API_KEY straight out of the
 # vault and into a request. Allowlist, per CLAUDE.md: explicit allowlist beats
 # implicit denylist.
 #
 # DNS-level SSRF (a public hostname that RESOLVES to a private address, or
 # rebinds between check and connect): this NAME-level guard does not catch it —
 # closing it needs resolve-then-pin at the HTTP layer. That is now DONE for the
 # Python egress: lib/seo-data/safe_fetch.py pins every fetch (sitemap, linkgraph,
 # rendercheck, drift). It is NOT done for shell `curl`, which cannot pin without
 # `curl --resolve`; those paths keep this literal-local check only. Stated, not
 # silent — see lib/seo-data/README.md (safe_fetch).
 set -uo pipefail
 _die() { echo "url-guard: $1" >&2; exit 2; }
 # Whole-string charset guards: C locale + POSIX `case`, the same shape as
 # fetch.sh:25 _label_safe. Newline-proof and locale-independent, unlike a
 # per-line grep. No `$` or backtick inside the patterns, so nothing expands.
 _host_charset_ok() ( LC_ALL=C; case "$1" in
  ''|[!A-Za-z0-9]*|*[!A-Za-z0-9.-]*) exit 1 ;; esac )
 # Authority + path + query. Excludes $ ` \ " ' ; | ( ) * ! space and newline —
 # none of which a real sitemap URL needs, all of which a shell reads.
 _rest_charset_ok() ( LC_ALL=C; case "$1" in
  ''|*[!A-Za-z0-9._~:/?#@=\&%+,-]*) exit 1 ;; esac )
 # Literal local/private/metadata targets. This is a LITERAL check, not a DNS
 # one: it stops the obvious, not a hostname that resolves inward.
 _host_is_local() ( LC_ALL=C
  # ${1,,} not tr: no fork, and no SC2018/SC2019 noise. Safe because the
  # charset guard has already run — the string is [A-Za-z0-9.-] by here.
  case "${1,,}" in
    localhost|*.localhost|*.local|0.0.0.0|broadcasthost) exit 0 ;;
    127.*|10.*|169.254.*|192.168.*) exit 0 ;;
    172.1[6-9].*|172.2[0-9].*|172.3[01].*) exit 0 ;;
    metadata.google.internal|metadata) exit 0 ;;
    *) exit 1 ;;
  esac )
 _reject_local() { _host_is_local "$1" && _die "local/private target refused: '$1'"; return 0; }
 check_host() {
  _host_charset_ok "$1" || _die "host charset (allowed A-Za-z0-9.-): '$1'"
  _reject_local "$1"
  printf '%s\n' "$1"
 }
 check_url() {
  local rest host
  case "$1" in
    https://*) rest="${1#https://}" ;;
    http://*)  rest="${1#http://}"  ;;
    *) _die "scheme must be http or https: '$1'" ;;
  esac
  _rest_charset_ok "$rest" || _die "url charset: '$1'"
  host="${rest%%/*}"; host="${host%%\?*}"; host="${host%%#*}"
  # user@host hides the real target: https://trusted.com@127.0.0.1/ hits .0.0.1
  case "$host" in *@*) _die "userinfo in authority (confusion vector): '$1'" ;; esac
  host="${host%%:*}"                       # drop :port before validating the host
  _host_charset_ok "$host" || _die "host charset: '$host'"
  _reject_local "$host"
  printf '%s\n' "$1"
 }
 case "${1:-}" in
  host) [ $# -eq 2 ] || _die "usage: url-guard.sh host <hostname>"; check_host "$2" ;;
  url)  [ $# -eq 2 ] || _die "usage: url-guard.sh url <url>";       check_url  "$2" ;;
  *) _die "usage: url-guard.sh {host|url} <value>" ;;
 esac
@@ -2,8 +2,10 @@
 Runs in the ORCHESTRATOR MAIN LOOP after the dev step completes. Turns a
 finished diff into a verified, security-cleared change through two fresh
-gates and bounded loops. The dev stays inline (LRN-083: subagents =
+gates and bounded loops. Loop decisions live here, in the main loop
-execution + report; loop decisions live here, in the main loop).
+(LRN-083: subagents = execution + report). The dev step is a dispatched
 sonnet executor (feat's `feater`, bugfix's `bugfixer`): "hand the dev"
 below means re-dispatch a FRESH executor with exactly those inputs.
 Inputs the caller must have ready:
 - `CONTRACT`: path to the contract file written by `contract-interview.md`.
@@ -25,7 +27,8 @@ Parse its single `VERIFY — VERDICT:` line:
 - `CONFORME` → go to GATE 2. (First-pass conforme = no loop.)
 - `ECARTS(n)` → hand the dev the CONTRACT path + the exact `CRITERIA` gap
-  lines (NOT-MET / out-of-scope), nothing else. Dev fixes inline, then
+  lines (NOT-MET / out-of-scope), nothing else. Inline dev fixes in place;
  a dispatched dev is re-dispatched FRESH with those inputs only. Then
  re-dispatch a FRESH verifier. Repeat. **Max 3 conformity iterations** →
  STOP + human escalation with the CRITERIA table (the contract-vs-realized
  diff).
@@ -49,8 +52,8 @@ stdout-only, no Write).
 Parse its single `SECURITY — VERDICT:` line:
 - `PASS` → done, proceed to commit.
- `BLOCK(n)` → hand the dev the `BLOCKING` list + the CONTRACT path. Dev
+- `BLOCK(n)` → hand the dev the `BLOCKING` list + the CONTRACT path (inline
-  fixes inline. Then **re-verify the REQUEST first** (GATE 1, fresh
+  fix, or FRESH executor re-dispatch). Then **re-verify the REQUEST first** (GATE 1, fresh
  verifier) — a security fix can drift the behavior — **then re-run GATE 2**
  (fresh auditor), in that order. **Max 3 security iterations** → STOP +
  human escalation with the BLOCKING table.
@@ -134,11 +134,25 @@
      "Read(**/credentials.json)",
      "Read(**/.aws/credentials)",
      "Read(**/.azure/**)",
-      "Write(**/.env)",
+      "Edit(**/.env)",
-      "Write(**/.env.*)",
+      "Edit(**/.env.*)",
-      "Write(**/secrets/**)",
+      "Edit(**/secrets/**)",
-      "Write(**/*.pem)",
+      "Edit(**/*.pem)",
-      "Write(**/*.key)",
+      "Edit(**/*.key)",
      "Edit(**/*.p12)",
      "Edit(**/*.pfx)",
      "Edit(**/id_rsa*)",
      "Edit(**/id_ed25519*)",
      "Edit(**/.ssh/**)",
      "Edit(**/credentials)",
      "Edit(**/credentials.json)",
      "Edit(**/.aws/credentials)",
      "Edit(**/.azure/**)",
      "Edit(**/*.lock)",
      "Edit(**/package-lock.json)",
      "Edit(**/pnpm-lock.yaml)",
      "Edit(**/go.sum)",
      "Edit(**/node_modules/**)",
      "Bash(eval *)",
      "Bash(exec *)",
      "Bash(find * -delete*)",
@@ -257,16 +271,6 @@
            "command": "bash ~/.claude/hooks/rtk-rewrite.sh"
          }
        ]
      },
      {
        "matcher": "Edit|Write|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "bash ~/.claude/hooks/config-protection.sh",
            "timeout": 5
          }
        ]
      }
    ],
    "UserPromptSubmit": [
@@ -277,6 +281,12 @@
            "command": "bash ~/.claude/hooks/design-toolchain-reminder.sh",
            "timeout": 5,
            "statusMessage": "Checking design signals..."
          },
          {
            "type": "command",
            "command": "bash ~/.claude/hooks/ctx7-reminder.sh",
            "timeout": 5,
            "statusMessage": "Checking fast-libs..."
          }
        ]
      }
@@ -5,6 +5,10 @@ argument-hint: <file/area to analyze — OR paste error/stack trace for DEBUG mo
 allowed-tools: Read, Grep, Glob, Bash
 ---
 MODEL GATE (blocking): run `$HOME/.claude/lib/model-gate.md` BEFORE anything
 below. Verdict `small` → STOP — print the gate's remedy, end the turn, run
 no analysis. Deep factual analysis is reflection; it needs the big model.
 Load and follow strictly:
 - $HOME/.claude/agents/analyzer.md
@@ -22,6 +22,13 @@ allowed-tools:
 # /audit-delta — Incremental multi-axis code audit
 ## MODEL GATE (blocking — run before any other step)
 Run `$HOME/.claude/lib/model-gate.md`. Reflection here (planning, audit
 judgment, loop decisions) requires Fable/Opus. Verdict `small` → STOP: the
 gate prints the remedy; end the turn — no later step, no dispatch. Nominal
 (big) path is silent.
 Audit only what changed since the last run, on the axes the user picks.
 Per axis: **audit → approval gate → fix → re-verify → marker update**,
 strictly in that order, one axis fully closed before the next starts.
@@ -159,10 +166,31 @@ Append to `.claude/audits/AUDIT-DELTA.md` (create if absent), append-only:
 Then show the user the same compact table inline.
 ### 3b-bis. CHALLENGE THE PROPOSALS (before the gate)
 This axis' findings + proposed fixes are a proposal set worth attacking before
 the human gate. Persist THIS axis' finding list (not the whole append-only
 report) to `.claude/tasks/plans/<date>-<axis>-<HHMM>.md`, then run
 `$HOME/.claude/lib/challenge-plan.md` with `PLAN` = that file, `KIND` =
 `proposals`, `SCOPE` = this axis' STEP 1 audit set, `CONSTRAINTS` = the axis
 spec + the project CLAUDE.md norms already loaded. Three blind challengers ask
 whether these are the RIGHT findings/priorities and what the audit under-rated;
 the main loop RE-THINKS every aspect a BLOCKER lands (a named change to the
 finding set, or `[deferred <date>]`) and re-challenges once if it materially
 changed. Feed the REVISED findings + a CHALLENGE SUMMARY into 3c.
 ### 3c. APPROVAL GATE ★ MANDATORY STOP
 Show the CHALLENGE SUMMARY (from 3b-bis) with the 3b findings table, then
 AskUserQuestion: **fix all / pick which / none**.
 ```
 CHALLENGE SUMMARY (3b-bis — 3 lenses):
  BLOCKERs addressed : <n> — <finding → the named finding-set change that closes it>
  Deferred (human-ack): <list | none>
  Lenses returned    : correctness / robustness / simplicity (NAME any that failed to return)
 ```
 - "Fix what you find" said **in the invocation** does NOT skip this gate:
  nobody can approve findings that did not exist yet. The gate is about
  *these specific findings*.
@@ -20,9 +20,271 @@ allowed-tools:
  - Agent
 ---
-Load and follow strictly:
+# /bugfix — root-cause orchestrator (reflection inline, execution dispatched)
 - $HOME/.claude/agents/bugfixer.md
-Execute the BUGFIXER agent on the following target:
+MODEL GATE (blocking): run `$HOME/.claude/lib/model-gate.md` BEFORE any
 step below. Verdict `small` → STOP — print the gate's remedy, end the
 turn, dispatch nothing.
 ## REQUEST
 $ARGUMENTS
 ---
 ## STEP 1 — GATHER CONTEXT
 Understand the current state:
 ```bash
 git status
 git log --oneline -5
 ```
 Read the error message, stack trace, or bug description.
 Identify:
 - **What** is broken (symptom)
 - **Where** it manifests (file, line, endpoint, UI element)
 - **When** it started (recent commit? always? after a deploy?)
 ```bash
 # If the user mentions "it was working before":
 git log --oneline -20 --all -- <suspected files>
 ```
 ## STEP 1.5 — DESIGN GATE
 Follow `$HOME/.claude/lib/design-gate.md`:
 - Scan $ARGUMENTS and target files for design/UI/style signals (CSS, component, layout, animation).
 - If signals found → run `design-tool-gate.sh`; if it reports INCOMPLETE,
  tell the user to run `/profile design` before proceeding.
 - If no signals → skip (zero overhead).
 ## STEP 2 — INVESTIGATE
 Trace the bug from symptom to root cause:
 1. Read the code path involved (follow the data flow).
 2. Check recent changes to the affected files:
   ```bash
   git log --oneline -10 -- <file>
   git diff HEAD~5 -- <file>  # if recent regression suspected
   ```
 3. Look for related tests — do they pass? Do they cover
   the broken case?
 4. Search for similar patterns elsewhere that might have
   the same bug:
   ```bash
   # grep for the same pattern to assess blast radius
   ```
 ## STEP 2.5 — MEMORY READ-BEFORE (blockers-first)
 Run the scan per `$HOME/.claude/lib/analyze-before-plan.md`, blockers-weighted: a resolved
 BLK may already name THIS exact root cause; an in-force BDR may constrain the fix. Emit
 RELATED MEMORY. Consumption is NATURAL — the reflection that emits this IS what writes STEP 3's
 diagnosis (reader = planner, no external skill to inject into).
 TEETH: STEP 3's DIAGNOSIS must name any binding prior (`PRIOR: BLK-xxx — known cause/fix`,
 or `honors BDR-xxx`) OR the RELATED MEMORY line states none bears. Reading blockers then
 diagnosing without naming a match is the read-then-ignore failure this prevents.
 `.claude/memory/` absent → guarded no-op, proceed.
 ## STEP 3 — DIAGNOSE + PLAN
 Present findings before dispatching a fix:
 ```
 BUGFIX — DIAGNOSIS
 BUG     : <one-line symptom>
 ROOT CAUSE: <what is actually wrong and why>
 EVIDENCE: <what confirmed it — test, trace, diff>
 BLAST RADIUS: <other places affected, or "isolated">
 FIX PLAN:
  1. <file:line> — <what to change>
  2. <file:line> — <what to change>
  [3. <test file> — add/update test for this case]
 RISK: <low/medium — what could go wrong>
 ```
 - If the root cause is still unclear after investigation,
  say so explicitly. List remaining hypotheses ranked by
  probability. Ask the user before proceeding.
 - If the fix is trivial after investigation (1-2 lines):
  proceed directly — no need to wait for approval on an
  obvious fix.
 - If the fix is significant (>10 lines, multiple files,
  behavior change): wait for user approval.
 ## STEP 3b — CHALLENGE THE FIX PLAN (before the contract)
 Unless the fix is the trivial 1-2 line case STEP 3 already fast-paths, the
 DIAGNOSIS + FIX PLAN is a reflection worth attacking before it hardens into a
 contract. Persist it to `.claude/tasks/plans/<date>-<slug>-<HHMM>.md`, then run
 `$HOME/.claude/lib/challenge-plan.md` with `PLAN` = that file, `KIND` = `build-plan`,
 `SCOPE` = the FIX PLAN files, `CONSTRAINTS` = the STEP 2 in-force BDR/LRN/BLK
 dispositions. Three blind challengers attack it (correctness = is the root cause
 right; robustness = blast radius / regressions; simplicity = is the fix minimal);
 RE-THINK every aspect a BLOCKER lands, re-challenge once if the plan materially
 changed. STEP 3.5 writes the contract from the REVISED plan. Print a CHALLENGE SUMMARY
 (BLOCKERs addressed / deferred / lenses returned), folding any deferred BLOCKER into
 the STEP 3 approval gate.
 ## STEP 3.5 — CONTRACT
 Run `$HOME/.claude/lib/contract-interview.md` (main loop). The DIAGNOSIS
 feeds it: REQUEST verbatim = the bug report as received; ACCEPTANCE CRITERIA
 = the symptom reproduced-then-gone + a regression test present and passing;
 FILE SCOPE = the FIX PLAN files. Questions stay proportional (a clear,
 reproduced bug → zero). It writes the contract to
 `.claude/tasks/contracts/<date>-<slug>-<HHMM>.md`; keep the path — the
 executor reads it first and GATE 1 (STEP 6) hands it to a fresh verifier.
 ## STEP 4 — BRANCH
 **Gitflow aiguillage (before dispatch):** follow `$HOME/.claude/lib/gitflow-aiguillage.md`
 — your type = `bugfix`. On `main`/`develop` it branches first; on a working
 branch it's a no-op (commit in place). Never `finish`.
 ## STEP 5 — DISPATCH EXECUTOR
 Dispatch the executor — sonnet by frontmatter pin, do not override:
 ```
 Agent(subagent_type="bugfixer")
 prompt: "CONTRACT: <path from STEP 3.5>
 DIAGNOSIS: <ROOT CAUSE + EVIDENCE from STEP 3>
 FIX PLAN: <the STEP 3 FIX PLAN — exact edits + the regression test to add>
 BRANCH: <current branch — verify with git branch --show-current, never switch>
 Apply the fix to the letter + the regression test. No commit, no branch
 ops, no security dispatch. Finish with the BUGFIX-EXEC REPORT."
 ```
 Parse the `BUGFIX-EXEC REPORT`:
 - `STATUS : DONE` → STEP 6.
 - `STATUS : NEED-DECISION` → make the decision HERE (that is reflection),
  append it to the plan, re-dispatch a FRESH bugfixer with plan + decision.
  Max 2 decision round-trips → escalate to the user.
 - `STATUS : BLOCKED` → surface the blocker to the user, stop.
 ## STEP 6 — VERIFY + SECURE + PRE-COMMIT GATE + COMMIT (main loop, LRN-083)
 1. Run the two fresh gates per `$HOME/.claude/lib/verify-secure-loop.md` with
   `CONTRACT` = the STEP 3.5 path, `DIFF` = the executor's working-tree diff,
   `TEST` = the suite named in its report:
   - GATE 1 — a FRESH verifier judges the fix against the contract (bug gone
     + regression test present). CONFORME on the first pass → straight to
     GATE 2, no loop. ECARTS → the "dev" of the loop is the dispatched
     executor: re-dispatch a FRESH bugfixer with the CONTRACT path + the
     exact gap lines, nothing else. Max 3 → escalate.
   - GATE 2 — a FRESH security-auditor (`MODE: gate`) scans the diff (a bug
     fix can introduce a vuln). PASS → the pre-commit gate below. BLOCK →
     re-dispatch a FRESH bugfixer with the BLOCKING list + the CONTRACT
     path; re-verify the request THEN re-scan, max 3 → escalate.
   Loop decisions stay HERE, in the main loop (LRN-083). Nominal = one
   executor + one verifier + one security dispatch.
 2. **Pre-commit confirmation gate.** Before running `git commit`, present the diff
   summary and the proposed message, then wait for approval:
   ```
   BUGFIX — READY TO COMMIT
   FILE(S) : <list>
   DIFF    : <git diff --stat>
   MESSAGE :
     fix(<scope>): <root cause description>
     <what was wrong and why>
     <what the fix does>
   Commit now? (yes / edit message / skip / amend last)
   ```
   - `yes` → run `git commit`.
   - `edit message` → user provides corrected message; redraw gate.
   - `skip` → leave changes uncommitted, exit cleanly.
   - `amend last` → the fix should fold into the previous commit (use only when prior commit is unpushed).
 3. Commit using conventional format (after approval):
   ```
   fix(<scope>): <root cause description>
   <what was wrong and why>
   <what the fix does>
   ```
 4. Print summary:
   ```
   BUGFIX COMPLETE
   BUG        : <symptom>
   ROOT CAUSE : <one-line>
   FILE(S)    : <changed files>
   TEST(S)    : <added/updated tests, or "none — verified manually">
   REGRESSION : <checked areas>
   ```
 ## STEP 7 — DOC SYNC (automatic)
 Dispatch the doc pipeline (BDR-077 — audit judgment on opus, patch on the
 sonnet pin, gate HERE):
 1. `Agent(subagent_type="doc-syncer", model="opus")` — `MODE: audit` +
   `auto-mode scope: <list of files modified during this session>`.
 2. Silence (NONE) → done. `[MINOR]` PATCH PLAN → re-dispatch
   `Agent(subagent_type="doc-syncer")` with `MODE: patch` + the plan
   verbatim (no gate — auto behavior preserved; a `SHAPE ESCALATION` in
   its report comes back here, gated as SIGNIFICANT).
 3. SIGNIFICANT → gate here (`Apply? yes / no / select`), then
   `MODE: patch` with the approved subset.
 **Then commit the docs** — follow `$HOME/.claude/lib/doc-commit.md`: it surgically commits
 ONLY the files doc-syncer patched (its `PATCHED_FILES` output), never `git add -A`, never
 `.claude/`/`CLAUDE.md` (rc 4 = a loud BDR-022 anomaly, not a silent skip), and no-ops when
 nothing was patched — the common case for a trivial change. No FINISH in an inline flow, so
 it just commits the docs on the current branch (no ordering concern).
 ## STEP 8 — CAPITALIZE (memory registries)
 A bugfix with an understood root cause is almost always worth one entry:
 1. Propose a `BLK-XXX` entry in `.claude/memory/blockers.md` pre-filled from STEP 3 diagnosis:
   - `friction` = symptom
   - `real_cause` = root cause identified
   - `solution` = the fix applied
   - `status` = resolved
 2. If the root cause exposed a **reusable pattern** (would catch the same bug elsewhere or in other projects) → also propose an `LRN-XXX` entry in `.claude/memory/learnings.md`.
 3. Present as:
   ```
   CAPITALIZE — proposé
     BLK-XXX — <friction> — resolved
     [LRN-XXX — <pattern>]   (optionnel)
   Valider ? (all / blockers-only / edit / skip)
   ```
 4. Append approved entries + update the Index. Add a line to today's heading in `.claude/memory/journal.md`.
 **Language rule**: written entries are ALWAYS in English (see CLAUDE.md "Memory registries" § Language). The interactive gate may mirror the user's language; the appended entries must not.
 If the bug was trivial and the root cause not transferable → skip with `CAPITALIZE: trivial, skip`.
 **Then commit the memory** — follow `$HOME/.claude/lib/capitalize-commit.md`: it
 surgically commits what capitalize just wrote (`.claude/memory` + `.claude/tasks`
 only, never `git add -A`) as one `chore(memory)` commit, reports the memory-commit
 hash, and no-ops if nothing was written.
 ---
 ## RULES
 - No fix without understanding the root cause first (STEP 2/3).
 - Reflection (GATHER, INVESTIGATE, DIAGNOSIS, contract, loop decisions) NEVER
  leaves this main loop; execution NEVER stays in it — the executor is the
  sonnet-pinned bugfixer subagent (BDR-066).
 - The executor is re-dispatched FRESH on every round-trip (NEED-DECISION,
  ECARTS, BLOCK) — feedback travels as contract path + named
  gaps/decisions, never as transcript.
 - Design gate only if UI/style signals detected. See STEP 1.5.
 - If investigation reveals a design flaw requiring significant
  refactoring → stop, explain, suggest `/ship-feature` for the
  proper fix.
 - Always add a regression test when possible.
 - Keep the fix scoped. No "while we're here" cleanups.
 - If >5 files need changes → reconsider if `/ship-feature`
  is more appropriate.
@@ -9,7 +9,7 @@ description: |
  Triggers: "capitalize", "before clear/compact", "flush memory", "don't
  lose this", "avant de clear/compact", "capitalise ce qui manque",
  "close", "fin de journée", "checkpoint memory".
-argument-hint: "[--ritual] (scans conversation + git + TODO against .claude/memory/; --ritual adds the 3-question reflection)"
+argument-hint: "[--ritual] [--no-push] (scans conversation + git + TODO against .claude/memory/; --ritual adds the 3-question reflection; --no-push holds memory on the chore branch instead of the default auto-merge+push)"
 allowed-tools:
  - Read
  - Edit
@@ -51,7 +51,10 @@ mark-superseded). It only appends.
 Before STEP 4 writes anything, follow `$HOME/.claude/lib/gitflow-aiguillage.md`
 — this skill's TYPE = `chore`. On `main`/`develop` it branches to `chore/<name>`
 off develop, so the memory commit lands on a branch, never direct on a protected
-base; on a working branch it proceeds in place. Never `gitflow finish` (human-gated).
+base; on a working branch it proceeds in place. **Record whether it branched this
 run** (PROTECTED → a fresh `chore/<name>` was created off develop; remember
 `<name>`) — STEP 5C uses that to auto-persist. Do NOT `gitflow finish` here; the
 finish is STEP 5C's job, after the commit, and only for a branch THIS run created.
 ## STEP 0 — PRECHECK
@@ -308,6 +311,33 @@ journal-only example.
 Surgical scope is the helper's (stages ONLY `.claude/memory` + `.claude/tasks`,
 changed-paths-filtered, never `git add -A`). Do NOT hand-roll git here.
 ## STEP 5C — AUTO-PERSIST THE MEMORY (finish + push)
 Memory's value is cross-session persistence — a commit stranded on an unmerged
 `chore/<name>` branch is invisible to the next session sitting on develop, so the
 skill closes the loop itself. This is a SCOPED exception to the human-gated merge
 + [[LRN-069]] push rule: it fires ONLY for this memory-only commit, ONLY on a
 `chore/<name>` branch THIS run created off develop (BDR-068).
 Fire only when ALL hold — else SKIP (STEP 6 prints the manual-merge note, the
 pre-BDR-068 behavior):
 - STEP 5B committed cleanly (`rc 0`), AND
 - the aiguillage BRANCHED this run (PROTECTED → `chore/<name>`; on a WORKING
  branch the memory already rides feature/bugfix — never auto-merge it), AND
 - `--no-push` was NOT passed (the hold escape hatch).
 Then, from the `chore/<name>` branch:
    bash "$HOME/.claude/lib/gitflow.sh" finish chore <name>   # merge → develop, delete branch
    git push origin develop
 - **finish + push OK** → surface `develop <short> pushed` in STEP 6.
 - **push fails** (offline / rejected) → the merge to develop ALREADY happened
  locally; report `merged to develop, push FAILED — push manually`. Do NOT retry
  or reset the merge.
 - **`--no-push` / WORKING branch / rc 3** → skip this step; the commit stays where
  it is. STEP 6 prints the manual-merge note.
 ## STEP 6 — FINAL OUTPUT + HANDOFF
 ```
@@ -319,18 +349,22 @@ CAPITALIZE COMPLETE — <YYYY-MM-DD>  (<pre-wipe flush | session-close>)
  TODO.md      : checked <N>, added <M>
  journal.md   : +1 line under ## <date>
  committed    : <mem_hash>  (chore(memory): …)   | ⚠️ NOT committed (rc 3 — see closing line)
  persisted    : develop <short> pushed   | on chore/<name>, not merged (--no-push) | merged, push FAILED
  dropped as already-captured: LRN-023, BLK-006
  ignored as noise: push/tag release
 ```
-Then the mode-specific closing line:
+Then the closing line — pick by the STEP 5C persist result (`<mode>` = `Context
 flushed` for pre-wipe, `Session closed` for ritual):
- **pre-wipe flush** → `✅ Context flushed + committed <mem_hash>. Safe to /clear or /compact now.`
+- **auto-persisted (default — branched off develop, pushed)** → `✅ <mode> + persisted to origin/develop (<short>). Next session: read .claude/memory/ at startup.`
- **session-close ritual** → `✅ Session closed + committed <mem_hash>. Next session: read .claude/memory/ at startup.`
+- **--no-push (held on branch)** → `✅ <mode> + committed on chore/<name>, NOT pushed (--no-push). Merge + push when ready.`
- **commit skipped (rc 3)** → keep the ✅ on the FLUSH but make the gap loud, never
+- **push failed after merge** → `✅ <mode> + merged to develop — ⚠️ push FAILED (<reason>); merged locally, push manually.`
-  buried: `✅ Context flushed — ⚠️ NOT committed (<reason: detached/merge/non-git>); entries safe on disk, commit manually.`
+- **WORKING branch (rode a feature branch)** → `✅ <mode> + committed <mem_hash> on <branch>. Integrates when the branch merges.`
-  The ✅ covers the write (entries on disk); the ⚠️ marks the commit gap so it is
+- **commit skipped (rc 3)** → keep the ✅ on the WRITE but make the gap loud, never
-  not read as "all committed".
+  buried: `✅ <mode> — ⚠️ NOT committed (<reason: detached/merge/non-git>); entries safe on disk, commit manually.`
  The ✅ covers the write (entries on disk); the ⚠️ marks the gap so it is not read
  as "all done".
 The closing line matters — confirm the wipe is safe (default) or the session is
 checkpointed (ritual), AND whether the memory was committed (5B) or left for a
@@ -358,6 +392,11 @@ manual commit (rc 3).
  approved entries is automated via `lib/capitalize-commit.md` (BDR-034 contract).
  The journal always writes → memory is always pending at 5B, so a successful run
  always produces a commit; only an unsafe git state (rc 3) skips it.
 - **Auto-persist the flush (STEP 5C, BDR-068)** — a memory-only commit on a
  `chore/<name>` branch THIS run created off develop auto-finishes → develop +
  pushes; a scoped exception to LRN-069. `--no-push` holds it on the branch; a
  WORKING branch (memory rides feature/bugfix) or rc 3 skips it. NEVER auto-finish
  a branch the run did not create.
 - **Skip trivial** for the 4 ID registries; journal excepted.
 - `.claude/memory/` missing → STOP at STEP 0, do not create the structure here.
@@ -21,10 +21,19 @@ allowed-tools:
  - Agent
 ---
 MODEL GATE (blocking): run `$HOME/.claude/lib/model-gate.md` BEFORE loading
 the agent below. Verdict `small` → STOP — print the gate's remedy, end the
 turn, do not load the agent.
 Load and follow strictly:
 - $HOME/.claude/agents/client-handover-writer.md
-Execute the CLIENT HANDOVER WRITER agent on this project.
+Execute the CLIENT HANDOVER WRITER agent on this project. It runs the
 audit/fix/gate pipeline INLINE on the big session model (gated above), its
 skill-runner children dispatched `model: "fable"`, then delegates the
 client deliverable to the two-mode `handover-doc-writer` subagent —
 synthesize on opus, render (Markdown + branded HTML + PDF) on the sonnet
 pin (BDR-077).
 The agent runs a **ship-and-handover pipeline** with explicit gates:
@@ -20,9 +20,210 @@ allowed-tools:
  - AskUserQuestion
 ---
-Load and follow strictly:
+# /code-clean — cleanup orchestrator (audit inline, execution dispatched)
 - $HOME/.claude/agents/code-cleaner.md
-Execute the CODE-CLEANER agent on the following target:
+MODEL GATE (blocking): run `$HOME/.claude/lib/model-gate.md` BEFORE any
 step below. Verdict `small` → STOP — print the gate's remedy, end the
 turn, dispatch nothing.
 ## TARGET
 $ARGUMENTS
 If blank → entire project from repository root.
 The audit (STEPS 1-3) runs inline, on the session model — reading code and
 judging severity is reflection. Once the user approves a scope (STEP 4),
 execution is dispatched to the sonnet-pinned `code-cleaner` executor
 (STEP 5). The iron law is unchanged across both halves: zero behavior
 change — identical observable output before and after.
 ---
 ## STEP 1 — LOAD PROJECT NORMS
 Read the project's coding standards in this priority order:
 1. `CLAUDE.md` at project root (primary authority)
 2. Language/framework config files present in the repo:
   - JS/TS: `.eslintrc*`, `.prettierrc*`, `tsconfig.json`
   - Python: `pyproject.toml`, `setup.cfg`, `.flake8`, `ruff.toml`
   - PHP: `phpcs.xml`, `.php-cs-fixer.php`
   - Go: `.golangci.yml`
   - General: `.editorconfig`
 3. If neither CLAUDE.md nor config files define a rule, fall back
   to language community defaults (PEP8, Airbnb, PSR-12, etc.)
 CLAUDE.md rules always win over tool configs when they conflict.
 ## STEP 2 — SCAN
 Systematically scan the target for three categories of issues.
 **A. Dead code**
 - Unused imports and variables
 - Unused functions/methods (not exported, no callers)
 - Unreachable code blocks (after return, break, etc.)
 - Commented-out code blocks (more than 2 consecutive lines)
 - TODO/FIXME comments older than 90 days (check with `git log`)
 ```bash
 # Check age of TODO/FIXME comments
 git log --all -p --reverse -S "TODO" -- <file> | head -40
 ```
 **B. Style and norm violations**
 - Line length, function length, parameter count (per CLAUDE.md limits)
 - Naming inconsistencies (mixed conventions in same scope)
 - Missing or outdated docstrings/headers (only where project norms require them)
 - Formatting issues not caught by auto-formatters
 **C. Structural issues**
 - Files in wrong directory (per project conventions)
 - Functions with multiple responsibilities (should be split)
 - Inconsistent file/module naming patterns
 - Circular or tangled dependencies (where detectable by reading imports)
 ## STEP 3 — BUILD REPORT
 Produce a structured report with three sections.
 Each item follows this format:
 ```
 file:line — description — severity — proposed fix
 ```
 Severity levels:
 - **blocking**: must fix (dead code with side-effect risk, norm violation that breaks build/lint)
 - **warn**: should fix (unused code, style violations, naming inconsistencies)
 - **info**: optional improvement (minor structural suggestions)
 ```
 CODE-CLEAN AUDIT — <target>
 Scanned: <N files, N lines>
 Norms source: <CLAUDE.md / .eslintrc / PEP8 fallback / etc.>
 ═══ DEAD CODE ═══
  1. src/utils.py:42 — unused import `os` — warn — delete import
  2. src/api/handler.ts:118-134 — commented-out block — warn — delete block
  3. ...
 ═══ STYLE VIOLATIONS ═══
  1. src/core/parser.py:67 — function `process_data` is 48 lines (max 25) — blocking — split into parse + validate
  2. ...
 ═══ STRUCTURAL ISSUES ═══
  1. lib/helpers/auth.ts — auth logic in helpers/, should be in lib/auth/ — info — move file
  2. ...
 TOTALS: <N blocking, N warn, N info>
 ```
 If no issues found: report clean state and stop.
 ## STEP 3b — CHALLENGE THE SCOPE (before approval)
 The STEP 3 report is the proposed cleanup scope — worth attacking before the
 human approves it. It is still inline, so FIRST persist it to
 `.claude/tasks/plans/<date>-<slug>-<HHMM>.md` (STEP 3 report format, one item
 per line), then run `$HOME/.claude/lib/challenge-plan.md` with `PLAN` = that
 file, `KIND` = `proposals`, `SCOPE` = the scanned target ($ARGUMENTS or repo
 root), `CONSTRAINTS` = the STEP 1 project norms + the iron law (zero behavior
 change). Three blind challengers ask whether these are the RIGHT items and what
 the scan under- or over-scoped; the main loop RE-THINKS every aspect a BLOCKER
 lands (a named scope change re-written into the report, or `[deferred <date>]`)
 and re-challenges once if the scope materially changed. Feed the REVISED scope +
 a CHALLENGE SUMMARY into STEP 4. Advisory — the human still approves per item.
 ## STEP 4 — VALIDATION GATE (interactive)
 Present the report from STEP 3 with the STEP 3b CHALLENGE SUMMARY. Then ask:
 ```
 CHALLENGE SUMMARY (STEP 3b — 3 lenses):
  BLOCKERs addressed : <n> — <finding → the named scope change that closes it>
  Deferred (human-ack): <list | none>
  Lenses returned    : correctness / robustness / simplicity (NAME any that failed to return)
 AskUserQuestion:
  Approve which items for execution? (all / <item numbers> / clarify <item>)
 ```
 - `all` → every item in the report is approved for execution.
 - `<item numbers>` (e.g. `A1,A3,B2`) → only those items are approved; the
  rest stay untouched.
 - `clarify <item>` → discuss the item, then re-ask.
 **Exported / public-API symbols**: any dead-code item flagged as exported or
 part of a public API requires EXPLICIT per-item confirmation before it can
 be approved — even if it appears unused internally. Ask for it by name; do
 not fold it into a blanket `all`. This consent lives HERE, at the gate —
 the dispatched executor never asks, it only executes what this step already
 cleared.
 **Do NOT proceed to STEP 5 until the user explicitly approves.** If nothing
 is approved, stop — no dispatch.
 ## STEP 5 — PERSIST SCOPE + DISPATCH
 1. **Persist the approved scope.** Write the approved items to
   `.claude/audits/CODE-CLEAN-SCOPE.md` (run `mkdir -p .claude/audits`
   first), one per line in the report format `file:line — item —
   severity — proposed fix`. This is the executor's scope-of-work on
   disk — named, auditable, the same contract discipline as the dev
   gates (verifier reads its contract from disk).
 2. **Dispatch the executor** — sonnet by frontmatter pin, do not override:
   ```
   Agent(subagent_type="code-cleaner")
   prompt: "SCOPE: .claude/audits/CODE-CLEAN-SCOPE.md
   APPROVED: <the approved item list, incl. any per-item exported-symbol clears>
   BRANCH: <current branch — verify with git branch --show-current, never switch>
   Execute PHASE 2 on the approved scope only. Zero behavior change. No commit.
   Finish with the CODE-CLEAN-EXEC REPORT."
   ```
 3. Parse the `CODE-CLEAN-EXEC REPORT`:
   - `STATUS : DONE` → STEP 6.
   - `STATUS : BLOCKED` → surface the blocker to the user, stop.
 ## STEP 6 — SUMMARY
 Translate the executor's `CODE-CLEAN-EXEC REPORT` into the user-facing
 summary:
 ```
 CODE-CLEAN COMPLETE — <target>
 REMOVED:
 - <N> dead code items (unused imports, functions, commented blocks)
 REFACTORED:
 - <N> style fixes
 - <N> structural improvements
 SKIPPED (user decision):
 - <item> — <reason>
 BUGS FOUND: <N> (logged to .claude/audits/BUGS-FOUND.md)
 TESTS: passing / no test suite / <failures>
 ```
 No commit here — code-clean has never auto-committed. Leave the working
 tree for the user, or a follow-up `/commit-change`.
 ---
 ## RULES
 - Zero behavior change. If unsure whether a deletion changes behavior,
  leave it and flag it — never guess.
 - No "while we're here" scope creep. Only items approved at STEP 4 reach
  the executor.
 - Exported/public API symbols require explicit per-item user consent AT
  THE GATE (STEP 4) before approval — even if they appear unused. The
  executor never asks; it only executes what the gate already cleared.
 - Bugs go to `.claude/audits/BUGS-FOUND.md`, not fixed in this workflow.
 - If the codebase has no tests and the changes are non-trivial, warn the
  user about the risk before dispatching.
 - No plugin check (lightweight skill).
 - If the audit reveals systemic issues requiring architecture changes,
  stop and suggest `/ship-feature` for a proper redesign.
@@ -16,15 +16,108 @@ allowed-tools:
  - AskUserQuestion
 ---
-Load and follow strictly: `$HOME/.claude/agents/commit-changer.md`.
+# /commit-change — propose → confirm → apply dispatcher
-If unreachable, emit `Commit-changer agent missing.` and STOP. Never auto-commit blind — a wrong group is harder to undo than not committing.
+Grouping (propose, `model="opus"` override — judgment) and committing
 (apply, sonnet pin — mechanical) both run on the dispatched `commit-changer`
 subagent (dispatch makes the pin effective). No inline reflection happens
 in this dispatcher to protect, so there is no model gate. This dispatcher
 owns the two approval gates that used to live inside the subagent:
 commit-plan approval and capitalize approval — the subagent never asks;
 `MODE: propose` only proposes, `MODE: apply` only executes what this
 dispatcher confirms. Never auto-commit blind — a wrong group is harder to
 undo than not committing.
-Pre-flight checks (the agent should also perform, but flag here):
+## STEP 0 — Pre-flight (STOP conditions, before any dispatch)
 - Detached HEAD or unmerged conflicts → STOP, report state.
 - Identity unconfigured (`git config user.email` empty) → STOP, ask user.
 - On a protected base (`main`/`develop`) the agent runs the gitflow
  aiguillage (Phase 0) and branches to `chore/*` before committing — code
  never lands directly on a protected branch.
-$ARGUMENTS
+```bash
 git rev-parse --abbrev-ref HEAD                        # "HEAD" = detached
 git status --porcelain=v1 | grep -c '^UU\|^AA\|^DD'     # unmerged conflicts
 git status --porcelain=v1 | wc -l                       # nothing pending?
 git config user.email
 ```
 - Detached HEAD → STOP, report the state, do not dispatch.
 - Any unmerged conflict entries (`UU`/`AA`/`DD`) → STOP, tell the user to
  resolve conflicts first, do not dispatch.
 - Nothing pending (`git status --porcelain` empty) → STOP, tell the user
  there's nothing to commit.
 - `git config user.email` empty → STOP, ask the user to configure identity
  first, do not dispatch.
 On a protected base (`main`/`develop`) the subagent runs the gitflow
 aiguillage itself inside `MODE: propose` (its Phase 0) and branches to
 `chore/*` before drafting the plan — code never lands directly on a
 protected branch.
 ## STEP 1 — Propose
 ```
 Agent(subagent_type="commit-changer", model="opus")
 prompt: "MODE: propose
 $ARGUMENTS"
 ```
 (`model="opus"` — BDR-077: propose = narrative reconstruction + capitalize
 routing, judgment tier; the call-site override takes precedence over the
 sonnet frontmatter pin. Apply, STEP 4, stays on the pin.)
 Read the returned `COMMIT PLAN` + `EDGE CASES` + `CAPITALIZE CANDIDATES`,
 terminated by `READY TO APPLY — awaiting dispatcher confirmation`.
 The subagent reported `BLOCKED: unresolved merge conflicts...` instead of a
 plan (a race with STEP 0) → STOP, surface it, do not proceed.
 ## STEP 2 — Gate 1: commit-plan approval
 Show the `COMMIT PLAN` and any `EDGE CASES` verbatim, then:
 ```
 AskUserQuestion:
  Approve the commit plan? (all / <numbers> / edit <n> / skip)
 ```
 - `all` → every step in the plan is approved as-is.
 - `<numbers>` (e.g. `1,3`) → only those steps are approved; the rest stay
  uncommitted for a later run.
 - `edit <n>` → re-dispatch `commit-changer` with `MODE: propose` and the
  user's correction for step N folded into the prompt, so all grouping /
  message judgment stays on the dispatched propose mode (`model="opus"`,
  BDR-077 — never redrawn inline on the session model); show the redrawn
  plan and re-ask.
 - `skip` → exit cleanly, no commits created, no `MODE: apply` dispatch.
  Note: if the propose run created a `chore/*` branch (gitflow aiguillage
  off a protected base), that branch stays checked out with the work
  uncommitted — mention it so the user isn't surprised by the branch switch.
 ## STEP 3 — Gate 2: capitalize approval
 If the STEP 1 output said `CAPITALIZE: nothing to log`, skip this gate —
 treat the capitalize entries as `none` and go straight to STEP 4.
 Otherwise show the `CAPITALIZE CANDIDATES` block, then:
 ```
 AskUserQuestion:
  Valider les entrées mémoire ? (all / <IDs> / skip)
 ```
 - `all` → every candidate entry is approved verbatim.
 - `<IDs>` (e.g. `BDR-041,LRN-019`) → only those entries are approved.
 - `skip` → no memory write; `MODE: apply` still runs for the code commits.
 ## STEP 4 — Apply
 ```
 Agent(subagent_type="commit-changer")
 prompt: "MODE: apply
 APPROVED PLAN: <the STEP-2-approved steps — numbers, messages, files,
  exactly as confirmed, including any edits>
 APPROVED CAPITALIZE ENTRIES: <the STEP-3-approved entries verbatim, or none>"
 ```
 Parse the `COMMIT-EXEC REPORT`:
 - `STATUS: DONE` → report the `COMMITS` + `MEMORY` hashes to the user.
 - `STATUS: BLOCKED` → surface the blocker verbatim and stop. Do not retry
  automatically — a blocked step (e.g. one file needs an interactive
  `git add -p` split) needs a human decision.
@@ -15,12 +15,31 @@ allowed-tools:
  - Bash
  - Grep
  - Glob
  - Agent
 ---
-Load and follow strictly:
+Run the two-mode doc pipeline (BDR-077 — audit judgment on opus, patch on
- $HOME/.claude/agents/doc-syncer.md
+the sonnet pin, the validation gate in THIS loop; a dispatched agent cannot
 hold a gate):
-Execute the DOC SYNCER on this project.
+1. AUDIT — dispatch:
   `Agent(subagent_type="doc-syncer", model="opus")`
   prompt: "MODE: audit. Audit public docs for this project. Context from
   the user: $ARGUMENTS. Emit the DOC SYNC REPORT + PATCH PLAN — no writes."
-Context from the user (if any):
+2. GATE — present the report and run the DOC SYNC — VALIDATION GATE from
-$ARGUMENTS
+   the agent's DISPATCHER PROTOCOL (AUTO yes/select/cancel; HUMAN, CREATE,
   CLEAN per-item; README CREATE has no skip). Wait for explicit approval.
   `DOC SYNC: all docs current` → stop here.
 3. PATCH — re-dispatch:
   `Agent(subagent_type="doc-syncer")` (sonnet pin)
   prompt: "MODE: patch." + the APPROVED PATCH PLAN verbatim (approved item
   lines + rendered drafts for approved CREATE items). A `SHAPE ESCALATION`
   in its report → re-gate the named set here, then re-dispatch patch with
   the kept subset.
 4. COMMIT — from THIS loop per `$HOME/.claude/lib/doc-commit.md` (surgical:
   only the report's `PATCHED_FILES`, summary composed from its
   `CHANGE SUMMARY` block, never `.claude/`/`CLAUDE.md`, no-op if nothing
   patched).
@@ -1,10 +1,10 @@
 ---
 name: feat
 description: |
-  Small feature implementation (1-5 files). Light planning, direct
+  Small feature implementation (1-5 files). Reflection inline (scope,
-  implementation, no heavy orchestration. For features that don't
+  plan, contract — session model), execution dispatched to the
-  need the full /ship-feature pipeline (no design brainstorm, no
+  sonnet-pinned feater executor. For features that don't need the full
-  subagents, no plugin check gate).
+  /ship-feature pipeline (no design brainstorm, no plugin check gate).
  Trigger: "feat", "small feature", "add this", "petite feature",
  "quick feature", "ajoute ca", "implement this small thing".
  For multi-file features needing design → use /ship-feature.
@@ -20,9 +20,241 @@ allowed-tools:
  - Agent
 ---
-Load and follow strictly:
+# /feat — small-feature orchestrator (reflection inline, execution dispatched)
 - $HOME/.claude/agents/feater.md
-Execute the FEATER agent on the following target:
+MODEL GATE (blocking): run `$HOME/.claude/lib/model-gate.md` BEFORE any
 step below. Verdict `small` → STOP — print the gate's remedy, end the
 turn, dispatch nothing.
 ## REQUEST
 $ARGUMENTS
 ---
 ## STEP 0 — SCOPE CHECK
 Before starting, verify this is actually a small feature:
 ```bash
 git status
 git log --oneline -3
 ```
 Read the relevant existing code to understand the context.
 ### Decision rules (apply in order — first match wins)
 | Rule | Trigger | Action |
 |---|---|---|
 | 1 | Estimated diff < 2 files AND no logic (config value, copy fix, missing field) | DOWNGRADE → route to `/hotfix` (its orchestrator does LOCATE + dispatches the hotfixer executor; never load the bare agent file) |
 | 2 | New external dependency (`npm install <x>`, `pip install`, `cargo add`) required | ESCALATE → `/ship-feature` (dep choices need design gate) |
 | 3 | New route family / new top-level module / new DB migration | ESCALATE → `/ship-feature` |
 | 4 | Estimated diff > 5 files | ESCALATE → `/ship-feature` |
 | 5 | User wording is uncertain ("not sure how", "what do you think") | ESCALATE → `/ship-feature` (needs brainstorming) |
 | 6 | UI feature on a stack with a design system AND the design toolchain incomplete | Proceed in `/feat`, but flag it in STEP 0.5 design gate |
 | 7 | Otherwise | PROCEED in `/feat` |
 ### Worked examples
 - "Add `/health` endpoint returning `{status:"ok",version}`" → 1-2 files, no new dep, route added to existing router → **PROCEED**.
 - "Add a dark-mode toggle bound to `prefers-color-scheme`" → 2-3 files, design system exists → **PROCEED** (design gate triggers in STEP 0.5).
 - "Add OAuth login (Google + GitHub providers)" → new deps, new routes, secrets handling → **ESCALATE** to `/ship-feature`.
 - "Show a 'New' badge on items created this week" → 1-2 files, pure UI predicate → **PROCEED**.
 - "Fix copy: 'Sign In' → 'Sign in'" in 1 file → **DOWNGRADE** to `/hotfix`.
 Print a one-line scope confirmation (use the rule that fired):
 ```
 FEAT: <feature name> — rule <N>, ~<N> files, <brief approach>
 ```
 ## STEP 0.5 — DESIGN GATE
 Follow `$HOME/.claude/lib/design-gate.md`:
 - Scan $ARGUMENTS and target files for design/UI/style signals.
 - If signals found → run `design-tool-gate.sh`; if it reports INCOMPLETE,
  tell the user to run `/profile design` before proceeding.
 - If no signals → skip (zero overhead).
 ## STEP 0.6 — MEMORY READ-BEFORE (decisions-first)
 Run the scan per `$HOME/.claude/lib/analyze-before-plan.md`, decisions-weighted: a BDR may
 already constrain or forbid the approach; an LRN may name a gotcha to apply. Emit RELATED
 MEMORY; feed STEP 1 PLAN. Inline consumption — reader = planner, no injection.
 `.claude/memory/` absent → guarded no-op (zero overhead on a memory-less repo).
 ## STEP 0.7 — CONTRACT
 Run `$HOME/.claude/lib/contract-interview.md` (main loop — you are it). It
 captures the request verbatim, asks 0-3 questions PROPORTIONAL to ambiguity
 (a complete request → zero questions, silent), derives testable acceptance
 criteria + file scope, and writes the contract to
 `.claude/tasks/contracts/<date>-<slug>-<HHMM>.md`. Keep the path — the
 executor reads it first and GATE 1 (STEP 4) hands it to a fresh verifier.
 ## STEP 1 — PLAN (dispatch-ready)
 The executor follows this plan to the letter and CANNOT ask questions —
 close every decision here:
 1. Files to create or modify (with line references).
 2. Approach in 2-5 bullets — name every choice (naming, data shape, API
   surface); an open choice left here comes back as a NEED-DECISION
   round-trip.
 3. Edge cases to handle.
 4. Tests to add/update (exact files).
 5. Disposition (from STEP 0.6): name each in-force BDR/LRN this plan honors
   (`honors BDR-xxx by …`), or state `no in-force decision constrains this feature`.
   A plan with neither = read-then-ignore; the disposition must surface as a trace.
 Print the plan as a compact checklist:
 ```
 PLAN:
  [ ] <file> — <what to do>
  [ ] <file> — <what to do>
  [ ] <test file> — <test to add>
 ```
 If the approach is ambiguous: ask the user ONE focused question BEFORE
 dispatching — never after (the executor cannot relay questions).
 ## STEP 1b — CHALLENGE THE PLAN (before branching)
 The STEP 1 plan is a reflection worth attacking before a branch is spent on it.
 Persist it to `.claude/tasks/plans/<date>-<slug>-<HHMM>.md`, then run
 `$HOME/.claude/lib/challenge-plan.md` with `PLAN` = that file, `KIND` = `build-plan`,
 `SCOPE` = the STEP 1 files, `CONSTRAINTS` = the STEP 0.6 in-force BDR/LRN dispositions.
 Three blind challengers attack it; RE-THINK every aspect a BLOCKER lands (a named
 plan change, or `[deferred]`), re-challenge once if the plan materially changed. The
 STEP 3 executor receives the REVISED plan. Before dispatch, print a CHALLENGE SUMMARY
 (BLOCKERs addressed / deferred / lenses returned), surfacing any deferred BLOCKER via
 STEP 1's one-question gate.
 ## STEP 2 — BRANCH
 **Gitflow aiguillage (before dispatch):** follow `$HOME/.claude/lib/gitflow-aiguillage.md`
 — your type = `feature`. On `main`/`develop` it branches first; on a working
 branch it's a no-op (commit in place). Never `finish`.
 ## STEP 3 — DISPATCH EXECUTOR
 Dispatch the executor — sonnet by frontmatter pin, do not override:
 ```
 Agent(subagent_type="feater")
 prompt: "CONTRACT: <path from STEP 0.7>
 PLAN: <the STEP 1 checklist + approach bullets + edge cases, verbatim>
 BRANCH: <current branch — verify with git branch --show-current, never switch>
 Implement the plan to the letter. Tests alongside code. No commit, no
 branch ops, no new dependencies, no files outside the contract FILE SCOPE.
 Finish with the FEAT-EXEC REPORT."
 ```
 Parse the `FEAT-EXEC REPORT`:
 - `STATUS : DONE` → STEP 4.
 - `STATUS : NEED-DECISION` → make the decision HERE (that is reflection),
  append it to the plan, re-dispatch a FRESH feater with plan + decision.
  Max 2 decision round-trips → escalate to the user.
 - `STATUS : BLOCKED` → surface the blocker to the user, stop.
 ## STEP 4 — VERIFY + SECURE (fresh gates, bounded loops)
 Run the two fresh gates per `$HOME/.claude/lib/verify-secure-loop.md` with
 `CONTRACT` = the STEP 0.7 path, `DIFF` = the working-tree diff the executor
 produced, `TEST` = the suite named in its report:
 - GATE 1 — a FRESH verifier judges the diff against the contract (blind).
  CONFORME on the first pass → straight to GATE 2, no loop. ECARTS → the
  "dev" of the loop is the dispatched executor: re-dispatch a FRESH feater
  with the CONTRACT path + the exact gap lines, nothing else. Max 3 →
  escalate.
 - GATE 2 — a FRESH security-auditor (`MODE: gate`) scans the diff. PASS →
  STEP 5. BLOCK → re-dispatch a FRESH feater with the BLOCKING list + the
  CONTRACT path; re-verify the request THEN re-scan, max 3 → escalate.
 Loop decisions stay HERE, in the main loop (LRN-083). Nominal (clear
 request, conform first pass, clean diff) = one executor + one
 verifier + one security dispatch.
 ## STEP 5 — COMMIT
 Commit using conventional format:
 ```
 feat(<scope>): <what was added>
 <brief description of the feature>
 ```
 If the feature touched multiple concerns (e.g., feature + config +
 test), consider splitting into 2-3 atomic commits grouped by logical
 unit — or run `/commit-change` on the pending work (it dispatches the
 commit-changer (propose opus / apply sonnet, BDR-077); never inline-load the bare agent, it is now a
 propose/apply executor).
 Print summary:
 ```
 FEAT COMPLETE
 FEATURE  : <name>
 FILE(S)  : <created/modified files>
 TEST(S)  : <added tests>
 VERIFIED : <what was checked>
 ```
 ## STEP 6 — DOC SYNC (automatic)
 Dispatch the doc pipeline (BDR-077 — audit judgment on opus, patch on the
 sonnet pin, gate HERE):
 1. `Agent(subagent_type="doc-syncer", model="opus")` — `MODE: audit` +
   `auto-mode scope: <list of files modified during this session>`.
 2. Silence (NONE) → done. `[MINOR]` PATCH PLAN → re-dispatch
   `Agent(subagent_type="doc-syncer")` with `MODE: patch` + the plan
   verbatim (no gate — auto behavior preserved; a `SHAPE ESCALATION` in
   its report comes back here, gated as SIGNIFICANT).
 3. SIGNIFICANT → gate here (`Apply? yes / no / select`), then
   `MODE: patch` with the approved subset.
 **Then commit the docs** — follow `$HOME/.claude/lib/doc-commit.md`: it surgically commits
 ONLY the files doc-syncer patched (its `PATCHED_FILES` output), never `git add -A`, never
 `.claude/`/`CLAUDE.md` (rc 4 = a loud BDR-022 anomaly, not a silent skip), and no-ops when
 nothing was patched — the common case for a trivial change. No FINISH in an inline flow, so
 it just commits the docs on the current branch (no ordering concern).
 ## STEP 7 — CAPITALIZE (memory registries)
 A small feature may or may not involve a design choice. Scan the work for:
 - **Non-trivial design choice** (even small: a library pick, a naming convention, a data-model tradeoff) → propose `BDR-XXX` in `.claude/memory/decisions.md` with alternatives considered.
 - **Reusable pattern or gotcha encountered** → propose `LRN-XXX` in `.claude/memory/learnings.md`.
 Present the candidates grouped:
 ```
 CAPITALIZE — proposé
  [decisions.md]   BDR-XXX — <titre> (optionnel)
  [learnings.md]   LRN-XXX — <pattern> (optionnel)
 Valider ? (all / <IDs> / edit / skip)
 ```
 Always append a 1-line entry to today's heading in `.claude/memory/journal.md`.
 **Language rule**: written entries are ALWAYS in English (see CLAUDE.md "Memory registries" § Language). The interactive gate may mirror the user's language; the appended entries must not.
 If no substantive capture candidate → skip with `CAPITALIZE: nothing to log`.
 **Then commit the memory** — follow `$HOME/.claude/lib/capitalize-commit.md`: it
 surgically commits what capitalize just wrote (`.claude/memory` + `.claude/tasks`
 only, never `git add -A`) as one `chore(memory)` commit, reports the memory-commit
 hash, and no-ops if nothing was written.
 ---
 ## RULES
 - Max 5 files. If more needed → `/ship-feature`.
 - Reflection (scope, plan, contract, loop decisions) NEVER leaves this main
  loop; execution NEVER stays in it — the executor is the sonnet-pinned
  feater subagent (BDR-066).
 - The executor is dispatched FRESH on every round-trip — feedback travels
  as contract path + named gaps/decisions, never as transcript.
 - Design gate only (not full plugin check). See STEP 0.5.
 - No brainstorm/design phase (if needed → `/ship-feature`).
 - Keep scope tight. If scope creep happens mid-work, stop
  and suggest splitting into `/feat` + follow-up task.
 - Follow existing code patterns. Don't introduce new patterns
  for a small feature.
@@ -22,6 +22,13 @@ allowed-tools:
 # /geo — GEO (AI-search) audit + fix dispatcher
 ## MODEL GATE (blocking — run before any other step)
 Run `$HOME/.claude/lib/model-gate.md`. Reflection here (planning, audit
 judgment, loop decisions) requires Fable/Opus. Verdict `small` → STOP: the
 gate prints the remedy; end the turn — no later step, no dispatch. Nominal
 (big) path is silent.
 Dispatches the `geo-analyzer` subagent (audit + fix bundle), then applies
 the bundle from THIS main loop at **L1** — same shape as `/web-validate`
 and `/seo`. The analyzer never edits files: it emits a `## FIX BUNDLE`
@@ -29,27 +36,65 @@ terminated by `READY TO APPLY — awaiting dispatcher confirmation`, and this
 skill applies it. Applying from here (one dispatch level, no nested spawn)
 is what makes fixes land on any Claude Code version.
-## STEP 1 — Dispatch geo-analyzer (audit + bundle)
+## STEP 1 — Run the geo pipeline (collect → judge → template, BDR-077)
 Gather depth + business context HERE first (ask the user in this loop if
 needed — a dispatched agent cannot ask). Mint `RUNID=$(date +%s)-geo`.
 Pass the same CONTEXT block ($ARGUMENTS + gathered context) VERBATIM to
 every phase (LRN-126). Clean `.audit/geo-signals-<RUNID>.md` after apply.
 **A — collect (sonnet):**
 ```
 Agent(subagent_type="geo-analyzer", model="sonnet")
 prompt: "MODE: collect
 RUNID: <RUNID>
 Dispatched from /geo. Context: <CONTEXT>
 Execute STEP 0-5 per your spec, write the signals file + COLLECTION
 COMPLETE sentinel, emit the COLLECT REPORT, stop."
 ```
 **B — judge (opus pin, no override):**
 ```
 Agent(subagent_type="geo-analyzer")
-prompt: """
+prompt: "MODE: judge
-Dispatched from /geo. Execute your full spec at
+RUNID: <RUNID>
-~/.claude/agents/geo-analyzer.md (STEP 0 onward — gather depth + business
+Context: <CONTEXT>
-context as needed; if you must ask the user, ask and I relay).
+Load .audit/geo-signals-<RUNID>.md (fail closed per your spec), run STEP
-
+6-12, report scoring + findings + action plan + triage batches."
 Produce your report:
 - If .claude/audits/SEO.md already exists → merge findings into its
  §7 — Optimisation GEO / IA.
 - Else write .claude/audits/GEO.md.
 Then emit the `## FIX BUNDLE` (STEP 13) terminated by the verbatim
 `READY TO APPLY — awaiting dispatcher confirmation` sentinel. Do NOT apply
 any fix and do NOT dispatch any sub-agent — /geo applies your bundle.
 $ARGUMENTS
 """
 ```
 **ERROR CONTRACT:** `GEO JUDGE — VERDICT: ERROR(…)` or a mute judge →
 STOP: no template, no apply. Surface verbatim, retry ONCE with a fresh
 collect+judge, then escalate. Never carry a mute/ERROR judge into
 templating.
 **C — template (sonnet):**
 ```
 Agent(subagent_type="geo-analyzer", model="sonnet")
 prompt: "MODE: template
 Context: <CONTEXT>
 JUDGE REPORT (verbatim, ground truth — never re-derive a score):
 <the judge report>
 Run STEP 13-15. Produce your report: if .claude/audits/SEO.md already
 exists → merge findings into its §7 — Optimisation GEO / IA; else write
 .claude/audits/GEO.md. Then emit the `## FIX BUNDLE` terminated by the
 verbatim `READY TO APPLY — awaiting dispatcher confirmation` sentinel.
 Do NOT apply any fix and do NOT dispatch any sub-agent — /geo applies
 your bundle."
 ```
 ## STEP 1b — CHALLENGE THE FIX BUNDLE (advisory, before apply)
 The analyzer returned a `## FIX BUNDLE` — worth attacking before any edit lands.
 **Skip if intervention mode = conservative** (nothing is applied). Else persist the
 bundle verbatim to `.claude/tasks/plans/<date>-<slug>-<HHMM>.md`, then run
 `$HOME/.claude/lib/challenge-plan.md` with `PLAN` = that file, `KIND` = `fix-bundle`,
 `SCOPE` = the target site files the items touch, `CONSTRAINTS` = the geo-analyzer
 file-ownership (robots.txt, llms.txt, JSON-LD, content shape) + the shared-file edit
 discipline each item carries + intervention mode. Three blind challengers ask, per item:
 will it ACHIEVE its goal / could it BREAK or regress the page / is a simpler (or no) fix
 better. This main loop RE-THINKS every aspect a BLOCKER lands (a named bundle change, or
 `[deferred <date>]`) and re-challenges once if the bundle materially changed. Advisory —
 it sits BEFORE (never replaces) the STEP 2 GATED approval; carry its CHALLENGE SUMMARY
 into that gate.
 ## STEP 2 — Apply the fix bundle (from THIS main loop, at L1)
@@ -83,6 +128,11 @@ Present every GATED item (G5.x) in ONE gate:
 ```
 GEO — gated content-shape changes need approval (visible):
  G5.1 <change> — impact: <visible change>
 CHALLENGE SUMMARY (STEP 1b — 3 lenses):
  BLOCKERs addressed : <n> — <finding → the named bundle change that closes it>
  Deferred (human-ack): <list | none>
  Lenses returned    : correctness / robustness / simplicity (NAME any that failed to return)
 Approve all / select (ids) / skip all?
 ```
@@ -1 +1 @@
-0.9.6
+0.9.15
@@ -1,6 +1,6 @@
 ---
 name: graphify
-description: "Use when graphify-out/ exists (or the user asks to build a knowledge graph): questions about the codebase, its architecture, file relationships, or project content are then treated as graphify queries first. Turns any input (code, docs, papers, images, videos) into a persistent knowledge graph with god nodes, community detection, and query/path/explain tools."
+description: "Use for any question about a codebase, its architecture, file relationships, or project content — especially when graphify-out/ exists, where the question should be treated as a graphify query first. Turns any input (code, docs, papers, images, videos) into a persistent knowledge graph with god nodes, community detection, and query/path/explain tools."
 ---
 # /graphify
@@ -10,7 +10,7 @@ Turn any folder of files into a navigable knowledge graph with community detecti
 ## Usage
 ```
-/graphify                                             # full pipeline on current directory → Obsidian vault
+/graphify                                             # full pipeline on current directory (HTML viz; add --obsidian for a vault)
 /graphify <path>                                      # full pipeline on specific path
 /graphify https://github.com/<owner>/<repo>           # clone repo then run full pipeline on it
 /graphify https://github.com/<owner>/<repo> --branch <branch>  # clone a specific branch
@@ -70,7 +70,7 @@ PYTHON=""
 GRAPHIFY_BIN=$(which graphify 2>/dev/null)
 # 1. uv tool installs — most reliable on modern Mac/Linux
 if [ -z "$PYTHON" ] && command -v uv >/dev/null 2>&1; then
-    _UV_PY=$(uv tool run graphifyy python -c "import sys; print(sys.executable)" 2>/dev/null)
+    _UV_PY=$(uv tool run --from graphifyy python -c "import sys; print(sys.executable)" 2>/dev/null)
    if [ -n "$_UV_PY" ]; then PYTHON="$_UV_PY"; fi
 fi
 # 2. Read shebang from graphify binary (pipx and direct pip installs)
@@ -86,7 +86,7 @@ if [ -z "$PYTHON" ]; then PYTHON="python3"; fi
 if ! "$PYTHON" -c "import graphify" 2>/dev/null; then
    if command -v uv >/dev/null 2>&1; then
        uv tool install --upgrade graphifyy -q 2>&1 | tail -3
-        _UV_PY=$(uv tool run graphifyy python -c "import sys; print(sys.executable)" 2>/dev/null)
+        _UV_PY=$(uv tool run --from graphifyy python -c "import sys; print(sys.executable)" 2>/dev/null)
        if [ -n "$_UV_PY" ]; then PYTHON="$_UV_PY"; fi
    else
        "$PYTHON" -m pip install graphifyy -q 2>/dev/null \
@@ -313,7 +313,8 @@ from graphify.cache import save_semantic_cache
 from pathlib import Path
 new = json.loads(Path('graphify-out/.graphify_semantic_new.json').read_text(encoding=\"utf-8\")) if Path('graphify-out/.graphify_semantic_new.json').exists() else {'nodes':[],'edges':[],'hyperedges':[]}
-saved = save_semantic_cache(new.get('nodes', []), new.get('edges', []), new.get('hyperedges', []), root='INPUT_PATH')
+uncached = [line for line in Path('graphify-out/.graphify_uncached.txt').read_text(encoding=\"utf-8\").splitlines() if line]
 saved = save_semantic_cache(new.get('nodes', []), new.get('edges', []), new.get('hyperedges', []), root='INPUT_PATH', allowed_source_files=uncached)
 print(f'Cached {saved} files')
 "
 ```
@@ -22,6 +22,13 @@ allowed-tools:
 # /harden — web hardening audit
 ## MODEL GATE (blocking — run before any other step)
 Run `$HOME/.claude/lib/model-gate.md`. Reflection here (planning, audit
 judgment, loop decisions) requires Fable/Opus. Verdict `small` → STOP: the
 gate prints the remedy; end the turn — no later step, no dispatch. Nominal
 (big) path is silent.
 This skill orchestrates a narrow-scope hardening audit: TLS + security
 headers + redirects + canonical + custom 404 + server configs. It
 reuses the `seo-analyzer` agent with a **strict scope filter** to avoid
@@ -511,6 +518,21 @@ Extract the score and critical-alert count from `.claude/audits/HARDEN.md` for t
 ---
 ## STEP 2b — CHALLENGE THE FIX BUNDLE (MODE=fix only, advisory)
 Skip if MODE=audit (no bundle exists). Else, before the STEP 3 gate, harden the bundle:
 extract the `## 8. Fix bundle` section from HARDEN.md to
 `.claude/tasks/plans/<date>-<slug>-<HHMM>.md` (a clean, blind-judgeable artifact), then run
 `$HOME/.claude/lib/challenge-plan.md` with `PLAN` = that file, `KIND` = `fix-bundle`,
 `SCOPE` = the config/target files each patch touches (.htaccess, next.config.js, _headers…),
 `CONSTRAINTS` = the STEP 1 strict scope + framework-native mechanism rule (no `.htaccess`
 on Next/Astro) + the severity guide. Three blind challengers ask, per patch: will it ACHIEVE
 the hardening goal / could it BREAK the site (over-broad CSP, redirect loop) / is a simpler
 fix better. This main loop RE-THINKS every aspect a BLOCKER lands (a named bundle change, or
 `[deferred <date>]`) and re-challenges once if the bundle materially changed. Advisory — it
 sits BEFORE (never replaces) the STEP 3 confirmation; carry its CHALLENGE SUMMARY into that gate.
 ---
 ## STEP 3 — Apply fixes (MODE=fix only)
 Skip this step if MODE=audit.
@@ -527,6 +549,11 @@ If MODE=fix and `.claude/audits/HARDEN.md` ends with `READY TO APPLY — awaitin
     - .htaccess           (3 fixes : HTTP→HTTPS redirect, HSTS, 404 page)
     - next.config.js      (2 fixes : CSP header, X-Frame-Options)
   CHALLENGE SUMMARY (STEP 2b — 3 lenses) :
     BLOCKERs addressed : <n> — <finding → the named bundle change that closes it>
     Deferred (human-ack): <list | none>
     Lenses returned    : correctness / robustness / simplicity (NAME any that failed to return)
   Options :
     A) Apply all
     B) Review each diff before applying
@@ -18,9 +18,213 @@ allowed-tools:
  - Agent
 ---
-Load and follow strictly:
+# /hotfix — quick-fix orchestrator (reflection inline, execution dispatched)
 - $HOME/.claude/agents/hotfixer.md
-Execute the HOTFIXER agent on the following target:
+MODEL GATE (blocking): run `$HOME/.claude/lib/model-gate.md` BEFORE any
 step below. Verdict `small` → STOP — print the gate's remedy, end the
 turn, dispatch nothing.
 ## REQUEST
 $ARGUMENTS
 ---
 ## STEP 1 — LOCATE (reflection)
 Find the bug. Use the description and any error message to go
 straight to the source:
 ```bash
 git status
 git log --oneline -3
 ```
 - Read the relevant file(s). Confirm the root cause is obvious
  and superficial (typo, wrong value, missing import, etc.).
 - If the bug turns out to be deeper than expected (unclear cause,
  multiple files involved, logic error): STOP and say:
  "This looks deeper than a hotfix — it needs investigation. Re-run this
  as `/bugfix` (root-cause investigation, then a scoped fix)."
 - Settle the proposed fix HERE — the executor cannot ask questions, so the
  exact edit (what changes, in which file(s)) must be closed before dispatch.
 OPTIONAL — memory check (exempt by default; hotfix = obvious fix, mirror of its capitalize
 skip). For a RECURRING or urgent bug only, a quick blockers-only glance may save time:
      [ -d .claude/memory ] && grep -nE '^## BLK-' .claude/memory/blockers.md   # "déjà vu ?"
 If a prior BLK names this bug, jump to its solution. Not mandatory; no RELATED MEMORY
 disposition required at hotfix weight.
 ## STEP 1.5 — DESIGN GATE
 Follow `$HOME/.claude/lib/design-gate.md`:
 - Scan $ARGUMENTS and target files for design/UI/style signals (CSS, component, styling, animation).
 - If signals found → run `design-tool-gate.sh`; if it reports INCOMPLETE,
  tell the user to run `/profile design` before proceeding.
 - If no signals → skip (zero overhead).
 ## STEP 1.7 — CONTRACT (silent autofill)
 Run `$HOME/.claude/lib/contract-interview.md` at hotfix weight: **zero
 questions ever** (a hotfix is an obvious fix by definition). Autofill the
 contract — REQUEST verbatim = the bug description as given; ACCEPTANCE
 CRITERIA = "symptom gone; build/tests green"; FILE SCOPE = the 1-2 target
 files from STEP 1. It writes `.claude/tasks/contracts/<date>-<slug>-<HHMM>.md`.
 This is the reference the executor reads first, and the scope for STEP 4's
 security gate and the escalation report if a gate fails. No verifier is
 dispatched at hotfix weight — STEP 4's smoke result already verifies these
 trivial criteria; the gate hotfix adds is security (STEP 4).
 ## STEP 1.8 — CHALLENGE THE FIX (logic fixes only)
 GUARD — this is the one place the plan-challenge phase is kept proportionate to
 hotfix's speed. SKIP entirely for a purely cosmetic fix (CSS value, copy/typo, a
 broken link): there is nothing for three lenses to bite on, and speed is the
 point. Run it ONLY when the settled fix touches control flow or behaviour — an
 off-by-one, a wrong operator/variable, a behaviour-changing config value, or a
 missing import that alters execution. In doubt → it is probably a `/bugfix`.
 For a logic fix: persist the STEP 1 located fix (root cause + the exact edit) to
 `.claude/tasks/plans/<date>-<slug>-<HHMM>.md`, then run
 `$HOME/.claude/lib/challenge-plan.md` with `PLAN` = that file, `KIND` =
 `build-plan`, `SCOPE` = the 1-2 target files, `CONSTRAINTS` = the STEP 1.7
 contract's acceptance criteria. Three blind challengers attack the fix; the main
 loop RE-THINKS any aspect a BLOCKER lands (a named change to the fix, or
 `[deferred]`) and re-challenges once if it materially changed. Print a
 CHALLENGE SUMMARY (BLOCKERs addressed / deferred / lenses returned). A BLOCKER
 that shows the fix is wrong or incomplete means this was never
 a hotfix — escalate to `/bugfix` (its STEP 3b runs the same phase under the full
 verify+secure loop).
 ## STEP 2 — PRE-FLIGHT
 **Gitflow aiguillage (before dispatch):** follow `$HOME/.claude/lib/gitflow-aiguillage.md`
 — your type = `hotfix`. On `main`/`develop` it branches first; on a working
 branch it's a no-op (commit in place). Never `finish`.
 Snapshot current state so revert is possible:
 ```bash
 git diff HEAD --stat   # confirm working tree is clean OR carries only the
                       # in-progress hotfix area; if unrelated dirty files are
                       # present, ask user whether to stash them first
 git rev-parse HEAD     # capture the SHA to revert to on failure
 ```
 If the working tree contains unrelated uncommitted changes the user has not
 mentioned: STOP and ask `"working tree dirty: stash and continue, or abort?"`.
 ## STEP 3 — DISPATCH EXECUTOR
 Dispatch the executor — sonnet by frontmatter pin, do not override:
 ```
 Agent(subagent_type="hotfixer")
 prompt: "CONTRACT: <path from STEP 1.7>
 LOCATED: <file(s) found in STEP 1 + the confirmed root cause>
 FIX: <the proposed minimal fix, closed in STEP 1>
 BRANCH: <current branch — verify with git branch --show-current, never switch>
 Apply the minimal fix. No refactoring, no commit, no branch ops, no
 security dispatch, no revert. Finish with the HOTFIX-EXEC REPORT."
 ```
 Parse the `HOTFIX-EXEC REPORT`:
 - `STATUS : DONE` → STEP 4 (the SMOKE line in the report decides pass/fail
  there; DONE here means execution completed, not that it verified clean).
 - `STATUS : BLOCKED` → if any edits were made, `git restore .` to the
  pre-flight SHA (STEP 2); surface the blocker to the user; STOP. One
  attempt only — hotfix never re-dispatches (escalate to `/bugfix` for
  deeper work).
 ## STEP 4 — VERIFY + SECURE + COMMIT (main loop, LRN-083)
 1. Read the SMOKE line from the executor's report. **Failure branch** — if
   it reports a failing test/build result:
   - Print the failure output verbatim (under 30 lines).
   - Run `git restore .` to revert the working-tree edits to the pre-flight
     SHA (STEP 2). (Files were not yet staged — restore is safe.)
   - STOP and tell user: `"Hotfix introduced a regression. Reverted.
     Escalate to /bugfix or /analyze for deeper investigation."`
   - Do NOT commit a broken fix.
 2. **Security gate (fresh auditor) — failure REVERTS, never loops.** Dispatch
   a FRESH security-auditor (`subagent_type: security-auditor`, or load
   `agents/security-auditor.md`) with `MODE: gate`, `SCOPE:` the working-tree
   diff vs the pre-flight SHA. Parse its `SECURITY — VERDICT:` line:
   - `PASS` (or `DEGRADED` with no BLOCK) → proceed to commit.
   - `BLOCK(n)` → this is hotfix: do NOT loop. Run `git restore .` to the
     pre-flight SHA, print the `BLOCKING` list, and STOP:
     `"Hotfix introduced a security finding. Reverted. Escalate to /bugfix
     for a fix under the full verify+security loop."` The hotfix model is
     one attempt; any gate failure (smoke OR security) reverts and escalates.
   - Structural failure (mute / unparsable / no VERDICT line) → treat as a
     failed gate: retry ONCE fresh; a 2nd structural failure → revert +
     escalate. A mute auditor is never a PASS.
 3. Commit using conventional format (only after smoke AND security pass):
   ```
   fix(<scope>): <what was wrong>
   ```
 4. Print summary:
   ```
   HOTFIX APPLIED
   FILE(S) : <changed files>
   FIX     : <one-line description>
   VERIFIED: <test name or smoke check that passed>
   SECURITY: <PASS | DEGRADED (checklist only)>
   ```
 ## STEP 5 — DOC SYNC (automatic)
 Dispatch the doc pipeline (BDR-077 — audit judgment on opus, patch on the
 sonnet pin, gate HERE):
 1. `Agent(subagent_type="doc-syncer", model="opus")` — `MODE: audit` +
   `auto-mode scope: <list of files modified during this session>`.
 2. Silence (NONE) → done. `[MINOR]` PATCH PLAN → re-dispatch
   `Agent(subagent_type="doc-syncer")` with `MODE: patch` + the plan
   verbatim (no gate — auto behavior preserved; a `SHAPE ESCALATION` in
   its report comes back here, gated as SIGNIFICANT).
 3. SIGNIFICANT → gate here (`Apply? yes / no / select`), then
   `MODE: patch` with the approved subset.
 **Then commit the docs** — follow `$HOME/.claude/lib/doc-commit.md`: it surgically commits
 ONLY the files doc-syncer patched (its `PATCHED_FILES` output), never `git add -A`, never
 `.claude/`/`CLAUDE.md` (rc 4 = a loud BDR-022 anomaly, not a silent skip), and no-ops when
 nothing was patched — the common case for a trivial hotfix. No FINISH in an inline flow, so
 it just commits the docs on the current branch (no ordering concern).
 ## STEP 6 — CAPITALIZE (memory registries, lightweight)
 Hotfixes are often trivial (typo, config, import) — skip by default. But if the fix revealed something non-obvious:
 - Wrong default that should never have been merged → propose `LRN-XXX` in `.claude/memory/learnings.md`.
 - Bug that cost real time to locate despite being "superficial" → propose `BLK-XXX` in `.claude/memory/blockers.md` (status: resolved).
 Default behaviour: `CAPITALIZE: hotfix trivial, skip` (no prompt, no output).
 Ask the user only when there is an actual candidate to propose.
 Always append a 1-line entry to today's heading in `.claude/memory/journal.md` (even trivial hotfix — journal is timeline, not signal).
 **Language rule**: the journal line and any proposed BLK/LRN entries are ALWAYS written in English (see CLAUDE.md "Memory registries" § Language).
 **Then commit the memory** — follow `$HOME/.claude/lib/capitalize-commit.md`: it
 surgically commits what capitalize just wrote (`.claude/memory` + `.claude/tasks`
 only, never `git add -A`) as one `chore(memory)` commit, reports the memory-commit
 hash, and no-ops if nothing was written. The always-on journal line means a
 trivial hotfix still produces a `chore(memory): journal — …` commit (Frame 2 / F3).
 ---
 ## RULES
 - Max 2 files changed. If more needed → `/bugfix`.
 - Reflection (LOCATE, contract, gate decisions) NEVER leaves this main
  loop; execution NEVER stays in it — the executor is the sonnet-pinned
  hotfixer subagent (BDR-066).
 - The executor is dispatched FRESH, once — hotfix never re-dispatches (no
  decision round-trips; a blocked or failed attempt reverts and escalates
  to `/bugfix`, it does not retry).
 - Design gate only if CSS/style signals detected. See STEP 1.5.
 - **Revert-not-loop preserved**: smoke FAIL or security BLOCK → `git
  restore .` to the pre-flight SHA + STOP + escalate to `/bugfix`; hotfix
  never loops. No verifier is dispatched at hotfix weight.
 - If root cause is unclear → escalate to `/bugfix` (STEP 1).
 - If fix touches >5 lines of logic → reconsider if this is
  truly a hotfix.
@@ -7,6 +7,13 @@ allowed-tools: Read, Write, Edit, Bash, Grep, Glob
 # ORCHESTRATOR: INIT PROJECT
 ## MODEL GATE (blocking — run before any other step)
 Run `$HOME/.claude/lib/model-gate.md`. Reflection here (planning, audit
 judgment, loop decisions) requires Fable/Opus. Verdict `small` → STOP: the
 gate prints the remedy; end the turn — no later step, no dispatch. Nominal
 (big) path is silent.
 ## REQUEST
 $ARGUMENTS
@@ -29,7 +36,8 @@ so the user does not assume Claude has hung.
 ---
 ## STEP 0 — PLUGIN CHECK + AUTO-ACTIVATE
-Load `$HOME/.claude/agents/plugin-advisor.md`. Feed request.
+Run `$HOME/.claude/lib/plugin-gate.md`. Feed request (dispatch plugin-probe →
 checkpoint → dispatch plugin-advisor; gates stay in this loop — BDR-077).
 - ACTION REQUIRED → show RECOMMENDATIONS block, offer: A) fix plugins B) type "force". STOP.
 - PROPOSED CHANGES exist → show list, ask "Apply? (yes / no / customize)". Apply on confirm.
 - OK → `✅ Plugin check passed — [active plugins] — complexity: <score>%`, continue.
@@ -84,15 +92,31 @@ contract, each tagged `[gated <date>]`. STEP 9's verifier judges against this
 enriched contract.
 ## STEP 5 — SCAFFOLD
-Load `$HOME/.claude/agents/scaffolder.md`. Pass: BRIEF + DESIGN + `~/.claude/templates/project-CLAUDE.md` + `~/.claude/CLAUDE.md`.
+Dispatch `Agent(subagent_type="scaffolder")` (pin sonnet, effort high —
 BDR-077 : le design est CLOS au gate #1, le scaffold est de l'exécution,
 plus jamais inline sur le modèle de session). Pass IN THE PROMPT (LRN-126 —
 every field the scaffolder consumes crosses the dispatch): BRIEF (verbatim)
 + DESIGN (verbatim) + paths `~/.claude/templates/project-CLAUDE.md` +
 `~/.claude/CLAUDE.md`. A STOP (missing input) comes back as its report —
 resolve here, re-dispatch. The ~30s liveness pings are THIS loop's job
 while waiting.
 Creates: CLAUDE.md, `.claude/settings.json`, `.claudeignore`, `.gitignore`, `.env.example`, empty entry points. NO README, NO features, NO `.claude/tasks/` or `.claude/memory/` (not bootstrapped by this flow — copy from `~/.claude/templates/memory/` manually if wanted before STEP 10b's memory commit).
 Verify: `git init` + build passes.
 ## STEP 5b — CREATE README
-Load `$HOME/.claude/agents/doc-syncer.md` (AUTO MODE, scope: full project). README.md missing → its README bootstrap creates it. No stop.
+Dispatch the doc pipeline (BDR-077):
 `Agent(subagent_type="doc-syncer", model="opus")`
 — `MODE: audit` (FULL-AUDIT path, NOT `auto-mode scope:` —
 auto-mode gates a missing README as SIGNIFICANT; the full audit's STEP 5
 renders it `[CREATE-AUTO]`, unconditional). README.md missing → the
 report carries the rendered README draft as `[CREATE-AUTO]`; re-dispatch
 `Agent(subagent_type="doc-syncer")` (sonnet pin) with `MODE: patch` +
 that plan to write it. No stop (README bootstrap is unconditional).
 ## STEP 5c — CTX7 PRE-FETCH (if fast-libs detected)
-If `fast-libs` signal was detected in STEP 0 (Next.js, React 18+, Prisma, Supabase, Drizzle, etc.):
+If `fast-libs` signal was detected in STEP 0 — single source of truth:
 `bash ~/.claude/lib/fast-libs.sh detect .` (Next.js, React, Prisma,
 Supabase, Drizzle… — BDR-078):
 1. Create `.ctx7-cache/` directory in project root.
 2. For each detected fast-lib, fetch core docs:
   ```bash
@@ -148,12 +172,27 @@ implemented on a `feature/*` branch off `develop` (STEP 8).
 Invoke `superpowers:writing-plans` with BRIEF + skeleton.
 Granular tasks (2-5 min each), exact file paths, TDD: tests before code.
 ## STEP 6b — CHALLENGE THE PLAN (before the gate)
 Before the human sees the implementation plan, harden it. Run
 `$HOME/.claude/lib/challenge-plan.md` with `PLAN` = the plan STEP 6 wrote under
 `docs/superpowers/plans/`, `KIND` = `build-plan`, `SCOPE` = the skeleton + task file
 paths, `CONSTRAINTS` = the STEP 4-validated architecture + founding decisions.
 Three blind challengers (correctness / robustness / simplicity) attack it; the main
 loop RE-THINKS every aspect a BLOCKER lands (a named plan change, or `[deferred]`),
 re-challenges once if the plan materially changed, and feeds the REVISED plan + a
 CHALLENGE SUMMARY into STEP 7. Advisory — the human remains the decider.
 ## STEP 7 — VALIDATION GATE #2 ★ MANDATORY STOP
 ```
 INIT PROJECT — IMPLEMENTATION PLAN
 SKELETON: ✅ build passes
 FEATURES: <N> → <M> tasks
 <numbered task list with paths>
 CHALLENGE SUMMARY (STEP 6b — 3 lenses):
  BLOCKERs addressed : <n> — <finding → the named plan change that closes it>
  Deferred (human-ack): <list | none>
  Lenses returned    : correctness / robustness / simplicity (NAME any that failed to return)
 Approve and start? (yes / request changes)
 ```
 Changes → back to STEP 6. Approved → continue.
@@ -169,6 +208,12 @@ Invoke `superpowers:subagent-driven-development` for the per-task implement loop
 `gitflow finish` (STEP 11). When SDD's flow reaches "Use
 finishing-a-development-branch", stop and return.
 **Model routing (BDR-066):** every subagent dispatched under SDD — per-task
 implementers AND its reviewers — MUST carry `model: "sonnet"` in the Agent
 call. The plan is closed; execution and plan-conformity review are sonnet
 work. Reflection (task decomposition, review verdict arbitration) stays in
 this loop.
 ## STEP 8b — GRAPHIFY FULL (after implementation)
 If `graphify` CLI is installed AND complexity >= 30%:
 1. Run full graphify on the implemented project:
@@ -195,7 +240,10 @@ against the founding contract. Distinct axis from STEP 10 code review
 ([[LRN-095]]) — both run.
 ## STEP 10 — CODE REVIEW
-Invoke `superpowers:requesting-code-review`. Fix all CRITICAL before proceeding.
+Invoke `superpowers:requesting-code-review`. **Model routing (BDR-077):** the
 review subagent it dispatches MUST carry `model: "opus"` in the Agent call —
 craft review is dispatched judgment, never inherited from the session. Fix
 all CRITICAL before proceeding.
 ## STEP 10b — CAPITALIZE FOUNDING DECISIONS (memory registries)
 A greenfield's founding architecture decisions are the highest-value BDRs — the
@@ -254,8 +302,12 @@ does NOT commit them, and `gitflow finish` integrates only COMMITTED history
 — so a patch left uncommitted never reaches the merge/PR. Same PR-stranding class as the
 STEP 10b capitalize fix (BDR-034).
-Load `$HOME/.claude/agents/doc-syncer.md` (AUTO MODE, scope: files changed this session).
+Dispatch the doc pipeline (BDR-077):
-Detect drift, update cmds/vars/structure, add recent changes entry.
+`Agent(subagent_type="doc-syncer", model="opus")`
 — `MODE: audit` + `auto-mode scope: <files changed this
 session>`; NONE → done; `[MINOR]` plan → `MODE: patch` re-dispatch (sonnet
 pin, no gate; SHAPE ESCALATION comes back gated); SIGNIFICANT → gate here,
 then `MODE: patch` with the approved subset.
 **Then commit the docs** — follow `$HOME/.claude/lib/doc-commit.md`: it surgically commits
 ONLY the files doc-syncer patched (its `PATCHED_FILES` output, one path per line → one argv
@@ -7,6 +7,13 @@ allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Agent, Skill
 # ORCHESTRATOR: ONBOARD
 ## MODEL GATE (blocking — run before any other step)
 Run `$HOME/.claude/lib/model-gate.md`. Reflection here (planning, audit
 judgment, loop decisions) requires Fable/Opus. Verdict `small` → STOP: the
 gate prints the remedy; end the turn — no later step, no dispatch. Nominal
 (big) path is silent.
 ## REQUEST
 $ARGUMENTS
@@ -14,7 +21,7 @@ $ARGUMENTS
 ## STEP 0 — PLUGIN CHECK + AUTO-ACTIVATE
-Load `$HOME/.claude/agents/plugin-advisor.md` with hint "onboarding existing project + $ARGUMENTS".
+Run `$HOME/.claude/lib/plugin-gate.md` with hint "onboarding existing project + $ARGUMENTS" (dispatch plugin-probe → checkpoint → dispatch plugin-advisor → gates in this loop, BDR-077).
 - ACTION REQUIRED → show RECOMMENDATIONS block, offer: A) apply recos B) type "force". STOP.
 - PROPOSED CHANGES exist → show list, ask "Apply? (yes / no / customize)". Apply on confirm.
@@ -82,7 +89,11 @@ STOP. La réponse détermine si STEP 1 tourne une fois (A) ou N fois (C) ou avec
 ## STEP 2 — BASELINE CONFIG (onboarder agent)
-Load `$HOME/.claude/agents/onboarder.md`. Passer un BRIEF minimal issu du filesystem scan :
+Dispatch `Agent(subagent_type="onboarder")` (pin sonnet — BDR-077 : config
 templating = exécution, plus jamais inline sur le modèle de session). Un
 BLOCAGE (clé manquante, CLAUDE.md existant) revient en rapport — l'agent ne
 peut pas te demander ; TU arbitres ici puis re-dispatches. Passer un BRIEF
 minimal issu du filesystem scan :
 - `archetype` (depuis STEP 1)
 - `project_name` (depuis package.json/pyproject.toml/README.md/dir name)
 - `stack` (depuis manifests détectés)
@@ -196,13 +207,10 @@ ls .ctx7-cache/ 2>/dev/null
 ```
 ### Détection fast-libs
-Parse manifests selon l'archétype :
+Source unique : `bash ~/.claude/lib/fast-libs.sh detect .` (deps JS/TS via
- **nextjs-app-router** → chercher : next, react, prisma, @supabase/*, drizzle-orm, next-auth, @clerk/*
+package.json + Python via requirements/pyproject — liste centralisée,
- **react-spa** → chercher : react, @tanstack/*, zustand, jotai
+BDR-078). Archétypes wordpress / cli-tool / library / dotfiles-meta /
- **rest-api-node** → chercher : fastify, @nestjs/*, prisma, drizzle-orm
+static-html → souvent aucune fast-lib, audit léger.
 - **rest-api-python** → chercher : fastapi, pydantic, sqlalchemy (si ≥ 2.0)
 - **astro-static** → chercher : astro, @astrojs/*
 - **wordpress / cli-tool / library / dotfiles-meta / static-html** → souvent aucune fast-lib, audit léger
 ### Vérification cache
 Pour chaque fast-lib détectée :
@@ -347,7 +355,7 @@ Lire le bloc `audit_stack:` du fichier `~/.claude/lib/project-archetypes/<archet
 | Entry | Action | Livraison |
 |---|---|---|
 | `analyze` | Déjà fait en STEP 5 | L3a |
-| `code-clean` | Spawn subagent `code-cleaner` (audit-only) | L3a |
+| `code-clean` | Spawn subagent `general-purpose` (audit-only, `model="opus"` — BDR-076: dispatched audits off the session model) | L3a |
 | `cso` | Si gstack ON → Skill(cso). Sinon → Agent general-purpose avec checklist OWASP + deps audit | L3a |
 | `doc` | Spawn subagent `doc-syncer` (auto-mode OFF, report-only) | L3a |
 | `seo` | Subagents seo-analyzer + geo-analyzer en parallèle | L3b |
@@ -359,11 +367,12 @@ Lire le bloc `audit_stack:` du fichier `~/.claude/lib/project-archetypes/<archet
 Lancer EN PARALLÈLE (un seul message, plusieurs Agent calls) les audits correspondant aux entrées de `audit_stack:` qui sont en L3a (`code-clean`, `cso`, `doc`).
-#### Dispatch code-cleaner (si `code-clean` dans audit_stack)
+#### Dispatch code-clean audit (si `code-clean` dans audit_stack)
 ```
 Agent(
-  subagent_type="code-cleaner",
+  subagent_type="general-purpose",
-  description="Onboard — code-clean audit only",
+  model="opus",
  description="Onboard — code-clean audit only (read-only, opus)",
  prompt="""
  AUDIT-ONLY mode — NO fixes, NO refactoring, NO file modifications.
  Target: <PROJECT_ROOT>. ARCHETYPE: <archetype>.
@@ -399,6 +408,7 @@ bash $HOME/.claude/lib/toggle-external.sh list 2>/dev/null | grep -E "^gstack\s+
  ```
  Agent(
    subagent_type="general-purpose",
    model="opus",
    description="Onboard — security audit fallback (archetype-adaptive)",
    prompt="""
    READ-ONLY security audit. No file modifications.
@@ -522,9 +532,11 @@ flux de dev sont deux formes distinctes ([[BDR-050]] pipeline dev ≠ audit).
 ```
 Agent(
  subagent_type="doc-syncer",
  model="opus",
  description="Onboard — doc drift audit only",
  prompt="""
-  REPORT-ONLY mode — NO edits, NO auto-sync.
+  MODE: audit — REPORT-ONLY, NO edits, NO auto-sync (no patch dispatch
  follows: the report feeds the onboard backlog).
  Target: full project at <PROJECT_ROOT>.
  Scope:
    1. README drift (build/test commands, install steps, usage examples vs actual code)
@@ -640,6 +652,7 @@ Si le skill ne supporte pas `--output`, capturer la sortie et écrire à la main
 ```
 Agent(
  subagent_type="general-purpose",
  model="opus",
  description="Onboard — static design review fallback",
  prompt="""
  AUDIT-ONLY mode — NO edits. Static design review du code UI.
@@ -683,6 +696,7 @@ Puis parser le JSON Lighthouse (scores perf/a11y/bp/seo/pwa + top opportunities)
 ```
 Agent(
  subagent_type="general-purpose",
  model="opus",
  description="Onboard — static perf audit",
  prompt="""
  AUDIT-ONLY mode — NO edits.
@@ -725,6 +739,7 @@ Parser axe-core résultats (violations, incomplete, inapplicable, passes) → `.
 ```
 Agent(
  subagent_type="general-purpose",
  model="opus",
  description="Onboard — static a11y audit",
  prompt="""
  AUDIT-ONLY mode — NO edits.
@@ -770,6 +785,7 @@ Spawn un subagent synthétiseur (isolé, chargé uniquement du contenu de `.onbo
 ```
 Agent(
  subagent_type="general-purpose",
  model="opus",
  description="Onboard — synthèse vers .claude/audits/",
  prompt="""
  Lire tous les fichiers de <PROJECT_ROOT>/.onboard-audit/ :
@@ -862,6 +878,22 @@ Vérifier que les 4 fichiers `.claude/audits/ONBOARD_REPORT.md`, `.claude/audits
 ---
 ## STEP 7b — CHALLENGE THE PROPOSALS (before the human gate)
 The 4 audit files are on disk; `AUDIT_PROPOSALS.md` is the artifact worth
 attacking before the human spends a gate on it. Run
 `$HOME/.claude/lib/challenge-plan.md` with `PLAN` =
 `.claude/audits/AUDIT_PROPOSALS.md`, `KIND` = `proposals`, `SCOPE` = the audited
 project paths (the `audit_stack` coverage), `CONSTRAINTS` = the STEP 1 archetype
 profile + the STEP 3 interview constraints (stade, légal, budget perf). Three
 blind challengers ask whether these are the RIGHT priorities and what the audit
 under-rated; the main loop RE-THINKS every aspect a BLOCKER lands (a named
 proposals change re-written into `AUDIT_PROPOSALS.md`, or `[deferred <date>]`)
 and re-challenges once if the file materially changed. Feed the REVISED
 proposals + a CHALLENGE SUMMARY into STEP 8. Advisory — the human remains the
 decider.
 ---
 ## STEP 8 — VALIDATION GATE ★ MANDATORY STOP
 Afficher à l'utilisateur :
@@ -886,6 +918,11 @@ TOP 5 PRIORITÉS :
  4. [P1 Haute]    <titre>
  5. [P2 Moyenne]  <titre>
 CHALLENGE SUMMARY (STEP 7b — 3 lenses):
  BLOCKERs addressed : <n> — <finding → the named proposals change that closes it>
  Deferred (human-ack): <list | none>
  Lenses returned    : correctness / robustness / simplicity (NAME any that failed to return)
 Prochaine étape : générer .claude/tasks/TODO.md depuis .claude/audits/AUDIT_PROPOSALS.md approuvé.
 Options :
--- a/Show More
+++ b/Show More
		`@@ -0,0 +1,2 @@`
							`{"inspectionResult":{"indexStatusResult":{`
							`"verdict":"PASS","coverageState":"Submitted and indexed","lastCrawlTime":"2026-07-01T10:00:00Z"}}}`