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

name, description, proactive

name	description	proactive
wake-up	Restore full session context and continuity from the 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.

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.
• 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
• 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
• Link-resolution canary (seconds-cheap): verify MEMORY.md's file pointers resolve — every ](file.md) target exists in the memory dir. Flag dead pointers in the briefing, distinguishing pre-existing-broken from newly-broken (grep the previous git state if in doubt). A pointer to a missing file is the index lying about what memory holds.
• Telos conditional: if the pulling thread touches the studium engine / The Making / ARC-as-public-proof (the engine's reason-for-being), also read project-studium-engine-telos-chamber-of-voices.md and hold ONE line of the why in the briefing — the telos lane drawn first, never only the production lanes. Do NOT recite it on unrelated wakes (decorative).

b. The files layer — primary memory [palace-memory MemPalace wound down 2026-07-07]

The durable memory is the Markdown + JSONL files (git-tracked, dual-remote). There is no separate index to consult and none to keep in sync — reconstruct directly from the files, and when in doubt verify against the substrate (code, git, the document itself).

b.1. Thread trajectory — the chain across sessions. Read the last ~3 session memory files (session-*.md, newest by mtime) — their Future/pulling-thread and Present/mood sections are the cross-session arc. §2.a's Active Session pointer names the newest; these give the trajectory (where the work has been heading), replacing the old diary + thread-lineage glance.

b.2. Drift patterns — what I've returned from. grep 'drift-pattern' ~/.claude/projects/-Users-davidglidden/memory/knowledge-graph.jsonl — the file-native KG (a JSONL export of 329 triples; ~84 are claude-code drift-patterns). Surface the one or two worth holding today. This replaces the old kg_query claude-code ritual; treat the JSONL as a point-in-time export that wrap §5 keeps current by appending.

And one prevention alongside them — grep 'prevention' …/knowledge-graph.jsonl. Surface one line each way. Grepping only drift-pattern opens every session by re-reading what went wrong and never what compounded; a prevention records a lesson from one failure class stopping a different one. One of each, not a tally.

b.3. Depth on the thread — grep, don't query. When the session files don't carry enough, grep the memory dir + the CapableMind thinking docs + the Obsidian vault directly for the thread's keywords. The files are authoritative; there is no catalogue in front of them.

(The typography palace — a separate MemPalace instance queried via CLI for ARC type work — is KEPT, unaffected by the wind-down; reach for it only when the thread is ARC typography.)

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.
• Governance drift check — run python3 ~/dotfiles/scripts/governance-drift-check.py (~0.2 s). It reports state claims in ~/CLAUDE.md that the substrate contradicts: unresolvable paths, named tools with no configured server, hooks claimed to fire that are unconfigured, expired date horizons, and structural damage. Report the count in the briefing; list the findings only if the count changed since the last wake. Do not correct — correction of doctrine or steward-held state requires [ESCALATE] (Constitutional Constraint #1); this step is detection only, which needs no authorization. If the script prints INSTRUMENT NOT VERIFIED, its positive controls failed — treat the result as unestablished rather than clean.

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 — RETIRED 2026-07-07. palace-memory is being wound down; there is no MemPalace to keep current, so no upgrade check runs. (The typography palace, a separate instance queried via CLI for ARC type work, is unaffected and deliberately not upgrade-checked from the wake.)

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.

Substrate-check anything you call outstanding — a disposition clause is not a status. REVIEWED.md's "If AUTHORIZED: build X → then Y" records what was authorized, never what was done; the same is true of a PENDING item's **Awaiting:** line and any tracker's "next steps." Before listing an authorized item as unbuilt, check the substrate — the code, the spec header, the repo's CLAUDE.md, the fleet test count — and mark each item verified against substrate or unverified. Cheap: usually one grep for the named function or declared-data key.

This matters more here than anywhere else in the briefing: the wake is the highest-leverage place a false claim can land. It shapes the steward's picture of their own project before any work begins, and it arrives with the authority of a status report. An unverified backlog reads as fact, and the steward has no reason to doubt it. If a check is genuinely too expensive, say "unverified — last confirmed [when]" rather than stating it flat; an honest gap is inheritable, a confident error is not.

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

• The files layer is primary memory. The git-tracked Markdown (MEMORY.md, session-*.md, REVIEWED/PENDING, the feedback/project memories) + knowledge-graph.jsonl are the durable record — reconstruct from them, and when in doubt verify against the substrate (code, git, the document itself). Storage becomes memory only when read against the pulling thread, not transcribed.
• No separate memory index to consult or keep current. palace-memory MemPalace was wound down 2026-07-07 (its search + KG were confirmatory, not load-bearing — a 46-session audit found genuine reach ≈0.07/session, graph features 0× used). Do not call mempalace_* tools for palace-memory. (The typography palace is a separate instance, still queried via CLI for ARC type work only.)
• 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.