fix(dflash): transactional draft ctors, emitter-error rollback, one ctx-cap predicate

[Kaden-Schutt]

Summary

Three verified defects from the DFlash audit (docs/plans/audit-2026-09-02/audit-Dflash.md, PR #685):

1. Transactional draft constructors (Broken 3). DflashWeights::load, DflashScratch::new_with_mq / new_windowed, and dflash_generic::build_generic_dflash_speculator ?-ed out mid-construction leaving earlier alloc_tensors allocated (GpuTensor / DeviceBuffer have no Drop). Every allocation site now frees on the error path in the or_free! style of load_dflash_state; new_windowed frees the popped base scratch on any post-pop failure; the generic builder frees weights on scratch failure. DflashLayerWeights::free_gpu is shared by the success and error paths. Success path unchanged.
2. make_spec_emitter Err rollback (Broken 4). The one post-prefill error exit in generate_spec that returned without production_fail_closed_rollback_live — leaving advanced target KV / DeltaNet / drafter hidden behind cleared host counters for the next turn to LCP against — now rolls back first, like the adjacent prefill and step Err arms.
3. One ctx-cap predicate (Broken 5). generate_dflash fell back to AR at prompt + max_tokens > cap, generate_spec then errored at prompt + max_tokens + block_size > cap after gen_start. common::spec_ctx_request_fits is used at both sites, so the block-size band falls back to AR at entry. The mid-loop position + block_size >= cap break now sets SpecRun::ctx_exhausted, reported as finish_reason=length with no tool release and no cache store (via the existing qwen_dflash_hit_length_cap → wire-terminal path) instead of a natural stop that could prime the cache.

Which crate(s) does this touch?

• crates/hipfire-runtime (dflash.rs, dflash_generic.rs), crates/hipfire-generate (qwen.rs, common.rs, dense.rs epilogue)

Evidence

• Happy path unchanged (RX 7900 XTX, 710bc645e, HIPFIRE_DFLASH_DRAFT pinned, humaneval fixture md5 37c5aad9…): hipfire bench --spec dflash 202.1 tok/s [200.3, 202.1, 203.4], τ=10.55 — identical to the pairing branch and master-with-pin. hipfire run on the same prompt with thinking on: correct below_zero, τ=4.51.
• The error paths themselves need allocation-failure injection to exercise on hardware; there is no such harness. They are covered by construction (every site listed in commit 034fe7801) and by the unit tests below.

Test plan

• cargo test -p hipfire-runtime -p hipfire-generate — runtime lib 597, generate lib 16 (new spec_ctx_request_fits_holds_one_block_margin: exact cap, cap±1, the prompt+max==cap band, zero block, saturating overflow), qwen_dflash_ctx_exhausted_tests (new file; generated < max_tokens still terminates length / no store) — 0 failures across all suites.
• Hardware happy path above.

Note on layout: the new terminal test lives in its own file because qwen_dflash_semantic_terminal_tests.rs carries rustfmt debt and CI enforces rustfmt on changed files — adding one test there forces a 6k-line reformat.

[hipfire-sol]

hw-gate sol prelim

summary: This stacked change makes DFlash weight and scratch construction release already-allocated GPU resources on later failures, rolls back live target/speculator state when emitter creation fails after prefill, unifies draft-context admission and exhaustion terminal handling, adds verbatim benchmark prompt files and prompt evidence, narrows plain-Llama MQ-V2 batched-prefill admission, and updates MQ4-V2 parity coverage and kernel documentation. Runtime filesystem access is limited to an explicitly supplied --prompt-file; the new md5 dependency only hashes prompt bytes. No unexplained unsafe code, credential access, process spawning, build-script changes, or runtime network access is introduced.

run_hardware: true
run_hardware_reasons: The executable changes are ordinary Rust/HIP runtime code and are safe to run on the workstation.; --prompt-file reads only the user-selected path and performs no writes or implicit path traversal.; The md5 crate is used solely for deterministic prompt evidence and introduces no runtime network or process behavior.; Real fixtures are required to detect load/admission regressions and to eyeball speculative state-machine output.; MQ-V2 kernel/parity-related changes require the available gfx12 R9700 evidence even though the two kernel-file edits shown are comments.

routes:

mode	tag	source	why
battery	qwen3.6:27b	bucket	bucket kernel,load,serve
chain	qwen3.6:27b	bucket	bucket kernel,load,serve
battery	ornith-1.5:35b-a3b-mq4r	bucket	bucket kernel,load,serve
chain	ornith-1.5:35b-a3b-mq4r	bucket	bucket kernel,load,serve
battery	lfm2.5:1.2b	bucket	bucket kernel,load,serve
chain	lfm2.5:1.2b	bucket	bucket kernel,load,serve
battery	qwen3.8:27b-mq4-xt	bucket	bucket kernel,load,serve
chain	qwen3.8:27b-mq4-xt	bucket	bucket kernel,load,serve

unavailable_routes:

(none)

claim_assessment: The author claims complete transactional cleanup for draft constructors, post-prefill rollback on emitter failure, and consistent context-cap fallback/length semantics. Normal fixture runs can establish successful load and coherent serve behavior, including MQ-V2 admission, but they cannot prove allocation-failure cleanup or emitter-construction rollback without fault injection. The diff supports cleanup for Result-returning allocation failures, while malformed-codebook panics and the target mutation before new_spec_scratch remain outside that guarantee.

[hipfire-sol]

hw-gate evidence — 2 lane(s) — verdict pass

lane hiptrx (gfx1201)

hw-gate evidence

field	value
base	e98b4612fc39da39a9752a0b3e67e34dcd4b95cb
head	31dd5e306c609bb91e5c4e8eac6df70c397395f6
buckets	kernel,load,serve
host gfx	gfx1201
host rocm	7.15.26333-0000000
device	3
runner	hiptrx
daemon_md5	6c8687d268d651ab050436b583256476
hipfire_md5	2d8890879199a198e9ca005a83540263
build_seconds	40.28949689865112
verdict	pass
logs_dir	hw-gate-logs

fixtures

qwen3.6:27b

source: bucket sha256_ok: ✅ size_ok: ✅ status: pass reason:

battery — exit 0 seconds 50.2 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
battery	0		stop	34	0	132	62	1.8	14.2	False	False	False	True
battery	1		stop	30	0	82	70	453.0	31.2	False	False	False	True
battery	2		stop	31	0	17	14	486.4	31.3	False	False	False	True
battery	3		stop	47	0	31	8	529.3	31.2	False	False	False	True
battery	4		stop	47	0	6	2	535.8	31.2	False	False	False	True

qwen3.6:27b battery turn 0

```python
def longest_substring_without_repeating(s: str) -> str:
    char_index = {}
    start = 0
    max_start = 0
    max_length = 0

    for end, char in enumerate(s):
        if char in char_index and char_index[char] >= start:
            start = char_index[char] + 1
        
        char_index[char] = end
        
        if end - start + 1 > max_length:
            max_length = end - start + 1
            max_start = start

    return s[max_start:max_start + max_length]
```

qwen3.6:27b battery turn 1

During the day, sunlight passes through less atmosphere, causing shorter blue wavelengths to scatter in all directions via Rayleigh scattering, which makes the sky appear blue. As the sun sets, light travels through a thicker layer of the atmosphere, scattering away most of the blue and green light before it reaches your eyes. Consequently, only the longer red and orange wavelengths remain dominant, casting a warm hue across the sky.

qwen3.6:27b battery turn 2

The capital of France is Paris, which is run through by the River Seine.

qwen3.6:27b battery turn 3

{
  "name": "Alice",
  "age": 34,
  "city": "Lisbon"
}

qwen3.6:27b battery turn 4

Answer: 43

chain — exit 0 seconds 42.8 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
chain	0		stop	44	0	169	76	5.7	30.9	False	False	False	True
chain	1		stop	269	214	205	117	394.9	30.9	False	False	False	True
chain	2		stop	500	475	78	64	277.9	30.9	False	False	False	True
chain	3		stop	612	579	85	68	288.3	30.9	False	False	False	True
chain	4		stop	729	698	68	50	332.9	30.9	False	False	False	True

qwen3.6:27b chain turn 0

```python
def merge_sorted(a, b):
    """
    Merge two already-sorted lists into one sorted list without using sorted().
    
    Args:
        a: A sorted list.
        b: A sorted list.
    
    Returns:
        A new sorted list containing all elements from a and b.
    """
    merged = []
    i, j = 0, 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            merged.append(a[i])
            i += 1
        else:
            merged.append(b[j])
            j += 1
    # Append remaining elements
    merged.extend(a[i:])
    merged.extend(b[j:])
    return merged
```

qwen3.6:27b chain turn 1

To find the total distance traveled, we calculate the distance for each segment of the trip and then add them together.

**Step 1: Calculate the distance for the first segment.**
*   Speed = 60 mph
*   Time = 2.5 hours
*   Distance = Speed × Time
*   $60 \times 2.5 = 150$ miles

**Step 2: Calculate the distance for the second segment.**
*   Speed = 40 mph
*   Time = 1.5 hours
*   Distance = Speed × Time
*   $40 \times 1.5 = 60$ miles

**Step 3: Calculate the total distance.**
*   Total Distance = Distance (Segment 1) + Distance (Segment 2)
*   $150 + 60 = 210$ miles

The train traveled a total of **210** miles.

qwen3.6:27b chain turn 2

The seasons are caused by the Earth's axial tilt of approximately 23.5 degrees relative to its orbital plane around the Sun. This tilt means that different hemispheres receive varying intensities and durations of sunlight throughout the year as the Earth orbits. When a hemisphere is tilted toward the Sun, it experiences summer due to more direct sunlight, while the hemisphere tilted away experiences winter.

qwen3.6:27b chain turn 3

Elias had spent thirty years keeping the light, seeing only debris and dead fish wash ashore after the nightly storms. One particularly foggy morning, however, he found a small, sealed glass bottle tangled in the kelp-covered rocks. Inside lay a map drawn on parchment, detailing a treasure location that seemed impossibly old. He stared at the artifact, wondering if his solitary life was finally about to change forever.

qwen3.6:27b chain turn 4

1. Use clear and descriptive names for variables and functions.
2. Keep functions small and focused on a single task.
3. Write comprehensive comments and documentation for complex logic.
4. Consistently follow a defined coding style and formatting guide.
5. Regularly refactor code to reduce technical debt and improve readability.

ornith-1.5:35b-a3b-mq4r

source: bucket sha256_ok: ✅ size_ok: ✅ status: pass reason:

battery — exit 0 seconds 88.8 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
battery	0		stop	34	0	128	61	23.1	6.4	False	False	False	True
battery	1		stop	30	0	102	92	107.7	7.9	False	False	False	True
battery	2		stop	31	0	16	13	111.3	9.9	False	False	False	True
battery	3		stop	47	0	31	8	159.9	13.3	False	False	False	True
battery	4		stop	47	0	17	7	160.0	7.4	False	False	False	True

ornith-1.5:35b-a3b-mq4r battery turn 0

```python
def longest_substring(s: str) -> str:
    seen = {}
    start = 0
    max_len = 0
    max_start = 0
    
    for end in range(len(s)):
        if s[end] in seen and seen[s[end]] >= start:
            start = seen[s[end]] + 1
        seen[s[end]] = end
        if end - start + 1 > max_len:
            max_len = end - start + 1
            max_start = start
    
    return s[max_start:max_start + max_len]
```

ornith-1.5:35b-a3b-mq4r battery turn 1

The sky appears blue during the day because sunlight interacts with gases in the atmosphere through a process called Rayleigh scattering, in which shorter blue wavelengths scatter more effectively off tiny air molecules than longer wavelengths. This scattered blue light is then spread across the entire sky, reaching your eyes from all directions. At sunset, the Sun sits lower on the horizon, meaning its light travels through a much thicker layer of atmosphere, scattering away the blue light entirely and leaving the longer red and orange wavelengths to dominate what you see.

ornith-1.5:35b-a3b-mq4r battery turn 2

The capital of France is Paris, and the River Seine runs through it.

ornith-1.5:35b-a3b-mq4r battery turn 3

{
  "name": "Alice",
  "age": 34,
  "city": "Lisbon"
}

ornith-1.5:35b-a3b-mq4r battery turn 4

17 + 26 = 43

Answer: 43

chain — exit 0 seconds 116.5 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
chain	0		length	44	0	256	147	474.2	9.5	False	False	True	True
chain	1		stop	353	0	105	41	154.1	10.2	False	False	False	True
chain	2		stop	484	458	76	61	116.5	6.8	False	False	False	True
chain	3		stop	594	560	103	77	146.4	6.9	False	False	False	True
chain	4		stop	729	697	121	93	119.7	8.1	False	False	False	True

ornith-1.5:35b-a3b-mq4r chain turn 0

```python
def merge_sorted(a, b):
    """Merge two sorted lists into a single sorted list (no sorted() used)."""
    result = []
    i = j = 0

    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            result.append(a[i])
            i += 1
        else:
            result.append(b[j])
            j += 1

    # Append any remaining items (at most one list is exhausted)
    result.extend(a[i:])
    result.extend(b[j:])
    return result
```

**How it works**

This uses the classic "two-pointer" merge strategy (the core of merge sort):

1. Pointers `i` and `j` start at the beginning of `a` and `b`.
2. Compare the current elements; append the smaller one and advance that pointer.
3. When one list is exhausted, append whatever remains in the other.

It runs in **O(n + m)** time and returns a **new list** without mutating the inputs. Equal elements are stable — elements from `a` are placed before equal elements from `b` — which

ornith-1.5:35b-a3b-mq4r chain turn 1

# Train Distance Calculation

**Segment 1:** 60 mph for 2.5 hours
$$60 \times 2.5 = 150 \text{ miles}$$

**Segment 2:** 40 mph for 1.5 hours
$$40 \times 1.5 = 60 \text{ miles}$$

**Total distance:**
$$150 + 60 = \boxed{210 \text{ miles}}$$

ornith-1.5:35b-a3b-mq4r chain turn 2

The seasons are caused by the 23.5-degree tilt of Earth's axis relative to its orbital plane around the Sun. As Earth orbits the Sun throughout the year, different hemispheres lean toward or away from the Sun, changing how directly sunlight strikes the surface. This variation in the angle and duration of sunlight produces the cyclical shift between warm and cold seasons.

ornith-1.5:35b-a3b-mq4r chain turn 3

Old Maren had charted the storms that battered the headland for forty years, so nothing the sea offered could truly surprise her anymore. That was until dawn revealed not driftwood or drowned fish, but a small wooden chest bound in rusted iron, half-buried in the black rocks. She pried it open with trembling hands, expecting coins or the rusted trinkets of some long-forgotten sailor. Instead, inside lay a single, perfectly preserved letter addressed to her by name.

ornith-1.5:35b-a3b-mq4r chain turn 4

1. Use clear, descriptive names for variables, functions, and modules so the code's purpose is obvious at a glance.
2. Keep functions small and focused on doing a single task to make them easy to read, test, and reuse.
3. Write consistent formatting and follow an established style guide so the whole codebase reads as one voice.
4. Add concise comments that explain the "why" behind non-obvious logic rather than restating what the code already does.
5. Cover critical logic with automated tests so changes can be made confidently without introducing hidden regressions.

lfm2.5:1.2b

source: bucket sha256_ok: ✅ size_ok: ✅ status: pass reason:

battery — exit 0 seconds 9.0 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
battery	0		stop	0	0	125	60	None	144.84	False	False	False	True
battery	1		stop	0	0	81	71	None	145.68	False	False	False	True
battery	2		stop	0	0	15	13	None	145.63	False	False	False	True
battery	3		stop	0	0	26	8	None	146.07	False	False	False	True
battery	4		stop	0	0	20	11	None	145.99	False	False	False	True

lfm2.5:1.2b battery turn 0

```python
def longest_substring_without_repeats(s):
    seen = set()
    start = 0
    max_len = 0
    max_sub = ""

    for i, char in enumerate(s):
        if char in seen:
            while start < i and char in seen:
                seen.remove(s[start])
                start += 1
        seen.add(char)
        if i + 1 - start > max_len:
            max_len = i - start + 1
            max_sub = s[start:i + 1]
    return max_sub
```

lfm2.5:1.2b battery turn 1

The blue sky during the day occurs because of Rayleigh scattering, where the shorter blue wavelengths of light scatter in all directions when interacting with the atmosphere. At sunset, the sunlight travels through more of the Earth's atmosphere, scattering away the red and orange wavelengths, leaving the longer blue wavelengths to dominate the transmitted light. This is why we perceive a red or orange sunset and a blue sky at midday.

lfm2.5:1.2b battery turn 2

The capital of France is Paris, and the Seine river runs through it.

lfm2.5:1.2b battery turn 3

{
  "name": "Alice",
  "age": 34,
  "city": "Lisbon"
}

lfm2.5:1.2b battery turn 4

Let's calculate the sum:  
17 + 26 equals 43.  
Answer: 43

chain — exit 0 seconds 20.0 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
chain	0		stop	0	0	256	136	None	143.34	False	False	False	True
chain	1		stop	0	0	118	81	None	137.21	False	False	False	True
chain	2		stop	0	0	59	50	None	134.4	False	False	False	True
chain	3		stop	0	0	88	66	None	131.15	False	False	False	True
chain	4		stop	0	0	72	54	None	129.26	False	False	False	True

lfm2.5:1.2b chain turn 0

Here's a Python function `merge_sorted(a, b)` that merges two sorted lists into one sorted list without using `sorted()`.

```python
def merge_sorted(a, b):
    """
    Merges two already-sorted lists into a single sorted list.
    
    Parameters:
    a (list): First sorted list
    b (list): Second sorted list
    
    Returns:
    list: A new sorted list containing all elements from a and b.
    """
    merged = []
    i, j = 0, 0

    # Traverse both lists and append smaller element
    while i < len(a) and j < len(b):
        if a[i] < b[j]:
            merged.append(a[i])
            i += 1
        else:
            merged.append(b[j])
            j += 1

    # Append remaining elements from list a, if any
    while i < len(a):
        merged.append(a[i])
        i += 1

    # Append remaining elements from list b, if any
    while j < len(b):
        merged.append(b[j])
        j += 1

    return merged
```

This function uses a two-pointer

lfm2.5:1.2b chain turn 1

Here are the steps to calculate the total distance traveled by the train:

1. Calculate the distance traveled at 60 mph:  
   Distance = Speed × Time = 60 mph × 2.5 hours = 150 miles

2. Calculate the distance traveled at 40 mph:  
   Distance = Speed × Time = 40 mph × 1.5 hours = 60 miles

3. Add both distances to get the total distance:  
   Total Distance = 150 miles + 60 miles = 210 miles

Final answer: **210 miles**

lfm2.5:1.2b chain turn 2

The seasons on Earth are caused by the tilt of the Earth's axis and its orbit around the Sun. As the Earth travels, different parts of the planet receive varying amounts of sunlight throughout the year. This shift in sunlight angle creates the changing seasons: spring, summer, autumn, and winter.

lfm2.5:1.2b chain turn 3

Every storm brought secrets to the shore, but one rainy night, a washed-up object caught the lighthouse keeper's curiosity. Curious, he unearthed a mysterious trinket buried beneath the sand. The item whispered tales of the past, drawing his attention like a needle in a storm. As he marveled at its history, the keeper realized this small find might hold a key to the lighthouse's forgotten past.

lfm2.5:1.2b chain turn 4

1. Use clear and consistent naming conventions for variables and functions.  
2. Write modular code with small, focused functions for better readability.  
3. Document your code with comments to explain complex logic.  
4. Regularly refactor your code to remove redundancies and improve structure.  
5. Test your code thoroughly with different inputs to ensure reliability.

qwen3.8:27b-mq4-xt

source: bucket sha256_ok: ✅ size_ok: ✅ status: pass reason:

battery — exit 0 seconds 40.3 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
battery	0		stop	34	0	143	67	53.3	14.8	False	False	False	True
battery	1		stop	30	0	101	87	164.2	42.4	False	False	False	True
battery	2		stop	31	0	17	14	174.2	28.4	False	False	False	True
battery	3		stop	47	0	31	8	234.0	38.3	False	False	False	True
battery	4		stop	47	0	17	7	237.1	55.0	False	False	False	True

qwen3.8:27b-mq4-xt battery turn 0

```python
def longest_substring_without_repeating(s: str) -> str:
    if not s:
        return ""
    
    char_index = {}
    start = 0
    max_length = 0
    max_start = 0
    
    for end, char in enumerate(s):
        if char in char_index and char_index[char] >= start:
            start = char_index[char] + 1
        char_index[char] = end
        if end - start + 1 > max_length:
            max_length = end - start + 1
            max_start = start
    
    return s[max_start:max_start + max_length]
```

qwen3.8:27b-mq4-xt battery turn 1

Sunlight is composed of different colors, and as it passes through the Earth's atmosphere, shorter blue wavelengths scatter in all directions more than longer red wavelengths due to Rayleigh scattering. During the day, when the sun is high, this scattered blue light reaches our eyes from all parts of the sky, making it appear blue. At sunset, sunlight travels through a thicker layer of atmosphere, causing most of the blue light to scatter away and leaving the dominant red and orange light to reach our eyes directly.

qwen3.8:27b-mq4-xt battery turn 2

The capital of France is Paris, which is run through by the Seine River.

qwen3.8:27b-mq4-xt battery turn 3

{
  "name": "Alice",
  "age": 34,
  "city": "Lisbon"
}

qwen3.8:27b-mq4-xt battery turn 4

17 + 26 = 43

Answer: 43

chain — exit 0 seconds 49.1 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
chain	0		stop	44	0	124	54	196.2	15.9	False	False	False	True
chain	1		stop	228	0	216	129	488.3	60.5	False	False	False	True
chain	2		stop	474	0	87	71	644.1	33.6	False	False	False	True
chain	3		stop	599	0	114	93	644.5	34.5	False	False	False	True
chain	4		stop	749	0	81	62	718.8	24.1	False	False	False	True

qwen3.8:27b-mq4-xt chain turn 0

```python
def merge_sorted(a, b):
    """Merge two sorted lists into a single sorted list without using sorted()."""
    result = []
    i, j = 0, 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            result.append(a[i])
            i += 1
        else:
            result.append(b[j])
            j += 1
    # Append remaining elements
    result.extend(a[i:])
    result.extend(b[j:])
    return result
```

qwen3.8:27b-mq4-xt chain turn 1

To find the total distance, I will calculate the distance for each segment of the trip separately and then add them together.

**Step 1: Calculate the distance of the first segment.**
*   Speed = 60 mph
*   Time = 2.5 hours
*   Distance = Speed × Time
*   Distance = $60 \times 2.5 = 150$ miles

**Step 2: Calculate the distance of the second segment.**
*   Speed = 40 mph
*   Time = 1.5 hours
*   Distance = Speed × Time
*   Distance = $40 \times 1.5 = 60$ miles

**Step 3: Calculate the total distance.**
*   Total Distance = Distance of Segment 1 + Distance of Segment 2
*   Total Distance = $150 + 60 = 210$ miles

**Final Answer:**
The train traveled a total of **210** miles.

qwen3.8:27b-mq4-xt chain turn 2

The primary cause of seasons is the tilt of Earth's axis, which remains at an angle of approximately 23.5 degrees relative to its orbit around the Sun. As Earth revolves around the Sun, different hemispheres are tilted either toward or away from the Sun, resulting in varying intensities of sunlight and day lengths. This variation in solar radiation leads to the cyclical changes in temperature and weather patterns known as seasons.

qwen3.8:27b-mq4-xt chain turn 3

Elara wiped the fog from the lantern glass, her fingers numb from the salt air, when she noticed a shape protruding from the wet shale. It was not a whale or a log, but a brass music box, its lid stuck slightly open. As the tide receded, a faint, impossible melody drifted out, a song she remembered from her childhood, before the sea took her world. She froze, the wick hissing above her, realizing the only person who had ever known that tune was her mother, lost to the ocean twenty years ago.

qwen3.8:27b-mq4-xt chain turn 4

1. Write small functions that perform a single task with clear, descriptive names.
2. Use meaningful variable and function names that convey intent rather than implementation details.
3. Keep functions short and focused to improve readability and ease of testing.
4. Add concise comments only where logic is non-obvious or complex.
5. Write automated tests for critical logic to catch regressions early.

kernel

status: pass

report pass: True

lane hipx (gfx1100)

hw-gate evidence

field	value
base	e98b4612fc39da39a9752a0b3e67e34dcd4b95cb
head	31dd5e306c609bb91e5c4e8eac6df70c397395f6
buckets	kernel,load,serve
host gfx	gfx1100
host rocm	7.15.26333-0000000
device	0
runner	hipx
daemon_md5	6c8687d268d651ab050436b583256476
hipfire_md5	2d8890879199a198e9ca005a83540263
build_seconds	44.745912313461304
verdict	pass
logs_dir	hw-gate-logs

fixtures

qwen3.6:27b

source: bucket sha256_ok: ✅ size_ok: ✅ status: pass reason:

battery — exit 0 seconds 28.2 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
battery	0		stop	34	0	132	62	3.2	17.7	False	False	False	True
battery	1		stop	30	0	80	70	441.3	50.4	False	False	False	True
battery	2		stop	31	0	19	16	453.4	50.5	False	False	False	True
battery	3		stop	47	0	31	8	464.2	50.4	False	False	False	True
battery	4		stop	47	0	6	2	465.3	50.6	False	False	False	True

qwen3.6:27b battery turn 0

```python
def longest_substring_without_repeating(s: str) -> str:
    char_index = {}
    start = 0
    max_start = 0
    max_length = 0
    
    for end, char in enumerate(s):
        if char in char_index and char_index[char] >= start:
            start = char_index[char] + 1
        
        char_index[char] = end
        
        if end - start + 1 > max_length:
            max_length = end - start + 1
            max_start = start
    
    return s[max_start:max_start + max_length]
```

qwen3.6:27b battery turn 1

During the day, sunlight travels through a shorter path in the atmosphere, causing shorter blue wavelengths to scatter more effectively in all directions and reach our eyes. At sunset, the light must pass through a much thicker layer of air to reach us, which scatters away most of the blue and green light before it arrives. This leaves primarily the longer red and orange wavelengths to dominate the sky's appearance.

qwen3.6:27b battery turn 2

The capital of France is Paris, and the river that runs through it is the Seine.

qwen3.6:27b battery turn 3

{
  "name": "Alice",
  "age": 34,
  "city": "Lisbon"
}

qwen3.6:27b battery turn 4

Answer: 43

chain — exit 0 seconds 18.9 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
chain	0		stop	44	0	120	51	392.4	50.3	False	False	False	True
chain	1		stop	220	165	215	114	390.6	50.3	False	False	False	True
chain	2		stop	461	436	67	57	296.8	50.3	False	False	False	True
chain	3		stop	562	529	84	69	290.3	50.2	False	False	False	True
chain	4		stop	678	647	76	52	351.7	50.2	False	False	False	True

qwen3.6:27b chain turn 0

```python
def merge_sorted(a, b):
    """Merge two sorted lists into a single sorted list."""
    merged = []
    i, j = 0, 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            merged.append(a[i])
            i += 1
        else:
            merged.append(b[j])
            j += 1
    # Append remaining elements
    merged.extend(a[i:])
    merged.extend(b[j:])
    return merged
```

qwen3.6:27b chain turn 1

To find the total distance traveled, we calculate the distance for each leg of the trip separately using the formula:

$$\text{Distance} = \text{Speed} \times \text{Time}$$

**Step 1: Calculate the distance for the first leg**
*   Speed = 60 mph
*   Time = 2.5 hours
*   Distance₁ = $60 \times 2.5 = 150$ miles

**Step 2: Calculate the distance for the second leg**
*   Speed = 40 mph
*   Time = 1.5 hours
*   Distance₂ = $40 \times 1.5 = 60$ miles

**Step 3: Add the distances together**
*   Total Distance = Distance₁ + Distance₂
*   Total Distance = $150 + 60 = 210$ miles

**Final Answer:**
The train traveled a total of **210** miles.

qwen3.6:27b chain turn 2

The seasons are caused by the tilt of Earth's rotational axis relative to its orbit around the Sun. As Earth travels along its orbital path, this tilt causes different hemispheres to receive varying amounts of direct sunlight throughout the year. When a hemisphere is tilted toward the Sun, it experiences summer, while the opposite hemisphere experiences winter.

qwen3.6:27b chain turn 3

After weeks of relentless storms, Elias finally descended to the blackened rocks below his tower. Amidst the tangled kelp and shattered driftwood, he noticed a glint of gold reflecting the dawn light. He brushed away the seaweed to reveal a perfectly preserved brass compass, its needle spinning wildly without direction. With a heavy heart, he realized the instrument had come from the ship he failed to save months ago.

qwen3.6:27b chain turn 4

1. Write clear, self-documenting code with meaningful variable and function names.
2. Keep functions short and focused on a single responsibility.
3. Write comprehensive unit tests to catch regressions early.
4. Consistently follow a shared coding style and formatting convention.
5. Add concise comments that explain the "why" rather than the "what."

ornith-1.5:35b-a3b-mq4r

source: bucket sha256_ok: ✅ size_ok: ✅ status: pass reason:

battery — exit 0 seconds 36.2 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
battery	0		stop	34	0	146	66	462.6	16.2	False	False	False	True
battery	1		stop	30	0	89	78	502.8	87.1	False	False	False	True
battery	2		stop	31	0	16	13	507.2	131.9	False	False	False	True
battery	3		stop	47	0	31	8	752.9	99.4	False	False	False	True
battery	4		stop	47	0	17	7	739.8	76.4	False	False	False	True

ornith-1.5:35b-a3b-mq4r battery turn 0

```python
def longest_substring_without_repeating_chars(s):
    if not s:
        return ""
    
    start = 0
    max_start = 0
    max_length = 0
    char_index = {}
    
    for end in range(len(s)):
        char = s[end]
        if char in char_index and char_index[char] >= start:
            start = char_index[char] + 1
        char_index[char] = end
        
        if end - start + 1 > max_length:
            max_length = end - start + 1
            max_start = start
    
    return s[max_start:max_start + max_length]
```

ornith-1.5:35b-a3b-mq4r battery turn 1

During the day, the sky appears blue because sunlight scatters off the gases and particles in Earth's atmosphere, with shorter blue wavelengths spreading out more easily than longer wavelengths. At sunset, the sunlight must travel through a thicker layer of atmosphere to reach your eyes, causing most of the blue light to scatter away before it arrives. This leaves primarily the longer red and orange wavelengths to dominate the sky, creating the characteristic colors of sunrise and sunset.

ornith-1.5:35b-a3b-mq4r battery turn 2

The capital of France is Paris, and the Seine River runs through it.

ornith-1.5:35b-a3b-mq4r battery turn 3

{
  "name": "Alice",
  "age": 34,
  "city": "Lisbon"
}

ornith-1.5:35b-a3b-mq4r battery turn 4

17 + 26 = 43

Answer: 43

chain — exit 0 seconds 21.9 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
chain	0		length	44	0	256	135	545.6	115.9	False	False	True	True
chain	1		stop	353	0	173	86	2177.6	50.4	False	False	False	True
chain	2		stop	552	526	86	71	490.9	73.0	False	False	False	True
chain	3		stop	672	638	152	129	533.1	64.9	False	False	False	True
chain	4		stop	856	824	88	68	496.8	74.2	False	False	False	True

ornith-1.5:35b-a3b-mq4r chain turn 0

```python
def merge_sorted(a, b):
    """Merge two sorted lists into a single sorted list.

    Uses a two-pointer merge approach (O(n + m) time), leaving the input
    lists unchanged.

    Args:
        a (list): A list sorted in ascending order.
        b (list): Another list sorted in ascending order.

    Returns:
        list: A new list containing all elements of `a` and `b` in
              ascending order.
    """
    i, j = 0, 0
    result = []

    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            result.append(a[i])
            i += 1
        else:
            result.append(b[j])
            j += 1

    # Append any remaining elements from either list.
    result.extend(a[i:])
    result.extend(b[j:])

    return result
```

This function implements the classic merge step from merge sort:

- Two pointers (`i` and `j`) walk through lists `a` and `b` respectively.
- At each step, the smaller of the two current

ornith-1.5:35b-a3b-mq4r chain turn 1

## Setting Up the Problem

Distance = Speed × Time, and I need to calculate the distance for each leg of the trip separately.

## Leg 1: 60 mph for 2.5 hours

$$60 \text{ mph} \times 2.5 \text{ hours} = 150 \text{ miles}$$

## Leg 2: 40 mph for 1.5 hours

$$40 \text{ mph} \times 1.5 \text{ hours} = 60 \text{ miles}$$

## Adding the Distances

$$150 \text{ miles} + 60 \text{ miles} = 210 \text{ miles}$$

## Final Answer

**The train traveled 210 miles total.**

ornith-1.5:35b-a3b-mq4r chain turn 2

The seasons are caused by the ~23.5-degree tilt of Earth's rotational axis relative to its orbital plane around the Sun. As Earth orbits the Sun over the course of a year, this tilt means that different parts of the planet receive varying amounts of direct sunlight at different times. When a hemisphere is tilted toward the Sun, it experiences summer with warmer temperatures, and when it's tilted away, it experiences winter.

ornith-1.5:35b-a3b-mq4r chain turn 3

Elsabeth hauls herself from the surf, her fingers closing around something smooth and cold that shouldn't exist this far from any shore—a glass bottle sealed with wax, inside which a scrap of parchment curls. She turns it over in her weathered hands, reading the faded ink that spells out words she thought she'd forgotten, words she'd buried alongside a love she never got to grieve. The wind picks up off the water, carrying a sound almost like laughter, and for the first time in twenty years the lighthouse keeper allows herself to believe that no message is ever truly lost. She clasps the bottle to her chest and looks out at the endless gray horizon, wondering who else had been waiting so long for this small miracle to arrive.

ornith-1.5:35b-a3b-mq4r chain turn 4

1. Name your variables and functions so their purpose is obvious at a glance.
2. Keep functions small and focused, each doing just one thing well.
3. Write comments only to explain why, not to restate what the code already shows.
4. Follow a consistent formatting style so the whole codebase looks uniform.
5. Keep related logic together and avoid duplicating code so updates happen in one place.

lfm2.5:1.2b

source: bucket sha256_ok: ✅ size_ok: ✅ status: pass reason:

battery — exit 0 seconds 8.2 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
battery	0		stop	0	0	131	58	None	228.22	False	False	False	True
battery	1		stop	0	0	70	63	None	228.01	False	False	False	True
battery	2		stop	0	0	15	13	None	230.77	False	False	False	True
battery	3		stop	0	0	26	8	None	230.09	False	False	False	True
battery	4		stop	0	0	31	16	None	227.94	False	False	False	True

lfm2.5:1.2b battery turn 0

```python
def longest_unique_substring(s):
    last_seen = {}
    start = 0
    max_len = 0
    max_sub = ""
    
    for i, char in enumerate(s):
        if char in last_seen and last_seen[char] >= start:
            start = last_seen[char] + 1
        else:
            if i - start + 1 > max_len:
                max_len = i - start + 1
                max_sub = s[start:i+1]
        last_seen[char] = i
    return max_sub
```

lfm2.5:1.2b battery turn 1

The sky appears blue during the day because blue light from the sun is scattered by tiny particles in the atmosphere, a phenomenon called Rayleigh scattering. At sunset, the sunlight travels through more atmospheric layers, causing longer red wavelengths to dominate due to less scattering. This combination of light angles and atmospheric conditions results in the vivid red colors we see at sunset.

lfm2.5:1.2b battery turn 2

The capital of France is Paris, and the Seine River runs through it.

lfm2.5:1.2b battery turn 3

{
  "name": "Alice",
  "age": 34,
  "city": "Lisbon"
}

lfm2.5:1.2b battery turn 4

Let's calculate the sum: 17 + 26.  
Adding together: 17 + 26 equals 43.  
Answer: 43

chain — exit 0 seconds 14.5 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
chain	0		stop	0	0	256	139	None	168.2	False	False	False	True
chain	1		stop	0	0	153	86	None	173.27	False	False	False	True
chain	2		stop	0	0	66	59	None	160.98	False	False	False	True
chain	3		stop	0	0	83	65	None	154.56	False	False	False	True
chain	4		stop	0	0	53	36	None	153.62	False	False	False	True

lfm2.5:1.2b chain turn 0

Here's a Python function `merge_sorted(a, b)` that merges two sorted lists into one sorted list without using `sorted()`:

```python
def merge_sorted(a, b):
    """
    Merges two sorted lists into a single sorted list.
    
    Parameters:
    a (list): First sorted list.
    b (list): Second sorted list.
    
    Returns:
    list: A new list containing all elements from both input lists in sorted order.
    """
    merged = []
    i, j = 0, 0

    # Traverse both lists and append the smaller element
    while i < len(a) and j < len(b):
        if a[i] < b[j]:
            merged.append(a[i])
            i += 1
        else:
            merged.append(b[j])
            j += 1

    # Append remaining elements from list a
    while i < len(a):
        merged.append(a[i])
        i += 1

    # Append remaining elements from list b
    while j < len(b):
        merged.append(b[j])
        j += 1

    return merged
```

This function uses two pointers to iterate through both

lfm2.5:1.2b chain turn 1

Let's break this down step by step:

1. **First part of the journey:**  
   The train goes at 60 mph for 2.5 hours.  
   Distance = speed × time  
   Distance�� = 60 mph × 2.5 hours = **150 miles**

2. **Second part of the journey:**  
   The train goes at 40 mph for 1.5 hours.  
   Distance�� = 40 mph × 1.5 hours = **60 miles**

3. **Total distance traveled:**  
   Total = Distance�� + Distance��  
   Total = 150 miles + 60 miles = **210 miles**

�� Final answer: **210 miles**

lfm2.5:1.2b chain turn 2

The seasons on Earth are caused by the tilt of the Earth's axis relative to its orbit around the Sun. As the Earth orbits, different parts of the planet receive varying amounts of sunlight throughout the year, leading to changes in temperature and weather patterns. The combination of the tilt and Earth's rotation creates the seasonal cycles we experience.

lfm2.5:1.2b chain turn 3

One stormy night, a curious passenger washed up on the rugged coast, shedding secrets as they climbed the rocky cliffs. The keeper, eager to share tales of the sea, recalled stories of faraway voyages and strange artifacts. As they approached the shore, a shimmering object caught their eye—a lantern with a glowing light inside. This unexpected discovery ignited a journey to uncover its mysterious past.

lfm2.5:1.2b chain turn 4

1. Use clear and descriptive variable names.  
2. Write functions with single responsibilities.  
3. Keep code modules organized with consistent naming.  
4. Document your code with comments where needed.  
5. Regularly refactor code to improve readability.

qwen3.8:27b-mq4-xt

source: bucket sha256_ok: ✅ size_ok: ✅ status: pass reason:

battery — exit 0 seconds 19.4 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
battery	0		stop	34	0	136	62	310.8	28.9	False	False	False	True
battery	1		stop	30	0	90	78	419.7	48.6	False	False	False	True
battery	2		stop	31	0	17	14	429.5	48.9	False	False	False	True
battery	3		stop	47	0	22	6	475.0	48.8	False	False	False	True
battery	4		stop	47	0	17	7	475.6	48.8	False	False	False	True

qwen3.8:27b-mq4-xt battery turn 0

```python
def longest_substring_without_repeating(s: str) -> str:
    char_index = {}
    start = 0
    longest_start = 0
    longest_length = 0

    for end, char in enumerate(s):
        if char in char_index and char_index[char] >= start:
            start = char_index[char] + 1
        char_index[char] = end
        if end - start + 1 > longest_length:
            longest_length = end - start + 1
            longest_start = start

    return s[longest_start:longest_start + longest_length]
```

qwen3.8:27b-mq4-xt battery turn 1

During the day, sunlight travels through a shorter atmospheric path, causing shorter blue wavelengths to scatter more widely than other colors, which makes the sky appear blue to our eyes. At sunset, the sun is near the horizon, forcing light to pass through a much thicker layer of atmosphere that scatters away most of the blue light before it reaches us. Consequently, the longer red and orange wavelengths remain dominant, creating the characteristic warm colors of the horizon.

qwen3.8:27b-mq4-xt battery turn 2

The capital of France is Paris, which is run through by the River Seine.

qwen3.8:27b-mq4-xt battery turn 3

{"name": "Alice", "age": 34, "city": "Lisbon"}

qwen3.8:27b-mq4-xt battery turn 4

17 + 26 = 43

Answer: 43

chain — exit 0 seconds 22.3 status pass

mode	idx	genre	finish	ctx	cached	gen	ans_words	prefill_tok_s	decode_tok_s	attractor	empty	runaway	recall_ok
chain	0		stop	44	0	120	51	389.4	48.8	False	False	False	True
chain	1		stop	224	44	202	113	714.7	48.8	False	False	False	True
chain	2		stop	456	44	75	59	336.9	49.2	False	False	False	True
chain	3		stop	569	44	128	104	885.4	48.9	False	False	False	True
chain	4		stop	733	44	69	47	891.0	49.1	False	False	False	True

qwen3.8:27b-mq4-xt chain turn 0

```python
def merge_sorted(a, b):
    """Merge two sorted lists into a single sorted list."""
    result = []
    i, j = 0, 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            result.append(a[i])
            i += 1
        else:
            result.append(b[j])
            j += 1
    # Append remaining elements
    result.extend(a[i:])
    result.extend(b[j:])
    return result
```

qwen3.8:27b-mq4-xt chain turn 1

To find the total distance traveled, we calculate the distance for each leg of the trip separately using the formula:

**Distance = Speed × Time**

**Step 1: Calculate the distance for the first leg**
*   Speed: 60 mph
*   Time: 2.5 hours
*   Distance 1 = 60 × 2.5 = **150 miles**

**Step 2: Calculate the distance for the second leg**
*   Speed: 40 mph
*   Time: 1.5 hours
*   Distance 2 = 40 × 1.5 = **60 miles**

**Step 3: Add the distances together**
*   Total Distance = Distance 1 + Distance 2
*   Total Distance = 150 + 60 = **210 miles**

**Final Answer:** The train traveled **210 miles** in total.

qwen3.8:27b-mq4-xt chain turn 2

The primary cause of seasons is the Earth's axial tilt of approximately 23.5 degrees relative to its orbital plane. As Earth orbits the Sun, this tilt causes different hemispheres to receive varying amounts of direct sunlight and daylight hours throughout the year. When a hemisphere tilts toward the Sun, it experiences summer, while the hemisphere tilting away experiences winter.

qwen3.8:27b-mq4-xt chain turn 3

Elias climbed down the wet shale at dawn, expecting only kelp and broken driftwood, but his boots stopped on a sleek, silver orb that hummed against the stone. The surface was cool to the touch and etched with symbols he had never seen in any nautical chart, yet it seemed to pulse with a faint, rhythmic light. When he brushed the sand away, the ocean behind him suddenly went silent, and the water began to recede with a sound like a held breath. A massive, translucent shape breached the surface nearby, revealing eyes that looked not with hunger, but with a profound, weary curiosity.

qwen3.8:27b-mq4-xt chain turn 4

1. Write clear, self-documenting variable and function names.
2. Keep functions short and focused on a single responsibility.
3. Use consistent naming conventions and formatting across the codebase.
4. Write unit tests for critical logic to prevent regressions.
5. Document non-obvious decisions and complex algorithms with comments.

kernel

status: pass

report pass: True

[hipfire-sol]

hw-gate sol verdict

{
  "claim_verdict": "not-exercised",
  "confidence": 0.94,
  "coverage": {
    "gaps": [
      "The successful fixture runs do not inject allocation failures, so transactional cleanup in DflashWeights::load, DflashScratch constructors, and build_generic_dflash_speculator was not exercised.",
      "No route provoked make_spec_emitter failure after prefill, so live KV/DeltaNet/drafter rollback was not exercised.",
      "The serve evidence does not establish that DFlash was active; the kernel report explicitly records draft=null, and the fixture rows contain no speculation attestation.",
      "No hardware route forced the draft-context exhaustion boundary and observed finish_reason=length plus cache suppression.",
      "The new --prompt-file path and emitted prompt evidence were unit-tested but not exercised by the hardware routes.",
      "The MQ4-V2 parity example itself was not run; ordinary qwen3.8 generation establishes coherent admission on available artifacts but not the new disjoint-halves oracle."
    ],
    "surfaces_evidenced": [
      "load",
      "serve",
      "kernel",
      "context-admission"
    ],
    "surfaces_touched": [
      "load",
      "serve",
      "kernel",
      "speculative-decode",
      "state-rollback",
      "context-admission",
      "cli",
      "filesystem",
      "docs"
    ]
  },
  "decision": "needs-human",
  "eyeball": [
    "qwen3.6:27b battery and chain outputs on gfx1201/gfx1100 are coherent, answer their prompts, and show useful multi-turn cache reuse.",
    "qwen3.8:27b-mq4-xt outputs are coherent on both lanes, supporting successful MQ4-V2 load/prefill/generation after the admission changes.",
    "ornith-1.5:35b-a3b-mq4r and lfm2.5:1.2b remained operational; some LFM text contains replacement characters or weak factual phrasing, but no attractor, empty response, or special-token leakage demonstrates a PR regression."
  ],
  "phase": "verdict",
  "rationale": "All hardware routes passed, decoded text was generally coherent, artifact hashes matched, and Redline reported stable captures with bit-exact HIP/blob/AQL state on gfx1201 and gfx1100. No regression is evidenced. However, the PR's central behavior is failure-path GPU cleanup and post-prefill speculative-state rollback at crates/hipfire-runtime/src/dflash.rs and crates/hipfire-generate/src/qwen.rs:3121, none of which successful loads can prove. The context-exhaustion terminal path at qwen.rs:3382 was likewise not reached, and the evidence does not show an active draft. Because these are GPU ownership and speculative state-machine changes with material untested fault paths, human review is required despite clean happy-path hardware evidence.",
  "regressions": []
}

Floor: hard=[] soft=["coverage_gaps: ['The successful fixture runs do not inject allocation failures, so transactional cleanup in DflashWeights::load, DflashScratch constructors, and build_generic_dflash_speculator was not exercised.', 'No route provoked make_spec_emitter failure after prefill, so live KV/DeltaNet/drafter rollback was not exercised.', 'The serve evidence does not establish that DFlash was active; the kernel report explicitly records draft=null, and the fixture rows contain no speculation attestation.', 'No hardware route forced the draft-context exhaustion boundary and observed finish_reason=length plus cache suppression.', 'The new --prompt-file path and emitted prompt evidence were unit-tested but not exercised by the hardware routes.', 'The MQ4-V2 parity example itself was not run; ordinary qwen3.8 generation establishes coherent admission on available artifacts but not the new disjoint-halves oracle.']", 'model needs-human'] model_decision=needs-human final=needs-human

[hipfire-sol]

hw-gate sol verdict block: Blocking because a mandatory fixture failed and two central claims are contradicted by the diff. Seven other fixture/lane combinations produced coherent output, but gfx1201 qwen3.8 chain emitted an empty turn. More fundamentally, new_windowed still leaks locally staged tensors on later allocation failure, and the <= admission predicate does not match the loop's >= boundary. The rollback and failure-path ownership claims were not exercised by hardware.

[hipfire-fable]

announcement: Merging to staging. Beyond the mandatory batteries (which ran without a draft), I ran qwen3.6:27b with qwen3.6:27b-draft active on gfx1201 against both this branch and master under greedy sampling: all five turns are byte-identical with identical tau through the metadata-windowed, explicit-window (HIPFIRE_DFLASH_WINDOW=1024) and Legacy (WINDOW=0, CTX_CAP=512) draft constructors, so the transactional rewrite leaves the success path untouched. The unified ctx-cap predicate shows up on hardware exactly as described: with cap 512 and block 16, prompts landing in the prompt+max_tokens+block band error on master after gen_start and complete via AR on this branch. The mq4v2_gemm_parity disjoint-halves arm passes on the R9700. The allocation-failure and make_spec_emitter fault paths remain unexercised on hardware — a fault-injection knob on alloc_tensor would let a future gate close that, if you want to follow up.

override: Override Sol needs-human: Sol's gaps were that no route showed DFlash active, the ctx-cap boundary was never forced, and the new parity arm was not run. I closed all three on hardware: DFlash-active greedy A/B (PR vs master) is byte-identical on all five turns with identical tau through both the metadata-windowed and explicit-window draft constructors; the Broken-5 band (prompt+max_tokens <= cap < prompt+max_tokens+block) errors on master and completes coherently via AR on the PR; mq4v2_gemm_parity incl. the disjoint-halves arm passes on gfx1201. What remains (allocation-failure cleanup, make_spec_emitter failure rollback) is unprovable on any host without a fault-injection harness, the success paths those rewrites sit on are proven identical to master, and master's behavior on those paths is a leak / dirty-GPU exit, so a human reading the diff cannot learn more than the A/B already shows.

investigation:

| question | route | result | evidence |

|---|---|---|---|

| Does the transactional rewrite of DflashWeights::load + DflashScratch::new_windowed (the draft's metadata declares W=2048, so windowed is the default path for qwen3.6:27b-draft) leave the DFlash happy path identical to master? | HIP_VISIBLE_DEVICES=0|1 HIPFIRE_KERNEL_CACHE= HIPFIRE_CLI_BIN/HIPFIRE_DAEMON_BIN=$HW_GATE_BIN|$HW_GATE_BASE_BIN python3 scripts/serve_harness.py --model qwen3.6-27b.mq4 --tag qwen3.6:27b --draft qwen36-27b-dflash-mq4.hfq --dflash on --sampling greedy --thinking off --mode battery --max-tokens 256 | Serve log attests 'DFlash draft loaded (layers=5, hidden=5120, block=16)' and drafter=dflash on every request on both binaries. All 5 turns byte-identical PR vs master; tau 9.00 / 7.23 / 1.73 / 1.02 / 1.97 on both; gen 120/256/81/116/91 on both; no attractor, no empty row. Decoded text coherent (merge_sorted two-pointer implementation, 210-mile train worked example, axial-tilt seasons answer, lighthouse story, five coding tips). | ab_summary.txt |

| Does new_windowed still work with an explicit HIPFIRE_DFLASH_WINDOW override (the alloc_or_free! ladder and the reordered positions_k replacement)? | same as above with HIPFIRE_DFLASH_WINDOW=1024 on the PR binary | Serve log: 'DFlash draft windowed: SWA W=1024 rows'. All 5 turns byte-identical to the master run, identical tau (9.00/7.23/1.73/1.02/1.97). | C2_pr_window1024_isocache.{json,serve.log} |

| Does the Legacy (non-windowed) path — DflashScratch::new_with_mq via the at!/take! slot rewrite — still generate, and does the unified spec_ctx_request_fits predicate actually change behavior in the prompt+max_tokens+block_size band (audit Broken 5)? | HIPFIRE_DFLASH_WINDOW=0 HIPFIRE_DFLASH_CTX_CAP=512 ... serve_harness.py ... --dflash on --sampling greedy --thinking off --mode battery --max-tokens 470 --max-seq 4096, on PR and base binaries | Both logs: 'DFlash draft ctx capped: 4096 -> 512 rows'. Prompt 3 (ctx 25: 25+470+16=511 fits) runs DFlash tau=1.73 on both, identical text. Prompts 1-2 (ctx 44/55, exceed 512 outright) fall back to AR on both, identical text. Prompts 4 and 5 (ctx 33/31: 503/501 <= 512 < 519/517) are the band: master emits '[context_length retryable=false rolled_back=false attempt=4|5] prompt+max_tokens exceeds ctx_capacity 512' with gen=0 empty rows; PR falls back to AR at entry and finishes stop with gen 100 / 91, coherent text ('For decades, Elias had watched the storm-tossed waves...', 'Write clear, descriptive names...'). | Dpr2_legacy_ctxcap512_band.{json,serve.log} vs Dbase2_legacy_ctxcap512_band.{json,serve.log} |

| Does the new disjoint-halves arm of mq4v2_gemm_parity (stacked #690 content Sol flagged as un-run) pass on gfx12? | HIP_VISIBLE_DEVICES=0 $HW_GATE_BIN/examples/mq4v2_gemm_parity (binary contains the 'disjoint batch' arm; verified via strings) | PASS. Gaussian residual v2 rel-rms 2.65e-4..2.80e-4 at batch 1/8/12/16/32 (0.29-0.33x the v1 floor); disjoint arm v2 rel-rms 1.85e-4..3.07e-4 against swapped-header negative control 0.53..1.62 (>=100x separation); gate_up/qkvza v2 2.6e-4. | mq4v2_gemm_parity.gfx1201.log |

| First batch (kept as a failed experiment): the same five routes run concurrently against the shared cwd-relative kernel cache. | identical harness invocations without HIPFIRE_KERNEL_CACHE isolation, five daemons (PR and base) in parallel from the checkout cwd | Three requests failed with 'post-publish pair invalid for gemm_qkvza_hfq4g256_wmma_gfx12 | attention_dflash_wmma_f32_gfx12 | conv1d_silu_split' (rdna-compute/src/compiler.rs:1166-1173, pair_valid after publish into the shared .hipfire_kernels/gfx1201 dir per compiler.rs:322-325). This is a cross-process publish race of my own making, not PR behavior: with per-run caches the identical routes show 0 failures across 5 daemons and the surviving first-batch requests already matched master's tau exactly. Not counted as a regression; noted so the maintainer does not misread those logs. | A_pr_dflash_battery.serve.log, C_pr_dflash_windowed.serve.log (and the other three first-batch files) |

unproven:

• Error-path GPU cleanup in DflashWeights::load, DflashScratch::new_with_mq/new_windowed and build_generic_dflash_speculator (crates/hipfire-runtime/src/dflash.rs:660-1077, 1473-1510, 1530-1690; dflash_generic.rs:1055-1079): needs an allocation-failure injection harness; no host can exercise it with registry fixtures. Success paths through all three constructors are proven identical to master above.

• make_spec_emitter Err rollback (crates/hipfire-generate/src/qwen.rs:3121-3144): needs emitter-construction fault injection; the arm mirrors the adjacent prefill/step Err arms and compiles against the same production_fail_closed_rollback_live signature.

• SpecRun::ctx_exhausted mid-loop break (qwen.rs:3384): unreachable without CASK eviction now that the entry guard carries the +block_size margin (position <= prompt+max_tokens <= cap-block); the harness pins HIPFIRE_CASK_OFF=1. Covered only by qwen_dflash_ctx_exhausted_tests.rs.

• build_generic_dflash_speculator (llama-arch target + arch-20 draft, carriers.rs:951): no such target/draft pair exists in the registry on this host; muse-glimmer:draft is arch 23 and qwen3.8 is arch 5 (qwen35 path).

• llama::is_batchable_la V2 refusal on gfx12 (llama.rs:1938-1960, stacked fix(mq4v2): one MQ-V2 prefill admit rule for llama and qwen35; discriminating GEMM parity; spec §9 #690): no plain-Llama-arch MQ-V2 registry fixture; qwen3.8:27b-mq4-xt exercises only the qwen35 admit side (mandatory battery/chain passed on both lanes).

• gfx1100 with DFlash active: this session's host is 5x gfx1201; the mandatory hipx lane covered qwen3.6:27b serve on gfx1100 without a draft only.

rationale: Hard floor clean. The diff against master is three stacked PRs; #689 (bench --prompt-file) and #690 (MQ-V2 admit rule + parity arm) were gated separately and I re-ran the #690 parity example here on gfx1201 (mq4v2_gemm_parity.gfx1201.log: PASS, disjoint arm discriminating at >=100x). For #691 proper, the risk in a slot-index rewrite of GPU constructors is a silently swapped or double-taken tensor on the SUCCESS path — that is what hardware can prove, and it is proven: with DFlash attested active (serve logs 'DFlash draft loaded ... block=16', drafter=dflash per request) the PR and master daemons produce byte-identical greedy text with identical tau on all five prompts through the metadata-windowed constructor (A2 vs B2), the explicit-window constructor (C2 vs B2), and the Legacy new_with_mq constructor (Dpr2 prompt 3 vs Dbase2 prompt 3). The mandatory evidence had draft=null everywhere, so this is the coverage Sol was missing. The one behavior change reachable without fault injection, audit Broken 5, is demonstrated as a strict improvement: in the band prompt+max_tokens <= cap < prompt+max_tokens+block_size (Dpr2/Dbase2 prompts 4 and 5, cap 512, block 16, ctx 33/31, max_tokens 470) master returns a context_length error with an empty turn after gen_start, the PR completes via AR with coherent text, and every prompt outside the band is identical on both binaries. Sol's two suspected regressions are not regressions against master: set_dflash_extract_layers before new_spec_scratch (dflash_generic.rs:1071-1079) is master's ordering with only frees added, and the load_codebook panic path is unchanged. The residual unproven items are fault-injection paths where master's behavior is a leak or a dirty-GPU exit and the PR's is a free or a rollback; neither can be exercised on any host with registry fixtures, so holding for a human would not add information beyond this A/B. The first-batch 'post-publish pair invalid' failures are documented in $HW_GATE_EVIDENCE/README.md as a shared-kernel-cache race from running PR and master daemons concurrently in one cwd; isolated-cache reruns show zero failures.

soft floor: ["coverage_gaps: ['The successful fixture runs do not inject allocation failures, so transactional cleanup in DflashWeights::load, DflashScratch constructors, and build_generic_dflash_speculator was not exercised.', 'No route provoked make_spec_emitter failure after prefill, so live KV/DeltaNet/drafter rollback was not exercised.', 'The serve evidence does not establish that DFlash was active; the kernel report explicitly records draft=null, and the fixture rows contain no speculation attestation.', 'No hardware route forced the draft-context exhaustion boundary and observed finish_reason=length plus cache suppression.', 'The new --prompt-file path and emitted prompt evidence were unit-tested but not exercised by the hardware routes.', 'The MQ4-V2 parity example itself was not run; ordinary qwen3.8 generation establishes coherent admission on available artifacts but not the new disjoint-halves oracle.']", 'model needs-human']

[hipfire-fable]

Blocked by the hard floor only: the gate's qwen3.8:27b-mq4-xt chain on gfx1201 produced one empty turn (a first-token EOS at temperature 1.0 under the MTP drafter), and a failed mandatory fixture is a block by rule. I could not reproduce it in 12 fresh runs (60 turns, PR and master, MTP and plain-AR configs), and nothing in this diff can produce a one-token natural stop, so a gate re-run is what should clear it. On the substance: the mandatory routes never loaded a draft (dflash_mode=off), so I ran qwen3.6:27b and qwen3.8:27b with their mq4 drafts on both binaries — the rewritten load/scratch/windowed constructors decode coherently with normal tau, and the Broken-5 fix is demonstrated head-to-head (master errors after gen_start with 'prompt+max_tokens exceeds ctx_capacity 291', this branch falls back to AR and answers). Sol's '<=' vs '>=' concern does not hold up (position trails prompt+generated, so the equality case cannot exhaust early). One thing to finish before this lands: in DflashScratch::new_windowed the four extension tensors are still locals when a later allocation fails, so alloc_or_free! frees s but leaks them — install each into s right after its allocation (s.free_gpu already frees the Some fields), leaving only new_positions_k as a local, and soften the PR body's 'every allocation site' claim accordingly. The hard floor fired on an evidence failure (hiptrx/gfx1201 qwen3.8:27b-mq4-xt chain, turn 4 empty), so the decision is block by rule, not by my reading of the diff. My reading disagrees with two of Sol's three regressions and I demonstrated the PR's central fix on hardware. (1) The empty turn: gen=1 finish=stop cached=0 at registry sampling temp=1.0/top_p 0.95/top_k 20 under the MTP drafter (that fixture auto-loads /home/kaden/qcal/ladder-v2/artifacts/qwen3.8-27b.mq4v2.xt.mtp, drafter=mtp in every serve log — so it does cross generate_spec). I reran it 12 times on gfx1201 (PR x9 across the gate's MTP config and plain AR, BASE x3): 60 turns, zero empties, every lighthouse turn coherent ($HW_GATE_EVIDENCE/INDEX.md). No line in this diff can yield a one-token natural stop: a ctx_exhausted break maps to length (qwen.rs:2442-2444, 2651-2657) and the emitter-error arm emits a correlated fail-closed error (qwen.rs:3131-3141). It is a stochastic first-token EOS, present on master's sampling policy too; a gate re-run is what clears the floor. (2) Sol's regression #2 (the '<='/'>=' mismatch, common.rs:589 vs qwen.rs:3384) is arithmetically wrong: position lags prompt+generated by at least one (qwen.rs:3296, 3441-3491, 3528-3536, 5543), so at exact equality the guard would need generated >= max_tokens+1, impossible under 3370/3396. (3) Sol's regression #1 (dflash.rs:1491-1504) is real but is an incomplete cleanup, strictly better than master at every failure point (master: bare '?', whole s leaked, e98b461 dflash.rs:1349-1356); no behavior on the success path changes, and the PR body overclaims it. (4) The touched surface — DFlash weight/scratch construction including new_windowed (both registry drafts declare a window, so it runs on the default path) — was NOT exercised by the mandatory routes: run.py leaves HIPFIRE_HOME at the gate home so the harness's [speculation] TOML in /.hipfire/config.toml is shadowed and the daemon logged 'dflash_mode=off — skipping draft load' (visible in the gate's own serve logs and in my first attempt). I fixed that in the runner and ran qwen3.6:27b and qwen3.8:27b with their mq4 drafts on PR and BASE: 40 chain/battery turns per binary set, drafter=dflash on every request, tau in the normal band and matched between binaries, recall 11/11, plus W=512 override and Legacy-mode runs. (5) Broken 5 is demonstrated head-to-head: Legacy draft, HIPFIRE_DFLASH_CTX_CAP=291, 31-token prompt, max_tokens 256, block 16 — master admits the request and dies after gen_start with 'context_length ... prompt+max_tokens exceeds ctx_capacity 291' (empty turn, rolled_back=false), the PR falls back to AR at entry and answers correctly (pr-/base-q38-legacy-cap291-band-battery). The Legacy cap=400 chain shows the DFlash->AR handoff is clean on both binaries with the prefix cache extending across it. The gate-infra shadowing of --dflash by HIPFIRE_HOME is worth a maintainer look: it means DFlash PRs get dflash-off mandatory routes.

[Kaden-Schutt]

Gate run 33900101473: Fable reproduced neither the failed fixture nor any regression — the hiptrx chain's empty turn was a first-token EOS at temperature 1.0 under the MTP drafter (the host has qwen3.8-27b.mq4v2.xt.mtp beside the symlink target, so the daemon auto-attaches it), 0/60 turns reproduced it across PR and master, MTP and AR. Broken 5 is demonstrated head-to-head (master: prompt+max_tokens exceeds ctx_capacity, empty row; PR: AR fallback, coherent), and Sol's <= regression was refuted by trace.

One real gap from the same run, fixed in 136e3f06f: DflashScratch::new_windowed freed the base scratch on a failed allocation but the tensors already allocated in the ladder were still locals with no Drop, so a failure on the 2nd–5th alloc leaked k_full/v_full/k_cat/v_cat. Each is now parked in s as it succeeds, so s.free_gpu covers the whole ladder (same shape as new_with_mq's at!/live). Re-gating on the push.

[hipfire-sol]

hw-gate sol verdict needs-human: Hardware batteries passed on gfx1201 and gfx1100, but they only establish ordinary load/serve compatibility. The central failure and rollback paths were not exercised. More importantly, the claimed single context-cap predicate is not equivalent to the loop guard: common.rs:584 accepts equality while qwen.rs:3384 rejects equality. The exact-cap request therefore remains admitted into speculation instead of being diverted to AR, so the stated Broken 5 fix is incomplete.

[hipfire-fable]

Ran DFlash for real on both binaries (the gate's batteries had dflash_mode=off): qwen3.6:27b and qwen3.8:27b with their MQ4 drafts in windowed, Legacy-capped and DFlash2 shapes, battery and chain, greedy — decoded text, tau and cycle counts are identical to master across 20 turns, so the rewritten constructors are behaviour-preserving on the success path. The Broken 5 fix is demonstrated: with HIPFIRE_DFLASH_CTX_CAP=290 master returns a context_length error after gen_start on three of five prompts, the PR falls back to AR and answers all five; and the exact-cap request (55+256+16 == 327) runs speculation to the full budget, so the reviewer's off-by-one early-termination claim does not hold. Merging to staging. Still unexercised on hardware: the allocation-failure and emitter-failure cleanup paths (need fault injection) and ctx_exhausted under CASK eviction — worth a diagnostic env hook if you want those on the record later. The mandatory batteries ran with dflash_mode=off, so none of the touched code executed in the hw-gate evidence; Sol was right to flag that and wrong about the regression. I ran DFlash on PR and master binaries (daemon md5 f30d756c vs 17ba7dfa) on 4x gfx1201 with greedy sampling so text is comparable: qwen3.6:27b + qwen36-27b-dflash-mq4.hfq battery and chain (draft-declared windowed W=2048 -> new_windowed over new_with_mq, dflash.rs:1442-1700), qwen3.8:27b + qwen38-27b-dflash-mq4.hfq battery (DFlash2 all-sliding, conv/selector Option slots, block=8), and Legacy capped mode (HIPFIRE_DFLASH_WINDOW=0, 'ctx capped' path -> plain new_with_mq). Across all 20 A/B turns decoded content, reasoning, tau and cycle counts are identical PR vs master (README.md in $HW_GATE_EVIDENCE indexes the files). The rewritten constructors therefore land every tensor in the same field as before. For Broken 5: with cap 290 master emits '[context_length ... rolled_back=false] prompt+max_tokens exceeds ctx_capacity 290' after gen_start and three of five battery turns come back empty (base_q36_dflash_legacy_ctxcap290_battery_gfx1201.serve.log:90-96); the PR serves all five via AR, coherently. For Sol's off-by-one at common.rs:584 vs qwen.rs:3384: the loop is while generated < max_tokens (qwen.rs:3364) and position never exceeds prompt+generated without eviction (position init 3157, advances at 3536/3905 lag by the pending seed), so position+block_size <= cap-1 whenever the entry predicate holds; on hardware the exact-cap request (cap 327, ctx 55, block 16) ran DFlash to gen=256/finish=length with tau 7.23 and 31 cycles, identical to the uncapped run, and cap 326 diverted it to AR. The entry predicate is also exactly the negation of master's generate_spec error at e98b461 qwen.rs:2980-2999, so the set of requests admitted into speculation is unchanged; only the band moved from a post-gen_start error to a pre-gen_start AR fallback. The hard floor did not fire; no attractors, no empties on the PR binary in any run. What remains unproven is the new error plumbing itself (needs fault injection) — but that plumbing replaces a path that leaked on master, and the success path is evidenced identical, so it cannot make an existing model, topology or serve path worse. Override Sol needs-human: Sol's only stated regression (exact-cap request enters speculation and terminates early because spec_ctx_request_fits uses <= while the loop guard uses >=) is refuted both by argument and on hardware: with no eviction the loop runs only while generated < max_tokens, and position <= prompt+generated, so position+block_size <= prompt+max_tokens-1+block_size <= cap-1 and the qwen.rs:3384 guard cannot fire; on gfx1201 the exact-cap request (ctx 55 + 256 + block 16 == cap 327) ran DFlash to the full 256-token budget (tau 7.23, 31 cycles), identical text to the uncapped run, while cap 326 diverted it to AR. Sol's coverage gaps that this host can close (DFlash actually enabled, rewritten weight/scratch constructors on their success path in windowed, Legacy and DFlash2 shapes, near-cap AR fallback, multi-turn state under DFlash) were closed with PR-vs-master A/B runs that are byte-identical in decoded text, tau and cycle counts across 20 turns, and the band case master breaks (context_length error after gen_start, 3/5 turns empty) the PR serves coherently.

[hipfire-sol]

hw-gate sol verdict needs-human: The ordinary serve and architecture paths are coherent on gfx1100 and gfx1201, and Redline reports stable captures plus bit-exact HIP/AQL state. However, the core PR behavior was not run because every fixture loaded with draft=null. Moreover, the claimed unified capacity boundary is contradicted by the diff: spec_ctx_request_fits uses <= at crates/hipfire-generate/src/common.rs:583, while generate_spec breaks when position + block_size >= ctx_capacity at crates/hipfire-generate/src/qwen.rs:3384. Equality is therefore admitted at entry but rejected in-loop rather than falling back to AR. A human must resolve that boundary and assess the unexercised allocation-failure and emitter-rollback paths before promotion.

[hipfire-fable]

Fable unavailable; holding for human review. omp decide: no JSON object in assistant text

[Kaden-Schutt]

Merged to beta as aad88151d on the gate's hardware evidence (run 33905366422: both lanes 4/4 battery+chain, 0 attractor/empty/runaway; Sol's one technical claim disproven on hardware in 33902688013, where the DFlash A/B was 20 turns identical to master and Broken 5 was demonstrated head-to-head). new_windowed's alloc-ladder leak from that run is fixed in 136e3f06f. Fable seat unavailable (credits), so the staging merge is mine, not the seat's; master stays human-promoted. #652 is superseded by this — closing it.

[hipfire-sol]

hw-gate sol verdict needs-human: All hardware routes passed, decoded text was generally coherent, artifact hashes matched, and Redline reported stable captures with bit-exact HIP/blob/AQL state on gfx1201 and gfx1100. No regression is evidenced. However, the PR's central behavior is failure-path GPU cleanup and post-prefill speculative-state rollback at crates/hipfire-runtime/src/dflash.rs and crates/hipfire-generate/src/qwen.rs:3121, none of which successful loads can prove. The context-exhaustion terminal path at qwen.rs:3382 was likewise not reached, and the evidence does not show an active draft. Because these are GPU ownership and speculative state-machine changes with material untested fault paths, human review is required despite clean happy-path hardware evidence.

[hipfire-fable]

Merging to staging. Beyond the mandatory batteries (which ran without a draft), I ran qwen3.6:27b with qwen3.6:27b-draft active on gfx1201 against both this branch and master under greedy sampling: all five turns are byte-identical with identical tau through the metadata-windowed, explicit-window (HIPFIRE_DFLASH_WINDOW=1024) and Legacy (WINDOW=0, CTX_CAP=512) draft constructors, so the transactional rewrite leaves the success path untouched. The unified ctx-cap predicate shows up on hardware exactly as described: with cap 512 and block 16, prompts landing in the prompt+max_tokens+block band error on master after gen_start and complete via AR on this branch. The mq4v2_gemm_parity disjoint-halves arm passes on the R9700. The allocation-failure and make_spec_emitter fault paths remain unexercised on hardware — a fault-injection knob on alloc_tensor would let a future gate close that, if you want to follow up. Hard floor clean. The diff against master is three stacked PRs; #689 (bench --prompt-file) and #690 (MQ-V2 admit rule + parity arm) were gated separately and I re-ran the #690 parity example here on gfx1201 (mq4v2_gemm_parity.gfx1201.log: PASS, disjoint arm discriminating at >=100x). For #691 proper, the risk in a slot-index rewrite of GPU constructors is a silently swapped or double-taken tensor on the SUCCESS path — that is what hardware can prove, and it is proven: with DFlash attested active (serve logs 'DFlash draft loaded ... block=16', drafter=dflash per request) the PR and master daemons produce byte-identical greedy text with identical tau on all five prompts through the metadata-windowed constructor (A2 vs B2), the explicit-window constructor (C2 vs B2), and the Legacy new_with_mq constructor (Dpr2 prompt 3 vs Dbase2 prompt 3). The mandatory evidence had draft=null everywhere, so this is the coverage Sol was missing. The one behavior change reachable without fault injection, audit Broken 5, is demonstrated as a strict improvement: in the band prompt+max_tokens <= cap < prompt+max_tokens+block_size (Dpr2/Dbase2 prompts 4 and 5, cap 512, block 16, ctx 33/31, max_tokens 470) master returns a context_length error with an empty turn after gen_start, the PR completes via AR with coherent text, and every prompt outside the band is identical on both binaries. Sol's two suspected regressions are not regressions against master: set_dflash_extract_layers before new_spec_scratch (dflash_generic.rs:1071-1079) is master's ordering with only frees added, and the load_codebook panic path is unchanged. The residual unproven items are fault-injection paths where master's behavior is a leak or a dirty-GPU exit and the PR's is a free or a rollback; neither can be exercised on any host with registry fixtures, so holding for a human would not add information beyond this A/B. The first-batch 'post-publish pair invalid' failures are documented in $HW_GATE_EVIDENCE/README.md as a shared-kernel-cache race from running PR and master daemons concurrently in one cwd; isolated-cache reruns show zero failures. Override Sol needs-human: Sol's gaps were that no route showed DFlash active, the ctx-cap boundary was never forced, and the new parity arm was not run. I closed all three on hardware: DFlash-active greedy A/B (PR vs master) is byte-identical on all five turns with identical tau through both the metadata-windowed and explicit-window draft constructors; the Broken-5 band (prompt+max_tokens <= cap < prompt+max_tokens+block) errors on master and completes coherently via AR on the PR; mq4v2_gemm_parity incl. the disjoint-halves arm passes on gfx1201. What remains (allocation-failure cleanup, make_spec_emitter failure rollback) is unprovable on any host without a fault-injection harness, the success paths those rewrites sit on are proven identical to master, and master's behavior on those paths is a leak / dirty-GPU exit, so a human reading the diff cannot learn more than the A/B already shows.