Stages and gates are what make the (unsound, infinite) search converge

Parent: recursive-harness

The two halves finally weld: the stages-and-gates macro-structure is not another layer — it's the scaffold that makes the unsound, infinitely-branching MCTS search (non-determinism-and-infinite-branching) converge.

The two layers

Micro (inside a stage): MCTS + soft constraints over that stage's world-space (sampling, soft no-goods, satisficing), bounded by P×C.
Macro (stages & gates): the task is chunked into stages; between them sit gates.

A gate = where the soft, stochastic search is committed into a hard, verified result (re-grounding)

Inside a stage the search is unsound (the LLM-as-theory-solver errs; no-goods are soft beliefs). At the gate:

the gate is a verifying checkpoint that collapses the stage's accumulated soft belief into a (mechanically, where possible) checked hard commitment.

passing the gate = commit the stage (a stable sub-assembly, simon-ando); the soft uncertainty is re-grounded here;
the next stage builds on that verified hard result, not carrying the prior stage's soft uncertainty forward.

So the gate is the soft → hard converter. Without gates, the whole task is one long MCTS that accumulates unsound uncertainty → error compounds → drift (exactly necessity's pⁿ, here compounding the search's unsound error).

Why this is what makes a non-convergent search converge

Gates do three convergence-enabling things:

Bound the horizon — each stage is a short search; short searches can satisfice/converge, long ones can't.
Re-ground (stop the compounding) — each gate collapses accumulated soft uncertainty into a hard fact → unsound error does not compound across stages. This is necessity's checkpointing applied to the search's unsound error.
Scope no-goods / backjumps — backjumping stays within the current stage; a passed gate seals prior stages (verified), so backjumping is bounded. (Re-opening a committed stage is possible but expensive/explicit — correctly rare.)

Design principle (forced by the weld)

Put gates at mechanically-verifiable "done"s (the writable seam); between gates, run soft MCTS; the gate converts soft → hard.

more / more mechanical gates → the soft search is re-grounded more often → more convergence;
few / only-semantic gates → soft uncertainty compounds across stages → drift.

This unifies the seams: stage-anatomy (gate = verifiable done) + tacit-spec-as-spec-compression (writable/tacit) + non-determinism-and-infinite-branching (soft/hard) — all one thing: gates go where you can mechanically re-ground the soft search.

× the eight controls (control-methods) — all eight

A convergent recursive harness turns out to use all eight controls — none dispensable, spanning before/during/after/inside:

#1 script — the stage skeleton (script the conserved structure, free the volatile execution);
#2 gate — the gate itself (the soft→hard verifying collapse) — central;
#3 credentialing — verify-before-commit: a soft no-good/belief must prove itself (multi-sample / adversarial check) before being promoted to a hard constraint (non-determinism-and-infinite-branching); also, a candidate method must be qualified/applicable before admission. (Distinct from gate: gate verifies a stage's output; credentialing verifies a learned rule or a method's qualification.)
#4 metering — P×C as budget (horizon bound + deduction-search budget + satisfice);
#5 isolation — tentative branches must run side-effect-confined (sandbox / transaction / snapshot) so backtracking is reversible; effects are released to reality only at the gate (commit). Without it, irreversible side effects make backtracking impossible.
#6 audit — the no-good store / collapse-history / conflict analysis (negative, factual record);
#7 selection — the in-stage MCTS (sample many worlds, explore + evaluate);
#8 incentive-shaping — at an under-determined choice the agent records supplementary preference info so that current info + added info → a unique choice. The task didn't force it (residual ◇); injecting a disposition to break the tie is shaping, recorded for downstream consistency (the "taste = choose a world" of world-choice-and-consistency-gate).

Completeness + diagnostic

A convergent recursive harness is the complete eight-control composition — evidence the eight aren't a loose list but a closed, minimal-complete set. This gives a failure diagnostic: a drifting/stuck harness is missing one control — no isolation → irreversible side effects break backtracking; no credentialing → unverified soft no-goods prune real worlds; no shaping → residual ◇ never pins to one; no audit → re-wandering (drift); etc. Each failure mode ↔ the missing control.

The audit / shaping duality (why both are needed to reach a unique world)

record	control	role
no-good (which combos are incompatible — negative)	#6 audit	deletes inconsistent worlds
supplementary preference (what to prefer when free — positive)	#8 incentive-shaping	pins the remaining freedom to one

Formally (□/◇): constraints + collapse force the determined part into □; the residual ◇ (genuinely free) is what constraints can't pin — and incentive-shaping is exactly what pins it. Collapse alone converges to the consistent set (still many worlds); shaping is needed to converge to a single world.

Two notes: (a) a convergent harness is a composition, not one control. (b) Its weight is on the after/inside half (selection + deep audit + shaping) — exactly the half StandMeet was thin on (eight-controls-applied). This machine is the "make-it-better" half of the controls turned into a convergence engine, scaffolded by script + gate + metering.

Revisited — under the theory layer

"Gate = soft→hard converter" is now gate-theory: the hard commitment is a δ-neighborhood around a necessary waypoint of the reliable (1−α) success paths — the conversion was never to a point, and both tolerances are priced in P×C.
"More mechanical gates → more convergence" is quantified: mechanical gates have α ≈ 0 and their repair loops are monitored by the residual ratio k̂ (operationalizing-tolerances); "re-grounded more often" = shorter segments = contraction has less error to eat (inexact-contraction).
"Backjumping sealed within the stage" has two refinements: gate-subsumption lets a passed gate also stand in for downstream checks across mechanically-preserved segments (skip B when A + unchanged support covers it); and "re-opening a committed stage — possible but expensive, correctly rare" is now a specified event: it happens exactly when an infeasibility cut arrives from below.

Full stack, one line

Macro: stages-and-gates = a P×C-well-founded scaffold; a gate = a soft→hard verifying collapse. Micro: inside each stage's free zone, LLM-as-policy MCTS + soft constraints. The gate's "this stage is done" = the stage search's P×C stop = the same threshold. Without the scaffold the unsound + infinite MCTS doesn't converge; stages-and-gates chops it into gate-sealed short searches whose unsound error can't compound across stages — that's what makes it converge.