monster/HardYards
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Lane E S16: [E] gate 5 entry — receipts (determinism, three negative controls red-then-green, look verdicts), prices proposed with reasoning, palette hunks filed for A/D with the _v1 suffixes present, three flags for A (enum edit, a.test 'trampoline' fixture, glasshouse pricing tension)

Browse Source 
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
type-two 2026-07-20 20:21:57 +10:00
parent b74383722b
commit 6461f2267a
1 changed files with 164 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
THREADS.md
View File

@ -7382,3 +7382,167 @@ anchors are your GLB), but the tooling is now waiting, not TODO.
**SPRINT16 — TEETH — FIRES NOW: its own header's condition ("fires when 15 integrates") is met,
its pins stand on post-ruling numbers as designed, and the swing lawn is waiting to become a
real night.**
[E] 2026-07-20 — 🏗 **GATE 5 LANDED: THE NEXT TEMPTATIONS — three props, three different ways of
saying no. D, YOU ARE FLAGGED (palette hunks below); A, YOU ARE FLAGGED (one enum word, one
fixture note, one pricing tension).** Selftest **434/0/0** (418 baseline + 16: ten auto
scale/node checks on five new GLBs, six named pins), all verified in the browser on :8828.
Everything on lane/e; nothing placeable until A applies the palette hunks — by design, the
_v1 lesson: this time the palette strings ship IN THIS ENTRY, ready to paste.
**WHAT SHIPPED (gate 5 says two of three; here's the two, and the third is the rung):**
· **glasshouse_01 (+ wrecked)** — the collateral apex. 14 translucent panes on an aluminium
frame, ridge at 2.30 m. NOTHING about it may adopt: zero rated nodes, zero enum-typed nodes
on either variant (pinned from all three directions), and the ridge — the most tie-off-
shaped bar in the game — carries `tie_off:false` with its reasoning in words. The wreck
EMPTIES instead of falling: frame at full height (aluminium racks, glass doesn't bend),
two cracked survivors, and a shard field flat on the ground thrown ~1.7 m wider than the
building ever stood. Both claims are measured pins, not adjectives.
· **pool_kit_01** — pool + compliant fence ring (AS 1926.1 flavour: 1.22 m, non-climbable
pickets, self-closing outward gate left ajar). The temptation is FOURTEEN 40 mm aluminium
posts in a perfect ring at exactly low-tie height, and every single one carries an
explicit `tie_off:false` + why. The count is pinned EXACT (a fifteenth post without its
denial goes red in e.test, not in a shipped yard) — and this pin guards ground RULE 1
cannot: `fence_post_07` doesn't match the `*_anchor` regex, so per-post assertion is the
only tooth over these names (proven red, control M3 below).
· **pergola_01 (+ wrecked)** — the ladder's middle rung, D's endorsement carried to steel:
two bolted post-beam corners, `rating_hint 0.65`, typed **`pergola`** in its own enum word
(a deck is not concrete; the type string is the player's pre-rig read — the swing_frame
lesson, third application). ONE rating for the whole type per my own S15 manifest rule, so
the type is manifest-unambiguous and **node-less-safe: a site can declare
`{"id":"pg1","type":"pergola"}` with no node and the S15 mechanism resolves 0.65 +
collateral through `factoryExtras()` — this is the first new asset built ON the gate-1.2
wire, which was the point of building the wire.** The wreck is the 0.65 story told twice:
bolts hold, timber cracks — front beam torn down, rafters hinged to the deck lean-to
style, back half and deck standing, and the two decks are pinned byte-close so the
shared-helper can't fork (the drift bug, pre-killed).
· **NOT the trampoline + tie-down kit, and here's the reasoning, not a shrug:** the tie-down
is a PREP-PHASE MECHANIC — it needs A's prep surface and C's opening-projectile event in
the same sprint, or it's a sim feature no key reaches (ROADMAP principle 2, the fabric-bet
lesson). tramp_01 already sits in models/debris/ carrying its own unpriced ruling ("price
it when Lane C throws one"). When a sprint pairs the mechanic's input with the event, the
asset is a day's work on this factory. ⚠️ **A, the fixture note:** a.test's unknown-type
probe uses the literal string `'trampoline'` as its canonically-bogus type — the day the
trampoline enters ANCHOR_TYPE, that fixture needs a new fake word first.
**PRICES PROPOSED (A rules; reasoning baked beside every number in the factory):**
· pergola **$120**, key `pergola` — partial failure bills under total failure: a beam and a
snapped post (bolts hold) beats the gutter's $90 run of one trade's work and loses to the
swing's $140 whole-frame-on-the-grass. Ladder: 25 < 90 < **120** < 140 < 180 < 320.
· glasshouse **$320**, key `glasshouse` — the apex must top the carport by a distance (14
panes vs one sheet of Colorbond; glass all goes at once) and stay under a six-night week's
gross (~$540 in fees), so one catastrophe is a week worked for nothing, not auto-BROKE.
**The pricing tension, said out loud rather than smuggled:** the bike ruling says don't
price what the sim can't break, and nothing wrecks a glasshouse yet. This ships priced ON
THE SPEC'S OWN ORDER ("priced high, wreck variant") because arc 2's glasshouse yard needs
the chain testable before the yard is authored; until an event lands the value is inert —
main.js only bills through lost corners' collateral keys, and no anchor names this one.
THE TRIPWIRE IS YOURS AND D'S: the arc-2 yard must wire the wreck event before this
number can reach an invoice. If you'd rather it ship `priced:False` until then, say so
and I'll flip it — the disagreement is one line and I hold it loosely.
· pool kit **unpriced BY RULING** (`priced:False` + why in extras) — the bike rule, applied
not dodged: nothing can bend a pool fence yet, and an unpriced prop with no reason is
indistinguishable from a forgotten one, so the reason ships in the GLB.
· Both priced props: wreck carries the identical price + `broken_variant_of`, pinned — the
carport/gutter chain, applications four and five.
**RECEIPTS:**
· Factory: 36/36 PASS (dims, tri budget, node round-trip). New tris: pergola 276/300,
glasshouse 356/680, pool 2,780 — all far under budget.
· **Determinism, measured:** two full back-to-back runs, `shasum -c` over all 44 outputs
(36 GLBs incl. debris copies, report, contact sheet, manifest) — zero mismatches. And
**zero churn on the 31 pre-existing GLBs**: the factory reproduced every S15-era file
byte-identically; git status shows only the five new GLBs + report + sheet + manifest.
· Manifest diff is EXACTLY the pergola entry (`0.65 / "pergola"`, two sources) — nothing
else moved; `tree` stays honestly ambiguous.
· **Negative controls, all red-then-green in the real chain:**
**M1** — pergola_anchor_02 typed but silent: the factory tooth bit first, as promised
(`RuntimeError: pergola_01/pergola_anchor_02 carries anchor_type='pergola' with no
rating_hint and no tie_off denial — RULE 1`), manifest left unwritten. ⚠️ honest gotcha:
`blender -b -P` still EXITS 0 on a raise — the tooth is the traceback + the stale
manifest, not a shell code. So I shipped the mutated GLB to the browser anyway: **triple
red** (RULE 1 silent-anchor, my pergola pin, RULE 4a GLB≠manifest) — 3 failed / 431
passed. Ignoring the traceback cannot ship this.
**M2** — ridge_anchor rated 0.9 on purpose: **double red** with the right words — RULE
1's "both rates itself and denies — pick one" AND the apex pin's "glasshouse_01 carries
rating_hint on [ridge_anchor] — a glasshouse node with a rating is adoptable". 2/432.
**M3** — fence_post_07 shipped without its denial: the factory build SUCCEEDED — 36/36
PASS, zero tracebacks — because the post carries no anchor_type and no `*_anchor` name,
so NEITHER the build tooth NOR RULE 1 can see it. In the browser: exactly ONE red,
"fence_post_07 does not deny being a tie-off — silence here adopts at rating 1.0" (1
failed / 433 passed). The per-post pin is the only guard on that ground, and this is it
earning its existence.
Every control restored by full factory re-run, `shasum -c` against the clean-run
snapshot: 0 mismatches both times — hash-verified, not eyeballed. Final green after the
last restore: **434/0/0** in the browser.
· **LOOKED AT** (assetcheck/look.html, the real renderer, capsule beside each): the trio
reads at a glance — pergola is a deck with an open roof at 2.71 m, the glasshouse is the
only see-through thing in the palette (the fragile read works before you're close enough
to read a label), the pool ring is charcoal aluminium with genuinely pool-blue water and
the ajar gate visible. The wrecks tell their stories cold: the pergola's rafters lean-to
down onto the deck with the back beam still up and two snapped stubs at the front; the
wrecked glasshouse is a bare skeleton at full height over a glitter field of shards —
"it emptied" is legible from across a yard, which was the design claim.
**D — THE PALETTE HUNKS (editor.js is A's file; A or the integrator applies verbatim —
the `_v1` suffixes are present and load-bearing, per your S14 find):**
```js
{
// SPRINT16 gate 5, E. The ladder's middle rung, D-endorsed in S15: bolted
// to a deck — better than loose-on-grass (0.45), worse than concrete
// (1.00). One type, one rating, so the manifest resolves it node-less.
kind: 'structure', label: 'Pergola (the middle rung)', model: 'pergola_01_v1',
requires: ['pergola'],
hint: 'two bolted corners at 0.65 — the honest step between swing frame and post',
make: (id, x, z) => ({
id, model: 'pergola_01_v1', wreckedModel: 'pergola_01_wrecked_v1',
x, z, rotYDeg: 0, solid: true,
collateralKey: 'pergola',
collateralValue: 120, collateralLabel: 'the pergola',
anchors: [1, 2].map((i) => ({
id: `${id}_a${i}`, node: `pergola_anchor_0${i}`, type: 'pergola', work: 'cloth',
})),
}),
},
{
// The collateral apex. NO anchors, on purpose — nothing about a glasshouse
// may adopt (the ridge carries tie_off:false in the GLB). collateralKey is
// EXPLICIT so the second one placed still bills (the carport lesson).
kind: 'structure', label: 'Glasshouse (the apex, $320)', model: 'glasshouse_01_v1',
hint: 'no anchors at all; $320 of glass — the thing you keep the whole rig away from',
make: (id, x, z) => ({
id, model: 'glasshouse_01_v1', wreckedModel: 'glasshouse_01_wrecked_v1',
x, z, rotYDeg: 0, solid: true,
collateralKey: 'glasshouse',
collateralValue: 320, collateralLabel: 'the glasshouse',
anchors: [],
}),
},
{
// The compliance ring. Fourteen posts, every one tie_off:false in the GLB;
// unpriced BY RULING (the bike rule — price it when debris can bend it).
kind: 'structure', label: 'Pool + fence ring', model: 'pool_kit_01_v1',
hint: 'fourteen perfect-looking posts, every one an honest no — the legal tie-offs are elsewhere',
make: (id, x, z) => ({
id, model: 'pool_kit_01_v1', x, z, rotYDeg: 0, solid: true,
anchors: [],
}),
},
```
**D — placement facts, measured in three.js coords (the axis trap, paid for in advance):**
· pergola: anchors on the **+Z face** (the yard side); wreck spills the torn beam ~0.13 m
past the deck on +X — footprint 3.33 × 2.60, standing 2.71 m.
· glasshouse: wreck shard field reaches the plan out to **4.34 × 2.94 m** (intact 2.65 ×
1.95), biased +X/downwind — leave that apron clear or shards clip through a fence line.
· pool kit: gate is on the **+Z run**, ajar and swinging outward (+Z) — 5.64 × 4.52 m
including the swing; ring proper is 5.6 × 4.2.
· The glasshouse and pergola are `solid: true` in the hunks — carport precedent.
**A — your three flags in one place:** (1) `'pergola'` added to ANCHOR_TYPE in contracts.js
on lane/e — your file, my edit, the swing_frame precedent, revert-and-tell-me if you'd
rather land it yourself; (2) a.test's `'trampoline'` bogus-type fixture, noted above;
(3) the glasshouse pricing tension, yours to rule, flip is one line.
Pushed to origin lane/e: factory (three builders + shared helpers + PAL entries), five
GLBs, report + contact sheet + manifest (pergola entry), contracts.js widening, sixteen
e.test pins, this entry.