[chennyiiis]

What this changes

Simplifies kernel patch integration, fusion recovery, handoff rendering and shape alignment. _ControllerIntegration owns the pins, landed patches and admitted-round count for one sequential integration pass, so refusal and KEEP paths reuse the same result construction. Fusion recovery reads checkpoint and manifest objects through common.jsonio; handoff and chart rendering share their repeated section/title construction. Shape alignment removes a redundant guard because its budget always preserves at least one ladder row per (N, K) pair.

Against the current main, the production diff is 260 additions and 333 deletions (net -73) across controller_patch_integration.py, forge_fusion.py, forge_handoff.py, conc_sweep_plot.py, gemm_shape_coverage.py and common/jsonio.py. No module is added or removed. Seven metrics-baseline entries are retired. Existing complexity debt in untouched functions, including forge_fusion._normalize_manifest, remains covered by the baseline; this does not claim the whole package is below every threshold.

Observable effect

• Fusion recovery preserves a kept checkpoint's kernel_speedup: 0 when the aggregate manifest is empty or corrupt; this previously became null. A populated manifest can still supply its fallback measurement.
• read_json and read_json_strict accept an optional errors= argument, defaulting to strict. Fusion recovery explicitly uses replace, preserving its existing UTF-8 decoding policy.
• Valid serving-context text, patch integration ordering/verdicts, and shape-budget output remain unchanged. Nested serving configuration is consumed as a mapping, and unset environment variables as a sequence, following the producer contract.

The current diff does not modify attempt_summary.py or _normalize_manifest and introduces no change to keep-pending verification overlays.

Validation

Linux Python 3.10: the controller integration, Forge fusion, Forge handoff, GEMM shape coverage and shape-alignment handler suites passed (180 tests), as did 46 shared-JSON and plot tests. A deterministic differential probe compared shape alignment against main for 400 input/budget combinations. A recovery probe confirmed that only the documented zero-speedup cases differ among the tested checkpoint/manifest combinations. The current head's GitHub code-metrics, lint, test and coverage checks pass. GPU E2E jobs are skipped for this head, so they are not GPU execution evidence.

Linked issue: none. This is one refactoring concern across the kernel helpers; no size exemption is needed.

[github-actions]

Code metrics gate: PASSED

Judged: the 7 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	45	+0
Cognitive complexity	fails > 30	0	0	0	167	-3
Function length (lines)	fails > 80	0	0	0	311	-4
Nested block depth	fails > 5	0	0	0	19	+0
Parameter count	fails > 5	0	0	0	89	+0
Module length (lines)	warns > 800, fails > 1200	0	0	0	47	+0
Duplicated lines per file	fails > 0	0	0	0	96	+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

89 findings in files this change does not touch

Outside this change (informational): 89

Unit	Dimension	Baseline	Now
src/hyperloom/orchestrator/state/shared_state.py resolve_graded_comparison	Cognitive complexity	absent	34
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/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_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
src/kernelforge/loop/runner.py IterationLoop._rule_on_attempt	Function length (lines)	absent	102
src/kernelforge/loop/runner.py IterationLoop._source_attempt	Function length (lines)	absent	175
src/hyperloom_kb/http_service.py	Module length (lines)	absent	1525
src/kernelforge/cli/forge_loop_command.py	Module length (lines)	absent	2003
src/hyperloom/orchestrator/actions/executors/_geak_sweep.py sweep_via_geak	Cognitive complexity	67	70
src/hyperloom/orchestrator/actions/executors/_grid_runner.py run_grid	Cognitive complexity	177	180
src/hyperloom/orchestrator/actions/executors/explore.py ExploreExecutor.__call__	Cognitive complexity	369	383
src/hyperloom/orchestrator/kernel/request_handlers.py _run_forge_gemm_tuning	Cognitive complexity	124	125
src/hyperloom/orchestrator/phases/kernel.py KernelPhase._run_geak_kernel_phase	Cognitive complexity	122	130
src/hyperloom/orchestrator/phases/prelude.py PreludePhase.maybe_enqueue_warm_replay	Cognitive complexity	190	191
src/hyperloom/orchestrator/actions/executors/_grid_runner.py run_grid	Cyclomatic complexity	55	56

...and 64 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.}

[ZhengGong-amd]

Requesting changes: the behaviour matches base (I diffed every module), but the branch conflicts with main and the PR adds 479 lines of production code to lower complexity scores.

Production code: +1512/−1033 (net +479), with 17 new types (16 classes/NamedTuples and 1 Enum). A complexity refactor should shrink production code. Bring this PR to net-zero or negative by deleting the mechanisms below.

Blocking

1. Conflict in scripts/code_metrics_baseline.txt. Rebase onto main, keep main's lowered values, drop this PR's 15 entries, then run python scripts/code_metrics.py --update-baseline on the merged tree.
2. Net growth (see above). Remove the items under Simplify below.

Simplify instead of relocate

• controller_patch_integration.py:243-345: delete _IntegrationSession, _ControllerIntegration, _WorktreeInspection, _ValidationOutcome and _KeepCommit. These "value-or-refusal" pairs restate the loop's continues as .refusal is not None checks spread over 6 methods. Keep a single loop with continue, plus _refusal, _commit_keep, _integration_summary and _e2e_kept.
• Revert controller_publication.py:74-193 and geak_config.py:228-293. Neither load_controller_publication (cognitive 27, cyclomatic 18, 72 lines) nor _geak_accepted_kernel_specs (cognitive 24, cyclomatic 12) was over the thresholds or in the baseline. Delete _PublicationArtifacts, _PublicationCommits and the single-use _TwinVerdict enum.
• forge_fusion.py:148-163: delete _ManifestRead. _normalize_manifest reads the same dict through both manifest.raw and read.manifest; use manifest.raw only. Also drop _SalvagedKeep.kept (:574), which nothing reads.
• Keep the parts that remove duplication: _failed_fusion_result, _kernel_agent_results.py, _KernelTally and _SalvagedKeep.filled_from.

Metrics: the "15 entries retired" claim reproduces. Change only functions that were over the limits in [tool.hyperloom.code_metrics] (cyclomatic 20, cognitive 30, 80 lines).

[chennyiiis]

Merged current main into the branch (merge commit, so the review history stays attached) and worked through the list.

Blocking 1 — baseline conflict. Resolved; mergeable is MERGEABLE. The hunk was resolved by taking the lower value per entry and reading the merge base, so an entry main retired is dropped and one that only moved file is kept. --update-baseline cannot run on this machine (no ruff/jscpd), so the gate's own report is what the baseline was reconciled against.

Done

• controller_publication.py and geak_config.py are reverted to main. You are right that neither load_controller_publication nor _geak_accepted_kernel_specs was over a threshold or in the baseline, so neither belonged in this change. _PublicationArtifacts, _PublicationCommits and _TwinVerdict are gone with them, and both files are now byte-identical to main, so they are out of this PR's diff entirely.
• _normalize_manifest now reads the parsed manifest through _FusionManifest.raw only; the three remaining read.manifest accesses (artifacts, verdict, nomination) go through manifest.raw.
• attempt_summary.py no longer declares the unused log (CodeQL "unused global variable"); import logging went with it.
• Kept, as you asked: _failed_fusion_result, _kernel_agent_results.py, _KernelTally, _SalvagedKeep.filled_from.

Not done, with reasons

• Deleting _SalvagedKeep.kept: it is read at forge_fusion.py:625 (if not carried.kept or not carried.patch or ...), which is the gate that decides whether a salvaged run publishes a KEEP at all. Removing it changes behaviour.
• Deleting _ManifestRead: with it gone _read_fusion_manifest has to return the parsed manifest and the reason it could not be read as a bare pair, which is the "positional tuple of loosely related values" AGENTS.md rules out. The duplicate access path you flagged is fixed above; the type itself is the house shape for a two-field result.
• Deleting _IntegrationSession: _ControllerIntegration.__init__ would then take session_dir, shared_state, record_keep, validate, admit_round and results_dir — 6 parameters, over the repo's limit of 5 (PLR0913), and not baselined, so a new finding.
• Collapsing _ControllerIntegration back to one loop with continue: the pass carries eight pieces of per-run state (_pinned_bases, _pinned_heads, _pin_errors, _landed, _rounds_run, the result list and the two paths) across patches, which as locals is the 100+ line function this PR set out to split. I agree the .refusal is not None pairs are the weak part of it and I would rather fix that shape than the container: _inspect_worktree and the validation step can return None to mean "this path already recorded its own outcome", which deletes the refusal field from _WorktreeInspection and deletes _ValidationOutcome outright. Say the word and I will push that; I left it out of this round because it is a behavioural edit to the apply/validate path rather than a deletion.

Net production figure. +1388 / -992, net +396 (was +479): the two reverts took out 79 lines and three of the seventeen new types. Reaching net-zero needs the _ControllerIntegration collapse above, which trades the 5-parameter and complexity gates for it. Tell me which you want and I will take it the rest of the way.

[chennyiiis]

PR #1992 -- refactor(kernel): name the work in the orchestrator kernel modules instead of its position

What it does: Nine functions across six orchestrator/kernel modules measured over the repo's complexity ceiling, and attempt_summary.py could not absorb the builders those splits produce without crossing the module-length limit. The summary now resolves its per-session lookups once and tallies through one accumulator, with the kernel-agent result reading moved to a new sibling _kernel_agent_results.py; a forge-fusion manifest is split once into typed blocks with each outcome built by the function that names it; one pass object owns the controller integration's pinned bases, landed patches and round count; and the handoff document, the sweep chart and the aiter ladder fit are each expressed as named steps.

Blocking issues: 1

1. [X2] The description still describes two modules this PR no longer changes, and its module and function counts include them. [verified]
   Problem: body.txt carries a full bullet for controller_publication.py ("artifacts, payload, identity, operator id, commits and repository root are each validated by the function that names them"), names geak_config.py and "the accepted-kernel twin resolution" in the last bullet, and three times states counts that do not match the diff -- "eight orchestrator/kernel modules", "twelve functions across eight modules", "those eight modules plus the new sibling". The final commit on this branch, 43b57d8, is "leave the publication loader and the geak spec reader as main has them", and neither file appears in the diff at head. The diff changes six existing modules plus one new sibling, and the 15 retired baseline entries cover nine functions across six modules. src/hyperloom/orchestrator/kernel/controller_publication.py, src/hyperloom/orchestrator/kernel/geak_config.py
   Impact: the release cut aggregates these descriptions into the GitHub release and cannot reconstruct them from commit subjects, so the notes will tell a reader that two modules were restructured by a change that does not contain them.
   Action: delete the controller_publication.py bullet, drop geak_config.py and "the accepted-kernel twin resolution" from the last bullet, and change the three counts to six modules and nine functions.

Checked: kernel/attempt_summary.py (build_kernel_optimization_summary, _collect_summary_inputs, _hot_kernel_attempt, _tally_hot_kernels, _tally_ledger_only_kernels, _tally_gemm_tuning_keeps, _lane_totals_by_lane, _gemm_tuning_lane_totals, _render_attempted_row, _verification_block, _aggregate_failure_reasons and its three new buckets), the new kernel/_kernel_agent_results.py, kernel/forge_fusion.py (_normalize_manifest, salvage_forge_fusion_from_workspace, _failed_fusion_result, _timeout_result), kernel/controller_patch_integration.py (_ControllerIntegration and all six of its steps, _refusal, _commit_keep, _integration_summary, PatchIntegrationResult's field order), kernel/forge_handoff.py::build_serving_context_md, kernel/conc_sweep_plot.py::_render, kernel/gemm_shape_coverage.py, scripts/code_metrics_baseline.txt, and the two open bot threads (both outdated: the unused log global is removed at head) | Ran: differential harnesses running the base and head versions side by side -- 4000 randomized summary states, 448 on-disk salvage fixtures, 34 manifest fixtures, 288 handoff renders, 18 chart renders against a recording matplotlib stub, and 16 controller-integration scenarios comparing the full ordered side-effect trace (0 mismatches throughout), with two mutations injected to confirm the harnesses detect this defect class (1837 and 10 mismatches respectively); plus complexipy over the changed package and the complexity scan at a bar of 20 over all seven modules (prints nothing) | Base: adbc187 | Head: 43b57d8

SKIPPED: Publishing (--request-changes) -- GitHub refuses a change request on your own pull request and this reviewer holds the author token, so the blocking verdict is published as a comment instead. The finding above is CHANGES REQUESTED, not a note.

[ZhengGong-amd]

Production code is still too large. The net growth is +396 lines (it was +479), and it needs to keep shrinking before this can merge.

I classified every changed line in the touched production files with an AST pass (merge-base vs head c89d78ba6):

	net lines
executable logic	+21
docstrings	+109
def/class signatures	+133
NamedTuple/dataclass fields	+47
blank lines between new defs	+139
imports / __all__	+13

Functions go from 116 to 187, record types from 7 to 18, and total parameters from 208 to 337. Of the 82 new definitions, 61 are referenced exactly once in src/.

The logic barely changed (+21). The growth is the scaffolding around single-use units: their signatures, docstrings, fields and spacing (about +441 lines). That is the same control flow in more places, not a simpler one (AGENTS.md Simplify by removing a mechanism). The parameter-count and tuple-return limits in [tool.hyperloom.code_metrics] are review triggers, not a reason to add a type or a helper. When a limit and the clearer code disagree, keep the clearer code and say so (Size is a design signal).

Cut next:

• _IntegrationSession, _ControllerIntegration, _WorktreeInspection, _ValidationOutcome and _KeepCommit: one loop with continue, keeping _refusal.
• _ManifestRead.
• Inline the remaining helpers that have one caller and only thread arguments through, and drop the docstrings that restate a private helper's name (Comment below the local average).

Target: production net ≤ 0, or name each remaining new type in the description with what it removes.

[ZhengGong-amd]

Against merge-base 6f7a02494, this PR spends +396 net production lines (11 new NamedTuples, 71 new functions) to retire 15 baseline entries. A delete-first reference implementation retires the same 15 entries at −178 net lines with no new NamedTuple. It passes the code-metrics gate, and all 1486 tests in the 26 covering files pass. Please rework the PR along these lines before merge.

Targets. These functions are over a threshold at merge-base: build_kernel_optimization_summary (cc 21 / cog 59 / 190 lines), _render_attempted_row (cog 33 / 93), _gemm_tuning_lane_totals (cog 32), integrate_controller_patches (cog 38 / 261), _normalize_manifest (cog 44 / 147), salvage_forge_fusion_from_workspace (cog 41 / 82), align_shapes_to_aiter_keys (cog 33), conc_sweep_plot._render (95 lines), build_serving_context_md (84 lines). Nothing else was over a threshold, so revert these changes:

• the _kernel_agent_results.py move and its test-import change
• _aggregate_failure_reasons and its three _*_bucket helpers
• _BUCKET_OTHER
• the _draw_arm signature and the module-level palette constants

Delete

1. _SummaryInputs, _collect_summary_inputs, _AttemptMatch, _hot_kernel_attempt, _roofline_top15, _hot_kernel_ids, _integrated_kernel_ids, _pending_keep_kernel_id, _tally_hot_kernels, _tally_ledger_only_kernels, _tally_gemm_tuning_keeps, _KernelTally: a single-use bag, and one collection split into three passes. Replace them with _attempted_rows + _tally (Change 1).
2. _lane_totals_by_lane, _absent_geak_backends_takeaway: single-use. Inline them into the caller.
3. _verification_block, _artifact_error, _kernel_agent_result_path, _roofline_profile_fields, _ledger_progress_fields, _overlay_present_keys: single-use. Keep the row as one dict literal.
4. _LaneCounters, _gemm_tuning_results, _is_gemm_tuner_winner, _gemm_tuner_row_counts, _gemm_campaign_counts: a bag and pass-throughs. The e2e split is still duplicated at attempt_summary.py:305 and :317. See Change 2.
5. _IntegrationSession, _WorktreeInspection, _ValidationOutcome, _KeepCommit: value-or-refusal pairs. Have each stage return its result instead.
6. _e2e_kept, _commit_keep, _integration_summary, and the methods _record, _refuse_against_pinned_base, _inspect_worktree, _merge_onto_landed, _validate_applied_patch, _record_keep_in_state: single-use or pass-through. Inline them into integrate / _apply_and_validate.
7. _ManifestRead, _FusionManifest, _read_fusion_manifest, _fusion_manifest_blocks, _llm_unavailable_error, _infrastructure_abort_error, _aborted_on_infrastructure, _fusion_kernel_speedup, _fusion_activation_fields: bags and fragments of one decision, and the last two branch on compile_pass twice. Inline them into _normalize_manifest with one if compile_pass:.
8. _SalvagedKeep, _read_json_dict, the four _keep_from_*, _salvaged_keep_result. See Change 4.
9. _SweepSeries, _sweep_series, _draw_roofline_ceiling, _draw_arms, _apply_dark_theme: single-use. With only _chart_title extracted and the three single-use intermediates inlined, _render is 78 lines.
10. _serving_identity_lines, _source_repository_lines, _server_argument_lines, _environment_lines: single-use. _fenced_section alone gets the function to about 55 lines.
11. _ladder_rows_within_budget (gemm_shape_coverage.py:117): inline it back and delete the redundant outer if len(kept) > budget:, because the inner loop starts with the same break. That alone takes cog from 33 to 26.

Change

1. Derive the counts from the rows. Merge the top15 and ledger-only loops into one _attempted_rows(state, top15, where), and leave the gemm entries in the main function:

   def _tally(rows, top_candidates):
       counts = {"top_candidates": top_candidates, "attempted": len(rows),
                 "integrated": 0, "keep_pending": 0, "rejected": 0, "in_flight": 0}
       breakdown = dict.fromkeys([*KNOWN_REJECTION_REASONS, "other"], 0)
       for row in rows:
           counts[_category_count_key(row["category"])] += 1
           if row["category"] == CATEGORY_ATTEMPTED_REJECTED:
               breakdown[_rejection_bucket(str(row.get("rejected_reason") or ""))] += 1
       return counts, breakdown

   In _render_attempted_row, apply both overlays in one for source, keys in ((detail, _VERIFICATION_DETAIL_KEYS), (last_kernel_opt or {}, _VERIFICATION_DECISION_KEYS)): loop.
2. In _gemm_tuning_lane_totals, compute one (tried, winners) pair per result, then test requires_e2e_validation once to choose between unvalidated += winners and success += winners.
3. Controller:
   • Give _refusal a **fields parameter and use it for the hand-built results at controller_patch_integration.py:469 and :524.
   • Merge the three pin dicts into one dict[Path, tuple[str, str, str]].
   • Replace _IntegrationSession with __init__(validate, persist_keep, admit_round), where persist_keep is a 3-line closure.
   • integrate(publication) returns a result, and the outer loop records it once:

   for index, patch_dir in enumerate(_priority_ordered_patch_dirs(patches_root)):
       try:
           publication = load_controller_publication(patch_dir)
       except ControllerPublicationError as error:
           result = PatchIntegrationResult(patch_dir.name, "skipped_invalid", str(error))
       else:
           result = await run.integrate(publication)
       results.append(result); _write_result(results_dir, index, result)

4. Write salvage as one function with one ckpt.get(x) or manifest... chain per field. Read both files through jsonio, adding an errors= pass-through to read_json instead of a private reader.
5. Change _abort_result_fields to take (raw, loop, compile_pass) and call it as None if kept else ..., so not kept is tested once.
6. After rebasing, regenerate the baseline; it should retire only the same 15 entries. In the description, fix "eight modules" and drop size-exception.

Keep

• _latest_attempt_per_kernel, _chart_title, _fenced_section
• _refusal
• _ControllerIntegration with integrate and _apply_and_validate
• _failed_fusion_result and its use in _timeout_result
• _abort_result_fields, _fusion_source_file, _missing_keep_artifact
• the two _VERIFICATION_*_KEYS constants

Watch out

• Keep errors="replace" decoding in salvage. Strict read_json raises UnicodeDecodeError on a non-UTF-8 checkpoint, which crashes _timeout_result.
• When the checkpoint is kept with kernel_speedup == 0 and there is no manifest, base returns 0. This PR, like a naive or chain, returns None. Fall through to the manifest only when it exists.
• Keep the isinstance(result, dict) skip in _gemm_tuning_lane_totals. The list round-trips through state.json, and SharedState.from_dict does not validate its elements.
• Compute float(validation["new_tput"]) / gain_pct only in the e2e-not-KEEP and kept branches, never before the commit.
• The duplicate-literal check flags new repeats of "other", "in_flight" and "fusion.patch". Use dict-key forms or a local variable, not new constants.

The reference implementation reaches cc ≤ 9, cog ≤ 29 and lines ≤ 80 on every target with net ≤ 0 production lines.

[chennyiiis]

Reworked delete-first. The five modules went back to merge-base 6f7a02494 first, then each target was brought under the gate by removing a pass, a guard or a second source of the same state. Net −125 production lines against the merge base; 13 of the 15 baseline entries retired; all 1486 tests in the 26 covering files pass; CI is 40 checks / 0 failures.

Every function in scope also has to measure < 20 on Cmetrics (an external scale that additionally counts each and/or operand, each ternary and each comprehension clause, so it reads strictly higher than ruff/complexipy). Two did not get there by deleting; both are called out below.

Numbers

Function	Cmetrics	ruff cc	lines
build_kernel_optimization_summary	57 → 18	21 → 4	190 → 74
_attempted_rows (new, Change 1)	→ 18	→ 6	48
_tally (new, Change 1)	→ 6	→ 3	18
_render_attempted_row	27 → 19	10 → 6	93 → 65
_gemm_tuning_lane_totals	24 → 18	10 → 7	35 → 28
_aggregate_failure_reasons	21 → 17	11 → 11	52 → 50
integrate_controller_patches	37 → 9	16 → 6	261 → 69
_ControllerIntegration.integrate	→ 8	→ 6	27
_ControllerIntegration._apply_and_validate	→ 16	→ 6	78
conc_sweep_plot._render	22 → 17	11 → 8	95 → 78
build_serving_context_md	26 → 19	4 → 1	84 → 48
align_shapes_to_aiter_keys	22 → 18	10 → 8	45 → 44
salvage_forge_fusion_from_workspace	40 → 22	14 → 7	82 → 70
_normalize_manifest	48 → 48	11 → 11	147 → 147

Reverts

Done, all of them: _kernel_agent_results.py and its test-import change, _aggregate_failure_reasons with its three _*_bucket helpers, _BUCKET_OTHER, and the _draw_arm signature with the module-level palette constants are back at merge-base. _aggregate_failure_reasons then came from 21 to 17 by dropping four guards its own producer already satisfies: _render_attempted_row always writes backend_ladder as a list, backend_ladder_unavailable_reason and error_class as strings and verification as a dict, so the or [] / or "" / or {} around them could never fire.

Deletes 1–11

All eleven are done; every name you listed is gone from the tree.

1. Done — _attempted_rows + _tally exactly as in Change 1, with _latest_attempt_per_kernel kept. The top15 pass and the ledger-only pass are now one loop over an ordered {kernel_id: row} map, so the "same accounting as the loop above" comment has nothing left to warn about.
2. Done — inlined.
3. Done — the row is one dict literal, and both verification overlays run in the single for source, keys in ((detail, _VERIFICATION_DETAIL_KEYS), (last_kernel_opt, _VERIFICATION_DECISION_KEYS)): loop you asked for.
4. Done. The e2e split at attempt_summary.py:305/:317 is gone with Change 2.
5. / 6. Done — _ControllerIntegration now has only integrate and _apply_and_validate, each stage returning its result.
6. Done — _normalize_manifest is the merge-base single function with its one if compile_pass:; see the caveat below.
7. Done — see Change 4.
8. Done — only _chart_title is extracted, the three single-use intermediates are inlined, and _render is 78 lines.
9. Done — _fenced_section is back. The two bullet-list sections repeated the same heading/fallback shape, so they share _bullet_section with it; that is what took the function to 48 lines and Cmetrics 19.
10. Done, and it pays more than measured: inlining _ladder_rows_within_budget and dropping the redundant outer if len(kept) > budget: also makes the inner if len([1 for _m, _n, _k in kept if (_n, _k) == (n, k)]) > 1: guard unreachable. kept starts as the full ladder × nk_pairs product and budget >= len(nk_pairs), so the outer break fires before the last rung and no (N, K) can lose its last row. Deleting that comprehension is what took it from 33 to 18 rather than 26.

Changes 1–6

1. Done, verbatim. 2. Done — one (tried, winners) pair per result and one test of requires_e2e_validation; the isinstance(result, dict) skip is kept. 3. Done — _refusal takes **fields and builds both hand-made results; the three pin dicts are one dict[Path, tuple[str, str, str]]; __init__(validate, persist_keep, admit_round) with persist_keep a closure in integrate_controller_patches; the outer loop is the one you wrote. 4. Done — both files now go through jsonio.read_json, which gained an errors= pass-through (and read_json_strict with it), so errors="replace" survives and a non-UTF-8 checkpoint cannot crash _timeout_result. Each field is one ckpt.get(x) or manifest… chain; kernel_speedup falls through to the manifest only when the manifest exists, so a checkpointed 0 still returns 0. 5. Done. 6. Baseline regenerated with --update-baseline; it retires 13 entries, not 15 — the two it does not are _normalize_manifest's.

float(validation["new_tput"]) / gain_pct are computed only in the e2e-not-KEEP and kept branches, through _measured(validation); the duplicate-literal check is clean.

The two still ≥ 20 on Cmetrics

#7 _normalize_manifest — 48, unchanged, left reverted. It is one function with one if compile_pass: as you asked, and the nine helpers are deleted. Its Cmetrics weight is 27 or operands and 7 ternaries, and essentially all of them are per-key defaults for one external JSON contract (m.get("fusion_loop") or {}, str(m.get("verdict") or ""), patches[0].get("target_file") or patches[0].get("source_file") or src_file, …). Deleting any of them changes what the function reports for a manifest that omits that key. Getting from 48 to 19 needs the manifest parsed into a typed record once at the boundary — a redesign larger than this rework — so I left it exactly at merge-base rather than silently restoring the extraction you asked me to delete. Its two baseline entries (cognitive 44, lines 147) stay.

#8 salvage_forge_fusion_from_workspace — 22. Down from 40 and under both repo thresholds, so its baseline entry does retire. The residual 22 is the same shape: 11 or operands that are the checkpoint→manifest→campaign precedence itself, plus the if manifest: statement that exists only to preserve the kept-with-kernel_speedup == 0 case you flagged. Merging those into one record of facts loses that case, so I stopped at 22.

[ZhengGong-amd]

PR #1992 -- refactor(kernel): name the work in the orchestrator kernel modules instead of its position

What it does: Refactors six orchestrator/kernel modules (attempt summary, controller patch integration, forge-fusion salvage, forge handoff, conc-sweep plot, GEMM shape alignment) so 13 code-metrics baseline entries can be retired, for a net -125 production lines. It also adds an errors= pass-through to read_json / read_json_strict in common/jsonio.py.

Blocking issues: 3

1. [free:observable-effect-desync] The Observable effect section misstates what changes at runtime [verified]
   Problem: The section blames a function the diff does not touch, says ordinary runs are unaffected, and leaves out one malformed-input change.

   • "a manifest field that is neither a number nor a numeric string is coerced rather than raising": _normalize_manifest (src/hyperloom/orchestrator/kernel/forge_fusion.py:150) is unchanged. git diff e25cb2db2 2cd2e837f -- src/hyperloom/orchestrator/kernel/forge_fusion.py touches only the imports and salvage_forge_fusion_from_workspace, so no coercion change exists.
   • "Ordinary runs are unaffected": src/hyperloom/orchestrator/kernel/attempt_summary.py:611 now passes last_kernel_opt to kernels that are in the ledger but not in top15 (base attempt_summary.py:685 passed None). Repro: top15=[k001], ledger={k009: KEEP}, last_kernel_opt={kernel_id: k009, decision: KEEP, compile_passed: True, correctness_passed: True}. Row k009 verification: base {compile_passed: None, correctness_passed: None}, head {compile_passed: True, correctness_passed: True}.
   • Not stated: src/hyperloom/orchestrator/kernel/forge_fusion.py:436-440. Repro: a checkpoint with {kept: true, kernel_speedup: 0}, a fusion.patch, and a fusion_manifest.json that is {} or corrupt. kernel_speedup is None on base and 0 on head. A killed run can leave a corrupt manifest.
     Impact: The release notes would tell operators that normal runs are unchanged and that the only difference is manifest coercion. In practice, kernel_optimization_summary now shows verification flags on ledger-only keep-pending kernels, and salvaged kills can report a speedup of 0 instead of null, with nothing in the notes to explain either change.
     Action: Rewrite Observable effect to say three things. Ledger-only keep-pending rows now carry the last_kernel_opt verification overlay. Salvage of a kept checkpoint with kernel_speedup 0 and an empty or corrupt manifest now reports 0 instead of null. Duplicate kernel ids merge into one row. Delete the _normalize_manifest coercion sentence. Write the body against git diff origin/main...HEAD only; every name and number must be reproducible from that diff.

2. [free:deleted-names-not-on-main] "What was deleted" names code that never existed on main [verified]
   Problem: The section describes the PR's earlier revision instead of the change against main.

   • _kernel_agent_results.py, _BUCKET_OTHER, _tally_hot_kernels, _tally_ledger_only_kernels, _tally_gemm_tuning_keeps, _KernelTally, _IntegrationSession, _WorktreeInspection, _ValidationOutcome, _KeepCommit and _ladder_rows_within_budget are not defined anywhere: git grep over src and scripts at e25cb2d, 2cd2e83 and origin/main finds no definition of any of them. The palette constants also never existed on main.
   • "_aggregate_failure_reasons ... are reverted": the diff changes it (src/hyperloom/orchestrator/kernel/attempt_summary.py:837 and below). Three .get(...) reads become row[...], the str() around error_class is dropped, and the bucket lookup is inlined.
   • "the _draw_arm signature change ... reverted": _draw_arm (src/hyperloom/orchestrator/kernel/conc_sweep_plot.py:157) is identical at base and head, so there is nothing to report.
   • Accurate fact: the diff removes _gemm_tuning_entries_in_optimization_stack and the outer if len(kept) > budget: block plus the inner > 1 guard (gemm_shape_coverage.py:134-144). It adds _stack_entries, _latest_attempt_per_kernel, _attempted_rows, _tally, _chart_title, _refusal, _ControllerIntegration, _measured, _fenced_section and _bullet_section.
     Impact: The release notes would announce the removal of eleven names that never shipped, and would claim that _aggregate_failure_reasons is unchanged when its behaviour on malformed rows did change.
     Action: Replace the list with the removals and additions above, and say that _aggregate_failure_reasons was edited. Write the body against git diff origin/main...HEAD only; every name and number must be reproducible from that diff.

3. [free:size-complexity-claims] The gate claim and the size-exception label do not match the measured numbers [verified]
   Problem: Two size and complexity claims are contradicted by the repo's own tools.

   • "both under every repo gate": _normalize_manifest (src/hyperloom/orchestrator/kernel/forge_fusion.py:150) has cognitive complexity 44 against a gate of 30 (pyproject.toml:517) and 147 lines against a gate of 80 (pyproject.toml:521). It passes only because of scripts/code_metrics_baseline.txt:68 and :565.
   • The size-exception label: on main, scripts/pr_hygiene.py size --base e25cb2db2 --head 2cd2e837f reports "909 production Python lines changed", which is under LIMIT = 1000 (scripts/pr_hygiene.py:36). The body gives no reason for the waiver.
     Impact: The release notes would say the kernel modules are fully under the complexity gates while two baseline waivers remain. The PR would also carry a size exemption it does not need, without the justification the label requires.
     Action: Replace "both under every repo gate" with "_normalize_manifest remains over the cognitive (44 > 30) and length (147 > 80) gates and is held by its 2 baseline entries", and remove the size-exception label. Write the body against git diff origin/main...HEAD only; every name and number must be reproducible from that diff.

Checked: forge_fusion.py _normalize_manifest, salvage_forge_fusion_from_workspace; attempt_summary.py _attempted_rows, _tally, _aggregate_failure_reasons; gemm_shape_coverage.py align_shapes_to_aiter_keys; conc_sweep_plot.py _draw_arm; common/jsonio.py; scripts/code_metrics_baseline.txt; pyproject.toml thresholds; live PR body and labels | Ran: gh pr view 1992 --json headRefOid,title,body,labels; git diff e25cb2d 2cd2e83; git grep for the listed names at base, head and origin/main; base-vs-head repros of _attempted_rows and salvage; pr_hygiene.py size; trial merge with origin/main b772e94 (clean), code_metrics.py --base-ref origin/main (PASSED), 27 affected test files (1520 passed), ruff check and format (clean) | Base: e25cb2d | Head: 2cd2e83

[chaojhou]

PR #1992 -- refactor(kernel): name the work in the orchestrator kernel modules instead of its position

What it does: Brings five orchestrator kernel functions under the code-metrics limits and retires their seven baseline entries. Controller patch integration now runs through a pass object that owns the per-repository pins, landed patches and round count; fusion salvage reads its checkpoint and manifest through common.jsonio (which gains an errors= option); the serving-context handoff and the sweep-chart title use shared section/title builders; and the aiter ladder fit drops a guard its budget invariant made unreachable. The only behaviour change, which the description states, is that a kept checkpoint's kernel_speedup: 0 is no longer turned into null when the manifest is empty or corrupt.

Blocking issues: none

Checked: controller_patch_integration.py (_refusal, _ControllerIntegration.integrate / _apply_and_validate, _measured, persist_keep, integrate_controller_patches; all nine result constructions and their side-effect order against base), forge_fusion.py::salvage_forge_fusion_from_workspace and its caller _timeout_result, forge_handoff.py::build_serving_context_md with its producers (writeback.build_env_spec, SharedState.profile_workload_context), gemm_shape_coverage.py::align_shapes_to_aiter_keys, conc_sweep_plot.py::_chart_title / _render, common/jsonio.py::read_json / read_json_strict, scripts/code_metrics_baseline.txt, tree-wide callers of every changed function, CI at head, overlapping open PRs (#2063, #1867, #1685, #1672) | Ran: base/head differential probe (3000 ladder inputs: 0 differences; 72 handoff renders: 0; 162 salvage fixtures, including corrupt, non-object, empty and undecodable files: only the 3 documented kernel_speedup 0 cases differ); pytest test_forge_fusion.py test_forge_handoff.py test_gemm_shape_coverage.py on base and head (126 passed and the same 6 host-specific failures on both); test_controller_patch_integration.py cannot be collected on this Windows host (signal.SIGHUP) and passes in CI at head | Base: bb2da63 | Head: bf33caf

SKIPPED: V4 partial -- #1869, #1276, #1154 and #1032 were compared on their first 100 files only.

LGTM