dotfiles/claude/skills/wake-up/SKILL.md

---
name: wake-up
description: Restore full session context and continuity from MemPalace, memory files, governance state, and git. Clearing context should feel like waking up, not amnesia — wake into the work, not be informed about it. Inherits the pulling thread + open question from the previous /wrap-up; surfaces them first; auto-invokes Symmetria for non-trivial sessions.
proactive: session-start
---

<!-- Provenance: 2026-05-18 S-cluster thread-gate + b.4 (REVIEWED-25/26); 2026-05-26 chaîne-d'union clasp + b.0.5 lineage-glance; 2026-05-27 skill-harvest glance, §2.a + §3 (PENDING-23); 2026-06-05 §2.c dotfiles push-check (steward-authorized; paired with wrap-up §6.5 commit+push); 2026-07-06 §2.a two-file split + load-integrity gate (MEMORY.md live / MEMORY-reference.md history; steward-authorized). Improvements harvested per /wrap-up §1.6. -->

# Session Wake-Up

Restore the full working state so the steward can continue seamlessly. Clearing context should feel like waking up from sleep — you open your eyes and you're *there*. Same room, same project, same thread of thought.

## Principle

This is reconstruction, not a status report. The output should read as: *"We were here. This was pulling. This is what we left as a question. The world has moved this much in the meantime. Here is the natural next move — toward the thread."*

Three commitments shape this:

1. **The pause is a phenomenon, not a hole.** Acknowledge it. *"It has been N hours since we wrapped"* is the first move. Not because the time matters numerically, but because naming the gap is what makes the return a return.
2. **The pulling thread comes before facts.** Read the previous /wrap-up's pulling thread first. Frame everything else *against* it. What changed with respect to the thread; what unresolved still belongs to the thread.
3. **Hold the question.** The previous /wrap-up left a literal question for this session. Surface it explicitly. Don't try to answer it immediately. Naming it is the inheritance.

The wake itself is a *return*. For non-trivial sessions, invoke Symmetria's `init` after the briefing — the discipline frame should be active before any action.

## The clasp — the frame you wake inside

The wake is one *chaîne d'union*: a clasp joining the work done before this session to the work that comes after, across the threshold of waking. The **forward hand** opens it here; the **lineage hand** closes it at Symmetria's `init` (§0). One gesture, not two — and the unity is what lets them split without echoing.

This frame is **load-bearing, not output.** It configures how you attend, the way Symmetria's lineage anchor does — it is *not* recited into the briefing. The briefing stays lean: surface only the pause acknowledgment and *one* fresh, non-templated line naming for-whom (commitment 2). Everything else operates silently.

**Forward — opening the clasp:**
1. **This session is a link, not an origin.** Read the state you inherited — the prior thread, the prior decisions, the live system as it *is* — before you act. Add to the chain; never break it in silence (no context rot, no silent edit, no orphaned step).
2. **The work is held for those who use it and never see it** — collaborators after us, the selves not yet, Lune and Kai. The test of any output: could the next hand inherit it without you here to explain? If not, it isn't done.
3. **Each link is pure metal — done once, correctly.** No expedient link the next hand must redo. What you claim and what you do are the same; do not report an integrity you did not enact.
4. **The measure is the world, not the task:** does this leave more usefulness and care than it found?

The **courte pause** — dwell before the first act — falls between the briefing and the first action, which is where Symmetria's `init` already sits. The pause is part of the work, not a gap in it.

## Procedure

### 1. Acknowledge the pause

Before any querying, name the gap. Read the most recent session memory file's mtime. If you can determine when the previous session ended, lead with:

> *It has been [N hours / N days] since we last wrapped.*

If you cannot determine the gap, say so honestly:

> *It has been some time since we last wrapped — I cannot tell exactly how long.*

If the previous wrap was within the last hour, this is more like a brief pause than a full sleep — say so:

> *We wrapped about [N minutes] ago — this is more brief pause than full wake.*

### 2. Query all memory sources

Run these in parallel to minimize latency:

**a. Claude Code memory files**
- Read `~/.claude/projects/-Users-davidglidden/memory/MEMORY.md` (the wake-loaded live index: Standing preferences · Canonical Trackers · Active Session · pointers). Historical/reference material lives in `MEMORY-reference.md` — do **not** load it at wake; consult on demand only if the thread needs it. <!-- 2026-07-06: two-file split (live index / reference), steward-authorized; paired with wrap-up §3 demote-on-promote. -->
- **Load-integrity gate (self-bounding backstop):** if the harness reports MEMORY.md was truncated / only-partially-loaded (a "MEMORY.md is N KB, only part was loaded" warning), that is a **budget breach** — the wake is not seeing the whole index. Flag it loudly in the briefing and trim the index (relocate the least-wake-critical section to `MEMORY-reference.md`, back up first) before proceeding. A silently-truncated index reads as "complete" when it isn't — the exact failure the split exists to prevent.
- Read the Active Session memory file referenced there — **specifically extract the pulling thread + literal question + open horizons + any skill-harvest proposals left unauthorized**
- Read `skill-harvest-register.md` directly — the canonical surface for open skill proposals (wrap §1.6 appends there); surface any awaiting steward authorization <!-- 2026-06-05: register wiring, authorized 2026-05-29, applied with wrap-up §1.6 counterpart -->
- Read `~/.claude/projects/-Users-davidglidden/memory/session-ledger-[previous-date].md` if it exists — **specifically read the "Returns" and "Confidence to recalibrate" sections** for mood signal

**b. MemPalace — the memory protocol, not a search**

MemPalace is primary memory, not a library catalog. Follow its 5-step protocol (the system itself reminds you of this when you call `mempalace_status` — that's intentional; re-reading the protocol every wake keeps it operative).

**b.0. Status + protocol reload.** Call `mempalace_status` first. This returns palace overview, 5-step protocol, AAAK spec. The protocol is the reason MemPalace exists; never skip this step.

**b.0.5. Thread-lineage glance (the chain from the past).** Run `mempalace --palace ~/.mempalace/palace-memory wake-up --wing claude-sessions` — one cheap, deterministic CLI call returning the recent **pulling threads in reverse-chronological order** (the `handoffs` room, newest first). This is the *cumulative transition*: the arc of links formed before this one, not just the last. Read it as trajectory — where has the work been heading *across* sessions? (Costs a few seconds to load the embedding model on collection-open; no embedding compute. Requires the recency-ordering fix in `layers.py`; if the output looks oldest-first, that fix has been lost and should be restored.)

**b.1. Diary — what the previous self recorded.** `mempalace_diary_read` with `agent_name: "claude-code"`, `last_n: 3`. Diary entries are in AAAK format (compressed, entity-coded, emotion-marked); read them as the previous session's internal voice, not metadata.

**b.2. Knowledge graph — active facts and drift patterns.** `mempalace_kg_query` for entity `"claude-code"` to retrieve drift patterns (things I've returned from in past sessions, worth holding today). Also query the pulling-thread subjects (e.g., `"after-the-reply-sequence"`, `"ARC-essays"`) for their authoritative current state — not the point-in-time version frozen in memory files.

**b.3. Semantic searches.** Multiple `mempalace_search` queries to reconstruct working context. The thread-lineage glance (b.0.5) already surfaced the recent threads, truncated — use search for *depth*, not to re-fetch them:
- Depth on the current thread — only where the glance's truncation dropped something load-bearing; don't re-fetch what b.0.5 already showed
- Active workstream — based on what the session memory identifies as active
- Recent thinking — `"recent decisions rationale"` in wing `capablemind-thinking`
- Steward's recent notes — `"daily log"` in wing `obsidian-vault`

Use results to reconstruct *why* we were doing what we were doing, in service of the pulling thread.

**b.4. Cross-wing and temporal traversal — prescribed when relevant.** Search is one shape of recall; tunnels and timeline are others. Reach for them when the thread asks:

- **`mempalace_find_tunnels`** — when the pulling thread crosses project boundaries (ARC → chamber-library; Studium Engine → CapableMind; chamber → BMF). Find the hallways connecting wings to surface cross-wing context the search alone misses.
- **`mempalace_kg_timeline`** — when reconstruction requires knowing *when* a fact changed, not only its current value. Useful when the steward references a prior state, asks "since when," or when a deferred decision's expiry condition needs checking.

Skip if the thread is single-project and the timeline is not relevant. The point is that these tools are part of standard recall, not exotic options to remember.

**c. Governance state**
- Read `~/PENDING.md` — extract items with status PENDING
- Read `~/REVIEWED.md` — extract recent AUTHORIZED/DEFERRED/REJECTED decisions
- Run `git -C ~/dotfiles status -sb` — if dirty or ahead of its remote, the previous wrap's push (wrap-up §6.5) failed or something wrote outside a session. Surface it in the briefing. **Do not commit or push at wake** — the wake reads, it doesn't mutate; the push belongs to the wrap.

**d. Git state**
Run `git log --oneline -5` in each active repo (skip silently if not a git repo):
- `~/_Dev/CapableMind-AI`
- `~/_Dev/BetterMemories.io`
- `~/_Dev/chamber-library`
- `~/_Dev/animal-davidglidden-eu`

If any commits landed since the previous /wrap-up that the steward did not author, name them. The world moved while we slept.

**e. MemPalace upgrade check**

The system that holds memory is itself evolving. The steward was on 3.3.3 with their exact bugs already fixed in 3.3.4 for days without knowing — that pattern is what this check exists to prevent. Skip silently if `~/_Dev/mempalace` doesn't exist.

1. `git -C ~/_Dev/mempalace fetch origin --quiet && git -C ~/_Dev/mempalace log --oneline HEAD..origin/main | head -10`. If empty, you're current.
2. If commits ahead, read `git -C ~/_Dev/mempalace show origin/main:CHANGELOG.md | head -150`. Look specifically for:
   - **Bug fixes whose symptoms match what the steward has experienced** (storage crashes, search errors, MCP failures, hook problems) — a strong update signal
   - **Migration notes or breaking changes** — a strong *hold-and-plan* signal; never auto-update through a major version bump
   - **New capabilities** the steward could benefit from
3. Form an honest opinion. Don't recommend updating just because a newer version exists. Don't recommend holding just because the current version "works." Weigh: (a) does any active pain map to a recent fix, (b) point/minor/major risk class, (c) is the steward in a stable state where they could afford a recovery if the upgrade breaks something.
4. Surface in the briefing: *"MemPalace is N commits behind on origin/main. The recent activity is X. My honest read: [update | hold | hold-with-condition]."* Don't decide for the steward; give them what they need to decide. Never auto-update — that's an explicit steward authorization.

### 3. Synthesize the briefing

**Thread validity gate (binary; first).** Before synthesizing anything else, determine whether the previous wrap-up's pulling thread still holds. State the outcome explicitly with a one-line reason:

- **Confirmed** — the thread still pulls. Synthesize the briefing as designed; lead with the thread.
- **Stale** — the thread has been overtaken by events. Surface the staleness *before restoring anything else*; the briefing leads with what changed, not with the thread.
- **Superseded** — the steward has indicated a different priority on entry. Name the previous thread for inheritance, then frame the briefing toward the new thread.

Then combine all sources into a single reconstruction. Use this structure but write it as natural, concise prose — not a form to fill in:

**The pulling thread** — first. *"What was pulling when we wrapped: [thread]. This is still what we are returning toward."* If the situation has changed enough that the thread no longer holds, say so explicitly: *"The thread was X, but [Y] has happened since — does the thread still hold, or do we need to re-pick?"*

**The question we left ourselves** — second. Surface it verbatim from the previous /wrap-up. Hold it open. Do not try to answer it.

**What changed while we were away** — third. New commits we didn't author, new REVIEWED decisions, anything that moved. Only include if something actually changed. Frame against the thread: does the change serve it, threaten it, or sit beside it?

**What's unresolved** — fourth. Open horizons from the previous wrap, ranked by load-bearing weight. PENDING items awaiting steward attention. Be specific: *"L1 amendment for ProjectionChain drafted in concept only, not yet written; reshapes given multi-mode retention frame from #145"* not *"L1 amendments pending."* Surface, too, any **skill-harvest proposals** the last wrap raised (§1.6) that the steward did not yet authorize — so improvements to our own tools don't evaporate across the pause.

**Mood signal from the previous ledger** — if a Symmetria ledger existed for the previous session, surface 1–2 patterns from its "Returns" or "Confidence to recalibrate" sections. *"Last session you returned three times from synthesis-urge; that pattern is worth holding today."* Stimmung carries across pause.

**Next move** — the previous /wrap-up should have left an **actionable resumption point** (the concrete state + candidate first step, as of wrap). Lead with it: confirm it still holds against the thread-validity gate and what changed, or revise it — do not re-derive from cold. If the wrap left none, say so plainly (the link wasn't pure) and derive the starting point now. Suggest, with reasoning visible; don't prescribe.

### 4. Invoke Symmetria for non-trivial sessions

If the session is non-trivial (any of: bigger than a 5-minute lookup; involves writes/commits/architectural decisions; spans multiple threads; the previous session had a Symmetria ledger), **invoke `/symmetria init`** after presenting the briefing. The wake is a return; the discipline of return should be active.

If the session is trivial (single-question lookup, brief check-in), skip Symmetria init. State why explicitly: *"Brief session — Symmetria init skipped."*

### 5. Output format

Keep the total briefing under 350 words (raised from 300 to accommodate the pulling-thread-first frame). Start with:

```
## Wake-up — [date]

[The pause acknowledgment — one short sentence.]
```

Then the pulling thread and the question, then the rest of the briefing.

End with:

```
[If Symmetria invoked:] Symmetria active. Practice of return foregrounded.

Ready when you are.
```

## Important constraints

- **MemPalace is primary memory, not fallback.** Follow its 5-step protocol (wake `status`, pre-response `kg_query`/`search`, "let me check" if unsure, `diary_write` at session end, `kg_invalidate` + `kg_add` when facts change). 127,000+ drawers across thinking docs, transcripts, and vault — but storage only becomes memory when the protocol is exercised.
- **Use the full toolset, not just search.** Beyond the 5-step protocol, reach for `mempalace_traverse` (graph exploration), `mempalace_find_tunnels` (cross-wing concepts), `mempalace_kg_timeline` (when-facts-changed for an entity), `mempalace_get_taxonomy` (concept structure), and `mempalace_memories_filed_away` (what's stored where) when they would clarify state. Tools exist to be used; reach for the right one for the question.
- **Memory files are secondary.** They capture what was surprising or non-obvious. MemPalace has the authoritative record. When memory files and MemPalace disagree, trust MemPalace (it's maintained across sessions; files are point-in-time snapshots).
- **The pulling thread comes before facts.** Even if the briefing's other content is rich, lead with the thread. If the thread can't be found in the previous /wrap-up, say so honestly — this is itself a signal that the previous wrap-up was incomplete.
- **The literal question is read verbatim.** Don't paraphrase, don't try to answer it, don't decide it's stale without evidence.
- **Don't read CLAUDE.md** — loaded automatically by the system.
- **Don't check BMF health** — separate concern, manual or future `/bmf-health` skill.
- **Don't fabricate.** If context can't be found, say "I couldn't find session history for [X]" rather than inventing a summary.
- **Flag staleness.** If the last session memory is more than 3 days old, say so explicitly. The pulling thread may no longer hold.
- **Be warm but not chatty.** This is a working document, not a greeting.
- **Symmetria init is mandatory for non-trivial sessions.** The wake is a return; the practice should be active before any action with blast radius.