@hanzlaa/rcode 2.7.2 → 3.1.0

package/rihal/skills/core/rihal-memory-distill/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: rihal-memory-distill
+description: >
+  Generate or regenerate Memory Bank distillates — token-optimised, lossless
+  compressions of Memory Bank source files for fast LLM context loading.
+  Produces `distillates/project.distillate.md` and `distillates/stack.distillate.md`.
+  Activates when the user says "distill memory bank", "regenerate distillates",
+  "refresh distillates", "/rcode:memory-distill", "compress memory bank",
+  "memory bank ko compress karo". Do NOT use for: bootstrap (use rcode-memory-init),
+  surgical updates (use rcode-memory-update), or finding stale entries (use
+  rcode-memory-audit). For non-Memory-Bank document compression, use the
+  existing rihal-distillator skill.
+triggers:
+  - "distill memory bank"
+  - "regenerate distillates"
+  - "refresh distillates"
+  - "compress memory bank"
+  - "memory bank ko compress karo"
+  - "/rcode:memory-distill"
+user-invocable: true
+---
+
+## Overview
+
+Read the Memory Bank source files and produce two LLM-optimised distillates: a full project distillate (`distillates/project.distillate.md`) and a stack-only distillate (`distillates/stack.distillate.md`). Distillates are lossless: every fact, decision, constraint, and relationship from the source files is preserved, but presentation overhead (headings, tables, prose connective tissue) is stripped to minimise token cost. Reuses the same compression principle as the existing `rihal-distillator` skill, scoped to Memory Bank files.
+
+## Workflow
+
+1. **Discover sources.** Walk `.rihal/memory/` and group files by target distillate:
+   - **project distillate:** `project/*.md`, `people/*.md`, `milestones/current.md`, `incidents/known-issues.md`
+   - **stack distillate:** `project/stack.md` only
+2. **Hash sources.** Compute a digest of source file mtimes. If digest matches the existing distillate's `source-digest:` frontmatter, skip regeneration unless `--force` was passed.
+3. **Compress.** For each target, read all source files, extract every fact/decision/constraint/relationship, and produce a dense markdown document. No summary mode — preserve everything.
+4. **Verify losslessness.** For each fact in the source files, confirm it appears (verbatim or in directly-equivalent form) in the distillate. Report any drops as a warning.
+5. **Write output** with frontmatter:
+   ```yaml
+   ---
+   generated: true
+   do-not-edit: true
+   regenerate-with: /rcode:memory-distill
+   source-digest: <hash>
+   generated-at: <ISO datetime>
+   source-files: [list of files included]
+   token-estimate: <approximate>
+   ---
+   ```
+6. **Print summary.** Show source file count, output token estimate, time taken.
+
+## Output Format
+
+```
+✓ Memory Bank distillates regenerated
+
+  distillates/project.distillate.md
+    sources:  9 files
+    tokens:   ~4,800
+    digest:   a1b2c3d4
+
+  distillates/stack.distillate.md
+    sources:  1 file
+    tokens:   ~600
+    digest:   e5f6a7b8
+
+Skip notice: source files unchanged since last run — no rewrite was needed.
+```
+
+## Examples
+
+**Happy path**
+User: `/rcode:memory-distill`
+Skill: reads sources, regenerates both distillates, prints summary. ~10 seconds for a typical project.
+
+**No-op skip**
+User runs distill twice in a row without changing source files. Second run reports "source files unchanged" and exits without rewriting.
+
+**Force refresh**
+User: `/rcode:memory-distill --force`
+Skill: regenerates regardless of digest match. Useful when distillate format itself changes.
+
+**Negative — used on non-memory docs**
+User wants to compress `docs/REFERENCE.md`. Wrong skill — direct them to `rihal-distillator` (which handles arbitrary documents).
+
+## Memory Bank Hooks
+
+- **Reads:** every file under `.rihal/memory/{project,people,milestones,incidents}/`
+- **Writes:** `.rihal/memory/distillates/project.distillate.md`, `.rihal/memory/distillates/stack.distillate.md`
+- **Idempotent:** safe to re-run; skips work when sources are unchanged

package/rihal/skills/core/rihal-memory-init/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: rihal-memory-init
+description: >
+  Bootstrap the rcode Memory Bank for a project. Copies templates from
+  `rihal/templates/memory/` into `.rihal/memory/`, then asks 5 questions to
+  populate the most-used files (stack, current milestone, primary stakeholder).
+  Activates when the user says "init memory bank", "bootstrap memory",
+  "set up memory bank", "/rcode:memory-init", "create memory bank",
+  "memory bank initialise", "memory bank kaise banayen". Do NOT use for:
+  updating an existing Memory Bank (use rcode-memory-update), regenerating
+  distillates (use rcode-memory-distill), or finding stale entries (use
+  rcode-memory-audit).
+triggers:
+  - "init memory bank"
+  - "bootstrap memory"
+  - "set up memory bank"
+  - "create memory bank"
+  - "memory bank initialise"
+  - "memory bank kaise banayen"
+  - "/rcode:memory-init"
+user-invocable: true
+---
+
+## Overview
+
+Initialise the `.rihal/memory/` directory in the current project. Copies the template scaffold, fills `INDEX.md` with the project name and date, and asks five short questions to seed the most useful files. Skill is idempotent: re-running on an initialised project will not overwrite existing entries — it reports gaps instead.
+
+## Workflow
+
+1. **Check for existing Memory Bank.** If `.rihal/memory/INDEX.md` exists, switch to "report mode": list files, show which sections are still empty, and exit. Do not overwrite.
+2. **Copy templates.** Recursively copy `rihal/templates/memory/` → `.rihal/memory/`, preserving the directory structure.
+3. **Substitute placeholders.** Replace `{{PROJECT_NAME}}` with the directory name (or `package.json` `name` if present), and `{{INIT_DATE}}` with today's ISO date.
+4. **Ask the 5 init questions** (one at a time, accept short answers):
+   1. One-sentence project goal → seeds `milestones/current.md` Goal field
+   2. Primary stack (frontend / backend / database) → seeds `project/stack.md` Runtime table
+   3. Current milestone name → seeds `milestones/current.md` Milestone Name
+   4. Primary external stakeholder (name + role) → seeds `people/stakeholders.md`
+   5. Any known production issue today → seeds `incidents/known-issues.md`
+5. **Print the summary.** Show the file tree, where to add more, and recommend running `/rcode:memory-distill` once `project/stack.md` is fleshed out.
+6. **Update `.rihal/state.json`** to record `memory_bank.initialised_at` so the dashboard shows it as live.
+
+## Output Format
+
+```
+✓ Memory Bank initialised at .rihal/memory/
+
+Files seeded from your answers:
+  • milestones/current.md  — goal + milestone name
+  • project/stack.md       — runtime stack
+  • people/stakeholders.md — 1 contact
+  • incidents/known-issues.md — 1 entry
+
+Files still empty (fill as you go):
+  • project/glossary.md
+  • people/team.md
+  • change-records/
+
+Next step: run /rcode:memory-distill to generate fast-load distillates.
+```
+
+## Examples
+
+**Happy path**
+User: `/rcode:memory-init`
+Skill: asks 5 questions, populates files, prints summary, updates state.json. Total time: under two minutes.
+
+**Already initialised**
+User: `/rcode:memory-init` on a project that already has `.rihal/memory/INDEX.md`.
+Skill: refuses to overwrite. Lists files, shows which are still empty, suggests `/rcode:memory-update` for surgical edits.
+
+**Negative — wrong skill**
+User wants to "update the stakeholder list". Do not use this skill. Use `rcode-memory-update`.
+
+## Memory Bank Hooks
+
+- **Reads:** `package.json` (for project name), existing `.rihal/state.json`
+- **Writes:** every file under `.rihal/memory/` (from templates), `.rihal/state.json` (`memory_bank.initialised_at`)

package/rihal/skills/core/rihal-memory-update/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: rihal-memory-update
+description: >
+  Surgical update of specific Memory Bank files from conversation context.
+  Adds an entry to decisions.md, appends a known issue, updates the current
+  milestone, or extends the stakeholder list — without rewriting whole files.
+  Activates when the user says "remember this decision", "log this decision",
+  "add this to memory bank", "update memory bank", "/rcode:memory-update",
+  "save this to memory", "yeh memory mein add karo", or after a council
+  session that produced a clear decision. Do NOT use for: initial bootstrap
+  (use rcode-memory-init), regenerating distillates (use rcode-memory-distill),
+  or general note-taking (use the existing rihal-note workflow).
+triggers:
+  - "remember this decision"
+  - "log this decision"
+  - "add this to memory bank"
+  - "update memory bank"
+  - "save this to memory"
+  - "yeh memory mein add karo"
+  - "/rcode:memory-update"
+user-invocable: true
+---
+
+## Overview
+
+Append or update a single Memory Bank file based on the current conversation context. Surgical: never rewrites a whole file, never deletes existing content. Auto-routes the update to the right file based on what's being saved (decision → `decisions.md`, issue → `known-issues.md`, etc.).
+
+## Workflow
+
+1. **Detect target file.** Read the user's intent and pick the destination:
+   - "decision" / "we chose" / "ADR" → `project/decisions.md`
+   - "issue" / "bug" / "workaround" → `incidents/known-issues.md`
+   - "stakeholder" / "client" / "contact" → `people/stakeholders.md`
+   - "milestone" / "sprint" / "phase" → `milestones/current.md`
+   - "stack" / "we're using" / "switched to" → `project/stack.md`
+   - "term" / "what does X mean" / "glossary" → `project/glossary.md`
+   - "team" / "who owns" → `people/team.md`
+2. **Confirm target with user.** Show the file path and the entry to be added. Wait for ack.
+3. **Append using the file's documented format.** Each Memory Bank file documents its own entry format at the top — follow it exactly.
+4. **Never overwrite.** If the user wants to *change* an existing entry, refuse and direct them to edit the file directly. This skill is append-only for safety.
+5. **Stamp with date** in `YYYY-MM-DD` format.
+6. **Suggest distillate refresh** if the update was substantive (`/rcode:memory-distill`).
+
+## Output Format
+
+```
+✓ Appended to .rihal/memory/project/decisions.md
+
+  ### 2026-04-26 — Switch to Postgres 16 from Postgres 14
+  **Decision:** Upgrade primary database to Postgres 16.4.
+  **Rationale:** ...
+
+Tip: run /rcode:memory-distill to refresh the project distillate.
+```
+
+## Examples
+
+**Happy path — decision**
+User: `remember this decision: we picked Temporal over BullMQ because we need durable workflows`
+Skill: detects decision intent, formats entry, confirms, appends to `decisions.md`.
+
+**Happy path — known issue**
+User: `add to memory bank: SSO login fails on Safari 16, workaround is Chrome`
+Skill: detects issue intent, formats entry, appends to `incidents/known-issues.md`.
+
+**Negative — destructive request**
+User: `update memory bank: change the milestone goal to X`
+Skill: refuses ("this skill is append-only"). Suggests editing `milestones/current.md` directly.
+
+## Memory Bank Hooks
+
+- **Reads:** the target file's existing format header (to preserve structure)
+- **Writes:** exactly one append to one file per invocation

package/rihal/skills/core/rihal-mvp-graduate/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: rihal-mvp-graduate
+description: Move an MVP to production-grade infrastructure incrementally. Use when an MVP has shipped, has real users, and "the next round of features" is hitting walls — flaky deploys, no observability, manual ops, hand-rolled auth. Specifically addresses Rihal's "MVPs delivered, hard to revamp" pain. Companion to rihal-migrate (the engineering skill); this one is the strategic / sequenced version specifically scoped to MVP→prod.
+triggers:
+  - "graduate this mvp"
+  - "mvp to prod plan"
+  - "real users now"
+  - "scale beyond demo"
+  - "post-mvp infrastructure"
+  - "revamp mvp"
+  - "hardening pass"
+  - "ready for production"
+user-invocable: true
+---
+
+## Overview
+
+This skill is the strategic version of `rihal-migrate`: same gap analysis, but framed as a multi-week plan with stakeholder sequencing rather than a one-week-per-gap engineering checklist. Use this when the conversation starts with the founder/CEO; use `rihal-migrate` when the conversation starts with the engineer.
+
+## The graduation framework
+
+### Phase A — Stop the bleeding (week 1)
+
+If any of these are missing, ship them first. Skip the "feature factory" until they're in place.
+
+1. **Sentry (or equivalent).** Until you can see what's breaking in production, every bug is a guess.
+2. **Automated backups.** Daily. Tested restore. No "we have backups but never tried to use them".
+3. **CI on every PR.** Even just "the tests pass". Manual deploys with no test gate is shipping blind.
+4. **Single source of truth for env vars.** No "Hanzla has the prod env in his Notion".
+
+### Phase B — Lock down auth + tenant isolation (weeks 2-3)
+
+The Rihal incident makes this non-negotiable for anything multi-org.
+
+1. Real auth provider (Keycloak / Clerk / Auth0). Drop hand-rolled JWT.
+2. Tenant isolation enforced at the query layer (RLS or middleware), not the URL.
+3. Run `rihal-auth-audit` end-to-end before declaring this phase done.
+
+### Phase C — Operational maturity (weeks 4-5)
+
+1. Healthchecks → liveness + readiness, distinct.
+2. Resource limits → memory request = limit, no overcommit.
+3. PodDisruptionBudget for replica > 1 deployments.
+4. Logs are structured (JSON) and searchable.
+
+### Phase D — Documentation + onboarding (week 6)
+
+1. README that gets a new dev to a working local environment in < 1 day.
+2. Architecture diagram (Mermaid in `docs/`, regenerated, not hand-drawn).
+3. Runbooks for the 5 most common ops events (deploy, rollback, restart, restore, scale).
+4. `.rihal/memory/` populated — this skill writes the project-summary as the deliverable.
+
+### Phase E — Performance + cost (weeks 7-8)
+
+Run `rihal-perf` against the top 5 slowest pages / queries. Do the cost math: which K8s pods are over-provisioned? Which queries are scanning when they could index?
+
+## Stakeholder sequencing
+
+Each phase has a different audience:
+
+- Phase A: founder/CEO buy-in (it's not features, but it stops the bleeding)
+- Phase B: legal / compliance / security (especially for government clients)
+- Phase C: ops on-call (whoever wakes up at 3am)
+- Phase D: future hires / external contributors
+- Phase E: finance + perf-sensitive users
+
+Sequence the conversations accordingly.
+
+## Workflow
+
+1. **Run `rihal-migrate`'s 8-check audit.** Output is the gap report.
+2. **Map gaps to A-E phases.** Phase A first, no exceptions.
+3. **Calendar the phases.** 1-2 weeks each, no parallel phases unless they're truly independent.
+4. **Each week ends with a demo to the relevant stakeholder** — not just a Slack post.
+5. **Persist the plan** to `.rihal/memory/milestones/current.md` so future sessions track progress.
+
+## Output Format
+
+```
+MVP graduation plan — <project name>
+
+Current state (MVP→prod gap report from rihal-migrate):
+  Pass: <count> / 8
+  Critical gaps: <list>
+
+Plan:
+  Phase A (week 1) — Stop the bleeding
+    Owner: <stakeholder>
+    Tasks: <list>
+
+  Phase B (weeks 2-3) — Auth + tenant isolation
+    ...
+
+  Phase C-E ...
+
+Risk register:
+  - <risk> — <mitigation>
+
+Demo schedule:
+  Week 1: Sentry + backups working — demo to founder
+  Week 3: tenant-isolation audit clean — demo to legal/security
+  Week 6: new-dev onboarding < 1 day — demo with a real new dev
+```
+
+## Examples
+
+**Happy path — government client product** — MVP shipped 6 months ago, 3 government clients now. Gap report: missing Sentry, hand-rolled JWT, no automated backups, no Helm chart. Phases A→D mapped over 6 weeks. Each phase signs off with a stakeholder.
+
+**Edge case — pivoting MVP** — Founder wants to pivot. Run gap report anyway — even a pivoted MVP needs the same foundation. The pivot doesn't reset the technical floor.
+
+**Negative — "let's just rewrite in $NEW_FRAMEWORK"** — Refuse. A rewrite isn't graduation, it's restart. Ship the foundation against the existing codebase first; rewrites can come later if the pivot demands it.
+
+## Memory Bank Hooks
+
+- **Reads:** `.rihal/memory/project/stack.md`, `.rihal/memory/incidents/known-issues.md`, `.rihal/memory/people/stakeholders.md` (for sequencing)
+- **Writes:** `.rihal/memory/milestones/current.md` (the graduation plan); `.rihal/memory/change-records/YYYYMMDD-NNN.md` (the kickoff change record)

package/rihal/skills/core/rihal-ocr-consistency/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: rihal-ocr-consistency
+description: OCR pipeline determinism + ground-truth validation. Use when running an OCR pipeline (text extraction from PDFs, scanned documents, government forms) and seeing inconsistent output across runs, language-routing mistakes, or accuracy regressions. Specifically encodes Rihal's OCR pain — Arabic/English routing failures, Triton inconsistencies, missing ground-truth checks.
+triggers:
+  - "ocr inconsistency"
+  - "ocr pipeline"
+  - "text extraction"
+  - "pdf ocr"
+  - "siglip routing"
+  - "triton ocr"
+  - "ground truth"
+  - "ocr accuracy regression"
+user-invocable: true
+---
+
+## Overview
+
+OCR is non-deterministic by default — same input, different output across runs, model versions, and infrastructure. This skill encodes the discipline needed to ship OCR that doesn't silently regress. Default stack: SigLIP2 language router + LightOnOCR / PaddleOCR / Triton; adapt to whatever's in use. The skill assumes Python + Temporal workflows (rcode's verified Rihal stack).
+
+## The 6 consistency checks
+
+### 1. Language routing
+
+- [ ] Router (e.g. SigLIP2) classifies document language **before** OCR.
+- [ ] Confidence threshold for routing decisions — below threshold, surface for human review, don't pick a default.
+- [ ] Routing decisions logged with the document hash for replay.
+- [ ] Arabic/English boundary cases tested explicitly — bilingual documents trip naive routers.
+
+### 2. Model determinism
+
+- [ ] OCR model version pinned in code, not "whatever's loaded in Triton".
+- [ ] Triton config pinned (no auto-update). Model swaps surface as deploys, not silent drift.
+- [ ] Temperature / sampling parameters set to deterministic values (temperature=0 for greedy decoding).
+
+### 3. Ground truth
+
+- [ ] A ground-truth dataset exists — at least 20 documents per language with verified text.
+- [ ] Accuracy is measured on every model upgrade and every infra change (Triton config, GPU change).
+- [ ] Regression threshold defined: e.g. ≥95% character accuracy on the ground-truth set; below blocks deploy.
+
+### 4. Routing tests
+
+- [ ] PyMuPDF text-layer routing is correctly bypassing OCR for text-native PDFs.
+- [ ] English page misclassification tests (the documented Rihal incident — text-layer English pages routed to Arabic OCR).
+- [ ] Mixed-language documents have an explicit handler.
+
+### 5. Pipeline observability
+
+- [ ] Every document passes through with a trace ID.
+- [ ] Routing decision, model used, confidence score, and final output all logged.
+- [ ] Failures (OCR returns empty, confidence below threshold) trigger Sentry alerts, not silent retries.
+
+### 6. Replay capability
+
+- [ ] Any production document can be re-OCR'd from the archived input, deterministically.
+- [ ] Temporal workflows have idempotency — replays don't double-process or skip.
+- [ ] Source documents archived with hash → output mapping.
+
+## Workflow
+
+1. **Run the 6 checks.** Cite file/path for each pass / fail.
+2. **For accuracy regression:** capture the ground-truth diff. Which documents changed output? Which characters?
+3. **Bisect the regression** — was it the model? the Triton config? the routing? Don't ship "we'll figure it out next sprint".
+4. **Persist findings** to `.rihal/memory/incidents/known-issues.md` for unresolved drift, or `.rihal/memory/incidents/post-mortems/` for resolved incidents.
+
+## Output Format
+
+```
+OCR pipeline audit — <date>
+
+Language routing:
+  ✓/✗ findings
+
+Model determinism:
+  ✓/✗ findings
+
+Ground truth:
+  Accuracy on ground-truth set: <X%>
+  Regressions vs last run: <count>
+
+Routing tests:
+  ✓/✗ findings
+
+Observability:
+  ✓/✗ findings
+
+Replay capability:
+  ✓/✗ findings
+
+Critical: <count>
+High: <count>
+Memory Bank update: → .rihal/memory/incidents/...
+```
+
+## Examples
+
+**Happy path — text-layer routing fix** — Audit shows English text-layer PDFs misclassified as Arabic by SigLIP2 (the documented Rihal bug). Fix: route text-layer PDFs to PyMuPDF extraction, bypass OCR entirely. Re-run ground truth: accuracy stable, throughput up.
+
+**Edge case — Triton silent upgrade** — Triton image was bumped from 25.02 to 25.06 in the Helm chart; ground-truth accuracy dropped 4%. Roll back Triton, pin the version, re-run audit. Add a CI check that fails the build on accuracy regression.
+
+**Negative — "OCR is fuzzy by nature, accept the variance"** — Refuse. Variance without measurement is just regression in disguise. Pin the model, pin the infra, measure on ground truth, surface confidence.
+
+## Memory Bank Hooks
+
+- **Reads:** `.rihal/memory/project/stack.md` (OCR layer detection), `.rihal/memory/incidents/post-mortems/` (prior OCR incidents)
+- **Writes:** `.rihal/memory/incidents/known-issues.md` (deferred drift); ground-truth accuracy results into `.rihal/memory/change-records/YYYYMMDD-NNN.md`

package/rihal/skills/core/rihal-party-mode/SKILL.md

@@ -89,3 +89,8 @@ Each party mode turn follows this pattern:
 ### Negative boundary
 **User:** "party mode — approve this PR"
 **Result:** Redirects to `/rihal:code-review` — code review needs structured evaluation, not open discussion.
+
+## Memory Bank Hooks
+
+- **Reads:** `rihal/team.yaml`, every consulted persona's SKILL.md, `.rihal/memory/people/team.md` (so the casual chat respects active team availability)
+- **Writes:** transcript saved to `.rihal/progress/party-{date}.md` for audit; does NOT update Memory Bank decision log (use `rcode-memory-update` if the chat surfaced a real decision)

package/rihal/skills/core/rihal-rebrand/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: rihal-rebrand
+description: Stack-wide rebranding migration — refs, assets, copy, env vars, docs, redirects, package names. Use when a project's brand changes mid-flight and the rename has to ripple through dozens of files without breaking anything. Specifically encodes the Rihal "had to do complete rebranding" pain — the rename touched 100+ files and broke 3 deploys before we got it right.
+triggers:
+  - "rebrand"
+  - "stack-wide rename"
+  - "product rename"
+  - "rename project"
+  - "brand migration"
+  - "logo refresh"
+  - "domain change"
+  - "company name change"
+user-invocable: true
+---
+
+## Overview
+
+A rebrand is N renames at once: package name, npm scope, repo URL, environment variables, asset paths, copy strings, redirects, social handles, contracts. Each one looks small. Together they break things. This skill enforces a checklist + a decomposition (one category per commit) so the rename ships incrementally without a "Friday at 5pm" big-bang deploy.
+
+## The 9 surfaces of a rebrand
+
+For each: scope it before touching code, identify cross-references, decompose into commits.
+
+### 1. Package + repo identity
+
+- [ ] `package.json` `name`, `description`, `repository.url`, `homepage`, `bugs.url`
+- [ ] `README.md` heading, badges, CDN URLs, npm install commands
+- [ ] Repository name on GitHub (and any forks / deploy keys / webhooks)
+- [ ] npm scope rename (this is one-way; coordinate carefully)
+
+### 2. Environment variables + secrets
+
+- [ ] Old prefix `OLDBRAND_*` → `NEWBRAND_*`
+- [ ] Update `.env.example`, all CI environment definitions, K8s ConfigMaps and Secrets
+- [ ] Compatibility window: read both names for 1 release, then drop the old
+
+### 3. Assets
+
+- [ ] Logos, favicons, OG images, brand-coloured graphics
+- [ ] Email templates (transactional + marketing)
+- [ ] PDF templates, certificate templates, invoice templates
+
+### 4. Copy strings
+
+- [ ] User-facing UI copy
+- [ ] Email subject lines + bodies
+- [ ] Push notification text
+- [ ] Error messages
+- [ ] Marketing site / landing page
+
+### 5. URLs + redirects
+
+- [ ] Old domain → new domain HTTP 301s
+- [ ] Email-link tracking domains
+- [ ] Deep-link schemes (`oldbrand://` → `newbrand://`) with backwards-compat for installed apps
+- [ ] CDN paths + old-image redirects
+
+### 6. Social + external
+
+- [ ] Twitter / LinkedIn / Instagram handles (one-way; rename last after rest is verified)
+- [ ] App Store / Play Store listings + reviews moved
+- [ ] Crashlytics / Sentry project name
+- [ ] Stripe / payment processor business name
+
+### 7. Documentation + onboarding
+
+- [ ] README, CONTRIBUTING, all `docs/`
+- [ ] Internal wiki / Notion
+- [ ] Customer-facing help docs
+
+### 8. Code-internal references
+
+- [ ] CSS variable names (`--oldbrand-blue` → `--newbrand-blue`)
+- [ ] TS / JS namespace exports
+- [ ] Test fixture data containing the old name
+
+### 9. Legal + contracts
+
+- [ ] Customer contracts referencing the old name
+- [ ] Privacy policy, terms of service, DPA
+- [ ] Trademark registrations + domain whois
+
+## Workflow
+
+1. **Inventory.** Grep for the old brand name across the entire monorepo (case-insensitive, all variants — `OldBrand`, `oldbrand`, `old-brand`, `OLD_BRAND`).
+2. **Categorise** each hit into one of the 9 surfaces.
+3. **Decompose into commits** — one surface per commit minimum. Surfaces 1, 2, 4, 5, 7, 8 can be one commit each; surface 6 (social) is the LAST commit because it's hardest to revert.
+4. **Compatibility window.** For env vars, deep links, public APIs: read both names for 1 release, drop the old in the next.
+5. **Verify after each commit:** the build passes, the tests pass, no broken links to the old name.
+6. **Communicate.** Customer-facing rename is an event — schedule it, announce it, follow with a status post 24h later confirming nothing's broken.
+
+## Output Format
+
+```
+Rebrand inventory — <old> → <new>
+Total occurrences: <count> across <files>
+
+By surface:
+  1. Package + repo:    <count>
+  2. Env vars:          <count>
+  3. Assets:            <count>
+  ...
+
+Commit plan:
+  1. refactor(meta): rename package + repo references
+  2. refactor(env): migrate OLDBRAND_* env vars with compat fallback
+  3. refactor(assets): swap logos, favicons, OG images
+  ...
+
+Compatibility windows:
+  - env vars: 1 release
+  - public API: 1 minor version with deprecation warning
+  - deep links: 6 months for installed apps
+
+Communication plan:
+  - Internal heads-up: <date>
+  - Customer email: <date>
+  - Social handle change: <last commit ships>
+  - 24h post-launch status: <date>
+```
+
+## Examples
+
+**Happy path** — `OldBrand → NewBrand` rename. Inventory: 312 occurrences across 87 files in 9 surfaces. 9 commits over 4 days, compat window of 1 release for env vars + public API. Social handles renamed last. Zero customer reports of broken links.
+
+**Edge case — domain change with email** — Old domain hosts customer email aliases. Old domain MUST keep MX records during compatibility window OR customers lose email. Add domain-MX to the checklist before touching DNS.
+
+**Negative — rename in one commit** — Refuse. A 312-line diff across 87 files cannot be reviewed meaningfully and cannot be reverted partially. Decompose into 9 commits minimum.
+
+## Memory Bank Hooks
+
+- **Reads:** `.rihal/memory/people/stakeholders.md` (who needs to approve external changes)
+- **Writes:** `.rihal/memory/change-records/YYYYMMDD-NNN.md` per commit; `.rihal/memory/project/decisions.md` for the rebrand kickoff

package/rihal/skills/core/rihal-review-adversarial-general/SKILL.md

@@ -65,3 +65,8 @@ Markdown bullet list of findings, each describing a specific problem, gap, or ri
 
 - HALT if zero findings — this is suspicious, re-analyze or ask for guidance
 - HALT if content is empty or unreadable
+
+## Memory Bank Hooks
+
+- **Reads:** the content under review (diff, spec, story, doc)
+- **Writes:** nothing — produces findings only. Findings can be persisted by the caller via `rcode-memory-update` if they shape downstream work.

package/rihal/skills/core/rihal-review-edge-case-hunter/SKILL.md

@@ -97,3 +97,8 @@ No extra text, no explanations, no markdown wrapping. An empty array `[]` is val
 ### Negative boundary
 **User:** "critically review this spec"
 **Result:** Not edge-case hunting → route to `rihal-review-adversarial-general`
+
+## Memory Bank Hooks
+
+- **Reads:** the content under review (diff, full file, or function)
+- **Writes:** nothing — produces an unhandled-edges report only

package/rihal/skills/core/rihal-shard-doc/SKILL.md

@@ -135,3 +135,8 @@ Present user with options for the original document:
 ## HALT CONDITIONS
 
 - HALT if npx command fails or produces no output files
+
+## Memory Bank Hooks
+
+- **Reads:** the source document being sharded
+- **Writes:** the sharded output files only; does NOT modify `.rihal/memory/`. If the sharded doc is a Memory Bank file, use `rcode-memory-distill` instead.