holonovel 2026.8.22

package/dist/index.js

@@ -0,0 +1,4051 @@
+#!/usr/bin/env node
+// Inform MCP Server — Ruleset-Free Holonovel Build
+// REQ-001, REQ-020, REQ-022, REQ-023, REQ-195 through REQ-202, REQ-218, REQ-219
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+import { expandMacros } from "./core/macros.js";
+import { StateManager, DIFFICULTY_TRACKS, migrateNovelData, normalizeAutonomy } from "./core/state.js";
+import { initServer, getBadge, requireGM, requirePlayer, requireNotObserver, requireNovel, novelSnapshot, } from "./core/server.js";
+import { DEFAULT_ENRICHMENT } from "./core/enrichment.js";
+import { ROOM_DIRECTIONS, createEmptyWorldModel, convertSource, worldMap, worldKinds, oppositeDirection, } from "./world/model.js";
+import { dispatchCommand, resolveGoMovement } from "./world/parser.js";
+import { RulesetManager, HOST_VERSION, rollDice, } from "./rulesets.js";
+import { generateAbilityScores, getClassData, abilityNames, computeDerived, startingEquipmentFor, creationSteps, creationStepPrompt, applySpeciesAdjustments, } from "./core/character-creation.js";
+import { createRng, sessionRoll } from "./core/rng.js";
+// ── Constants ──────────────────────────────────────────────────────
+const __filename = new URL(import.meta.url).pathname;
+const __dirname = path.dirname(__filename);
+const DATA_DIR = process.env.TTRPG_DATA_DIR ?? path.join(__dirname, "..", ".holonovel-state");
+function computeSpecHash() {
+    try {
+        const specPath = path.join(__dirname, "holonovel.md");
+        if (!fs.existsSync(specPath))
+            return "unknown";
+        return crypto.createHash("sha256").update(fs.readFileSync(specPath)).digest("hex");
+    }
+    catch {
+        return "unknown";
+    }
+}
+const SPEC_HASH = computeSpecHash();
+const RULESET_DIR = process.env.TTRPG_RULESET_DIRS ?? path.join(DATA_DIR, "rulesets");
+// ── State ──────────────────────────────────────────────────────────
+const state = new StateManager(DATA_DIR);
+state.loadRoster();
+state.loadServerNotes();
+state.buildFingerprint.specHash = SPEC_HASH;
+state.buildFingerprint.lastSpecReview = new Date().toISOString();
+// ── Server ─────────────────────────────────────────────────────────
+const server = new McpServer({
+    name: "inform-holonovel",
+    version: "2026.08.22",
+});
+// ── Helpers ────────────────────────────────────────────────────────
+// Badge gating and snapshot helpers provided by core/server.ts
+initServer(state);
+// ── Performance / token-efficiency contracts (REQ-408, REQ-409, REQ-410, REQ-411) ──
+// REQ-408 — tool parameter ceiling, recorded at build time. The reference host
+// computes the ceiling from its own registrations rather than hardcoding a
+// blind cap: the ceiling is the maximum parameter count any single tool exposes.
+const PARAMETER_CEILING = 8;
+function registrationFingerprint() {
+    const tools = server._registeredTools ?? {};
+    const prompts = server._registeredPrompts ?? {};
+    return crypto.createHash("sha1")
+        .update([...Object.keys(tools)].sort().join(","))
+        .update("|")
+        .update([...Object.keys(prompts)].sort().join(","))
+        .digest("hex");
+}
+let metadataCache = null;
+let cacheHits = 0;
+let cacheMisses = 0;
+function computeToolMetrics() {
+    const tools = server._registeredTools ?? {};
+    let bytes = 0;
+    const counts = {};
+    for (const [name, tool] of Object.entries(tools)) {
+        const desc = (tool?.description ?? "");
+        const schema = tool?.inputSchema;
+        const shape = (schema && schema.shape) ? Object.keys(schema.shape) : [];
+        counts[name] = shape.length;
+        bytes += Buffer.byteLength(desc, "utf-8") + 64; // name overhead + description
+        for (const key of shape)
+            bytes += Buffer.byteLength(key, "utf-8") + 16;
+    }
+    return { bytes, counts };
+}
+function promptScaffoldBytes() {
+    const prompts = server._registeredPrompts ? Object.values(server._registeredPrompts) : [];
+    return prompts.reduce((n, p) => n + Buffer.byteLength(p?.description ?? "", "utf-8") + Buffer.byteLength(p?.name ?? "", "utf-8") + 32, 0);
+}
+// Return cached metadata when registrations are unchanged; recompute otherwise.
+function cachedMetadata() {
+    const fp = registrationFingerprint();
+    if (metadataCache && metadataCache.fingerprint === fp) {
+        cacheHits++;
+        return metadataCache;
+    }
+    cacheMisses++;
+    const { bytes, counts } = computeToolMetrics();
+    metadataCache = {
+        fingerprint: fp,
+        toolsListBytes: bytes,
+        toolParameterCounts: counts,
+        promptBytes: promptScaffoldBytes(),
+    };
+    return metadataCache;
+}
+// Prime the cache once at startup so the first tools/list read is warm.
+cachedMetadata();
+// REQ-409 — enumeration verbosity, session-scoped. Lean (summary) is the
+// default; a per-call `detail: true` requests full entries for a single call.
+let enumerationVerbosity = "summary";
+// REQ-409 — normalize the per-call detail request: absent → summary (lean
+// default); explicit `true` → full entries; explicit `false` → summary.
+const detailZod = { detail: z.boolean().optional() };
+function wantsDetail(detail) {
+    return detail === true;
+}
+// ── Ruleset packages (REQ-389, REQ-390, REQ-379) ───────────────────
+const rulesets = new RulesetManager(RULESET_DIR, HOST_VERSION);
+const scanErrors = rulesets.scan();
+const eagerSlugs = (process.env.TTRPG_RULESETS ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+for (const slug of eagerSlugs) {
+    if (rulesets.isInstalled(slug)) {
+        try {
+            rulesets.hydrate(slug);
+        }
+        catch { /* hydration failures surfaced at call time */ }
+    }
+}
+// Convert a JSON-Schema-style inputSchema (as shipped by a package's tools.json)
+// into a Zod raw shape registerTool accepts (REQ-389 — schemas-as-data).
+function jsonSchemaToZod(schema) {
+    if (!schema || typeof schema !== "object")
+        return z.any();
+    const t = schema.type;
+    if (t === "string") {
+        if (Array.isArray(schema.enum))
+            return z.enum(schema.enum);
+        return z.string();
+    }
+    if (t === "number" || t === "integer")
+        return z.number();
+    if (t === "boolean")
+        return z.boolean();
+    if (t === "array")
+        return z.array(jsonSchemaToZod(schema.items ?? {}));
+    if (t === "object") {
+        const shape = {};
+        const requiredSet = new Set(Array.isArray(schema.required) ? schema.required : []);
+        for (const [k, v] of Object.entries(schema.properties ?? {})) {
+            let zs = jsonSchemaToZod(v);
+            if (requiredSet.has(k)) {
+                if (zs && typeof zs === "object" && zs._def?.typeName === "ZodOptional") {
+                    zs = zs.unwrap();
+                }
+            }
+            else if (!zs || typeof zs !== "object" || zs._def?.typeName !== "ZodOptional") {
+                zs = zs.optional();
+            }
+            shape[k] = zs;
+        }
+        return z.object(shape);
+    }
+    if (schema.anyOf) {
+        const nonNull = schema.anyOf.filter((s) => s?.type !== "null");
+        if (nonNull.length === 1)
+            return jsonSchemaToZod(nonNull[0]).optional();
+        return z.any();
+    }
+    return z.any();
+}
+// Generic ruleset tool handlers. Tools are expressed as data (REQ-389); the
+// host dispatches on the tool's `kind` so a package's tools serve without the
+// host re-parsing source Markdown.
+function gatedRulesetTool(slug, schema) {
+    return async (args) => {
+        if (!rulesets.isInstalled(slug)) {
+            return err("STATE_CONFLICT", `Ruleset '${slug}' is not installed.`);
+        }
+        if (!rulesets.isHydrated(slug)) {
+            return err("STATE_CONFLICT", `Ruleset '${slug}' is installed but not activated. Open a campaign bound to '${slug}', or set TTRPG_RULESETS=${slug} for eager hydration.`);
+        }
+        const pkg = rulesets.hydrate(slug);
+        switch (schema.kind) {
+            case "lookup": {
+                const collection = schema.collection ?? "concepts";
+                const key = String(args.key ?? args.name ?? "").toLowerCase();
+                const coll = (pkg.model[collection] ?? {});
+                if (coll && key in coll) {
+                    return raw(JSON.stringify(coll[key], null, 2));
+                }
+                const hits = rulesets.search(slug, key || args.key || "", 5);
+                if (hits.length === 0)
+                    return err("NOT_FOUND", `No '${args.key}' found in ${collection}.`);
+                return raw(JSON.stringify(hits, null, 2));
+            }
+            case "search": {
+                const q = String(args.query ?? "");
+                const hits = rulesets.search(slug, q, args.max_results ?? 10);
+                if (hits.length === 0)
+                    return err("NOT_FOUND", `No ruleset entry matches '${q}'.`);
+                return raw(JSON.stringify(hits, null, 2));
+            }
+            case "roll": {
+                try {
+                    const notation = String(args.dice ?? args.notation ?? "1d20");
+                    const label = args.skill ? `${args.skill} check` : (args.notation ?? args.dice ?? "1d20");
+                    let r = rollDice(notation, args.seed);
+                    const extra = Number(args.modifier ?? 0);
+                    if (extra !== 0) {
+                        r = { total: r.total + extra, dice: r.dice, modifier: r.modifier + extra, notation: r.notation };
+                    }
+                    const parts = [`${label} (${r.notation}${extra !== 0 ? ` ${extra > 0 ? "+" : "-"} ${Math.abs(extra)}` : ""})`];
+                    parts.push(`**${r.total}**`);
+                    if (r.dice.length > 1)
+                        parts.push(`(${r.dice.join(" + ")})`);
+                    return ok(parts.join(" → "));
+                }
+                catch (e) {
+                    return err("INVALID_INPUT", e.message);
+                }
+            }
+            case "table": {
+                const collection = schema.collection ?? "tables";
+                const tables = (pkg.model[collection] ?? {});
+                const name = String(args.table ?? args.name ?? "");
+                const table = name ? tables[name] ?? tables[name.toLowerCase()] : undefined;
+                if (!table)
+                    return err("NOT_FOUND", `No table '${name}' found.`);
+                if (Array.isArray(table)) {
+                    const rng = args.seed ? createRng(args.seed) : null;
+                    const idx = rng ? rng.roll(table.length) - 1 : sessionRoll(table.length) - 1;
+                    const row = table[Math.max(0, Math.min(idx, table.length - 1))];
+                    return raw(JSON.stringify(row, null, 2));
+                }
+                return raw(JSON.stringify(table, null, 2));
+            }
+            case "info":
+                return raw(String(schema.description ?? ""));
+            default:
+                return err("UNIMPLEMENTED", `Ruleset tool kind '${schema.kind}' is not supported by this host.`);
+        }
+    };
+}
+// Register ruleset-prefixed tools for every installed package (REQ-379).
+for (const slug of rulesets.installedSlugs()) {
+    for (const schema of rulesets.toolSchemas(slug)) {
+        const toolName = `${slug}_${schema.name}`;
+        try {
+            server.registerTool(toolName, {
+                title: schema.title ?? schema.name,
+                description: `${schema.description ?? ""} (ruleset: ${slug})`,
+                inputSchema: jsonSchemaToZod(schema.inputSchema),
+            }, gatedRulesetTool(slug, schema));
+        }
+        catch (e) {
+            // Tool name already registered or schema unrecoverable — skip.
+        }
+    }
+}
+function audit(tool, args, prefix) {
+    const novel = state.activeNovel;
+    if (novel)
+        state.audit(novel, getBadge(), tool, args, prefix);
+}
+function getActiveEntity() {
+    return state.getActiveEntity();
+}
+function resolveEntity(id) {
+    return state.resolveEntity(id);
+}
+function ok(text) {
+    return { content: [{ type: "text", text: `[OK] ${expandMacros(text, buildMacroContext())}` }] };
+}
+const CORRECTIVE_ACTIONS = {
+    NOT_FOUND: "Check the name or id for typos, or list valid values with help.",
+    INVALID_INPUT: "Supply a valid value for every required parameter.",
+    STATE_CONFLICT: "Resolve the conflicting state before retrying.",
+    FORBIDDEN: "Switch badges with set_badge to gain access, or use a permitted tool.",
+    RULE_VIOLATION: "Choose an action the rules permit.",
+    AMBIGUOUS: "Disambiguate by supplying the full name.",
+    UNIMPLEMENTED: "This operation is not supported by the current ruleset host.",
+};
+function err(code, msg, correctiveAction) {
+    const expanded = expandMacros(msg, buildMacroContext());
+    const action = correctiveAction ?? CORRECTIVE_ACTIONS[code];
+    const text = action ? `[ERROR] [${code}] ${expanded}\nCorrective action: ${action}` : `[ERROR] [${code}] ${expanded}`;
+    return { content: [{ type: "text", text }] };
+}
+function raw(text) {
+    return { content: [{ type: "text", text: expandMacros(text, buildMacroContext()) }] };
+}
+function warn(text) {
+    return { content: [{ type: "text", text: `[WARNING] ${expandMacros(text, buildMacroContext())}` }] };
+}
+function needInput(text) {
+    return { content: [{ type: "text", text: `[NEED_INPUT] ${expandMacros(text, buildMacroContext())}` }] };
+}
+function buildMacroContext() {
+    const novel = state.activeNovel;
+    const entity = state.getActiveEntity();
+    const countdowns = {};
+    if (novel) {
+        for (const [name, cd] of novel.countdowns) {
+            countdowns[name] = { remaining: cd.ticks, total: cd.total, scope: cd.scope, direction: cd.direction };
+        }
+    }
+    return {
+        entityName: entity?.name,
+        sceneCurrent: novel?.scene_description,
+        sceneLocation: novel?.scene_location,
+        sceneTimeOfDay: novel?.scene_time_of_day,
+        sceneAtmosphere: novel?.scene_atmosphere,
+        sceneType: novel?.scene_type?.join(", "),
+        countdowns,
+        novelSlug: novel?.slug,
+        badgeActive: novel?.badge ?? undefined,
+        partySize: novel ? novel.entities.size : undefined,
+        currentRoom: entity?.current_room ?? undefined,
+        worldRoomCount: novel ? novel.world.rooms.size : undefined,
+        worldThingCount: novel ? novel.world.things.size : undefined,
+    };
+}
+function worldSnapshot() {
+    novelSnapshot();
+}
+// ── Help Categories ─────────────────────────────────────────────────
+const BUILDER_CATEGORIES = {
+    "Badge & Workflow": ["set_badge", "respond", "undo", "redo", "help"],
+    "Characters": ["create_character", "import_character", "stage_character", "character_sheet", "set_active_entity", "set_personality", "set_voice_examples", "player_signal", "remove_entity", "list_roster_characters", "remove_roster_character"],
+    "World Model": ["command", "resolve_intent", "create_room", "remove_room", "create_thing", "remove_thing", "create_exit", "remove_exit", "convert_source"],
+    "Lookups": ["search_rules", "suggest_actions", "spec_health"],
+    "Combat (GM)": ["init_combat", "advance_combat", "end_combat", "add_combat_participant", "remove_combat_participant"],
+    "Conditions (GM)": ["apply_condition", "remove_condition"],
+    "Narrative (GM)": ["set_scene_state", "set_scene_type", "set_narrative_directive"],
+    "NPCs (GM)": ["create_npc", "update_npc", "remove_npc"],
+    "Factions (GM)": ["create_faction", "update_faction", "remove_faction"],
+    "Secrets (GM)": ["set_secret", "reveal_secret", "get_knowledge"],
+    "Relationships (GM)": ["set_relationship", "get_relationships"],
+    "Vows (GM)": ["set_vow", "mark_milestone", "resolve_vow", "forsake_vow"],
+    "Countdowns (GM)": ["set_countdown", "advance_countdown", "remove_countdown"],
+    "Lore (GM)": ["set_lore_entry", "update_lore_entry", "remove_lore_entry", "toggle_lore_entry", "set_lore_group", "suggest_lore", "export_lorebook", "import_lorebook"],
+    "Story Journal (GM)": ["record_story", "update_story", "remove_story", "list_stories"],
+    "Notes": ["set_note", "remove_note", "list_notes"],
+    "Server Notes (GM)": ["set_server_note", "remove_server_note", "list_server_notes"],
+    "Pause/Resume (GM)": ["set_pause_context", "get_pause_context"],
+    "Checkpoints (GM)": ["set_checkpoint", "list_checkpoints", "restore_checkpoint", "remove_checkpoint"],
+    "Guidance (GM)": ["set_briefing_order", "compact_audit_log", "load_adventure", "generate_adventure", "generate_encounter", "set_help_category", "toggle_action_patterns", "present_choices"],
+    "Autonomy (GM)": ["set_autonomy"],
+    "Oracle": ["ask_oracle"],
+    "Session": ["session_recap"],
+    "Novel Lifecycle": ["create_novel", "resume_novel", "switch_novel", "end_novel", "export_novel", "import_novel", "rename_novel", "list_novels", "novel_info", "clone_novel"],
+    "Synthesis (GM)": ["revert_synthesis"],
+};
+const GMToolsSet = new Set([
+    "init_combat", "advance_combat", "end_combat", "add_combat_participant", "remove_combat_participant",
+    "set_scene_state", "set_scene_type", "set_narrative_directive",
+    "create_npc", "update_npc", "remove_npc",
+    "set_countdown", "advance_countdown", "remove_countdown",
+    "set_lore_entry", "update_lore_entry", "remove_lore_entry", "toggle_lore_entry", "set_lore_group",
+    "suggest_lore", "export_lorebook", "import_lorebook",
+    "set_briefing_order", "compact_audit_log", "load_adventure", "generate_adventure", "generate_encounter",
+    "set_help_category", "export_novel", "import_novel", "revert_synthesis",
+    "create_room", "remove_room", "create_thing", "remove_thing", "create_exit", "remove_exit", "convert_source",
+    "apply_condition", "remove_condition",
+    "create_faction", "update_faction", "remove_faction",
+    "set_secret", "reveal_secret", "get_knowledge",
+    "set_relationship", "get_relationships",
+    "set_vow", "mark_milestone", "resolve_vow", "forsake_vow",
+    "set_checkpoint", "list_checkpoints", "restore_checkpoint", "remove_checkpoint",
+    "set_server_note", "remove_server_note", "list_server_notes",
+    "set_pause_context", "get_pause_context",
+    "record_story", "update_story", "remove_story", "list_stories",
+    "present_choices", "toggle_action_patterns",
+    "set_autonomy",
+    "rename_novel", "list_novels", "novel_info", "clone_novel",
+    "remove_entity", "remove_roster_character", "list_roster_characters",
+]);
+function isGMTool(name) {
+    return GMToolsSet.has(name);
+}
+function buildExampleInvocation(name, schema) {
+    if (!schema || typeof schema !== "object")
+        return `${name}()`;
+    const shape = schema._def?.typeName === "ZodObject" ? schema._def.shape() : schema;
+    if (!shape)
+        return `${name}()`;
+    const entries = Object.entries(shape);
+    const required = entries.filter(([, v]) => !v.isOptional?.() && !v._def?.typeName?.startsWith("ZodOptional"));
+    if (required.length === 0 && entries.length > 0) {
+        const [key] = entries[0];
+        return `${name}({ ${key}: ${illustrate(key, entries[0][1])} })`;
+    }
+    if (required.length === 0)
+        return `${name}()`;
+    const args = required.map(([k, v]) => `${k}: ${illustrate(k, v)}`).join(", ");
+    return `${name}({ ${args} })`;
+}
+function illustrate(key, schema) {
+    const typeName = schema._def?.typeName ?? "";
+    if (typeName === "ZodString")
+        return key === "name" ? '"example"' : `"<${key}>"`;
+    if (typeName === "ZodNumber")
+        return "1";
+    if (typeName === "ZodBoolean")
+        return "true";
+    if (typeName === "ZodEnum") {
+        const values = schema._def?.values ?? [];
+        if (values.length > 0)
+            return `"${values[0]}"`;
+        return `"<${key}>"`;
+    }
+    if (typeName === "ZodArray")
+        return "[]";
+    return `"<${key}>"`;
+}
+function fmtEntitySheet(entity) {
+    const p = entity.personality ?? {};
+    let sheet = `## ${entity.name}\n`;
+    if (entity.inventory?.length > 0) {
+        sheet += `**Inventory:** ${entity.inventory.join(", ")}\n`;
+    }
+    if (entity.current_room) {
+        sheet += `**Location:** ${entity.current_room}\n`;
+    }
+    if (entity.stats) {
+        sheet += `\n### Mechanical Stats\n${fmtStats(entity.stats)}\n`;
+    }
+    if (p.description || p.voice || p.background || p.goals) {
+        sheet += `\n### Personality\n`;
+        if (p.description)
+            sheet += `**Description:** ${p.description}\n`;
+        if (p.voice)
+            sheet += `**Voice:** ${p.voice}\n`;
+        if (p.background)
+            sheet += `**Background:** ${p.background}\n`;
+        if (p.goals)
+            sheet += `**Goals:** ${p.goals}\n`;
+    }
+    if (!entity.stats) {
+        sheet += `\n_World-model only — no mechanical stats._`;
+    }
+    return sheet;
+}
+function fmtStats(stats) {
+    const lines = [];
+    if (stats.class)
+        lines.push(`**Class:** ${stats.class}`);
+    if (stats.level != null)
+        lines.push(`**Level:** ${stats.level}`);
+    if (stats.species)
+        lines.push(`**Species:** ${stats.species}`);
+    if (stats.abilityScores) {
+        const ab = stats.abilityScores;
+        const mod = (s) => (Math.floor((s - 10) / 2) >= 0 ? `+${Math.floor((s - 10) / 2)}` : `${Math.floor((s - 10) / 2)}`);
+        const entries = Object.keys(ab).map((k) => `${k} ${ab[k]} (${mod(ab[k])})`);
+        lines.push(`**Abilities:** ${entries.join(" · ")}`);
+    }
+    // Ruleset-declared derived statistics, rendered generically under their
+    // declared labels (REQ-181a). Falls back to legacy field names when a
+    // pre-refactor entity carries legacy hard-coded stats.
+    const derivedLabels = stats._derived_labels?.labels ?? {};
+    const derivedOrder = stats._derived_labels?.order ?? [];
+    const rendered = new Set();
+    for (const key of derivedOrder) {
+        const label = derivedLabels[key] ?? key;
+        if (stats[label] == null)
+            continue;
+        rendered.add(label);
+        lines.push(`**${label}:** ${stats[label]}`);
+    }
+    for (const [k, v] of Object.entries(stats)) {
+        if (k.startsWith("_") || ["class", "level", "species", "abilityScores", "statMethod", "trainedSkills", "feats", "talents", "equipment"].includes(k))
+            continue;
+        if (typeof v !== "number")
+            continue;
+        if (rendered.has(k))
+            continue;
+        lines.push(`**${k}:** ${v}`);
+    }
+    if (stats.trainedSkills?.length)
+        lines.push(`**Trained Skills:** ${stats.trainedSkills.join(", ")}`);
+    if (stats.feats?.length)
+        lines.push(`**Feats:** ${stats.feats.join(", ")}`);
+    if (stats.talents?.length)
+        lines.push(`**Talents:** ${stats.talents.join(", ")}`);
+    if (stats.equipment?.length) {
+        const eq = stats.equipment.map((e) => (typeof e === "string" ? e : `${e.name}${e.quantity && e.quantity !== 1 ? ` ×${e.quantity}` : ""}`)).join(", ");
+        lines.push(`**Equipment:** ${eq}`);
+    }
+    return lines.join("\n");
+}
+function formatNpcSheet(npc) {
+    let s = `## ${npc.name}\n`;
+    if (npc.description)
+        s += `*${npc.description}*\n`;
+    if (npc.disposition)
+        s += `**Disposition:** ${npc.disposition}\n`;
+    if (npc.location)
+        s += `**Location:** ${npc.location}\n`;
+    return s;
+}
+// ── Tools ──────────────────────────────────────────────────────────
+// --- Badge & Workflow ---
+function badgeLabel(badge) {
+    if (badge === "none")
+        return "Editor";
+    return badge;
+}
+server.registerTool("set_badge", {
+    title: "Set Active Badge",
+    description: "Switch active badge: player, game_master, observer, or none (Editor). Always callable.",
+    inputSchema: { badge: z.enum(["player", "game_master", "observer", "none"]) },
+}, async ({ badge }) => {
+    const novel = state.activeNovel;
+    if (novel) {
+        if (novel.pending_workflow) {
+            return err("STATE_CONFLICT", "A workflow decision is pending. Resolve it with respond before switching badges.");
+        }
+        novel.badge = badge;
+        state.saveNovel(novel);
+    }
+    if (badge === "none")
+        return ok("Active badge: Editor — full access");
+    if (badge === "observer")
+        return ok("Active badge: observer — read-only spectator mode");
+    return ok(`Active badge: ${badge}`);
+});
+server.registerTool("respond", {
+    title: "Respond to Workflow Decision",
+    description: "Respond to a pending workflow decision.",
+    inputSchema: { decision: z.string(), option: z.string() },
+}, async ({ decision, option }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    if (option === "cancel") {
+        novel.pending_workflow = null;
+        state.saveNovel(novel);
+        return ok("Workflow cancelled.");
+    }
+    if (decision.toLowerCase().includes("end novel") || decision.toLowerCase().includes("end_novel")) {
+        const slug = state.activeNovel.slug;
+        const result = state.endNovel(novel, option);
+        if (result.removed)
+            return ok(`Novel '${slug}' ended.`);
+        return ok("End novel cancelled.");
+    }
+    if (decision.toLowerCase().includes("present_choices")) {
+        novel.pending_workflow = null;
+        state.saveNovel(novel);
+        return ok(`Choice '${option}' selected.`);
+    }
+    if (decision.toLowerCase().startsWith("safety_escalation:")) {
+        const target = decision.slice("safety_escalation:".length);
+        const auto = novel.autonomy;
+        if (option.toLowerCase() === "decline" || option.toLowerCase() === "cancel") {
+            novel.pending_workflow = null;
+            state.saveNovel(novel);
+            return ok(`Safety escalation declined — tier remains ${auto.safety}.`);
+        }
+        if (option.toLowerCase() !== "confirm") {
+            return err("INVALID_INPUT", "Respond 'confirm' to raise the safety tier, or 'decline' to keep the current tier.");
+        }
+        auto.safety = target;
+        if (!auto.confirmed_safety_tiers.includes(target))
+            auto.confirmed_safety_tiers.push(target);
+        novel.pending_workflow = null;
+        state.saveNovel(novel);
+        audit("set_autonomy", { safety: target, confirmed: true });
+        return ok(`Safety tier raised to '${target}'.`);
+    }
+    if (decision.toLowerCase().includes("character_creation")) {
+        const pw = novel.pending_workflow;
+        if (!pw || !("creation" in pw) || !pw.creation)
+            return err("STATE_CONFLICT", "No character-creation workflow in progress.");
+        const wf = pw.creation;
+        const steps = creationSteps(wf.rules ?? undefined);
+        const step = steps[wf.stepIndex] ?? "name";
+        const ans = String(option).trim();
+        switch (step) {
+            case "name":
+                wf.answers.name = ans;
+                break;
+            case "species":
+                wf.answers.species = ans;
+                break;
+            case "classes":
+                wf.answers.classLevels = parseClassLevels(ans);
+                break;
+            case "ability_scores": {
+                wf.answers.statMethod = "planned";
+                wf.answers.abilityScores = parseAbilityScores(ans, wf.rules ?? undefined);
+                break;
+            }
+            case "skills":
+                wf.answers.trainedSkills = ans.split(/[\s,]+/).filter(Boolean);
+                break;
+            case "equipment":
+                wf.answers.equipment = ans.split(/[\s,]+/).filter(Boolean);
+                break;
+        }
+        wf.stepIndex++;
+        if (wf.stepIndex < steps.length) {
+            novel.pending_workflow = { decision: "character_creation", snapshot: null, creation: wf };
+            state.saveNovel(novel);
+            return needInput(creationStepPrompt(wf));
+        }
+        novel.pending_workflow = null;
+        const rules = wf.rules;
+        if (!rules) {
+            // Ruleset-free workflow completed — profile-only entity.
+            const name = wf.answers.name ?? "Unnamed";
+            const species = wf.answers.species;
+            const entity = state.createEntity(name, undefined, species ? { species } : undefined);
+            state.addEntity(novel, entity);
+            state.saveNovel(novel);
+            return ok(`${fmtEntitySheet(entity)}
+
+Character '${name}' created as ${entity.id} (profile-only — no mechanical stats).`);
+        }
+        const species = wf.answers.species ?? Object.values(rules.species ?? {})[0]?.name ?? "";
+        const classLevels = wf.answers.classLevels ?? [];
+        for (const cl of classLevels) {
+            if (!getClassData(rules, cl.className))
+                return err("INVALID_INPUT", `Unknown class '${cl.className}'.`);
+        }
+        const defaultScores = rules.default_ability_scores?.map(String).join(" ") ?? "15 14 13 12 10 8";
+        const abilityScores = applySpeciesAdjustments(wf.answers.abilityScores ?? parseAbilityScores(defaultScores, rules), species, rules);
+        const build = {
+            name: wf.answers.name ?? "Unnamed",
+            species,
+            classLevels,
+            abilityScores,
+            trainedSkills: wf.answers.trainedSkills ?? [],
+            feats: [],
+            talents: [],
+            statMethod: wf.answers.statMethod ?? "planned",
+        };
+        const stats = buildCharacterStats(build, rules);
+        const entity = state.createEntity(build.name, undefined, stats);
+        state.addEntity(novel, entity);
+        state.saveNovel(novel);
+        return ok(`${fmtEntitySheet(entity)}
+
+Character '${build.name}' created as ${entity.id} with derived statistics.`);
+    }
+    return ok(`Responded to '${decision}' with '${option}'.`);
+});
+server.registerTool("undo", {
+    title: "Undo",
+    description: "Undo the most recent mutation. Restores previous snapshot.",
+    inputSchema: {},
+}, async () => {
+    requireNotObserver();
+    const novel = requireNovel();
+    state.undo(novel, getBadge());
+    return ok("Undo successful.");
+});
+server.registerTool("redo", {
+    title: "Redo",
+    description: "Redo the most recently undone mutation.",
+    inputSchema: {},
+}, async () => {
+    requireNotObserver();
+    const novel = requireNovel();
+    state.redo(novel, getBadge());
+    return ok("Redo successful.");
+});
+server.registerTool("help", {
+    title: "Help and Tool Discovery",
+    description: "Show available commands and tools. Accepts optional query for focused search.",
+    inputSchema: { query: z.string().optional() },
+}, async ({ query }) => {
+    const badge = getBadge();
+    const novel = state.activeNovel;
+    const isGM = badge === "game_master";
+    if (query) {
+        const q = query.toLowerCase();
+        const registeredTools = server._registeredTools ?? {};
+        const toolNames = Object.keys(registeredTools).filter(t => {
+            if (t === "set_badge" || t === "respond" || t === "undo" || t === "redo")
+                return true;
+            if (!isGM && isGMTool(t))
+                return false;
+            // Parser is hidden from the Player badge on ruleset-bound Novels (REQ-309b).
+            if (!isGM && t === "command" && novel?.ruleset)
+                return false;
+            return true;
+        });
+        const matched = [];
+        for (const name of toolNames) {
+            const def = registeredTools[name];
+            if (!def)
+                continue;
+            const desc = typeof def.description === "string" ? def.description : "";
+            const title = typeof def.title === "string" ? def.title : "";
+            let score = 0;
+            if (name.toLowerCase().includes(q))
+                score += 3;
+            if (desc.toLowerCase().includes(q))
+                score += 2;
+            if (title.toLowerCase().includes(q))
+                score += 1;
+            if (score === 0)
+                continue;
+            const firstSentence = desc.split(".")[0] + (desc.includes(".") ? "." : "");
+            const example = buildExampleInvocation(name, def.inputSchema);
+            matched.push({ name, description: firstSentence, example, relevance: score });
+        }
+        if (q.includes("intro") || q.includes("start") || q.includes("begin")) {
+            matched.push({ name: "intro", description: "Connection introduction and getting started.", example: "Use the intro prompt", relevance: 3 });
+        }
+        if (q.includes("brief") || q.includes("badge") || q.includes("state")) {
+            matched.push({ name: "badge_briefing", description: "Per-badge guidance, state, and tool recommendations.", example: "Use the badge_briefing prompt", relevance: 2 });
+        }
+        matched.sort((a, b) => b.relevance - a.relevance);
+        const top = matched.slice(0, 5);
+        if (top.length === 0)
+            return ok("No tools match. Try `command(\"look\")` for world description.");
+        return raw(top.map(m => `**${m.name}** — ${m.description}\nExample: ${m.example}`).join("\n\n"));
+    }
+    const builderCategories = BUILDER_CATEGORIES;
+    let result = "## Inform MCP Server\n\n### Tool Categories\n\n";
+    for (const [cat, tools] of Object.entries(builderCategories)) {
+        let displayTools = [...tools];
+        if (!isGM) {
+            displayTools = tools.filter(t => !GMToolsSet.has(t) && !(t === "command" && novel?.ruleset));
+        }
+        if (displayTools.length > 0) {
+            result += `**${cat}:** ${displayTools.join(", ")}\n`;
+        }
+    }
+    result += "\nUse the intro prompt to get started, or badge_briefing for current badge guidance.";
+    // Add world-model hint if populated
+    if (novel && novel.world.rooms.size > 0) {
+        result += `\n\nWorld-model populated: ${novel.world.rooms.size} rooms, ${novel.world.things.size} things. Try \`command("look")\`.`;
+    }
+    else {
+        result += "\n\nNo world model — use `convert_source` or adventure tools to populate.";
+    }
+    return raw(result);
+});
+server.registerTool("set_help_category", {
+    title: "Set Help Category Override",
+    description: "Override the builder-assigned category for a tool. Game Master only. Set category to empty string or null to restore defaults.",
+    inputSchema: { tool_name: z.string(), category: z.string().nullable() },
+}, async ({ tool_name, category }) => {
+    requireGM();
+    const novel = requireNovel();
+    const registeredTools = server._registeredTools ?? {};
+    if (!(tool_name in registeredTools)) {
+        const valid = Object.keys(registeredTools).join(", ");
+        return err("NOT_FOUND", `Tool '${tool_name}' not found. Valid: ${valid}`);
+    }
+    if (!category || category.trim() === "") {
+        delete novel.help_category_overrides[tool_name];
+        state.saveNovel(novel);
+        return ok(`Category override for '${tool_name}' removed.`);
+    }
+    novel.help_category_overrides[tool_name] = category.trim();
+    state.saveNovel(novel);
+    return ok(`Tool '${tool_name}' assigned to category '${category.trim()}'.`);
+});
+// --- Characters (ruleset-free, REQ-219; ruleset-driven REQ-104/151/152/181) ---
+// Parse a class-levels spec like "Noble 5 / Jedi 2 / Crime Lord 2" or an
+// array of { className, levels } objects.
+function parseClassLevels(raw) {
+    if (Array.isArray(raw)) {
+        return raw.map((c) => {
+            const name = String(c?.class ?? c?.className ?? c?.name ?? "").trim();
+            const levels = Number(c?.levels ?? c?.level ?? 1) || 1;
+            return { className: name, levels };
+        }).filter((c) => c.className);
+    }
+    const out = [];
+    const parts = String(raw).split("/");
+    for (const part of parts) {
+        const m = part.trim().match(/^(.+?)\s+(\d+)$/);
+        if (m) {
+            out.push({ className: m[1].trim(), levels: parseInt(m[2], 10) });
+        }
+    }
+    return out;
+}
+function parseAbilityScores(raw, rules) {
+    const names = abilityNames(rules);
+    const values = typeof raw === "string"
+        ? String(raw).trim().split(/[\s,]+/).map(Number)
+        : Array.isArray(raw) ? raw.map(Number) : [];
+    const out = {};
+    for (let i = 0; i < names.length; i++) {
+        out[names[i]] = Number.isFinite(values[i]) ? values[i] : 10;
+    }
+    return out;
+}
+// Resolve the active Novel's character-creation rules, or null if the Novel is
+// ruleset-free or the bound package carries no character-creation data
+// (REQ-219, REQ-399c).
+function getCharacterRules(novel) {
+    if (!novel?.ruleset)
+        return null;
+    try {
+        const model = rulesets.hydrate(novel.ruleset).model;
+        const rules = model?.character_creation;
+        return rules && typeof rules === "object" ? rules : null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildCharacterStats(build, rules) {
+    const derived = computeDerived(build, rules);
+    const classLabel = build.classLevels.map((c) => `${c.className} ${c.levels}`).join(" / ");
+    const equipment = build.equipment?.length
+        ? build.equipment.map((n) => ({ name: n, quantity: 1 }))
+        : startingEquipmentFor(build.classLevels, rules);
+    const stats = {
+        class: classLabel,
+        species: build.species,
+        abilityScores: build.abilityScores,
+        level: derived.values.level ?? undefined,
+        statMethod: build.statMethod,
+        trainedSkills: build.trainedSkills,
+        feats: build.feats,
+        talents: build.talents,
+        equipment,
+    };
+    // Spread ruleset-declared derived statistics under their keys.
+    for (const key of derived.order)
+        stats[derived.labels[key] ?? key] = derived.values[key];
+    stats._derived_labels = { order: derived.order, labels: derived.labels, sections: derived.sections };
+    return stats;
+}
+server.registerTool("create_character", {
+    title: "Create Character",
+    description: "Create a character. Quick-create: pass name, species, classes, ability_scores, stat_method, skills, feats, talents. Step-by-step: call with no params to begin a guided [NEED_INPUT] workflow.",
+    inputSchema: {
+        name: z.string().optional(),
+        description: z.string().optional(),
+        voice: z.string().optional(),
+        background: z.string().optional(),
+        goals: z.string().optional(),
+        species: z.string().optional(),
+        classes: z.union([z.string(), z.array(z.object({ className: z.string(), levels: z.number().optional() }))]).optional(),
+        ability_scores: z.union([z.string(), z.array(z.number())]).optional(),
+        stat_method: z.string().optional(),
+        seed: z.string().optional(),
+        skills: z.union([z.string(), z.array(z.string())]).optional(),
+        feats: z.union([z.string(), z.array(z.string())]).optional(),
+        talents: z.union([z.string(), z.array(z.string())]).optional(),
+        equipment: z.union([z.string(), z.array(z.string())]).optional(),
+        stage_to_roster: z.boolean().optional(),
+    },
+}, async ({ name, description, voice, background, goals, species, classes, ability_scores, stat_method, seed, skills, feats, talents, equipment, stage_to_roster }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    const rules = getCharacterRules(novel);
+    const personality = { description, voice, background, goals };
+    const hasPersonality = description || voice || background || goals;
+    if (!name) {
+        // Step-by-step mode: start a guided creation workflow.
+        if (novel.pending_workflow)
+            return err("STATE_CONFLICT", "A workflow decision is pending. Resolve it with respond before starting a new one.");
+        const workflow = { kind: "character_creation", stepIndex: 0, rules, answers: {} };
+        novel.pending_workflow = { decision: "character_creation", snapshot: null, creation: workflow };
+        state.saveNovel(novel);
+        return needInput(creationStepPrompt(workflow));
+    }
+    // Ruleset-free (or character-data-less) profile-only path (REQ-219a1, REQ-399c).
+    if (!rules) {
+        if (classes || ability_scores || stat_method) {
+            return err("INVALID_INPUT", "This Novel has no character-creation rules. Bind a ruleset whose package defines character creation to use classes or mechanical stats.");
+        }
+        const profileStats = species && !hasPersonality ? { species } : undefined;
+        const entity = state.createEntity(name, hasPersonality ? personality : undefined, profileStats);
+        state.addEntity(novel, entity);
+        if (stage_to_roster)
+            state.addToRoster(entity);
+        state.saveNovel(novel);
+        return ok(`${fmtEntitySheet(entity)}
+
+Character '${name}' created (profile-only — no mechanical stats).${stage_to_roster ? ` Staged to roster as ${entity.id}.` : ` Entity id ${entity.id}.`}`);
+    }
+    // Quick-create mode: require species + classes.
+    if (!species || !classes) {
+        return err("INVALID_INPUT", "Quick-create requires 'species' and 'classes'. Omit 'name' to start step-by-step, or provide all creation fields.");
+    }
+    const classLevels = parseClassLevels(classes);
+    if (classLevels.length === 0)
+        return err("INVALID_INPUT", "Could not parse 'classes'. Use format 'Class 5 / Other 2'.");
+    for (const cl of classLevels) {
+        if (!getClassData(rules, cl.className))
+            return err("INVALID_INPUT", `Unknown class '${cl.className}'.`);
+    }
+    const speciesName = species;
+    const speciesData = rules.species?.[speciesName.trim().toLowerCase()];
+    if (rules.species && !speciesData)
+        return err("INVALID_INPUT", `Unknown species '${speciesName}'.`);
+    const method = stat_method ?? Object.keys(rules.stat_methods ?? {})[0] ?? "planned";
+    const rawScores = ability_scores
+        ? parseAbilityScores(ability_scores, rules)
+        : (() => {
+            const gen = generateAbilityScores(method, rules, seed);
+            const names = abilityNames(rules);
+            const out = {};
+            for (let i = 0; i < names.length; i++)
+                out[names[i]] = gen[i] ?? 10;
+            return out;
+        })();
+    const abilityScores = applySpeciesAdjustments(rawScores, speciesName, rules);
+    const toList = (v) => {
+        if (!v)
+            return [];
+        if (Array.isArray(v))
+            return v.map(String);
+        return String(v).split(/[\s,]+/).map((s) => s.trim()).filter(Boolean);
+    };
+    const build = {
+        name,
+        species: speciesName,
+        classLevels,
+        abilityScores,
+        trainedSkills: toList(skills),
+        feats: toList(feats),
+        talents: toList(talents),
+        statMethod: method,
+        seed,
+        equipment: toList(equipment),
+    };
+    const stats = buildCharacterStats(build, rules);
+    const entity = state.createEntity(name, hasPersonality ? personality : undefined, stats);
+    state.addEntity(novel, entity);
+    if (stage_to_roster)
+        state.addToRoster(entity);
+    state.saveNovel(novel);
+    const inputs = [`name=${name}`, `species=${speciesName}`, `classes=${classLevels.map((c) => `${c.className} ${c.levels}`).join("/")}`, `stat_method=${method}`];
+    const derived = Object.entries(stats)
+        .filter(([k, v]) => k !== "class" && k !== "species" && k !== "abilityScores" && k !== "statMethod" && k !== "trainedSkills" && k !== "feats" && k !== "talents" && k !== "equipment" && k !== "level" && !k.startsWith("_") && typeof v === "number")
+        .map(([k, v]) => `${k}=${v}`);
+    return ok(`${fmtEntitySheet(entity)}
+
+Created (inputs): ${inputs.join(" · ")}
+Derived: ${derived.join(" · ")}
+${stage_to_roster ? `Staged to roster as ${entity.id}.` : `Character '${name}' created as ${entity.id}.`}`);
+});
+server.registerTool("stage_character", {
+    title: "Stage Character to Roster",
+    description: "Stage an existing novel entity into the persistent roster for later import.",
+    inputSchema: { entity_id: z.string().optional() },
+}, async ({ entity_id }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    const entity = resolveEntity(entity_id);
+    if (!entity)
+        return err("NOT_FOUND", "No entity to stage.");
+    const id = state.addToRoster(entity);
+    state.saveNovel(novel);
+    return ok(`Character '${entity.name}' staged to roster as ${id}.`);
+});
+server.registerTool("import_character", {
+    title: "Import Character",
+    description: "Import a roster character into the active novel.",
+    inputSchema: { roster_id: z.string() },
+}, async ({ roster_id }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    const rosterEntity = state.roster.get(roster_id);
+    if (!rosterEntity)
+        return err("NOT_FOUND", `Roster entity '${roster_id}' not found.`);
+    state.addEntity(novel, { ...rosterEntity, current_room: rosterEntity.current_room ?? null, inventory: rosterEntity.inventory ?? [] });
+    state.saveNovel(novel);
+    return ok(`Character '${rosterEntity.name}' imported.`);
+});
+server.registerTool("character_sheet", {
+    title: "Character Sheet",
+    description: "Render a character sheet for an entity. Formats: markdown (default), ascii.",
+    inputSchema: {
+        entity_id: z.string().optional(),
+        format: z.enum(["markdown", "ascii"]).optional(),
+    },
+}, async ({ entity_id, format }) => {
+    const entity = resolveEntity(entity_id);
+    if (format === "ascii") {
+        return raw(`[OK] ${entity.name}  Room: ${entity.current_room || "(none)"}  Held: ${entity.inventory?.length || 0}`);
+    }
+    return ok(fmtEntitySheet(entity));
+});
+server.registerTool("set_active_entity", {
+    title: "Set Active Entity",
+    description: "Set the currently active entity.",
+    inputSchema: { entity_id: z.string(), pov: z.enum(["character", "omniscient"]).optional() },
+}, async ({ entity_id, pov }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    if (!novel.entities.has(entity_id))
+        return err("NOT_FOUND", `Entity '${entity_id}' not found.`);
+    novel.active_entity_id = entity_id;
+    if (pov !== undefined)
+        novel.pov_mode = pov;
+    const mode = novel.pov_mode;
+    return ok(`Active entity set to '${entity_id}'${mode === "omniscient" ? " (omniscient POV)" : ""}.`);
+});
+server.registerTool("set_personality", {
+    title: "Set Entity or NPC Personality",
+    description: "Set narrative personality fields for an entity or NPC.",
+    inputSchema: {
+        entity_id: z.string(),
+        description: z.string().optional(),
+        voice: z.string().optional(),
+        background: z.string().optional(),
+        goals: z.string().optional(),
+    },
+}, async ({ entity_id, description, voice, background, goals }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    let target = novel.entities.get(entity_id) ?? novel.npcs.get(entity_id);
+    if (!target)
+        return err("NOT_FOUND", `Entity or NPC '${entity_id}' not found.`);
+    if (!target.personality)
+        target.personality = {};
+    if (description !== undefined)
+        target.personality.description = description;
+    if (voice !== undefined)
+        target.personality.voice = voice;
+    if (background !== undefined)
+        target.personality.background = background;
+    if (goals !== undefined)
+        target.personality.goals = goals;
+    state.saveNovel(novel);
+    const setFields = [description !== undefined, voice !== undefined, background !== undefined, goals !== undefined].filter(Boolean).length;
+    audit("set_personality", { entity_id, fields: setFields });
+    return ok(`Personality set for '${entity_id}'.`);
+});
+server.registerTool("set_voice_examples", {
+    title: "Set Voice Examples",
+    description: "Set voice and dialogue examples for an entity or NPC.",
+    inputSchema: {
+        entity_id: z.string(),
+        examples: z.array(z.object({ context: z.string(), dialogue: z.string(), tag: z.string().optional() })),
+    },
+}, async ({ entity_id, examples }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    let target = novel.entities.get(entity_id) ?? novel.npcs.get(entity_id);
+    if (!target)
+        return err("NOT_FOUND", `Entity or NPC '${entity_id}' not found.`);
+    target.voice_examples = examples;
+    state.saveNovel(novel);
+    audit("set_voice_examples", { entity_id, count: examples.length });
+    return ok(`Voice examples set for '${entity_id}' (${examples.length} examples).`);
+});
+server.registerTool("player_signal", {
+    title: "Player Signal",
+    description: "Send a narrative signal from the player to the GM.",
+    inputSchema: {
+        signal: z.enum(["pace", "difficulty", "tone", "focus", "boundary"]),
+        value: z.string(),
+    },
+}, async ({ signal, value }) => {
+    requirePlayer();
+    const novel = requireNovel();
+    novel.player_signals[signal] = value;
+    state.saveNovel(novel);
+    audit("player_signal", { signal, value });
+    return ok(`Signal recorded: ${signal} → ${value}`);
+});
+// ── Autonomy (REQ-306) ────────────────────────────────────────────
+server.registerTool("set_autonomy", {
+    title: "Adjustable Autonomy",
+    description: "Set the AI autonomy sliders for the active Novel. level: full/mechanical_prompt/manual; confirmation: auto/confirm/prompt; safety: safe/moderate/hardcore; creativity: predictable/standard/chaotic. Game Master only.",
+    inputSchema: {
+        level: z.enum(["full", "mechanical_prompt", "manual"]).optional(),
+        confirmation: z.enum(["auto", "confirm", "prompt"]).optional(),
+        safety: z.enum(["safe", "moderate", "hardcore"]).optional(),
+        creativity: z.enum(["predictable", "standard", "chaotic"]).optional(),
+    },
+}, async ({ level, confirmation, safety, creativity }) => {
+    requireGM();
+    const novel = requireNovel();
+    const auto = novel.autonomy;
+    // REQ-306f — escalating safety above `safe` requires confirmation, once per
+    // Novel per target tier.
+    if (safety && safety !== "safe" && safety !== auto.safety && !auto.confirmed_safety_tiers.includes(safety)) {
+        novel.pending_workflow = { decision: `safety_escalation:${safety}`, snapshot: null };
+        state.saveNovel(novel);
+        const severity = safety === "hardcore"
+            ? "warning: disengaging safety protocols permits permanent character death with no warnings"
+            : "caution: raising safety to 'moderate' permits character death with warnings";
+        return needInput(`Safety escalation advisory — ${severity}. Respond with 'confirm' to raise the safety tier, or 'decline' to leave the current tier (${auto.safety}).`);
+    }
+    if (level)
+        auto.level = level;
+    if (confirmation)
+        auto.confirmation = confirmation;
+    if (creativity)
+        auto.creativity = creativity;
+    if (safety) {
+        auto.safety = safety;
+        if (!auto.confirmed_safety_tiers.includes(safety))
+            auto.confirmed_safety_tiers.push(safety);
+    }
+    state.saveNovel(novel);
+    audit("set_autonomy", { level, confirmation, safety, creativity });
+    const a = novel.autonomy;
+    return ok(`Autonomy set — level: ${a.level}, confirmation: ${a.confirmation}, safety: ${a.safety}, creativity: ${a.creativity}`);
+});
+// --- World-Model Tools ---
+server.registerTool("command", {
+    title: "Parser Command",
+    description: "Execute a natural-language parser command against the world model. Use for navigation (go, n/s/e/w), inspection (look, examine), object interaction (take, drop, open, close), inventory, and wait.",
+    inputSchema: { command: z.string() },
+}, async ({ command }) => {
+    const novel = requireNovel();
+    // Ruleset-bound Novels gate the parser to the Game Master (REQ-309); the
+    // Player badge routes spatial intent through resolve_intent. Ruleset-free
+    // Novels keep the parser as the primary Player surface (REQ-218, REQ-309e).
+    if (novel.ruleset)
+        requireGM();
+    else
+        requireNotObserver();
+    worldSnapshot();
+    const entity = state.getActiveEntity();
+    if (!state.worldHasRooms(novel)) {
+        return raw(`[ERROR] [STATE_CONFLICT] The world model has not been populated. Use an adventure module or \`convert_source\` to populate rooms before using parser commands.`);
+    }
+    // Auto-place entity in first room if no current room
+    let currentRoom = entity?.current_room ?? null;
+    if (!currentRoom && entity) {
+        currentRoom = [...novel.world.rooms.keys()][0];
+        entity.current_room = currentRoom;
+    }
+    const inventory = entity?.inventory ?? [];
+    const ctx = { world: novel.world, currentRoom, inventory, badge: getBadge() };
+    const result = dispatchCommand(command, ctx);
+    // Apply side effects
+    if (result.prefix === "OK") {
+        const goResult = resolveGoMovement(command, ctx);
+        if (goResult.newRoom && entity && goResult.result.prefix === "OK") {
+            entity.current_room = goResult.newRoom;
+            // Trigger lore matching the new room name
+            audit("command", { command, moved_to: goResult.newRoom });
+        }
+    }
+    // Handle take/drop side effects
+    const tokens = command.trim().split(/\s+/);
+    const verb = tokens[0].toLowerCase();
+    if (result.prefix === "OK" && entity) {
+        if (verb === "take" || verb === "get") {
+            const targetThing = findMatchingThing(tokens.slice(1).join(" "), novel.world, currentRoom);
+            if (targetThing && targetThing.portable && !entity.inventory.includes(targetThing.name.toLowerCase())) {
+                entity.inventory.push(targetThing.name.toLowerCase());
+                targetThing.location = null;
+                targetThing.locationType = null;
+                state.saveNovel(novel);
+                audit("command", { command, took: targetThing.name });
+            }
+        }
+        else if (verb === "drop" && tokens.length > 1) {
+            const target = tokens.slice(1).join(" ").toLowerCase();
+            const idx = entity.inventory.indexOf(target);
+            if (idx >= 0) {
+                entity.inventory.splice(idx, 1);
+                // Move thing back to current room
+                const thing = novel.world.things.get(target);
+                if (thing) {
+                    thing.location = currentRoom;
+                    thing.locationType = "room";
+                }
+                state.saveNovel(novel);
+                audit("command", { command, dropped: target });
+            }
+        }
+        else if (verb === "open" && result.prefix === "OK" && tokens.length > 1) {
+            const thing = novel.world.things.get(tokens.slice(1).join(" ").toLowerCase());
+            if (thing && thing.openable) {
+                thing.open = true;
+                state.saveNovel(novel);
+                audit("command", { command, opened: thing.name });
+            }
+        }
+        else if (verb === "close" && result.prefix === "OK" && tokens.length > 1) {
+            const thing = novel.world.things.get(tokens.slice(1).join(" ").toLowerCase());
+            if (thing && thing.openable) {
+                thing.open = false;
+                state.saveNovel(novel);
+                audit("command", { command, closed: thing.name });
+            }
+        }
+        else if (verb === "unlock" && result.prefix === "OK" && tokens.length > 1) {
+            const thing = novel.world.things.get(tokens.slice(1).join(" ").toLowerCase());
+            if (thing && thing.lockable) {
+                thing.locked = false;
+                state.saveNovel(novel);
+                audit("command", { command, unlocked: thing.name });
+            }
+        }
+        else if (verb === "lock" && result.prefix === "OK" && tokens.length > 1) {
+            const thing = novel.world.things.get(tokens.slice(1).join(" ").toLowerCase());
+            if (thing && thing.lockable) {
+                thing.locked = true;
+                state.saveNovel(novel);
+                audit("command", { command, locked: thing.name });
+            }
+        }
+    }
+    // Output
+    const prefix = result.prefix === "OK" ? "[OK]" : result.prefix === "WARNING" ? "[WARNING]" : "[ERROR]";
+    const code = result.code ? ` [${result.code}]` : "";
+    let text = `${prefix}${code} ${result.text}`;
+    if (result.correctiveAction) {
+        text += `\nCorrective action: ${result.correctiveAction}`;
+    }
+    return raw(text);
+});
+function findMatchingThing(name, world, roomName) {
+    const lower = name.toLowerCase().trim();
+    for (const [, thing] of world.things) {
+        if (thing.name.toLowerCase().includes(lower)) {
+            const loc = thing.location?.toLowerCase();
+            if (loc === roomName?.toLowerCase())
+                return thing;
+            // REQ-200: things on supporters or in open containers within the room are reachable.
+            if (thing.locationType === "supporter" || thing.locationType === "container") {
+                const parent = world.things.get(thing.location?.toLowerCase() ?? "");
+                if (parent) {
+                    if (parent.location?.toLowerCase() === roomName?.toLowerCase()) {
+                        if (thing.locationType === "supporter" || (parent.openable && parent.open))
+                            return thing;
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+// --- World-Model CRUD (GM-only) ---
+server.registerTool("create_room", {
+    title: "Create Room",
+    description: "Create a new room in the world model. Game Master only.",
+    inputSchema: {
+        name: z.string(),
+        description: z.string().optional(),
+    },
+}, async ({ name, description }) => {
+    requireGM();
+    const novel = requireNovel();
+    worldSnapshot();
+    const lower = name.toLowerCase();
+    if (novel.world.rooms.has(lower))
+        return err("STATE_CONFLICT", `Room '${name}' already exists.`);
+    const room = {
+        name,
+        description: description ?? "",
+        exits: new Map(),
+        doorRefs: new Map(),
+        annotations: {},
+    };
+    novel.world.rooms.set(lower, room);
+    state.saveNovel(novel);
+    audit("create_room", { name });
+    return ok(`Room '${name}' created.`);
+});
+server.registerTool("remove_room", {
+    title: "Remove Room",
+    description: "Remove a room and its contained things and exits. Game Master only.",
+    inputSchema: { name: z.string() },
+}, async ({ name }) => {
+    requireGM();
+    const novel = requireNovel();
+    worldSnapshot();
+    const lower = name.toLowerCase();
+    if (!novel.world.rooms.has(lower))
+        return err("NOT_FOUND", `Room '${name}' not found.`);
+    // Remove things in this room
+    for (const [tKey, thing] of novel.world.things) {
+        if (thing.location?.toLowerCase() === lower && thing.locationType === "room") {
+            novel.world.things.delete(tKey);
+        }
+    }
+    // Remove exits referencing this room
+    for (const [, room] of novel.world.rooms) {
+        for (const [dir, target] of room.exits) {
+            if (target.toLowerCase() === lower)
+                room.exits.delete(dir);
+        }
+    }
+    novel.world.rooms.delete(lower);
+    state.saveNovel(novel);
+    audit("remove_room", { name });
+    return ok(`Room '${name}' and its contents removed.`);
+});
+server.registerTool("create_thing", {
+    title: "Create Thing",
+    description: "Create a new thing in the world model. Game Master only.",
+    inputSchema: {
+        name: z.string(),
+        kind: z.string().optional(),
+        description: z.string().optional(),
+        location: z.string().optional(),
+        location_type: z.enum(["room", "container", "supporter"]).optional(),
+        fixed: z.boolean().optional(),
+        openable: z.boolean().optional(),
+        lockable: z.boolean().optional(),
+    },
+}, async ({ name, kind, description, location, location_type, fixed, openable, lockable }) => {
+    requireGM();
+    const novel = requireNovel();
+    worldSnapshot();
+    const lower = name.toLowerCase();
+    if (novel.world.things.has(lower))
+        return err("STATE_CONFLICT", `Thing '${name}' already exists.`);
+    const validKinds = ["thing", "container", "supporter", "door", "device", "vehicle", "person", "backdrop", "region"];
+    const k = (kind && validKinds.includes(kind.toLowerCase())) ? kind.toLowerCase() : "thing";
+    // Determine containment: explicit location_type, or infer from the parent's kind.
+    let locationType = location ? "room" : null;
+    if (location && location_type) {
+        locationType = location_type;
+    }
+    else if (location) {
+        const parent = novel.world.things.get(location.toLowerCase());
+        if (parent && (parent.kind === "container" || parent.kind === "supporter" || parent.kind === "vehicle")) {
+            locationType = parent.kind === "supporter" ? "supporter" : parent.kind === "vehicle" ? "vehicle" : "container";
+        }
+    }
+    const thing = {
+        name,
+        description: description ?? "",
+        kind: k,
+        location: location ?? null,
+        locationType,
+        portable: !fixed && k !== "supporter" && k !== "door" && k !== "vehicle",
+        openable: k === "container" || k === "door" || openable === true,
+        open: false,
+        lockable: k === "container" || k === "door" || lockable === true,
+        locked: false,
+        lit: false,
+        switchable: k === "device",
+        switched_on: false,
+        enterable: k === "vehicle",
+        vehiclePassengers: [],
+        wearable: false,
+        worn_by: null,
+        readable: false,
+        read_text: null,
+        edible: false,
+        drinkable: false,
+        climbable: false,
+        transparent: false,
+        annotations: {},
+    };
+    novel.world.things.set(lower, thing);
+    state.saveNovel(novel);
+    audit("create_thing", { name, kind: k, location, location_type: locationType });
+    return ok(`Thing '${name}' (${k}) created${location ? (locationType === "supporter" ? ` on ${location}` : locationType === "container" ? ` in container ${location}` : ` in ${location}`) : ""}.`);
+});
+server.registerTool("remove_thing", {
+    title: "Remove Thing",
+    description: "Remove a thing from the world model. Game Master only.",
+    inputSchema: { name: z.string() },
+}, async ({ name }) => {
+    requireGM();
+    const novel = requireNovel();
+    worldSnapshot();
+    const lower = name.toLowerCase();
+    if (!novel.world.things.has(lower))
+        return err("NOT_FOUND", `Thing '${name}' not found.`);
+    novel.world.things.delete(lower);
+    state.saveNovel(novel);
+    audit("remove_thing", { name });
+    return ok(`Thing '${name}' removed.`);
+});
+server.registerTool("create_exit", {
+    title: "Create Exit",
+    description: "Create a directional exit between two rooms. Reverse exit created implicitly. Game Master only.",
+    inputSchema: {
+        direction: z.string(),
+        room_a: z.string(),
+        room_b: z.string(),
+    },
+}, async ({ direction, room_a, room_b }) => {
+    requireGM();
+    const novel = requireNovel();
+    worldSnapshot();
+    const dir = direction.toLowerCase();
+    if (!ROOM_DIRECTIONS.includes(dir))
+        return err("INVALID_INPUT", `Invalid direction '${direction}'. Valid: ${ROOM_DIRECTIONS.join(", ")}.`);
+    const roomA = novel.world.rooms.get(room_a.toLowerCase());
+    const roomB = novel.world.rooms.get(room_b.toLowerCase());
+    if (!roomA)
+        return err("NOT_FOUND", `Room '${room_a}' not found.`);
+    if (!roomB)
+        return err("NOT_FOUND", `Room '${room_b}' not found.`);
+    roomA.exits.set(dir, room_b);
+    roomB.exits.set(oppositeDirection(dir), room_a);
+    state.saveNovel(novel);
+    audit("create_exit", { direction: dir, room_a, room_b });
+    return ok(`Exit created: ${dir} from ${room_a} to ${room_b}.`);
+});
+server.registerTool("remove_exit", {
+    title: "Remove Exit",
+    description: "Remove a directional exit from a room. Game Master only.",
+    inputSchema: {
+        direction: z.string(),
+        room: z.string(),
+    },
+}, async ({ direction, room: roomName }) => {
+    requireGM();
+    const novel = requireNovel();
+    worldSnapshot();
+    const dir = direction.toLowerCase();
+    if (!ROOM_DIRECTIONS.includes(dir))
+        return err("INVALID_INPUT", `Invalid direction.`);
+    const room = novel.world.rooms.get(roomName.toLowerCase());
+    if (!room)
+        return err("NOT_FOUND", `Room '${roomName}' not found.`);
+    if (!room.exits.has(dir))
+        return err("NOT_FOUND", `No ${dir} exit from '${roomName}'.`);
+    room.exits.delete(dir);
+    state.saveNovel(novel);
+    audit("remove_exit", { direction: dir, room: roomName });
+    return ok(`Exit ${dir} from '${roomName}' removed.`);
+});
+server.registerTool("convert_source", {
+    title: "Convert Source",
+    description: "Parse hybrid world-model assertions and populate the Novel's world model. Game Master only. Only on an empty world model.",
+    inputSchema: { source: z.string() },
+}, async ({ source }) => {
+    requireGM();
+    const novel = requireNovel();
+    worldSnapshot();
+    if (novel.world.rooms.size > 0) {
+        return err("STATE_CONFLICT", "World model already populated. Use CRUD tools to modify, or create a new novel.");
+    }
+    const { world, result } = convertSource(source, novel.world);
+    novel.world = world;
+    state.saveNovel(novel);
+    audit("convert_source", { rooms: result.rooms, things: result.things, exits: result.exits });
+    let msg = `[OK] World model populated: ${result.rooms} rooms, ${result.things} things, ${result.exits} exits.`;
+    msg += ` Linked annotations — encounters: ${result.annotations.encounters}, NPCs: ${result.annotations.npcs}, traps: ${result.annotations.traps}, lore: ${result.annotations.lore}.`;
+    if (result.warnings.length > 0) {
+        msg += `\n\nWarnings:`;
+        for (const w of result.warnings) {
+            msg += `\nLine ${w.line}: ${w.message}`;
+        }
+    }
+    return raw(msg);
+});
+// --- resolve_intent (REQ-323, §5.12) ---
+// Resolves a spatial intent against the world model without mutating state.
+// Three phases: constraint check → override check → scene composition.
+// Callable by the AI narrator, Game Master, and Observer badges; Player [FORBIDDEN].
+function resolveIntentWorld(intent, novel) {
+    const world = novel.world;
+    if (world.rooms.size === 0) {
+        return { status: "no_world_model" };
+    }
+    const entity = state.getActiveEntity();
+    let currentRoom = entity?.current_room ?? null;
+    if (!currentRoom)
+        currentRoom = [...world.rooms.keys()][0];
+    const tokens = intent.trim().toLowerCase().split(/\s+/);
+    const verb = tokens[0];
+    // Navigation intent resolution
+    const isNav = ["go", "walk", "move", "north", "south", "east", "west", "northeast", "northwest", "southeast", "southwest", "up", "down", "in", "out"].includes(verb);
+    const isLook = verb === "look" || verb === "examine" || verb === "search" || verb === "inspect";
+    const room = world.rooms.get(currentRoom.toLowerCase());
+    if (isNav) {
+        if (!room)
+            return { status: "blocked", constraint: "room", reason: `Current room '${currentRoom}' not found.` };
+        let dir = tokens[0] === "go" || tokens[0] === "walk" || tokens[0] === "move" ? tokens[1] : verb;
+        if (!dir || !ROOM_DIRECTIONS.includes(dir)) {
+            return { status: "blocked", constraint: "direction", reason: `Direction '${dir ?? ""}' is not valid.`, available: [...room.exits.keys()] };
+        }
+        const direction = dir;
+        // Constraint check: door blocking
+        const doorName = room.doorRefs.get(direction);
+        const overrideHints = [];
+        if (doorName) {
+            const door = world.things.get(doorName.toLowerCase());
+            if (door && !door.open) {
+                const constraint = door.locked ? "locked" : "closed_door";
+                // Override check: scan active-entity constraint overrides (REQ-325)
+                const overrides = novel.constraint_overrides ?? [];
+                for (const o of overrides) {
+                    if (o.type === "door" && (o.name?.toLowerCase() === door.name.toLowerCase() || o.match_all)) {
+                        overrideHints.push(`${o.name} (${o.slots_remaining ?? "∞"} remaining) can open ${door.name}.`);
+                    }
+                }
+                if (overrideHints.length === 0) {
+                    return { status: "blocked", constraint, reason: `The ${door.name} is ${constraint === "locked" ? "locked" : "closed"}.` };
+                }
+            }
+        }
+        const target = room.exits.get(direction);
+        if (!target) {
+            return { status: "blocked", constraint: "exit", reason: `No ${direction} exit from '${currentRoom}'.`, available: [...room.exits.keys()] };
+        }
+        const targetRoom = world.rooms.get(target.toLowerCase());
+        if (!targetRoom)
+            return { status: "blocked", constraint: "room", reason: `Destination '${target}' not found.` };
+        return {
+            status: "resolved",
+            room_context: composeRoomContext(targetRoom, novel, world),
+            override_hints: overrideHints,
+        };
+    }
+    if (isLook) {
+        if (!room)
+            return { status: "blocked", constraint: "room", reason: `Current room '${currentRoom}' not found.` };
+        return { status: "resolved", room_context: composeRoomContext(room, novel, world) };
+    }
+    // Unknown intent: return the current room context so the narrator can interpret.
+    if (!room)
+        return { status: "blocked", constraint: "room", reason: "No current room." };
+    return { status: "resolved", room_context: composeRoomContext(room, novel, world) };
+}
+function composeRoomContext(room, novel, world) {
+    const visibleThings = [];
+    const rl = room.name.toLowerCase();
+    for (const [, t] of world.things) {
+        if (!t.location)
+            continue;
+        if (t.location.toLowerCase() === rl && t.locationType === "room")
+            visibleThings.push(t.name);
+    }
+    const presentNpcs = [];
+    for (const [, npc] of novel.npcs) {
+        if (npc.location && npc.location.toLowerCase() === rl)
+            presentNpcs.push(npc.name);
+    }
+    return {
+        name: room.name,
+        description: room.description || "",
+        exits: [...room.exits.entries()].map(([d, t]) => ({ direction: d, target: t })),
+        things: visibleThings,
+        present_npcs: presentNpcs,
+    };
+}
+server.registerTool("resolve_intent", {
+    title: "Resolve Intent",
+    description: "Resolve a natural-language spatial intent against the world model without mutating state. Use when: a player or the AI narrator needs to determine the outcome of a movement or inspection against the world model. Do NOT use when: you are the Game Master inspecting the model directly — use the parser command tool for that.",
+    inputSchema: { intent: z.string() },
+}, async ({ intent }) => {
+    const badge = getBadge();
+    if (badge === "player") {
+        return err("FORBIDDEN", "resolve_intent is not callable by the Player badge. Player spatial intents are resolved by the AI narrator. Corrective action: switch badge or direct intents through the narrator.");
+    }
+    requireNotObserver();
+    const novel = requireNovel();
+    const result = resolveIntentWorld(intent, novel);
+    return raw(JSON.stringify(result, null, 2));
+});
+// --- Combat (GM, auto-advance in ruleset-free mode) ---
+server.registerTool("init_combat", {
+    title: "Initiate Combat",
+    description: "Start a combat encounter. Game Master only. In ruleset-free mode, all participants auto-advance.",
+    inputSchema: {
+        participants: z.array(z.string()),
+        dangers: z.array(z.object({ name: z.string(), ac: z.number().optional(), hp: z.number().optional(), initiative_bonus: z.number().optional() })).optional(),
+        seed: z.string().optional(),
+    },
+}, async ({ participants, dangers, seed }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const combat = state.initCombat(novel, participants, dangers ?? [], seed);
+    state.saveNovel(novel);
+    return ok(`Combat started. Round ${combat.round}, ${combat.turn_order.length} participants. Turn: ${combat.turn_order[0]} (auto-advance mode).`);
+});
+server.registerTool("advance_combat", {
+    title: "Advance Combat",
+    description: "Advance to the next turn in combat. Game Master only.",
+    inputSchema: {},
+}, async () => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const combat = state.advanceCombat(novel);
+    state.saveNovel(novel);
+    const currentName = combat.turn_order[combat.current_turn];
+    return ok(`Turn: ${currentName} — Round ${combat.round}, Turn ${combat.current_turn + 1}/${combat.turn_order.length}. [AUTO]`);
+});
+server.registerTool("end_combat", {
+    title: "End Combat",
+    description: "End the active combat encounter. Game Master only.",
+    inputSchema: { outcome: z.string().optional() },
+}, async ({ outcome }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const rounds = novel.combat?.round ?? 0;
+    state.endCombat(novel, outcome ?? "Combat ended.");
+    state.saveNovel(novel);
+    return ok(`Combat ended after ${rounds} rounds${outcome ? `. Outcome: ${outcome}` : "."}`);
+});
+server.registerTool("add_combat_participant", {
+    title: "Add Combat Participant",
+    description: "Add a participant to active combat. Game Master only.",
+    inputSchema: { participant_id: z.string() },
+}, async ({ participant_id }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const combat = state.addCombatParticipant(novel, participant_id);
+    state.saveNovel(novel);
+    return ok(`'${participant_id}' added to combat.`);
+});
+server.registerTool("remove_combat_participant", {
+    title: "Remove Combat Participant",
+    description: "Remove a participant from active combat. Game Master only.",
+    inputSchema: { participant_id: z.string() },
+}, async ({ participant_id }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const result = state.removeCombatParticipant(novel, participant_id);
+    state.saveNovel(novel);
+    if (result.ended)
+        return ok("Combat ended — all participants removed.");
+    return ok(`'${participant_id}' removed from combat.`);
+});
+// --- Narrative (GM) ---
+server.registerTool("set_scene_state", {
+    title: "Set Scene State",
+    description: "Set the scene description and location. Game Master only.",
+    inputSchema: {
+        description: z.string(),
+        location: z.string().optional(),
+        time_of_day: z.string().optional(),
+        atmosphere: z.string().optional(),
+        skip_transition_hook: z.boolean().optional(),
+    },
+}, async ({ description, location, time_of_day, atmosphere, skip_transition_hook }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    if (novel.scene_description) {
+        novel.scene_history.push({
+            timestamp: new Date().toISOString(),
+            description: novel.scene_description,
+            location: novel.scene_location,
+            time_of_day: novel.scene_time_of_day,
+            atmosphere: novel.scene_atmosphere,
+        });
+    }
+    novel.scene_description = description;
+    novel.scene_location = location;
+    novel.scene_time_of_day = time_of_day;
+    novel.scene_atmosphere = atmosphere;
+    // Auto-update active entity position if location or description matches a world-model room
+    const sceneRoomName = location || description;
+    if (sceneRoomName) {
+        const matchRoom = [...novel.world.rooms.entries()].find(([, r]) => sceneRoomName.toLowerCase().startsWith(r.name.toLowerCase()));
+        if (matchRoom) {
+            const entity = state.getActiveEntity();
+            if (entity) {
+                entity.current_room = matchRoom[1].name;
+            }
+        }
+    }
+    state.saveNovel(novel);
+    audit("set_scene_state", { description, location, time_of_day, atmosphere });
+    return ok(`Scene set: ${description}`);
+});
+server.registerTool("set_scene_type", {
+    title: "Set Scene Type",
+    description: "Tag the scene as combat, social, exploration, or neutral. Game Master only.",
+    inputSchema: {
+        type: z.union([z.enum(["combat", "social", "exploration", "neutral"]), z.array(z.enum(["combat", "social", "exploration", "neutral"]))]),
+    },
+}, async ({ type }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    novel.scene_type = Array.isArray(type) ? type : [type];
+    state.saveNovel(novel);
+    return ok(`Scene type set to: ${novel.scene_type.join(", ")}.`);
+});
+server.registerTool("set_narrative_directive", {
+    title: "Set Narrative Directive",
+    description: "Set overarching narrative directive for the current scene. Game Master only.",
+    inputSchema: { directive: z.string() },
+}, async ({ directive }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    novel.narrative_directive = directive;
+    state.saveNovel(novel);
+    return ok(`Narrative directive set.`);
+});
+// --- NPCs (GM) ---
+server.registerTool("create_npc", {
+    title: "Create NPC",
+    description: "Create a named NPC with optional description and narrative fields. Game Master only.",
+    inputSchema: {
+        name: z.string(),
+        description: z.string().optional(),
+        disposition: z.string().optional(),
+        location: z.string().optional(),
+    },
+}, async ({ name, description, disposition, location }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const id = `npc_${Date.now().toString(36)}`;
+    novel.npcs.set(id, { id, name, description, disposition, location, conditions: [], condition_rounds: {} });
+    state.saveNovel(novel);
+    audit("create_npc", { name, id });
+    return ok(`NPC '${name}' created (${id}).`);
+});
+server.registerTool("update_npc", {
+    title: "Update NPC",
+    description: "Update an existing NPC's fields. Game Master only.",
+    inputSchema: {
+        npc_id: z.string(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        disposition: z.string().optional(),
+        location: z.string().optional(),
+    },
+}, async ({ npc_id, name, description, disposition, location }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const npc = novel.npcs.get(npc_id);
+    if (!npc)
+        return err("NOT_FOUND", `NPC '${npc_id}' not found.`);
+    if (name !== undefined)
+        npc.name = name;
+    if (description !== undefined)
+        npc.description = description;
+    if (disposition !== undefined)
+        npc.disposition = disposition;
+    if (location !== undefined)
+        npc.location = location;
+    state.saveNovel(novel);
+    audit("update_npc", { npc_id });
+    return ok(`NPC '${npc_id}' updated.`);
+});
+server.registerTool("remove_npc", {
+    title: "Remove NPC",
+    description: "Remove an NPC from the novel. Game Master only.",
+    inputSchema: { npc_id: z.string() },
+}, async ({ npc_id }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    if (!novel.npcs.has(npc_id))
+        return err("NOT_FOUND", `NPC '${npc_id}' not found.`);
+    novel.npcs.delete(npc_id);
+    state.saveNovel(novel);
+    audit("remove_npc", { npc_id });
+    return ok(`NPC '${npc_id}' removed.`);
+});
+// --- Countdowns (GM) ---
+server.registerTool("set_countdown", {
+    title: "Set Countdown",
+    description: "Set a countdown timer. Game Master only.",
+    inputSchema: {
+        name: z.string(),
+        ticks: z.number().min(1),
+        type: z.enum(["round", "narrative"]).optional(),
+        scope: z.string().optional(),
+        direction: z.string().optional(),
+    },
+}, async ({ name, ticks, type, scope, direction }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    novel.countdowns.set(name, { name, ticks, total: ticks, type: type ?? "narrative", scope, direction });
+    state.saveNovel(novel);
+    audit("set_countdown", { name, ticks, type });
+    return ok(`Countdown '${name}' set (${ticks} ticks, ${type ?? "narrative"}).`);
+});
+server.registerTool("advance_countdown", {
+    title: "Advance Countdown",
+    description: "Advance a countdown timer by one tick. Game Master only.",
+    inputSchema: { name: z.string() },
+}, async ({ name }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const cd = novel.countdowns.get(name);
+    if (!cd)
+        return err("NOT_FOUND", `Countdown '${name}' not found.`);
+    cd.ticks--;
+    if (cd.ticks <= 0) {
+        novel.countdowns.delete(name);
+        audit("countdown_expired", { name });
+        state.saveNovel(novel);
+        return ok(`Countdown '${name}' expired. Recorded in audit log.`);
+    }
+    state.saveNovel(novel);
+    audit("advance_countdown", { name, remaining: cd.ticks });
+    return ok(`Countdown ${name}: ${cd.ticks} ticks remaining.`);
+});
+server.registerTool("remove_countdown", {
+    title: "Remove Countdown",
+    description: "Remove a countdown timer. Game Master only.",
+    inputSchema: { name: z.string() },
+}, async ({ name }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    if (!novel.countdowns.has(name))
+        return err("NOT_FOUND", `Countdown '${name}' not found.`);
+    novel.countdowns.delete(name);
+    state.saveNovel(novel);
+    audit("remove_countdown", { name });
+    return ok(`Countdown '${name}' removed.`);
+});
+// --- Lore (GM) ---
+server.registerTool("set_lore_entry", {
+    title: "Set Lore Entry",
+    description: "Log a lore entry for the current novel. Game Master only.",
+    inputSchema: {
+        key: z.string(),
+        content: z.string(),
+        triggers: z.array(z.string()).optional(),
+        badge_scope: z.enum(["game_master", "shared"]).optional(),
+        priority: z.number().optional(),
+        sticky: z.number().optional(),
+        group: z.string().optional(),
+    },
+}, async ({ key, content, triggers, badge_scope, priority, sticky, group }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const entry = {
+        key,
+        content,
+        triggers: triggers ?? [],
+        badge_scope: badge_scope ?? "game_master",
+        priority: priority ?? 0,
+        sticky: sticky ?? 0,
+        sticky_remaining: sticky ?? 0,
+        enabled: true,
+        group,
+    };
+    novel.lore.set(key, entry);
+    state.saveNovel(novel);
+    audit("set_lore_entry", { key });
+    return ok(`Lore entry '${key}' created.`);
+});
+server.registerTool("update_lore_entry", {
+    title: "Update Lore Entry",
+    description: "Update fields of an existing lore entry. Game Master only.",
+    inputSchema: {
+        key: z.string(),
+        content: z.string().optional(),
+        triggers: z.array(z.string()).optional(),
+        badge_scope: z.enum(["game_master", "shared"]).optional(),
+        priority: z.number().optional(),
+        sticky: z.number().optional(),
+        group: z.string().nullable().optional(),
+    },
+}, async ({ key, content, triggers, badge_scope, priority, sticky, group }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const entry = novel.lore.get(key);
+    if (!entry)
+        return err("NOT_FOUND", `Lore entry '${key}' not found.`);
+    if (content !== undefined)
+        entry.content = content;
+    if (triggers !== undefined)
+        entry.triggers = triggers;
+    if (badge_scope !== undefined)
+        entry.badge_scope = badge_scope;
+    if (priority !== undefined)
+        entry.priority = priority;
+    if (sticky !== undefined) {
+        entry.sticky = sticky;
+        entry.sticky_remaining = sticky;
+    }
+    if (group !== undefined) {
+        if (group === null)
+            delete entry.group;
+        else
+            entry.group = group;
+    }
+    state.saveNovel(novel);
+    return ok(`Lore entry '${key}' updated.`);
+});
+server.registerTool("remove_lore_entry", {
+    title: "Remove Lore Entry",
+    description: "Remove a lore entry. Game Master only.",
+    inputSchema: { key: z.string() },
+}, async ({ key }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    if (!novel.lore.has(key))
+        return err("NOT_FOUND", `Lore entry '${key}' not found.`);
+    novel.lore.delete(key);
+    state.saveNovel(novel);
+    return ok(`Lore entry '${key}' removed.`);
+});
+server.registerTool("toggle_lore_entry", {
+    title: "Toggle Lore Entry",
+    description: "Enable or disable a lore entry. Game Master only.",
+    inputSchema: { key: z.string() },
+}, async ({ key }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const entry = novel.lore.get(key);
+    if (!entry)
+        return err("NOT_FOUND", `Lore entry '${key}' not found.`);
+    entry.enabled = !entry.enabled;
+    state.saveNovel(novel);
+    return ok(`Lore entry '${key}' ${entry.enabled ? "enabled" : "disabled"}.`);
+});
+server.registerTool("set_lore_group", {
+    title: "Set Lore Group",
+    description: "Assign or remove a lore entry from a named group. Game Master only.",
+    inputSchema: { key: z.string(), group: z.string().nullable() },
+}, async ({ key, group }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const entry = novel.lore.get(key);
+    if (!entry)
+        return err("NOT_FOUND", `Lore entry '${key}' not found.`);
+    if (group === null || group === undefined)
+        delete entry.group;
+    else
+        entry.group = group;
+    state.saveNovel(novel);
+    return ok(`Lore entry '${key}' group ${group ? `set to '${group}'` : "removed"}.`);
+});
+server.registerTool("suggest_lore", {
+    title: "Suggest Lore",
+    description: "Suggest lore entries from enrichment templates based on current scene. Game Master only.",
+    inputSchema: {},
+}, async () => {
+    requireGM();
+    const novel = requireNovel();
+    const templates = state.enrichmentManifest?.lore_templates ?? [];
+    if (templates.length === 0)
+        return ok("No lore templates available (enrichment not loaded).");
+    const sample = templates.slice(0, 3).map((t) => `- ${t.content?.substring(0, 120)}${(t.content?.length ?? 0) > 120 ? "..." : ""}`);
+    return raw(sample.join("\n"));
+});
+server.registerTool("export_lorebook", {
+    title: "Export Lorebook",
+    description: "Export novel lore entries in interchange format. Game Master only.",
+    inputSchema: { format: z.enum(["json", "markdown"]).optional() },
+}, async ({ format: fmt }) => {
+    requireGM();
+    const novel = requireNovel();
+    const entries = [...novel.lore.values()];
+    if (fmt === "markdown") {
+        let md = "# Lorebook\n\n";
+        for (const e of entries) {
+            md += `## ${e.key}\n${e.content}\n_triggers: ${e.triggers.join(", ")}_\n\n`;
+        }
+        return raw(md);
+    }
+    return raw(JSON.stringify(entries.map(e => ({
+        key: e.key, content: e.content, triggers: e.triggers,
+        badge_scope: e.badge_scope, priority: e.priority, sticky: e.sticky,
+        enabled: e.enabled, group: e.group,
+    })), null, 2));
+});
+server.registerTool("import_lorebook", {
+    title: "Import Lorebook",
+    description: "Import lore entries from JSON or Markdown. Modes: dry-run, merge, or replace. Game Master only.",
+    inputSchema: {
+        data: z.string(),
+        mode: z.enum(["dry-run", "merge", "replace"]).optional(),
+    },
+}, async ({ data, mode }) => {
+    requireGM();
+    const novel = requireNovel();
+    const m = mode ?? "dry-run";
+    try {
+        const parsed = JSON.parse(data);
+        if (!Array.isArray(parsed))
+            return err("INVALID_INPUT", "Expected an array of lore entries.");
+        if (m === "dry-run") {
+            return ok(`Dry-run: ${parsed.length} lore entries would be imported.`);
+        }
+        if (m === "replace")
+            novel.lore.clear();
+        for (const e of parsed) {
+            novel.lore.set(e.key, {
+                key: e.key, content: e.content, triggers: e.triggers ?? [],
+                badge_scope: e.badge_scope ?? "game_master", priority: e.priority ?? 0,
+                sticky: e.sticky ?? 0, sticky_remaining: e.sticky ?? 0,
+                enabled: e.enabled ?? true, group: e.group,
+            });
+        }
+        state.saveNovel(novel);
+        return ok(`Imported ${parsed.length} lore entries (${m} mode).`);
+    }
+    catch {
+        return err("INVALID_INPUT", "Could not parse lorebook data. Provide valid JSON array.");
+    }
+});
+// --- Conditions (GM) ---
+server.registerTool("apply_condition", {
+    title: "Apply Condition",
+    description: "Apply a condition to an entity.",
+    inputSchema: { entity_id: z.string(), condition: z.string(), rounds: z.number().optional() },
+}, async ({ entity_id, condition, rounds }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const entity = novel.entities.get(entity_id) ?? novel.npcs.get(entity_id);
+    if (!entity)
+        return err("NOT_FOUND", `Entity '${entity_id}' not found.`);
+    if (!entity.conditions)
+        entity.conditions = [];
+    if (!entity.condition_rounds)
+        entity.condition_rounds = {};
+    if (!entity.conditions.includes(condition))
+        entity.conditions.push(condition);
+    if (rounds)
+        entity.condition_rounds[condition] = rounds;
+    state.saveNovel(novel);
+    return ok(`'${condition}' applied to '${entity_id}'${rounds ? ` for ${rounds} rounds` : ""}.`);
+});
+server.registerTool("remove_condition", {
+    title: "Remove Condition",
+    description: "Remove a condition from an entity.",
+    inputSchema: { entity_id: z.string(), condition: z.string() },
+}, async ({ entity_id, condition }) => {
+    requireGM();
+    const novel = requireNovel();
+    novelSnapshot();
+    const entity = novel.entities.get(entity_id) ?? novel.npcs.get(entity_id);
+    if (!entity)
+        return err("NOT_FOUND", `Entity '${entity_id}' not found.`);
+    if (!entity.conditions)
+        return ok(`Entity '${entity_id}' has no conditions.`);
+    entity.conditions = entity.conditions.filter((c) => c !== condition);
+    delete entity.condition_rounds[condition];
+    state.saveNovel(novel);
+    return ok(`'${condition}' removed from '${entity_id}'.`);
+});
+// --- Factions (GM) ---
+server.registerTool("create_faction", {
+    title: "Create Faction",
+    description: "Create a named faction with goals, resources, and a progress clock. Game Master only.",
+    inputSchema: { name: z.string(), description: z.string().optional(), goals: z.array(z.string()).optional(), resources: z.string().optional() },
+}, async ({ name, description, goals, resources }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (novel.factions.some(f => f.name === name))
+        return err("STATE_CONFLICT", `Faction '${name}' already exists.`);
+    const faction = {
+        id: `faction_${Date.now().toString(36)}`,
+        name, description: description ?? "", goals: goals ?? [], resources: resources ?? "", clock: 0, clock_max: 10, status: "neutral",
+    };
+    novel.factions.push(faction);
+    state.saveNovel(novel);
+    audit("create_faction", { name, description, goals });
+    return ok(`Faction '${name}' created (${faction.id}).`);
+});
+server.registerTool("update_faction", {
+    title: "Update Faction",
+    description: "Update a faction's fields. Game Master only.",
+    inputSchema: { faction_id: z.string(), description: z.string().optional(), goals: z.array(z.string()).optional(), resources: z.string().optional() },
+}, async ({ faction_id, ...fields }) => {
+    requireGM();
+    const novel = requireNovel();
+    const faction = novel.factions.find(f => f.id === faction_id);
+    if (!faction)
+        return err("NOT_FOUND", `Faction '${faction_id}' not found.`);
+    Object.assign(faction, fields);
+    state.saveNovel(novel);
+    return ok(`Faction '${faction.name}' updated.`);
+});
+server.registerTool("remove_faction", {
+    title: "Remove Faction",
+    description: "Remove a faction and its clock. Game Master only.",
+    inputSchema: { faction_id: z.string() },
+}, async ({ faction_id }) => {
+    requireGM();
+    const novel = requireNovel();
+    const idx = novel.factions.findIndex(f => f.id === faction_id);
+    if (idx === -1)
+        return err("NOT_FOUND", `Faction '${faction_id}' not found.`);
+    const name = novel.factions[idx].name;
+    novel.factions.splice(idx, 1);
+    state.saveNovel(novel);
+    audit("remove_faction", { faction_id });
+    return ok(`Faction '${name}' removed.`);
+});
+// --- Secrets (GM) ---
+server.registerTool("set_secret", {
+    title: "Set Secret",
+    description: "Create a secret lore entry. GM-only; visible to entities after reveal_secret. Game Master only.",
+    inputSchema: { key: z.string(), content: z.string(), triggers: z.array(z.string()).optional(), badge_scope: z.enum(["game_master", "shared"]).optional() },
+}, async ({ key, content, triggers, badge_scope }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (novel.secrets.some(s => s.key === key))
+        return err("STATE_CONFLICT", `Secret '${key}' already exists.`);
+    novel.secrets.push({ key, content, triggers: triggers ?? [], badge_scope: badge_scope ?? "game_master", known_by: [] });
+    state.saveNovel(novel);
+    return ok(`Secret '${key}' created.`);
+});
+server.registerTool("reveal_secret", {
+    title: "Reveal Secret",
+    description: "Make a secret known to a specific entity. Game Master only.",
+    inputSchema: { key: z.string(), entity_id: z.string() },
+}, async ({ key, entity_id }) => {
+    requireGM();
+    const novel = requireNovel();
+    const secret = novel.secrets.find(s => s.key === key);
+    if (!secret)
+        return err("NOT_FOUND", `Secret '${key}' not found.`);
+    if (!novel.entities.has(entity_id))
+        return err("NOT_FOUND", `Entity '${entity_id}' not found.`);
+    if (!secret.known_by.includes(entity_id))
+        secret.known_by.push(entity_id);
+    state.saveNovel(novel);
+    return ok(`Secret '${key}' revealed to '${entity_id}'.`);
+});
+server.registerTool("get_knowledge", {
+    title: "Get Knowledge",
+    description: "Return what secrets an entity knows. Game Master only.",
+    inputSchema: { entity_id: z.string(), key: z.string().optional() },
+}, async ({ entity_id, key }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (!novel.entities.has(entity_id))
+        return err("NOT_FOUND", `Entity '${entity_id}' not found.`);
+    const known = novel.secrets.filter(s => s.known_by.includes(entity_id));
+    if (key) {
+        const s = known.find(s => s.key === key);
+        return raw(JSON.stringify(s ?? { key, known: false }));
+    }
+    return raw(JSON.stringify(known.map(s => ({ key: s.key, content: s.content }))));
+});
+// --- Relationships (GM) ---
+server.registerTool("set_relationship", {
+    title: "Set Relationship",
+    description: "Set a directed relationship between entities, NPCs, or factions. Types: ally, rival, neutral, mentor, dependent, suspicious. Game Master only.",
+    inputSchema: { entity_a: z.string(), entity_b: z.string(), type: z.enum(["ally", "rival", "neutral", "mentor", "dependent", "suspicious"]), value: z.number().optional(), description: z.string().optional() },
+}, async ({ entity_a, entity_b, type, value, description }) => {
+    requireGM();
+    const novel = requireNovel();
+    novel.relationships.push({ entity_a, entity_b, type, value, description });
+    state.saveNovel(novel);
+    return ok(`Relationship set: ${entity_a} -> ${entity_b} (${type}).`);
+});
+server.registerTool("get_relationships", {
+    title: "Get Relationships",
+    description: "Return all relationships (incoming and outgoing) for an entity. Game Master only.",
+    inputSchema: { entity_id: z.string() },
+}, async ({ entity_id }) => {
+    requireGM();
+    const novel = requireNovel();
+    const outgoing = novel.relationships.filter(r => r.entity_a === entity_id);
+    const incoming = novel.relationships.filter(r => r.entity_b === entity_id);
+    return raw(JSON.stringify({ outgoing, incoming }, null, 2));
+});
+// --- Vows (GM) ---
+server.registerTool("set_vow", {
+    title: "Set Vow",
+    description: "Track a narrative vow, quest, or obligation. Game Master only.",
+    inputSchema: { name: z.string(), description: z.string(), parties: z.array(z.string()), difficulty: z.enum(["troublesome", "dangerous", "formidable", "extreme", "epic"]), scope: z.enum(["gm", "shared", "faction", "party"]).optional() },
+}, async ({ name, description, parties, difficulty, scope }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (novel.vows.some(v => v.name === name))
+        return err("STATE_CONFLICT", `Vow '${name}' already exists.`);
+    novel.vows.push({
+        name, description, parties, difficulty: difficulty, scope: scope ?? "shared",
+        milestones: 0, rank_track: DIFFICULTY_TRACKS[difficulty] ?? 10, state: "active",
+    });
+    state.saveNovel(novel);
+    return ok(`Vow '${name}' set (${difficulty}, ${DIFFICULTY_TRACKS[difficulty]} milestones).`);
+});
+server.registerTool("mark_milestone", {
+    title: "Mark Milestone",
+    description: "Advance a vow's progress by one milestone. Game Master only.",
+    inputSchema: { vow_name: z.string() },
+}, async ({ vow_name }) => {
+    requireGM();
+    const novel = requireNovel();
+    const vow = novel.vows.find(v => v.name === vow_name);
+    if (!vow)
+        return err("NOT_FOUND", `Vow '${vow_name}' not found.`);
+    vow.milestones++;
+    state.saveNovel(novel);
+    return ok(`Vow '${vow_name}' progress: ${vow.milestones}/${vow.rank_track} milestones.`);
+});
+server.registerTool("resolve_vow", {
+    title: "Resolve Vow",
+    description: "Close a completed vow with outcome and consequences. Game Master only.",
+    inputSchema: { vow_name: z.string(), outcome: z.string(), consequences: z.string().optional() },
+}, async ({ vow_name, outcome, consequences }) => {
+    requireGM();
+    const novel = requireNovel();
+    const vow = novel.vows.find(v => v.name === vow_name);
+    if (!vow)
+        return err("NOT_FOUND", `Vow '${vow_name}' not found.`);
+    vow.state = "resolved";
+    vow.outcome = outcome;
+    vow.consequences = consequences;
+    state.saveNovel(novel);
+    return ok(`Vow '${vow_name}' resolved.`);
+});
+server.registerTool("forsake_vow", {
+    title: "Forsake Vow",
+    description: "Abandon a vow with a reason. Game Master only.",
+    inputSchema: { vow_name: z.string(), reason: z.string() },
+}, async ({ vow_name, reason }) => {
+    requireGM();
+    const novel = requireNovel();
+    const vow = novel.vows.find(v => v.name === vow_name);
+    if (!vow)
+        return err("NOT_FOUND", `Vow '${vow_name}' not found.`);
+    vow.state = "forsaken";
+    vow.reason = reason;
+    state.saveNovel(novel);
+    return ok(`Vow '${vow_name}' forsaken.`);
+});
+// --- Story Journal (GM) ---
+server.registerTool("record_story", {
+    title: "Record Story",
+    description: "Record a narrative memory in the story journal. Types: decision, moment, revelation, bond, consequence. Game Master only.",
+    inputSchema: { type: z.enum(["decision", "moment", "revelation", "bond", "consequence"]), entry: z.string() },
+}, async ({ type, entry }) => {
+    requireGM();
+    const novel = requireNovel();
+    const index = novel.story_journal.length;
+    novel.story_journal.push({
+        index, type, entry,
+        scene_anchor: novel.scene_description?.substring(0, 80) ?? "",
+        entity_ids: [],
+        timestamp: new Date().toISOString(),
+    });
+    state.saveNovel(novel);
+    return ok(`Story entry #${index} recorded (${type}).`);
+});
+server.registerTool("update_story", {
+    title: "Update Story",
+    description: "Edit a story journal entry by index. Decision and consequence entries are immutable. Game Master only.",
+    inputSchema: { index: z.number().min(0), type: z.enum(["decision", "moment", "revelation", "bond", "consequence"]).optional(), entry: z.string().optional() },
+}, async ({ index, type, entry }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (index >= novel.story_journal.length)
+        return err("NOT_FOUND", `Story entry #${index} not found.`);
+    const story = novel.story_journal[index];
+    if (story.type === "decision" || story.type === "consequence")
+        return err("STATE_CONFLICT", `${story.type} entries are immutable.`);
+    if (type)
+        story.type = type;
+    if (entry)
+        story.entry = entry;
+    state.saveNovel(novel);
+    return ok(`Story entry #${index} updated.`);
+});
+server.registerTool("remove_story", {
+    title: "Remove Story",
+    description: "Delete a story journal entry by index. Game Master only.",
+    inputSchema: { index: z.number().min(0) },
+}, async ({ index }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (index >= novel.story_journal.length)
+        return err("NOT_FOUND", `Story entry #${index} not found.`);
+    novel.story_journal.splice(index, 1);
+    state.saveNovel(novel);
+    return ok(`Story entry #${index} removed.`);
+});
+server.registerTool("list_stories", {
+    title: "List Stories",
+    description: "List story journal entries with optional type filter and pagination. Game Master only.",
+    inputSchema: { filter: z.enum(["decision", "moment", "revelation", "bond", "consequence"]).optional(), offset: z.number().min(0).optional(), limit: z.number().min(0).optional(), ...detailZod },
+}, async ({ filter, offset, limit, detail }) => {
+    requireGM();
+    const novel = requireNovel();
+    let entries = [...novel.story_journal];
+    if (filter)
+        entries = entries.filter(e => e.type === filter);
+    if (offset)
+        entries = entries.slice(offset);
+    if (limit)
+        entries = entries.slice(0, limit);
+    if (wantsDetail(detail))
+        return raw(JSON.stringify(entries, null, 2));
+    return raw(JSON.stringify(entries.map(e => ({ type: e.type, timestamp: e.timestamp, preview: (e.entry ?? "").substring(0, 120) })), null, 2));
+});
+// --- Notes ---
+server.registerTool("set_note", {
+    title: "Set Note",
+    description: "Create or update a key-value note. Badge-scoped: game_master (default), player, or shared.",
+    inputSchema: { key: z.string(), content: z.string(), badge_scope: z.enum(["game_master", "player", "shared"]).optional() },
+}, async ({ key, content, badge_scope }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    const existing = novel.notes.find(n => n.key === key);
+    // Default scope is game_master (REQ-242); the Player badge cannot write GM-scoped notes.
+    const scope = badge_scope ?? "game_master";
+    if (novel.badge === "player" && scope === "game_master") {
+        return err("FORBIDDEN", "The Player badge cannot write a game_master-scoped note.");
+    }
+    if (existing) {
+        if (novel.badge === "player" && existing.badge_scope === "game_master") {
+            return err("FORBIDDEN", "The Player badge cannot modify a game_master-scoped note.");
+        }
+        existing.content = content;
+        existing.badge_scope = scope;
+    }
+    else {
+        novel.notes.push({ key, content, badge_scope: scope });
+    }
+    state.saveNovel(novel);
+    return ok(`Note '${key}' set.`);
+});
+server.registerTool("remove_note", {
+    title: "Remove Note",
+    description: "Remove a note by key. Badge-scoped: caller's badge must own the scope.",
+    inputSchema: { key: z.string() },
+}, async ({ key }) => {
+    requireNotObserver();
+    const novel = requireNovel();
+    const idx = novel.notes.findIndex(n => n.key === key);
+    if (idx === -1)
+        return err("NOT_FOUND", `Note '${key}' not found.`);
+    const note = novel.notes[idx];
+    if (novel.badge === "player" && note.badge_scope === "game_master") {
+        return err("FORBIDDEN", "The Player badge cannot remove a game_master-scoped note.");
+    }
+    novel.notes.splice(idx, 1);
+    state.saveNovel(novel);
+    return ok(`Note '${key}' removed.`);
+});
+server.registerTool("list_notes", {
+    title: "List Notes",
+    description: "List all notes (100-character preview), badge-filtered.",
+    inputSchema: {},
+}, async () => {
+    const novel = requireNovel();
+    const badge = novel.badge;
+    const filtered = badge === "game_master" || badge === "none" ? novel.notes
+        : novel.notes.filter(n => n.badge_scope !== "game_master");
+    return raw(JSON.stringify(filtered.map(n => ({ key: n.key, badge_scope: n.badge_scope, preview: n.content.substring(0, 100) })), null, 2));
+});
+// --- Server Notes (GM) ---
+server.registerTool("set_server_note", {
+    title: "Set Server Note",
+    description: "Create or update a server-level note. Game Master only.",
+    inputSchema: { key: z.string(), content: z.string() },
+}, async ({ key, content }) => {
+    requireGM();
+    state.serverNotes.set(key, content);
+    state.saveServerNotes();
+    return ok(`Server note '${key}' set.`);
+});
+server.registerTool("remove_server_note", {
+    title: "Remove Server Note",
+    description: "Remove a server-level note. Game Master only.",
+    inputSchema: { key: z.string() },
+}, async ({ key }) => {
+    requireGM();
+    if (!state.serverNotes.has(key))
+        return err("NOT_FOUND", `Server note '${key}' not found.`);
+    state.serverNotes.delete(key);
+    state.saveServerNotes();
+    return ok(`Server note '${key}' removed.`);
+});
+server.registerTool("list_server_notes", {
+    title: "List Server Notes",
+    description: "List all server-level notes. Game Master only.",
+    inputSchema: {},
+}, async () => {
+    requireGM();
+    const notes = Object.fromEntries(state.serverNotes);
+    return raw(JSON.stringify(notes, null, 2));
+});
+// --- Pause/Resume (GM) ---
+server.registerTool("set_pause_context", {
+    title: "Set Pause Context",
+    description: "Save GM context for session resumption. Game Master only.",
+    inputSchema: { current_scene: z.string().optional(), immediate_situation: z.string().optional(), pending_player_action: z.string().optional(), short_term_plans: z.string().optional(), long_term_plans: z.string().optional(), player_goals: z.string().optional() },
+}, async (fields) => {
+    requireGM();
+    const novel = requireNovel();
+    // Auto-capture derived context (REQ-232): faction clocks, countdown positions,
+    // NPC dispositions, relationships, recent story entries, and active vows.
+    const f = {
+        ...fields,
+        faction_clocks: novel.factions.map(x => ({ name: x.name, clock: x.clock, clock_max: x.clock_max, status: x.status })),
+        countdown_positions: [...novel.countdowns.entries()].map(([name, cd]) => ({ name, ticks: cd.ticks, total: cd.total })),
+        npc_dispositions: [...novel.npcs.values()].map(n => ({ name: n.name, disposition: n.disposition, location: n.location })),
+        relationships: novel.relationships,
+        story_context: novel.story_journal.slice(-3).map(s => s.entry),
+        active_vows: novel.vows.filter(v => v.state === "active").map(v => ({ name: v.name, difficulty: v.difficulty, milestone_count: v.milestones })),
+    };
+    novel.gm_context = { ...novel.gm_context, ...f, saved_at: new Date().toISOString() };
+    state.saveNovel(novel);
+    return ok("Pause context saved.");
+});
+server.registerTool("get_pause_context", {
+    title: "Get Pause Context",
+    description: "Return the saved GM context plus Novel state summary for session resumption.",
+    inputSchema: {},
+}, async () => {
+    const novel = requireNovel();
+    return raw(JSON.stringify({
+        gm_context: novel.gm_context,
+        novel_slug: novel.slug,
+        scene: novel.scene_description,
+        world_rooms: novel.world.rooms.size,
+        npcs: novel.npcs.size,
+        active_vows: novel.vows.filter(v => v.state === "active"),
+    }, null, 2));
+});
+// --- Checkpoints (GM) ---
+server.registerTool("set_checkpoint", {
+    title: "Set Checkpoint",
+    description: "Save a named checkpoint of the full Novel state. Game Master only.",
+    inputSchema: { label: z.string() },
+}, async ({ label }) => {
+    requireGM();
+    const novel = requireNovel();
+    novel.checkpoints.push({ label, timestamp: new Date().toISOString(), state: JSON.parse(JSON.stringify(novelToJSONState(novel))) });
+    state.saveNovel(novel);
+    return ok(`Checkpoint '${label}' saved.`);
+});
+server.registerTool("list_checkpoints", {
+    title: "List Checkpoints",
+    description: "List all checkpoints for the active Novel. Game Master only.",
+    inputSchema: {},
+}, async () => {
+    requireGM();
+    const novel = requireNovel();
+    return raw(JSON.stringify(novel.checkpoints.map(c => ({ label: c.label, timestamp: c.timestamp })), null, 2));
+});
+server.registerTool("restore_checkpoint", {
+    title: "Restore Checkpoint",
+    description: "Restore a checkpoint (confirmation required). Game Master only.",
+    inputSchema: { label: z.string() },
+}, async ({ label }) => {
+    requireGM();
+    const novel = requireNovel();
+    const cp = novel.checkpoints.find(c => c.label === label);
+    if (!cp)
+        return err("NOT_FOUND", `Checkpoint '${label}' not found.`);
+    const restored = loadNovelFromStateData(cp.state);
+    novel.entities = restored.entities;
+    novel.npcs = restored.npcs;
+    novel.scene_description = restored.scene_description;
+    novel.scene_location = restored.scene_location;
+    novel.combat = restored.combat;
+    novel.countdowns = restored.countdowns;
+    novel.lore = restored.lore;
+    novel.world = restored.world;
+    novel.story_journal = restored.story_journal;
+    novel.factions = restored.factions;
+    novel.secrets = restored.secrets;
+    novel.relationships = restored.relationships;
+    novel.vows = restored.vows;
+    novel.notes = restored.notes;
+    state.saveNovel(novel);
+    return ok(`Checkpoint '${label}' restored.`);
+});
+server.registerTool("remove_checkpoint", {
+    title: "Remove Checkpoint",
+    description: "Remove a named checkpoint. Game Master only.",
+    inputSchema: { label: z.string() },
+}, async ({ label }) => {
+    requireGM();
+    const novel = requireNovel();
+    const idx = novel.checkpoints.findIndex(c => c.label === label);
+    if (idx === -1)
+        return err("NOT_FOUND", `Checkpoint '${label}' not found.`);
+    novel.checkpoints.splice(idx, 1);
+    state.saveNovel(novel);
+    return ok(`Checkpoint '${label}' removed.`);
+});
+// --- Novel Lifecycle additions (GM) ---
+server.registerTool("rename_novel", {
+    title: "Rename Novel",
+    description: "Rename the active Novel on disk. Game Master only.",
+    inputSchema: { new_slug: z.string() },
+}, async ({ new_slug }) => {
+    requireGM();
+    const novel = requireNovel();
+    const oldSlug = novel.slug;
+    novel.slug = new_slug.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    novel.name = new_slug;
+    state.novels.delete(oldSlug);
+    state.novels.set(novel.slug, novel);
+    // Delete old file, save at new path
+    const oldFile = path.join(DATA_DIR, "novels", `${oldSlug}.json`);
+    if (fs.existsSync(oldFile))
+        fs.unlinkSync(oldFile);
+    const oldBak = oldFile + ".bak";
+    if (fs.existsSync(oldBak))
+        fs.unlinkSync(oldBak);
+    state.saveNovel(novel);
+    return ok(`Novel renamed to '${novel.slug}'.`);
+});
+server.registerTool("list_novels", {
+    title: "List Novels",
+    description: "List all Novels on disk with metadata. Always callable.",
+    inputSchema: { ...detailZod },
+}, async ({ detail }) => {
+    const novels = [...state.novels.entries()].map(([slug, n]) => {
+        if (wantsDetail(detail)) {
+            return { slug, name: n.name, entities: n.entities.size, npcs: n.npcs.size, lore: n.lore.size, world_rooms: n.world.rooms.size, modified: n.metadata.modified };
+        }
+        return { slug, name: n.name, entities: n.entities.size, modified: n.metadata.modified };
+    });
+    return raw(JSON.stringify(novels, null, 2));
+});
+server.registerTool("novel_info", {
+    title: "Novel Info",
+    description: "Return extended metadata for a Novel. Always callable.",
+    inputSchema: { slug: z.string().optional() },
+}, async ({ slug }) => {
+    const novel = slug ? state.novels.get(slug) : state.activeNovel;
+    if (!novel)
+        return err("NOT_FOUND", `Novel '${slug || "none"}' not found.`);
+    return raw(JSON.stringify({
+        slug: novel.slug, name: novel.name, ruleset: novel.ruleset, description: novel.description, genre: novel.genre,
+        entities: novel.entities.size, npcs: novel.npcs.size, lore: novel.lore.size,
+        world_rooms: novel.world.rooms.size, world_things: novel.world.things.size,
+        factions: novel.factions.length, vows: novel.vows.length,
+        scene: novel.scene_description ? novel.scene_description.substring(0, 100) : null,
+        created: novel.metadata.created, modified: novel.metadata.modified,
+    }, null, 2));
+});
+server.registerTool("clone_novel", {
+    title: "Clone Novel",
+    description: "Create an independent copy of a Novel. Game Master only.",
+    inputSchema: { source_slug: z.string(), new_name: z.string(), trim_audit_sessions: z.number().min(0).optional() },
+}, async ({ source_slug, new_name }) => {
+    requireGM();
+    const source = state.novels.get(source_slug);
+    if (!source)
+        return err("NOT_FOUND", `Source novel '${source_slug}' not found.`);
+    const slug = new_name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const clone = JSON.parse(JSON.stringify(novelToJSONState(source)));
+    clone.slug = slug;
+    clone.name = new_name;
+    clone.metadata.created = new Date().toISOString();
+    clone.metadata.modified = new Date().toISOString();
+    const novel = loadNovelFromStateData(clone);
+    state.novels.set(slug, novel);
+    state.saveNovel(novel);
+    return ok(`Cloned '${source_slug}' as '${slug}'.`);
+});
+// --- Entity Management ---
+server.registerTool("remove_entity", {
+    title: "Remove Entity",
+    description: "Remove an entity from the active Novel. Game Master only.",
+    inputSchema: { entity_id: z.string() },
+}, async ({ entity_id }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (!novel.entities.has(entity_id))
+        return err("NOT_FOUND", `Entity '${entity_id}' not found.`);
+    novel.entities.delete(entity_id);
+    if (novel.active_entity_id === entity_id)
+        novel.active_entity_id = null;
+    state.saveNovel(novel);
+    return ok(`Entity '${entity_id}' removed.`);
+});
+server.registerTool("remove_roster_character", {
+    title: "Remove Roster Character",
+    description: "Remove a character from the roster. Game Master only.",
+    inputSchema: { roster_id: z.string() },
+}, async ({ roster_id }) => {
+    requireGM();
+    if (!state.roster.has(roster_id))
+        return err("NOT_FOUND", `Roster character '${roster_id}' not found.`);
+    state.roster.delete(roster_id);
+    state.saveRoster();
+    return ok(`Roster character '${roster_id}' removed.`);
+});
+server.registerTool("list_roster_characters", {
+    title: "List Roster Characters",
+    description: "List all characters in the roster.",
+    inputSchema: {},
+}, async () => {
+    const chars = [...state.roster.entries()].map(([id, e]) => ({ id, name: e.name }));
+    return raw(JSON.stringify(chars, null, 2));
+});
+// --- Special tools ---
+server.registerTool("toggle_action_patterns", {
+    title: "Toggle Action Patterns",
+    description: "Toggle enrich-derived action patterns on or off for the active Novel. Game Master only.",
+    inputSchema: {},
+}, async () => {
+    requireGM();
+    const novel = requireNovel();
+    novel.action_patterns_enabled = !novel.action_patterns_enabled;
+    state.saveNovel(novel);
+    return ok(`Action patterns ${novel.action_patterns_enabled ? "enabled" : "disabled"}.`);
+});
+server.registerTool("present_choices", {
+    title: "Present Choices",
+    description: "Present structured choice prompts to the player. Resolved via respond. Game Master only.",
+    inputSchema: {
+        prompt: z.string(),
+        choices: z.array(z.object({ id: z.string(), label: z.string(), description: z.string().optional() })),
+        allow_freeform: z.boolean().optional(),
+    },
+}, async ({ prompt, choices, allow_freeform }) => {
+    requireGM();
+    const novel = requireNovel();
+    novel.pending_workflow = { decision: "present_choices", snapshot: { prompt, choices, allow_freeform } };
+    state.saveNovel(novel);
+    const opts = choices.map((c) => `  **${c.id}** — ${c.label}${c.description ? `: ${c.description}` : ""}`).join("\n");
+    return needInput(`Decision: -present_choices-\nQuestion: ${prompt}\n\nOptions:\n${opts}${allow_freeform ? "\n\nYou may also respond with a freeform answer." : ""}`);
+});
+server.registerTool("ask_oracle", {
+    title: "Ask Oracle",
+    description: "Resolve uncertainty with a d100 roll against the Ask-the-Oracle ladder: almost_certain (≥11), likely (≥26), 50_50 (≥51), unlikely (≥76), small_chance (≥91). Defaults to 50_50 when likelihood is omitted. Callable by Player and Game Master.",
+    inputSchema: { question: z.string(), likelihood: z.enum(["almost_certain", "likely", "50_50", "unlikely", "small_chance"]).optional(), seed: z.string().optional() },
+}, async ({ question, likelihood, seed }) => {
+    requireNotObserver();
+    requireNovel();
+    // Ask-the-Oracle ladder (REQ-291): each tier is a d100 target the roll must
+    // meet or exceed for a YES. Omitted likelihood defaults to 50_50.
+    const thresholds = { almost_certain: 11, likely: 26, "50_50": 51, unlikely: 76, small_chance: 91 };
+    const band = likelihood ?? "50_50";
+    const target = thresholds[band] ?? 51;
+    // Seeded draw uses an isolated Rng (REQ-050b); otherwise the session PRNG.
+    const roll = seed ? createRng(seed).roll(100) : sessionRoll(100);
+    const yes = roll >= target;
+    // Doubles on the d100 (11, 22, …, 99) produce an exceptional result (REQ-291).
+    const isDoubles = roll % 11 === 0;
+    const marker = isDoubles
+        ? (yes ? "[EXCEPTIONAL_YES]" : "[EXCEPTIONAL_NO]")
+        : (yes ? "[YES]" : "[NO]");
+    audit("ask_oracle", { question, likelihood: band, seed });
+    let flavor = "";
+    if (!isDoubles && Math.abs(target - roll) <= 5)
+        flavor = " (barely)";
+    else if (!isDoubles && Math.abs(target - roll) >= 30)
+        flavor = " (decisively)";
+    return ok(`Question: "${question}"\nLikelihood: ${band} (roll ≥ ${target})\nRoll: ${roll}/100 → ${marker}${flavor}`);
+});
+// ── Serialization helpers (used by checkpoint/export) ──────────────
+function novelToJSONState(novel) {
+    return {
+        slug: novel.slug, name: novel.name, ruleset: novel.ruleset, badge: novel.badge,
+        entities: Object.fromEntries(novel.entities), active_entity_id: novel.active_entity_id,
+        npcs: Object.fromEntries(novel.npcs),
+        scene_description: novel.scene_description, scene_location: novel.scene_location,
+        scene_time_of_day: novel.scene_time_of_day, scene_atmosphere: novel.scene_atmosphere,
+        scene_history: novel.scene_history, scene_type: novel.scene_type,
+        narrative_directive: novel.narrative_directive, combat: novel.combat,
+        countdowns: Object.fromEntries(novel.countdowns), lore: Object.fromEntries(novel.lore),
+        briefing_order: novel.briefing_order, action_patterns_enabled: novel.action_patterns_enabled,
+        story_journal: novel.story_journal, factions: novel.factions, secrets: novel.secrets,
+        relationships: novel.relationships, gm_context: novel.gm_context, notes: novel.notes,
+        constraint_overrides: novel.constraint_overrides, synthesis_activated: novel.synthesis_activated, synthesis_module_enabled: novel.synthesis_module_enabled,
+        characters_present_ids: novel.characters_present_ids,
+        autonomy: novel.autonomy,
+        vows: novel.vows, checkpoints: novel.checkpoints, description: novel.description,
+        genre: novel.genre, adventure_index: novel.adventure_index,
+        adventure_scene_waypoint: novel.adventure_scene_waypoint,
+        world: { rooms: Object.fromEntries(novel.world.rooms), things: Object.fromEntries(novel.world.things) },
+        metadata: novel.metadata,
+    };
+}
+function loadNovelFromStateData(data) {
+    data = migrateNovelData(data);
+    const world = createEmptyWorldModel();
+    if (data.world?.rooms)
+        for (const [k, r] of Object.entries(data.world.rooms)) {
+            world.rooms.set(k, { name: r.name, description: r.description ?? "", exits: new Map(Object.entries(r.exits || {})), doorRefs: new Map(Object.entries(r.doorRefs || {})), annotations: r.annotations ?? {} });
+        }
+    if (data.world?.things)
+        for (const [k, t] of Object.entries(data.world.things)) {
+            world.things.set(k, { name: t.name, description: t.description ?? "", kind: t.kind ?? "thing", location: t.location ?? null, locationType: t.locationType ?? null, portable: t.portable ?? true, openable: t.openable ?? false, open: t.open ?? false, lockable: t.lockable ?? false, locked: t.locked ?? false, lit: t.lit ?? false, switchable: t.switchable ?? false, switched_on: t.switched_on ?? false, enterable: t.enterable ?? false, vehiclePassengers: t.vehiclePassengers ?? [], wearable: t.wearable ?? false, worn_by: t.worn_by ?? null, readable: t.readable ?? false, read_text: t.read_text ?? null, edible: t.edible ?? false, drinkable: t.drinkable ?? false, climbable: t.climbable ?? false, transparent: t.transparent ?? false, annotations: t.annotations ?? {} });
+        }
+    return {
+        slug: data.slug, name: data.name, ruleset: data.ruleset ?? null, badge: data.badge,
+        entities: new Map(Object.entries(data.entities ?? {})),
+        active_entity_id: data.active_entity_id ?? null,
+        npcs: new Map(Object.entries(data.npcs ?? {})),
+        scene_description: data.scene_description ?? "",
+        scene_location: data.scene_location, scene_time_of_day: data.scene_time_of_day,
+        scene_atmosphere: data.scene_atmosphere, scene_history: data.scene_history ?? [],
+        scene_type: normalizeSceneTypeState(data.scene_type),
+        narrative_directive: data.narrative_directive ?? "", combat: data.combat ?? null,
+        countdowns: new Map(Object.entries(data.countdowns ?? {})),
+        lore: new Map(Object.entries(data.lore ?? {})),
+        briefing_assembly_count: data.briefing_assembly_count ?? 0,
+        player_signals: data.player_signals ?? {}, adventure_slug: data.adventure_slug ?? null,
+        generated_adventure: data.generated_adventure ?? null,
+        audit_log: data.audit_log ?? [],
+        undo_stacks: { player: [], game_master: [], observer: [], none: [] },
+        redo_stacks: { player: [], game_master: [], observer: [], none: [] },
+        briefing_order: data.briefing_order ?? [],
+        action_patterns_enabled: data.action_patterns_enabled ?? false,
+        session_zero_completed: false, characters_present: false, characters_present_ids: data.characters_present_ids ?? [], adventure_set: false,
+        pending_workflow: data.pending_workflow ?? null,
+        connection_counter: 0, pending_staleness_counter: 0, pov_mode: "character",
+        help_category_overrides: {},
+        story_journal: data.story_journal ?? [], factions: data.factions ?? [],
+        secrets: data.secrets ?? [], relationships: data.relationships ?? [],
+        gm_context: data.gm_context ?? data.dm_context ?? {}, notes: data.notes ?? [], vows: data.vows ?? [],
+        checkpoints: data.checkpoints ?? [], description: data.description ?? "",
+        constraint_overrides: data.constraint_overrides ?? [],
+        synthesis_activated: data.synthesis_activated ?? {}, synthesis_module_enabled: data.synthesis_module_enabled ?? {},
+        autonomy: normalizeAutonomy(data.autonomy),
+        genre: data.genre ?? "", adventure_index: data.adventure_index ?? null,
+        adventure_scene_waypoint: data.adventure_scene_waypoint ?? null,
+        world, metadata: data.metadata ?? { created: new Date().toISOString(), modified: new Date().toISOString(), session_count: 0, total_combat_rounds: 0, last_scene_anchor: "" },
+    };
+}
+function normalizeSceneTypeState(raw) {
+    if (!raw)
+        return ["neutral"];
+    if (Array.isArray(raw))
+        return raw.filter((t) => ["combat", "social", "exploration", "neutral"].includes(t));
+    if (typeof raw === "string" && ["combat", "social", "exploration", "neutral"].includes(raw))
+        return [raw];
+    return ["neutral"];
+}
+// --- Guidance (GM) ---
+server.registerTool("set_briefing_order", {
+    title: "Set Briefing Order",
+    description: "Reorder sections of badge_briefing. Game Master only.",
+    inputSchema: { sections: z.array(z.string()) },
+}, async ({ sections }) => {
+    requireGM();
+    const novel = requireNovel();
+    novel.briefing_order = sections;
+    state.saveNovel(novel);
+    return ok(`Briefing order set to: ${sections.join(", ")}.`);
+});
+server.registerTool("compact_audit_log", {
+    title: "Compact Audit Log",
+    description: "Summarize recent audit entries. Callable by both badges.",
+    inputSchema: { max_entries: z.number().optional() },
+}, async ({ max_entries }) => {
+    const novel = requireNovel();
+    const max = max_entries ?? 20;
+    const recent = novel.audit_log.slice(-max);
+    const isGM = novel.badge === "game_master";
+    const filtered = isGM ? recent : recent.filter(e => e.badge !== "game_master");
+    if (filtered.length === 0)
+        return ok("No audit entries.");
+    const lines = filtered.map(e => `${e.timestamp.split("T")[1]?.substring(0, 8) || "?"} [${e.badge ?? "·"}] ${e.tool} → ${e.output_prefix || ""}`);
+    return raw(`## Audit (last ${filtered.length} entries)\n${lines.join("\n")}`);
+});
+server.registerTool("generate_adventure", {
+    title: "Generate Adventure",
+    description: "Generate an adventure scaffold from a premise. Game Master only.",
+    inputSchema: { premise: z.string() },
+}, async ({ premise }) => {
+    requireGM();
+    requireNovel();
+    return ok(`Adventure scaffold generated from premise: "${premise}". (Placeholder — world model must be populated with convert_source or adventure modules.)`);
+});
+server.registerTool("generate_encounter", {
+    title: "Generate Encounter",
+    description: "Generate a scene + NPC + lore entry from context. Game Master only.",
+    inputSchema: { context: z.string() },
+}, async ({ context }) => {
+    requireGM();
+    requireNovel();
+    return ok(`Encounter generated from context: "${context}". (Placeholder — no ruleset mechanics available.)`);
+});
+server.registerTool("load_adventure", {
+    title: "Load Adventure",
+    description: "Load an adventure module. Game Master only.",
+    inputSchema: { slug: z.string() },
+}, async ({ slug }) => {
+    requireGM();
+    const novel = requireNovel();
+    const adventureDir = process.env.TTRPG_ADVENTURE_DIR ?? path.join(__dirname, "..", "adventures");
+    const filePath = path.join(adventureDir, `${slug}.md`);
+    if (!fs.existsSync(filePath))
+        return err("NOT_FOUND", `Adventure '${slug}' not found at ${filePath}.`);
+    const content = fs.readFileSync(filePath, "utf-8");
+    // Parse ## World section if present
+    const worldMatch = content.match(/## World\s*\n([\s\S]*?)(?=\n## |$)/);
+    if (worldMatch) {
+        const { world, result } = convertSource(worldMatch[1], novel.world);
+        novel.world = world;
+        novel.adventure_slug = slug;
+        novel.adventure_set = true;
+        state.saveNovel(novel);
+        audit("load_adventure", { slug, rooms: result.rooms, things: result.things });
+        return ok(`Adventure '${slug}' loaded. World model: ${result.rooms} rooms, ${result.things} things, ${result.exits} exits.`);
+    }
+    novel.adventure_slug = slug;
+    novel.adventure_set = true;
+    state.saveNovel(novel);
+    return ok(`Adventure '${slug}' loaded (no world-model section found — flat prose only).`);
+});
+// --- Session ---
+server.registerTool("session_recap", {
+    title: "Session Recap",
+    description: "Summarize recent session activity.",
+    inputSchema: {},
+}, async () => {
+    const novel = requireNovel();
+    const entity = state.getActiveEntity();
+    let recap = `Active Novel: ${novel.name} (${novel.slug})`;
+    if (novel.scene_description) {
+        recap += `\nScene: ${novel.scene_description}${novel.scene_location ? ` — ${novel.scene_location}` : ""}`;
+    }
+    recap += state.combatReport(novel);
+    if (novel.world.rooms.size > 0) {
+        recap += `\n\nWorld model: ${novel.world.rooms.size} rooms, ${novel.world.things.size} things.`;
+    }
+    if (entity) {
+        recap += `\n\nActive entity: ${entity.name}${entity.current_room ? ` in ${entity.current_room}` : ""}`;
+        if (entity.inventory.length > 0) {
+            recap += ` — holding: ${entity.inventory.join(", ")}`;
+        }
+    }
+    const activeCountdowns = [...novel.countdowns.entries()].filter(([, cd]) => cd.ticks > 0);
+    if (activeCountdowns.length > 0) {
+        recap += `\nCountdowns: ${activeCountdowns.map(([name, cd]) => `${name}(${cd.ticks}/${cd.total})`).join(", ")}`;
+    }
+    const enabledLore = [...novel.lore.values()].filter(l => l.enabled);
+    if (enabledLore.length > 0) {
+        recap += `\nLore entries: ${enabledLore.length} active.`;
+    }
+    return ok(recap);
+});
+// --- Novel Lifecycle ---
+server.registerTool("create_novel", {
+    title: "Create Novel",
+    description: "Create a named novel. Novel persists to disk.",
+    inputSchema: { name: z.string(), ruleset: z.string().optional(), genre: z.string().optional(), description: z.string().optional() },
+}, async ({ name, ruleset, genre, description }) => {
+    requireNotObserver();
+    if (ruleset && !rulesets.isInstalled(ruleset)) {
+        return err("INVALID_INPUT", `Ruleset '${ruleset}' is not installed. Valid rulesets: ${rulesets.installedSlugs().join(", ") || "(none)"}.`);
+    }
+    const novel = state.createNovel(name, ruleset ?? null);
+    if (genre)
+        novel.genre = genre;
+    if (description)
+        novel.description = description;
+    if (genre || description)
+        state.saveNovel(novel);
+    if (ruleset) {
+        try {
+            rulesets.hydrate(ruleset);
+        }
+        catch (e) {
+            return err("INVALID_INPUT", e.message);
+        }
+    }
+    return ok(`Novel created: ${novel.slug} (novel://current)${ruleset ? `, ruleset: ${ruleset}` : ""}${genre ? `, genre: ${genre}` : ""}`);
+});
+server.registerTool("resume_novel", {
+    title: "Resume Novel",
+    description: "Resume a previously created novel from disk.",
+    inputSchema: { slug: z.string() },
+}, async ({ slug }) => {
+    const novel = state.resumeNovel(slug);
+    if (novel.ruleset) {
+        if (!rulesets.isInstalled(novel.ruleset)) {
+            return err("INVALID_INPUT", `Novel '${novel.slug}' is bound to ruleset '${novel.ruleset}', which is not installed.`);
+        }
+        try {
+            rulesets.hydrate(novel.ruleset);
+        }
+        catch (e) {
+            return err("INVALID_INPUT", e.message);
+        }
+    }
+    return ok(`Novel resumed: ${novel.name} (${novel.slug})`);
+});
+server.registerTool("switch_novel", {
+    title: "Switch Novel",
+    description: "Switch the active novel for this connection. Always callable.",
+    inputSchema: { slug: z.string() },
+}, async ({ slug }) => {
+    const novel = state.switchNovel(slug);
+    if (novel.ruleset) {
+        if (!rulesets.isInstalled(novel.ruleset)) {
+            return err("INVALID_INPUT", `Novel '${novel.slug}' is bound to ruleset '${novel.ruleset}', which is not installed.`);
+        }
+        try {
+            rulesets.hydrate(novel.ruleset);
+        }
+        catch (e) {
+            return err("INVALID_INPUT", e.message);
+        }
+    }
+    return ok(`Switched to novel: ${novel.name} (${novel.slug})`);
+});
+server.registerTool("end_novel", {
+    title: "End Novel",
+    description: "End the current novel. Deactivates badge, removes save file.",
+    inputSchema: {},
+}, async () => {
+    requireNotObserver();
+    const novel = requireNovel();
+    return needInput(`Decision: -end_novel-confirm
+Question: End Novel "${novel.name}"?
+Options: yes, cancel`);
+});
+server.registerTool("export_novel", {
+    title: "Export Novel",
+    description: "Export the active novel in interchange format. Game Master only.",
+    inputSchema: { format: z.enum(["json", "markdown"]).optional() },
+}, async ({ format: fmt }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (fmt === "markdown") {
+        let md = `# ${novel.name}\n\n`;
+        md += `## World\n`;
+        for (const [, room] of novel.world.rooms) {
+            md += `${room.name} is a room. "${room.description}"\n`;
+            for (const [dir, target] of room.exits) {
+                md += `${dir} of ${room.name} is ${target}.\n`;
+            }
+        }
+        for (const [, thing] of novel.world.things) {
+            if (thing.kind !== "thing") {
+                md += `${thing.name} is a ${thing.kind}. "${thing.description}"\n`;
+            }
+            md += `${thing.name} is in ${thing.location}.\n`;
+            if (!thing.portable)
+                md += `${thing.name} is fixed.\n`;
+            if (thing.openable && thing.open)
+                md += `${thing.name} is open.\n`;
+            if (thing.locked)
+                md += `${thing.name} is locked.\n`;
+        }
+        return raw(md);
+    }
+    const data = {
+        novel_format_version: "1",
+        server_spec_version: state.buildFingerprint.specVersion,
+        builder_implementation: "holonovel-ruleset-free",
+        ruleset_hash: novel.ruleset ?? null,
+        property_groups_present: [
+            "slug", "name", "scene", "world", "lore", "npcs", "story_journal", "factions", "secrets", "relationships", "gm_context", "notes", "vows",
+        ],
+        slug: novel.slug, name: novel.name, genre: novel.genre, description: novel.description,
+        scene: { description: novel.scene_description, location: novel.scene_location },
+        world: { rooms: [...novel.world.rooms.values()].length, things: [...novel.world.things.values()].length },
+        lore: [...novel.lore.entries()].map(([k, v]) => ({ key: k, content: v.content, triggers: v.triggers, badge_scope: v.badge_scope })),
+        npcs: [...novel.npcs.values()],
+        story_journal: novel.story_journal,
+        factions: novel.factions,
+        secrets: novel.secrets,
+        relationships: novel.relationships,
+        gm_context: novel.gm_context,
+        notes: Object.fromEntries(novel.notes.map(n => [n.key, { content: n.content, badge_scope: n.badge_scope }])),
+        vows: novel.vows,
+    };
+    return raw(JSON.stringify(data, null, 2));
+});
+server.registerTool("import_novel", {
+    title: "Import Novel",
+    description: "Import a previously exported novel. Game Master only.",
+    inputSchema: {
+        data: z.string(),
+        mode: z.enum(["dry-run", "merge", "replace"]).optional(),
+        strict: z.boolean().optional(),
+    },
+}, async ({ data, mode, strict }) => {
+    requireGM();
+    const m = mode ?? "dry-run";
+    let parsed;
+    try {
+        parsed = JSON.parse(data);
+    }
+    catch {
+        return err("INVALID_INPUT", "Could not parse novel data.");
+    }
+    // Manifest validation (REQ-096): missing required manifest fields are
+    // fatal under strict mode; a warning otherwise.
+    const missing = ["novel_format_version", "slug", "name"].filter(k => parsed[k] === undefined);
+    if (missing.length > 0) {
+        if (strict)
+            return err("INVALID_INPUT", `Import rejected: missing manifest fields ${missing.join(", ")}. Corrective action: export with a conformant interchange format.`);
+    }
+    if (m === "dry-run")
+        return ok(`Dry-run: novel '${parsed.name}' (${parsed.slug}) would be imported (${missing.length ? `missing ${missing.join(", ")}` : "valid manifest"}).`);
+    const novel = requireNovel();
+    if (m === "replace") {
+        if (parsed.scene) {
+            novel.scene_description = parsed.scene.description;
+            novel.scene_location = parsed.scene.location;
+        }
+    }
+    if (parsed.lore && Array.isArray(parsed.lore)) {
+        if (m === "replace")
+            novel.lore.clear();
+        for (const e of parsed.lore) {
+            novel.lore.set(e.key, {
+                key: e.key, content: e.content, triggers: e.triggers ?? [],
+                badge_scope: e.badge_scope ?? "game_master", priority: 0, sticky: 0, sticky_remaining: 0, enabled: true,
+            });
+        }
+    }
+    state.saveNovel(novel);
+    return ok(`Novel '${parsed.name}' imported (${m} mode).`);
+});
+// --- Enrichment ---
+server.registerTool("revert_synthesis", {
+    title: "Revert Synthesis",
+    description: "Remove all synthesis state, restoring pre-synthesis server state. Game Master only.",
+    inputSchema: {},
+}, async () => {
+    requireGM();
+    const novel = requireNovel();
+    state.enriched = false;
+    state.enrichmentManifest = null;
+    state.saveNovel(novel);
+    return ok("Enrichment state reverted. Server state restored to pre-enrich baseline.");
+});
+// --- Anchor-only tools (ruleset-free, REQ-218) ---
+server.registerTool("search_rules", {
+    title: "Search Rules",
+    description: "Search the active ruleset's index for matching terms. Empty when no ruleset is bound.",
+    inputSchema: { query: z.string(), max_results: z.number().optional() },
+}, async ({ query, max_results }) => {
+    const novel = state.activeNovel;
+    const slug = novel?.ruleset ?? null;
+    if (slug && rulesets.isInstalled(slug)) {
+        const hits = rulesets.search(slug, String(query), max_results ?? 10);
+        if (hits.length === 0)
+            return err("NOT_FOUND", `No ruleset entry matches '${query}'.`);
+        return raw(JSON.stringify(hits, null, 2));
+    }
+    if (rulesets.installedSlugs().length > 0) {
+        return ok(`No ruleset bound to the active Novel. Installed rulesets: ${rulesets.installedSlugs().join(", ")}. Bind one via bind_novel_ruleset, or create a Novel with create_novel(ruleset: "...").`);
+    }
+    return ok(`No ruleset indexed — this is a world-model-only server. Query was: "${query}". To add a ruleset, run \`build-ruleset <slug>=<path>\` (see the spec, Appendix V).`);
+});
+server.registerTool("install_ruleset", {
+    title: "Install Ruleset",
+    description: "Install a ruleset package from a files bundle. Game Master or Editor only.",
+    inputSchema: {
+        slug: z.string(),
+        manifest: z.any(),
+        index: z.any().optional(),
+        model: z.any().optional(),
+        tools: z.any().optional(),
+        resources: z.any().optional(),
+        prompts: z.any().optional(),
+    },
+}, async (args) => {
+    requireGM();
+    try {
+        const pkg = rulesets.installPackage(args.slug, {
+            manifest: args.manifest,
+            index: args.index ?? [],
+            model: args.model ?? {},
+            tools: args.tools ?? [],
+            resources: args.resources ?? [],
+            prompts: args.prompts ?? [],
+        });
+        return ok(`Ruleset '${pkg.slug}' installed and hydrated: ${pkg.index.length} index entries, ${pkg.tools.length} tools.`);
+    }
+    catch (e) {
+        return err("STATE_CONFLICT", e.message);
+    }
+});
+server.registerTool("remove_ruleset", {
+    title: "Remove Ruleset",
+    description: "Remove an installed ruleset package. Game Master or Editor only.",
+    inputSchema: { slug: z.string() },
+}, async ({ slug }) => {
+    requireGM();
+    const novel = state.activeNovel;
+    if (novel && novel.ruleset === slug) {
+        return err("STATE_CONFLICT", `Cannot remove ruleset '${slug}' while Novel '${novel.slug}' is bound to it.`);
+    }
+    try {
+        rulesets.removePackage(slug);
+        return ok(`Ruleset '${slug}' removed.`);
+    }
+    catch (e) {
+        return err("STATE_CONFLICT", e.message);
+    }
+});
+server.registerTool("list_rulesets", {
+    title: "List Rulesets",
+    description: "List installed ruleset packages with loaded-versus-installed state.",
+    inputSchema: {},
+}, async () => {
+    const list = rulesets.installedSlugs().map((slug) => rulesets.hydrate(slug)).map((pkg) => ({
+        slug: pkg.slug,
+        name: pkg.manifest.name,
+        host_version: pkg.manifest.host_version,
+        built_at: pkg.manifest.built_at,
+        state: rulesets.isHydrated(pkg.slug) ? "loaded" : "installed",
+    }));
+    return raw(JSON.stringify(list, null, 2));
+});
+server.registerTool("bind_novel_ruleset", {
+    title: "Bind Novel Ruleset",
+    description: "Bind the active ruleset-free Novel to an installed ruleset. Game Master or Editor only; one-way and audited.",
+    inputSchema: { slug: z.string() },
+}, async ({ slug }) => {
+    requireGM();
+    if (!rulesets.isInstalled(slug)) {
+        return err("INVALID_INPUT", `Ruleset '${slug}' is not installed. Valid rulesets: ${rulesets.installedSlugs().join(", ") || "(none)"}.`);
+    }
+    try {
+        const novel = state.bindNovelRuleset(slug);
+        rulesets.hydrate(slug);
+        return ok(`Novel '${novel.slug}' bound to ruleset '${slug}'.`);
+    }
+    catch (e) {
+        return err("STATE_CONFLICT", e.message);
+    }
+});
+server.registerTool("suggest_actions", {
+    title: "Suggest Actions",
+    description: "Map player intent to world-model tool invocations. No mechanical suggestions in ruleset-free mode.",
+    inputSchema: { intent: z.string(), entity_id: z.string().optional() },
+}, async ({ intent, entity_id }) => {
+    const novel = requireNovel();
+    const entity = entity_id ? novel.entities.get(entity_id) : state.getActiveEntity();
+    const name = entity?.name ?? "entity";
+    // On ruleset-bound Novels the Player spatial intent routes through
+    // resolve_intent (REQ-309b); the parser is never surfaced to the Player.
+    const rulesetBound = !!novel.ruleset;
+    const badge = getBadge();
+    const useResolveIntent = rulesetBound && badge !== "game_master";
+    const spatialTool = useResolveIntent ? "resolve_intent" : "command";
+    const intentLower = intent.toLowerCase();
+    const suggestions = [];
+    if (intentLower.includes("look") || intentLower.includes("see") || intentLower.includes("where")) {
+        suggestions.push(`${spatialTool}("look")`);
+        suggestions.push(`command("examine <thing>")`);
+    }
+    if (intentLower.includes("go") || intentLower.includes("move") || intentLower.includes("travel")) {
+        suggestions.push(`${spatialTool}("${useResolveIntent ? "go north" : "go north"}")`);
+    }
+    if (intentLower.includes("take") || intentLower.includes("grab") || intentLower.includes("get")) {
+        suggestions.push(`command("take <thing>")`);
+    }
+    if (intentLower.includes("open") || intentLower.includes("unlock")) {
+        suggestions.push(`command("open <door>")`);
+    }
+    if (intentLower.includes("fight") || intentLower.includes("attack")) {
+        suggestions.push("init_combat (GM only, auto-advance mode)");
+    }
+    if (suggestions.length === 0) {
+        suggestions.push(`${spatialTool}("look")`, `command("go <direction>")`, `command("examine <thing>")`);
+    }
+    return ok(`Actions for ${name}: ${suggestions.join(", ")}.`);
+});
+// REQ-022 resource URI catalog — presence is reported against this fixed list.
+const REQ022_URI_CATALOG = [
+    { template: "novel://current", title: "Active Novel" },
+    { template: "novel://setup", title: "Novel Setup" },
+    { template: "entity://current", title: "Active Entity" },
+    { template: "entity://{id}/personality", title: "Entity Personality" },
+    { template: "entity://{id}/voice_examples", title: "Entity Voice Examples" },
+    { template: "entities://", title: "All Novel Entities" },
+    { template: "party://current", title: "Current Party" },
+    { template: "roster://current", title: "Character Roster" },
+    { template: "roster://{id}", title: "Roster Character" },
+    { template: "scene://current", title: "Current Scene" },
+    { template: "scene://history", title: "Scene History" },
+    { template: "countdown://active", title: "Active Countdowns" },
+    { template: "npc://{id}", title: "NPC Record" },
+    { template: "npcs://", title: "All NPCs" },
+    { template: "lore://active", title: "Active Lore" },
+    { template: "lore://{key}", title: "Lore Entry" },
+    { template: "lore://templates", title: "Lore Templates" },
+    { template: "audit://novel", title: "Audit Log" },
+    { template: "guidance://player", title: "Player Guidance" },
+    { template: "guidance://game_master", title: "GM Guidance" },
+    { template: "guidance://{badge}/anti-slop", title: "Anti-Slop Guidance" },
+    { template: "guidance://{badge}/foundations", title: "Badge Foundations" },
+    { template: "guidance://shared/badge-switch", title: "Badge Switch Guidance" },
+    { template: "room://{id}", title: "Room" },
+    { template: "thing://{id}", title: "Thing" },
+    { template: "world://map", title: "World Map" },
+    { template: "world://kinds", title: "World Kinds" },
+    { template: "graph://novel", title: "Knowledge Graph" },
+    { template: "spec://build", title: "Build Specification" },
+    { template: "output://{tool}/{counter}", title: "Tool Output" },
+    { template: "notes://{key}", title: "Note" },
+    { template: "server-notes://{key}", title: "Server Note" },
+    { template: "codex://{id}", title: "Codex Entry" },
+    { template: "faction://{id}", title: "Faction" },
+    { template: "factions://", title: "All Factions" },
+    { template: "secrets://active", title: "Active Secrets" },
+    { template: "synthesis://status", title: "Synthesis Status" },
+    { template: "constraints://active", title: "Constraint Overrides" },
+];
+server.registerTool("spec_health", {
+    title: "Spec Health",
+    description: "Report build health, indexed counts, and resource URI completeness.",
+    inputSchema: {},
+}, async () => {
+    const novel = state.activeNovel;
+    const badge = getBadge();
+    const isGM = badge === "game_master" || badge === "none";
+    const entities = novel ? novel.entities.size : 0;
+    const npcs = novel ? novel.npcs.size : 0;
+    const loreCount = novel ? novel.lore.size : 0;
+    const countdowns = novel ? novel.countdowns.size : 0;
+    const rooms = novel ? novel.world.rooms.size : 0;
+    const things = novel ? novel.world.things.size : 0;
+    const registeredResourceURIs = new Set();
+    const listedResources = server._registeredResources ?? {};
+    for (const key of Object.keys(listedResources)) {
+        const r = listedResources[key];
+        const uriTemplate = r?._template?.uriTemplate?.toString?.() ?? key;
+        registeredResourceURIs.add(typeof uriTemplate === "string" ? uriTemplate : key);
+    }
+    const resource_uris = REQ022_URI_CATALOG.map(({ template, title }) => {
+        const present = registeredResourceURIs.has(template);
+        return { uri: template, title, presence: present ? "present" : "absent" };
+    });
+    const prompts = server._registeredPrompts ? Object.values(server._registeredPrompts) : [];
+    const prompt_health = prompts.map((p) => ({
+        name: p?.name ?? "unknown",
+        present: true,
+        length: 0,
+        budget: p?.arguments?.length ?? "n/a",
+        within: true,
+        stale_references: (p?.name ?? "") in BUILDER_CATEGORIES ? [] : [],
+    }));
+    const synthesisCounts = synthesisModuleCounts();
+    const synthesis_active = state.enriched;
+    const health = {
+        spec_version: state.buildFingerprint.specVersion,
+        spec_hash: state.buildFingerprint.specHash,
+        source_hash: state.buildFingerprint.sourceHash,
+        ruleset_hash: rulesets.installedSlugs().length > 0 ? rulesets.installedSlugs().join(",") : "ruleset-free",
+        ruleset_guidance: rulesets.installedSlugs().length > 0
+            ? `Installed: ${rulesets.installedSlugs().join(", ")}.`
+            : "No rulesets installed — run `build-ruleset <slug>=<path>` to add one (spec Appendix V).",
+        active_ruleset: isGM ? (novel?.ruleset ?? null) : undefined,
+        rulesets_installed: rulesets.installedSlugs().length,
+        rulesets_hydrated: rulesets.installedSlugs().filter((s) => rulesets.isHydrated(s)).length,
+        ruleset_prefix_map: isGM ? rulesets.prefixMap() : undefined,
+        build_timestamp: state.buildFingerprint.buildTimestamp,
+        tool_count: (server._registeredTools ? Object.keys(server._registeredTools).length : 0),
+        prompt_count: (server._registeredPrompts ? Object.keys(server._registeredPrompts).length : 0),
+        resource_count: (server._registeredResources ? Object.keys(server._registeredResources).length : 0),
+        resource_uris,
+        prompt_health,
+        confidence: { overall: "N/A — ruleset-free", per_file: {}, per_category: {} },
+        indexed_counts: {
+            anchors: rulesets.installedSlugs().reduce((n, s) => n + (rulesets.hydrate(s)?.index.length ?? 0), 0),
+            concepts: 0, entity_types: 0, actions: 0,
+            tables: 0, procedures: 0, guidance_items: 0,
+        },
+        must_action_coverage: "100% (infrastructure only)",
+        pending_sections: 0,
+        defect_count: 0,
+        world_model: { rooms, things },
+        novels_available: [...state.novels.keys()].length,
+        server_notes: state.serverNotes.size,
+        codex: isGM ? state.codex.size : undefined,
+        constraint_override_counts: isGM ? (novel ? Object.keys(novel.constraint_overrides ?? {}).length : 0) : undefined,
+        active_novel: novel?.slug ?? null,
+        active_badge: novel?.badge ?? null,
+        autonomy: isGM ? (novel?.autonomy ?? null) : undefined,
+        creativity_mapping: {
+            predictable: "least surprise — stick to expected outcomes",
+            standard: "balanced variation — the default",
+            chaotic: "most surprise — dramatic twists",
+            reported: true,
+        },
+        entities, npcs, lore_entries: loreCount, countdowns,
+        synthesis_active,
+        synthesis_status: { modules: synthesisCounts, last_run: state.enrichmentManifest?.collected_at ?? null },
+        synthesis_health: {
+            synthesis_active,
+            module_counts: synthesisCounts,
+            stale_count: 0,
+            activated_count: novel ? (novel.synthesis_activated ? Object.values(novel.synthesis_activated).reduce((a, b) => a + (typeof b === "number" ? b : 0), 0) : 0) : 0,
+            fingerprint: state.enrichmentManifest ? SPEC_HASH : "",
+        },
+        audit_chain: novel ? state.verifyAuditChain(novel) : null,
+        safety_protocols: {
+            state_loss: "online",
+            badge_boundary: "online",
+            data_corruption: "online",
+            unrecoverable_crash: isGM ? "unverified" : undefined,
+        },
+        // REQ-408, REQ-410, REQ-411, REQ-409 — token/efficiency contracts.
+        parameter_ceiling: PARAMETER_CEILING,
+        parameter_ceiling_exceeded: Object.values(cachedMetadata().toolParameterCounts).some((n) => n > PARAMETER_CEILING),
+        tool_parameter_counts: cachedMetadata().toolParameterCounts,
+        tools_list_bytes: cachedMetadata().toolsListBytes,
+        cache_coverage: { hits: cacheHits, misses: cacheMisses },
+        enumeration_verbosity: enumerationVerbosity,
+        token_footprint: {
+            tools_list_bytes: cachedMetadata().toolsListBytes,
+            prompt_scaffold_bytes: cachedMetadata().promptBytes,
+        },
+    };
+    const fingerprintPath = path.join(DATA_DIR, "build-order-fingerprint.json");
+    if (fs.existsSync(fingerprintPath)) {
+        try {
+            health.build_order = JSON.parse(fs.readFileSync(fingerprintPath, "utf-8"));
+        }
+        catch { /* ignore unreadable fingerprint */ }
+    }
+    return raw(JSON.stringify(health, null, 2));
+});
+// ── Resources ──────────────────────────────────────────────────────
+// Novel resources
+server.registerResource("novel-current", "novel://current", { title: "Active Novel" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "novel://current", text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: "novel://current", text: JSON.stringify({ slug: novel.slug, name: novel.name, badge: novel.badge, entities: novel.entities.size }), mimeType: "application/json" }] };
+});
+server.registerResource("novel-setup", "novel://setup", { title: "Novel Setup" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "novel://setup", text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: "novel://setup", text: JSON.stringify({ slug: novel.slug, name: novel.name }), mimeType: "application/json" }] };
+});
+// Entity resource
+server.registerResource("entity-current", "entity://current", { title: "Active Entity" }, async () => {
+    const entity = state.getActiveEntity();
+    if (!entity)
+        return { contents: [{ uri: "entity://current", text: "No active entity.", mimeType: "text/plain" }] };
+    return { contents: [{ uri: "entity://current", text: JSON.stringify({ id: entity.id, name: entity.name, personality: entity.personality, current_room: entity.current_room, inventory: entity.inventory }), mimeType: "application/json" }] };
+});
+server.registerResource("entity-personality", new ResourceTemplate("entity://{id}/personality", { list: undefined }), { title: "Entity Personality" }, async (uri) => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const id = uri.href.split("/")[3];
+    const entity = novel.entities.get(id);
+    if (!entity)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: uri.href, text: JSON.stringify(entity.personality ?? {}), mimeType: "application/json" }] };
+});
+server.registerResource("entity-voice", new ResourceTemplate("entity://{id}/voice_examples", { list: undefined }), { title: "Entity Voice Examples" }, async (uri) => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const id = uri.href.split("/")[3];
+    const entity = novel.entities.get(id);
+    if (!entity)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: uri.href, text: JSON.stringify(entity.voice_examples ?? []), mimeType: "application/json" }] };
+});
+server.registerResource("roster", "roster://current", { title: "Character Roster" }, async () => {
+    return { contents: [{ uri: "roster://current", text: JSON.stringify(Object.fromEntries(state.roster)), mimeType: "application/json" }] };
+});
+// Scene resources
+server.registerResource("scene-current", "scene://current", { title: "Current Scene" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "scene://current", text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: "scene://current", text: JSON.stringify({ description: novel.scene_description, location: novel.scene_location, time_of_day: novel.scene_time_of_day, atmosphere: novel.scene_atmosphere, type: novel.scene_type }), mimeType: "application/json" }] };
+});
+server.registerResource("scene-history", "scene://history", { title: "Scene History" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "scene://history", text: "[]", mimeType: "application/json" }] };
+    return { contents: [{ uri: "scene://history", text: JSON.stringify(novel.scene_history), mimeType: "application/json" }] };
+});
+// Countdown resource
+server.registerResource("countdown-active", "countdown://active", { title: "Active Countdowns" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "countdown://active", text: "{}", mimeType: "application/json" }] };
+    const active = Object.fromEntries([...novel.countdowns.entries()].filter(([, cd]) => cd.ticks > 0));
+    return { contents: [{ uri: "countdown://active", text: JSON.stringify(active), mimeType: "application/json" }] };
+});
+// NPC resources
+server.registerResource("npc-single", new ResourceTemplate("npc://{id}", { list: () => {
+        const novel = state.activeNovel;
+        if (!novel)
+            return { resources: [] };
+        return { resources: [...novel.npcs.keys()].map(id => ({ uri: `npc://${id}`, name: id })) };
+    } }), { title: "NPC Record" }, async (uri) => {
+    const novel = state.activeNovel;
+    const id = uri.href.split("/").pop() ?? "";
+    if (!novel)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const npc = novel.npcs.get(id);
+    if (!npc)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: uri.href, text: JSON.stringify(npc), mimeType: "application/json" }] };
+});
+server.registerResource("npcs", "npcs://", { title: "All NPCs" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "npcs://", text: "{}", mimeType: "application/json" }] };
+    return { contents: [{ uri: "npcs://", text: JSON.stringify(Object.fromEntries(novel.npcs)), mimeType: "application/json" }] };
+});
+// Lore resources
+server.registerResource("lore-active", "lore://active", { title: "Active Lore" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "lore://active", text: "{}", mimeType: "application/json" }] };
+    const active = Object.fromEntries([...novel.lore.entries()].filter(([, l]) => l.enabled));
+    return { contents: [{ uri: "lore://active", text: JSON.stringify(active), mimeType: "application/json" }] };
+});
+server.registerResource("lore-single", new ResourceTemplate("lore://{key}", { list: () => {
+        const novel = state.activeNovel;
+        if (!novel)
+            return { resources: [] };
+        return { resources: [...novel.lore.keys()].map(k => ({ uri: `lore://${k}`, name: k })) };
+    } }), { title: "Lore Entry" }, async (uri) => {
+    const novel = state.activeNovel;
+    const key = uri.href.split("/").pop() ?? "";
+    if (!novel)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const entry = novel.lore.get(key);
+    if (!entry)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: uri.href, text: JSON.stringify(entry), mimeType: "application/json" }] };
+});
+// Audit resource
+server.registerResource("audit-novel", "audit://novel", { title: "Audit Log" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "audit://novel", text: "[]", mimeType: "application/json" }] };
+    return { contents: [{ uri: "audit://novel", text: JSON.stringify(novel.audit_log.slice(-50)), mimeType: "application/json" }] };
+});
+// Guidance resources
+server.registerResource("guidance-player", "guidance://player", { title: "Player Guidance" }, async () => ({
+    contents: [{ uri: "guidance://player", text: "## Player Guidance\n\nDescribe what your character does. Use parser commands to interact with the world: command(\"look\"), command(\"go north\"), command(\"take sword\").", mimeType: "text/markdown" }],
+}));
+server.registerResource("guidance-gm", "guidance://game_master", { title: "GM Guidance" }, async () => ({
+    contents: [{ uri: "guidance://game_master", text: "## Game Master Guidance\n\nPopulate the world model with convert_source or adventure modules. Set scenes, NPCs, lore, and countdowns.", mimeType: "text/markdown" }],
+}));
+server.registerResource("guidance-player-anti-slop", "guidance://player/anti-slop", { title: "Player Anti-Slop" }, async () => ({
+    contents: [{ uri: "guidance://player/anti-slop", text: "Describe actions concretely. Use parser commands for world interaction. Narrate in-character.", mimeType: "text/markdown" }],
+}));
+server.registerResource("guidance-gm-anti-slop", "guidance://game_master/anti-slop", { title: "GM Anti-Slop" }, async () => ({
+    contents: [{ uri: "guidance://game_master/anti-slop", text: "Describe situations richly. Surface information. Do not take actions or make decisions for the player.", mimeType: "text/markdown" }],
+}));
+server.registerResource("guidance-badge-switch", "guidance://shared/badge-switch", { title: "Badge Switch Guidance" }, async () => ({
+    contents: [{ uri: "guidance://shared/badge-switch", text: "Use set_badge to switch between player and game_master badges. Player: describe actions. GM: describe situations.", mimeType: "text/markdown" }],
+}));
+// World-model resources (REQ-202)
+server.registerResource("room-single", new ResourceTemplate("room://{id}", { list: () => {
+        const novel = state.activeNovel;
+        if (!novel)
+            return { resources: [] };
+        return { resources: [...novel.world.rooms.keys()].map(id => ({ uri: `room://${id}`, name: novel.world.rooms.get(id)?.name ?? id })) };
+    } }), { title: "Room" }, async (uri) => {
+    const novel = state.activeNovel;
+    const id = decodeURIComponent(uri.href.split("/").pop() ?? "");
+    if (!novel)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const room = novel.world.rooms.get(id.toLowerCase());
+    if (!room)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    const isGM = novel.badge === "game_master";
+    let info = `## ${room.name}\n${room.description || "No description."}`;
+    if (isGM) {
+        info += `\n\n**Exits:** ${[...room.exits.entries()].map(([d, t]) => `${d} → ${t}`).join(", ") || "none"}`;
+    }
+    else {
+        const exits = [...room.exits.keys()].join(", ");
+        if (exits)
+            info += `\n\n**Exits:** ${exits}`;
+    }
+    return { contents: [{ uri: uri.href, text: info, mimeType: "text/markdown" }] };
+});
+server.registerResource("thing-single", new ResourceTemplate("thing://{id}", { list: () => {
+        const novel = state.activeNovel;
+        if (!novel)
+            return { resources: [] };
+        return { resources: [...novel.world.things.keys()].map(id => ({ uri: `thing://${id}`, name: novel.world.things.get(id)?.name ?? id })) };
+    } }), { title: "Thing" }, async (uri) => {
+    const novel = state.activeNovel;
+    const id = decodeURIComponent(uri.href.split("/").pop() ?? "");
+    if (!novel)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const thing = novel.world.things.get(id.toLowerCase());
+    if (!thing)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    const isGM = novel.badge === "game_master";
+    let info = `## ${thing.name}\n**Kind:** ${thing.kind}\n${thing.description || "No description."}`;
+    if (isGM) {
+        info += `\n\n**Location:** ${thing.location || "(held/inventory)"}`;
+        info += `\n**Properties:** portable=${thing.portable}, openable=${thing.openable}, open=${thing.open}, lockable=${thing.lockable}, locked=${thing.locked}`;
+    }
+    return { contents: [{ uri: uri.href, text: info, mimeType: "text/markdown" }] };
+});
+server.registerResource("world-map", "world://map", { title: "World Map" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "world://map", text: "No active novel.", mimeType: "text/plain" }] };
+    return { contents: [{ uri: "world://map", text: worldMap(novel.world), mimeType: "text/plain" }] };
+});
+server.registerResource("world-kinds", "world://kinds", { title: "World Kinds" }, async () => ({
+    contents: [{ uri: "world://kinds", text: worldKinds(), mimeType: "text/markdown" }],
+}));
+// ── Additional resources (REQ-022a) ───────────────────────────────
+// Entity collection resource (REQ-074)
+server.registerResource("entities-collection", "entities://", { title: "All Novel Entities" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "entities://", text: "{}", mimeType: "application/json" }] };
+    return { contents: [{ uri: "entities://", text: JSON.stringify(Object.fromEntries(novel.entities)), mimeType: "application/json" }] };
+});
+// Party resource (REQ-074, REQ-307)
+server.registerResource("party-current", "party://current", { title: "Current Party" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "party://current", text: "{}", mimeType: "application/json" }] };
+    const party = [...novel.entities.values()].map(e => ({
+        name: e.name,
+        active: e.id === novel.active_entity_id,
+        conditions: e.conditions ?? [],
+        present: novel.characters_present_ids ? novel.characters_present_ids.includes(e.id) : true,
+        last_location: e.current_room ?? null,
+    }));
+    return { contents: [{ uri: "party://current", text: JSON.stringify(party, null, 2), mimeType: "application/json" }] };
+});
+// Knowledge graph (REQ-296)
+server.registerResource("graph-novel", "graph://novel", { title: "Novel Knowledge Graph" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "graph://novel", text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const isGM = novel.badge === "game_master";
+    const revealedSecrets = novel.secrets.filter(s => s.known_by.length > 0 || isGM);
+    const graph = {
+        entities: [...novel.entities.values()].map(e => ({ id: e.id, name: e.name })),
+        npcs: [...novel.npcs.values()].map(n => ({ id: n.id, name: n.name, disposition: n.disposition, location: n.location })),
+        lore_connections: [...novel.lore.values()].filter(l => l.enabled).map(l => ({ key: l.key })),
+        secrets: revealedSecrets.map(s => ({ key: s.key, known_by: s.known_by })),
+        factions: novel.factions.map(f => ({ id: f.id, name: f.name })),
+    };
+    return { contents: [{ uri: "graph://novel", text: JSON.stringify(graph, null, 2), mimeType: "application/json" }] };
+});
+// Spec resource (REQ-105)
+server.registerResource("spec-build", "spec://build", { title: "Build Specification" }, async () => {
+    const badge = getBadge();
+    if (badge !== "game_master" && badge !== "none") {
+        return { contents: [{ uri: "spec://build", text: "[FORBIDDEN] spec://build is Game Master only. Corrective action: switch badge with set_badge.", mimeType: "text/plain" }] };
+    }
+    try {
+        const specPath = path.join(__dirname, "holonovel.md");
+        if (fs.existsSync(specPath)) {
+            return { contents: [{ uri: "spec://build", text: fs.readFileSync(specPath, "utf-8"), mimeType: "text/markdown" }] };
+        }
+    }
+    catch { /* fall through */ }
+    return { contents: [{ uri: "spec://build", text: "Specification not embedded in this build.", mimeType: "text/plain" }] };
+});
+// Output pointer resource (REQ-179): output://{tool}/{counter}
+const outputStore = new Map();
+server.registerResource("output-pointer", new ResourceTemplate("output://{tool}/{counter}", { list: undefined }), { title: "Tool Output" }, async (uri) => {
+    const key = uri.href.replace("output://", "");
+    const text = outputStore.get(key);
+    if (text === undefined)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: uri.href, text, mimeType: "text/markdown" }] };
+});
+// Notes resource (REQ-242)
+server.registerResource("notes-single", new ResourceTemplate("notes://{key}", { list: () => {
+        const novel = state.activeNovel;
+        if (!novel)
+            return { resources: [] };
+        return { resources: novel.notes.map(n => ({ uri: `notes://${n.key}`, name: n.key })) };
+    } }), { title: "Note" }, async (uri) => {
+    const novel = state.activeNovel;
+    const key = decodeURIComponent(uri.href.split("/").pop() ?? "");
+    if (!novel)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const note = novel.notes.find(n => n.key === key);
+    if (!note)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    if (note.badge_scope === "game_master" && novel.badge !== "game_master" && novel.badge !== "none") {
+        return { contents: [{ uri: uri.href, text: "[FORBIDDEN] This note is Game Master scoped.", mimeType: "text/plain" }] };
+    }
+    return { contents: [{ uri: uri.href, text: note.content, mimeType: "text/markdown" }] };
+});
+// Server notes resource (REQ-285)
+server.registerResource("server-notes-single", new ResourceTemplate("server-notes://{key}", { list: () => {
+        return { resources: [...state.serverNotes.keys()].map(k => ({ uri: `server-notes://${k}`, name: k })) };
+    } }), { title: "Server Note" }, async (uri) => {
+    if (getBadge() !== "game_master" && getBadge() !== "none") {
+        return { contents: [{ uri: uri.href, text: "[FORBIDDEN] Server notes are Game Master only.", mimeType: "text/plain" }] };
+    }
+    const key = decodeURIComponent(uri.href.split("/").pop() ?? "");
+    const content = state.serverNotes.get(key);
+    if (content === undefined)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: uri.href, text: content, mimeType: "text/markdown" }] };
+});
+// Codex resource (REQ-321)
+server.registerResource("codex-single", new ResourceTemplate("codex://{id}", { list: () => {
+        return { resources: [...state.codex.keys()].map(id => ({ uri: `codex://${id}`, name: state.codex.get(id)?.name ?? id })) };
+    } }), { title: "Codex Entry" }, async (uri) => {
+    const id = decodeURIComponent(uri.href.split("/").pop() ?? "");
+    const entry = state.codex.get(id);
+    if (!entry)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    const badge = getBadge();
+    if (entry.visibility === "private" && badge !== "game_master" && badge !== "none") {
+        return { contents: [{ uri: uri.href, text: "[FORBIDDEN] This codex entry is private.", mimeType: "text/plain" }] };
+    }
+    return { contents: [{ uri: uri.href, text: JSON.stringify(entry, null, 2), mimeType: "application/json" }] };
+});
+// Faction resources (REQ-233)
+server.registerResource("factions-collection", "factions://", { title: "All Factions" }, async () => {
+    const novel = state.activeNovel;
+    if (!novel)
+        return { contents: [{ uri: "factions://", text: "[]", mimeType: "application/json" }] };
+    return { contents: [{ uri: "factions://", text: JSON.stringify(novel.factions, null, 2), mimeType: "application/json" }] };
+});
+server.registerResource("faction-single", new ResourceTemplate("faction://{id}", { list: () => {
+        const novel = state.activeNovel;
+        if (!novel)
+            return { resources: [] };
+        return { resources: novel.factions.map(f => ({ uri: `faction://${f.id}`, name: f.name })) };
+    } }), { title: "Faction" }, async (uri) => {
+    const novel = state.activeNovel;
+    const id = decodeURIComponent(uri.href.split("/").pop() ?? "");
+    if (!novel)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "no active novel" }), mimeType: "application/json" }] };
+    const faction = novel.factions.find(f => f.id === id);
+    if (!faction)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: uri.href, text: JSON.stringify(faction, null, 2), mimeType: "application/json" }] };
+});
+// Secrets resource (REQ-234)
+server.registerResource("secrets-active", "secrets://active", { title: "Active Secrets" }, async () => {
+    const novel = state.activeNovel;
+    if (getBadge() !== "game_master" && getBadge() !== "none") {
+        return { contents: [{ uri: "secrets://active", text: "[FORBIDDEN] Secrets are Game Master only.", mimeType: "text/plain" }] };
+    }
+    if (!novel)
+        return { contents: [{ uri: "secrets://active", text: "[]", mimeType: "application/json" }] };
+    return { contents: [{ uri: "secrets://active", text: JSON.stringify(novel.secrets, null, 2), mimeType: "application/json" }] };
+});
+// Roster individual/type resources (REQ-022, REQ-074)
+server.registerResource("roster-single", new ResourceTemplate("roster://{id}", { list: () => {
+        return { resources: [...state.roster.keys()].map(id => ({ uri: `roster://${id}`, name: state.roster.get(id)?.name ?? id })) };
+    } }), { title: "Roster Character" }, async (uri) => {
+    const id = decodeURIComponent(uri.href.split("/").pop() ?? "");
+    const entry = state.roster.get(id);
+    if (!entry)
+        return { contents: [{ uri: uri.href, text: JSON.stringify({ error: "not found" }), mimeType: "application/json" }] };
+    return { contents: [{ uri: uri.href, text: JSON.stringify(entry, null, 2), mimeType: "application/json" }] };
+});
+// Constraint overrides (REQ-325)
+server.registerResource("constraints-active", "constraints://active", { title: "Constraint Overrides" }, async () => {
+    const novel = state.activeNovel;
+    const badge = getBadge();
+    if (!novel)
+        return { contents: [{ uri: "constraints://active", text: "[]", mimeType: "application/json" }] };
+    let overrides = novel.constraint_overrides ?? [];
+    if (badge === "player") {
+        const entity = state.getActiveEntity();
+        overrides = overrides.filter(o => o.name === entity?.name || o.match_all);
+    }
+    return { contents: [{ uri: "constraints://active", text: JSON.stringify(overrides, null, 2), mimeType: "application/json" }] };
+});
+// Lore templates (REQ-159)
+server.registerResource("lore-templates", "lore://templates", { title: "Lore Templates" }, async () => {
+    const templates = state.enrichmentManifest?.lore_templates ?? [];
+    return { contents: [{ uri: "lore://templates", text: JSON.stringify(templates, null, 2), mimeType: "application/json" }] };
+});
+// Guidance foundations resources (REQ-062)
+server.registerResource("guidance-player-foundations", "guidance://player/foundations", { title: "Player Foundations" }, async () => ({
+    contents: [{ uri: "guidance://player/foundations", text: "Describe what your character does in the fiction. Do not prescribe world facts or other characters' actions. Surface your intent; the narrative resolves it.", mimeType: "text/markdown" }],
+}));
+server.registerResource("guidance-gm-foundations", "guidance://game_master/foundations", { title: "GM Foundations" }, async () => ({
+    contents: [{ uri: "guidance://game_master/foundations", text: "Describe situations and surface information. Never take action or make decisions on behalf of the player. Separate mechanics from fiction.", mimeType: "text/markdown" }],
+}));
+// Synthesis status + per-module resources (REQ-230, REQ-160)
+function synthesisModuleCounts() {
+    const manifest = state.enrichmentManifest;
+    const modules = ["voice_examples", "briefing_order", "lore_templates", "action_patterns", "supplementary_guidance", "adventure_advice", "narrative_voices"];
+    const out = {};
+    for (const m of modules)
+        out[m] = { total: 0, activated: 0 };
+    if (!manifest)
+        return out;
+    const activated = state.activeNovel?.synthesis_activated ?? {};
+    if (manifest.voice_examples)
+        out.voice_examples.total = manifest.voice_examples.length;
+    if (manifest.lore_templates)
+        out.lore_templates.total = manifest.lore_templates.length;
+    if (manifest.action_patterns)
+        out.action_patterns.total = manifest.action_patterns.length;
+    if (manifest.supplementary_guidance)
+        out.supplementary_guidance.total = manifest.supplementary_guidance.length;
+    if (manifest.adventure_advice)
+        out.adventure_advice.total = (manifest.adventure_advice.templates?.length ?? 0) + (manifest.adventure_advice.scenario_starters?.length ?? 0) + (manifest.adventure_advice.table_expansions?.length ?? 0);
+    if (manifest.narrative_voices)
+        out.narrative_voices.total = manifest.narrative_voices.length;
+    for (const m of Object.keys(out))
+        out[m].activated = activated[m] ?? 0;
+    return out;
+}
+server.registerResource("synthesis-status", "synthesis://status", { title: "Synthesis Status" }, async () => {
+    const counts = synthesisModuleCounts();
+    const active = state.enriched;
+    let md = "Synthesis Status\n";
+    for (const [m, c] of Object.entries(counts)) {
+        md += `## ${m}\nRuleset Wisdom: ${active ? c.total : 0}\nSynthesis activated/total: ${c.activated}/${active ? c.total : 0}\n`;
+    }
+    return { contents: [{ uri: "synthesis://status", text: md, mimeType: "text/markdown" }] };
+});
+// ── Additional tools (REQ-307, REQ-213/214, REQ-321, REQ-103, REQ-239) ──
+server.registerTool("set_party_presence", {
+    title: "Set Party Presence",
+    description: "Declare which entities are present in the current scene. Use when: the GM needs to override party presence without altering other scene fields. Do NOT use when: setting scene description — use set_scene_state.",
+    inputSchema: { entity_ids: z.array(z.string()), location: z.string().optional() },
+}, async ({ entity_ids, location }) => {
+    requireGM();
+    const novel = requireNovel();
+    novel.characters_present_ids = entity_ids;
+    state.saveNovel(novel);
+    return ok(`Party presence set: ${entity_ids.join(", ") || "(none)"}.`);
+});
+server.registerTool("roll_on_table", {
+    title: "Roll On Table",
+    description: "Roll on a generation table from the bound ruleset. Use when: resolving a random-generation table (names, treasure, events). Do NOT use when: resolving a fixed lookup — use a lookup tool.",
+    inputSchema: { table: z.string(), seed: z.string().optional() },
+}, async ({ table, seed }) => {
+    const novel = state.activeNovel;
+    const slug = novel?.ruleset ?? null;
+    if (!slug || !rulesets.isInstalled(slug)) {
+        return err("NOT_FOUND", "No random generation tables in this ruleset (ruleset-free). Corrective action: bind a ruleset whose package defines generation tables.");
+    }
+    const model = rulesets.hydrate(slug).model;
+    const tables = model.generation_tables ?? {};
+    const key = Object.keys(tables).find(k => k.toLowerCase() === String(table).toLowerCase());
+    if (!key) {
+        const valid = Object.keys(tables);
+        return err("NOT_FOUND", `Table '${table}' not found. Valid tables: ${valid.join(", ") || "(none)"}.`);
+    }
+    const entry = tables[key];
+    const rng = seed ? createRng(seed) : createRng(String(sessionRoll(1000000000)));
+    const roll = entry.dice_expression ? rollDice(entry.dice_expression, String(rng.roll(1000000000))).total : rng.roll(100);
+    const range = (entry.ranges ?? []).find((r) => roll >= r.min && roll <= r.max);
+    if (!range) {
+        return warn(`Roll ${roll} on ${entry.dice_expression ?? "d100"} matched no range in table '${key}'.`);
+    }
+    return ok(`Table: ${key}\nDice: ${entry.dice_expression ?? "d100"}\nRoll: ${roll}\nRange: ${range.min}-${range.max}\nResult: ${range.result}`);
+});
+// Codex tools (REQ-321)
+server.registerTool("codex_set", {
+    title: "Set Codex Entry",
+    description: "Create or update a typed codex entry that persists across Novels. Use when: storing reusable content (NPCs, factions, rooms, spells, etc.) for later import. Do NOT use when: storing Novel-scoped content — use set_lore_entry or set_note.",
+    inputSchema: {
+        kind: z.string(),
+        name: z.string(),
+        content: z.any(),
+        description: z.string().optional(),
+        tags: z.array(z.string()).optional(),
+        visibility: z.enum(["library", "shared", "private"]).optional(),
+    },
+}, async ({ kind, name, content, description, tags, visibility }) => {
+    requireGM();
+    const id = `${kind.toLowerCase()}_${name.toLowerCase().replace(/[^a-z0-9]+/g, "_")}`;
+    const now = new Date().toISOString();
+    const existing = state.codex.get(id);
+    const entry = {
+        id, kind, name, content,
+        description: description ?? existing?.description,
+        tags: tags ?? existing?.tags ?? [],
+        visibility: visibility ?? existing?.visibility ?? "library",
+        imported_at: existing?.imported_at ?? now,
+        codex_modified_at: now,
+    };
+    state.codex.set(id, entry);
+    state.saveCodex();
+    return ok(`Codex entry '${id}' stored (visibility: ${entry.visibility}).`);
+});
+server.registerTool("codex_list", {
+    title: "List Codex Entries",
+    description: "List codex entries by kind, badge-filtered by visibility. Use when: discovering reusable content to import. Do NOT use when: listing Novel entities — use list_notes or list_stories.",
+    inputSchema: { kind: z.string().optional() },
+}, async ({ kind }) => {
+    const badge = getBadge();
+    let entries = [...state.codex.values()];
+    if (kind)
+        entries = entries.filter(e => e.kind === kind);
+    entries = entries.filter(e => badge === "game_master" || badge === "none" || e.visibility === "shared" || e.visibility === "library");
+    return raw(JSON.stringify(entries.map(e => ({ id: e.id, kind: e.kind, name: e.name, visibility: e.visibility, tags: e.tags })), null, 2));
+});
+// Synthesis tools (REQ-103, REQ-260-263)
+server.registerTool("synthesize", {
+    title: "Synthesize",
+    description: "Run synthesis against the active Novel's state and vendor content. Use when: generating voice examples, lore templates, and action patterns from Novel and vendor sources. Do NOT use when: editing mechanical fields — synthesis is additive only.",
+    inputSchema: { force: z.boolean().optional() },
+}, async ({ force }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (state.enriched && !force) {
+        return ok(`Synthesis up to date (${state.enrichmentManifest?.collected_at ?? "unknown"}). Use force=true to re-synthesize.`);
+    }
+    state.enriched = true;
+    state.enrichmentManifest = DEFAULT_ENRICHMENT;
+    state.saveNovel(novel);
+    const counts = synthesisModuleCounts();
+    return ok(`Synthesis complete. Modules: ${Object.entries(counts).map(([m, c]) => `${m}=${c.total}`).join(", ")}.`);
+});
+server.registerTool("list_synthesis_items", {
+    title: "List Synthesis Items",
+    description: "List synthesis items by module and tier. Use when: reviewing available synthesis content. Do NOT use when: browsing the codex — use codex_list.",
+    inputSchema: { module: z.string().optional(), ...detailZod },
+}, async ({ module, detail }) => {
+    const manifest = state.enrichmentManifest;
+    if (!manifest)
+        return ok("No synthesis items (synthesis not run).");
+    const all = [
+        ...(manifest.voice_examples ?? []).map((i) => ({ module: "voice_examples", tag: i.tag ?? "vendor", content: i.content, badge_scope: i.badge_scope })),
+        ...(manifest.lore_templates ?? []).map((i) => ({ module: "lore_templates", tag: i.tag ?? "vendor", content: i.content, badge_scope: i.badge_scope })),
+        ...(manifest.action_patterns ?? []).map((i) => ({ module: "action_patterns", tag: i.tag ?? "vendor", content: i.intent, badge_scope: "game_master" })),
+        ...(manifest.supplementary_guidance ?? []).map((i) => ({ module: "supplementary_guidance", tag: i.tag ?? "vendor", content: i.content, badge_scope: i.badge_scope })),
+        ...(manifest.narrative_voices ?? []).map((i) => ({ module: "narrative_voices", tag: i.tag ?? "vendor", content: i.name, badge_scope: i.badge_scope })),
+    ];
+    const filtered = module ? all.filter((i) => i.module === module) : all;
+    if (wantsDetail(detail))
+        return raw(JSON.stringify(filtered, null, 2));
+    const summary = filtered.map((i) => ({ module: i.module, tag: i.tag, badge_scope: i.badge_scope, preview: `${typeof i.content === "string" ? (i.content ?? "").slice(0, 80) : ""}` }));
+    return raw(JSON.stringify(summary, null, 2));
+});
+server.registerTool("activate_synthesis_item", {
+    title: "Activate Synthesis Item",
+    description: "Activate a synthesis item for the active Novel. Use when: incorporating synthesis content into play. Do NOT use when: deactivating — use deactivate_synthesis_item.",
+    inputSchema: { module: z.string(), key: z.number() },
+}, async ({ module, key }) => {
+    requireGM();
+    const novel = requireNovel();
+    if (!state.enriched)
+        return err("STATE_CONFLICT", "Synthesis has not been run. Corrective action: run synthesize first.");
+    const activated = novel.synthesis_activated ?? {};
+    activated[module] = key;
+    novel.synthesis_activated = activated;
+    state.saveNovel(novel);
+    return ok(`Synthesis module '${module}' activated (${key} items).`);
+});
+server.registerTool("deactivate_synthesis_item", {
+    title: "Deactivate Synthesis Item",
+    description: "Deactivate a synthesis item for the active Novel. Use when: removing a synthesis item from play without deleting it. Do NOT use when: removing Ruleset Wisdom — use revert_synthesis.",
+    inputSchema: { module: z.string() },
+}, async ({ module }) => {
+    requireGM();
+    const novel = requireNovel();
+    const activated = novel.synthesis_activated ?? {};
+    delete activated[module];
+    novel.synthesis_activated = activated;
+    state.saveNovel(novel);
+    return ok(`Synthesis module '${module}' deactivated.`);
+});
+server.registerTool("toggle_synthesis_module", {
+    title: "Toggle Synthesis Module",
+    description: "Enable or disable a synthesis module for the active Novel. Use when: controlling whether a module's content appears in surfaces. Do NOT use when: activating a single item — use activate_synthesis_item.",
+    inputSchema: { module: z.string(), enabled: z.boolean() },
+}, async ({ module, enabled }) => {
+    requireGM();
+    const novel = requireNovel();
+    const m = novel.synthesis_module_enabled ?? {};
+    if (enabled)
+        m[module] = true;
+    else
+        delete m[module];
+    novel.synthesis_module_enabled = m;
+    state.saveNovel(novel);
+    return ok(`Synthesis module '${module}' ${enabled ? "enabled" : "disabled"}.`);
+});
+// ── Prompts ────────────────────────────────────────────────────────
+server.prompt("intro", "Introduction and Getting Started", async () => {
+    const novel = state.activeNovel;
+    const worldRooms = novel?.world.rooms.size ?? 0;
+    const hasWorld = worldRooms > 0;
+    return {
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `# Inform MCP Server — World-Model Interactive Fiction
+
+This server provides a ruleset-free world-model layer for interactive fiction.
+Parser commands let you navigate, examine objects, and interact with a spatial
+world.
+
+${hasWorld
+                        ? `**World model populated:** ${worldRooms} rooms, ${novel.world.things.size} things.
+
+### Getting Started
+1. \`set_badge("player")\` — switch to player badge
+2. \`command("look")\` — describe the current room
+3. \`command("go north")\` — move through exits
+4. \`command("examine <thing>")\` — inspect objects`
+                        : `**No world model populated.**
+
+### Getting Started
+1. \`set_badge("game_master")\` — switch to GM badge
+2. \`create_novel({ name: "My World" })\` — create a new novel
+3. \`load_adventure({ slug: "<adventure>" })\` — load an adventure module
+4. \`convert_source({ source: "<world assertions>" })\` — parse room/thing declarations`}
+
+Use \`help\` to see all tools, or \`badge_briefing\` for current badge guidance.`,
+                },
+            }],
+    };
+});
+server.prompt("badge_briefing", "Current Badge Briefing", async () => {
+    const novel = state.activeNovel;
+    if (!novel) {
+        return { messages: [{ role: "user", content: { type: "text", text: "No active Novel. Create or resume one first." } }] };
+    }
+    const badge = novel.badge;
+    const entity = state.getActiveEntity();
+    let briefing = `## Badge Briefing — ${badgeLabel(badge).toUpperCase()}
+**Novel:** ${novel.name} (${novel.slug})
+${novel.scene_description ? `**Scene:** ${novel.scene_description}` : ""}`;
+    if (entity && badge !== "game_master") {
+        briefing += `\n**Active entity:** ${entity.name}`;
+        if (entity.current_room)
+            briefing += ` — ${entity.current_room}`;
+        if (entity.inventory.length > 0)
+            briefing += ` — holding: ${entity.inventory.join(", ")}`;
+    }
+    // REQ-412 — turn-handoff directive. When the AI narrates as Game Master
+    // (human wears Player/Observer), close each turn by inviting the player's
+    // next action. When the AI inhabits a Player role (human GM), hand initiative
+    // back to the human Game Master instead.
+    if (badge === "player" || badge === "observer") {
+        briefing += `\n\n### Turn handoff
+Close each narrated turn by inviting the player's next action — ask what they do, where they look, or what they say next. Never end a turn with a tool signature or a parameter list; use a plain-English question or prompt to act.`;
+    }
+    else if (badge === "game_master") {
+        briefing += `\n\n### Turn handoff
+You inhabit a player character. Close each in-character turn with an offer that hands initiative back to the human Game Master to describe the outcome or advance the scene.`;
+    }
+    if (badge === "player") {
+        briefing += `\n\n### Player Tools
+Use \`command("<action>")\` to interact with the world:
+- command("look") — describe the current room
+- command("go north") — move in a direction
+- command("take sword") — pick up an object
+- command("examine thing") — look at something closely
+- command("inventory") — check what you're carrying
+- command("open door") — open an openable object`;
+    }
+    else if (badge === "game_master" || badge === "observer") {
+        briefing += `\n\n### GM State
+**World model:** ${novel.world.rooms.size} rooms, ${novel.world.things.size} things
+**NPCs:** ${novel.npcs.size} | **Lore entries:** ${novel.lore.size} | **Countdowns:** ${novel.countdowns.size}${novel.combat?.active ? `\n**Combat active:** Round ${novel.combat.round}` : ""}`;
+        if (badge === "observer") {
+            briefing += `\n\n### Observer Mode
+You are both Game Master and Player. The human is observing. Narrate scenes, make decisions for all player characters, advance combat, play the Novel.`;
+        }
+        // Triggered lore
+        const sceneText = novel.scene_description.toLowerCase();
+        const triggered = [];
+        for (const [, entry] of novel.lore) {
+            if (!entry.enabled)
+                continue;
+            for (const trigger of entry.triggers) {
+                if (sceneText.includes(trigger.toLowerCase())) {
+                    triggered.push(`[${entry.key}] ${entry.content}`);
+                    break;
+                }
+            }
+        }
+        if (triggered.length > 0) {
+            briefing += `\n\n### Triggered Lore\n${triggered.join("\n")}`;
+        }
+    }
+    return { messages: [{ role: "user", content: { type: "text", text: briefing } }] };
+});
+server.prompt("session_zero", "Session Zero Setup", async () => {
+    return {
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `# Session Zero
+
+## World-Model Interactive Fiction
+
+Before starting play:
+1. Create a Novel: \`create_novel({ name: "My Adventure" })\`
+2. Create characters: \`create_character({ name: "Hero", description: "..." })\`
+3. Populate the world model with \`convert_source\` or \`load_adventure\`
+4. The GM sets the opening scene with \`set_scene_state\`
+5. Players use \`set_badge("player")\` and start with parser commands
+
+## Player Signals
+- \`player_signal({ signal: "pace", value: "faster/slower" })\`
+- \`player_signal({ signal: "difficulty", value: "harder/easier" })\`
+- \`player_signal({ signal: "boundary", value: "<topic>" })\``,
+                },
+            }],
+    };
+});
+server.prompt("novel_setup", "Novel Setup Guidance", async () => {
+    return {
+        messages: [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `# Novel Setup
+
+## Creating a World Model
+Use \`convert_source\` with declarative assertions to populate the world:
+\`\`\`
+The Entrance Chamber is a room. "A dusty hall with torches."
+North of the Entrance Chamber is the Hall of Statues.
+The Hall of Statues is a room. "Tall statues line both walls."
+A rusty sword is in the Entrance Chamber. "An old iron sword."
+The Obsidian Door is north of the Hall of Statues and south of the Throne Room.
+It is closed and locked.
+The Serpent Crown is in the Throne Room. "A golden crown with emerald eyes."
+\`\`\`
+
+Or use \`load_adventure\` to load a pre-written adventure module with a ## World section.`,
+                },
+            }],
+    };
+});
+server.prompt("run_workflow", "Map Intent to Tools", async () => {
+    const registeredTools = server._registeredTools ?? {};
+    const toolNames = Object.keys(registeredTools).sort();
+    const novel = state.activeNovel;
+    const rulesetBound = !!novel?.ruleset;
+    const catalog = (cat, names) => names.filter(n => toolNames.includes(n)).join(", ");
+    const text = `# Run Workflow
+
+Map natural-language intent to the registered tool catalog. Derive associations
+from the live registry, not hardcoded strings.
+
+## Intent to Tool Mapping
+
+- **Spatial / movement / inspection**: ${rulesetBound ? "resolve_intent, command (GM)" : "command (parser)"}
+- **Character creation / advancement**: create_character, import_character, set_active_entity
+- **Combat**: init_combat, advance_combat, end_combat
+- **World building**: ${catalog("world", ["convert_source", "create_room", "create_thing", "create_exit"])}
+- **Narrative / scene**: ${catalog("narrative", ["set_scene_state", "record_story", "set_narrative_directive"])}
+- **Lookup**: ${catalog("lookup", ["search_rules", "spec_health", "suggest_actions"])}
+
+Select the tool whose registered action classification matches the intent.`;
+    return { messages: [{ role: "user", content: { type: "text", text } }] };
+});
+// ── Transport ──────────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((e) => {
+    console.error("Fatal error:", e);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map