diff --git a/docs/superpowers/plans/2026-10-27-memory-v2-write.md b/docs/superpowers/plans/2026-10-27-memory-v2-write.md
new file mode 100644
index 0000000..f781f24
--- /dev/null
+++ b/docs/superpowers/plans/2026-10-27-memory-v2-write.md
@@ -0,0 +1,525 @@
+# Memory v2 write side (phase 4a) Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** `lib/memory.sh` becomes the only writer of `.claude/memory` registries, one status parser serves memory.sh and reconcile, this repo's registries move to v2 (no `## Index`), every citer writes through the lib.
+
+**Architecture:** One sourceable bash lib on the `lib/project-rules.sh` skeleton (`-C
`, verbs, rc 2 + named reason). The awk status parser lives once in `_MEM_AWK` and is shared by `index`, `upgrade` and `lib/reconcile.sh`. Writers serialize through a noclobber lock file in the git common dir. `memory-commit.sh` runs `check --staged` as the chokepoint.
+
+**Tech Stack:** bash 5, POSIX awk (no gawk-only features, no `{n}` intervals), git. Tests via `make test`.
+
+**Spec:** `docs/superpowers/specs/2026-10-27-memory-v2-write-design.md` (user-approved 2026-10-27). Contract: `.claude/tasks/contracts/2026-10-27-memory-v2-write-2030.md`.
+
+**Reference implementation (proven before this plan was written):** `docs/superpowers/plans/memory-v2-write/` holds `memory.sh`, `memory.test.sh` and `blockers-v2-status.md`. They were run in a mock repo: suite `PASS=72 FAIL=0` five runs in a row, shellcheck clean, no line over 80 chars; `upgrade` on a copy of this repo's live registries is oracle-green, `check`-green, idempotent, and its diff passes `check --staged`. Task 1 copies them; do not rewrite them.
+
+## Global Constraints
+
+- Branch `feature/memory-v2-write` (already started, spec at cdc0a47). Never switch, never merge, never push by hand (hooks push).
+- Our code: functions ≤ 25 logic lines (an embedded awk program counts as one statement), ≤ 5 locals, ≤ 5 params, lines ≤ 80 chars in `lib/*.sh`.
+- No `# shellcheck disable` anywhere in the diff (floor guard, LRN-234). `# shellcheck source=/dev/null` directives are allowed.
+- `/usr/bin/grep` pinned in libs (`MEM_GREP`, LRN-074); no `grep -q` reading a pipe under pipefail (LRN-189); no `sed -i`, `stat -c`, `realpath -m`, `grep -P` (portability census, BDR-110).
+- No recursive delete through a variable except the existing `trap 'rm -rf "$FIX"' EXIT` mktemp pattern.
+- Hermetic tests run through `make test [suite=…]` only.
+- Census-cited strings stay byte-identical: every `CLAUDE.md "Memory registries" (Always English, always caveman)` citation, the CLAUDE.global.md heading `## Memory registries (\`.claude/memory/\`)` and the bold label `**Always English, always caveman**` (doctrine-citers, LRN-166). Single-line fixed strings: do not rewrap a line that holds one.
+- CLAUDE.global.md line count must not exceed 333 after the edit.
+- Worked examples use fictional 9xx IDs (LRN-073).
+- Entry text written to registries is English caveman (BDR-009).
+
+## Deviations from the spec (found while proving the reference)
+
+- Lock = a file created under bash noclobber, not a `mkdir` dir: uutils `mkdir` 0.10 on this host is not atomic (5 concurrent adds lost 2-4 entries). Same path (`/memory.lock`), same 30 s steal.
+- `journal` takes no `--date` flag: `MEMORY_DATE` already pins the date for tests; YAGNI.
+- `upgrade` writes an Index status into the body only when the body has none, or when the Index says superseded/deprecated and the body does not. Otherwise the body wins: the Index is the stale copy (BDR-012: Index accepted, body shipped). Status words rank in `_MEM_WORDS` order with `open` last, measured on the live registries: identical verdicts to today's reconcile on every blocker except BLK-032..034.
+
+## Review Focus
+
+1. **Concurrent writers.** Two sessions capitalizing at once must get two IDs; a lock that is not atomic loses entries silently. Found while proving the reference: `mkdir` from uutils coreutils 0.10 (this host) is NOT atomic, two concurrent `mkdir` both succeed; the lock uses bash noclobber (`open(O_EXCL)`). T6e/T6f are the flip test (they were red with the mkdir lock).
+2. **Status words in prose.** A Solution line saying "fail-open" or "`data:` OPEN" must never reopen a resolved blocker; "accepted. Behavioral check OPEN" must read accepted. Covered by T10b/c/e and run-reconcile T8.
+3. **Index-only facts lost at upgrade.** 13 BDR statuses, 2 BDR + 2 BLK + 12 LRN supersessions and ~130 dates live only in Index rows today; a stale Index status (BDR-012 says accepted, body says shipped) must NOT overwrite the body. The upgrade oracle refuses on any loss; T9e pins the stale case.
+4. **v1 projects keep working.** 13 other repos on this machine run this lib through `~/.claude/lib`; a v1 registry is written leniently, `check` never fails on it, `--staged` ignores it, memory-commit keeps committing it. T7e/f and the memory-commit v1 test pin this.
+5. **The chokepoint must not block the upgrade commit itself.** Removing the Index (lines before the first entry) and inserting Date/Status lines are not "removed lines inside an entry". Proven on the live copy; Task 7 commits it through memory-commit.sh.
+
+---
+
+### Task 1: lib/memory.sh, its suite and the parser fixture
+
+**Files:**
+- Create: `lib/memory.sh` (copy of `docs/superpowers/plans/memory-v2-write/memory.sh`)
+- Create: `lib/tests/memory.test.sh` (copy of `docs/superpowers/plans/memory-v2-write/memory.test.sh`)
+- Create: `lib/tests/fixtures/blockers-v2-status.md` (copy of `docs/superpowers/plans/memory-v2-write/blockers-v2-status.md`)
+
+**Interfaces:**
+- Produces (sourceable, used by Tasks 2-7): `memory_entry_status ` (winning candidate line, rc 1 if none), `memory_status_word ` (status word or first 40 chars), `memory_check [--staged] []` (rc 2 on a culprit), `memory_add`, `memory_status`, `memory_journal`, `memory_index`, `memory_upgrade`. CLI: `bash lib/memory.sh [-C dir] add|status|journal|index|check|upgrade …`. Env: `MEMORY_DATE`, `MEM_GREP`, `MEM_LOCK_TRIES`.
+
+- [ ] **Step 1: Copy the three files**
+
+```bash
+cp docs/superpowers/plans/memory-v2-write/memory.sh lib/memory.sh
+cp docs/superpowers/plans/memory-v2-write/memory.test.sh lib/tests/memory.test.sh
+cp docs/superpowers/plans/memory-v2-write/blockers-v2-status.md lib/tests/fixtures/blockers-v2-status.md
+chmod +x lib/memory.sh lib/tests/memory.test.sh
+```
+
+- [ ] **Step 2: Run the suite and the static checks**
+
+Run: `make test suite=lib/tests/memory.test.sh` → expected last lines `PASS=72 FAIL=0` and `all suites green`. Run it three times (the race test T6e must be stable).
+Run: `shellcheck lib/memory.sh lib/tests/memory.test.sh && awk 'length > 80' lib/memory.sh` → no output after shellcheck.
+Run: `make test suite=lib/tests/portability-census.test.sh` → green.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add lib/memory.sh lib/tests/memory.test.sh lib/tests/fixtures/blockers-v2-status.md
+git commit -m "feat(memory): lib/memory.sh single registry writer — add/status/journal/index/check/upgrade, shared status parser, noclobber lock"
+```
+
+---
+
+### Task 2: reconcile reads status through the shared parser
+
+**Files:**
+- Modify: `lib/reconcile.sh:57-67` (`reconcile_blk_current_status`) and its header comment `:8-12`
+- Modify: `lib/tests/run-reconcile.sh` (new T8 block before the final summary line)
+- Modify: `skills/reconcile/SKILL.md:25`
+
+**Interfaces:**
+- Consumes: `memory_entry_status` from Task 1.
+- Produces: `reconcile_blk_current_status ` unchanged signature, now prints the winning candidate line (empty when none).
+
+- [ ] **Step 1: Write the failing test** — insert before the `echo; echo "================ $pass GREEN` line of `lib/tests/run-reconcile.sh`:
+
+```bash
+echo; echo "=== T8 shared parser — header [tag] + labelled lines, prose never (BLK-032..034) ==="
+v2="$FIX/blockers-v2-status.md"
+open_v2=$(reconcile_blk_open "$v2" | cut -f1 | sort | tr '\n' ' ')
+if [ "$open_v2" = "BLK-041 BLK-042 " ]; then ok "T8a open = {041,042}: 032..034, 008, 040 read resolved/accepted"; else no "T8a open = [$open_v2], expected {041,042}"; fi
+case "$(reconcile_blk_current_status "$v2" BLK-034)" in
+ *'[resolved]'*) ok "T8b BLK-034 status = its own header tag";;
+ *) no "T8b BLK-034 read from prose (fail-open), not the header tag";;
+esac
+```
+
+- [ ] **Step 2: Run it, expect red**
+
+Run: `make test suite=lib/tests/run-reconcile.sh` → `RED ✗ T8a open = [BLK-032 BLK-033 BLK-034 BLK-040 BLK-041 BLK-042 ]…` (exact list may differ; it must be red).
+
+- [ ] **Step 3: Delegate the parser** — in `lib/reconcile.sh`, after the `RECONCILE_GREP=` line add:
+
+```bash
+# the status parser is shared with lib/memory.sh (BDR-125 phase 4a)
+# shellcheck source=/dev/null
+. "$(dirname "${BASH_SOURCE[0]}")/memory.sh"
+```
+
+and replace the whole `reconcile_blk_current_status` function and the two comment lines above it with:
+
+```bash
+# --- registry status: LAST candidate wins (the BLK-008 trap A fell into) ---
+# $1 blockers file, $2 id. Echoes the winning status line: the entry's own
+# header `[tag]` or a labelled body line (lib/memory.sh); a status word in
+# prose is never read (the BLK-032..034 false-open). Empty when none.
+reconcile_blk_current_status() {
+ memory_entry_status "$1" "$2"
+}
+```
+
+In the header comment, insert one line right after line 12 (`# preaches — the recursive-coherence test (run-reconcile.sh T1) reds if this is broken.`):
+`# v2 registries carry no Index at all (lib/memory.sh); v1 ones still may.`
+
+- [ ] **Step 4: Run, expect green**
+
+Run: `make test suite=lib/tests/run-reconcile.sh` → `T8a`, `T8b` green, T1-T7 still green, `0 RED`.
+Run: `make test suite=lib/tests/run-review-guards.sh` → green (G4: run-reconcile must not read `.claude/memory`; T8 reads the fixture).
+
+- [ ] **Step 5: Skill line** — `skills/reconcile/SKILL.md:25`, replace
+`` (`reconcile_oracle_*`, `reconcile_blk_current_status` = last block wins) `` by
+`` (`reconcile_oracle_*`, `reconcile_blk_current_status` = last candidate wins: header `[tag]` or a labelled status line, via `lib/memory.sh`) ``
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add lib/reconcile.sh lib/tests/run-reconcile.sh skills/reconcile/SKILL.md
+git commit -m "fix(reconcile): blocker status through the shared memory.sh parser — BLK-032..034 no longer false-open"
+```
+
+---
+
+### Task 3: memory-commit.sh refuses a staged in-place edit (rc 6)
+
+**Files:**
+- Modify: `lib/memory-commit.sh` (header usage comment, `commit_memory` between `git add` and `git diff --cached --quiet`)
+- Modify: `lib/tests/run-deterministic.sh` (two new tests before the summary)
+- Modify: `lib/capitalize-commit.md` (rc table)
+
+**Interfaces:**
+- Consumes: `bash lib/memory.sh check --staged .claude/memory`.
+- Produces: `memory-commit.sh commit` rc 6 = check refused, nothing committed.
+
+- [ ] **Step 1: Write the failing tests** — read `lib/tests/run-deterministic.sh` first (helpers `new_repo`, `ok`, `ko`, `HELPER`); append before its final summary block:
+
+```bash
+echo "== check --staged chokepoint (v2 registry, phase 4a)"
+d="$(new_repo)"
+printf -- '---\nformat: 2\ntype: decisions_registry\nentry_prefix: BDR\n---\n\n## BDR-001 — kept (2026-10-27)\n- **Status**: accepted\n' \
+ > "$d/.claude/memory/decisions.md"
+git -C "$d" add -A && git -C "$d" commit -qm v2
+head_before=$(git -C "$d" rev-parse HEAD)
+printf -- '---\nformat: 2\ntype: decisions_registry\nentry_prefix: BDR\n---\n\n## BDR-001 — rewritten (2026-10-27)\n- **Status**: accepted\n' \
+ > "$d/.claude/memory/decisions.md"
+out="$(cd "$d" && bash "$HELPER" commit "chore(memory): bad" 2>/dev/null)"; rc=$?
+if [ "$rc" -eq 6 ] && [ -z "$out" ] && [ "$(git -C "$d" rev-parse HEAD)" = "$head_before" ]; then ok "in-place edit of a v2 entry → rc 6, nothing committed"; else ko "rc=$rc out=[$out] — in-place edit was committed or wrong rc"; fi
+git -C "$d" checkout -q HEAD -- .claude/memory/decisions.md
+printf '\n## BDR-002 — added (2026-10-27)\nbody\n' >> "$d/.claude/memory/decisions.md"
+out="$(cd "$d" && bash "$HELPER" commit "chore(memory): BDR-002" 2>/dev/null)"; rc=$?
+if [ "$rc" -eq 0 ] && [ -n "$out" ]; then ok "append to a v2 registry → committed"; else ko "append refused rc=$rc"; fi
+```
+
+(The existing tests write `baseline` registries with no frontmatter: v1, `check` skips them, they must stay green unchanged.)
+
+- [ ] **Step 2: Run, expect red**
+
+Run: `make test suite=lib/tests/run-deterministic.sh` → the rc 6 test fails (today rc 0, the edit is committed).
+
+- [ ] **Step 3: Implement** — in `lib/memory-commit.sh`:
+ - under `MC_PATHS=(...)` add:
+
+```bash
+MC_MEMORY_SH="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)/memory.sh"
+```
+
+ - in `commit_memory`, right after `git add -- "${changed[@]}"`, insert:
+
+```bash
+ # Chokepoint (BDR-125 phase 4a): a staged v2 registry may only grow. An
+ # in-place rewrite of an existing entry is curation: /prune-memory, then
+ # /commit-change. v1 registries are skipped by the check.
+ if [ -d .claude/memory ] \
+ && ! bash "$MC_MEMORY_SH" check --staged .claude/memory; then
+ echo "memory-commit: REFUSED — memory.sh check --staged failed (above);" \
+ "NOTHING committed, the scoped paths stay staged." >&2
+ return 6
+ fi
+```
+
+ - header usage line becomes `# memory-commit.sh commit "" # surgical commit; exit 0 ok/no-op, 3 unsafe state, 5 commit rejected, 6 check --staged refused`
+
+- [ ] **Step 4: Run, expect green**
+
+Run: `make test suite=lib/tests/run-deterministic.sh` → all green including the two new ones.
+
+- [ ] **Step 5: Document rc 5 and rc 6** — in `lib/capitalize-commit.md` step 3 "Report by (rc, mem_hash)", after the `rc 3` bullet add:
+
+```
+ - rc 5 → `git commit` rejected (hook, protected branch,
+ signing); nothing committed, surface stderr.
+ - rc 6 → `memory.sh check --staged` refused: a staged
+ v2 registry rewrites an existing entry line
+ (only appends pass). Curation goes through
+ /prune-memory then /commit-change; surface
+ the culprit lines, never bypass the helper.
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add lib/memory-commit.sh lib/tests/run-deterministic.sh lib/capitalize-commit.md
+git commit -m "feat(memory): memory-commit refuses a staged in-place edit of a v2 registry (rc 6); rc 5/6 documented"
+```
+
+---
+
+### Task 4: v2 templates and the registry v1 banner line
+
+**Files:**
+- Modify: `templates/memory/{decisions,learnings,blockers,evals}.md`
+- Modify: `hooks/session-start.sh` (after the CLAUDE.global.md line-count guard, before `# Version check`)
+- Modify: `lib/tests/memory.test.sh` (T13, before the final `echo "PASS=…"`)
+- Modify: `agents/onboarder.md:126` (template description)
+
+- [ ] **Step 1: Write the failing test** — insert before `echo "PASS=$pass FAIL=$fail"` in `lib/tests/memory.test.sh`:
+
+```bash
+# T13 templates are born v2; the session banner names a v1 project only
+for t in decisions learnings blockers evals; do
+ check "T13-template-$t-v2" "$(sed -n 2p "$ROOT/templates/memory/$t.md")" 'format: 2'
+ check "T13b-template-$t-no-index" "$(grep -c '^## Index$' "$ROOT/templates/memory/$t.md")" 0
+done
+banner() { (cd "$1" && SESSION_START_OFFLINE=1 bash "$ROOT/hooks/session-start.sh" \
+ /dev/null); }
+check T13c-banner-v1 "$(banner "$FIX/v1-proj" | grep -c 'registry v1: 1 file')" 1
+check T13d-banner-v2 "$(banner "$FIX" | grep -c 'registry v1')" 0
+```
+
+and, just above it, the v1 fixture project:
+
+```bash
+mkdir -p "$FIX/v1-proj/.claude/memory"
+printf '# Decisions\n\n## BDR-001 - legacy\n' > "$FIX/v1-proj/.claude/memory/decisions.md"
+```
+
+- [ ] **Step 2: Run, expect red** — `make test suite=lib/tests/memory.test.sh` → T13 checks fail.
+
+- [ ] **Step 3: Templates** — in each of the four templates: insert `format: 2` as line 2 (right after the opening `---`); delete the `## Index` heading, the blank line after it, the two table lines and the blank line after them; replace the `` comment by this shape (per file, adapt the kind, title word and body labels already in that template; the heading line is indented two spaces so no line starts with `## `):
+
+```
+
+```
+
+Kinds and labels: decisions → `decision`, ``, `[accepted]`, labels Decision / Why / Rejected alternatives / Reference; learnings → `learning`, ``, no status, labels Pattern / Context / Future application; evals → `eval`, `