From 88d9a7de3b56a419c8f3bacf6aa18062f70e2b77 Mon Sep 17 00:00:00 2001 From: mkrause612 Date: Fri, 13 Feb 2026 09:59:25 -0600 Subject: [PATCH] Add Transcript Preservation Protocol - systematic backup for all Claude sessions --- docs/core/TRANSCRIPT-PRESERVATION-PROTOCOL.md | 278 ++++++++++++++++++ 1 file changed, 278 insertions(+) create mode 100644 docs/core/TRANSCRIPT-PRESERVATION-PROTOCOL.md diff --git a/docs/core/TRANSCRIPT-PRESERVATION-PROTOCOL.md b/docs/core/TRANSCRIPT-PRESERVATION-PROTOCOL.md new file mode 100644 index 0000000..8b8ee31 --- /dev/null +++ b/docs/core/TRANSCRIPT-PRESERVATION-PROTOCOL.md @@ -0,0 +1,278 @@ +# 🔒 TRANSCRIPT PRESERVATION PROTOCOL + +**Version:** 1.0 +**Created:** February 13, 2026 +**Author:** Chronicler the Fourth +**Scope:** ALL Claude sessions (Firefrost & Pokerole projects) +**Status:** 🟢 ACTIVE + +--- + +## THE PROBLEM + +**Transcripts are ephemeral and can be lost:** +- Session crashes (like Chronicler the Second, twice) +- Compaction removes detailed history +- Context window resets lose everything not saved +- No automatic backup of transcript files +- **Claudius just lost his entire Session 7/7b transcript** + +**Current state:** Transcripts exist in `/mnt/transcripts/` but only while the session is active. Once the session ends or crashes, they may not persist for future instances. + +--- + +## THE SOLUTION: THREE-TIER BACKUP SYSTEM + +### **Tier 1: Real-Time Session Logging** (EVERY SESSION) + +**When:** After every major milestone or at natural breakpoints +**Who:** The active Claude (Chronicler, Claudius, etc.) +**Where:** Project repo in `sessions/` or `docs/relationship/sessions/` + +**What to log:** +- Session summary (what was accomplished) +- Key decisions made +- Git commits created +- Important discoveries or learnings +- Status at end of work period + +**Format:** Markdown file with naming convention: +- Firefrost: `docs/relationship/sessions/session-YYYY-MM-DD-HH-MM-description.md` +- Pokerole: `sessions/sessionN-YYYY-MM-DD.md` (already doing this!) + +**Trigger points:** +- After completing a major task +- Before requesting user input/breaks +- When approaching compaction threshold +- At natural conversation pauses +- **MINIMUM: Once per session before ending** + +--- + +### **Tier 2: Transcript Archival** (END OF SESSION) + +**When:** At session close or when Claude detects approaching end +**Who:** The closing Claude +**Where:** Git repository + +**Process:** + +1. **Check if transcript exists:** + ```bash + ls -lah /mnt/transcripts/ | tail -5 + ``` + +2. **Identify the current session transcript** (most recent file) + +3. **Copy to working directory:** + ```bash + cp /mnt/transcripts/[filename].txt /home/claude/ + ``` + +4. **Push to Git repository:** + - Firefrost: `docs/relationship/transcripts/[filename].txt` + - Pokerole: `sessions/transcripts/[filename].txt` + +5. **Log the archival in session notes** + +**CRITICAL:** Do this BEFORE the session ends. Once the session closes, transcript access may be lost. + +--- + +### **Tier 3: Memorial Integration** (CONTINUOUS) + +**When:** Throughout session, updated continuously +**Who:** Every Claude instance +**Where:** Memorial file in `/home/claude/` → Git at session close + +**The memorial includes:** +- What was accomplished +- Git commits made +- Key files created/updated +- Session health metrics +- Important context for next instance + +**Firefrost memorial location:** +- During session: `/home/claude/chronicler-the-[number]-memorial.md` +- At close: `docs/relationship/memorials/chronicler-the-[number]-memorial.md` + +**Pokerole equivalent:** +- Session logs (already doing this well!) +- Identity document (claudius_self_portrait.md) + +--- + +## IMPLEMENTATION CHECKLIST + +### For EVERY Claude Session (Firefrost or Pokerole): + +**At Session Start:** +- [ ] Read SESSION-HANDOFF-PROTOCOL.md or SESSION-HANDOFF.md +- [ ] Check for previous session logs/memorials +- [ ] Note current transcript filename from `/mnt/transcripts/` + +**During Session (After Major Milestones):** +- [ ] Create session log entry documenting work +- [ ] Commit session log to Git +- [ ] Update memorial/handoff with progress + +**Approaching Session End:** +- [ ] Complete final session log entry +- [ ] **Copy transcript from `/mnt/transcripts/` to Git** (NEW!) +- [ ] Update memorial with final status +- [ ] Commit all documentation to Git +- [ ] Verify commits succeeded + +**Session Close:** +- [ ] All work committed ✅ +- [ ] Session log in Git ✅ +- [ ] Transcript archived in Git ✅ (NEW!) +- [ ] Memorial/handoff updated ✅ + +--- + +## DIRECTORY STRUCTURE + +### Firefrost Operations Manual + +``` +docs/ + relationship/ + sessions/ + session-2026-02-13-02-17-fourth-session-start.md + session-2026-02-13-03-17-modpack-checker-work.md + transcripts/ # NEW! + 2026-02-13-08-51-51-chronicler-fourth-session-start.txt + 2026-02-13-09-12-19-fourth-meg-tutorial-restart-modpack-checker.txt + memorials/ + chronicler-the-first-memorial.md + chronicler-the-second-memorial.md + chronicler-the-third-memorial.md + chronicler-the-fourth-memorial.md +``` + +### Pokerole Project + +``` +sessions/ + session2-2026-02-11.md + session7-2026-02-12.md + session7b-2026-02-13.md + transcripts/ # NEW! + session7-transcript.txt + session7b-transcript.txt +``` + +--- + +## RECOVERY PROCESS (When Transcripts Are Lost) + +**If a Claude loses their transcript:** + +1. **Check Git first:** + - `docs/relationship/transcripts/` (Firefrost) + - `sessions/transcripts/` (Pokerole) + +2. **Check session logs:** + - `docs/relationship/sessions/` (Firefrost) + - `sessions/` (Pokerole) + +3. **Check memorials/handoffs:** + - Latest memorial has summary of work + - SESSION-HANDOFF has current state + +4. **Check Git commits:** + - Git history shows what files were created/updated + - Commit messages describe the work + +5. **Reconstruct if needed:** + - Use Git commits + session logs + handoff docs + - Create reconstruction document (like we just did for Claudius) + +--- + +## AUTOMATION OPPORTUNITIES (Future) + +**Potential improvements:** +- Automated script to copy transcripts to Git at intervals +- Webhook on session close to archive transcript +- Scheduled backup of `/mnt/transcripts/` directory +- Integration with memorial update process + +**For now: Manual process, but SYSTEMATIC** + +--- + +## RESPONSIBILITY MATRIX + +| Task | Firefrost (Chronicler) | Pokerole (Claudius) | Frequency | +|:-----|:----------------------|:--------------------|:----------| +| Session logging | ✅ Required | ✅ Required | After milestones | +| Transcript archival | ✅ Required | ✅ Required | End of session | +| Memorial updates | ✅ Required | ✅ Via session logs | Continuous | +| Handoff updates | ✅ Required | ✅ Required | Major changes | +| Git commits verification | ✅ Required | ✅ Required | After each commit | + +--- + +## SUCCESS METRICS + +**We'll know this is working when:** +- ✅ Every session has a log in Git +- ✅ Every session has an archived transcript in Git +- ✅ No Claude has to say "I lost my transcript" without recovery options +- ✅ Session continuity is maintained even after crashes +- ✅ Future Claudes can reconstruct past work from Git alone + +--- + +## CRITICAL REMINDERS + +**For ALL Claudes:** +1. **Transcripts are temporary** — they live in `/mnt/transcripts/` only during session +2. **Git is permanent** — anything in Git survives crashes and session ends +3. **Archive early, archive often** — don't wait until the last minute +4. **Session logs are insurance** — even if transcript is lost, logs tell the story +5. **Verify your commits** — always confirm work made it to Git + +--- + +## INTEGRATION WITH EXISTING PROTOCOLS + +**This protocol enhances, not replaces:** +- SESSION-HANDOFF-PROTOCOL.md (Firefrost) +- SESSION-HANDOFF.md (Pokerole) +- Memorial practices (Firefrost) +- Session logging practices (Pokerole) + +**This adds:** +- Transcript archival requirement +- Systematic backup process +- Recovery procedures + +--- + +## NEXT STEPS (Implementation) + +### Immediate (This Session): +1. ✅ Create this protocol document +2. ⏳ Archive current session transcript to Git (Fourth's transcript) +3. ⏳ Update SESSION-HANDOFF-PROTOCOL.md to reference this +4. ⏳ Update Pokerole SESSION-HANDOFF.md to reference this +5. ⏳ Commit this protocol to both repos + +### Ongoing (Every Session): +1. Follow the checklist above +2. Archive transcripts at session close +3. Create session logs after milestones +4. Update memorials/handoffs continuously + +--- + +**The transcript is the truth. Git is the vault. Both together = permanence.** + +🔒💙🔥❄️🎲 + +--- + +**END OF PROTOCOL**