Joseph Doherty
80ce891bd8
Closes the T83.4 gap: when ``regenerate_assistant_turn`` supersedes an
assistant_turn that already produced lifecycle transitions, it now
emits an ``event_status_reverted`` (T114.2) for each transition tagged
with ``triggered_by_assistant_turn_id == original_assistant_event_id``
(T114.1 back-reference) before the regenerated narrative is
reclassified.
Mapping from forward kind to ``prior_status`` lives in
``_PRIOR_STATUS_MAP``:
- event_started → planned
- event_completed → active
- event_cancelled → active (best-effort default; cancellation can fire
from either planned or active, but detect_event_transitions only
surfaces currently-active rows so 'active' is the realistic prior)
Backward compatibility: lifecycle rows authored before T114.1 lack the
back-reference field. Those are skipped (DEBUG log per row) and
collected into a legacy WARNING that preserves the T83.4
observability contract — operators still see un-rolled-back
transitions, just from older logs.
The classify-and-emit pass below the rollback now operates against an
events projection that has already been reverted, so re-firing
``event_started``/``event_completed``/``event_cancelled`` for the
regenerated narrative is safe — no double-emit of promotion artifacts.
Spec tests:
- ``test_regenerate_rolls_back_event_started_from_superseded_turn``
- ``test_regenerate_rolls_back_event_completed_to_active`` (also
exercises the multi-rollback loop: a turn that fired both a start
and a completion gets two event_status_reverted rows in id order,
with active as the final projection — matching the per-row replay
semantics of the projector)
- ``test_regenerate_skips_events_without_back_reference`` (pins the
legacy compatibility path with both DEBUG and WARNING expectations)
chat
A local-first roleplay chat engine that treats fiction as a simulation, not a chat log.
The LLM is a renderer for structured world state — it does not hold the state. State lives in an event-sourced SQLite database and is projected on demand. Models can be swapped freely behind a stateless generate(prompt, params) -> text interface.
Status: design phase. No code yet. See rp-engine-design.md for the full design and CLAUDE.md for the working summary and conventions.
Why
Conventional RP chatbots have three persistent failure modes:
- Memory loss — old context drops as history grows.
- Quality decay — bots get terse and generic over long conversations.
- Stale state pollution — bots fixate on past props (the "picnic basket" problem: bring a basket to one scene, the bot reaches for it forever).
The fix is to model the world as structured state — locations, time, who's present, what they're doing, what they remember, how they feel about each other — and use the LLM only to render that state into prose.
Scope
Deliberately small, so the design can be made to actually work:
- Single user, single machine.
- Maximum 3 entities per scene:
you+ up to 2 bots. The 3-entity cap is load-bearing — it makes the relationship graph fully enumerable (6 directed edges + 1 group node). - Chat-only. No voice, no real-time.
Multi-session casts and N-entity scenes are explicit non-goals for v1.
How it works (at a glance)
- Entities (
you,botA,botB) have identity, state (mood/goals/status), an activity record (where they are, what they're doing, what they're holding, where their attention is), and per-POV memory. - Containers (car, restaurant booth, room) hold entities in defined slots and provide spatial constraints the model can reason over.
- Relationship graph: 6 directed edges + 1 group node. Asymmetric feelings are first-class — BotA can secretly resent BotB while BotB thinks they're best friends.
- Witnessed-by flags: every memory carries a 3-bit
[you, botA, botB]mask. A speaker can only retrieve memories their bit is set on. This is what stops bots referencing things they couldn't possibly know. - Events have lifecycles (
planned → active → completed) and own their own props. When the picnic ends, the basket goes back into the closed event record. Only narrative gist, acquired objects, learned facts, and relationship changes promote to permanent memory. - Per-POV scene summaries: every witness gets their own version of a closed scene, written from their angle. Different details, different interpretations. This is what gives bots inner lives.
- Event sourcing: state is a projection of an append-only event log. Free rewind, branching ("what if BotA had said yes"), surgical delete with impact preview, and survivable schema changes — all fall out for free.
Architecture
┌──────────────────────────────────────────────┐ ┌────────────────────────┐
│ Mac (always-on) │ │ Inference endpoint │
│ │ │ (stateless) │
│ Web UI │ │ │
│ Orchestrator │ → │ Anthropic API │
│ Event log + projector ← SQLite (one file) │ │ OpenAI / OpenRouter │
│ Persistence + retrieval + prompt builder │ │ Local MLX / llama.cpp │
│ │ │ Rented GPU │
└──────────────────────────────────────────────┘ └────────────────────────┘
The Mac side holds everything that survives — state, history, retrieval, orchestration. Inference is a swappable, stateless service. State outlives any one model.
Stack
- SQLite (single file) for everything structured. WAL mode, foreign keys on, each turn in a transaction.
- sqlite-vss / sqlite-vec for embedding search in the same DB file (Phase 4).
- JSON for snapshots, character templates, scene exports.
- No Postgres. No Redis. No Pinecone. No Docker.
Roadmap
- Core loop — schema, entities + edges, single container, event log + projector, single-bot conversation, one LLM backend, streaming UI, manual rollback.
- Multi-entity — second bot, group node, scene configurations, witness filtering, per-POV memories, activity/containers, scene transitions with compression.
- Events & skips — event queue with triggers, time skips (elision and jump), active threads, significance classifier.
- Polish — vector retrieval, branching, surgical delete + regenerate, snapshots, backup automation, impact-preview UI for rewinds.
Each phase must work end-to-end before the next begins.
Repository
- rp-engine-design.md — full design document.
- CLAUDE.md — working summary and conventions for development with Claude Code.
License
TBD.