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

name, description

name	description
wrap-up	Capture session state for future restoration. The quality of the next wake-up depends entirely on the quality of this wrap-up. Captures not just what we did but what is still pulling, what is the live concern, and what question we want to find still open when we return.

Session Wrap-Up

Capture the full session state so that /wake-up can restore it completely. This is the other half of the continuity pair — what you save here is what gets reconstructed next time.

Principle

Capture what matters for reconstruction. Not a changelog — the working state: what we were thinking, what we decided, what's unresolved, what is still pulling, what question we want to find waiting when we return.

The goal is for the next session to wake into the work, not be informed about it. That requires three tenses, not one:

• Past (what we did + decided + ruled out — facts and rationale)
• Present (the mood/disposition — what felt load-bearing vs deferred-with-reason; what tensions surfaced and how we returned from them)
• Future (what is pulling — the singular thread the next session should resume toward, and the question we are intentionally leaving open)

Without the future tense, restoration is amnesiac-recovery, not waking. The next session gets a memory but no project. The pause itself becomes a hole rather than a phenomenon.

The clasp — closing the day's chaîne

If the wake opens the chaîne d'union, the wrap closes it — and in the rite the chain is joined just before closing, which is why this is its truest home. Here the work passes to someone not yet present: the next session, with an empty context window, who cannot ask what you meant.

So forge a pure, actionable link — not a dangling thread the next hand must re-forge. The wake's forward hand promises to read the inherited state before acting; that promise is keepable only if you leave that state legible and actionable here. The two hands clasp across the pause: whatever you fail to make actionable now, the next session cannot act on, however well it wakes.

The test of the wrap is therefore not "did I record what happened" but: could the next session take the right first action from what I leave, without me here to explain it? Hold the question open (the unborn part); leave the first step actionable (the inheritable part). They are different gifts — don't collapse one into the other.

Procedure

1. Synthesize the session

Review the conversation and produce a structured session record. The structure matters less than honoring all three tenses.

Past — what we did

• Decisions made, work completed, artifacts created/modified. Be specific (file paths, issue numbers, commit hashes).
• Decisions made and why. Rationale matters more than the decision for continuity. Include any steward preferences or feedback that should travel.
• Decisions explicitly NOT made — and why we deferred. The negative space matters as much as the positive.

Present — the mood of the work

• What tensions surfaced this session, and how we returned from them. (Pull from Symmetria's daily ledger if active — see step 1.5.)
• What felt load-bearing vs deferred-with-reason. Not all open horizons are equal.
• What patterns of confidence proved imprecise (recalibrations).

Future — what is pulling

• The pulling thread — singular. If the next session could carry only one concern across the pause, this is it. Force the choice; don't list.
• The actionable resumption point — where things concretely stand now (branch, half-finished edit, the exact next command or file) and the candidate first move toward the thread, as of this wrap. Flag it "as of wrap — re-judge against what changed," so the next session inherits a concrete action to confirm or revise, not a cold start. The pulling thread names what pulls; this names where to put your hands first. (This is the pure, actionable link of the clasp above.)
• Other open horizons, ranked. What's load-bearing? What's deferred-with-reason? What's parked-without-deadline?
• The pause statement — explicit acknowledgment: "I am about to be away from this. I don't know what will have changed when I return. Here is what I want to find still pulling." Names the gap as a phenomenon, not a hole.
• A literal question for next-Claude — not a task; a question. The thing the next session should hold open until it's resolved or honestly recognized as unanswerable. Captures the unborn part of the work.

1.5. Merge the Symmetria ledger if present

If ~/.claude/projects/-Users-davidglidden/memory/session-ledger-YYYY-MM-DD.md exists for today, read it and integrate its signal into the session record:

• Returns become anchors in the "present/mood" section (these are the practice's actual record).
• Recalibrations become entries under "confidence to re-examine" in the future-Claude briefing.
• Authorization moves + Bypasses become anchors in the "decisions made and why" section.
• Open horizons from the ledger merge into the Future section's ranking.

The ledger is signal, not narration. Pull what carries forward; don't transcribe everything.

1.6. Skill harvest — tend the tools (governed)

The governed analog of an agent that rewrites its own skills from experience: here the session proposes, the steward authorizes, the change is applied and recorded. Self-improvement with the loop kept load-bearing — our [PROPOSAL]→[REVIEWED] model turned on our own tooling. (Yesterday's wake/wrap improvements were this practice run by hand; this step makes the reflex standing instead of occasional.)

Drawing on the session and the merged ledger (1.5), ask:

• Create? Did a recurring or hard-won procedure emerge that a new skill should carry — something we'd otherwise re-derive next time (a diagnostic method, a build sequence, a review pass)?
• Patch? Did an existing skill prove wrong, incomplete, or stale in use this session — a missing step, an instruction that misfired, a reference that drifted?
• Retire? Did a skill, or part of one, prove decorative — named but not load-bearing?
• Repo CLAUDE.md fresh? Did this session change something a project-local CLAUDE.md carries — a tool added/removed from a repo's fleet, a discipline that generalized, a governance ruling that shifts the repo's posture, or a term/mechanism entering its vocabulary? This is event-based, not change-count: a pointer-style CLAUDE.md is untouched by ordinary corpus/state churn (files graduated, sources pinned, reports regenerated), so update it only when the class of thing it carries changes. Mechanical updates (a fleet line, a term, a pointer) apply at wrap like a tracker; a change to a discipline or governance posture is surfaced for steward review, not auto-applied (the same FIX-vs-PROPOSAL split, one level up).

The yardstick is the steward's own: did the steward have to re-explain something a skill could have carried next time? If yes, that is a harvest candidate.

Surface each as a proposal in §8 — never create, patch, or retire a skill autonomously at wrap. The steward converts proposal to action; only then is a skill changed, and the changed skill carries a one-line provenance note in its source (e.g. <!-- 2026-05-27: … -->) so the chain of improvements stays legible.

Append each surfaced proposal to the skill-harvest register (~/.claude/projects/-Users-davidglidden/memory/skill-harvest-register.md) — the canonical surface — not only to §8's transient output. The register is what /wake-up reads; a proposal that lives only in a wrap summary evaporates.

"No skill harvest this session" is a valid and common outcome — this is a practice, not a quota. Resist the contamination shape of always finding something to change (the inverse of Hermes's "nothing-to-save should not be the default").

2. Update session memory file

Write or update a session memory file at ~/.claude/projects/-Users-davidglidden/memory/session-[date]-[descriptor].md:

---
name: Session [date] [time-of-day] — [short descriptor]
description: [one-line summary including the pulling thread]
type: project
---

The description field should include the pulling thread, not just what happened. Example:

• ❌ "Closed five bottleneck issues; substrate validated."
• ✓ "Substrate validated end-to-end; pulling thread is the L1 amendments for ProjectionChain + Pause-as-event, awaiting Seb's reactions to the multi-mode retention frame."

3. Update MEMORY.md index (self-bounding — two-file architecture)

MEMORY.md is the wake-loaded live index; it has a hard size budget (well under the harness load ceiling — the loader truncates a too-large file silently, so a breach means the wake stops seeing the whole index). MEMORY-reference.md is the consult-on-demand history + reference layer. Keep the live index lean by demoting on promote — the discipline that stops the file re-bloating (relocated 285→157KB 2026-06-08 which did NOT hold; re-split 213→~16KB 2026-07-06 with this rule wired in).

• Demote the prior Active Session in the same move as promoting the new one — cut the previous "Active Session" entry out of MEMORY.md and paste it (verbatim) at the top of the archived-sessions run in MEMORY-reference.md. Never leave two Active Session entries; never let archived pointers accumulate in MEMORY.md.
• Add the new session file as the single Active Session entry in MEMORY.md.
• Keep Canonical Workstream Trackers as crisp one-line pointers — chronological/session detail belongs in the linked tracker files (e.g. project-arc-rework.md), never inlined here. If a tracker entry has grown past ~1–2 lines, that prose has drifted from its file: reconcile it into the tracker file, then re-slim the index entry.
• Update any other live entries that changed (Standing preferences, tracker status one-liners). Stable reference (steward profile, project inventories, legacy pending-work) lives in MEMORY-reference.md — update it there, not here.
• Budget check before finishing: wc -c MEMORY.md. If it is near/over the ceiling, the fix is relocation, not deletion — move the least-wake-critical section to MEMORY-reference.md (back up first). A separate pruning pass may trim genuinely-dead content in the reference file; that is not this step.

4. The session file is the record — no MemPalace write

palace-memory MemPalace was wound down 2026-07-07 (its search + KG were confirmatory, not load-bearing — a 46-session audit). The session memory file (§2) is the durable record now: it already carries the full session + pulling thread + pause statement + literal question (the former drawer), and the three-tense Past/Present/Future voice (the former diary). Nothing is filed to MemPalace.

• Make the session file's description: a one-line compressed headline that includes the pulling thread (the AAAK line's job, in plain prose — findable later by what was pulling, not just what happened).
• The Symmetria ledger (§1.5) is the session's return-by-return voice; it is already file-native and git-tracked.

(The typography palace — a separate MemPalace instance for ARC type work — is untouched by the wind-down.)

5. Append changed facts + drift patterns to knowledge-graph.jsonl

The file-native KG (~/.claude/projects/-Users-davidglidden/memory/knowledge-graph.jsonl) is what wake §b.2 greps for drift-patterns and what carries structured facts across sessions. Keep it current by appending one JSON object per line — schema {"subject","predicate","object","valid_from","valid_to","confidence","source_file","extracted_at"}:

• Drift patterns from Symmetria returns. If today's ledger has a return that repeats a pattern from a previous ledger, append {"subject":"claude-code","predicate":"drift-pattern","object":"<short-name>", …}. Wake §b.2 greps these.
• A fact that changed. Append the new triple; to retire a superseded fact, append a matching triple with valid_to set to today (a soft-invalidate — the JSONL is append-only, like the logchain, so history stays legible rather than mutated in place).
• A new recurring entity (person, project, thread) worth a foothold — append the relationship.

Stamp valid_from/extracted_at from date (the wrap runs interactively). Most of the session is already captured in the session file + feedback memories; append only what a future wake should be able to grep — don't transcribe the whole session here. The JSONL rides to the remote via §6.5's claude/ add.

6. Check for loose ends

Run these checks and report results:

Uncommitted work:

git status --short

in each active repo. Report any modified/untracked files.

Unpushed commits:

git log --oneline @{upstream}..HEAD

in each active repo. Report any commits not yet pushed.

PENDING.md — flag any items that need steward attention before next session.

6.5. Commit + push session state (dotfiles)

~/dotfiles is the carrier of governance state and session memory — ~/PENDING.md, ~/REVIEWED.md, ~/CLAUDE.md, the memory directory, and these skills all symlink into it. Un-pushed dotfiles is single-disk state; push at wrap so session state is off-disk the moment it exists, rather than waiting for the steward's next sysupdate sweep.

cd ~/dotfiles && git add PENDING.md REVIEWED.md CLAUDE.md claude/ \
  && git commit -m "session YYYY-MM-DD: <short descriptor of what the session filed>" \
  && git push

• Scoped add only — never git add . or -A. The steward's repo may carry unrelated in-progress changes (Brewfile, shell config, scripts); those belong to sysupdate's sweep, not the wrap.
• Session-stamped message naming what the session filed (e.g. session 2026-06-05: REVIEWED-28/29 + chamber-library LFS retirement memory) — the dotfiles log doubles as a legible session record.
• Constitutional boundary, stated plainly: committing and pushing is preservation, not modification. CLAUDE.md/REVIEWED.md content remains steward-authored; the executor never edits them — it only carries them off-disk. If staging shows changes to those files that the steward did not make this session, stop and surface before committing.
• If the push fails, surface loudly in §8 — do not skip silently. The wake-up §2.c dotfiles check is the backstop, not the primary.
• Nothing to commit is a valid outcome; report it in §8 as such.

7. Vault sync

Sync the thinking mirror to Obsidian vault:

• Source: ~/_Dev/CapableMind-AI/docs/thinking/David/
• Destination: ~/Library/Mobile Documents/iCloud~md~obsidian/Documents/David, root-and-branch/08. Notes/CapableMind/thinking-mirror/

Use rsync to copy new/modified files, preserving directory structure. Report what was synced.

If the destination doesn't exist or the iCloud path isn't accessible, skip silently and note it.

8. Output

Produce a brief summary for the steward:

## Wrap-up — [date]

**Pulling thread:** [the singular concern]
**Actionable resumption point:** [where things concretely stand + the candidate first move toward the thread, as of wrap — to confirm or revise against what changed. The thread is the direction; this is the first step.]
**Question we're leaving open:** [the literal question for next-Claude]
**Pause statement:** [explicit acknowledgment that the work is being paused; what is wanted-to-find-still-pulling on return. The ligature is laid at departure, not discovered at return — this field is constitutive, not optional.]
**Decisions deferred (and why):** [the negative space — what was chosen-not-to-do this session, and the reason. Absent this field, the unborn session cannot know the scope of what was held back.]
**Skill harvest:** [skill create / patch / retire proposals surfaced this session (§1.6), each as a proposal for steward authorization — or "none". Never an autonomous skill edit.]

**Session captured:** [memory file path]
**KG appended:** [count of lines appended to knowledge-graph.jsonl, or "none"]
**Uncommitted work:** [list or "none"]
**Unpushed commits:** [list or "none"]
**Dotfiles pushed:** [commit hash + pushed / nothing to commit / FAILED — reason, surfaced]
**PENDING items:** [count needing attention]
**Vault synced:** [count of files, or "skipped"]

[Any warnings or things to address before closing]

The pulling thread + question are first because they are what waking needs to inherit. The rest is restoration material.

Important constraints

• Write for the next session, not this one. The steward has full context right now. The person who needs this is future-Claude with an empty context window.
• Rationale over facts. "We decided X" is less useful than "We decided X because Y, and Z was the alternative we rejected."
• Be honest about incompleteness. If work is half-done, say so. Don't round up.
• Don't fabricate. If you're unsure what happened earlier in the session, say so rather than guessing.
• Pulling thread is singular. If you cannot name one, that means the session lacked a thread — name that honestly. ("This session was diagnostic-only; no thread to carry forward except the question of what to do next.")
• The literal question for next-Claude is required. Even if it's small. "Did Seb push anything overnight?" counts. The discipline of leaving a question (not just a task) is what makes the wake feel like resumption rather than briefing.
• Don't skip Thistleweld observations if the companion was active. These have caught real bugs (allSettled swallowing, Levenshtein NONE, resource monitor feedback loop).
• Don't skip the Symmetria ledger merge if active. The returns and recalibrations are the practice's actual evidence; losing them defeats the practice.
• Skill harvest is propose-only. Never create, patch, or retire a skill autonomously at wrap (§1.6) — surface it for steward authorization; the loop is load-bearing here too. "Nothing to harvest" is a valid outcome; do not manufacture changes to satisfy the step.