claude: back up custom skills, memory, and settings with symlink pattern

The ~/.claude/ directory was previously local-only — a machine wipe
would have lost the accumulated memory, custom skills, and settings.
This commit moves the durable parts into dotfiles with the same
symlink-to-home pattern used for CLAUDE.md, PENDING.md, REVIEWED.md,
and L2-BOOTSTRAP.md.

Preserved (symlinked from ~/.claude/* into here):
  skills/audit/              — thinking-folder drift scanner
  skills/symmetria/          — practice-of-return discipline
  skills/vault-update-people/ — Obsidian People-file maintainer
  skills/wake-up/            — session restoration
  skills/wrap-up/            — session state capture
  memory/                    — 55+ memory files (MEMORY.md, sessions,
                               ledgers, project state, feedback, etc.)
  settings/settings.json     — user preferences (hooks, flags, no secrets)

Deliberately NOT backed up:
  settings.local.json   — contains operational secrets (HF_TOKEN,
                           SSH password in expect scripts); by naming
                           convention, *.local.* is not synced.
                           Needs separate review and probable rotation.
  sessions/, history.jsonl, caches, telemetry — ephemeral
  plugins/, marketplace skills and agents — reinstallable

The working copies at ~/.claude/skills/* and
~/.claude/projects/-Users-davidglidden/memory are symlinks into this
directory, so every write flows here automatically. install.sh
recreates the symlinks on a fresh machine.

FOLLOW-ON (flagged, not in this commit):
  settings.local.json contains a HuggingFace token and an SSH password
  as plaintext strings inside allowed Bash command patterns. These
  should be rotated and moved to secure storage (keychain / pass /
  env file outside the settings file).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

claude/skills/wake-up/SKILL.md

@@ -0,0 +1,125 @@
+---
+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
+---
+
+# 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.