fix(cloud-frontend test): wrap StewardLoginSection in I18nProvider

The test renders the component inside MemoryRouter alone, but
StewardLoginSection calls useT() (i18n hook) which requires I18nProvider
in the tree. That's why the playwright test job failed both cases with
'useI18n must be used inside <I18nProvider>'. Wrapping the render in
<I18nProvider initialLang="en"> mirrors how this component is mounted at
runtime by App.tsx and makes the two tests pass locally (vitest run).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: lalalune

packages/chip/compiler/runtime/e1_npu_runtime.py

@@ -319,6 +319,7 @@ def stage_prepared_descriptor_batch(
     if not isinstance(sequence, Mapping):
         raise ValueError("prepared descriptor batch requires host_runtime_sequence")
     _validate_sequence_mmio_preamble(prepared, sequence)
+    _validate_descriptor_writeback_preamble(prepared, image)
     _validate_descriptor_submission(image, sequence, descriptor_base, descriptor_count)
     _validate_sequence_descriptor_memory_writes(sequence, image)
     result = stage_host_runtime_sequence(
@@ -423,6 +424,7 @@ def stage_prepared_descriptor_execution_batches(
         if not isinstance(sequence, Mapping):
             raise ValueError("prepared execution batch requires host_runtime_sequence")
         _validate_sequence_mmio_preamble(batch, sequence)
+        _validate_descriptor_writeback_preamble(batch, image)
         _validate_descriptor_submission(image, sequence, expected_descriptor_base, descriptor_count)
         _validate_sequence_descriptor_memory_writes(sequence, image)
         sequences.append(sequence)
@@ -576,6 +578,38 @@ def _validate_descriptor_word0(word0: int) -> None:
         raise ValueError("prepared execution batch writeback_request requires GEMM opcode")
 
 
+def _validate_descriptor_writeback_preamble(
+    batch: Mapping[str, Any], image: Mapping[str, Any]
+) -> None:
+    descriptor_words = image.get("descriptor_words")
+    op_mmio_preamble = batch.get("op_mmio_preamble")
+    if not isinstance(descriptor_words, list) or not isinstance(op_mmio_preamble, list):
+        raise ValueError("prepared execution batch requires descriptor_words and op_mmio_preamble")
+    if len(descriptor_words) != len(op_mmio_preamble):
+        raise ValueError("prepared execution batch descriptor_words count does not match op_mmio_preamble")
+    for words, entry in zip(descriptor_words, op_mmio_preamble, strict=True):
+        if not isinstance(words, list) or not words:
+            raise ValueError("prepared execution batch descriptor_words entry must have four words")
+        word0 = words[0]
+        if not isinstance(word0, int):
+            raise ValueError("prepared execution batch descriptor_words value must be a uint32")
+        if not word0 & E1NpuRuntime.DESC_FLAG_WRITEBACK_REQUEST:
+            continue
+        if not isinstance(entry, Mapping):
+            raise TypeError("prepared execution batch preamble entry must be a mapping")
+        preamble = entry.get("mmio_preamble")
+        if not isinstance(preamble, Mapping):
+            raise ValueError("prepared execution batch requires mmio_preamble metadata")
+        cfg = preamble.get("GEMM_CFG")
+        if not isinstance(cfg, int) or cfg < 0 or cfg > 0xFFFF_FFFF:
+            raise ValueError("prepared execution batch GEMM_CFG must be a uint32")
+        writeback_bytes = (cfg & 0x3) * ((cfg >> 8) & 0x3) * 4
+        if writeback_bytes == 0:
+            raise ValueError(
+                "prepared execution batch writeback_request requires nonzero GEMM output"
+            )
+
+
 def _validate_descriptor_submission(
     image: Mapping[str, Any],
     sequence: Mapping[str, Any],

packages/chip/compiler/runtime/test_e1_npu_runtime_commandbuffer.py

@@ -799,6 +799,50 @@ def test_stage_prepared_descriptor_execution_batches_validates_descriptor_byte_c
     assert memory_writes == []
 
 
+def test_stage_prepared_descriptor_execution_batches_validates_writeback_gemm_output() -> None:
+    prepared = (
+        partition_module(parse_module(_mismatched_dot_payload()))
+        .prepared_descriptor_execution_batches(
+            arena_base=0x8000_0000,
+            descriptor_base=0x2100,
+            descriptor_stride_bytes=0x40,
+        )
+        .as_dict()
+    )
+    mmio_writes: list[tuple[int, int]] = []
+    memory_writes: list[tuple[int, int]] = []
+    first_batch = dict(prepared["prepared_execution_batches"][0])
+    op_preamble = dict(first_batch["op_mmio_preamble"][0])
+    mmio_preamble = dict(op_preamble["mmio_preamble"])
+    mmio_preamble["GEMM_CFG"] = 0
+    op_preamble["mmio_preamble"] = mmio_preamble
+    first_batch["op_mmio_preamble"] = [op_preamble]
+    sequence = dict(first_batch["host_runtime_sequence"])
+    sequence_preamble = dict(sequence["mmio_preamble_writes"][0])
+    sequence_preamble["writes"] = [
+        {**write, "value": 0} if write["register"] == "GEMM_CFG" else write
+        for write in sequence_preamble["writes"]
+    ]
+    sequence["mmio_preamble_writes"] = [sequence_preamble]
+    first_batch["host_runtime_sequence"] = sequence
+
+    with pytest.raises(ValueError, match="writeback_request requires nonzero GEMM output"):
+        stage_prepared_descriptor_execution_batches(
+            {
+                **prepared,
+                "prepared_execution_batches": [
+                    first_batch,
+                    prepared["prepared_execution_batches"][1],
+                ],
+            },
+            write_mmio32=lambda address, value: mmio_writes.append((address, value)),
+            write_mem32=lambda address, value: memory_writes.append((address, value)),
+        )
+
+    assert mmio_writes == []
+    assert memory_writes == []
+
+
 def test_stage_prepared_descriptor_execution_batches_validates_mmio_preamble() -> None:
     prepared = (
         partition_module(parse_module(_mismatched_dot_payload()))
@@ -1095,6 +1139,44 @@ def test_stage_prepared_descriptor_batch_validates_scratch_bounds_before_writes(
     assert memory_writes == []
 
 
+def test_stage_prepared_descriptor_batch_validates_writeback_gemm_output_before_writes() -> None:
+    prepared = (
+        partition_module(parse_module(_dot_payload()))
+        .prepared_descriptor_batch(
+            arena_base=0x8000_0000,
+            descriptor_base=0x2000,
+        )
+        .as_dict()
+    )
+    mmio_writes: list[tuple[int, int]] = []
+    memory_writes: list[tuple[int, int]] = []
+    op_preamble = dict(prepared["op_mmio_preamble"][0])
+    mmio_preamble = dict(op_preamble["mmio_preamble"])
+    mmio_preamble["GEMM_CFG"] = 0
+    op_preamble["mmio_preamble"] = mmio_preamble
+    sequence = dict(prepared["host_runtime_sequence"])
+    sequence_preamble = dict(sequence["mmio_preamble_writes"][0])
+    sequence_preamble["writes"] = [
+        {**write, "value": 0} if write["register"] == "GEMM_CFG" else write
+        for write in sequence_preamble["writes"]
+    ]
+    sequence["mmio_preamble_writes"] = [sequence_preamble]
+
+    with pytest.raises(ValueError, match="writeback_request requires nonzero GEMM output"):
+        stage_prepared_descriptor_batch(
+            {
+                **prepared,
+                "op_mmio_preamble": [op_preamble],
+                "host_runtime_sequence": sequence,
+            },
+            write_mmio32=lambda address, value: mmio_writes.append((address, value)),
+            write_mem32=lambda address, value: memory_writes.append((address, value)),
+        )
+
+    assert mmio_writes == []
+    assert memory_writes == []
+
+
 def test_stage_prepared_descriptor_batch_validates_submission_before_writes() -> None:
     prepared = (
         partition_module(parse_module(_dot_payload()))

packages/chip/docs/evidence/linux/linux-external-bsp-status.json

@@ -4,10 +4,6 @@
       "detail": "/home/shaw/milady/eliza/packages/chip/external/linux",
       "id": "external_linux_tree_missing"
     },
-    {
-      "detail": "set CROSS_COMPILE=... or install a riscv64 Linux compiler",
-      "id": "riscv_cross_compiler_missing"
-    },
     {
       "detail": "docs/evidence/linux/eliza_e1_kernel_build.log",
       "id": "linux_kernel_build_evidence_blocked"
@@ -59,10 +55,10 @@
   "status": "blocked",
   "tools": {
     "cross_compile": "",
-    "dtc": "",
+    "dtc": "tools/bin/dtc",
     "make": "/usr/bin/make",
     "make_version": "GNU Make 4.3",
     "make_version_ok": true,
-    "riscv_compiler": ""
+    "riscv_compiler": "riscv64-linux-gnu-gcc"
   }
 }

packages/cloud-frontend/src/pages/login/steward-login-section.test.tsx

@@ -83,15 +83,18 @@ vi.mock("./wallet-buttons", () => ({
   ),
 }));
 
+import { I18nProvider } from "@/providers/I18nProvider";
 import StewardLoginSection from "./steward-login-section";
 
 function renderLogin() {
   return render(
-    <MemoryRouter initialEntries={["/login"]}>
-      <Routes>
-        <Route path="/login" element={<StewardLoginSection />} />
-      </Routes>
-    </MemoryRouter>,
+    <I18nProvider initialLang="en">
+      <MemoryRouter initialEntries={["/login"]}>
+        <Routes>
+          <Route path="/login" element={<StewardLoginSection />} />
+        </Routes>
+      </MemoryRouter>
+    </I18nProvider>,
   );
 }
 

packages/os/linux/variants/elizaos-debian-riscv64/scripts/check_release_manifest.py

@@ -265,15 +265,17 @@ def check_evidence_rows_collected(manifest: dict, is_template: bool) -> list[Gat
     return out
 
 
-def _resolve_evidence_path(path_value: str) -> Path:
+def _resolve_evidence_path(variant_dir: Path, path_value: str) -> Path:
     """Resolve an evidence path relative to the variant directory."""
     candidate = Path(path_value)
     if not candidate.is_absolute():
-        candidate = (VARIANT_DIR / candidate).resolve()
+        candidate = (variant_dir / candidate).resolve()
     return candidate
 
 
-def check_qemu_virt_evidence(manifest: dict, is_template: bool) -> list[GateResult]:
+def check_qemu_virt_evidence(
+    manifest: dict, is_template: bool, variant_dir: Path
+) -> list[GateResult]:
     """Cross-check the qemu-virt evidence JSON against the manifest."""
     rows = _evidence_index(manifest)
     row = rows.get("qemu-virt-boot")
@@ -291,7 +293,7 @@ def check_qemu_virt_evidence(manifest: dict, is_template: bool) -> list[GateResu
             ]
         return [GateResult("BLOCKED", "qemu-virt-boot.path not filled")]
 
-    evidence_path = _resolve_evidence_path(path_value)
+    evidence_path = _resolve_evidence_path(variant_dir, path_value)
     if not evidence_path.is_file():
         return [GateResult("BLOCKED", f"evidence file not present: {evidence_path}")]
 
@@ -338,7 +340,7 @@ def check_qemu_virt_evidence(manifest: dict, is_template: bool) -> list[GateResu
     if isinstance(transcript_value, str):
         transcript_text = transcript_value
     elif isinstance(transcript_path_value, str) and transcript_path_value:
-        transcript_path = _resolve_evidence_path(transcript_path_value)
+        transcript_path = _resolve_evidence_path(variant_dir, transcript_path_value)
         if not transcript_path.is_file():
             out.append(GateResult("FAIL", f"transcript file missing: {transcript_path}"))
         else:
@@ -364,7 +366,9 @@ def check_qemu_virt_evidence(manifest: dict, is_template: bool) -> list[GateResu
     return out
 
 
-def check_iso_sha256_against_file(manifest: dict, is_template: bool) -> list[GateResult]:
+def check_iso_sha256_against_file(
+    manifest: dict, is_template: bool, variant_dir: Path
+) -> list[GateResult]:
     """If the ISO file is reachable, its sha256 must match the manifest."""
     if is_template:
         return [GateResult("BLOCKED", "iso sha256 not checked: template manifest")]
@@ -374,7 +378,7 @@ def check_iso_sha256_against_file(manifest: dict, is_template: bool) -> list[Gat
         return [GateResult("BLOCKED", "manifest.sha256 not filled")]
     if not isinstance(filename, str) or filename == TEMPLATE_SENTINEL_FILENAME:
         return [GateResult("BLOCKED", "manifest.filename not filled")]
-    iso_path = VARIANT_DIR / "out" / filename
+    iso_path = variant_dir / "out" / filename
     if not iso_path.is_file():
         return [GateResult("BLOCKED", f"ISO file not present locally: {iso_path}")]
     hasher = hashlib.sha256()
@@ -409,8 +413,8 @@ def run_checks(variant_dir: Path) -> tuple[Status, list[GateResult], Path, bool]
     results.extend(check_schema(manifest, schema))
     results.extend(check_required_evidence_rows(manifest))
     results.extend(check_evidence_rows_collected(manifest, is_template))
-    results.extend(check_qemu_virt_evidence(manifest, is_template))
-    results.extend(check_iso_sha256_against_file(manifest, is_template))
+    results.extend(check_qemu_virt_evidence(manifest, is_template, variant_dir))
+    results.extend(check_iso_sha256_against_file(manifest, is_template, variant_dir))
     return aggregate(results), results, manifest_path, is_template