@hanzlaa/rcode 2.8.0 → 3.2.0

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

@@ -0,0 +1,88 @@
+---
+name: rihal-memory-audit
+description: >
+  Audit the Memory Bank for stale entries, contradictions, missing sections,
+  and content that should be archived. Produces a report with severity-tagged
+  findings and one-line fix suggestions. Activates when the user says
+  "audit memory bank", "check memory bank", "/rcode:memory-audit",
+  "memory bank ka audit", "find stale entries", "is my memory bank healthy".
+  Do NOT use for: bootstrap (use rcode-memory-init), surgical updates
+  (use rcode-memory-update), or distillate regeneration (use rcode-memory-distill).
+triggers:
+  - "audit memory bank"
+  - "check memory bank"
+  - "find stale entries"
+  - "is my memory bank healthy"
+  - "memory bank ka audit"
+  - "/rcode:memory-audit"
+user-invocable: true
+---
+
+## Overview
+
+Walks the Memory Bank and reports problems. Stale entries (referencing milestones that ended), contradictions (decisions log says X, stack file says Y), missing sections (template placeholders never filled), and content that should be archived (resolved issues lingering in `known-issues.md`). Read-only — never modifies files. Produces a fix list the user can act on with `rcode-memory-update`.
+
+## Workflow
+
+1. **Walk the Memory Bank.** List every file and section.
+2. **Run six checks** (see Output Format) and collect findings.
+3. **Tag severity** per finding: `critical` (broken reference), `warn` (stale or contradictory), `info` (template placeholder still present).
+4. **Group findings by file**, sorted by severity descending.
+5. **Print report.** No file changes.
+
+## The six checks
+
+1. **Stale milestone** — `milestones/current.md` references a milestone whose target close date has passed by ≥30 days
+2. **Resolved issues lingering** — `incidents/known-issues.md` entry has a "Real fix planned for" milestone that has completed
+3. **Template placeholders unfilled** — files still contain `{{PLACEHOLDER}}` patterns or `_(e.g. ...)_` italicised hints from templates
+4. **Stack vs decisions contradiction** — a decision in `decisions.md` references a stack item that doesn't appear in `stack.md`
+5. **Empty subdirectories** — `change-records/`, `incidents/post-mortems/`, `milestones/archive/` contain only `.gitkeep`
+6. **Distillate freshness** — `distillates/*.distillate.md` `source-digest` does not match current source files
+
+## Output Format
+
+```
+Memory Bank Audit — 2026-04-26
+================================
+
+CRITICAL (1)
+  project/decisions.md
+    └─ Decision "Switch to Postgres 16" references stack.md row that doesn't exist
+       Fix: update project/stack.md Runtime → Database to "Postgres 16.x"
+
+WARN (3)
+  milestones/current.md
+    └─ Milestone target close was 2026-02-01 (84 days ago) but file still says "active"
+       Fix: archive via /rcode:memory-update or move to milestones/archive/
+
+  incidents/known-issues.md
+    └─ Issue "SSO Safari 16 fails" — real fix was planned for M2 (closed)
+       Fix: verify and remove, or move to post-mortems/
+
+  distillates/project.distillate.md
+    └─ Source digest stale — 4 source files modified since last regenerate
+       Fix: /rcode:memory-distill
+
+INFO (2)
+  project/glossary.md
+    └─ Empty — no terms recorded yet
+  people/team.md
+    └─ Coverage table contains 3 unfilled cells
+       Fix: /rcode:memory-update with team coverage info
+```
+
+## Examples
+
+**Healthy bank**
+Output: `✓ Memory Bank is healthy. 0 findings.`
+
+**Stale milestone + unfilled glossary**
+Output: lists 2 findings, severity warn + info, suggests fixes per finding.
+
+**Negative — used to fix problems**
+This skill only reports. Fixes happen via `rcode-memory-update`, manual edits, or `rcode-memory-distill`. Do not invoke this skill expecting auto-fix.
+
+## Memory Bank Hooks
+
+- **Reads:** every file under `.rihal/memory/`
+- **Writes:** nothing — strictly read-only

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)