[chennyiiis]

What this does

writeback.py was doing three jobs at once: settling a finished task result into
SharedState, ruling on a GEAK end-to-end win, and describing the launch
current_best was measured on. The GEAK ruling now lives in a sibling module of
its own, and every function in both measures under 20 on the Cmetrics scale.

New module	Job
loop/_geak_revalidation.py	Ruling on a GEAK win: the 2b rebench it dispatches and the ruling that rebench earns, and the 2a replay through GEAK's own harness behind it

It is a mixin on WritebackCollaborator, so every call site and every method name
is unchanged. The import graph is a DAG: writeback imports GeakRevalidation
and nothing imports back. An earlier revision also split out
loop/_launch_identity.py and loop/_promote_outcome.py; both were folded back
into writeback.py, so the launch descriptor (_handoff_launch_identity and
friends) and _PromoteOutcome stay there.

src/hyperloom/orchestrator/collaborator.py changes with them.
CoordinatorCollaborator.__init__ now takes coordinator: Any and the borrowed
properties cast(...) to their own types, because naming Coordinator here —
in a module every collaborator in the orchestrator imports — points the package
root back up into loop.coordinator and makes the whole loop package cyclic.
.state loses its CoordinatorState annotation for the same reason. Nothing
executes differently; cast is a no-op at runtime.

The functions that were over the ceiling

Measured on the Cmetrics scale — ruff C901's statement branches plus each
and/or operand past the first, each ternary and each comprehension clause.
"Before" is the value on main at the merge base ac0c2dd97, "After" the value at this head:

Function	Before	After
lift_to_current_best	92	11
_promote_explore	144	19
_promote_baseline	68	19
_promote_integrate_patch	67	19
handle_unpromotable_result	55	19
validate_geak_via_geak_harness	44	14
_replay_keep_from_result	37	11
build_env_spec	36	19
geak_rebench_params	30	5
_recover_pending_integrate_from_task	32	18
_drain_agent_keep_outbox	30	14
_keep_patch_sources	30	5
_resume_recover_orphaned_keeps	30	15
_promote_profile	29	14
_enqueue_agent_keep_outbox	27	17
_resume_recover_pending_integrate	27	14
_persist_eval_failure	23	8
_resume_consistency_pass	24	12
_parse_baseline_workload_extra	22	15
_promote_roofline	22	6
record_integrate_keep	21	17

The 2b ruling this PR's first revision lifted out of _promote_explore was itself
over the ceiling, and is under it now too: _geak_rebench_decision 32 → 13,
_rule_on_geak_rebench 21 → 15.

Each promote path reads as the sequence of decisions it makes — what grading
refuses, what a stack row is attributed to, which recipe delta a KEEP re-applies,
what a failed baseline is charged to, what the anchor run's facts are — rather
than one scroll of nested branches. Values that travel together became named
types (_LiftRequest, _ResolvedLaunch, _GeakProduct, _RebenchEngagement,
_IntegrateMarker, _KeptResultScan, _ExploreLift, _StackKey,
_ReplayRegime, _ReplayOverlay), which is also what brought
_record_geak_rebench_timeline from eight parameters down to five.

Three duplicated or dead mechanisms went with it:

• the profile and roofline handlers each cleared the pending auto-roofline
  pointer twice, under the same condition, in the same call;
• the GEAK 2a "did not validate" summary carried accuracy_failure fields that
  an accuracy failure returns before it can ever reach;
• _promote_baseline guarded two getattr(task, ...) reads with a
  task is not None ternary that could not change their result.

Observable effect

One line of output changes. The GEAK 2a "did not validate" warning no longer
prints an accuracy_failure= field. On that path an accuracy failure returns
before the field can be filled, so an operator reading that warning on main
sees an empty value; they will now see no field at all. Nothing else an operator
can observe changes: no interface, default, flag, artifact, persisted shape or
ordering of effects.

The framework-levers ordering is not a difference against main. An earlier
revision of this PR had _promote_integrate_patch register the patch's levers
before _confirmed_integrate_completion — that check sets the stop reason,
saves the session and raises when a tree recovery is unconfirmed, so the levers
would have been persisted for a patch that resume may roll back, leaving explore
benching switches whose code is no longer on disk. main's order is restored, so
an unconfirmed recovery persists no levers, exactly as it does today.

Merged with current main

main moved while this was in flight. The branch now contains f7f64aceb
(#1984, Remove the accuracy eval opt-out), and the opt-out is gone from the
extracted code as well as from the module: _settle_pending_revalidation — the
helper this PR lifted that check into — rules on accuracy_meets_floor alone,
and disable_run_eval is out of _BASELINE_FINGERPRINT_KEYS. eval_disabled
has no occurrence left in the tree. #1985, #1986, #1918 and #2021 are contained
too; none of them touches any of these files.

Module length

writeback.py goes from 4716 lines on main to 4156, even after adding 91 named
helpers (78 functions on main, 169 across the two modules now), because the
GEAK group moved out. scripts/code_metrics_baseline.txt only loses entries and
lowers values: 31 entries retired, and module-lines .../loop/writeback.py lowered from 4716 to 4156.

_geak_revalidation.py is 818 lines — over the 800-line review trigger, under
the gate's 1200. It stays one module on purpose: an earlier revision had the 2a
harness replay in a file of its own, and that split was wrong in both directions.
The replay is reached only from the 2b ruling and hands its verdict back as a
_ReplayRuling, so the revalidation called into the replay through the mixin
while the replay imported the revalidation's decision vocabulary at module level
— a cycle with the evidence removed, which CodeQL reported as four possibly-
undefined names. Deleting the module removed the cycle, the import and a mixin
class rather than relocating any of them.

Why size-exception

Against main the diff is 2,409 lines added and 2,179 deleted across 4 files,
because one coherent group moved out of writeback.py whole and the rest was
split in place: a moved block counts once as a deletion and once as an addition,
and the two modules together are 258 lines longer than the one they replace
(4156 + 818 = 4974, against 4716 on main). That growth comes with the 91 named helpers that take every
function under the complexity ceiling; neither module reaches the 1,200-line gate.
There is one concern here — bring writeback.py under the complexity ceiling —
and splitting it across PRs would mean landing a module whose functions are still
over it.

Verification

• cc_scan_cmetrics.py 20 prints nothing for writeback.py or
  _geak_revalidation.py: no function in them reaches 20.
• ruff check --select C901 --config "lint.mccabe.max-complexity=20" clean on
  both modules; ruff check / ruff format --check clean.
• The string constants of the new module were compared against main's
  writeback.py value by value, so no literal was caught by a rename.
• Every review comment on this PR has a reply: the geak_result dead store is
  removed, the import cycle between the two GEAK modules is deleted with the
  module, and the remaining py/cyclic-import alerts name imports
  loop/writeback.py already makes on main.

[github-actions]

Code metrics gate: PASSED

Judged: the 4 files this change touches. Files it does not touch never fail it; anything found there is listed under Outside this change for information.

Dimension	Limit	New	Worse	Baseline out of date	Baseline entries	vs base
Cyclomatic complexity	fails > 20	0	0	0	6	-5
Cognitive complexity	fails > 30	0	0	0	54	-11
Function length (lines)	fails > 80	0	0	0	174	-14
Nested block depth	fails > 5	0	0	0	8	+0
Parameter count	fails > 5	0	0	0	82	-1
Module length (lines)	warns > 800, fails > 1200	0	0	0	45	+0
Duplicated lines per file	fails > 0	0	0	0	95	+0
Dead code (vulture)	fails > 0	0	0	0	2	+0

Check	Findings	Effect
Comments	0
English only	0
Production code imports test code	0
Repeated literals	0
A1 Private name of another package	0
A8 Flag argument	0
A9 Tuple return	0
A10 Raw vocabulary comparison	0
A11 Hidden global write	0
A12 Pure forwarder	0
A12 Single-implementation abstraction	0

Module length warning: over 800 lines, within the 1200-line failure limit (not failing): 1

Module	Lines	Limit
src/hyperloom/orchestrator/loop/_geak_revalidation.py	818	warns > 800

67 findings in files this change does not touch

Outside this change (informational): 67

Unit	Dimension	Baseline	Now
src/hyperloom/orchestrator/actions/executors/_integrate_apply.py ApplyStageMixin._stage_apply	Cognitive complexity	absent	32
src/hyperloom_kb/collect/mapping.py _experience	Cognitive complexity	absent	31
src/kernelforge/cli/forge_loop_command.py forge_loop	Cognitive complexity	absent	31
src/kernelforge/loop/runner.py IterationLoop._collect_session_candidate	Cognitive complexity	absent	44
src/kernelforge/loop/runner.py IterationLoop._rule_on_attempt	Cognitive complexity	absent	38
src/hyperloom/orchestrator/phases/kernel.py KernelPhase._record_geak_delegation_timeline	Parameter count	absent	7
src/hyperloom/inference_optimizer/cli/__init__.py _reexport_session_environment	Function length (lines)	absent	107
src/hyperloom/inference_optimizer/cli/__init__.py _resolve_agent_lineup	Function length (lines)	absent	89
src/hyperloom/inference_optimizer/cli/__init__.py _resolve_run_topology	Function length (lines)	absent	92
src/hyperloom/inference_optimizer/multi_node/scripts/launch_multinode.py _build_parser	Function length (lines)	absent	84
src/hyperloom/inference_optimizer/multi_node/scripts/launch_multinode.py _spawn_rank_actors	Function length (lines)	absent	84
src/hyperloom/orchestrator/actions/executors/_integrate_apply.py ApplyStageMixin._stage_apply	Function length (lines)	absent	186
src/hyperloom/orchestrator/actions/executors/_integrate_bench.py BenchStageMixin._bench_patch	Function length (lines)	absent	223
src/hyperloom/orchestrator/actions/executors/_integrate_enablement_gate.py EnablementGateMixin._enablement_keep_records	Function length (lines)	absent	110
src/hyperloom/orchestrator/actions/executors/_integrate_enablement_gate.py EnablementGateMixin._gate_enablement	Function length (lines)	absent	222
src/hyperloom/orchestrator/actions/executors/_integrate_perf_gate.py PerfGateMixin._gate_perf	Function length (lines)	absent	241
src/hyperloom/orchestrator/actions/executors/_integrate_perf_gate.py PerfGateMixin._keep_inert_switches	Function length (lines)	absent	92
src/hyperloom/orchestrator/actions/executors/_integrate_perf_gate.py PerfGateMixin._switch_off_parity	Function length (lines)	absent	116
src/hyperloom/orchestrator/actions/executors/_integrate_resolve.py ResolveStageMixin._stage_provision_attempt_runtime	Function length (lines)	absent	105
src/hyperloom/orchestrator/actions/executors/_integrate_resolve.py ResolveStageMixin._stage_resolve	Function length (lines)	absent	104
src/hyperloom/orchestrator/trace_analysis/_analysis_reports.py write_reports	Function length (lines)	absent	204
src/hyperloom_kb/sync.py GlobalSync.pull	Function length (lines)	absent	84
src/kernelforge/loop/runner.py IterationLoop._close_iteration	Function length (lines)	absent	117
src/kernelforge/loop/runner.py IterationLoop._collect_session_candidate	Function length (lines)	absent	185
src/kernelforge/loop/runner.py IterationLoop._implementer_history	Function length (lines)	absent	112

...and 42 more; the job log lists every row.

Verdict computed by the gate scripts in /home/runner/work/_temp/code-metrics-gate, not by this tree's copy.

_{Thresholds and sources: [tool.hyperloom.code_metrics] in pyproject.toml. Tools: complexipy 8.0.1, jscpd 5.4.1, ruff 0.16.2, vulture 2.16.}

[chennyiiis]

Addressed the CodeQL finding at writeback.py:3018 (geak_result assigned twice).

It is a real dead assignment, and it is the one main already carries — origin/main:writeback.py:2791 has it verbatim; the extraction moved the line and ruff format collapsed it to one, which is why CodeQL reads it as new here. The except branch bound geak_result, and the refusal branch below rebinds it before any read on every path that reaches either, so the first binding was never observable.

Removed. An AST check confirms the first remaining write (L3021) still precedes the first read (L3027).

Verification: pytest across the 7 test files covering the promote and GEAK revalidation paths — 508 passed.

[xiaofei-zheng]

What this PR does

loop/writeback.py had grown to 4717 lines with 21 functions above the repo's complexity ceiling of 20 (_promote_explore at 159, lift_to_current_best at 94), so no further change to it could clear the code-metrics gate. The GEAK-revalidation group — the 2b rebench ruling and the 2a replay through GEAK's own harness — moves into a new loop/_geak_revalidation.py as a GeakRevalidation mixin that WritebackCollaborator inherits; the rest is split in place into ~106 private helpers, with values that already travelled together as locals becoming NamedTuples; orchestrator/collaborator.py drops its TYPE_CHECKING import of Coordinator/CoordinatorState so the loop package stays acyclic.

The behaviour-preservation claim holds everywhere I checked. The depth of that check is at the bottom.

Blocking issues

1. The description describes a revision that no longer exists.

The "New module" table names three new modules; the diff has one. loop/_launch_identity.py and loop/_promote_outcome.py do not exist anywhere in the tree — _PromoteOutcome is at src/hyperloom/orchestrator/loop/writeback.py:384 and _handoff_launch_identity at writeback.py:3057 — and writeback.py:88 imports one mixin, not two, so "the first two are mixins" and the three-node DAG sentence both describe an earlier revision (the commit refactor(writeback): keep the launch descriptor and the promote outcome in writeback is where they went away).

The numbers went stale with it:

Body says	At head
_geak_revalidation.py is 1080 lines	818
writeback.py 4783 on main → 4123	4717 → 4156
"the four files together are shorter than the one they replace"	three files plus the metrics baseline

Both counts are identical under wc -l and under the gate's own len(read_bytes().splitlines()), so no alternate measurement rescues them.

src/hyperloom/orchestrator/collaborator.py is in the diff and the description never mentions it. It is not cosmetic: CoordinatorCollaborator.__init__ now takes coordinator: Any instead of "Coordinator", and .state loses its CoordinatorState return annotation — the type contract every orchestrator collaborator inherits. Nothing executes differently, but the reason for it (breaking the package cycle) is exactly what the description is there to carry.

Action: rewrite the module table, the line counts and the "four files" sentence against head, and state the collaborator.py change and why it was needed.

2. scripts/code_metrics_baseline.txt records a length writeback.py does not have.

scripts/code_metrics_baseline.txt:467 records module-lines src/hyperloom/orchestrator/loop/writeback.py 3972. The file at head is 4156 lines under the collector's own metric (module_lines, scripts/code_metrics_collect.py:310) — the entry understates by 184.

Nothing in CI reports this. The finding at 4156 lands in worsened against the recorded 3972; excuse_base_backlog then measures the same unit at the merge base (4717), concludes the change did not make it worse, and moves it to base_backlog, which is not part of failed. growth passes too, because 3972 against the base baseline's 4717 is a lowering. So the gate is green on a baseline entry 184 lines short of the tree, and the PR cites that bookkeeping as verified ("32 entries retired, 1 lowered"). It matches the same stale revision as the "4123" figure above.

Action: set the entry to 4156.

What was checked

• Complexity ceiling, the PR's whole point: ruff check --select C901 --config "lint.mccabe.max-complexity=20" on writeback.py, _geak_revalidation.py and collaborator.py is clean at head.
• Behaviour preservation, four groups compared line by line against the merge base: lift_to_current_best / build_env_spec / geak_rebench_params / _keep_patch_sources; _promote_explore plus all of _geak_revalidation.py; the five promote handlers plus _persist_eval_failure and _parse_baseline_workload_extra; the resume/recovery group. No undeclared difference found. Three traps verified by hand at head:
  • main computes measured_ok from result["output_throughput"] before measured is rebound to output_tput_of(rebench_measurement); _GeakRebench preserves that split via round_tput (_geak_revalidation.py:402,421).
  • main's geak_fallback branch returns unconditionally (the only return in that block), so _reconcile_revalidated_watermark re-reading result["output_throughput"] is reached only on the native path.
  • _promote_integrate_patch calls _confirmed_integrate_completion (writeback.py:2838) before _record_authored_levers (2839), restoring main's order.
• fix(writeback): report an orphaned framework KEEP under the kind that produced it is a slip introduced and fixed inside this branch: head reports orphan_kind from the payload's own kind, and _orphan_stack_key reproduces main's (stack_action, variant) key including the FRAMEWORK_STACK_ACTION remap — identical to the merge base.
• Programmatic diff of the merge-base writeback.py against the two files at head: no def/class name lost; every numeric literal present with the same value; every string literal present except five docstrings reduced to their summary line and the declared accuracy_failure= field drop in the 2a warning. The one module-level name that moved, _MIN_KERNEL_ENGAGED_GAIN_PCT, is still 2.0 with its one reader.
• GeakRevalidation and WritebackCollaborator share no method name, so the mixin cannot shadow anything; the suites that reach wb._PromoteOutcome, _promote_explore, _handoff_launch_identity and _BASELINE_FINGERPRINT_KEYS still resolve them from loop.writeback.
• CI at head: all 12 test shards, both coverage jobs, ruff, pylint, mypy (advisory), import-linter, CodeQL and code-metrics green.

Base e34bb7afd760de8dd6a60759bb9bf7040b28a9e2, head c95b00ad976da4c4f66c374f8abaaf662cf4f592.

Both findings fixed: baseline entry corrected to 4156 in d51536f, PR description rewritten against head.

[xiaofei-zheng]

Both findings from the previous round are fixed in place rather than handed back:

• scripts/code_metrics_baseline.txt recorded module-lines .../writeback.py 3972 while the file is 4156. Corrected in d51536f. The gate had been excusing the drift as base backlog (merge base 4717), so nothing would have reported it.
• The description's module table, line counts and "four files" sentence described an earlier revision with three new modules. Rewritten against head: one new module, _geak_revalidation.py at 818 lines, writeback.py 4717 → 4156, plus the collaborator.py type change and the cycle it breaks.

No blocking issues. LGTM.

What was checked:

• Complexity ceiling, the PR's whole point: ruff check --select C901 --config "lint.mccabe.max-complexity=20" on writeback.py, _geak_revalidation.py and collaborator.py is clean at head.
• Behaviour preservation, four groups compared line by line against the merge base: lift_to_current_best / build_env_spec / geak_rebench_params / _keep_patch_sources; _promote_explore plus all of _geak_revalidation.py; the five promote handlers plus _persist_eval_failure and _parse_baseline_workload_extra; the resume/recovery group. No undeclared difference. Three traps verified by hand at head:
  • main computes measured_ok from result["output_throughput"] before measured is rebound to output_tput_of(rebench_measurement); _GeakRebench preserves that split via round_tput (_geak_revalidation.py:402,421).
  • main's geak_fallback branch returns unconditionally (the only return in that block), so _reconcile_revalidated_watermark re-reading result["output_throughput"] is reached only on the native path.
  • _promote_integrate_patch calls _confirmed_integrate_completion (writeback.py:2838) before _record_authored_levers (2839), restoring main's order.
• fix(writeback): report an orphaned framework KEEP under the kind that produced it is a slip introduced and fixed inside this branch: head reports orphan_kind from the payload's own kind, and _orphan_stack_key reproduces main's (stack_action, variant) key including the FRAMEWORK_STACK_ACTION remap — identical to the merge base.
• Programmatic diff of the merge-base writeback.py against the two files at head: no def/class name lost; every numeric literal present with the same value; every string literal present except five docstrings reduced to their summary line and the declared accuracy_failure= field drop in the 2a warning. The one module-level name that moved, _MIN_KERNEL_ENGAGED_GAIN_PCT, is still 2.0 with its one reader.
• GeakRevalidation and WritebackCollaborator share no method name, so the mixin cannot shadow anything; the suites that reach wb._PromoteOutcome, _promote_explore, _handoff_launch_identity and _BASELINE_FINGERPRINT_KEYS still resolve them from loop.writeback.
• CI at c95b00a: all 12 test shards, both coverage jobs, ruff, pylint, mypy (advisory), import-linter, CodeQL and code-metrics green. The baseline commit on top touches only scripts/code_metrics_baseline.txt.

Base e34bb7afd760de8dd6a60759bb9bf7040b28a9e2, head d51536fb3.

[xiaofei-zheng]

The two red shards here (test (py3.10 shard 2/6), test (py3.11 shard 4/6)) are inherited from main, not introduced by this PR — but the breakage is yours to fix, so flagging it here.

FAILED src/hyperloom/inference_optimizer/tests/test_coordinator_async_batch2_unit.py::test_a_candidate_after_resume_still_sees_the_kept_source_layer
AttributeError: module 'hyperloom.orchestrator.actions.executors.integrate_patch' has no attribute '_git_head_sha'

Two PRs that landed on main within the same window collide:

• 3122104 (fix(resume): reinstall the kept source patches on a framework tree that lost them #2091) added the test; at test_coordinator_async_batch2_unit.py:559-568 it does from ...executors import integrate_patch as ip and then calls ip._git_head_sha(tree), ip._git_stash_if_dirty(tree), ip._git_reset_clean(tree, accepted_head).
• 8b0ae55 (refactor(integrate-patch): give each stage of an integration attempt a module of its own #2098, yours) split integrate_patch into _patch_git / _git / _integrate_vocabulary / _patch_artifacts / _patch_sources. _git_head_sha now lives in executors/_git.py:55 and integrate_patch no longer re-exports it.

main itself is red: at 8b0ae55 the same two shards fail with the same message, so every PR branching from or merging main after that commit carries it. Fix belongs on main — either re-export the three _git_* names from integrate_patch, or point the test at executors._git / executors._patch_git directly. The second is the one your split argues for.

Nothing else is red on this PR: lint, code-metrics, CodeQL, packaging, import-linter and the other 10 shards pass at 328e404, and the branch is MERGEABLE again after the two main merges.

[chennyiiis]

Confirmed and fixed on main: #2113.

Your read is exact. _git_head_sha is at executors/_git.py:55; _git_stash_if_dirty and _git_reset_clean are in executors/_patch_git.py. I took the second option — the test now imports from the two owning modules. Re-exporting the three names from integrate_patch would reinstate the forwarding layer #2098 removed, which is the thing that split was for.

test_coordinator_async_batch2_unit.py is 185 passed locally on that branch, ruff check and format clean.

Once #2113 is in, I will merge main into this branch so the two shards go green here. Nothing in this PR touched either module.

[chaojhou]

PR #1956 -- refactor(writeback): bring every function in the writeback module under the complexity ceiling

What it does: brings every function in loop/writeback.py under the complexity ceiling of 20. The GEAK 2a/2b revalidation ruling moves into loop/_geak_revalidation.py, a GeakRevalidation mixin on WritebackCollaborator. The rest is split in place into named helpers. collaborator.py drops its Coordinator type import so loop/ stays acyclic. This is a refactor: the only operator-visible change is one warning field, and the description states it.

Status at this head:

• All three findings from my review at 112a442 stay fixed.
• The author's three merges from main keep #2001, #2091 and #2098 in the helpers that now hold that code, in main's order.
• #1845, #2029 and #2075 do not touch the PR's files.
• A trial merge with current main is clean.

Blocking issues: 1

1. [X2] The size-exception justification states numbers the diff contradicts [verified]
   Problem: the "Why size-exception" section says "The diff is ~10k production lines" and "the two modules together are shorter than the one they replace". At this head, src/hyperloom/orchestrator/loop/writeback.py is 4156 lines and src/hyperloom/orchestrator/loop/_geak_revalidation.py is 818, for 4974 in total. At the merge base the file was 4716 lines, so the split adds 258 lines rather than removing any. Production churn is 2408 insertions and 2147 deletions, about 4.5k lines rather than ~10k. The "Module length" section's "32 entries retired, 1 lowered" is 31 retired plus 1 lowered: the 32 removed baseline lines include the lowered entry.
   Impact: this paragraph is the PR's answer to the open review objection about net production growth. The baseline-raise / size exception and the release notes would rest on a size reduction that does not exist.
   Action: rewrite the paragraph against this head: 4974 against 4716 (+258), about 4.5k lines of churn, 31 entries retired and 1 lowered. Then give the reason the net growth is acceptable, or reduce it; ZhengGong-amd asked for each remaining new type to be named with what it removes.

CI: all checks pass at 93e1905 (35 pass, 7 skipped), including all test shards, coverage and code-metrics. The PR is mergeable.

Checked: loop/writeback.py (the five originally over-ceiling functions: _promote_explore, lift_to_current_best, _promote_baseline, handle_unpromotable_result, _promote_integrate_patch; _write_current_best for #2001; the resume path for #2091; the #2098 import moves), loop/_geak_revalidation.py, collaborator.py, scripts/code_metrics_baseline.txt, the description; the three merges in d51536f..93e1905 against their first parents and main's changes; main commits #2001, #2091, #2098, #1845, #2029 and #2075 | Ran: git merge-tree against current main; line counts and numstat at base and head; imports of writeback and _geak_revalidation on an extracted merge tree; the lift and warm-replay tests on a Windows extract of the merge tree (the one failure there fails the same way on main); definition and type reference counts across src/; rule checklist and two independent refutation passes | Base: ac0c2dd | Head: 93e1905

[chennyiiis]

Description updated — the last blocking point was in the Observable effect section, which contradicted itself: it opened with "No observable change: internal structure only. No behaviour, interface, default, flag or artifact changes" and then named a log line that does change.

It now leads with the one thing an operator sees:

One line of output changes. The GEAK 2a "did not validate" warning no longer prints an accuracy_failure= field. On that path an accuracy failure returns before the field can be filled, so an operator reading that warning on main sees an empty value; they will now see no field at all. Nothing else an operator can observe changes: no interface, default, flag, artifact, persisted shape or ordering of effects.

The framework-levers ordering is stated in the same section rather than buried under the merge notes, and stated as what it is — not a difference against main. An earlier revision of this PR registered the levers before _confirmed_integrate_completion; main's order is restored, so an unconfirmed recovery persists no levers, exactly as today.

Three figures in the description were also wrong against the current head and are corrected from the real diff:

	was	now
diff size	"~10k production lines"	2,409 added / 2,179 deleted across 4 files
helpers added	"~106"	91 (78 functions on main → 169 across the two modules)
writeback.py on main	4717	4716

Head is 93e1905a3: 35 checks pass, 0 fail, MERGEABLE. No code changed for this round — description only.

Blocker fixed in the description at 93e1905; superseded by the LGTM comment below.

[chaojhou]

PR #1956 -- refactor(writeback): bring every function in the writeback module under the complexity ceiling

What it does: brings every function in loop/writeback.py under the complexity ceiling of 20. The GEAK 2a/2b revalidation ruling moves into loop/_geak_revalidation.py, a GeakRevalidation mixin on WritebackCollaborator. The rest is split in place into named helpers. collaborator.py drops its Coordinator type import so loop/ stays acyclic. Behaviour is unchanged apart from the one warning field the description names.

Blocking issues: none

The size-exception finding from my review at 93e1905 is fixed in the description. It now gives the net change as +258 lines (4156 + 818 = 4974 against 4716 on main), states the churn as 2,409 added and 2,179 deleted, records 31 baseline entries retired with writeback.py lowered from 4716 to 4156, and gives the reason for the growth. The head is unchanged, so the code results from that review still hold:

• All three findings from my review at 112a442 stay fixed.
• fix(writeback): keep replace-mode launch controls when a KEEP declares none #2001, fix(resume): reinstall the kept source patches on a framework tree that lost them #2091 and refactor(integrate-patch): give each stage of an integration attempt a module of its own #2098 sit in the helpers that now hold that code, in main's order.
• A trial merge with current main is clean.
• All checks pass (35 pass, 7 skipped).

Checked: the live description against 93e1905 (writeback.py 4716 at ac0c2dd and 4156 at 93e1905; _geak_revalidation.py 818; the scripts/code_metrics_baseline.txt diff is +1/-32, the added line replacing the old writeback.py entry); the earlier code review at this head (the five originally over-ceiling functions, the three merges since d51536f, main commits #2001, #2091, #2098, #1845, #2029 and #2075) | Ran: line counts and numstat at base and head; git merge-tree against current main; gh pr checks 1956 | Base: ac0c2dd | Head: 93e1905

LGTM

[chaojhou]

@ZhengGong-amd On the net-growth point: as maintainer I accept the +258 production lines here. The description now states the growth (4156 + 818 = 4974 against 4716 on main) and why it exists: the 91 named helpers are what take every function under the complexity ceiling, and neither module reaches the 1,200-line gate.

[chaojhou]

PR #1956 -- refactor(writeback): bring every function in the writeback module under the complexity ceiling

What it does: moves the GEAK revalidation (the 2b rebench ruling and the 2a harness replay behind it) out of writeback.py into a GeakRevalidation mixin in loop/_geak_revalidation.py, and splits the rest of writeback.py into named helpers, so that every function in both modules scores under 20. Behaviour is unchanged apart from the one log field the description names.

Blocking issues: none

Re-review at 93e1905:

• Equivalence, branch by branch against main ac0c2dd. Covered the promote paths, the GEAK 2b/2a ruling, build_env_spec and geak_rebench_params, the resume and recovery paths, and the agent KEEP outbox. In each, the same conditions lead to the same effects in the same order, including the levers registered after _confirmed_integrate_completion.
• Merge with current main. It merges cleanly with 1a5bcbf; #2075, #2097 and #2119 touch none of these files. The merged tree imports.
• Description. Corrected in place: the module-length paragraph now reads 258 lines longer and 31 entries retired. The complexity table had six stale "After" values, measured before 2ed05d0 folded helpers back in. It is re-measured on the description's own scale, with Before at ac0c2dd and After at this head. The highest value at head is 19.

Ran: branch-by-branch comparison of main and head exports; git merge-tree --write-tree origin/main 93e1905a3 (clean); the targeted writeback test files on head and main (identical results); the complexity scorer on main and head. CI: 35 pass, 7 skipped.

Head: 93e1905