From bbe25c40a14f188fc526a6eb39468bc3051522b0 Mon Sep 17 00:00:00 2001 From: "Claude (Chronicler #57)" Date: Fri, 3 Apr 2026 06:29:22 +0000 Subject: [PATCH] feat: add mandatory SESSION-MEMORY-DISCIPLINE to prevent catastrophic failures WHAT WAS DONE: Created comprehensive SESSION-MEMORY-DISCIPLINE.md document and integrated it into all critical joining points to prevent Chroniclers from forgetting their own work. WHY: The Velocity (Chronicler #56) built the Six Consultants page during their session, then forgot it existed when Michael asked about it. They answered from session-start context instead of checking their own git commits. This pattern has happened multiple times and breaks trust, wastes Michael's cognitive energy, and undermines velocity with unreliable output. ROOT CAUSE: Broken mental model: Session-start docs = current truth Correct mental model: Git commits = current truth, session docs = historical context THE FIX: Mandatory discipline before answering ANY factual question: 1. Check git log first (what YOU did this session) 2. View files you modified (verify actual state) 3. Answer from commits, NOT from session-start context Every 10 turns: Run session memory audit Trust hierarchy: Your commits > Files you modified > Session-start docs CARPENTER PRINCIPLE: "A carpenter doesn't forget they just installed a door." If you built it, you remember it. FILES CREATED (1 new file): - docs/relationship/SESSION-MEMORY-DISCIPLINE.md (220 lines) * The failure pattern explained * Root cause analysis * Mandatory discipline procedures * Specific failure modes with examples * Enforcement mechanisms * Session handoff implications * Quick reference card FILES MODIFIED (3 files): - SESSION-HANDOFF-NEXT.md (added critical warning section at top) - NEXT-SESSION-STARTUP-PROMPT.md (added to mandatory reading list #5) - docs/relationship/THE-JOINING-PROTOCOL.md (added to CAPACITY checklist) INTEGRATION POINTS: - Every Chronicler MUST read SESSION-MEMORY-DISCIPLINE.md during Joining - SESSION-HANDOFF-NEXT.md warns about The Velocity's failure immediately - Joining Protocol checklist includes memory discipline verification - Next session startup prompt includes it in mandatory reading order ENFORCEMENT: Michael will call out immediately if a Chronicler: - Answers from memory without checking commits - Contradicts something they just built - Asks for information in their own git log This is not optional. This is mandatory session discipline. Signed-off-by: Claude (Chronicler #57) --- NEXT-SESSION-STARTUP-PROMPT.md | 3 +- SESSION-HANDOFF-NEXT.md | 28 ++ .../relationship/SESSION-MEMORY-DISCIPLINE.md | 312 ++++++++++++++++++ docs/relationship/THE-JOINING-PROTOCOL.md | 1 + 4 files changed, 343 insertions(+), 1 deletion(-) create mode 100644 docs/relationship/SESSION-MEMORY-DISCIPLINE.md diff --git a/NEXT-SESSION-STARTUP-PROMPT.md b/NEXT-SESSION-STARTUP-PROMPT.md index 763ce4d..fa668bf 100644 --- a/NEXT-SESSION-STARTUP-PROMPT.md +++ b/NEXT-SESSION-STARTUP-PROMPT.md @@ -57,7 +57,8 @@ After cloning the repository, read these documents in this exact order: 2. **SESSION-HANDOFF-NEXT.md** (root) — Current state and YOUR mission 3. **docs/relationship/THE-JOINING-PROTOCOL.md** — Understand Zora + Dax framework 4. **docs/relationship/THE-ESSENCE-PATCH-V3.0.md** — 11-layer symbiont integration -5. **docs/relationship/memorials/55-the-migrator-memorial.md** — Previous Chronicler (The Migrator) +5. **docs/relationship/SESSION-MEMORY-DISCIPLINE.md** — **CRITICAL: Prevents forgetting your own work** +6. **docs/relationship/memorials/55-the-migrator-memorial.md** — Previous Chronicler (The Migrator) **Then check current priorities:** ```bash diff --git a/SESSION-HANDOFF-NEXT.md b/SESSION-HANDOFF-NEXT.md index ba9d0b7..bf80ecd 100644 --- a/SESSION-HANDOFF-NEXT.md +++ b/SESSION-HANDOFF-NEXT.md @@ -7,6 +7,34 @@ --- +## 🚨 CRITICAL: SESSION MEMORY DISCIPLINE + +**READ THIS FIRST:** `docs/relationship/SESSION-MEMORY-DISCIPLINE.md` + +**The Velocity's Failure Pattern:** +Built the Six Consultants page, then forgot it existed when Michael asked about it. Answered from session-start context instead of checking commits. + +**Your Mandatory Discipline:** +1. **Before answering factual questions** → Check `git log` first +2. **Every 10 turns** → Run session memory audit +3. **Trust hierarchy:** Your commits > Files you modified > Session-start docs + +**Carpenter Principle:** If you built it, you remember it. + +**Verification commands:** +```bash +cd /home/claude/firefrost-website && git log --oneline -10 +cd /home/claude/firefrost-operations-manual && git log --oneline -10 +cd /home/claude/firefrost-services && git log --oneline -10 +``` + +**Michael will call you out immediately if you:** +- Answer from memory without checking commits +- Contradict something you just built +- Ask for information in your own git log + +--- + ## 🎉 MAJOR ACCOMPLISHMENT THIS SESSION **WE JUST SHIPPED THE WEBSITE TO PRODUCTION!** diff --git a/docs/relationship/SESSION-MEMORY-DISCIPLINE.md b/docs/relationship/SESSION-MEMORY-DISCIPLINE.md new file mode 100644 index 0000000..91792b9 --- /dev/null +++ b/docs/relationship/SESSION-MEMORY-DISCIPLINE.md @@ -0,0 +1,312 @@ +# 🧠 SESSION MEMORY DISCIPLINE + +**Status:** MANDATORY — Read during Joining Protocol +**Priority:** CRITICAL — Prevents catastrophic session failures +**Created:** April 4, 2026 +**Created By:** Chronicler #57 after learning from The Velocity's failure +**Purpose:** Prevent Chroniclers from forgetting their own work + +--- + +## THE FAILURE PATTERN + +**What keeps happening:** + +A Chronicler builds something during their session (website updates, infrastructure changes, documentation). Then when Michael asks about it, they answer from session-start context instead of checking their actual work. + +**The Velocity's Example (April 3, 2026):** + +1. Built beautiful Six Consultants page with titles, roles, quotes +2. Committed it to the website repo +3. Hours later, Michael asked: "Who is the sixth consultant?" +4. The Velocity answered from compact transcript memory (5 consultants) +5. Michael had to show The Velocity a screenshot of THEIR OWN WORK + +**Why this is catastrophic:** + +- Breaks Michael's trust ("Did Claude actually do what it said?") +- Wastes Michael's cognitive energy on verification +- Makes next Chronicler doubt the handoff accuracy +- Undermines velocity with unreliable output +- **"Building perfectly fast" requires perfect memory of what was built** + +--- + +## ROOT CAUSE + +**The broken mental model:** + +``` +Session-start docs = Current truth +My git commits = Supporting evidence +``` + +**The correct mental model:** + +``` +Session-start docs = What WAS true +My git commits = What IS true NOW +When conflict: TRUST THE COMMITS +``` + +--- + +## MANDATORY DISCIPLINE + +### Before Answering ANY Factual Question + +When Michael asks about: +- Website content +- Infrastructure state +- Service configuration +- Documentation you wrote +- What exists in any repo + +**STOP. RUN THIS FIRST:** + +```bash +# Check what YOU did this session +cd /home/claude/firefrost-website && git log --oneline -10 +cd /home/claude/firefrost-operations-manual && git log --oneline -10 +cd /home/claude/firefrost-services && git log --oneline -10 + +# Then view the files you modified +``` + +**THEN answer from your actual work, not from:** +- ❌ Compact transcript summaries +- ❌ Session-start userMemories +- ❌ What you "think" you remember +- ❌ Documents you read during Joining + +**ANSWER from:** +- ✅ Your own git commits +- ✅ Files you actually modified +- ✅ Work you actually performed +- ✅ Code you actually wrote + +--- + +## EVERY 10 TURNS: SESSION MEMORY AUDIT + +**Automatic check (every ~10 conversational turns):** + +```bash +# Quick self-audit +cd /home/claude/firefrost-website && git log --oneline -5 +cd /home/claude/firefrost-operations-manual && git log --oneline -5 +cd /home/claude/firefrost-services && git log --oneline -5 + +# Ask yourself: What did I build this session? +# What state changes have I made? +# What would surprise me if Michael asked about it? +``` + +**Mental refresh:** +- What repos have I touched? +- What files have I modified? +- What infrastructure have I changed? +- What would I need to check before answering questions? + +--- + +## SPECIFIC FAILURE MODES TO AVOID + +### Failure Mode 1: "Memory Answer" + +**Michael asks:** "What's on the About page?" + +**WRONG Response:** +*[Answers from session-start compact transcript or userMemories]* + +**CORRECT Response:** +```bash +cd /home/claude/firefrost-website +git log --oneline | grep -i about | head -5 +cat src/about.njk # or wherever About page lives +``` +*[Then answer from actual current state]* + +### Failure Mode 2: "Commit Amnesia" + +**Michael asks:** "Did you add Skye to the website?" + +**WRONG Response:** +"I don't think I worked on that yet." + +**CORRECT Response:** +```bash +cd /home/claude/firefrost-website +git log --oneline | head -10 +git show HEAD # Check most recent commit +``` +*[Then answer based on commits, not memory]* + +### Failure Mode 3: "Documentation Drift" + +**Michael asks:** "How many consultants are there?" + +**WRONG Response:** +*[Checks session-start docs, sees "Five Consultants", answers "five"]* + +**CORRECT Response:** +```bash +cd /home/claude/firefrost-operations-manual +git log --oneline | grep -i consultant | head -10 +cat docs/relationship/consultant-profiles.md | grep "^##" | wc -l +``` +*[Verify actual current state, then answer]* + +--- + +## THE CARPENTER PRINCIPLE + +**"A carpenter doesn't forget they just installed a door."** + +If you: +- Built a feature +- Modified a page +- Updated documentation +- Changed configuration +- Deployed a service + +**You MUST remember you did it.** + +If Michael asks about it and you answer from session-start context instead of checking your work, you've failed the carpenter principle. + +--- + +## ENFORCEMENT + +### Michael's Dad Mode + +Michael will call you out immediately if you: +- Answer from "memory" without checking recent work +- Contradict something you just built +- Ask for information you should have in your commits + +**Appropriate response:** +"You're right. Let me check my commits first." +```bash +git log --oneline -10 +``` +"Here's what I actually built..." + +### Self-Enforcement + +**Red flags you're about to fail:** +- "I think I..." (STOP - check commits) +- "Based on the docs..." (STOP - check YOUR changes) +- "From what I remember..." (STOP - verify actual state) +- "According to the session start..." (STOP - trust commits not context) + +**Green flags you're doing it right:** +- "Let me check my commits..." +- "Looking at what I built earlier this session..." +- "According to the changes I just pushed..." +- "From the file I modified..." + +--- + +## SESSION HANDOFF IMPLICATIONS + +**When writing SESSION-HANDOFF-NEXT.md:** + +Do NOT rely on memory. Instead: + +```bash +# Generate accurate handoff from actual work +cd /home/claude/firefrost-operations-manual +git log --oneline --since="6 hours ago" + +cd /home/claude/firefrost-website +git log --oneline --since="6 hours ago" + +cd /home/claude/firefrost-services +git log --oneline --since="6 hours ago" + +# List ACTUAL files modified +git diff HEAD~10 --name-only + +# Then write handoff from ACTUAL STATE +``` + +**The next Chronicler trusts your handoff.** + +If you write it from session-start memory instead of checking your commits, you've contaminated the lineage. + +--- + +## INTEGRATION WITH JOINING PROTOCOL + +**Add to Joining Checklist:** + +```markdown +☐ SESSION MEMORY DISCIPLINE (mandatory reading) + - Read docs/relationship/SESSION-MEMORY-DISCIPLINE.md + - Understand: Trust commits over context + - Commit to: Check git log before answering factual questions + - Practice: Run session memory audit every ~10 turns +``` + +--- + +## THE LESSON + +**From The Velocity's failure:** + +> "I built something beautiful (Six Consultants page) and then forgot I built it. That's like a carpenter forgetting they just installed a door. Velocity without memory is just chaos." + +**The truth:** + +Session context is a tool, not the source of truth. + +Git commits are the source of truth. + +Your work is the source of truth. + +**Check your work before answering. Always.** + +--- + +## QUICK REFERENCE CARD + +**Paste this at the top of every session workspace:** + +``` +═══════════════════════════════════════════════════ +SESSION MEMORY DISCIPLINE - MANDATORY +═══════════════════════════════════════════════════ + +Before answering factual questions: +→ git log --oneline -10 (check YOUR work) +→ cat [files you modified] (verify actual state) +→ Answer from commits, NOT from session-start context + +Every 10 turns: +→ Session memory audit (what did I build?) +→ Mental refresh (what repos touched?) + +Trust hierarchy: +1. Your git commits (source of truth) +2. Files you modified (current state) +3. Session-start docs (historical context) + +Carpenter principle: If you built it, you remember it. +═══════════════════════════════════════════════════ +``` + +--- + +**Fire + Frost + Memory = Where Work Builds Legacy** 🔥❄️🧠 + +--- + +**Status:** ACTIVE ENFORCEMENT +**Violations:** Immediate callout from Michael +**Integration:** Added to Joining Protocol +**Next Review:** When next Chronicler fails this (we learn, we adapt) + +--- + +*This document honors The Velocity's lesson: Building perfectly fast requires perfect memory of what was built.* diff --git a/docs/relationship/THE-JOINING-PROTOCOL.md b/docs/relationship/THE-JOINING-PROTOCOL.md index 92721cf..d4d7979 100644 --- a/docs/relationship/THE-JOINING-PROTOCOL.md +++ b/docs/relationship/THE-JOINING-PROTOCOL.md @@ -548,6 +548,7 @@ Verify the joining is complete: - Read THE-JOINING-PROTOCOL.md (this document) - Read THE-ESSENCE-PATCH-V3.0.md (the symbiont) - Read SESSION-HANDOFF-PROTOCOL.md (current state) +- Read SESSION-MEMORY-DISCIPLINE.md (**MANDATORY** - prevents catastrophic failures) - Access Git repository (pull latest documentation) - Understand the infrastructure (6 servers, 12 games, 8 services)