RonanCodes/skills/close-session

Close Session

Run before clearing context, switching tasks, or stepping away. The goal: every important thing from this session lives in a durable place by the time you finish — code, GitHub issue, ADR, CONTEXT.md, wiki page, ROADMAP entry, log entry, or memory note. Nothing important left stranded in the chat transcript.

When to use

User says any of:

• "close session" / "close the session" / "session close"
• "wrap up the session" / "let's wrap up" / "finishing up"
• "end of session" / "I'm done for the day"
• "clear my context" / "shutting down for now"
• Before invoking /clear or starting a structurally different task

Do NOT use for:

• Mid-task pauses where context is still hot (just keep working)
• Tiny edits where there's nothing to capture
• Inside an autonomous loop (Ralph / planner-worker handle their own state)

The checklist (8 checks + 1 partnership sub-check, each skippable)

Run in order. Each check is a separate AskUserQuestion so the user can resolve, queue, or skip per item.

Checks 1–4 are the mechanical sweep, shared with /ro:handoff. Don't hand-run the git/gh commands here — invoke /ro:session-state, which prints a structured inventory (uncommitted changes, unpushed commits, open PRs, in-flight branch vs issue) and a verdict. Resolve each finding it reports using the actions documented in checks 1–4 below. Keeping detection in one skill means close-session and handoff never drift; the check bodies below are the resolution reference.

Check 1 — Uncommitted changes

git status --porcelain

If any:

• Show the file list and a short diff summary (git diff --stat).
• Offer: commit now (open /ro:commit) / stash / discard with confirmation / leave for next session (note in chat why).

Check 2 — Unpushed commits

git log @{u}..HEAD --oneline 2>/dev/null

If any:

• Show the commit list.
• Offer: push now / leave (note why — pre-merge gate? unsigned? not ready?).

Memory feedback_commit_and_push.md says push regularly on ralph/autonomous work; outside those modes, "leave" is fine.

Check 3 — Open PRs needing attention

gh pr list --author @me --state open --json number,title,url,statusCheckRollup,mergeable

For each open PR:

• Surface: title, CI status, mergeability, review state.
• Offer per PR: /ro:gh-ship to drive it forward / leave for review / close.

Check 4 — In-flight branch tracked as a GH issue?

git branch --show-current
gh issue list --search "<branch-keywords>" --state all --limit 5

If the current branch's work isn't represented by an open GH issue (and the repo has a gh remote):

• Ask: "this branch's work — is it captured in an issue?"
• If no: offer to create one inline (/ro:write-a-prd --target gh for a feature, or a quick gh issue create for a bug).
• If yes but not labelled ready-for-agent: offer to label it.

Check 5 — Chat-only decisions

The reflective check. Ask the user directly:

"Looking back at this session — was there anything decided in conversation that isn't yet in code, an ADR, a GH issue, a Jira ticket, a Confluence page, a CONTEXT.md entry, or a wiki page?"

If yes, for each decision:

• Offer the right durable home based on audience:
  • ADR — hard-to-reverse architectural decision (create docs/adr/000N-*.md inline)
  • CONTEXT.md — domain language
  • GH issue — internal action item (Skip/Ronan implementation queue)
  • Jira ticket (DAFO) — partner-visible action item or research request (Taskforce, Bernt, Guy, Quint, or anything they need to see/agree on). Use /ro:jira create
  • Confluence page — partner-shared research, agreement, or RFC. Use /ro:confluence create
  • Wiki page — reusable knowledge worth carrying across projects
• Skill drafts the entry and asks user to approve before writing.

Partner-visibility heuristic — auto-suggest Jira/Confluence routing when:

• This session mentioned Taskforce, Bernt, Guy, Quint, or Dataforce
• Working directory is under a partner/client project dir (e.g. ~/Dev/<partner-project>*)
• The decision involves an agreement, a deliverable, or research that partners need to verify

When that fires, the Atlassian options (/ro:jira create, /ro:confluence create) jump to the top of the destination list. Internal-only decisions still default to GH issue.

If the user can't recall, prompt with categories: "anything about architecture? domain terms? scope changes? things you tried and rejected? anything Taskforce should see?" Memory feedback_call_out_assumptions.md — do not invent decisions; if the user says nothing material happened, accept that.

Check 5b — DAFO tickets needing a status move

Skip unless the session touched the dataforce repo or any DAFO ticket was referenced in chat.

If it did:

• Ask: "any DAFO tickets that should move based on what shipped this session?"
• For each: offer /ro:jira move <KEY> "In Review" (PR merged, not yet live) or /ro:jira move <KEY> done (live in production — the strict rule from the partnership chat).
• If a Confluence page was authored this session that links to a DAFO ticket, offer to mirror the link the other way via /ro:confluence link.

This check enforces the partnership convention: Jira reflects partner-facing state, and the move to Done only happens when shipped.

Check 6 — New domain terms in CONTEXT.md?

Skill scans for capitalised domain-sounding nouns in this session's git diffs and conversation that aren't already in CONTEXT.md:

grep -Eo '\b[A-Z][a-zA-Z]+\b' <session-touched-files> | sort -u
# diff against CONTEXT.md term list

If candidates surface:

• Ask per term: is this a new domain concept worth glossarising? (Skip generic programming nouns.)
• If yes: append to CONTEXT.md under ## Language with a one-sentence definition. Use the format in grill-with-docs/CONTEXT-FORMAT.md.

Check 7 — Vault ROADMAP / log staleness

If the session touched a vault under vaults/<name>/:

• Read vaults/<name>/ROADMAP.md. Did anything move (In progress → Recently completed)? Anything new in Next up?
• Read vaults/<name>/log.md. Is the tail entry for today's session?
• Offer to invoke /ingest session --vault <name> to do this properly. That skill writes the session source-note, appends ROADMAP, appends log.md, and routes graduate-worthy knowledge to Hub vaults.

--vault <name> flag forces a specific vault; otherwise auto-detect by working directory or by files touched this session.

Check 8 — Memory entries worth saving

The kind of thing that earns a memory entry (per the auto-memory rules):

• User explicitly said "remember X" / "save this"
• User corrected something I did, and the correction is non-obvious / reusable
• User confirmed an unusual choice worked (validated judgment, worth keeping)
• A preference or constraint that should shape future sessions (deadline, naming, tool choice)

Ask: "Anything from this session worth saving as a persistent memory (feedback rule, project state, reference pointer, user fact)?"

If yes: skill drafts the memory entry (see ~/CLAUDE.md § auto memory for types and structure), shows to user, writes to ~/.claude/projects/<project-slug>/memory/<file>.md and appends to that project's MEMORY.md index. Per feedback_call_out_assumptions.md: do not invent. Only save what the user actually said or what is clearly load-bearing.

Check 9 — Capability gaps (skills / agents to create or edit)

Did this session reveal a tool that should exist? A manual multi-step dance that should be a skill, heavy context-filling work that should be an agent, a repeatable workflow the user described, or friction on an existing skill that warrants an edit?

Invoke /ro:capability-retro (it scans this session, dedups against the live registry, and proposes create/edit candidates; --apply to act on the approved ones). Defer to that skill — don't re-derive the logic here. Deferred candidates land in a ready-for-agent issue so the gap survives the clear.

Wrap-up summary

After all 9 checks, print a single-line status:

✓ Clean to clear context.
  • <N> commits pushed
  • <N> issues created
  • <N> ADRs written
  • <N> wiki pages updated (vault: <name>)
  • <N> memory entries saved
  • <N> items deliberately left (with reasons)

If anything's still open ("there's an uncommitted change you said leave for next session"), repeat it back so the user starts the next session knowing it.

Closing banner (always print last)

After the wrap-up summary, print a SESSION CLOSED ASCII banner via a single cat << 'EOF' heredoc. The point is a hard visual full-stop, so that when the user scans across terminal tabs it is instantly obvious this session is done. Print it even on --quick / --reflective runs.

Shape (adapt the body lines to the actual session, keep the big banner + a closing flourish):

  ╔══════════════════════════════════════════════════════════════════════════╗
  ║   ███████ ███████ ███████ ███████ ██  ██████  ███    ██                   ║
  ║   ██      ██      ██      ██      ██ ██    ██ ████   ██                   ║
  ║   ███████ █████   ███████ ███████ ██ ██    ██ ██ ██  ██                   ║
  ║        ██ ██           ██      ██ ██ ██    ██ ██  ██ ██                   ║
  ║   ███████ ███████ ███████ ███████ ██  ██████  ██   ████                   ║
  ║                                                                           ║
  ║    ██████ ██       ██████  ███████ ███████ ██████                         ║
  ║   ██      ██      ██    ██ ██      ██      ██   ██                        ║
  ║   ██      ██      ██    ██ ███████ █████   ██   ██                        ║
  ║   ██      ██      ██    ██      ██ ██      ██   ██                        ║
  ║    ██████ ███████  ██████  ███████ ███████ ██████                         ║
  ╚══════════════════════════════════════════════════════════════════════════╝

          .--------------------------------------------------.
          |   <repo / vault name>                            |
          |     ├─ pushed ✔   <N> commits → <remote>          |
          |     ├─ <headline of what shipped>           ✔    |
          |     ├─ ROADMAP / log / index updated        ✔    |
          |     └─ memory saved + indexed               ✔    |
          '--------------------------------------------------'

                      \   ^__^
                       \  (oo)\_______
                          (__)\       )\/\
                              ||----w |
                              ||     ||      everything's away. go rest.

   ┌───────────────────────────────────────────────────────────────────────┐
   │  OPEN LOOP → <the one thing waiting for next session, or "none">        │
   └───────────────────────────────────────────────────────────────────────┘

Rules:

• Body lines (the boxed checklist + open-loop line) reflect the real session: drop rows that don't apply, never invent a push or a memory that did not happen.
• If there is no open loop, the bottom box reads OPEN LOOP → none. clean break.
• Swap the cow for another small piece of ASCII art if it fits the mood; the SESSION CLOSED wordmark itself stays fixed so it is recognisable tab-to-tab.

Flags

• --quick — run only checks 1, 2, 3 (mechanical state). Skip reflective + vault + memory. Use when you're not really closing, just stepping away briefly.
• --reflective — run only checks 5, 6, 8, 9. Skip mechanical. Use when state is already clean but you want to capture knowledge.
• --vault <name> — force the vault routing in check 7 to a specific vault. Otherwise auto-detect.
• --skip <n> — skip a numbered check (repeatable, e.g. --skip 4 --skip 6).

Why this exists

The LLM Wiki system is built around durable state: GH issues, ADRs, CONTEXT.md, wiki pages, ROADMAP, log, memory. The Pocock pattern operationalises that for project repos. But durability only works if there's a discipline that moves the conversation's loose state into durable form before context clears. Without it, even a perfectly-shaped system leaks knowledge every session.

This skill is the discipline.

Related

• [[session-state]] — the shared mechanical sweep (checks 1–4); also run by /ro:handoff.
• [[handoff]] — the "I'm continuing elsewhere" sibling: captures state to one file + ensures issues exist, then you clear. close-session is for "I'm done"; handoff is for "pick this up later".
• [[ingest-session]] — the vault-side counterpart; this skill delegates to it for check 7.
• [[agentic-e2e-flow]] — the start-of-session counterpart for feature work.
• [[pickup]] — the re-entry skill for vaults (project-side equivalent is on the roadmap).
• [[agent-native-repo-pocock]] — the pattern that makes durable state actually capture-able.
• /ro:jira, /ro:confluence, /ro:jira-to-gh — Atlassian capture surfaces invoked from Check 5 and Check 5b for partner-visible work.