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.

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.

3. Synthesize the briefing

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