.beads-1-1 (1)

1-1: ⚠️ Potential issue | 🟠 Major

Avoid committing machine-specific absolute paths in repo config.

This path hard-codes one workstation and will fail for anyone else. It’s like committing your own /etc/hosts and expecting every machine to resolve the same way.

🔧 Proposed fix

-/home/jeanclawdai/.beads-stores/upstream-sync-2026-Q1
+.beads-stores/upstream-sync-2026-Q1

If .beads must stay local-only, prefer ignoring it and documenting a one-time setup step instead.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.beads at line 1, Remove the machine-specific absolute path
"/home/jeanclawdai/.beads-stores/upstream-sync-2026-Q1" from the .beads file and
replace it with a portable alternative (e.g., a relative path, an
environment-variable placeholder like ${BEADS_STORE_PATH}, or a generic store
name), or remove the file from source control; if you choose to keep it
local-only, add .beads to .gitignore and add a short setup note in the repo
README or CONTRIBUTING documenting the one-time step to create the user-specific
store path or set BEADS_STORE_PATH so others can configure it on their machines.

docs/superpowers/plans/2026-03-31-phase-04-mamba-cache-architecture-reconcile.md-503-504 (1)

503-504: ⚠️ Potential issue | 🟠 Major

Replace hard-coded workstation path with repo-relative execution.

This makes the plan brittle outside one machine. Use repo-root relative commands so any contributor/runner can execute it.

🔧 Suggested adjustment

-cd /home/jeanclawdai/sglang-mamba/worktrees/upstream-sync-2026-Q1
-pytest test/registered/radix_cache/test_mamba_radix_cache_comprehensive.py -v --timeout=120 2>&1 | tail -30
+git rev-parse --show-toplevel >/dev/null || exit 1
+pytest test/registered/radix_cache/test_mamba_radix_cache_comprehensive.py -v --timeout=120 2>&1 | tail -30

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@docs/superpowers/plans/2026-03-31-phase-04-mamba-cache-architecture-reconcile.md`
around lines 503 - 504, The plan uses a hard-coded workstation path ("cd
/home/jeanclawdai/sglang-mamba/worktrees/upstream-sync-2026-Q1") making it
non-portable; change it to run relative to the repo root (e.g., replace the cd
with a repo-root discovery like cd "$(git rev-parse --show-toplevel)" or use ./
from the project root) and ensure the pytest invocation (pytest
test/registered/radix_cache/test_mamba_radix_cache_comprehensive.py -v
--timeout=120 2>&1 | tail -30) is executed from that repo-root context so any
contributor can run it reliably.

docs/superpowers/plans/2026-03-31-phase-04-mamba-cache-architecture-reconcile.md-345-351 (1)

345-351: ⚠️ Potential issue | 🟠 Major

Guard the sync call to prevent crashes on non-CUDA devices.

The plan recommends unconditional torch.cuda.synchronize() before extraction. This will fail on CPU or other non-CUDA backends (xpu, hpu, npu, musa) since torch.cuda.synchronize() is CUDA-specific. The codebase explicitly supports multiple device types via DeviceConfig, so this guidance needs a device-aware guard.

🔧 Suggested adjustment

-# Ensure all pending GPU ops on Mamba state are complete before CPU extraction
-torch.cuda.synchronize()
+# Ensure pending CUDA ops complete before CPU extraction (CUDA-only)
+if torch.cuda.is_available() and mamba_pool.device.startswith("cuda"):
+    torch.cuda.synchronize()

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@docs/superpowers/plans/2026-03-31-phase-04-mamba-cache-architecture-reconcile.md`
around lines 345 - 351, The unconditional torch.cuda.synchronize() will crash on
non-CUDA backends; update extract_state_from_pool in mamba_snapshot.py to
perform a device-aware sync before the .clone().cpu() calls: detect the Mamba
state device (e.g., via the DeviceConfig or the tensor/device.type used in
extract_state_from_pool) and only call the appropriate sync for CUDA
(torch.cuda.synchronize()) when device.type == "cuda" (or
torch.cuda.is_available()); skip or use the correct backend sync for other
device types so CPU-only or non-CUDA backends do not call
torch.cuda.synchronize().

python/sglang/srt/managers/schedule_batch.py-366-370 (1)

366-370: ⚠️ Potential issue | 🟠 Major

Release precomputed_embeddings here as well.

This helper only drops item.feature, but MultimodalDataItem stores its payload in either feature or precomputed_embeddings. If this replaces the old mm_items = None cleanup path, precomputed-embedding requests now keep the large tensor alive and lose the memory win.

🔧 Proposed fix

     def release_features(self):
-        """Release feature tensors to free GPU memory."""
+        """Release multimodal payload tensors to free GPU memory."""
         for item in self.mm_items:
             item.feature = None
+            item.precomputed_embeddings = None

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/managers/schedule_batch.py` around lines 366 - 370, The
release_features method currently only clears item.feature, leaving
MultimodalDataItem.precomputed_embeddings intact and thus retaining GPU memory;
update release_features to also set item.precomputed_embeddings = None for each
item in self.mm_items (and safely handle cases where mm_items or the attributes
may be missing) so both storage paths are released when freeing tensors.

python/sglang/srt/mem_cache/base_prefix_cache.py-113-120 (1)

113-120: ⚠️ Potential issue | 🟠 Major

Converge the init_load_back API across abstract base, implementations, and call sites.

The abstract method in BasePrefixCache (lines 224–228) still uses the old positional signature (last_host_node, host_hit_length, …), but hi_mamba_radix_cache.py has already been updated to accept InitLoadBackParams as a single parameter object. Meanwhile, hiradix_cache.py and the session_aware_cache wrapper still use the old signature, creating an API boundary mismatch—implementations and callers are now pulling in different directions.

To fix: Update the abstract method and all remaining implementations (hiradix_cache, session_aware_cache, and any others) to accept InitLoadBackParams as the parameter, matching what schedule_policy.py is already attempting to pass. This eliminates the risk of drift between the contract and the implementations.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/mem_cache/base_prefix_cache.py` around lines 113 - 120,
Update the init_load_back API to use the InitLoadBackParams object across the
abstract base and all implementations: change BasePrefixCache.init_load_back to
accept a single parameter typed as InitLoadBackParams, then refactor
hiradix_cache.py and session_aware_cache (and any other implementations) to
match that signature and consume fields from the InitLoadBackParams instance;
ensure callers (e.g., schedule_policy.py) that currently pass an
InitLoadBackParams continue to pass it unchanged and adjust any call sites that
still pass positional args (last_host_node, host_hit_length, etc.) to construct
and pass an InitLoadBackParams instead so the abstract, implementations, and
callers are consistent with hi_mamba_radix_cache.py.

test/registered/4-gpu-models/test_qwen3_next_models_mtp.py-217-251 (1)

217-251: ⚠️ Potential issue | 🟠 Major

Restore the previous SGLANG_ENABLE_SPEC_V2 value.

This flips a process-global flag to True, but teardown always writes False and setUpClass has no rollback if popen_launch_server(...) fails. That makes later suites order-dependent. Save the old value, restore it on launch failure, and put that same value back in tearDownClass.

🔁 Suggested fix

     `@classmethod`
     def setUpClass(cls):
         cls.model = QWEN3_NEXT_MODEL
-        envs.SGLANG_ENABLE_SPEC_V2.set(True)
+        cls._prev_spec_v2 = envs.SGLANG_ENABLE_SPEC_V2.get()
+        envs.SGLANG_ENABLE_SPEC_V2.set(True)
         cls.base_url = DEFAULT_URL_FOR_TEST
-        cls.process = popen_launch_server(
-            cls.model,
-            cls.base_url,
-            timeout=DEFAULT_TIMEOUT_FOR_SERVER_LAUNCH,
-            other_args=[
-                "--trust-remote-code",
-                "--speculative-algorithm",
-                "NEXTN",
-                "--speculative-num-steps",
-                "3",
-                "--speculative-eagle-topk",
-                "1",
-                "--speculative-num-draft-tokens",
-                "4",
-                "--mem-fraction-static",
-                "0.8",
-                "--tp",
-                "4",
-                "--chunked-prefill-size",
-                "2048",
-                "--mamba-scheduler-strategy",
-                "extra_buffer",
-                "--mamba-track-interval",
-                "128",
-            ],
-        )
+        try:
+            cls.process = popen_launch_server(
+                cls.model,
+                cls.base_url,
+                timeout=DEFAULT_TIMEOUT_FOR_SERVER_LAUNCH,
+                other_args=[
+                    "--trust-remote-code",
+                    "--speculative-algorithm",
+                    "NEXTN",
+                    "--speculative-num-steps",
+                    "3",
+                    "--speculative-eagle-topk",
+                    "1",
+                    "--speculative-num-draft-tokens",
+                    "4",
+                    "--mem-fraction-static",
+                    "0.8",
+                    "--tp",
+                    "4",
+                    "--chunked-prefill-size",
+                    "2048",
+                    "--mamba-scheduler-strategy",
+                    "extra_buffer",
+                    "--mamba-track-interval",
+                    "128",
+                ],
+            )
+        except Exception:
+            envs.SGLANG_ENABLE_SPEC_V2.set(cls._prev_spec_v2)
+            raise

     `@classmethod`
     def tearDownClass(cls):
-        envs.SGLANG_ENABLE_SPEC_V2.set(False)
-        kill_process_tree(cls.process.pid)
+        envs.SGLANG_ENABLE_SPEC_V2.set(getattr(cls, "_prev_spec_v2", False))
+        if hasattr(cls, "process"):
+            kill_process_tree(cls.process.pid)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/registered/4-gpu-models/test_qwen3_next_models_mtp.py` around lines 217
- 251, setUpClass currently flips the process-global flag
envs.SGLANG_ENABLE_SPEC_V2 to True without preserving the prior value and
tearDownClass always sets it to False; change setUpClass to read and save the
previous value (e.g., prev_spec_v2 = envs.SGLANG_ENABLE_SPEC_V2.get()), then set
True, and if popen_launch_server fails restore the saved value before
propagating the error; also change tearDownClass to restore the saved previous
value (not hardcode False) so the original state is preserved; reference
setUpClass, tearDownClass, envs.SGLANG_ENABLE_SPEC_V2, and popen_launch_server
when making these changes.

python/sglang/srt/disaggregation/decode.py-165-165 (1)

165-165: ⚠️ Potential issue | 🟠 Major

mamba_size is wired to thin air right now.

effective_mamba_size is computed, but _init_mamba_pool(...) still gets size + pre_alloc_size for its capacity args. That makes the new mamba_size input a no-op, so decode-side Mamba state will still be sized incorrectly whenever that cap is set.

Also applies to: 184-197

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/disaggregation/decode.py` at line 165, The new mamba_size
parameter is ignored because _init_mamba_pool(...) is still called with size +
pre_alloc_size; compute the effective_mamba_size (use mamba_size when not None,
otherwise keep existing logic) and pass effective_mamba_size into all
_init_mamba_pool(...) capacity arguments (replace occurrences using size +
pre_alloc_size around the effective_mamba_size computation and in the blocks
referenced roughly at lines 184-197). Also ensure default None handling remains
correct so callers can override capacity by providing mamba_size.

python/sglang/srt/layers/attention/hybrid_linear_attn_backend.py-51-56 (1)

51-56: ⚠️ Potential issue | 🟠 Major

Guard the CuTe DSL fallback path.

If the import fails here, cutedsl_fused_sigmoid_gating_delta_rule_update becomes None, but GDNAttnBackend.__init__ still selects it whenever SGLANG_USE_CUTEDSL_GDN_DECODE is enabled. That turns the first decode into a NoneType call instead of a clean fallback.

Suggested guard

 use_cutedsl = Envs.SGLANG_USE_CUTEDSL_GDN_DECODE.get()
+if use_cutedsl and cutedsl_fused_sigmoid_gating_delta_rule_update is None:
+    rank0_log(
+        "CuTe DSL GDN decode requested but kernel is unavailable; falling back."
+    )
+    use_cutedsl = False
 self._kernel_func = (
     cutedsl_fused_sigmoid_gating_delta_rule_update
     if use_cutedsl
     else fused_sigmoid_gating_delta_rule_update
 )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/layers/attention/hybrid_linear_attn_backend.py` around
lines 51 - 56, The import fall-back leaves
cutedsl_fused_sigmoid_gating_delta_rule_update as None but
GDNAttnBackend.__init__ still picks it when SGLANG_USE_CUTEDSL_GDN_DECODE is
enabled, causing a NoneType call on decode; update GDNAttnBackend.__init__ to
check that cutedsl_fused_sigmoid_gating_delta_rule_update is not None before
selecting it (and only enable the CuTe DSL path when both
SGLANG_USE_CUTEDSL_GDN_DECODE is true and
cutedsl_fused_sigmoid_gating_delta_rule_update is callable), otherwise fall back
to the existing safe implementation so decode never tries to call None.

test/unit/test_mamba_state_scatter_triton.py-164-167 (1)

164-167: ⚠️ Potential issue | 🟠 Major

Fail fast when the fused kernel cannot import on CUDA.

On a CUDA worker, that import is exactly what this test is supposed to validate. skipTest() turns a broken Triton module into a false green.

Suggested fix

-        if fused_mamba_state_scatter_with_mask is None:
-            self.skipTest(
-                f"fused_mamba_state_scatter_with_mask import failed: {_FUSED_IMPORT_ERROR}"
-            )
+        if fused_mamba_state_scatter_with_mask is None:
+            self.fail(
+                f"fused_mamba_state_scatter_with_mask import failed: {_FUSED_IMPORT_ERROR}"
+            )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/unit/test_mamba_state_scatter_triton.py` around lines 164 - 167, The
current test silently skips when fused_mamba_state_scatter_with_mask is None by
calling self.skipTest, which masks import failures on CUDA; change this to fail
fast by replacing the skipTest call with an explicit test failure (e.g.,
self.fail or raise ImportError) that includes _FUSED_IMPORT_ERROR so the test
fails when the Triton fused kernel cannot be imported; locate the check
referencing fused_mamba_state_scatter_with_mask and _FUSED_IMPORT_ERROR and swap
skipTest(...) for a failing call that reports the import error.

test/unit/test_mamba_state_scatter_triton.py-1-2 (1)

1-2: 🛠️ Refactor suggestion | 🟠 Major

Use pytest for this new test module.

This adds a fresh unittest suite under test/, which makes it an outlier for fixtures, markers, and selection.

As per coding guidelines, test/**/*.py: Use pytest for testing with the 9-phase test plan structure in test/phases/.

Also applies to: 160-354

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/unit/test_mamba_state_scatter_triton.py` around lines 1 - 2, The new
test module test/unit/test_mamba_state_scatter_triton.py is written with
unittest; convert it to pytest-style tests by removing the unittest import and
TestCase subclasses and rewriting tests as plain functions (or pytest-style
classes without unittest.TestCase) that use pytest fixtures/markers; ensure you
adopt the repository's 9-phase test plan by hooking into the appropriate
fixtures from test/phases/ and add any required pytest markers (e.g.,
`@pytest.mark`.*) used elsewhere in tests so the file is consistent with pytest
discovery and selection.

python/sglang/srt/mem_cache/memory_pool_host.py-1480-1487 (1)

1480-1487: ⚠️ Potential issue | 🟠 Major

HostPoolGroup serializes only the anchor pool.

get_data_page(), get_dummy_flat_data_page(), and set_from_flat_data_page() all delegate to anchor_entry.host_pool. If this wrapper is used for L3 write/read, every extra PoolEntry disappears on disk round-trips, so restore can bring back KV without the matching Mamba state — like saving the label on the box but not what’s inside it.

Based on learnings, Mamba SSM snapshot persistence is the primary architectural feature being added to SGLang for fast multi-turn inference in the fork.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/mem_cache/memory_pool_host.py` around lines 1480 - 1487,
HostPoolGroup currently only proxies get_data_page, get_dummy_flat_data_page,
and set_from_flat_data_page to anchor_entry.host_pool which causes only the
anchor pool to be serialized; change these methods in HostPoolGroup to operate
on the specific PoolEntry corresponding to the requested index (or
iterate/coordinate across all PoolEntry.host_pool instances for dummy/read/write
operations) so that every PoolEntry.host_pool state is included in
persistence/restore. Locate HostPoolGroup and revise get_data_page(index, flat),
get_dummy_flat_data_page(), and set_from_flat_data_page(index, data_page) to
reference the correct PoolEntry (not just anchor_entry) and ensure the
serialization logic writes/reads each PoolEntry.host_pool state so KV and Mamba
state remain consistent after disk round-trips.

python/sglang/srt/layers/attention/hybrid_linear_attn_backend.py-242-247 (1)

242-247: ⚠️ Potential issue | 🟠 Major

DRAFT_EXTEND_V2 still initializes linear metadata with None.

HybridLinearAttnBackend.init_forward_metadata() calls every sub-backend. In this file, both Mamba2AttnBackend.init_forward_metadata() and LightningAttentionBackend.init_forward_metadata() immediately pass metadata.query_start_loc into prepare_*, so returning None here can still fail before layer dispatch ever skips the Mamba path.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/layers/attention/hybrid_linear_attn_backend.py` around
lines 242 - 247, The branch for forward_batch.forward_mode.is_draft_extend_v2()
sets query_start_loc = None which breaks downstream init_forward_metadata calls
that immediately forward metadata.query_start_loc into prepare_*; change this to
a valid integer (e.g., 0) instead of None so
Mamba2AttnBackend.init_forward_metadata and
LightningAttentionBackend.init_forward_metadata receive a usable
metadata.query_start_loc during HybridLinearAttnBackend.init_forward_metadata
execution (ensure the value is an int derived from the forward_batch or default
to 0).

python/sglang/srt/mem_cache/session_aware_cache.py-20-27 (1)

20-27: ⚠️ Potential issue | 🟠 Major

Give _VirtualNode the tiny HiCache node interface, or stop returning it as last_host_node.

match_prefix() currently hands downstream HiCache code a sentinel with no backuped, parent, get_last_hash_value(), or get_prefix_hash_values(). With streaming sessions plus storage prefetch enabled, the first slot hit will crash with AttributeError instead of just skipping prefetch.

🩹 One lightweight way to make the sentinel safe

 class _VirtualNode:
     """Sentinel node for streaming session requests.
@@
-    pass
+    backuped = False
+    parent = None
+
+    def get_last_hash_value(self):
+        return None
+
+    def get_prefix_hash_values(self, _node):
+        return []

Also applies to: 177-181

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/mem_cache/session_aware_cache.py` around lines 20 - 27,
match_prefix() can return the sentinel _VirtualNode as last_host_node but that
sentinel lacks the small HiCache node interface leading to AttributeError when
downstream code expects attributes/methods like backuped, parent,
get_last_hash_value(), and get_prefix_hash_values(); fix by giving _VirtualNode
that tiny interface (add attributes backuped and parent and stub methods
get_last_hash_value and get_prefix_hash_values that return safe defaults) or
change match_prefix() to never return _VirtualNode as last_host_node; update the
_VirtualNode class (and the other sentinel at lines ~177-181) to implement these
minimal members so streaming-session code and prefetch can safely call them.

python/sglang/srt/managers/scheduler.py-2594-2606 (1)

2594-2606: ⚠️ Potential issue | 🟠 Major

Keep the fast-fail Req wired to the original worker and trace.

This fallback constructor drops http_worker_ipc and time_stats. In multi-http-worker mode the abort can lose its way home, and this path also disappears from the request-level timing/trace data.

🔧 Minimal fix

             req = Req(
                 recv_req.rid,
                 recv_req.input_text,
                 recv_req.input_ids,
                 recv_req.sampling_params,
                 vocab_size=self.model_config.vocab_size,
+                http_worker_ipc=recv_req.http_worker_ipc,
+                time_stats=recv_req.time_stats,
             )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/managers/scheduler.py` around lines 2594 - 2606, The
fast-fail Req being constructed drops the original request's worker/trace info
so aborts and timing are lost; when creating the fallback Req (the one using
recv_req.rid/... and calling set_finish_with_abort, init_req_max_new_tokens, and
_add_request_to_queue) copy over recv_req.http_worker_ipc and
recv_req.time_stats (and any trace/worker fields used for routing/metrics) onto
the new req so the abort will route back to the original worker and the
request-level timing/trace data is preserved.

python/sglang/srt/mem_cache/session_aware_cache.py-68-75 (1)

68-75: ⚠️ Potential issue | 🟠 Major

Release the slot-held Mamba allocation when the session closes.

save_from_req() moves mamba_pool_idx out of the request, but release_session() only frees KV indices and the req-pool slot. On hybrid/Mamba models, closing enough streaming sessions will slowly exhaust the Mamba pool even though the sessions are gone.

Also applies to: 218-238

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/mem_cache/session_aware_cache.py` around lines 68 - 75, The
session leaves a held Mamba allocation behind because save_from_req() moves
mamba_pool_idx out of the request but release_session() only clears req_pool_idx
and KV indices; update release_session() to also free the mamba slot when
present by checking session.mamba_pool_idx (and any related fields like
mamba_ping_pong_track_buffer, mamba_next_track_idx, mamba_last_track_seqlen,
mamba_branching_seqlen), return that index to the Mamba pool allocator and set
session.mamba_pool_idx (and the corresponding req.mamba_* fields if applicable)
to None/cleared; apply the same cleanup logic to the other release branch
referenced around the 218-238 area so hybrid/Mamba sessions do not leak pool
slots.

python/sglang/srt/managers/session_controller.py-116-133 (1)

116-133: ⚠️ Potential issue | 🟠 Major

Don’t rotate a streaming session onto a still-running request.

The streaming path reuses the previous request without checking last_req.finished(). If another turn sneaks in while the first one is still decoding, the new request is built from partial output_ids and the old request loses its session link mid-flight — like changing train tracks while the cars are still moving.

🧭 Suggested guard

         elif self.req_nodes:
             assert len(self.req_nodes) == 1
-            _, last_req_node = self.req_nodes.popitem()
+            last_rid, last_req_node = next(iter(self.req_nodes.items()))
             last_req = last_req_node.req
+            if not last_req.finished():
+                abort = True
+                abort_message = (
+                    "Streaming session request is appending to a request that hasn't finished."
+                )
+                logging.warning(abort_message)
+            else:
+                self.req_nodes.pop(last_rid)

Also applies to: 225-233

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/managers/session_controller.py` around lines 116 - 133,
When reusing the previous request in the streaming path, guard against rotating
onto a still-running request: in the block where self.streaming and
self.req_nodes is inspected (the code that pops last_req_node and sets
last_req), first peek the last_req_node.req and call its finished() (or
equivalent) — if finished() is False then do not pop or reuse it; instead set
abort = True and abort_message = "Cannot rotate streaming session onto a
still-running request." Apply the same guard in the other similar block
referenced (the block around lines 225-233) so both places check
last_req.finished() before reusing or popping the previous request.

python/sglang/test/run_eval.py-101-104 (1)

101-104: ⚠️ Potential issue | 🟡 Minor

Fix: Change --dataset-path default to None to allow per-eval defaults.

The GPQA fallback pattern looks defensive, but there's a logical trap. Since --dataset-path has a default value of "THUDM/LongBench-v2" (line 270), the command:

python3 -m sglang.test.run_eval --eval-name gpqa

...will set args.dataset_path to the LongBench-v2 default, making it truthy. The or fallback to the GPQA CSV URL never triggers—it's like setting up a safety net under the wrong apparatus. GPQAEval then receives the wrong dataset and fails on pandas.read_csv().

The fix is simple: change the --dataset-path default to None so each evaluator applies its own appropriate default. This is safe because LongBenchV2Eval has internal fallback logic (if not data_source: data_source = DEFAULT_DATASET), so passing None still works correctly for LongBench v2.

Proposed fix: Change default to None

     parser.add_argument(
         "--dataset-path",
         type=str,
-        default="THUDM/LongBench-v2",
+        default=None,
         help="Path to dataset file or HuggingFace dataset name for LongBench-v2",
     )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/test/run_eval.py` around lines 101 - 104, Change the CLI
default for --dataset-path from the string "THUDM/LongBench-v2" to None so
per-evaluator defaults can apply; update the argument definition that creates
args.dataset_path (the add_argument call for "dataset_path") to use
default=None, ensuring GPQAEval(filename, ...) sees the intended None/fallback
path and LongBenchV2Eval still handles None via its internal fallback logic.

docs/superpowers/plans/2026-03-31-phase-04-mamba-cache-architecture-reconcile.md-477-484 (1)

477-484: ⚠️ Potential issue | 🟡 Minor

Remove the first import check; python.sglang is not a valid import path in this repo.

The first import (import python.sglang...) is like checking if a door exists by walking into a wall—it never works and masks whether the real door (the sys.path pattern) actually opens. Since the package root is sglang (per pyproject.toml), only the second import pattern with sys.path.insert(0, 'python') is valid. The codebase uses this pattern consistently everywhere, so simplify the script to rely on the one path that actually works.

🔧 Suggested adjustment

-python -c "
-import python.sglang.srt.snapshot.mamba_snapshot as ms
-print('mamba_snapshot imports OK')
-" 2>&1 || python -c "
+python -c "
 import sys; sys.path.insert(0, 'python')
 from sglang.srt.snapshot.mamba_snapshot import MambaSnapshotManager
 print('MambaSnapshotManager importable')
 " 2>&1 || echo "Import check deferred to runtime validation"

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
`@docs/superpowers/plans/2026-03-31-phase-04-mamba-cache-architecture-reconcile.md`
around lines 477 - 484, Remove the invalid import check that tries to import
python.sglang.srt.snapshot.mamba_snapshot and instead keep the working pattern
that prepends 'python' to sys.path and imports MambaSnapshotManager from
sglang.srt.snapshot.mamba_snapshot; specifically, delete the first python -c
block (the "import python.sglang..." check) and rely on the second block that
does sys.path.insert(0, 'python') followed by from
sglang.srt.snapshot.mamba_snapshot import MambaSnapshotManager so the import
validation uses the correct package root and matches other scripts.

python/sglang/srt/mem_cache/base_prefix_cache.py-132-136 (1)

132-136: ⚠️ Potential issue | 🟡 Minor

Keep host_hit_length as a count, not a sentinel.

Using max(kv_host_tokens, 1-if-mamba-on-host) turns this field into both an odometer and a warning light. Downstream accounting still treats it as literal token count, so a state-only host restore will be reported as a one-token host hit unless every consumer special-cases the sentinel.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/mem_cache/base_prefix_cache.py` around lines 132 - 136, The
host_hit_length field is being used as both a token count and a sentinel via
max(kv_host_tokens, 1 - if-mamba-on-host); change it to always carry the literal
token count (i.e., set host_hit_length = kv_host_tokens) and stop injecting the
1-as-sentinel behavior. Introduce or set a separate boolean/enum flag (e.g.,
host_state_only or mamba_host_restore) to indicate a state-only/mamba-on-host
restore when applicable (use the existing mamba-on-host condition to populate
that flag). Update the code paths that compute and consume host_hit_length
(refer to host_hit_length and kv_host_tokens in this module) and adjust any
docs/comments to state host_hit_length is a pure count and the new flag
indicates state-only restores.

python/sglang/srt/managers/io_struct.py-1642-1643 (1)

1642-1643: ⚠️ Potential issue | 🟡 Minor

Validate timeout to reject non-positive values.

timeout currently accepts negative (or zero) values, which can cause confusing immediate-timeout behavior at session open.

Suggested fix

 `@dataclass`
 class OpenSessionReqInput(BaseReq):
     capacity_of_str_len: int
     session_id: Optional[str] = None
     streaming: bool = False
     timeout: Optional[float] = None
+
+    def __post_init__(self):
+        if self.timeout is not None and self.timeout <= 0:
+            raise ValueError("timeout must be > 0 when provided.")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/managers/io_struct.py` around lines 1642 - 1643, Validate
the timeout attribute so it cannot be zero or negative: in the class or
dataclass that defines the streaming and timeout fields (the object containing
attributes streaming: bool and timeout: Optional[float]), add a check in the
constructor/__post_init__ (or the setter used for timeout) that raises a
ValueError if timeout is not None and timeout <= 0, with a clear message like
"timeout must be positive or None"; ensure callers that pass timeout get the
same validation behavior when constructing or modifying the instance.

python/sglang/srt/server_args.py-2096-2110 (1)

2096-2110: ⚠️ Potential issue | 🟡 Minor

Reject unknown mamba_backend values in _handle_mamba_backend.

argparse guards the CLI path, but direct ServerArgs(...) callers can still pass arbitrary strings and this method currently treats any non-flashinfer value as valid. That lets a typo slip past the front desk and blow up later in backend dispatch.

Suggested guard

 def _handle_mamba_backend(self):
+    if self.mamba_backend not in MAMBA_BACKEND_CHOICES:
+        raise ValueError(
+            f"Invalid mamba backend: {self.mamba_backend}. "
+            f"Expected one of {MAMBA_BACKEND_CHOICES}."
+        )
+
     if self.mamba_backend == "flashinfer":
         if is_flashinfer_available():
             try:
                 import flashinfer.mamba  # noqa: F401

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/server_args.py` around lines 2096 - 2110, The
_handle_mamba_backend method currently only handles the "flashinfer" case and
silently accepts any other mamba_backend value; update it to explicitly reject
unknown values by validating self.mamba_backend against allowed backends (e.g.,
"flashinfer") and raising a ValueError with a clear message when the value is
not recognized. Locate the _handle_mamba_backend method and add an else branch
(or an initial validation) that checks self.mamba_backend and raises
ValueError("Unknown mamba_backend: {self.mamba_backend}. Supported backends:
flashinfer") so direct ServerArgs(...) callers cannot pass arbitrary strings.

python/sglang/srt/layers/attention/mamba/ops/ssu_dispatch.py-21-42 (1)

21-42: ⚠️ Potential issue | 🟡 Minor

Move the abstract __call__ body onto its own line.

def __call__(...) -> None: ... is the E704 flake8 error here, so this file will keep pre-commit red until the body is rewritten as a normal block.

✏️ Lint-safe form

     `@abstractmethod`
     def __call__(
         self,
         state: torch.Tensor,
         x: torch.Tensor,
@@
         cache_steps: int | None = None,
         retrieve_parent_token: torch.Tensor | None = None,
         intermediate_state_indices: torch.Tensor | None = None,
-    ) -> None: ...
+    ) -> None:
+        pass

As per coding guidelines, "Lint code using ruff via pre-commit hooks".

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/layers/attention/mamba/ops/ssu_dispatch.py` around lines 21
- 42, The abstractmethod decorated __call__ signature currently ends with a
trailing ellipsis causing E704; change the stub from a single-line "def
__call__(...) -> None: ..." to a proper block for the abstractmethod (e.g.,
place the colon at end of the signature line and add an indented body on the
next line) and use a suitable no-op or explicit abstract implementation such as
"raise NotImplementedError" (or "pass") inside the body so the abstract __call__
in this class is lint-compliant; look for the __call__ method definition with
the `@abstractmethod` decorator to apply this change.

python/sglang/srt/mem_cache/memory_pool.py-551-557 (1)

551-557: ⚠️ Potential issue | 🟡 Minor

F-strings missing placeholders — should be regular strings.

Static analysis flagged these f-strings as having no interpolation. They should be plain strings to avoid confusion.

         assert len(select_index) == len(
             mamba_indices
-        ), f"Not enough space for mamba cache, try to increase --mamba-full-memory-ratio or --max-mamba-cache-size."
+        ), "Not enough space for mamba cache, try to increase --mamba-full-memory-ratio or --max-mamba-cache-size."
         if self.enable_mamba_extra_buffer:
             assert len(select_index) == len(
                 mamba_ping_pong_track_buffers
-            ), f"Not enough space for mamba ping pong idx, try to increase --mamba-full-memory-ratio."
+            ), "Not enough space for mamba ping pong idx, try to increase --mamba-full-memory-ratio."

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/mem_cache/memory_pool.py` around lines 551 - 557, Replace
the two assert messages that are written as f-strings but contain no
interpolation with plain string literals; locate the assertions in
memory_pool.py where select_index, mamba_indices, and (when
enable_mamba_extra_buffer is True) mamba_ping_pong_track_buffers are compared
and change the f"... " messages to regular strings like "Not enough space for
mamba cache, try to increase --mamba-full-memory-ratio or
--max-mamba-cache-size." and "Not enough space for mamba ping pong idx, try to
increase --mamba-full-memory-ratio." to avoid misleading f-strings in the code
paths using select_index, mamba_indices, and enable_mamba_extra_buffer.

.gitignore (1)

241-242: Nice organizational touch!

The new "# Other repos" section clearly groups external repository ignores.

If lmms-eval refers specifically to a cloned directory (which seems likely), consider using lmms-eval/ with a trailing slash for precision—think of it like a targeted spell versus an area-of-effect one. Without the slash, it'll match both files and directories named lmms-eval, which might be broader than needed.

📁 Optional refinement for directory-specific pattern

 # Other repos
-lmms-eval
+lmms-eval/

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.gitignore around lines 241 - 242, Change the .gitignore entry so it matches
only the directory by updating the existing "lmms-eval" pattern to a
directory-specific pattern; locate the "lmms-eval" line under the "# Other
repos" section and replace it with a trailing-slash pattern (use "lmms-eval/")
so only the cloned directory is ignored, not files that might share the same
name.

test/registered/models/test_nvidia_nemotron_3_nano.py (1)

29-39: Nice coverage target; please land it in the phase-based pytest plan instead of another unittest class.

This grows the legacy registered matrix again, so the flashinfer coverage lives in a parallel lane rather than the repo’s main 9-phase flow.

As per coding guidelines, test/**/*.py: Use pytest for testing with the 9-phase test plan structure in test/phases/.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/registered/models/test_nvidia_nemotron_3_nano.py` around lines 29 - 39,
The test class TestNvidiaNemotron3Nano30BBF16FlashInfer should be converted from
a unittest-style registered matrix class into a pytest phase-based test under
the repo’s 9-phase plan: remove the class and instead implement a pytest test in
the phases structure that invokes the same model
("nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16"), model_config_name
("lm_eval_configs/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16.yaml"), other_args
(including "--tp-size","2","--mamba-backend","flashinfer" plus
NEMOTRON_3_NANO_THINKING_ARGS) and integrates with the existing phase
fixtures/markers used by the test/phases flow so the flashinfer coverage runs in
the main 9-phase pipeline rather than as a parallel unittest class.

test/registered/4-gpu-models/test_qwen3_next_models_mtp.py (1)

215-297: Useful spec-v2 coverage; please land it in test/phases/ with pytest.

Adding another unittest suite here keeps the new validation outside the repo’s phase plan, which makes the test story harder to read and maintain.

As per coding guidelines, test/**/*.py: Use pytest for testing with the 9-phase test plan structure in test/phases/.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@test/registered/4-gpu-models/test_qwen3_next_models_mtp.py` around lines 215
- 297, The TestQwen3NextMTPV2 unittest class should be converted into a pytest
test module under test/phases/ to follow the 9-phase test plan; replace the
class-based setUpClass/tearDownClass (envs.SGLANG_ENABLE_SPEC_V2 toggling and
popen_launch_server/kill_process_tree usage) with pytest fixtures that launch
the server (popen_launch_server) and yield the base_url/process, and rewrite
test_gsm8k as a plain pytest test function that calls run_eval and asserts
against ACC_THRESHOLDS[self.model]["gsm8k"]; ensure helper names
(popen_launch_server, kill_process_tree, run_eval, ACC_THRESHOLDS,
QWEN3_NEXT_MODEL, envs.SGLANG_ENABLE_SPEC_V2) are imported or referenced the
same way and place the file in the appropriate phase slot so it integrates with
the repo phase plan.

python/sglang/srt/mem_cache/hi_mamba_radix_cache.py (1)

2079-2086: Potential issue: _alloc_with_evict could return None when indexing [0].

At line 2086, _alloc_with_evict(...)[0] assumes the allocation succeeded. However, _alloc_with_evict returns None if allocation fails even after eviction. Although error_message is set which would raise RuntimeError, the exception path might not be the intended behavior here.

Consider explicitly checking for None before indexing, or ensuring the exception is the desired outcome:

indices = self._alloc_with_evict(
    self.req_to_token_pool.mamba_pool,
    len(last_hit_node.mamba_host_value),
    self.evict_mamba,
    lock_node=last_hit_node,
    error_message="Cannot alloc request mamba cache for host load back",
)
# indices is guaranteed non-None due to error_message raising RuntimeError
req.mamba_pool_idx = indices[0]

The current code works correctly because error_message is provided, triggering the exception. But the inline [0] makes it easy to miss this dependency during code review.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@python/sglang/srt/mem_cache/hi_mamba_radix_cache.py` around lines 2079 -
2086, The code currently indexes the result of _alloc_with_evict(...) directly
with [0], which can be None on failure; change it to first capture the return
value from _alloc_with_evict (called with self.req_to_token_pool.mamba_pool,
len(last_hit_node.mamba_host_value), self.evict_mamba, lock_node=last_hit_node,
error_message="Cannot alloc request mamba cache for host load back") into a
local variable, then either assert/raise if that variable is None or rely on the
provided error_message to raise and only then set req.mamba_pool_idx =
indices[0]; this makes the dependency on _alloc_with_evict’s exception behavior
explicit and avoids an accidental None indexing bug.

python/sglang/srt/mem_cache/hicache_storage.py (1)

493-517: Consider edge case when page_size is not defined on host_pool.

Line 498 uses getattr(host_pool, "page_size", 1) or 1 which handles missing/None/0 cases well. However, line 514 assumes host_indices is indexable by i * page_size. If page_size > 1 but host_indices doesn't have the expected length (despite the check at 502), accessing host_indices[i * page_size] could still be out of bounds for the last few entries when len(keys) * page_size != host_indices.numel().

The validation at 502-510 should catch this, but the error message could be clearer about what "expected" vs "got" means in terms of page alignment.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes