# GCU Log Event Catalog & Failure Signatures

Companion reference for `reading-gcu-logs`. Contents:

1. [Flash log event catalog](#flash-log-event-catalog)
2. [Shift phase numbers](#shift-phase-numbers) (HB `phase=`)
3. [Live serial shift trace lines](#live-serial-shift-trace-lines)
4. [DUMP_STATUS fields](#dump_status-fields)
5. [Failure-mode signatures](#failure-mode-signatures) — false neutrals, with decision tree
6. [Crash diagnosis checklist](#crash-diagnosis-checklist)
7. [Worked example](#worked-example-false-neutral-incident)

## Flash log event catalog

Failure-class events (marked ✗) get wall-clock + `(sess)` + `lap:` context
when the AiM dash was alive at event time. They also carry `thr:N latg:N
long:N` — AiM throttle (raw, may exceed 100; 65535 = dash absent) and
signed lateral/longitudinal G from the 0x712 AiM Dynamics broadcast, all
frozen at the moment the event was written. `latg:0`/`long:0` when 0x712
had not been received. Exception-class events also go to the separate
`/exceptions.log` (dumped by `DUMP_EXCEPTIONS`).

| Event name                             | Class       | Meaning                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| -------------------------------------- | ----------- |   |
| `SHIFT_BLOCK_MONEY`                    | ✗ exception | Downshift refused — predicted RPM over the money-shift limit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `SHIFT_BLOCK_INVALID_CAN`              | ✗ exception | Shift refused — gear/RPM data invalid or stale                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `SHIFT_BLOCK_LOW_RPM`                  | ✗ exception | Shift refused — RPM too low                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `SHIFT_BLOCK_LOW_GEAR`                 | ✗ exception | Shift refused — already in lowest legal gear for that direction/mode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `PRESSURE_CRIT`                        | ✗ exception | Tank pressure critically high (≥110 PSI)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `CAN_TIMEOUT_RPM` / `CAN_TIMEOUT_GEAR` | ✗ exception | ECU RPM / gear data stopped arriving                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `CAN_ERROR`                            | ✗ exception | General CAN fault                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `SHIFT_OK_UP` / `SHIFT_OK_DOWN`        | normal      | Shift completed. Message is EITHER the full per-sample body (interesting shift) OR a one-line summary `g:FROM->TO rpm_pre:N dur:Nms` (clean shift, or an interesting shift whose staged trace was evicted from the ring before flush). "Interesting" = landed off the expected gear (drum kinematics), a 1↔2 shift (traverses N), a misshift retry fired, or landed in N/unknown. `SET trace_all_shifts 1` forces the full body for every shift. Full body, same in both directions: `g:FROM->TO tps_pre:N rpm_pre:N rpm:[...] thr:[...] bf:[...] br:[...] adc:[...]`. `tps_pre:` is a single header value (not an array), reads 0 on this ECU. `bf:[...]`/`br:[...]` = front/rear brake pressure in **signed psi** per 10 ms sample, BOTH directions (no conversion — released reads near 0, slightly negative at rest; rising brake into an adc[]→N drum trace = Mode E brake-induced false-neutral). `br:[...]` is always the AiM rear channel, so `-32768` = dash stale/absent. `bf:[...]` follows `brake_front_source`: at 1 (default) it is the GCU analog sensor on A4, the dash can be stale while `bf` is valid, and `-32768` = that source unavailable or excluded; at 0 it is the AiM front channel and `-32768` = dash stale/absent. `adc:[...]` = raw GP drum ADC per sample, on upshifts as well as downshifts (issue #180). Firmware older than 2026-07-26 carries `gss:[...]` in that position on upshifts instead. It is not a drum trace and it is not usable: trace sampling starts after the valve closes and the throttle is back to nominal, so it reads all zeros in every such log. Do not infer cut, blip, or drum movement from it, and do not report an absent cut on its evidence (`SKILL.md` has the canonical wording). `thr[i]` = AiM raw throttle at that sample (65535 = dash stale/absent). Older logs may still carry the dropped `tps:[...] psi:[...] gear:[...]` arrays, or an evicted-trace pre-4.1.1 truncated stub (cut at 47 chars). `g:X->X` (unchanged) after a `CL_TIMEOUT` = completion not confirmed, not necessarily failed. |
| `SHIFT_OK_NT_UP` / `SHIFT_OK_NT_DOWN`  | normal      | Neutral-button shift completed (N→1 / 1→N)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `SHIFT_FAIL_UP` / `SHIFT_FAIL_DOWN`    | ✗           | Shift failed outright                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `COMPRESSOR_ON` / `COMPRESSOR_OFF`     | normal      | Compressor relay hysteresis (on ≤70 PSI, off ≥90 PSI). Constant rapid cycling = air leak.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `BOOT`                                 | normal      | System startup — marks a new session/power cycle                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `HEALTH`                               | normal      | Periodic health snapshot                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `SHIFT_CL_OK`                          | normal      | Closed-loop validator saw the drum reach the target gear                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `SHIFT_CL_TIMEOUT`                     | ✗           | Validator never saw the target within the window. Msg `Closed-loop shift timeout`. The `gear:` field = where the drum actually was. Singles at high RPM are noise; see Failure modes for when it matters.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `NEUTRAL_CL_OK` / `NEUTRAL_CL_TIMEOUT` | normal / ✗  | Progressive neutral-finder (pulse-and-check hunting for the N half-detent) succeeded / gave up. Timeout msg `Neutral overshoot` = drum blew past N.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `GEAR_MISMATCH`                        | ✗           | GP drum sensor and CAN gear disagree. Msg `GP/CAN disagree (arbitrated=GP)` tells you which source won. Benign in the ~100 ms after a shift; meaningful when persistent or showing `gear:0` after a 2→1.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `MISSHIFT_RETRY`                       | ✗           | A 1↔2 shift landed on N — automatic corrective valve pulse fired. Msg distinguishes `Misshift retry` (in-shift), `Misshift legacy escalation` (final full-length push), `Post-shift bounce retry` (from post-shift validation).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `TIMESYNC`                             | normal      | Wall clock (re)anchored from AiM GPS time — pairs epoch with millis                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `RPM_STALE_DOWNSHIFT`                  | ✗           | Money-shift gate evaluated against an RPM sample older than `rpm_stale_warn_ms`. Shift still allowed — warn only.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `SERIAL_OVERSIZE`                      | ✗ exception | Firmware had to split an over-long serial line (firmware bug indicator)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `CONSTS_MIGRATED`                      | info        | Settings file migrated to v2; legacy `max_rpm`/`downshift_safety_margin` folded into `downshift_block_rpm`. Msg records old→new threshold.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |

## Shift phase numbers

HB `phase=` values (the shift state machine):

| #   | Phase           | Meaning                                                                         |
| --- | --------------- | ------------------------------------------------------------------------------- |
| 0   | IDLE            | No shift in progress                                                            |
| 1   | ACTIVE          | Shift valve open, throttle cut/blip active                                      |
| 2   | POST_DELAY1     | Valve closed, waiting before countershift                                       |
| 3   | COUNTERSHIFT    | Opposite valve pulsed to seat the drum (skipped for 1↔2 and from-N shifts)      |
| 4   | POST_DELAY2     | Final settle delay                                                              |
| 5   | TRACE_SAMPLING  | Valve closed; capturing the 300 ms post-shift trace (rpm/thr/bf/br/adc samples) |
| 6   | MISSHIFT_SETTLE | Waiting between misshift retry pulses                                           |
| 7   | MISSHIFT_PULSE  | Retry valve pulse firing                                                        |
| 8   | MISSHIFT_LEGACY | Last-resort full-duration push-through                                          |
| 9   | NEUTRAL_PULSE   | Progressive neutral-finder pulse                                                |
| 10  | NEUTRAL_SETTLE  | Waiting for drum to settle between neutral pulses                               |
| 11  | POST_VALIDATE   | Watching GP sensor for post-shift bounce (only if `post_shift_validate_ms` > 0) |

A 1 Hz heartbeat almost always samples `phase=0`; catching a non-zero phase
is luck, and a _repeating_ non-zero phase means the machine is stuck.

## Live serial shift trace lines

Real-time lines (uptime-stamped, only in live captures — not in flash):

```
[HH:MM:SS.mmm] SHIFT #00042 start   src=USER dir=DOWN from=3 tgt=2 nt_mode=MOTO rpm= 7100 psi=  78 cl=1 tmo= 187 in_id=0099
[HH:MM:SS.mmm] VALVE #00042 DOWN HIGH cmdr=SHIFT
[HH:MM:SS.mmm] SHIFT #00042 gchange g=2 at=  62ms
[HH:MM:SS.mmm] SHIFT #00042 success from=3 to=2 in=  64ms
[HH:MM:SS.mmm] COUNT #00042 fire   cmdr=SHIFT dur= 15 gear=2
[HH:MM:SS.mmm] SHIFT #00042 complete total= 142ms
[HH:MM:SS.mmm] SHIFT #00042 fail    from=2 tgt=1 landed=0 in= 187ms reason=...
```

`#00042` is the shift ID — correlate all lines of one shift by it. `src=`
is who requested it: `user` (paddle pull), `nt` (neutral button), `auto`
(auto-downshift preselect — no paddle pull for this specific shift; see
SKILL.md § Auto-downshift), `retry` / `legacy_retry` (misshift correction
pulses), `prog_neutral` (progressive neutral finder). `cl=1` = closed-loop. `tmo=`
= timeout budget ms. `landed=` on a fail line is where the drum ended up
(`0` = the false-neutral case). `COUNT ... skipped reason=` explains a
suppressed countershift (1↔2 shifts and from-N shifts always skip it — the
N half-detent could capture the drum on the counter-pulse).

## DUMP_STATUS fields

| Line                                                                                     | Meaning                                                                                                                                                                                                                                                    |
| ---------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `RESET_CAUSE 0xNN <reason>`                                                              | Why the last reset happened — see crash checklist                                                                                                                                                                                                          |
| `UPTIME_MS`                                                                              | Milliseconds since boot                                                                                                                                                                                                                                    |
| `TIER tier=public\|dev`                                                                  | Tunable subset compiled in. `public` = 16 tunables visible in GET_CONSTS (shorter list is normal, not truncation)                                                                                                                                          |
| `FLASH_SAFE_MODE n fails=N`                                                              | 1 = logging disabled after repeated flash-init boot deaths                                                                                                                                                                                                 |
| `CAN_TX queued= dropped= pending= tec=`                                                  | CAN TX accounting; `dropped` growing on a healthy bus is bad                                                                                                                                                                                               |
| `LOOP_MAX_US n CAN_SEND_MAX_US n`                                                        | Worst-case main-loop / CAN-send time. Loop should be well under 1000 µs                                                                                                                                                                                    |
| `FLASH_HEALTH erases= erase_fail= prog_fail=`                                            | QSPI flash wear/failure counters; growing failures = dying flash chip                                                                                                                                                                                      |
| `EIC_RECOVERIES n`                                                                       | Paddle interrupt-controller re-attach count. Far above the session's shift count + "lost paddles" reports = wedged interrupt controller                                                                                                                    |
| `SHIFT_BLOCKS money= boundary= invalid_can=`                                             | Refused-shift counters by reason: `money` = over-rev saves (driving/limit signal), `boundary` = drum-limit refusals (down-from-1/N, up-from-6 — paddling into a wall, harmless), `invalid_can` = blocked on stale/invalid CAN data (data-health signal)    |
| `AIM epoch= speed_raw= lap= brake_f_raw= brake_r_raw= sess_raw= fresh= thr= latg= long=` | AiM dash snapshot; `epoch=0` = no GPS fix this boot. `thr=` raw AiM throttle (uint16; `65535` = stale or dash absent). `latg=`/`long=` signed raw lateral/longitudinal G from 0x712; both `0` when the dynamics frame has not been seen or has gone stale. |
| `--- RAM LOG QUEUE ---`                                                                  | Records not yet flushed to flash (would be lost on power cut)                                                                                                                                                                                              |

## Failure-mode signatures

The Rush SR has a ~1% false-neutral rate on 2→1 downshifts: the drum stops
in the N half-detent between 1 and 2 instead of completing. Several
distinct mechanisms produce that same symptom; classify by signature.

### Mode A — post-shift bounce

Drum reaches 1st long enough for success to be declared, then bounces back
across the 1/N boundary after the valve closes.

- `SHIFT_CL_OK` (success declared) **then** `GEAR_MISMATCH`/HB showing
  `gear:0` shortly after; no `MISSHIFT_RETRY` (retry machinery never fired
  because success was already declared)
- In the post-shift trace (when readable): `adc[]` starts in the 1st band
  (~140), rises into the N band (~270) within 30–150 ms (older logs show the
  dropped `gear[]` array doing the same: 1 → 0)

**Response:** enable post-shift validation —
`UNLOCK_ACCESS CONFIRM` / `SET post_shift_validate_ms 150` /
`SET post_shift_validate_confirm 3` / `SAVE_CONSTS`. After enabling, the
same situation produces `MISSHIFT_RETRY ... Post-shift bounce retry` and a
corrected gear.

### Mode B — bound dogs (drum stuck in N during the shift)

Dog teeth tip-loaded against each other; pneumatic pressure alone can't
break the bind, so retry pulses don't move the drum.

- `SHIFT_CL_TIMEOUT` with the drum at `gear:0` while target was 1 (or 2)
- Followed by ~3× `MISSHIFT_RETRY ... Misshift retry`
- Then `MISSHIFT_RETRY ... Misshift legacy escalation`
- Then `SHIFT_CL_TIMEOUT ... Misshift legacy failed`
- Drum stays at 0 throughout

**Response:** no firmware mitigation exists (an "unstick" opposite-pulse
maneuver was deliberately not implemented — risk of a wrong-direction
shift). Repeated Mode B → collect logs, file an issue. These are accepted
losses today.

### Mode C — low pressure

- Trace/HB `psi` < 65 during the failed shift, often after rapid sequential
  shifts drained the tank; `PRESSURE_CRIT` or compressor thrash nearby

**Response:** air-system problem, not firmware. Compressor health, leaks,
check valves.

### Mode D — rev-limited blip at high entry RPM

On high-RPM 2→1, the required rev-match exceeds what the Suzuki ECU's
quickshifter blip will deliver (its own redline safety cuts the blip
short); dogs misaligned at engagement, drum parks in N.

- Failures **cluster at high entry RPM** while lower-RPM 2→1s succeed
- `SHIFT_CL_TIMEOUT` landing `gear:0`, pressure normal
- Compute predicted 1st-gear RPM = entry RPM × (2.562 / 2.052) ≈ ×1.249.
  Field evidence (2026-06-12): predicted ~9.1k succeeded, predicted
  ~10.1–10.4k failed.

**Response:** `SET downshift_block_rpm 11600` (lower block threshold)
only helps if the predicted RPM is near the gate (default gate 11800). For
failures well below the gate, a dedicated 2→1 entry-RPM limit
(`down_2to1_max_entry_rpm`-style gate) is the right fix — flag for
firmware work.

### Decision tree

```
"Ended up in N" / 2→1 failed:
├─ Success declared (SHIFT_CL_OK) then gear:0 appeared after?
│    → Mode A (bounce). Enable post_shift_validate_ms.
├─ CL_TIMEOUT at gear:0 + 3×MISSHIFT_RETRY + legacy escalation + legacy failed?
│    → Mode B (bound dogs) — but if failures cluster at high entry RPM,
│      suspect Mode D wearing a Mode B signature; check predicted-RPM math.
├─ psi < 65 around the failure?
│    → Mode C (air system).
└─ Entry RPM high, predicted 1st-gear RPM ≥ ~9.5k, lower-RPM 2→1s fine?
     → Mode D (rev-limited blip).
```

### The dangerous aftermath: N→1 at road speed

Whatever parked the drum in N, the _next_ down-pull (N→1) engages 1st at
whatever the car is still rolling at — and that shift is **ungated** (no
ratio exists to predict RPM from N). The signature: `SHIFT_OK_DOWN ...
g:0->1` where `rpm:` (post-shift) is several thousand RPM above
`rpm_pre:`. Always call this out — it's the part of a false-neutral
incident that can damage the engine. Related: the Suzuki ECU also imposes
a ~6000 RPM soft limiter while in N, so the engine note/data in N can look
rev-limited; that's the ECU, not the GCU.

## Crash diagnosis checklist

1. Log ends mid-shift, then a boot: check last HB. `bo=`/`tec=` non-zero →
   solenoid EMI killed the CAN bus. Both zero and a countershift just
   fired → power-rail collapse (hardware: shared-ground sag).
2. `RESET_CAUSE 0x20 WATCHDOG` → main loop hung >500 ms (software).
3. `RESET_CAUSE 0x01 power-on` → supply collapsed or genuine key-off/on.
   Note: the installed GCU is 12V-powered — replugging USB does _not_
   power-cycle it; only key off/on gives a true power-on reset.
4. `RESET_CAUSE 0x40 system` → commanded reboot (`REBOOT CONFIRM`) — clean.
5. "Lost paddles" mid-session → check `EIC_RECOVERIES` in DUMP_STATUS and
   `WARN eic_recovery` lines (wedged interrupt controller).
6. Rapid-fire shifts from one paddle pull → check `doubles=`/`ghosts=`
   counters (EMI) before suspecting the release logic.

## Worked example: false-neutral incident

From an on-car log, 2026-06-12 (fw 4.1.1):

```
[1967655] 15:33:14.024 SHIFT_OK_DOWN rpm:8866 gear:2 psi:73 g:3->2 ...     ← 3→2 fine
[1968363] 15:33:14.732 (23:55.889 sess) MISSHIFT_RETRY rpm:8308 gear:0 psi:75 lap:5 Misshift retry
[1968453] ... MISSHIFT_RETRY (×3 total)
[1968633] ... MISSHIFT_RETRY ... Misshift legacy escalation
[1968733] ... SHIFT_CL_TIMEOUT rpm:8308 gear:0 psi:75 lap:5 Misshift legacy failed
[1969499] 15:33:15.868 SHIFT_CL_OK rpm:4167 gear:1 psi:71
[1969855] 15:33:16.224 SHIFT_OK_DOWN rpm:10157 gear:1 psi:70 g:0->1 ... rpm_pre:4167
```

Reading: the 2→1 pull at ~8.3k entry parked the drum in N; all retries
failed (Mode B signature, but entry RPM clustering suggests Mode D —
predicted 1st-gear RPM ≈ 8308 × 1.249 ≈ 10.4k, beyond the blip's
rev-match). The driver pulled down again from N; 1st engaged at road speed
and slammed the engine from 4,167 to 10,157 RPM — the ungated N→1
aftermath. Pressure was healthy throughout (69–75 PSI), ruling out Mode C.
