better compile times for throughput scheduling

fix failing no-plan throughput ablation runs
update results

docs/compiler/scheduling.md

@@ -63,8 +63,11 @@ lanes of an operation and computes one ordered partition with a prefix DP.
 The DP jointly assigns operation prefixes and at most sixteen units of spare
 core capacity. Each configured stage reserves one physical core. Quantization
 limits initialization only; refinement uses geometric core transfers, including one core.
-Quantization can miss a feasible allocation. Initialization failure reports a
-bounded-search limitation, not proved hardware infeasibility.
+If the quality grid has no feasible state, a minimum-resource prefix DP checks
+every physical core count for each segment. This preserves feasibility over
+the segment assignments found by the constructive packers, independently of
+resource quantization. Packing failure remains a bounded-search limitation,
+not proved hardware infeasibility.
 The seed minimizes maximum stage packing/dependency priority over the legal
 active-stage counts within the configured depth. These priorities provide
 a starting point, not a timing guarantee. Refinement can remove stage boundaries.
@@ -76,6 +79,13 @@ constructive ordered-packing curves and uses reuse-first resident-weight packing
 when order alone cannot realize a capacity bound. A feasible packing remains
 feasible with idle extra cores. All placements pass the existing topology-aware
 physical packing, operation-group, adjacency and capacity checks.
+Ordered packing returns an unavailable cost when no ordered assignment fits.
+Every finite feasibility cost has an ordered or reuse-first constructive assignment.
+Initialization retains that assignment before adding idle spare cores. If topology-aware
+greedy placement and reconstruction in physical task order fail, it uses the
+retained assignment.
+Task reordering cannot discard the initial partition's constructive capacity evidence.
+This evidence does not prove final backend legality.
 
 Refinement uses a beam of two schedules ranked by the larger queue estimate.
 Its ordered neighborhood moves operation groups across adjacent stage boundaries,
@@ -163,7 +173,9 @@ Unsupported or incomplete target timing produces an `unavailable` report.
 
 The analysis brackets the maximum cycle ratio within one nanosecond. It tests
 edge delays `w - II*d`, sweeping the distance-zero DAG between recurrence
-relaxations. At most `R+1` sweeps detect a positive cycle, where `R` counts
+relaxations. A positive predecessor cycle can terminate an infeasible probe early.
+The final witness pass retains the full relaxation procedure and deterministic
+witness selection. At most `R+1` sweeps detect a positive cycle, where `R` counts
 positive-distance edges. Bisection uses at most 64 tests. Timing outside the
 supported numeric range produces an explicit unavailable result. A predecessor
 cycle supplies a witness, including delay, iteration distance, cores, and links.
@@ -337,6 +349,11 @@ Functional simulation still executes Softmax. Estimated timing and energy exclud
 The shared queue engine models controller arrival arbitration and cross-generation dependencies.
 The compiler does not execute candidate programs or invoke a simulator.
 
+Spatial extraction permits at most one million operation visits per physical core.
+The total visit count is diagnostic; adding cores does not reduce another core's analysis allowance.
+Abstract queue construction permits two million non-work event visits per candidate.
+The complete-state recurrence limits remain unchanged.
+
 Both arbitration policies must establish complete-state recurrence within bounded analysis budgets.
 Their estimates are sensitivity checks, not formal bounds.
 The candidate with the lowest larger estimate must separate from the initialized schedule.
@@ -362,6 +379,8 @@ If every candidate fails, one diagnostic lists all attempted candidates and caus
 
 `reports/pipeline_selection.json` records Spatial costs, eligibility, selection, and backend attempts.
 It also records search parents, compact task-stage runs, core budgets, recurrence contributions, termination, attempts, queue budget, and phase times.
+Phase times separate neighborhood scoring, constructive packing, dependency-witness
+analysis, and queue execution with its complete-state proof.
 `--enable-timing` adds per-pass lowering times and IR operation/value counts.
 Final instruction generation uses the normal compiler timing report.
 Explicit Spatial exports and IR dumps reconstruct pre-lowering artifacts for the selected schedule.
@@ -424,7 +443,8 @@ fragment/consumer demands, and resource quantization `Q <= 16`.
 | Weight indexing | Up to `O(R W)` equality comparisons |
 | Weight lower bounds | `O(R + W)` / `O(W)` bits |
 | Constructive best fit | `O(T log T + P R + P W)` / `O(P W)` bits plus `O(T + P)`; bounded retries only on failure |
-| Joint initialization DP | `O(G² Q Kpack + S G² Q²)` time / `O(G² Q + S G Q)` storage; `Kpack` is one ordered-pack cost query |
+| Joint initialization DP | `O(G² Q Kpack + S G² Q²)` time / `O(G² Q + S G Q)` storage; `Kpack` is one constructive pack-cost query |
+| Feasibility completion, only if the quality grid fails | `O(G² P Kpack + S G²)` time / `O(G² + S G)` additional storage |
 | Neighborhood memory service | Expected `O(T + F)` per partition / `O(T + F)` scratch |
 | Topology clustering / cached PEFT distances | `O(P²)` time |
 | Concat cost extraction | `O(A D)` for `A` inputs of rank `D`; constant auxiliary space |