RELEASE NOTES

A small feedback tab now lives in the bottom-right corner of the battle screen at all times. Click it to open a panel where you can flag a bug, suggest a change, or leave any note — without leaving the game. Submissions go straight to the admin review queue.

• app/tactical/_components/feedback-tab.tsx: New Pure Fabrication component. Corner tab triggers a slide-up panel with a type selector (Bug / Suggestion / Other), textarea (1000 char limit, live counter), and Send button. Submits to POST /api/feedback with page: '/tactical'. Shows success confirmation and auto-closes after 1.8s. No store access.
• app/tactical/page.tsx: FeedbackTab imported and rendered as the last child of <main>, after the post-match screen.
• app/docs/roadmap/page.tsx: In-Game Feedback Button moved from HIGH to COMPLETE.
• lib/version.ts + package.json: bumped to v00.21.05.

After every match, instead of a bare win/loss popup, you now see a full post-match screen with three tabs. The Battle Chronicle tells the story of what happened in each faction's voice — Vampires speak of blood-tithes while placeholder units get dry field reports. The Tactical Report shows MVP, first blood, turning points, and momentum shifts. The Squad Breakdown shows how each squad performed in kills, damage, and losses. Everything runs from the battle log with no AI token cost.

• lib/tactical/post-match/match-analyzer.ts: New module. analyzeMatch() reads the battle log to compute per-squad kills, damage, and losses. Identifies MVP (kills×3 + damage/5 + objectives×4 − modelsLost), tanker (most damage absorbed), first blood, and turning points (momentum swings, squad wipes, VP swings, multi-kill rounds). Tracks kill attribution via a lastAttacker Map built from damage_dealt events.
• lib/tactical/post-match/narrative-generator.ts: New module. Faction voice registry (VOICE_REGISTRY) with themed vocabulary for all 10 factions. generateNarrative() produces a multi-paragraph battle chronicle with title, verdict, and key insight.
• lib/tactical/post-match/index.ts: Barrel export for analyzeMatch, generateNarrative, and their types.
• app/tactical/_components/post-match-screen.tsx: Three-tab UI component — Battle Chronicle (narrative), Tactical Report (stats), Squad Breakdown (per-squad cards). Cinzel/parchment/gold styling consistent with existing game UI.
• app/tactical/page.tsx: Old inline win/draw overlay (~80 lines) replaced with <PostMatchScreen> component.
• lib/tactical/store.ts + ai-orchestrator.ts: battle_ended log event added when checkWinConditions() detects game over. Payload: winner, reason, finalVP, survivors, totalRounds. const→let fix in advanceRitePhase for log append.
• lib/version.ts + package.json: bumped to v00.21.04.

When you buy a larger army than the AI opponent (more squads in total), the game was getting stuck after the AI ran out of squads to activate. The turn would flip to the AI with nothing for it to do, and instead of passing the turn back it left the game in a broken state where you could accidentally click and select the enemy's units. This is now fixed — when the AI has no squads left to activate, it correctly hands control back to you.

• ai-orchestrator.ts: getActivatableSquads imported from engine. After takeTurn() produces an empty action list, the orchestrator now checks whether P1 still has activatable squads. If yes, it flips currentPlayer back to 1 and pushes a player-turn toast. If both sides have nothing left (defensive fallback), it clears isAITurn without freezing. Previously the empty-actions path fell through to the recursive terminus which correctly cleared isAITurn but left currentPlayer === 2, making enemy models selectable.
• lib/version.ts + package.json: bumped to v00.21.03.

Legibility pass on the army builder screens. Secondary text in both the faction selector and the unit cards was too small and too dark to read comfortably. Font sizes and colours updated throughout.

• army-builder.tsx (faction step): Faction name 0.75→0.9rem; resource label 0.45→0.6rem, colour lightened; tagline 0.5→0.62rem, colour lightened; “COMING SOON” badge made visible from near-invisible to #4a3a28.
• army-builder.tsx (unit cards): Tier/class/MDL line 0.42→0.6rem, lightened; “PTS” label 0.38→0.55rem, lightened; stat label row 0.32→0.5rem, lightened; weapon line 0.42→0.6rem, lightened; trait badge 0.37→0.55rem, lightened; ability excerpt 0.42→0.6rem, lightened; “NOT IN ARMY” label lightened; footer and eyebrow labels also lifted to match.
• lib/version.ts + package.json: bumped to v00.21.02.

Two fixes for the new army-building flow. First: after picking your army and edicts on the second (or later) game in a session, the edict selector was being skipped entirely — the game dropped straight into the old battle still loaded in memory. Second: if you bought more squads than the AI opponent had, you could only deploy as many squads as the AI before the deploy phase ended prematurely.

• page.tsx: Pre-battle gate condition changed from !battle to pendingEdicts === null. The old condition routed correctly on the first game (battle was null) but skipped the EdictSelector on all subsequent games because the previous battle remained loaded in the Zustand store. The new condition gates purely on local React flow state and is unaffected by store contents.
• store.ts: placeSquad() — nextPlayer changed from const to let; if the natural next player has no squads remaining, it skips forward to the player who still has squads. Previously, when P2 ran out of squads first, activePlayer was set to P2 with selectedSquadId: null, leaving P1 with unplaced squads and no way to continue. The AI auto-deploy trigger is unchanged but now fires correctly for uneven army sizes.
• lib/version.ts + package.json: bumped to v00.21.01.

The game now starts with a genuine choice. Before deploying your forces, you build your warband from scratch — pick your faction from the full roster, then spend your point budget on units from that faction's available lineup. Larger battles give you more points and a bigger army. Every game starts differently because you decide which squads to bring.

• lib/tactical/army-builder.ts: New module — ARMY_POINT_LIMITS (400 / 650 / 1000 pts for Skirmish / Standard / Grand), ArmySquadEntry, ArmySelection types, FACTION_META (all 10 factions, only VAM available), FACTION_UNITS registry.
• army-builder.tsx: New component — two-step full-screen flow. Step 1: faction selector (10 faction cards; VAM enabled, others Coming Soon). Step 2: unit picker grid with per-unit cards, point-meter progress bar, +/− squad controls, and sticky footer with point total. Matches pre-battle visual style (Cinzel, dark bg, gold accent).
• dev-state.ts: buildDevState() gains optional p1Squads?: ArmySquadEntry[] param. When provided, P1's warband is built from the player's selection; otherwise falls back to the hardcoded dev setup (two VAM T1 squads). Squad IDs use sequential p1-squad-N prefix.
• page.tsx: Pre-battle flow extended to three steps: BattleSizeSelector → ArmyBuilder → EdictSelector. pendingArmy: ArmySelection | null state added. PLAY AGAIN resets all three steps. Docstring updated to reflect live flow.
• lib/version.ts + package.json: bumped to v00.21.00.

When a heavy unit successfully blocks a charge, the game now shows a clear CHARGE DENIED result in the combat log — no more wondering why the charge did not land. The denied result appears alongside First Strike and standard charge panels so all reactive outcomes have the same visible feedback.

• store.ts: lastChargeDenied: boolean added to TacticalUIState; resolveChargeLanding() sets it true when applyChargeDenialIfEligible() fires a denial and false on all other charge resolutions.
• page.tsx: CHARGE DENIED log panel added (red border, consistent with charge panel stack); reads lastChargeDenied from store subscription; renders when true. Panel clears on next interaction alongside other combat log panels.
• lib/version.ts: bumped to v00.20.30.

Heavy, armoured units can now deny a charge entirely before it resolves — if a unit with the Charge Denial trait is waiting when an enemy tries to rush in, the charge is stopped cold and the attacker eats a free counter-attack. No wounds land, no retaliation fires; the charge simply does not happen. The placeholder Brute unit now carries this trait so the mechanic can be tested immediately.

• types.ts: 'charge-denial' added to UnitTrait union; 'charge_denied' added to BattleEventType (after 'first_strike_triggered').
• engine.ts: applyChargeDenialIfEligible() implemented — checks the defending squad for the charge-denial trait, fires a pooled melee counter-attack against the charging squad, logs a charge_denied event, and returns a chargeDenied flag.
• actions.ts: applyChargeDenialIfEligible imported from engine; wired as the first check inside applyChargeWithRetaliation() — fires before the First Strike path and before charge attacks. If chargeDenied is true, the function returns early with empty results.
• placeholder-units.ts: traits: ['charge-denial'] added to the T3 Brute (ph-brute) entry.

Thrall units now have a reason to stay in the fight — every kill they land this round charges up a bonus attack die that carries into their next swing. Stack kills and the Thrall becomes genuinely threatening; lose the round without landing a kill and the bonus resets. A ⚡ badge on the unit info panel shows the current bonus so you always know how many extra dice you're sitting on.

• types.ts: killTriggerBonus?: number added to LiveSquad; kill-trigger trait comment updated to reference VAM Thrall.
• engine.ts: applyChargeAttacks() consumes killTriggerBonus before swing and increments it on kill; resolveEndOfRound() resets killTriggerBonus: 0 for all squads.
• actions.ts: executeAttack() consumes killTriggerBonus before resolveAttack() and increments it after spillover kills (ranged and melee). Bonus is capped at 3.
• unit-info-panel.tsx: killTriggerBonus prop added; ⚡ +N ATK badge renders in gold when bonus is > 0.
• page.tsx: killTriggerBonus passed to UnitInfoPanel from infoSquad state.

Nightshroud now punishes charging enemies with First Strike — if the defenders deal enough damage before the charge lands, the charge is suppressed entirely and the attacker never gets to swing. The combat log shows the First Strike results first, then the charge result (or “CHARGE SUPPRESSED” in red if the charge was stopped).

• engine.ts: applyFirstStrikeIfEligible() implemented — checks the defending squad for the first-strike trait, fires pooled melee attacks against the charging squad, and returns results plus a chargeSuppressed flag if the charge point member was slain.
• store.ts: resolveChargeLanding() now calls applyFirstStrikeIfEligible() before applyChargeAttacks(). If chargeSuppressed is true, both applyChargeAttacks and applyRetaliationIfEligible are skipped. lastFirstStrikeResults set on every charge resolution; cleared to [] on normal attacks. Fixed missing unitMoveDestinations: {} in initial state block.
• page.tsx: First Strike combat log panel added (amber/gold border) above the charge panel. “CHARGE SUPPRESSED” text appears in the panel when first strike kills the point member. lastFirstStrikeResults selector added.
• vam-units.ts: Nightshroud traits: ['first-strike'] (corrected from invalid firstStrike: true field).

No gameplay changes. This release finishes a clean-up pass on the main game file — moving the last two visual helper functions into their own dedicated module. The code that decides which hexes to warn you about during formation and which colours to show on unit-move ghosts now lives in a focused formation utilities file, keeping the top-level page code lean and readable.

• formation-utils.ts (new — lib/tactical/): getFormationWarnHexes() (Extraction 6/7) and getSquadMoveGhostColors() (Extraction 7/7) extracted from page.tsx. getSquadMoveGhostColors() uses getFactionColors() from unit-codes.ts instead of a direct FACTION_COLORS lookup, matching the canonical faction-colour resolution path. Completes the 7-extraction decomposition pass.
• page.tsx: Both IIFEs replaced with clean one-liner calls importing from formation-utils. hexDistance and FACTION_COLORS imports removed. No logic changes.
• styles.ts (same session — Extraction 5/7): Style constants extracted from page.tsx into app/tactical/_components/styles.ts in the same decomposition pass. BattleSizeSelector import path corrected as part of that patch.

Forced March and Press The Line now move the entire squad reliably. Previously, some members could get stuck if a squad-mate that moved earlier happened to occupy a hex their forward path would have used. The fix makes front-most models advance first, clearing the way for those behind them.

• edict-actions.ts: applyForcedMarch() and applyPressTheLine() now sort livingMembers front-to-back before iterating — descending by q for P1, ascending for P2. Front models advance first, vacating hexes that rear members need to find valid forward candidates. No change to movement rules, step count, or hasMoved handling. Resolves M-05.

When you hover a destination in Unit Move mode, you can now instantly tell which ghost is the point member leading the formation and which are followers snapping in behind. The leader shows a gold pip at its centre, a slightly larger token ring, and a solid gold outline — followers are smaller, dimmer, and dashed. No rules or logic changed.

• tactical-map.tsx: Leader ghost (index squadMoveLeaderIndex, always 0) now renders with radius 11 (vs 9 for followers), solid gold stroke (#c8a840) at 1.5px (vs dashed 1px), opacity 0.75 (vs 0.55), and a filled gold center pip (r=3, fill="#c8a840"). Follower ghosts retain the existing dashed faction-colored style at reduced opacity. No store, engine, or types changes. Resolves P-17.

After you put a model on overwatch, the bottom bar no longer shows two competing pieces of text at once. The “OVERWATCH SET” confirmation now appears where the phase label normally sits, styled in the same gold so it reads as a status report rather than an instruction. The Advance button on the right remains visible — you can still step to the next phase immediately after declaring overwatch.

• page.tsx: Phase label (· MOVE PHASE ·) is now suppressed when statusMessage is set and selectedModelId is null — the condition unique to overwatch declaration. In that state the status message renders in the phase-label slot: gold, 0.65rem, 0.14em letter-spacing. All other status messages (NO VALID TARGETS IN RANGE, SELECT ENEMY TARGET) fire while a model is still selected, so they continue to render as red warnings below the phase label. No store, engine, or types changes. Resolves P-20.

Objective scoring at the end of each round now gets a proper moment. The round-start toast now shows a third line in gold — “OBJECTIVES · P1 +2 VP · P2 +1 VP” — so both players can immediately see what the round was worth. If no objectives were scored, the line is omitted. When VP is shown, the toast stays on screen for 3 seconds instead of 2 to give you time to read it.

• types.ts: Optional vpMessage?: string field added to BattleToast. Only populated on kind: 'round' toasts when at least one player scored VP this round.
• store.ts: In advanceRitePhase(), VP delta computed as newBattle.vp[N] - battle.vp[N] after completeSquadActivation() returns. When either delta is non-zero, vpMessage is set to “OBJECTIVES · P1 +N VP · P2 +N VP” and durationMs extends from 2000 to 3000. No engine changes.
• page.tsx: RiteToast renders a third gold line (#c8a840, 0.6rem Cinzel) when toast.vpMessage is set. Positioned below the initiative line. Resolves P-04.

The deploy screen now clearly shows which side of the map each player owns. The left zone is highlighted in blue for Player 1, the right in red for Player 2 — with matching labels on the map edges and inside the zones themselves. The squad panel also shows a short direction hint so you always know where to place your forces.

• tactical-map.tsx: Edge labels conditioned on state.phase === 'deploy' — now only shown during deployment. Fill colors changed from near-black to P1-blue (#3a6aaa) and P2-red (#aa3a3a), text expanded to “PLAYER 1 DEPLOY ZONE” / “PLAYER 2 DEPLOY ZONE”. Two additional in-grid P1 / P2 labels added inside the zoom/pan group, x-positions derived from hexToPixel() column averages via new DEPLOY_ZONE_LABEL_X_P1 / DEPLOY_ZONE_LABEL_X_P2 constants — labels track the map at any zoom level.
• deploy-panel.tsx: Zone direction hint added under the header divider: ← YOUR ZONE · LEFT SIDE for P1, YOUR ZONE · RIGHT SIDE → for P2. Color matches player accent. Display-only change. Resolves P-16.

New players now see a brief rules screen before their first activation. After the coin toss resolves and the first-player choice is made, the coin-flip modal advances to a second screen “The Law of the Rite” that explains the three core activation rules. The player dismisses it by clicking BEGIN BATTLE — it is never auto-dismissed.

• coin-flip-modal.tsx: Two-step flow added via local step: 'flip' | 'rules' state and pendingFirstPlayer: 1 | 2 | null. Player choice buttons and the AI auto-choose path now set pendingFirstPlayer and advance step to 'rules' instead of calling onChoose directly. Rules screen shows three onboarding rules (One Squad Per Turn, Players Alternate, Hold the Ground) in the existing Cinzel / dark-gold visual style. onChoose fires only when BEGIN BATTLE is clicked. No store, types, engine, or other UI changes. Resolves P-14.

The bottom bar now gives first-time players clearer guidance when nothing is selected. During the battle phase it reads “Click a friendly member to begin your rite” with a sub-line reminding you that each squad gets one turn to move, shoot, or fight. During deployment it points you to the panel and tells you to click your zone to place.

• page.tsx: Idle state fallback in the action bar centre replaced with a phase-aware two-line block. Battle idle: primary CLICK A FRIENDLY MEMBER TO BEGIN YOUR RITE, sub Move · Shoot · Fight — one squad per turn. Deploy idle: primary SELECT A SQUAD FROM THE PANEL, sub Then click your deployment zone to place it. Sub-line styled #8a7a5a, 0.55rem — consistent with the edict phase flavour text. Display-only change. Resolves P-12.

The AI no longer deploys in silence — after each enemy squad is placed during the deploy phase, a banner slides in from the top of the screen reading “ENEMY DEPLOYS: [UNIT NAME]” and fades out automatically. Previously the AI's tokens simply appeared on the map with no feedback.

• store.ts: placeSquad() now pushes a 'phase' kind BattleToast (1500ms, auto-dismiss) when isAIDeploy === true. Message is ENEMY DEPLOYS: <DEF NAME>, derived from unitDefinitions[squad.definitionId].name. Uses the existing PhaseBanner component and popToast/dismissToast infrastructure — no new state, types, or UI components. Resolves P-06.

Edict cards on the battlefield now open a full-detail modal when clicked — showing the edict name, category, timing, and full description alongside the Spend Edict button. Previously clicking a card expanded it inline; now the cards stay compact and the modal handles all the detail, matching the behaviour of the edict selection screen.

• edict-strip.tsx: Replaced inline expand/collapse with a EdictDetailModal component. Cards are now compact name chips with a ◈ hint icon. Clicking any card opens the modal. Modal matches the selector's visual style — category badge, name, timing pill, full description, and SPEND EDICT button. Backdrop click or ✕ closes it.

Portrait tokens no longer show a unit code label over the image — the portrait itself is the identity. Tokens without a portrait are unchanged.

• tactical-model-token.tsx: Unit code text block is now suppressed when TOKEN_IMAGES[definitionId] is set. Flat-fill tokens render the label as before.

Nightshroud tokens now show a portrait on the hex map — a tight crop of the unit's face with glowing red eyes centered in the circle. The token system was also refactored: instead of a hardcoded check for a single unit, any unit can now get a portrait token by adding one line to a central registry.

• tactical-model-token.tsx: Added TOKEN_IMAGES registry (Record<definitionId, imagePath>). Token body block now checks TOKEN_IMAGES[definitionId] instead of hardcoding definitionId === 'vam-thrall'. Adding portrait tokens for future units requires one registry entry — no render logic changes.
• public/images/factions/vampires/units/nightshroud/token.jpg: New 259×259px face-centred crop of the Nightshroud portrait, centred on the glowing eyes at 48% x / 22% y of the original 576×1024 image.

Updated the design guide to accurately reflect the current token visual spec — token sizes, stroke weights, and ring measurements now match the code exactly.

• app/docs/design-guide/page.tsx: Geometry spec table corrected — token body radius updated from r=11px (all tiers) to r=9–18px (tier-scaled) with the full T1–T6 breakdown; token stroke width updated from 1.5px to 0.75px (T1–T4) · 1px (T5–T6); member view faction ring updated from r=11 · 1.5px to tier radius · 0.75px.

Fixed a bug where only the lead model of a charging squad would reach the enemy — the rest of the unit was left behind because followers were only allowed their normal movement range during a charge. Now the whole squad commits to the charge together, using the same extended range as the charging leader.

• Fix (engine.ts — getChargeDestinations): Charge followers now use chargeRange (MOV + 3) instead of MOV when computing reachable follower slots. Previously followers were evaluated at base MOV, causing them to be marked stranded whenever the charge destination was more than MOV hexes from their current position.

Vampire Thrall tokens on the hex map now show a portrait of the unit instead of a flat colour. A face-centred crop of the unit's oil painting portrait is displayed inside the circular token, giving each Thrall a distinct visual identity on the battlefield. A new dev tool for saving image crops to the public folder was also added to support future unit portrait work.

• tactical-model-token.tsx: Thrall token body now renders a circular portrait image (token.jpg) via SVG <image> + <clipPath>, with a faction-coloured stroke ring. All other units unchanged.
• public/images/factions/vampires/units/thrall/token.jpg: New 276×276px face-centred crop of the Thrall portrait, optimised for circular token rendering.
• app/api/save-image/route.ts: Dev-only POST endpoint that accepts a base64 image payload and writes it to public/images/. Used by the canvas crop pipeline.
• Fix (page.tsx): _abModel temporal dead zone crash resolved — declaration moved above _showMoveUnit which referenced it.

Fixed a loop where selecting a unit that had already moved would trap the player in an empty movement mode with no way to attack, charge, or advance — forcing a cancel and re-select that just repeated the same dead end. The unit now correctly falls through to show whatever actions are still available after its move is spent.

• Fix (store.ts): initiateUnitMove() now guards on pointMember.hasMoved. Previously it entered unit-move mode with zero destinations when the point member had already moved, which set unitMoveMode: true and hid all ATTACK, CHARGE, and OVERWATCH buttons (all require !unitMoveMode). Now returns early so the player sees the correct remaining actions.
• Fix (page.tsx): _showMoveUnit visibility flag now includes !_abModel?.hasMoved so the MOVE UNIT button does not appear as a dead option after movement is spent.

Edict cards are now significantly more readable — larger text and brighter colours throughout. A new “third click” Full View button opens a centred modal for each edict showing the full name, category, timing, and description at comfortable reading size, with a select/deselect button inside so you never have to close it to make a choice.

• edict-selector.tsx: Edict name bumped from 0.6rem to 0.75rem; unselected colour lifted from #8a7a5a to #b0a080; selected name now #e8d090. Category label up from 0.45rem to 0.55rem; all five category colours brightened. Inline description up from 0.55rem #6a5a3a to 0.72rem #a09070.
• edict-selector.tsx: ‘◈ FULL VIEW’ button added to each card alongside ‘▼ DETAILS’. Opens EdictModal — a z-80 overlay with edict name at 1.25rem, category badge, timing pill, full description at 0.95rem/1.75 line-height, and an add/remove toggle button. Backdrop click closes the modal.

Admins can now configure how P2 is set up before a battle starts. A new Battle Configuration page in the admin panel offers four modes: Baseline (always placeholder units), Random (AI picks from available factions each game), Specific Faction (admin pre-selects which faction P2 plays), and Player Selected (pending — requires faction selection screen). The P2 squad roster is now data-driven and will expand automatically as new factions are built.

• Schema (prisma/schema.prisma): New GameConfig model — key/value singleton rows for admin-controlled runtime settings. Run prisma db push before deploying.
• API (app/api/game-config/route.ts): GET returns current P2 config (public, read by tactical page on load). PATCH updates config (admin-only). Defaults to baseline if no row exists yet.
• Admin page (app/admin/game-config/page.tsx): Four mode options with descriptions. Specific Faction mode reveals a faction picker (all available factions + baseline). Player Selected shown as PENDING badge. Active state summary. Save button with saving/saved feedback.
• Admin layout (app/admin/layout.tsx): BATTLE CFG entry added to sidebar nav.
• Admin hub (app/admin/page.tsx): Battle Configuration card added.
• Tactical page (app/tactical/page.tsx): P2_FACTION_SQUADS registry maps faction IDs to squad definitions (placeholder + vam). resolveP2Faction() handles all four modes. buildDevState() accepts p2Mode and p2SpecificFaction params. Page fetches config on mount and passes it through. Hardcoded P2 placeholder squads replaced with data-driven loop.

Three new opening-game edicts give you powerful plays in rounds 1–2, before the lines engage. Forced March lets a squad rush forward without burning their move action. Scouting Report strips cover from an enemy squad for the rest of the round. Forward Scouts teleports a T1 squad to the board's midfield in a bold early gambit. A direction bug in Press The Line and Forced March was also fixed — both now correctly push squads along the board's horizontal axis toward the enemy.

• Bug fix (edict-actions.ts): applyPressTheLine() was filtering and scoring movement along the r-axis (rows) instead of the q-axis (columns). P1 deploys in low-q columns; P2 in high-q. All three axis references corrected: filter conditions now check nb.q against pos.q, and the reducer picks the candidate with the largest q-direction delta.
• Feature (edict-actions.ts): applyForcedMarch() added — identical to Press The Line's q-axis advance logic, but hasMoved is intentionally NOT set on moved models, preserving their full move action for later in their activation.
• Feature (edict-actions.ts): applyScoutingReport() added — sets edictBuffs.scoutedSquadId on the target enemy squad. Cover is stripped in executeAttack() in actions.ts whenever the target squad's ID matches the scouted ID.
• Feature (edict-actions.ts): applyForwardScouts() added — T1-only, hasAttacked guard; places squad within 3 hexes of board centre via buildDeployFormation(); iterates sorted anchor candidates until a full formation fits.
• Types (types.ts): EdictId union extended with forced-march, scouting-report, forward-scouts. edictBuffs shape on BattleState gains scoutedSquadId: string | null.
• Registry (edicts.ts): Three new EdictDefinition entries appended to UNIVERSAL_EDICTS. Forward Scouts carries tierLimit: 1.
• Actions (actions.ts): executeAttack() — cover computation now checks edictBuffs.scoutedSquadId; if the target squad is scouted, cover is forced to 'none' before passing to resolveAttack().
• Init (page.tsx): buildDevState() — edictBuffs initialiser updated to include scoutedSquadId: null.
• Reset (engine.ts): resolveEndOfRound() — edictBuffs reset object updated to include scoutedSquadId: null.

Vampire tokens now show their correct unit labels and faction colours on the battlefield. The Thrall shows THRL and the Nightshroud shows NSHD instead of the fallback VAM– that appeared for both units. Tokens also render in true vampire crimson rather than grey — the faction colour palette now resolves correctly from short faction codes like 'vam'.

• Fix (unit-codes.ts): UNIT_CODES added a new block of tactical-game entries in hyphen format (e.g. 'vam-thrall') matching the IDs used by vam-units.ts and placeholder-units.ts. Previous entries used underscore format from the retired game2 system, causing getUnitCode() to fall back to a truncated ID for every live tactical unit. Underscore entries retained in a separate deprecated block for safety. Placeholder unit codes added: ph-skirmisher → SKMR, ph-line → LINE, ph-archer → ARCH, ph-brute → BRUE, ph-elite → ELTE, and so on. VAM T1 codes: vam-thrall → THRL, vam-nightshroud → NSHD.
• Fix (unit-codes.ts): FACTION_SHORT_TO_PALETTE_KEY map added — bridges short faction codes ('vam', 'wol', 'gol', etc.) to the long-form keys used by FACTION_COLORS ('vampires', 'werewolves', 'golems', etc.). getFactionColors(faction) helper exported — resolves via the map first, then falls back to a direct key match, then falls back to the 'placeholder' palette. Root cause: vam-units.ts sets faction: 'vam'; FACTION_COLORS is keyed on 'vampires'; direct lookup returned undefined, causing grey tokens for all VAM units.
• Fix (tactical-model-token.tsx, tactical-map.tsx): All direct FACTION_COLORS[faction] lookups replaced with getFactionColors(faction). Covers the token body fill in tactical-model-token.tsx and the squad-mate dashed ring colour in tactical-map.tsx.

A redundant toast notification that fired at the start of every round has been removed. The round banner already tells you who strikes first — the player-turn toast no longer repeats the same message a moment later at round boundaries.

• Fix (store.ts): advanceRitePhase() player_turn toast now gated on roundAfter === roundBefore. At round boundaries the round toast already shows initiative via PLAYER X STRIKES FIRST; mid-round player switches (same round) still fire a player_turn toast as before.
• Docs: UX-UI-AUDIT.md — P-18 moved to resolved archive.

The combat log panels no longer pile up and cover the action bar when multiple results are showing at once. A new Retaliation panel also appears after any melee counter-strike so you can see exactly what the defending squad hit back with.

• Fix (page.tsx): Combat log stack given maxHeight calc(100% - 80px) and overflowY auto — panels no longer overflow the screen or cover the action bar when multiple results are showing simultaneously.
• Feature (page.tsx): RETALIATION log panel added to the combat log stack (green border, υ arrow). Displays after attack/charge results when a retaliation counter-strike fires. Stack visibility condition updated to include lastRetaliationResults.length > 0.

Melee now bites back. Any squad attacked in melee — whether in the fight phase or on the receiving end of a charge — gets to counter-strike immediately if they have the models for it. Reckless or unskilled units can be tagged with a no-retaliation trait to opt out. Skirmishers will eventually gain first-strike to avoid the risk entirely.

• Feature (engine.ts): applyRetaliationIfEligible() — universal melee retaliation engine function. Four gates: (1) defender has a melee weapon, (2) at least one in-formation defender is adjacent to a living attacker, (3) retaliation cap not reached (retaliationsUsedThisRound < maxRetaliationsPerRound, default 1 per round), (4) defender does not have the no-retaliation trait. Pools ATK from all in-formation defenders. Full spillover damage. Does not set hasAttacked on defenders.
• Chore (engine.ts): resolveEndOfRound() now resets retaliationsUsedThisRound: 0 on all squads alongside the existing per-round reset.
• Types (types.ts): Added UnitTrait union (no-retaliation | first-strike | flying | kill-trigger). Added traits?: UnitTrait[] and maxRetaliationsPerRound?: number to UnitDefinition. Added retaliationsUsedThisRound?: number to LiveSquad (optional for backwards compatibility). Added retaliation_strike to BattleEventType. Removed stale firstStrike?: boolean field superseded by traits.
• Store (store.ts): resolveAttackOnTarget() calls applyRetaliationIfEligible() after every melee attack resolves. resolveChargeLanding() calls applyRetaliationIfEligible() after applyChargeAttacks(). Retaliation result stored in lastRetaliationResults: ChargeResult[]. Removed stale imports of applyChargeWithRetaliation and RetaliationResult from a previous incomplete session.

Vampire T1 units arrive — the player side of the battle is now a real faction. Thrall and Nightshroud replace the generic placeholder squads for Player 1. Thralls grind forward and hit harder than anything at their tier; Nightshrouds are glass cannons that will eventually kill anything that charges them.

• Feature (vam-units.ts): New faction file for Vampire units. Thrall — T1, 3 models, HP 2, DMG 2, melee only, kill-trigger ability text. Nightshroud — T1, 3 models, HP 1, DMG 3, melee only, first-strike ability text. Both use MEL 3 / DFN 1 / MOV 3 / ARM 0.
• Feat (page.tsx): buildDevState() swaps P1 squads from ph-skirmisher + ph-line to vam-thrall + vam-nightshroud (3 models each). P2 retains placeholder units as AI opponent and stat baseline. Unit registry now merges PLACEHOLDER_UNITS and VAM_UNITS.
• Docs (roadmap): Three new HIGH priority items added — Retaliation (charge response layer), First Strike (unit ability, blocked on Retaliation), Kill-Trigger VAM Thrall Enhancement.
• Design (05-DECISIONS-LOG-2026-04-06.md): Decision 7 — placeholder units retained permanently as stat baseline; Decision 8 — First Strike and Retaliation deferred with design intent locked.

Edict System arrives — before each battle you now pick a set of powerful one-use orders. During the Edict Phase you can spend one per round to reshape the battlefield: resurrect a fallen soldier, double melee damage, shield your squad, curse an enemy, or reposition across the map in an instant.

• Feature (edicts.ts): New Universal Edicts registry — 12 named edicts each with category, timing, target type, and description. getEdictDefinition() helper for lookup by ID.
• Feature (edict-actions.ts): All 12 edict effect implementations — applyEdictEffect() dispatcher routes to Iron Will, War Cry, Expose Weakness, Killing Blow, Smoke and Shadow, Press the Line, Suppressing Fire, Field Dressing, Armour of Contempt, Marked for Death, Fury of the Ancients, Ghost Step.
• Engine (engine.ts): resolveEndOfRound() extracted as a dedicated function — single reset path for all per-round state (edict buffs cleared, edictsRemaining reset to 1). advanceRound() delegates entirely to it.
• Engine (actions.ts): executeAttack() applies edict buffs — ATK bonus/halved, double melee DMG, SHRD bonus, DFN penalty/bonus, SHRD ignore, and +1 MEL/AIM for Marked for Death.
• Engine (types.ts): Added EdictId, EdictTiming, EdictCategory, EdictDefinition, EdictBuff types. Extended BattleState with edictsRemaining, selectedEdicts, spentEdictIdThisRound, edictBuffs.
• Store (store.ts): spendEdict() action — guards ritePhase, edictsRemaining, and selectedEdicts. Friendly-target edicts fire immediately; enemy-target edicts set pendingEdictId and await a map click. selectHex() handles the pending-edict early-exit to apply and clear the target.
• UI (edict-selector.tsx): Pre-battle edict selection modal — grid of 12 cards, pick exactly N = maxRounds edicts, expandable descriptions, gold border on selected, MARCH TO WAR confirm.
• UI (edict-strip.tsx): In-battle edict strip shown above the action bar during Edict Phase — collapsible cards, single row for Skirmish/Standard, two-row 4+4 for Grand, SPEND EDICT button inside expanded card, green checkmark on spent edict.
• UI (page.tsx): Three-step pre-battle flow: BattleSizeSelector → EdictSelector → battle. buildDevState() accepts selectedEdicts and sets all edict state fields. P2 (AI) receives a random N-edict selection. EdictStrip wired above action bar.

Dead code removed — ActionType and pendingAction were vestigial types never used by any live logic. Deleting them shrinks the type surface and eliminates a misleading field from ActivationState.

• Chore (types.ts): Removed ActionType type definition ('move' | 'shoot' | 'charge' | 'ability' | 'overwatch') and pendingAction: ActionType | null field from ActivationState. The field was hard-coded to null everywhere it appeared and never read.
• Chore (engine.ts): Removed ActionType from the import list. Removed pendingAction: null from the activation reset object inside completeSquadActivation().
• Chore (page.tsx): Removed pendingAction: null from the activation object in buildDevState().

Shoot and Fight phases now reachable — a critical bug caused squads to always end their rite after Move. Weapon range was being read from the wrong field, so the engine never detected ranged or melee weapons. Also includes a cleanup pass: internal naming aligned and a documentation value corrected.

• Fix (store.ts, page.tsx — w.range bug): WeaponProfile has no top-level range field — range lives at weapon.stats.RANGE. All seven occurrences of w.range replaced with w.stats.RANGE: three in advanceRitePhase() and initiateCharge() in store.ts; four in page.tsx covering the _abHasMelee derivation, the ADVANCE button label IIFE, and the action bar charge guard. Before this fix, hasRanged and hasMelee always evaluated to false, so getNextRitePhase() skipped Shoot and Fight phases entirely.
• Cleanup (types.ts, engine.ts): wound_inflicted renamed to damage_dealt in HitResult and both call sites in engine.ts. PWR JSDoc updated to reflect its role as flat damage before ARM reduction.
• Docs (LOCAL-SETTINGS.md): Cover bonus values corrected — light cover was documented as +2 DFN; corrected to +1 DFN to match the locked stat system.

Combat system overhauled — the Wound and Save steps are gone. Every attack now resolves in two steps: a contested hit roll, then flat damage. The result is faster, more legible combat where every stat has a clear, direct function.

• Engine (types.ts): HitResult updated; WoundResult and SaveResult removed. RNG stat renamed to AIM across all model stat interfaces. RANGE moved from a top-level model stat into WeaponStats, removing the naming collision with weapon range values.
• Engine (engine.ts): resolveHit() replaced with a contested roll — both sides roll d6 and add their stat (AIM/MEL vs DFN); attacker wins ties. resolveAttack() updated to the two-step Hit → Damage chain. selectWeaponForRange() reads weapon.stats.RANGE. checkAndFireOverwatch() and applyChargeAttacks() both use AIM/MEL contested rolls.
• Engine (actions.ts): executeAttack() updated to use AIM and weapon.stats.RANGE. No other action logic changed.
• Data (placeholder-units.ts): Full rewrite — all unit stat profiles rebalanced around the new resolution chain. RNG fields replaced with AIM. RANGE moved into per-weapon stats blocks.
• UI (page.tsx): Combat log panels updated to display contested roll pairs (attacker roll vs defender roll) and flat damage totals. Wound and Save rows removed from all log views.
• Docs (user-guide/page.tsx): Resolution chain section, cover table, charging section, terrain table, and full stat glossary all updated to reflect the new system. ARM described as flat damage reduction; SHRD as flat ARM negation; cover as DFN bonus (light) or DFN + ARM bonus (heavy).

User Guide rewritten from the ground up — restructured around the journey of a new player, with eleven purpose-written sections covering the tactical game from first boot to VP scoring. All auto-battler era content archived in JSX comments.

• Docs (User Guide — Full Rewrite): app/docs/user-guide/page.tsx restructured top-to-bottom. Eleven sections sequenced in new-player learning order: What Is Dark Wars, Starting a Match (battle sizes, deploy zone SVG), Reading the Screen (token anatomy SVG), The Rite (four-phase flow SVG), Moving (highlight colours, MOVE UNIT vs MOVE INDIVIDUAL), Attacking (pooled ATK, resolution chain table, cover, OOF), Charging (two-step flow, spillover), Overwatch (set and consume), Formation (kept verbatim from v00.19.97), Terrain (kept verbatim), Objectives and VP (DOM control, HUD dots, dot-states SVG), and Terminology (updated to Model/Squad/Warband/Rite/Round/Phase). Stale auto-battler sections (Getting Started, VS AI Mode, Factions, Commanders & Clans, Reading the Battlefield, Warband Building, Combat, Commander Abilities, Victory Conditions, Turn Structure) archived in a JSX comment block at the bottom of the file — not deleted.

Formation rules documented on the web — a new Formation section in the User Guide explains adjacency, out-of-formation consequences, attack pooling, and how to rejoin, with an inline SVG diagram.

• Docs (User Guide — Formation): New section added to app/docs/user-guide/page.tsx covering the adjacency-based formation rule (distance 1), the in-formation vs out-of-formation stat comparison boxes, the ATK pool mechanic, and the rejoining rule. Includes an inline SVG diagram showing a 4-model squad in formation (left, all green) vs a 3-model chain with one detached model (right, amber). Section inserted before Victory Conditions.

Formation coherency tightened from 2 hexes to 1 — models must be strictly adjacent to at least one squadmate to be considered in-formation. This makes positioning matter more: only models touching the chain contribute to the attack pool.

• Design Decision — Formation Coherency Distance (Locked): checkFormation() and checkFormationSilent() in engine.ts changed from hexDistance <= 2 to hexDistance <= 1. A model is now out-of-formation if no squadmate occupies an adjacent hex. This cascades to ATK pool eligibility in executeAttack() and applyChargeAttacks() (both filter by !m.outOfFormation), the OOF damage penalty, and the formation warning overlay on the map. Also corrects a doc/code inconsistency — checkFormation()'s docstring already said “adjacent (1 hex)” but the implementation used 2.

P-19 resolved — both combat log panels now show how many attackers contributed to a pooled roll, making the unit-action system legible at a glance.

• Polish (P-19 — Pooled Attacker Count): attackerCount?: number added to AttackResult in types.ts. executeAttack() in actions.ts stamps the field with eligibleMembers.length; applyChargeAttacks() in engine.ts stamps it with inFormationMembers.length. The “LAST COMBAT RESULT” panel in page.tsx shows “N ATTACKERS POOLED” below the attacker line when attackerCount > 1. The “CHARGE COMBAT” header appends “· N ATTACKERS POOLED” from lastChargeResults[0].attackResult.attackerCount, replacing the old lastChargeResults.length > 1 check which never fired.

Edict phase map cleanup — move highlights and formation warnings no longer appear during edict phase, where movement isn't possible anyway. The map now reads clean during the order phase.

• Polish (Edict Phase Move Highlights): TacticalMap now receives an empty moveHighlights array when ritePhase === 'edict', suppressing the Dijkstra highlight overlay during a phase where clicking a hex has no effect. The formationWarnHexes guard in page.tsx also short-circuits on edict phase, preventing the amber formation-warning overlay from appearing. Both changes are display-only — no store, engine, or action logic altered.

Action bar grouping — buttons are now split into three visually distinct groups with subtle dividers, making it easier to read your options at a glance. The advance/end-rite button reads clearly as the primary action. Plus a store hotfix preventing a stuck-selection edge case mid-rite.

• Polish (P-07 — Action Bar Grouping): The flat button row in page.tsx is replaced with three labelled groups: Escape (CANCEL, MOVE INDIVIDUAL — ghost style), Action (MOVE UNIT, ATTACK, CHARGE, OVERWATCH — existing color coding), and Advance (ADVANCE TO MOVE/SHOOT/FIGHT, END RITE — gold primary). Groups are separated by a 1px #2a2318 vertical divider that only renders when both adjacent groups have visible buttons. The advance/end-rite button gets padding: 4px 16px (wider than the base 4px 10px) to distinguish it as the primary CTA without changing its color or style constant. Button logic, visibility conditions, and store actions are unchanged. Pre-render visibility flags (_escapeGroupHasButtons, _actionGroupHasButtons, _advanceGroupHasButtons) computed before JSX to drive conditional divider rendering.
• Hotfix (clearSelection ritePhase reset): clearSelection() in store.ts now resets UI ritePhase to null. Previously, clicking an empty hex mid-rite left the rite phase active in UI state, causing the F-08 squad-lock guard to block all subsequent model selection until the player reloaded. The fix was in the working tree since v00.19.92 but not previously committed.

Five UX polish items closed — charge step indicators, ghost preview hold, deploy panel text contrast, and coin flip text contrast all addressed.

• Polish (P-03 — Charge Step Indicators): Bottom bar messages for the two-step charge targeting flow (pick target squad, then pick landing hex) updated in page.tsx to be more prominent and clearly signpost each step to the player.
• Polish (P-05 — Ghost Preview Hold): Unit-move ghost preview now holds the last valid formation on cursor when moving off a valid hex, rather than disappearing. Implemented in store.ts — unitMoveHoverKey only clears on explicit cancel or commit, not on hover-miss.
• Polish (P-09 / P-10 — Deploy Panel Text Contrast): “DEPLOY A SQUAD” header and the tier label / model count text under each squad card in deploy-panel.tsx lightened to meet readable contrast against the panel background.
• Polish (P-11 — Coin Flip Text Contrast): “ROUNDS 2+ ALTERNATE AUTOMATICALLY” footer in coin-flip-modal.tsx color changed from #3a3020 to #5a5040 — now legible against the dark modal background.

P-02 resolved — the AI turn is now visible at two levels: a pulsing orange “◆ AI TURN” label in the HUD strip, and an orange dashed ring that tracks whichever model the AI is currently moving or attacking on the map.

• Polish (P-02 — AI Turn Visibility): New aiActiveModelId: string | null field added to TacticalUIState in store.ts. ai-orchestrator.ts sets it before every move and attack action and clears it on endActivation. tactical-map.tsx accepts a new optional aiActiveModelId prop and renders an orange dashed ring (#e06020, r+9, dash 6 2) that tracks the acting model through its tween animation — using the same tween-position logic as the existing gold active ring. page.tsx reads the field from the store, passes it to TacticalMap, and replaces the old small red “· AI THINKING…” label with a larger pulsing “◆ AI TURN” in orange matching the ring color. CSS keyframe animation injected via a scoped <style> tag. Design guide updated: new Overlay Rings reference table documents all six ring types with color, radius offset, dash pattern, and trigger conditions.

Move Unit is now the default — clicking a multi-model squad enters formation-move mode immediately. Individual model moves are an explicit opt-out via a new MOVE INDIVIDUAL button.

• Feature (unit-move as default): selectModel() in store.ts now calls initiateUnitMove() unconditionally after setting selection state. initiateUnitMove() self-guards on livingCount < 2 and phase legality, so solo models and single-survivor squads silently fall through to individual move highlights as before. advanceRitePhase() also calls initiateUnitMove() when advancing to the Move phase, catching the edict → move transition where a model is already selected. No engine changes.
• Feature (MOVE INDIVIDUAL escape hatch): New switchToIndividualMove() action added to store.ts. Exits unit-move mode and restores per-model Dijkstra highlights for the selected model. Wired to a new MOVE INDIVIDUAL ghost button in the action bar, visible only while in unit-move mode with a multi-member squad selected. The existing MOVE UNIT button is retained as a re-entry path after opting into individual mode.

P-01 resolved — squads that have finished their activation now show a grey fog overlay on every token, giving the player a clear at-a-glance read of which squads are done for the round.

• Polish (P-01 — Activated Squad Indicator): When a squad completes its rite, all of its tokens now display a semi-transparent grey overlay (rgba(160,160,160,0.28)) inside the token body. The overlay sits above the existing per-model spent hatch and below the HP arc and unit code text, so health and identity remain readable. Applied at both standard (LOD 1) and macro (LOD 0) zoom levels. Data source: LiveSquad.activatedThisRound, already set by completeSquadActivation() and reset by advanceRound(). squadActivatedThisRound added to the modelMeta lookup in tactical-map.tsx and threaded to TacticalModelToken as a new prop. No engine, store, types, or actions changes.

D-02 resolved — declaring Overwatch now shows a confirmation message in the bottom bar so the player knows the action registered.

• Polish (D-02 — Overwatch confirmation): overwatchSelectedModel() in store.ts now sets statusMessage: 'OVERWATCH SET · MODEL WILL REACT TO ENEMY MOVES' after applying overwatch stance. The message appears in the bottom bar centre and clears on the next selection or mode change, consistent with the existing status message system. No engine, type, or UI file changes.

Charge spillover — excess damage from a charge attack now carries to the next nearest enemy model in the target squad until exhausted.

• Feature (charge wound spillover): Previously, damage beyond a model's remaining HP was lost. Now, after the primary target is killed, any excess damage carries to the next nearest living member of the target squad as raw HP reduction. Wounds are already resolved — no additional dice are rolled. Spillover cascades through the target squad in distance order until damage is exhausted or the squad is wiped. Implemented in applyChargeAttacks() in engine.ts only. No changes to types, store, actions, ranged attacks, overwatch, or UI.

Fix — melee ATK pooling applied correctly for both charge and normal melee attacks. All in-formation squad members now contribute ATK as long as at least one member is adjacent to the target.

• Fix (charge and melee ATK pooling): The pooling rule established in v00.19.49 states: for melee, if at least one squad member is adjacent to the target, all in-formation members contribute their ATK regardless of individual distance. Both applyChargeAttacks() in engine.ts and executeAttack() in actions.ts were instead filtering the pool to only members with dist === 1, meaning followers who landed behind the point member during a charge contributed nothing. Fix: split eligibility into a gate check (at least one adjacent member) and a pool computation (all in-formation members). Charge attacks now correctly fire the full squad's pooled ATK. Normal melee attacks receive the same correction. No changes to ranged pooling, engine types, store, or UI.

P-13 — Unit Info Panel. Selecting a model now slides a stat panel into the bottom-left corner showing HP, all model stats, weapon profiles, and active status flags.

• Feature (P-13 — Unit Info Panel): New component app/tactical/_components/unit-info-panel.tsx. Pure Fabrication — receives model, definition, and player as props from page.tsx; no store access. Renders null when nothing is selected so the panel is fully absent (not hidden). When present it slides in from the left over 200 ms via CSS translateX transform. Content: unit name and faction/tier header, HP bar (green → amber → red), 3×2 stat grid (MOV/MEL/RNG/DFN/ARM/DOM), weapon section (ATK/PWR/SHRD/DMG + MELEE or NHEX range per weapon), and a conditional status flags row (OVERWATCH, MOVED, SPENT). Left-border accent matches player faction colour (P1 blue, P2 red). page.tsx changes limited to: import, three-line data derivation before return, and one <UnitInfoPanel> render inside the map container. No engine, store, types, or action file changes.

F-07 resolved — the version string is now visible on the Battle Size Selector screen, not only inside the game HUD.

• Fix (F-07 — version not visible on Battle Size Selector): Added a small version label below the ← RETURN TO HOME link in BattleSizeSelector. Renders APP_VERSION (already imported) in Cinzel, extremely muted (#2a2218), 0.4rem, centred. No visual weight — present for dev reference without drawing attention. Display-only change in page.tsx; no engine, store, or action file changes.

F-06 resolved — the Battle Size Selector now has a ghost “Return to Home” link so players can back out before committing to a battle.

• Fix (F-06 — no exit from Battle Size Selector): The selector previously had no way to leave the screen once entered — the only action was DEPLOY FORCES. Added a ghost ← RETURN TO HOME anchor link directly below the DEPLOY FORCES button, pointing to /. Styled in Cinzel, very muted gold-on-dark, brightens subtly on hover. Display-only change in page.tsx; no engine, store, or action file changes.

F-05 resolved — the “RITE X OF Y” counter now shows a stable denominator that cannot shrink mid-round as models die.

• Fix (F-05 — unstable rite counter): totalRites was recomputed live each render by counting squads with at least one living model. If a squad was wiped out mid-round, the denominator would drop — turning “RITE 2 OF 4” into “RITE 2 OF 3” unexpectedly. Fix: added roundTotalRites: number | null to TacticalUIState in store.ts. The count is snapshotted in initBattle (round 1) and at every round boundary in advanceRitePhase (rounds 2+), using the post-activation newBattle state so dead squads are already excluded from the next round's total. The HUD reads roundTotalRites directly; the live count is retained only as a null-fallback. No changes to engine, actions, or AI files.

Charge cancel fix — pressing CANCEL during charge-target or charge-dest mode now fully clears charge state instead of leaving the player locked.

• Fix (charge mode cancel lock): clearSelection() was resetting attackMode and unitMoveMode but not the four charge state fields (chargeTargetMode, chargeDestMode, chargeTargetSquadId, chargeDestinations). When the player pressed CANCEL during charge targeting, selectedModelId cleared (hiding the CANCEL button) while chargeTargetMode stayed true, routing all subsequent hex clicks into resolveChargeOnTarget and making the interface unresponsive. Fix: all four charge state fields added to the clearSelection() reset. Additionally, the CANCEL button visibility condition in page.tsx now includes chargeTargetMode and chargeDestMode as explicit guards so the button is always visible while any charge mode is active.

F-04 resolved — pressing ATTACK when no valid targets exist now shows a bottom-bar message instead of silently doing nothing.

• Fix (F-04 — silent no-op on ATTACK): When initiateAttack() computed zero attackable hexes, the store previously returned silently with no player feedback. Now sets a statusMessage UI state field to “NO VALID TARGETS IN RANGE”. The bottom bar centre displays this message in red, overriding the normal mode text, until the player changes selection or cancels. The statusMessage field is cleared on any selection change, mode transition, or successful attack-mode entry. No changes to engine, actions, or AI files.

F-03 resolved — combat log panels consolidated into a single stacked column so overwatch, attack, and charge results never overlap.

• Fix (F-03 — log panel overlap): Overwatch, attack, and charge log panels previously rendered as three independent absolutely-positioned elements — the overwatch panel at right-80 and attack/charge at right-4. When both overwatch and attack results existed simultaneously (e.g. overwatch fires during a move, then the player attacks), the panels could visually clash or overlap at narrow viewports. All three panels now live inside a single flex-column wrapper anchored at bottom-16 right-4, stacking vertically with an 8px gap. Each panel retains its own conditional visibility and styling. Display-only change in page.tsx.

F-02 resolved — active squad display in bottom HUD now shows the unit definition name instead of the raw store key.

• Fix (F-02 — active squad display): The bottom HUD bar previously rendered the raw activeSquadId store key (e.g. “P1-SKM”). Now resolves through battle.squads[id].definitionId → battle.unitDefinitions[defId].name and displays the uppercased unit definition name (e.g. “SKIRMISHER”). Falls back to the raw ID if the lookup fails.

F-01 resolved — models auto-re-select after move or attack so the player sees remaining action options.

• Fix (F-01 — post-action selection): moveSelectedModel() and resolveAttackOnTarget() in store.ts now re-select the acting model after resolution instead of clearing to null. After a move, the player immediately sees attack / charge / overwatch buttons. After an attack, the player sees the ADVANCE button and current phase state. Guarded for model death — if the model was slain by overwatch or cursed terrain during the move, selection correctly clears.

AI token rendering fix — per-model independent tween system replaces single shared RAF. P2 model tokens now animate smoothly during AI turns.

• Fix (move animation): The old tween system used a single shared RAF loop that was cancelled and restarted whenever any model moved. With 350ms AI move delays vs 1000ms tween duration, earlier models' animations were interrupted mid-flight, leaving tokens visually displaced from their hexes. Replaced with a per-model independent tween system: each model tracks its own animation start time in a persistent activeTweensRef map, and a single self-terminating RAF loop processes all active tweens concurrently. New moves add entries without cancelling in-progress animations. Both P1 and P2 tokens now animate smoothly regardless of move timing.

F-08 resolved — only one squad can be active at a time during the battle phase.

• Fix (F-08 — multi-squad activation): Added a guard in selectModel() that blocks selection of models from a different squad while a rite is already in progress (ritePhase !== null). The active squad now locks out all others until END RITE is pressed. Re-selecting models within the active squad (F-09 fix) is preserved.

F-11 resolved — hex cells render as regular hexagons and mouse-to-hex mapping is accurate across the full board.

• Fix (F-11 — hex distortion): Restored preserveAspectRatio="xMidYMid meet" in tactical-map.tsx. The v00.19.71 switch to "none" fixed click alignment but stretched hexes non-uniformly when the browser was wider than the SVG's natural aspect ratio.
• Fix (F-11 — click alignment): All three mouse-to-SVG coordinate conversions (hover, wheel zoom, pan) now use svg.getScreenCTM().inverse() via DOMPoint.matrixTransform() instead of manual scaleX/scaleY math. This correctly accounts for the centering offset (letterboxing) that "xMidYMid meet" introduces, making hover and click registration accurate across the full board width including P2's high-q columns.
• Simplified initial camera fit: With "meet", the browser handles fitting the viewBox to the container. Initial zoom seeded to 1.0 instead of computing width / SVG_W.

Tech debt — code path unification (TD-01 Phase 2 complete). Human and AI now share the same move and attack functions.

• Unified move pipeline: New executeMoveWithEffects() in actions.ts composes applyMove → checkAndFireOverwatch → applyCursedEntryIfNeeded into a single call. Replaces 4 duplicated call sites (individual move, unit move, charge landing, AI move). Human and AI token movement now uses identical mechanical code.
• Unified attack pipeline: New executeAttack() in actions.ts handles weapon selection, pooled ATK, cover, cursed ARM penalty, OOF bonus, damage, and prune in one call. Replaces 2 duplicated call sites (player attack, AI attack). Human and AI attack resolution now uses identical mechanical code.
• Bug fix (AI cover): AI attacks previously hardcoded cover: 'none', ignoring terrain cover bonuses on the target hex. The shared executeAttack() now correctly computes cover from terrain for both human and AI attacks.
• TD-01 resolved: No parallel code paths remain for P1 vs P2 movement or attack. Both actors submit decisions through the same shared functions. store.ts reduced to ~420 lines. actions.ts expanded to ~170 lines. ai-orchestrator.ts reduced to ~140 lines.

Tech debt — store.ts mechanical decomposition (TD-02 Phase 1 complete).

• Refactor (TD-02): store.ts decomposed from ~780 lines to ~500 lines. Four pure helper functions extracted to lib/tactical/actions.ts (getTerrainLookup, applyCursedEntryIfNeeded, computeMoveHighlights, buildDeployFormation). AI turn orchestrator and AI deploy scheduler extracted to lib/tactical/ai-orchestrator.ts (runAITurnOrchestrator, scheduleAIDeploy). Store keeps thin wrappers. Zero logic changes — pure mechanical extraction. All 23 features validated intact.

P2 hex alignment fix — mouse-to-hex mapping now correct across the full battlefield width (pending play-test).

• Fix candidate (F-11 root cause): tactical-map.tsx switched from preserveAspectRatio="xMidYMid meet" to preserveAspectRatio="none". The previous value caused the browser to apply a hidden horizontal centering offset when fitting the SVG into its container. This offset was not accounted for in the mouse-to-hex inverse calculation, causing clicks and hover events on P2's high-q side to register on the wrong hex. With none, the viewBox maps directly to the container and the existing zoom/pan inverse math is correct across the full width.

Initial camera — mount-time zoom seeding so the full battlefield width fits on load (pending play-test).

• Fix candidate (F-11): tactical-map.tsx now seeds initial zoom via a mount-time useEffect that reads the SVG element's rendered width with getBoundingClientRect() and sets zoom = svgWidth / SVG_W. At zoom 1.0, only P1's side of the map was visible on ~1270px screens; P2 tokens appeared off-screen. No ResizeObserver, no window.innerWidth, no preserveAspectRatio changes — one effect, runs once on mount. Awaiting play-test confirmation.

Rite phase preservation — re-selecting a model mid-rite no longer resets the squad back to the edict phase.

• Fix (F-09): selectModel in store.ts now preserves the current ritePhase when the player re-selects a model belonging to the squad whose rite is already in progress. Previously, clicking any model mid-rite reset ritePhase to 'edict', stranding the player in the shoot phase with no actionable buttons.

Token alignment fix — tokens now always render centered in their hex cells.

• Fix: tactical-map.tsx model tokens, squad-mate rings, and active model indicator now fall back to hexToPixel(model.position) when no tween is active, instead of using potentially stale visualPositions values. Tokens are now always aligned with their hex cells when not animating.

AI round 2+ fix — AI now correctly takes its turn every round, including when it has initiative at the start of a new round.

• Fix: runAITurn endActivation branch in store.ts now detects when a new round starts with currentPlayer === 2 and re-triggers the AI instead of clearing isAITurn. Previously the AI would only run when triggered by the player ending their rite, causing it to skip its turn entirely when it had initiative at round start.
• Fix: buildDevState in page.tsx was hardcoding maxRounds: 4 regardless of the battle size chosen. Standard (6 rounds) and Grand (8 rounds) games now use the correct round count.

AI & Coin Flip Fixes — AI now moves and attacks; coin flip correctly handled for single-player.

• Fix: Removed bestMoveDist >= currentDist guard in ai.ts that prevented the AI from moving when already near an enemy.
• Fix: Removed !model.hasMoved guard in runAITurn (store.ts) that blocked follower moves after the point member moved.
• Fix: coin-flip-modal.tsx now correctly handles single-player vs AI. If Player 1 wins the toss they see choice buttons (I GO FIRST / OPPONENT GOES FIRST). If the AI wins the toss, it auto-chooses after a short delay and the player sees the result.

Move Animation Polish — squad-mate rings and active model indicator now track the token body throughout the move animation.

• Fix: squadMateRings and activeModelIndicator memos in tactical-map.tsx now read visualPositions[id] (the live tween pixel position) instead of hexToPixel(logical). Both rings track the token body throughout the animation rather than snapping to the destination hex while the token is still mid-tween. Dep arrays updated accordingly.
• Chore: File header comment in tactical-map.tsx updated to reflect current state. Roadmap housekeeping from v00.19.64: Battle Size Selector added to COMPLETE array; Hex-Grid Core Engine detail updated.

Battle Size Selector — choose Skirmish, Standard, or Grand before deploying forces.

• Feature: BattleSizeSelector modal renders on mount before initBattle() is called. Three options: Skirmish (4 rounds), Standard (6 rounds), Grand (8 rounds). Skirmish pre-selected. Confirm button labelled DEPLOY FORCES.
• Feature: buildDevState() now accepts a maxRounds parameter (default 4) instead of hardcoding it. The chosen size is passed through handleSizeConfirm on the page.
• Fix: PLAY AGAIN now returns to the size picker instead of auto-restarting with the previous size.
• Chore: Removed stale "Win Condition — Per-Round VP Scoring" entry from roadmap HIGHEST array (completed in v00.19.63).

VP Scoring — game now runs to 4 rounds (Skirmish) and the HUD tracks objective control in real time.

• Feature: maxRounds set to 4 (Skirmish) in buildDevState(). The game now ends by round limit, surfacing the existing VP and DOM tiebreak logic in checkWinConditions() that was previously unreachable at 99 rounds.
• Feature: Objective control indicators in the HUD centre strip. One dot per objective, coloured blue (P1), red (P2), or dim grey (uncontrolled). Updates after every round via scoreObjectives(). Dot label shows the first letter of the objective name. Hidden during deploy phase.

Command Phase — pre-battle coin flip, round initiative system, and HUD initiative indicator.

• Feature: advanceRound() now wires initiativePlayer correctly. Whoever went second last round goes first next round (strict alternation). currentPlayer at round start is set from initiativePlayer, not the previous player's flip.
• Feature: Added coinFlipPending: boolean to BattleState. Set true at deploy→battle transition. Cleared by resolveCoinFlip() after player choice.
• Feature: CoinFlipModal component. Appears once, pre-battle, after all squads are deployed. Auto-resolves a coin flip on mount, reveals the winner, and lets the winner choose who activates first in Round 1. Cannot be skipped.
• Feature: Initiative HUD indicator. · INITIATIVE P1 or · INITIATIVE P2 displayed in the HUD centre strip during battle, coloured to the player's theme colour.
• Feature: Round toasts now include a PLAYER X STRIKES FIRST line coloured to the initiative player, so every round transition communicates who goes first.

Deploy → battle transition fix — player can no longer get stuck in attack mode with no valid targets at battle start.

• Fix: initiateAttack() now guards against entering attack mode when attackHighlights is empty. Previously clicking ATTACK with no enemies in range set attackMode = true with an empty highlight array, leaving the player stuck with no red targets and only CANCEL as an escape.
• Fix: placeSquad() now calls clearedUI() when transitioning to phase: 'battle'. Ensures all deploy-phase UI state (ghost positions, selection flags) is fully reset the moment battle begins.

Deploy token snap fix — placed units now appear correctly on their hex instead of animating in from off-screen.

• Fix: seededRef block in tactical-map.tsx now skips off-grid models (q < 0) when initialising visualPosRef. Previously hexToPixel(-1,-1) produced an off-screen pixel position which became the tween start point.
• Fix: Move animation effect now detects off-grid → on-grid transitions (prev.q < 0) and snaps directly to the real hex pixel position instead of tweening from the invalid off-screen origin.

AI deploy recursion fix — P1 squads no longer place in P2's zone due to activePlayer being wrong when the player clicks.

• Fix: placeSquad() was calling itself recursively via the AI auto-deploy callback without a guard, causing activePlayer to flip to P2 before P1's second placement. P1's second click then landed in P2's zone.
• Fix: Added isAIDeploy?: boolean parameter to placeSquad(). When true, the AI auto-deploy callback is suppressed. The AI always passes true; human clicks always use the default false.

Deploy formation placement fix — squads now place correctly in the deploy zone instead of drifting to the centre of the map.

• Fix: buildDeployFormation() in store.ts was using hand-rolled odd-r offset neighbour direction tables (DIRS_EVEN / DIRS_ODD) which produced incorrect neighbours for this coordinate system. Replaced with hexNeighbors() + withinGridBounds() from hex-utils.ts, which use the correct cube-coordinate conversion.
• Chore: hexNeighbors and withinGridBounds added to the hex-utils import in store.ts.

AI Deploy — P2 automatically places its squads after each P1 placement, mirroring the alternating deploy sequence.

• Feat: After P1 places a squad, placeSquad() schedules a 400ms delayed callback that reads fresh state, picks the first entry in unplacedP2, finds a valid formation anchor in P2's zone (sorted toward centre row for variety), and calls placeSquad() on P2's behalf.
• Feat: AI deploy respects all the same guards as human placement — zone keys, occupied hexes, formation availability. Falls back silently if no valid anchor exists.
• Feat: When P2's auto-placement completes, the panel and activePlayer flip back to P1 for the next squad, matching the intended alternating deployment sequence.

Deployment Zones Slices 3–4 — hover ghost preview and squad placement. Players can now fully deploy their warbands before battle begins.

• Feat: placeSquad(q, r) store action — places the selected squad in formation starting at the clicked hex (BFS fills adjacent zone hexes), removes it from unplacedP1/P2, flips activePlayer, and auto-selects the next squad for the incoming player. When all squads are placed, transitions to phase: 'battle'.
• Feat: hoverDeployHex(q, r) store action — computes formation ghost positions when hovering a valid deploy zone hex with a squad selected. Stored in UI-only deployGhostPositions state.
• Feat: buildDeployFormation() pure helper in store.ts — BFS from anchor hex, finds N adjacent free hexes within the deploy zone for formation placement.
• Feat: selectHex dispatch updated — during deploy phase with a squad selected, routes clicks to placeSquad instead of model selection.
• Feat: page.tsx wired — onHexHover routes to hoverDeployHex during deploy; deployGhostPositions passed to TacticalMap as squadMoveGhosts, reusing the existing ghost rendering pipeline.
• Feat: After each placement, the panel automatically selects the next squad for the new active player — no manual re-selection needed.

Deployment Zone Orientation Fix — zones now render as left/right columns matching the horizontal battlefield layout.

• Fix: buildDeploymentZoneKeys() in maps.ts was iterating over rows (r), producing top/bottom bands. Corrected to iterate over columns (q): P1 gets cols 0–3, P2 gets cols 18–21, all rows full height.
• Fix: maps.ts file header comment updated — now correctly documents the horizontal battlefield orientation (P1 left / P2 right).
• Fix: Shattered Crossroads map comment updated to reflect left/right deployment columns instead of top/bottom rows.

Deployment Zones Slice 2 — Squad Selection Panel. The active player sees their unplaced squads and can click one to select it for placement.

• Feat: New DeployPanel component (app/tactical/_components/deploy-panel.tsx) — left-edge overlay panel showing the active player's unplaced squads as clickable cards.
• Feat: selectSquadForDeploy(squadId | null) action added to store.ts — sets or toggles deployment.selectedSquadId. No-op outside deploy phase.
• Feat: buildDevState() updated: models start at off-grid sentinel (q=-1, r=-1) instead of pre-placed positions. deployment.unplacedP1 / unplacedP2 populated from all squad IDs. Two squads per side (Skirmisher + Line Infantry).
• Feat: tactical-map.tsx filters off-grid models (position.q < 0) from token rendering so unplaced squads are invisible on the map until placed.
• Visual: Panel shows player colour accent, squad name, tier label, model count, “NEXT TO PLACE” badge on the first card, and “✓ SELECTED” indicator. Clicking the selected card again deselects it.

Deployment Zones Slice 1 — zone highlight. P1 and P2 deployment bands are visually tinted on the map whenever the game is in the deploy phase.

• Feat: deployment?: DeploymentState added to BattleState in types.ts (optional field — safe for battle-phase harness).
• Feat: buildDeploymentZoneKeys() imported into tactical-map.tsx. Two memoised zone sets (P1 / P2) are computed from mapConfig whenever state.phase === 'deploy'; empty sets otherwise.
• Visual: Each hex in a deployment zone receives a semi-transparent tint overlay polygon — blue (rgba(42,106,170,0.18)) for P1 rows 0–3, red (rgba(170,42,42,0.18)) for P2 rows 14–17. No-man's-land (rows 4–13) receives no tint.
• Dev harness: buildDevState() in page.tsx now sets phase: 'deploy' so the zones are immediately visible at localhost. Battle logic and AI turn are untouched.

hasMoved Flag — per-model one-move-per-activation guard layered on top of rite phase gating.

• Feat: hasMoved: boolean added to LiveModel in types.ts. Initialised false in buildDevState().
• Feat: applyMove() in engine.ts sets hasMoved: true on the moved model at move time. Covers individual moves, unit moves (point member & all followers), and charge landing moves.
• Feat: getMovableHexes() returns an empty Map immediately when model.hasMoved === true. Both this guard and isActionLegalForPhase() must pass for a move to be legal.
• Feat: advanceRound() resets hasMoved: false on all models alongside hasAttacked, hasCharged, and onOverwatch.
• Feat: AI move path in runAITurn() skips emitting a move action for any model where hasMoved === true. AI still bypasses rite phase gating.

Onboarding wizard now persists across all setup screens instead of disappearing on phase advance.

• Wizard persistence fix: The wizard was rendered inside each per-phase return block, so advancing from Faction Select to Clan Select (or any subsequent step) unmounted it mid-read. The fix hoists both wizards to the Game2Client root level and replaces the per-phase early returns with a single renderPhaseContent() helper. The wizard now survives every phase transition and is only removed when the battle starts.
• Reopen link follows the player: The Tier 2 reopen link (“Show Dark Wars Guide”) now appears on all setup screens beyond Match Settings, not just Faction Select, so dismissed players can recall it at any point in the flow.

Onboarding wizard no longer blocks the Confirm button on faction and settings screens.

• Wizard overlap fix: The onboarding panel is fixed to the right edge at 300px wide. On screens where the wizard is open, the bottom action bar now reserves 316px of right padding — keeping the Confirm button and footer controls clear of the panel at all times. Affects the Match Settings footer and the Faction Select confirm bar.

Admin nav version number brightness corrected — now matches the footer version.

• SiteNav version label: The version string shown in the top-right admin bar was text-parchment/20 — visibly dimmer than the text-parchment/50 footer version. Both now use the same opacity for visual consistency.

The /lore/units page now has a sticky faction filter bar — click any faction to show only that faction's units, or ALL to reset.

• Faction filter bar (UI-12): A sticky bar sits just below the page hero band and above the unit list. It shows an ALL button plus one button for each of the 10 factions. Clicking a faction hides all other faction sections and shows only the selected one. ALL resets the view.
• Faction accent colours: The active filter button highlights using that faction's accent colour — crimson for Vampires, amber for Werewolves, sea blue for Atlanteans, and so on. The ALL button highlights in gold-warm when active.
• Client component conversion: The page was converted from a server component to a client component to hold the filter state locally. No URL params, no server round-trips — purely local React state.

One-line docs cross-link — the roadmap now links back to release notes.

• Roadmap header cross-link (UI-16): A ‘← WHAT'S CHANGED’ link now sits right-aligned next to the roadmap subtitle, mirroring the ‘SEE WHAT'S NEXT →’ link that already existed in the release notes header. The two docs pages are now symmetrically cross-linked in both directions.

Two UX polish items: the clan select screen now tells you when more options are below, and the clan ability button finally shows you how long until it recharges.

• Clan select scroll indicator: A faint gradient and ‘↓ MORE’ label appear at the bottom of the clan card grid when there are clans below the visible area. The indicator disappears once you've scrolled to the end — it only shows when the list is actually clipped.
• Ability recharge fill-bar: When a round-based clan ability has been used, the button now shows an animated amber fill-bar that fills from left to right as the round progresses, with a percentage label. You can see at a glance how close you are to the next activation window.
• Exhausted treatment: Match-limited abilities that have been used display ‘EXHAUSTED’ in dim text instead of the generic ‘USED’ label — a more thematic and readable state for a permanent spend.
• Ability ready pulse: When a round-based ability finishes recharging, the button briefly glows amber once to signal availability — a peripheral-vision readable cue that doesn't demand your full attention mid-battle.

New player onboarding wizard is now fully wired — a dismissible field guide appears on first visit at setup screens.

• Tier 1 wizard (genre newcomer): Appears on the Match Settings screen for first-time visitors. Explains what an auto-battler is, what a warband is, how continuous time works, and what a Commander does. Key framing: you build the army, then command it — you do not control individual units.
• Tier 2 wizard (Dark Wars newcomer): Appears on the Faction Select screen for players who haven't yet seen the Dark Wars overview. Covers faction identity, faction resources, how clans differentiate Commanders, and the win condition.
• Manuscript panel aesthetic: Both wizards render as a scrollable parchment panel alongside (not covering) the setup screen. Styled as pages from a field manual — consistent with the Old Book by Candlelight aesthetic.
• Dismissible and re-openable: Each wizard can be skipped or closed at any time. Once dismissed, a small ‘Show Field Guide’ or ‘Show Dark Wars Guide’ link appears in the screen's footer bar so it can be recalled. State persisted in localStorage via darkwars_wizard.
• Never appears during battle: The wizard is wired exclusively to MATCH_SETTINGS and FACTION_P1 setup phases. It is never rendered during live combat.

Unit tokens now scale with zoom — three distinct tiers of detail as you move from full battlefield view down to individual members.

• Macro view (zoomed out): At extreme zoom-out, unit tokens show faction colour, HP arc, and identity dots only — no text labels. Broken units display a red dashed ring. The map reads cleanly at a glance without illegible text cluttering the tokens.
• Standard view (default): At normal zoom levels, each token shows its unit code abbreviation, member count in Roman numerals, HP arc, and cohesion arc. Unchanged from before.
• Member view (zoomed in): Past 1.6× zoom, individual member dots appear in their ring layout. All detail layers are visible. Unchanged from before.
• Smooth transitions: The tier boundary sits at 0.65× scale — just above the 0.5× speed setting. Switching speeds or manually zooming crosses the boundary naturally. All animations, state flashes, hover rings, and last-stand pulses are preserved across all three tiers.

Setup flow now shows your place in the ritual.

• Step progress indicator: A sticky bar now appears at the top of every setup screen — Settings · Faction · Clan · Warband. Wax-seal dots mark each step: hollow for steps ahead, gold-filled and glowing for the active step, dim for completed steps. A thin connector line runs between them, filling in as you advance.
• Stays visible while scrolling: The bar is sticky — it remains anchored at the top as you scroll through clan cards or the warband builder, so you always know where you are in the preparation sequence.

Vampire Revenant redesigned — death is a delay, not an ending.

• Revenant resurrection: The Revenant no longer survives at 100 HP. Instead, when destroyed for the first time it is removed from the field, then returns 2 seconds later at the nearest unoccupied hex to the Bloodcrypt — 1 member at 50% HP/mbr (1,000 HP base). HP/mbr scales with any buffs active at the time of return. Once per match.
• Fortress return: The respawn hex is determined by BFS outward from the Bloodcrypt. The fortress hex itself is used if unoccupied; otherwise the nearest free adjacent hex is chosen. Fortress control does not matter — the Revenant always returns to its own player’s fortress anchor.
• Combat log: Two new log entries — “REVENANT falls — but death holds no claim here.” on destruction, and “REVENANT rises at the Bloodcrypt — 1 member, 1000 HP.” on return.

Normal difficulty targeting: 2-strike patience window before switching to penetrable targets.

• Normal difficulty — 2-strike rule: Units on normal difficulty will attempt up to 2 attacks on their current target before the penetration-preference logic kicks in. After 2 consecutive 0-damage hits on the same target, the unit switches to a penetrable enemy if one exists. Counter resets immediately when the target changes or when any damage is dealt.
• Hard difficulty unchanged: Hard AI still prefers penetrable targets immediately on every targeting decision — no patience window.
• Fields added: consecutiveZeroDmgHits and lastTargetId on WatchUnit to track the per-unit counter without any state outside the unit itself.

Smart targeting — units at normal and hard difficulty prefer enemies they can actually damage.

• Penetration-preferred targeting: At normal and hard difficulty, units now prefer targets whose DFN they can exceed (ATK > DFN) before applying their normal priority (closest / lowest HP / highest ATK). If all enemies are impenetrable, the unit falls back to its normal logic rather than becoming inert.
• Easy difficulty unchanged: Easy AI continues to pick random targets with no penetration awareness, preserving the intentionally underpowered feel.
• Applies to both sides: P1 player units use the same logic so your own units make smarter decisions on normal/hard. P2 AI units likewise seek penetrable targets within their hard/normal pools.

App-wide muted text brightness pass — lore, docs, and homepage.

• Opacity remap: All parchment opacity values below /75 lifted across every public-facing lore and docs page. Remap: /15→/30, /20→/35, /25→/45, /30→/55, /40→/60, /50→/70, /60→/80, /70→/85. Borders, dates, secondary labels, and body text all affected.
• Pages updated: lore/world, lore/timeline, lore/page (hub), lore/factions/[faction], lore/factions/[faction]/[clan], lore/units, docs/page, docs/release-notes, docs/user-guide, and app/page (homepage).

Terrain reference SVG added to user guide and design guide.

• User guide — new Terrain section: Added between Combat and Victory Conditions. Contains a player-facing SVG reference table covering all six terrain types with move cost, DFN, ATK, and LOS columns plus per-terrain notes. Followed by a brief description of The Contested Ridge layout.
• Design guide — terrain table replaced: The sparse plain HTML terrain table under “TERRAIN — MECHANICAL QUICK REFERENCE” has been replaced with the full SVG diagram. Now includes a Cohesion column (Forest +20, Ruins +40, Cursed −15 per second), plus the Fortress Hex regen block (on-hex +200, adjacent +100) with all five faction fortress names.