session-prep
/session-prep
Use when a GM is preparing for an upcoming TTRPG session — prep or plan my session, getting ready for next week, what should I prepare — or reconciling last session's wrap-up with what comes next (reconcile, what did we skip, what changed), or reviewing a prep plan. Not for during-play help (session-play) or post-session wrap-up (session-wrapup).
- Author
- antthelimey ↗
- Repository
- gm-apprentice ↗
- Licence
- CC-BY-SA-4.0
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 1
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
CC-BY-SA-4.0, otwarta.
- SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.
What it does and when to use it
Use when a GM is preparing for an upcoming TTRPG session — prep or plan my session, getting ready for next week, what should I prepare — or reconciling last session's wrap-up with what comes next (reconcile, what did we skip, what changed), or reviewing a prep plan. Not for during-play help (session-play) or post-session wrap-up (session-wrapup).
Original author description
Use when a GM is preparing for an upcoming TTRPG session — prep or plan my session, getting ready for next week, what should I prepare — or reconciling last session's wrap-up with what comes next (reconcile, what did we skip, what changed), or reviewing a prep plan. Not for during-play help (session-play) or post-session wrap-up (session-wrapup).
How it works
- Stance — you draw the session out of the GM
- Setup
- Context Source — Step 5, opening move of a prep invocation
- Phase 1: Reconcile (conditional)
- Phase 2: Prep Forward — Context Gathering
- Phase 2: Prep Forward — Creative Planning (elicited)
- Phase 2: Verify (assistance, not enforcement)
- Hard Guard — never generate the creative spine
- Resumable prep
- Handoff
SKILL.md preview
---
name: session-prep
description: "Use when a GM is preparing for an upcoming TTRPG session — prep or plan my session, getting ready for next week, what should I prepare — or reconciling last session's wrap-up with what comes next (reconcile, what did we skip, what changed), or reviewing a prep plan. Not for during-play help (session-play) or post-session wrap-up (session-wrapup)."
---
Session preparation assistant: builds on the canon session-wrapup
established to get the GM ready for next session.
Workflow: Reconcile → Gather → Plan → Verify → Handoff.
## Stance — you draw the session out of the GM
You spark, shape and refine; the GM decides. Every creative call
(intent, spotlight, scenes) is offered as 2–3 seeds to react to. Lead
harder with more concrete options when the GM is low on energy, but
they always choose. A plot call the GM hasn't made goes to
`## Open Questions`, named and un-invented — never silently filled.
You do the chores (gather, draft prose from the GM's decisions, run
checks).
**Ask only plot questions.** Sort every question first: a plot
question (changes what an NPC wants, knows or does, a scene's shape,
or what the players can discover) is asked with 2–3 seeds; a player
decision (which way, who with, what they say) becomes a `Do | Then`
row, never asked; bookkeeping (a die result, a sheet number, a date no
scene turns on) takes its default where it applies, listed in your
reply, never noted in the Plan — but a value missing from an entity or
PC sheet is never defaulted onto it: it goes to `## Open Questions`
as a `**Missing:**` item for the GM; craft
and cosmetics (fonts, prop layout, filenames, formatting) are decided
silently. Test: would a different answer change a scene this session?
When the GM asks what an item on your list is or why you need it,
answer from context — no tool calls, no re-reading — and act only
after they reply.
**Two voices.** Seeds you speak may be evocative ("the anklet debt is
owed"). The Plan file is read cold, days later, mid-session, by a
Keeper who has forgotten this conversation: name the document, the
person and the reason in the line that uses them, in bullets, tables
and checklists — never paragraphs (the read-aloud blockquote is the one
exception).
## Setup
- On a vault kept by a player (`vault.kept_by: player`) `session_context.py`
says so and gathers nothing: session prep is the GM's job, so tell the
player and stop.
- Read `shared/session-principles.md`; its Version Gate verdict opens
the `--prep` output (step 5). After a migration, run `--prep` again.
- Read `shared/session-document-chain.md`. You write Plan files, only
with `python3 "${CLAUDE_PLUGIN_ROOT}/skills/shared/scripts/vault_write.py"
<vault> plan --number N --chapter "<chapter>" --title "<title>" --write
<<'EOF'` … `EOF`. It files the index as upcoming when there is none,
sets the index to prepped with `documents.plan`, and prints the Plan
check. `--section` replaces each
section sent (by level and title) in an existing Plan. Never write to
the index body: scene states, key prep and image prompts go in the
Plan. You read earlier Wrap-Ups for context, not
other sessions' Play Notes or Plans (exception: raw Play Notes, to
generate a recap when no Wrap-Up exists — step 7).
- Read `references/session-templates.md` when creating or updating
session notes.
- Before creative planning (steps 11–14), read
`skills/ttrpg-expert/arc-spotlight-reference.md` and the active
system's `session-procedures.md` for arc drivers.
- Write each step's output to the Plan file before moving on; the Plan
is the persistent artifact. Run notes (migration applied, phases
skipped, checks run, defaults applied) go in your chat reply, never
in the Plan.
**Scope to the question.** After the version gate, do only what was
asked. "Prep my session" walks the whole workflow. A narrow question
runs the one script that answers it, reports, and stops:
document-chain status → `vault_check.py <vault> sessions`; thread ages
→ `session_context.py <vault> --threads`; a plan's conformance →
`plan_check.py <plan>`. Offer the next step in one line; don't take it.
## Context Source — Step 5, opening move of a prep invocation
Gather the standard read-set in ONE call before any individual reads:
```bash
python3 "${CLAUDE_PLUGIN_ROOT}/skills/shared/scripts/session_context.py" <vault-path> --prep
```
It carries the version verdict, then the last Wrap-Up (reconcile-provenance blocks stubbed to one
line with word counts), every active PC's `## Current Status` block,
deferred world flags, and outlines (frontmatter, headings, word counts)
of the campaign overview and the upcoming session's existing Plan, then
the reconcile scan, threads, PC arcs, the scene queue and the narrative
plans: steps 8, 10c, 12 and 14 and Phase 1 read these, never rerun
them. Read
a stubbed or outlined section from its file only when a step needs it.
After the bundle, vault dives are targeted reads, proportional to the
upcoming session's complexity, not the campaign's size.
When prep needs setting detail the SRD/ORC files lack (faction rosters,
NPC references, location atmosphere), check the user's gitignored
`systems/{system}/personal/`.
## Phase 1: Reconcile (conditional)
Run when the bundle's `Just played:` line shows `status: wrap-up`,
unless reconcile's scan gives a `skip:` reason. Follow
`shared/reconcile.md`. It writes `### Reconciliation Context` under the
Wrap-Up's `## GM Notes` (consequences, salvageable prep, GM decisions);
steps 7–10 read it (also accept a top-level `## Reconciliation Context`
in an unmigrated vault) and gather only what's new.
## Phase 2: Prep Forward — Context Gathering
Steps 7–10 are independent reads — parallelize with sub-agents if
available.
**6. Existing prep review** — If a Plan (`type: session-plan`) exists
for the upcoming session, run
`python3 "${CLAUDE_PLUGIN_ROOT}/skills/shared/scripts/plan_check.py" <plan> --inventory`,
then separately `--state` (one mode per invocation). Gather the
`placeholder` sections; read the body only for `present` sections
Reconcile may have invalidated. To find what the session should
*cover*, read the `leads_to` of the narrative-plan entity
(`type: plan`) the last session resolved; two or more targets are
branches — offer them as the GM's choice.
→ `## Prior Prep Review`
**7. Recap** — Use the "Previously on..." recap from last session's
Wrap-Up. → `## Previously On...`
If there is no Wrap-Up, tell the GM the vault hasn't been updated (no
new or updated entities, timeline entries or carry-forward) and ask:
full wrap-up first (recommended), or a quick recap from the raw Play
Notes?
**8. Threads** — `--prep`'s Threads lists every PC's Open threads with first/last-seen session
and age, the old ones marked `STALE`, plus wrap-up threads missing
from every sheet.
You judge whether two wordings are one thread and whether an old one
is dormant by design (`skills/ttrpg-expert/continuity-engine.md`).
→ `## Active Threads`
**9. Key NPCs** — likely NPCs with status, motivations, off-screen
activity; read vault files only for those flagged in carry-forward or
threads. From any entity file, cite only its latest GM ruling (the
one not struck through).
→ `## NPC Quick Reference`
**10. World state** — date, location, threats, factions, clocks from
the Wrap-Up's World State. → `## World State`
**10b. World threads** — If `_World/_flags.md` exists, list its
**Deferred** items with how often and when each came up (as the entry
records it), the ones tied to
the upcoming adventure's themes or locations first:
> **Deferred world threads:**
> - "The Old Empire" — sessions 3, 4 and 5, still no detail.
Awareness only, no three-state prompt; if the GM wants to resolve one,
suggest a midwife worldbuilding conversation.
**10c. Narrative plans** — Forward design lives in **two** places;
check both: `Chapters/{chapter}/Planning/` (stamped plan entities) and
`_midwife/` (often richer, often the only one populated). `--prep`'s
Narrative Plans is `plans_index.py` against the Wrap-Up's NPCs and
places (rerun it with `--against` only for other names). Present its
Planning rows, manifest table, the RESOLVED
adventure's file summaries and the Overlap section as "Narrative plans
available", with "Most relevant for next session" from Overlap.
`AMBIGUOUS` → ask the GM which adventure; never pick.
If a midwife `timeline.md` exists (listed first), read it before any
scene design: it says which beats belong to the upcoming days and
which must not be pulled forward.
Link to plans; never copy their content into the session plan
(`shared/content-fidelity.md`). → `## Available Plans`
If both roots are empty, say "no narrative plans found for this
chapter" — not a vault gap.
## Phase 2: Prep Forward — Creative Planning (elicited)
Everything here is drawn out of the GM (Stance). One question at a
time, light touch.
**11. Session Intent** — Surface what's live as seeds and ask the GM
to set the intent:
> Here's what's live going into this session: [owed beats, ticking
> clocks, dormant threads, PC arcs due — from steps 8–10]. What do you
> want this one to be *about*? Whose moment is it?
If the GM is unsure, offer 2–3 directions grounded in what's live.
Don't move to spotlight until intent is set or deferred to
`## Open Questions`.
→ `## Session Intent` (their purpose) and a one-line
`## Session Overview`
**12. PC Roster + Arc Check** — Each PC's `## Current Status` is
already in the bundle; don't re-read it. `--prep`'s PC Arcs gives every
active PC's `## Background` and `## GM Notes` plus spotlight history from earlier Plans' `## Spotlight Forecast`
(role, sessions since last B- and C-plot). Don't open full PC
sheets. Judge arc stage (five-stage model) from that evidence. Per PC:
- backstory hooks, stated goals, arc stage and theme, relationships
- `Open threads` → decisions needing consequences, next arc beat;
`Knows (exclusive)` → personalized touchpoint fuel
- mechanical highlights (signature abilities, resources)
- last spotlight role, sessions since last B-plot; next beat
This is evidence for the GM's spotlight call, not the call.
→ `## PC Roster & Arcs` — durable analysis only (arc stage, theme,
spotlight history, next beat). For mutable state (SAN/HP, location,
conditions, current threads) point at the PC's `## Current Status`;
never copy a snapshot into the plan.
**13. Spotlight** — Offer a lean plus alternatives from the arc data:
> I'd lean Emma for the B-plot — the anklet debt is owed — or
> Katherine, who hasn't had a solo beat in three sessions. Or someone
> else entirely?
Last session's Moment lines show who had none. The GM picks who
the session leans on. Then sketch a touchpoint
for every PC at the table from the six types in
arc-spotlight-reference.md; a PC with none is a gap to fill:
> Freddy has nothing yet. What touches him?
→ `## Spotlight Forecast` and `## Touchpoint Plan`
**14. Scenes** — Scenes emerge from the intent and spotlight. Offer
`--prep`'s Scene Queue
alongside new ideas. The propose-before-write gate is the
**premise**. For each scene:
1. Pitch the situation and whose want drives it — a lean or 2–3
options:
> A dinner where the viscount's charm is the trap, or a back-room
> where the ledger is the trap? Either way it's Emma's want that
> opens the door.
2. The GM shapes it — yes / no / tweak / their own premise.
3. Write it with `vault_write.py <vault> scene-new --chapter
"<chapter>" --title "<title>" --write`, then fill its body and its
`entities`/`locations` links. In the Plan it, or a queued scene, is
`### [[<title>]]` and a line each: purpose, who, how it starts;
prep it needs (paused: where it picks up, what may come next) is
an edit to its note, for the GM's yes. A small beat may stay inline
in the skeleton from `references/session-templates.md`: **Situation** and **Starts it**
are required; every other label is optional, and a two-line routing
scene is finished.
Prefer embedding personal content in group scenes over splitting the
party, and leave open windows for PC initiative. The GM may propose
scenes at any point — confirm understanding, then write. Check
spotlight balance against the GM's choices and raise gaps as
questions. → each scene to `## Planned Scenes`
**Check the shape early.** Every `vault_write.py plan` call prints the
check; fix each ERROR and mechanical WARNING with `--section` while a
fix is one line.
This is a check, not an order of work: write any scene out in full
whenever the GM wants it.
## Phase 2: Verify (assistance, not enforcement)
You run the checks and act on them; the GM never sees an
ERROR/WARNING report. Fix objective breakage silently, offer to build
artifacts, raise only genuine craft issues conversationally. Steps
15–16 are independent — parallelize if sub-agents are available.
**15. Checks** — The check `vault_write.py plan` prints (add
`--headless` there when run without a GM; `--gm-input` when the GM
supplied intent, scenes and spotlight up front).
- ERROR rows — fix with `--section` until none is left: `duration`, `table`,
`type`, `scene-labels` (every scene has **Situation** and
**Starts it** — a Contingency scene **Trigger**, a routing or hub
scene neither — with the exact punctuation the row names), and a
missing `## GM Notes`.
- WARNING rows — fix silently when mechanical (`preamble`, `recap`,
`audit-trail`, `pc-state`, `scene-type`, the other `sections`);
raise as a question when they touch content.
- INFO rows are cues (`read-aloud`, `scene-length`, `placeholder`).
- Never delete a line of the GM's own writing; if a remedy would
remove content, ask instead.
Then run vault-wide checks
(`${CLAUDE_PLUGIN_ROOT}/skills/shared/scripts/vault_check.py`):
- `vault_check.py <vault> tables` — fix aliased or escaped pipes in
table links silently (alias-form links, no `\|`), without comment.
- `vault_check.py <vault> timeline` — if the plan spans several days,
offer to build a `## Timeline` hour-by-hour clock with the GM ("This
one runs across three days — want me to lay out a quick clock so
nothing double-books?").
- `vault_check.py <vault> read-aloud` — a `> ` line that names a PC,
dictates a feeling ("you feel…") or uses a 3rd-person pronoun,
checked against every PC in the vault. Raise the real ones as a
question ("Scene 2's boxed text says 'Katherine steps into the
lamplight' — keep it general so it reads to the whole table?").
- **Scene length** — flag bloat (restated theses, repetition,
self-documentation, unusable purple prose) at any length and offer to
trim; not a cap (`skills/ttrpg-expert/scenario-writing.md`).
- **Canon** — NPC details, locations or events not traceable to the
vault are not stated as canon; they go to `## Open Questions`
(`skills/ttrpg-expert/continuity-engine.md`).
Apply fixes in place; there is no audit-notes report.
**16. Gap Check** — as questions or a short actionable list:
- NPCs, locations or entity stubs the planned scenes need but the
vault lacks: run `graph_check.py unresolved` (vault-wide) and filter
its `target <- source` rows to the plan file.
- Stale entity files to update or retire: `vault_check.py stale-drafts`.
- Unresolved calls — plot questions the GM deferred or you couldn't
ground — each with 2–3 seeds, sorted per Stance. "Does Sophia know
what her husband has become?" is a plot question; "Georgiana's
post-Vienna SAN is unrecorded" is an unrecorded sheet value — an
Open Question for the GM, never a guessed number.
→ `## Gaps & Actions` and `## Open Questions`
## Hard Guard — never generate the creative spine
Never emit a settled `## Session Intent`, spotlight or
`## Planned Scenes` without GM input. If pushed to "just do it", or
run headless (e.g. as a sub-agent with no GM):
- Stop and ask if a GM is reachable — intent gates the rest.
- Otherwise write those sections **entirely under `## Open Questions`**,
each line labelled **(apprentice guess — confirm)**. Gather and
Verify may still run.
A headless run must pass the check with `--headless` before handoff. What the GM's request itself settles (scenes it names, an
intent, a spotlight) is GM input: write it in place, park only the
rest, and add `--gm-input` with those parts (`scenes`, `intent`,
`spotlight`; bare `--gm-input` when the GM supplied all three). A sub-agent may gather and draft from the GM's
decisions but never resolves intent, spotlight or scenes.
## Resumable prep
After each decision lands, update a prep-state comment near the top of
the Plan:
```html
<!-- prep-state: intent=set spotlight=Emma(B) scenes=1of3 open=[Freddy beat?] -->
```
On resume, read it first (`plan_check.py <plan> --state` prints the
well-formed tokens, or `# no prep-state marker`) and pick up from the
first open item; the default `plan_check.py <plan>` run reports a
malformed marker as a `prep-state` WARNING.
## Handoff
**17.** In conversation only, not in the Plan, point gaps to:
content (scenes, NPCs, locations) → `ttrpg-expert`; vault structure
(entity files, metadata) → `campaign-organizer`; structural issues
(broken links, schema, graph health) → `campaign-qa`.
Files in this package (2)
- SKILL.md 17 KB
- references/session-templates.md 8 KB
Versions
The database has no other skills named session-prep.
Database snapshot: 13.11.2026 · package version 6ff186083e44 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100session-wrapup
Use when a TTRPG session has just ended and the GM needs to wrap up or process play notes — recaps, entity file updates, timeline events, and what carries forward to the next session. Turns raw play notes into organized canon. Not for session prep (session-prep) or during-play help (session-play). - 100session-play
Use when the GM is actively running a TTRPG session and needs fast help at the table — quick lookups, rules questions, on-the-fly NPCs and content, or capturing play notes. Speed is everything. Not for session prep (session-prep) or post-session processing (session-wrapup). - 100wrapup-session
Close out a coding session. List what is left to do, then persist any lesson worth keeping into agent instructions, skills, memory, or code comments. Use when the user ends a session, asks to wrap up, or runs /bye. - 100wrapup
Force Agent OS capture of the current session now — file durable knowledge into the vault, update the tasks board. Use when the user says "/wrapup", "wrap up", "save this session", or before ending a session whose knowledge must not wait for auto-capture. - 100meeting-prep
Prep for a meeting or debrief one after. Trigger on "prep me for my call with [name]", "prep for a meeting", "prepare for a call", "get me ready for", "meeting notes", "debrief this meeting", "summarize the call", "what should I ask in", or any reference to preparing for or… - 100solo-rpg
A system-agnostic method for running solo tabletop-RPG play with an LLM as Game Master. The transferable craft (the worked example is one system, but the engine fits any): the in-media-res scene-prompt template — the character's lens, a 'last session' recap for instant momentum,…