Merge branch 'main' into staging/features

Merge pull request '✨Feature: implement run state management with combat resolution and room entry' (#7 ) from feature/run-state-flow into staging/features
Reviewed-on: #7
2026-03-15 19:04:06 +00:00 · 2026-03-15 18:53:14 +00:00 · 2026-03-15 18:53:03 +00:00 · 2026-03-15 18:52:27 +00:00 · 2026-03-15 18:52:08 +00:00 · 2026-03-15 18:46:14 +00:00
7 changed files with 104 additions and 939 deletions
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,344 +1,71 @@
 import React from "react";
 import { sampleContentPack } from "@/data/sampleContentPack";
 import { createStartingAdventurer } from "@/rules/character";
 import {
  createRunState,
  enterCurrentRoom,
  getAvailableMoves,
  isCurrentRoomCombatReady,
  resolveRunEnemyTurn,
  resolveRunPlayerTurn,
  startCombatInCurrentRoom,
  travelCurrentExit,
 } from "@/rules/runState";
 import type { RunState } from "@/types/state";
-function createDemoRun() {
+const planningDocs = [
-  const adventurer = createStartingAdventurer(sampleContentPack, {
+  "Planning/PROJECT_PLAN.md",
-    name: "Aster",
+  "Planning/GAME_SPEC.md",
-    weaponId: "weapon.short-sword",
+  "Planning/content-checklist.json",
-    armourId: "armour.leather-vest",
+  "Planning/DATA_MODEL.md",
-    scrollId: "scroll.lesser-heal",
+  "Planning/IMPLEMENTATION_NOTES.md",
-  });
+];
-  return createRunState({
+const nextTargets = [
-    content: sampleContentPack,
+  "Encode Level 1 foundational tables into structured JSON.",
-    campaignId: "campaign.demo",
+  "Implement dice utilities for D3, D6, 2D6, and D66.",
-    adventurer,
+  "Create character creation state and validation.",
-  });
+  "Build deterministic room generation for the Level 1 loop.",
-}
+];
 function getRoomTitle(run: RunState, roomId?: string) {
  if (!roomId) {
    return "Unknown Room";
  }
  const room = run.dungeon.levels[run.currentLevel]?.rooms[roomId];
  if (!room) {
    return "Unknown Room";
  }
  return (
    sampleContentPack.roomTemplates.find((template) => template.id === room.templateId)?.title ??
    room.notes[0] ??
    room.templateId ??
    room.id
  );
 }
 function App() {
  const [run, setRun] = React.useState<RunState>(() => createDemoRun());
  const currentLevel = run.dungeon.levels[run.currentLevel];
  const currentRoom = run.currentRoomId ? currentLevel?.rooms[run.currentRoomId] : undefined;
  const availableMoves = getAvailableMoves(run);
  const combatReadyEncounter = isCurrentRoomCombatReady(run);
  const handleReset = () => {
    setRun(createDemoRun());
  };
  const handleEnterRoom = () => {
    setRun((previous) => enterCurrentRoom({ content: sampleContentPack, run: previous }).run);
  };
  const handleStartCombat = () => {
    setRun((previous) =>
      startCombatInCurrentRoom({ content: sampleContentPack, run: previous }).run,
    );
  };
  const handleTravel = (direction: "north" | "east" | "south" | "west") => {
    setRun((previous) =>
      travelCurrentExit({
        content: sampleContentPack,
        run: previous,
        exitDirection: direction,
      }).run,
    );
  };
  const handlePlayerTurn = (manoeuvreId: string, targetEnemyId: string) => {
    setRun((previous) =>
      resolveRunPlayerTurn({
        content: sampleContentPack,
        run: previous,
        manoeuvreId,
        targetEnemyId,
      }).run,
    );
  };
  const handleEnemyTurn = () => {
    setRun((previous) =>
      resolveRunEnemyTurn({ content: sampleContentPack, run: previous }).run,
    );
  };
  return (
    <main className="app-shell">
      <section className="hero">
-        <div>
+        <p className="eyebrow">2D6 Dungeon Web</p>
-          <p className="eyebrow">2D6 Dungeon Web</p>
+        <h1>Project scaffold is live.</h1>
-          <h1>Dungeon Loop Shell</h1>
+        <p className="lede">
-          <p className="lede">
+          The app now has a Vite + React + TypeScript foundation, shared type
-            Traverse generated rooms, auto-resolve room entry, and engage combat
+          models, and Zod schemas that mirror the planning documents.
-            when a room reveals a real encounter.
+        </p>
          </p>
        </div>
        <div className="hero-actions">
          <button className="button button-primary" onClick={handleReset}>
            Reset Demo Run
          </button>
          <div className="status-chip">
            <span>Run Status</span>
            <strong>{run.status}</strong>
          </div>
        </div>
      </section>
-      {combatReadyEncounter && !run.activeCombat ? (
+      <section className="panel-grid">
        <section className="alert-banner">
          <div>
            <span className="alert-kicker">Encounter Ready</span>
            <strong>{currentRoom?.encounter?.resultLabel}</strong>
            <p>
              This room contains a combat-ready encounter. Engage now to enter
              tactical resolution.
            </p>
          </div>
          <button className="button button-primary" onClick={handleStartCombat}>
            Engage Encounter
          </button>
        </section>
      ) : null}
      <section className="dashboard-grid">
        <article className="panel panel-highlight">
          <div className="panel-header">
            <h2>Adventurer</h2>
            <span>Level {run.adventurerSnapshot.level}</span>
          </div>
          <div className="stat-strip">
            <div>
              <span>HP</span>
              <strong>
                {run.adventurerSnapshot.hp.current}/{run.adventurerSnapshot.hp.max}
              </strong>
            </div>
            <div>
              <span>Shift</span>
              <strong>{run.adventurerSnapshot.stats.shift}</strong>
            </div>
            <div>
              <span>Discipline</span>
              <strong>{run.adventurerSnapshot.stats.discipline}</strong>
            </div>
            <div>
              <span>Precision</span>
              <strong>{run.adventurerSnapshot.stats.precision}</strong>
            </div>
            <div>
              <span>XP</span>
              <strong>{run.adventurerSnapshot.xp}</strong>
            </div>
          </div>
          <p className="supporting-text">
            {run.adventurerSnapshot.name} is equipped with a{" "}
            {sampleContentPack.weapons.find(
              (weapon) => weapon.id === run.adventurerSnapshot.weaponId,
            )?.name ?? "weapon"}
            .
          </p>
          <p className="supporting-text">
            Run rewards: {run.xpGained} XP earned, {run.defeatedCreatureIds.length} foes defeated.
          </p>
        </article>
        <article className="panel">
-          <div className="panel-header">
+          <h2>Planning Set</h2>
-            <h2>Current Room</h2>
+          <ul>
-            <span>Level {run.currentLevel}</span>
+            {planningDocs.map((doc) => (
-          </div>
+              <li key={doc}>{doc}</li>
          <h3 className="room-title">
            {getRoomTitle(run, run.currentRoomId)}
          </h3>
          <p className="supporting-text">
            {currentRoom?.notes[1] ?? "No encounter notes available yet."}
          </p>
          <div className="room-meta">
            <span>Entered: {currentRoom?.discovery.entered ? "Yes" : "No"}</span>
            <span>Cleared: {currentRoom?.discovery.cleared ? "Yes" : "No"}</span>
            <span>Exits: {currentRoom?.exits.length ?? 0}</span>
          </div>
          <div className="button-row">
            <button className="button" onClick={handleEnterRoom}>
              Enter Room
            </button>
            <button
              className="button button-primary"
              onClick={handleStartCombat}
              disabled={!combatReadyEncounter || Boolean(run.activeCombat)}
            >
              Start Combat
            </button>
          </div>
          <div className="encounter-box">
            <span className="encounter-label">Encounter</span>
            <strong>{currentRoom?.encounter?.resultLabel ?? "None"}</strong>
          </div>
        </article>
        <article className="panel">
          <div className="panel-header">
            <h2>Navigation</h2>
            <span>{availableMoves.length} exits</span>
          </div>
          <div className="move-list">
            {availableMoves.map((move) => (
              <button
                key={move.direction}
                className="move-card"
                onClick={() => handleTravel(move.direction)}
                disabled={Boolean(run.activeCombat)}
              >
                <span>{move.direction}</span>
                <strong>{move.leadsToRoomId ? "Travel" : "Generate"}</strong>
                <em>
                  {move.leadsToRoomId
                    ? getRoomTitle(run, move.leadsToRoomId)
                    : `${move.exitType} exit`}
                </em>
              </button>
            ))}
-          </div>
+          </ul>
          <div className="mini-map">
            {currentLevel?.discoveredRoomOrder.map((roomId) => {
              const room = currentLevel.rooms[roomId];
              const active = roomId === run.currentRoomId;
              return (
                <article
                  key={roomId}
                  className={`map-node${active ? " map-node-active" : ""}`}
                >
                  <span>
                    {room.position.x},{room.position.y}
                  </span>
                  <strong>{getRoomTitle(run, roomId)}</strong>
                </article>
              );
            })}
          </div>
        </article>
        <article className="panel">
-          <div className="panel-header">
+          <h2>Immediate Build Targets</h2>
-            <h2>Combat</h2>
+          <ol>
-            <span>{run.activeCombat ? `Round ${run.activeCombat.round}` : "Inactive"}</span>
+            {nextTargets.map((target) => (
-          </div>
+              <li key={target}>{target}</li>
-          {run.activeCombat ? (
+            ))}
-            <>
+          </ol>
              <div className="combat-status">
                <span>Acting Side</span>
                <strong>{run.activeCombat.actingSide}</strong>
              </div>
              <div className="enemy-list">
                {run.activeCombat.enemies.map((enemy) => (
                  <div key={enemy.id} className="enemy-card">
                    <div>
                      <strong>{enemy.name}</strong>
                      <span>
                        HP {enemy.hpCurrent}/{enemy.hpMax}
                      </span>
                    </div>
                    <div className="enemy-actions">
                      <button
                        className="button"
                        onClick={() =>
                          handlePlayerTurn("manoeuvre.exact-strike", enemy.id)
                        }
                        disabled={
                          run.activeCombat?.actingSide !== "player" ||
                          enemy.hpCurrent <= 0
                        }
                      >
                        Exact Strike
                      </button>
                      <button
                        className="button"
                        onClick={() => handlePlayerTurn("manoeuvre.guard-break", enemy.id)}
                        disabled={
                          run.activeCombat?.actingSide !== "player" ||
                          enemy.hpCurrent <= 0
                        }
                      >
                        Guard Break
                      </button>
                    </div>
                  </div>
                ))}
              </div>
              <div className="button-row">
                <button
                  className="button button-primary"
                  onClick={handleEnemyTurn}
                  disabled={run.activeCombat.actingSide !== "enemy"}
                >
                  Resolve Enemy Turn
                </button>
              </div>
            </>
          ) : (
            <p className="supporting-text">
              No active combat. Travel until a room reveals a hostile encounter,
              then engage it from the banner or room panel.
            </p>
          )}
        </article>
-        <article className="panel panel-log">
+        <article className="panel">
-          <div className="panel-header">
+          <h2>Sample Content Pack</h2>
-            <h2>Run Log</h2>
+          <dl className="stats">
-            <span>{run.log.length} entries</span>
+            <div>
-          </div>
+              <dt>Tables</dt>
-          <div className="log-list">
+              <dd>{sampleContentPack.tables.length}</dd>
-            {run.log.length === 0 ? (
+            </div>
-              <p className="supporting-text">No events recorded yet.</p>
+            <div>
-            ) : (
+              <dt>Weapons</dt>
-              run.log
+              <dd>{sampleContentPack.weapons.length}</dd>
-                .slice()
+            </div>
-                .reverse()
+            <div>
-                .map((entry) => (
+              <dt>Manoeuvres</dt>
-                  <article key={entry.id} className="log-entry">
+              <dd>{sampleContentPack.manoeuvres.length}</dd>
-                    <span>{entry.type}</span>
+            </div>
-                    <p>{entry.text}</p>
+            <div>
-                  </article>
+              <dt>Creatures</dt>
-                ))
+              <dd>{sampleContentPack.creatures.length}</dd>
-            )}
+            </div>
-          </div>
+          </dl>
        </article>
      </section>
    </main>
--- a/src/data/contentHelpers.ts
+++ b/src/data/contentHelpers.ts
@@ -61,16 +61,3 @@ export function findCreatureByName(
  return creature;
 }
 export function findCreatureById(
  content: ContentPack,
  creatureId: string,
 ): CreatureDefinition {
  const creature = content.creatures.find((entry) => entry.id === creatureId);
  if (!creature) {
    throw new Error(`Unknown creature id: ${creatureId}`);
  }
  return creature;
 }
--- a/src/rules/runState.test.ts
+++ b/src/rules/runState.test.ts
@@ -6,12 +6,9 @@ import { createStartingAdventurer } from "./character";
 import {
  createRunState,
  enterCurrentRoom,
  getAvailableMoves,
  isCurrentRoomCombatReady,
  resolveRunEnemyTurn,
  resolveRunPlayerTurn,
  startCombatInCurrentRoom,
  travelCurrentExit,
 } from "./runState";
 function createSequenceRoller(values: number[]) {
@@ -185,72 +182,5 @@ describe("run state flow", () => {
    expect(result.run.dungeon.levels["1"]!.rooms["room.level1.start"]!.encounter?.rewardPending).toBe(
      false,
    );
    expect(result.run.adventurerSnapshot.xp).toBe(2);
    expect(result.run.xpGained).toBe(2);
    expect(result.run.defeatedCreatureIds).toEqual(["creature.level1.guard"]);
    expect(result.run.log.at(-1)?.text).toContain("Victory rewards");
  });
  it("lists available traversable exits for the current room", () => {
    const run = createRunState({
      content: sampleContentPack,
      campaignId: "campaign.1",
      adventurer: createAdventurer(),
    });
    expect(getAvailableMoves(run)).toEqual([
      expect.objectContaining({
        direction: "north",
        generated: false,
      }),
    ]);
  });
  it("travels through an unresolved exit, generates a room, and enters it", () => {
    const run = createRunState({
      content: sampleContentPack,
      campaignId: "campaign.1",
      adventurer: createAdventurer(),
      at: "2026-03-15T14:00:00.000Z",
    });
    const result = travelCurrentExit({
      content: sampleContentPack,
      run,
      exitDirection: "north",
      roller: createSequenceRoller([1, 1]),
      at: "2026-03-15T14:05:00.000Z",
    });
    expect(result.run.currentRoomId).toBe("room.level1.room.002");
    expect(result.run.dungeon.levels["1"]!.discoveredRoomOrder).toEqual([
      "room.level1.start",
      "room.level1.room.002",
    ]);
    expect(result.run.dungeon.levels["1"]!.rooms["room.level1.room.002"]!.discovery.entered).toBe(
      true,
    );
    expect(result.run.log[0]?.text).toContain("Travelled north");
  });
  it("flags combat-ready rooms once entry resolves a hostile encounter", () => {
    const run = createRunState({
      content: sampleContentPack,
      campaignId: "campaign.1",
      adventurer: createAdventurer(),
      at: "2026-03-15T14:00:00.000Z",
    });
    const room = run.dungeon.levels["1"]!.rooms["room.level1.start"]!;
    room.encounter = {
      id: `${room.id}.encounter`,
      sourceTableCode: "L1G",
      creatureIds: ["a", "b"],
      creatureNames: ["Guard", "Warrior"],
      resultLabel: "Guard and Warrior",
      resolved: true,
    };
    expect(isCurrentRoomCombatReady(run)).toBe(true);
  });
 });
--- a/src/rules/runState.ts
+++ b/src/rules/runState.ts
@@ -6,7 +6,6 @@ import type {
  RunState,
 } from "@/types/state";
 import type { LogEntry } from "@/types/rules";
 import { findCreatureById } from "@/data/contentHelpers";
 import { startCombatFromRoom } from "./combat";
 import {
@@ -15,11 +14,7 @@ import {
  type ResolveEnemyTurnOptions,
  type ResolvePlayerAttackOptions,
 } from "./combatTurns";
-import {
+import { initializeDungeonLevel } from "./dungeon";
  expandLevelFromExit,
  getUnresolvedExits,
  initializeDungeonLevel,
 } from "./dungeon";
 import type { DiceRoller } from "./dice";
 import { enterRoom } from "./roomEntry";
@@ -60,23 +55,6 @@ export type ResolveRunEnemyTurnOptions = {
  at?: string;
 };
 export type TravelCurrentExitOptions = {
  content: ContentPack;
  run: RunState;
  exitDirection: "north" | "east" | "south" | "west";
  roomTableCode?: string;
  roller?: DiceRoller;
  at?: string;
 };
 export type AvailableMove = {
  direction: "north" | "east" | "south" | "west";
  exitType: string;
  discovered: boolean;
  leadsToRoomId?: string;
  generated: boolean;
 };
 export type RunTransitionResult = {
  run: RunState;
  logEntries: LogEntry[];
@@ -189,37 +167,6 @@ function requireCurrentRoomId(run: RunState) {
  return run.currentRoomId;
 }
 function requireCurrentRoom(run: RunState) {
  const levelState = requireCurrentLevel(run);
  const roomId = requireCurrentRoomId(run);
  const room = levelState.rooms[roomId];
  if (!room) {
    throw new Error(`Unknown room id: ${roomId}`);
  }
  return room;
 }
 function inferNextRoomTableCode(run: RunState) {
  const room = requireCurrentRoom(run);
  const levelState = requireCurrentLevel(run);
  if (room.roomClass === "start") {
    return "L1LR";
  }
  if (room.roomClass === "small") {
    return "L1LR";
  }
  if (room.roomClass === "large") {
    return "L1SR";
  }
  return levelState.discoveredRoomOrder.length % 2 === 0 ? "L1LR" : "L1SR";
 }
 function syncPlayerToAdventurer(run: RunState) {
  if (!run.activeCombat) {
    return;
@@ -233,52 +180,6 @@ function appendLogs(run: RunState, logEntries: LogEntry[]) {
  run.log.push(...logEntries);
 }
 function createRewardLog(
  id: string,
  at: string,
  text: string,
  relatedIds: string[],
 ): LogEntry {
  return {
    id,
    at,
    type: "progression",
    text,
    relatedIds,
  };
 }
 function applyCombatRewards(
  content: ContentPack,
  run: RunState,
  completedCombat: CombatState,
  at: string,
 ) {
  const defeatedCreatureIds = completedCombat.enemies
    .filter((enemy) => enemy.hpCurrent === 0 && enemy.sourceDefinitionId)
    .map((enemy) => enemy.sourceDefinitionId!);
  const xpAwarded = defeatedCreatureIds.reduce((total, creatureId) => {
    return total + (findCreatureById(content, creatureId).xpReward ?? 0);
  }, 0);
  run.defeatedCreatureIds.push(...defeatedCreatureIds);
  run.xpGained += xpAwarded;
  run.adventurerSnapshot.xp += xpAwarded;
  if (xpAwarded === 0) {
    return [] as LogEntry[];
  }
  return [
    createRewardLog(
      `${completedCombat.id}.rewards`,
      at,
      `Victory rewards: gained ${xpAwarded} XP from ${defeatedCreatureIds.length} defeated creature${defeatedCreatureIds.length === 1 ? "" : "s"}.`,
      [completedCombat.id, ...defeatedCreatureIds],
    ),
  ];
 }
 export function createRunState(options: CreateRunOptions): RunState {
  const at = options.at ?? new Date().toISOString();
  const levelState = initializeDungeonLevel({
@@ -303,8 +204,6 @@ export function createRunState(options: CreateRunOptions): RunState {
      globalFlags: [],
    },
    adventurerSnapshot: options.adventurer,
    defeatedCreatureIds: [],
    xpGained: 0,
    log: [],
    pendingEffects: [],
  };
@@ -333,106 +232,6 @@ export function enterCurrentRoom(
  };
 }
 export function getAvailableMoves(run: RunState): AvailableMove[] {
  const room = requireCurrentRoom(run);
  return room.exits
    .filter((exit) => exit.traversable)
    .map((exit) => ({
      direction: exit.direction,
      exitType: exit.exitType,
      discovered: exit.discovered,
      leadsToRoomId: exit.leadsToRoomId,
      generated: Boolean(exit.leadsToRoomId),
    }));
 }
 export function isCurrentRoomCombatReady(run: RunState) {
  const room = requireCurrentRoom(run);
  return Boolean(
    room.encounter?.resolved &&
      room.encounter.creatureNames &&
      room.encounter.creatureNames.length > 0,
  );
 }
 export function travelCurrentExit(
  options: TravelCurrentExitOptions,
 ): RunTransitionResult {
  const run = cloneRun(options.run);
  if (run.activeCombat) {
    throw new Error("Cannot travel while combat is active.");
  }
  const levelState = requireCurrentLevel(run);
  const roomId = requireCurrentRoomId(run);
  const room = requireCurrentRoom(run);
  const exit = room.exits.find((candidate) => candidate.direction === options.exitDirection);
  if (!exit) {
    throw new Error(`Current room does not have an exit to the ${options.exitDirection}.`);
  }
  if (!exit.traversable) {
    throw new Error(`Exit ${exit.id} is not traversable.`);
  }
  let nextLevelState = levelState;
  let destinationRoomId = exit.leadsToRoomId;
  const at = options.at ?? new Date().toISOString();
  if (!destinationRoomId) {
    const unresolvedExits = getUnresolvedExits(levelState);
    const matchingExit = unresolvedExits.find(
      (candidate) =>
        candidate.roomId === roomId && candidate.direction === options.exitDirection,
    );
    if (!matchingExit) {
      throw new Error(`Exit ${exit.id} is no longer available for generation.`);
    }
    const expansion = expandLevelFromExit({
      content: options.content,
      levelState,
      fromRoomId: roomId,
      exitDirection: options.exitDirection,
      roomTableCode: options.roomTableCode ?? inferNextRoomTableCode(run),
      roller: options.roller,
    });
    nextLevelState = expansion.levelState;
    destinationRoomId = expansion.createdRoom.id;
  }
  run.dungeon.levels[run.currentLevel] = nextLevelState;
  run.currentRoomId = destinationRoomId;
  const movedLog: LogEntry = {
    id: `${roomId}.travel.${options.exitDirection}.${run.log.length + 1}`,
    at,
    type: "room",
    text: `Travelled ${options.exitDirection} from ${room.id} to ${destinationRoomId}.`,
    relatedIds: [room.id, destinationRoomId],
  };
  appendLogs(run, [movedLog]);
  const entered = enterCurrentRoom({
    content: options.content,
    run,
    roller: options.roller,
    at,
  });
  return {
    run: entered.run,
    logEntries: [movedLog, ...entered.logEntries],
  };
 }
 export function startCombatInCurrentRoom(
  options: StartCurrentCombatOptions,
 ): RunTransitionResult {
@@ -486,16 +285,9 @@ export function resolveRunPlayerTurn(
  appendLogs(run, result.logEntries);
  if (result.combatEnded) {
    const completedCombat = result.combat;
    const levelState = requireCurrentLevel(run);
    const roomId = requireCurrentRoomId(run);
    const room = levelState.rooms[roomId];
    const rewardLogs = applyCombatRewards(
      options.content,
      run,
      completedCombat,
      options.at ?? new Date().toISOString(),
    );
    if (room?.encounter) {
      room.encounter.rewardPending = false;
@@ -503,7 +295,6 @@ export function resolveRunPlayerTurn(
    }
    run.activeCombat = undefined;
    appendLogs(run, rewardLogs);
  }
  return {
--- a/src/schemas/state.ts
+++ b/src/schemas/state.ts
@@ -214,8 +214,6 @@ export const runStateSchema = z.object({
  dungeon: dungeonStateSchema,
  adventurerSnapshot: adventurerStateSchema,
  activeCombat: combatStateSchema.optional(),
  defeatedCreatureIds: z.array(z.string()),
  xpGained: z.number().int().nonnegative(),
  log: z.array(logEntrySchema),
  pendingEffects: z.array(ruleEffectSchema),
 });
--- a/src/styles.css
+++ b/src/styles.css
@@ -1,10 +1,9 @@
 :root {
-  font-family: "Trebuchet MS", "Segoe UI", sans-serif;
+  font-family: "Segoe UI", "Aptos", sans-serif;
-  color: #f4efe3;
+  color: #f3f1e8;
  background:
-    radial-gradient(circle at top, rgba(177, 91, 29, 0.25), transparent 26%),
+    radial-gradient(circle at top, rgba(179, 121, 59, 0.35), transparent 30%),
-    radial-gradient(circle at 20% 20%, rgba(227, 188, 101, 0.12), transparent 18%),
+    linear-gradient(180deg, #17130f 0%, #0d0b09 100%);
    linear-gradient(180deg, #160f0b 0%, #0b0807 100%);
  line-height: 1.5;
  font-weight: 400;
  color-scheme: dark;
@@ -24,373 +23,108 @@ body {
  min-height: 100vh;
 }
 button,
 input,
 textarea,
 select {
  font: inherit;
 }
 #root {
  min-height: 100vh;
 }
 .app-shell {
-  width: min(1200px, calc(100% - 2rem));
+  width: min(1100px, calc(100% - 2rem));
  margin: 0 auto;
-  padding: 1.5rem 0 3rem;
+  padding: 3rem 0 4rem;
 }
 .hero {
-  display: flex;
+  padding: 2rem;
-  justify-content: space-between;
+  border: 1px solid rgba(243, 241, 232, 0.16);
-  gap: 1.5rem;
+  background: rgba(21, 18, 14, 0.72);
-  align-items: end;
+  box-shadow: 0 30px 80px rgba(0, 0, 0, 0.35);
-  padding: 1.75rem;
+  backdrop-filter: blur(12px);
  border: 1px solid rgba(255, 231, 196, 0.12);
  background:
    linear-gradient(135deg, rgba(62, 34, 17, 0.92), rgba(24, 18, 15, 0.86)),
    rgba(18, 14, 12, 0.9);
  box-shadow: 0 24px 80px rgba(0, 0, 0, 0.42);
 }
 .eyebrow {
-  margin: 0 0 0.85rem;
+  margin: 0 0 0.75rem;
  text-transform: uppercase;
-  letter-spacing: 0.18em;
+  letter-spacing: 0.14em;
-  color: #f1ba73;
+  color: #d8b27a;
-  font-size: 0.76rem;
+  font-size: 0.8rem;
 }
 .hero h1 {
  margin: 0;
-  font-size: clamp(2.6rem, 6vw, 4.8rem);
+  font-size: clamp(2.5rem, 7vw, 4.5rem);
-  line-height: 0.92;
+  line-height: 0.95;
 }
 .lede {
-  width: min(56ch, 100%);
+  width: min(55ch, 100%);
-  margin: 1rem 0 0;
+  margin: 1.25rem 0 0;
-  color: rgba(244, 239, 227, 0.78);
+  color: rgba(243, 241, 232, 0.82);
  font-size: 1.05rem;
 }
-.hero-actions {
+.panel-grid {
  display: flex;
  flex-direction: column;
  gap: 0.85rem;
  align-items: flex-end;
 }
 .status-chip {
  display: flex;
  gap: 0.65rem;
  align-items: center;
  padding: 0.75rem 1rem;
  border: 1px solid rgba(255, 231, 196, 0.12);
  background: rgba(255, 231, 196, 0.05);
  text-transform: uppercase;
  letter-spacing: 0.08em;
  font-size: 0.78rem;
 }
 .status-chip strong {
  color: #f7d59d;
  font-size: 0.95rem;
 }
 .alert-banner {
  display: flex;
  justify-content: space-between;
  gap: 1rem;
  align-items: center;
  margin-top: 1rem;
  padding: 1rem 1.2rem;
  border: 1px solid rgba(255, 176, 94, 0.3);
  background:
    linear-gradient(90deg, rgba(117, 43, 21, 0.92), rgba(48, 22, 18, 0.92)),
    rgba(48, 22, 18, 0.92);
 }
 .alert-kicker {
  display: block;
  color: #ffbf78;
  text-transform: uppercase;
  letter-spacing: 0.12em;
  font-size: 0.74rem;
 }
 .alert-banner strong {
  display: block;
  margin-top: 0.25rem;
  font-size: 1.15rem;
  color: #fff4de;
 }
 .alert-banner p {
  margin: 0.35rem 0 0;
  color: rgba(244, 239, 227, 0.82);
 }
 .dashboard-grid {
  display: grid;
-  grid-template-columns: repeat(12, minmax(0, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
  gap: 1rem;
  margin-top: 1rem;
 }
 .panel {
-  grid-column: span 4;
+  padding: 1.25rem;
-  padding: 1.2rem;
+  border: 1px solid rgba(243, 241, 232, 0.14);
-  border: 1px solid rgba(255, 231, 196, 0.1);
+  background: rgba(29, 24, 19, 0.82);
  background: rgba(25, 19, 16, 0.86);
  box-shadow: inset 0 1px 0 rgba(255, 231, 196, 0.03);
 }
-.panel-highlight {
+.panel h2 {
-  background:
+  margin-top: 0;
    linear-gradient(180deg, rgba(101, 52, 28, 0.28), rgba(25, 19, 16, 0.92)),
    rgba(25, 19, 16, 0.9);
 }
 .panel-log {
  grid-column: span 12;
 }
 .panel-header {
  display: flex;
  justify-content: space-between;
  align-items: baseline;
  gap: 1rem;
  margin-bottom: 0.75rem;
  font-size: 1rem;
  color: #f6d49e;
 }
-.panel-header h2 {
+.panel ul,
 .panel ol {
  margin: 0;
-  font-size: 1rem;
+  padding-left: 1.1rem;
  color: #f8d79f;
 }
-.panel-header span {
+.panel li + li {
-  color: rgba(244, 239, 227, 0.58);
+  margin-top: 0.45rem;
  font-size: 0.83rem;
  text-transform: uppercase;
  letter-spacing: 0.08em;
 }
-.stat-strip {
+.stats {
  display: grid;
-  grid-template-columns: repeat(4, minmax(0, 1fr));
+  grid-template-columns: repeat(2, minmax(0, 1fr));
  gap: 0.75rem;
  margin: 0;
 }
-.stat-strip div,
+.stats div {
 .encounter-box,
 .combat-status {
  padding: 0.9rem;
-  background: rgba(255, 245, 223, 0.04);
+  background: rgba(243, 241, 232, 0.05);
  border: 1px solid rgba(255, 231, 196, 0.08);
 }
-.stat-strip span,
+.stats dt {
-.encounter-label,
+  color: rgba(243, 241, 232, 0.62);
-.combat-status span,
+  font-size: 0.8rem;
 .room-meta span,
 .log-entry span {
  display: block;
  color: rgba(244, 239, 227, 0.56);
  font-size: 0.76rem;
  text-transform: uppercase;
  letter-spacing: 0.08em;
 }
-.stat-strip strong,
+.stats dd {
-.encounter-box strong,
+  margin: 0.3rem 0 0;
-.combat-status strong {
+  font-size: 1.7rem;
-  display: block;
+  font-weight: 700;
  margin-top: 0.3rem;
  font-size: 1.45rem;
  color: #fff2d6;
 }
-.supporting-text {
+@media (max-width: 640px) {
  margin: 0.9rem 0 0;
  color: rgba(244, 239, 227, 0.76);
 }
 .room-title {
  margin: 0 0 0.35rem;
  font-size: 1.5rem;
  color: #fff2d6;
 }
 .room-meta {
  display: flex;
  flex-wrap: wrap;
  gap: 0.9rem;
  margin-top: 0.95rem;
 }
 .button-row,
 .enemy-actions {
  display: flex;
  flex-wrap: wrap;
  gap: 0.65rem;
  margin-top: 1rem;
 }
 .button {
  border: 1px solid rgba(255, 217, 163, 0.24);
  background: rgba(255, 245, 223, 0.04);
  color: #f4efe3;
  padding: 0.72rem 1rem;
  cursor: pointer;
  transition:
    transform 140ms ease,
    background 140ms ease,
    border-color 140ms ease;
 }
 .button:hover:enabled {
  transform: translateY(-1px);
  background: rgba(255, 217, 163, 0.09);
  border-color: rgba(255, 217, 163, 0.35);
 }
 .button:disabled {
  opacity: 0.42;
  cursor: not-allowed;
 }
 .button-primary {
  background: linear-gradient(180deg, #c36b2d, #8d4617);
  border-color: rgba(255, 217, 163, 0.32);
  color: #fff4e1;
 }
 .button-primary:hover:enabled {
  background: linear-gradient(180deg, #d97833, #9f501b);
 }
 .encounter-box,
 .combat-status {
  margin-top: 1rem;
 }
 .move-list,
 .mini-map,
 .enemy-list {
  display: grid;
  gap: 0.75rem;
 }
 .mini-map,
 .enemy-list {
  margin-top: 1rem;
 }
 .move-card,
 .map-node,
 .enemy-card {
  width: 100%;
  text-align: left;
  padding: 0.95rem;
  border: 1px solid rgba(255, 231, 196, 0.08);
  background: rgba(255, 245, 223, 0.04);
 }
 .move-card {
  cursor: pointer;
  transition:
    transform 140ms ease,
    background 140ms ease,
    border-color 140ms ease;
 }
 .move-card:hover:enabled {
  transform: translateY(-1px);
  background: rgba(255, 217, 163, 0.09);
  border-color: rgba(255, 217, 163, 0.35);
 }
 .move-card:disabled {
  opacity: 0.42;
  cursor: not-allowed;
 }
 .move-card span,
 .map-node span {
  display: block;
  color: rgba(244, 239, 227, 0.56);
  font-size: 0.74rem;
  text-transform: uppercase;
  letter-spacing: 0.08em;
 }
 .move-card strong,
 .map-node strong,
 .enemy-card strong {
  display: block;
  margin-top: 0.3rem;
  font-size: 1rem;
  color: #fff2d6;
 }
 .move-card em,
 .enemy-card span {
  display: block;
  margin-top: 0.3rem;
  font-style: normal;
  color: rgba(244, 239, 227, 0.7);
 }
 .map-node-active {
  border-color: rgba(243, 186, 115, 0.55);
  background: rgba(243, 186, 115, 0.12);
 }
 .log-list {
  display: grid;
  gap: 0.75rem;
  max-height: 340px;
  overflow: auto;
  padding-right: 0.2rem;
 }
 .log-entry {
  padding: 0.9rem;
  border-left: 3px solid rgba(243, 186, 115, 0.7);
  background: rgba(255, 245, 223, 0.04);
 }
 .log-entry p {
  margin: 0.35rem 0 0;
  color: #f4efe3;
 }
@media (max-width: 980px) {
  .panel,
  .panel-log {
    grid-column: span 12;
  }
 }
@media (max-width: 720px) {
  .app-shell {
-    width: min(100% - 1rem, 1200px);
+    width: min(100% - 1rem, 1100px);
-    padding-top: 0.75rem;
+    padding-top: 1rem;
  }
  .hero,
-  .alert-banner {
+  .panel {
-    flex-direction: column;
+    padding: 1rem;
    align-items: stretch;
  }
  .hero-actions {
    align-items: stretch;
  }
  .stat-strip {
    grid-template-columns: repeat(2, minmax(0, 1fr));
  }
 }
--- a/src/types/state.ts
+++ b/src/types/state.ts
@@ -215,8 +215,6 @@ export type RunState = {
  dungeon: DungeonState;
  adventurerSnapshot: AdventurerState;
  activeCombat?: CombatState;
  defeatedCreatureIds: string[];
  xpGained: number;
  log: LogEntry[];
  pendingEffects: RuleEffect[];
 };
Author	SHA1	Message	Date
Keith Solomon	7fb3bd6cf5	Merge branch 'main' into staging/features	2026-03-15 19:04:06 +00:00
Keith Solomon	9c7acf6825	Merge pull request '✨Feature: implement run state management with combat resolution and room entry' (#7 ) from feature/run-state-flow into staging/features Reviewed-on: #7	2026-03-15 18:53:14 +00:00
Keith Solomon	102cbfeaad	Merge branch 'staging/features' into feature/run-state-flow	2026-03-15 18:53:03 +00:00
Keith Solomon	377a533466	Merge pull request '✨Feature: implement combat' (#6 ) from feature/combat into staging/features Reviewed-on: #6	2026-03-15 18:52:27 +00:00
Keith Solomon	e3f90ca545	Merge branch 'staging/features' into feature/combat	2026-03-15 18:52:08 +00:00
Keith Solomon	79b9e448b7	Merge pull request '✨Feature: implement combat turn resolution with player and enemy actions' (#5 ) from feature/combat-turns into feature/combat Reviewed-on: #5	2026-03-15 18:46:14 +00:00
Keith Solomon	aea00d31e8	Merge pull request '✨Feature: implement room entry flow with encounter resolution and logging' (#4 ) from feature/room-entry-flow into staging/features Reviewed-on: #4	2026-03-15 18:30:14 +00:00
Keith Solomon	fdaa2e3135	Merge branch 'staging/features' into feature/room-entry-flow	2026-03-15 18:28:40 +00:00
Keith Solomon	67453df51e	Merge pull request '✨Feature: enhance encounter resolution with creature names and result labels' (#3 ) from feature/encounter-resolution into staging/features Reviewed-on: #3	2026-03-15 18:19:53 +00:00
Keith Solomon	cff5f786a0	Merge pull request '✨Feature: implement dungeon state management with room expansion and exit handling' (#2 ) from feature/dungeon-state into staging/features Reviewed-on: #2	2026-03-15 18:19:15 +00:00
Keith Solomon	5debb5bd5e	Merge pull request '✨Feature: Add foundational rules and mechanics' (#1 ) from feature/rules-foundation into main Reviewed-on: #1	2026-03-15 17:58:14 +00:00