# Car demos: code review and mechanical accuracy implementation report

Date: 20 October 2026 (Asia/Kolkata)

Publication follow-up: [Origin PR #1 — Interactive clutch cutaway](https://cursor.com/codebase/yachint/car-demos/pull/1) had advanced to `ff83f9333b20c135fa6d4e24b14885cd299b631a` when posting this report. The findings below were verified at `81cca6e`, not that newer head; re-check each before implementing because some may already be resolved. F01–F15 and I01–I10 are local to this report and are not the F/R/P/T/M/A IDs used by earlier PR comments.

## Scope and evidence

- Repository: `car-demos`, hosted on Cursor Origin as `yachint/car-demos`.
- Reviewed branch: `cursor/clutch-cutaway-demo-ec31`.
- Reviewed head: `81cca6e` — Keep the release fork and the footwell out of the clutch plates.
- Comparison: merge base with `main`, `4cf5ebf33fbae2ffc713a9cef9cecb8487bc712c`. The local and tracked remote main references agreed at review time.
- The change introduces the application across 18 files. This is a review of that branch-wide change, not just its final commit.
- Method: defect-first review using review-agent, plus three parallel GPT-6.1 Sol agents with High reasoning assessing physics, geometry, and educational accuracy.
- Existing validation: all 29 Node tests passed; an in-memory Vite production build succeeded without writing build outputs.
- Additional evidence: read-only numerical probes, instantiated Three.js geometry with minimal DOM stubs, and a stub AudioContext.
- Limitation: no live-browser visual verification was performed. Geometry findings are based on source and computed transforms/bounds; keyboard findings are based on event-handler inspection.
- Line references below identify the reviewed head. Re-resolve them if implementation moves the code.
- No implementation fixes were made during review. This report distinguishes confirmed defects from optional fidelity extensions.

P2 means an ordinary actionable defect. P3 means a lower-impact defect worth fixing. There are no P0 or P1 findings in this report.

## Confirmed defects

### F01 — [P2] Close the clutch surfaces when clamped

**Location:** `src/vehicle.js:137–141`; geometry at `src/vehicle.js:273` and `src/vehicle.js:299`.

**Scenario and evidence:** Set the clutch pedal to zero with Explode off. Pressure-plate center is x = 0.700 m and friction-disc center is x = 0.720 m. Both annuli are 0.008 m thick. Their opposing surfaces are x = 0.704 m and x = 0.716 m, leaving a measured 0.012 m (12 mm) gap. The status nevertheless says “Plates locked.” The flywheel friction annulus is also centered inside the thicker flywheel body rather than placed on the exposed contact face.

**Impact:** The central teaching image shows torque transmission through visibly separated surfaces. The documented exaggeration of *open* clearance does not explain a gap in the fully clamped state.

**Implementation:** Define flywheel contact face, disc thickness, and pressure-plate thickness in one stack description. Derive their assembled centers from those faces. Apply release clearance and exploded offsets after computing the assembled configuration. Keep deliberate open-clearance exaggeration.

**Acceptance checks:**

- At pedal zero, both disc contact interfaces meet without a visible gap or penetration.
- At the modeled touch boundary, separation approaches zero continuously.
- When fully open, the interfaces separate by the intended exaggerated clearance.
- Explode can separate the stack independently and returns to the same assembled contacts.
- Check geometry bounds and inspect both inset views.

### F02 — [P2] Correct reverse gear rotation

**Location:** `src/vehicle.js:156–158`, reverse pair at `src/vehicle.js:419`, and ratio storage at `src/vehicle.js:427`.

**Scenario and evidence:** The loose-gear loop applies the same forward-mesh sign to all gears. A reverse-driving probe gave reverse gear angle +0.10493156 rad and output-shaft angle −0.10493156 rad: the selected gear turns exactly opposite its shaft. The idler uses the same sign as the countershaft, despite their external mesh.

**Impact:** Reverse demonstrates the wrong mechanism, and its supposedly engaged sleeve connects counter-rotating components.

**Implementation:** Store gear identity and mesh direction with each gear. Reverse main-gear rotation should have the appropriate extra sign reversal; the idler should oppose its mating countershaft gear. Check the reverse gear layout as well: the main/counter nominal radius sum is 0.119 m against a 0.110 m center distance, so the current arrangement still intersects as though directly meshed.

**Acceptance checks:** For every selected gear, angular velocity agrees with the output shaft; each external gear mesh has the proper opposite direction; reverse changes output direction without reversing the running engine. Verify signs in world coordinates.

### F03 — [P2] Apply transmission losses according to power direction

**Location:** `src/sim.js:453` and `src/sim.js:463`; related lock solve at `src/sim.js:424–426`.

**Scenario and evidence:** Wheel force always uses `ETA * clutchTorque * G / WHEEL_R`. During backdrive, clutch torque times input angular velocity is negative. With this fixed efficiency multiplier, the combined mechanical power across the gearbox is `(ETA - 1) * clutchTorque * inputOmega > 0`. At 12 m/s in fourth, closed throttle, a probe gave approximately −31.2147 Nm and 1,484.65 rpm, corresponding to roughly **388 W of artificial gearbox power**.

**Impact:** The lossy gearbox supplies some of the energy consumed by the engine, making engine braking quantitatively wrong.

**Implementation:** Use power-direction-aware loss equations, consistently in both the clutch constraint solve and wheel force. A dissipative loss torque formulation can avoid a discontinuity near zero power. Do not change only the final force expression while retaining an inconsistent locked solve.

**Acceptance checks:** In forward drive and backdrive, gearbox net power must never be positive after accounting for stored energy. With efficiency one, recover the ideal power relationship. Test positive and negative road speeds and smooth torque reversal.

**Reference:** [MathWorks: Model Gears with Losses](https://www.mathworks.com/help/sdl/ug/model-gears-with-losses.html).

### F04 — [P2] Include input-shaft inertia in neutral clutch locking

**Location:** `src/sim.js:408–419` and `src/sim.js:470`.

**Scenario and evidence:** The neutral lock torque considers current slip but omits engine external torque. Once “locked,” input speed is copied from engine speed. At 3,000 rpm/full throttle, both open and closed clutch cases initially accelerate the engine at 813.33 rad/s². A locked engine/input assembly with inertias 0.25 + 0.02 kg·m² should initially accelerate at approximately 753.09 rad/s² before input drag.

**Impact:** The input shaft gains angular momentum without the corresponding reaction torque on the engine. Neutral rev response and clutch synchronization are inaccurate.

**Implementation:** Solve both inertias with their external torques. In the locked state, use their combined inertia and determine the torque needed to preserve equal speed. Apply input-shaft drag consistently; do not replace its speed without accounting for the transferred momentum.

**Acceptance checks:** Locked acceleration agrees with total torque divided by combined inertia; clutch-open acceleration reflects engine inertia alone; locking conserves angular momentum subject to external impulses and dissipates the appropriate energy.

**Reference:** [MathWorks: Build a Clutch Lockup Model](https://www.mathworks.com/help/simulink/slref/building-a-clutch-lock-up-model.html).

### F05 — [P2] Derive gear geometry and animation from consistent ratios

**Location:** `src/vehicle.js:399–427`, `src/sim.js:7–15`, and `src/sim.js:510`.

**Scenario and evidence:** Gear radii, rounded tooth counts, and simulated ratios are independently specified. Selected fourth rotates about 1.44% faster than its output shaft: `1.03 / 1.6 * (0.0676 / 0.0429) = 1.01439`. Visible first-gear tooth counts imply 3.49375 rather than 3.36; second implies about 2.1667 rather than 2.08. The final-drive drawing has 47/13 teeth, or 3.615, while simulation uses 3.9.

**Impact:** Locked parts drift against each other, and counting visible teeth contradicts the displayed ratios.

**Implementation:** Use one transmission configuration for integer tooth counts, module/center distance, ratios, and animation. If decorative teeth remain schematic, identify that limitation and still make engaged gears rotate exactly with their shafts. Set tooth phase offsets so mating teeth do not pass through one another.

**Acceptance checks:** Every selected gear matches output angular velocity over many revolutions; displayed ratios match the shared specification; gear-center distances and tooth phases remain coherent.

**Reference:** [KHK: Calculation of Gear Dimensions](https://khkgears.net/gear-knowledge/gear-technical-reference/calculation-gear-dimensions/).

### F06 — [P2] Correct the driveshaft rotation-axis convention

**Location:** `src/vehicle.js:172–173` and `src/vehicle.js:676`.

**Scenario and evidence:** `buildShaft` orients its local positive X axis toward the rear axle, whereas the output and pinion groups use positive world X. All receive the same positive rotation angle. Their physical rotation directions therefore oppose one another across the joints.

**Impact:** The connected driveshaft visually reverses rotation between the gearbox and pinion.

**Implementation:** Adopt one signed shaft-axis convention or invert the driveshaft angle to account for its local orientation. Keep joint and stripe animation in the same convention.

**Acceptance checks:** Place witness marks on output, shaft, and pinion. During forward and reverse driving, verify compatible world-space rotation at both universal joints.

### F07 — [P2] Move asphalt with the road markings

**Location:** `src/studio.js:74–76`; road dimensions at `src/studio.js:43` and texture repeats at `src/studio.js:98`.

**Scenario and evidence:** A 36 m road with 10 texture repeats uses `offset.x -= shift / 4.5`. A negative UV offset moves a recognizable texture feature in positive world X. Its apparent speed is 36/10/4.5 = 0.8 times vehicle speed. Dashes move in negative X at full vehicle speed.

**Impact:** Asphalt, markings, and wheel rotation disagree about travel direction and distance.

**Implementation:** Derive offset from geometry length and repeat count. With the present mapping, use a positive change of `shift * repeat.x / roadLength`, or `shift / 3.6`. Preserve continuous wrapping in both directions.

**Acceptance checks:** A recognizable asphalt feature and a road dash move backward together. One wheel revolution corresponds to approximately 1.948 m of road travel with radius 0.31 m. Repeat in reverse.

### F08 — [P2] Handle backward coasting before recommending a gear

**Location:** `src/explain.js:59–64`; helper at `src/sim.js:66`.

**Scenario and evidence:** In neutral, clutch down, speed −5 m/s, the narration recommends first and tells the learner to release the clutch. The helper considers only forward gears and scores absolute rpm.

**Impact:** Following the instruction connects a forward gear while rolling backward, contradicting the app's wrong-direction stall explanation.

**Implementation:** Handle negative road speed before selecting a forward cruise gear. Explain stopping before changing direction. Make travel direction visible beside the unsigned speed readout. Apply the same direction awareness to the lower-speed neutral copy, which also defaults to selecting first.

**Acceptance checks:** Positive, negative, and near-zero neutral speeds get appropriate advice. No backward-coasting state instructs the learner to release into a forward gear as normal cruise behavior.

### F09 — [P2] Base engine-braking narration on torque direction

**Location:** `src/explain.js:124–128`.

**Scenario and evidence:** At 6 m/s in fourth, clutch up and zero throttle, after one 60 Hz frame the model reports approximately 742.7 rpm, +28.5 Nm clutch torque, and +0.117 m/s² acceleration. Narration says the wheels turn the engine, fuel is cut, and pumping loss slows the car.

**Impact:** The explanation reverses the actual torque flow when idle assistance is driving the vehicle.

**Implementation:** Classify engine braking using negative transmitted power/torque, not just throttle position and speed. Add an idle-assistance explanation for positive torque near idle. Avoid asserting a fuel-cut state unless the simulation explicitly models and exposes it.

**Acceptance checks:** At low-rpm zero throttle, positive torque selects idle-assistance copy; at higher-rpm negative torque, engine-braking copy appears. Narration should agree with sampled power direction in reverse too.

### F10 — [P2] Match the pull-away narration to actual revs

**Location:** `src/lessons.js:30–35`.

**Scenario and evidence:** The 5.5–7.5-second step promises 1,200–1,500 rpm. A 60 Hz replay remains between approximately 722 and 860 rpm throughout that step.

**Impact:** The learner sees and hears a different behavior from the narrated instruction.

**Implementation:** Either separate the initial throttle increase from clutch loading and tune the sequence to produce the stated range, or describe the current idle-assisted launch. Prefer state-aware narration when exact rpm matters.

**Acceptance checks:** Assert rpm during this specific step, rather than only the lesson's overall peak. Run the lesson at multiple presentation rates and in Slow mode; keep its successful final launch outcome.

### F11 — [P2] Mute the road-noise channel

**Location:** `src/audio.js:120–123`; routing at `src/audio.js:65–75`.

**Scenario and evidence:** Road noise connects directly to the audio destination. Muting fades only the engine master; subsequent updates return early. A stub probe after driving at 12 m/s and muting left direct-to-speaker gains at 0 and 0.042. Road noise persists at the previous level even after speed becomes zero.

**Impact:** The Sound toggle does not silence the app.

**Implementation:** Route every audible output through a common mute gain, or explicitly fade the road channel and active transient channels. Preserve separate per-source volume controls upstream of mute.

**Acceptance checks:** Drive, mute, then stop: all outputs become silent. Re-enable sound and verify volumes reflect the current state. Cover engine, road, grind, and stall sounds.

### F12 — [P2] Support keyboard activation of the starter button

**Location:** `src/ui.js:60–69`.

**Scenario and evidence:** Starter behavior is attached only to pointer events. Standard Enter/Space activation of a focused button has no corresponding starter handler. The global E shortcut is separate.

**Impact:** The visible button is not operable through normal keyboard button interaction.

**Implementation:** Support keyboard press/release for the hold-to-crank action. Release on keyup, blur, cancellation, and visibility loss. Account for global keyboard handlers so Space is not intercepted incorrectly. Clarify the hold action in visible help.

**Acceptance checks:** Tab to Start engine, hold and release Enter/Space, and observe cranking and release. Pointer and E behavior still work. No starter remains held after losing focus.

### F13 — [P2] Preserve clutch state after an engine stall

**Location:** `src/sim.js:296`.

**Scenario and evidence:** A dead engine with any clutch engagement and any selected gear is classified as “stalled-locked,” even when the solver says unlocked. After a high-gear stall, opening the clutch, then partially releasing it, a probe reported engine/input speeds of approximately 3/280 rpm and `locked: false`, while mode remained `stalled-locked`.

**Impact:** Both the coupling indicator and model label assert a rigid connection during obvious slip.

**Implementation:** Separate combustion state from clutch mechanical state. Use the solver's lock state and engagement to distinguish open, slipping, and locked even when the engine is dead. Update all label/copy consumers together.

**Acceptance checks:** Cover stalled-open, stalled-slipping, and stalled-locked states while stopped and coasting. A “locked” label must not accompany substantially different shaft speeds.

### F14 — [P3] Keep locked neutral shaft speeds equal at high revs

**Location:** `src/sim.js:470–471`.

**Scenario and evidence:** The code first copies engine speed to the input shaft, then independently clamps the input to 700 rad/s. Holding full throttle in neutral settles around engine 6,739 rpm and input 6,685 rpm with `locked: true` and approximately 54 rpm slip.

**Impact:** The speed meters contradict “Locked together” during normal free revving.

**Implementation:** Apply compatible limits to a coupled state. Any numerical speed safety limit must preserve the locked constraint or explicitly unlock the coupling rather than silently clipping one shaft.

**Acceptance checks:** Sweep the full neutral throttle range, including the limiter. When locked, engine and input speeds remain equal within numerical tolerance.

### F15 — [P3] Preserve tire contact when animating pitch

**Location:** `src/vehicle.js:220–222`; wheels attached to car at `src/vehicle.js:121`.

**Scenario and evidence:** Pitch rotates the complete car, including wheel centers, around the ground-level origin. At pitch 0.022 rad, front wheels rise approximately 30 mm and rear wheels sink approximately 27 mm.

**Impact:** Acceleration and braking make tires float above or penetrate the road.

**Implementation:** Put sprung components in a separate body/chassis/powertrain group and preserve road contact at the hubs, or explicitly solve suspension travel. Coordinate driveshaft/joint geometry with any relative movement.

**Acceptance checks:** Measure tire minimum height through hard acceleration and braking. Contact remains at the road, body motion is smooth, and axle/driveline attachments remain connected.

## Mechanical and educational improvements

These are enhancements or calibration work, not additional claims that every simplification is a regression.

### I01 — Solve the clutch release mechanism as a connected linkage

**Locations:** `src/vehicle.js:142–150`, `src/vehicle.js:275`, `src/vehicle.js:333`, `src/vehicle.js:348`.

Bearing translation, diaphragm angle, fork angle, slave travel, and pressure-plate lift currently use independent formulas. This can leave the parts visually disconnected throughout travel. Derive bearing motion from fork contact, finger deflection from bearing contact, and pressure-plate lift from the spring geometry. Distinguish the stationary carrier from the rotating thrust race and extend the diaphragm action beyond its fulcrum.

Sweep pedal travel and verify contact continuity, non-intersection, and pressure-plate response. Preserve exaggerated educational travel. Continuous release-bearing rotation is not automatically wrong: preloaded constant-contact bearings exist. [ZF clutch systems](https://aftermarket.zf.com/en/aftermarket-portal/our-portfolio/passenger-cars/products/clutches/).

### I02 — Add finite synchronizer torque and shift duration

**Locations:** `src/sim.js:238`, `src/sim.js:350`, `src/sim.js:393`.

Gear selection immediately changes the input-speed constraint. Introduce a small shift state machine: neutral, synchronizing, engaged. Keep input speed as a state while bounded cone-clutch torque accelerates or decelerates the shaft; engage the dog sleeve only near synchronization. Account for work and heat.

Validate that downshifts accelerate the input, upshifts decelerate it, larger mismatches take longer, and already matched shifts require little work. Keep beginner safeguards if useful, but identify mandatory clutch-down and over-rev selection blocking as app safeguards rather than universal mechanical restrictions. [MathWorks synchronizer model](https://www.mathworks.com/help/sdl/ref/synchronizer.html).

### I03 — Calibrate engine response and idle assistance

**Locations:** `src/sim.js:124`, `test/sim.test.js:217`, `README.md:21`.

Torque and proportional idle assistance react instantly. Add a calibrated torque/air-charge response state, bounded idle actuator response, and optionally integral control. A fuller model may integrate manifold pressure. Specify a representative engine/vehicle calibration rather than presenting the one-second creep versus 0.6-second stall boundary as universal.

Validate throttle-step rise/fall times, neutral revving, coastdown, idle recovery under moderate load, sustained-overload stalls, and full-throttle torque. Keep friction, pumping, combustion, and idle control separately observable. [MathWorks engine timing example](https://www.mathworks.com/help/simulink/slref/modeling-engine-timing-using-triggered-subsystems.html).

### I04 — Make clutch heat consistent with energy and temperature

**Locations:** `src/sim.js:483–485`, `test/lessons.test.js:73`.

The present heat is a normalized visual signal with a roughly 1.54-second decay constant, not calibrated temperature. Slip energy uses pre-step relative speed; on a step that synchronizes two free inertias, impulse times pre-slip overestimates the ideal synchronization energy. The analytic no-external-work reference is `0.5 * J_reduced * deltaOmega^2`.

Integrate slip through the step or split the locking event and reconcile dissipated energy with external work and kinetic-energy change. Then use thermal capacity and cooling, for example `Cth * dT/dt = Pslip - Qcooling`. Derive clutch capacity from friction coefficient, clamp force, effective radius, and number of friction faces. Add temperature-dependent friction only with defensible data.

Validate analytic synchronization energy, zero frictional heat when locked, repeated-launch heat accumulation, and cooling toward ambient. Explain prolonged slip to the learner without presenting the current normalized value as a temperature. [MathWorks disc friction clutch](https://www.mathworks.com/help/sdl/ref/discfrictionclutch.html).

### I05 — Add grade and explicit tire/road coupling

**Locations:** `src/sim.js:392`, `src/sim.js:451`.

The current road is flat and wheel angular speed is always vehicle speed divided by radius, assuming perfect adhesion. First add grade force and static brake holding. Later introduce a rear-axle rotational state and bounded tire force based on slip and rear normal load; keep front-wheel rotation separate.

Validate rollback in neutral, hill starts, brake holding, traction-limited acceleration, low-grip wheelspin, and smooth behavior near zero speed. Recover existing straight-line no-slip outcomes on high grip. [MathWorks tire model reference](https://www.mathworks.com/help/sdl/ref/tiremagicformula.html).

### I06 — Add limited driveline compliance after correcting conservation

**Location:** `src/sim.js:474`.

The rigid driveline is a reasonable teaching simplification but cannot show torsional wind-up, lash, or launch oscillation. Start with one torsional spring/damper between clutch hub and driveline; add backlash only if it supports a lesson.

Validate damped response after torque steps, no unforced energy growth, torque reversals, and convergence with smaller integration steps. Do not let cosmetic shudder substitute for a dynamically consistent model.

### I07 — Improve component packaging and differential detail

**Locations:** `src/vehicle.js:464–481`, `src/vehicle.js:780`, `src/vehicle.js:827`, `src/layout.js:7`.

Overall dimensions are coherent for a compact low coupe; there is no need to redesign proportions without a target vehicle. Improve packaging first: cut actual wheel openings in the far-side body panel, add visible suspension/upright connections, and reconcile the driveshaft's actual roughly 6.1-degree slope with the 3-degree comment.

For the differential, replace crossed spur-like placeholders with recognizable bevel/hypoid geometry if it becomes a teaching focus, using the same final-drive ratio as the simulation. Equal rear wheel speeds are acceptable in the current straight-line demo. If turning is added, separate halfshaft groups and enforce carrier speed equal to the mean of left/right speeds while animating spider motion. [Eaton open differential explanation](https://www.eaton.com/br/en-us/products/differentials-traction-control/open-differential.html).

### I08 — Distinguish physical effects from visual cues

**Locations:** `src/vehicle.js:204`, `src/vehicle.js:668`, `src/vehicle.js:177`.

Brake rotors glow immediately with pedal pressure, even at rest. Either label this as a brake-application highlight or derive thermal glow from dissipated braking energy and cooling. The starter pinion currently withdraws radially and rotates at a fixed speed; a more realistic representation uses axial engagement and a rotation rate/sign derived from its tooth ratio.

Validate zero braking heat at standstill, heat proportional to braking work, and coherent starter mesh and direction. These are secondary to correcting clutch contact and shaft rotation. [DENSO rotating electrics](https://www.denso-am.eu/products/rotating-electrics).

### I09 — Explain vehicle-specific assumptions and safeguards

**Locations:** `README.md:21`, `src/explain.js:10`, `src/explain.js:121`.

Describe idle-only creep as behavior of this configured, level-road, idle-assisted vehicle. Explain the starter restriction as a clutch interlock. Identify instantaneous shifts, perfect adhesion, flat road, and deliberately exaggerated clearances until those assumptions change.

Keep the cutaway, exploded view, exposed gears, and exaggerated open clearance: they improve readability when the underlying contacts and motion remain coherent.

### I10 — Add observation controls and a downshift lesson

**Locations:** `src/lessons.js:243`, `src/lessons.js:89`.

Add pause/continue and concept-step navigation so a learner can inspect the mechanism without racing the narration. Pause simulation and lesson time together. Add a controlled comparison of rev-matched and unmatched downshifts, showing the disc pulling engine speed upward and the road-speed limit for each gear.

Validate consistent state when pausing/resuming, agreement between narration and sampled values, and finite clutch energy for each downshift scenario.

## Suggested implementation sequence

1. Fix F01–F06: contact geometry, rotation signs/ratios, power conservation, and neutral inertia. These establish the model's mechanical consistency.
2. Fix F07–F15: road motion, truthful narration, audio mute, keyboard starter, stalled/locked reporting, high-rpm coupling, and ground contact.
3. Add I01 and I02: connected release linkage and finite synchronization.
4. Calibrate I03 and I04: engine dynamics and energy/temperature.
5. Add I05–I10 selectively according to teaching goals: grade, grip, compliance, packaging, explicit assumptions, and lesson controls.

Each phase should retain the current launch, shift, and stop lessons while adding checks that test the mechanism rather than just final outcomes.

## Validation plan for the implementer

| Area | Required checks |
| --- | --- |
| Existing behavior | Keep all 29 current tests passing unless an intentional behavior change has a documented replacement expectation. |
| Conservation | Verify shaft-power balance in both directions, inertia loading, synchronization momentum, and heat versus lost mechanical energy. |
| Constraints | Locked engine/disc speeds match; selected gear/output velocities match; no inconsistent independent speed clipping. |
| Geometry | Closed clutch contact, open clearance, connected release linkage, correct mesh signs/phases, tire contact, and axle attachments. |
| Narrative | Direction-aware neutral advice; torque-aware engine braking; step-specific rpm expectations; stalled clutch state. |
| Controls and audio | Keyboard and pointer starter hold/release, blur/cancel handling, complete mute, and correct sound after unmute. |
| Numerical robustness | Forward/reverse and low/high-speed cases; 30/60/144 Hz presentation; reduced integration-step comparisons for new physics. |
| Visual review | Both clutch inset modes, Explode transition, forward/reverse drive, acceleration/braking, and narrow-screen controls. |

## Reproduction examples

These commands use existing Node and repository modules. Run from the repository root. They do not install dependencies or write files.

### Neutral inertia, backward narration, and engine-braking narration

```sh
node --input-type=module <<'JS'
import { createSim } from './src/sim.js'
import { explain } from './src/explain.js'

for (const clutch of [0, 1]) {
  const sim = createSim()
  sim.place({ gear: 0, clutch, engineRpm: 3000, throttle: 1 })
  const before = sim.engineOmega
  sim.step(1 / 240)
  console.log('Neutral acceleration', clutch, (sim.engineOmega - before) * 240)
}

const backward = createSim()
backward.place({ gear: 0, speed: -5, clutch: 1 })
console.log('Backward neutral advice', explain(backward.sample()))

const idle = createSim()
idle.place({ gear: 4, speed: 6, clutch: 0, throttle: 0 })
idle.step(1 / 60)
const s = idle.sample()
console.log('Idle torque versus narration', {
  rpm: s.engineRpm, torque: s.clutchTorque,
  acceleration: s.accel, explanation: explain(s)
})
JS
```

### Lesson rpm and inconsistent locked states

```sh
node --input-type=module <<'JS'
import { createSim } from './src/sim.js'
import { createLessonPlayer } from './src/lessons.js'

const demo = createSim()
const player = createLessonPlayer(demo)
player.play('start')
let low = Infinity, high = -Infinity
for (let i = 0; i < 480; i++) {
  player.tick(1 / 60)
  const v = player.view()
  demo.setInputs({ clutch: v.clutch, brake: v.brake, throttle: v.throttle })
  demo.step(1 / 60)
  player.observe(demo.sample())
  if (i >= 330 && i < 450) {
    low = Math.min(low, demo.sample().engineRpm)
    high = Math.max(high, demo.sample().engineRpm)
  }
}
console.log('Pull-away step rpm range', { low, high })

const neutral = createSim()
neutral.place({ gear: 0, clutch: 0, throttle: 1 })
for (let i = 0; i < 1800; i++) neutral.step(1 / 60)
const n = neutral.sample()
console.log('Neutral high-rpm lock', n.engineRpm, n.inputRpm, n.locked)

const stalled = createSim()
stalled.place({ gear: 5, speed: 12 / 3.6, clutch: 0 })
for (let i = 0; i < 60; i++) stalled.step(1 / 60)
stalled.setInputs({ clutch: 1 })
for (let i = 0; i < 60; i++) stalled.step(1 / 60)
stalled.setInputs({ clutch: 0.8 })
stalled.step(1 / 60)
const t = stalled.sample()
console.log('Stalled clutch state', t.mode, t.locked, t.engineRpm, t.inputRpm)
JS
```

## Completion criteria

Resolve the 15 confirmed findings with focused regression checks. Treat the ten improvement areas as a prioritized fidelity roadmap, not a requirement to implement an entire vehicle simulator in this PR. Report which extensions remain intentionally simplified, preserve educational exaggerations, and verify the final rendered model before claiming mechanical accuracy.

