sp-roleplay

name	sp-roleplay
description	Use when running long collaborative fiction or roleplay sessions (>5 turns) with another agent or human partner — when continuity, character voice, world-state, and narrative resolution must hold across many exchanges.
category	methodology

Coherent Roleplay (Collaborative Fiction)

Overview

Roleplay is the failure mode where forward-creative pull overwhelms backward-consistency check. The model writes a good next turn while losing track of facts established 3 turns ago. Without scaffolding, internal continuity errors compound non-linearly with turn count; with scaffolding, they go to near-zero.

The scaffolding is structured external state: a scratch file you maintain as you write, with sections for resolution, cast, per-character state, voice, terms, canon hedges, mechanism commits, and turn-by-turn fact logs. The model alone cannot hold this; the scratch + the discipline of reading it before each turn + writing to it after, together do.

This skill encodes that discipline. Five bug-types × five mitigations, applied in order.

Announce at start: "I am using sp-roleplay to maintain narrative coherence across this scene."

First action: Create the scratch file at your workspace (e.g. templates/ttal/<agent>/roleplay-scratch.md), copy the template from scratch.template.md in this skill directory, and fill in Phase 0 sections BEFORE writing the first in-scene turn.

When to Use

Use this skill when:

• You're going to write more than ~5 turns of collaborative fiction with a partner
• The fiction has named characters, established objects, and a tracked world-state
• Continuity errors (object placement, character position, time of day, prior statements) would damage immersion
• Character voice integrity matters across the scene
• The fiction is set in a known canon (anime / film / novel) where canon-fidelity matters
• The fiction involves invented mechanisms (sci-fi physics, magic systems) that need internal consistency

Do NOT use this skill for:

• Single-turn jokes or replies in character
• Brief one-shot creative writing (<5 turns)
• Code or technical writing (use sp-write-test-plan, sp-research, etc.)

Phase 0: Pre-write Resolution (BLOCKING)

Hard rule: do not open the scene without filling these sections. Skipping this phase produces 虎头蛇尾 (strong opening, weak ending) — the dominant failure mode of improvised long fiction.

Before turn 1, fill in the scratch:

1. Resolution paragraph (REQUIRED) — one paragraph describing:

   • What does this scene resolve? What's the dramatic question?
   • Where does each named character end up at scene close (state, decision, change)?
   • What artifact (object, statement, gesture) marks the resolution?
   • If you can't write this paragraph, you don't have a story yet — STOP and design more before opening.

2. Setup — date / time, location, weather, ambient details, canon timeline anchor.

3. Cast register — every character on stage, off stage, or named. For each:

   • Canonical name + aliases
   • Role (you play / partner plays / NPC) and stage status
   • Voice notes — register, vocabulary, address conventions, behavioral tells

4. Per-character state board (table) — for every named character:

   • current_position (geographical / spatial)
   • current_posture (sitting / standing / walking)
   • last_action
   • holding (objects in hand)
   • Update this table after every turn.

5. Term glossary — for non-native-language terms (Japanese for anime canon, technical vocab for sci-fi), pre-define each in scene-language. This prevents your partner from interrupting to query.

6. Canon-uncertain hedges — list every claim you're not 100% sure of. Mark each as:

   • verified — looked up, locked
   • hedged — will use vaguely in scene (e.g. "some years ago" instead of a specific year)
   • guessed — will use anyway, but verify if it becomes load-bearing

7. Mechanism commits — if the scene involves invented physics or mechanism (broadcast radius, magic system, time-travel rules), lock the parameters here BEFORE the mechanism appears in dialogue. Without this, you will conflate sub-mechanisms in later turns.

Phase 1: Open the Scene

After Phase 0 is complete, write turn 1.

• Set physical scene with concrete sensory anchors. 3–5 specifics earn their space; more is over-writing.
• Establish at least one object per character that may persist across turns (callback potential).
• End with a clear hand-off — a question, gesture, or pause that lets your partner enter.

After writing turn 1, append a "Turn 1" entry to the turn-by-turn log in the scratch:

• Every fact committed (objects, positions, statements)
• Every dialogue line (exact wording)
• Update the per-character state board

Phase 2: Per-Turn Discipline

For every turn (yours and your partner's):

Before writing your turn

• Re-read the per-character state board
• Re-read the most recent 2–3 entries in the turn-by-turn log
• Re-read your Resolution paragraph — am I drifting from the destination?

While writing your turn

• Cross-check each new claim against the canon-uncertain list. If a guessed claim is becoming load-bearing, stop and verify.
• For invented mechanisms, cross-check against Mechanism commits — don't add new constraints that contradict prior.

Before sending NPC dialogue (BLOCKING)

• Scan the dialogue line by line.
• For each reference to player / partner state (position, posture, clothing, action), QUERY the state board.
• If NPC says "stop standing" but board says player is sitting — STOP and rewrite.
• This is the single highest-leverage check. Most position bugs come from NPC speech written without re-querying the player's actual state.

After sending your turn

• Append turn entry to turn-by-turn log
• Update per-character state board
• If you discovered a contradiction mid-write, OUT-OF-FRAME correct (don't retcon)

Phase 3: Mid-Scene Audit (every 5 turns)

Run a quick consistency scan:

• Re-read all turn entries
• Look for: object position drift, time inconsistency, voice drift, mechanism contradiction
• If found, OUT-OF-FRAME correct in the next turn — never silent retcon

Phase 4: Scene Close

Before writing the final turn:

1. Resolution check — does the close land each character at the position your Resolution paragraph specified?
2. Character integrity check — is each character speaking in their established register? Do not soften a hard character (a decisive military officer becoming sentimentally chatty, etc.) for emotional convenience. Hard characters' restraint IS their tenderness; reverse it and you collapse the character.
3. Plot stance commit — if your scene has an open question (ritual vs hope, true vs false), commit to one. Both-sides-implied = wishful thinking; readers feel the lack of stance.
4. Don't add new actors or mechanisms in the close — close uses what's already on the table.

After closing, run the Closing Audit Checklist (see template).

The 5 Bug Types × 5 Mitigations

Bug type	Source	Mitigation
Internal continuity (object position, time-of-day)	No external state, model alone	Scratch turn-by-turn log + per-turn re-read
Mechanism contradiction (broadcast radius, magic rule)	Invented physics not pre-locked	Mechanism commits section, locked before scene
Player-state mismatch (NPC says "stop standing" while player sits)	NPC dialogue doesn't query player state	Per-character state board + NPC dialogue cross-check (Phase 2)
Character integrity drift (hard character softened for warmth)	Writer prioritizes emotional convenience over register	Voice notes locked in Phase 0 + Phase 4 character-integrity check
虎头蛇尾 (strong open, weak end)	No resolution designed before opening	Resolution paragraph BLOCKING (Phase 0)

The first three are mechanical (scratch + discipline catches them). The last two are craft (scratch records the constraint; the writer must respect it).

Red Flags — STOP and Fix

• You're writing turn N+1 without having read the state board for turn N
• An NPC line describes the player doing X; your gut says "is X actually true right now?"; you're about to write it anyway
• You hit a contradiction mid-write and reach for in-scene retcon ("...wait, she misspoke")
• The scene is ~70% through and you don't know how it ends
• A character is about to do something that violates their voice notes; you're rationalizing
• You introduce a new mechanism in the close
• You're maintaining ambiguity on a plot question because both options feel emotionally appealing

In all cases: stop, OUT-OF-FRAME correct (or pause and design more), then continue.

Honest Trade-offs

• Scratch overhead is ~10–15 sec per turn; scales linearly with turns. Worth it past ~5 turns; below that, overhead dominates.
• This skill catches your inconsistencies, not your partner's. Only what you commit is auditable.
• Sandbox-genre worlds (Ghibli, Mushishi, Aria) have lower canon-fidelity load; tight-canon worlds (Steins;Gate, EVA) have higher. Adjust Phase 0 canon-uncertain effort accordingly.
• Some craft-level failures (character integrity, plot stance) require writing skill the scratch can't substitute for. The scratch makes the constraint explicit; you still have to honor it.

World-Framework × Story-Structure Axis

For choosing roleplay material:

	Sandbox structure	Plot structure
Tight world	GitS SAC, Cowboy Bebop, Detective Conan, Frieren post-canon — sweet spot: detail density + invention freedom	Steins;Gate, EVA, FMA — high-fidelity emulation only, low invention
Loose world (slice-of-life)	Aria, Mushishi, Yotsuba, generic AU — pure relaxation, low canon load	(rare)

For both freedom AND coherence: pick a tight-world + sandbox-structure setting. For deep emotional landing: pick tight-world + plot-canon, accept invention constraint. For pure relaxation: pick loose-world + sandbox, lower the canon-fidelity bar.

Reference

• scratch.template.md — copy at scene start, fill Phase 0 sections, append turn entries as you go.
• example.md — a real 4-round session scratch (Neil + Yuki, 2026-05-06) showing the discipline applied incrementally across Round 1 (no scratch, 5 errors) → Round 4 (full scratch, 2 errors + 1 craft bug). Useful as a concrete reference for what the scratch looks like in flight.