A repo-review pass turned up a few drift points worth fixing in one
go:

- The 100% coverage claim in CLAUDE.md didn't match pyproject's 95%
gate or the silent cli.py / srd/* omits. Documented the exclusions
honestly and moved the gate into pytest addopts at the current
floor (96%) — bumping the floor as coverage improves is the new
rule.
- No pre-commit was running, so 119 latent ruff issues had piled up.
Cleared them, added PT/RUF, and ignored RUF001-3 since em dashes
are house style.
- Stood up .pre-commit-config.yaml + loq.toml (with a baseline for
the 14 pre-existing oversized files) so future regressions get
caught at commit time.
- Added pyright matching the docket/uncalled-for setup. Strict mode
was 1300+ errors mostly from dict/yaml-heavy code, so settled on
basic + per-file pragmas for the FastMCP DI markers (`world: str
= World()` looks like a type error but FastMCP resolves it at
call time) and the test files where load_character() returns
Optional and tests subscript directly. Real null-narrowing gaps
in display.py / planner.py / cli.py / srd/extract.py are fixed.
- Refactored test_execute_tool.py to lift the asyncio + Client +
combat-flip scaffolding into mcp_call / mcp_call_in_combat
fixtures, deleting four inline async _run blocks with try/finally
cleanup. The for i in range(3) loop became a fixture too.
- Added pytest-xdist (-n 4) and codespell (with the SRD content
skipped — codespell really doesn't like Wight, Sting, or Cant).
- Renamed prompts/cold-draft.md → arc-cold-draft.md so it sorts
next to its sibling arc-architect.md (they're a two-stage pipeline
for the planner's plot_arc pass).
- Deleted plans/architecture-implementation.md (Milestone 0–4 doc
from before any code existed; predates the streaming-CLI pivot
away from Textual).

CLI thinning into src/storied/commands/* and the actual climb from
96% → 100% coverage are deferred — both are their own focused
workstreams.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Even after the anti-rut arc work, every campaign was still drifting
toward the same handful of fantasy names — Aldric Voss, Mira, Vera
Blackwater, Tilde Barren — because Claude has hot-path defaults for
naming that don't really respond to context. This adds a phonotactic
name generator and wires the seeder, planner, and DM to use it for
every named entity instead of typing names directly.

The new module (src/storied/names/) is self-contained and designed
to be lifted out into a standalone package later — there's an
AGENTS.md plus an AST-scan test that fails the build if anything in
storied.names imports from elsewhere in storied. README.md inside
the module covers attribution and design history; the architecture
owes a substantial debt to William Annis's Lexifer, the conlang
community's (C)V(C) template tradition, and standard phonological
machinery (sonority sequencing, Zipfian/Gusein-Zade frequency).

Cultures are forged per-campaign, not pre-built. The forge picks a
random hand-encoded inventory inspired by a real language family
(Welsh, Old Norse, Quechuan, etc. — about 25 of them), trims and
re-weights it, picks syllable templates and morphology pools, then
runs the assembled engine to generate the culture's *own* self-name
as its first emission. That self-name becomes the file id and the
canonical reference. Each campaign gets its own 4-8 cultures during
seeding and they never collide across campaigns.

Cultures are first-class world entities — they live alongside npcs
and locations, get indexed into the search.db with content_type=
cultures, and are discoverable via the existing recall tool. The
phonotactic profile lives next to the entity as a sibling YAML file
the engine reads when generating names.

Two MCP tools wired through tools/names.py: forge_culture and
generate_names, both visible to dm/seeder/planner. The arc_architect
intentionally doesn't get them — its surface stays at commit_arc +
recall. The seeder prompt now requires generate_names for every
named entity ("never type a fantasy name yourself"), and the DM and
planner prompts cover the same rule for new entities created during
play or enrichment.

PHOIBLE is the obvious next data source if we want richer or more
authentic inventories — flagged as the v0.2 plan in the README, not
part of v0.1. The current 25 hand-encoded inventories are tuned by
ear for fantasy output and they work; we can swap in real PHOIBLE
data once we've watched the generator in actual play.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

The DM prompt has been showing "[Day 1, 06:30]" forever even though the
log on disk was clearly advancing through the afternoon. Tracked it
down to start_mcp_server: every caller (engine, seed_world, plot_arc,
the background advancement evaluator, the tick_world ticker) was
constructing its own CampaignLog / EntityIndex / VectorIndex and
calling init_ctx, which clobbered the global _ctx each time. After the
advancement evaluator first fired (around turn 5), set_scene was
mutating the evaluator's stale CampaignLog while the engine's display
kept reading its own original instance — frozen at whatever time it
was when the swap happened. Same hazard applied to the entity_index
cache and the initiative tracker; we just hadn't noticed yet.

Storied only ever serves one campaign at a time, so the honest fix is
to make the singleton actually a singleton. Add get_or_create_ctx as
the production entry point: first caller wins, subsequent callers get
the same instance back, mismatched world_id/player_id raises rather
than silently rebinding. start_mcp_server, the engine, planner,
advancement, and the ticker all stop building their own slices and
read from the shared ctx. The engine pulls _campaign_log straight off
the handle so display reads can't drift from tool mutations.

init_ctx survives as the test-only override the conftest fixture
already uses (paired with reset_ctx for teardown).

With the slices truly shared across the engine thread and the various
MCP uvicorn worker threads, the previously-implicit "only one writer
at a time" assumption no longer holds. Add per-instance RLocks to:

- CampaignLog.append_entry (read-modify-write on current_time and
the day-file save), plus format_for_context / get_recent_entries /
get_all_entries / time_since_rest so list iteration can't see a
half-mutated current_entries.
- VectorIndex around the shared sqlite connection — check_same_thread
is already off, but concurrent execute calls from different MCP
threads can still race on commit boundaries.
- InitiativeTracker around every public mutator and format_for_context.

EntityIndex stays unlocked: it's pure dict get/set with no
read-modify-write, so the GIL is enough.

Two test_engine.py fixtures had a hand-rolled fake Ctx that was
missing campaign_log; added it.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

After two campaigns the model kept reaching for the same skeleton no
matter what the player asked for in style.md — small water-adjacent
town, hereditary wardens, sleeping cosmic prisoner under ancient
stonework. claude -p doesn't expose temperature, so the fix has to be
prompt-shaped.

Add a new arc_architect MCP role with a deliberately tiny tool surface
(commit_arc + recall) that runs before the seeder during cold start.
The architect makes two passes: first a cold-draft call with no
novelty injection at all, capturing the model's actual default for
this character + style as text. Then a second call where that cold
draft is the negative example, alongside a handful of random concepts
pulled from procedural pools (industrial materials, kitchen objects,
historical occupations, weather, anatomical, mundane-with-a-wrong-note,
numerical, linguistic) and a drawn hand of Oblique Strategies cards.
The architect critiques and commits a loose arc.md — commitments and
"off the table" list, not an outline.

The seeder then reads arc.md and gets its own draw of concepts +
obliques. The planner gets obliques only as soft thinking-moves —
forcing random material into existing entities would distort what's
already there. The ticker stays as small-motion only.

The DM loads arc.md alongside style.md every turn. seed_world,
plan_world, and tick_world all run at effort=max now too.

Approach was prompted by noticing aldenmere and the new default world
were rhyming hard despite very different style.md inputs. The
cold-draft trick was Chris's idea — much sharper than asking me to
write trope blocklists, since the model itself is the most accurate
diagnostic for its own defaults.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Paths used to be threaded through every function as base_path kwargs,
defaulting to cwd — a holdover from when storied ran out of the repo
root. That pattern stopped making sense once worlds/ and players/
moved to ~/.storied/, and it meant a forgotten kwarg in a test would
silently write to the user's real home dir.

Centralize all filesystem roots in storied.paths as module globals,
configured once at CLI startup via configure(). Everything downstream
reads through getters (world_path, player_path, etc.). Drop base_path
from every library function, class, and tool wrapper; delete the
StorageRoot() dep and the base_path field on ToolContext.

While the paths layer was already in pieces, add a third content layer
for personal homebrew at ~/.storied/rules/. Priority is
world > user > shipped — a campaign override beats your homebrew which
beats the stock SRD. The vector index tags rows by source (srd/user/
world) and recall(scope="rules") now covers all three, so dropping a
spell into ~/.storied/rules/spells/ shows up across every campaign
after a `storied index rebuild`.

Test isolation is now an autouse fixture that points paths at tmp_path
for every function, with STORIED_HOME belt-and-suspenders for any
subprocess that re-enters storied. The sandbox mode keeps user homebrew
accessible — only worlds/players move to the tempdir.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>