From 4e110ca9fc9a7337dca8db3a94bf1750c02a84a7 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Tue, 18 Aug 2026 22:35:19 +0200
Subject: [PATCH 01/12] 32 players lobby

---
 src/app/services/lobby.service.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/app/services/lobby.service.ts b/src/app/services/lobby.service.ts
index 93593f559..ca0e7a880 100644
--- a/src/app/services/lobby.service.ts
+++ b/src/app/services/lobby.service.ts
@@ -16,7 +16,7 @@ import { WsService } from './ws.service';
 import { normalizeDisplayName } from '../utils/display-name.util';
 
 const LOBBY_CODE_PATTERN = /^[a-z0-9]{4}$/;
-const MAX_LOBBY_PARTICIPANTS = 16;
+const MAX_LOBBY_PARTICIPANTS = 32;
 const MAX_LOBBY_FORCES = 8;
 const MAX_REMOTE_LOAD_ATTEMPTS = 8;
 

From a8233856d6934c01dc9907109c920d27bf206005 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Wed, 19 Aug 2026 17:33:04 +0200
Subject: [PATCH 02/12] cleanup of the walk/run/standup rules

---
 .../hex-slider/hex-slider.component.html      |   7 +-
 .../hex-slider/hex-slider.component.scss      |  16 +-
 .../hex-slider/hex-slider.component.spec.ts   |  17 +
 .../hex-slider/hex-slider.component.ts        |  17 +-
 .../page-psr-warning-panel.component.spec.ts  |  36 +-
 .../page-psr-warning-panel.component.ts       |  20 +-
 .../page-standing-up-panel.component.html     | 129 +++--
 .../page-standing-up-panel.component.scss     |  10 +
 .../page-standing-up-panel.component.spec.ts  | 180 ++++++-
 .../page-standing-up-panel.component.ts       |  68 ++-
 .../page-turn-summary-panel.component.html    |  36 +-
 .../page-turn-summary-panel.component.scss    |  37 ++
 .../page-turn-summary-panel.component.spec.ts | 155 ++++++
 .../page-turn-summary-panel.component.ts      |  49 +-
 .../overlay/page-turn-summary.util.spec.ts    |  37 +-
 .../overlay/page-turn-summary.util.ts         |  19 +
 .../svg-interaction.service.spec.ts           |   1 +
 .../coolant-system-failure.util.ts            |   2 +-
 .../escalating-equipment.handler.spec.ts      |   4 +-
 src/app/models/cbt-force-unit.model.ts        |  10 +-
 src/app/models/force-serialization.ts         |   2 +
 src/app/models/rules/mek-rules.spec.ts        | 419 ++++++++++++++-
 src/app/models/rules/mek-rules.ts             | 263 +++++++--
 src/app/models/rules/tw-rules.spec.ts         |  21 +
 src/app/models/rules/tw-rules.ts              |  50 +-
 src/app/models/rules/unit-type-rules.ts       |  64 ++-
 src/app/models/rules/vehicle-rules.spec.ts    |   1 +
 src/app/models/turn-state.model.spec.ts       | 499 +++++++++++++++++-
 src/app/models/turn-state.model.ts            | 108 ++--
 .../services/force-builder.service.spec.ts    |   1 +
 src/app/services/unit-svg-mek.service.ts      |  17 +-
 src/app/services/unit-svg.service.ts          |   2 +-
 src/app/testing/unit-test-helpers.ts          |   4 +-
 ...nventory-control-opfor-target.util.spec.ts |   1 +
 .../inventory-control-opfor-target.util.ts    |   2 +-
 src/app/utils/mek-critical-hit.util.spec.ts   |   4 +-
 36 files changed, 2060 insertions(+), 248 deletions(-)
 create mode 100644 src/app/components/page-viewer/overlay/page-turn-summary-panel.component.spec.ts

diff --git a/src/app/components/hex-slider/hex-slider.component.html b/src/app/components/hex-slider/hex-slider.component.html
index f4daf72ed..2295ee208 100644
--- a/src/app/components/hex-slider/hex-slider.component.html
+++ b/src/app/components/hex-slider/hex-slider.component.html
@@ -5,7 +5,7 @@
     tabindex="0"
     [attr.aria-label]="ariaLabel()"
     [attr.aria-valuemin]="effectiveMinValue()"
-    [attr.aria-valuemax]="maxValue()"
+    [attr.aria-valuemax]="effectiveMaxValue()"
     [attr.aria-valuenow]="clampedValue()"
     [attr.aria-valuetext]="valueLabel()"
     (keydown)="onKeyDown($event)"
@@ -13,7 +13,10 @@
     <div class="slider-scale" #sliderScale>
         <div class="track" aria-hidden="true">
             @if (blockedMinPercent() > 0) {
-                <div class="blocked-track" [style.width.%]="blockedMinPercent()"></div>
+                <div class="blocked-track blocked-min-track" [style.width.%]="blockedMinPercent()"></div>
+            }
+            @if (blockedMaxPercent() > 0) {
+                <div class="blocked-track blocked-max-track" [style.width.%]="blockedMaxPercent()"></div>
             }
         </div>
         @for (tick of displayTicks(); track tick) {
diff --git a/src/app/components/hex-slider/hex-slider.component.scss b/src/app/components/hex-slider/hex-slider.component.scss
index 5f5be8acf..fe013e8f0 100644
--- a/src/app/components/hex-slider/hex-slider.component.scss
+++ b/src/app/components/hex-slider/hex-slider.component.scss
@@ -43,15 +43,23 @@
     inset-inline-end: calc(var(--hex-slider-track-overhang) * -1);
     block-size: var(--hex-slider-track-height);
     transform: translateY(-50%);
-    background: rgba(70, 70, 70, 0.72);
-    border: 1px solid rgba(255, 255, 255, 0.06);
+    background: var(--background-input);
     box-sizing: border-box;
     overflow: hidden;
 }
 
 .blocked-track {
-    block-size: 100%;
-    background: #800;
+    position: absolute;
+    inset-block: 0;
+    background: #666;
+}
+
+.blocked-min-track {
+    inset-inline-start: 0;
+}
+
+.blocked-max-track {
+    inset-inline-end: 0;
 }
 
 .tick {
diff --git a/src/app/components/hex-slider/hex-slider.component.spec.ts b/src/app/components/hex-slider/hex-slider.component.spec.ts
index 9d6585977..042f949de 100644
--- a/src/app/components/hex-slider/hex-slider.component.spec.ts
+++ b/src/app/components/hex-slider/hex-slider.component.spec.ts
@@ -81,6 +81,23 @@ describe('HexSliderComponent', () => {
         expect(valueCommits).toEqual([1]);
     });
 
+    it('shows and enforces a blocked upper range', () => {
+        fixture.componentRef.setInput('blockedMax', 6);
+        fixture.detectChanges();
+        const slider = fixture.nativeElement.querySelector('.hex-slider') as HTMLDivElement;
+
+        expect(component.effectiveMaxValue()).toBe(6);
+        expect(component.blockedMaxPercent()).toBe(40);
+        expect(slider.getAttribute('aria-valuemax')).toBe('6');
+        expect(fixture.nativeElement.querySelector('.blocked-max-track')).not.toBeNull();
+
+        slider.dispatchEvent(pointerEvent('pointerdown', 1, 90));
+        window.dispatchEvent(pointerEvent('pointerup', 1, 90));
+
+        expect(valueChanges).toEqual([6]);
+        expect(valueCommits).toEqual([6]);
+    });
+
     it('uses tick label overrides without replacing other generated tick labels', () => {
         fixture.componentRef.setInput('tickLabelOverrides', { 8: 'RUN', 10: 'MASC' });
         fixture.detectChanges();
diff --git a/src/app/components/hex-slider/hex-slider.component.ts b/src/app/components/hex-slider/hex-slider.component.ts
index a44981e64..e29b2ca79 100644
--- a/src/app/components/hex-slider/hex-slider.component.ts
+++ b/src/app/components/hex-slider/hex-slider.component.ts
@@ -35,6 +35,7 @@ export class HexSliderComponent {
     readonly min = input<number>(0);
     readonly max = input<number>(100);
     readonly blockedMin = input<number | null>(null);
+    readonly blockedMax = input<number | null>(null);
     readonly step = input<number>(1);
     readonly value = input<number>(0);
     readonly ticks = input<readonly number[] | null>(null);
@@ -57,11 +58,23 @@ export class HexSliderComponent {
         if (blockedMin === null) return this.minValue();
         return Math.max(this.minValue(), Math.min(this.maxValue(), this.normalizeNumber(blockedMin, this.minValue())));
     });
+    readonly effectiveMaxValue = computed(() => {
+        const blockedMax = this.blockedMax();
+        if (blockedMax === null) return this.maxValue();
+        return Math.max(
+            this.effectiveMinValue(),
+            Math.min(this.maxValue(), this.normalizeNumber(blockedMax, this.maxValue())),
+        );
+    });
     readonly stepValue = computed(() => Math.max(0.000001, Math.abs(this.normalizeNumber(this.step(), 1))));
     readonly clampedValue = computed(() => this.alignToStep(this.value()));
     readonly valueLabel = computed(() => this.label() ?? `${this.clampedValue()}`);
     readonly valuePercent = computed(() => this.percentForValue(this.clampedValue()));
     readonly blockedMinPercent = computed(() => this.effectiveMinValue() > this.minValue() ? this.percentForValue(this.effectiveMinValue()) : 0);
+    readonly blockedMaxPercent = computed(() => this.effectiveMaxValue() < this.maxValue()
+        ? 100 - this.percentForValue(this.effectiveMaxValue())
+        : 0
+    );
     readonly displayTicks = computed(() => {
         const explicitTicks = this.ticks();
         if (explicitTicks !== null) {
@@ -134,7 +147,7 @@ export class HexSliderComponent {
         if (event.key === 'PageUp') next = this.clampedValue() + step * 5;
         if (event.key === 'PageDown') next = this.clampedValue() - step * 5;
         if (event.key === 'Home') next = this.effectiveMinValue();
-        if (event.key === 'End') next = this.maxValue();
+        if (event.key === 'End') next = this.effectiveMaxValue();
         if (next === null) return;
 
         event.preventDefault();
@@ -198,7 +211,7 @@ export class HexSliderComponent {
 
     private alignToStep(value: number): number {
         const min = this.minValue();
-        const max = this.maxValue();
+        const max = this.effectiveMaxValue();
         const effectiveMin = this.effectiveMinValue();
         const step = this.stepValue();
         const stepped = min + Math.round((value - min) / step) * step;
diff --git a/src/app/components/page-viewer/overlay/page-psr-warning-panel.component.spec.ts b/src/app/components/page-viewer/overlay/page-psr-warning-panel.component.spec.ts
index aaa0cead9..68a6cff27 100644
--- a/src/app/components/page-viewer/overlay/page-psr-warning-panel.component.spec.ts
+++ b/src/app/components/page-viewer/overlay/page-psr-warning-panel.component.spec.ts
@@ -2,13 +2,45 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Author: Drake
 
-import { signal } from '@angular/core';
+import { Injector, signal } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
+import { Overlay } from '@angular/cdk/overlay';
+import { Subject } from 'rxjs';
 import { DiceRollerComponent } from '../../dice-roller/dice-roller.component';
 import { OverlayManagerService } from '../../../services/overlay-manager.service';
 import type { PSRCheck } from '../../../models/rules/unit-type-rules';
 import { PageInteractionOverlayComponent } from './page-interaction-overlay.component';
-import { PagePsrWarningPanelComponent, psrRollOutcome } from './page-psr-warning-panel.component';
+import { PagePsrWarningPanelComponent, psrRollOutcome, togglePsrWarningOverlay } from './page-psr-warning-panel.component';
+
+describe('togglePsrWarningOverlay', () => {
+    it('keeps Turn Summary open until PSR Warning closes', () => {
+        const closed = new Subject<void>();
+        const overlayManager = {
+            has: jasmine.createSpy('has').and.returnValue(false),
+            closeManagedOverlay: jasmine.createSpy('closeManagedOverlay'),
+            createManagedOverlay: jasmine.createSpy('createManagedOverlay').and.returnValue({ closed }),
+            blockCloseUntil: jasmine.createSpy('blockCloseUntil'),
+            unblockClose: jasmine.createSpy('unblockClose'),
+        } as unknown as OverlayManagerService;
+        const parent = { unit: signal({ id: 'unit-1' }) } as unknown as PageInteractionOverlayComponent;
+        const overlay = { scrollStrategies: { block: () => ({}) } } as unknown as Overlay;
+
+        togglePsrWarningOverlay(
+            parent,
+            overlayManager,
+            Injector.create({ providers: [] }),
+            overlay,
+        );
+
+        expect(overlayManager.blockCloseUntil).toHaveBeenCalledOnceWith('turnSummary-unit-1');
+        expect(overlayManager.closeManagedOverlay).not.toHaveBeenCalledWith('turnSummary-unit-1');
+
+        closed.next();
+
+        expect(overlayManager.unblockClose).toHaveBeenCalledOnceWith('turnSummary-unit-1');
+        expect(overlayManager.closeManagedOverlay).not.toHaveBeenCalledWith('turnSummary-unit-1');
+    });
+});
 
 describe('psrRollOutcome', () => {
     it('succeeds on or above the target and fails below it', () => {
diff --git a/src/app/components/page-viewer/overlay/page-psr-warning-panel.component.ts b/src/app/components/page-viewer/overlay/page-psr-warning-panel.component.ts
index 2356af01e..3c57890a8 100644
--- a/src/app/components/page-viewer/overlay/page-psr-warning-panel.component.ts
+++ b/src/app/components/page-viewer/overlay/page-psr-warning-panel.component.ts
@@ -9,7 +9,7 @@ import type { PSRCheck } from '../../../models/rules/unit-type-rules';
 import { OverlayManagerService } from '../../../services/overlay-manager.service';
 import { DiceRollerComponent } from '../../dice-roller/dice-roller.component';
 import { PageInteractionOverlayComponent } from './page-interaction-overlay.component';
-import { displayPsrModifiers } from './page-turn-summary.util';
+import { displayPsrModifiers, openTurnSummaryChildOverlay } from './page-turn-summary.util';
 import { getMekLocationLabel } from '../../../models/entity/types';
 
 export function psrRollOutcome(sum: number, target: number): 'success' | 'failed' {
@@ -40,14 +40,16 @@ export function togglePsrWarningOverlay(
         parent: injector
     });
     const portal = new ComponentPortal(PagePsrWarningPanelComponent, null, customInjector);
-    overlayManager.createManagedOverlay(overlayKey, null, portal, {
-        hasBackdrop: true,
-        backdropClass: 'cdk-overlay-dark-backdrop',
-        panelClass: 'psr-warning-overlay-panel',
-        closeOnOutsideClick: true,
-        scrollStrategy: overlay.scrollStrategies.block(),
-        positions: []
-    });
+    openTurnSummaryChildOverlay(overlayManager, unitId, () =>
+        overlayManager.createManagedOverlay(overlayKey, null, portal, {
+            hasBackdrop: true,
+            backdropClass: 'cdk-overlay-dark-backdrop',
+            panelClass: 'psr-warning-overlay-panel',
+            closeOnOutsideClick: true,
+            scrollStrategy: overlay.scrollStrategies.block(),
+            positions: []
+        })
+    );
 }
 
 @Component({
diff --git a/src/app/components/page-viewer/overlay/page-standing-up-panel.component.html b/src/app/components/page-viewer/overlay/page-standing-up-panel.component.html
index 8c909a91c..dd599555c 100644
--- a/src/app/components/page-viewer/overlay/page-standing-up-panel.component.html
+++ b/src/app/components/page-viewer/overlay/page-standing-up-panel.component.html
@@ -1,9 +1,11 @@
 <div class="panel glass preventZoomReset framed-borders has-shadow" (click)="$event.stopPropagation()">
-    <div class="header">Standing Up</div>
-    <div class="psr-target">
-        <span>Target roll</span>
-        <strong>{{ targetRoll() }}</strong>
-    </div>
+    <div class="header">{{ reviewOnly ? 'Standing Up Review' : 'Standing Up' }}</div>
+    @if (!canStandWithoutPSR()) {
+        <div class="psr-target">
+            <span>Target roll</span>
+            <strong>{{ targetRoll() }}</strong>
+        </div>
+    }
     <div class="body">
         <div class="attempts">
             <span>Attempts</span>
@@ -15,51 +17,60 @@
                     aria-label="Increase stand attempts" title="Increase stand attempts" (click)="adjustAttempts(1)">+</button>
             </div>
         </div>
-        <div class="psr-list">
-            <div class="psr-item" [class.resolved]="lastOutcome() === 'success'"
-                [class.failed]="lastOutcome() === 'failed'">
-                <div class="psr-check-header">
-                    <div class="psr-item-content">
-                        <div class="psr-reason">Stand up!</div>
-                        <div class="psr-subtitle">Failure: <span class="psr-failure-value">Remain prone</span></div>
-                    </div>
-                    @if (lastOutcome(); as result) {
-                        <div class="psr-result" [class.failed]="result === 'failed'">{{ result }}</div>
-                    }
-                </div>
-                @if (lastOutcome() !== 'success') {
-                    <div class="psr-resolution-actions">
-                        <button type="button" class="random-button" [disabled]="diceRoller()?.isRolling()"
-                            aria-label="Roll 2d6 for standing up" title="Roll 2d6 for standing up"
-                            (click)="roll()"></button>
-                        <button class="bt-button success" type="button" (click)="resolve('success')">SUCCESS</button>
-                        <button class="bt-button danger" type="button" (click)="resolve('failed')">FAILURE</button>
+        @if (!canStandWithoutPSR()) {
+            <div class="psr-list">
+                <div class="psr-item" [class.resolved]="lastOutcome() === 'success'"
+                    [class.failed]="lastOutcome() === 'failed'">
+                    <div class="psr-check-header">
+                        <div class="psr-item-content">
+                            <div class="psr-reason">Stand up!
+                            @if (attemptLimit(); as limit) {
+                                <span class="stand-attempt-limit">({{ limit }} attempt per turn)</span>
+                            }</div>
+                            <div class="psr-subtitle">Failure: <span class="psr-failure-value">Remain prone</span></div>
+                        </div>
+                        @if (lastOutcome(); as result) {
+                            <div class="psr-result" [class.failed]="result === 'failed'">{{ result }}</div>
+                        }
                     </div>
-                }
-            </div>
-        </div>
-        <label class="careful-stand">
-            <input type="checkbox" class="bt-checkbox" [checked]="carefulStand()" (change)="setCarefulStand($event)">
-            <span>Careful stand (optional)</span>
-            <span class="modifier-badge">-2</span>
-        </label>
-        @if (modifiersList().length > 0) {
-            <div class="roll-details">
-                <div class="roll-details-label">Modifiers</div>
-                <div class="modifiers">
-                    @for (modifier of modifiersList(); track $index) {
-                        <div class="modifier-item">
-                            <span class="modifier-location">
-                                @if (modifier.loc) { {{ modifier.loc }} } @else { &mdash; }
-                            </span>
-                            <span class="modifier-reason">{{ modifier.reason }}</span>
-                            <strong class="modifier-value" [class.bonus]="modifier.pilotCheck < 0">
-                                {{ modifier.pilotCheck >= 0 ? '+' : '' }}{{ modifier.pilotCheck }}
-                            </strong>
+                    @if (!reviewOnly && lastOutcome() !== 'success' && canAttemptStand()) {
+                        <div class="psr-resolution-actions">
+                            <button type="button" class="random-button" [disabled]="diceRoller()?.isRolling()"
+                                aria-label="Roll 2d6 for standing up" title="Roll 2d6 for standing up"
+                                (click)="roll()"></button>
+                            <button class="bt-button success" type="button" (click)="resolve('success')">SUCCESS</button>
+                            <button class="bt-button danger" type="button" (click)="resolve('failed')">FAILURE</button>
                         </div>
                     }
                 </div>
             </div>
+            @if (!reviewOnly && supportsCarefulStand()) {
+                <label class="careful-stand" [class.disabled]="!canCarefulStand()"
+                    [attr.title]="canCarefulStand() ? 'Consumes all remaining movement and counts as walking' : 'Requires at least 3 available Walking MP'">
+                    <input type="checkbox" class="bt-checkbox" [checked]="carefulStand()" [disabled]="!canCarefulStand()"
+                        (change)="setCarefulStand($event)">
+                    <span>Careful stand (optional)</span>
+                    <span class="modifier-badge">-2</span>
+                </label>
+            }
+            @if (modifiersList().length > 0) {
+                <div class="roll-details">
+                    <div class="roll-details-label">Modifiers</div>
+                    <div class="modifiers">
+                        @for (modifier of modifiersList(); track $index) {
+                            <div class="modifier-item">
+                                <span class="modifier-location">
+                                    @if (modifier.loc) { {{ modifier.loc }} } @else { &mdash; }
+                                </span>
+                                <span class="modifier-reason">{{ modifier.reason }}</span>
+                                <strong class="modifier-value" [class.bonus]="modifier.pilotCheck < 0">
+                                    {{ modifier.pilotCheck >= 0 ? '+' : '' }}{{ modifier.pilotCheck }}
+                                </strong>
+                            </div>
+                        }
+                    </div>
+                </div>
+            }
         }
     </div>
     <div class="actions">
@@ -67,16 +78,18 @@
     </div>
 </div>
 
-<dice-roller
-    #roller
-    [diceCount]="2"
-    [diceSides]="6"
-    [showInline]="false"
-    [showOverlay]="true"
-    [reserveOverlayResultSpace]="true"
-    [compactOverlayResult]="true"
-    [overlayResult]="rolledResult()"
-    [overlayResultTone]="rolledResultTone()"
-    overlayCloseHint="Click to return to standing up"
-    (finished)="onRollFinished($event)"
-/>
+@if (!reviewOnly && !canStandWithoutPSR()) {
+    <dice-roller
+        #roller
+        [diceCount]="2"
+        [diceSides]="6"
+        [showInline]="false"
+        [showOverlay]="true"
+        [reserveOverlayResultSpace]="true"
+        [compactOverlayResult]="true"
+        [overlayResult]="rolledResult()"
+        [overlayResultTone]="rolledResultTone()"
+        overlayCloseHint="Click to return to standing up"
+        (finished)="onRollFinished($event)"
+    />
+}
diff --git a/src/app/components/page-viewer/overlay/page-standing-up-panel.component.scss b/src/app/components/page-viewer/overlay/page-standing-up-panel.component.scss
index d59df5652..f826d41da 100644
--- a/src/app/components/page-viewer/overlay/page-standing-up-panel.component.scss
+++ b/src/app/components/page-viewer/overlay/page-standing-up-panel.component.scss
@@ -12,6 +12,11 @@
     margin: 0;
 }
 
+.careful-stand.disabled {
+    opacity: 0.55;
+    cursor: not-allowed;
+}
+
 .modifier-badge {
     flex: 0 0 24px;
     inline-size: 24px;
@@ -42,6 +47,11 @@
     font-weight: 700;
 }
 
+.stand-attempt-limit {
+    font-size: 0.8em;
+    color: var(--bt-yellow);
+}
+
 .attempts strong {
     min-inline-size: 2ch;
     color: var(--text-color);
diff --git a/src/app/components/page-viewer/overlay/page-standing-up-panel.component.spec.ts b/src/app/components/page-viewer/overlay/page-standing-up-panel.component.spec.ts
index 19f4ced18..16f5fa0b0 100644
--- a/src/app/components/page-viewer/overlay/page-standing-up-panel.component.spec.ts
+++ b/src/app/components/page-viewer/overlay/page-standing-up-panel.component.spec.ts
@@ -7,26 +7,48 @@ import { TestBed } from '@angular/core/testing';
 import { DiceRollerComponent } from '../../dice-roller/dice-roller.component';
 import { OverlayManagerService } from '../../../services/overlay-manager.service';
 import { PageInteractionOverlayComponent } from './page-interaction-overlay.component';
-import { PageStandingUpPanelComponent } from './page-standing-up-panel.component';
+import { PageStandingUpPanelComponent, STANDING_UP_REVIEW_ONLY } from './page-standing-up-panel.component';
 
 describe('PageStandingUpPanelComponent', () => {
     it('applies careful standing, resolves rolls, and adjusts the attempt count', () => {
         const attempts = signal<number | undefined>(undefined);
-        const resolveStandAttempt = jasmine.createSpy('resolveStandAttempt').and.callFake(() => {
+        const carefulStand = signal(false);
+        const canStandUp = signal(true);
+        const canCarefulStand = signal(true);
+        const resolveStandAttempt = jasmine.createSpy('resolveStandAttempt').and.callFake((
+            _outcome: string,
+            options: { carefulStand?: boolean },
+        ) => {
             attempts.update(current => (current ?? 0) + 1);
+            if (options.carefulStand) {
+                carefulStand.set(true);
+                canStandUp.set(false);
+            }
             return true;
         });
         const adjustStandAttempts = jasmine.createSpy('adjustStandAttempts').and.callFake((delta: number) => {
             attempts.update(current => Math.max(0, (current ?? 0) + delta));
+            if (delta < 0) {
+                carefulStand.set(false);
+                canStandUp.set(true);
+            }
         });
         const turnState = {
             standAttempts: attempts,
+            carefulStand,
+            canStandUp,
+            canStandWithoutPSR: signal(false),
             resolveStandAttempt,
             adjustStandAttempts,
         };
         const unit = {
             id: 'unit-1',
-            rules: { standingUpPSRModifier: -1 },
+            rules: {
+                standingUpPSRModifier: -1,
+                getStandAttemptLimit: () => 1,
+                supportsCarefulStand: true,
+                canCarefulStand: () => canCarefulStand() && !carefulStand(),
+            },
             turnState: () => turnState,
             PSRTargetRoll: () => 8,
             PSRModifiers: () => ({ modifiers: [{ pilotCheck: 1, reason: 'Gyro damaged' }] }),
@@ -49,6 +71,15 @@ describe('PageStandingUpPanelComponent', () => {
 
         expect((fixture.nativeElement.querySelector('.careful-stand .modifier-badge') as HTMLElement).textContent?.trim()).toBe('-2');
         expect((fixture.nativeElement.querySelector('.careful-stand') as HTMLElement).textContent).not.toContain('(-2 PSR)');
+        expect((fixture.nativeElement.querySelector('.stand-attempt-limit') as HTMLElement).textContent?.trim())
+            .toBe('(1 attempt per turn)');
+        const carefulStandCheckbox = fixture.nativeElement.querySelector('.careful-stand input') as HTMLInputElement;
+        expect(carefulStandCheckbox.disabled).toBeFalse();
+        canCarefulStand.set(false);
+        fixture.detectChanges();
+        expect(carefulStandCheckbox.disabled).toBeTrue();
+        canCarefulStand.set(true);
+        fixture.detectChanges();
         expect(component.targetRoll()).toBe(7);
         expect(component.attempts()).toBe(0);
 
@@ -64,7 +95,7 @@ describe('PageStandingUpPanelComponent', () => {
         component.onRollFinished({ results: [3, 3], sum: 6 });
 
         expect(roller.roll).toHaveBeenCalledTimes(1);
-        expect(resolveStandAttempt).toHaveBeenCalledOnceWith('success');
+        expect(resolveStandAttempt).toHaveBeenCalledOnceWith('success', { carefulStand: true });
         expect(component.lastOutcome()).toBe('success');
         expect(component.rolledResult()).toBe('SUCCESS');
         expect(component.attempts()).toBe(1);
@@ -90,8 +121,18 @@ describe('PageStandingUpPanelComponent', () => {
     it('does not apply the Core standing modifier under TW rules', () => {
         const unit = {
             id: 'unit-1',
-            rules: { standingUpPSRModifier: 0 },
-            turnState: () => ({ standAttempts: signal<number | undefined>(undefined) }),
+            rules: {
+                standingUpPSRModifier: 0,
+                getStandAttemptLimit: () => null,
+                supportsCarefulStand: true,
+                canCarefulStand: () => false,
+            },
+            turnState: () => ({
+                standAttempts: signal<number | undefined>(undefined),
+                carefulStand: signal(false),
+                canStandUp: signal(true),
+                canStandWithoutPSR: signal(false),
+            }),
             PSRTargetRoll: () => 8,
             PSRModifiers: () => ({ modifiers: [] }),
         };
@@ -108,4 +149,131 @@ describe('PageStandingUpPanelComponent', () => {
         expect(component.targetRoll()).toBe(8);
         expect(component.modifiersList()).toEqual([]);
     });
+
+    it('does not offer careful stand under Core rules', () => {
+        const unit = {
+            id: 'unit-1',
+            rules: {
+                standingUpPSRModifier: -1,
+                getStandAttemptLimit: () => null,
+                supportsCarefulStand: false,
+                canCarefulStand: () => false,
+            },
+            turnState: () => ({
+                standAttempts: signal<number | undefined>(undefined),
+                carefulStand: signal(false),
+                canStandUp: signal(true),
+                canStandWithoutPSR: signal(false),
+            }),
+            PSRTargetRoll: () => 8,
+            PSRModifiers: () => ({ modifiers: [] }),
+        };
+
+        TestBed.configureTestingModule({
+            imports: [PageStandingUpPanelComponent],
+            providers: [
+                { provide: PageInteractionOverlayComponent, useValue: { unit: signal(unit) } },
+                { provide: OverlayManagerService, useValue: { closeManagedOverlay: jasmine.createSpy('closeManagedOverlay') } },
+            ],
+        });
+        const fixture = TestBed.createComponent(PageStandingUpPanelComponent);
+        fixture.detectChanges();
+
+        expect(fixture.nativeElement.querySelector('.careful-stand')).toBeNull();
+        expect(fixture.componentInstance.carefulStand()).toBeFalse();
+    });
+
+    it('renders a standing-attempt review without mutable attempt controls (except attempts stepper)', () => {
+        const attempts = signal<number | undefined>(2);
+        const carefulStand = signal(false);
+        const resolveStandAttempt = jasmine.createSpy('resolveStandAttempt');
+        const adjustStandAttempts = jasmine.createSpy('adjustStandAttempts');
+        const unit = {
+            id: 'unit-1',
+            rules: {
+                standingUpPSRModifier: -1,
+                getStandAttemptLimit: () => 1,
+                supportsCarefulStand: true,
+                canCarefulStand: () => false,
+            },
+            turnState: () => ({
+                standAttempts: attempts,
+                carefulStand,
+                canStandUp: signal(true),
+                canStandWithoutPSR: signal(false),
+                resolveStandAttempt,
+                adjustStandAttempts,
+            }),
+            PSRTargetRoll: () => 8,
+            PSRModifiers: () => ({ modifiers: [{ pilotCheck: 1, reason: 'Gyro damaged' }] }),
+        };
+
+        TestBed.configureTestingModule({
+            imports: [PageStandingUpPanelComponent],
+            providers: [
+                { provide: PageInteractionOverlayComponent, useValue: { unit: signal(unit) } },
+                { provide: OverlayManagerService, useValue: { closeManagedOverlay: jasmine.createSpy('closeManagedOverlay') } },
+                { provide: STANDING_UP_REVIEW_ONLY, useValue: true },
+            ],
+        });
+        const fixture = TestBed.createComponent(PageStandingUpPanelComponent);
+        fixture.detectChanges();
+        const component = fixture.componentInstance;
+
+        expect(component.reviewOnly).toBeTrue();
+        expect((fixture.nativeElement.querySelector('.header') as HTMLElement).textContent?.trim())
+            .toBe('Standing Up Review');
+        expect((fixture.nativeElement.querySelector('.attempts strong') as HTMLElement).textContent?.trim()).toBe('2');
+        expect(fixture.nativeElement.querySelector('.psr-resolution-actions')).toBeNull();
+        expect(fixture.nativeElement.querySelector('.careful-stand')).toBeNull();
+        expect(fixture.nativeElement.querySelector('dice-roller')).toBeNull();
+
+        component.adjustAttempts(1);
+        component.resolve('success');
+        component.onRollFinished({ results: [6, 6], sum: 12 });
+        component.setCarefulStand({ target: { checked: true } } as unknown as Event);
+
+        expect(adjustStandAttempts).toHaveBeenCalledOnceWith(1);
+        expect(resolveStandAttempt).not.toHaveBeenCalled();
+        expect(component.carefulStand()).toBeFalse();
+    });
+
+    it('shows only stand attempts when reviewing a unit that can stand without a PSR', () => {
+        const unit = {
+            id: 'quad-1',
+            rules: {
+                standingUpPSRModifier: -1,
+                getStandAttemptLimit: () => null,
+                supportsCarefulStand: true,
+                canCarefulStand: () => true,
+            },
+            turnState: () => ({
+                standAttempts: signal<number | undefined>(1),
+                carefulStand: signal(false),
+                canStandUp: signal(true),
+                canStandWithoutPSR: signal(true),
+                adjustStandAttempts: jasmine.createSpy('adjustStandAttempts'),
+            }),
+            PSRTargetRoll: () => 8,
+            PSRModifiers: () => ({ modifiers: [{ pilotCheck: 1, reason: 'Gyro damaged' }] }),
+        };
+
+        TestBed.configureTestingModule({
+            imports: [PageStandingUpPanelComponent],
+            providers: [
+                { provide: PageInteractionOverlayComponent, useValue: { unit: signal(unit) } },
+                { provide: OverlayManagerService, useValue: { closeManagedOverlay: jasmine.createSpy('closeManagedOverlay') } },
+                { provide: STANDING_UP_REVIEW_ONLY, useValue: true },
+            ],
+        });
+        const fixture = TestBed.createComponent(PageStandingUpPanelComponent);
+        fixture.detectChanges();
+
+        expect((fixture.nativeElement.querySelector('.attempts strong') as HTMLElement).textContent?.trim()).toBe('1');
+        expect(fixture.nativeElement.querySelector('.psr-target')).toBeNull();
+        expect(fixture.nativeElement.querySelector('.psr-list')).toBeNull();
+        expect(fixture.nativeElement.querySelector('.careful-stand')).toBeNull();
+        expect(fixture.nativeElement.querySelector('.roll-details')).toBeNull();
+        expect(fixture.nativeElement.querySelector('dice-roller')).toBeNull();
+    });
 });
diff --git a/src/app/components/page-viewer/overlay/page-standing-up-panel.component.ts b/src/app/components/page-viewer/overlay/page-standing-up-panel.component.ts
index 8a7199f3c..55f4ab569 100644
--- a/src/app/components/page-viewer/overlay/page-standing-up-panel.component.ts
+++ b/src/app/components/page-viewer/overlay/page-standing-up-panel.component.ts
@@ -2,21 +2,28 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Author: Drake
 
-import { ChangeDetectionStrategy, Component, computed, inject, Injector, signal, viewChild } from '@angular/core';
+import { ChangeDetectionStrategy, Component, computed, inject, InjectionToken, Injector, signal, viewChild } from '@angular/core';
 import { Overlay } from '@angular/cdk/overlay';
 import { ComponentPortal } from '@angular/cdk/portal';
 import { OverlayManagerService } from '../../../services/overlay-manager.service';
 import { DiceRollerComponent } from '../../dice-roller/dice-roller.component';
 import { PageInteractionOverlayComponent } from './page-interaction-overlay.component';
-import { displayPsrModifiers } from './page-turn-summary.util';
+import { displayPsrModifiers, openTurnSummaryChildOverlay } from './page-turn-summary.util';
 import { psrRollOutcome } from './page-psr-warning-panel.component';
 import type { RuleCheckOutcome } from '../../../models/force-serialization';
 
+export const STANDING_UP_REVIEW_ONLY = new InjectionToken<boolean>('Standing up review');
+
+export interface StandingUpOverlayOptions {
+    readonly reviewOnly?: boolean;
+}
+
 export function toggleStandingUpOverlay(
     parent: PageInteractionOverlayComponent,
     overlayManager: OverlayManagerService,
     injector: Injector,
     overlay: Overlay,
+    options: StandingUpOverlayOptions = {},
 ): void {
     const unitId = parent.unit()?.id;
     if (!unitId) return;
@@ -28,18 +35,23 @@ export function toggleStandingUpOverlay(
     }
 
     const customInjector = Injector.create({
-        providers: [{ provide: PageInteractionOverlayComponent, useValue: parent }],
+        providers: [
+            { provide: PageInteractionOverlayComponent, useValue: parent },
+            { provide: STANDING_UP_REVIEW_ONLY, useValue: options.reviewOnly ?? false },
+        ],
         parent: injector,
     });
     const portal = new ComponentPortal(PageStandingUpPanelComponent, null, customInjector);
-    overlayManager.createManagedOverlay(overlayKey, null, portal, {
-        hasBackdrop: true,
-        backdropClass: 'cdk-overlay-dark-backdrop',
-        panelClass: 'standing-up-overlay-panel',
-        closeOnOutsideClick: true,
-        scrollStrategy: overlay.scrollStrategies.block(),
-        positions: [],
-    });
+    openTurnSummaryChildOverlay(overlayManager, unitId, () =>
+        overlayManager.createManagedOverlay(overlayKey, null, portal, {
+            hasBackdrop: true,
+            backdropClass: 'cdk-overlay-dark-backdrop',
+            panelClass: 'standing-up-overlay-panel',
+            closeOnOutsideClick: true,
+            scrollStrategy: overlay.scrollStrategies.block(),
+            positions: [],
+        })
+    );
 }
 
 @Component({
@@ -57,7 +69,11 @@ export class PageStandingUpPanelComponent {
     private readonly overlayManager = inject(OverlayManagerService);
     readonly diceRoller = viewChild<DiceRollerComponent>('roller');
     readonly unit = this.parent.unit;
-    readonly carefulStand = signal(false);
+    readonly reviewOnly = inject(STANDING_UP_REVIEW_ONLY, { optional: true }) ?? false;
+    readonly carefulStand = signal(
+        this.unit()?.rules.supportsCarefulStand === true
+        && this.unit()?.turnState().carefulStand?.() === true
+    );
     readonly lastOutcome = signal<RuleCheckOutcome | null>(null);
     readonly rolledResult = signal<string | null>(null);
     readonly rolledResultTone = computed<'default' | 'success' | 'failed'>(() => {
@@ -73,6 +89,17 @@ export class PageStandingUpPanelComponent {
     });
 
     readonly attempts = computed(() => this.unit()?.turnState().standAttempts() ?? 0);
+    readonly canStandWithoutPSR = computed(() => this.unit()?.turnState().canStandWithoutPSR() ?? false);
+    readonly attemptLimit = computed(() => {
+        const unit = this.unit();
+        return unit?.rules.getStandAttemptLimit(unit.turnState()) ?? null;
+    });
+    readonly supportsCarefulStand = computed(() => this.unit()?.rules.supportsCarefulStand ?? false);
+    readonly canCarefulStand = computed(() => {
+        const unit = this.unit();
+        return unit?.rules.canCarefulStand(unit.turnState()) ?? false;
+    });
+    readonly canAttemptStand = computed(() => this.unit()?.turnState().canStandUp() ?? false);
 
     readonly modifiersList = computed(() => {
         const unit = this.unit();
@@ -92,10 +119,13 @@ export class PageStandingUpPanelComponent {
     }
 
     setCarefulStand(event: Event): void {
-        this.carefulStand.set((event.target as HTMLInputElement).checked);
+        if (this.reviewOnly) return;
+        const checked = (event.target as HTMLInputElement).checked;
+        this.carefulStand.set(checked && this.canCarefulStand());
     }
 
     roll(): void {
+        if (this.reviewOnly) return;
         const roller = this.diceRoller();
         if (!roller || roller.isRolling() || this.lastOutcome() === 'success') return;
         this.lastOutcome.set(null);
@@ -104,20 +134,28 @@ export class PageStandingUpPanelComponent {
     }
 
     onRollFinished(event: { readonly results: number[]; readonly sum: number }): void {
+        if (this.reviewOnly) return;
         const result = psrRollOutcome(event.sum, this.targetRoll());
         this.resolve(result);
         if (this.lastOutcome() === result) this.rolledResult.set(result.toUpperCase());
     }
 
     resolve(outcome: RuleCheckOutcome): void {
+        if (this.reviewOnly) return;
         const unit = this.unit();
         if (!unit || this.lastOutcome() === 'success') return;
         this.rolledResult.set(null);
-        if (unit.turnState().resolveStandAttempt(outcome)) this.lastOutcome.set(outcome);
+        if (unit.turnState().resolveStandAttempt(outcome, { carefulStand: this.carefulStand() })) {
+            this.lastOutcome.set(outcome);
+        }
     }
 
     adjustAttempts(delta: number): void {
-        this.unit()?.turnState().adjustStandAttempts(delta);
+        //Note: even in reviewOnly mode we still allow to adjust the attempts. That's the whole point of the review mode...
+        const turnState = this.unit()?.turnState();
+        turnState?.adjustStandAttempts(delta);
+        const committedCarefulStand = turnState?.carefulStand?.();
+        if (committedCarefulStand !== undefined) this.carefulStand.set(committedCarefulStand);
         if (this.lastOutcome() !== 'success') this.lastOutcome.set(null);
         this.rolledResult.set(null);
     }
diff --git a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.html b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.html
index 76610a77c..578ffd421 100644
--- a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.html
+++ b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.html
@@ -7,6 +7,9 @@
     <header id="turn-summary-title" class="panel-header">TURN TRACKER</header>
 
     <section class="summary-section" aria-label="Movement">
+        @if (showImmobileStatus()) {
+            <div class="summary-row immobile-status" role="status">Unit is immobile</div>
+        } @else {
         @if (canSwitchAirborneMode()) {
             <div class="button-row">
                 <button
@@ -26,12 +29,6 @@
             </div>
         }
 
-        @if (prone() && canStandUp()) {
-            <div class="button-row">
-                <button type="button" class="bt-button move-button" (click)="standUp($event)">Stand up!</button>
-            </div>
-        }
-
         @if (canSwitchAirborneMode() === false || airborne() !== null) {
             <div class="summary-row">
                 @for (moveMode of moveModes(); track moveMode.mode) {
@@ -40,9 +37,11 @@
                         type="button"
                         class="bt-button move-button"
                         [class.stationary]="mode === 'stationary'"
+                        [class.stationary-only]="mode === 'stationary' && onlyStationaryMoveMode()"
                         [class.selected]="currentMoveMode() === mode"
                         [class.danger]="moveMode.psr"
                         [disabled]="isMoveModeDisabled(mode)"
+                        [attr.aria-label]="mode === 'stationary' ? 'Stationary' : null"
                         [attr.aria-pressed]="currentMoveMode() === mode"
                         (click)="selectMove(mode)"
                     >
@@ -60,13 +59,35 @@
                 }
             </div>
 
+            @if (prone() && canStandUp()) {
+                <div class="button-row">
+                    <button type="button" class="bt-button move-button" [class.danger]="standUpRequiresPSR()"
+                        (click)="standUp($event)">Stand up!</button>
+                </div>
+            }
+
+            @if (standAttempts() > 0) {
+                <div class="summary-row stand-attempts-summary">
+                    <button
+                        type="button"
+                        class="stand-attempts-link"
+                        aria-haspopup="dialog"
+                        title="Review stand-up attempt details"
+                        (click)="reviewStandAttempts($event)"
+                    >
+                        Stand attempts: {{ standAttempts() }} (&minus;{{ standAttemptMovementPointsSpent() }} MP)
+                    </button>
+                </div>
+            }
+
             @if (currentMoveMode() !== 'stationary' && currentMoveMode() !== null) {
                 <div class="summary-row">
                     <hex-slider
                         class="move-slider"
                         [min]="0"
-                        [max]="moveMax()"
+                        [max]="moveCapacity()"
                         [blockedMin]="moveMin()"
+                        [blockedMax]="moveMax()"
                         [step]="1"
                         [value]="moveDistance()"
                         [ticks]="moveDistanceTicks()"
@@ -129,6 +150,7 @@
                 </div>
             }
         }
+        }
 
         <div class="button-row">
             <button
diff --git a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.scss b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.scss
index 18dff1238..89ad91072 100644
--- a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.scss
+++ b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.scss
@@ -114,6 +114,19 @@
     &.stationary {
         max-width: 40px;
     }
+
+    &.stationary-only {
+        width: 100%;
+        max-width: none;
+    }
+}
+
+.immobile-status {
+    min-height: 40px;
+    justify-content: center;
+    font-weight: 600;
+    text-align: center;
+    color: var(--text-color-secondary);
 }
 
 .spotting-button {
@@ -127,6 +140,30 @@
     min-width: 0;
 }
 
+.stand-attempts-summary {
+    justify-content: center;
+    padding: 4px;
+}
+
+.stand-attempts-link {
+    appearance: none;
+    border: 0;
+    background: none;
+    padding: 0;
+    color: var(--text-color-secondary);
+    font: inherit;
+    font-size: 0.82em;
+    font-variant-numeric: tabular-nums;
+    text-decoration: underline;
+    text-underline-offset: 2px;
+    cursor: pointer;
+
+    &:hover,
+    &:focus-visible {
+        color: var(--text-color);
+    }
+}
+
 .equipment-track-row {
     gap: 2px;
 }
diff --git a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.spec.ts b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.spec.ts
new file mode 100644
index 000000000..bdf401403
--- /dev/null
+++ b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.spec.ts
@@ -0,0 +1,155 @@
+// Copyright (C) 2026 The MegaMek Team
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Author: Drake
+
+import { signal } from '@angular/core';
+import { TestBed } from '@angular/core/testing';
+import { Overlay } from '@angular/cdk/overlay';
+import { Subject } from 'rxjs';
+import { CORE_2026_GAME_RULES, TW_GAME_RULES } from '../../../models/rules/game-rules';
+import { DataService } from '../../../services/data.service';
+import { DialogsService } from '../../../services/dialogs.service';
+import { EquipmentInteractionRegistryService } from '../../../services/equipment-interaction-registry.service';
+import { OverlayManagerService } from '../../../services/overlay-manager.service';
+import { ToastService } from '../../../services/toast.service';
+import { PageInteractionOverlayComponent } from './page-interaction-overlay.component';
+import { STANDING_UP_REVIEW_ONLY } from './page-standing-up-panel.component';
+import { PageTurnSummaryPanelComponent } from './page-turn-summary-panel.component';
+
+describe('PageTurnSummaryPanelComponent', () => {
+    it('distinguishes an Immobile unit from one with only Stationary available', () => {
+        const immobile = signal(false);
+        const rulesId = signal<'core2026' | 'tw'>('core2026');
+        const turnState = { airborne: signal<boolean | null>(false) };
+        const unit = {
+            get gameRules() {
+                return rulesId() === 'tw' ? TW_GAME_RULES : CORE_2026_GAME_RULES;
+            },
+            getCondition: (condition: string) => condition === 'immobile' && immobile(),
+            getAvailableMotiveModes: () => [{ mode: 'stationary', label: 'Stationary', psr: false }],
+            turnState: () => turnState,
+        };
+
+        TestBed.configureTestingModule({
+            imports: [PageTurnSummaryPanelComponent],
+            providers: [
+                { provide: PageInteractionOverlayComponent, useValue: { unit: signal(unit), force: signal(null) } },
+                { provide: OverlayManagerService, useValue: { closeManagedOverlay: () => undefined } },
+                { provide: Overlay, useValue: {} },
+                { provide: EquipmentInteractionRegistryService, useValue: { getRegistry: () => ({}) } },
+                { provide: ToastService, useValue: {} },
+                { provide: DialogsService, useValue: {} },
+                { provide: DataService, useValue: {} },
+            ],
+        });
+        const fixture = TestBed.createComponent(PageTurnSummaryPanelComponent);
+        const component = fixture.componentInstance;
+        Object.assign(component, {
+            dirty: () => false,
+            damageReceived: () => 0,
+            hasPSRChecks: () => false,
+            falling: () => false,
+            PSRChecksCount: () => 0,
+            controlRollShortLabel: () => 'PSR',
+            currentMoveMode: () => null,
+            prone: () => false,
+            canStandUp: () => false,
+            standAttempts: () => 0,
+            standUpRequiresPSR: () => false,
+            getTotalTargetModifierAsDefender: () => '0',
+            defenseTargetModifierTooltip: () => null,
+            spotting: () => false,
+            cover: () => undefined,
+            waterDepth: () => '',
+            buildingLevel: () => '',
+            coverModifierLabel: () => null,
+            spottingModifierLabel: () => null,
+            tracksHeat: () => false,
+            heatRows: () => [],
+            psrModifiers: () => [],
+            equipmentTrackControlRows: () => [],
+            airborne: () => false,
+            canSwitchAirborneMode: () => false,
+        });
+
+        expect(component.immobile()).toBeFalse();
+        expect(component.onlyStationaryMoveMode()).toBeTrue();
+        fixture.detectChanges();
+
+        expect(fixture.nativeElement.querySelectorAll('.move-button').length).toBe(1);
+        expect(fixture.nativeElement.querySelector('.move-button.stationary-only')).not.toBeNull();
+        expect(fixture.nativeElement.querySelector('.immobile-status')).toBeNull();
+
+        immobile.set(true);
+        fixture.detectChanges();
+
+        expect(component.immobile()).toBeTrue();
+        expect(fixture.nativeElement.querySelector('.move-button')).toBeNull();
+        expect(fixture.nativeElement.querySelector('.immobile-status')?.textContent.trim())
+            .toBe('Unit is immobile');
+
+        rulesId.set('tw');
+        fixture.detectChanges();
+
+        expect(component.immobile()).toBeTrue();
+        expect(component.showImmobileStatus()).toBeFalse();
+        expect(fixture.nativeElement.querySelector('.immobile-status')).toBeNull();
+        expect(fixture.nativeElement.querySelectorAll('.move-button').length).toBe(1);
+        expect(fixture.nativeElement.querySelector('.move-button.stationary-only')).not.toBeNull();
+    });
+
+    it('reports spent stand-attempt MP and reopens the standing dialog without changing the attempt', () => {
+        const attempts = signal<number | undefined>(1);
+        const getMovementPointsSpent = jasmine.createSpy('getMovementPointsSpent').and.returnValue(2);
+        const turnState = { standAttempts: attempts };
+        const unit = {
+            id: 'unit-1',
+            rules: { getMovementPointsSpent },
+            turnState: () => turnState,
+        };
+        const standingOverlayClosed = new Subject<void>();
+        const overlayManager = {
+            has: jasmine.createSpy('has').and.returnValue(false),
+            closeManagedOverlay: jasmine.createSpy('closeManagedOverlay'),
+            createManagedOverlay: jasmine.createSpy('createManagedOverlay').and.returnValue({
+                closed: standingOverlayClosed,
+            }),
+            blockCloseUntil: jasmine.createSpy('blockCloseUntil'),
+            unblockClose: jasmine.createSpy('unblockClose'),
+        };
+
+        TestBed.configureTestingModule({
+            imports: [PageTurnSummaryPanelComponent],
+            providers: [
+                { provide: PageInteractionOverlayComponent, useValue: { unit: signal(unit), force: signal(null) } },
+                { provide: OverlayManagerService, useValue: overlayManager },
+                { provide: Overlay, useValue: { scrollStrategies: { block: () => ({}) } } },
+                { provide: EquipmentInteractionRegistryService, useValue: { getRegistry: () => ({}) } },
+                { provide: ToastService, useValue: {} },
+                { provide: DialogsService, useValue: {} },
+                { provide: DataService, useValue: {} },
+            ],
+        });
+        const component = TestBed.createComponent(PageTurnSummaryPanelComponent).componentInstance;
+        const event = { stopPropagation: jasmine.createSpy('stopPropagation') } as unknown as MouseEvent;
+
+        expect(component.standAttempts()).toBe(1);
+        expect(component.standAttemptMovementPointsSpent()).toBe(2);
+
+        component.reviewStandAttempts(event);
+
+        expect(event.stopPropagation).toHaveBeenCalled();
+        expect(attempts()).toBe(1);
+        expect(overlayManager.createManagedOverlay).toHaveBeenCalled();
+        expect(overlayManager.createManagedOverlay.calls.mostRecent().args[0]).toBe('standingUp-unit-1');
+        const portal = overlayManager.createManagedOverlay.calls.mostRecent().args[2];
+        expect(portal.injector.get(STANDING_UP_REVIEW_ONLY)).toBeTrue();
+        expect(overlayManager.blockCloseUntil).toHaveBeenCalledOnceWith('turnSummary-unit-1');
+        expect(overlayManager.closeManagedOverlay).not.toHaveBeenCalledWith('turnSummary-unit-1');
+
+        standingOverlayClosed.next();
+
+        expect(overlayManager.unblockClose).toHaveBeenCalledOnceWith('turnSummary-unit-1');
+        expect(overlayManager.closeManagedOverlay).not.toHaveBeenCalledWith('turnSummary-unit-1');
+    });
+});
diff --git a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.ts b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.ts
index 52f0fdd19..8be680b96 100644
--- a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.ts
+++ b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.ts
@@ -149,23 +149,51 @@ export class PageTurnSummaryPanelComponent {
 
     readonly prone = computed(() => this.unit()?.getCondition('prone') ?? false);
 
+    readonly immobile = computed(() => this.unit()?.getCondition('immobile') ?? false);
+
+    readonly showImmobileStatus = computed(() => {
+        const unit = this.unit();
+        return unit?.gameRules.id === 'core2026' && this.immobile();
+    });
+
     readonly canStandUp = computed(() => this.unit()?.turnState().canStandUp() ?? false);
 
+    readonly standAttempts = computed(() => this.unit()?.turnState().standAttempts() ?? 0);
+
+    readonly standAttemptMovementPointsSpent = computed(() => {
+        const unit = this.unit();
+        return unit?.rules.getMovementPointsSpent(unit.turnState()) ?? 0;
+    });
+
+    readonly standUpRequiresPSR = computed(() => {
+        const turnState = this.unit()?.turnState();
+        return turnState?.canStandUp() === true && !turnState.canStandWithoutPSR();
+    });
+
     isMoveModeDisabled(mode: MotiveModes): boolean {
+        if (this.unit()?.turnState().carefulStand?.()) return true;
         return isMoveModeDisabledWhileProne(mode, this.prone());
     }
 
     standUp(event: MouseEvent): void {
         event.stopPropagation();
         const unit = this.unit();
-        if (!unit || !unit.turnState().canStandUp()) return;
-        if (unit.turnState().canStandWithoutPSR()) {
-            unit.turnState().resolveStandAttempt('success');
+        if (!unit) return;
+        const turnState = unit.turnState();
+        if (!turnState.prepareStandAttempt()) return;
+        if (turnState.canStandWithoutPSR()) {
+            turnState.resolveStandAttempt('success');
             return;
         }
         toggleStandingUpOverlay(this.parent, this.overlayManager, this.injector, this.overlay);
     }
 
+    reviewStandAttempts(event: MouseEvent): void {
+        event.stopPropagation();
+        if (this.standAttempts() === 0) return;
+        toggleStandingUpOverlay(this.parent, this.overlayManager, this.injector, this.overlay, { reviewOnly: true });
+    }
+
     moveModeModifierLabel(mode: MotiveModes): string | null {
         const unit = this.unit();
         const modifier = unit?.rules.getAttackMovementModifier(mode, unit.turnState().airborne() ?? false) ?? 0;
@@ -303,6 +331,11 @@ export class PageTurnSummaryPanelComponent {
         return unit.getAvailableMotiveModes(unit.turnState().airborne() ?? false);
     });
 
+    readonly onlyStationaryMoveMode = computed(() => {
+        const modes = this.moveModes();
+        return modes.length === 1 && modes[0].mode === 'stationary';
+    });
+
     selectMove(mode: MotiveModes): void {
         const unit = this.unit();
         if (!unit || this.isMoveModeDisabled(mode)) return;
@@ -376,6 +409,14 @@ export class PageTurnSummaryPanelComponent {
         return unit.turnState().maxDistanceCurrentMoveMode();
     });
 
+    readonly moveCapacity = computed(() => {
+        const unit = this.unit();
+        if (!unit) return 0;
+        const mode = unit.turnState().moveMode();
+        if (!mode) return 0;
+        return unit.turnState().movementCapacityCurrentMoveMode();
+    });
+
     readonly moveMin = computed(() => {
         const unit = this.unit();
         if (!unit) return 0;
@@ -385,7 +426,7 @@ export class PageTurnSummaryPanelComponent {
     });
 
     readonly moveDistanceTicks = computed(() => {
-        const max = this.moveMax();
+        const max = this.moveCapacity();
         const length = Math.max(0, max + 1);
         return Array.from({ length }, (_value, index) => index);
     });
diff --git a/src/app/components/page-viewer/overlay/page-turn-summary.util.spec.ts b/src/app/components/page-viewer/overlay/page-turn-summary.util.spec.ts
index 68926c656..d12cdac8a 100644
--- a/src/app/components/page-viewer/overlay/page-turn-summary.util.spec.ts
+++ b/src/app/components/page-viewer/overlay/page-turn-summary.util.spec.ts
@@ -2,7 +2,42 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Author: Drake
 
-import { composeTurnSummaryHeatRows, countActionablePsrChecks, displayPsrModifiers, isMoveModeDisabledWhileProne } from './page-turn-summary.util';
+import { Subject } from 'rxjs';
+import type { ManagedOverlayRef, OverlayManagerService } from '../../../services/overlay-manager.service';
+import { composeTurnSummaryHeatRows, countActionablePsrChecks, displayPsrModifiers, isMoveModeDisabledWhileProne, openTurnSummaryChildOverlay } from './page-turn-summary.util';
+
+describe('openTurnSummaryChildOverlay', () => {
+    it('blocks the parent summary until the child overlay closes', () => {
+        const closed = new Subject<void>();
+        const overlayManager = jasmine.createSpyObj<OverlayManagerService>(
+            'OverlayManagerService',
+            ['blockCloseUntil', 'unblockClose'],
+        );
+        const childOverlay = { closed } as ManagedOverlayRef<unknown>;
+        const openOverlay = jasmine.createSpy('openOverlay').and.returnValue(childOverlay);
+
+        expect(openTurnSummaryChildOverlay(overlayManager, 'unit-1', openOverlay)).toBe(childOverlay);
+        expect(overlayManager.blockCloseUntil).toHaveBeenCalledOnceWith('turnSummary-unit-1');
+        expect(openOverlay).toHaveBeenCalledTimes(1);
+        expect(overlayManager.unblockClose).not.toHaveBeenCalled();
+
+        closed.next();
+
+        expect(overlayManager.unblockClose).toHaveBeenCalledOnceWith('turnSummary-unit-1');
+    });
+
+    it('unblocks the parent summary if the child overlay cannot be created', () => {
+        const overlayManager = jasmine.createSpyObj<OverlayManagerService>(
+            'OverlayManagerService',
+            ['blockCloseUntil', 'unblockClose'],
+        );
+        const error = new Error('overlay creation failed');
+
+        expect(() => openTurnSummaryChildOverlay(overlayManager, 'unit-1', () => { throw error; }))
+            .toThrow(error);
+        expect(overlayManager.unblockClose).toHaveBeenCalledOnceWith('turnSummary-unit-1');
+    });
+});
 
 describe('isMoveModeDisabledWhileProne', () => {
     it('disables only jump while prone without changing its selected state', () => {
diff --git a/src/app/components/page-viewer/overlay/page-turn-summary.util.ts b/src/app/components/page-viewer/overlay/page-turn-summary.util.ts
index 2e4ba0f16..ed699c02f 100644
--- a/src/app/components/page-viewer/overlay/page-turn-summary.util.ts
+++ b/src/app/components/page-viewer/overlay/page-turn-summary.util.ts
@@ -5,6 +5,7 @@
 import type { PSRCheck, UnitHeatSource } from '../../../models/rules/unit-type-rules';
 import type { SelectedInventoryWeaponHeat } from '../../../utils/inventory-control-heat.util';
 import type { MotiveModes } from '../../../models/motiveModes.model';
+import type { ManagedOverlayRef, OverlayManagerService } from '../../../services/overlay-manager.service';
 
 export interface TurnSummaryHeatRow {
     readonly id: string;
@@ -17,6 +18,24 @@ export interface TurnSummaryHeatRow {
 
 export const TURN_SUMMARY_UNDERWATER_HEAT_SOURCE_ID = 'underwater-dissipation';
 
+/** Keeps the summary's capture-phase outside-click handler dormant while a modal child is open. */
+export function openTurnSummaryChildOverlay<T>(
+    overlayManager: OverlayManagerService,
+    unitId: string,
+    openOverlay: () => ManagedOverlayRef<T>,
+): ManagedOverlayRef<T> {
+    const parentOverlayKey = `turnSummary-${unitId}`;
+    overlayManager.blockCloseUntil(parentOverlayKey);
+    try {
+        const childOverlay = openOverlay();
+        childOverlay.closed.subscribe(() => overlayManager.unblockClose(parentOverlayKey));
+        return childOverlay;
+    } catch (error) {
+        overlayManager.unblockClose(parentOverlayKey);
+        throw error;
+    }
+}
+
 export function composeTurnSummaryHeatRows(
     sources: readonly UnitHeatSource[],
     selection: SelectedInventoryWeaponHeat,
diff --git a/src/app/components/page-viewer/svg-interaction.service.spec.ts b/src/app/components/page-viewer/svg-interaction.service.spec.ts
index 4f95ca289..9acfe0167 100644
--- a/src/app/components/page-viewer/svg-interaction.service.spec.ts
+++ b/src/app/components/page-viewer/svg-interaction.service.spec.ts
@@ -1980,6 +1980,7 @@ function createInventoryInteractionUnit(html = `
         pilotingSkill: () => 5,
         turnState: () => ({
             moveMode: () => null,
+            effectiveMoveMode: () => null,
             airborne: () => false,
             getAttackMovementModifier: () => 0,
             getAttackModifierBreakdown: () => [],
diff --git a/src/app/equipment-handlers/coolant-system-failure.util.ts b/src/app/equipment-handlers/coolant-system-failure.util.ts
index bd7b6c871..d6fd2ee9a 100644
--- a/src/app/equipment-handlers/coolant-system-failure.util.ts
+++ b/src/app/equipment-handlers/coolant-system-failure.util.ts
@@ -20,7 +20,7 @@ export function getFailedCoolantSystemHeatSources(
     if (!isEquipmentDisabledByFailure(equipment) && !committedDestroyed) return [];
 
     const sources: UnitHeatSource[] = [];
-    const moveMode = turnState.moveMode();
+    const moveMode = turnState.effectiveMoveMode();
     if (moveMode !== null && moveMode !== 'stationary') {
         sources.push({ id: `${sourceId}:movement`, label, value: 1 });
     }
diff --git a/src/app/equipment-handlers/escalating-equipment.handler.spec.ts b/src/app/equipment-handlers/escalating-equipment.handler.spec.ts
index 72159af39..934f999b7 100644
--- a/src/app/equipment-handlers/escalating-equipment.handler.spec.ts
+++ b/src/app/equipment-handlers/escalating-equipment.handler.spec.ts
@@ -38,8 +38,10 @@ function equipmentFixture(
     unitType: 'Mek' | 'Aero' = 'Mek',
     turnStateOverrides: Partial<Record<'moveMode' | 'weaponsHeat', () => unknown>> = {},
 ): EquipmentFixture {
+    const moveMode = turnStateOverrides.moveMode ?? (() => null);
     const turnState = {
-        moveMode: () => null,
+        moveMode,
+        effectiveMoveMode: moveMode,
         weaponsHeat: () => 0,
         ...turnStateOverrides,
     } as unknown as TurnState;
diff --git a/src/app/models/cbt-force-unit.model.ts b/src/app/models/cbt-force-unit.model.ts
index 24fc1f555..72561c5ff 100644
--- a/src/app/models/cbt-force-unit.model.ts
+++ b/src/app/models/cbt-force-unit.model.ts
@@ -1268,7 +1268,7 @@ export class CBTForceUnit extends ForceUnit {
     private isPhysicalActionUnavailable(entry: MountedEquipment): boolean {
         if (!entry.isPhysicalWeapon()) return false;
         if (this.getCondition('prone')) return true;
-        const moveMode = this.turnState().moveMode();
+        const moveMode = this.turnState().effectiveMoveMode();
         if (moveMode === null) return false; // unknown!
 
         const attack = entry.name.trim().toLocaleLowerCase();
@@ -1574,11 +1574,15 @@ export class CBTForceUnit extends ForceUnit {
     }
 
     public getAvailableMotiveModes(airborne: boolean): MotiveModeOption[] {
+        const turnState = this.turnState();
         return getMotiveModesOptionsByUnit(this.getUnit(), airborne)
-            .filter(option => this._rules.isMotiveModeAvailable(option.mode))
+            .filter(option => this._rules.isMotiveModeAvailable(option.mode, turnState))
             .map(option => ({
                 ...option,
-                psr: this._rules.getCommittedDamageMovementModePSRCheck(option.mode) !== null,
+                psr: this._rules.getCommittedDamageMovementModePSRCheck(
+                    option.mode,
+                    option.mode === turnState.moveMode() ? turnState.moveDistance() : 0,
+                ) !== null,
             }));
     }
 
diff --git a/src/app/models/force-serialization.ts b/src/app/models/force-serialization.ts
index ab699fffa..3e80b2dd0 100644
--- a/src/app/models/force-serialization.ts
+++ b/src/app/models/force-serialization.ts
@@ -84,6 +84,7 @@ export interface SerializedTurnState {
     moveMode?: MotiveModes;
     moveDistance?: number;
     standAttempts?: number;
+    carefulStand?: boolean;
     cover?: SerializedUnitCover;
     dmgReceived?: number;
     weaponsHeat?: number;
@@ -441,6 +442,7 @@ export const TURN_STATE_SCHEMA = Sanitizer.schema<SerializedTurnState>()
     .custom('moveMode', (value: unknown) => MOTIVE_MODE_VALUES.includes(value as MotiveModes) ? value as MotiveModes : undefined)
     .custom('moveDistance', sanitizeOptionalNonNegativeNumber)
     .custom('standAttempts', sanitizeOptionalNonNegativeNumber)
+    .custom('carefulStand', (value: unknown) => typeof value === 'boolean' ? value : undefined)
     .custom('cover', sanitizeOptionalCover)
     .custom('dmgReceived', sanitizeOptionalNonNegativeNumber)
     .custom('weaponsHeat', sanitizeOptionalNonNegativeNumber)
diff --git a/src/app/models/rules/mek-rules.spec.ts b/src/app/models/rules/mek-rules.spec.ts
index 2cc2acd24..e3eccb6a2 100644
--- a/src/app/models/rules/mek-rules.spec.ts
+++ b/src/app/models/rules/mek-rules.spec.ts
@@ -2483,6 +2483,97 @@ describe('MekRules', () => {
         }).hasComputedCondition('crippled')).toBeFalse();
     });
 
+    it('marks TW biped, tripod, and quad Meks immobile after the required four limbs are destroyed', () => {
+        const scenarios = [
+            {
+                context: 'Biped',
+                internalLocations: ['LT', 'RT', 'CT', 'LA', 'RA', 'LL', 'RL'],
+                mobileDestroyedLocationSets: [['LA', 'RA', 'LL']],
+                immobileDestroyedLocations: ['LA', 'RA', 'LL', 'RL'],
+            },
+            {
+                context: 'Tripod',
+                internalLocations: ['LT', 'RT', 'CT', 'LA', 'RA', 'LL', 'CL', 'RL'],
+                mobileDestroyedLocationSets: [
+                    ['LA', 'RA', 'LL'],
+                    ['LA', 'LL', 'CL', 'RL'],
+                ],
+                immobileDestroyedLocations: ['LA', 'RA', 'LL', 'CL'],
+            },
+            {
+                context: 'Quad',
+                internalLocations: ['LT', 'RT', 'CT', 'FLL', 'FRL', 'RLL', 'RRL'],
+                mobileDestroyedLocationSets: [['FLL', 'FRL', 'RLL']],
+                immobileDestroyedLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
+            },
+        ];
+
+        for (const scenario of scenarios) {
+            const immobileUnit = createForceUnitHarness({
+                internalLocations: scenario.internalLocations,
+                committedDestroyedLocations: scenario.immobileDestroyedLocations,
+                rulesId: 'tw',
+            });
+
+            for (const destroyedLocations of scenario.mobileDestroyedLocationSets) {
+                const mobileUnit = createForceUnitHarness({
+                    internalLocations: scenario.internalLocations,
+                    committedDestroyedLocations: destroyedLocations,
+                    rulesId: 'tw',
+                });
+                expect(mobileUnit.rules.hasComputedCondition('immobile'))
+                    .withContext(`${scenario.context} with ${destroyedLocations.join(', ')} destroyed`)
+                    .toBeFalse();
+            }
+            expect(immobileUnit.rules.hasComputedCondition('immobile'))
+                .withContext(`${scenario.context} after the fourth required limb is destroyed`)
+                .toBeTrue();
+        }
+    });
+
+    it('marks Core biped and tripod Meks immobile when two destroyed legs reduce ground MP to zero', () => {
+        const scenarios = [
+            {
+                context: 'Biped',
+                internalLocations: ['LT', 'RT', 'CT', 'LA', 'RA', 'LL', 'RL'],
+                twoDestroyedLegs: ['LL', 'RL'],
+            },
+            {
+                context: 'Tripod',
+                internalLocations: ['LT', 'RT', 'CT', 'LA', 'RA', 'LL', 'CL', 'RL'],
+                twoDestroyedLegs: ['LL', 'CL'],
+            },
+        ];
+
+        for (const scenario of scenarios) {
+            const mobileUnit = createForceUnitHarness({
+                internalLocations: scenario.internalLocations,
+                committedDestroyedLocations: ['LL'],
+                jump: 0,
+                umu: 0,
+            });
+            const immobileUnit = createForceUnitHarness({
+                internalLocations: scenario.internalLocations,
+                committedDestroyedLocations: scenario.twoDestroyedLegs,
+                jump: 0,
+                umu: 0,
+            });
+
+            expect((mobileUnit.rules as MekRules).movementState())
+                .withContext(`${scenario.context} with one destroyed leg`)
+                .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+            expect(mobileUnit.rules.hasComputedCondition('immobile'))
+                .withContext(`${scenario.context} with one destroyed leg`)
+                .toBeFalse();
+            expect((immobileUnit.rules as MekRules).movementState())
+                .withContext(`${scenario.context} with two destroyed legs`)
+                .toEqual(jasmine.objectContaining({ walk: 0, run: 0 }));
+            expect(immobileUnit.rules.hasComputedCondition('immobile'))
+                .withContext(`${scenario.context} with two destroyed legs`)
+                .toBeTrue();
+        }
+    });
+
     it('keeps core2026 Meks mobile while a damage-available movement mode remains', () => {
         const forceUnit = createForceUnitHarness({
             internalLocations: ['LL', 'RA', 'RT'],
@@ -2578,8 +2669,22 @@ describe('MekRules', () => {
         }
     });
 
-    it('offers Run only when the selected rules permit it after leg destruction', () => {
+    it('offers ordinary or minimum Run movement when the selected rules permit it after leg destruction', () => {
         const coreBiped = createForceUnitHarness({ committedDestroyedLocations: ['LL'] });
+        const coreTripod = createForceUnitHarness({
+            internalLocations: ['LL', 'CL', 'RL'],
+            committedDestroyedLocations: ['LL'],
+        });
+        const coreQuadWithTwoDestroyedLegs = createForceUnitHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL'],
+            walk: 3,
+            run: 5,
+        });
+        const coreQuadWithThreeDestroyedLegs = createForceUnitHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL', 'RRL'],
+        });
         const twBiped = createForceUnitHarness({ committedDestroyedLocations: ['LL'], rulesId: 'tw' });
         const twTripod = createForceUnitHarness({
             internalLocations: ['LL', 'CL', 'RL'],
@@ -2596,14 +2701,272 @@ describe('MekRules', () => {
             committedDestroyedLocations: ['RLL', 'FLL'],
             rulesId: 'tw',
         });
+        const twQuadWithThreeDestroyedLegs = createForceUnitHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL', 'RRL'],
+            rulesId: 'tw',
+        });
         const offersRun = (unit: CBTForceUnit) => unit.getAvailableMotiveModes(false)
             .some(option => option.mode === 'run');
+        const runAvailability = (unit: CBTForceUnit) => ({
+            rules: unit.rules.isMotiveModeAvailable('run'),
+            offered: offersRun(unit),
+        });
+
+        expect((coreBiped.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+        expect((coreTripod.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+        expect((coreQuadWithTwoDestroyedLegs.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+        expect((coreQuadWithThreeDestroyedLegs.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+        expect((twBiped.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 0 }));
+        expect((twTripod.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 0 }));
+        expect((twQuadWithOneDestroyedLeg.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 4, run: 6 }));
+        expect((twQuadWithTwoDestroyedLegs.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 0 }));
+        expect((twQuadWithThreeDestroyedLegs.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 0, run: 0 }));
+        expect(runAvailability(coreBiped)).toEqual({ rules: true, offered: true });
+        expect(runAvailability(coreTripod)).toEqual({ rules: true, offered: true });
+        expect(runAvailability(coreQuadWithTwoDestroyedLegs))
+            .toEqual({ rules: true, offered: true });
+        expect(runAvailability(coreQuadWithThreeDestroyedLegs))
+            .toEqual({ rules: true, offered: true });
+        expect(runAvailability(twBiped)).toEqual({ rules: true, offered: true });
+        expect(runAvailability(twTripod)).toEqual({ rules: true, offered: true });
+        expect(runAvailability(twQuadWithOneDestroyedLeg))
+            .toEqual({ rules: true, offered: true });
+        expect(runAvailability(twQuadWithTwoDestroyedLegs))
+            .toEqual({ rules: true, offered: true });
+        expect(runAvailability(twQuadWithThreeDestroyedLegs))
+            .toEqual({ rules: false, offered: false });
+    });
+
+    it('offers TW Running Minimum Movement and spends it on a one-legged stand attempt', () => {
+        const forceUnit = createForceUnitHarness({
+            committedDestroyedLocations: ['LL'],
+            rulesId: 'tw',
+        });
+        const turnState = forceUnit.turnState();
+        const offersRun = () => forceUnit.getAvailableMotiveModes(false)
+            .some(option => option.mode === 'run');
+
+        expect(forceUnit.rules.isMotiveModeAvailable('run')).toBeTrue();
+        expect(offersRun()).toBeTrue();
+        expect(forceUnit.rules.getEffectiveMaxDistanceForMoveMode('run', turnState)).toBe(1);
+
+        turnState.moveMode.set('run');
+        turnState.moveDistance.set(1);
+
+        expect(turnState.movementCapacityCurrentMoveMode()).toBe(1);
+        expect(turnState.maxDistanceCurrentMoveMode()).toBe(1);
+        expect(forceUnit.getAvailableMotiveModes(false).find(option => option.mode === 'run')?.psr).toBeTrue();
+
+        forceUnit.setCondition('prone', true);
+
+        expect(forceUnit.rules.isMotiveModeAvailable('run')).toBeTrue();
+        expect(forceUnit.rules.isMotiveModeAvailable('run', turnState)).toBeTrue();
+        expect(offersRun()).toBeTrue();
+        expect(turnState.movementCapacityCurrentMoveMode()).toBe(1);
+        expect(turnState.maxDistanceCurrentMoveMode()).toBe(1);
+
+        expect(turnState.resolveStandAttempt('success')).toBeTrue();
+
+        expect(turnState.moveMode()).toBe('run');
+        expect(turnState.standAttempts()).toBe(1);
+        expect(turnState.movementCapacityCurrentMoveMode()).toBe(1);
+        expect(turnState.maxDistanceCurrentMoveMode()).toBe(0);
+        expect(offersRun()).toBeTrue();
+
+        turnState.moveMode.set(null);
+
+        expect(offersRun()).toBeTrue();
+    });
+
+    it('does not grant TW Running Minimum Movement without usable Walking MP', () => {
+        const forceUnit = createForceUnitHarness({
+            committedDestroyedLocations: ['LL'],
+            rulesId: 'tw',
+            walk: 0,
+            run: 0,
+        });
+
+        expect((forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 0, run: 0 }));
+        expect(forceUnit.rules.isMotiveModeAvailable('run')).toBeFalse();
+        expect(forceUnit.getAvailableMotiveModes(false).some(option => option.mode === 'run')).toBeFalse();
+        expect(forceUnit.rules.getEffectiveMaxDistanceForMoveMode('run', forceUnit.turnState())).toBe(0);
+    });
+
+    it('requires heat-adjusted Walking MP for ground movement and standing', () => {
+        const forceUnit = createForceUnitHarness({ walk: 5, run: 8 });
+        const turnState = forceUnit.turnState();
+        forceUnit.setCondition('prone', true);
+
+        forceUnit.setHeatData({ current: 24, previous: 24 });
+
+        expect((forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+        expect(forceUnit.rules.isMotiveModeAvailable('walk')).toBeTrue();
+        expect(forceUnit.rules.isMotiveModeAvailable('run')).toBeTrue();
+        expect(turnState.canStandUp()).toBeTrue();
+
+        forceUnit.setHeatData({ current: 30, previous: 30 });
 
-        expect(offersRun(coreBiped)).toBeTrue();
-        expect(offersRun(twBiped)).toBeFalse();
-        expect(offersRun(twTripod)).toBeFalse();
-        expect(offersRun(twQuadWithOneDestroyedLeg)).toBeTrue();
-        expect(offersRun(twQuadWithTwoDestroyedLegs)).toBeFalse();
+        expect((forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 0, run: 0 }));
+        expect(forceUnit.rules.isMotiveModeAvailable('walk')).toBeFalse();
+        expect(forceUnit.rules.isMotiveModeAvailable('run')).toBeFalse();
+        expect(forceUnit.getAvailableMotiveModes(false).map(option => option.mode))
+            .not.toContain('walk');
+        expect(forceUnit.getAvailableMotiveModes(false).map(option => option.mode))
+            .not.toContain('run');
+        expect(turnState.canStandUp()).toBeFalse();
+    });
+
+    it('does not offer Walk when leg destruction leaves no ground MP or facing change', () => {
+        const scenarios = [
+            {
+                context: 'Core biped with both legs destroyed',
+                internalLocations: ['LL', 'RL'],
+                committedDestroyedLocations: ['LL', 'RL'],
+                rulesId: 'core2026' as const,
+            },
+            {
+                context: 'Core quad with all legs destroyed',
+                internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+                committedDestroyedLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+                rulesId: 'core2026' as const,
+            },
+            {
+                context: 'TW biped with both legs destroyed',
+                internalLocations: ['LL', 'RL'],
+                committedDestroyedLocations: ['LL', 'RL'],
+                rulesId: 'tw' as const,
+            },
+            {
+                context: 'TW quad with three legs destroyed',
+                internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+                committedDestroyedLocations: ['RLL', 'FLL', 'RRL'],
+                rulesId: 'tw' as const,
+            },
+        ];
+
+        for (const scenario of scenarios) {
+            const forceUnit = createForceUnitHarness(scenario);
+
+            expect((forceUnit.rules as MekRules).movementState()?.walk)
+                .withContext(scenario.context)
+                .toBe(0);
+            expect(forceUnit.rules.isMotiveModeAvailable('walk'))
+                .withContext(scenario.context)
+                .toBeFalse();
+            expect(forceUnit.getAvailableMotiveModes(false).some(option => option.mode === 'walk'))
+                .withContext(scenario.context)
+                .toBeFalse();
+        }
+    });
+
+    it('colors Run for the current action rather than a potential destroyed-leg check', () => {
+        const forceUnit = createForceUnitHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL', 'RRL'],
+            walk: 4,
+            run: 6,
+        });
+        const turnState = forceUnit.turnState();
+        const runOption = () => forceUnit.getAvailableMotiveModes(false)
+            .find(option => option.mode === 'run');
+        turnState.moveMode.set('run');
+        turnState.moveDistance.set(0);
+        forceUnit.setCondition('prone', true);
+
+        expect(runOption()?.psr).toBeFalse();
+
+        forceUnit.setCondition('prone', false);
+        turnState.moveDistance.set(1);
+
+        expect(runOption()?.psr).toBeTrue();
+    });
+
+    it('treats two destroyed Core Quad legs as a hip hit when using Running MP', () => {
+        const forceUnit = createForceUnitHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL'],
+            walk: 4,
+            run: 6,
+        });
+        const turnState = forceUnit.turnState();
+        turnState.moveMode.set('run');
+        turnState.moveDistance.set(0);
+
+        const runOption = forceUnit.getAvailableMotiveModes(false)
+            .find(option => option.mode === 'run');
+
+        expect(runOption?.psr).toBeFalse();
+        expect(turnState.getPSRChecks()).not.toContain(jasmine.objectContaining({
+            reason: 'Running with damaged hip',
+        }));
+
+        turnState.moveDistance.set(1);
+
+        expect(forceUnit.getAvailableMotiveModes(false).find(option => option.mode === 'run')?.psr).toBeTrue();
+        expect(turnState.getPSRChecks()).toContain(jasmine.objectContaining({
+            reason: 'Running with damaged hip',
+        }));
+    });
+
+    it('keeps TW Run colored when running itself triggers a zero-hex damage PSR', () => {
+        const forceUnit = createForceUnitHarness({
+            critSlots: [{ ...crit('Gyro'), loc: 'CT' }],
+            rulesId: 'tw',
+        });
+        const turnState = forceUnit.turnState();
+        turnState.moveMode.set('run');
+        turnState.moveDistance.set(0);
+
+        const runOption = forceUnit.getAvailableMotiveModes(false)
+            .find(option => option.mode === 'run');
+
+        expect(runOption?.psr).toBeTrue();
+    });
+
+    it('marks TW destroyed-leg Minimum Movement as a zero-hex Run PSR', () => {
+        const biped = createForceUnitHarness({
+            committedDestroyedLocations: ['LL'],
+            rulesId: 'tw',
+        });
+        const bipedTurnState = biped.turnState();
+        bipedTurnState.moveMode.set('run');
+        bipedTurnState.moveDistance.set(0);
+
+        expect((biped.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 1, run: 0 }));
+        expect(biped.rules.isMotiveModeAvailable('run', bipedTurnState)).toBeTrue();
+        expect(biped.rules.getCommittedDamageMovementModePSRCheck('run', 0))
+            .toEqual(jasmine.objectContaining({ loc: 'LL', reason: 'Running with damaged leg' }));
+        expect(biped.getAvailableMotiveModes(false).find(option => option.mode === 'run')?.psr).toBeTrue();
+
+        const oneDestroyedLegQuad = createRulesHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL'],
+            rulesId: 'tw',
+        });
+        const twoDestroyedLegQuad = createRulesHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL'],
+            rulesId: 'tw',
+        });
+
+        expect(oneDestroyedLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+        expect(twoDestroyedLegQuad.isMotiveModeAvailable('run')).toBeTrue();
+        expect(twoDestroyedLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)?.reason)
+            .toBe('Running with damaged leg');
     });
 
     it('never lets destroyed-leg movement increase a slower biped', () => {
@@ -2665,10 +3028,50 @@ describe('MekRules', () => {
             internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
             committedDestroyedLocations: ['RLL', 'FLL'],
         });
+        const threeLegQuad = createRulesHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL', 'RRL'],
+        });
 
         expect(oneLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)).toBeNull();
-        expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.reason).toBe('Running with damaged leg');
+        expect(oneLegQuad.getCommittedDamageMovementModePSRCheck('jump', 1)).toBeNull();
+        expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+        expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.reason).toBe('Running with damaged hip');
+        expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.kind)
+            .toBe('damaged-hip-movement');
+        expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('jump', 0)?.reason).toBe('Jumping with damaged hip');
         expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.loc).toBeUndefined();
+        expect(threeLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+        expect(threeLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.reason)
+            .toBe('Running with damaged leg');
+        expect(threeLegQuad.getCommittedDamageMovementModePSRCheck('jump', 0)?.reason)
+            .toBe('Jumping with damaged leg');
+
+        const damagedGyro = createRulesHarness({
+            critSlots: [{ ...crit('Gyro'), loc: 'CT' }],
+        });
+        const damagedHip = createRulesHarness({
+            critSlots: [{ ...crit('Hip'), loc: 'LL' }],
+        });
+
+        expect(damagedGyro.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+        expect(damagedHip.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+
+        const twDamagedGyro = createRulesHarness({
+            critSlots: [{ ...crit('Gyro'), loc: 'CT' }],
+            rulesId: 'tw',
+        });
+        const twDamagedHip = createRulesHarness({
+            critSlots: [{ ...crit('Hip'), loc: 'LL' }],
+            rulesId: 'tw',
+        });
+
+        expect(twDamagedGyro.getCommittedDamageMovementModePSRCheck('run', 0)?.reason)
+            .toBe('Running with damaged gyro');
+        expect(twDamagedHip.getCommittedDamageMovementModePSRCheck('run', 0)?.reason)
+            .toBe('Running with damaged hip');
+        expect(twDamagedHip.getCommittedDamageMovementModePSRCheck('run', 0)?.kind)
+            .toBe('damaged-hip-movement');
     });
 
     it('requires a jump PSR for foot damage without requiring a run PSR', () => {
@@ -2678,6 +3081,8 @@ describe('MekRules', () => {
 
         expect(rules.getCommittedDamageMovementModePSRCheck('jump', 0)?.reason)
             .toBe('Jumping with damaged leg actuator');
+        expect(rules.getCommittedDamageMovementModePSRCheck('jump', 0)?.kind)
+            .toBe('damaged-leg-actuator-movement');
         expect(rules.getCommittedDamageMovementModePSRCheck('run', 1)).toBeNull();
     });
 
diff --git a/src/app/models/rules/mek-rules.ts b/src/app/models/rules/mek-rules.ts
index 8ac00b2b1..89b4a7011 100644
--- a/src/app/models/rules/mek-rules.ts
+++ b/src/app/models/rules/mek-rules.ts
@@ -7,7 +7,7 @@ import type { CBTForceUnit, EquipmentAction } from '../cbt-force-unit.model';
 import type { CrewMember, SkillType } from '../crew-member.model';
 import type { MountedEquipment } from '../mounted-equipment.model';
 import type { CriticalSlot, RuleCheckOutcome } from '../force-serialization';
-import { CrewStateControlDefinition, CrewStateDefinition, crewStateDefinitions, NARC_CONDITION_COLOR, sortPSRModifiers, UnitConditionControl, unitConditionControls, UnitTypeRulesBase, type ChargeDamage, type LocationConditionControl, type PSRCheck, type UnitHeatSource, type UnitModifierBreakdownEntry, type UnitRuleModifier } from './unit-type-rules';
+import { CrewStateControlDefinition, CrewStateDefinition, crewStateDefinitions, NARC_CONDITION_COLOR, PSRCheckKind, sortPSRModifiers, UnitConditionControl, unitConditionControls, UnitTypeRulesBase, type ChargeDamage, type LocationConditionControl, type PSRCheck, type UnitHeatSource, type UnitModifierBreakdownEntry, type UnitRuleModifier } from './unit-type-rules';
 import type { EquipmentStatus, EquipmentStatusFacts } from '../equipment-status.model';
 import type { TurnState } from '../turn-state.model';
 import { type HeatScaleEntry, HeatManagement, getHeatEffects } from './heat-management';
@@ -21,6 +21,7 @@ import {
     LEG_LOCATIONS,
     MEK_TORSO_LOCATIONS,
     QUAD_LEG_LOCATIONS,
+    type MekConfig,
 } from '../entity/types';
 import { resolveShieldProfile, type ShieldProfile } from '../entity/utils/physical-weapon';
 import type { Equipment } from '../equipment.model';
@@ -32,6 +33,11 @@ import { uuidv7 } from '../../utils/uuid.util';
 
 type ArmLocation = 'LA' | 'RA';
 
+const LEG_DAMAGE_MOVEMENT_CRITICAL_NAMES: Partial<Record<PSRCheckKind, readonly string[]>> = {
+    ['damaged-leg-actuator-movement']: ['Leg', 'Foot', 'Hip'],
+    ['damaged-hip-movement']: ['Hip'],
+};
+
 interface MekArmStatus {
     destroyedShoulder: boolean;
     destroyedHand: boolean;
@@ -196,7 +202,18 @@ export class MekRules extends UnitTypeRulesBase {
 
         const config = inferMekConfigFromLocations(internalLocations.keys());
         const limbLocations = getMekLimbLocations(config);
-        return limbLocations.every(loc => !internalLocations.has(loc) || this.unit.isInternalLocCommittedDestroyed(loc));
+        const isDestroyedOrMissing = (loc: string) =>
+            !internalLocations.has(loc) || this.unit.isInternalLocCommittedDestroyed(loc);
+        if (config !== 'Tripod') return limbLocations.every(isDestroyedOrMissing);
+
+        const armsDestroyedOrMissing = limbLocations
+        .filter(loc => !isMekLegLocation(config, loc))
+        .every(isDestroyedOrMissing);
+        // For Tripod is enough 2 of the 3 legs to consider that all legs are destroyed, as if they where bipeds
+        const destroyedOrMissingLegs = getMekLegLocations(config)
+            .filter(isDestroyedOrMissing)
+            .length;
+        return armsDestroyedOrMissing && destroyedOrMissingLegs >= 2;
     }
 
     protected isDestroyedOrDestroyingCrit(slot: CriticalSlot): boolean {
@@ -322,6 +339,25 @@ export class MekRules extends UnitTypeRulesBase {
         }
     }
 
+    protected readonly currentLegState = computed(() => {
+        const internalLocations = this.unit.locations?.internal;
+        const config = inferMekConfigFromLocations(internalLocations?.keys() ?? []);
+        const legs = getMekLegLocations(config);
+        const destroyedLegs = legs.filter(loc =>
+            internalLocations?.has(loc) && this.unit.isInternalLocDestroyed(loc)
+        );
+        const hasIntactLeg = legs.some(loc =>
+            internalLocations?.has(loc) && !this.unit.isInternalLocDestroyed(loc)
+        );
+        const allLegsIntact = legs.every(loc =>
+            internalLocations?.has(loc) && !this.unit.isInternalLocDestroyed(loc)
+        );
+        const destroyedArms = ['LA', 'RA'].filter(loc =>
+            internalLocations?.has(loc) && this.unit.isInternalLocDestroyed(loc)
+        );
+        return { config, destroyedLegs, destroyedArms, hasIntactLeg, allLegsIntact };
+    });
+
     // ── PSR ──────────────────────────────────────────────────────────────────
 
     override readonly autoFall = computed<boolean>(() => {
@@ -384,7 +420,8 @@ export class MekRules extends UnitTypeRulesBase {
                 });
             }
             const movementCheck = turnState.applyMovePSR()
-                ? this.getCommittedDamageMovementModePSRCheck(turnState.moveMode(), turnState.moveDistance())
+                && !this.isMovementPSRFoldedIntoStandAttempt(turnState)
+                ? this.getCommittedDamageMovementModePSRCheck(turnState.effectiveMoveMode(), turnState.moveDistance())
                 : null;
             checks.push(...this.getLegActuatorPSRChecks(turnState, movementCheck));
             const gyroHits = (psr.gyroHit || 0);
@@ -459,32 +496,37 @@ export class MekRules extends UnitTypeRulesBase {
         return Array.from(checksByLeg.values());
     }
 
+    protected isLegDamageMovementPSRCheck(
+        check: PSRCheck | null,
+    ): check is PSRCheck & { kind: PSRCheckKind } {
+        return check?.kind !== undefined
+            && LEG_DAMAGE_MOVEMENT_CRITICAL_NAMES[check.kind] !== undefined;
+    }
+
     private getLegActuatorMovementPSRChecks(check: PSRCheck): PSRCheck[] | null {
-        let includesSlot: (slot: CriticalSlot) => boolean;
-        if (check.reason === 'Jumping with damaged leg actuator') {
-            includesSlot = slot => this.isNamedCrit(slot, 'Leg')
-                || this.isNamedCrit(slot, 'Foot')
-                || this.isNamedCrit(slot, 'Hip');
-        } else if (check.reason === 'Running with damaged hip') {
-            includesSlot = slot => this.isNamedCrit(slot, 'Hip');
-        } else {
-            return null;
-        }
+        const criticalNames = check.kind === undefined
+            ? undefined
+            : LEG_DAMAGE_MOVEMENT_CRITICAL_NAMES[check.kind];
+        if (!criticalNames) return null;
 
         const reasonsByLeg = new Map<string, Set<string>>();
         this.unit.getCritSlots().forEach(slot => {
-            if (!slot.loc || !LEG_LOCATIONS.has(slot.loc) || !this.isCritUnavailable(slot) || !includesSlot(slot)) return;
+            if (!slot.loc
+                || !LEG_LOCATIONS.has(slot.loc)
+                || !this.isCritUnavailable(slot)
+                || !criticalNames.some(name => this.isNamedCrit(slot, name))) return;
             const reasons = reasonsByLeg.get(slot.loc) ?? new Set<string>();
             if (this.isNamedCrit(slot, 'Hip')) reasons.add('Hip hit');
             else if (this.isNamedCrit(slot, 'Foot')) reasons.add('Foot hit');
             else reasons.add('Leg Actuator hit');
             reasonsByLeg.set(slot.loc, reasons);
         });
-        return Array.from(reasonsByLeg, ([loc, reasons]) => ({
+        const movementChecks = Array.from(reasonsByLeg, ([loc, reasons]) => ({
             ...check,
             loc,
             reason: this.formatLegActuatorPSRReasons(...reasons),
         }));
+        return movementChecks.length > 0 ? movementChecks : null;
     }
 
     private formatLegActuatorPSRReasons(...reasons: string[]): string {
@@ -528,7 +570,10 @@ export class MekRules extends UnitTypeRulesBase {
     override getCommittedDamageMovementModePSRCheck(moveMode: MotiveModes | null, moveDistance?: number | null): PSRCheck | null {
         if (moveMode !== 'run' && moveMode !== 'jump') return null;
         if (moveDistance === null) return null;
-        if (moveMode === 'run' && moveDistance !== undefined && moveDistance < 1) return null;
+        if (moveMode === 'run'
+            && moveDistance !== undefined
+            && moveDistance < 1
+            && this.runningDamageCheckRequiresHexMovement()) return null;
 
         const critSlots = this.unit.getCritSlots();
         const damagedGyro = critSlots.find(slot => this.isCritUnavailable(slot) && this.isNamedCrit(slot, 'Gyro'));
@@ -555,12 +600,23 @@ export class MekRules extends UnitTypeRulesBase {
         const isQuadruped = QUAD_LEG_LOCATIONS.some(loc => internalLocations.has(loc));
         const destroyedLegsCount = this.systemsStatus().destroyedLegsCount;
         const damagedLegRequiresCheck = this.damagedLegRequiresMovementCheck(isQuadruped, destroyedLegsCount);
+        const destroyedLegsApplyHipCheck = this.destroyedLegsApplyHipMovementCheck(
+            isQuadruped,
+            destroyedLegsCount,
+        );
 
         if (moveMode === 'jump') {
             if (damagedGyro) {
                 const check = this.damagedGyroMovementPSRCheck(moveMode);
                 return check ? this.withPSRLocation(check, damagedGyro.loc) : null;
             }
+            if (destroyedLegsApplyHipCheck) {
+                return {
+                    fallCheck: 0,
+                    pilotCheck: 0,
+                    reason: 'Jumping with damaged hip',
+                };
+            }
             if (hasDamagedLeg && damagedLegRequiresCheck) {
                 return {
                     fallCheck: 0,
@@ -573,6 +629,7 @@ export class MekRules extends UnitTypeRulesBase {
                 return {
                     fallCheck: 0,
                     pilotCheck: 0,
+                    kind: 'damaged-leg-actuator-movement',
                     reason: 'Jumping with damaged leg actuator'
                 };
             }
@@ -583,7 +640,17 @@ export class MekRules extends UnitTypeRulesBase {
             const gyroMovementCheck = this.damagedGyroMovementPSRCheck(moveMode);
             if (gyroMovementCheck) return this.withPSRLocation(gyroMovementCheck, damagedGyro.loc);
         }
-        if (this.runningWithDestroyedLegRequiresCheck() && hasDamagedLeg && damagedLegRequiresCheck) {
+        if (destroyedLegsApplyHipCheck) {
+            return {
+                fallCheck: 0,
+                pilotCheck: 0,
+                kind: 'damaged-hip-movement',
+                reason: 'Running with damaged hip',
+            };
+        }
+        if (this.runningWithDestroyedLegRequiresCheck()
+            && hasDamagedLeg
+            && damagedLegRequiresCheck) {
             return {
                 fallCheck: 0,
                 pilotCheck: 0,
@@ -591,20 +658,32 @@ export class MekRules extends UnitTypeRulesBase {
                 reason: 'Running with damaged leg'
             };
         }
-        if (!hasDamagedLegActuators) return null;
-
-        const hasDamagedHip = critSlots.some(slot => {
-            if (!slot.name || !slot.loc || !this.isCritUnavailable(slot)) return false;
-            if (!LEG_LOCATIONS.has(slot.loc)) return false;
-            return this.isNamedCrit(slot, 'Hip');
-        });
-        if (!hasDamagedHip) return null;
-
-        return {
-            fallCheck: 0,
-            pilotCheck: 0,
-            reason: 'Running with damaged hip'
-        };
+        if (hasDamagedLegActuators) {
+            const hasDamagedHip = critSlots.some(slot => {
+                if (!slot.name || !slot.loc || !this.isCritUnavailable(slot)) return false;
+                if (!LEG_LOCATIONS.has(slot.loc)) return false;
+                return this.isNamedCrit(slot, 'Hip');
+            });
+            if (hasDamagedHip) {
+                return {
+                    fallCheck: 0,
+                    pilotCheck: 0,
+                    kind: 'damaged-hip-movement',
+                    reason: 'Running with damaged hip'
+                };
+            }
+        }
+        if (this.runningMinimumMovementWithDestroyedLegRequiresCheck()
+            && hasDamagedLeg
+            && damagedLegRequiresCheck) {
+            return {
+                fallCheck: 0,
+                pilotCheck: 0,
+                ...(damagedLegLocation && { loc: damagedLegLocation }),
+                reason: 'Running with damaged leg'
+            };
+        }
+        return null;
     }
 
     protected damagedGyroMovementPSRCheck(moveMode: 'run' | 'jump'): PSRCheck | null {
@@ -632,6 +711,18 @@ export class MekRules extends UnitTypeRulesBase {
         return true;
     }
 
+    protected runningMinimumMovementWithDestroyedLegRequiresCheck(): boolean {
+        return false;
+    }
+
+    protected runningDamageCheckRequiresHexMovement(): boolean {
+        return true;
+    }
+
+    protected destroyedLegsApplyHipMovementCheck(isQuadruped: boolean, destroyedLegsCount: number): boolean {
+        return isQuadruped && destroyedLegsCount === 2;
+    }
+
     override evaluateLegDestroyed(location: string, hits: number): void {
         if (!LEG_LOCATIONS.has(location)) return;
         const turnState = this.unit.turnState();
@@ -727,7 +818,7 @@ export class MekRules extends UnitTypeRulesBase {
     }
 
     private computeMovementHeat(turnState: TurnState): number {
-        const moveMode = turnState.moveMode();
+        const moveMode = turnState.effectiveMoveMode();
         const hasXXLEngine = this.hasXXLEngine();
         const superCooledMyomerActive = this.hasActiveSuperCooledMyomer();
         if (moveMode === 'stationary') {
@@ -1022,23 +1113,18 @@ export class MekRules extends UnitTypeRulesBase {
         let preExisting = 0;
         const modifiers: PSRCheck[] = [];
 
-        const internalLocations = this.unit.locations?.internal;
-        const config = inferMekConfigFromLocations(internalLocations?.keys() ?? []);
-        let undamagedLegs = true;
+        const { config, destroyedLegs } = this.currentLegState();
+        const undamagedLegs = destroyedLegs.length === 0;
         // Calculate pre-existing leg destruction modifiers. If a leg is gone, is gone.
-        for (const loc of getMekLegLocations(config)) {
-            if (!internalLocations?.has(loc)) continue;
-            if (this.unit.isInternalLocDestroyed(loc)) {
-                undamagedLegs = false;
-                ignoreLeg.add(loc); // Track destroyed legs, we ignore further modifiers on that leg
-                const modifier = this.destroyedLegPSR(config === 'Quad').pilotCheck;
-                preExisting += modifier;
-                modifiers.push({
-                    pilotCheck: modifier,
-                    loc,
-                    reason: 'Leg Destroyed',
-                });
-            }
+        for (const loc of destroyedLegs) {
+            ignoreLeg.add(loc); // Track destroyed legs, we ignore further modifiers on that leg
+            const modifier = this.destroyedLegPSR(config === 'Quad').pilotCheck;
+            preExisting += modifier;
+            modifiers.push({
+                pilotCheck: modifier,
+                loc,
+                reason: 'Leg Destroyed',
+            });
         }
         if (undamagedLegs) {
             if (config === 'Tripod') {
@@ -1231,14 +1317,89 @@ export class MekRules extends UnitTypeRulesBase {
         return null;
     }
 
-    override isMotiveModeAvailable(moveMode: MotiveModes): boolean {
-        return moveMode !== 'run' || this.computeBaseMovementProfile()?.runDisabled !== true;
+    override isMotiveModeAvailable(moveMode: MotiveModes, turnState?: TurnState): boolean {
+        const movement = this.movementState();
+        if (moveMode === 'walk') return (movement?.walk ?? 0) > 0;
+        if (moveMode === 'run') {
+            return (movement?.run ?? 0) > 0 || this.getRunningMinimumMovementDistance() > 0;
+        }
+        return true;
+    }
+
+    protected getRunningMinimumMovementDistance(): number {
+        return 0;
+    }
+
+    protected maximumDestroyedLegsForStanding(config: MekConfig): number {
+        return config === 'Quad' ? 3 : 1;
+    }
+
+    protected destroyedLegStandAttemptLimit(_config: MekConfig, _destroyedLegs: number): number | null {
+        return null;
+    }
+
+    protected isMovementPSRFoldedIntoStandAttempt(_turnState: TurnState): boolean {
+        return false;
+    }
+
+    protected destroyedLegStandAttemptRequiresRunning(config: MekConfig, destroyedLegs: number): boolean {
+        return destroyedLegs === (config === 'Quad' ? 3 : 1);
+    }
+
+    override canStandUp(turnState: TurnState): boolean {
+        if (turnState.carefulStand()) return false;
+        if (!turnState.unitState.hasCondition('prone')) return false;
+        // Standing normally costs MP, and Minimum Movement can only reduce that
+        // cost when the Mek still has at least 1 usable Walking MP.
+        if ((this.movementState()?.walk ?? 0) < 1) return false;
+        const { config, destroyedLegs, destroyedArms, hasIntactLeg } = this.currentLegState();
+        if (!hasIntactLeg || destroyedLegs.length > this.maximumDestroyedLegsForStanding(config)) return false;
+        return config === 'Quad' || destroyedLegs.length !== 1 || destroyedArms.length !== 2;
+    }
+
+    override canStandWithoutPSR(_turnState: TurnState): boolean {
+        const { config, allLegsIntact } = this.currentLegState();
+        return config === 'Quad' && allLegsIntact;
+    }
+
+    override canCarefulStand(turnState: TurnState): boolean {
+        if (!this.supportsCarefulStand) return false;
+        if (!this.canStandUp(turnState)) return false;
+        const walkingMp = this.movementState()?.walk ?? 0;
+        const standAttemptMp = Math.max(0, turnState.standAttempts() ?? 0) * 2;
+        return walkingMp - standAttemptMp >= 3;
+    }
+
+    override getStandAttemptMovementMode(turnState: TurnState): MotiveModes | null {
+        const { config, destroyedLegs } = this.currentLegState();
+        if (this.destroyedLegStandAttemptRequiresRunning(config, destroyedLegs.length)
+            || this.movementState()?.walk === 1) {
+            return 'run';
+        }
+        return turnState.moveMode() === 'run' ? 'run' : 'walk';
+    }
+
+    override getStandAttemptLimit(_turnState: TurnState): number | null {
+        const { config, destroyedLegs } = this.currentLegState();
+        return this.destroyedLegStandAttemptLimit(config, destroyedLegs.length);
+    }
+
+    override getMovementPointsSpent(turnState: TurnState): number {
+        const standAttemptMp = Math.max(0, turnState.standAttempts() ?? 0) * 2;
+        if (!turnState.carefulStand()) return standAttemptMp;
+
+        const moveMode = turnState.moveMode();
+        const movementCapacity = moveMode === null
+            ? 0
+            : this.getEffectiveMaxDistanceForMoveMode(moveMode, turnState) ?? 0;
+        return Math.max(standAttemptMp, movementCapacity);
     }
 
     override getEffectiveMaxDistanceForMoveMode(moveMode: MotiveModes, turnState: TurnState): number | null {
         if (moveMode !== 'run') return this.getMaxDistanceForMoveMode(moveMode);
         const movement = this.movementState();
-        if (!movement || movement.run === 0) return 0;
+        if (!movement) return 0;
+        if (movement.run === 0) return this.getRunningMinimumMovementDistance();
 
         const runValueCoeff = 1.5 + this.unit.getRunMovementMultiplierBonus(turnState);
         const armorModifierOnRun = (this.unit.getUnit().armorType === 'Hardened') ? -1 : 0;
diff --git a/src/app/models/rules/tw-rules.spec.ts b/src/app/models/rules/tw-rules.spec.ts
index cf3cf57a1..42204f7a1 100644
--- a/src/app/models/rules/tw-rules.spec.ts
+++ b/src/app/models/rules/tw-rules.spec.ts
@@ -172,6 +172,7 @@ describe('TWMekRules', () => {
         expect(turnState.getPSRChecks()).toEqual([jasmine.objectContaining({
             fallCheck: 0,
             pilotCheck: 0,
+            kind: 'damaged-leg-actuator-movement',
             reason: 'Jumping with damaged leg actuator',
         })]);
         expect(turnState.PSRRollsCount()).toBe(1);
@@ -183,6 +184,26 @@ describe('TWMekRules', () => {
         }));
     });
 
+    it('classifies movement checks independently from their display reason', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('lower-leg', 'Lower Leg Actuator', 'LL'),
+        ]);
+        const turnState = forceUnit.turnState();
+        turnState.moveMode.set('jump');
+        turnState.moveDistance.set(1);
+        spyOn(forceUnit.rules, 'getCommittedDamageMovementModePSRCheck').and.returnValue({
+            fallCheck: 0,
+            pilotCheck: 0,
+            kind: 'damaged-leg-actuator-movement',
+            reason: 'Localized movement check label',
+        });
+
+        expect(turnState.getPSRChecks()).toEqual([jasmine.objectContaining({
+            kind: 'damaged-leg-actuator-movement',
+            reason: 'Localized movement check label',
+        })]);
+    });
+
     it('keeps current-hit and committed-movement actuator PSRs independent in TW', () => {
         const forceUnit = createTWForceUnit([
             legActuatorCrit('lower-leg', 'Lower Leg Actuator', 'LL'),
diff --git a/src/app/models/rules/tw-rules.ts b/src/app/models/rules/tw-rules.ts
index 0d7b61fef..1f98cfb3b 100644
--- a/src/app/models/rules/tw-rules.ts
+++ b/src/app/models/rules/tw-rules.ts
@@ -12,7 +12,7 @@ import type { ChargeDamage, PSRCheck, UnitHeatSource } from './unit-type-rules';
 import type { CriticalSlot, SerializedC3NetworkGroup } from '../force-serialization';
 import type { CBTForceUnit } from '../cbt-force-unit.model';
 import { C3TaxCalculator } from '../c3-network.model';
-import { getMekLimbLocations, inferMekConfigFromLocations, LEG_LOCATIONS, MEK_SIDE_TORSO_LOCATIONS, MEK_TORSO_LOCATIONS } from '../entity/types';
+import { getMekLimbLocations, inferMekConfigFromLocations, LEG_LOCATIONS, MEK_SIDE_TORSO_LOCATIONS, MEK_TORSO_LOCATIONS, QUAD_LEG_LOCATIONS, type MekConfig } from '../entity/types';
 import type { TurnState } from '../turn-state.model';
 import type { Equipment } from '../equipment.model';
 
@@ -31,7 +31,7 @@ function calculateTWChargeDamage(
     maxBonusDamage = bonusDamage,
 ): ChargeDamage {
     const damagePerHex = unit.getUnit().tons / 10;
-    const moveMode = unit.turnState().moveMode();
+    const moveMode = unit.turnState().effectiveMoveMode();
     const movedHexes = Math.max(1, unit.turnState().moveDistance() ?? 0);
     const maxMovedHexes = Math.max(1, unit.getUnit().run);
     const ramPlates = unit.getInventory().filter(entry => entry.equipment?.hasFlag('F_RAM_PLATE'));
@@ -58,9 +58,31 @@ function calculateTWChargeDamage(
 
 export class TWMekRules extends MekRules {
     override readonly standingUpPSRModifier: number = 0;
+    override readonly supportsCarefulStand: boolean = true;
     protected override get shieldBashPunchBonusEnabled(): boolean { return false; }
     protected override get standaloneShieldDamageEnabled(): boolean { return true; }
 
+    /** If more legs are destroyed, the unit simply can't stand up at all */
+    protected override maximumDestroyedLegsForStanding(config: MekConfig): number {
+        return config === 'Quad' ? 2 : 1;
+    }
+
+    /** Limit how many attempts can be made to stand up */
+    protected override destroyedLegStandAttemptLimit(config: MekConfig, destroyedLegs: number): number | null {
+        return destroyedLegs === (config === 'Quad' ? 2 : 1) ? 1 : null;
+    }
+
+    protected override isMovementPSRFoldedIntoStandAttempt(turnState: TurnState): boolean {
+        const { config, destroyedLegs } = this.currentLegState();
+        return (turnState.standAttempts() ?? 0) > 0
+            && (turnState.moveDistance() ?? 0) === 0
+            && destroyedLegs.length === (config === 'Quad' ? 2 : 1);
+    }
+
+    protected override destroyedLegStandAttemptRequiresRunning(config: MekConfig, destroyedLegs: number): boolean {
+        return destroyedLegs === (config === 'Quad' ? 2 : 1);
+    }
+
     override heatLifeSupportPilotHits(heat: number): number {
         if (!this.hasDamagedLifeSupport() || heat <= 0) return 0;
 
@@ -105,8 +127,7 @@ export class TWMekRules extends MekRules {
                 reason: 'Hip hit',
             });
         });
-        if (movementCheck?.reason === 'Jumping with damaged leg actuator'
-            || movementCheck?.reason === 'Running with damaged hip') {
+        if (this.isLegDamageMovementPSRCheck(movementCheck)) {
             checks.push(movementCheck);
         }
         return checks;
@@ -285,6 +306,27 @@ export class TWMekRules extends MekRules {
         return false;
     }
 
+    protected override runningMinimumMovementWithDestroyedLegRequiresCheck(): boolean {
+        return this.getRunningMinimumMovementDistance() > 0;
+    }
+
+    protected override runningDamageCheckRequiresHexMovement(): boolean {
+        return false;
+    }
+
+    protected override destroyedLegsApplyHipMovementCheck(_isQuadruped: boolean, _destroyedLegsCount: number): boolean {
+        return false;
+    }
+
+    protected override getRunningMinimumMovementDistance(): number {
+        const movement = this.movementState();
+        if (!movement || movement.walk < 1) return 0;
+        const systemsStatus = this.systemsStatus();
+        const isQuadruped = QUAD_LEG_LOCATIONS.some(loc => systemsStatus.internalLocations.has(loc));
+        const oneLeggedDestroyedCount = isQuadruped ? 2 : 1;
+        return systemsStatus.destroyedLegsCount === oneLeggedDestroyedCount ? 1 : 0;
+    }
+
     protected override applyLegDamageToMovement(
         walk: number,
         _unitRun: number,
diff --git a/src/app/models/rules/unit-type-rules.ts b/src/app/models/rules/unit-type-rules.ts
index e20604a75..bad9978e5 100644
--- a/src/app/models/rules/unit-type-rules.ts
+++ b/src/app/models/rules/unit-type-rules.ts
@@ -29,10 +29,13 @@ import type {
     UnitSystemStatusFacts,
 } from '../equipment-status.model';
 
+export type PSRCheckKind = 'damaged-leg-actuator-movement' | 'damaged-hip-movement';
+
 export interface PSRCheck {
     id?: string;
     fallCheck?: number;
     pilotCheck?: number;
+    kind?: PSRCheckKind;
     reason: string;
     modifierReason?: string;
     failureOutcome?: string;
@@ -255,6 +258,24 @@ export interface UnitTypeRules {
     /** Modifier applied specifically when this unit attempts to stand up. */
     readonly standingUpPSRModifier: number;
 
+    /** Whether this unit can stand up in its current turn state. */
+    canStandUp(turnState: TurnState): boolean;
+
+    /** Whether this unit's current configuration lets it stand without a control roll. */
+    canStandWithoutPSR(turnState: TurnState): boolean;
+
+    /** Whether this rules implementation supports the optional Careful Stand rule. */
+    readonly supportsCarefulStand: boolean;
+
+    /** Whether this unit has at least 3 available Walking MP for a careful stand attempt. */
+    canCarefulStand(turnState: TurnState): boolean;
+
+    /** Movement mode used to classify a stand attempt in the current turn state. */
+    getStandAttemptMovementMode(turnState: TurnState): MotiveModes | null;
+
+    /** Maximum stand attempts permitted this turn, or null when no special limit applies. */
+    getStandAttemptLimit(turnState: TurnState): number | null;
+
     /** Whether current phase damage causes automatic falling or equivalent unit-type failure. */
     readonly autoFall: Signal<boolean>;
 
@@ -369,11 +390,14 @@ export interface UnitTypeRules {
     /** Unit-type-specific effective movement distance for turn-state choices. */
     getEffectiveMaxDistanceForMoveMode(moveMode: MotiveModes, turnState: TurnState): number | null;
 
+    /** Movement points already spent on non-translational movement actions. */
+    getMovementPointsSpent(turnState: TurnState): number;
+
     /** Unit-type-specific minimum movement distance override. Return null to use 0. */
     getMinDistanceForMoveMode(moveMode: MotiveModes): number | null;
 
-    /** Unit-type-specific movement mode availability. */
-    isMotiveModeAvailable(moveMode: MotiveModes): boolean;
+    /** Unit-type-specific movement mode availability, optionally for the current turn context. */
+    isMotiveModeAvailable(moveMode: MotiveModes, turnState?: TurnState): boolean;
 
     /** Unit-type-specific attack movement modifier. */
     getAttackMovementModifier(moveMode: MotiveModes | null | undefined, airborne?: boolean): number;
@@ -650,6 +674,28 @@ export abstract class UnitTypeRulesBase implements UnitTypeRules {
         return [];
     }
 
+    canStandUp(_turnState: TurnState): boolean {
+        return false;
+    }
+
+    canStandWithoutPSR(_turnState: TurnState): boolean {
+        return false;
+    }
+
+    readonly supportsCarefulStand: boolean = false;
+
+    canCarefulStand(_turnState: TurnState): boolean {
+        return false;
+    }
+
+    getStandAttemptMovementMode(turnState: TurnState): MotiveModes | null {
+        return turnState.moveMode();
+    }
+
+    getStandAttemptLimit(_turnState: TurnState): number | null {
+        return null;
+    }
+
     reconcileRuleChecks(): void {
     }
 
@@ -706,11 +752,15 @@ export abstract class UnitTypeRulesBase implements UnitTypeRules {
         return this.getMaxDistanceForMoveMode(moveMode);
     }
 
+    getMovementPointsSpent(_turnState: TurnState): number {
+        return 0;
+    }
+
     getMinDistanceForMoveMode(_moveMode: MotiveModes): number | null {
         return null;
     }
 
-    isMotiveModeAvailable(_moveMode: MotiveModes): boolean {
+    isMotiveModeAvailable(_moveMode: MotiveModes, _turnState?: TurnState): boolean {
         return true;
     }
 
@@ -736,8 +786,8 @@ export abstract class UnitTypeRulesBase implements UnitTypeRules {
 
     getAttackModifierBreakdown(turnState: TurnState): UnitModifierBreakdownEntry[] {
         const entries: UnitModifierBreakdownEntry[] = [];
-        const moveMode = turnState.moveMode();
-        const movementModifier = this.getAttackMovementModifier(turnState.moveMode(), turnState.airborne() ?? false);
+        const moveMode = turnState.effectiveMoveMode();
+        const movementModifier = this.getAttackMovementModifier(moveMode, turnState.airborne() ?? false);
         if (movementModifier !== 0 && moveMode !== null) {
             entries.push({
                 label: getMotiveModeLabel(moveMode, this.unit.getUnit(), turnState.airborne() ?? false),
@@ -756,7 +806,7 @@ export abstract class UnitTypeRulesBase implements UnitTypeRules {
         if (this.unit.gameRules.supportsSkidding && turnState.unitState.hasCondition('skidding')) {
             entries.push({ label: 'Skidding', modifier: TN_SKIDDING_MODIFIER });
         }
-        const moveMode = turnState.moveMode();
+        const moveMode = turnState.effectiveMoveMode();
         if (moveMode === 'jump') {
             entries.push({ label: 'Jumped', modifier: TN_AIRBORNE_MOVE_TYPE_MODIFIER });
         } else if (turnState.airborne() === true) {
@@ -802,7 +852,7 @@ export abstract class UnitTypeRulesBase implements UnitTypeRules {
 
     protected computeChargeDamage(bonusDamage = 0, maxBonusDamage = bonusDamage): ChargeDamage {
         const damagePerTMM = this.unit.getUnit().tons / 5;
-        const moveMode = this.unit.turnState().moveMode();
+        const moveMode = this.unit.turnState().effectiveMoveMode();
         const ramPlates = this.unit.getInventory().filter(entry => entry.equipment?.hasFlag('F_RAM_PLATE'));
         const hasRamPlate = ramPlates.length > 0;
         const hasWorkingRamPlate = ramPlates.some(entry => this.unit.isEquipmentOperational(entry));
diff --git a/src/app/models/rules/vehicle-rules.spec.ts b/src/app/models/rules/vehicle-rules.spec.ts
index 2d3bf1567..8dc73e0b7 100644
--- a/src/app/models/rules/vehicle-rules.spec.ts
+++ b/src/app/models/rules/vehicle-rules.spec.ts
@@ -169,6 +169,7 @@ function createRulesHarness(options: {
         gunnerySkill: () => options.gunnery ?? 4,
         turnState: () => ({
             moveMode: () => options.moveMode ?? null,
+            effectiveMoveMode: () => options.moveMode ?? null,
             moveDistance: () => options.moveDistance ?? 0,
             spotting: () => false,
             getAttackMovementModifier: () => rules.getAttackMovementModifier(options.moveMode ?? null),
diff --git a/src/app/models/turn-state.model.spec.ts b/src/app/models/turn-state.model.spec.ts
index b3c2025c3..971f18093 100644
--- a/src/app/models/turn-state.model.spec.ts
+++ b/src/app/models/turn-state.model.spec.ts
@@ -28,6 +28,7 @@ interface TurnStateHarnessOptions {
     internalLocations?: string[];
     unit?: Partial<Unit>;
     destroyed?: boolean;
+    immobile?: boolean;
     prone?: boolean;
     shutdown?: boolean;
     skidding?: boolean;
@@ -93,7 +94,7 @@ function createTurnStateHarness(options: TurnStateHarnessOptions = {}): TurnStat
         isLoaded: () => true,
         destroyed: options.destroyed ?? false,
         shutdown: options.shutdown ?? false,
-        getCondition: () => false,
+        getCondition: (condition: string) => condition === 'immobile' && (options.immobile ?? false),
         getCrewMembers: () => [{ getState: () => 'healthy' }],
         getCritSlots: () => critSlots(),
         getInventory: () => inventory(),
@@ -125,6 +126,10 @@ function createTurnStateHarness(options: TurnStateHarnessOptions = {}): TurnStat
         },
         setCondition,
         getUnit: () => ({ type: 'Mek', comp: [], ...options.unit } as Unit),
+        getAvailableMotiveModes: () => [
+            { mode: 'stationary' as const, label: 'Stationary' },
+            { mode: 'walk' as const, label: 'Walk' },
+        ],
         getHeight: () => getUnitHeight(
             { type: 'Mek', tons: 0, ...options.unit } as Pick<Unit, 'type' | 'tons'>,
             options.prone ?? false,
@@ -139,6 +144,7 @@ function createTurnStateHarness(options: TurnStateHarnessOptions = {}): TurnStat
         hasUnconsolidatedLocations: computed(() => false),
         hasUnconsolidatedInventory: computed(() => false),
         hasCondition: (state: string) => {
+            if (state === 'immobile') return options.immobile ?? false;
             if (state === 'prone') return options.prone ?? false;
             if (state === 'skidding') return options.skidding ?? false;
             return false;
@@ -358,6 +364,33 @@ describe('TurnState', () => {
             expect(restored.serialize()).toEqual({ standAttempts: 0 });
         });
 
+        it('round-trips a careful stand and clears it with an empty update', () => {
+            const { turnState } = createTurnStateHarness({ rulesId: 'tw' });
+            turnState.carefulStand.set(true);
+
+            expect(turnState.serialize()).toEqual({ carefulStand: true });
+
+            const { turnState: restored } = createTurnStateHarness({ rulesId: 'tw' });
+            restored.update(turnState.serialize());
+
+            expect(restored.carefulStand()).toBeTrue();
+            expect(restored.serialize()).toEqual({ carefulStand: true });
+
+            restored.update(undefined);
+
+            expect(restored.carefulStand()).toBeFalse();
+            expect(restored.serialize()).toBeUndefined();
+        });
+
+        it('discards careful-stand state under Core rules', () => {
+            const { turnState } = createTurnStateHarness({ rulesId: 'core2026' });
+
+            turnState.update({ carefulStand: true });
+
+            expect(turnState.carefulStand()).toBeFalse();
+            expect(turnState.serialize()).toBeUndefined();
+        });
+
         it('omits no cover and round-trips active cover', () => {
             const { turnState } = createTurnStateHarness();
 
@@ -582,6 +615,101 @@ describe('TurnState', () => {
 
             expect(turnState.moveDistance()).toBe(8);
         });
+
+        it('keeps the movement-distance range editable while prone in either ruleset', () => {
+            for (const rulesId of ['core2026', 'tw'] as const) {
+                const { turnState } = createTurnStateHarness({
+                    prone: true,
+                    rulesId,
+                    unit: { walk: 4, walk2: 4, run: 6, run2: 6 },
+                });
+                turnState.moveMode.set('walk');
+                turnState.moveDistance.set(1);
+
+                expect(turnState.movementCapacityCurrentMoveMode()).withContext(rulesId).toBe(4);
+                expect(turnState.maxDistanceCurrentMoveMode()).withContext(rulesId).toBe(4);
+
+                turnState.clampMoveDistanceToCurrentModeRange();
+
+                expect(turnState.moveDistance()).withContext(rulesId).toBe(1);
+            }
+        });
+
+        it('retains Run 2 capacity for a Core Quad with three destroyed legs', () => {
+            const { turnState, rules } = createTurnStateHarness({
+                prone: false,
+                internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
+                committedDestroyedLegs: ['FLL', 'FRL', 'RLL'],
+                unit: { walk: 4, walk2: 4, run: 6, run2: 6 },
+            });
+            turnState.moveMode.set('run');
+
+            expect((rules as MekRules).movementState())
+                .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+            expect(turnState.movementCapacityCurrentMoveMode()).toBe(2);
+            expect(turnState.maxDistanceCurrentMoveMode()).toBe(2);
+        });
+
+        it('retains Run 2 capacity for a prone Core Quad with three destroyed legs', () => {
+            const { turnState, rules } = createTurnStateHarness({
+                prone: true,
+                internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
+                committedDestroyedLegs: ['FLL', 'FRL', 'RLL'],
+                unit: { walk: 4, walk2: 4, run: 6, run2: 6 },
+            });
+            turnState.moveMode.set('run');
+
+            expect((rules as MekRules).movementState())
+                .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+            expect(turnState.movementCapacityCurrentMoveMode()).toBe(2);
+            expect(turnState.maxDistanceCurrentMoveMode()).toBe(2);
+        });
+
+        it('preserves movement already completed when the unit becomes prone', () => {
+            for (const rulesId of ['core2026', 'tw'] as const) {
+                const { turnState } = createTurnStateHarness({
+                    prone: true,
+                    rulesId,
+                    unit: { walk: 4, walk2: 4, run: 6, run2: 6 },
+                });
+                turnState.moveMode.set('run');
+                turnState.moveDistance.set(6);
+
+                expect(turnState.movementCapacityCurrentMoveMode()).withContext(rulesId).toBe(6);
+                expect(turnState.maxDistanceCurrentMoveMode()).withContext(rulesId).toBe(6);
+
+                turnState.clampMoveDistanceToCurrentModeRange();
+
+                expect(turnState.moveDistance()).withContext(rulesId).toBe(6);
+            }
+        });
+
+        it('subtracts two movement points per stand attempt in Core and TW', () => {
+            for (const rulesId of ['core2026', 'tw'] as const) {
+                const { turnState } = createTurnStateHarness({
+                    rulesId,
+                    unit: { walk: 4, walk2: 4, run: 6, run2: 6 },
+                });
+                turnState.moveMode.set('walk');
+                turnState.moveDistance.set(4);
+
+                turnState.adjustStandAttempts(1);
+
+                expect(turnState.movementCapacityCurrentMoveMode()).withContext(rulesId).toBe(4);
+                expect(turnState.maxDistanceCurrentMoveMode()).withContext(rulesId).toBe(2);
+                expect(turnState.moveDistance()).withContext(rulesId).toBe(2);
+
+                turnState.adjustStandAttempts(1);
+
+                expect(turnState.maxDistanceCurrentMoveMode()).withContext(rulesId).toBe(0);
+                expect(turnState.moveDistance()).withContext(rulesId).toBe(0);
+
+                turnState.moveMode.set('run');
+
+                expect(turnState.movementCapacityCurrentMoveMode()).withContext(rulesId).toBe(6);
+                expect(turnState.maxDistanceCurrentMoveMode()).withContext(rulesId).toBe(2);
+            }
+        });
     });
 
     describe('standing up', () => {
@@ -598,6 +726,34 @@ describe('TurnState', () => {
             expect(turnState.standAttempts()).toBe(0);
         });
 
+        it('reconciles stand-attempt heat through the selected rules', () => {
+            const core = createTurnStateHarness();
+            core.turnState.moveMode.set('run');
+            core.turnState.acknowledgeHeatSources();
+
+            core.turnState.adjustStandAttempts(1);
+
+            expect(core.turnState.heatSources()).toEqual([]);
+
+            const tw = createTurnStateHarness({ rulesId: 'tw' });
+            tw.turnState.moveMode.set('run');
+            tw.turnState.acknowledgeHeatSources();
+
+            tw.turnState.adjustStandAttempts(1);
+
+            expect(getMovementHeat(tw.turnState)).toBe(3);
+            tw.turnState.acknowledgeHeatSources();
+
+            tw.turnState.resetStandAttempts();
+
+            expect(getMovementHeat(tw.turnState)).toBe(2);
+            tw.turnState.acknowledgeHeatSources();
+
+            tw.turnState.resetStandAttempts();
+
+            expect(tw.turnState.heatSources()).toEqual([]);
+        });
+
         it('records outcomes and removes prone only after success', () => {
             const { turnState } = createTurnStateHarness({ prone: true });
 
@@ -610,10 +766,108 @@ describe('TurnState', () => {
             expect(turnState.unitState.unit.setCondition).toHaveBeenCalledOnceWith('prone', false);
         });
 
-        it('disables standing for stationary movement and too many destroyed legs', () => {
+        it('supports careful stand only in TW and requires at least three remaining Walking MP', () => {
+            const core = createTurnStateHarness({
+                prone: true,
+                rulesId: 'core2026',
+                unit: { walk: 5, walk2: 5, run: 8, run2: 8 },
+            });
+            const exactThreshold = createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                unit: { walk: 3, walk2: 3, run: 5, run2: 5 },
+            });
+            const belowThreshold = createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                unit: { walk: 2, walk2: 2, run: 3, run2: 3 },
+            });
+            const threeRemaining = createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                unit: { walk: 5, walk2: 5, run: 8, run2: 8 },
+            });
+            const twoRemaining = createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                unit: { walk: 4, walk2: 4, run: 6, run2: 6 },
+            });
+            threeRemaining.turnState.adjustStandAttempts(1);
+            twoRemaining.turnState.adjustStandAttempts(1);
+
+            expect(core.rules.supportsCarefulStand).toBeFalse();
+            expect(core.rules.canCarefulStand(core.turnState)).toBeFalse();
+            expect(core.turnState.resolveStandAttempt('failed', { carefulStand: true })).toBeFalse();
+            expect(core.turnState.standAttempts()).toBeUndefined();
+
+            expect(exactThreshold.rules.supportsCarefulStand).toBeTrue();
+            expect(exactThreshold.rules.canCarefulStand(exactThreshold.turnState)).toBeTrue();
+            expect(belowThreshold.rules.canCarefulStand(belowThreshold.turnState)).toBeFalse();
+            expect(threeRemaining.rules.canCarefulStand(threeRemaining.turnState)).toBeTrue();
+            expect(twoRemaining.rules.canCarefulStand(twoRemaining.turnState)).toBeFalse();
+            expect(belowThreshold.turnState.resolveStandAttempt('failed', { carefulStand: true })).toBeFalse();
+            expect(belowThreshold.turnState.standAttempts()).toBeUndefined();
+        });
+
+        it('spends the entire phase on a careful stand whether it succeeds or fails', () => {
+            for (const outcome of ['success', 'failed'] as const) {
+                const { turnState, rules } = createTurnStateHarness({
+                    prone: true,
+                    rulesId: 'tw',
+                    unit: { walk: 5, walk2: 5, run: 8, run2: 8 },
+                });
+                turnState.moveMode.set('stationary');
+
+                expect(turnState.resolveStandAttempt(outcome, { carefulStand: true }))
+                    .withContext(outcome)
+                    .toBeTrue();
+                expect(turnState.carefulStand()).withContext(outcome).toBeTrue();
+                expect(turnState.moveMode()).withContext(outcome).toBe('walk');
+                expect(turnState.standAttempts()).withContext(outcome).toBe(1);
+                expect(turnState.movementCapacityCurrentMoveMode()).withContext(outcome).toBe(5);
+                expect(rules.getMovementPointsSpent(turnState)).withContext(outcome).toBe(5);
+                expect(turnState.maxDistanceCurrentMoveMode()).withContext(outcome).toBe(0);
+                expect(turnState.canStandUp()).withContext(outcome).toBeFalse();
+            }
+        });
+
+        it('retains Run as the worse movement mode when making a careful stand', () => {
+            const { turnState, rules } = createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                unit: { walk: 5, walk2: 5, run: 8, run2: 8 },
+            });
+            turnState.moveMode.set('run');
+            turnState.moveDistance.set(0);
+
+            expect(turnState.resolveStandAttempt('failed', { carefulStand: true })).toBeTrue();
+
+            expect(turnState.moveMode()).toBe('run');
+            expect(turnState.movementCapacityCurrentMoveMode()).toBe(8);
+            expect(rules.getMovementPointsSpent(turnState)).toBe(8);
+            expect(turnState.maxDistanceCurrentMoveMode()).toBe(0);
+
+            turnState.adjustStandAttempts(-1);
+
+            expect(turnState.carefulStand()).toBeFalse();
+            expect(turnState.standAttempts()).toBe(0);
+            expect(turnState.movementCapacityCurrentMoveMode()).toBe(8);
+            expect(rules.getMovementPointsSpent(turnState)).toBe(0);
+            expect(turnState.maxDistanceCurrentMoveMode()).toBe(8);
+        });
+
+        it('applies the Core and TW limb requirements for standing', () => {
             const stationary = createTurnStateHarness({ prone: true });
             stationary.turnState.moveMode.set('stationary');
-            expect(stationary.turnState.canStandUp()).toBeFalse();
+            expect(stationary.turnState.canStandUp()).toBeTrue();
+            expect(stationary.turnState.prepareStandAttempt()).toBeTrue();
+            expect(stationary.turnState.moveMode()).toBe('walk');
+            expect(stationary.turnState.moveDistance()).toBe(0);
+
+            expect(createTurnStateHarness({
+                prone: true,
+                currentDestroyedLegs: ['LL'],
+            }).turnState.canStandUp()).toBeTrue();
 
             expect(createTurnStateHarness({
                 prone: true,
@@ -630,14 +884,156 @@ describe('TurnState', () => {
                 prone: true,
                 internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
                 currentDestroyedLegs: ['FLL', 'FRL', 'RLL'],
+            }).turnState.canStandUp()).toBeTrue();
+
+            expect(createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
+                currentDestroyedLegs: ['FLL', 'FRL', 'RLL'],
+            }).turnState.canStandUp()).toBeFalse();
+
+            expect(createTurnStateHarness({
+                prone: true,
+                internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
+                currentDestroyedLegs: ['FLL', 'FRL', 'RLL', 'RRL'],
+            }).turnState.canStandUp()).toBeFalse();
+
+            expect(createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                internalLocations: ['LA', 'RA', 'LL', 'RL'],
+                currentDestroyedLegs: ['LA', 'RA'],
+            }).turnState.canStandUp()).toBeTrue();
+
+            expect(createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                internalLocations: ['LA', 'RA', 'LL', 'RL'],
+                currentDestroyedLegs: ['LA', 'RA', 'LL'],
             }).turnState.canStandUp()).toBeFalse();
         });
 
+        it('classifies each TW destroyed-leg exception as running and reports its one-attempt limit', () => {
+            const scenarios = [
+                { label: 'biped with one leg', locations: ['LL', 'RL'], destroyed: ['LL'] },
+                { label: 'tripod with two legs', locations: ['LL', 'CL', 'RL'], destroyed: ['LL'] },
+                {
+                    label: 'quad with two legs',
+                    locations: ['FLL', 'FRL', 'RLL', 'RRL'],
+                    destroyed: ['FLL', 'FRL'],
+                },
+            ];
+
+            for (const scenario of scenarios) {
+                const { turnState, rules } = createTurnStateHarness({
+                    prone: true,
+                    rulesId: 'tw',
+                    internalLocations: scenario.locations,
+                    committedDestroyedLegs: scenario.destroyed,
+                    unit: { walk: 5, walk2: 5, run: 8, run2: 8, jump: 0, umu: 0, heat: 0 },
+                });
+                turnState.moveMode.set('walk');
+
+                expect((rules as MekRules).movementState())
+                    .withContext(scenario.label)
+                    .toEqual(jasmine.objectContaining({ walk: 1, run: 0 }));
+                expect(rules.isMotiveModeAvailable('run')).withContext(scenario.label).toBeTrue();
+                expect(turnState.canStandUp()).withContext(scenario.label).toBeTrue();
+                expect(rules.getStandAttemptLimit(turnState)).withContext(scenario.label).toBe(1);
+
+                expect(turnState.prepareStandAttempt()).withContext(scenario.label).toBeTrue();
+
+                expect(turnState.moveMode()).withContext(scenario.label).toBe('run');
+                expect(turnState.moveDistance()).withContext(scenario.label).toBe(0);
+                expect(turnState.movementCapacityCurrentMoveMode()).withContext(scenario.label).toBe(1);
+                expect(turnState.maxDistanceCurrentMoveMode()).withContext(scenario.label).toBe(1);
+                expect(turnState.standAttempts()).withContext(scenario.label).toBeUndefined();
+
+                expect(turnState.resolveStandAttempt('failed')).withContext(scenario.label).toBeTrue();
+
+                expect(getMovementHeat(turnState)).withContext(scenario.label).toBe(3);
+                expect(turnState.standAttempts()).withContext(scenario.label).toBe(1);
+                expect(turnState.movementCapacityCurrentMoveMode()).withContext(scenario.label).toBe(1);
+                expect(turnState.maxDistanceCurrentMoveMode()).withContext(scenario.label).toBe(0);
+                expect(turnState.canStandUp()).withContext(scenario.label).toBeTrue();
+            }
+        });
+
+        it('classifies a Core one-legged stand as running while retaining ordinary Run movement', () => {
+            const { turnState, rules } = createTurnStateHarness({
+                prone: true,
+                committedDestroyedLegs: ['LL'],
+                unit: { walk: 5, walk2: 5, run: 8, run2: 8, jump: 0, umu: 0, heat: 0 },
+            });
+            turnState.moveMode.set('walk');
+
+            expect((rules as MekRules).movementState())
+                .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+            expect(rules.isMotiveModeAvailable('run')).toBeTrue();
+
+            expect(turnState.prepareStandAttempt()).toBeTrue();
+
+            expect(turnState.moveMode()).toBe('run');
+            expect(turnState.moveDistance()).toBe(0);
+
+            expect(turnState.resolveStandAttempt('failed')).toBeTrue();
+
+            expect(getMovementHeat(turnState)).toBe(2);
+        });
+
+        it('does not apply the TW one-attempt exception to a quad with only one destroyed leg', () => {
+            const { turnState } = createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
+                committedDestroyedLegs: ['FLL'],
+                unit: { walk: 5, walk2: 5, run: 8, run2: 8, jump: 0, umu: 0, heat: 0 },
+            });
+            turnState.moveMode.set('walk');
+
+            expect(turnState.unitState.unit.rules.getStandAttemptLimit(turnState)).toBeNull();
+
+            expect(turnState.resolveStandAttempt('failed')).toBeTrue();
+
+            expect(turnState.moveMode()).toBe('walk');
+            expect(turnState.canStandUp()).toBeTrue();
+        });
+
+        it('does not classify TW units that cannot stand as destroyed-leg stand exceptions', () => {
+            const scenarios = [
+                { label: 'biped with no legs', locations: ['LL', 'RL'], destroyed: ['LL', 'RL'] },
+                {
+                    label: 'quad with one leg',
+                    locations: ['FLL', 'FRL', 'RLL', 'RRL'],
+                    destroyed: ['FLL', 'FRL', 'RLL'],
+                },
+            ];
+
+            for (const scenario of scenarios) {
+                const { turnState, rules } = createTurnStateHarness({
+                    prone: true,
+                    rulesId: 'tw',
+                    internalLocations: scenario.locations,
+                    committedDestroyedLegs: scenario.destroyed,
+                });
+                turnState.moveMode.set('walk');
+
+                expect(turnState.canStandUp()).withContext(scenario.label).toBeFalse();
+                expect(rules.getStandAttemptLimit(turnState)).withContext(scenario.label).toBeNull();
+                expect(rules.getStandAttemptMovementMode(turnState)).withContext(scenario.label).toBe('walk');
+            }
+        });
+
         it('lets only an intact quad stand without a PSR', () => {
             const quad = createTurnStateHarness({
                 prone: true,
                 internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
             });
+            const standingQuad = createTurnStateHarness({
+                prone: false,
+                internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
+            });
             const damagedQuad = createTurnStateHarness({
                 prone: true,
                 internalLocations: ['FLL', 'FRL', 'RLL', 'RRL'],
@@ -646,9 +1042,21 @@ describe('TurnState', () => {
             const biped = createTurnStateHarness({ prone: true });
 
             expect(quad.turnState.canStandWithoutPSR()).toBeTrue();
+            expect(standingQuad.turnState.canStandUp()).toBeFalse();
+            expect(standingQuad.turnState.canStandWithoutPSR()).toBeTrue();
             expect(damagedQuad.turnState.canStandWithoutPSR()).toBeFalse();
             expect(biped.turnState.canStandWithoutPSR()).toBeFalse();
         });
+
+        it('does not apply Mek standing rules to other unit types', () => {
+            const infantry = createTurnStateHarness({ prone: true, rulesType: 'infantry' });
+            const aero = createTurnStateHarness({ prone: true, rulesType: 'aero' });
+
+            expect(infantry.turnState.canStandUp()).toBeFalse();
+            expect(infantry.turnState.canStandWithoutPSR()).toBeFalse();
+            expect(aero.turnState.canStandUp()).toBeFalse();
+            expect(aero.turnState.canStandWithoutPSR()).toBeFalse();
+        });
     });
 
     describe('getPSRChecks', () => {
@@ -692,6 +1100,70 @@ describe('TurnState', () => {
             expect(getReasons(turnState)).toContain('Leg Actuator hit');
             expect(getReasons(turnState)).not.toContain('Jumping with damaged leg actuator');
         });
+
+        it('folds TW destroyed-leg stand movement PSRs into the single stand roll', () => {
+            const scenarios = [
+                {
+                    label: 'biped with damaged gyro',
+                    locations: ['LL', 'RL'],
+                    destroyedLegs: ['LL'],
+                    crit: createCritSlot('Gyro', 'CT', { destroyed: 1 }),
+                    movementReason: 'Running with damaged gyro',
+                },
+                {
+                    label: 'biped with damaged hip',
+                    locations: ['LL', 'RL'],
+                    destroyedLegs: ['LL'],
+                    crit: createCritSlot('Hip', 'RL', { destroyed: 1 }),
+                    movementReason: 'Running with damaged hip',
+                },
+                {
+                    label: 'quad with damaged gyro',
+                    locations: ['FLL', 'FRL', 'RLL', 'RRL'],
+                    destroyedLegs: ['FLL', 'FRL'],
+                    crit: createCritSlot('Gyro', 'CT', { destroyed: 1 }),
+                    movementReason: 'Running with damaged gyro',
+                },
+            ];
+
+            for (const scenario of scenarios) {
+                const { turnState, rules } = createTurnStateHarness({
+                    prone: true,
+                    rulesId: 'tw',
+                    internalLocations: scenario.locations,
+                    committedDestroyedLegs: scenario.destroyedLegs,
+                    critSlots: [scenario.crit],
+                    unit: { subtype: 'BattleMek' },
+                });
+                turnState.moveMode.set('run');
+                turnState.moveDistance.set(0);
+
+                const standModifier = rules.PSRModifiers().modifier;
+                expect(getReasons(turnState)).withContext(scenario.label).toContain(scenario.movementReason);
+                expect(turnState.PSRRollsCount()).withContext(scenario.label).toBe(1);
+
+                expect(turnState.resolveStandAttempt('failed')).withContext(scenario.label).toBeTrue();
+
+                expect(getReasons(turnState)).withContext(scenario.label).not.toContain(scenario.movementReason);
+                expect(turnState.PSRRollsCount()).withContext(scenario.label).toBe(0);
+                expect(rules.PSRModifiers().modifier).withContext(scenario.label).toBe(standModifier);
+            }
+        });
+
+        it('keeps ordinary TW running PSRs separate from an ordinary stand roll', () => {
+            const { turnState } = createTurnStateHarness({
+                prone: true,
+                rulesId: 'tw',
+                critSlots: [createCritSlot('Gyro', 'CT', { destroyed: 1 })],
+            });
+            turnState.moveMode.set('run');
+            turnState.moveDistance.set(0);
+
+            expect(turnState.resolveStandAttempt('failed')).toBeTrue();
+
+            expect(getReasons(turnState)).toContain('Running with damaged gyro');
+            expect(turnState.PSRRollsCount()).toBe(1);
+        });
     });
 
     describe('modifier breakdowns', () => {
@@ -770,6 +1242,27 @@ describe('TurnState', () => {
     });
 
     describe('movement distance limits', () => {
+        it('treats a Core Immobile unit as stationary without storing a movement selection', () => {
+            const { turnState } = createTurnStateHarness({ immobile: true });
+
+            expect(turnState.moveMode()).toBeNull();
+            expect(turnState.effectiveMoveMode()).toBe('stationary');
+            expect(turnState.getAttackMovementModifier()).toBe(0);
+            expect(turnState.missingAttackMovementModifier()).toBeFalse();
+            expect(turnState.currentPhase()).toBe('W');
+            expect(turnState.dirty()).toBeFalse();
+        });
+
+        it('does not assign an effective movement mode to a TW Immobile unit', () => {
+            const { turnState } = createTurnStateHarness({ immobile: true, rulesId: 'tw' });
+
+            expect(turnState.moveMode()).toBeNull();
+            expect(turnState.effectiveMoveMode()).toBeNull();
+            expect(turnState.missingAttackMovementModifier()).toBeTrue();
+            expect(turnState.currentPhase()).toBe('M');
+            expect(turnState.dirty()).toBeFalse();
+        });
+
         it('uses unit rules for minimum movement distance', () => {
             const { turnState } = createTurnStateHarness({
                 rulesType: 'infantry',
diff --git a/src/app/models/turn-state.model.ts b/src/app/models/turn-state.model.ts
index b60e8f463..8bad2e6b4 100644
--- a/src/app/models/turn-state.model.ts
+++ b/src/app/models/turn-state.model.ts
@@ -4,7 +4,6 @@
 
 import { computed, signal, type WritableSignal } from "@angular/core";
 import { canChangeAirborneGround, getMotiveModeMaxDistance, type MotiveModes } from "./motiveModes.model";
-import { getMekLegLocations, inferMekConfigFromLocations } from "./entity/types";
 import type { CBTForceUnitState } from "./cbt-force-unit-state.model";
 import type { RuleCheckOutcome, SerializedPSRChecks, SerializedTurnState } from "./force-serialization";
 import { calculateModifierTotal, type PSRCheck, type UnitHeatSource, type UnitModifierBreakdownEntry, type UnitModifierTotal } from "./rules/unit-type-rules";
@@ -61,7 +60,17 @@ export class TurnState {
     airborne = this.modifiedSignal<boolean | null>(null, 'movement');
     moveMode = this.modifiedSignal<MotiveModes | null>(null, 'movement');
     moveDistance = this.modifiedSignal<number | null>(null, 'movement');
+    /** Movement mode used by rules; Core defaults an unassigned Immobile unit to stationary. */
+    effectiveMoveMode = computed<MotiveModes | null>(() => {
+        const selectedMoveMode = this.moveMode();
+        if (selectedMoveMode !== null) return selectedMoveMode;
+        const unit = this.unitState.unit;
+        return unit.gameRules.id === 'core2026' && unit.getCondition('immobile')
+            ? 'stationary'
+            : null;
+    });
     standAttempts = this.modifiedSignal<number | undefined>(undefined);
+    carefulStand = this.modifiedSignal<boolean>(false);
     cover = this.modifiedSignal<UnitCover | undefined>(undefined);
     private readonly waterState = computed(() => {
         const cover = this.cover();
@@ -91,6 +100,7 @@ export class TurnState {
         const moveMode = this.moveMode();
         const moveDistance = this.moveDistance();
         const standAttempts = this.standAttempts();
+        const carefulStand = this.carefulStand();
         const cover = this.cover();
         const dmgReceived = this.dmgReceived();
         const weaponsHeat = this.weaponsHeat();
@@ -101,6 +111,7 @@ export class TurnState {
             || moveMode !== null
             || moveDistance !== null
             || standAttempts !== undefined
+            || carefulStand
             || cover !== undefined
             || dmgReceived != 0
             || weaponsHeat > 0
@@ -147,53 +158,16 @@ export class TurnState {
         });
     });
 
-    canRun = computed<boolean>(() => {
-        const unit = this.unitState.unit;
-        let damagedLegsCount = 0;
-        const internalLocations = unit.locations?.internal;
-        const config = inferMekConfigFromLocations(internalLocations?.keys() ?? []);
-        // Calculate pre-existing leg destruction modifiers. If a leg is gone, is gone.
-        for (const loc of getMekLegLocations(config)) {
-            if (!internalLocations?.has(loc)) continue;
-            if (unit.isInternalLocCommittedDestroyed(loc)) {
-                damagedLegsCount++;
-            }
-        }
-        return config === 'Quad' ? damagedLegsCount < 2 : damagedLegsCount < 1;
-    });
-
-    private readonly standingLegState = computed(() => {
-        const unit = this.unitState.unit;
-        const internalLocations = unit.locations?.internal;
-        const config = inferMekConfigFromLocations(internalLocations?.keys() ?? []);
-        const legs = getMekLegLocations(config);
-        const destroyedLegs = legs.filter(loc =>
-            internalLocations?.has(loc) && unit.isInternalLocDestroyed(loc)
-        ).length;
-        return { config, legs, destroyedLegs, internalLocations };
-    });
-
     canStandUp = computed<boolean>(() => {
-        if (!this.unitState.hasCondition('prone') || this.moveMode() === 'stationary') return false;
-        const { config, destroyedLegs } = this.standingLegState();
-        return destroyedLegs < (config === 'Quad' ? 3 : 2);
+        return this.unitState.unit.rules.canStandUp(this);
     });
 
     canStandWithoutPSR = computed<boolean>(() => {
-        if (!this.canStandUp()) return false;
-        const unit = this.unitState.unit;
-        const { config, legs, internalLocations } = this.standingLegState();
-        return config === 'Quad' && legs.every(loc =>
-            internalLocations?.has(loc) && !unit.isInternalLocDestroyed(loc)
-        );
-    });
-
-    getSpottingModifier = computed<number>(() => {
-        return this.spotting() ? this.unitState.unit.rules.getSpottingModifier() : 0;
+        return this.unitState.unit.rules.canStandWithoutPSR(this);
     });
 
     getAttackMovementModifier = computed<number>(() => {
-        return this.unitState.unit.rules.getAttackMovementModifier(this.moveMode(), this.airborne() ?? false);
+        return this.unitState.unit.rules.getAttackMovementModifier(this.effectiveMoveMode(), this.airborne() ?? false);
     });
 
     attackMovementModifierCanApply = computed<boolean>(() => {
@@ -210,7 +184,7 @@ export class TurnState {
     });
 
     missingAttackMovementModifier = computed<boolean>(() => {
-        return this.moveMode() === null && this.attackMovementModifierCanApply();
+        return this.effectiveMoveMode() === null && this.attackMovementModifierCanApply();
     });
 
     getAttackModifierBreakdown = computed<UnitModifierBreakdownEntry[]>(() => {
@@ -255,25 +229,47 @@ export class TurnState {
         return true;
     }
 
-    resolveStandAttempt(outcome: RuleCheckOutcome): boolean {
-        if (!this.canStandUp()) return false;
+    resolveStandAttempt(outcome: RuleCheckOutcome, options: { carefulStand?: boolean } = {}): boolean {
+        const carefulStand = options.carefulStand === true;
+        if (carefulStand && !this.unitState.unit.rules.canCarefulStand(this)) return false;
+        if (!this.prepareStandAttempt()) return false;
         this.adjustStandAttempts(1);
+        if (carefulStand) {
+            this.carefulStand.set(true);
+            this.clampMoveDistanceToCurrentModeRange();
+        }
         if (outcome === 'success') this.unitState.unit.setCondition('prone', false);
         return true;
     }
 
+    prepareStandAttempt(): boolean {
+        if (!this.canStandUp()) return false;
+        const standingMovementMode = this.unitState.unit.rules.getStandAttemptMovementMode(this);
+        if (standingMovementMode !== null && standingMovementMode !== this.moveMode()) {
+            this.moveMode.set(standingMovementMode);
+            if (this.moveDistance() === null) this.moveDistance.set(0);
+        }
+        return true;
+    }
+
     adjustStandAttempts(delta: number): void {
         if (!Number.isFinite(delta)) return;
+        const normalizedDelta = Math.trunc(delta);
         const current = this.standAttempts() ?? 0;
-        const next = Math.max(0, current + Math.trunc(delta));
-        if (next === current) return;
+        const next = Math.max(0, current + normalizedDelta);
+        const removedCarefulStand = normalizedDelta < 0 && this.carefulStand();
+        if (removedCarefulStand) this.carefulStand.set(false);
+        if (next === current && !removedCarefulStand) return;
         this.standAttempts.set(next);
-        if (this.unitState.unit.gameRules.id === 'tw') this.invalidateHeatSource('movement');
+        this.clampMoveDistanceToCurrentModeRange();
+        this.reconcileHeatSources();
     }
 
     resetStandAttempts(): void {
         this.standAttempts.set(0);
-        if (this.unitState.unit.gameRules.id === 'tw') this.invalidateHeatSource('movement');
+        this.carefulStand.set(false);
+        this.clampMoveDistanceToCurrentModeRange();
+        this.reconcileHeatSources();
     }
 
     setCover(cover: UnitCover | undefined): void {
@@ -294,7 +290,8 @@ export class TurnState {
     }
 
     currentPhase = computed<'I' | 'M' | 'W' | 'P' | 'H'>(() => {
-        if (this.moveMode() === null || (this.moveMode() !== 'stationary' && this.moveDistance() === null)) {
+        const moveMode = this.effectiveMoveMode();
+        if (moveMode === null || (moveMode !== 'stationary' && this.moveDistance() === null)) {
             return 'M';
         } else {
             return 'W';
@@ -434,6 +431,7 @@ export class TurnState {
         const moveMode = this.moveMode();
         const moveDistance = this.moveDistance();
         const standAttempts = this.standAttempts();
+        const carefulStand = this.carefulStand();
         const cover = this.cover();
         const psrChecks = this.serializePSRChecks();
 
@@ -441,6 +439,7 @@ export class TurnState {
         if (moveMode !== null) turnState.moveMode = moveMode;
         if (moveDistance !== null) turnState.moveDistance = moveDistance;
         if (standAttempts !== undefined) turnState.standAttempts = standAttempts;
+        if (carefulStand && this.unitState.unit.rules.supportsCarefulStand) turnState.carefulStand = true;
         if (cover !== undefined) turnState.cover = serializeUnitCover(cover);
         if (this.dmgReceived() > 0) turnState.dmgReceived = this.dmgReceived();
         if (this.weaponsHeat() > 0) turnState.weaponsHeat = this.weaponsHeat();
@@ -467,6 +466,9 @@ export class TurnState {
             this.moveMode.set(data?.moveMode ?? null);
             this.moveDistance.set(data?.moveDistance ?? null);
             this.standAttempts.set(data?.standAttempts);
+            this.carefulStand.set(
+                data?.carefulStand === true && this.unitState.unit.rules.supportsCarefulStand
+            );
             this.cover.set(deserializeUnitCover(data?.cover));
             this.dmgReceived.set(data?.dmgReceived ?? 0);
             this.weaponsHeat.set(data?.weaponsHeat ?? 0);
@@ -592,7 +594,7 @@ export class TurnState {
         return JSON.stringify([source.value, source.replacedByFiringEntryId ?? null, source.signature ?? null]);
     }
 
-    maxDistanceCurrentMoveMode = computed<number>(() => {
+    movementCapacityCurrentMoveMode = computed<number>(() => {
         const moveMode = this.moveMode();
         if (moveMode === 'stationary') {
             return 0;
@@ -611,6 +613,12 @@ export class TurnState {
         return getMotiveModeMaxDistance(moveMode, unit, airborne ?? false);
     });
 
+    maxDistanceCurrentMoveMode = computed<number>(() => {
+        const capacity = this.movementCapacityCurrentMoveMode();
+        const rules = this.unitState.unit.rules;
+        return Math.max(0, capacity - rules.getMovementPointsSpent(this));
+    });
+
     minDistanceCurrentMoveMode = computed<number>(() => {
         const moveMode = this.moveMode();
         if (moveMode === 'stationary' || !moveMode) {
diff --git a/src/app/services/force-builder.service.spec.ts b/src/app/services/force-builder.service.spec.ts
index fbb949b77..83d483306 100644
--- a/src/app/services/force-builder.service.spec.ts
+++ b/src/app/services/force-builder.service.spec.ts
@@ -609,6 +609,7 @@ describe('ForceBuilderService OPFOR inventory target synchronization', () => {
             getActiveNarcWaterLayers: () => ({ aboveWater: false, underwater: false }),
             turnState: () => ({
                 moveMode: signal(null),
+                effectiveMoveMode: signal(null),
                 moveDistance: signal<number | null>(0),
                 airborne: signal<boolean | null>(false),
                 cover: signal<UnitCover | undefined>(cover)
diff --git a/src/app/services/unit-svg-mek.service.ts b/src/app/services/unit-svg-mek.service.ts
index 44281d7c8..48dd9bc68 100644
--- a/src/app/services/unit-svg-mek.service.ts
+++ b/src/app/services/unit-svg-mek.service.ts
@@ -275,7 +275,10 @@ export class UnitSvgMekService extends UnitSvgService {
         const movement = this.mekRules.movementState();
         if (!movement) return;
 
-        const runWarning = movement.maxRun > 0 ? this.unit.rules.getCommittedDamageMovementModePSRCheck('run') : null;
+        const turnState = this.unit.turnState();
+        const runWarning = this.unit.rules.isMotiveModeAvailable('run', turnState)
+            ? this.unit.rules.getCommittedDamageMovementModePSRCheck('run')
+            : null;
         const jumpWarning = movement.jump > 0 ? this.unit.rules.getCommittedDamageMovementModePSRCheck('jump') : null;
         const jumpMoveElementId = svg.getElementById('mpJump') ? 'mpJump' : (svg.getElementById('mp_2') ? 'mp_2' : null);
 
@@ -289,7 +292,8 @@ export class UnitSvgMekService extends UnitSvgService {
         const warningEl = svg.getElementById(`${moveElementId}-psr-warning`) as SVGTextElement | null;
         if (!warningEl) return;
 
-        const currentMoveMode = this.unit.turnState().moveMode();
+        const turnState = this.unit.turnState();
+        const currentMoveMode = turnState.effectiveMoveMode();
         let selectedMoveElementId: string | null = null;
         if (currentMoveMode === 'walk' || currentMoveMode === 'stationary') {
             selectedMoveElementId = 'mpWalk';
@@ -310,9 +314,12 @@ export class UnitSvgMekService extends UnitSvgService {
         warningEl.style.display = 'block';
         const warningMoveMode = moveElementId === 'mpRun' ? 'run' : 'jump';
         const isCurrentMoveMode = currentMoveMode === warningMoveMode;
-        const moveDistance = this.unit.turnState().moveDistance();
-        const triggersPsr = moveDistance !== null && (warningMoveMode === 'jump' || moveDistance > 0);
-        warningEl.classList.toggle('noPsrCheck', !isCurrentMoveMode || !triggersPsr);
+        const triggersPsr = isCurrentMoveMode
+            && this.unit.rules.getCommittedDamageMovementModePSRCheck(
+                warningMoveMode,
+                turnState.moveDistance(),
+            ) !== null;
+        warningEl.classList.toggle('noPsrCheck', !triggersPsr);
 
         if (!selectedMoveElementId) {
             warningEl.classList.remove('currentMoveMode', 'unusedMoveMode');
diff --git a/src/app/services/unit-svg.service.ts b/src/app/services/unit-svg.service.ts
index 7b461a5a6..413c9179d 100644
--- a/src/app/services/unit-svg.service.ts
+++ b/src/app/services/unit-svg.service.ts
@@ -1711,7 +1711,7 @@ export class UnitSvgService {
             summaryProjection.projected
         );
         // Update move mode display
-        const moveMode = turnState.moveMode();
+        const moveMode = turnState.effectiveMoveMode();
         const moveModifier = turnState.getAttackMovementModifier();
         let el: SVGElement | null = null;
         const mpWalkEl = svg.getElementById('mpWalk') as SVGElement | null;
diff --git a/src/app/testing/unit-test-helpers.ts b/src/app/testing/unit-test-helpers.ts
index a57123d15..64a0479a5 100644
--- a/src/app/testing/unit-test-helpers.ts
+++ b/src/app/testing/unit-test-helpers.ts
@@ -199,11 +199,11 @@ export interface CBTForceUnitTestHarnessOptions {
 
 export interface CBTForceUnitTestTurnState {
     moveMode(): MotiveModes | null;
+    effectiveMoveMode(): MotiveModes | null;
     airborne(): boolean;
     getAttackMovementModifier(): number;
     getAttackModifierBreakdown(): UnitModifierBreakdownEntry[];
     missingAttackMovementModifier(): boolean;
-    getSpottingModifier(): number;
     heatSources(): Array<{ id: string; label: string; value: number }>;
     heatDissipationBalance(): number;
     effectiveHeatDissipation(): number;
@@ -265,13 +265,13 @@ export class CBTForceUnitTestHarness {
         );
         this.turnState = {
             moveMode: () => options.moveMode ?? null,
+            effectiveMoveMode: () => options.moveMode ?? null,
             airborne: () => false,
             getAttackMovementModifier: attackMovementModifier,
             getAttackModifierBreakdown: () => options.attackModifierBreakdown ?? (attackMovementModifier() !== 0
                 ? [{ label: getMotiveModeLabel(options.moveMode!, baseUnit, false), modifier: attackMovementModifier(), priority: ATTACK_MOVEMENT_MODIFIER_BREAKDOWN_PRIORITY }]
                 : []),
             missingAttackMovementModifier: () => (options.moveMode ?? null) === null && (options.attackMovementCanAffectTargetNumbers ?? true),
-            getSpottingModifier: () => 0,
             heatSources: () => [
                 ...(options.heatSources ? [{ id: 'test-source', label: 'Test Source', value: options.heatSources }] : []),
                 ...(firedHeat > 0 ? [{ id: 'weapons', label: 'Weapons', value: firedHeat }] : []),
diff --git a/src/app/utils/inventory-control-opfor-target.util.spec.ts b/src/app/utils/inventory-control-opfor-target.util.spec.ts
index 2593bf3a8..21980033e 100644
--- a/src/app/utils/inventory-control-opfor-target.util.spec.ts
+++ b/src/app/utils/inventory-control-opfor-target.util.spec.ts
@@ -51,6 +51,7 @@ function forceUnit(options: {
             moveDistance,
             airborne,
             moveMode,
+            effectiveMoveMode: moveMode,
             cover,
             isDepth1: () => cover() === 'underwater-depth-1',
         })
diff --git a/src/app/utils/inventory-control-opfor-target.util.ts b/src/app/utils/inventory-control-opfor-target.util.ts
index 09b4ff45f..08ab4c240 100644
--- a/src/app/utils/inventory-control-opfor-target.util.ts
+++ b/src/app/utils/inventory-control-opfor-target.util.ts
@@ -44,7 +44,7 @@ export function deriveOpforTargetCalculatorState(
     const immobile = unit.getCondition('immobile');
     const prone = unit.getCondition('prone');
     const moveDistance = unit.turnState().moveDistance();
-    const isAirborne = unit.turnState().moveMode() === 'jump' || unit.turnState().airborne() === true;
+    const isAirborne = unit.turnState().effectiveMoveMode() === 'jump' || unit.turnState().airborne() === true;
     const cover = unit.turnState().cover();
     const narcWaterLayers = unit.getActiveNarcWaterLayers();
     const targetMovementBracket = moveDistance !== null
diff --git a/src/app/utils/mek-critical-hit.util.spec.ts b/src/app/utils/mek-critical-hit.util.spec.ts
index dd9f196d9..93a939c78 100644
--- a/src/app/utils/mek-critical-hit.util.spec.ts
+++ b/src/app/utils/mek-critical-hit.util.spec.ts
@@ -128,7 +128,7 @@ describe('Mek critical-hit workflow', () => {
         }
     });
 
-    it('empties an exploding ammo bin and applies the Core damage cap with transfer', () => {
+    it('does not empties an exploding ammo bin and applies the Core damage cap with transfer', () => {
         const fixture = explodingAmmoUnit(CORE_2026_GAME_RULES);
 
         const outcome = applyMekCriticalRoll(fixture.unit, 'LT', [1, 1], true);
@@ -137,7 +137,7 @@ describe('Mek critical-hit workflow', () => {
         expect(outcome?.equipment).toBe('AC/10 Ammo');
         expect(outcome?.explosion?.rawDamage).toBe(100);
         expect(outcome?.explosion?.pilotHits).toBe(1);
-        expect(fixture.slot.consumed).toBe(10);
+        expect(fixture.slot.consumed).toBe(0);
         expect(fixture.internalHits.get('LT')).toBe(12);
         expect(fixture.internalHits.get('CT')).toBe(8);
         expect(fixture.armorHits.get('CT-rear')).toBe(12);

From 72810a4df7c9a6707743b3806d4e22e716d8c0ba Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Wed, 19 Aug 2026 20:57:37 +0200
Subject: [PATCH 03/12] cleanup

---
 .../page-turn-summary-panel.component.html    |   3 +-
 .../page-turn-summary-panel.component.spec.ts |  39 +-
 .../page-turn-summary-panel.component.ts      |  31 +-
 src/app/models/cbt-force-unit.model.ts        |   2 +-
 src/app/models/rules/mek-rules.spec.ts        | 392 +++++++++++++++++-
 src/app/models/rules/mek-rules.ts             | 188 ++++++---
 src/app/models/rules/tw-rules.ts              |  77 +++-
 src/app/models/rules/unit-type-rules.ts       |   6 +-
 src/app/services/unit-svg-mek.service.ts      |   3 +-
 9 files changed, 629 insertions(+), 112 deletions(-)

diff --git a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.html b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.html
index 578ffd421..cfff493bf 100644
--- a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.html
+++ b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.html
@@ -9,7 +9,8 @@
     <section class="summary-section" aria-label="Movement">
         @if (showImmobileStatus()) {
             <div class="summary-row immobile-status" role="status">Unit is immobile</div>
-        } @else {
+        }
+        @if (showMovementControls()) {
         @if (canSwitchAirborneMode()) {
             <div class="button-row">
                 <button
diff --git a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.spec.ts b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.spec.ts
index bdf401403..5b10ed615 100644
--- a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.spec.ts
+++ b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.spec.ts
@@ -20,12 +20,29 @@ describe('PageTurnSummaryPanelComponent', () => {
     it('distinguishes an Immobile unit from one with only Stationary available', () => {
         const immobile = signal(false);
         const rulesId = signal<'core2026' | 'tw'>('core2026');
-        const turnState = { airborne: signal<boolean | null>(false) };
+        const moveMode = signal<'stationary' | 'walk' | 'run' | 'jump' | 'UMU' | 'VTOL' | null>(null);
+        const turnState = {
+            airborne: signal<boolean | null>(false),
+            moveMode,
+            moveDistance: signal<number | null>(5),
+            carefulStand: signal(false),
+        };
         const unit = {
             get gameRules() {
                 return rulesId() === 'tw' ? TW_GAME_RULES : CORE_2026_GAME_RULES;
             },
             getCondition: (condition: string) => condition === 'immobile' && immobile(),
+            getUnit: () => ({
+                type: 'Mek',
+                subtype: 'BattleMek',
+                moveType: 'Biped',
+                jump: 0,
+                umu: 0,
+            }),
+            rules: {
+                getAttackMovementModifier: () => 0,
+                getCommittedDamageMovementModePSRCheck: () => null,
+            },
             getAvailableMotiveModes: () => [{ mode: 'stationary', label: 'Stationary', psr: false }],
             turnState: () => turnState,
         };
@@ -51,7 +68,6 @@ describe('PageTurnSummaryPanelComponent', () => {
             falling: () => false,
             PSRChecksCount: () => 0,
             controlRollShortLabel: () => 'PSR',
-            currentMoveMode: () => null,
             prone: () => false,
             canStandUp: () => false,
             standAttempts: () => 0,
@@ -70,6 +86,13 @@ describe('PageTurnSummaryPanelComponent', () => {
             equipmentTrackControlRows: () => [],
             airborne: () => false,
             canSwitchAirborneMode: () => false,
+            moveDistance: () => 5,
+            moveCapacity: () => 0,
+            moveMin: () => 0,
+            moveMax: () => 0,
+            moveDistanceTicks: () => [0],
+            hasMoveDistance: () => true,
+            overDistance: () => true,
         });
 
         expect(component.immobile()).toBeFalse();
@@ -96,6 +119,18 @@ describe('PageTurnSummaryPanelComponent', () => {
         expect(fixture.nativeElement.querySelector('.immobile-status')).toBeNull();
         expect(fixture.nativeElement.querySelectorAll('.move-button').length).toBe(1);
         expect(fixture.nativeElement.querySelector('.move-button.stationary-only')).not.toBeNull();
+
+        rulesId.set('core2026');
+        moveMode.set('run');
+        fixture.detectChanges();
+
+        expect(fixture.nativeElement.querySelector('.immobile-status')?.textContent.trim())
+            .toBe('Unit is immobile');
+        expect(Array.from<HTMLElement>(fixture.nativeElement.querySelectorAll('.move-button'))
+            .map(button => button.textContent?.trim())).toEqual(['', 'Run']);
+        expect(fixture.nativeElement.querySelector('.move-button.selected')?.textContent.trim()).toBe('Run');
+        expect(fixture.nativeElement.querySelector('hex-slider')).not.toBeNull();
+        expect(fixture.nativeElement.querySelector('.hex.danger')?.textContent.trim()).toBe('5');
     });
 
     it('reports spent stand-attempt MP and reopens the standing dialog without changing the attempt', () => {
diff --git a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.ts b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.ts
index 8be680b96..7872ee25a 100644
--- a/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.ts
+++ b/src/app/components/page-viewer/overlay/page-turn-summary-panel.component.ts
@@ -7,7 +7,7 @@ import { CommonModule } from '@angular/common';
 import { Overlay } from '@angular/cdk/overlay';
 import { OverlayManagerService } from '../../../services/overlay-manager.service';
 import { PageInteractionOverlayComponent } from './page-interaction-overlay.component';
-import { canChangeAirborneGround, type MotiveModeOption, type MotiveModes } from '../../../models/motiveModes.model';
+import { canChangeAirborneGround, getMotiveModesOptionsByUnit, type MotiveModeOption, type MotiveModes } from '../../../models/motiveModes.model';
 import { HexSliderComponent } from '../../hex-slider/hex-slider.component';
 import { TooltipDirective } from '../../../directives/tooltip.directive';
 import type { TooltipLine } from '../../tooltip/tooltip.component';
@@ -156,6 +156,10 @@ export class PageTurnSummaryPanelComponent {
         return unit?.gameRules.id === 'core2026' && this.immobile();
     });
 
+    readonly showMovementControls = computed(() => (
+        !this.showImmobileStatus() || this.currentMoveMode() !== null
+    ));
+
     readonly canStandUp = computed(() => this.unit()?.turnState().canStandUp() ?? false);
 
     readonly standAttempts = computed(() => this.unit()?.turnState().standAttempts() ?? 0);
@@ -328,7 +332,30 @@ export class PageTurnSummaryPanelComponent {
     readonly moveModes = computed<MotiveModeOption[]>(() => {
         const unit = this.unit();
         if (!unit) return [];
-        return unit.getAvailableMotiveModes(unit.turnState().airborne() ?? false);
+        const turnState = unit.turnState();
+        const airborne = turnState.airborne() ?? false;
+        const availableModes = unit.getAvailableMotiveModes(airborne);
+        const currentMode = turnState.moveMode();
+        if (currentMode === null || availableModes.some(option => option.mode === currentMode)) {
+            return availableModes;
+        }
+
+        const supportedModes = getMotiveModesOptionsByUnit(unit.getUnit(), airborne);
+        const currentOption = supportedModes.find(option => option.mode === currentMode);
+        if (!currentOption) return availableModes;
+
+        const visibleModes = new Map(availableModes.map(option => [option.mode, option]));
+        visibleModes.set(currentMode, {
+            ...currentOption,
+            psr: unit.rules.getCommittedDamageMovementModePSRCheck(
+                currentMode,
+                turnState.moveDistance(),
+            ) !== null,
+        });
+        return supportedModes.flatMap(option => {
+            const visibleOption = visibleModes.get(option.mode);
+            return visibleOption ? [visibleOption] : [];
+        });
     });
 
     readonly onlyStationaryMoveMode = computed(() => {
diff --git a/src/app/models/cbt-force-unit.model.ts b/src/app/models/cbt-force-unit.model.ts
index 72561c5ff..95230a4dc 100644
--- a/src/app/models/cbt-force-unit.model.ts
+++ b/src/app/models/cbt-force-unit.model.ts
@@ -1576,7 +1576,7 @@ export class CBTForceUnit extends ForceUnit {
     public getAvailableMotiveModes(airborne: boolean): MotiveModeOption[] {
         const turnState = this.turnState();
         return getMotiveModesOptionsByUnit(this.getUnit(), airborne)
-            .filter(option => this._rules.isMotiveModeAvailable(option.mode, turnState))
+            .filter(option => this._rules.isMotiveModeAvailable(option.mode))
             .map(option => ({
                 ...option,
                 psr: this._rules.getCommittedDamageMovementModePSRCheck(
diff --git a/src/app/models/rules/mek-rules.spec.ts b/src/app/models/rules/mek-rules.spec.ts
index e3eccb6a2..52472ddec 100644
--- a/src/app/models/rules/mek-rules.spec.ts
+++ b/src/app/models/rules/mek-rules.spec.ts
@@ -1065,6 +1065,86 @@ describe('MekRules', () => {
         expect(depletedCore.forceUnit.isEquipmentOperational(depletedCore.shield)).toBeFalse();
     });
 
+    it('removes the shield mobility modifier at the ruleset-specific destruction threshold', () => {
+        const coreZeroCapacity = createShieldHarness('core2026', 4);
+        const twOneCriticalRemaining = createShieldHarness('tw', 4);
+        const twAllCriticalsDestroyed = createShieldHarness('tw', 5);
+
+        expect((coreZeroCapacity.forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 6, run: 9 }));
+        expect((twOneCriticalRemaining.forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 5, run: 8 }));
+        expect((twAllCriticalsDestroyed.forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 6, run: 9 }));
+    });
+
+    it('uses DA zero in Core but all unavailable shield criticals in TW for the mobility modifier', () => {
+        const core = createShieldHarness('core2026');
+        const tw = createShieldHarness('tw');
+        for (const forceUnit of [core.forceUnit, tw.forceUnit]) {
+            for (const slot of forceUnit.getCritSlots().filter(candidate =>
+                candidate.loc === 'LA' && !candidate.eq?.hasFlag('F_SHIELD'))) {
+                forceUnit.setCritLoc({ ...slot, destroyed: 1 });
+            }
+        }
+
+        expect((core.forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 6, run: 9 }));
+        expect((tw.forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 5, run: 8 }));
+
+        tw.forceUnit.setLocations(createCommittedLocationState(['LA']), true);
+
+        expect((tw.forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 6, run: 9 }));
+    });
+
+    it('restores ended equipment penalties before applying movement damage', () => {
+        const shieldEquipment = miscEquipment(
+            'ISMediumShield',
+            'Shield (Medium)',
+            ['F_SHIELD', 'S_SHIELD_MEDIUM'],
+        );
+        const modularArmor = miscEquipment(
+            'ISModularArmor',
+            'Modular Armor',
+            ['F_MODULAR_ARMOR'],
+        );
+        const shieldCriticals: CriticalSlot[] = Array.from({ length: 5 }, (_, index) => ({
+            ...crit('Shield (Medium)'),
+            id: `ISMediumShield@LA#${index + 4}`,
+            loc: 'LA',
+            slot: index + 4,
+            eq: shieldEquipment,
+        }));
+        const forceUnit = createForceUnitHarness({
+            rulesId: 'tw',
+            walk: 2,
+            run: 3,
+            internalLocations: ['LA', 'RA', 'LT', 'LL', 'RL'],
+            critSlots: [
+                ...shieldCriticals,
+                { ...crit('Modular Armor', false), id: 'modular-armor', loc: 'LT', slot: 0, eq: modularArmor },
+                { ...crit('Hip'), id: 'left-hip', loc: 'LL', slot: 0 },
+            ],
+        });
+        const currentShieldCriticals = forceUnit.getCritSlots().filter(slot => slot.eq === shieldEquipment);
+        forceUnit.setInventory([new MountedEquipment({
+            owner: forceUnit,
+            id: 'ISMediumShield@LA',
+            name: 'Shield (Medium)',
+            equipment: shieldEquipment,
+            locations: new Set(['LA']),
+            critSlots: currentShieldCriticals,
+        })]);
+
+        // Stored Walk 2 includes both -1 penalties. The destroyed shield first
+        // restores the live base to 3; the surviving modular armor remains baked
+        // in, then the TW hip hit halves 3 to 2.
+        expect((forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
+    });
+
     it('identifies shoulder and paired AES modifiers for push attacks', () => {
         const forceUnit = createForceUnitHarness({
             critSlots: [
@@ -2483,6 +2563,93 @@ describe('MekRules', () => {
         }).hasComputedCondition('crippled')).toBeFalse();
     });
 
+    it('restores the modular armor Walk penalty only after every panel is unavailable', () => {
+        for (const rulesId of ['core2026', 'tw'] as const) {
+            const createUnit = (lastPanelConsumed: number) => {
+                const modularArmor = miscEquipment(
+                    'ISModularArmor',
+                    'Modular Armor',
+                    ['F_MODULAR_ARMOR'],
+                );
+                return createForceUnitHarness({
+                    rulesId,
+                    walk: 0,
+                    run: 0,
+                    internalLocations: ['LT', 'RT', 'LL', 'RL'],
+                    critSlots: [
+                        { ...crit('Modular Armor'), id: 'modular-armor-lt', loc: 'LT', slot: 0, eq: modularArmor },
+                        {
+                            ...crit('Modular Armor', false),
+                            id: 'modular-armor-rt',
+                            loc: 'RT',
+                            slot: 0,
+                            consumed: lastPanelConsumed,
+                            eq: modularArmor,
+                        },
+                    ],
+                });
+            };
+            const onePanelRemaining = createUnit(9);
+            const allPanelsUnavailable = createUnit(10);
+
+            expect((onePanelRemaining.rules as MekRules).movementState())
+                .withContext(rulesId)
+                .toEqual(jasmine.objectContaining({ walk: 0, run: 0 }));
+            expect((onePanelRemaining.rules as MekRules).PSRModifiers().modifier)
+                .withContext(rulesId)
+                .toBe(1);
+            expect((allPanelsUnavailable.rules as MekRules).movementState())
+                .withContext(rulesId)
+                .toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+            expect((allPanelsUnavailable.rules as MekRules).PSRModifiers().modifier)
+                .withContext(rulesId)
+                .toBe(0);
+        }
+    });
+
+    it('marks movement impaired when damage consumes Walk MP restored from destroyed equipment', () => {
+        const modularArmor = miscEquipment(
+            'ISModularArmor',
+            'Modular Armor',
+            ['F_MODULAR_ARMOR'],
+        );
+        const forceUnit = createForceUnitHarness({
+            rulesId: 'core2026',
+            walk: 0,
+            run: 0,
+            internalLocations: ['LT', 'RT', 'LL', 'RL'],
+            critSlots: [
+                {
+                    ...crit('Modular Armor', false),
+                    id: 'modular-armor',
+                    loc: 'LT',
+                    slot: 0,
+                    consumed: 10,
+                    eq: modularArmor,
+                },
+                { ...crit('Hip'), id: 'left-hip', loc: 'LL', slot: 0 },
+            ],
+        });
+
+        expect((forceUnit.rules as MekRules).movementState()).toEqual(jasmine.objectContaining({
+            walk: 0,
+            run: 0,
+            moveImpaired: true,
+        }));
+
+        const shieldUnit = createShieldHarness('core2026', 4).forceUnit;
+        shieldUnit.writeCrits([
+            ...shieldUnit.getCritSlots(),
+            { ...crit('Hip'), id: 'left-hip', loc: 'LL', slot: 0 },
+        ]);
+
+        expect((shieldUnit.rules as MekRules).movementState()).toEqual(jasmine.objectContaining({
+            walk: 5,
+            run: 8,
+            moveImpaired: true,
+        }));
+    });
+
     it('marks TW biped, tripod, and quad Meks immobile after the required four limbs are destroyed', () => {
         const scenarios = [
             {
@@ -2596,7 +2763,7 @@ describe('MekRules', () => {
         expect(twForceUnit.rules.hasComputedCondition('immobile')).toBeTrue();
     });
 
-    it('treats surviving Jump MP as mobile only while a zero-ground-MP Core Mek is standing', () => {
+    it('only lets surviving Jump MP prevent Core damage immobility while standing', () => {
         const forceUnit = createForceUnitHarness({
             internalLocations: ['LA', 'RA', 'LL', 'RL'],
             committedDestroyedLocations: ['LL', 'RL'],
@@ -2616,6 +2783,73 @@ describe('MekRules', () => {
         forceUnit.setCondition('prone', true);
 
         expect(rules.hasComputedCondition('immobile')).toBeTrue();
+
+        const twForceUnit = createForceUnitHarness({
+            internalLocations: ['LA', 'RA', 'LL', 'RL'],
+            committedDestroyedLocations: ['LL', 'RL'],
+            critSlots: [crit('Jump Jet', false)],
+            jump: 1,
+            umu: 0,
+            rulesId: 'tw',
+        });
+        expect(twForceUnit.rules.hasComputedCondition('immobile')).toBeFalse();
+
+        twForceUnit.setCondition('prone', true);
+
+        // TW explicitly says that a biped with both legs destroyed is not Immobile.
+        expect(twForceUnit.rules.hasComputedCondition('immobile')).toBeFalse();
+    });
+
+    it('does not mark a prone Core Mek immobile when heat, rather than damage, reduced ground MP to zero', () => {
+        const forceUnit = createForceUnitHarness({
+            critSlots: [crit('Jump Jet', false)],
+            jump: 1,
+            umu: 0,
+        });
+        forceUnit.setHeat(30, true);
+        forceUnit.setCondition('prone', true);
+
+        expect((forceUnit.rules as MekRules).movementState()).toEqual(jasmine.objectContaining({
+            walk: 0,
+            run: 0,
+            jump: 1,
+        }));
+        expect(forceUnit.rules.hasComputedCondition('immobile')).toBeFalse();
+    });
+
+    it('does not mark a prone Core 0/0/1 Mek immobile when its unit profile already includes equipment penalties', () => {
+        const forceUnit = createForceUnitHarness({
+            critSlots: [crit('Jump Jet', false)],
+            walk: 0,
+            run: 0,
+            jump: 1,
+            umu: 0,
+        });
+        forceUnit.setCondition('prone', true);
+
+        expect((forceUnit.rules as MekRules).movementState()).toEqual(jasmine.objectContaining({
+            walk: 0,
+            run: 0,
+            jump: 1,
+        }));
+        expect(forceUnit.rules.hasComputedCondition('immobile')).toBeFalse();
+    });
+
+    it('does not offer depleted Jump or UMU modes', () => {
+        const forceUnit = createForceUnitHarness({
+            critSlots: [
+                { ...crit('Jump Jet'), loc: 'LT' },
+                { ...crit('UMU'), loc: 'RT' },
+            ],
+            jump: 1,
+            umu: 1,
+        });
+
+        const modes = forceUnit.getAvailableMotiveModes(false).map(option => option.mode);
+        expect(forceUnit.rules.isMotiveModeAvailable('jump')).toBeFalse();
+        expect(forceUnit.rules.isMotiveModeAvailable('UMU')).toBeFalse();
+        expect(modes).not.toContain('jump');
+        expect(modes).not.toContain('UMU');
     });
 
     it('does not let UMU MP keep a prone zero-ground-MP Core Mek mobile', () => {
@@ -2765,12 +2999,11 @@ describe('MekRules', () => {
 
         expect(turnState.movementCapacityCurrentMoveMode()).toBe(1);
         expect(turnState.maxDistanceCurrentMoveMode()).toBe(1);
-        expect(forceUnit.getAvailableMotiveModes(false).find(option => option.mode === 'run')?.psr).toBeTrue();
+        expect(forceUnit.getAvailableMotiveModes(false).find(option => option.mode === 'run')?.psr).toBeFalse();
 
         forceUnit.setCondition('prone', true);
 
         expect(forceUnit.rules.isMotiveModeAvailable('run')).toBeTrue();
-        expect(forceUnit.rules.isMotiveModeAvailable('run', turnState)).toBeTrue();
         expect(offersRun()).toBeTrue();
         expect(turnState.movementCapacityCurrentMoveMode()).toBe(1);
         expect(turnState.maxDistanceCurrentMoveMode()).toBe(1);
@@ -2779,6 +3012,7 @@ describe('MekRules', () => {
 
         expect(turnState.moveMode()).toBe('run');
         expect(turnState.standAttempts()).toBe(1);
+        expect(forceUnit.rules.getMovementPointsSpent(turnState)).toBe(2);
         expect(turnState.movementCapacityCurrentMoveMode()).toBe(1);
         expect(turnState.maxDistanceCurrentMoveMode()).toBe(0);
         expect(offersRun()).toBeTrue();
@@ -2872,6 +3106,19 @@ describe('MekRules', () => {
         }
     });
 
+    it('offers only Stationary when a TW Mek is actually immobile', () => {
+        const forceUnit = createForceUnitHarness({
+            internalLocations: ['LA', 'RA', 'LL', 'RL'],
+            committedDestroyedLocations: ['LA', 'RA', 'LL', 'RL'],
+            rulesId: 'tw',
+            jump: 4,
+            umu: 2,
+        });
+
+        expect(forceUnit.getCondition('immobile')).toBeTrue();
+        expect(forceUnit.getAvailableMotiveModes(false).map(option => option.mode)).toEqual(['stationary']);
+    });
+
     it('colors Run for the current action rather than a potential destroyed-leg check', () => {
         const forceUnit = createForceUnitHarness({
             internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
@@ -2936,7 +3183,7 @@ describe('MekRules', () => {
         expect(runOption?.psr).toBeTrue();
     });
 
-    it('marks TW destroyed-leg Minimum Movement as a zero-hex Run PSR', () => {
+    it('does not invent a TW PSR merely because destroyed-leg Minimum Movement counts as running', () => {
         const biped = createForceUnitHarness({
             committedDestroyedLocations: ['LL'],
             rulesId: 'tw',
@@ -2947,10 +3194,9 @@ describe('MekRules', () => {
 
         expect((biped.rules as MekRules).movementState())
             .toEqual(jasmine.objectContaining({ walk: 1, run: 0 }));
-        expect(biped.rules.isMotiveModeAvailable('run', bipedTurnState)).toBeTrue();
-        expect(biped.rules.getCommittedDamageMovementModePSRCheck('run', 0))
-            .toEqual(jasmine.objectContaining({ loc: 'LL', reason: 'Running with damaged leg' }));
-        expect(biped.getAvailableMotiveModes(false).find(option => option.mode === 'run')?.psr).toBeTrue();
+        expect(biped.rules.isMotiveModeAvailable('run')).toBeTrue();
+        expect(biped.rules.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+        expect(biped.getAvailableMotiveModes(false).find(option => option.mode === 'run')?.psr).toBeFalse();
 
         const oneDestroyedLegQuad = createRulesHarness({
             internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
@@ -2965,8 +3211,24 @@ describe('MekRules', () => {
 
         expect(oneDestroyedLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
         expect(twoDestroyedLegQuad.isMotiveModeAvailable('run')).toBeTrue();
-        expect(twoDestroyedLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)?.reason)
-            .toBe('Running with damaged leg');
+        expect(twoDestroyedLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+    });
+
+    it('ignores a TW hip hit in a destroyed leg but checks a hip in the surviving leg', () => {
+        const destroyedLegHip = createRulesHarness({
+            committedDestroyedLocations: ['LL'],
+            critSlots: [{ ...crit('Hip'), loc: 'LL' }],
+            rulesId: 'tw',
+        });
+        const survivingLegHip = createRulesHarness({
+            committedDestroyedLocations: ['LL'],
+            critSlots: [{ ...crit('Hip'), loc: 'RL' }],
+            rulesId: 'tw',
+        });
+
+        expect(destroyedLegHip.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+        expect(survivingLegHip.getCommittedDamageMovementModePSRCheck('run', 0)?.reason)
+            .toBe('Running with damaged hip');
     });
 
     it('never lets destroyed-leg movement increase a slower biped', () => {
@@ -2986,8 +3248,8 @@ describe('MekRules', () => {
         const expected = [
             { destroyed: ['RLL'], walk: 4, run: 6, psr: 1 },
             { destroyed: ['RLL', 'FLL'], walk: 3, run: 5, psr: 2 },
-            { destroyed: ['RLL', 'FLL', 'RRL'], walk: 1, run: 2, psr: 3 },
-            { destroyed: locations, walk: 0, run: 0, psr: 4 },
+            { destroyed: ['RLL', 'FLL', 'RRL'], walk: 1, run: 2, psr: 4 },
+            { destroyed: locations, walk: 0, run: 0, psr: 0 },
         ];
 
         for (const scenario of expected) {
@@ -3007,6 +3269,107 @@ describe('MekRules', () => {
         }
     });
 
+    it('keeps the fixed Core 1/2 profile when the sole remaining Quad leg has actuator damage', () => {
+        const rules = createRulesHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL', 'RRL'],
+            critSlots: [{ ...crit('Upper Leg Actuator'), loc: 'FRL' }],
+            walk: 5,
+            run: 8,
+        });
+
+        expect(rules.movementState()).toEqual(jasmine.objectContaining({ walk: 1, run: 2 }));
+    });
+
+    it('uses aggregate TW Quad leg-destruction PSR modifiers', () => {
+        const locations = ['RLL', 'FLL', 'RRL', 'FRL'];
+        const expected = [
+            { destroyed: ['RLL'], modifier: 0 },
+            { destroyed: ['RLL', 'FLL'], modifier: 5 },
+            { destroyed: ['RLL', 'FLL', 'RRL'], modifier: 0 },
+            { destroyed: locations, modifier: 0 },
+        ];
+
+        for (const scenario of expected) {
+            const rules = createRulesHarness({
+                internalLocations: locations,
+                committedDestroyedLocations: scenario.destroyed,
+                rulesId: 'tw',
+            });
+
+            expect(rules.PSRModifiers().modifier)
+                .withContext(`${scenario.destroyed.length} destroyed Quad legs`)
+                .toBe(scenario.modifier);
+        }
+    });
+
+    it('applies the TW Quad one-leg +5 only to the required jump PSR', () => {
+        const forceUnit = createForceUnitHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL'],
+            rulesId: 'tw',
+        });
+        const turnState = forceUnit.turnState();
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(0);
+        expect(forceUnit.rules.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
+        expect(forceUnit.rules.getCommittedDamageMovementModePSRCheck('jump', 0))
+            .toEqual(jasmine.objectContaining({ pilotCheck: 5, reason: 'Jumping with damaged leg' }));
+
+        turnState.moveMode.set('jump');
+        turnState.moveDistance.set(1);
+
+        expect(turnState.getPSRChecks()).toEqual([
+            jasmine.objectContaining({ pilotCheck: 5, reason: 'Jumping with damaged leg' }),
+        ]);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(5);
+    });
+
+    it('halves TW Quad Walking MP for each surviving-leg hip hit after leg-loss adjustment', () => {
+        const rules = createRulesHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL'],
+            critSlots: [{ ...crit('Hip'), loc: 'FRL' }],
+            rulesId: 'tw',
+            walk: 5,
+            run: 8,
+        });
+
+        expect(rules.movementState()).toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
+    });
+
+    it('keeps the Core Quad two-leg hip-equivalent run trigger to one PSR', () => {
+        const forceUnit = createForceUnitHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            committedDestroyedLocations: ['RLL', 'FLL'],
+            critSlots: [
+                { ...crit('Hip'), id: 'rear-left-hip', loc: 'RLL' },
+                { ...crit('Hip'), id: 'front-left-hip', loc: 'FLL' },
+            ],
+        });
+        const turnState = forceUnit.turnState();
+        turnState.moveMode.set('run');
+        turnState.moveDistance.set(1);
+
+        expect(turnState.getPSRChecks().filter(check => check.reason === 'Running with damaged hip').length)
+            .toBe(1);
+    });
+
+    it('does not let an intact Core Quad stand with a destroyed gyro', () => {
+        const forceUnit = createForceUnitHarness({
+            internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
+            critSlots: [
+                { id: 'gyro-1', name: 'Gyro', loc: 'CT', slot: 0, destroyed: 1 },
+                { id: 'gyro-2', name: 'Gyro', loc: 'CT', slot: 1, destroyed: 1 },
+            ],
+        });
+        forceUnit.setCondition('prone', true);
+
+        expect(forceUnit.turnState().canStandUp()).toBeFalse();
+        // This only classifies an otherwise-legal stand; canStandUp owns eligibility.
+        expect(forceUnit.turnState().canStandWithoutPSR()).toBeTrue();
+    });
+
     it('requires one hex for running damage PSRs but checks zero-hex jumps', () => {
         const biped = createRulesHarness({ committedDestroyedLocations: ['LL'] });
 
@@ -3037,8 +3400,7 @@ describe('MekRules', () => {
         expect(oneLegQuad.getCommittedDamageMovementModePSRCheck('jump', 1)).toBeNull();
         expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
         expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.reason).toBe('Running with damaged hip');
-        expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.kind)
-            .toBe('damaged-hip-movement');
+        expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.kind).toBeUndefined();
         expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('jump', 0)?.reason).toBe('Jumping with damaged hip');
         expect(twoLegQuad.getCommittedDamageMovementModePSRCheck('run', 1)?.loc).toBeUndefined();
         expect(threeLegQuad.getCommittedDamageMovementModePSRCheck('run', 0)).toBeNull();
@@ -3340,7 +3702,7 @@ describe('MekRules', () => {
             fallCheck: 2,
             pilotCheck: 2,
             loc: 'CT',
-            reason: 'Jumping with damaged heavy-duty gyro',
+            reason: 'Jumping with damaged HD gyro',
             ignorePreExistingGyro: true,
         }));
     });
diff --git a/src/app/models/rules/mek-rules.ts b/src/app/models/rules/mek-rules.ts
index 89b4a7011..873b8590b 100644
--- a/src/app/models/rules/mek-rules.ts
+++ b/src/app/models/rules/mek-rules.ts
@@ -7,7 +7,7 @@ import type { CBTForceUnit, EquipmentAction } from '../cbt-force-unit.model';
 import type { CrewMember, SkillType } from '../crew-member.model';
 import type { MountedEquipment } from '../mounted-equipment.model';
 import type { CriticalSlot, RuleCheckOutcome } from '../force-serialization';
-import { CrewStateControlDefinition, CrewStateDefinition, crewStateDefinitions, NARC_CONDITION_COLOR, PSRCheckKind, sortPSRModifiers, UnitConditionControl, unitConditionControls, UnitTypeRulesBase, type ChargeDamage, type LocationConditionControl, type PSRCheck, type UnitHeatSource, type UnitModifierBreakdownEntry, type UnitRuleModifier } from './unit-type-rules';
+import { CrewStateControlDefinition, CrewStateDefinition, crewStateDefinitions, NARC_CONDITION_COLOR, sortPSRModifiers, UnitConditionControl, unitConditionControls, UnitTypeRulesBase, type ChargeDamage, type LocationConditionControl, type PSRCheck, type PSRCheckKind, type UnitHeatSource, type UnitModifierBreakdownEntry, type UnitRuleModifier } from './unit-type-rules';
 import type { EquipmentStatus, EquipmentStatusFacts } from '../equipment-status.model';
 import type { TurnState } from '../turn-state.model';
 import { type HeatScaleEntry, HeatManagement, getHeatEffects } from './heat-management';
@@ -33,9 +33,9 @@ import { uuidv7 } from '../../utils/uuid.util';
 
 type ArmLocation = 'LA' | 'RA';
 
-const LEG_DAMAGE_MOVEMENT_CRITICAL_NAMES: Partial<Record<PSRCheckKind, readonly string[]>> = {
-    ['damaged-leg-actuator-movement']: ['Leg', 'Foot', 'Hip'],
-    ['damaged-hip-movement']: ['Hip'],
+const LEG_DAMAGE_MOVEMENT_CRITICAL_NAMES: Record<PSRCheckKind, readonly string[]> = {
+    'damaged-leg-actuator-movement': ['Leg', 'Foot', 'Hip'],
+    'damaged-hip-movement': ['Hip'],
 };
 
 interface MekArmStatus {
@@ -143,12 +143,19 @@ export class MekRules extends UnitTypeRulesBase {
     protected override readonly immobile = computed<boolean>(() => {
         if (!this.unit.isLoaded()) return false;
         if (this.unit.getCondition('shutdown')) return true;
-        if (this.allLimbsDestroyedOrMissing()) return true;
         if (!this.hasDroneOperatingSystem() && !this.hasFunctionalCrew()) return true;
         const unit = this.unit.getUnit();
         const movement = this.computeBaseMovementProfile();
         if (!movement) return false;
         const canUseJumpingMovement = !this.unit.getCondition('prone');
+        const hasUsableNonGroundMovement = canUseJumpingMovement && (
+            (unit.jump > 0 && movement.jump > 0)
+            || (unit.umu > 0 && movement.UMU > 0)
+        );
+        // Sparse records can omit destroyed limbs entirely. Losing every limb
+        // is damage-caused immobility unless a standing Mek can still leave by
+        // a surviving non-ground mode.
+        if (this.allLimbsDestroyedOrMissing() && !hasUsableNonGroundMovement) return true;
         const availableModes = [
             unit.walk > 0 ? movement.walk : null,
             unit.run > 0 ? this.baseRunValue(movement) : null,
@@ -207,9 +214,9 @@ export class MekRules extends UnitTypeRulesBase {
         if (config !== 'Tripod') return limbLocations.every(isDestroyedOrMissing);
 
         const armsDestroyedOrMissing = limbLocations
-        .filter(loc => !isMekLegLocation(config, loc))
-        .every(isDestroyedOrMissing);
-        // For Tripod is enough 2 of the 3 legs to consider that all legs are destroyed, as if they where bipeds
+            .filter(loc => !isMekLegLocation(config, loc))
+            .every(isDestroyedOrMissing);
+        // A tripod with two destroyed legs follows the biped both-legs-destroyed state.
         const destroyedOrMissingLegs = getMekLegLocations(config)
             .filter(isDestroyedOrMissing)
             .length;
@@ -591,6 +598,7 @@ export class MekRules extends UnitTypeRulesBase {
         const hasDamagedLegActuators = critSlots.some(slot => {
             if (!slot.name || !slot.loc || !this.isCritUnavailable(slot)) return false;
             if (!LEG_LOCATIONS.has(slot.loc)) return false;
+            if (this.unit.isInternalLocCommittedDestroyed(slot.loc)) return false;
             return this.isNamedCrit(slot, 'Leg')
                 || this.isNamedCrit(slot, 'Foot')
                 || this.isNamedCrit(slot, 'Hip');
@@ -618,10 +626,15 @@ export class MekRules extends UnitTypeRulesBase {
                 };
             }
             if (hasDamagedLeg && damagedLegRequiresCheck) {
+                const modifier = this.destroyedLegMovementPSRModifier(
+                    moveMode,
+                    isQuadruped,
+                    destroyedLegsCount,
+                );
                 return {
-                    fallCheck: 0,
-                    pilotCheck: 0,
-                    ...(damagedLegLocation && { loc: damagedLegLocation }),
+                    fallCheck: modifier,
+                    pilotCheck: modifier,
+                    ...(modifier === 0 && damagedLegLocation && { loc: damagedLegLocation }),
                     reason: 'Jumping with damaged leg'
                 };
             }
@@ -644,7 +657,6 @@ export class MekRules extends UnitTypeRulesBase {
             return {
                 fallCheck: 0,
                 pilotCheck: 0,
-                kind: 'damaged-hip-movement',
                 reason: 'Running with damaged hip',
             };
         }
@@ -673,16 +685,6 @@ export class MekRules extends UnitTypeRulesBase {
                 };
             }
         }
-        if (this.runningMinimumMovementWithDestroyedLegRequiresCheck()
-            && hasDamagedLeg
-            && damagedLegRequiresCheck) {
-            return {
-                fallCheck: 0,
-                pilotCheck: 0,
-                ...(damagedLegLocation && { loc: damagedLegLocation }),
-                reason: 'Running with damaged leg'
-            };
-        }
         return null;
     }
 
@@ -692,7 +694,7 @@ export class MekRules extends UnitTypeRulesBase {
             return {
                 fallCheck: 2,
                 pilotCheck: 2,
-                reason: 'Jumping with damaged heavy-duty gyro',
+                reason: 'Jumping with damaged HD gyro',
                 ignorePreExistingGyro: true,
             };
         }
@@ -707,12 +709,16 @@ export class MekRules extends UnitTypeRulesBase {
         return isQuadruped ? destroyedLegsCount >= 2 : destroyedLegsCount >= 1;
     }
 
-    protected runningWithDestroyedLegRequiresCheck(): boolean {
-        return true;
+    protected destroyedLegMovementPSRModifier(
+        _moveMode: 'run' | 'jump',
+        _isQuadruped: boolean,
+        _destroyedLegsCount: number,
+    ): number {
+        return 0;
     }
 
-    protected runningMinimumMovementWithDestroyedLegRequiresCheck(): boolean {
-        return false;
+    protected runningWithDestroyedLegRequiresCheck(): boolean {
+        return true;
     }
 
     protected runningDamageCheckRequiresHexMovement(): boolean {
@@ -1118,14 +1124,10 @@ export class MekRules extends UnitTypeRulesBase {
         // Calculate pre-existing leg destruction modifiers. If a leg is gone, is gone.
         for (const loc of destroyedLegs) {
             ignoreLeg.add(loc); // Track destroyed legs, we ignore further modifiers on that leg
-            const modifier = this.destroyedLegPSR(config === 'Quad').pilotCheck;
-            preExisting += modifier;
-            modifiers.push({
-                pilotCheck: modifier,
-                loc,
-                reason: 'Leg Destroyed',
-            });
         }
+        const destroyedLegModifiers = this.getPreExistingDestroyedLegPSRModifiers(config, destroyedLegs);
+        preExisting += destroyedLegModifiers.reduce((total, modifier) => total + (modifier.pilotCheck ?? 0), 0);
+        modifiers.push(...destroyedLegModifiers);
         if (undamagedLegs) {
             if (config === 'Tripod') {
                 preExisting -= 1; // Tripod unit with all legs intact gets -1 modifier
@@ -1183,16 +1185,12 @@ export class MekRules extends UnitTypeRulesBase {
                 reason: "Mounts Hardened Armor"
             });
         }
-        const modularArmorPanelsCount = critSlots.filter(slot => this.isNamedCrit(slot, 'Modular Armor')).length;
-        if (modularArmorPanelsCount > 0) {
-            const destroyedModularArmorPanelsCount = critSlots.filter(slot => this.isNamedCrit(slot, 'Modular Armor') && (slot.destroyed || ((slot.consumed ?? 0) >= 10))).length;
-            if (destroyedModularArmorPanelsCount < modularArmorPanelsCount) {
-                preExisting += 1; // Modular armor gives +1 modifier (until destroyed or fully consumed)
-                modifiers.push({
-                    pilotCheck: 1,
-                    reason: "Mounts Modular Armor"
-                });
-            }
+        if (this.modularArmorState().active) {
+            preExisting += 1; // Modular armor gives +1 modifier (until destroyed or fully consumed)
+            modifiers.push({
+                pilotCheck: 1,
+                reason: "Mounts Modular Armor"
+            });
         }
         const hasSmallOrTorsoCockpit = critSlots.some(slot => slot.loc
             && ((this.isNamedCrit(slot, 'Cockpit') && this.isNamedCrit(slot, 'Small'))
@@ -1226,6 +1224,34 @@ export class MekRules extends UnitTypeRulesBase {
         return { modifier: finalModifier, modifiers: sortPSRModifiers(modifiers) };
     });
 
+    protected getPreExistingDestroyedLegPSRModifiers(
+        config: MekConfig,
+        destroyedLegs: readonly string[],
+    ): PSRCheck[] {
+        if (config !== 'Quad') {
+            const modifier = this.destroyedLegPSR(false).pilotCheck;
+            return destroyedLegs.map(loc => ({
+                pilotCheck: modifier,
+                loc,
+                reason: 'Leg Destroyed',
+            }));
+        }
+
+        let modifier = 0;
+        if (destroyedLegs.length <= 2) {
+            modifier = destroyedLegs.length;
+        } else if (destroyedLegs.length === 3) {
+            modifier = this.destroyedLegPSR(false).pilotCheck;
+        }
+        if (modifier === 0) return [];
+        return [{
+            pilotCheck: modifier,
+            ...(destroyedLegs.length === 1 && { loc: destroyedLegs[0] }),
+            reason: 'Leg Destroyed',
+            ...(destroyedLegs.length > 1 && { modifierReason: `Legs Destroyed (${destroyedLegs.length})` }),
+        }];
+    }
+
     protected getPreExistingLegActuatorPSRModifiers(
         critSlots: readonly CriticalSlot[],
         ignoreLeg: Set<string>,
@@ -1317,12 +1343,15 @@ export class MekRules extends UnitTypeRulesBase {
         return null;
     }
 
-    override isMotiveModeAvailable(moveMode: MotiveModes, turnState?: TurnState): boolean {
+    override isMotiveModeAvailable(moveMode: MotiveModes): boolean {
+        if (this.immobile()) return moveMode === 'stationary';
         const movement = this.movementState();
         if (moveMode === 'walk') return (movement?.walk ?? 0) > 0;
         if (moveMode === 'run') {
             return (movement?.run ?? 0) > 0 || this.getRunningMinimumMovementDistance() > 0;
         }
+        if (moveMode === 'jump') return (movement?.jump ?? 0) > 0;
+        if (moveMode === 'UMU') return (movement?.UMU ?? 0) > 0;
         return true;
     }
 
@@ -1330,30 +1359,28 @@ export class MekRules extends UnitTypeRulesBase {
         return 0;
     }
 
-    protected maximumDestroyedLegsForStanding(config: MekConfig): number {
+    protected destroyedLegStandThreshold(config: MekConfig): number {
         return config === 'Quad' ? 3 : 1;
     }
 
-    protected destroyedLegStandAttemptLimit(_config: MekConfig, _destroyedLegs: number): number | null {
-        return null;
-    }
-
     protected isMovementPSRFoldedIntoStandAttempt(_turnState: TurnState): boolean {
         return false;
     }
 
-    protected destroyedLegStandAttemptRequiresRunning(config: MekConfig, destroyedLegs: number): boolean {
-        return destroyedLegs === (config === 'Quad' ? 3 : 1);
+    protected isDestroyedLegStandException(config: MekConfig, destroyedLegs: number): boolean {
+        return destroyedLegs === this.destroyedLegStandThreshold(config);
     }
 
     override canStandUp(turnState: TurnState): boolean {
         if (turnState.carefulStand()) return false;
         if (!turnState.unitState.hasCondition('prone')) return false;
+        if (this.immobile()) return false;
+        if (this.gyroPSRModifierHitCount() >= this.gyroDestructionHitThreshold()) return false;
         // Standing normally costs MP, and Minimum Movement can only reduce that
         // cost when the Mek still has at least 1 usable Walking MP.
         if ((this.movementState()?.walk ?? 0) < 1) return false;
         const { config, destroyedLegs, destroyedArms, hasIntactLeg } = this.currentLegState();
-        if (!hasIntactLeg || destroyedLegs.length > this.maximumDestroyedLegsForStanding(config)) return false;
+        if (!hasIntactLeg || destroyedLegs.length > this.destroyedLegStandThreshold(config)) return false;
         return config === 'Quad' || destroyedLegs.length !== 1 || destroyedArms.length !== 2;
     }
 
@@ -1372,27 +1399,22 @@ export class MekRules extends UnitTypeRulesBase {
 
     override getStandAttemptMovementMode(turnState: TurnState): MotiveModes | null {
         const { config, destroyedLegs } = this.currentLegState();
-        if (this.destroyedLegStandAttemptRequiresRunning(config, destroyedLegs.length)
+        if (this.isDestroyedLegStandException(config, destroyedLegs.length)
             || this.movementState()?.walk === 1) {
             return 'run';
         }
         return turnState.moveMode() === 'run' ? 'run' : 'walk';
     }
 
-    override getStandAttemptLimit(_turnState: TurnState): number | null {
-        const { config, destroyedLegs } = this.currentLegState();
-        return this.destroyedLegStandAttemptLimit(config, destroyedLegs.length);
-    }
-
     override getMovementPointsSpent(turnState: TurnState): number {
         const standAttemptMp = Math.max(0, turnState.standAttempts() ?? 0) * 2;
-        if (!turnState.carefulStand()) return standAttemptMp;
-
         const moveMode = turnState.moveMode();
         const movementCapacity = moveMode === null
             ? 0
             : this.getEffectiveMaxDistanceForMoveMode(moveMode, turnState) ?? 0;
-        return Math.max(standAttemptMp, movementCapacity);
+        return turnState.carefulStand()
+            ? movementCapacity
+            : standAttemptMp; // We return the full value so the user can clearly see they over-attempted
     }
 
     override getEffectiveMaxDistanceForMoveMode(moveMode: MotiveModes, turnState: TurnState): number | null {
@@ -1660,7 +1682,12 @@ export class MekRules extends UnitTypeRulesBase {
         const unit = this.unit.getUnit();
         if (!unit) return null;
 
-        let walkValue = unit.walk;
+        const restoredWalk = unit.walk + this.restoredEquipmentWalkMP();
+        const restoredRun = Math.max(
+            0,
+            Math.round(restoredWalk * 1.5) + (unit.armorType === 'Hardened' ? -1 : 0),
+        );
+        let walkValue = restoredWalk;
         let jumpValue = unit.jump;
         let UMUValue = unit.umu;
         let moveImpaired = false;
@@ -1669,7 +1696,7 @@ export class MekRules extends UnitTypeRulesBase {
         const internalLocations = systemsStatus.internalLocations;
         const legMovement = this.applyLegDamageToMovement(
             walkValue,
-            unit.run,
+            restoredRun,
             systemsStatus,
             internalLocations.has('LL') && internalLocations.has('RL'),
             internalLocations.has('RLL') && internalLocations.has('FLL')
@@ -1681,7 +1708,7 @@ export class MekRules extends UnitTypeRulesBase {
             walkValue -= systemsStatus.destroyedLegActuatorsCount;
             walkValue -= systemsStatus.destroyedFeetCount;
         }
-        walkValue = Math.max(0, Math.min(unit.walk, walkValue));
+        walkValue = Math.max(0, Math.min(restoredWalk, walkValue));
         if (systemsStatus.destroyedLegActuatorsCount != 0 || systemsStatus.destroyedFeetCount != 0) {
             moveImpaired = true;
         }
@@ -1703,6 +1730,7 @@ export class MekRules extends UnitTypeRulesBase {
         }
 
         return {
+            baselineWalk: restoredWalk,
             walk: walkValue,
             runDisabled: legMovement.runDisabled,
             runCap: legMovement.runCap,
@@ -1714,6 +1742,33 @@ export class MekRules extends UnitTypeRulesBase {
         };
     }
 
+    private restoredEquipmentWalkMP(): number {
+        const modularArmor = this.modularArmorState();
+        const config = inferMekConfigFromLocations(this.unit.locations?.internal.keys() ?? []);
+        const shields = config === 'Quad'
+            ? []
+            : this.unit.getInventory().filter(entry =>
+                entry.equipment?.hasFlag('F_SHIELD')
+                && entry.equipment.hasAnyFlag(['S_SHIELD_LARGE', 'S_SHIELD_MEDIUM']));
+        return (modularArmor.installed && !modularArmor.active ? 1 : 0)
+            + shields.filter(entry => !this.shieldRetainsMobilityPenalty(entry)).length;
+    }
+
+    private modularArmorState(): { installed: boolean; active: boolean } {
+        const panels = this.unit.getCritSlots().filter(slot =>
+            slot.eq?.hasFlag('F_MODULAR_ARMOR') || this.isNamedCrit(slot, 'Modular Armor'));
+        return {
+            installed: panels.length > 0,
+            active: panels.some(slot => !this.isCritUnavailable(slot) && (slot.consumed ?? 0) < 10),
+        };
+    }
+
+    protected shieldRetainsMobilityPenalty(entry: MountedEquipment): boolean {
+        // Core shields stop imposing their Mobility Modifier as soon as either
+        // current DA or DC reaches 0. Equipment status already evaluates both.
+        return this.unit.isEquipmentOperational(entry);
+    }
+
     protected applyLegDamageToMovement(
         walk: number,
         unitRun: number,
@@ -1749,6 +1804,7 @@ export class MekRules extends UnitTypeRulesBase {
             } else if (damage.destroyedLegsCount === 3) {
                 walk = Math.min(walk, 1);
                 runCap = Math.min(unitRun, 2);
+                applyActuatorDamage = false;
             } else {
                 walk = 0;
                 runDisabled = true;
@@ -1833,7 +1889,7 @@ export class MekRules extends UnitTypeRulesBase {
         }
 
         return {
-            moveImpaired: baseMovement.moveImpaired || (walkValue < unit.walk),
+            moveImpaired: baseMovement.moveImpaired || (walkValue < baseMovement.baselineWalk),
             walk: walkValue,
             maxWalk: maxWalkValue,
             run: runValue,
diff --git a/src/app/models/rules/tw-rules.ts b/src/app/models/rules/tw-rules.ts
index 1f98cfb3b..c07320c80 100644
--- a/src/app/models/rules/tw-rules.ts
+++ b/src/app/models/rules/tw-rules.ts
@@ -15,6 +15,7 @@ import { C3TaxCalculator } from '../c3-network.model';
 import { getMekLimbLocations, inferMekConfigFromLocations, LEG_LOCATIONS, MEK_SIDE_TORSO_LOCATIONS, MEK_TORSO_LOCATIONS, QUAD_LEG_LOCATIONS, type MekConfig } from '../entity/types';
 import type { TurnState } from '../turn-state.model';
 import type { Equipment } from '../equipment.model';
+import type { MountedEquipment } from '../mounted-equipment.model';
 
 function calculateTWC3Tax(
     unit: CBTForceUnit,
@@ -62,25 +63,31 @@ export class TWMekRules extends MekRules {
     protected override get shieldBashPunchBonusEnabled(): boolean { return false; }
     protected override get standaloneShieldDamageEnabled(): boolean { return true; }
 
-    /** If more legs are destroyed, the unit simply can't stand up at all */
-    protected override maximumDestroyedLegsForStanding(config: MekConfig): number {
+    protected override shieldRetainsMobilityPenalty(entry: MountedEquipment): boolean {
+        if (entry.committedDestroyed()) return false;
+        const criticals = this.entryCriticalSlots(entry);
+        if (criticals.length === 0) {
+            return this.unit.getEquipmentInstallationLocationStatus(entry) === 'available';
+        }
+        // TW retains the modifier until every shield critical is unavailable.
+        // Critical status also accounts for a committed destroyed/blown-off arm.
+        return criticals.some(slot => this.unit.isEquipmentOperational(slot));
+    }
+
+    protected override destroyedLegStandThreshold(config: MekConfig): number {
         return config === 'Quad' ? 2 : 1;
     }
 
-    /** Limit how many attempts can be made to stand up */
-    protected override destroyedLegStandAttemptLimit(config: MekConfig, destroyedLegs: number): number | null {
-        return destroyedLegs === (config === 'Quad' ? 2 : 1) ? 1 : null;
+    override getStandAttemptLimit(_turnState: TurnState): number | null {
+        const { config, destroyedLegs } = this.currentLegState();
+        return this.isDestroyedLegStandException(config, destroyedLegs.length) ? 1 : null;
     }
 
     protected override isMovementPSRFoldedIntoStandAttempt(turnState: TurnState): boolean {
         const { config, destroyedLegs } = this.currentLegState();
         return (turnState.standAttempts() ?? 0) > 0
             && (turnState.moveDistance() ?? 0) === 0
-            && destroyedLegs.length === (config === 'Quad' ? 2 : 1);
-    }
-
-    protected override destroyedLegStandAttemptRequiresRunning(config: MekConfig, destroyedLegs: number): boolean {
-        return destroyedLegs === (config === 'Quad' ? 2 : 1);
+            && this.isDestroyedLegStandException(config, destroyedLegs.length);
     }
 
     override heatLifeSupportPilotHits(heat: number): number {
@@ -298,6 +305,27 @@ export class TWMekRules extends MekRules {
         return { fallCheck: 100, pilotCheck: 5 };
     }
 
+    protected override getPreExistingDestroyedLegPSRModifiers(
+        config: MekConfig,
+        destroyedLegs: readonly string[],
+    ): PSRCheck[] {
+        if (config !== 'Quad') return super.getPreExistingDestroyedLegPSRModifiers(config, destroyedLegs);
+        if (destroyedLegs.length !== 2) return [];
+        return [{
+            pilotCheck: 5,
+            reason: 'Leg Destroyed',
+            modifierReason: 'Legs Destroyed (2)',
+        }];
+    }
+
+    protected override destroyedLegMovementPSRModifier(
+        moveMode: 'run' | 'jump',
+        isQuadruped: boolean,
+        destroyedLegsCount: number,
+    ): number {
+        return moveMode === 'jump' && isQuadruped && destroyedLegsCount === 1 ? 5 : 0;
+    }
+
     protected override damagedLegRequiresMovementCheck(_isQuadruped: boolean, destroyedLegsCount: number): boolean {
         return destroyedLegsCount > 0;
     }
@@ -306,10 +334,6 @@ export class TWMekRules extends MekRules {
         return false;
     }
 
-    protected override runningMinimumMovementWithDestroyedLegRequiresCheck(): boolean {
-        return this.getRunningMinimumMovementDistance() > 0;
-    }
-
     protected override runningDamageCheckRequiresHexMovement(): boolean {
         return false;
     }
@@ -338,9 +362,15 @@ export class TWMekRules extends MekRules {
         let moveImpaired = false;
 
         if (isBiped) {
-            for (let index = 0; index < damage.destroyedHipsCount; index++) {
-                walk = Math.ceil(walk * 0.5);
+            if (damage.destroyedHipsCount === 2) {
+                walk = 0;
                 moveImpaired = true;
+                runDisabled = true;
+            } else {
+                for (let index = 0; index < damage.destroyedHipsCount; index++) {
+                    walk = Math.ceil(walk * 0.5);
+                    moveImpaired = true;
+                }
             }
             if (damage.destroyedLegsCount === 1) {
                 walk = Math.min(walk, 1);
@@ -352,10 +382,6 @@ export class TWMekRules extends MekRules {
                 runDisabled = true;
             }
         } else if (isQuadruped) {
-            if (damage.destroyedHipsCount !== 0) {
-                walk -= damage.destroyedHipsCount;
-                moveImpaired = true;
-            }
             if (damage.destroyedLegsCount === 1) walk--;
             if (damage.destroyedLegsCount === 2) {
                 walk = Math.min(walk, 1);
@@ -364,6 +390,17 @@ export class TWMekRules extends MekRules {
                 walk = 0;
                 runDisabled = true;
             }
+            
+            if (damage.destroyedHipsCount === 4) {
+                walk = 0;
+                moveImpaired = true;
+                runDisabled = true;
+            } else {
+                for (let index = 0; index < damage.destroyedHipsCount && walk > 0; index++) {
+                    walk = Math.ceil(walk * 0.5);
+                    moveImpaired = true;
+                }
+            }
         }
 
         return { walk, runDisabled, runCap: null, moveImpaired, applyActuatorDamage: true };
diff --git a/src/app/models/rules/unit-type-rules.ts b/src/app/models/rules/unit-type-rules.ts
index bad9978e5..97aae62c9 100644
--- a/src/app/models/rules/unit-type-rules.ts
+++ b/src/app/models/rules/unit-type-rules.ts
@@ -396,8 +396,8 @@ export interface UnitTypeRules {
     /** Unit-type-specific minimum movement distance override. Return null to use 0. */
     getMinDistanceForMoveMode(moveMode: MotiveModes): number | null;
 
-    /** Unit-type-specific movement mode availability, optionally for the current turn context. */
-    isMotiveModeAvailable(moveMode: MotiveModes, turnState?: TurnState): boolean;
+    /** Unit-type-specific movement mode availability. */
+    isMotiveModeAvailable(moveMode: MotiveModes): boolean;
 
     /** Unit-type-specific attack movement modifier. */
     getAttackMovementModifier(moveMode: MotiveModes | null | undefined, airborne?: boolean): number;
@@ -760,7 +760,7 @@ export abstract class UnitTypeRulesBase implements UnitTypeRules {
         return null;
     }
 
-    isMotiveModeAvailable(_moveMode: MotiveModes, _turnState?: TurnState): boolean {
+    isMotiveModeAvailable(_moveMode: MotiveModes): boolean {
         return true;
     }
 
diff --git a/src/app/services/unit-svg-mek.service.ts b/src/app/services/unit-svg-mek.service.ts
index 48dd9bc68..191f33511 100644
--- a/src/app/services/unit-svg-mek.service.ts
+++ b/src/app/services/unit-svg-mek.service.ts
@@ -275,8 +275,7 @@ export class UnitSvgMekService extends UnitSvgService {
         const movement = this.mekRules.movementState();
         if (!movement) return;
 
-        const turnState = this.unit.turnState();
-        const runWarning = this.unit.rules.isMotiveModeAvailable('run', turnState)
+        const runWarning = this.unit.rules.isMotiveModeAvailable('run')
             ? this.unit.rules.getCommittedDamageMovementModePSRCheck('run')
             : null;
         const jumpWarning = movement.jump > 0 ? this.unit.rules.getCommittedDamageMovementModePSRCheck('jump') : null;

From c512ce836f202b9850d958f3b1ab3c86802bb3eb Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Wed, 19 Aug 2026 21:01:31 +0200
Subject: [PATCH 04/12] shield and hip fix for tripod

---
 .../page-viewer/svg-interaction.service.ts    |  16 ++-
 src/app/models/rules/mek-rules.spec.ts        |  35 ++++++
 src/app/models/rules/mek-rules.ts             | 103 ++++++++++++++----
 src/app/models/rules/tw-rules.ts              |   6 +-
 src/app/services/unit-svg-mek.service.ts      |  15 ++-
 5 files changed, 144 insertions(+), 31 deletions(-)

diff --git a/src/app/components/page-viewer/svg-interaction.service.ts b/src/app/components/page-viewer/svg-interaction.service.ts
index 2797b98e6..b7490398c 100644
--- a/src/app/components/page-viewer/svg-interaction.service.ts
+++ b/src/app/components/page-viewer/svg-interaction.service.ts
@@ -47,6 +47,7 @@ import { MekCriticalChanceDialogComponent, type MekCriticalChanceDialogData } fr
 import { MekCriticalRollDialogComponent, type MekCriticalRollDialogData } from './mek-critical-roll-dialog.component';
 import { applyMekBlowOff, canApplyMekCriticalHitToSlot, mekCriticalChanceCanBlowOff, mekCriticalChanceModifiers, type MekCriticalChanceResult } from '../../utils/mek-critical-hit.util';
 import { uidTranslations } from '../../models/common.model';
+import type { MekRules } from '../../models/rules/mek-rules';
 
 type SheetInventoryRangeKey = InventoryRangeKey | 'extreme';
 type HeatMarkerData = { el: SVGElement | null, heat: number; baselineHeat: number };
@@ -636,13 +637,20 @@ export class SvgInteractionService {
                 pipsCount = 0;
             }
 
-            const getHits = () => {
+            const getStoredHits = () => {
                 if (isStructure) {
                     return this.unit()?.getInternalHits(loc) || 0;
                 } else {
                     return (this.unit()?.getArmorHits(loc, rear) || 0);
                 }
-            }
+            };
+            const getHits = () => {
+                const unit = this.unit();
+                if (isShield && unit?.getUnit().type === 'Mek') {
+                    return (unit.rules as MekRules).getShieldTrackHits(loc, true) ?? getStoredHits();
+                }
+                return getStoredHits();
+            };
 
             const armorToastId = `${this.unit()?.id}-${isStructure ? 'structure' : 'armor'}-${loc}-${rear ? 'rear' : ''}`;
             let lastAmountVariationTimestamp = 0;
@@ -719,7 +727,9 @@ export class SvgInteractionService {
                 };
                 const title = `${loc}${rear ? ' (Rear)' : ''}`;
                 const position = { x, y };
-                const startValue = - getHits() - consumedModularArmorPoints;
+                // Critical/actuator shield losses are derived and cannot be
+                // repaired by erasing ordinary damage from the DA/DC track.
+                const startValue = -getStoredHits() - consumedModularArmorPoints;
                 const remainingArmorPoints = Math.max(0, pipsCount - getHits() + availableModularArmorPoints);
                 const internalPoints = !isStructure && !isShield ? (this.unit()?.getInternalPoints(loc) ?? 0) : 0;
                 const remainingInternalPoints = Math.max(0, internalPoints - (this.unit()?.getInternalHits(loc) ?? 0));
diff --git a/src/app/models/rules/mek-rules.spec.ts b/src/app/models/rules/mek-rules.spec.ts
index 52472ddec..b06d0f0bb 100644
--- a/src/app/models/rules/mek-rules.spec.ts
+++ b/src/app/models/rules/mek-rules.spec.ts
@@ -343,6 +343,8 @@ function createShieldHarness(
             { ...crit('Triple Strength Myomer', false), loc: 'RT', slot: 0, eq: tsm },
         ],
     });
+    forceUnit.locations!.armor.set('DALA', { loc: 'DALA', rear: false, points: 5 });
+    forceUnit.locations!.armor.set('DCLA', { loc: 'DCLA', rear: false, points: 18 });
     const currentShieldCriticals = forceUnit.getCritSlots().filter(slot => slot.eq === shieldEquipment);
     forceUnit.setInventory([new MountedEquipment({
         owner: forceUnit,
@@ -1065,6 +1067,39 @@ describe('MekRules', () => {
         expect(depletedCore.forceUnit.isEquipmentOperational(depletedCore.shield)).toBeFalse();
     });
 
+    it('subtracts 1 DA and 5 DC for every destroyed shield critical in both rulesets', () => {
+        for (const rulesId of ['core2026', 'tw'] as const) {
+            const { forceUnit } = createShieldHarness(rulesId, 1);
+            const rules = forceUnit.rules as MekRules;
+
+            expect(rules.getShieldTrackHits('DALA')).withContext(`${rulesId} DA`).toBe(1);
+            expect(rules.getShieldTrackHits('DCLA')).withContext(`${rulesId} DC`).toBe(5);
+        }
+    });
+
+    it('uses exhausted DA or DC for Core shield mobility but retains the TW modifier', () => {
+        for (const track of ['DALA', 'DCLA'] as const) {
+            const core = createShieldHarness('core2026');
+            const tw = createShieldHarness('tw');
+            const hits = core.forceUnit.getArmorPoints(track);
+            core.forceUnit.setArmorHits(track, hits);
+            tw.forceUnit.setArmorHits(track, hits);
+
+            expect((core.forceUnit.rules as MekRules).movementState())
+                .withContext(`Core ${track}`)
+                .toEqual(jasmine.objectContaining({ walk: 6, run: 9 }));
+            expect(core.forceUnit.isEquipmentOperational(core.shield))
+                .withContext(`Core ${track}`)
+                .toBeFalse();
+            expect((tw.forceUnit.rules as MekRules).movementState())
+                .withContext(`TW ${track}`)
+                .toEqual(jasmine.objectContaining({ walk: 5, run: 8 }));
+            expect(tw.forceUnit.isEquipmentOperational(tw.shield))
+                .withContext(`TW ${track}`)
+                .toBeFalse();
+        }
+    });
+
     it('removes the shield mobility modifier at the ruleset-specific destruction threshold', () => {
         const coreZeroCapacity = createShieldHarness('core2026', 4);
         const twOneCriticalRemaining = createShieldHarness('tw', 4);
diff --git a/src/app/models/rules/mek-rules.ts b/src/app/models/rules/mek-rules.ts
index 873b8590b..2f292576a 100644
--- a/src/app/models/rules/mek-rules.ts
+++ b/src/app/models/rules/mek-rules.ts
@@ -1764,9 +1764,10 @@ export class MekRules extends UnitTypeRulesBase {
     }
 
     protected shieldRetainsMobilityPenalty(entry: MountedEquipment): boolean {
-        // Core shields stop imposing their Mobility Modifier as soon as either
-        // current DA or DC reaches 0. Equipment status already evaluates both.
-        return this.unit.isEquipmentOperational(entry);
+        // Core removes the Mobility Modifier as soon as either live shield
+        // track reaches 0. TW deliberately overrides this with its all-slots rule.
+        const state = this.getShieldDamageState(entry);
+        return state !== null && state.absorption > 0 && state.capacity > 0;
     }
 
     protected applyLegDamageToMovement(
@@ -2446,9 +2447,9 @@ export class MekRules extends UnitTypeRulesBase {
         for (const entry of this.unit.getMountedEquipmentByFlag('F_SHIELD')) {
             const profile = resolveShieldProfile(entry.equipment);
             if (!profile || !this.shieldMountsAt(entry, loc)) continue;
-            // Equipment status is committed-only and already owns mount, location, critical, and shield-capacity
-            // destruction. In particular, a pending hit must not remove the bonus before damage is committed.
-            if (this.unit.getEquipmentStatus(entry) === 'destroyed') continue;
+            // Pending damage must not remove the committed bonus early.
+            const state = this.getShieldDamageState(entry);
+            if (!state || state.absorption === 0 || state.capacity === 0) continue;
             return profile.bashBonus;
         }
         return 0;
@@ -2456,35 +2457,91 @@ export class MekRules extends UnitTypeRulesBase {
 
     private currentShieldDamageAbsorption(
         entry: MountedEquipment,
-        loc: ArmLocation | undefined,
-        profile: ShieldProfile,
+        _loc: ArmLocation | undefined,
+        _profile: ShieldProfile,
     ): number {
-        return this.shieldDamageState(
-            profile,
-            this.shieldCriticalSlots(entry, loc).filter(slot => !!slot.destroyed).length,
-            loc,
-        ).absorption;
+        return this.getShieldDamageState(entry)?.absorption ?? 0;
+    }
+
+    /**
+     * Effective damage shown on a shield DA/DC track. Critical-slot and arm
+     * actuator losses are derived rather than persisted as ordinary shield
+     * hits, so repairing a critical cannot accidentally repair combat damage.
+     */
+    getShieldTrackHits(trackLocation: string, includePending = false): number | null {
+        const match = /^(DA|DC)(LA|RA)$/.exec(trackLocation);
+        if (!match) return null;
+
+        const track = match[1] as 'DA' | 'DC';
+        const loc = match[2] as ArmLocation;
+        const entry = this.unit.getMountedEquipmentByFlag('F_SHIELD')
+            .find(candidate => this.shieldMountsAt(candidate, loc));
+        if (!entry) return null;
+
+        const profile = resolveShieldProfile(entry.equipment);
+        const state = this.getShieldDamageState(entry, includePending);
+        if (!profile || !state) return null;
+        const maximum = track === 'DA' ? profile.damageAbsorption : profile.damageCapacity;
+        const remaining = track === 'DA' ? state.absorption : state.capacity;
+        return Math.min(maximum, Math.max(0, maximum - remaining));
+    }
+
+    private getShieldDamageState(
+        entry: MountedEquipment,
+        includePending = false,
+    ): { absorption: number; capacity: number } | null {
+        const profile = resolveShieldProfile(entry.equipment);
+        if (!profile) return null;
+
+        const loc = this.shieldArmLocation(entry);
+        const mountUnavailable = entry.committedDestroyed() || (includePending && entry.isDestroying());
+        const locationUnavailable = loc !== undefined && (includePending
+            ? this.unit.isInternalLocDestroyed(loc)
+            : this.unit.isInternalLocCommittedDestroyed(loc));
+        if (mountUnavailable || locationUnavailable) return { absorption: 0, capacity: 0 };
+
+        const destroyedCriticalCount = this.shieldCriticalSlots(entry, loc)
+            .filter(slot => includePending ? this.isDestroyedOrDestroyingCrit(slot) : !!slot.destroyed)
+            .length;
+        return this.shieldDamageState(profile, destroyedCriticalCount, loc, includePending);
     }
 
     private shieldDamageState(
         profile: ShieldProfile,
         destroyedCriticalCount: number,
         loc: ArmLocation | undefined,
+        includePending = false,
     ): { absorption: number; capacity: number } {
-        let actuatorPenalty = 0;
-        if (loc) {
-            const armStatus = this.systemsStatus().locationModifiers[loc];
-            if (armStatus?.destroyedShoulder) actuatorPenalty += 2;
-            if (armStatus?.destroyedUpperArms) actuatorPenalty++;
-            if (armStatus?.destroyedLowerArms) actuatorPenalty++;
-            if (armStatus?.destroyedHand) actuatorPenalty++;
-        }
+        const actuatorPenalty = loc ? this.shieldActuatorPenalty(loc, includePending) : 0;
+        const absorptionHits = loc
+            ? (includePending ? this.unit.getArmorHits(`DA${loc}`) : this.unit.getCommittedArmorHits(`DA${loc}`))
+            : 0;
+        const capacityHits = loc
+            ? (includePending ? this.unit.getArmorHits(`DC${loc}`) : this.unit.getCommittedArmorHits(`DC${loc}`))
+            : 0;
         return {
-            absorption: Math.max(0, profile.damageAbsorption - destroyedCriticalCount - actuatorPenalty),
-            capacity: Math.max(0, profile.damageCapacity - (destroyedCriticalCount * 5) - actuatorPenalty),
+            absorption: Math.max(0, profile.damageAbsorption - destroyedCriticalCount - actuatorPenalty - absorptionHits),
+            capacity: Math.max(0, profile.damageCapacity - (destroyedCriticalCount * 5) - actuatorPenalty - capacityHits),
         };
     }
 
+    private shieldActuatorPenalty(loc: ArmLocation, includePending: boolean): number {
+        if (!includePending) {
+            const armStatus = this.systemsStatus().locationModifiers[loc];
+            return (armStatus?.destroyedShoulder ? 2 : 0)
+                + (armStatus?.destroyedUpperArms ? 1 : 0)
+                + (armStatus?.destroyedLowerArms ? 1 : 0)
+                + (armStatus?.destroyedHand ? 1 : 0);
+        }
+
+        const unavailable = (name: string) => this.unit.getCritSlots().some(slot =>
+            slot.loc === loc && this.isNamedCrit(slot, name) && this.isDestroyedOrDestroyingCrit(slot));
+        return (unavailable('Shoulder') ? 2 : 0)
+            + (unavailable('Upper Arm') ? 1 : 0)
+            + (unavailable('Lower Arm') ? 1 : 0)
+            + (unavailable('Hand') ? 1 : 0);
+    }
+
     private shieldCriticalSlots(entry: MountedEquipment, loc?: string): CriticalSlot[] {
         return this.entryCriticalSlots(entry).filter(slot => !loc || slot.loc === loc);
     }
diff --git a/src/app/models/rules/tw-rules.ts b/src/app/models/rules/tw-rules.ts
index c07320c80..0436ebddf 100644
--- a/src/app/models/rules/tw-rules.ts
+++ b/src/app/models/rules/tw-rules.ts
@@ -362,7 +362,7 @@ export class TWMekRules extends MekRules {
         let moveImpaired = false;
 
         if (isBiped) {
-            if (damage.destroyedHipsCount === 2) {
+            if (damage.destroyedHipsCount >= 2) {
                 walk = 0;
                 moveImpaired = true;
                 runDisabled = true;
@@ -390,8 +390,8 @@ export class TWMekRules extends MekRules {
                 walk = 0;
                 runDisabled = true;
             }
-            
-            if (damage.destroyedHipsCount === 4) {
+
+            if (damage.destroyedHipsCount >= 4) {
                 walk = 0;
                 moveImpaired = true;
                 runDisabled = true;
diff --git a/src/app/services/unit-svg-mek.service.ts b/src/app/services/unit-svg-mek.service.ts
index 191f33511..5864d7c44 100644
--- a/src/app/services/unit-svg-mek.service.ts
+++ b/src/app/services/unit-svg-mek.service.ts
@@ -454,7 +454,12 @@ export class UnitSvgMekService extends UnitSvgService {
                 if (!loc || !linkedLoc) return;
                 if (!shieldInfo[loc]) {
                     const d = locations[loc];
-                    shieldInfo[loc] = { committed: d?.armor ?? 0, total: (d?.armor ?? 0) + (d?.pendingArmor ?? 0), idx: 0 };
+                    shieldInfo[loc] = {
+                        committed: this.mekRules.getShieldTrackHits(loc) ?? d?.armor ?? 0,
+                        total: this.mekRules.getShieldTrackHits(loc, true)
+                            ?? (d?.armor ?? 0) + (d?.pendingArmor ?? 0),
+                        idx: 0,
+                    };
                 }
                 const s = shieldInfo[loc];
                 this.updatePip(pip, ++s.idx, s.committed, s.total, initial);
@@ -464,7 +469,13 @@ export class UnitSvgMekService extends UnitSvgService {
             this.unit.locations?.armor.forEach(entry => {
                 const el = svg.querySelector(`.shield:not(.pip)[loc="${entry.loc}"]`);
                 if (!el) return;
-                const shieldExhausted = this.unit.isArmorLocDestroyed('DC' + entry.loc) || this.unit.isArmorLocDestroyed('DA' + entry.loc);
+                const shieldExhausted = ['DA', 'DC'].some(prefix => {
+                    const trackLoc = `${prefix}${entry.loc}`;
+                    const points = this.unit.getArmorPoints(trackLoc);
+                    const hits = this.mekRules.getShieldTrackHits(trackLoc, true)
+                        ?? this.unit.getArmorHits(trackLoc);
+                    return points > 0 && hits >= points;
+                });
                 if (shieldExhausted || this.unit.isInternalLocDestroyed(entry.loc)) {
                     el.classList.add('damaged');
                 } else {

From eef73efa08a708165791f5cd3800a8aef5b95d00 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Wed, 19 Aug 2026 21:02:26 +0200
Subject: [PATCH 05/12] shield

---
 src/app/models/rules/mek-rules.spec.ts | 31 ++++++++++++++++++++++++++
 src/app/models/rules/mek-rules.ts      | 10 +--------
 2 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/src/app/models/rules/mek-rules.spec.ts b/src/app/models/rules/mek-rules.spec.ts
index b06d0f0bb..92dc05329 100644
--- a/src/app/models/rules/mek-rules.spec.ts
+++ b/src/app/models/rules/mek-rules.spec.ts
@@ -3373,6 +3373,37 @@ describe('MekRules', () => {
         expect(rules.movementState()).toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
     });
 
+    it('reduces TW ground MP to zero at the terminal hip threshold without making the Mek immobile', () => {
+        const scenarios = [
+            { name: 'biped', locations: ['LL', 'RL'], hips: ['LL', 'RL'] },
+            { name: 'tripod', locations: ['LL', 'RL', 'CL'], hips: ['LL', 'RL'] },
+            { name: 'tripod past threshold', locations: ['LL', 'RL', 'CL'], hips: ['LL', 'RL', 'CL'] },
+            { name: 'quad', locations: ['RLL', 'FLL', 'RRL', 'FRL'], hips: ['RLL', 'FLL', 'RRL', 'FRL'] },
+        ];
+
+        for (const scenario of scenarios) {
+            const forceUnit = createForceUnitHarness({
+                internalLocations: scenario.locations,
+                critSlots: scenario.hips.map((loc, index) => ({
+                    ...crit('Hip'),
+                    id: `${loc}-hip`,
+                    loc,
+                    slot: index,
+                })),
+                rulesId: 'tw',
+                walk: 5,
+                run: 8,
+            });
+
+            expect((forceUnit.rules as MekRules).movementState())
+                .withContext(scenario.name)
+                .toEqual(jasmine.objectContaining({ walk: 0, run: 0, moveImpaired: true }));
+            expect(forceUnit.rules.hasComputedCondition('immobile'))
+                .withContext(scenario.name)
+                .toBeFalse();
+        }
+    });
+
     it('keeps the Core Quad two-leg hip-equivalent run trigger to one PSR', () => {
         const forceUnit = createForceUnitHarness({
             internalLocations: ['RLL', 'FLL', 'RRL', 'FRL'],
diff --git a/src/app/models/rules/mek-rules.ts b/src/app/models/rules/mek-rules.ts
index 2f292576a..ce6add3f5 100644
--- a/src/app/models/rules/mek-rules.ts
+++ b/src/app/models/rules/mek-rules.ts
@@ -2059,7 +2059,7 @@ export class MekRules extends UnitTypeRulesBase {
                 ? { damage, text: `+${damage}`, weakened: false }
                 : { damage: null, text: '—', weakened: false };
         }
-        const damage = this.currentShieldDamageAbsorption(entry, location, profile);
+        const damage = this.getShieldDamageState(entry)?.absorption ?? 0;
         return {
             damage,
             text: `${damage}`,
@@ -2455,14 +2455,6 @@ export class MekRules extends UnitTypeRulesBase {
         return 0;
     }
 
-    private currentShieldDamageAbsorption(
-        entry: MountedEquipment,
-        _loc: ArmLocation | undefined,
-        _profile: ShieldProfile,
-    ): number {
-        return this.getShieldDamageState(entry)?.absorption ?? 0;
-    }
-
     /**
      * Effective damage shown on a shield DA/DC track. Critical-slot and arm
      * actuator losses are derived rather than persisted as ordinary shield

From f0c8f8d87598e109d70fb770ae0c0c51e45ebd80 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Wed, 19 Aug 2026 21:03:36 +0200
Subject: [PATCH 06/12] shield helper

---
 src/app/models/rules/mek-rules.ts | 8 +++++++-
 src/app/models/rules/tw-rules.ts  | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/app/models/rules/mek-rules.ts b/src/app/models/rules/mek-rules.ts
index ce6add3f5..04d6b6a28 100644
--- a/src/app/models/rules/mek-rules.ts
+++ b/src/app/models/rules/mek-rules.ts
@@ -1765,11 +1765,17 @@ export class MekRules extends UnitTypeRulesBase {
 
     protected shieldRetainsMobilityPenalty(entry: MountedEquipment): boolean {
         // Core removes the Mobility Modifier as soon as either live shield
-        // track reaches 0. TW deliberately overrides this with its all-slots rule.
+        // track reaches 0, or when the shield itself has no surviving slot.
+        if (entry.committedDestroyed() || this.allShieldCriticalsUnavailable(entry)) return false;
         const state = this.getShieldDamageState(entry);
         return state !== null && state.absorption > 0 && state.capacity > 0;
     }
 
+    protected allShieldCriticalsUnavailable(entry: MountedEquipment): boolean {
+        const criticals = this.entryCriticalSlots(entry);
+        return criticals.length > 0 && criticals.every(slot => !this.unit.isEquipmentOperational(slot));
+    }
+
     protected applyLegDamageToMovement(
         walk: number,
         unitRun: number,
diff --git a/src/app/models/rules/tw-rules.ts b/src/app/models/rules/tw-rules.ts
index 0436ebddf..4cd907f1e 100644
--- a/src/app/models/rules/tw-rules.ts
+++ b/src/app/models/rules/tw-rules.ts
@@ -71,7 +71,7 @@ export class TWMekRules extends MekRules {
         }
         // TW retains the modifier until every shield critical is unavailable.
         // Critical status also accounts for a committed destroyed/blown-off arm.
-        return criticals.some(slot => this.unit.isEquipmentOperational(slot));
+        return !this.allShieldCriticalsUnavailable(entry);
     }
 
     protected override destroyedLegStandThreshold(config: MekConfig): number {

From fc7b7b99a1dc5151057959280b9cdca0e6906cf8 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Wed, 19 Aug 2026 23:11:21 +0200
Subject: [PATCH 07/12] destroy shield = restore jump MP, fixed foot actuator
 PSR modifier in Core

---
 src/app/models/cbt-force-unit.model.ts |  13 +-
 src/app/models/rules/mek-rules.spec.ts | 208 +++++++++++++++++++++++--
 src/app/models/rules/mek-rules.ts      | 118 ++++++++++----
 src/app/models/rules/tw-rules.spec.ts  |  14 ++
 4 files changed, 307 insertions(+), 46 deletions(-)

diff --git a/src/app/models/cbt-force-unit.model.ts b/src/app/models/cbt-force-unit.model.ts
index 95230a4dc..1e0bcd076 100644
--- a/src/app/models/cbt-force-unit.model.ts
+++ b/src/app/models/cbt-force-unit.model.ts
@@ -25,7 +25,7 @@ import type { EquipmentFlag } from './equipment-flags.type';
 import type { WeaponType } from './weapon-types.model';
 import { C3Capabilities, type C3Component, C3NetworkType, C3Role } from './c3-network.model';
 import { isC3DisruptingStealthActive } from './stealth-equipment.model';
-import { getMotiveModesOptionsByUnit, type MotiveModeOption } from './motiveModes.model';
+import { getMotiveModeLabel, getMotiveModesOptionsByUnit, type MotiveModeOption, type MotiveModes } from './motiveModes.model';
 import type { TurnState } from './turn-state.model';
 import { Sanitizer } from '../utils/sanitizer.util';
 import type { UnitTypeRules } from './rules/unit-type-rules';
@@ -1575,7 +1575,16 @@ export class CBTForceUnit extends ForceUnit {
 
     public getAvailableMotiveModes(airborne: boolean): MotiveModeOption[] {
         const turnState = this.turnState();
-        return getMotiveModesOptionsByUnit(this.getUnit(), airborne)
+        const unit = this.getUnit();
+        const options = getMotiveModesOptionsByUnit(unit, airborne);
+        for (const mode of ['jump', 'UMU'] satisfies MotiveModes[]) {
+            if ((mode !== 'jump' || !airborne)
+                && !options.some(option => option.mode === mode)
+                && (this._rules.getMaxDistanceForMoveMode(mode) ?? 0) > 0) {
+                options.push({ mode, label: getMotiveModeLabel(mode, unit, airborne) });
+            }
+        }
+        return options
             .filter(option => this._rules.isMotiveModeAvailable(option.mode))
             .map(option => ({
                 ...option,
diff --git a/src/app/models/rules/mek-rules.spec.ts b/src/app/models/rules/mek-rules.spec.ts
index 92dc05329..53d7ac931 100644
--- a/src/app/models/rules/mek-rules.spec.ts
+++ b/src/app/models/rules/mek-rules.spec.ts
@@ -357,6 +357,72 @@ function createShieldHarness(
     return { forceUnit, shield: forceUnit.getInventory()[0] };
 }
 
+function createShieldPropulsionHarness(
+    rulesId: 'core2026' | 'tw',
+    size: 'medium' | 'large',
+    destroyedShieldCriticals = 0,
+): { forceUnit: CBTForceUnit; shield: MountedEquipment } {
+    const large = size === 'large';
+    const shieldEquipment = miscEquipment(
+        large ? 'ISLargeShield' : 'ISMediumShield',
+        large ? 'Shield (Large)' : 'Shield (Medium)',
+        ['F_SHIELD', large ? 'S_SHIELD_LARGE' : 'S_SHIELD_MEDIUM'],
+    );
+    const jumpJet = miscEquipment('ISJumpJet', 'Jump Jet', ['F_JUMP_JET']);
+    const umu = miscEquipment('ISUMU', 'UMU', ['F_UMU']);
+    const shieldCriticalCount = large ? 7 : 5;
+    const shieldCriticals: CriticalSlot[] = Array.from({ length: shieldCriticalCount }, (_, index) => ({
+        ...crit(shieldEquipment.name, index < destroyedShieldCriticals),
+        id: `${shieldEquipment.id}@LA#${index + 4}`,
+        loc: 'LA',
+        slot: index + 4,
+        eq: shieldEquipment,
+    }));
+    const forceUnit = createForceUnitHarness({
+        rulesId,
+        walk: 4,
+        run: 6,
+        jump: large ? 0 : 2,
+        umu: large ? 0 : 2,
+        internalLocations: ['LA', 'RA', 'LT', 'RT', 'LL', 'RL'],
+        critSlots: [
+            ...armCritSlots('LA'),
+            ...armCritSlots('RA'),
+            ...shieldCriticals,
+            ...Array.from({ length: 3 }, (_, index) => ({
+                ...crit('Jump Jet', false),
+                id: `jump-jet-${index}`,
+                loc: 'LT',
+                slot: index,
+                eq: jumpJet,
+            })),
+            ...Array.from({ length: 2 }, (_, index) => ({
+                ...crit('UMU', false),
+                id: `umu-${index}`,
+                loc: 'RT',
+                slot: index,
+                eq: umu,
+            })),
+        ],
+    });
+    forceUnit.locations!.armor.set('DALA', {
+        loc: 'DALA', rear: false, points: large ? 7 : 5,
+    });
+    forceUnit.locations!.armor.set('DCLA', {
+        loc: 'DCLA', rear: false, points: large ? 25 : 18,
+    });
+    const currentShieldCriticals = forceUnit.getCritSlots().filter(slot => slot.eq === shieldEquipment);
+    forceUnit.setInventory([new MountedEquipment({
+        owner: forceUnit,
+        id: `${shieldEquipment.id}@LA`,
+        name: shieldEquipment.name,
+        equipment: shieldEquipment,
+        locations: new Set(['LA']),
+        critSlots: currentShieldCriticals,
+    })]);
+    return { forceUnit, shield: forceUnit.getInventory()[0] };
+}
+
 function directFireWeaponEntry(forceUnit: CBTForceUnit, flags: EquipmentFlag[] = []): MountedEquipment {
     const equipment = new WeaponEquipment({
         id: 'DirectFireWeapon',
@@ -1113,6 +1179,47 @@ describe('MekRules', () => {
             .toEqual(jasmine.objectContaining({ walk: 6, run: 9 }));
     });
 
+    it('restores shield-suppressed Jump and UMU from installed propulsion', () => {
+        for (const rulesId of ['core2026', 'tw'] as const) {
+            const activeMedium = createShieldPropulsionHarness(rulesId, 'medium');
+            const destroyedMedium = createShieldPropulsionHarness(rulesId, 'medium', 5);
+            const activeLarge = createShieldPropulsionHarness(rulesId, 'large');
+            const destroyedLarge = createShieldPropulsionHarness(rulesId, 'large', 7);
+
+            expect((activeMedium.forceUnit.rules as MekRules).movementState())
+                .withContext(`${rulesId} active medium shield`)
+                .toEqual(jasmine.objectContaining({ walk: 4, jump: 2, UMU: 2 }));
+            expect((destroyedMedium.forceUnit.rules as MekRules).movementState())
+                .withContext(`${rulesId} destroyed medium shield`)
+                .toEqual(jasmine.objectContaining({ walk: 5, jump: 3, UMU: 2 }));
+            expect((activeLarge.forceUnit.rules as MekRules).movementState())
+                .withContext(`${rulesId} active large shield`)
+                .toEqual(jasmine.objectContaining({ walk: 4, jump: 0, UMU: 0 }));
+            expect((destroyedLarge.forceUnit.rules as MekRules).movementState())
+                .withContext(`${rulesId} destroyed large shield`)
+                .toEqual(jasmine.objectContaining({ walk: 5, jump: 3, UMU: 2 }));
+
+            const activeModes = activeLarge.forceUnit.getAvailableMotiveModes(false).map(option => option.mode);
+            const restoredModes = destroyedLarge.forceUnit.getAvailableMotiveModes(false).map(option => option.mode);
+            expect(activeModes).withContext(`${rulesId} active large shield modes`).not.toContain('jump');
+            expect(activeModes).withContext(`${rulesId} active large shield modes`).not.toContain('UMU');
+            expect(restoredModes).withContext(`${rulesId} destroyed large shield modes`).toContain('jump');
+            expect(restoredModes).withContext(`${rulesId} destroyed large shield modes`).toContain('UMU');
+        }
+    });
+
+    it('uses Core DA exhaustion but TW critical destruction to restore shield-suppressed Jump', () => {
+        const core = createShieldPropulsionHarness('core2026', 'medium');
+        const tw = createShieldPropulsionHarness('tw', 'medium');
+        core.forceUnit.setArmorHits('DALA', 5);
+        tw.forceUnit.setArmorHits('DALA', 5);
+
+        expect((core.forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ jump: 3 }));
+        expect((tw.forceUnit.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ jump: 2 }));
+    });
+
     it('uses DA zero in Core but all unavailable shield criticals in TW for the mobility modifier', () => {
         const core = createShieldHarness('core2026');
         const tw = createShieldHarness('tw');
@@ -2642,6 +2749,83 @@ describe('MekRules', () => {
         }
     });
 
+    it('restores modular-armor Jump MP before applying Jump Jet damage', () => {
+        for (const rulesId of ['core2026', 'tw'] as const) {
+            const modularArmor = miscEquipment(
+                'ISModularArmor',
+                'Modular Armor',
+                ['F_MODULAR_ARMOR'],
+            );
+            const jumpJet = miscEquipment('ISJumpJet', 'Jump Jet', ['F_JUMP_JET']);
+            const forceUnit = createForceUnitHarness({
+                rulesId,
+                jump: 2,
+                umu: 0,
+                internalLocations: ['LT', 'RT', 'LL', 'RL'],
+                critSlots: [
+                    {
+                        ...crit('Modular Armor', false),
+                        id: 'modular-armor',
+                        loc: 'RT',
+                        slot: 0,
+                        consumed: 10,
+                        eq: modularArmor,
+                    },
+                    ...Array.from({ length: 3 }, (_, index) => ({
+                        ...crit('Jump Jet', index === 0),
+                        id: `jump-jet-${index}`,
+                        loc: 'LT',
+                        slot: index,
+                        eq: jumpJet,
+                    })),
+                ],
+            });
+
+            expect((forceUnit.rules as MekRules).movementState())
+                .withContext(rulesId)
+                .toEqual(jasmine.objectContaining({ jump: 2, jumpImpaired: true }));
+            expect(forceUnit.getAvailableMotiveModes(false).map(option => option.mode))
+                .withContext(rulesId)
+                .toContain('jump');
+        }
+    });
+
+    it('uses restored equipment movement as the Core pre-damage immobility baseline', () => {
+        const modularArmor = miscEquipment(
+            'ISModularArmor',
+            'Modular Armor',
+            ['F_MODULAR_ARMOR'],
+        );
+        const createUnit = (consumed: number) => createForceUnitHarness({
+            rulesId: 'core2026',
+            walk: 0,
+            run: 0,
+            jump: 0,
+            umu: 0,
+            internalLocations: ['LT', 'LL', 'RL'],
+            critSlots: [
+                {
+                    ...crit('Modular Armor', false),
+                    id: 'modular-armor',
+                    loc: 'LT',
+                    slot: 0,
+                    consumed,
+                    eq: modularArmor,
+                },
+                { ...crit('Hip'), id: 'left-hip', loc: 'LL', slot: 0 },
+            ],
+        });
+        const activeArmor = createUnit(9);
+        const destroyedArmor = createUnit(10);
+
+        expect((activeArmor.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 0, run: 0 }));
+        expect(activeArmor.rules.hasComputedCondition('immobile')).toBeFalse();
+        expect((destroyedArmor.rules as MekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 0, run: 0, moveImpaired: true }));
+        expect(destroyedArmor.rules.hasComputedCondition('immobile')).toBeTrue();
+    });
+
     it('marks movement impaired when damage consumes Walk MP restored from destroyed equipment', () => {
         const modularArmor = miscEquipment(
             'ISModularArmor',
@@ -3602,12 +3786,14 @@ describe('MekRules', () => {
             reason: 'Hip hit, Leg Actuator hit, Foot hit',
         })]);
         expect(turnState.PSRRollsCount()).toBe(1);
-        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(2);
         expect(forceUnit.rules.PSRModifiers().modifiers).toEqual(jasmine.arrayContaining([
             jasmine.objectContaining({ pilotCheck: 1, loc: 'LL', reason: 'Hip Destroyed' }),
             jasmine.objectContaining({ pilotCheck: 1, loc: 'LL', reason: 'Leg Actuator(s) Destroyed' }),
-            jasmine.objectContaining({ pilotCheck: 1, loc: 'LL', reason: 'Foot Actuator(s) Destroyed' }),
         ]));
+        expect(forceUnit.rules.PSRModifiers().modifiers.some(
+            modifier => modifier.reason === 'Foot Actuator(s) Destroyed',
+        )).toBeFalse();
     });
 
     it('uses separate Core jump PSRs for actuator damage in different legs', () => {
@@ -3627,10 +3813,10 @@ describe('MekRules', () => {
             jasmine.objectContaining({ loc: 'RL', reason: 'Hip hit' }),
         ]);
         expect(turnState.PSRRollsCount()).toBe(2);
-        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(2);
     });
 
-    it('keeps pre-existing destroyed actuator modifiers grouped by location', () => {
+    it('keeps Core pre-existing leg actuator modifiers grouped by location and ignores feet', () => {
         const forceUnit = createForceUnitHarness({
             critSlots: [
                 legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL'),
@@ -3639,7 +3825,7 @@ describe('MekRules', () => {
             ],
         });
 
-        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(2);
         expect(forceUnit.rules.PSRModifiers().modifiers).toEqual(jasmine.arrayContaining([
             jasmine.objectContaining({
                 pilotCheck: 2,
@@ -3647,13 +3833,8 @@ describe('MekRules', () => {
                 reason: 'Leg Actuator(s) Destroyed',
                 modifierReason: 'Leg Actuators Destroyed (2)',
             }),
-            jasmine.objectContaining({
-                pilotCheck: 1,
-                loc: 'RL',
-                reason: 'Foot Actuator(s) Destroyed',
-                modifierReason: 'Foot Actuator Destroyed',
-            }),
         ]));
+        expect(forceUnit.rules.PSRModifiers().modifiers.some(modifier => modifier.loc === 'RL')).toBeFalse();
     });
 
     it('merges current and movement actuator triggers for the same Core leg', () => {
@@ -3835,7 +4016,10 @@ describe('MekRules', () => {
         expect(rules.PSRModifiers().modifiers).toContain(jasmine.objectContaining({
             pilotCheck: 1, loc: 'LL', reason: 'Hip Destroyed',
         }));
-        expect(rules.PSRModifiers().modifiers.some(modifier => modifier.reason === 'Leg Actuator(s) Destroyed')).toBeFalse();
+        expect(rules.PSRModifiers().modifiers.some(modifier =>
+            modifier.reason === 'Leg Actuator(s) Destroyed'
+            || modifier.reason === 'Foot Actuator(s) Destroyed'
+        )).toBeFalse();
         expect(rules.PSRModifiers().modifiers).toContain(jasmine.objectContaining({ pilotCheck: 2, reason: 'Gyro damaged' }));
         expect(toHitModifierTotal(rules.getEquipmentToHitModifiers(armWeapon))).toBe(0);
 
diff --git a/src/app/models/rules/mek-rules.ts b/src/app/models/rules/mek-rules.ts
index 04d6b6a28..a273a53e9 100644
--- a/src/app/models/rules/mek-rules.ts
+++ b/src/app/models/rules/mek-rules.ts
@@ -56,6 +56,15 @@ interface MekArmStatus {
     singleArmMod: number;
 }
 
+interface MekMobilityEquipmentState {
+    modularArmorInstalled: boolean;
+    modularArmorActive: boolean;
+    mediumShieldsInstalled: number;
+    mediumShieldsActive: number;
+    largeShieldsInstalled: number;
+    largeShieldsActive: number;
+}
+
 const TORSO_CRIPPLE_CHECK_KEY = 'core.torso-crippling';
 
 export const MEK_UNIT_CONDITION_CONTROLS: readonly UnitConditionControl[] = unitConditionControls(['shutdown', 'prone', 'swarmed', 'tagged', 'ecm-shielded', 'skidding', 'jammed']);
@@ -144,25 +153,22 @@ export class MekRules extends UnitTypeRulesBase {
         if (!this.unit.isLoaded()) return false;
         if (this.unit.getCondition('shutdown')) return true;
         if (!this.hasDroneOperatingSystem() && !this.hasFunctionalCrew()) return true;
-        const unit = this.unit.getUnit();
         const movement = this.computeBaseMovementProfile();
         if (!movement) return false;
         const canUseJumpingMovement = !this.unit.getCondition('prone');
         const hasUsableNonGroundMovement = canUseJumpingMovement && (
-            (unit.jump > 0 && movement.jump > 0)
-            || (unit.umu > 0 && movement.UMU > 0)
+            movement.jump > 0 || movement.UMU > 0
         );
         // Sparse records can omit destroyed limbs entirely. Losing every limb
         // is damage-caused immobility unless a standing Mek can still leave by
         // a surviving non-ground mode.
         if (this.allLimbsDestroyedOrMissing() && !hasUsableNonGroundMovement) return true;
-        const availableModes = [
-            unit.walk > 0 ? movement.walk : null,
-            unit.run > 0 ? this.baseRunValue(movement) : null,
-            unit.jump > 0 && canUseJumpingMovement ? movement.jump : null,
-            unit.umu > 0 && canUseJumpingMovement ? movement.UMU : null,
+        const damageAvailableModes = [
+            movement.baselineWalk > 0 ? movement.walk : null,
+            movement.baselineJump > 0 && canUseJumpingMovement ? movement.jump : null,
+            movement.baselineUMU > 0 && canUseJumpingMovement ? movement.UMU : null,
         ].filter((value): value is number => value !== null);
-        return availableModes.length > 0 && availableModes.every(value => value <= 0);
+        return damageAvailableModes.length > 0 && damageAvailableModes.every(value => value <= 0);
     });
 
     protected override readonly crippled = computed<boolean>(() => {
@@ -1270,7 +1276,6 @@ export class MekRules extends UnitTypeRulesBase {
         for (const [loc, slots] of slotsByLocation) {
             const destroyedHipsCount = slots.filter(slot => this.isNamedCrit(slot, 'Hip')).length;
             const destroyedLegActuatorsCount = slots.filter(slot => this.isNamedCrit(slot, 'Leg')).length;
-            const destroyedFeetCount = slots.filter(slot => this.isNamedCrit(slot, 'Foot')).length;
             if (destroyedHipsCount > 0) {
                 modifiers.push({
                     pilotCheck: destroyedHipsCount * this.hipPSRModifier,
@@ -1288,16 +1293,6 @@ export class MekRules extends UnitTypeRulesBase {
                         : `Leg Actuators Destroyed (${destroyedLegActuatorsCount})`,
                 });
             }
-            if (destroyedFeetCount > 0) {
-                modifiers.push({
-                    pilotCheck: destroyedFeetCount,
-                    loc,
-                    reason: 'Foot Actuator(s) Destroyed',
-                    modifierReason: destroyedFeetCount === 1
-                        ? 'Foot Actuator Destroyed'
-                        : `Foot Actuators Destroyed (${destroyedFeetCount})`,
-                });
-            }
         }
         return {
             modifier: modifiers.reduce((total, modifier) => total + (modifier.pilotCheck ?? 0), 0),
@@ -1682,17 +1677,28 @@ export class MekRules extends UnitTypeRulesBase {
         const unit = this.unit.getUnit();
         if (!unit) return null;
 
-        const restoredWalk = unit.walk + this.restoredEquipmentWalkMP();
+        const systemsStatus = this.systemsStatus();
+        const mobilityEquipment = this.mobilityEquipmentState();
+        const restoredWalk = unit.walk + this.restoredEquipmentWalkMP(mobilityEquipment);
         const restoredRun = Math.max(
             0,
             Math.round(restoredWalk * 1.5) + (unit.armorType === 'Hardened' ? -1 : 0),
         );
+        const baselineJump = this.equipmentAdjustedJumpBaseline(
+            unit.jump,
+            systemsStatus.jumpJetsCount,
+            mobilityEquipment,
+        );
+        const baselineUMU = this.equipmentAdjustedUMUBaseline(
+            unit.umu,
+            systemsStatus.UMUCount,
+            mobilityEquipment,
+        );
         let walkValue = restoredWalk;
-        let jumpValue = unit.jump;
-        let UMUValue = unit.umu;
+        let jumpValue = baselineJump;
+        let UMUValue = baselineUMU;
         let moveImpaired = false;
 
-        const systemsStatus = this.systemsStatus();
         const internalLocations = systemsStatus.internalLocations;
         const legMovement = this.applyLegDamageToMovement(
             walkValue,
@@ -1719,7 +1725,10 @@ export class MekRules extends UnitTypeRulesBase {
         } else {
             jumpValue = Math.max(0, jumpValue - systemsStatus.destroyedJumpJetsCount);
             if (systemsStatus.hasPartialWings) {
-                jumpValue -= this.partialWingJumpBonus(0) - this.partialWingJumpBonus();
+                jumpValue = Math.max(
+                    0,
+                    jumpValue - (this.partialWingJumpBonus(0) - this.partialWingJumpBonus()),
+                );
             }
         }
 
@@ -1731,18 +1740,55 @@ export class MekRules extends UnitTypeRulesBase {
 
         return {
             baselineWalk: restoredWalk,
+            baselineJump,
+            baselineUMU,
             walk: walkValue,
             runDisabled: legMovement.runDisabled,
             runCap: legMovement.runCap,
             jump: jumpValue,
             UMU: UMUValue,
             moveImpaired,
-            jumpImpaired: (jumpValue < unit.jump),
-            UMUImpaired: (UMUValue < unit.umu),
+            jumpImpaired: jumpValue < baselineJump,
+            UMUImpaired: UMUValue < baselineUMU,
         };
     }
 
-    private restoredEquipmentWalkMP(): number {
+    private restoredEquipmentWalkMP(equipment: MekMobilityEquipmentState): number {
+        return (equipment.modularArmorInstalled && !equipment.modularArmorActive ? 1 : 0)
+            + equipment.mediumShieldsInstalled - equipment.mediumShieldsActive
+            + equipment.largeShieldsInstalled - equipment.largeShieldsActive;
+    }
+
+    private equipmentAdjustedJumpBaseline(
+        storedJump: number,
+        installedJumpJets: number,
+        equipment: MekMobilityEquipmentState,
+    ): number {
+        if (equipment.largeShieldsActive > 0) return 0;
+
+        const hasInstalledPenalty = equipment.modularArmorInstalled
+            || equipment.mediumShieldsInstalled > 0
+            || equipment.largeShieldsInstalled > 0;
+        if (!hasInstalledPenalty) return storedJump;
+        if (installedJumpJets === 0) return 0;
+
+        const partialWingBonus = this.partialWingJumpBonus(0);
+        const activePenalty = equipment.mediumShieldsActive
+            + (equipment.modularArmorActive ? 1 : 0);
+        return Math.max(0, installedJumpJets + partialWingBonus - activePenalty);
+    }
+
+    private equipmentAdjustedUMUBaseline(
+        storedUMU: number,
+        installedUMUs: number,
+        equipment: MekMobilityEquipmentState,
+    ): number {
+        if (equipment.largeShieldsActive > 0) return 0;
+        if (equipment.largeShieldsInstalled === 0) return storedUMU;
+        return installedUMUs;
+    }
+
+    private mobilityEquipmentState(): MekMobilityEquipmentState {
         const modularArmor = this.modularArmorState();
         const config = inferMekConfigFromLocations(this.unit.locations?.internal.keys() ?? []);
         const shields = config === 'Quad'
@@ -1750,8 +1796,16 @@ export class MekRules extends UnitTypeRulesBase {
             : this.unit.getInventory().filter(entry =>
                 entry.equipment?.hasFlag('F_SHIELD')
                 && entry.equipment.hasAnyFlag(['S_SHIELD_LARGE', 'S_SHIELD_MEDIUM']));
-        return (modularArmor.installed && !modularArmor.active ? 1 : 0)
-            + shields.filter(entry => !this.shieldRetainsMobilityPenalty(entry)).length;
+        const mediumShields = shields.filter(entry => entry.equipment?.hasFlag('S_SHIELD_MEDIUM'));
+        const largeShields = shields.filter(entry => entry.equipment?.hasFlag('S_SHIELD_LARGE'));
+        return {
+            modularArmorInstalled: modularArmor.installed,
+            modularArmorActive: modularArmor.active,
+            mediumShieldsInstalled: mediumShields.length,
+            mediumShieldsActive: mediumShields.filter(entry => this.shieldRetainsMobilityPenalty(entry)).length,
+            largeShieldsInstalled: largeShields.length,
+            largeShieldsActive: largeShields.filter(entry => this.shieldRetainsMobilityPenalty(entry)).length,
+        };
     }
 
     private modularArmorState(): { installed: boolean; active: boolean } {
@@ -1841,9 +1895,9 @@ export class MekRules extends UnitTypeRulesBase {
                 maxWalk: 0,
                 run: 0,
                 maxRun: 0,
-                jumpImpaired: unit.jump > 0,
+                jumpImpaired: baseMovement.baselineJump > 0,
                 jump: 0,
-                UMUImpaired: unit.umu > 0,
+                UMUImpaired: baseMovement.baselineUMU > 0,
                 UMU: 0,
             };
         }
diff --git a/src/app/models/rules/tw-rules.spec.ts b/src/app/models/rules/tw-rules.spec.ts
index 42204f7a1..72c67d9d7 100644
--- a/src/app/models/rules/tw-rules.spec.ts
+++ b/src/app/models/rules/tw-rules.spec.ts
@@ -140,6 +140,20 @@ describe('TWMekRules', () => {
         expect(forceUnit.rules.PSRModifiers().modifier).toBe(5);
     });
 
+    it('retains the destroyed foot actuator PSR modifier in TW', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('foot', 'Foot', 'LL'),
+        ]);
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(1);
+        expect(forceUnit.rules.PSRModifiers().modifiers).toContain(jasmine.objectContaining({
+            pilotCheck: 1,
+            loc: 'LL',
+            reason: 'Leg Actuator(s) Destroyed',
+            modifierReason: 'Leg Actuator Destroyed',
+        }));
+    });
+
     it('stacks independent TW actuator checks with damage and gyro PSRs', () => {
         const forceUnit = createTWForceUnit();
         const turnState = forceUnit.turnState();

From cf4f14a269e1d8a1b30929f59ae165183791f581 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Thu, 20 Aug 2026 01:01:22 +0200
Subject: [PATCH 08/12] fix hip+leg actuators

---
 .../page-viewer/svg-interaction.service.ts    |   2 +
 src/app/models/cbt-force-unit-state.model.ts  |  19 ++-
 src/app/models/cbt-force-unit.model.spec.ts   |  26 +++
 src/app/models/cbt-force-unit.model.ts        |   8 +-
 src/app/models/force-serialization.spec.ts    |  16 +-
 src/app/models/force-serialization.ts         |   9 +
 src/app/models/rules/mek-rules.spec.ts        | 115 +++++++++++--
 src/app/models/rules/mek-rules.ts             |  60 ++++---
 src/app/models/rules/tw-rules.spec.ts         | 160 +++++++++++++++++-
 src/app/models/rules/tw-rules.ts              |  59 ++++++-
 src/app/models/turn-state.model.spec.ts       |  14 +-
 src/app/models/turn-state.model.ts            |  12 +-
 src/app/models/units.model.ts                 |   1 +
 src/app/testing/unit-test-helpers.ts          |   2 +
 14 files changed, 437 insertions(+), 66 deletions(-)

diff --git a/src/app/components/page-viewer/svg-interaction.service.ts b/src/app/components/page-viewer/svg-interaction.service.ts
index b7490398c..1824b1f22 100644
--- a/src/app/components/page-viewer/svg-interaction.service.ts
+++ b/src/app/components/page-viewer/svg-interaction.service.ts
@@ -889,6 +889,7 @@ export class SvgInteractionService {
         }
         critLoc.destroying = undefined;
         critLoc.destroyed = undefined;
+        critLoc.destroyedTurn = undefined;
         unit.setCritLoc(critLoc);
     }
 
@@ -976,6 +977,7 @@ export class SvgInteractionService {
         }
         critLoc.destroying = undefined;
         critLoc.destroyed = undefined;
+        critLoc.destroyedTurn = undefined;
         unit.setCritLoc(critLoc);
     }
 
diff --git a/src/app/models/cbt-force-unit-state.model.ts b/src/app/models/cbt-force-unit-state.model.ts
index 3fae0cca8..203ca3b2d 100644
--- a/src/app/models/cbt-force-unit-state.model.ts
+++ b/src/app/models/cbt-force-unit-state.model.ts
@@ -33,8 +33,8 @@ export class CBTForceUnitState extends ForceUnitState {
         this.turnState.set(new TurnState(this));
     }
 
-    resetTurnState() {
-        const turnState = new TurnState(this);
+    resetTurnState(turnCounter = 0) {
+        const turnState = new TurnState(this, turnCounter);
         this.turnState.set(turnState);
         turnState.capturePassiveHeatSourceBaseline();
     }
@@ -93,6 +93,11 @@ export class CBTForceUnitState extends ForceUnitState {
     consolidateCrits() {
         if (!this.hasUnconsolidatedCrits()) return;
         const crits = this.crits();
+        const commitsDestruction = crits.some(crit =>
+            crit.destroying !== undefined && crit.destroyed === undefined);
+        const destructionTurn = commitsDestruction
+            ? this.turnState().getTurnCounter()
+            : undefined;
         let updated = false;
         crits.forEach(crit => {
             if ((crit.pendingHits ?? 0) !== 0) {
@@ -102,8 +107,9 @@ export class CBTForceUnitState extends ForceUnitState {
                 crit.pendingHitTimestamps = undefined;
                 updated = true;
             }
-            if (!!crit.destroying !== !!crit.destroyed) {
+            if ((crit.destroying !== undefined) !== (crit.destroyed !== undefined)) {
                 crit.destroyed = crit.destroying;
+                crit.destroyedTurn = crit.destroying !== undefined ? destructionTurn : undefined;
                 updated = true;
             }
         });
@@ -250,6 +256,7 @@ export class CBTForceUnitState extends ForceUnitState {
                         !this.numberArraysEqual(existingCrit.pendingHitTimestamps, incomingCrit.pendingHitTimestamps) ||
                         existingCrit.destroying !== incomingCrit.destroying ||
                         existingCrit.destroyed !== incomingCrit.destroyed ||
+                        existingCrit.destroyedTurn !== incomingCrit.destroyedTurn ||
                         existingCrit.consumed !== incomingCrit.consumed) {
                         existingCrit.hits = incomingCrit.hits;
                         existingCrit.pendingHits = incomingCrit.pendingHits;
@@ -259,6 +266,7 @@ export class CBTForceUnitState extends ForceUnitState {
                         existingCrit.name = incomingCrit.name;
                         existingCrit.originalName = incomingCrit.originalName;
                         existingCrit.destroyed = incomingCrit.destroyed;
+                        existingCrit.destroyedTurn = incomingCrit.destroyedTurn;
                         existingCrit.consumed = incomingCrit.consumed;
                         critsChanged = true;
                     }
@@ -267,7 +275,9 @@ export class CBTForceUnitState extends ForceUnitState {
                     if ((existingCrit.hits ?? 0) > 0 || (existingCrit.pendingHits ?? 0) !== 0 ||
                         (existingCrit.hitTimestamps?.length ?? 0) > 0 || (existingCrit.pendingHitTimestamps?.length ?? 0) > 0 ||
                         existingCrit.destroying !== undefined ||
-                        existingCrit.destroyed !== undefined || (existingCrit.consumed ?? 0) > 0 ||
+                        existingCrit.destroyed !== undefined ||
+                        existingCrit.destroyedTurn !== undefined ||
+                        (existingCrit.consumed ?? 0) > 0 ||
                         existingCrit.originalName !== undefined) {
                         existingCrit.hits = 0;
                         existingCrit.pendingHits = undefined;
@@ -275,6 +285,7 @@ export class CBTForceUnitState extends ForceUnitState {
                         existingCrit.pendingHitTimestamps = undefined;
                         existingCrit.destroying = undefined;
                         existingCrit.destroyed = undefined;
+                        existingCrit.destroyedTurn = undefined;
                         existingCrit.consumed = undefined;
                         if (existingCrit.originalName) {
                             existingCrit.name = existingCrit.originalName;
diff --git a/src/app/models/cbt-force-unit.model.spec.ts b/src/app/models/cbt-force-unit.model.spec.ts
index b5f9b1bbe..deadd260e 100644
--- a/src/app/models/cbt-force-unit.model.spec.ts
+++ b/src/app/models/cbt-force-unit.model.spec.ts
@@ -2986,10 +2986,36 @@ describe('CBTForceUnit direct inventory ammo bins', () => {
         expect(restored.turnState().dmgReceived()).toBe(20);
         expect(restored.turnState().weaponsHeat()).toBe(8);
         expect(restored.turnState().spotting()).toBeTrue();
+        expect(restored.turnState().getTurnCounter()).toBe(forceUnit.turnState().getTurnCounter());
         expect(restored.turnState().getPSRCheckState().legActuators?.get('LL')).toBe(1);
         expect(restored.turnState().getPSRCheckState().hipsHit?.has('RL')).toBeTrue();
     });
 
+    it('increments and persists the per-unit turn counter on endTurn', () => {
+        const forceUnit = createForceUnit();
+
+        expect(forceUnit.turnState().getTurnCounter()).toBe(0);
+
+        forceUnit.endTurn();
+        forceUnit.endTurn();
+
+        expect(forceUnit.turnState().getTurnCounter()).toBe(2);
+
+        const restored = CBTForceUnit.deserialize(
+            forceUnit.serialize(),
+            new TestCBTForce('Restored Turn Counter Force', dataService, unitInitializer, injector),
+            dataService,
+            unitInitializer,
+            injector,
+        );
+
+        expect(restored.turnState().getTurnCounter()).toBe(2);
+
+        restored.endTurn();
+
+        expect(restored.turnState().getTurnCounter()).toBe(3);
+    });
+
     it('exposes spotting as a transient condition and clears it at end of turn', () => {
         const forceUnit = createForceUnit();
 
diff --git a/src/app/models/cbt-force-unit.model.ts b/src/app/models/cbt-force-unit.model.ts
index 1e0bcd076..1d3d70dc9 100644
--- a/src/app/models/cbt-force-unit.model.ts
+++ b/src/app/models/cbt-force-unit.model.ts
@@ -493,8 +493,9 @@ export class CBTForceUnit extends ForceUnit {
         slot.hits = Math.max(0, (slot.hits ?? 0) + damage);
         const destroying = slot.armored ? slot.hits >= 2 : slot.hits >= 1;
         slot.destroying = destroying ? Date.now() : undefined;
-        if (slot.destroyed && !destroying) {
+        if (slot.destroyed !== undefined && !destroying) {
             slot.destroyed = undefined; // Reset destroyed immediately
+            slot.destroyedTurn = undefined;
         }
         this.setCritSlot(slot);
         if (consolidateImmediately) {
@@ -1512,8 +1513,9 @@ export class CBTForceUnit extends ForceUnit {
         this.state.crew.set(crew);
         // Clear all crits
         const crits = this.state.crits().map(crit => {
-            if (crit.destroyed) {
+            if (crit.destroyed !== undefined || crit.destroyedTurn !== undefined) {
                 crit.destroyed = undefined;
+                crit.destroyedTurn = undefined;
             }
             if (crit.destroying) {
                 crit.destroying = undefined;
@@ -1662,7 +1664,7 @@ export class CBTForceUnit extends ForceUnit {
         if (endsForceTurn) this.force.clearExpiredManualTargetTags(this);
         this.inventoryControl.markAmmoSourcesChanged();
         this.phaseTrigger.update(v => v + 1); // Trigger change detection
-        this.state.resetTurnState();
+        this.state.resetTurnState(this.turnState().getTurnCounter() + 1);
     }
 
     private _hasDirectInventory: boolean | null = null;
diff --git a/src/app/models/force-serialization.spec.ts b/src/app/models/force-serialization.spec.ts
index b4076241c..d32d44c3b 100644
--- a/src/app/models/force-serialization.spec.ts
+++ b/src/app/models/force-serialization.spec.ts
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // Author: Drake
 
-import { CBT_SERIALIZED_STATE_SCHEMA, C3_NETWORK_GROUP_SCHEMA, FORCE_TAG_MAX_COUNT, HEAT_SCHEMA, sanitizeForceTagLabels, sanitizeForceTags, TURN_STATE_SCHEMA } from './force-serialization';
+import { CBT_SERIALIZED_STATE_SCHEMA, C3_NETWORK_GROUP_SCHEMA, CRIT_SLOT_SCHEMA, FORCE_TAG_MAX_COUNT, HEAT_SCHEMA, sanitizeForceTagLabels, sanitizeForceTags, TURN_STATE_SCHEMA } from './force-serialization';
 import { Sanitizer } from '../utils/sanitizer.util';
 import { C3NetworkType } from './c3-network.model';
 
@@ -95,6 +95,20 @@ describe('heat state sanitization', () => {
         });
     });
 
+    it('sanitizes turn chronology as non-negative integer counters', () => {
+        expect(Sanitizer.sanitize({ turnCounter: 4.9 }, TURN_STATE_SCHEMA))
+            .toEqual({ turnCounter: 4 });
+        expect(Sanitizer.sanitize({ turnCounter: -2 }, TURN_STATE_SCHEMA))
+            .toEqual({ turnCounter: 0 });
+        expect(Sanitizer.sanitize({ turnCounter: Number.NaN }, TURN_STATE_SCHEMA))
+            .toEqual({});
+
+        expect(Sanitizer.sanitize({ id: 'crit', destroyedTurn: 7.8 }, CRIT_SLOT_SCHEMA))
+            .toEqual({ id: 'crit', destroyedTurn: 7 });
+        expect(Sanitizer.sanitize({ id: 'crit', destroyedTurn: Number.POSITIVE_INFINITY }, CRIT_SLOT_SCHEMA))
+            .toEqual({ id: 'crit' });
+    });
+
     it('sanitizes consumed heat dissipation as a non-negative finite number', () => {
         expect(Sanitizer.sanitize({ heatDissipationConsumed: '6' }, TURN_STATE_SCHEMA)).toEqual({
             heatDissipationConsumed: 6,
diff --git a/src/app/models/force-serialization.ts b/src/app/models/force-serialization.ts
index 3e80b2dd0..e5f5cc7a8 100644
--- a/src/app/models/force-serialization.ts
+++ b/src/app/models/force-serialization.ts
@@ -80,6 +80,7 @@ export interface SerializedPSRChecks {
 }
 
 export interface SerializedTurnState {
+    turnCounter?: number;
     airborne?: boolean;
     moveMode?: MotiveModes;
     moveDistance?: number;
@@ -374,6 +375,7 @@ export interface CriticalSlot {
     consumed?: number; // If is an ammo slot: how much ammo have been consumed. If is a F_MODULAR_ARMOR, is the armor points used
     destroying?: number; // If this location is in the process of being destroyed. Contains the timestamp of when the destruction started
     destroyed?: number; // If this location is destroyed (can be from 0 hits if the structure is completely destroyed). Contains the timestamp of the destruction
+    destroyedTurn?: number; // Per-unit turn counter when this slot was destroyed
     originalName?: string; // saved original name in case we override the current name
     armored?: boolean; // If this critical slot is armored (for locations that can be armored)
     el?: SVGElement;
@@ -438,6 +440,7 @@ function sanitizePSRChecks(value: unknown): SerializedPSRChecks | undefined {
 }
 
 export const TURN_STATE_SCHEMA = Sanitizer.schema<SerializedTurnState>()
+    .custom('turnCounter', sanitizeOptionalNonNegativeInteger)
     .custom('airborne', (value: unknown) => typeof value === 'boolean' ? value : undefined)
     .custom('moveMode', (value: unknown) => MOTIVE_MODE_VALUES.includes(value as MotiveModes) ? value as MotiveModes : undefined)
     .custom('moveDistance', sanitizeOptionalNonNegativeNumber)
@@ -486,6 +489,7 @@ export const CRIT_SLOT_SCHEMA = Sanitizer.schema<CriticalSlot>()
         if (typeof value === 'number') return value;
         return undefined;
     })
+    .custom('destroyedTurn', sanitizeOptionalNonNegativeInteger)
     .string('originalName')
     .boolean('armored')
     .build();
@@ -527,6 +531,11 @@ function sanitizeOptionalNonNegativeNumber(value: unknown): number | undefined {
     return Number.isFinite(parsed) ? Math.max(0, parsed) : undefined;
 }
 
+function sanitizeOptionalNonNegativeInteger(value: unknown): number | undefined {
+    const parsed = sanitizeOptionalNonNegativeNumber(value);
+    return parsed === undefined ? undefined : Math.floor(parsed);
+}
+
 function sanitizeOptionalCover(value: unknown): SerializedUnitCover | undefined {
     const cover = deserializeUnitCover(value);
     return cover === undefined ? undefined : serializeUnitCover(cover);
diff --git a/src/app/models/rules/mek-rules.spec.ts b/src/app/models/rules/mek-rules.spec.ts
index 53d7ac931..6a7573be9 100644
--- a/src/app/models/rules/mek-rules.spec.ts
+++ b/src/app/models/rules/mek-rules.spec.ts
@@ -11,7 +11,7 @@ import { MountedEquipment, MountedWeapon } from '../mounted-equipment.model';
 import { type CriticalSlot, type LocationData } from '../force-serialization';
 import { AmmoEquipment, Equipment, WeaponEquipment, type AmmoType } from '../equipment.model';
 import { EquipmentRegistry } from '../equipment-lookup';
-import type { Unit, UnitSubtype } from '../units.model';
+import type { Unit, UnitComponent, UnitSubtype } from '../units.model';
 import { DataService } from '../../services/data.service';
 import { EquipmentInteractionRegistryService } from '../../services/equipment-interaction-registry.service';
 import { UnitInitializerService } from '../../services/unit-initializer.service';
@@ -27,6 +27,7 @@ import { VIBROBLADE_MODE_STATE, VIBROBLADE_ON_MODE, VibrobladeHandler } from '..
 import { PPC_CAPACITOR_CHARGED_STATE, PPC_CAPACITOR_CHARGING_STATE, PPC_CAPACITOR_STATE_KEY, PpcCapacitorHandler } from '../../equipment-handlers/ppc-capacitor.handler';
 import { EquipmentFlag } from '../equipment-flags.type';
 import { isInventoryControlSelectableEntry, syncSvgMode } from '../../utils/inventory-control.util';
+import { MEK_LOCATIONS, MEK_QUAD_LOCATIONS, MEK_TRIPOD_LOCATIONS } from '../entity/types';
 
 class TestCBTForce extends CBTForce {
     override emitChanged(): void {
@@ -64,6 +65,7 @@ function createRulesHarness(options: {
     subtype?: UnitSubtype;
     rulesId?: 'core2026' | 'tw';
     forcedWithdrawal?: boolean;
+    components?: UnitComponent[];
 } = {}): MekRules {
     return createForceUnitHarness(options).rules as MekRules;
 }
@@ -107,6 +109,18 @@ function normalizeGeneratedCriticalSlots(criticalSlots: readonly CriticalSlot[])
     });
 }
 
+function canonicalMekInternalLocations(subtype: UnitSubtype, requested: readonly string[] = []): string[] {
+    const isQuad = subtype.startsWith('Quad')
+        || requested.some(loc => ['FLL', 'FRL', 'RLL', 'RRL'].includes(loc));
+    const isTripod = subtype.startsWith('Tripod') || requested.includes('CL');
+    const canonical: readonly string[] = isQuad
+        ? MEK_QUAD_LOCATIONS
+        : isTripod
+            ? MEK_TRIPOD_LOCATIONS
+            : MEK_LOCATIONS;
+    return [...new Set([...canonical, ...requested])];
+}
+
 function createForceUnitHarness(options: {
     crewStates?: Exclude<CrewMemberState, 'dead'>[];
     crewHits?: number[];
@@ -125,6 +139,7 @@ function createForceUnitHarness(options: {
     subtype?: UnitSubtype;
     rulesId?: 'core2026' | 'tw';
     forcedWithdrawal?: boolean;
+    components?: UnitComponent[];
 } = {}): CBTForceUnit {
     optionsService.options.update(current => ({
         ...current,
@@ -146,12 +161,13 @@ function createForceUnitHarness(options: {
         umu: options.umu ?? 2,
         tons: options.tons ?? 50,
         engine: options.engine ?? 'Fusion',
+        comp: options.components ?? [],
     });
 
     dataService.getUnitByName.and.callFake((name: string): Unit | undefined => name === baseUnit.name ? baseUnit : undefined);
     const force = new TestCBTForce('Test Force', dataService, unitInitializer, injector);
     const forceUnit = new CBTForceUnit(baseUnit, force, dataService, unitInitializer, injector);
-    const internalLocations = options.internalLocations ?? ['LL', 'RL'];
+    const internalLocations = canonicalMekInternalLocations(baseUnit.subtype, options.internalLocations);
     const locationPoints = options.locationPoints ?? 1;
     forceUnit.locations = {
         internal: new Map(internalLocations.map(loc => [loc, { loc, points: locationPoints }])),
@@ -357,6 +373,18 @@ function createShieldHarness(
     return { forceUnit, shield: forceUnit.getInventory()[0] };
 }
 
+function unitComponent(equipment: Equipment, quantity: number, location: string): UnitComponent {
+    return {
+        id: equipment.id,
+        q: quantity,
+        n: equipment.name,
+        t: 'C',
+        p: 0,
+        l: location,
+        eq: equipment,
+    };
+}
+
 function createShieldPropulsionHarness(
     rulesId: 'core2026' | 'tw',
     size: 'medium' | 'large',
@@ -384,6 +412,10 @@ function createShieldPropulsionHarness(
         run: 6,
         jump: large ? 0 : 2,
         umu: large ? 0 : 2,
+        components: [
+            unitComponent(jumpJet, 3, 'LT'),
+            unitComponent(umu, 2, 'RT'),
+        ],
         internalLocations: ['LA', 'RA', 'LT', 'RT', 'LL', 'RL'],
         critSlots: [
             ...armCritSlots('LA'),
@@ -1798,7 +1830,8 @@ describe('MekRules', () => {
         const punchModifiers = rules.getEquipmentToHitModifiers(punchEntry(forceUnit));
         expect(toHitModifierTotal(punchModifiers)).toBe(-1);
         expect(punchModifiers).toEqual([{ label: 'Dedicated Pilot', modifier: -1 }]);
-        expect(rules.PSRTargetRoll()).toBe(4);
+        expect(rules.PSRModifiers().modifier).toBe(-2);
+        expect(rules.PSRTargetRoll()).toBe(3);
     });
 
     it('uses the first active alternate gunner with a modifier when the Tripod dedicated gunnery officer is disabled', () => {
@@ -1856,7 +1889,8 @@ describe('MekRules', () => {
         expect(punchModifiers).toEqual([
             { label: 'Dedicated Pilot disabled', modifier: 2, weakened: true },
         ]);
-        expect(rules.PSRTargetRoll()).toBe(8);
+        expect(rules.PSRModifiers().modifier).toBe(1);
+        expect(rules.PSRTargetRoll()).toBe(7);
     });
 
     it('applies the Tripod dedicated pilot modifier to physical attacks', () => {
@@ -2761,6 +2795,7 @@ describe('MekRules', () => {
                 rulesId,
                 jump: 2,
                 umu: 0,
+                components: [unitComponent(jumpJet, 3, 'LT')],
                 internalLocations: ['LT', 'RT', 'LL', 'RL'],
                 critSlots: [
                     {
@@ -2790,6 +2825,61 @@ describe('MekRules', () => {
         }
     });
 
+    it('restores modular-armor Jump from mounted Improved Jump Jets rather than occupied slots', () => {
+        for (const rulesId of ['core2026', 'tw'] as const) {
+            const modularArmor = miscEquipment(
+                'ISModularArmor',
+                'Modular Armor',
+                ['F_MODULAR_ARMOR'],
+            );
+            const improvedJumpJet = miscEquipment(
+                'ISImprovedJumpJet',
+                'Improved Jump Jet',
+                ['F_JUMP_JET', 'S_IMPROVED'],
+            );
+            const forceUnit = createForceUnitHarness({
+                rulesId,
+                jump: 1,
+                umu: 0,
+                components: [unitComponent(improvedJumpJet, 2, 'LT')],
+                internalLocations: ['LT', 'RT', 'LL', 'RL'],
+                critSlots: [
+                    {
+                        ...crit('Modular Armor', false),
+                        id: 'modular-armor',
+                        loc: 'RT',
+                        slot: 0,
+                        consumed: 10,
+                        eq: modularArmor,
+                    },
+                    ...Array.from({ length: 4 }, (_, index) => ({
+                        ...crit('Improved Jump Jet', false),
+                        id: `improved-jump-jet-${Math.floor(index / 2)}`,
+                        loc: 'LT',
+                        slot: index,
+                        eq: improvedJumpJet,
+                    })),
+                ],
+            });
+
+            expect((forceUnit.rules as MekRules).movementState())
+                .withContext(rulesId)
+                .toEqual(jasmine.objectContaining({ jump: 2, jumpImpaired: false }));
+
+            forceUnit.applyHitToCritSlot(forceUnit.getCritSlot('LT', 0)!);
+            forceUnit.endPhase();
+            expect((forceUnit.rules as MekRules).movementState())
+                .withContext(`${rulesId} first occupied slot`)
+                .toEqual(jasmine.objectContaining({ jump: 1, jumpImpaired: true }));
+
+            forceUnit.applyHitToCritSlot(forceUnit.getCritSlot('LT', 1)!);
+            forceUnit.endPhase();
+            expect((forceUnit.rules as MekRules).movementState())
+                .withContext(`${rulesId} second occupied slot of the same mount`)
+                .toEqual(jasmine.objectContaining({ jump: 1, jumpImpaired: true }));
+        }
+    });
+
     it('uses restored equipment movement as the Core pre-damage immobility baseline', () => {
         const modularArmor = miscEquipment(
             'ISModularArmor',
@@ -2960,26 +3050,19 @@ describe('MekRules', () => {
         }
     });
 
-    it('keeps core2026 Meks mobile while a damage-available movement mode remains', () => {
+    it('keeps a Core Mek mobile until damage reduces its canonical ground movement to zero', () => {
         const forceUnit = createForceUnitHarness({
-            internalLocations: ['LL', 'RA', 'RT'],
+            internalLocations: ['HD', 'CT', 'LT', 'RT', 'LA', 'RA', 'LL', 'RL'],
             committedDestroyedLocations: ['LL'],
+            jump: 0,
+            umu: 0,
         });
 
-        expect(forceUnit.isInternalLocCommittedDestroyed('RA')).toBeFalse();
         expect(forceUnit.rules.hasComputedCondition('immobile')).toBeFalse();
 
-        forceUnit.setLocations(createCommittedLocationState(['LL', 'RT']), true);
+        forceUnit.setLocations(createCommittedLocationState(['LL', 'RL']), true);
 
-        expect(forceUnit.isInternalLocCommittedDestroyed('RA')).toBeTrue();
         expect(forceUnit.rules.hasComputedCondition('immobile')).toBeTrue();
-
-        const twForceUnit = createForceUnitHarness({
-            internalLocations: ['LL', 'RA', 'RT'],
-            committedDestroyedLocations: ['LL', 'RA'],
-            rulesId: 'tw',
-        });
-        expect(twForceUnit.rules.hasComputedCondition('immobile')).toBeTrue();
     });
 
     it('only lets surviving Jump MP prevent Core damage immobility while standing', () => {
diff --git a/src/app/models/rules/mek-rules.ts b/src/app/models/rules/mek-rules.ts
index a273a53e9..38b94b14f 100644
--- a/src/app/models/rules/mek-rules.ts
+++ b/src/app/models/rules/mek-rules.ts
@@ -25,6 +25,7 @@ import {
 } from '../entity/types';
 import { resolveShieldProfile, type ShieldProfile } from '../entity/utils/physical-weapon';
 import type { Equipment } from '../equipment.model';
+import type { EquipmentFlag } from '../equipment-flags.type';
 
 export { LEG_LOCATIONS } from '../entity/types';
 import type { InventoryControlDisplayData } from '../../utils/inventory-control.util';
@@ -156,13 +157,6 @@ export class MekRules extends UnitTypeRulesBase {
         const movement = this.computeBaseMovementProfile();
         if (!movement) return false;
         const canUseJumpingMovement = !this.unit.getCondition('prone');
-        const hasUsableNonGroundMovement = canUseJumpingMovement && (
-            movement.jump > 0 || movement.UMU > 0
-        );
-        // Sparse records can omit destroyed limbs entirely. Losing every limb
-        // is damage-caused immobility unless a standing Mek can still leave by
-        // a surviving non-ground mode.
-        if (this.allLimbsDestroyedOrMissing() && !hasUsableNonGroundMovement) return true;
         const damageAvailableModes = [
             movement.baselineWalk > 0 ? movement.walk : null,
             movement.baselineJump > 0 && canUseJumpingMovement ? movement.jump : null,
@@ -209,24 +203,23 @@ export class MekRules extends UnitTypeRulesBase {
 
     // ── Cripple Check Utilities ──────────────────────────────────────────────
 
-    protected allLimbsDestroyedOrMissing(): boolean {
+    protected allLimbsDestroyed(): boolean {
         const internalLocations = this.unit.locations?.internal;
         if (!internalLocations) return false;
 
         const config = inferMekConfigFromLocations(internalLocations.keys());
         const limbLocations = getMekLimbLocations(config);
-        const isDestroyedOrMissing = (loc: string) =>
-            !internalLocations.has(loc) || this.unit.isInternalLocCommittedDestroyed(loc);
-        if (config !== 'Tripod') return limbLocations.every(isDestroyedOrMissing);
+        const isDestroyed = (loc: string) => this.unit.isInternalLocCommittedDestroyed(loc);
+        if (config !== 'Tripod') return limbLocations.every(isDestroyed);
 
-        const armsDestroyedOrMissing = limbLocations
+        const armsDestroyed = limbLocations
             .filter(loc => !isMekLegLocation(config, loc))
-            .every(isDestroyedOrMissing);
+            .every(isDestroyed);
         // A tripod with two destroyed legs follows the biped both-legs-destroyed state.
-        const destroyedOrMissingLegs = getMekLegLocations(config)
-            .filter(isDestroyedOrMissing)
+        const destroyedLegs = getMekLegLocations(config)
+            .filter(isDestroyed)
             .length;
-        return armsDestroyedOrMissing && destroyedOrMissingLegs >= 2;
+        return armsDestroyed && destroyedLegs >= 2;
     }
 
     protected isDestroyedOrDestroyingCrit(slot: CriticalSlot): boolean {
@@ -976,10 +969,17 @@ export class MekRules extends UnitTypeRulesBase {
         const destroyedMASC = critSlots.some(slot => this.isNamedCrit(slot, 'MASC') && this.isCritUnavailable(slot));
         const hasSupercharger = critSlots.some(slot => this.isNamedCrit(slot, 'Supercharger'));
         const destroyedSupercharger = critSlots.some(slot => this.isNamedCrit(slot, 'Supercharger') && this.isCritUnavailable(slot));
-        const jumpJetsCount = critSlots.filter(slot => this.isNamedCrit(slot, 'Jump Jet') || this.isNamedCrit(slot, 'JumpJet')).length;
-        const destroyedJumpJetsCount = critSlots.filter(slot => (this.isNamedCrit(slot, 'Jump Jet') || this.isNamedCrit(slot, 'JumpJet')) && this.isCritUnavailable(slot)).length;
-        const UMUCount = critSlots.filter(slot => this.isNamedCrit(slot, 'UMU')).length;
-        const destroyedUMUCount = critSlots.filter(slot => this.isNamedCrit(slot, 'UMU') && this.isCritUnavailable(slot)).length;
+        const jumpJetSlots = critSlots.filter(slot =>
+            this.isNamedCrit(slot, 'Jump Jet') || this.isNamedCrit(slot, 'JumpJet'));
+        const UMUSlots = critSlots.filter(slot => this.isNamedCrit(slot, 'UMU'));
+        const jumpJetsCount = new Set(jumpJetSlots.map(slot => slot.id)).size;
+        const destroyedJumpJetsCount = new Set(jumpJetSlots
+            .filter(slot => this.isCritUnavailable(slot))
+            .map(slot => slot.id)).size;
+        const UMUCount = new Set(UMUSlots.map(slot => slot.id)).size;
+        const destroyedUMUCount = new Set(UMUSlots
+            .filter(slot => this.isCritUnavailable(slot))
+            .map(slot => slot.id)).size;
         const hasPartialWings = critSlots.some(slot => slot.eq?.hasFlag('F_PARTIAL_WING'));
         const destroyedPartialWingsCount = hasPartialWings ? critSlots.filter(slot => slot.eq?.hasFlag('F_PARTIAL_WING') && this.isCritUnavailable(slot)).length : 0;
         const partialWingsHeatBonus = hasPartialWings ? Math.max(0, 3 - destroyedPartialWingsCount) : 0;
@@ -1686,12 +1686,12 @@ export class MekRules extends UnitTypeRulesBase {
         );
         const baselineJump = this.equipmentAdjustedJumpBaseline(
             unit.jump,
-            systemsStatus.jumpJetsCount,
+            this.installedComponentQuantity('F_JUMP_JET'),
             mobilityEquipment,
         );
         const baselineUMU = this.equipmentAdjustedUMUBaseline(
             unit.umu,
-            systemsStatus.UMUCount,
+            this.installedComponentQuantity('F_UMU'),
             mobilityEquipment,
         );
         let walkValue = restoredWalk;
@@ -1710,12 +1710,12 @@ export class MekRules extends UnitTypeRulesBase {
         );
         walkValue = legMovement.walk;
         moveImpaired = legMovement.moveImpaired;
+        const actuatorMovementReduction = this.legActuatorMovementReduction();
         if (legMovement.applyActuatorDamage) {
-            walkValue -= systemsStatus.destroyedLegActuatorsCount;
-            walkValue -= systemsStatus.destroyedFeetCount;
+            walkValue -= actuatorMovementReduction;
         }
         walkValue = Math.max(0, Math.min(restoredWalk, walkValue));
-        if (systemsStatus.destroyedLegActuatorsCount != 0 || systemsStatus.destroyedFeetCount != 0) {
+        if (actuatorMovementReduction !== 0) {
             moveImpaired = true;
         }
         
@@ -1753,12 +1753,22 @@ export class MekRules extends UnitTypeRulesBase {
         };
     }
 
+    protected legActuatorMovementReduction(): number {
+        const systemsStatus = this.systemsStatus();
+        return systemsStatus.destroyedLegActuatorsCount + systemsStatus.destroyedFeetCount;
+    }
+
     private restoredEquipmentWalkMP(equipment: MekMobilityEquipmentState): number {
         return (equipment.modularArmorInstalled && !equipment.modularArmorActive ? 1 : 0)
             + equipment.mediumShieldsInstalled - equipment.mediumShieldsActive
             + equipment.largeShieldsInstalled - equipment.largeShieldsActive;
     }
 
+    private installedComponentQuantity(flag: EquipmentFlag): number {
+        return this.unit.getUnit().comp.reduce((total, component) =>
+            total + (component.eq?.hasFlag(flag) ? component.q : 0), 0);
+    }
+
     private equipmentAdjustedJumpBaseline(
         storedJump: number,
         installedJumpJets: number,
diff --git a/src/app/models/rules/tw-rules.spec.ts b/src/app/models/rules/tw-rules.spec.ts
index 72c67d9d7..7f4b1de3b 100644
--- a/src/app/models/rules/tw-rules.spec.ts
+++ b/src/app/models/rules/tw-rules.spec.ts
@@ -14,6 +14,7 @@ import { UnitInitializerService } from '../../services/unit-initializer.service'
 import { createEmptyUnit } from '../../testing/unit-test-helpers';
 import { OptionsService } from '../../services/options.service';
 import { TWMekRules } from './tw-rules';
+import { MEK_LOCATIONS } from '../entity/types';
 
 class TestCBTForce extends CBTForce {
     override emitChanged(): void {
@@ -56,8 +57,8 @@ function createTWForceUnit(critSlots: CriticalSlot[] = []): CBTForceUnit {
     const force = new TestCBTForce('Test Force', dataService, unitInitializer, injector);
     const forceUnit = new CBTForceUnit(baseUnit, force, dataService, unitInitializer, injector);
     forceUnit.locations = {
-        internal: new Map(['LL', 'RL'].map(loc => [loc, { loc, points: 1 }])),
-        armor: new Map(['LL', 'RL'].map(loc => [loc, { loc, rear: false, points: 1 }])),
+        internal: new Map(MEK_LOCATIONS.map(loc => [loc, { loc, points: 1 }])),
+        armor: new Map(MEK_LOCATIONS.map(loc => [loc, { loc, rear: false, points: 1 }])),
     };
     forceUnit.setLocations({}, true);
     forceUnit.writeCrits(critSlots);
@@ -65,6 +66,12 @@ function createTWForceUnit(critSlots: CriticalSlot[] = []): CBTForceUnit {
     return forceUnit;
 }
 
+function hitCrit(forceUnit: CBTForceUnit, loc: string, slot: number): void {
+    const crit = forceUnit.getCritSlot(loc, slot);
+    if (!crit) throw new Error(`Missing critical slot ${loc}:${slot}`);
+    forceUnit.applyHitToCritSlot(crit);
+}
+
 describe('TWMekRules', () => {
     beforeEach(() => {
         dataService = jasmine.createSpyObj<DataService>('DataService', ['getEquipmentRegistry', 'findEquipment', 'getUnitByName']);
@@ -140,6 +147,147 @@ describe('TWMekRules', () => {
         expect(forceUnit.rules.PSRModifiers().modifier).toBe(5);
     });
 
+    it('keeps multiple committed leg-actuator modifiers cumulative in TW', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL', false),
+            legActuatorCrit('lower-leg', 'Lower Leg Actuator', 'LL', false),
+        ]);
+
+        hitCrit(forceUnit, 'LL', 1);
+        hitCrit(forceUnit, 'LL', 2);
+        forceUnit.endPhase();
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(2);
+        expect(forceUnit.rules.PSRModifiers().modifiers).toContain(jasmine.objectContaining({
+            pilotCheck: 2,
+            loc: 'LL',
+            modifierReason: 'Leg Actuators Destroyed (2)',
+        }));
+        expect((forceUnit.rules as TWMekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 3, run: 5 }));
+    });
+
+    it('keeps same-phase hip and leg-actuator modifiers cumulative after commit in TW', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('hip', 'Hip', 'LL', false),
+            legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL', false),
+        ]);
+        let timestamp = 100;
+        spyOn(Date, 'now').and.callFake(() => ++timestamp);
+
+        hitCrit(forceUnit, 'LL', 1);
+        const actuatorDestructionTimestamp = forceUnit.getCritSlot('LL', 1)?.destroying;
+        hitCrit(forceUnit, 'LL', 0);
+        const hipDestructionTimestamp = forceUnit.getCritSlot('LL', 0)?.destroying;
+
+        expect(forceUnit.turnState().getPSRChecks().map(check => check.reason)).toEqual([
+            'Leg actuator hit',
+            'Hip hit',
+        ]);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+
+        forceUnit.endPhase();
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        expect(actuatorDestructionTimestamp!).toBeLessThan(hipDestructionTimestamp!);
+        expect(forceUnit.getCritSlot('LL', 0)?.destroyed).toBe(hipDestructionTimestamp);
+        expect(forceUnit.getCritSlot('LL', 1)?.destroyed).toBe(actuatorDestructionTimestamp);
+        expect(forceUnit.getCritSlot('LL', 0)?.destroyedTurn)
+            .toBe(forceUnit.getCritSlot('LL', 1)?.destroyedTurn);
+        expect((forceUnit.rules as TWMekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
+    });
+
+    it('keeps an earlier-phase actuator when the same-turn hip is hit later in TW', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('hip', 'Hip', 'LL', false),
+            legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL', false),
+        ]);
+        let timestamp = 200;
+        spyOn(Date, 'now').and.callFake(() => ++timestamp);
+
+        hitCrit(forceUnit, 'LL', 1);
+        forceUnit.endPhase();
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(1);
+
+        hitCrit(forceUnit, 'LL', 0);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        forceUnit.endPhase();
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        expect(forceUnit.getCritSlot('LL', 1)!.destroyed!)
+            .toBeLessThan(forceUnit.getCritSlot('LL', 0)!.destroyed!);
+        expect(forceUnit.getCritSlot('LL', 0)?.destroyedTurn)
+            .toBe(forceUnit.getCritSlot('LL', 1)?.destroyedTurn);
+        expect((forceUnit.rules as TWMekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
+    });
+
+    it('keeps a later-phase actuator modifier after an existing same-leg hip in TW', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('hip', 'Hip', 'LL', false),
+            legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL', false),
+        ]);
+        let timestamp = 300;
+        spyOn(Date, 'now').and.callFake(() => ++timestamp);
+
+        hitCrit(forceUnit, 'LL', 0);
+        forceUnit.endPhase();
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(2);
+
+        hitCrit(forceUnit, 'LL', 1);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        forceUnit.endPhase();
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        expect(forceUnit.getCritSlot('LL', 0)!.destroyed!)
+            .toBeLessThan(forceUnit.getCritSlot('LL', 1)!.destroyed!);
+        expect(forceUnit.getCritSlot('LL', 1)?.destroyedTurn)
+            .toBe(forceUnit.getCritSlot('LL', 0)?.destroyedTurn);
+        expect((forceUnit.rules as TWMekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
+    });
+
+    it('lets a later-turn hip replace an earlier same-leg actuator modifier in TW', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('hip', 'Hip', 'LL', false),
+            legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL', false),
+        ]);
+
+        hitCrit(forceUnit, 'LL', 1);
+        forceUnit.endTurn();
+
+        hitCrit(forceUnit, 'LL', 0);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(2);
+        forceUnit.endPhase();
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(2);
+        expect(forceUnit.getCritSlot('LL', 0)!.destroyedTurn!)
+            .toBeGreaterThan(forceUnit.getCritSlot('LL', 1)!.destroyedTurn!);
+        expect((forceUnit.rules as TWMekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 3, run: 5 }));
+    });
+
+    it('keeps a later-turn actuator modifier after an existing same-leg hip in TW', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('hip', 'Hip', 'LL', false),
+            legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL', false),
+        ]);
+
+        hitCrit(forceUnit, 'LL', 0);
+        forceUnit.endTurn();
+
+        hitCrit(forceUnit, 'LL', 1);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        forceUnit.endPhase();
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        expect(forceUnit.getCritSlot('LL', 1)!.destroyedTurn!)
+            .toBeGreaterThan(forceUnit.getCritSlot('LL', 0)!.destroyedTurn!);
+        expect((forceUnit.rules as TWMekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
+    });
+
     it('retains the destroyed foot actuator PSR modifier in TW', () => {
         const forceUnit = createTWForceUnit([
             legActuatorCrit('foot', 'Foot', 'LL'),
@@ -173,11 +321,11 @@ describe('TWMekRules', () => {
         expect(forceUnit.rules.PSRModifiers().modifier).toBe(6);
     });
 
-    it('retains one legacy TW movement trigger and hip-dominant modifier for same-leg damage', () => {
+    it('keeps one TW movement trigger when a later hip replaces older same-leg modifiers', () => {
         const forceUnit = createTWForceUnit([
-            legActuatorCrit('hip', 'Hip', 'LL'),
-            legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL'),
-            legActuatorCrit('foot', 'Foot', 'LL'),
+            { ...legActuatorCrit('hip', 'Hip', 'LL'), destroyedTurn: 2 },
+            { ...legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL'), destroyedTurn: 1 },
+            { ...legActuatorCrit('foot', 'Foot', 'LL'), destroyedTurn: 1 },
         ]);
         const turnState = forceUnit.turnState();
         turnState.moveMode.set('jump');
diff --git a/src/app/models/rules/tw-rules.ts b/src/app/models/rules/tw-rules.ts
index 4cd907f1e..f8cd21cd7 100644
--- a/src/app/models/rules/tw-rules.ts
+++ b/src/app/models/rules/tw-rules.ts
@@ -130,7 +130,6 @@ export class TWMekRules extends MekRules {
                 fallCheck: this.hipPSRModifier,
                 pilotCheck: this.hipPSRModifier,
                 loc,
-                legFilter: loc,
                 reason: 'Hip hit',
             });
         });
@@ -148,19 +147,18 @@ export class TWMekRules extends MekRules {
         const modifiers: PSRCheck[] = [];
         const destroyedHips = critSlots.filter(slot => slot.loc
             && LEG_LOCATIONS.has(slot.loc)
-            && !this.unit.isEquipmentOperational(slot)
+            && slot.destroyed !== undefined
             && !ignoreLeg.has(slot.loc)
             && this.isNamedCrit(slot, 'Hip'));
         for (const hip of destroyedHips) {
             modifier += this.hipPSRModifier;
             modifiers.push({ pilotCheck: this.hipPSRModifier, loc: hip.loc!, reason: 'Hip Destroyed' });
-            ignoreLeg.add(hip.loc!);
         }
-        const destroyedActuators = critSlots.filter(slot => slot.loc
-            && LEG_LOCATIONS.has(slot.loc)
-            && !this.unit.isEquipmentOperational(slot)
-            && !ignoreLeg.has(slot.loc)
-            && (this.isNamedCrit(slot, 'Leg') || this.isNamedCrit(slot, 'Foot')));
+        const destroyedActuators = this.effectiveCommittedLegActuators(
+            critSlots,
+            this.unit.turnState().getPSRCheckState().hipsHit,
+        )
+            .filter(slot => !ignoreLeg.has(slot.loc!));
         const destroyedActuatorCounts = new Map<string, number>();
         for (const actuator of destroyedActuators) {
             destroyedActuatorCounts.set(actuator.loc!, (destroyedActuatorCounts.get(actuator.loc!) ?? 0) + 1);
@@ -179,6 +177,49 @@ export class TWMekRules extends MekRules {
         return { modifier, modifiers };
     }
 
+    private effectiveCommittedLegActuators(
+        critSlots: readonly CriticalSlot[],
+        currentTurnHipHits: ReadonlySet<string> | undefined = undefined,
+    ): CriticalSlot[] {
+        // BMM: a hip replaces same-leg actuator modifiers from earlier turns;
+        // actuator hits from the hip's turn or a later turn remain cumulative.
+        const hipDestroyedOnTurnByLeg = new Map<string, number>();
+        for (const slot of critSlots) {
+            if (!slot.loc
+                || !LEG_LOCATIONS.has(slot.loc)
+                || slot.destroyed === undefined
+                || !this.isNamedCrit(slot, 'Hip')) continue;
+            hipDestroyedOnTurnByLeg.set(
+                slot.loc,
+                Math.max(
+                    hipDestroyedOnTurnByLeg.get(slot.loc) ?? 0,
+                    slot.destroyedTurn ?? 0,
+                ),
+            );
+        }
+        if (currentTurnHipHits && currentTurnHipHits.size > 0) {
+            const currentTurn = this.unit.turnState().getTurnCounter();
+            for (const loc of currentTurnHipHits) {
+                hipDestroyedOnTurnByLeg.set(loc, currentTurn);
+            }
+        }
+
+        return critSlots.filter(slot => {
+            if (!slot.loc
+                || !LEG_LOCATIONS.has(slot.loc)
+                || slot.destroyed === undefined
+                || this.unit.isInternalLocCommittedDestroyed(slot.loc)
+                || (!this.isNamedCrit(slot, 'Leg') && !this.isNamedCrit(slot, 'Foot'))) return false;
+            const hipDestroyedOnTurn = hipDestroyedOnTurnByLeg.get(slot.loc);
+            const actuatorDestroyedOnTurn = slot.destroyedTurn ?? 0;
+            return hipDestroyedOnTurn === undefined || actuatorDestroyedOnTurn >= hipDestroyedOnTurn;
+        });
+    }
+
+    protected override legActuatorMovementReduction(): number {
+        return this.effectiveCommittedLegActuators(this.unit.getCritSlots()).length;
+    }
+
     protected override usesTorsoCripplingRules(): boolean {
         return false;
     }
@@ -296,7 +337,7 @@ export class TWMekRules extends MekRules {
     protected override readonly immobile = computed<boolean>(() => {
         if (!this.unit.isLoaded()) return false;
         if (this.unit.getCondition('shutdown')) return true;
-        if (this.allLimbsDestroyedOrMissing()) return true;
+        if (this.allLimbsDestroyed()) return true;
         if (!this.hasDroneOperatingSystem() && !this.hasFunctionalCrew()) return true;
         return false;
     });
diff --git a/src/app/models/turn-state.model.spec.ts b/src/app/models/turn-state.model.spec.ts
index 971f18093..e7c585978 100644
--- a/src/app/models/turn-state.model.spec.ts
+++ b/src/app/models/turn-state.model.spec.ts
@@ -528,6 +528,18 @@ describe('TurnState', () => {
             expect(restored.serialize()).toBeUndefined();
         });
 
+        it('starts at turn zero and round-trips the current turn counter', () => {
+            const { turnState } = createTurnStateHarness();
+
+            expect(turnState.getTurnCounter()).toBe(0);
+            expect(turnState.serialize()).toBeUndefined();
+
+            const { turnState: restored } = createTurnStateHarness();
+            restored.update(turnState.serialize());
+
+            expect(restored.getTurnCounter()).toBe(0);
+        });
+
         it('persists disabled movement PSRs while omitting other false and empty state', () => {
             const { turnState } = createTurnStateHarness();
             turnState.airborne.set(false);
@@ -542,7 +554,7 @@ describe('TurnState', () => {
 
             const serialized = turnState.serialize();
 
-            expect(serialized).toEqual({ applyMovePSR: false });
+            expect(turnState.serialize()).toEqual({ applyMovePSR: false });
 
             const { turnState: restored } = createTurnStateHarness();
             restored.update(serialized);
diff --git a/src/app/models/turn-state.model.ts b/src/app/models/turn-state.model.ts
index 8bad2e6b4..88f8fb0c9 100644
--- a/src/app/models/turn-state.model.ts
+++ b/src/app/models/turn-state.model.ts
@@ -57,6 +57,8 @@ export class TurnState {
     private readonly heatDissipationConsumed = this.modifiedSignal<number>(0);
     private readonly psrOutcomes = this.modifiedSignal<Record<string, RuleCheckOutcome>>({});
     private readonly equipmentStateChanged = this.modifiedSignal<boolean>(false);
+    /** Per-unit turn sequence, retained across phase commits. */
+    private turnCounter: number;
     airborne = this.modifiedSignal<boolean | null>(null, 'movement');
     moveMode = this.modifiedSignal<MotiveModes | null>(null, 'movement');
     moveDistance = this.modifiedSignal<number | null>(null, 'movement');
@@ -349,8 +351,9 @@ export class TurnState {
 
     heatProjectionVisible = computed<boolean>(() => this.hasPendingHeatResolution());
 
-    constructor(unitState: CBTForceUnitState) {
+    constructor(unitState: CBTForceUnitState, turnCounter = 0) {
         this.unitState = unitState;
+        this.turnCounter = turnCounter;
     }
 
     capturePassiveHeatSourceBaseline(): void {
@@ -427,6 +430,7 @@ export class TurnState {
 
     serialize(): SerializedTurnState | undefined {
         const turnState: SerializedTurnState = {};
+        const turnCounter = this.turnCounter;
         const airborne = this.airborne();
         const moveMode = this.moveMode();
         const moveDistance = this.moveDistance();
@@ -435,6 +439,7 @@ export class TurnState {
         const cover = this.cover();
         const psrChecks = this.serializePSRChecks();
 
+        if (turnCounter > 0) turnState.turnCounter = turnCounter;
         if (airborne === true) turnState.airborne = true;
         if (moveMode !== null) turnState.moveMode = moveMode;
         if (moveDistance !== null) turnState.moveDistance = moveDistance;
@@ -462,6 +467,7 @@ export class TurnState {
 
     update(data: SerializedTurnState | undefined) {
         this.withSuppressedModified(() => {
+            this.turnCounter = data?.turnCounter ?? this.turnCounter;
             this.airborne.set(data?.airborne ?? null);
             this.moveMode.set(data?.moveMode ?? null);
             this.moveDistance.set(data?.moveDistance ?? null);
@@ -482,6 +488,10 @@ export class TurnState {
         });
     }
 
+    getTurnCounter(): number {
+        return this.turnCounter;
+    }
+
     markEquipmentStateChanged(): void {
         this.equipmentStateChanged.set(true);
     }
diff --git a/src/app/models/units.model.ts b/src/app/models/units.model.ts
index 4e1b8c6ba..28104db55 100644
--- a/src/app/models/units.model.ts
+++ b/src/app/models/units.model.ts
@@ -139,6 +139,7 @@ export interface Unit {
     engineHSType: string | null; // Type of HeatSinks on the engine: "Heat Sink", "Double Heat Sink", "Laser Heat Sink", etc...
     source: string[]; // Sourcebook abbreviations exported from units.json.
     published: string[]; // Record sheet source(s), e.g. "RS:AS".
+    rulesRefs: string[]; // Rulebook abbreviations containing rules for the unit, e.g. "TM".
     canon: boolean; // True if the unit is canon, false if is not (e.g. alt-universe or april fools units)
     canAntiMech: boolean; // Whether the unit's Anti-Mech skill can be assigned below its restricted default
     role: string;
diff --git a/src/app/testing/unit-test-helpers.ts b/src/app/testing/unit-test-helpers.ts
index 64a0479a5..69a997acc 100644
--- a/src/app/testing/unit-test-helpers.ts
+++ b/src/app/testing/unit-test-helpers.ts
@@ -106,6 +106,7 @@ export function createEmptyUnit(overrides: TestUnitOverrides = {}): Unit {
         engineHSType: 'Heat Sink',
         source: [],
         published: [],
+        rulesRefs: [],
         canon: true,
         canAntiMech: false,
         role: '',
@@ -151,6 +152,7 @@ export function createEmptyUnit(overrides: TestUnitOverrides = {}): Unit {
 
     unit.source = unitOverrides.source ? [...unitOverrides.source] : [];
     unit.published = unitOverrides.published ? [...unitOverrides.published] : [];
+    unit.rulesRefs = unitOverrides.rulesRefs ? [...unitOverrides.rulesRefs] : [];
     unit.comp = unitOverrides.comp ? [...unitOverrides.comp] : [];
     unit.quirks = unitOverrides.quirks ? [...unitOverrides.quirks] : [];
     unit.features = unitOverrides.features ? [...unitOverrides.features] : [];

From 3099ba3af75e39dca7d08080bea3a00829b04cf7 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Thu, 20 Aug 2026 01:05:31 +0200
Subject: [PATCH 09/12] testt

---
 src/app/models/rules/tw-rules.spec.ts | 33 ++++++++++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/src/app/models/rules/tw-rules.spec.ts b/src/app/models/rules/tw-rules.spec.ts
index 7f4b1de3b..4d9ea0485 100644
--- a/src/app/models/rules/tw-rules.spec.ts
+++ b/src/app/models/rules/tw-rules.spec.ts
@@ -167,7 +167,7 @@ describe('TWMekRules', () => {
             .toEqual(jasmine.objectContaining({ walk: 3, run: 5 }));
     });
 
-    it('keeps same-phase hip and leg-actuator modifiers cumulative after commit in TW', () => {
+    it('keeps same-phase actuator then hip modifiers cumulative after commit in TW', () => {
         const forceUnit = createTWForceUnit([
             legActuatorCrit('hip', 'Hip', 'LL', false),
             legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL', false),
@@ -198,6 +198,37 @@ describe('TWMekRules', () => {
             .toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
     });
 
+    it('keeps same-phase hip then actuator modifiers cumulative after commit in TW', () => {
+        const forceUnit = createTWForceUnit([
+            legActuatorCrit('hip', 'Hip', 'LL', false),
+            legActuatorCrit('upper-leg', 'Upper Leg Actuator', 'LL', false),
+        ]);
+        let timestamp = 150;
+        spyOn(Date, 'now').and.callFake(() => ++timestamp);
+
+        hitCrit(forceUnit, 'LL', 0);
+        const hipDestructionTimestamp = forceUnit.getCritSlot('LL', 0)?.destroying;
+        hitCrit(forceUnit, 'LL', 1);
+        const actuatorDestructionTimestamp = forceUnit.getCritSlot('LL', 1)?.destroying;
+
+        expect(forceUnit.turnState().getPSRChecks().map(check => check.reason)).toEqual([
+            'Hip hit',
+            'Leg actuator hit',
+        ]);
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+
+        forceUnit.endPhase();
+
+        expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
+        expect(hipDestructionTimestamp!).toBeLessThan(actuatorDestructionTimestamp!);
+        expect(forceUnit.getCritSlot('LL', 0)?.destroyed).toBe(hipDestructionTimestamp);
+        expect(forceUnit.getCritSlot('LL', 1)?.destroyed).toBe(actuatorDestructionTimestamp);
+        expect(forceUnit.getCritSlot('LL', 1)?.destroyedTurn)
+            .toBe(forceUnit.getCritSlot('LL', 0)?.destroyedTurn);
+        expect((forceUnit.rules as TWMekRules).movementState())
+            .toEqual(jasmine.objectContaining({ walk: 2, run: 3 }));
+    });
+
     it('keeps an earlier-phase actuator when the same-turn hip is hit later in TW', () => {
         const forceUnit = createTWForceUnit([
             legActuatorCrit('hip', 'Hip', 'LL', false),

From f4c22ed8d037f739bea4c61964f196b40ecc3d74 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Thu, 20 Aug 2026 01:19:32 +0200
Subject: [PATCH 10/12] test

---
 src/app/models/rules/tw-rules.spec.ts | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/app/models/rules/tw-rules.spec.ts b/src/app/models/rules/tw-rules.spec.ts
index 4d9ea0485..8d4792287 100644
--- a/src/app/models/rules/tw-rules.spec.ts
+++ b/src/app/models/rules/tw-rules.spec.ts
@@ -211,10 +211,9 @@ describe('TWMekRules', () => {
         hitCrit(forceUnit, 'LL', 1);
         const actuatorDestructionTimestamp = forceUnit.getCritSlot('LL', 1)?.destroying;
 
-        expect(forceUnit.turnState().getPSRChecks().map(check => check.reason)).toEqual([
-            'Hip hit',
-            'Leg actuator hit',
-        ]);
+        expect(forceUnit.turnState().getPSRChecks().map(check => check.reason)).toEqual(
+            jasmine.arrayWithExactContents(['Hip hit', 'Leg actuator hit']),
+        );
         expect(forceUnit.rules.PSRModifiers().modifier).toBe(3);
 
         forceUnit.endPhase();

From 3f2ae1e3e4590d527ec0472687abf7d2088b0da9 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Thu, 20 Aug 2026 01:53:00 +0200
Subject: [PATCH 11/12] lobby case

---
 .../join-lobby-dialog/join-lobby-dialog.component.ts        | 6 +++---
 src/app/components/lobby-dialog/lobby-dialog.component.scss | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/app/components/join-lobby-dialog/join-lobby-dialog.component.ts b/src/app/components/join-lobby-dialog/join-lobby-dialog.component.ts
index baa5209f6..7e13a78f6 100644
--- a/src/app/components/join-lobby-dialog/join-lobby-dialog.component.ts
+++ b/src/app/components/join-lobby-dialog/join-lobby-dialog.component.ts
@@ -129,7 +129,7 @@ export interface JoinLobbyDialogData {
             font-family: monospace;
             font-size: 1.4rem;
             font-weight: 700;
-            text-transform: lowercase;
+            text-transform: uppercase;
         }
 
         .hint {
@@ -163,7 +163,7 @@ export class JoinLobbyDialogComponent {
     readonly generatingName = signal(false);
     readonly joining = signal(false);
     readonly joinError = signal('');
-    readonly isValid = computed(() => /^[a-z0-9]{4}$/.test(this.code()) && normalizeDisplayName(this.displayName()) !== null);
+    readonly isValid = computed(() => /^[a-z0-9]{4}$/i.test(this.code()) && normalizeDisplayName(this.displayName()) !== null);
 
     onCodeInput(event: Event): void {
         const input = event.target as HTMLInputElement;
@@ -194,7 +194,7 @@ export class JoinLobbyDialogComponent {
         event?.stopPropagation();
         if (this.joining()) return;
         const displayName = normalizeDisplayName(this.displayName());
-        if (!displayName || !/^[a-z0-9]{4}$/.test(this.code())) return;
+        if (!displayName || !/^[a-z0-9]{4}$/i.test(this.code())) return;
 
         this.joining.set(true);
         this.joinError.set('');
diff --git a/src/app/components/lobby-dialog/lobby-dialog.component.scss b/src/app/components/lobby-dialog/lobby-dialog.component.scss
index d768c7f17..0d4d26f04 100644
--- a/src/app/components/lobby-dialog/lobby-dialog.component.scss
+++ b/src/app/components/lobby-dialog/lobby-dialog.component.scss
@@ -43,7 +43,7 @@
     font-weight: bold;
     line-height: 1;
     letter-spacing: 0;
-    text-transform: lowercase;
+    text-transform: uppercase;
 }
 
 .lobby-code-wrapper {

From dd9c99164238a4fe2594b4ef821201f19ae15175 Mon Sep 17 00:00:00 2001
From: exeea <dev@exeea.com>
Date: Thu, 20 Aug 2026 01:53:35 +0200
Subject: [PATCH 12/12] rulebooks filter

---
 src/app/services/unit-search-filters.model.ts |  1 +
 .../unit-search-filters.service.spec.ts       | 36 +++++++++++-
 .../services/unit-search-filters.service.ts   |  1 +
 .../unit-search-index.service.spec.ts         | 20 ++++++-
 src/app/services/unit-search-index.service.ts |  4 +-
 src/app/unit-search.worker.spec.ts            | 43 +++++++++++++-
 src/app/utils/semantic-filter-ast.util.ts     | 10 +++-
 src/app/utils/unit-filter-kernel.util.ts      | 16 +++++-
 .../utils/unit-search-executor.util.spec.ts   | 19 ++++++-
 src/app/utils/unit-search-shared.util.ts      | 57 ++++++++++++++++++-
 .../unit-search-worker-request.util.spec.ts   | 25 +++++++-
 11 files changed, 222 insertions(+), 10 deletions(-)

diff --git a/src/app/services/unit-search-filters.model.ts b/src/app/services/unit-search-filters.model.ts
index b9e7c509d..7b1288a5c 100644
--- a/src/app/services/unit-search-filters.model.ts
+++ b/src/app/services/unit-search-filters.model.ts
@@ -440,6 +440,7 @@ export const DROPDOWN_FILTERS: readonly DropdownFilterConfig[] = Object.freeze([
     { key: 'features', semanticKey: 'features', label: 'Features', multistate: true, game: GameSystem.CLASSIC, optionSource: 'indexed', availabilitySource: 'indexed', propertyShape: 'array' },
     { key: 'quirks', semanticKey: 'quirks', label: 'Quirks', multistate: true, game: GameSystem.CLASSIC, optionSource: 'indexed', availabilitySource: 'indexed', propertyShape: 'array' },
     { key: 'source', semanticKey: 'source', label: 'Source', multistate: true, optionSource: 'indexed', availabilitySource: 'indexed', propertyShape: 'array' },
+    { key: 'rulesRefs', semanticKey: 'rulesRefs', label: 'Rulebooks', optionSource: 'indexed', availabilitySource: 'indexed', propertyShape: 'array' },
     { key: 'forcePack', semanticKey: 'pack', label: 'Force Packs', external: true, optionSource: 'external', availabilitySource: 'context', propertyShape: 'scalar' },
     { key: '_tags', semanticKey: 'tags', label: 'Tags', multistate: true, optionSource: 'indexed', availabilitySource: 'indexed', propertyShape: 'array' },
 ]);
diff --git a/src/app/services/unit-search-filters.service.spec.ts b/src/app/services/unit-search-filters.service.spec.ts
index c772414da..e950760f7 100644
--- a/src/app/services/unit-search-filters.service.spec.ts
+++ b/src/app/services/unit-search-filters.service.spec.ts
@@ -4965,11 +4965,43 @@ describe('UnitSearchFiltersService search telemetry', () => {
         expect(service.queryParameters()['filters']).toBe(`as.specials:"${special}"`);
     });
 
-    it('declares indexed dropdown capabilities for source, faction, and era', () => {
+    it('ignores extra rulebook expansions until a baseline is selected', () => {
+        const bundle = createStandaloneBundle();
+        bundle.units.units[0].name = 'Unit A';
+        bundle.units.units[0].rulesRefs = ['BMM', 'Shrap01', 'IO:AE'];
+        bundle.units.units[1].name = 'Unit B';
+        bundle.units.units[1].rulesRefs = ['TW', 'Shrap01', 'AAA'];
+
+        const { service } = createService(bundle);
+        const rulebookOptions = service.advOptions()['rulesRefs']?.options ?? [];
+        expect(rulebookOptions.filter(option => typeof option !== 'number').map(option => option.name).sort())
+            .toEqual(['AAA', 'BMM', 'IO:AE', 'Shrap01', 'TW']);
+
+        service.setFilter('rulesRefs', ['Shrap01']);
+        expect(service.filteredUnits().map(unit => unit.name)).toEqual(['Unit A', 'Unit B']);
+
+        service.setFilter('rulesRefs', ['Shrap01', 'AAA']);
+        expect(service.filteredUnits().map(unit => unit.name)).toEqual(['Unit A', 'Unit B']);
+
+        service.setFilter('rulesRefs', ['TW', 'Shrap01']);
+        expect(service.filteredUnits().map(unit => unit.name)).toEqual([]);
+
+        service.setFilter('rulesRefs', ['TW']);
+        expect(service.filteredUnits().map(unit => unit.name)).toEqual([]);
+
+        service.setFilter('rulesRefs', ['TW', 'Shrap01', 'AAA']);
+        expect(service.filteredUnits().map(unit => unit.name)).toEqual(['Unit B']);
+    });
+
+    it('declares indexed dropdown capabilities for rules references, source, faction, and era', () => {
+        const rulesRefsConfig = getAdvancedFilterConfigByKey('rulesRefs');
         const sourceConfig = getAdvancedFilterConfigByKey('source');
         const factionConfig = getAdvancedFilterConfigByKey('faction');
         const eraConfig = getAdvancedFilterConfigByKey('era');
 
+        expect(rulesRefsConfig?.multistate).toBeFalsy();
+        expect(usesIndexedDropdownUniverse(rulesRefsConfig)).toBeTrue();
+        expect(usesIndexedDropdownAvailability(rulesRefsConfig)).toBeTrue();
         expect(usesIndexedDropdownUniverse(sourceConfig)).toBeTrue();
         expect(usesIndexedDropdownAvailability(sourceConfig)).toBeTrue();
         expect(usesIndexedDropdownUniverse(factionConfig)).toBeTrue();
@@ -6467,4 +6499,4 @@ describe('UnitSearchFiltersService search telemetry', () => {
 
         expect(service.filteredUnits().map(unit => unit.name)).toEqual(['Test Mek']);
     });
-});
\ No newline at end of file
+});
diff --git a/src/app/services/unit-search-filters.service.ts b/src/app/services/unit-search-filters.service.ts
index eec81319f..cda1aa66b 100644
--- a/src/app/services/unit-search-filters.service.ts
+++ b/src/app/services/unit-search-filters.service.ts
@@ -172,6 +172,7 @@ export class UnitSearchFiltersService {
     /** Display name resolvers that need service dependencies (can't be defined in static config) */
     private readonly displayNameFns: Partial<Record<string, (v: string) => string>> = {
         'source': (v) => this.dataService.getSourcebookTitle(v),
+        'rulesRefs': (v) => this.dataService.getSourcebookTitle(v),
     };
 
     private buildIndexedDropdownOptions(
diff --git a/src/app/services/unit-search-index.service.spec.ts b/src/app/services/unit-search-index.service.spec.ts
index 80040f22e..f1b7adc85 100644
--- a/src/app/services/unit-search-index.service.spec.ts
+++ b/src/app/services/unit-search-index.service.spec.ts
@@ -255,6 +255,24 @@ describe('UnitSearchIndexService', () => {
         ]);
     });
 
+    it('indexes every unit rules reference as a dropdown value', () => {
+        const service = new UnitSearchIndexService();
+
+        service.rebuildIndexes([
+            createUnit({ name: 'Atlas AS7-D', rulesRefs: ['TM', 'TO'] }),
+            createUnit({ name: 'Locust LCT-1V', rulesRefs: ['TM'] }),
+            createUnit({ name: 'Legacy Unit' }),
+        ], [], []);
+
+        expect(service.getIndexedFilterValues('rulesRefs')).toEqual(['TM', 'TO']);
+        expect(service.getIndexedUnitIds('rulesRefs', 'TM')).toEqual(new Set(['Atlas AS7-D', 'Locust LCT-1V']));
+        expect(service.getIndexedUnitIds('rulesRefs', 'TO')).toEqual(new Set(['Atlas AS7-D']));
+        expect(service.getDropdownOptionUniverse('rulesRefs')).toEqual([
+            { name: 'TM' },
+            { name: 'TO' },
+        ]);
+    });
+
     it('indexes canon and published status as yes/no values', () => {
         const service = new UnitSearchIndexService();
 
@@ -338,4 +356,4 @@ describe('UnitSearchIndexService', () => {
         expect(unit._weaponTypeCounts).toEqual({});
         expect(service.getIndexedFilterValues('weaponType')).toEqual([]);
     });
-});
\ No newline at end of file
+});
diff --git a/src/app/services/unit-search-index.service.ts b/src/app/services/unit-search-index.service.ts
index d9c818e59..dec0f8ca5 100644
--- a/src/app/services/unit-search-index.service.ts
+++ b/src/app/services/unit-search-index.service.ts
@@ -298,6 +298,7 @@ export class UnitSearchIndexService {
             this.addSearchIndexValues('as.specials', unit.as?.specials ?? [], unit.name);
             this.addSearchIndexValues('as._motive', this.getASMotiveDisplayNames(unit), unit.name);
             this.addSearchIndexValues('source', getUnitSourceFilterValues(unit), unit.name);
+            this.addSearchIndexValues('rulesRefs', unit.rulesRefs ?? [], unit.name);
             this.addSearchIndexValues('componentName', unit.comp.map(component => component.n), unit.name);
             this.addComponentCountValues(unit);
             this.prepareUnitWeaponTypes(unit);
@@ -429,6 +430,7 @@ export class UnitSearchIndexService {
             'moveType',
             'as._motive',
             'source',
+            'rulesRefs',
             'componentName',
             'weaponType',
             'features',
@@ -609,4 +611,4 @@ export class UnitSearchIndexService {
         return Math.round(sum);
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/app/unit-search.worker.spec.ts b/src/app/unit-search.worker.spec.ts
index efc9002c5..61ac2f16c 100644
--- a/src/app/unit-search.worker.spec.ts
+++ b/src/app/unit-search.worker.spec.ts
@@ -214,4 +214,45 @@ describe('unit-search worker', () => {
             telemetryQuery: 'canon:no',
         }).entries).toEqual([{ unitName: 'Unpublished Non-Canon' }]);
     });
-});
\ No newline at end of file
+
+    it('ignores extra rulebook expansions until a baseline is selected in the worker', () => {
+        const unitA = createUnit('Unit A');
+        unitA.rulesRefs = ['BMM', 'Shrap01', 'IO:AE'];
+        const unitB = createUnit('Unit B');
+        unitB.rulesRefs = ['TW', 'Shrap01', 'AAA'];
+
+        const runtime = __test__.hydrateCorpus({
+            corpusVersion: '1:0',
+            units: [unitA, unitB],
+            indexes: {
+                rulesRefs: {
+                    BMM: ['Unit A'],
+                    TW: ['Unit B'],
+                    Shrap01: ['Unit A', 'Unit B'],
+                    'IO:AE': ['Unit A'],
+                    AAA: ['Unit B'],
+                },
+            },
+            factionEraIndex: {},
+        });
+        const baseRequest = createRequest();
+
+        const getEntries = (executionQuery: string) => __test__.buildResultMessage(runtime, {
+            ...baseRequest,
+            executionQuery,
+            telemetryQuery: executionQuery,
+        }).entries;
+
+        expect(getEntries('rulesRefs=Shrap01')).toEqual([
+            { unitName: 'Unit A' },
+            { unitName: 'Unit B' },
+        ]);
+        expect(getEntries('rulesRefs=Shrap01,AAA')).toEqual([
+            { unitName: 'Unit A' },
+            { unitName: 'Unit B' },
+        ]);
+        expect(getEntries('rulesRefs=TW,Shrap01')).toEqual([]);
+        expect(getEntries('rulesRefs=TW')).toEqual([]);
+        expect(getEntries('rulesRefs=TW,Shrap01,AAA')).toEqual([{ unitName: 'Unit B' }]);
+    });
+});
diff --git a/src/app/utils/semantic-filter-ast.util.ts b/src/app/utils/semantic-filter-ast.util.ts
index 6a5639cd2..996f7b706 100644
--- a/src/app/utils/semantic-filter-ast.util.ts
+++ b/src/app/utils/semantic-filter-ast.util.ts
@@ -33,7 +33,7 @@ import { ADVANCED_FILTERS, type AdvFilterConfig, AdvFilterType, type Availabilit
 import { type SemanticOperator, type SemanticToken, buildSemanticKeyMap, VIRTUAL_SEMANTIC_KEYS, parseValues, parseValueWithQuantity, type QuantityConstraint } from './semantic-filter.util';
 import { normalizeLooseText, wildcardToRegex } from './string.util';
 import { usesIndexedDropdownUniverse } from './unit-search-filter-config.util';
-import { checkQuantityConstraint as checkQuantityConstraintCore, isEmbeddedApostrophe } from './unit-search-shared.util';
+import { checkQuantityConstraint as checkQuantityConstraintCore, isEmbeddedApostrophe, unitMatchesRulesRefsSelection } from './unit-search-shared.util';
 import { isASDamageSemanticKey, parseASDamageValue } from './as-damage.util';
 
 // ============================================================================
@@ -2751,6 +2751,14 @@ function evaluateDropdownFilter(
         return evaluateASSpecialsFilter(unitValue, operator, values);
     }
 
+    if (conf.key === 'rulesRefs' && (operator === '=' || operator === '==')) {
+        const selectedRulesRefs = Array.from(new Set(values.flatMap(value => {
+            const indexedMatches = matchIndexedStoredValues(conf.key, value, context);
+            return indexedMatches.length > 0 ? indexedMatches : [value];
+        })));
+        return unitMatchesRulesRefsSelection(unitValue, selectedRulesRefs);
+    }
+
     if (unitValue == null) return operator === '!=';
     
     // Normalize unit value(s) to array
diff --git a/src/app/utils/unit-filter-kernel.util.ts b/src/app/utils/unit-filter-kernel.util.ts
index ebdd380e8..e564a6aa3 100644
--- a/src/app/utils/unit-filter-kernel.util.ts
+++ b/src/app/utils/unit-filter-kernel.util.ts
@@ -21,6 +21,7 @@ import {
     getSelectedPositiveDropdownNames,
     getUnitCountableFilterData,
     normalizeMultiStateSelection,
+    unitMatchesRulesRefsSelection,
 } from './unit-search-shared.util';
 import { getUnitVariantGroupKey } from './unit-variant.util';
 import { isCountableBackedDropdown } from './unit-search-filter-config.util';
@@ -284,6 +285,19 @@ export function applyFilterStateToUnits(request: ApplyUnitFilterStateRequest): U
             continue;
         }
 
+        if (conf.type === AdvFilterType.DROPDOWN && conf.key === 'rulesRefs') {
+            const selectedRulesRefs = Array.isArray(val)
+                ? val.filter((value): value is string => typeof value === 'string')
+                : [];
+            if (selectedRulesRefs.length > 0) {
+                results = results.filter(unit => unitMatchesRulesRefsSelection(
+                    dependencies.getProperty(unit, conf.key),
+                    selectedRulesRefs,
+                ));
+            }
+            continue;
+        }
+
         if (conf.type === AdvFilterType.DROPDOWN && conf.multistate) {
             results = filterUnitsByMultiState(
                 results,
@@ -465,4 +479,4 @@ export function applyFilterStateToUnits(request: ApplyUnitFilterStateRequest): U
     }
 
     return results;
-}
\ No newline at end of file
+}
diff --git a/src/app/utils/unit-search-executor.util.spec.ts b/src/app/utils/unit-search-executor.util.spec.ts
index c7501c5a0..d76780d94 100644
--- a/src/app/utils/unit-search-executor.util.spec.ts
+++ b/src/app/utils/unit-search-executor.util.spec.ts
@@ -210,4 +210,21 @@ describe('unit-search-executor', () => {
         expect(executeQuery([dualTyped, areaEffectOnly], 'weaponType&="AI:>=2" weaponType&="AE:>=2"').map(unit => unit.name))
             .toEqual(['Dual Typed']);
     });
-});
\ No newline at end of file
+
+    it('ignores extra rulebook expansions until a baseline is selected', () => {
+        const unitA = createEmptyUnit({ name: 'Unit A', rulesRefs: ['BMM', 'Shrap01', 'IO:AE'] });
+        const unitB = createEmptyUnit({ name: 'Unit B', rulesRefs: ['TW', 'Shrap01', 'AAA'] });
+        const units = [unitA, unitB];
+
+        expect(executeQuery(units, 'rulesRefs=Shrap01').map(unit => unit.name))
+            .toEqual(['Unit A', 'Unit B']);
+        expect(executeQuery(units, 'rulesRefs=Shrap01,AAA').map(unit => unit.name))
+            .toEqual(['Unit A', 'Unit B']);
+        expect(executeQuery(units, 'rulesRefs=TW,Shrap01').map(unit => unit.name))
+            .toEqual([]);
+        expect(executeQuery(units, 'rulesRefs=TW').map(unit => unit.name))
+            .toEqual([]);
+        expect(executeQuery(units, 'rulesRefs=TW,Shrap01,AAA').map(unit => unit.name))
+            .toEqual(['Unit B']);
+    });
+});
diff --git a/src/app/utils/unit-search-shared.util.ts b/src/app/utils/unit-search-shared.util.ts
index 8827fd84e..e60f8247d 100644
--- a/src/app/utils/unit-search-shared.util.ts
+++ b/src/app/utils/unit-search-shared.util.ts
@@ -66,6 +66,61 @@ export function getUnitSourceFilterValues(unit: Pick<Unit, 'source' | 'published
     return Array.from(merged.values());
 }
 
+export const BASELINE_UNIT_RULES_REFS = Object.freeze(['TW', 'TM', 'BMM', 'Core']);
+
+const baselineUnitRulesRefKeys = new Set(BASELINE_UNIT_RULES_REFS.map(value => value.toLowerCase()));
+
+function normalizeUnitRulesRefs(values: unknown): Set<string> {
+    if (!Array.isArray(values)) {
+        return new Set<string>();
+    }
+
+    return new Set(
+        values
+            .filter((value): value is string => typeof value === 'string')
+            .map(value => value.trim().toLowerCase())
+            .filter(value => value.length > 0),
+    );
+}
+
+/**
+ * Matches the specialized Rulebooks filter semantics.
+ *
+ * Without a selected baseline, expansion references are ordinary OR choices and
+ * extra expansion references on a unit are ignored. Once a baseline is selected,
+ * a unit must contain any selected baseline and the selected expansions become
+ * the complete allowed expansion set. With only baselines selected, units
+ * carrying any expansion are excluded.
+ */
+export function unitMatchesRulesRefsSelection(unitRulesRefs: unknown, selectedRulesRefs: readonly string[]): boolean {
+    const selectedRefs = normalizeUnitRulesRefs(selectedRulesRefs);
+    if (selectedRefs.size === 0) {
+        return true;
+    }
+
+    const unitRefs = normalizeUnitRulesRefs(unitRulesRefs);
+    const selectedBaselines = new Set(Array.from(selectedRefs).filter(value => baselineUnitRulesRefKeys.has(value)));
+    const selectedExpansions = new Set(Array.from(selectedRefs).filter(value => !baselineUnitRulesRefKeys.has(value)));
+    const unitBaselines = Array.from(unitRefs).filter(value => baselineUnitRulesRefKeys.has(value));
+    const unitExpansions = Array.from(unitRefs).filter(value => !baselineUnitRulesRefKeys.has(value));
+
+    if (selectedBaselines.size === 0) {
+        return selectedExpansions.size > 0
+            && unitExpansions.some(value => selectedExpansions.has(value));
+    }
+
+    if (!unitBaselines.some(value => selectedBaselines.has(value))) {
+        return false;
+    }
+
+    if (selectedExpansions.size === 0) {
+        return unitExpansions.length === 0;
+    }
+
+    return unitExpansions.length > 0
+        && unitExpansions.every(value => selectedExpansions.has(value));
+}
+
 export function getProperty(obj: any, key?: string) {
     if (!obj || !key) return undefined;
     if (key === '_tags') {
@@ -363,4 +418,4 @@ export function measureStage<T>(
 
     stages.push(stage);
     return value;
-}
\ No newline at end of file
+}
diff --git a/src/app/utils/unit-search-worker-request.util.spec.ts b/src/app/utils/unit-search-worker-request.util.spec.ts
index efb79b3db..08a52be42 100644
--- a/src/app/utils/unit-search-worker-request.util.spec.ts
+++ b/src/app/utils/unit-search-worker-request.util.spec.ts
@@ -97,6 +97,29 @@ describe('buildWorkerExecutionQuery', () => {
         expect(executionQuery).toContain('weaponType&=AE');
         expect(parseSemanticQueryAST(executionQuery, GameSystem.CLASSIC).errors).toEqual([]);
     });
+
+    it('serializes plain rulebook selections for worker execution', () => {
+        const executionQuery = buildWorkerExecutionQuery({
+            effectiveFilterState: {
+                rulesRefs: {
+                    value: ['TW', 'Shrap01', 'AAA'],
+                    interactedWith: true,
+                },
+            },
+            effectiveTextSearch: '',
+            gameSystem: GameSystem.CLASSIC,
+            totalRangesCache: {},
+        });
+
+        expect(executionQuery).toBe('rulesRefs=TW,Shrap01,AAA');
+        expect(parseSemanticQueryAST(executionQuery, GameSystem.CLASSIC).tokens).toEqual([
+            jasmine.objectContaining({
+                field: 'rulesrefs',
+                operator: '=',
+                values: ['TW', 'Shrap01', 'AAA'],
+            }),
+        ]);
+    });
 });
 
 describe('getWorkerCorpusSnapshot', () => {
@@ -113,4 +136,4 @@ describe('getWorkerCorpusSnapshot', () => {
 
         expect(second.snapshot).toBe(first.snapshot);
     });
-});
\ No newline at end of file
+});