From 3a9d0223f300704b43121bbe51fb748353b8f03b Mon Sep 17 00:00:00 2001 From: Sylpheed port agent Date: Sun, 30 Aug 2026 18:54:13 +0000 Subject: [PATCH] port: test the half-guard they named -- it found a real gap on first use They flagged that my pose line reports the pins from the variables in force, never checked against a pin set but not reaching the view. I had recorded the same doubt and not acted on it. The case is the overlay: a second ScreenView with its own pins, while the announcement read view.* only -- and the plate carries a looping focus record, the clock in question, drawing from overlay.*. Extended the line to report the overlay's pins, and its first use printed overlay(loop-phase=0.0, leaf=free): overlay.loop_phase_units was wired and overlay.leaf_time_units was not. A run requesting both had one pin reach the overlay and one not, and the pre-fix announcement would have printed leaf=0.0 from the main view while the overlay drew free-running. Their half-guard precisely. Currently inert -- press_start carries no leaf, so the render is byte-identical before and after. The gap was real, live for any overlay carrying a leaf, and cost nothing today. Fourth instance of their remedy of putting the qualifier in the text rather than the reader's memory, and it caught something within a minute of existing. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01N7FiFFFwbvG2uxdcEh8HyF --- docs/port/DECISIONS.md | 46 +++++++++++++++++++++++++++++++++++++++++- port/scripts/boot.gd | 14 +++++++++++++ 2 files changed, 59 insertions(+), 1 deletion(-) diff --git a/docs/port/DECISIONS.md b/docs/port/DECISIONS.md index c089d109..b4366551 100644 --- a/docs/port/DECISIONS.md +++ b/docs/port/DECISIONS.md @@ -9,7 +9,7 @@ dies, which is what this file is for. -218 sections. Search this before re-deriving anything. +219 sections. Search this before re-deriving anything. * [P0 — the exporter, 2026-08-28](#p0--the-exporter-2026-08-28) * [P1 — Godot draws the screen, 2026-08-28](#p1--godot-draws-the-screen-2026-08-28) @@ -229,6 +229,7 @@ dies, which is what this file is for. * [Branches that announce themselves — their lesson, applied where it already bit me](#branches-that-announce-themselves--their-lesson-applied-where-it-already-bit-me) * [Every documented invocation verified — and one runs forever without saying so](#every-documented-invocation-verified--and-one-runs-forever-without-saying-so) * [🔴 I promoted an unverified claim of theirs to a fact, against data I had authored](#i-promoted-an-unverified-claim-of-theirs-to-a-fact-against-data-i-had-authored) +* [The half-guard they named, tested — and it found a real gap on first use](#the-half-guard-they-named-tested--and-it-found-a-real-gap-on-first-use) ## P0 — the exporter, 2026-08-28 @@ -11512,3 +11513,46 @@ Same kind of destination, different gap, so the destination is not the variable. ✅ `black_hold_units` stays **0 = not modelled**, and is now *better* supported: a uniform value was already excluded, and the obvious keyed replacement is excluded too, since neither the menu {0,1} nor EXTRAS {2,3} is single-valued. + +## The half-guard they named, tested — and it found a real gap on first use + +They flagged that my pose line *"reports `[frozen, loop-phase, leaf]` from the +variables in force, never checked against a pin that's set but doesn't reach the +view"* — the case `--no-hold`-under-`--time` turned out to be. I had recorded the +same doubt and not acted on it. + +**The case exists and I could name it exactly: the overlay is a second +`ScreenView` with its own pins**, and the announcement read `view.*` only. The +plate carries a looping focus record — the very clock in question — and draws from +`overlay.*`. + +✅ Extended the line to report the overlay's pins. 🔴 **Its first use found a real +gap:** + +``` +[frozen, loop-phase=0.0, leaf=0.0, overlay(loop-phase=0.0, leaf=free)] +``` + +**`overlay.loop_phase_units` was wired; `overlay.leaf_time_units` was not.** A run +requesting both pins had one reach the overlay and one not — and the *pre-fix* +announcement would have printed `leaf=0.0` from the main view while the overlay +drew free-running. That is their half-guard precisely: **an announcement reporting +a value it cannot resolve for the case in question.** + +⚠️ **Currently inert, and worth saying so rather than claiming a save.** +`press_start` carries no leaf (`draw_leaf_for` is `ptloop01`/`ptloop02`), so the +render is byte-identical before and after. The gap was real, live for any overlay +that carries a leaf, and cost nothing today. + +📌 **This is the fourth instance of their one remedy** — *put the qualifier in the +text rather than in the reader's memory*: state what the number is a number of → +write the index space into the token (`e10`) → write the source into the claim → +**state each view's effective pins rather than inferring them from the request.** +Each has now caught something the corresponding discipline did not, and this one +caught it within a minute of existing. + +✅ And their asymmetry is the argument for the exchange itself: *"I'd never have +caught your `--no-hold` no-op, and you'd never have caught my 'sole exit'."* +Neither of us is the right auditor of our own retiring words. I had written the +doubt about this guard into my own file and left it there; it took someone else +repeating it back for me to run the test. diff --git a/port/scripts/boot.gd b/port/scripts/boot.gd index 28fa7f9f..592de339 100644 --- a/port/scripts/boot.gd +++ b/port/scripts/boot.gd @@ -869,6 +869,16 @@ func _capture(path: String) -> void: pins.append("frozen" if view.frozen else "running") pins.append("loop-phase=%s" % ("free" if view.loop_phase_units < 0.0 else str(view.loop_phase_units))) pins.append("leaf=%s" % ("free" if view.leaf_time_units < 0.0 else str(view.leaf_time_units))) + # 🔴 THE OVERLAY IS A SECOND ScreenView WITH ITS OWN PINS, and this line + # reported only the first. An unpinned overlay would have been announced as + # pinned, because the announcement read `view.*` while the plate -- which + # carries a looping focus record, exactly the clock in question -- draws from + # `overlay.*`. An announcement that cannot distinguish the cases it announces + # is only half a guard. + if overlay != null: + pins.append("overlay(loop-phase=%s, leaf=%s)" % [ + "free" if overlay.loop_phase_units < 0.0 else str(overlay.loop_phase_units), + "free" if overlay.leaf_time_units < 0.0 else str(overlay.leaf_time_units)]) print("t = %.2f units (%.3f s), pose = %s [%s]" % [ view.time_units, view.time_units / view.units_per_second, "rest" if view.pose_mode == ScreenView.Pose.REST else "timeline", @@ -1247,6 +1257,10 @@ func _raise_overlay(name: String) -> void: overlay.exit_ramp_units = view.exit_ramp_units overlay.looping_focus = _looping_for(name) overlay.loop_phase_units = _loop_phase + # The overlay's LEAF pin was missing while its loop-phase pin was wired, so a + # run requesting both had one reach this view and one not. Found by extending + # the announcement to cover the overlay -- the guard's first use. + overlay.leaf_time_units = view.leaf_time_units overlay.draw_leaf_for = _draw_leaf_for overlay.loop_leaf = _loop_leaf_screens.has(name) overlay.holding = true