rom24-quickmud-python 2.14.211__tar.gz → 2.14.268__tar.gz

{rom24_quickmud_python-2.14.211 → rom24_quickmud_python-2.14.268}/CHANGELOG.md

@@ -7,6 +7,479 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.14.268] - 2026-07-05
+
+### Changed (CI)
+
+- **Full test suite gated to pull-request + manual dispatch; master pushes run
+  only the collect-smokes.** Empirically the pinned full suite takes ~32 CI-min
+  on a GitHub runner (verified: it ran clean to 98% with no worker crash, i.e.
+  the 2.14.267 pinning fix works — it just needs headroom), so running it on
+  every push would cost ~36 CI-min/push, no cheaper than the old broken matrix.
+  Direct pushes to master now trigger just the ~4-min 3.10/3.11 import smokes
+  (the full suite is validated locally via `.venv` before pushing); the full
+  suite still gates PRs and is runnable on demand via `workflow_dispatch`.
+  Full-suite `timeout-minutes` raised 30 → 40 for headroom.
+
+## [2.14.267] - 2026-07-05
+
+### Fixed (CI)
+
+- **CI Tests workflow green again after ~10 months red** (last passed 2025-09-15
+  at v1.2.3, when the suite was tiny). Two root causes, both confirmed by
+  reproducing the failure locally:
+  - **Unpinned deps → bleeding-edge crash.** The job installed `.[dev,test]`
+    (unpinned floors), which pip resolved to **pytest 9.1.1 / pytest-xdist 3.8.0**.
+    That stack crashes xdist workers mid-run (`node down: Not properly terminated`
+    → `INTERNALERROR` in `loadscope._reschedule`) — reproduced on a machine with
+    ample RAM, so it is a plugin incompatibility, not OOM. The pinned lock
+    (`requirements-dev.txt`, pytest 8.x — the same stack that runs green locally)
+    does not. **Fix:** the full-suite job now installs `-r requirements-dev.txt`.
+  - **Suite outgrew the 10-minute cap.** 6131 tests need ~13 min at the runner's
+    worker count; the job capped at 10 min and always timed out. **Fix:**
+    `timeout-minutes: 30`.
+- **CI cost reduced.** The 3-way full-suite matrix (3.10/3.11/3.12, ~30 CI-min/push,
+  all failing) is replaced by one full-suite run on **3.12** (the version the lock
+  is built + proven against) plus near-free **`--collect-only`** import smokes on
+  **3.10/3.11** that guard the "Python 3.10+" floor (these would have caught the
+  `datetime.UTC` 3.10 break in 2.14.266). Net: fewer CI minutes *and* green.
+- Note: the separate `CI` workflow (`ci.yml`) remains **disabled** (it was turned
+  off manually); its coverage gate + drift/mypy/rng static checks are not
+  currently enforced. Re-enabling it (pinned, with a timeout) is a follow-up.
+
+## [2.14.266] - 2026-07-05
+
+### Fixed
+
+- **Python 3.10 compatibility: `admin_logging` no longer imports `datetime.UTC`.**
+  `datetime.UTC` is a Python **3.11+** alias; `mud/admin_logging/admin.py` used it,
+  and since that module is imported transitively across the engine, every test
+  collecting `mud` failed at import under 3.10 (`ImportError: cannot import name
+  'UTC' from 'datetime'`) — making the advertised "Python 3.10+" support false in
+  CI. Swapped to `timezone.utc` (available since 3.2, behavior-identical). Also
+  fixed the same import in `tests/test_logging_rotation.py`.
+
+## [2.14.265] - 2026-07-05
+
+### Changed (dev tooling)
+
+- **CI: bump GitHub Actions off deprecated Node 20.** `actions/checkout@v4→v7`,
+  `actions/setup-python@v5→v6`, `actions/upload-artifact@v4→v7`,
+  `actions/download-artifact@v4→v8` across `ci.yml`, `release.yml`, `test.yml`,
+  `docker-image.yml` — GitHub was force-running the v4/v5 actions on Node 24 and
+  warning they target the deprecated Node 20 runtime. `pypa/gh-action-pypi-publish`
+  is Docker-based and unaffected. No workflow logic changed.
+
+## [2.14.264] - 2026-07-05
+
+### Changed
+
+- **Test suite: per-test hang-guard via `--timeout=120 --timeout-method=thread`
+  in `pyproject` addopts** (pytest-timeout, already a declared dep). A single
+  hung test now fails with a stack dump after 120s instead of stalling the run
+  indefinitely. Does not affect the intermittent xdist *sessionfinish* teardown
+  flake (environmental, harmless — all tests have reported by then). Disable with
+  `--timeout=0`; override per test with `@pytest.mark.timeout(n)`.
+
+### Added
+
+- **Coverage-lock: `xp_compute` neutral-branch alignment `c_div` truncation.** A
+  probe verified the XP/group award math is ROM-faithful;
+  `test_fight055…::test_fight055_neutral_align_change_truncates_toward_zero` pins
+  the one signed-math site test_fight055's ±500 branches didn't cover — the
+  neutral-alignment change `gch->alignment * base_exp / 500 * level / total_levels`
+  (`src/fight.c:1908`) truncates toward zero (`c_div`) for a negative killer, not
+  floor (`//`). Also filed SPLIT-001 (`do_split`'s non-ROM `N gold` keyword form)
+  for maintainer review.
+
+- **Dev environment: run tests in a project virtualenv (`.venv`).** Documented in
+  AGENTS.md ("Build / Lint / Test" → Environment): the shared system framework
+  Python is over-constrained across projects (`fastapi`/`gradio` need
+  `starlette < 1.0`, `sse-starlette` needs `>= 0.49.1` — no single global version
+  works), which silently broke 4 web/session test files at collection when the
+  global `starlette` drifted to 1.3.1. Setup: `python3 -m venv .venv &&
+  .venv/bin/python -m pip install -r requirements-dev.txt`. The project's own pins
+  were always correct — only the global env was wrong.
+
+### Fixed (dev tooling)
+
+- **`requirements-dev.txt` lock now includes the test plugins.** Added
+  `pytest-xdist`, `pytest-timeout`, and `hypothesis` to `requirements-dev.in` and
+  regenerated the pip-compiled lock (existing pins preserved). Previously the lock
+  omitted these plugins that `pyproject`'s `[dev]` extra and the default `addopts`
+  (`-n auto`, `--timeout`) require, so a fresh `pip install -r requirements-dev.txt`
+  produced a venv that couldn't even parse the pytest options. A clean install from
+  the lock now yields a runnable suite.
+
+- **Coverage-lock: `aggr_update` victim reservoir selection.** New
+  `TestAggressiveUpdateVictimReservoir` in
+  `tests/integration/test_mob_ai.py` pins ROM's reservoir sampling
+  (`src/update.c:1115-1131`): an aggressive NPC facing multiple eligible PCs
+  draws one `number_range(0, count)` per victim in `room.people` order, keeping
+  the first eligible victim (count==0 always selects) unless a later victim's
+  roll wins. Freezes the shared-RNG draw sequence at a classic desync site that
+  had no deterministic regression test.
+
+- **Coverage-lock: `gain_condition` DRUNK sober-message guard.** New
+  `tests/integration/test_gain_condition_drunk_sober_guard.py` pins ROM's
+  `if (condition != 0)` old-value guard (`src/update.c:391-394`): "You are sober."
+  fires only when the DRUNK slot was non-zero before ticking to 0, so an
+  already-sober idle player is never re-notified (unlike HUNGER/THIRST, which
+  announce unconditionally at 0). Locks a previously-untested branch.
+
+- **HANDLER-008: faithful unified `get_skill` port (core).** Added
+  `mud/skills/skill_lookup.py:get_skill` mirroring ROM `src/handler.c:346-448` —
+  the PC class-level gate + learned percent, the full NPC formula dispatch
+  (spell/weapon/kick/backstab/dodge/parry/trip/bash/disarm/… by flags), the daze
+  (`skill/2` spell, `2*skill/3` skill) and drunk (`9*skill/10`) reductions, and the
+  `URANGE(0,skill,100)` clamp. Self-contained + unit-tested; call-site migrations
+  (retiring the per-skill NPC-formula partial mirrors) follow.
+
+- **Differential harness death autosac coverage** — added `__plr_autosac=0|1`
+  to the C/Python replay drivers and committed the `death_auto_sac` scenario +
+  golden. The new replay confirms death `PLR_AUTOSAC` converges with ROM
+  `src/fight.c:968-979` / `src/act_obj.c:1838-1862` for an empty NPC corpse.
+- **Differential harness grouped autosplit coverage** — added `__plr_autosplit=0|1`
+  and descriptorless `__group_pc=<name>` setup to the C/Python replay drivers,
+  then committed the `death_autosac_autosplit` scenario + golden. The replay
+  confirms grouped death `PLR_AUTOSAC` + `PLR_AUTOSPLIT` converges with ROM:
+  the driver sees the sacrifice/split lines and the grouped peer receives its
+  silver share.
+- **Differential harness death autogold/autosplit coverage** — committed the
+  `death_autogold_autosplit` scenario + golden, pinning ROM `get_obj` autosplit
+  behavior when `PLR_AUTOGOLD` collects NPC corpse coins for a grouped PC. The
+  replay confirms the driver keeps the remainder share and the grouped peer
+  receives its split silver without the autosac branch.
+- **Differential harness death autoloot/autosplit coverage** — committed the
+  `death_autoloot_autosplit` scenario + golden, pinning ROM `do_get all corpse`
+  behavior when `PLR_AUTOLOOT` collects mixed NPC corpse contents for a grouped
+  PC with `PLR_AUTOSPLIT`.
+- **`weather_tick` RNG draw-order regression lock** — `tests/test_weather_tick_draw_order.py`
+  pins the Mitchell-Moore draw sequence of ROM `weather_update`
+  (`src/update.c:578`): the pressure line `change += diff*dice(1,4) + dice(2,6)
+  - dice(2,6)` is a single C expression whose three `dice()` calls have
+  *unspecified* evaluation order in C, but the diff-harness build platform
+  evaluates it strictly left-to-right — which is the order the Python port
+  draws in. The test locks the draw count, order, operand sizes, and the +/−
+  assignment (so a refactor cannot silently swap the two `dice(2,6)` draws and
+  desync every subsequent MM draw shared with combat/spells), plus the
+  per-sky-state `number_bits(2)` draw count. No behavior change — this path was
+  previously unguarded by any dedicated test.
+- **Differential harness non-death `get all corpse` autosplit coverage** —
+  committed the `get_corpse_money_autosplit` scenario + golden, exercising the
+  shared `do_get` → `get_obj` autosplit path (`src/act_obj.c:162-184`) via a
+  **manual** `get all corpse` (autoloot/autogold OFF) rather than the death
+  auto-branch. A grouped level-5 PC with `PLR_AUTOSPLIT` picks up 17 silver /
+  2 gold from a slain janitor's corpse; ROM emits the "You get ..." line plus
+  both `do_split` share lines (9 silver / 1 gold), and Python converges — locking
+  the FIGHT-080 fix on the non-death entry point.
+
+### Fixed
+
+- **PRACTICE-002: below-level skills can't be practiced even when already known.**
+  ROM `do_practice` (`src/act_info.c:2744-2757`) rejects a skill whenever
+  `ch->level < skill_level[class]`, unconditionally — a group-granted spell stored
+  at 1% that a low-level character isn't high enough for still can't be practiced.
+  The port only applied the level gate at 0%, so a below-level mage could practice
+  a known-at-1% spell (spending a session, raising the percent). Made the level
+  gate unconditional. Test:
+  `tests/integration/test_do_practice_command.py::test_practice_below_class_level_known_skill_is_rejected`.
+
+- **LOOK-010: room-occupant aura tags — order + double-render.** ROM prints
+  `(Pink Aura)` (faerie fire) before `(White Aura)` (sanctuary)
+  (`src/act_info.c:266,272`); both Python aura sites had them reversed. The room
+  list also double-rendered them (`_room_occupant_line` prepended auras and then
+  used `describe_character`, which prepends them too), so an aura'd occupant showed
+  `(White)(Pink)(White)(Pink) Name`. Fixed the order in both sites and removed the
+  duplicate prepend. Test:
+  `tests/integration/test_do_look_command.py::test_room_occupant_line_aura_order_pink_before_white`.
+
+- **MAGIC-049: `dispel magic` was missing ROM's opening save.** ROM
+  `spell_dispel_magic` (`src/magic.c:2082`) opens with `saves_spell(level, victim,
+  DAM_OTHER)`; on success it aborts ("You feel a brief tingling sensation." /
+  "You failed.") and strips nothing. The port had no gate, so it always proceeded
+  to the per-effect dispel loop — a missing RNG draw, two absent messages, and a
+  high-saving victim losing buffs ROM preserves. Added the gate. Test:
+  `tests/test_utility_spells_parity.py::test_dispel_magic_aborts_when_victim_saves`.
+
+- **AFFECTS-001: `affects` double-colon on the level-20+ duplicate line.** For a
+  level-20+ character with two same-spell affects (e.g. `bless`, which applies
+  APPLY_HITROLL + APPLY_SAVING_SPELL), the continuation line rendered a double
+  colon (`: :`). ROM (`src/act_info.c:1726`) emits 22 spaces then `": modifies…"`
+  — one colon; the port added an extra `": "`. Dropped it. Test:
+  `tests/integration/test_do_affects.py::test_affects_level_20_plus_duplicate_continuation_single_colon`.
+
+- **MAGIC-048: `chain lightning` arcs to every target in a bounce pass.** ROM's
+  bounce loop (`src/magic.c:1259-1278`) has no level-based break — once a pass
+  starts, the bolt arcs to every valid target in the room even after `level`
+  reaches 0 (0 damage, but the save roll and messages still fire). The port broke
+  out at `level <= 0`, skipping later occupants and desyncing the shared RNG.
+  Removed the break. Test:
+  `tests/test_skills_damage.py::test_chain_lightning_arcs_to_every_target_in_the_pass`.
+  (Also corrected two invisible-attacker masking tests that predated the FIGHT-092
+  invis-on-hit reveal.)
+
+- **MAGIC-047: `stone skin` already-affected guard checks the caster, not the
+  target.** ROM `spell_stone_skin` (`src/magic.c:4447`) is unique among buffs —
+  its guard tests `is_affected(ch)` (the caster) while still applying the affect
+  to the victim; the port checked the target. So a stone-skinned caster casting on
+  a different un-skinned victim wrongly buffed the victim (and the mirror case
+  wrongly refused). Now gates on the caster, matching ROM. Test:
+  `tests/test_skills_buffs.py::test_stone_skin_guard_checks_caster_not_victim`.
+
+- **MOVE-008: container open/close message order (CLOSED before CLOSEABLE).** ROM
+  `do_open`/`do_close` (`src/act_move.c`) check `CONT_CLOSED` before
+  `CONT_CLOSEABLE`, so an already-open non-closeable container reports "It's
+  already open." (and already-closed → "It's already closed."). The port checked
+  `CLOSEABLE` first and wrongly returned "You can't do that." for those states.
+  Reordered both container arms. Test:
+  `tests/integration/test_door_container_message_order.py`.
+
+- **FIGHT-092: attacking reveals an invisible attacker.** ROM `damage()`
+  (`src/fight.c:763-769`) strips the attacker's invis/mass-invis affects and
+  `AFF_INVISIBLE` and broadcasts "$n fades into existence." on every connecting
+  hit; the port's `apply_damage` did nothing, so an invisible caster/thief stayed
+  hidden through a whole fight. Added the strip + room broadcast after the
+  parry/dodge/shield-block checks. Test:
+  `tests/integration/test_invisibility_combat.py::test_invisible_attacker_revealed_on_connecting_hit`.
+
+- **SELL-005: keeper standardizes a sold item's cost even when the existing
+  duplicate is free.** ROM `obj_to_keeper` (`src/act_obj.c:2424`) does
+  `obj->cost = t_obj->cost` unconditionally when stacking onto a same-proto
+  duplicate; the port skipped it for a `cost==0` duplicate. Removed the guard.
+  Test: `tests/test_shops.py::test_obj_to_keeper_standardizes_cost_even_when_existing_is_zero`.
+
+- **BUY-011: `buy N*item` counts only consecutive stock.** The multi-buy stock
+  check scanned the keeper's whole inventory and counted non-adjacent duplicates,
+  but ROM `do_buy` (`src/act_obj.c:2667-2686`) counts only a consecutive run and
+  stops at the first non-matching item. So a keeper carrying `[lantern, dagger,
+  lantern]` refuses `buy 2*lantern` ("I don't have that many in stock.") in ROM,
+  but the port sold both. `_collect_matching_stock` now breaks on the first
+  non-matching candidate. Test:
+  `tests/test_shops.py::test_buy_multi_stock_requires_consecutive_run`.
+
+- **GET-016: magic containers weigh less toward carry limits (WEIGHT_MULT).** The
+  command-local `_get_obj_weight` helpers (do_get's `can_carry_w` gate and do_put's
+  fit check) summed a container's contents at full weight, ignoring ROM's
+  `WEIGHT_MULT` (`get_obj_weight(tobj) * WEIGHT_MULT(obj) / 100`,
+  `src/handler.c` / `merc.h:2137`). So a magic bag (`value[4]=50`) holding a
+  100-lb item counted as bag+100 instead of bag+50, and Python could refuse a
+  `get <magic-bag>` that ROM allows. Both helpers now apply the multiplier. Test:
+  `tests/integration/test_get_weight_mult.py`.
+
+- **PUT-004: putting into a carried bag no longer corrupts encumbrance (INV-011).**
+  `do_put`'s object move subtracted the item's weight/number from the carrier but
+  never re-added it, so `put sword bag` (a carried bag) permanently dropped
+  `carry_weight`/`carry_number` — a player could stuff a carried bag to slip under
+  the `can_carry_w` movement gate. ROM `obj_to_obj` re-adds
+  `get_obj_weight(obj) * WEIGHT_MULT(container) / 100` (and the number) for each
+  carried container in the nesting chain (`src/handler.c:1971-1984`), so a normal
+  bag (WEIGHT_MULT=100) is net-zero and a magic bag reduces weight. `_obj_to_obj`
+  now performs that walk. Test:
+  `tests/integration/test_put_weight_mult.py::test_put_into_carried_bag_is_net_zero_on_carry_weight`.
+
+- **WEAR-010: `wear/wield/hold N.item` count prefix now resolves.** `do_wear`
+  found its target with a substring-only helper instead of ROM's `get_obj_carry`
+  (`src/act_obj.c:1726`), so `wear 2.ring` returned "You do not have that item."
+  where ROM wears the 2nd of two same-named rings. `wield`/`hold` delegate to
+  `do_wear`, so all three were affected. Same finder class as EAT-008; wired to the
+  existing `get_obj_carry`. Test:
+  `tests/integration/test_equipment_system.py::test_wear_count_prefix_selects_nth_item`.
+
+- **EAT-008: `eat N.item` count prefix now resolves.** `do_eat` found its target
+  with a substring-only helper instead of ROM's `get_obj_carry`
+  (`src/act_obj.c:1296`), so the `N.name` count prefix never parsed — `eat
+  2.mushroom` returned "You do not have that item." where ROM eats the 2nd of two
+  same-named items. Wired `do_eat` to the existing `get_obj_carry` (already used by
+  `do_quaff`/`do_drink`), a strict superset of the old match. Test:
+  `tests/integration/test_consumables.py::test_eat_count_prefix_selects_nth_item`.
+
+- **GL-048: mob delay-trigger ends the tick unconditionally (`mobile_update`).**
+  ROM's TRIG_DELAY block (`src/update.c:448-454`) fires the trigger on expiry and
+  `continue`s **unconditionally**, so the mob does not scavenge or wander that
+  tick. The port returned `mp_percent_trigger`'s result, so a *failed* delay
+  percent roll let the mob fall through into scavenge/wander — drawing extra RNG
+  off the shared stream (desyncing the whole tick) and sometimes picking up an
+  item or moving when ROM would not. Also added the missing `HAS_TRIGGER` gate so
+  a mob without a delay program no longer counts its `mprog_delay` down. Test:
+  `tests/integration/test_gl048_mp_delay_trigger_parity.py`.
+
+- **GL-047: regen drains in a negative-rate room + signed rate math (`char_update`).**
+  `hit_gain`/`mana_gain`/`move_gain` returned `max(0, min(gain, deficit))`, so a
+  room with a negative `heal_rate`/`mana_rate` (a "drain room", fully
+  representable via OLC or the signed area loader) never actually drained HP/mana/
+  move — ROM returns `UMIN(gain, max-cur)`, a plain min that goes negative and the
+  caller subtracts it (`src/update.c:229,698`). The clamp is removed. Separately,
+  once the room-rate multiply makes `gain` negative, the rate `/100`, furniture
+  `/100`, and poison `/4` / plague `/8` / haste `/2` divisions must truncate
+  toward zero like C; the port used floor `//` (off-by-one on a negative
+  dividend) — switched to `c_div`. Test:
+  `tests/integration/test_gl047_regen_drain_room.py`.
+
+- **GL-046: plague-spread RNG draw order/count parity (`char_update`).** The
+  per-tick plague infection loop desynced the shared Mitchell-Moore RNG stream
+  from ROM `src/update.c:824,829-841` three ways: it drew the spread affect's
+  `number_range` **duration** once per infected victim instead of once before the
+  loop; it skipped the carrier/immortals/already-plagued occupants without drawing
+  their `saves_spell` roll (ROM draws the save for every occupant as the first
+  `&&` operand); and it drew `number_bits(4)` **before** the save instead of last.
+  Any of the three shifts every downstream RNG consumer in that pulse (regen,
+  later chars' affect fades, combat) whenever a plagued character stands in a
+  populated room. The loop now mirrors ROM's operand order and draw count exactly.
+  Char-side twin of GL-045/GL-026. Test:
+  `tests/integration/test_gl046_plague_spread_rng_order.py`.
+
+- **HANDLER-008 do_trip NPC trip-chance uses `get_skill` (was hardcoded 100).** `do_trip`'s NPC branch set `skill_level = 100`, so any OFF_TRIP mob tripped at a near-certain base chance regardless of level. It now uses `get_skill(char, "trip")` = ROM's `10 + 3*level` for an OFF_TRIP NPC (`src/handler.c:373-432`, `src/fight.c:2649`) — a level-10 mob's trip base drops from 100 to 40. The OFF_TRIP gate and the `""` silent return for descriptor-less mobs are unchanged. PC path unchanged (a separate opportunistic migration). This closes the last dict-sourced NPC skill lookup — every `get_skill` site in the HANDLER-008 port is now migrated. Test: `test_fight_026_npc_offensive_skill_no_crash.py::test_npc_trip_chance_uses_get_skill_not_hardcoded_100` (+ an over-correction guard confirming a low roll still lands).
+
+- **HANDLER-008 test hygiene: `test_fight035` disarm caster is now a warrior.** The disarm act-structure test's caster was a level-30 mage, but ROM's `disarm` skill is mage@53 — so `get_skill` gates it to 0 ("You don't know how to disarm"). The test only passed because it never calls `initialize_world`, leaving the global `skill_registry` empty so the class-gate was skipped; once a sibling test on the same xdist worker populated the registry, the gate activated and the test flaked. Set `ch_class=3` (warrior, disarm@11) so the gate passes deterministically — the same ROM-faithful fix already applied to the `TestDisarmRomParity` chars when the disarm gate was migrated (2.14.236). Exposed by the defensive-check migration reshuffling worker grouping.
+
+- **HANDLER-008 complete: defensive checks use `get_skill` — NPCs can finally dodge/parry/shield-block.** `check_dodge`, `check_parry`, and `check_shield_block` sourced their skill from the ad-hoc `_get_skill_percent(defender, …)`, which reads the skills dict — empty (→0) for mobs — so **NPC mobs never dodged, parried, or shield-blocked**. All three now route through the unified `get_skill(victim, …)` (`src/handler.c:373-432`): an NPC with OFF_DODGE/OFF_PARRY gets `level*2`, every NPC gets shield_block `10+2*level`, and PCs are gated below their class skill level. This retires the last dict-sourced defensive site and completes the get_skill port. Test blast radius (13 tests, all re-verified against `get_skill`'s actual output): PC-defender formula tests set a class that learns the skill early (warrior parry@1 / thief dodge@1) to preserve the level-diff; the one NPC-defender test had its expected chance recomputed from the ROM formula (the old dict value was inert); `test_combat_defenses_prob` NPC victims switched from `skills[...]` to `off_flags` with equalized attacker/victim levels (so the level-diff modifier doesn't leak a chance into an unflagged defense).
+
+- **FIGHT-090: unified the two `do_trip` implementations.** The `trip` command (`do_trip`) and the `trip` skill function (`skill_handlers.trip`) were divergent duplicate ports of ROM `do_trip`; `skill_handlers.trip` is now a thin delegate to the single canonical `do_trip`. Merged three ROM fixes that had landed only on the handler copy into do_trip: the self-trip colour + `$n trips over $s own feet!` room broadcast (FIGHT-039), the PERS flying/position gate messages `$S`/`$N` (TRIP-001, do_trip had baked "Their"/"They"), and `check_improve` on success/failure (do_trip omitted it, so trip never improved via the command). Also dropped the handler's non-ROM post-damage RESTING re-set. Filed a HANDLER-008 follow-up: do_trip's NPC trip chance still hardcodes 100 instead of get_skill's 10+3*level.
+
+- **MAGIC-046: `heat_metal` walks ROM's single `victim->carrying` list + emits `remove_obj` lines.** The spell iterated `inventory + equipment.values()` (carried then worn) instead of ROM's one LIFO list interleaving both by acquisition, so its per-object RNG draws hit different objects. Added `Character.iter_carrying()` (descending `_carry_seq`, the FINDING-020 acquisition counter) and route heat_metal through it; also restored `remove_obj`'s "$n stops using $p." / "You stop using $p." lines before the heat throw lines (src/magic.c:3134, src/act_obj.c:1389-1390).
+
+- **HANDLER-008 test fixes: warrior `ch_class` on disarm/rescue PC casters.** The disarm-skill and do_rescue get_skill migrations enforce ROM's PC class-level gate; cross-file disarm/rescue tests that created default mage-class casters now set `ch_class=3` (+ adequate level) — ROM-faithful, since a mage can't disarm/rescue below level 53. Restores the full suite to green.
+
+- **HANDLER-008 migration: do_rescue uses `get_skill`.** The rescue success roll now comes from unified `get_skill(char, "rescue")` — class-gated for PCs and 40+level for NPCs (was 0 via the dict → NPC rescue never succeeded). Fifth get_skill site migration; all offensive-skill NPC-formula workarounds are now retired.
+
+- **HANDLER-008 migration: disarm-skill gate uses `get_skill`.** `do_disarm`'s skill gate/chance now come from unified `get_skill(caster, "disarm")` — enforcing ROM's PC class-level requirement and finally letting an NPC with OFF_DISARM disarm (20+3*level; was 0 via the dict → always rejected). Fourth of five get_skill site migrations.
+
+- **HANDLER-008 migration: disarm hand-to-hand uses `get_skill`.** The unarmed disarm chance sources its hand-to-hand skill from unified `get_skill` (retiring `_hand_to_hand_skill`); daze/drunk now apply. The disarm-*skill* gate migration (which enforces ROM's PC class-level requirement) is a documented follow-up.
+
+- **HANDLER-008 migration: backstab THAC0 uses `get_skill`.** `attack_round`'s backstab branch sources its skill from unified `get_skill` (retiring `engine._backstab_skill`); daze/drunk now factor into the backstab near-auto-hit.
+
+- **HANDLER-008 migration: `do_kick` routes through `get_skill`.** The kick chance now comes from the unified `get_skill(char, "kick")` — retiring the inline NPC-formula workaround (FIGHT-091) and newly applying ROM's daze/drunk reductions at this site.
+
+- **FIGHT-091: an NPC's kick never landed (chance was 0).** `do_kick` read the
+  kick percent from the skills dict — empty for mobs — so an aggressive OFF_KICK
+  mob could never land a kick. The NPC branch now uses ROM `get_skill`'s
+  `10 + 3*level` (`src/handler.c:410`). Fourth site of the get_skill NPC-formula
+  class (HANDLER-008), which the unified port will consolidate.
+
+- **FIGHT-088: `do_trip` now emits ROM's three act() lines and the failure
+  `damage(0)`.** The trip command returned a single baked
+  `"You trip X and they go down!"` with no room broadcast or `$N`/`$M` pronoun
+  render, and on a miss only set the wait — never starting the fight. Success now
+  pushes the TO_VICT line, broadcasts the `$M`-gendered TO_NOTVICT to the room, and
+  returns the TO_CHAR line; a miss now calls `damage(ch, victim, 0, gsn_trip, …)`
+  before the wait (miss combat message + fight-start), matching
+  `src/fight.c:2735-2751`. Filed FIGHT-090 (divergent duplicate trip
+  implementations to unify).
+
+- **FIGHT-087: unarmed disarm used a hand-to-hand floor of 1 and a non-ROM gate.**
+  An unarmed NPC disarmer computed `chance * 1 / 150` (via `max(hand_to_hand, 1)`)
+  instead of ROM's `chance * (40+2*level) / 150` — a near-guaranteed failure. Added
+  a `_hand_to_hand_skill` helper (PC learned / NPC `40+2*level`, per ROM
+  `get_skill`), dropped the floor, and aligned the unarmed gate to ROM's
+  `hth==0 OR (IS_NPC AND !OFF_DISARM)`. The disarm-skill NPC lookup on the same
+  function remains part of HANDLER-008.
+
+- **FIGHT-089: `check_dodge` visibility halving was inert.** The dodge check
+  halved chance when the defender couldn't see the attacker, but the port used a
+  `getattr(victim, "can_see", lambda x: True)` fallback that never fired (runtime
+  entities have no `can_see` method), so a blind defender dodged at full chance.
+  Now `not can_see_character(victim, attacker)` (ROM `src/fight.c:1363`) — the twin
+  of the FIGHT-084 `check_parry` fix.
+
+- **FIGHT-086: backstab THAC0 bonus was missing.** ROM `one_hit`
+  (`src/fight.c:474-475`) subtracts `10 * (100 - get_skill(ch, gsn_backstab))`
+  from THAC0 for a backstab — a near-guaranteed hit below skill 100. The port
+  had the backstab *damage* multiplier but not the THAC0 branch, so sub-100
+  backstabs missed far more often than ROM. Added the branch in `attack_round`
+  plus a `_backstab_skill` helper mirroring ROM `get_skill` (PC learned / NPC
+  thief `20+2*level`). Surfaced HANDLER-008 (systemic daze/drunk get_skill
+  modifiers still unported).
+
+- **FIGHT-085: skill wait-states were haste/slow-scaled; ROM uses raw beats.**
+  `SkillRegistry._compute_skill_lag` halved a skill's lag under `AFF_HASTE` and
+  doubled it under `AFF_SLOW`. ROM's `WAIT_STATE` macro (`src/merc.h:2116`) is a
+  bare `UMAX` that applies the raw `skill_table[sn].beats`; haste/slow only
+  change the number of attacks (`multi_hit`), never lag. Removed the scaling so
+  bash/kick/backstab/rescue and every registry-`use()` skill match ROM.
+
+- **FIGHT-084: `check_parry` visibility halving used the wrong direction and was
+  inert.** ROM `src/fight.c:1311` halves parry on `!can_see(attacker, victim)`;
+  the port used `victim.can_see(attacker)` (wrong direction) with a
+  `lambda x: True` fallback that never halved. Now `not
+  can_see_character(attacker, victim)`. (The sibling inert halving in
+  `check_dodge` is filed as FIGHT-089.)
+- **FIGHT-083: `dirt_kicking` false-zero hack + `chance == 0` terrain gate.**
+  `src/fight.c:2566-2608`. Restored ROM's "sloppy hack to prevent false zeroes"
+  (`chance % 5 == 0 → += 1`, before the terrain switch) and changed the
+  post-terrain gate from `chance <= 0` to `chance == 0`, so a weak/low-dex
+  kicker on dry land no longer wrongly sees "There isn't any dirt to kick." and
+  correctly eats the guaranteed-miss WAIT_STATE; only water/air (which hard-set
+  chance to 0) report no dirt.
+- **MAGIC-045: `heat_metal` collapsed ROM's cursed-item branches (HIGH).**
+  `src/magic.c:3123-3277`. The port hardcoded `can_drop_obj` to `True`, so a
+  worn cursed (NODROP) weapon/armor or a cursed inventory item was dropped and
+  took the wrong damage instead of ROM's "sears your flesh / skin is seared"
+  else-branch (item stays). Restored the real `can_drop_obj` (NODROP +
+  immortal bypass), modelled `remove_obj`'s NOREMOVE failure, preserved ROM's
+  `&&` short-circuit so the worn-armor DEX `number_range` is only drawn when the
+  item is droppable (RNG parity), and switched that bound to
+  `get_curr_stat(DEX)`. Iteration-order sub-finding refiled as MAGIC-046.
+- **FIGHT-082: `do_trip` cluster — four ROM divergences (HIGH).** `src/fight.c:2711-2753`.
+  (a) dropped the spurious `skill_level // 20` term from the bash-damage bound
+  (ROM `number_range(2, 2 + 2*victim->size)`); (b) added the missing
+  OFF_FAST/AFF_HASTE speed modifier (`+10` self / `-20` victim); (c) fixed the
+  wait/daze values — success now WAITs the attacker for the skill's raw `beats`
+  (24) and `DAZE`s the victim (`2*PULSE_VIOLENCE`) instead of WAITing it, failure
+  WAITs `beats*2/3` (16), and self-trip WAITs `2*beats` (48) — all previously a
+  flat `PULSE_VIOLENCE`.
+- **FIGHT-081: melee AC modifiers applied at the wrong scale/order in
+  `attack_round` (HIGH — every swing).** ROM `one_hit` (`src/fight.c:480-503`)
+  divides `GET_AC` by 10 **first**, then applies the `< -15` rescale and the
+  `-4/+4/+6` visibility/position modifiers on the /10 scale; the port applied
+  them to the raw (×10) AC and divided last, making the modifiers ~10× too weak
+  and mis-firing the rescale for nearly every armored character. Extracted
+  `_compute_victim_ac` mirroring ROM order, and gated the -4 on
+  `not can_see_character(attacker, victim)` (blind/dark/hide/detect-invis aware)
+  instead of the victim's INVISIBLE affect. No existing combat test needed
+  re-baselining.
+- **GL-045: `obj_update` object-affect fade skipped its RNG draw at level 0
+  (RNG desync).** `_tick_object_affects` had the fade-roll operands swapped
+  (`level > 0 and number_range(0,4) == 0`), so a level-0 object affect with
+  `duration > 0` short-circuited past the draw. ROM
+  (`if (number_range(0,4) == 0 && paf->level > 0)`, `src/update.c:933`) consumes
+  the roll unconditionally for every `duration>0` affect. The skipped draw
+  desynced the shared Mitchell-Moore stream for every downstream consumer in the
+  pulse — the object-side twin of the character-side GL-026 fix. Reordered to
+  roll first. Test: `tests/test_obj_update_affect_fade_rng.py`.
+- **PICK-003: `do_pick` door immortal-bypass used the wrong threshold and
+  skipped the `get_trust` level fallback.** The door branch had
+  `is_immortal = trust >= 51` reading raw `char.trust`. ROM gates on
+  `!IS_IMMORTAL(ch)` where `IS_IMMORTAL = get_trust(ch) >= LEVEL_IMMORTAL` (=52)
+  and `get_trust` falls back to level when trust is unset
+  (`src/act_move.c:958,963,973`, `src/merc.h:149,2091`). So (a) a trust-51
+  mortal hero wrongly bypassed pickproof/open-door gates, and (b) a level-52
+  immortal with trust 0 was wrongly refused ("You failed.") on a pickproof door.
+  Fixed to `char.is_immortal()`. Contradicts a stale "immortal bypass FIXED"
+  audit claim. Same wrong-constant class as GET-015.
+- **GET-015: `get all <pit>` greed gate treated a level-51 mortal hero as
+  immortal.** The pit donation gate hardcoded `char_trust >= 51`, but ROM gates
+  on `!IS_IMMORTAL(ch)` where `IS_IMMORTAL = get_trust(ch) >= LEVEL_IMMORTAL`
+  and `LEVEL_IMMORTAL = 52` (`src/act_obj.c:320-321`, `src/merc.h:149,2091`).
+  Level/trust 51 is `LEVEL_HERO` — the top *mortal* tier — so a max-level mortal
+  could empty a donation pit in one command. Fixed to compare `>= LEVEL_IMMORTAL`.
+  The prior test encoded the misread (`trust = 51 # ROM: god = 51`) and was
+  corrected; added a hero-trust-51 regression.
+- **FIGHT-080 follow-up: AUTOSPLIT output from `get_obj` is now preserved in
+  `do_get` output.** ROM `get_obj` (`src/act_obj.c:162-184`) calls `do_split`
+  after the "You get ..." money line, so `PLR_AUTOLOOT` over a mixed corpse must
+  show both split lines for the actor. Python updated the balances but dropped
+  `do_split`'s returned actor lines. The new `death_autoloot_autosplit` C-oracle
+  replay caught and locks the fix.
+- **INV-054 DESCRIPTOR-WAIT-BUFFERS-INPUT** — commands typed while a connected
+  player is in ROM wait-state recovery are now buffered at the descriptor read
+  chokepoint and replayed after recovery clears, matching `src/comm.c:619-623`.
+  This removes the Python-only visible `"You are still recovering."` result for
+  live `cast magic`/combat-command input during kill/cast lag; the command now
+  waits in the session buffer instead of dispatching early into `do_cast`.
+  Enforced by
+  `tests/test_networking_telnet.py::test_wait_state_buffers_command_until_recovered_per_rom`.
+
 ## [2.14.211] - 2026-06-22
 
 ### Added

{rom24_quickmud_python-2.14.211/rom24_quickmud_python.egg-info → rom24_quickmud_python-2.14.268}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rom24-quickmud-python
-Version: 2.14.211
+Version: 2.14.268
 Summary: A modern Python port of the ROM 2.4b6 MUD engine with full telnet server and JSON world loading
 Author-email: Mark Jedrzejczyk <mark.jedrzejczyk@gmail.com>
 Maintainer-email: Mark Jedrzejczyk <mark.jedrzejczyk@gmail.com>
@@ -59,10 +59,10 @@ Dynamic: license-file
 
 # QuickMUD - A Modern ROM 2.4 Python Port
 
-[![Version](https://img.shields.io/badge/version-2.14.211-blue.svg)](https://github.com/Nostoi/rom24-quickmud-python)
+[![Version](https://img.shields.io/badge/version-2.14.268-blue.svg)](https://github.com/Nostoi/rom24-quickmud-python)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Tests](https://img.shields.io/badge/tests-6034%20passing-brightgreen.svg)](https://github.com/Nostoi/rom24-quickmud-python)
+[![Tests](https://img.shields.io/badge/tests-6127%20passing-brightgreen.svg)](https://github.com/Nostoi/rom24-quickmud-python)
 [![ROM 2.4b Parity](https://img.shields.io/badge/ROM%202.4b%20Parity-parity%20beta-blue.svg)](docs/parity/ROM_C_SUBSYSTEM_AUDIT_TRACKER.md)
 [![ROM C Audit](https://img.shields.io/badge/ROM%20C%20Audit-43%2F43%20audited-success.svg)](docs/parity/ROM_C_SUBSYSTEM_AUDIT_TRACKER.md)
 [![Integration Tests](https://img.shields.io/badge/integration%20tests-1000%2B-brightgreen.svg)](tests/integration/)
@@ -83,7 +83,7 @@ A "[Multi-User Dungeon](https://en.wikipedia.org/wiki/MUD)" (MUD) is a text-base
 - **⚔️ ROM Combat System**: Classic ROM combat mechanics and skill system
 - **👥 Social Features**: Say, tell, shout, and 100+ social interactions
 - **🛠️ Admin Commands**: Teleport, spawn, ban management, and OLC building
-- **📊 Comprehensive Testing**: 6,034 passing tests across unit, integration, and command-registry suites
+- **📊 Comprehensive Testing**: 6,076 passing tests across unit, integration, and command-registry suites
 - **🔧 ROM C-Compatible API**: Public API wrappers for external tools and scripts (27 functions)
 
 ## 📦 Installation
@@ -228,7 +228,7 @@ python -m mud  # Start development server
 **Stage: parity beta** — feature-complete and playable; parity fidelity is being
 systematically hardened toward ROM-exact behavioral equivalence.
 
-- **Version**: 2.14.211
+- **Version**: 2.14.268
 - **Playability**: ✅ All 255 ROM commands implemented. Combat, spells, skills,
   movement, shops, mob programs, OLC building, and admin tools work and pass their
   tests. You can run a server and play today.
@@ -256,7 +256,7 @@ systematically hardened toward ROM-exact behavioral equivalence.
   diffed. Any behavioral divergence surfaces mechanically rather than requiring a
   hand-written assertion. Coverage is growing; uncovered surfaces are the remaining
   parity-confidence gap.
-- **Test Suite**: ✅ **6,034 passed, 4 skipped** (full `pytest` run, ~5min parallel).
+- **Test Suite**: ✅ **6,049 passed, 4 skipped** (full `pytest` run, ~5min parallel).
   Unit, integration, command-registry, and differential-harness layers.
 - **Active focus**: Cross-file invariants and the divergence-class roster (the
   enumeration-of-structural-divergences pass). Recently closed: **divergence-class
@@ -421,7 +421,7 @@ being hardened gap-by-gap (see **Project Status** above).
 
 ### 📈 Quality Metrics
 
-- **Test Suite**: 6,034 passing, 4 skipped on the latest full run.
+- **Test Suite**: 6,076 passing, 4 skipped on the latest full run.
 - **Audit Coverage**: every ROM 2.4b6 gameplay subsystem has a completed audit
   document (combat, skills, spells, movement, communication, world/db, save/load,
   mob programs, 255/255 commands). Audit completion means *reviewed and documented*,

{rom24_quickmud_python-2.14.211 → rom24_quickmud_python-2.14.268}/README.md

@@ -1,9 +1,9 @@
 # QuickMUD - A Modern ROM 2.4 Python Port
 
-[![Version](https://img.shields.io/badge/version-2.14.211-blue.svg)](https://github.com/Nostoi/rom24-quickmud-python)
+[![Version](https://img.shields.io/badge/version-2.14.268-blue.svg)](https://github.com/Nostoi/rom24-quickmud-python)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Tests](https://img.shields.io/badge/tests-6034%20passing-brightgreen.svg)](https://github.com/Nostoi/rom24-quickmud-python)
+[![Tests](https://img.shields.io/badge/tests-6127%20passing-brightgreen.svg)](https://github.com/Nostoi/rom24-quickmud-python)
 [![ROM 2.4b Parity](https://img.shields.io/badge/ROM%202.4b%20Parity-parity%20beta-blue.svg)](docs/parity/ROM_C_SUBSYSTEM_AUDIT_TRACKER.md)
 [![ROM C Audit](https://img.shields.io/badge/ROM%20C%20Audit-43%2F43%20audited-success.svg)](docs/parity/ROM_C_SUBSYSTEM_AUDIT_TRACKER.md)
 [![Integration Tests](https://img.shields.io/badge/integration%20tests-1000%2B-brightgreen.svg)](tests/integration/)
@@ -24,7 +24,7 @@ A "[Multi-User Dungeon](https://en.wikipedia.org/wiki/MUD)" (MUD) is a text-base
 - **⚔️ ROM Combat System**: Classic ROM combat mechanics and skill system
 - **👥 Social Features**: Say, tell, shout, and 100+ social interactions
 - **🛠️ Admin Commands**: Teleport, spawn, ban management, and OLC building
-- **📊 Comprehensive Testing**: 6,034 passing tests across unit, integration, and command-registry suites
+- **📊 Comprehensive Testing**: 6,076 passing tests across unit, integration, and command-registry suites
 - **🔧 ROM C-Compatible API**: Public API wrappers for external tools and scripts (27 functions)
 
 ## 📦 Installation
@@ -169,7 +169,7 @@ python -m mud  # Start development server
 **Stage: parity beta** — feature-complete and playable; parity fidelity is being
 systematically hardened toward ROM-exact behavioral equivalence.
 
-- **Version**: 2.14.211
+- **Version**: 2.14.268
 - **Playability**: ✅ All 255 ROM commands implemented. Combat, spells, skills,
   movement, shops, mob programs, OLC building, and admin tools work and pass their
   tests. You can run a server and play today.
@@ -197,7 +197,7 @@ systematically hardened toward ROM-exact behavioral equivalence.
   diffed. Any behavioral divergence surfaces mechanically rather than requiring a
   hand-written assertion. Coverage is growing; uncovered surfaces are the remaining
   parity-confidence gap.
-- **Test Suite**: ✅ **6,034 passed, 4 skipped** (full `pytest` run, ~5min parallel).
+- **Test Suite**: ✅ **6,049 passed, 4 skipped** (full `pytest` run, ~5min parallel).
   Unit, integration, command-registry, and differential-harness layers.
 - **Active focus**: Cross-file invariants and the divergence-class roster (the
   enumeration-of-structural-divergences pass). Recently closed: **divergence-class
@@ -362,7 +362,7 @@ being hardened gap-by-gap (see **Project Status** above).
 
 ### 📈 Quality Metrics
 
-- **Test Suite**: 6,034 passing, 4 skipped on the latest full run.
+- **Test Suite**: 6,076 passing, 4 skipped on the latest full run.
 - **Audit Coverage**: every ROM 2.4b6 gameplay subsystem has a completed audit
   document (combat, skills, spells, movement, communication, world/db, save/load,
   mob programs, 255/255 commands). Audit completion means *reviewed and documented*,

{rom24_quickmud_python-2.14.211 → rom24_quickmud_python-2.14.268}/mud/admin_logging/admin.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -100,7 +100,7 @@ def log_admin_command(
     """
 
     Path("log").mkdir(exist_ok=True)
-    timestamp = datetime.now(UTC).isoformat().replace("+00:00", "Z")
+    timestamp = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
     sanitized = _sanitize_command_line(command_line)
     if character is not None:
         try:
@@ -132,7 +132,7 @@ def rotate_admin_log(today: datetime | None = None) -> Path:
     active = log_dir / "admin.log"
     if not active.exists():
         return active
-    dt = today or datetime.now(UTC)
+    dt = today or datetime.now(timezone.utc)
     dated = log_dir / f"admin-{dt.strftime('%Y%m%d')}.log"
     # Avoid clobbering: if dated file exists, append current log and remove active
     if dated.exists():