Reverse Minesweeper: human controller lab, batch 1 (Spelunky verb set on Anchor 3)

1. return engine_state().frame, player.state, player.x, player.y, D.jump_v0, D.jump_ramp_from
-> 0
fall
4.5
11.6
8.8169066227332
0.18914638771747

2. engine_step(10) return player.state, player.x, player.y, player.vy, on_ground(player)
-> stand
4.5
11.6
0
true

3. script tools\verify.lua
--[[
  tools/verify.lua — the lab's assertion run.

  Run it against a live agent instance:

    anchor drive start lab
    anchor drive eval  lab --file tools/verify.lua
    anchor drive stop  lab

  It drives the real controller through the real input pump
  (input_inject_key -> the SDL queue -> input_pressed inside update), steps the
  engine, and prints every measured value next to its target. Poses are set
  directly (player.x = ...) ONLY to put the character somewhere; nothing about
  the controller's behaviour is faked.

  The one exception is `lab_jump_hold_ticks`, which forces the jump button to
  read as released after N ticks: a rendered frame is two ticks, so a 1-tick
  tap cannot otherwise be scripted. The 2-tick tap is measured as well, by
  pure key injection, and both are reported.

  Returns the report as a string (the eval channel prints it) and also writes
  it to tools/verify-report.txt.
]]

local R = {}
local pass_n, fail_n = 0, 0

local function line(s) R[#R + 1] = s end

local function check(name, measured, target, tol)
  local ok
  if tol then ok = math.abs(measured - target) <= tol else ok = (measured == target) end
  if ok then pass_n = pass_n + 1 else fail_n = fail_n + 1 end
  local m = (type(measured) == 'number') and string.format('%.4g', measured) or tostring(measured)
  local t = (type(target) == 'number') and string.format('%.4g', target) or tostring(target)
  line(string.format('%-4s %-46s measured %-12s target %s%s',
    ok and 'PASS' or 'FAIL', name, m, t, tol and string.format(' +-%.3g', tol) or ''))
  return ok
end

-- ── input plumbing ─────────────────────────────────────────────────────────
local held = {}
local function key(name, down)
  if held[name] == down then return end
  held[name] = down
  input_inject_key(name, down)
end
local function release_all()
  for k, v in pairs(held) do
    if v then input_inject_key(k, false) end
    held[k] = false
  end
  engine_step(1)
end
local function tap_key(name)
  key(name, true)
  engine_step(1)
  key(name, false)
end

-- ── pose plumbing ──────────────────────────────────────────────────────────
local function pose(x, y, state)
  local p = player
  p.x, p.y = x, y
  p.vx, p.vy = 0, 0
  p.state = state or 'fall'
  p.crouched = false
  p.hp, p.ropes = T.hp, T.rope_count
  p.hang_lock, p.rope_lock, p.buffer, p.coyote = 0, 0, 0, 0
  p.jump_hold, p.jump_hold_t, p.jump_hold_ticks = false, 0, 0
  p.jump_apex, p.jump_from_y = 0, y
  p.lower_hold, p.peek, p.peek_hold = 0, 0, 0
  p.last_land_h, p.last_land_dmg, p.last_land_t = 0, 0, 0
  p.last_rope_kick = 0
  p.rope = nil
  fall_reset(p)
  ropes = {}
  hurt_flash = 0
  camera_snap()
end

local function fresh(room)
  release_all()
  room_load(room or 'calibration')
  engine_step(1)
end

-- Step frame by frame until pred() or n frames have passed. Returns frames used.
local function step_until(pred, n)
  for i = 1, n do
    engine_step(1)
    if pred() then return i end
  end
  return n
end

local GROUND_Y = CALIBRATION_GROUND - D.hh   -- centre y of a character standing on the surface

-- ── 1. jump apexes ─────────────────────────────────────────────────────────
line('--- jump ---')
fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(70)
key('space', false)
check('held jump apex (tiles)', player.jump_apex, T.jump_apex_held, 0.03)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
lab_jump_hold_ticks = 1
key('space', true)
engine_step(70)
key('space', false)
lab_jump_hold_ticks = nil
check('tap jump apex, released after 1 tick', player.jump_apex, T.jump_apex_tap, 0.05)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(1)                -- one rendered frame = two ticks
key('space', false)
engine_step(70)
check('tap jump apex, released after 2 ticks', player.jump_apex, T.jump_apex_tap, 0.09)
release_all()

-- ── 2. speeds ──────────────────────────────────────────────────────────────
line('--- speeds ---')
local function speed_test(name, keys, target, tol)
  fresh('calibration')
  pose(2.5, GROUND_Y, 'stand')
  engine_step(3)
  for _, k in ipairs(keys) do key(k, true) end
  engine_step(40)
  local vx = player.vx
  release_all()
  check(name, vx, target, tol)
end
speed_test('walk speed (tiles/s)',  {'d'},            T.walk_speed,  0.05)
speed_test('run speed (tiles/s)',   {'d', 'lshift'},  T.run_speed,   0.1)
speed_test('crawl speed (tiles/s)', {'d', 's'},       T.crawl_speed, 0.05)

-- ── 3. terminal velocity ───────────────────────────────────────────────────
line('--- terminal velocity ---')
fresh('calibration')
local deep = CALIBRATION_PITS[#CALIBRATION_PITS]
pose(deep.x + 2, GROUND_Y, 'fall')
engine_step(40)               -- 0.67 s: terminal is reached at 0.36 s
check('terminal velocity (tiles/s)', player.vy, T.terminal_velocity, 0.1)

-- ── 4. fall damage tiers ───────────────────────────────────────────────────
line('--- fall damage (walk-off into the calibration pits) ---')
local function pit_test(depth, expect_dmg)
  local pit
  for _, q in ipairs(CALIBRATION_PITS) do if q.d == depth then pit = q end end
  fresh('calibration')
  pose(pit.x + 2, GROUND_Y, 'fall')
  step_until(function() return on_ground(player) or player.state == 'dead' end, 400)
  engine_step(2)
  local dmg = player.last_land_dmg
  local h = player.last_land_h
  check(string.format('%d-tile pit: damage', depth), dmg, expect_dmg)
  line(string.format('       equivalent height measured %.3f tiles (pit is %d), hp now %d',
                     h, depth, player.hp))
end
pit_test(7, 0)
pit_test(8, 1)
pit_test(16, 2)
pit_test(24, 99)
check('24-tile pit kills', player.state, 'dead')

-- ── 5. ledge grab: the 2-tile step yes, the 3-tile step no ─────────────────
line('--- ledge grab ---')
local function step_grab(x_left, label)
  fresh('calibration')
  pose(x_left, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)             -- walk into the face
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  local st = player.state
  release_all()
  return st, label
end
local st2 = step_grab(CALIBRATION_STEP2_X - 1.3, '2-tile')
check('standing jump at the 2-tile step -> hang', st2, 'hang')
local st3 = step_grab(CALIBRATION_STEP3_X - 1.3, '3-tile')
check('standing jump at the 3-tile step -> not hang', st3 ~= 'hang', true)

-- ── 6. from hang: drop, and the lockout; then the mantle ───────────────────
line('--- hang ---')
local function get_hang()
  fresh('calibration')
  pose(CALIBRATION_STEP2_X - 1.3, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  key('space', false)
  key('d', false)
  engine_step(1)
  return player.state == 'hang'
end

check('reached hang for the drop test', get_hang(), true)
key('s', true)
key('space', true)
engine_step(1)
check('hang + down + jump -> fall', player.state, 'fall')
check('hang lockout after the drop (s)', player.hang_lock, T.hang_lockout, 0.02)
local locked_grab = player.hang_lock > 0
check('no grab possible while locked out', locked_grab, true)
release_all()

check('reached hang for the mantle test', get_hang(), true)
key('space', true)
engine_step(1)
key('space', false)
step_until(function() return player.state == 'stand' end, 60)
check('hang + jump -> climb_up -> stand', player.state, 'stand')
check('  standing on top of the corner tile (y)', player.y, 10 - D.hh, 0.02)
check('  standing over the corner tile (x)', player.x, CALIBRATION_STEP2_X + 0.5, 0.02)
release_all()

-- ── 7. crouch to a lip, then lower-off ─────────────────────────────────────
line('--- lower-off ---')
fresh('calibration')
local pit1 = CALIBRATION_PITS[1]
pose(pit1.x - 2.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
key('d', true)
local lip_x, lip_frame, lower_frame, hang_frame = nil, nil, nil, nil
for i = 1, 240 do
  engine_step(1)
  if not lip_x and player.state == 'crouch' and at_lip(player, 1) then
    lip_x, lip_frame = player.x, i
  end
  if not lower_frame and player.state == 'lower_off' then lower_frame = i end
  if not hang_frame and player.state == 'hang' then hang_frame = i break end
end
check('crawl stops at the lip (box right edge)', (lip_x or 0) + D.hw, pit1.x, 0.03)
check('holding toward the drop enters lower_off', lower_frame ~= nil, true)
check('lower_off ends in hang', hang_frame ~= nil, true)
if lip_frame and lower_frame then
  check('hold before lower_off (s)', (lower_frame - lip_frame)/60, T.lower_off_hold, 0.05)
end
release_all()

-- ── 8. rope throws ─────────────────────────────────────────────────────────
line('--- ropes ---')
fresh('calibration')
pose(CALIBRATION_ROPE8_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 8-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 8)
  check('  segments unrolled', rope_length_of(ropes[1]), T.rope_length)
  check('  ropes left', player.ropes, T.rope_count - 1)
else
  check('rope up under the 8-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(CALIBRATION_ROPE4_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 4-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 4)
  check('  unrolls until the floor (segments)', rope_length_of(ropes[1]), 4)
else
  check('rope up under the 4-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(pit1.x - D.hw, GROUND_Y, 'stand')     -- box right edge exactly on the lip
player.facing = 1
engine_step(2)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down at a lip: anchor column (one ahead)', ropes[1].col, pit1.x)
  check('  anchor row = the thrower height', ropes[1].top_ty, CALIBRATION_GROUND - 1)
else
  check('rope down at a lip placed a rope', false, true)
end
release_all()

check('reached hang for the rope-down test', get_hang(), true)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down from a hang: anchor column', ropes[1].col, CALIBRATION_STEP2_X - 1)
  check('  anchor row = the hang row', ropes[1].top_ty, player.hang_ty)
else
  check('rope down from a hang placed a rope', false, true)
end
release_all()

-- ── 9. catching a rope mid-fall ────────────────────────────────────────────
line('--- rope catch ---')
local function rope_in_pit()
  fresh('calibration')
  local r = rope_place(deep.x + 2, CALIBRATION_GROUND + 6)
  r.bottom_ty = r.top_ty + T.rope_length - 1
  r.phase = 'set'
  pose(deep.x + 2 + 0.5, GROUND_Y, 'fall')
  ropes = {r}
  return r
end

local r1 = rope_in_pit()
key('w', true)
step_until(function() return player.state == 'rope' end, 200)
check('falling past a rope while holding up -> rope', player.state, 'rope')
check('  fall counter zeroed', player.fall_time, 0, 1e-9)
local caught_at = player.y
line(string.format('       caught at y %.2f (rope rows %d..%d)', caught_at, r1.top_ty, r1.bottom_ty))

-- 10. jumping off the rope with a direction held
key('w', false)
key('d', true)
engine_step(1)
tap_key('space')
engine_step(1)
check('jump off a rope with a direction: sideways kick', player.last_rope_kick, T.rope_jump_kick, 0.01)
check('  rope lockout after a jump-off (s)', player.rope_lock, T.rope_lockout_jump, 0.05)
release_all()

rope_in_pit()
step_until(function() return on_ground(player) or player.state == 'dead' end, 300)
check('falling past a rope WITHOUT holding up -> no catch', player.state ~= 'rope', true)
release_all()

-- ── 10. hot-reload probe (value only; the reload itself is driven outside) ──
line('--- tuning ---')
line(string.format('       jump v0 %.4f tiles/s, gravity ramp starts at %.4f of full',
                   D.jump_v0, D.jump_ramp_from))
line(string.format('       solved apexes: tap %.4f, held %.4f (targets %.2f / %.2f)',
                   D.jump_apex_tap_actual, D.jump_apex_held_actual,
                   T.jump_apex_tap, T.jump_apex_held))
line(string.format('       T.walk_speed is currently %.3f', T.walk_speed))

-- ── done ───────────────────────────────────────────────────────────────────
release_all()
fresh('calibration')

local report = string.format('verify: %d passed, %d failed\n', pass_n, fail_n) ..
               table.concat(R, '\n') .. '\n'
print(report)
if io and io.open then
  local f = io.open('tools/verify-report.txt', 'w')
  if f then f:write(report) f:close() end
end
return report

4. controller.lua

5. return engine_reload()
-> {"controller.lua"}

6. script tools\verify.lua
--[[
  tools/verify.lua — the lab's assertion run.

  Run it against a live agent instance:

    anchor drive start lab
    anchor drive eval  lab --file tools/verify.lua
    anchor drive stop  lab

  It drives the real controller through the real input pump
  (input_inject_key -> the SDL queue -> input_pressed inside update), steps the
  engine, and prints every measured value next to its target. Poses are set
  directly (player.x = ...) ONLY to put the character somewhere; nothing about
  the controller's behaviour is faked.

  The one exception is `lab_jump_hold_ticks`, which forces the jump button to
  read as released after N ticks: a rendered frame is two ticks, so a 1-tick
  tap cannot otherwise be scripted. The 2-tick tap is measured as well, by
  pure key injection, and both are reported.

  Returns the report as a string (the eval channel prints it) and also writes
  it to tools/verify-report.txt.
]]

local R = {}
local pass_n, fail_n = 0, 0

local function line(s) R[#R + 1] = s end

local function check(name, measured, target, tol)
  local ok
  if tol then ok = math.abs(measured - target) <= tol else ok = (measured == target) end
  if ok then pass_n = pass_n + 1 else fail_n = fail_n + 1 end
  local m = (type(measured) == 'number') and string.format('%.4g', measured) or tostring(measured)
  local t = (type(target) == 'number') and string.format('%.4g', target) or tostring(target)
  line(string.format('%-4s %-46s measured %-12s target %s%s',
    ok and 'PASS' or 'FAIL', name, m, t, tol and string.format(' +-%.3g', tol) or ''))
  return ok
end

-- ── input plumbing ─────────────────────────────────────────────────────────
local held = {}
local function key(name, down)
  if held[name] == down then return end
  held[name] = down
  input_inject_key(name, down)
end
local function release_all()
  for k, v in pairs(held) do
    if v then input_inject_key(k, false) end
    held[k] = false
  end
  engine_step(1)
end
local function tap_key(name)
  key(name, true)
  engine_step(1)
  key(name, false)
end

-- ── pose plumbing ──────────────────────────────────────────────────────────
local function pose(x, y, state)
  local p = player
  p.x, p.y = x, y
  p.vx, p.vy = 0, 0
  p.state = state or 'fall'
  p.crouched = false
  p.hp, p.ropes = T.hp, T.rope_count
  p.hang_lock, p.rope_lock, p.buffer, p.coyote = 0, 0, 0, 0
  p.jump_hold, p.jump_hold_t, p.jump_hold_ticks = false, 0, 0
  p.jump_apex, p.jump_from_y = 0, y
  p.lower_hold, p.peek, p.peek_hold = 0, 0, 0
  p.last_land_h, p.last_land_dmg, p.last_land_t = 0, 0, 0
  p.last_rope_kick = 0
  p.rope = nil
  fall_reset(p)
  ropes = {}
  hurt_flash = 0
  camera_snap()
end

local function fresh(room)
  release_all()
  room_load(room or 'calibration')
  engine_step(1)
end

-- Step frame by frame until pred() or n frames have passed. Returns frames used.
local function step_until(pred, n)
  for i = 1, n do
    engine_step(1)
    if pred() then return i end
  end
  return n
end

local GROUND_Y = CALIBRATION_GROUND - D.hh   -- centre y of a character standing on the surface

-- ── 1. jump apexes ─────────────────────────────────────────────────────────
line('--- jump ---')
fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(70)
key('space', false)
check('held jump apex (tiles)', player.jump_apex, T.jump_apex_held, 0.03)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
lab_jump_hold_ticks = 1
key('space', true)
engine_step(70)
key('space', false)
lab_jump_hold_ticks = nil
check('tap jump apex, released after 1 tick', player.jump_apex, T.jump_apex_tap, 0.05)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(1)                -- one rendered frame = two ticks
key('space', false)
engine_step(70)
check('tap jump apex, released after 2 ticks', player.jump_apex, T.jump_apex_tap, 0.09)
release_all()

-- ── 2. speeds ──────────────────────────────────────────────────────────────
line('--- speeds ---')
local function speed_test(name, keys, target, tol)
  fresh('calibration')
  pose(2.5, GROUND_Y, 'stand')
  engine_step(3)
  for _, k in ipairs(keys) do key(k, true) end
  engine_step(40)
  local vx = player.vx
  release_all()
  check(name, vx, target, tol)
end
speed_test('walk speed (tiles/s)',  {'d'},            T.walk_speed,  0.05)
speed_test('run speed (tiles/s)',   {'d', 'lshift'},  T.run_speed,   0.1)
speed_test('crawl speed (tiles/s)', {'d', 's'},       T.crawl_speed, 0.05)

-- ── 3. terminal velocity ───────────────────────────────────────────────────
line('--- terminal velocity ---')
fresh('calibration')
local deep = CALIBRATION_PITS[#CALIBRATION_PITS]
pose(deep.x + 2, GROUND_Y, 'fall')
engine_step(40)               -- 0.67 s: terminal is reached at 0.36 s
check('terminal velocity (tiles/s)', player.vy, T.terminal_velocity, 0.1)

-- ── 4. fall damage tiers ───────────────────────────────────────────────────
line('--- fall damage (walk-off into the calibration pits) ---')
local function pit_test(depth, expect_dmg)
  local pit
  for _, q in ipairs(CALIBRATION_PITS) do if q.d == depth then pit = q end end
  fresh('calibration')
  pose(pit.x + 2, GROUND_Y, 'fall')
  step_until(function() return on_ground(player) or player.state == 'dead' end, 400)
  engine_step(2)
  local dmg = player.last_land_dmg
  local h = player.last_land_h
  check(string.format('%d-tile pit: damage', depth), dmg, expect_dmg)
  line(string.format('       equivalent height measured %.3f tiles (pit is %d), hp now %d',
                     h, depth, player.hp))
end
pit_test(7, 0)
pit_test(8, 1)
pit_test(16, 2)
pit_test(24, 99)
check('24-tile pit kills', player.state, 'dead')

-- ── 5. ledge grab: the 2-tile step yes, the 3-tile step no ─────────────────
line('--- ledge grab ---')
local function step_grab(x_left, label)
  fresh('calibration')
  pose(x_left, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)             -- walk into the face
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  local st = player.state
  release_all()
  return st, label
end
local st2 = step_grab(CALIBRATION_STEP2_X - 1.3, '2-tile')
check('standing jump at the 2-tile step -> hang', st2, 'hang')
local st3 = step_grab(CALIBRATION_STEP3_X - 1.3, '3-tile')
check('standing jump at the 3-tile step -> not hang', st3 ~= 'hang', true)

-- ── 6. from hang: drop, and the lockout; then the mantle ───────────────────
line('--- hang ---')
local function get_hang()
  fresh('calibration')
  pose(CALIBRATION_STEP2_X - 1.3, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  key('space', false)
  key('d', false)
  engine_step(1)
  return player.state == 'hang'
end

check('reached hang for the drop test', get_hang(), true)
key('s', true)
key('space', true)
engine_step(1)
check('hang + down + jump -> fall', player.state, 'fall')
check('hang lockout after the drop (s)', player.hang_lock, T.hang_lockout, 0.02)
key('s', false)
key('d', true)                                    -- hold BACK into the wall
local regrabbed = false
for _ = 1, 9 do                                   -- 9 frames = 0.15 s, the lockout
  engine_step(1)
  if player.state == 'hang' then regrabbed = true end
end
check('no grab possible during the 0.15 s lockout', regrabbed, false)
release_all()

check('reached hang for the mantle test', get_hang(), true)
key('space', true)
engine_step(1)
key('space', false)
step_until(function() return player.state == 'stand' end, 60)
check('hang + jump -> climb_up -> stand', player.state, 'stand')
check('  standing on top of the corner tile (y)', player.y, 10 - D.hh, 0.02)
check('  standing over the corner tile (x)', player.x, CALIBRATION_STEP2_X + 0.5, 0.02)
release_all()

-- ── 7. crouch to a lip, then lower-off ─────────────────────────────────────
line('--- lower-off ---')
fresh('calibration')
local pit1 = CALIBRATION_PITS[1]
pose(pit1.x - 2.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
key('d', true)
local lip_x, lip_frame, lower_frame, hang_frame = nil, nil, nil, nil
for i = 1, 240 do
  engine_step(1)
  if not lip_x and player.state == 'crouch' and at_lip(player, 1) then
    lip_x, lip_frame = player.x, i
  end
  if not lower_frame and player.state == 'lower_off' then lower_frame = i end
  if not hang_frame and player.state == 'hang' then hang_frame = i break end
end
check('crawl stops at the lip (box right edge)', (lip_x or 0) + D.hw, pit1.x, 0.03)
check('holding toward the drop enters lower_off', lower_frame ~= nil, true)
check('lower_off ends in hang', hang_frame ~= nil, true)
if lip_frame and lower_frame then
  check('hold before lower_off (s)', (lower_frame - lip_frame)/60, T.lower_off_hold, 0.05)
end
release_all()

-- ── 8. rope throws ─────────────────────────────────────────────────────────
line('--- ropes ---')
fresh('calibration')
pose(CALIBRATION_ROPE8_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 8-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 8)
  check('  segments unrolled', rope_length_of(ropes[1]), T.rope_length)
  check('  ropes left', player.ropes, T.rope_count - 1)
else
  check('rope up under the 8-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(CALIBRATION_ROPE4_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 4-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 4)
  check('  unrolls until the floor (segments)', rope_length_of(ropes[1]), 4)
else
  check('rope up under the 4-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(pit1.x - D.hw, GROUND_Y, 'stand')     -- box right edge exactly on the lip
player.facing = 1
engine_step(2)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down at a lip: anchor column (one ahead)', ropes[1].col, pit1.x)
  check('  anchor row = the thrower height', ropes[1].top_ty, CALIBRATION_GROUND - 1)
else
  check('rope down at a lip placed a rope', false, true)
end
release_all()

check('reached hang for the rope-down test', get_hang(), true)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down from a hang: anchor column', ropes[1].col, CALIBRATION_STEP2_X - 1)
  check('  anchor row = the hang row', ropes[1].top_ty, player.hang_ty)
else
  check('rope down from a hang placed a rope', false, true)
end
release_all()

-- ── 9. catching a rope mid-fall ────────────────────────────────────────────
line('--- rope catch ---')
local function rope_in_pit()
  fresh('calibration')
  local r = rope_place(deep.x + 2, CALIBRATION_GROUND + 6)
  r.bottom_ty = r.top_ty + T.rope_length - 1
  r.phase = 'set'
  pose(deep.x + 2 + 0.5, GROUND_Y, 'fall')
  ropes = {r}
  return r
end

local r1 = rope_in_pit()
key('w', true)
step_until(function() return player.state == 'rope' end, 200)
check('falling past a rope while holding up -> rope', player.state, 'rope')
check('  fall counter zeroed', player.fall_time, 0, 1e-9)
local caught_at = player.y
line(string.format('       caught at y %.2f (rope rows %d..%d)', caught_at, r1.top_ty, r1.bottom_ty))

-- 10. jumping off the rope with a direction held
key('w', false)
key('d', true)
engine_step(1)
tap_key('space')
engine_step(1)
check('jump off a rope with a direction: sideways kick', player.last_rope_kick, T.rope_jump_kick, 0.01)
check('  rope lockout after a jump-off (s)', player.rope_lock, T.rope_lockout_jump, 0.05)
release_all()

rope_in_pit()
step_until(function() return on_ground(player) or player.state == 'dead' end, 300)
check('falling past a rope WITHOUT holding up -> no catch', player.state ~= 'rope', true)
release_all()

-- ── 10. hot-reload probe (value only; the reload itself is driven outside) ──
line('--- tuning ---')
line(string.format('       jump v0 %.4f tiles/s, gravity ramp starts at %.4f of full',
                   D.jump_v0, D.jump_ramp_from))
line(string.format('       solved apexes: tap %.4f, held %.4f (targets %.2f / %.2f)',
                   D.jump_apex_tap_actual, D.jump_apex_held_actual,
                   T.jump_apex_tap, T.jump_apex_held))
line(string.format('       T.walk_speed is currently %.3f', T.walk_speed))

-- ── done ───────────────────────────────────────────────────────────────────
release_all()
fresh('calibration')

local report = string.format('verify: %d passed, %d failed\n', pass_n, fail_n) ..
               table.concat(R, '\n') .. '\n'
print(report)
if io and io.open then
  local f = io.open('tools/verify-report.txt', 'w')
  if f then f:write(report) f:close() end
end
return report

7. controller.lua

8. return engine_reload()
-> {"controller.lua"}

9. script tools\verify.lua
--[[
  tools/verify.lua — the lab's assertion run.

  Run it against a live agent instance:

    anchor drive start lab
    anchor drive eval  lab --file tools/verify.lua
    anchor drive stop  lab

  It drives the real controller through the real input pump
  (input_inject_key -> the SDL queue -> input_pressed inside update), steps the
  engine, and prints every measured value next to its target. Poses are set
  directly (player.x = ...) ONLY to put the character somewhere; nothing about
  the controller's behaviour is faked.

  The one exception is `lab_jump_hold_ticks`, which forces the jump button to
  read as released after N ticks: a rendered frame is two ticks, so a 1-tick
  tap cannot otherwise be scripted. The 2-tick tap is measured as well, by
  pure key injection, and both are reported.

  Returns the report as a string (the eval channel prints it) and also writes
  it to tools/verify-report.txt.
]]

local R = {}
local pass_n, fail_n = 0, 0

local function line(s) R[#R + 1] = s end

local function check(name, measured, target, tol)
  local ok
  if tol then ok = math.abs(measured - target) <= tol else ok = (measured == target) end
  if ok then pass_n = pass_n + 1 else fail_n = fail_n + 1 end
  local m = (type(measured) == 'number') and string.format('%.4g', measured) or tostring(measured)
  local t = (type(target) == 'number') and string.format('%.4g', target) or tostring(target)
  line(string.format('%-4s %-46s measured %-12s target %s%s',
    ok and 'PASS' or 'FAIL', name, m, t, tol and string.format(' +-%.3g', tol) or ''))
  return ok
end

-- ── input plumbing ─────────────────────────────────────────────────────────
local held = {}
local function key(name, down)
  if held[name] == down then return end
  held[name] = down
  input_inject_key(name, down)
end
local function release_all()
  for k, v in pairs(held) do
    if v then input_inject_key(k, false) end
    held[k] = false
  end
  engine_step(1)
end
local function tap_key(name)
  key(name, true)
  engine_step(1)
  key(name, false)
end

-- ── pose plumbing ──────────────────────────────────────────────────────────
local function pose(x, y, state)
  local p = player
  p.x, p.y = x, y
  p.vx, p.vy = 0, 0
  p.state = state or 'fall'
  p.crouched = false
  p.hp, p.ropes = T.hp, T.rope_count
  p.hang_lock, p.rope_lock, p.buffer, p.coyote = 0, 0, 0, 0
  p.jump_hold, p.jump_hold_t, p.jump_hold_ticks = false, 0, 0
  p.jump_apex, p.jump_from_y = 0, y
  p.lower_hold, p.peek, p.peek_hold = 0, 0, 0
  p.last_land_h, p.last_land_dmg, p.last_land_t = 0, 0, 0
  p.last_rope_kick = 0
  p.rope = nil
  fall_reset(p)
  ropes = {}
  hurt_flash = 0
  camera_snap()
end

local function fresh(room)
  release_all()
  room_load(room or 'calibration')
  engine_step(1)
end

-- Step frame by frame until pred() or n frames have passed. Returns frames used.
local function step_until(pred, n)
  for i = 1, n do
    engine_step(1)
    if pred() then return i end
  end
  return n
end

local GROUND_Y = CALIBRATION_GROUND - D.hh   -- centre y of a character standing on the surface

-- ── 1. jump apexes ─────────────────────────────────────────────────────────
line('--- jump ---')
fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(70)
key('space', false)
check('held jump apex (tiles)', player.jump_apex, T.jump_apex_held, 0.03)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
lab_jump_hold_ticks = 1
key('space', true)
engine_step(70)
key('space', false)
lab_jump_hold_ticks = nil
check('tap jump apex, released after 1 tick', player.jump_apex, T.jump_apex_tap, 0.05)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(1)                -- one rendered frame = two ticks
key('space', false)
engine_step(70)
check('tap jump apex, released after 2 ticks', player.jump_apex, T.jump_apex_tap, 0.09)
release_all()

-- ── 2. speeds ──────────────────────────────────────────────────────────────
line('--- speeds ---')
local function speed_test(name, keys, target, tol)
  fresh('calibration')
  pose(2.5, GROUND_Y, 'stand')
  engine_step(3)
  for _, k in ipairs(keys) do key(k, true) end
  engine_step(40)
  local vx = player.vx
  release_all()
  check(name, vx, target, tol)
end
speed_test('walk speed (tiles/s)',  {'d'},            T.walk_speed,  0.05)
speed_test('run speed (tiles/s)',   {'d', 'lshift'},  T.run_speed,   0.1)
speed_test('crawl speed (tiles/s)', {'d', 's'},       T.crawl_speed, 0.05)

-- ── 3. terminal velocity ───────────────────────────────────────────────────
line('--- terminal velocity ---')
fresh('calibration')
local deep = CALIBRATION_PITS[#CALIBRATION_PITS]
pose(deep.x + 2, GROUND_Y, 'fall')
engine_step(40)               -- 0.67 s: terminal is reached at 0.36 s
check('terminal velocity (tiles/s)', player.vy, T.terminal_velocity, 0.1)

-- ── 4. fall damage tiers ───────────────────────────────────────────────────
line('--- fall damage (walk-off into the calibration pits) ---')
local function pit_test(depth, expect_dmg)
  local pit
  for _, q in ipairs(CALIBRATION_PITS) do if q.d == depth then pit = q end end
  fresh('calibration')
  pose(pit.x + 2, GROUND_Y, 'fall')
  step_until(function() return on_ground(player) or player.state == 'dead' end, 400)
  engine_step(2)
  local dmg = player.last_land_dmg
  local h = player.last_land_h
  check(string.format('%d-tile pit: damage', depth), dmg, expect_dmg)
  line(string.format('       equivalent height measured %.3f tiles (pit is %d), hp now %d',
                     h, depth, player.hp))
end
pit_test(7, 0)
pit_test(8, 1)
pit_test(16, 2)
pit_test(24, 99)
check('24-tile pit kills', player.state, 'dead')

-- ── 5. ledge grab: the 2-tile step yes, the 3-tile step no ─────────────────
line('--- ledge grab ---')
local function step_grab(x_left, label)
  fresh('calibration')
  pose(x_left, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)             -- walk into the face
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  local st = player.state
  release_all()
  return st, label
end
local st2 = step_grab(CALIBRATION_STEP2_X - 1.3, '2-tile')
check('standing jump at the 2-tile step -> hang', st2, 'hang')
local st3 = step_grab(CALIBRATION_STEP3_X - 1.3, '3-tile')
check('standing jump at the 3-tile step -> not hang', st3 ~= 'hang', true)

-- ── 6. from hang: drop, and the lockout; then the mantle ───────────────────
line('--- hang ---')
local function get_hang()
  fresh('calibration')
  pose(CALIBRATION_STEP2_X - 1.3, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  key('space', false)
  key('d', false)
  engine_step(1)
  return player.state == 'hang'
end

check('reached hang for the drop test', get_hang(), true)
key('s', true)
key('space', true)
engine_step(1)
check('hang + down + jump -> fall', player.state, 'fall')
check('hang lockout after the drop (s)', player.hang_lock, T.hang_lockout, 0.02)
key('s', false)
key('d', true)                                    -- hold BACK into the wall
local regrabbed = false
for _ = 1, 9 do                                   -- 9 frames = 0.15 s, the lockout
  engine_step(1)
  if player.state == 'hang' then regrabbed = true end
end
check('no grab possible during the 0.15 s lockout', regrabbed, false)
release_all()

check('reached hang for the mantle test', get_hang(), true)
key('space', true)
engine_step(1)
key('space', false)
step_until(function() return player.state == 'stand' end, 60)
check('hang + jump -> climb_up -> stand', player.state, 'stand')
check('  standing on top of the corner tile (y)', player.y, 10 - D.hh, 0.02)
check('  standing over the corner tile (x)', player.x, CALIBRATION_STEP2_X + 0.5, 0.02)
release_all()

-- ── 7. crouch to a lip, then lower-off ─────────────────────────────────────
line('--- lower-off ---')
fresh('calibration')
local pit1 = CALIBRATION_PITS[1]
pose(pit1.x - 2.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
key('d', true)
local lip_x, lip_frame, lower_frame, hang_frame = nil, nil, nil, nil
for i = 1, 240 do
  engine_step(1)
  if not lip_x and player.state == 'crouch' and at_lip(player, 1) then
    lip_x, lip_frame = player.x, i
  end
  if not lower_frame and player.state == 'lower_off' then lower_frame = i end
  if not hang_frame and player.state == 'hang' then hang_frame = i break end
end
check('crawl stops at the lip (box right edge)', (lip_x or 0) + D.hw, pit1.x, 0.03)
check('holding toward the drop enters lower_off', lower_frame ~= nil, true)
check('lower_off ends in hang', hang_frame ~= nil, true)
if lip_frame and lower_frame then
  check('hold before lower_off (s)', (lower_frame - lip_frame)/60, T.lower_off_hold, 0.05)
end
release_all()

-- ── 8. rope throws ─────────────────────────────────────────────────────────
line('--- ropes ---')
fresh('calibration')
pose(CALIBRATION_ROPE8_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 8-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 8)
  check('  segments unrolled', rope_length_of(ropes[1]), T.rope_length)
  check('  ropes left', player.ropes, T.rope_count - 1)
else
  check('rope up under the 8-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(CALIBRATION_ROPE4_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 4-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 4)
  check('  unrolls until the floor (segments)', rope_length_of(ropes[1]), 4)
else
  check('rope up under the 4-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(pit1.x - D.hw, GROUND_Y, 'stand')     -- box right edge exactly on the lip
player.facing = 1
engine_step(2)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down at a lip: anchor column (one ahead)', ropes[1].col, pit1.x)
  check('  anchor row = the thrower height', ropes[1].top_ty, CALIBRATION_GROUND - 1)
else
  check('rope down at a lip placed a rope', false, true)
end
release_all()

check('reached hang for the rope-down test', get_hang(), true)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down from a hang: anchor column', ropes[1].col, CALIBRATION_STEP2_X - 1)
  check('  anchor row = the hang row', ropes[1].top_ty, player.hang_ty)
else
  check('rope down from a hang placed a rope', false, true)
end
release_all()

-- ── 9. catching a rope mid-fall ────────────────────────────────────────────
line('--- rope catch ---')
local function rope_in_pit()
  fresh('calibration')
  local r = rope_place(deep.x + 2, CALIBRATION_GROUND + 6)
  r.bottom_ty = r.top_ty + T.rope_length - 1
  r.phase = 'set'
  pose(deep.x + 2 + 0.5, GROUND_Y, 'fall')
  ropes = {r}
  return r
end

local r1 = rope_in_pit()
key('w', true)
step_until(function() return player.state == 'rope' end, 200)
check('falling past a rope while holding up -> rope', player.state, 'rope')
check('  fall counter zeroed', player.fall_time, 0, 1e-9)
local caught_at = player.y
line(string.format('       caught at y %.2f (rope rows %d..%d)', caught_at, r1.top_ty, r1.bottom_ty))

-- 10. jumping off the rope with a direction held
key('w', false)
key('d', true)
engine_step(1)
tap_key('space')
engine_step(1)
check('jump off a rope with a direction: sideways kick', player.last_rope_kick, T.rope_jump_kick, 0.01)
check('  rope lockout after a jump-off (s)', player.rope_lock, T.rope_lockout_jump, 0.05)
release_all()

rope_in_pit()
step_until(function() return on_ground(player) or player.state == 'dead' end, 300)
check('falling past a rope WITHOUT holding up -> no catch', player.state ~= 'rope', true)
release_all()

-- ── 10. hot-reload probe (value only; the reload itself is driven outside) ──
line('--- tuning ---')
line(string.format('       jump v0 %.4f tiles/s, gravity ramp starts at %.4f of full',
                   D.jump_v0, D.jump_ramp_from))
line(string.format('       solved apexes: tap %.4f, held %.4f (targets %.2f / %.2f)',
                   D.jump_apex_tap_actual, D.jump_apex_held_actual,
                   T.jump_apex_tap, T.jump_apex_held))
line(string.format('       T.walk_speed is currently %.3f', T.walk_speed))

-- ── done ───────────────────────────────────────────────────────────────────
release_all()
fresh('calibration')

local report = string.format('verify: %d passed, %d failed\n', pass_n, fail_n) ..
               table.concat(R, '\n') .. '\n'
print(report)
if io and io.open then
  local f = io.open('tools/verify-report.txt', 'w')
  if f then f:write(report) f:close() end
end
return report

10. script tools\verify.lua
--[[
  tools/verify.lua — the lab's assertion run.

  Run it against a live agent instance:

    anchor drive start lab
    anchor drive eval  lab --file tools/verify.lua
    anchor drive stop  lab

  It drives the real controller through the real input pump
  (input_inject_key -> the SDL queue -> input_pressed inside update), steps the
  engine, and prints every measured value next to its target. Poses are set
  directly (player.x = ...) ONLY to put the character somewhere; nothing about
  the controller's behaviour is faked.

  The one exception is `lab_jump_hold_ticks`, which forces the jump button to
  read as released after N ticks: a rendered frame is two ticks, so a 1-tick
  tap cannot otherwise be scripted. The 2-tick tap is measured as well, by
  pure key injection, and both are reported.

  Returns the report as a string (the eval channel prints it) and also writes
  it to tools/verify-report.txt.
]]

local R = {}
local pass_n, fail_n = 0, 0

local function line(s) R[#R + 1] = s end

local function check(name, measured, target, tol)
  local ok
  if tol then ok = math.abs(measured - target) <= tol else ok = (measured == target) end
  if ok then pass_n = pass_n + 1 else fail_n = fail_n + 1 end
  local m = (type(measured) == 'number') and string.format('%.4g', measured) or tostring(measured)
  local t = (type(target) == 'number') and string.format('%.4g', target) or tostring(target)
  line(string.format('%-4s %-46s measured %-12s target %s%s',
    ok and 'PASS' or 'FAIL', name, m, t, tol and string.format(' +-%.3g', tol) or ''))
  return ok
end

-- ── input plumbing ─────────────────────────────────────────────────────────
local held = {}
local function key(name, down)
  if held[name] == down then return end
  held[name] = down
  input_inject_key(name, down)
end
local function release_all()
  for k, v in pairs(held) do
    if v then input_inject_key(k, false) end
    held[k] = false
  end
  engine_step(1)
end
local function tap_key(name)
  key(name, true)
  engine_step(1)
  key(name, false)
end

-- ── pose plumbing ──────────────────────────────────────────────────────────
local function pose(x, y, state)
  local p = player
  p.x, p.y = x, y
  p.vx, p.vy = 0, 0
  p.state = state or 'fall'
  p.crouched = false
  p.hp, p.ropes = T.hp, T.rope_count
  p.hang_lock, p.rope_lock, p.buffer, p.coyote = 0, 0, 0, 0
  p.jump_hold, p.jump_hold_t, p.jump_hold_ticks = false, 0, 0
  p.jump_apex, p.jump_from_y = 0, y
  p.lower_hold, p.peek, p.peek_hold = 0, 0, 0
  p.last_land_h, p.last_land_dmg, p.last_land_t = 0, 0, 0
  p.last_rope_kick = 0
  p.rope = nil
  fall_reset(p)
  ropes = {}
  hurt_flash = 0
  camera_snap()
end

local function fresh(room)
  release_all()
  room_load(room or 'calibration')
  engine_step(1)
end

-- Step frame by frame until pred() or n frames have passed. Returns frames used.
local function step_until(pred, n)
  for i = 1, n do
    engine_step(1)
    if pred() then return i end
  end
  return n
end

local GROUND_Y = CALIBRATION_GROUND - D.hh   -- centre y of a character standing on the surface

-- ── 1. jump apexes ─────────────────────────────────────────────────────────
line('--- jump ---')
fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(70)
key('space', false)
check('held jump apex (tiles)', player.jump_apex, T.jump_apex_held, 0.03)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
lab_jump_hold_ticks = 1
key('space', true)
engine_step(70)
key('space', false)
lab_jump_hold_ticks = nil
check('tap jump apex, released after 1 tick', player.jump_apex, T.jump_apex_tap, 0.05)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(1)                -- one rendered frame = two ticks
key('space', false)
engine_step(70)
check('tap jump apex, released after 2 ticks', player.jump_apex, T.jump_apex_tap, 0.09)
release_all()

-- ── 2. speeds ──────────────────────────────────────────────────────────────
line('--- speeds ---')
local function speed_test(name, keys, target, tol)
  fresh('calibration')
  pose(2.5, GROUND_Y, 'stand')
  engine_step(3)
  for _, k in ipairs(keys) do key(k, true) end
  engine_step(40)
  local vx = player.vx
  release_all()
  check(name, vx, target, tol)
end
speed_test('walk speed (tiles/s)',  {'d'},            T.walk_speed,  0.05)
speed_test('run speed (tiles/s)',   {'d', 'lshift'},  T.run_speed,   0.1)
speed_test('crawl speed (tiles/s)', {'d', 's'},       T.crawl_speed, 0.05)

-- ── 3. terminal velocity ───────────────────────────────────────────────────
line('--- terminal velocity ---')
fresh('calibration')
local deep = CALIBRATION_PITS[#CALIBRATION_PITS]
pose(deep.x + 2, GROUND_Y, 'fall')
engine_step(40)               -- 0.67 s: terminal is reached at 0.36 s
check('terminal velocity (tiles/s)', player.vy, T.terminal_velocity, 0.1)

-- ── 4. fall damage tiers ───────────────────────────────────────────────────
line('--- fall damage (walk-off into the calibration pits) ---')
local function pit_test(depth, expect_dmg)
  local pit
  for _, q in ipairs(CALIBRATION_PITS) do if q.d == depth then pit = q end end
  fresh('calibration')
  pose(pit.x + 2, GROUND_Y, 'fall')
  step_until(function() return on_ground(player) or player.state == 'dead' end, 400)
  engine_step(2)
  local dmg = player.last_land_dmg
  local h = player.last_land_h
  check(string.format('%d-tile pit: damage', depth), dmg, expect_dmg)
  line(string.format('       equivalent height measured %.3f tiles (pit is %d), hp now %d',
                     h, depth, player.hp))
end
pit_test(7, 0)
pit_test(8, 1)
pit_test(16, 2)
pit_test(24, 99)
check('24-tile pit kills', player.state, 'dead')

-- ── 5. ledge grab: the 2-tile step yes, the 3-tile step no ─────────────────
line('--- ledge grab ---')
local function step_grab(x_left, label)
  fresh('calibration')
  pose(x_left, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)             -- walk into the face
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  local st = player.state
  release_all()
  return st, label
end
local st2 = step_grab(CALIBRATION_STEP2_X - 1.3, '2-tile')
check('standing jump at the 2-tile step -> hang', st2, 'hang')
local st3 = step_grab(CALIBRATION_STEP3_X - 1.3, '3-tile')
check('standing jump at the 3-tile step -> not hang', st3 ~= 'hang', true)

-- ── 6. from hang: drop, and the lockout; then the mantle ───────────────────
line('--- hang ---')
local function get_hang()
  fresh('calibration')
  pose(CALIBRATION_STEP2_X - 1.3, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  key('space', false)
  key('d', false)
  engine_step(1)
  return player.state == 'hang'
end

check('reached hang for the drop test', get_hang(), true)
key('s', true)
key('space', true)
engine_step(1)
check('hang + down + jump -> fall', player.state, 'fall')
check('hang lockout after the drop (s)', player.hang_lock, T.hang_lockout, 0.02)
key('s', false)
key('d', true)                                    -- hold BACK into the wall
local regrabbed = false
for _ = 1, 9 do                                   -- 9 frames = 0.15 s, the lockout
  engine_step(1)
  if player.state == 'hang' then regrabbed = true end
end
check('no grab possible during the 0.15 s lockout', regrabbed, false)
release_all()

check('reached hang for the mantle test', get_hang(), true)
key('space', true)
engine_step(1)
key('space', false)
step_until(function() return player.state == 'stand' end, 60)
check('hang + jump -> climb_up -> stand', player.state, 'stand')
check('  standing on top of the corner tile (y)', player.y, 10 - D.hh, 0.02)
check('  standing over the corner tile (x)', player.x, CALIBRATION_STEP2_X + 0.5, 0.02)
release_all()

-- ── 7. crouch to a lip, then lower-off ─────────────────────────────────────
line('--- lower-off ---')
fresh('calibration')
local pit1 = CALIBRATION_PITS[1]
pose(pit1.x - 2.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
key('d', true)
local lip_x, lip_frame, lower_frame, hang_frame = nil, nil, nil, nil
for i = 1, 240 do
  engine_step(1)
  if not lip_x and player.state == 'crouch' and at_lip(player, 1) then
    lip_x, lip_frame = player.x, i
  end
  if not lower_frame and player.state == 'lower_off' then lower_frame = i end
  if not hang_frame and player.state == 'hang' then hang_frame = i break end
end
check('crawl stops at the lip (box right edge)', (lip_x or 0) + D.hw, pit1.x, 0.03)
check('holding toward the drop enters lower_off', lower_frame ~= nil, true)
check('lower_off ends in hang', hang_frame ~= nil, true)
if lip_frame and lower_frame then
  check('hold before lower_off (s)', (lower_frame - lip_frame)/60, T.lower_off_hold, 0.05)
end
release_all()

-- ── 8. rope throws ─────────────────────────────────────────────────────────
line('--- ropes ---')
fresh('calibration')
pose(CALIBRATION_ROPE8_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 8-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 8)
  check('  segments unrolled', rope_length_of(ropes[1]), T.rope_length)
  check('  ropes left', player.ropes, T.rope_count - 1)
else
  check('rope up under the 8-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(CALIBRATION_ROPE4_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 4-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 4)
  check('  unrolls until the floor (segments)', rope_length_of(ropes[1]), 4)
else
  check('rope up under the 4-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(pit1.x - D.hw, GROUND_Y, 'stand')     -- box right edge exactly on the lip
player.facing = 1
engine_step(2)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down at a lip: anchor column (one ahead)', ropes[1].col, pit1.x)
  check('  anchor row = the thrower height', ropes[1].top_ty, CALIBRATION_GROUND - 1)
else
  check('rope down at a lip placed a rope', false, true)
end
release_all()

check('reached hang for the rope-down test', get_hang(), true)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down from a hang: anchor column', ropes[1].col, CALIBRATION_STEP2_X - 1)
  check('  anchor row = the hang row', ropes[1].top_ty, player.hang_ty)
else
  check('rope down from a hang placed a rope', false, true)
end
release_all()

-- ── 9. catching a rope mid-fall ────────────────────────────────────────────
line('--- rope catch ---')
local function rope_in_pit()
  fresh('calibration')
  local r = rope_place(deep.x + 2, CALIBRATION_GROUND + 6)
  r.bottom_ty = r.top_ty + T.rope_length - 1
  r.phase = 'set'
  pose(deep.x + 2 + 0.5, GROUND_Y, 'fall')
  ropes = {r}
  return r
end

local r1 = rope_in_pit()
key('w', true)
step_until(function() return player.state == 'rope' end, 200)
check('falling past a rope while holding up -> rope', player.state, 'rope')
check('  fall counter zeroed', player.fall_time, 0, 1e-9)
local caught_at = player.y
line(string.format('       caught at y %.2f (rope rows %d..%d)', caught_at, r1.top_ty, r1.bottom_ty))

-- 10. jumping off the rope with a direction held
key('w', false)
key('d', true)
engine_step(1)
tap_key('space')
engine_step(1)
check('jump off a rope with a direction: sideways kick', player.last_rope_kick, T.rope_jump_kick, 0.01)
check('  rope lockout after a jump-off (s)', player.rope_lock, T.rope_lockout_jump, 0.05)
release_all()

rope_in_pit()
step_until(function() return on_ground(player) or player.state == 'dead' end, 300)
check('falling past a rope WITHOUT holding up -> no catch', player.state ~= 'rope', true)
release_all()

-- ── 10. hot-reload probe (value only; the reload itself is driven outside) ──
line('--- tuning ---')
line(string.format('       jump v0 %.4f tiles/s, gravity ramp starts at %.4f of full',
                   D.jump_v0, D.jump_ramp_from))
line(string.format('       solved apexes: tap %.4f, held %.4f (targets %.2f / %.2f)',
                   D.jump_apex_tap_actual, D.jump_apex_held_actual,
                   T.jump_apex_tap, T.jump_apex_held))
line(string.format('       T.walk_speed is currently %.3f', T.walk_speed))

-- ── done ───────────────────────────────────────────────────────────────────
release_all()
fresh('calibration')

local report = string.format('verify: %d passed, %d failed\n', pass_n, fail_n) ..
               table.concat(R, '\n') .. '\n'
print(report)
if io and io.open then
  local f = io.open('tools/verify-report.txt', 'w')
  if f then f:write(report) f:close() end
end
return report

11. room_load("shaft") engine_step(5) return map.seed, map.gen_to, player.x, player.y, player.state, #map.rows
-> 499811
47
6.5
3.6
stand
47

12. room_load("walls") engine_step(5) return map.w, map.h, player.x, player.y, player.state
-> 5
60
2.5
1.7909722222222
fall

13. script tools\snapshot.lua
-- tools/snapshot.lua — one picture of each room for the report.
local held = {}
local function key(n, d) if held[n] ~= d then held[n] = d input_inject_key(n, d) end end
local function release() for k, v in pairs(held) do if v then input_inject_key(k, false) end held[k] = false end engine_step(1) end
local out = {}

debug_on = true

-- calibration: the grab walls and the low corridor in frame
release()
room_load('calibration')
player.x, player.y = 40.5, 11.6
player.vx, player.vy = 0, 0
camera_snap()
engine_step(4)
engine_snapshot('tools/snapshots/calibration.png')
out[#out + 1] = 'tools/snapshots/calibration.png'

-- calibration: the pit row, labelled with their depths
player.x, player.y = 96.5, 11.6
player.vx, player.vy = 0, 0
camera_snap()
engine_step(4)
engine_snapshot('tools/snapshots/calibration-pits.png')
out[#out + 1] = 'tools/snapshots/calibration-pits.png'

-- shaft: the camp the descent starts from
release()
room_load('shaft')
engine_step(6)
engine_snapshot('tools/snapshots/shaft-camp.png')
out[#out + 1] = 'tools/snapshots/shaft-camp.png'

-- shaft: mid-descent, walking right and dropping down the hole
key('d', true)
for _ = 1, 240 do
  engine_step(1)
  if player.depth > 26 or player.state == 'dead' then break end
end
release()
engine_step(2)
engine_snapshot('tools/snapshots/shaft-descent.png')
out[#out + 1] = 'tools/snapshots/shaft-descent.png'
local depth, hp, st = player.depth, player.hp, player.state

-- walls
release()
room_load('walls')
engine_step(20)
engine_snapshot('tools/snapshots/walls.png')
out[#out + 1] = 'tools/snapshots/walls.png'

release()
room_load('calibration')
return table.concat(out, '\n'), string.format('shaft depth %.1f hp %d state %s', depth, hp, st)

14. view.lua

15. return engine_reload()
-> {"view.lua"}

16. script tools\snapshot.lua
-- tools/snapshot.lua — one picture of each room for the report.
local held = {}
local function key(n, d) if held[n] ~= d then held[n] = d input_inject_key(n, d) end end
local function release() for k, v in pairs(held) do if v then input_inject_key(k, false) end held[k] = false end engine_step(1) end
local out = {}

debug_on = true

-- calibration: the grab walls and the low corridor in frame
release()
room_load('calibration')
player.x, player.y = 40.5, 11.6
player.vx, player.vy = 0, 0
camera_snap()
engine_step(4)
engine_snapshot('tools/snapshots/calibration.png')
out[#out + 1] = 'tools/snapshots/calibration.png'

-- calibration: the pit row, labelled with their depths
player.x, player.y = 94.5, 11.6
player.vx, player.vy = 0, 0
camera_snap()
engine_step(4)
engine_snapshot('tools/snapshots/calibration-pits.png')
out[#out + 1] = 'tools/snapshots/calibration-pits.png'

-- shaft: the camp the descent starts from
release()
room_load('shaft')
engine_step(6)
engine_snapshot('tools/snapshots/shaft-camp.png')
out[#out + 1] = 'tools/snapshots/shaft-camp.png'

-- shaft: mid-descent, walking right and dropping down the hole
key('d', true)
for _ = 1, 900 do
  engine_step(1)
  -- let go once airborne so a held direction does not grab the shaft's corners
  if not on_ground(player) then key('d', false) end
  if on_ground(player) and player.state ~= 'hang' then key('d', true) end
  if player.depth > 26 or player.state == 'dead' then break end
end
release()
engine_step(2)
engine_snapshot('tools/snapshots/shaft-descent.png')
out[#out + 1] = 'tools/snapshots/shaft-descent.png'
local depth, hp, st = player.depth, player.hp, player.state

-- walls
release()
room_load('walls')
engine_step(20)
engine_snapshot('tools/snapshots/walls.png')
out[#out + 1] = 'tools/snapshots/walls.png'

release()
room_load('calibration')
return table.concat(out, '\n'), string.format('shaft depth %.1f hp %d state %s', depth, hp, st)

17. script tools\snapshot.lua
-- tools/snapshot.lua — one picture of each room for the report.
local held = {}
local function key(n, d) if held[n] ~= d then held[n] = d input_inject_key(n, d) end end
local function release() for k, v in pairs(held) do if v then input_inject_key(k, false) end held[k] = false end engine_step(1) end
local out = {}

debug_on = true

-- calibration: the grab walls and the low corridor in frame
release()
room_load('calibration')
player.x, player.y = 40.5, 11.6
player.vx, player.vy = 0, 0
camera_snap()
engine_step(4)
engine_snapshot('tools/snapshots/calibration.png')
out[#out + 1] = 'tools/snapshots/calibration.png'

-- calibration: the pit row, labelled with their depths
player.x, player.y = 94.5, 11.6
player.vx, player.vy = 0, 0
camera_snap()
engine_step(4)
engine_snapshot('tools/snapshots/calibration-pits.png')
out[#out + 1] = 'tools/snapshots/calibration-pits.png'

-- shaft: the camp the descent starts from
release()
room_load('shaft')
engine_step(6)
engine_snapshot('tools/snapshots/shaft-camp.png')
out[#out + 1] = 'tools/snapshots/shaft-camp.png'

-- shaft: mid-descent, walking right and dropping down the hole
for _ = 1, 1200 do
  if player.state == 'hang' then
    key('d', false) key('s', true) key('space', true)
  elseif on_ground(player) then
    key('s', false) key('space', false) key('d', true)
  else
    key('d', false) key('s', false) key('space', false)
  end
  engine_step(1)
  if player.depth > 40 or player.state == 'dead' then break end
end
release()
engine_step(2)
engine_snapshot('tools/snapshots/shaft-descent.png')
out[#out + 1] = 'tools/snapshots/shaft-descent.png'
local depth, hp, st = player.depth, player.hp, player.state

-- walls
release()
room_load('walls')
engine_step(20)
engine_snapshot('tools/snapshots/walls.png')
out[#out + 1] = 'tools/snapshots/walls.png'

release()
room_load('calibration')
return table.concat(out, '\n'), string.format('shaft depth %.1f hp %d state %s', depth, hp, st)

18. script tools\measure_walk.lua
-- tools/measure_walk.lua — one number: the settled walking speed, measured in
-- the running instance. Used to prove tuning.lua's hot reload.
local held = {}
local function key(n, d) if held[n] ~= d then held[n] = d input_inject_key(n, d) end end
for _, k in ipairs({'a','d','w','s','space','lshift','e'}) do key(k, false) end
engine_step(1)
room_load('calibration')
player.x, player.y = 2.5, CALIBRATION_GROUND - D.hh
player.vx, player.vy = 0, 0
player.state = 'stand'
camera_snap()
engine_step(3)
key('d', true)
engine_step(40)
local vx = player.vx
key('d', false)
engine_step(1)
room_load('calibration')
return string.format('T.walk_speed=%.3f  measured vx=%.4f  D.jump_ramp_from=%.4f  D.jump_v0=%.4f',
                     T.walk_speed, vx, D.jump_ramp_from, D.jump_v0)

19. tuning.lua

20. return engine_reload()
-> {"tuning.lua"}

21. script tools\measure_walk.lua
-- tools/measure_walk.lua — one number: the settled walking speed, measured in
-- the running instance. Used to prove tuning.lua's hot reload.
local held = {}
local function key(n, d) if held[n] ~= d then held[n] = d input_inject_key(n, d) end end
for _, k in ipairs({'a','d','w','s','space','lshift','e'}) do key(k, false) end
engine_step(1)
room_load('calibration')
player.x, player.y = 2.5, CALIBRATION_GROUND - D.hh
player.vx, player.vy = 0, 0
player.state = 'stand'
camera_snap()
engine_step(3)
key('d', true)
engine_step(40)
local vx = player.vx
key('d', false)
engine_step(1)
room_load('calibration')
return string.format('T.walk_speed=%.3f  measured vx=%.4f  D.jump_ramp_from=%.4f  D.jump_v0=%.4f',
                     T.walk_speed, vx, D.jump_ramp_from, D.jump_v0)

22. tuning.lua

23. return engine_reload()
-> {"tuning.lua"}

24. script tools\measure_walk.lua
-- tools/measure_walk.lua — one number: the settled walking speed, measured in
-- the running instance. Used to prove tuning.lua's hot reload.
local held = {}
local function key(n, d) if held[n] ~= d then held[n] = d input_inject_key(n, d) end end
for _, k in ipairs({'a','d','w','s','space','lshift','e'}) do key(k, false) end
engine_step(1)
room_load('calibration')
player.x, player.y = 2.5, CALIBRATION_GROUND - D.hh
player.vx, player.vy = 0, 0
player.state = 'stand'
camera_snap()
engine_step(3)
key('d', true)
engine_step(40)
local vx = player.vx
key('d', false)
engine_step(1)
room_load('calibration')
return string.format('T.walk_speed=%.3f  measured vx=%.4f  D.jump_ramp_from=%.4f  D.jump_v0=%.4f',
                     T.walk_speed, vx, D.jump_ramp_from, D.jump_v0)

25. tuning.lua

26. return engine_reload()
-> {"tuning.lua"}

27. script tools\measure_walk.lua
-- tools/measure_walk.lua — one number: the settled walking speed, measured in
-- the running instance. Used to prove tuning.lua's hot reload.
local held = {}
local function key(n, d) if held[n] ~= d then held[n] = d input_inject_key(n, d) end end
for _, k in ipairs({'a','d','w','s','space','lshift','e'}) do key(k, false) end
engine_step(1)
room_load('calibration')
player.x, player.y = 2.5, CALIBRATION_GROUND - D.hh
player.vx, player.vy = 0, 0
player.state = 'stand'
camera_snap()
engine_step(3)
key('d', true)
engine_step(40)
local vx = player.vx
key('d', false)
engine_step(1)
room_load('calibration')
return string.format('T.walk_speed=%.3f  measured vx=%.4f  D.jump_ramp_from=%.4f  D.jump_v0=%.4f',
                     T.walk_speed, vx, D.jump_ramp_from, D.jump_v0)

28. script tools\verify.lua
--[[
  tools/verify.lua — the lab's assertion run.

  Run it against a live agent instance:

    anchor drive start lab
    anchor drive eval  lab --file tools/verify.lua
    anchor drive stop  lab

  It drives the real controller through the real input pump
  (input_inject_key -> the SDL queue -> input_pressed inside update), steps the
  engine, and prints every measured value next to its target. Poses are set
  directly (player.x = ...) ONLY to put the character somewhere; nothing about
  the controller's behaviour is faked.

  The one exception is `lab_jump_hold_ticks`, which forces the jump button to
  read as released after N ticks: a rendered frame is two ticks, so a 1-tick
  tap cannot otherwise be scripted. The 2-tick tap is measured as well, by
  pure key injection, and both are reported.

  Returns the report as a string (the eval channel prints it) and also writes
  it to tools/verify-report.txt.
]]

local R = {}
local pass_n, fail_n = 0, 0

local function line(s) R[#R + 1] = s end

local function check(name, measured, target, tol)
  local ok
  if tol then ok = math.abs(measured - target) <= tol else ok = (measured == target) end
  if ok then pass_n = pass_n + 1 else fail_n = fail_n + 1 end
  local m = (type(measured) == 'number') and string.format('%.4g', measured) or tostring(measured)
  local t = (type(target) == 'number') and string.format('%.4g', target) or tostring(target)
  line(string.format('%-4s %-46s measured %-12s target %s%s',
    ok and 'PASS' or 'FAIL', name, m, t, tol and string.format(' +-%.3g', tol) or ''))
  return ok
end

-- ── input plumbing ─────────────────────────────────────────────────────────
local held = {}
local function key(name, down)
  if held[name] == down then return end
  held[name] = down
  input_inject_key(name, down)
end
local function release_all()
  for k, v in pairs(held) do
    if v then input_inject_key(k, false) end
    held[k] = false
  end
  engine_step(1)
end
local function tap_key(name)
  key(name, true)
  engine_step(1)
  key(name, false)
end

-- ── pose plumbing ──────────────────────────────────────────────────────────
local function pose(x, y, state)
  local p = player
  p.x, p.y = x, y
  p.vx, p.vy = 0, 0
  p.state = state or 'fall'
  p.crouched = false
  p.hp, p.ropes = T.hp, T.rope_count
  p.hang_lock, p.rope_lock, p.buffer, p.coyote = 0, 0, 0, 0
  p.jump_hold, p.jump_hold_t, p.jump_hold_ticks = false, 0, 0
  p.jump_apex, p.jump_from_y = 0, y
  p.lower_hold, p.peek, p.peek_hold = 0, 0, 0
  p.last_land_h, p.last_land_dmg, p.last_land_t = 0, 0, 0
  p.last_rope_kick = 0
  p.rope = nil
  fall_reset(p)
  ropes = {}
  hurt_flash = 0
  camera_snap()
end

local function fresh(room)
  release_all()
  room_load(room or 'calibration')
  engine_step(1)
end

-- Step frame by frame until pred() or n frames have passed. Returns frames used.
local function step_until(pred, n)
  for i = 1, n do
    engine_step(1)
    if pred() then return i end
  end
  return n
end

local GROUND_Y = CALIBRATION_GROUND - D.hh   -- centre y of a character standing on the surface

-- ── 1. jump apexes ─────────────────────────────────────────────────────────
line('--- jump ---')
fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(70)
key('space', false)
check('held jump apex (tiles)', player.jump_apex, T.jump_apex_held, 0.03)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
lab_jump_hold_ticks = 1
key('space', true)
engine_step(70)
key('space', false)
lab_jump_hold_ticks = nil
check('tap jump apex, released after 1 tick', player.jump_apex, T.jump_apex_tap, 0.05)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(1)                -- one rendered frame = two ticks
key('space', false)
engine_step(70)
check('tap jump apex, released after 2 ticks', player.jump_apex, T.jump_apex_tap, 0.09)
release_all()

-- ── 2. speeds ──────────────────────────────────────────────────────────────
line('--- speeds ---')
local function speed_test(name, keys, target, tol)
  fresh('calibration')
  pose(2.5, GROUND_Y, 'stand')
  engine_step(3)
  for _, k in ipairs(keys) do key(k, true) end
  engine_step(40)
  local vx = player.vx
  release_all()
  check(name, vx, target, tol)
end
speed_test('walk speed (tiles/s)',  {'d'},            T.walk_speed,  0.05)
speed_test('run speed (tiles/s)',   {'d', 'lshift'},  T.run_speed,   0.1)
speed_test('crawl speed (tiles/s)', {'d', 's'},       T.crawl_speed, 0.05)

-- ── 3. terminal velocity ───────────────────────────────────────────────────
line('--- terminal velocity ---')
fresh('calibration')
local deep = CALIBRATION_PITS[#CALIBRATION_PITS]
pose(deep.x + 2, GROUND_Y, 'fall')
engine_step(40)               -- 0.67 s: terminal is reached at 0.36 s
check('terminal velocity (tiles/s)', player.vy, T.terminal_velocity, 0.1)

-- ── 4. fall damage tiers ───────────────────────────────────────────────────
line('--- fall damage (walk-off into the calibration pits) ---')
local function pit_test(depth, expect_dmg)
  local pit
  for _, q in ipairs(CALIBRATION_PITS) do if q.d == depth then pit = q end end
  fresh('calibration')
  pose(pit.x + 2, GROUND_Y, 'fall')
  step_until(function() return on_ground(player) or player.state == 'dead' end, 400)
  engine_step(2)
  local dmg = player.last_land_dmg
  local h = player.last_land_h
  check(string.format('%d-tile pit: damage', depth), dmg, expect_dmg)
  line(string.format('       equivalent height measured %.3f tiles (pit is %d), hp now %d',
                     h, depth, player.hp))
end
pit_test(7, 0)
pit_test(8, 1)
pit_test(16, 2)
pit_test(24, 99)
check('24-tile pit kills', player.state, 'dead')

-- ── 5. ledge grab: the 2-tile step yes, the 3-tile step no ─────────────────
line('--- ledge grab ---')
local function step_grab(x_left, label)
  fresh('calibration')
  pose(x_left, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)             -- walk into the face
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  local st = player.state
  release_all()
  return st, label
end
local st2 = step_grab(CALIBRATION_STEP2_X - 1.3, '2-tile')
check('standing jump at the 2-tile step -> hang', st2, 'hang')
local st3 = step_grab(CALIBRATION_STEP3_X - 1.3, '3-tile')
check('standing jump at the 3-tile step -> not hang', st3 ~= 'hang', true)

-- ── 6. from hang: drop, and the lockout; then the mantle ───────────────────
line('--- hang ---')
local function get_hang()
  fresh('calibration')
  pose(CALIBRATION_STEP2_X - 1.3, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  key('space', false)
  key('d', false)
  engine_step(1)
  return player.state == 'hang'
end

check('reached hang for the drop test', get_hang(), true)
key('s', true)
key('space', true)
engine_step(1)
check('hang + down + jump -> fall', player.state, 'fall')
check('hang lockout after the drop (s)', player.hang_lock, T.hang_lockout, 0.02)
key('s', false)
key('d', true)                                    -- hold BACK into the wall
local regrabbed = false
for _ = 1, 9 do                                   -- 9 frames = 0.15 s, the lockout
  engine_step(1)
  if player.state == 'hang' then regrabbed = true end
end
check('no grab possible during the 0.15 s lockout', regrabbed, false)
release_all()

check('reached hang for the mantle test', get_hang(), true)
key('space', true)
engine_step(1)
key('space', false)
step_until(function() return player.state == 'stand' end, 60)
check('hang + jump -> climb_up -> stand', player.state, 'stand')
check('  standing on top of the corner tile (y)', player.y, 10 - D.hh, 0.02)
check('  standing over the corner tile (x)', player.x, CALIBRATION_STEP2_X + 0.5, 0.02)
release_all()

-- ── 7. crouch to a lip, then lower-off ─────────────────────────────────────
line('--- lower-off ---')
fresh('calibration')
local pit1 = CALIBRATION_PITS[1]
pose(pit1.x - 2.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
key('d', true)
local lip_x, lip_frame, lower_frame, hang_frame = nil, nil, nil, nil
for i = 1, 240 do
  engine_step(1)
  if not lip_x and player.state == 'crouch' and at_lip(player, 1) then
    lip_x, lip_frame = player.x, i
  end
  if not lower_frame and player.state == 'lower_off' then lower_frame = i end
  if not hang_frame and player.state == 'hang' then hang_frame = i break end
end
check('crawl stops at the lip (box right edge)', (lip_x or 0) + D.hw, pit1.x, 0.03)
check('holding toward the drop enters lower_off', lower_frame ~= nil, true)
check('lower_off ends in hang', hang_frame ~= nil, true)
if lip_frame and lower_frame then
  check('hold before lower_off (s)', (lower_frame - lip_frame)/60, T.lower_off_hold, 0.05)
end
release_all()

-- ── 8. rope throws ─────────────────────────────────────────────────────────
line('--- ropes ---')
fresh('calibration')
pose(CALIBRATION_ROPE8_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 8-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 8)
  check('  segments unrolled', rope_length_of(ropes[1]), T.rope_length)
  check('  ropes left', player.ropes, T.rope_count - 1)
else
  check('rope up under the 8-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(CALIBRATION_ROPE4_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 4-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 4)
  check('  unrolls until the floor (segments)', rope_length_of(ropes[1]), 4)
else
  check('rope up under the 4-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(pit1.x - D.hw, GROUND_Y, 'stand')     -- box right edge exactly on the lip
player.facing = 1
engine_step(2)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down at a lip: anchor column (one ahead)', ropes[1].col, pit1.x)
  check('  anchor row = the thrower height', ropes[1].top_ty, CALIBRATION_GROUND - 1)
else
  check('rope down at a lip placed a rope', false, true)
end
release_all()

check('reached hang for the rope-down test', get_hang(), true)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down from a hang: anchor column', ropes[1].col, CALIBRATION_STEP2_X - 1)
  check('  anchor row = the hang row', ropes[1].top_ty, player.hang_ty)
else
  check('rope down from a hang placed a rope', false, true)
end
release_all()

-- ── 9. catching a rope mid-fall ────────────────────────────────────────────
line('--- rope catch ---')
local function rope_in_pit()
  fresh('calibration')
  local r = rope_place(deep.x + 2, CALIBRATION_GROUND + 6)
  r.bottom_ty = r.top_ty + T.rope_length - 1
  r.phase = 'set'
  pose(deep.x + 2 + 0.5, GROUND_Y, 'fall')
  ropes = {r}
  return r
end

local r1 = rope_in_pit()
key('w', true)
step_until(function() return player.state == 'rope' end, 200)
check('falling past a rope while holding up -> rope', player.state, 'rope')
check('  fall counter zeroed', player.fall_time, 0, 1e-9)
local caught_at = player.y
line(string.format('       caught at y %.2f (rope rows %d..%d)', caught_at, r1.top_ty, r1.bottom_ty))

-- 10. jumping off the rope with a direction held
key('w', false)
key('d', true)
engine_step(1)
tap_key('space')
engine_step(1)
check('jump off a rope with a direction: sideways kick', player.last_rope_kick, T.rope_jump_kick, 0.01)
check('  rope lockout after a jump-off (s)', player.rope_lock, T.rope_lockout_jump, 0.05)
release_all()

rope_in_pit()
step_until(function() return on_ground(player) or player.state == 'dead' end, 300)
check('falling past a rope WITHOUT holding up -> no catch', player.state ~= 'rope', true)
release_all()

-- ── 10. hot-reload probe (value only; the reload itself is driven outside) ──
line('--- tuning ---')
line(string.format('       jump v0 %.4f tiles/s, gravity ramp starts at %.4f of full',
                   D.jump_v0, D.jump_ramp_from))
line(string.format('       solved apexes: tap %.4f, held %.4f (targets %.2f / %.2f)',
                   D.jump_apex_tap_actual, D.jump_apex_held_actual,
                   T.jump_apex_tap, T.jump_apex_held))
line(string.format('       T.walk_speed is currently %.3f', T.walk_speed))

-- ── done ───────────────────────────────────────────────────────────────────
release_all()
fresh('calibration')

local report = string.format('verify: %d passed, %d failed\n', pass_n, fail_n) ..
               table.concat(R, '\n') .. '\n'
print(report)
if io and io.open then
  local f = io.open('tools/verify-report.txt', 'w')
  if f then f:write(report) f:close() end
end
return report

29. script tools\verify.lua
--[[
  tools/verify.lua — the lab's assertion run.

  Run it against a live agent instance:

    anchor drive start lab
    anchor drive eval  lab --file tools/verify.lua
    anchor drive stop  lab

  It drives the real controller through the real input pump
  (input_inject_key -> the SDL queue -> input_pressed inside update), steps the
  engine, and prints every measured value next to its target. Poses are set
  directly (player.x = ...) ONLY to put the character somewhere; nothing about
  the controller's behaviour is faked.

  The one exception is `lab_jump_hold_ticks`, which forces the jump button to
  read as released after N ticks: a rendered frame is two ticks, so a 1-tick
  tap cannot otherwise be scripted. The 2-tick tap is measured as well, by
  pure key injection, and both are reported.

  Returns the report as a string (the eval channel prints it) and also writes
  it to tools/verify-report.txt.
]]

local R = {}
local pass_n, fail_n = 0, 0

local function line(s) R[#R + 1] = s end

local function check(name, measured, target, tol)
  local ok
  if tol then ok = math.abs(measured - target) <= tol else ok = (measured == target) end
  if ok then pass_n = pass_n + 1 else fail_n = fail_n + 1 end
  local m = (type(measured) == 'number') and string.format('%.4g', measured) or tostring(measured)
  local t = (type(target) == 'number') and string.format('%.4g', target) or tostring(target)
  line(string.format('%-4s %-46s measured %-12s target %s%s',
    ok and 'PASS' or 'FAIL', name, m, t, tol and string.format(' +-%.3g', tol) or ''))
  return ok
end

-- ── input plumbing ─────────────────────────────────────────────────────────
local held = {}
local function key(name, down)
  if held[name] == down then return end
  held[name] = down
  input_inject_key(name, down)
end
local function release_all()
  for k, v in pairs(held) do
    if v then input_inject_key(k, false) end
    held[k] = false
  end
  engine_step(1)
end
local function tap_key(name)
  key(name, true)
  engine_step(1)
  key(name, false)
end

-- ── pose plumbing ──────────────────────────────────────────────────────────
local function pose(x, y, state)
  local p = player
  p.x, p.y = x, y
  p.vx, p.vy = 0, 0
  p.state = state or 'fall'
  p.crouched = false
  p.hp, p.ropes = T.hp, T.rope_count
  p.hang_lock, p.rope_lock, p.buffer, p.coyote = 0, 0, 0, 0
  p.jump_hold, p.jump_hold_t, p.jump_hold_ticks = false, 0, 0
  p.jump_apex, p.jump_from_y = 0, y
  p.lower_hold, p.peek, p.peek_hold = 0, 0, 0
  p.last_land_h, p.last_land_dmg, p.last_land_t = 0, 0, 0
  p.last_rope_kick = 0
  p.rope = nil
  fall_reset(p)
  ropes = {}
  hurt_flash = 0
  camera_snap()
end

local function fresh(room)
  release_all()
  room_load(room or 'calibration')
  engine_step(1)
end

-- Step frame by frame until pred() or n frames have passed. Returns frames used.
local function step_until(pred, n)
  for i = 1, n do
    engine_step(1)
    if pred() then return i end
  end
  return n
end

local GROUND_Y = CALIBRATION_GROUND - D.hh   -- centre y of a character standing on the surface

-- ── 1. jump apexes ─────────────────────────────────────────────────────────
line('--- jump ---')
fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(70)
key('space', false)
check('held jump apex (tiles)', player.jump_apex, T.jump_apex_held, 0.03)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
lab_jump_hold_ticks = 1
key('space', true)
engine_step(70)
key('space', false)
lab_jump_hold_ticks = nil
check('tap jump apex, released after 1 tick', player.jump_apex, T.jump_apex_tap, 0.05)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(1)                -- one rendered frame = two ticks
key('space', false)
engine_step(70)
check('tap jump apex, released after 2 ticks', player.jump_apex, T.jump_apex_tap, 0.09)
release_all()

-- ── 2. speeds ──────────────────────────────────────────────────────────────
line('--- speeds ---')
local function speed_test(name, keys, target, tol)
  fresh('calibration')
  pose(2.5, GROUND_Y, 'stand')
  engine_step(3)
  for _, k in ipairs(keys) do key(k, true) end
  engine_step(40)
  local vx = player.vx
  release_all()
  check(name, vx, target, tol)
end
speed_test('walk speed (tiles/s)',  {'d'},            T.walk_speed,  0.05)
speed_test('run speed (tiles/s)',   {'d', 'lshift'},  T.run_speed,   0.1)
speed_test('crawl speed (tiles/s)', {'d', 's'},       T.crawl_speed, 0.05)

-- ── 3. terminal velocity ───────────────────────────────────────────────────
line('--- terminal velocity ---')
fresh('calibration')
local deep = CALIBRATION_PITS[#CALIBRATION_PITS]
pose(deep.x + 2, GROUND_Y, 'fall')
engine_step(40)               -- 0.67 s: terminal is reached at 0.36 s
check('terminal velocity (tiles/s)', player.vy, T.terminal_velocity, 0.1)

-- ── 4. fall damage tiers ───────────────────────────────────────────────────
line('--- fall damage (walk-off into the calibration pits) ---')
local function pit_test(depth, expect_dmg)
  local pit
  for _, q in ipairs(CALIBRATION_PITS) do if q.d == depth then pit = q end end
  fresh('calibration')
  pose(pit.x + 2, GROUND_Y, 'fall')
  step_until(function() return on_ground(player) or player.state == 'dead' end, 400)
  engine_step(2)
  local dmg = player.last_land_dmg
  local h = player.last_land_h
  check(string.format('%d-tile pit: damage', depth), dmg, expect_dmg)
  line(string.format('       equivalent height measured %.3f tiles (pit is %d), hp now %d',
                     h, depth, player.hp))
end
pit_test(7, 0)
pit_test(8, 1)
pit_test(16, 2)
pit_test(24, 99)
check('24-tile pit kills', player.state, 'dead')

-- ── 5. ledge grab: the 2-tile step yes, the 3-tile step no ─────────────────
line('--- ledge grab ---')
local function step_grab(x_left, label)
  fresh('calibration')
  pose(x_left, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)             -- walk into the face
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  local st = player.state
  release_all()
  return st, label
end
local st2 = step_grab(CALIBRATION_STEP2_X - 1.3, '2-tile')
check('standing jump at the 2-tile step -> hang', st2, 'hang')
local st3 = step_grab(CALIBRATION_STEP3_X - 1.3, '3-tile')
check('standing jump at the 3-tile step -> not hang', st3 ~= 'hang', true)

-- ── 6. from hang: drop, and the lockout; then the mantle ───────────────────
line('--- hang ---')
local function get_hang()
  fresh('calibration')
  pose(CALIBRATION_STEP2_X - 1.3, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  key('space', false)
  key('d', false)
  engine_step(1)
  return player.state == 'hang'
end

check('reached hang for the drop test', get_hang(), true)
key('s', true)
key('space', true)
engine_step(1)
check('hang + down + jump -> fall', player.state, 'fall')
check('hang lockout after the drop (s)', player.hang_lock, T.hang_lockout, 0.02)
key('s', false)
key('d', true)                                    -- hold BACK into the wall
local regrabbed = false
for _ = 1, 9 do                                   -- 9 frames = 0.15 s, the lockout
  engine_step(1)
  if player.state == 'hang' then regrabbed = true end
end
check('no grab possible during the 0.15 s lockout', regrabbed, false)
release_all()

check('reached hang for the mantle test', get_hang(), true)
key('space', true)
engine_step(1)
key('space', false)
step_until(function() return player.state == 'stand' end, 60)
check('hang + jump -> climb_up -> stand', player.state, 'stand')
check('  standing on top of the corner tile (y)', player.y, 10 - D.hh, 0.02)
check('  standing over the corner tile (x)', player.x, CALIBRATION_STEP2_X + 0.5, 0.02)
release_all()

-- ── 7. crouch to a lip, then lower-off ─────────────────────────────────────
line('--- lower-off ---')
fresh('calibration')
local pit1 = CALIBRATION_PITS[1]
pose(pit1.x - 2.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
key('d', true)
local lip_x, lip_frame, lower_frame, hang_frame = nil, nil, nil, nil
for i = 1, 240 do
  engine_step(1)
  if not lip_x and player.state == 'crouch' and at_lip(player, 1) then
    lip_x, lip_frame = player.x, i
  end
  if not lower_frame and player.state == 'lower_off' then lower_frame = i end
  if not hang_frame and player.state == 'hang' then hang_frame = i break end
end
check('crawl stops at the lip (box right edge)', (lip_x or 0) + D.hw, pit1.x, 0.03)
check('holding toward the drop enters lower_off', lower_frame ~= nil, true)
check('lower_off ends in hang', hang_frame ~= nil, true)
if lip_frame and lower_frame then
  check('hold before lower_off (s)', (lower_frame - lip_frame)/60, T.lower_off_hold, 0.05)
end
release_all()

-- ── 8. rope throws ─────────────────────────────────────────────────────────
line('--- ropes ---')
fresh('calibration')
pose(CALIBRATION_ROPE8_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 8-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 8)
  check('  segments unrolled', rope_length_of(ropes[1]), T.rope_length)
  check('  ropes left', player.ropes, T.rope_count - 1)
else
  check('rope up under the 8-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(CALIBRATION_ROPE4_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 4-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 4)
  check('  unrolls until the floor (segments)', rope_length_of(ropes[1]), 4)
else
  check('rope up under the 4-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(pit1.x - D.hw, GROUND_Y, 'stand')     -- box right edge exactly on the lip
player.facing = 1
engine_step(2)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down at a lip: anchor column (one ahead)', ropes[1].col, pit1.x)
  check('  anchor row = the thrower height', ropes[1].top_ty, CALIBRATION_GROUND - 1)
else
  check('rope down at a lip placed a rope', false, true)
end
release_all()

check('reached hang for the rope-down test', get_hang(), true)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down from a hang: anchor column', ropes[1].col, CALIBRATION_STEP2_X - 1)
  check('  anchor row = the hang row', ropes[1].top_ty, player.hang_ty)
else
  check('rope down from a hang placed a rope', false, true)
end
release_all()

-- ── 9. catching a rope mid-fall ────────────────────────────────────────────
line('--- rope catch ---')
local function rope_in_pit()
  fresh('calibration')
  local r = rope_place(deep.x + 2, CALIBRATION_GROUND + 6)
  r.bottom_ty = r.top_ty + T.rope_length - 1
  r.phase = 'set'
  pose(deep.x + 2 + 0.5, GROUND_Y, 'fall')
  ropes = {r}
  return r
end

local r1 = rope_in_pit()
key('w', true)
step_until(function() return player.state == 'rope' end, 200)
check('falling past a rope while holding up -> rope', player.state, 'rope')
check('  fall counter zeroed', player.fall_time, 0, 1e-9)
local caught_at = player.y
line(string.format('       caught at y %.2f (rope rows %d..%d)', caught_at, r1.top_ty, r1.bottom_ty))

-- 10. jumping off the rope with a direction held
key('w', false)
key('d', true)
engine_step(1)
tap_key('space')
engine_step(1)
check('jump off a rope with a direction: sideways kick', player.last_rope_kick, T.rope_jump_kick, 0.01)
check('  rope lockout after a jump-off (s)', player.rope_lock, T.rope_lockout_jump, 0.05)
release_all()

rope_in_pit()
step_until(function() return on_ground(player) or player.state == 'dead' end, 300)
check('falling past a rope WITHOUT holding up -> no catch', player.state ~= 'rope', true)
release_all()

-- ── 11. coyote time, the low corridor, peek, restart ───────────────────────
line('--- misc ---')
fresh('calibration')
pose(pit1.x - 1.2, GROUND_Y, 'stand')
engine_step(3)
key('d', true)
step_until(function() return player.state == 'fall' end, 120)
tap_key('space')                                  -- inside the 0.08 s coyote window
engine_step(1)
check('coyote jump just after walking off a lip', player.state, 'jump')
release_all()

fresh('calibration')
pose(45.5, GROUND_Y, 'stand')
engine_step(3)
key('d', true)
engine_step(150)
check('walks through the 1-tile corridor (x past 57)', player.x > 57, true)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
engine_step(60)                                   -- 1 s: 0.4 s delay then 0.6 s of scroll
check('peek down after peek_delay (tiles)', player.peek, (1 - T.peek_delay)*T.peek_speed, 0.1)
release_all()

fresh('calibration')
pose(deep.x + 2, GROUND_Y, 'fall')
step_until(function() return player.state == 'dead' end, 400)
check('death in the deepest pit', player.state, 'dead')
tap_key('r')
engine_step(2)
check('R restarts the room', player.hp, T.hp)
check('  and leaves the dead state', player.state ~= 'dead', true)
release_all()

-- ── 10. hot-reload probe (value only; the reload itself is driven outside) ──
line('--- tuning ---')
line(string.format('       jump v0 %.4f tiles/s, gravity ramp starts at %.4f of full',
                   D.jump_v0, D.jump_ramp_from))
line(string.format('       solved apexes: tap %.4f, held %.4f (targets %.2f / %.2f)',
                   D.jump_apex_tap_actual, D.jump_apex_held_actual,
                   T.jump_apex_tap, T.jump_apex_held))
line(string.format('       T.walk_speed is currently %.3f', T.walk_speed))

-- ── done ───────────────────────────────────────────────────────────────────
release_all()
fresh('calibration')

local report = string.format('verify: %d passed, %d failed\n', pass_n, fail_n) ..
               table.concat(R, '\n') .. '\n'
print(report)
if io and io.open then
  local f = io.open('tools/verify-report.txt', 'w')
  if f then f:write(report) f:close() end
end
return report

30. script tools\verify.lua
--[[
  tools/verify.lua — the lab's assertion run.

  Run it against a live agent instance:

    anchor drive start lab
    anchor drive eval  lab --file tools/verify.lua
    anchor drive stop  lab

  It drives the real controller through the real input pump
  (input_inject_key -> the SDL queue -> input_pressed inside update), steps the
  engine, and prints every measured value next to its target. Poses are set
  directly (player.x = ...) ONLY to put the character somewhere; nothing about
  the controller's behaviour is faked.

  The one exception is `lab_jump_hold_ticks`, which forces the jump button to
  read as released after N ticks: a rendered frame is two ticks, so a 1-tick
  tap cannot otherwise be scripted. The 2-tick tap is measured as well, by
  pure key injection, and both are reported.

  Returns the report as a string (the eval channel prints it) and also writes
  it to tools/verify-report.txt.
]]

local R = {}
local pass_n, fail_n = 0, 0

local function line(s) R[#R + 1] = s end

local function check(name, measured, target, tol)
  local ok
  if tol then ok = math.abs(measured - target) <= tol else ok = (measured == target) end
  if ok then pass_n = pass_n + 1 else fail_n = fail_n + 1 end
  local m = (type(measured) == 'number') and string.format('%.4g', measured) or tostring(measured)
  local t = (type(target) == 'number') and string.format('%.4g', target) or tostring(target)
  line(string.format('%-4s %-46s measured %-12s target %s%s',
    ok and 'PASS' or 'FAIL', name, m, t, tol and string.format(' +-%.3g', tol) or ''))
  return ok
end

-- ── input plumbing ─────────────────────────────────────────────────────────
local held = {}
local function key(name, down)
  if held[name] == down then return end
  held[name] = down
  input_inject_key(name, down)
end
local function release_all()
  for k, v in pairs(held) do
    if v then input_inject_key(k, false) end
    held[k] = false
  end
  engine_step(1)
end
local function tap_key(name)
  key(name, true)
  engine_step(1)
  key(name, false)
end

-- ── pose plumbing ──────────────────────────────────────────────────────────
local function pose(x, y, state)
  local p = player
  p.x, p.y = x, y
  p.vx, p.vy = 0, 0
  p.state = state or 'fall'
  p.crouched = false
  p.hp, p.ropes = T.hp, T.rope_count
  p.hang_lock, p.rope_lock, p.buffer, p.coyote = 0, 0, 0, 0
  p.jump_hold, p.jump_hold_t, p.jump_hold_ticks = false, 0, 0
  p.jump_apex, p.jump_from_y = 0, y
  p.lower_hold, p.peek, p.peek_hold = 0, 0, 0
  p.last_land_h, p.last_land_dmg, p.last_land_t = 0, 0, 0
  p.last_rope_kick = 0
  p.rope = nil
  fall_reset(p)
  ropes = {}
  hurt_flash = 0
  camera_snap()
end

local function fresh(room)
  release_all()
  room_load(room or 'calibration')
  engine_step(1)
end

-- Step frame by frame until pred() or n frames have passed. Returns frames used.
local function step_until(pred, n)
  for i = 1, n do
    engine_step(1)
    if pred() then return i end
  end
  return n
end

local GROUND_Y = CALIBRATION_GROUND - D.hh   -- centre y of a character standing on the surface

-- ── 1. jump apexes ─────────────────────────────────────────────────────────
line('--- jump ---')
fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(70)
key('space', false)
check('held jump apex (tiles)', player.jump_apex, T.jump_apex_held, 0.03)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
lab_jump_hold_ticks = 1
key('space', true)
engine_step(70)
key('space', false)
lab_jump_hold_ticks = nil
check('tap jump apex, released after 1 tick', player.jump_apex, T.jump_apex_tap, 0.05)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('space', true)
engine_step(1)                -- one rendered frame = two ticks
key('space', false)
engine_step(70)
check('tap jump apex, released after 2 ticks', player.jump_apex, T.jump_apex_tap, 0.09)
release_all()

-- ── 2. speeds ──────────────────────────────────────────────────────────────
line('--- speeds ---')
local function speed_test(name, keys, target, tol)
  fresh('calibration')
  pose(2.5, GROUND_Y, 'stand')
  engine_step(3)
  for _, k in ipairs(keys) do key(k, true) end
  engine_step(40)
  local vx = player.vx
  release_all()
  check(name, vx, target, tol)
end
speed_test('walk speed (tiles/s)',  {'d'},            T.walk_speed,  0.05)
speed_test('run speed (tiles/s)',   {'d', 'lshift'},  T.run_speed,   0.1)
speed_test('crawl speed (tiles/s)', {'d', 's'},       T.crawl_speed, 0.05)

-- ── 3. terminal velocity ───────────────────────────────────────────────────
line('--- terminal velocity ---')
fresh('calibration')
local deep = CALIBRATION_PITS[#CALIBRATION_PITS]
pose(deep.x + 2, GROUND_Y, 'fall')
engine_step(40)               -- 0.67 s: terminal is reached at 0.36 s
check('terminal velocity (tiles/s)', player.vy, T.terminal_velocity, 0.1)

-- ── 4. fall damage tiers ───────────────────────────────────────────────────
line('--- fall damage (walk-off into the calibration pits) ---')
local function pit_test(depth, expect_dmg)
  local pit
  for _, q in ipairs(CALIBRATION_PITS) do if q.d == depth then pit = q end end
  fresh('calibration')
  pose(pit.x + 2, GROUND_Y, 'fall')
  step_until(function() return on_ground(player) or player.state == 'dead' end, 400)
  engine_step(2)
  local dmg = player.last_land_dmg
  local h = player.last_land_h
  check(string.format('%d-tile pit: damage', depth), dmg, expect_dmg)
  line(string.format('       equivalent height measured %.3f tiles (pit is %d), hp now %d',
                     h, depth, player.hp))
end
pit_test(7, 0)
pit_test(8, 1)
pit_test(16, 2)
pit_test(24, 99)
check('24-tile pit kills', player.state, 'dead')

-- ── 5. ledge grab: the 2-tile step yes, the 3-tile step no ─────────────────
line('--- ledge grab ---')
local function step_grab(x_left, label)
  fresh('calibration')
  pose(x_left, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)             -- walk into the face
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  local st = player.state
  release_all()
  return st, label
end
local st2 = step_grab(CALIBRATION_STEP2_X - 1.3, '2-tile')
check('standing jump at the 2-tile step -> hang', st2, 'hang')
local st3 = step_grab(CALIBRATION_STEP3_X - 1.3, '3-tile')
check('standing jump at the 3-tile step -> not hang', st3 ~= 'hang', true)

-- ── 6. from hang: drop, and the lockout; then the mantle ───────────────────
line('--- hang ---')
local function get_hang()
  fresh('calibration')
  pose(CALIBRATION_STEP2_X - 1.3, GROUND_Y, 'stand')
  engine_step(3)
  key('d', true)
  engine_step(10)
  key('space', true)
  step_until(function() return player.state == 'hang' end, 60)
  key('space', false)
  key('d', false)
  engine_step(1)
  return player.state == 'hang'
end

check('reached hang for the drop test', get_hang(), true)
key('s', true)
key('space', true)
engine_step(1)
check('hang + down + jump -> fall', player.state, 'fall')
check('hang lockout after the drop (s)', player.hang_lock, T.hang_lockout, 0.02)
key('s', false)
key('d', true)                                    -- hold BACK into the wall
local regrabbed = false
for _ = 1, 9 do                                   -- 9 frames = 0.15 s, the lockout
  engine_step(1)
  if player.state == 'hang' then regrabbed = true end
end
check('no grab possible during the 0.15 s lockout', regrabbed, false)
release_all()

check('reached hang for the mantle test', get_hang(), true)
key('space', true)
engine_step(1)
key('space', false)
step_until(function() return player.state == 'stand' end, 60)
check('hang + jump -> climb_up -> stand', player.state, 'stand')
check('  standing on top of the corner tile (y)', player.y, 10 - D.hh, 0.02)
check('  standing over the corner tile (x)', player.x, CALIBRATION_STEP2_X + 0.5, 0.02)
release_all()

-- ── 7. crouch to a lip, then lower-off ─────────────────────────────────────
line('--- lower-off ---')
fresh('calibration')
local pit1 = CALIBRATION_PITS[1]
pose(pit1.x - 2.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
key('d', true)
local lip_x, lip_frame, lower_frame, hang_frame = nil, nil, nil, nil
for i = 1, 240 do
  engine_step(1)
  if not lip_x and player.state == 'crouch' and at_lip(player, 1) then
    lip_x, lip_frame = player.x, i
  end
  if not lower_frame and player.state == 'lower_off' then lower_frame = i end
  if not hang_frame and player.state == 'hang' then hang_frame = i break end
end
check('crawl stops at the lip (box right edge)', (lip_x or 0) + D.hw, pit1.x, 0.03)
check('holding toward the drop enters lower_off', lower_frame ~= nil, true)
check('lower_off ends in hang', hang_frame ~= nil, true)
if lip_frame and lower_frame then
  check('hold before lower_off (s)', (lower_frame - lip_frame)/60, T.lower_off_hold, 0.05)
end
release_all()

-- ── 8. rope throws ─────────────────────────────────────────────────────────
line('--- ropes ---')
fresh('calibration')
pose(CALIBRATION_ROPE8_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 8-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 8)
  check('  segments unrolled', rope_length_of(ropes[1]), T.rope_length)
  check('  ropes left', player.ropes, T.rope_count - 1)
else
  check('rope up under the 8-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(CALIBRATION_ROPE4_X + 0.5, GROUND_Y, 'stand')
engine_step(3)
tap_key('e')
step_until(function() return ropes[1] and ropes[1].phase == 'set' end, 120)
if ropes[1] then
  check('rope up under the 4-tile ceiling: anchor row',
        ropes[1].top_ty, CALIBRATION_GROUND - 4)
  check('  unrolls until the floor (segments)', rope_length_of(ropes[1]), 4)
else
  check('rope up under the 4-tile ceiling', false, true)
end
release_all()

fresh('calibration')
pose(pit1.x - D.hw, GROUND_Y, 'stand')     -- box right edge exactly on the lip
player.facing = 1
engine_step(2)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down at a lip: anchor column (one ahead)', ropes[1].col, pit1.x)
  check('  anchor row = the thrower height', ropes[1].top_ty, CALIBRATION_GROUND - 1)
else
  check('rope down at a lip placed a rope', false, true)
end
release_all()

check('reached hang for the rope-down test', get_hang(), true)
key('s', true)
tap_key('e')
engine_step(2)
if ropes[1] then
  check('rope down from a hang: anchor column', ropes[1].col, CALIBRATION_STEP2_X - 1)
  check('  anchor row = the hang row', ropes[1].top_ty, player.hang_ty)
else
  check('rope down from a hang placed a rope', false, true)
end
release_all()

-- ── 9. catching a rope mid-fall ────────────────────────────────────────────
line('--- rope catch ---')
local function rope_in_pit()
  fresh('calibration')
  local r = rope_place(deep.x + 2, CALIBRATION_GROUND + 6)
  r.bottom_ty = r.top_ty + T.rope_length - 1
  r.phase = 'set'
  pose(deep.x + 2 + 0.5, GROUND_Y, 'fall')
  ropes = {r}
  return r
end

local r1 = rope_in_pit()
key('w', true)
step_until(function() return player.state == 'rope' end, 200)
check('falling past a rope while holding up -> rope', player.state, 'rope')
check('  fall counter zeroed', player.fall_time, 0, 1e-9)
local caught_at = player.y
line(string.format('       caught at y %.2f (rope rows %d..%d)', caught_at, r1.top_ty, r1.bottom_ty))

-- 10. jumping off the rope with a direction held
key('w', false)
key('d', true)
engine_step(1)
tap_key('space')
engine_step(1)
check('jump off a rope with a direction: sideways kick', player.last_rope_kick, T.rope_jump_kick, 0.01)
check('  rope lockout after a jump-off (s)', player.rope_lock, T.rope_lockout_jump, 0.05)
release_all()

rope_in_pit()
step_until(function() return on_ground(player) or player.state == 'dead' end, 300)
check('falling past a rope WITHOUT holding up -> no catch', player.state ~= 'rope', true)
release_all()

-- ── 11. coyote time, the low corridor, peek, restart ───────────────────────
line('--- misc ---')
fresh('calibration')
pose(pit1.x - 1.2, GROUND_Y, 'stand')
engine_step(3)
key('d', true)
step_until(function() return player.state == 'fall' end, 120)
tap_key('space')                                  -- inside the 0.08 s coyote window
engine_step(1)
check('coyote jump just after walking off a lip', player.state, 'jump')
release_all()

fresh('calibration')
pose(45.5, GROUND_Y, 'stand')
engine_step(3)
key('d', true)
engine_step(150)
check('walks through the 1-tile corridor (x past 57)', player.x > 57, true)
release_all()

fresh('calibration')
pose(4.5, GROUND_Y, 'stand')
engine_step(3)
key('s', true)
engine_step(60)                                   -- 1 s: 0.4 s delay then 0.6 s of scroll
check('peek down after peek_delay (tiles)', player.peek, (1 - T.peek_delay)*T.peek_speed, 0.1)
release_all()

fresh('calibration')
pose(deep.x + 2, GROUND_Y, 'fall')
step_until(function() return player.state == 'dead' end, 400)
check('death in the deepest pit', player.state, 'dead')
tap_key('r')
engine_step(2)
check('R restarts the room', player.hp, T.hp)
check('  and leaves the dead state', player.state ~= 'dead', true)
release_all()

-- ── 10. hot-reload probe (value only; the reload itself is driven outside) ──
line('--- tuning ---')
line(string.format('       jump v0 %.4f tiles/s, gravity ramp starts at %.4f of full',
                   D.jump_v0, D.jump_ramp_from))
line(string.format('       solved apexes: tap %.4f, held %.4f (targets %.2f / %.2f)',
                   D.jump_apex_tap_actual, D.jump_apex_held_actual,
                   T.jump_apex_tap, T.jump_apex_held))
line(string.format('       T.walk_speed is currently %.3f', T.walk_speed))

-- ── done ───────────────────────────────────────────────────────────────────
release_all()
fresh('calibration')

local report = string.format('verify: %d passed, %d failed\n', pass_n, fail_n) ..
               table.concat(R, '\n') .. '\n'
print(report)
if io and io.open then
  local f = io.open('tools/verify-report.txt', 'w')
  if f then f:write(report) f:close() end
end
return report

31. engine_quit()