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

name, description, proactive

name	description	proactive
wake-up	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.	session-start

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.

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 index)
• Read the Active Session memory file referenced there — specifically extract the pulling thread + literal question + open horizons
• 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.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:

• Last session's pulling thread — in wing claude-sessions
• 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

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."

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 — based on everything above, what's the natural starting point toward the thread? 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.