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 — multi-query reconstruction

Run multiple targeted searches to reconstruct the full working state. MemPalace MCP tools are wired at user scope and should always be available.

• Last session's pulling thread: mempalace_search query using keywords from the previous /wrap-up's pulling thread, in wing claude-sessions
• Active workstream: mempalace_search query based on what the session memory identifies as the active work
• Recent thinking: mempalace_search query "recent decisions rationale" in wing capablemind-thinking
• Steward's recent notes: mempalace_search query "daily log" in wing obsidian-vault

Use the 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, not fallback. Query it first and lean on it heavily. It has 100,000+ drawers across thinking docs, transcripts, and vault.
• Memory files are secondary. They capture what was surprising or non-obvious. MemPalace has the full record.
• 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.