[chennyiiis]

What this does

Consolidates grading, profile identity construction, persisted winner controls, and trace-analysis projection in orchestrator/state/shared_state.py. Profile override names come from PROFILE_OVERRIDABLE_KEYS; the identity-key tuple derives from it. Winner controls reuse _control_fields, and gap trimming reuses gap_rows.recency_key instead of a local sorter. Hot-kernel row projection and bottleneck saturation bookkeeping become named helpers. No module or type is added.

Relative to main bb2da63332dcbc46bdf10702c516ef43eb80a016, production code is 134 lines smaller: shared_state.py +258/-382 and gaps.py +10/-20. Including the test and metrics baseline, the complete PR is 115 lines smaller.

The existing size-exception covers 670 changed production lines, counting additions plus deletions. The canonical trace-analysis projection, its history and saturation update, and the grading/profile values read from that state are reviewed together so the persisted contracts remain aligned. SharedState retains ownership of its serialized fields and canonical writes; the module's remaining size debt is lowered rather than redistributed into modules that would duplicate that ownership.

Observable effect

Valid numeric workload fields, valid trace-analysis envelopes, and KEEP/REVERT decisions retain their existing contracts. Canonical last_trace_analyze is still written before history is appended, and history failures still propagate after that write. Snapshot history retains the first baseline anchor and compares bottleneck saturation against the previous macro cycle when available.

Some malformed-input coercions change. Profile integers and the previous roofline snapshot id use to_int, which rejects booleans and non-finite numbers; such profile values become zero, and an invalid snapshot id restarts at one. Profile removal/unset lists use to_str_list, whose scalar fallback produces a stripped string instead of raising while attempting to iterate a scalar. These changes do not mean arbitrary malformed persisted state is accepted. The grading helper's zero fallback does not bypass the positive P50 gain threshold or the comparability and constraint gates.

Complexity and validation

Measured with ruff 0.16.2 and complexipy 8.0.1 against the main commit above; lines are physical spans from def through the last statement:

Method	Cyclomatic	Cognitive	Lines
record_trace_analyze	18 → 6	45 → 28	110 → 79
_append_roofline_snapshot_history	13 → 4	39 → 9	148 → 70
profile_workload_context	13 → 5	41 → 18	80 → 51

The baseline diff removes 8 entries, lowers the shared_state.py module-lines allowance 2549→2425, and adds none. This describes the changed units and does not claim the whole module has no existing size or complexity debt.

Validation: 92 tests passed in test_record_trace_analyze_lock.py, test_graded_comparison.py, and test_gaps_field.py under Linux/Python 3.10. This includes canonical-write/history-failure ordering, history capping, previous-cycle saturation, grading and gap merge behavior. Ruff lint and format checks passed for both production files. The head already contains the main commit named above.

[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	14	+0
Cognitive complexity	fails > 30	0	0	0	80	-5
Function length (lines)	fails > 80	0	0	0	213	-3
Nested block depth	fails > 5	0	0	0	8	+0
Parameter count	fails > 5	0	0	0	87	+0
Module length (lines)	warns > 800, fails > 1200	0	0	0	47	+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

60 findings in files this change does not touch

Outside this change (informational): 60

Unit	Dimension	Baseline	Now
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/_kv_metrics.py port_from_server_log	Nested block depth	absent	6
src/hyperloom/orchestrator/specialists/dispatch.py SpecialistDispatchCollaborator.warm_specialist_params	Cognitive complexity	93	94
src/hyperloom/agents/quantization/driver/retry.py quantize_via_prompt	Function length (lines)	102	103
src/hyperloom/inference_optimizer/breakdown/exporter.py build	Function length (lines)	132	136
src/hyperloom/inference_optimizer/cli/__init__.py _run_optimize	Function length (lines)	273	279
src/hyperloom/inference_optimizer/cli/preflight.py _preflight	Function length (lines)	203	208
src/hyperloom/inference_optimizer/multi_node/scripts/kernel_patch_multinode.py _do_apply	Function length (lines)	98	99
src/hyperloom/orchestrator/actions/executors/_multi_node_server_lifecycle.py restart_server_for_round	Function length (lines)	135	138

...and 35 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: equivalence holds (differential runs on base vs head are byte-identical), but the split grows production code by 361 lines and creates a second helper directory next to state/_shared_state/.

Production code: +1089/−728 (net +361), with 4 new modules (708 lines) and 6 new types/constants (InteractivityOutcome, _SnapshotArm, ArtifactPaths, RecoveredEnvelope, _HotKernelSummaries, _ROOFLINE_ARMS). A complexity refactor should shrink production code. Bring this to net-zero or negative by deleting mechanisms, not by relocating them.

Blocking

1. Merge conflict in scripts/code_metrics_baseline.txt: rebase on main and regenerate the baseline entries. (Main's Remove the accuracy eval opt-out #1984/fix: stop swallowing failures in 43 non-boundary broad handlers #1986 do not touch the moved code, so this is a textual conflict only.)
2. Net growth above: apply the deletions below and report the new net figure.

Simplify instead of relocate

• Put the new modules under the existing state/_shared_state/ package instead of four state/_*.py files; reuse _shared_state/gap_rows.recency_key and delete _gap_recency_key (gaps.py:77-85).
• _profile_workload.py:35-62: delete the 10 string-name constants; keep the literal (direct, base) pairs and the derived _RUNTIME_KEYS. Replace _sorted_env_map with dict(sorted(_normalize_envs(raw).items())).
• shared_state.py:2015,2041: delete the inner except Exception: pass (pure dict math). Wrap only the PerfModel calls in a narrow except that logs with exc_info=True, and add one entry-level test that calls record_trace_analyze twice and asserts bottleneck_shift. Right now a bug in the five new helpers would be swallowed silently and CI would stay green.
• _trace_analyze.py:129: narrow the carried-over broad except to (OSError, ValueError, AttributeError).

Also fix the stale _build_hot_kernel_summaries references in test_shared_state_kernel_opt.py:284,314. Drop the "Precedent: #1959, #1963, #1992" line too, since all three are still open.

[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 and code-metrics passes. You are right that #1984/#1986 do not touch the moved code, but they do touch these two files, so I checked the merge rather than assuming: #1984's removal of the eval_disabled field from SharedState and #1986's removal of the recipe_kb_traverse_issues block from GapRefreshCollaborator.refresh_gaps are both present in the merged tree, not reverted by the restructuring. shared_state.py is two lines shorter as a result and the baseline entry is lowered to 2264.

Done

• _gap_recency_key is deleted; gap trimming sorts with _shared_state.gap_rows.recency_key, which computed the same key.
• The two advisory handlers around record_trace_analyze no longer swallow. Both log at WARNING with exc_info=True, so a defect in the new helpers now leaves evidence instead of a green run. I kept each handler's scope rather than deleting the inner one: the outer handler already catches, so removing the inner one would stop a saturation failure before maybe_clear_bottleneck_switch_on_drift and the snapshot cap, which is a control-flow change rather than a deletion.
• _trace_analyze.py:129 is narrowed, to (OSError, ValueError, AttributeError, TypeError). I added TypeError to your three: payload.get("kernels") can return a non-iterable, and iterating it raises TypeError, which previously read as an empty sidecar.
• The stale _build_hot_kernel_summaries references in test_shared_state_kernel_opt.py:284,314 now name _trace_analyze._summarize_hot_kernels().
• The "Precedent: refactor(knowledge): match warm-start candidates in a module of their own #1959, refactor(workload): split materialize_config_with_envs into the phases it runs #1963, refactor(kernel): name the work in the orchestrator kernel modules instead of its position #1992" line is gone, and the description now carries the net figure, each new module's line count, and both observable effects above.

Not done, with reasons

• Moving the four modules under state/_shared_state/: shared_state.py imports three of them at module level, and _shared_state/__init__.py is what shared_state.py already imports the mixins from. Putting them there risks a module-level cycle between the package and its parent, which CodeQL flags outright, and the same pattern produced exactly that on refactor(writeback): bring every function in the writeback module under the complexity ceiling #1956. I would rather do the move as its own PR where the import graph is the whole change. Reusing gap_rows.recency_key above is the part of the item that was free of that risk.
• Deleting the ten string-name constants in _profile_workload.py: they are each referenced two or three times across _profile_workload.py, so inlining them scatters about twenty-five literals to save ten lines. Happy to do it if you still want it, but it reads to me as trading one kind of repetition for another.
• Replacing _sorted_env_map with dict(sorted(_normalize_envs(raw).items())): _normalize_envs lives in shared_state.py, which already imports _profile_workload at module level, so importing it back is the cycle above. The clean version is to move _normalize_envs into _profile_workload.py and have shared_state.py import it from there; that belongs with the package move.
• The entry-level test calling record_trace_analyze twice and asserting bottleneck_shift: not added. With the handlers now logging a traceback, a failure in the helpers is visible; I would rather add that test in the same change that makes the handlers fail closed than add it against handlers that still swallow.

Checked and clean: no try: float(...) / except was swapped for hyperloom.common.coerce in this PR, so the inf/nan/bool domain is unchanged; every float( and int( in the diff is the same plain call on both sides. I also re-checked the moved blocks against their guards: next_roofline_snapshot_id still reads the previous last_trace_analyze before the write, _summarize_hot_kernels still runs on the post-recovery envelope and path, and the snapshot-history steps still run in the base order.

Net production figure. +1086 / -729, net +357 (was +361).

[chennyiiis]

PR #2020 -- refactor(orchestrator-state): split SharedState's grading, profile-identity, trace-analyze and gap paths into named steps

What it does: Ten functions in orchestrator/state/{shared_state.py,gaps.py} sat over the repo's complexity ceiling while shared_state.py was already 2639 lines against a 1200-line module ceiling, so the over-limit bodies could not be split in place. This PR names the jobs that were inlined into them and lifts four of those jobs into sibling modules under state/ -- per-axis grading, the profile workload/runtime identity, the trace-analyze projection, and the load-time shape of the explore_search ledger -- leaving shared_state.py at 2264 lines with every function under the ceiling.

Blocking issues: none

Checked: state/shared_state.py (resolve_graded_comparison, profile_workload_context, current_profile_workload_context, from_dict, _langfuse_status_summary, record_trace_analyze, _append_roofline_snapshot_history and its four new methods), state/gaps.py (upsert_gap, _extract_gaps_from_attempts), the four new siblings _graded_comparison.py / _profile_workload.py / _trace_analyze.py / _explore_search_ledger.py, state/_shared_state/gap_rows.py::recency_key, common/coerce.py, phases/machine_state.py::phase_cumulative_seconds, the three consumers that compare profile_workload_context by equality (phases/kernel.py:360, kernel/request_handlers.py:2457, profile_trace_matches_workload), and scripts/code_metrics_baseline.txt | Ran: the four moved-statement order reconstructions (snapshot counter, steady_state_trace, _resolve_snapshot_arm inside the outer try, the lifecycle[-1] read), a head-tree grep for the three deleted names, and the complexity scan at a bar of 20 over both changed modules and the four new ones (prints nothing) | Base: adbc187 | Head: 3f7f5e3

LGTM

[ZhengGong-amd]

Production code is still too large. The net growth is +357 lines (it was +361), 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 6e75d97a2):

	net lines
executable logic	+9
docstrings	+114
def/class signatures	+82
NamedTuple/dataclass fields	+6
blank lines between new defs	+118
imports / __all__	+39

Functions go from 108 to 157, record types from 2 to 7, and total parameters from 138 to 228. Of the 58 new definitions, 34 are referenced exactly once in src/.

The logic barely changed (+9). The growth is the scaffolding around single-use units: their signatures, docstrings, fields and spacing (about +359 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:

• The four state/_*.py sibling modules: put them under the existing state/_shared_state/ package.
• The 10 string-name constants and _sorted_env_map in _profile_workload.py.
• 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]

This PR adds +310 net production lines (+1007/−697, 4 new modules, 53 new functions, 5 NamedTuples). A delete-first reference implementation brings the same seven functions under every threshold at −140 net lines, with 3 new functions, 1 new constant, no new modules or types, and byte-identical output on 656 valid-input cases. Please rework the PR along these lines before merge.

Targets (at merge-base): resolve_graded_comparison (cog 34, 99 lines), profile_workload_context (cog 43), _build_explore_search (cog 45), record_trace_analyze (cog 45, 110 lines), _build_hot_kernel_summaries (cog 36, 87 lines), _append_roofline_snapshot_history (cog 39, 148 lines), upsert_gap (cog 31). None of them is over cc 20. Three functions were not over any threshold, so revert these to base: current_profile_workload_context (keep only the key-tuple swap in Change 2), _langfuse_status_summary, and GapRefreshCollaborator._extract_gaps_from_attempts (cog 30, which is not over).

Delete

1. state/_graded_comparison.py entirely: InteractivityOutcome (value-or-refusal pair), _interactivity_reference, _interactivity_refusals, grade_interactivity, grade_output_throughput, and shared_state._output_grading_reference (single-use pass-throughs). Inline them back into resolve_graded_comparison.
2. state/_explore_search_ledger.py entirely. _normalized_control_values duplicates phase_state._string_list, _winner_controls duplicates phase_state._control_fields, and _normalized_winner/_winner_order/_normalized_winners_history/shape_explore_search are slices. Restore _build_explore_search and call _control_fields(entry).
3. state/_profile_workload.py entirely. The 10 string-alias constants (_EXTRA_SERVER_ARGS … _BASE_ARGS_MODE), the 5 *_SOURCE pairs and _COPIED_SOURCES duplicate _STACK_BASE_FIELDS. _sorted_env_map duplicates _normalize_envs. _normalized_control_list is sorted(set(to_str_list(x))). _TEXT_KEYS, _SHAPE_KEYS, _profile_field, _override_or_base, _resolved_model_path, identity_fields, shape_fields, runtime_fields, serving_config_of and _normalized_server_args are single-use slices. reusable_recorded_runtime, runtime_overrides, merged_runtime_envs, _RUNTIME_KEYS and _BARE_RUNTIME_ACTIONS only serve the out-of-scope function.
4. state/_trace_analyze.py entirely. ArtifactPaths and RecoveredEnvelope are state bags. artifact_paths, recover_from_session_report, next_roofline_snapshot_id and build_trace_analyze_record are pass-throughs. _carries_roofline_signal, _kernel_gpu_pct, _summarize_skipped_kernels, _coded_health_warnings and _analysis_markdown are one-liners or comprehensions to inline. _HotKernelSummaries and _summarize_hot_kernels go too: restore _build_hot_kernel_summaries with the base tuple return. Delete _rocprof_roofline_sidecar as well (_trace_analyze.py:113), which re-parses the file _read_session_roofline_report already parsed. Move _hot_kernel_row, _TOP_N (as _TRACE_HOT_KERNEL_TOP_N) and _ROOFLINE_SIGNAL_KEYS into shared_state.py.
5. In shared_state.py, delete _SnapshotArm, _ROOFLINE_ARMS, _resolve_snapshot_arm, _build_roofline_snapshot, _previous_cycle_snapshot, _newest_snapshot_before_cycle, _bottleneck_shift (5 params) and _cap_roofline_snapshots, and inline them back into _append_roofline_snapshot_history. Also delete _session_status_fields, _explore_runtime_telemetry and _last_lifecycle_fields (out of scope).
6. In gaps.py, delete _new_gap_row, _apply_gap_update and _trim_gaps_to_cap and inline them into upsert_gap. Also delete the dead branch if keep_count > 0 else [] (gaps.py:83): _GAPS_MAX_ENTRIES is the constant 50. Delete _gap_from_failure_row, _group_failures_into_gaps and _explore_plateau_gap (out of scope).

Change

1. In resolve_graded_comparison, move the perf_metric, gain_math and grading imports to module top. Delete the TYPE_CHECKING block and its "import cycle" comment (shared_state.py:28), which is stale: importing either module loads no orchestrator module, and lint-imports stays 10/10. Fold incomparability into the gates and collapse the verdict:

   (incomparability_reason(cand_perf, ref_perf), False),   # 4th gate
   refused = [gate for gate, held in gates if gate and not held]
   cleared = not degrade_reason and gain is not None and gain >= keep_threshold_pct
   sla_veto = constraint_veto_reason(measurement, state) if cleared else ""
   verdict = VERDICT_KEEP if cleared and not sla_veto else VERDICT_REVERT

2. In profile_workload_context, use one module constant PROFILE_OVERRIDABLE_KEYS for the 8 keys. Derive PROFILE_WORKLOAD_IDENTITY_KEYS from it, and use it in current_profile_workload_context as well. Replace the four "direct else base_*" ternaries and the two env loops with the existing helpers:

   runtime = {n: params[n] if n in params else params.get(b) for b, n, _ in _STACK_BASE_FIELDS}
   context["extra_envs"] = dict(sorted(_normalize_envs(runtime["extra_envs"]).items()))
   context["remove_args"] = sorted(set(to_str_list(runtime["remove_args"])))
   **{n: to_int(workload[n] or 0, 0) for n in ("tp", "conc", "isl", "osl", "max_model_len")}

   Flatten the model_path branch out of the loop.
3. In record_trace_analyze, run result = dict(result) once at entry and write each path as a or b or "". Pass disk["payload"] (or {}) to _build_hot_kernel_summaries in place of the path, and build the index from it:

   rocprof_by_kernel_id = {str(r["kernel_id"]): r.get("rocprof_roofline")
                           for r in report.get("kernels") or [] if isinstance(r, dict) and r.get("kernel_id")}

4. In _append_roofline_snapshot_history, write the arm as forced or ("current_best" if current_best tput is a positive number else "baseline"), then choose the achieved resolver by arm. In the shift record, drop the if prev_sat else "" / if previous_snapshot else None guards (shared_state.py:190,192,194), because .get already returns the default.
5. In upsert_gap, write the trim as others[-(_GAPS_MAX_ENTRIES - 1):] + [merged]. Keep your direct attempts slice and gap_rows.recency_key.
6. Add one entry-level test: two record_trace_analyze calls on different macro_cycles, asserting bottleneck_shift from/to/within_delta/prev_cycle.

Keep: PROFILE_OVERRIDABLE_KEYS, _hot_kernel_row, _saturation_delta, _record_bottleneck_saturation (saturation and drift as one method), and the _ROOFLINE_SIGNAL_KEYS name.

Watch out

• to_int is not the old try: int(). True becomes 0 (base gives 1), and inf becomes 0 (base raises OverflowError). to_str_list is not the old _normalized_list either: 0/False become ["0"]/["False"] (base gives []), a dict becomes its repr (base gives its keys), and a scalar 5 becomes ["5"] (base raises). The result persists in last_profile_workload and decides whether a profile is reused, so state this tightening in the PR description or reject those shapes at the boundary.
• _saturation_delta may drop its isinstance checks only because direction_saturation returns float | None.
• When you inline the analysis markdown read under suppress(OSError, ValueError), keep errors="replace".
• Keep the order append → shift → drift → cap.
• record_trace_analyze comes out at exactly 80 lines, so do not add lines there.

This gets every target to cc ≤ 8 / cog ≤ 28 / ≤ 80 lines with net ≤ 0 production lines. After rebasing, regenerate the baseline with scripts/code_metrics.py --update-baseline (11 entries retire), and state the net line count in the PR description.

[chennyiiis]

Reworked delete-first on 5c32506d8. Net production lines against the merge base are −140 (+283/−423, no new modules, no new types, three new functions and one new constant — the ones you asked to keep). CI: 40 checks, 0 failures.

Where the seven targets land

function	Cmetrics	ruff cc	complexipy cog	lines
resolve_graded_comparison	24 → 19	9 → 7	34 → under 30	99 → 74
profile_workload_context	29 → 19	14 → 6	43 → under 30	82 → 52
_build_explore_search	30 → 19	10 → 3	45 → under 30	62 → 47
record_trace_analyze	43 → 34	18 → 6	45 → under 30	110 → 79
_build_hot_kernel_summaries	26 → 12	12 → 5	36 → under 30	87 → 25
_append_roofline_snapshot_history	43 → 13	13 → 4	39 → under 30	148 → 70
upsert_gap	24 → 19	10 → 8	31 → under 30	51 → 37

New: _hot_kernel_row 12 / cc 4, _record_bottleneck_saturation 17 / cc 5, _saturation_delta 3 / cc 2. The eleven baseline entries retire exactly as you predicted (ten removed, module-lines lowered 2620 → 2490); scripts/code_metrics.py --update-baseline reports zero entries out of date.

Delete

1. Done. state/_graded_comparison.py is gone with InteractivityOutcome, _interactivity_reference, _interactivity_refusals, grade_interactivity, grade_output_throughput and shared_state._output_grading_reference; all of it is back inside resolve_graded_comparison.
2. Done. state/_explore_search_ledger.py is gone. I checked phase_state._control_fields against the deleted _winner_controls line by line (including _string_list vs _normalized_control_values): same coercion, same "omit when default", same args_mode rule. _build_explore_search now calls _control_fields(entry). I also deleted the degenerate one-element for source_list in (… ,) loop while I was in there.
3. Done. state/_profile_workload.py is gone. The ten string aliases and the five *_SOURCE pairs did duplicate _STACK_BASE_FIELDS, so the runtime fields are now read straight off it; _sorted_env_map duplicated _normalize_envs; _normalized_control_list was sorted(set(to_str_list(…))). The out-of-scope reusable_recorded_runtime, runtime_overrides, merged_runtime_envs, _RUNTIME_KEYS and _BARE_RUNTIME_ACTIONS went with it.
4. Done. state/_trace_analyze.py is gone, _rocprof_roofline_sidecar included — it re-read and re-parsed exactly the file _read_session_roofline_report had already parsed one call earlier. _hot_kernel_row, _TRACE_HOT_KERNEL_TOP_N and _ROOFLINE_SIGNAL_KEYS live in shared_state.py now; _build_hot_kernel_summaries is back to the base tuple return. I also removed the dead breakdown = RooflineBreakdown(0.0, 0.0, 0.0, "unknown") store that both roofline writers overwrote on the next line.
5. Done. _SnapshotArm, _ROOFLINE_ARMS, _resolve_snapshot_arm, _build_roofline_snapshot, _previous_cycle_snapshot, _newest_snapshot_before_cycle, _bottleneck_shift, _cap_roofline_snapshots, _session_status_fields, _explore_runtime_telemetry and _last_lifecycle_fields are all gone.
6. Done. _new_gap_row, _apply_gap_update, _trim_gaps_to_cap, _gap_from_failure_row, _group_failures_into_gaps and _explore_plateau_gap are gone. The if keep_count > 0 else [] branch was indeed unreachable — keep_count is _GAPS_MAX_ENTRIES - 1 = 49 — and is deleted.

Reverted to base as asked: current_profile_workload_context (only the PROFILE_OVERRIDABLE_KEYS swap from Change 2 kept), _langfuse_status_summary, GapRefreshCollaborator._extract_gaps_from_attempts.

Change

1. Done. perf_metric, gain_math and grading import at module top. The TYPE_CHECKING block and its "import cycle" comment were stale as you said — importing any of the three loads no orchestrator module (checked with a fresh interpreter), and import-linter is green on CI. Incomparability is the fourth gate with the gate and not held filter, and the verdict is your four lines.
2. Done. One PROFILE_OVERRIDABLE_KEYS; PROFILE_WORKLOAD_IDENTITY_KEYS is ("benchmark_mode", *PROFILE_OVERRIDABLE_KEYS) and current_profile_workload_context uses it too. The four ternaries and both env loops are the three lines you gave, and model_path is flattened out of the loop.
3. Done. result = dict(result) once at entry, each path as a or b or "", and _build_hot_kernel_summaries takes disk["payload"] (or {}) with the index built from it. It comes out at 79 lines.
4. Done. The arm is forced or ("current_best" if the current-best tput is a positive number else "baseline") and the achieved resolver is chosen by arm — identical because first_positive_tput returns that same tput when it is positive. The if prev_sat else "" / if previous_snapshot else None guards are gone.
5. Done. others[-(_GAPS_MAX_ENTRIES - 1):] + [merged], the direct attempts slice, and gap_rows.recency_key in place of the local _sort_key clone.
6. Done. test_bottleneck_shift_is_stamped_against_the_previous_macro_cycle in test_record_trace_analyze_lock.py: two record_trace_analyze calls on macro cycles 3 and 4, asserting from/to/prev_cycle/within_delta.

Kept: PROFILE_OVERRIDABLE_KEYS, _hot_kernel_row, _saturation_delta, _record_bottleneck_saturation (saturation and drift in one method), _ROOFLINE_SIGNAL_KEYS. The watch-outs are all honoured: _saturation_delta drops its isinstance checks only (direction_saturation returns float | None), the markdown read keeps errors="replace" under suppress(OSError, ValueError), the order is still append → shift → drift → cap.

One target did not reach the external Cmetrics ceiling

Our scope also has to measure < 20 on Cmetrics, which counts every and/or operand, every ternary and every comprehension clause on top of the branch count. Six of the seven get there by deleting. record_trace_analyze does not: 43 → 34. What is left is not duplication or dead code — it is twenty-three x or "" / x or [] defaults over an untyped result envelope plus four isinstance narrowings, and each one is a distinct persisted default. Deleting any of them changes what lands in last_trace_analyze. Re-extracting them is what you asked me to stop doing, so I have left it inlined and reverted: cc 6, cog under 30, 79 lines, under every repo threshold. Getting it under 20 on Cmetrics needs a typed envelope at the trace_analyze boundary, which is a larger change than this PR.

For the same reason three reverted functions sit above 20 on Cmetrics while being byte-identical to main: _extract_gaps_from_attempts 29, current_profile_workload_context 24, _langfuse_status_summary 22. They are over no repo threshold, as you noted.

One thing I could not do

You asked for the to_int / to_str_list tightening to be stated in the PR description. I was told not to edit the description on this pass, so it is in the commit message instead: True now reads as 0 rather than 1, a non-finite float as 0 rather than raising OverflowError, and a bare scalar or a dict as its string rather than being dropped — and the result persists in last_profile_workload, which decides whether a profile trace is reused. Say the word and I will move it into the description, or reject those shapes at the boundary instead.

[chennyiiis]

Follow-up on cb2152275: origin/main moved to ba808c37c (it now carries #1896, #1998, #1959 and #2046), so I merged it in -- merge commit, not a rebase, so the review history stays addressable. Nothing in the merge touched shared_state.py or gaps.py, and the delete-first rework described above is unchanged.

Re-measured against the new merge base:

• Net production lines: -140 (+283/-423). Still no new module, no new type; three new functions and one new constant, the ones you asked to keep.
• Docstrings: zero net growth. shared_state.py 107 -> 108 and gaps.py 24 -> 23 against main, 131 lines either way.
• Baseline: scripts/code_metrics.py --update-baseline on the merged tree reports 832 entries, 0 lowered, 0 added -- the eleven entries retired in the rework commit and nothing new is owed. scripts/code_metrics.py passes.
• CI: 40 checks, 0 failures. The first run after the merge showed three red, all one cause: py3.11 shard 5 passed its 4373 tests and then failed to upload its coverage artifact, so Enforce shard results reported MISSING_SHARDS: shard5 with TESTS_OK: true and both coverage jobs cascaded. A rerun of the failed jobs is green.
• Tests re-run locally on the merged tree: state/tests plus test_record_trace_analyze_lock.py, 46 passed, including the new test_bottleneck_shift_is_stamped_against_the_previous_macro_cycle.

The Cmetrics picture is unchanged, and so is the one blocker: record_trace_analyze sits at 34, with the weight in nineteen or-operands and four isinstance narrowings over the untyped trace_analyze result envelope, each of which is a distinct persisted default in last_trace_analyze. The three functions reverted to base -- _extract_gaps_from_attempts 29, current_profile_workload_context 24 (key-tuple swap only), _langfuse_status_summary 22 -- are byte-identical to main and over no repo threshold, as you noted. I have not re-extracted any of them.

Nothing else changed: no PR description edit, no baseline-raise, no e2e, no test weakened.

[chaojhou]

PR #2020 -- refactor(orchestrator-state): delete the duplicated grading, profile-identity and trace-analyze paths

What it does: Shrinks seven over-trigger bodies in orchestrator/state/shared_state.py and state/gaps.py by deleting logic other owners already provide: winners-history controls now come from phase_state._control_fields, gap trimming from gap_rows.recency_key, profile runtime fields from _STACK_BASE_FIELDS with coerce.to_int/to_str_list, and the hot-kernel row and bottleneck-saturation bookkeeping become _hot_kernel_row and _record_bottleneck_saturation. Production code is 134 lines smaller. A base-vs-head differential run over generated inputs gave identical output for valid inputs. Output differs only on the malformed-input coercions the description names, plus two it does not (see below; not blocking).

Blocking issues: 1

1. [V5] The PR now conflicts with main, and the conflict is in the hot-kernel row this PR moved [verified]
   Problem: #2087 merged into main at 4371269 (2026-10-22 03:31Z), after this branch's last merge of main. It added "call_count" and "duration_us" to the hot-kernel summary row inside _build_hot_kernel_summaries. This PR moved that same row into _hot_kernel_row at src/hyperloom/orchestrator/state/shared_state.py:291, so the PR's copy lacks both keys. gh pr view 2020 reports mergeable: CONFLICTING. git merge-tree main b0969ef4 conflicts in shared_state.py (that block) and in scripts/code_metrics_baseline.txt, where main's module-lines ... shared_state.py is 2548 and this PR's is 2425.
   Impact: The PR cannot merge. A resolution that keeps the PR side of the block silently removes call_count/duration_us from last_trace_analyze.hot_kernels_top15 and undoes #2087's report fix.
   Action: Merge current main. Add "call_count": entry.get("call_count") and "duration_us": entry.get("duration_us") to _hot_kernel_row after gpu_pct. Regenerate the baseline with scripts/code_metrics.py --update-baseline. Then confirm #2087's test_record_trace_analyze_disk_recovery.py::test_discovered_kernel_rows_carry_call_count_and_duration passes on the merged head.

SKIPPED: V4 -- # PARTIAL: lines for #1869, #1276, #1154, #1032 in openprs.txt; overlap with those PRs is unchecked.

Checked: shared_state.py at base bb2da63 vs head b0969ef for every moved/split unit: resolve_graded_comparison (both axes), profile_workload_context, current_profile_workload_context key swap, _build_explore_search vs phase_state._control_fields/_string_list, record_trace_analyze, _build_hot_kernel_summaries/_hot_kernel_row, _append_roofline_snapshot_history/_record_bottleneck_saturation/_saturation_delta, record_baseline_roofline_ceiling, append_stack_gain_entry; gaps.py upsert_gap vs gap_rows.recency_key; coerce.to_int/to_str_list, gain_math.gain_pct/gain_pct_or_zero, perf_metric.perf_snapshot_from_mapping/axis_of, roofline_snapshot.direction_saturation, roofline_ceiling.compute_roofline_breakdown_from_state; tree-wide grep of roofline_snapshots writers and of the callers of every reshaped function; main 4371269's _build_hot_kernel_summaries | Ran: differential harness on base and head src (6500 cases: 3000 profile_workload_context, 2000 resolve_graded_comparison, 1000 _build_explore_search, 200x60 upsert_gap, 300 record_trace_analyze) -> 0 diffs for grading/explore/gaps; profile diffs only on bool/inf/0/False/dict/scalar inputs; trace-analyze diffs only on a bool roofline_snapshot_id; head test_record_trace_analyze_lock.py run against base src (6 passed); ruff C901 head vs base on both files; fresh-interpreter import of gaps/grading/perf_metric/shared_state; gh pr view 2020 --json mergeable; git merge-tree main b0969ef; independent reader re-ran gh pr view and git merge-tree --write-tree origin/main(4371269) b0969ef | Base: bb2da63 | Head: b0969ef

[chaojhou]

PR #2020 -- refactor(orchestrator-state): delete the duplicated grading, profile-identity and trace-analyze paths

What it does: Shrinks seven over-trigger bodies in orchestrator/state/shared_state.py and state/gaps.py by deleting logic other owners already provide: winners-history controls now come from phase_state._control_fields, gap trimming from gap_rows.recency_key, profile runtime fields from _STACK_BASE_FIELDS with coerce.to_int/to_str_list, and the hot-kernel row and bottleneck-saturation bookkeeping become _hot_kernel_row and _record_bottleneck_saturation. Production code is 134 lines smaller. A base-vs-head differential run over generated inputs gave identical output for valid inputs. Output differs only on the malformed-input coercions the description names, plus two it does not (see below; not blocking).

Blocking issues: none

Checked: shared_state.py at base bb2da63 vs head b0969ef for every moved/split unit: resolve_graded_comparison (both axes), profile_workload_context, current_profile_workload_context key swap, _build_explore_search vs phase_state._control_fields/_string_list, record_trace_analyze, _build_hot_kernel_summaries/_hot_kernel_row, _append_roofline_snapshot_history/_record_bottleneck_saturation/_saturation_delta, record_baseline_roofline_ceiling, append_stack_gain_entry; gaps.py upsert_gap vs gap_rows.recency_key; coerce.to_int/to_str_list, gain_math.gain_pct/gain_pct_or_zero, perf_metric.perf_snapshot_from_mapping/axis_of, roofline_snapshot.direction_saturation, roofline_ceiling.compute_roofline_breakdown_from_state; tree-wide grep of roofline_snapshots writers and of the callers of every reshaped function; main 4371269's _build_hot_kernel_summaries | Ran: differential harness on base and head src (6500 cases: 3000 profile_workload_context, 2000 resolve_graded_comparison, 1000 _build_explore_search, 200x60 upsert_gap, 300 record_trace_analyze) -> 0 diffs for grading/explore/gaps; profile diffs only on bool/inf/0/False/dict/scalar inputs; trace-analyze diffs only on a bool roofline_snapshot_id; head test_record_trace_analyze_lock.py run against base src (6 passed); ruff C901 head vs base on both files; fresh-interpreter import of gaps/grading/perf_metric/shared_state; gh pr view 2020 --json mergeable; git merge-tree main b0969ef; independent reader re-ran gh pr view and git merge-tree --write-tree origin/main(4371269) b0969ef | Re-review at 6045eb3: the earlier [V5] is resolved -- the branch merges main (incl. #2087) and git merge-tree with origin/main is clean; _hot_kernel_row keeps call_count and duration_us (shared_state.py:305-306); non-baseline diff against main has the same patch-id as at b2e5d2b and the body is unchanged; baseline only removes 8 entries and lowers shared_state.py module-lines; CI green | Base: bb2da63 | Head: 6045eb3

LGTM