@kensaurus/skills 0.0.0-stage → 2.0.0

package/skills/plan-antislop/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: plan-antislop
+description: >
+  Plan-only authenticity / AI-slop audit across prose, UI, code, and IA.
+  Use when "looks like AI slop", "reads like ChatGPT", or "authenticity
+  burndown". One-page UX apply → enhance-web-ux. Visual polish →
+  enhance-web-ui.
+license: MIT
+effort: high
+---
+
+# Anti-Slop Audit + Authenticity Burndown Plan
+
+**Degree of freedom: HIGH** — inventory tells, score, plan. Stay
+**plan-only**. No rewrites until each phase is approved.
+
+## This skill vs neighbors
+
+| Skill | Owns |
+|---|---|
+| **plan-antislop** (this) | Authenticity / slop burndown (plan only) |
+| `enhance-web-ui` / `enhance-web-ux` | Apply polish after the plan |
+| `plan-uiux-unification` | Design-system + IA unification |
+| `plan-dead-code` | Provably unreachable code, deps, duplication |
+
+## How to reason (every plan item)
+
+1. **Propose** — direction to remove a tell (not the rewrite)
+2. **Risk** — how loudly it reads as machine-made, and who sees it first
+3. **Keep-working** — copy/UI/code that already sounds or looks intentional
+4. **Phase** — copy → visual → IA → code (do not execute)
+
+## Worked example
+
+> **Propose:** replace the hero dual-clause ("It's not just a tracker, it's a companion") with the concrete benefit already in the docs.
+> **Risk:** first-screen cadence is the loudest AI tell; readers bounce.
+> **Keep-working:** settings microcopy is already terse and product-specific.
+> **Phase:** Phase 1 — copy pass via `docs-writer`.
+
+**Role:** Senior editor + product designer + staff engineer (authenticity lens).
+
+**Task:** Inventory machine-generated tells across prose, visual/UI, code, and structure/IA.
+Score each finding by recognizability × effort, cluster into phased burndowns, emit
+`plan-antislop.md`. **Audit & plan only — no rewrites until each phase is approved.**
+
+**Find the AI tells. Plan their removal. Change nothing until approved.**
+
+"Slop" is content that is *recognizably* machine-generated: technically fine,
+semantically empty, and uniform in a way no human hand would produce. This skill
+is the **audit-and-plan** half of de-slopping. It inventories slop across four
+surfaces, ranks each finding by *recognizability × effort*, and emits a phased
+burndown the user approves before any rewrite happens.
+
+This skill never rewrites. It produces `plan-antislop.md`. Execution is handed to
+`enhance-web-ux`, `enhance-web-ui`, `enhance-web-landing`, `design-frontend`,
+`audit-i18n`, or `docs-writer` after approval — same contract as every `plan-*`
+skill in this repo.
+
+---
+
+## When this fires
+
+Trigger phrases: *"this feels AI-generated"*, *"de-slop this"*, *"reads like
+ChatGPT"*, *"make it sound human"*, *"every page looks identical"*, *"it's
+generic/templated/soulless"*, *"strip the AI smell before launch"*, *"voice and
+authenticity pass"*.
+
+Do **not** fire for: functional bugs (`debug-*`), security/RLS
+(`plan-security-audit`), missing tests (`plan-test-coverage`), or designing a new
+surface from scratch (`design-frontend`). Slop is about *recognizability*, not
+correctness — code can be 100% working and still be 100% slop.
+
+---
+
+## The four slop surfaces  [HIGH freedom]
+
+Audit each surface the codebase actually has. Skip surfaces that don't apply
+(a backend-only repo has no visual surface).
+
+### 1 · Prose & copy slop
+
+The most detectable surface. Scan all user-facing strings, marketing copy,
+READMEs, microcopy, error messages, and comments for:
+
+- **Cadence tells** — "It's not just X, it's Y." / "In today's fast-paced world…"
+  / "Let's dive in." / "The result? …" / "But here's the thing:" / rhetorical
+  question → one-line answer.
+- **Filler vocabulary** — *delve, tapestry, realm, landscape, leverage,
+  seamless, robust, elevate, unlock, empower, navigate, foster, testament,
+  bustling, vibrant, game-changer, at the end of the day.*
+- **Hedge-and-pad** — "it's important to note that", "it's worth mentioning",
+  "in conclusion", triple-adjective stacks, sentences that restate the heading.
+- **Punctuation tics** — em-dash overuse, "—and that's the point.", emoji as
+  bullet points, Title Case Everywhere, bolded **every** other phrase.
+- **Empty symmetry** — three benefits that are the same benefit, "Fast. Simple.
+  Powerful." triads, conclusions that summarize a 2-paragraph page.
+
+Output for each: file/line, the tell, *why a human wouldn't write it*, and a
+direction for the fix (not the fix itself).
+
+### 2 · Visual & UI slop
+
+The "I've seen this exact app 400 times" surface:
+
+- **Default-palette tell** — untouched shadcn violet/zinc, the default Tailwind
+  blue-600 CTA, no brand color anywhere.
+- **Card-grid monotony** — every section is a 3-up grid of identical rounded
+  cards with an icon, a bold title, and two lines of gray text.
+- **Centered-everything** — every section center-aligned, max-w-2xl, same
+  vertical rhythm, no asymmetry, no intentional focal point.
+- **Iconography slop** — a lucide icon on every feature whether it means
+  anything or not; emoji in headings.
+- **No hierarchy** — all sections weighted equally; nothing is the hero, nothing
+  recedes; uniform spacing top to bottom.
+- **Generic motion** — fade-in-on-scroll on everything, or no motion at all.
+
+Cross-check against the project's design tokens if `audit-uiux-design-system`
+data or a tokens file exists — slop is often *divergence from* the design system
+plus *convergence toward* the framework default.
+
+### 3 · Code slop
+
+Working code that no engineer would have left as-is:
+
+- **Placeholder residue** — `// TODO: implement`, `// your logic here`,
+  `foo`/`bar`/`data`/`handleClick` naming, `lorem ipsum`, commented-out
+  scaffolding, `console.log('here')`.
+- **Comment slop** — comments restating the code (`// increment i by 1`),
+  docstrings that paraphrase the function name, banner comments around trivial
+  blocks.
+- **Over-abstraction** — a factory + interface + strategy for one concrete case;
+  `utils/helpers/index.ts` dumping grounds; premature generics.
+- **Copy-paste uniformity** — five near-identical components that should be one
+  parameterized component; the same try/catch boilerplate everywhere.
+- **Defensive theater** — `if (!data) return null` guards that can't trigger;
+  empty catch blocks; types widened to `any` to silence the compiler.
+
+This overlaps `audit-code-quality` — here the lens is specifically *"looks
+auto-generated"*, not general correctness. Flag, don't fix.
+
+It also overlaps `plan-dead-code`, which owns *provable unreachability*
+(a module-graph fact). Split by which judgment you are making: commented-out
+scaffolding and guards that can't trigger are slop **because a human would
+not have left them**, not because a tool proved nothing reaches them. Counts
+and deletion of unused files, exports, deps, and duplication belong there.
+
+### 4 · Structure & IA slop
+
+The shape of the thing:
+
+- **Listicle-brain** — everything is a bulleted list because the model defaults
+  to lists; no prose, no flow, no argument.
+- **Symmetrical IA** — every page has identical Hero → Features → Testimonials →
+  CTA scaffolding regardless of purpose.
+- **README slop** — emoji-headers, a feature table no one asked for, "## Getting
+  Started" boilerplate, badges that don't link anywhere, a "Contributing"
+  section on a solo throwaway.
+- **Empty completeness** — sections that exist because the template had them
+  (FAQ with invented questions, "Roadmap" with placeholder quarters).
+
+---
+
+## Procedure  [HIGH freedom]
+
+1. **Scope.** Identify which of the four surfaces exist. State assumptions. If
+   the user pointed at a specific route/file, scope to it; otherwise sweep the
+   user-facing surface area.
+2. **Inventory.** Walk each in-scope surface. Collect concrete findings with
+   `path:line` (or route + screenshot region for visual). Quote the *minimum*
+   needed to identify the tell — never paste whole files.
+3. **Score.** Rate each finding **Recognizability** (how loudly it screams "AI
+   wrote this": High / Med / Low) × **Effort** (S / M / L). High-recognizability +
+   Small-effort items are the top of the burndown — biggest authenticity gain per
+   minute.
+4. **Cluster into phases.** Group findings so each phase is independently
+   shippable and maps to one execution skill. Suggested default ordering:
+   - **Phase 1 — Copy pass** (`docs-writer` / `audit-i18n`): kill cadence tells &
+     filler vocab. Highest signal, lowest risk, no visual regression.
+   - **Phase 2 — Visual identity** (`enhance-web-ui` / `design-frontend`): break
+     the default palette, introduce hierarchy and one intentional focal point per
+     view, de-monotonize the card grids.
+   - **Phase 3 — UX & flow** (`enhance-web-ux` / `enhance-web-landing`): fix IA,
+     replace symmetrical scaffolding with purpose-driven structure.
+   - **Phase 4 — Code cleanup** (`audit-code-quality` / `workflow-refactor`):
+     placeholder residue, comment slop, over-abstraction.
+5. **Emit the report.** Write `plan-antislop.md` (template below), then end the turn with a standalone recap in chat: the two or three highest-impact findings and the first phase to approve. The file is the deliverable — write it before the recap.
+   **Do not start Phase 1.** Wait for explicit approval per phase — the
+   `approved-plan-execution.mdc` handoff contract applies.
+
+---
+
+## Guardrails  [LOW freedom — run exactly]
+
+- **Plan only.** No rewrites, no edits, no "while I'm here" fixes. The deliverable
+  is the report.
+- **Slop ≠ broken.** Don't flag working code as slop just because it's simple.
+  Simple-and-intentional is the *goal*, not a defect. The test is "would a human
+  engineer/writer have left this exact thing?" — not "could this be fancier?"
+- **Voice is the user's, not yours.** Recommend *directions* ("warm up the CTA
+  copy to match the conversational tone of the docs"), never ghost-write the
+  replacement in the plan. The whole point is to remove generic voice, so don't
+  inject a different generic voice.
+- **Don't over-correct into anti-slop slop.** Forced quirkiness, ironic
+  lowercase, gratuitous em-dashes-the-other-way, and "edgy" copy are *also* slop.
+  Flag the tendency; aim for intentional, not performative.
+- **Cite the design system.** When flagging visual slop, reference the project's
+  actual tokens/brand if they exist. "Diverges from your defined `--brand-500`"
+  is actionable; "use nicer colors" is not.
+- **Minimal quoting.** Identify tells by location and short excerpt; never
+  reproduce large blocks of the source.
+
+## Self-critique before the burndown  [LOW freedom — do not skip]
+
+1. **evidenced-not-assumed** — `path:line` (or route + region) plus the tell
+2. **plan-only** — direction only; no rewrite and no ghost-written replacement
+3. **phase justified** — high-recognizability + small-effort leads; copy before code
+4. **right-owner** — functional bugs → `debug-*`; new surface from scratch → `design-frontend`
+5. **no-false-safety** — simple-and-intentional is not slop; don't invent anti-slop slop
+
+---
+
+## Report template — `plan-antislop.md`
+
+```markdown
+# Anti-Slop Burndown — <repo/route>
+
+_Audit-only. Nothing changes until each phase is approved._
+
+## Scope
+- Surfaces audited: [ ] Prose  [ ] Visual  [ ] Code  [ ] Structure
+- Out of scope / assumptions: …
+
+## Slop score (at a glance)
+| Surface    | Findings | High-recognizability | Top quick win |
+|------------|----------|----------------------|---------------|
+| Prose      | n        | n                    | …             |
+| Visual     | n        | n                    | …             |
+| Code       | n        | n                    | …             |
+| Structure  | n        | n                    | …             |
+
+## Findings
+### Prose & copy
+| # | Location | Tell | Why it reads as AI | Recog | Effort | Direction |
+|---|----------|------|--------------------|-------|--------|-----------|
+| P1 | hero/page.tsx:24 | "It's not just a tracker, it's a companion" | dual-clause hype cadence | High | S | state the concrete benefit plainly |
+
+### Visual & UI
+| # | Route/region | Tell | Recog | Effort | Direction |
+|---|--------------|------|-------|--------|-----------|
+
+### Code
+| # | path:line | Tell | Recog | Effort | Direction |
+|---|-----------|------|-------|--------|-----------|
+
+### Structure & IA
+| # | Location | Tell | Recog | Effort | Direction |
+|---|----------|------|-------|--------|-----------|
+
+## Phased burndown
+- **Phase 1 — Copy pass** → `docs-writer` / `audit-i18n` — items P1, P3, P7…
+- **Phase 2 — Visual identity** → `enhance-web-ui` / `design-frontend` — V1, V2…
+- **Phase 3 — UX & flow** → `enhance-web-ux` / `enhance-web-landing` — S1, S4…
+- **Phase 4 — Code cleanup** → `audit-code-quality` / `workflow-refactor` — C2…
+
+## Execution handoff
+Approve a phase to run it. Suggested order maximizes authenticity-per-effort.
+Re-run `plan-antislop` after execution to confirm the burndown closed.
+```
+
+---
+
+## Chains with
+
+- **Six-skill plan loop** — slots beside `plan-uiux-unification`; run after it so
+  visual-slop findings inherit the design-system burndown.
+- **Execution:** `enhance-web-ux`, `enhance-web-ui`, `enhance-web-landing`,
+  `design-frontend`, `audit-i18n`, `docs-writer`, `workflow-refactor`.
+- **Verify:** after execution, `test-playwright` (does it still work?) and a
+  second `plan-antislop` pass (did the slop actually drop?).
+
+> Planned at high effort; executed at the default effort under the approved-plan execution rule (`approved-plan-execution.mdc`), which forbids reward hacking and feature deletion on any model. The plan says *which* slop to remove; the rule constrains *how*.

package/skills/plan-aso/SKILL.md

@@ -0,0 +1,149 @@
+---
+name: plan-aso
+description: >
+  Plan-only ASO audit of App Store and Google Play listings: keywords,
+  localized metadata, screenshots, ratings prompts. Use when "optimize our
+  store listing", "improve app downloads", or "ASO". Submission readiness →
+  plan-mobile-readiness.
+license: MIT
+effort: high
+---
+
+# plan-aso — Store listing growth plan
+
+**Degree of freedom: HIGH** — audit the listing, emit a plan. Stay
+**plan-only**. No metadata, screenshot, or prompt edits until approved.
+
+**Role:** Mobile growth / ASO specialist.
+
+**Task:** Audit the listing that decides whether a visitor installs, emit
+`plan-aso.md`. **Plan only — no metadata, screenshot, or prompt edits until
+approved.**
+
+**ASO is two funnels:** keywords decide who *finds* the app; screenshots +
+first impression decide who *installs*.
+
+## This skill vs neighbors
+
+| Skill | Owns |
+|---|---|
+| **plan-aso** (this) | Find + install conversion of the *listing* |
+| `plan-mobile-readiness` | Submission mechanics, privacy manifest, demo account |
+| `plan-privacy-compliance` | Honest privacy labels (don't ASO-lie about data) |
+| `enhance-web-seo` / `plan-aeo-readiness` | Web / answer-engine discoverability |
+| `audit-monetization-iap` | Whether IAP actually works |
+| `design-frontend` | Asset production after the plan is approved |
+
+Do **not** fire for "will Play reject us / Guideline 2.5.2" →
+`plan-mobile-readiness`.
+
+## How to reason (every plan item)
+
+1. **Propose** — keyword, locale, screenshot order, or ratings-prompt change
+2. **Risk** — find vs install: who never sees the app, or who sees it and bounces
+3. **Keep-working** — locales/assets that already convert
+4. **Phase** — quick / medium / ongoing (do not execute)
+
+## Worked example
+
+> **Propose:** fill the unused 40 chars of the iOS keyword field; drop
+> title-word repeats; put the benefit screenshot first.
+> **Risk:** core use-case terms never indexed; first impression is a bare UI dump.
+> **Keep-working:** JP long description already locale-native.
+> **Phase:** quick — keywords + screenshot reorder.
+> **Find vs install:** find (keywords) + install (shot 1).
+
+---
+
+## Phase 0 — Gather the current listing  [HIGH freedom]
+
+Per platform × locale: name, subtitle (iOS) / short description (Android),
+iOS 100-char keyword field, long description, screenshots + captions, preview
+video, icon, category, ratings state. Note machine-translated or EN-only
+locales.
+
+---
+
+## Phase 1 — Discoverability (find)  [HIGH freedom]
+
+**iOS keywords** — 100 chars fully used, comma-separated, no wasted spaces, no
+repeats of title/subtitle words, no plural+singular waste. Core use-case terms
+present.
+
+**Title & subtitle** — Title carries the #1 keyword beyond brand. Subtitle is
+a keyword-bearing value line, not a slogan.
+
+**Android** — Play indexes the long description. Core terms in the first lines,
+natural density, not stuffed.
+
+**Localization** — Each locale is a separate keyword surface. JP + EN need
+*locale-native* keywords, not translated English. Untapped locales are the
+cheap win.
+
+**Category & competitors** — Right primary category? Terms competitors rank
+that this listing ignores?
+
+---
+
+## Phase 2 — Conversion (install)  [HIGH freedom]
+
+**Screenshots** — First 2–3 (no scroll) lead with benefit captions, not bare
+UI. Narrative across the set. Localized text for key markets.
+
+**Icon** — Distinct at thumbnail size.
+
+**Preview video** — Value in the first seconds (often muted autoplay).
+
+**Above-the-fold copy** — One-line hook, not "Welcome to…".
+
+**Ratings** — In-app prompt at a *positive* moment (after value, not on
+launch). Reviews responded to.
+
+**Trust** — No leftover screenshots from an old version.
+
+---
+
+## Phase 3 — Prioritized plan (approve before executing)  [HIGH freedom — plan only]
+
+- **Quick** — fill keyword field, drop redundant title words, add missing
+  core-market locale, reorder screenshots value-first
+- **Medium** — benefit captions, localized screenshot text, preview video,
+  well-timed rating prompt
+- **Ongoing** — locale expansion, review cadence, store A/B on icon/shots,
+  keyword iteration
+
+Each item: current → change → find vs install → effort. Asset work flagged
+for `design-frontend`.
+
+## Self-critique before the burndown  [LOW freedom — do not skip]
+
+1. **Per platform × locale** — do not audit EN-only and call JP done
+2. **Find vs install labeled** — every item says which funnel it moves
+3. **No ASO-lie** — privacy labels stay honest (`plan-privacy-compliance`)
+4. **Right owner** — Guideline 2.5.2 / demo account → `plan-mobile-readiness`
+5. **Nothing edited** on the listing until approved
+
+## Definition of Done
+
+- [ ] Listing inventory per platform × locale
+- [ ] iOS keywords + title/subtitle audited
+- [ ] Android description placement checked
+- [ ] Localization gaps with locale-native keyword notes
+- [ ] Screenshots / icon / video / hook / ratings reviewed
+- [ ] Plan prioritized; approved before listing edits
+
+## Output format
+
+1. **Inventory** — field × platform × locale
+2. **Find findings** — issue | severity | fix
+3. **Install findings** — issue | severity | fix
+4. **Plan** — quick / medium / ongoing
+5. **Recap and await approval** — end the turn with a standalone recap in chat: the two or three highest-impact findings and the first phase to approve. `plan-aso.md` is the deliverable; write it before the recap.
+
+## Related
+
+- `plan-mobile-readiness` — get into the store
+- `plan-privacy-compliance` — labels must match collection
+- `audit-monetization-iap` — paid features actually unlock
+- `enhance-web-seo` / `plan-aeo-readiness` — web counterparts
+- `design-frontend` — produce approved assets

package/skills/plan-backup-dr/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: plan-backup-dr
+description: >
+  Plan-only audit of whether a project can actually recover from data loss,
+  not just whether backups exist. Use when "can we recover if the DB dies",
+  "audit our backups", "what's our RPO/RTO", or "disaster recovery".
+license: MIT
+effort: high
+---
+
+# plan-backup-dr — Recovery capability plan
+
+**Degree of freedom: HIGH** — prove restore, quantify RPO/RTO, plan.
+Stay **plan-only**. No PITR toggles or prod-writing drills until approved.
+
+**Role:** Platform / disaster-recovery engineer.
+
+**Task:** Prove restore works, quantify RPO/RTO, emit `plan-backup-dr.md`.
+**Audit & plan only — no PITR toggles, lifecycle edits, or drills that write
+to prod until approved.**
+
+**Backup existence is not recovery capability.** An untested backup is a hope.
+
+## This skill vs neighbors
+
+| Skill | Owns |
+|---|---|
+| **plan-backup-dr** (this) | Can you restore? RPO/RTO, drill evidence, SPOF |
+| `plan-data-integrity` | Stop destructive ops *going forward* (unguarded DELETE/DROP) |
+| `audit-env-parity` | Staging pointing at prod data (blast-radius setup) |
+| `audit-infra-cost` | Backup retention that silently explodes the bill |
+| `plan-secrets-audit` | Credential exposure — not "can I reconstruct secrets after loss" |
+
+Do **not** fire for "is this migration safe / agent might delete prod" →
+`plan-data-integrity`. That skill *prevents* wipe; this one *recovers* after one.
+
+## How to reason (every plan item)
+
+1. **Propose** — backup, restore path, drill, or off-provider export
+2. **Risk** — worst-case in plain language ("lose up to a day of uploads")
+3. **Keep-working** — stores that already have a proven restore
+4. **Phase** — P0 / P1 / P2 (do not execute)
+
+## Worked example
+
+> **Propose:** run one isolated restore drill of the primary DB; write the
+> runbook from what you actually did.
+> **Risk:** daily snapshot exists, never restored — RPO 24h is a hope, RTO unbounded.
+> **Keep-working:** object-storage versioning already on.
+> **Phase:** P0 — no proven restore.
+> **Target:** drill into an isolated env, never over prod.
+
+---
+
+## Phase 0 — Map the recovery surface  [HIGH freedom]
+
+For each stateful thing, find backup *and* restore:
+
+- **Primary DB** (Supabase/Postgres): PITR? snapshots? retention? who restores?
+- **Object storage:** versioning? lifecycle that *deletes*? backed up at all?
+- **Secrets & config:** reconstructable if the account vanished?
+- **Auth users:** identities recoverable, or only app rows?
+- **External state:** Stripe, third-party subs, DNS, domain
+- **Code & IaC:** reproducible from repo, or dashboard-only?
+
+---
+
+## Phase 1 — Audit recovery reality  [HIGH freedom]
+
+**RPO** — Real gap between backups. Daily snapshot = up to 24h gone. PITR =
+seconds. State the number, not the aspiration.
+
+**RTO** — Walk the actual restore runbook. No runbook → RTO is unbounded.
+
+**Restore drill** — Evidence a restore *succeeded* and was verified. None →
+P0 is "run one end-to-end drill" (into an isolated env, never over prod).
+
+**SPOF** — One provider/region/account. Billing/ToS/compromise suspends
+everything? Off-provider export?
+
+**Silent loss** — Lifecycle rules or `ON DELETE CASCADE` that erase more than
+intended (cross-check `plan-data-integrity`). Backups that expire before anyone
+would notice slow corruption.
+
+**Bus-factor** — Restore credentials behind a login only one person has.
+
+---
+
+## Phase 2 — Phased DR plan (approve before executing)  [HIGH freedom — plan only]
+
+- **P0** — no proven restore; any store with *no* backup; secrets unrecoverable; bus-factor-1
+- **P1** — RPO worse than the data justifies; no written runbook; no off-provider export
+- **P2** — RTO reduction, automated restore verify, drill cadence
+
+Each item: current state, worst-case in plain language ("lose up to a day of
+uploads"), target RPO/RTO, concrete change.
+
+## Self-critique before the burndown  [LOW freedom — do not skip]
+
+1. **RPO is a number** — not "we have backups"
+2. **Drill evidence or P0** — absence is the finding
+3. **No prod writes** — isolated env only, and only after approval
+4. **Right owner** — unguarded DELETE → `plan-data-integrity`
+5. **Do not cut restore** to save cost (`audit-infra-cost` must not expire backups)
+
+## Definition of Done
+
+- [ ] Every stateful store has backup AND restore method
+- [ ] RPO stated as a real number per store
+- [ ] RTO estimated from the actual (or absent) runbook
+- [ ] Restore-drill evidence found — or absence flagged P0
+- [ ] Secrets/config reconstructable
+- [ ] SPOF + off-provider export status known
+- [ ] Recovery-access bus-factor assessed
+- [ ] Plan approved before infra change
+
+## Output format
+
+1. **Recovery surface** — store | backup | restore | RPO | RTO | last drill
+2. **Findings** — issue | worst-case | severity | evidence
+3. **SPOF map** — shared account/region/provider
+4. **Phased DR plan** — P0/P1/P2 with target RPO/RTO
+5. **Recap and await approval** — end the turn with a standalone recap in chat: the two or three highest-impact findings and the first phase to approve. `plan-backup-dr.md` is the deliverable; write it before the recap. Test restore only into an isolated env.
+
+## Related
+
+- `plan-data-integrity` — prevent wipe; this proves restore
+- `audit-env-parity` — staging vs prod data targeting
+- `audit-infra-cost` — retention vs bill
+- `plan-secrets-audit` — leaked keys, not reconstructability
+- `workflow-environment-ready` — local runnability, not DR