@elizaos/app-core 2.0.0-beta.2 → 2.0.11-beta.5

package/scripts/lib/stage-android-agent.mjs

@@ -9,9 +9,7 @@
  *
  * Layout produced under `packages/app/android/app/src/main/assets/agent/`:
  *
- *   agent-bundle.js                 (ABI-independent entry point; placeholder
- *                                    until Phase D replaces it with the real
- *                                    @elizaos/agent bundle)
+ *   agent-bundle.js                 (ABI-independent @elizaos/agent bundle)
  *   launch.sh                       (ABI-independent device-side launcher,
  *                                    a parameterised double-fork daemoniser)
  *   x86_64/bun                      (cuttlefish + x86_64 emulator)
@@ -22,43 +20,56 @@
  *   arm64-v8a/ld-musl-aarch64.so.1
  *   arm64-v8a/libstdc++.so.6.0.33
  *   arm64-v8a/libgcc_s.so.1
+ *   riscv64/bun                     (cuttlefish riscv64; required unless
+ *                                    ELIZA_BUN_RISCV64_OPTIONAL=1 since
+ *                                    upstream Bun has no riscv64-linux-musl
+ *                                    release)
+ *   riscv64/ld-musl-riscv64.so.1
+ *   riscv64/libstdc++.so.6.0.33
+ *   riscv64/libgcc_s.so.1
  *
  * Downloads are cached under `~/.cache/eliza-android-agent/<bun-version>/`
- * and the staging step is idempotent — already-staged files with the
- * matching size are left in place.
+ * and the staging step is idempotent — already-staged files with matching
+ * bytes are left in place.
  *
- * Pinned versions (mirrors scripts/spike-android-agent/bootstrap.sh):
- *   - bun 1.3.13                     proven on the Phase 0 spike
+ * Pinned versions:
+ *   - bun 1.3.14                     validated by Android agent bring-up
  *   - Alpine v3.21                   ships gcc 14.2 → libstdc++.so.6.0.33
  *
- * The ABI-independent `launch.sh` and `agent-bundle.js` placeholder are
- * derived from `scripts/spike-android-agent/launch-on-device.sh` and
- * `scripts/spike-android-agent/server.js` respectively. Phase D replaces
- * `agent-bundle.js` with the real bundled runtime.
+ * The ABI-independent `launch.sh` is the packaged production launcher;
+ * `agent-bundle.js` is produced by `bun run --cwd packages/agent build:mobile`.
  */
 import { spawn } from "node:child_process";
+import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const APP_CORE_ROOT = path.resolve(__dirname, "..", "..");
+const ELIZA_REPO_ROOT = path.resolve(APP_CORE_ROOT, "..", "..");
 
-const BUN_VERSION = "1.3.13";
-// Bun 1.3.13 has a segfault we hit during inference on Cuttlefish at
-// peak ~2.3 GB RSS ("panic(main thread): Segmentation fault at address
-// 0x5420"). The canary channel ships the upstream fix while we wait for
-// 1.3.14+. MILADY_BUN_CHANNEL=stable forces back to BUN_VERSION; default
-// is canary so AOSP/cvd inference doesn't crash mid-token.
-const BUN_CHANNEL = (process.env.MILADY_BUN_CHANNEL ?? "canary").toLowerCase();
+const BUN_VERSION = "1.3.14";
+// Bun 1.3.13 had a segfault during inference on Cuttlefish at peak
+// ~2.3 GB RSS ("panic(main thread): Segmentation fault at address 0x5420").
+// 1.3.14 (released 2026-05-13) is the stable release that supersedes the
+// canary stopgap we used while waiting for it. The canary channel remains
+// the default below for AOSP/CVD builds via run-mobile-build; stock APK
+// builds use this stable pin unless explicitly overridden.
+const DEFAULT_BUN_CHANNEL = "canary";
 const ALPINE_BRANCH = "v3.21";
+const RISCV64_BUN_ARTIFACT_FILENAME = "bun-linux-riscv64-musl.zip";
+export const RUNTIME_PROVENANCE_FILENAME =
+  "android-agent-runtime-provenance.json";
 
 /**
  * Default cache dir for compile-shim.mjs's outputs. Mirrors the default
- * in `scripts/elizaos/compile-shim.mjs`. We resolve from `os.homedir()`
- * directly instead of importing `compile-shim.mjs` to avoid pulling the
- * zig probe + shell-out machinery into the staging step (this module
- * runs unconditionally on every gradle build, not just AOSP).
+ * in `packages/app-core/scripts/aosp/compile-shim.mjs`. We resolve from
+ * `os.homedir()` directly instead of importing `compile-shim.mjs` to
+ * avoid pulling the zig probe + shell-out machinery into the staging
+ * step (this module runs unconditionally on every gradle build, not
+ * just AOSP).
  */
 const SECCOMP_SHIM_CACHE_DIR = path.join(
   os.homedir(),
@@ -80,6 +91,24 @@ const ABI_TARGETS = [
     alpineArch: "aarch64",
     ldName: "ld-musl-aarch64.so.1",
   },
+  {
+    // Upstream Bun has no riscv64-linux-musl release as of this writing,
+    // so this ABI only succeeds when `ELIZA_BUN_RISCV64_FILE` or
+    // `ELIZA_BUN_RISCV64_URL` points at a self-built canary zip produced
+    // by `packages/app-core/scripts/bun-riscv64/build.sh`. Objective AOSP
+    // builds fail closed by default; local native-library iteration can
+    // opt out with ELIZA_BUN_RISCV64_OPTIONAL=1.
+    androidAbi: "riscv64",
+    bunArch: "riscv64",
+    alpineArch: "riscv64",
+    ldName: "ld-musl-riscv64.so.1",
+  },
+];
+
+const NATIVE_LLAMA_ASSET_ENV_KEYS = [
+  "ELIZA_ANDROID_AGENT_NATIVE_ASSET_DIR",
+  "ELIZA_AOSP_LLAMA_ASSET_DIR",
+  "ELIZA_MTP_ANDROID_LIBDIR",
 ];
 
 const APK_PACKAGES = [
@@ -88,9 +117,93 @@ const APK_PACKAGES = [
   { pkg: "libgcc", file: "libgcc.apk" },
 ];
 
+const LLAMA_KERNEL_DIAGNOSTIC_SCRIPT = `#!/usr/bin/env bun
+/**
+ * Model-free llama.cpp kernel capability diagnostic for ElizaOS Android.
+ *
+ * This does not load a model or claim inference throughput. It verifies that
+ * the ABI-local llama.cpp payload advertises the kernel families expected by
+ * the E1/AOSP path, and optionally checks llama-server --help for CLI surface.
+ */
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+const REQUIRED_KERNELS = ["mtp", "turbo3", "turbo4", "turbo3_tcq", "qjl_full", "polarquant"];
+const REQUIRED_HELP_NEEDLES = ["--spec-type", "mtp", "tbq3_0", "tbq4_0", "qjl1_256", "q4_polar"];
+const REQUIRED_FILES = [
+  "CAPABILITIES.json",
+  "libllama.so",
+  "libggml.so",
+  "libeliza-llama-shim.so",
+  "libeliza-llama-speculative-shim.so",
+  "llama-server",
+];
+
+function hasKernel(capabilities, name) {
+  const kernels = capabilities.kernels ?? capabilities.kernel_features ?? {};
+  if (Array.isArray(kernels)) return kernels.includes(name);
+  if (typeof kernels === "object" && kernels !== null) {
+    const value = kernels[name];
+    if (value === true) return true;
+    if (typeof value === "object" && value !== null) {
+      return value.enabled === true || value.publishable === true;
+    }
+  }
+  return capabilities[name] === true;
+}
+
+const abiDir = path.resolve(process.argv[2] ?? process.cwd());
+const staticOnly = process.argv.includes("--static-only");
+const missingFiles = REQUIRED_FILES.filter((name) => !fs.existsSync(path.join(abiDir, name)));
+const capabilitiesPath = path.join(abiDir, "CAPABILITIES.json");
+let capabilities = {};
+if (fs.existsSync(capabilitiesPath)) {
+  capabilities = JSON.parse(fs.readFileSync(capabilitiesPath, "utf8"));
+}
+const missingKernels = REQUIRED_KERNELS.filter((name) => !hasKernel(capabilities, name));
+const publishable = capabilities.publishable === true || capabilities.release_status === "publishable";
+
+let helpStatus = null;
+let missingHelpNeedles = [];
+if (!staticOnly && fs.existsSync(path.join(abiDir, "llama-server"))) {
+  const result = spawnSync(path.join(abiDir, "llama-server"), ["--help"], {
+    cwd: abiDir,
+    encoding: "utf8",
+  });
+  const text = (result.stdout ?? "") + "\\n" + (result.stderr ?? "");
+  helpStatus = result.status;
+  missingHelpNeedles = REQUIRED_HELP_NEEDLES.filter((needle) => !text.includes(needle));
+}
+
+const ok =
+  missingFiles.length === 0 &&
+  missingKernels.length === 0 &&
+  publishable &&
+  (staticOnly || (helpStatus === 0 && missingHelpNeedles.length === 0));
+
+console.log(JSON.stringify({
+  schema: "eliza.android_llama_kernel_diagnostic.v1",
+  claim_boundary: "model_free_llama_cpp_kernel_capability_check_only_not_model_inference_or_performance_evidence",
+  abi_dir: abiDir,
+  ok,
+  publishable,
+  static_only: staticOnly,
+  required_files: REQUIRED_FILES,
+  missing_files: missingFiles,
+  required_kernels: REQUIRED_KERNELS,
+  missing_kernels: missingKernels,
+  llama_server_help_status: helpStatus,
+  missing_help_needles: missingHelpNeedles,
+}, null, 2));
+process.exit(ok ? 0 : 1);
+`;
+
 function jniLoaderName(ldName) {
   if (ldName.includes("aarch64")) return "libeliza_ld_musl_aarch64.so";
   if (ldName.includes("x86_64")) return "libeliza_ld_musl_x86_64.so";
+  if (ldName.includes("riscv64")) return "libeliza_ld_musl_riscv64.so";
   return `libeliza_${ldName.replace(/[^a-zA-Z0-9]+/g, "_")}.so`;
 }
 
@@ -103,11 +216,10 @@ function jniRealLoaderName(ldName) {
 }
 
 /**
- * Adapted from scripts/spike-android-agent/launch-on-device.sh. The script
- * ships *inside* the APK and is copied (with executable bit set) into the
- * app data dir by ElizaAgentService at first launch. It accepts the device
- * path, ABI-specific musl loader, and listen port as env vars so a single
- * shell file can drive both ABIs at runtime.
+ * The script ships *inside* the APK and is copied (with executable bit set)
+ * into the app data dir by ElizaAgentService at first launch. It accepts the
+ * device path, ABI-specific musl loader, and listen port as env vars so a
+ * single shell file can drive both ABIs at runtime.
  */
 const LAUNCH_SCRIPT = `#!/system/bin/sh
 # launch.sh — device-side launcher for the on-device Eliza agent.
@@ -118,26 +230,46 @@ const LAUNCH_SCRIPT = `#!/system/bin/sh
 # it off; without that adb shell / Service.onCreate parents reap it.
 #
 # Required env vars:
-#   DEVICE_DIR  Absolute path on the device that holds bun + musl + bundle.
+#   DEVICE_DIR  Absolute path on the device that holds bun + musl.
 #   LD_NAME     Per-ABI musl loader filename (ld-musl-{x86_64,aarch64}.so.1).
 #   PORT        Loopback port for Bun.serve() to bind 127.0.0.1 on.
 #
 # Optional:
-#   AGENT_BUNDLE  Defaults to "agent-bundle.js" in DEVICE_DIR.
-#   LOG_FILE      Defaults to "agent.log" in DEVICE_DIR.
+#   AGENT_ROOT         Directory that holds agent-bundle.js; defaults DEVICE_DIR.
+#   RUNTIME_DIR        Directory that holds bun + runtime libs; defaults DEVICE_DIR.
+#   BUN_PATH           Absolute bun executable path; defaults RUNTIME_DIR/bun.
+#   LD_PATH            Absolute musl-loader path; defaults RUNTIME_DIR/LD_NAME.
+#   AGENT_BUNDLE       Bundle filename; defaults agent-bundle.js.
+#   AGENT_BUNDLE_PATH  Absolute bundle path; defaults AGENT_ROOT/AGENT_BUNDLE.
+#   AGENT_COMMAND      Optional agent CLI command, e.g. android-bridge.
+#   LOG_FILE           Defaults to agent.log in AGENT_ROOT.
 
 DEVICE_DIR=\${DEVICE_DIR:-/data/local/tmp}
+RUNTIME_DIR=\${RUNTIME_DIR:-\${DEVICE_DIR}}
+AGENT_ROOT=\${AGENT_ROOT:-\${DEVICE_DIR}}
 LD_NAME=\${LD_NAME:-ld-musl-x86_64.so.1}
 PORT=\${PORT:-31337}
 AGENT_BUNDLE=\${AGENT_BUNDLE:-agent-bundle.js}
-LOG_FILE=\${LOG_FILE:-\${DEVICE_DIR}/agent.log}
+BUN_PATH=\${BUN_PATH:-\${RUNTIME_DIR}/bun}
+LD_PATH=\${LD_PATH:-\${RUNTIME_DIR}/\${LD_NAME}}
+AGENT_BUNDLE_PATH=\${AGENT_BUNDLE_PATH:-\${AGENT_ROOT}/\${AGENT_BUNDLE}}
+AGENT_COMMAND=\${AGENT_COMMAND:-}
+LOG_FILE=\${LOG_FILE:-\${AGENT_ROOT}/agent.log}
+RUNTIME_LD_LIBRARY_PATH=\${LD_LIBRARY_PATH:-\${RUNTIME_DIR}}
 
-cd "$DEVICE_DIR" || exit 1
-pkill -f "\${DEVICE_DIR}/bun" 2>/dev/null
+cd "$AGENT_ROOT" || exit 1
+pkill -f "\${BUN_PATH}" 2>/dev/null
+pkill -f "\${AGENT_BUNDLE_PATH}" 2>/dev/null
 sleep 1
 
+if [ -n "\${AGENT_COMMAND}" ]; then
+  set -- "\${LD_PATH}" "\${BUN_PATH}" "\${AGENT_BUNDLE_PATH}" "\${AGENT_COMMAND}"
+else
+  set -- "\${LD_PATH}" "\${BUN_PATH}" "\${AGENT_BUNDLE_PATH}"
+fi
+
 (
-  setsid sh -c "exec </dev/null >\\"$LOG_FILE\\" 2>&1; LD_LIBRARY_PATH=\\"$DEVICE_DIR\\" PORT=\\"$PORT\\" exec \\"$DEVICE_DIR/$LD_NAME\\" \\"$DEVICE_DIR/bun\\" \\"$DEVICE_DIR/$AGENT_BUNDLE\\"" &
+  setsid sh -c 'log_file=$1; agent_root=$2; runtime_ld=$3; port=$4; shift 4; exec </dev/null >"$log_file" 2>&1; cd "$agent_root" || exit 1; LD_LIBRARY_PATH="$runtime_ld" PORT="$port" exec "$@"' sh "\${LOG_FILE}" "\${AGENT_ROOT}" "\${RUNTIME_LD_LIBRARY_PATH}" "\${PORT}" "$@" &
 ) &
 disown 2>/dev/null || true
 exit 0
@@ -182,33 +314,273 @@ async function downloadFile(url, targetPath) {
   fs.writeFileSync(targetPath, buf);
 }
 
-async function ensureBunBinary({ cacheDir, bunArch, log }) {
-  const channelTag =
-    BUN_CHANNEL === "canary" ? "canary" : `bun-${BUN_VERSION}`;
-  const cacheKey = BUN_CHANNEL === "canary" ? "canary" : BUN_VERSION;
+function normalizeSha256(value, envName) {
+  const sha256 = value?.trim().toLowerCase();
+  if (!sha256) return null;
+  if (!/^[a-f0-9]{64}$/.test(sha256)) {
+    throw new Error(
+      `${envName} must be a lowercase or uppercase 64-character SHA-256 hex digest.`,
+    );
+  }
+  return sha256;
+}
+
+function firstEnvValue(names) {
+  for (const name of names) {
+    const value = process.env[name]?.trim();
+    if (value) return { name, value };
+  }
+  return null;
+}
+
+function riscv64BunSha256() {
+  const configured = firstEnvValue(["ELIZA_BUN_RISCV64_SHA256"]);
+  return normalizeSha256(
+    configured?.value,
+    configured?.name ?? "ELIZA_BUN_RISCV64_SHA256",
+  );
+}
+
+function defaultRiscv64BunArtifactPath() {
+  return path.resolve(
+    __dirname,
+    "..",
+    "bun-riscv64",
+    "dist",
+    RISCV64_BUN_ARTIFACT_FILENAME,
+  );
+}
+
+function riscv64BunFilePath() {
+  const configured = firstEnvValue(["ELIZA_BUN_RISCV64_FILE"]);
+  if (configured) return path.resolve(configured.value);
+  const defaultPath = defaultRiscv64BunArtifactPath();
+  return fs.existsSync(defaultPath) ? defaultPath : null;
+}
+
+function riscv64BunUrl() {
+  return firstEnvValue(["ELIZA_BUN_RISCV64_URL"])?.value ?? null;
+}
+
+function riscv64BunArtifactSource() {
+  const filePath = riscv64BunFilePath();
+  if (filePath) return { kind: "file", ...provenancePath(filePath) };
+  const url = riscv64BunUrl();
+  if (url) return { kind: "url", url };
+  return null;
+}
+
+function sha256File(filePath) {
+  const hash = crypto.createHash("sha256");
+  hash.update(fs.readFileSync(filePath));
+  return hash.digest("hex");
+}
+
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+
+function pathWithin(root, filePath) {
+  const relative = path.relative(root, filePath);
+  return relative && !relative.startsWith("..") && !path.isAbsolute(relative)
+    ? toPosixPath(relative)
+    : null;
+}
+
+function provenancePath(filePath) {
+  const absolute = path.resolve(filePath);
+  const repoRelative = pathWithin(ELIZA_REPO_ROOT, absolute);
+  if (repoRelative) {
+    return {
+      path: repoRelative,
+      path_provenance: "relative_to_git_checkout",
+    };
+  }
+  const appCoreRelative = pathWithin(APP_CORE_ROOT, absolute);
+  if (appCoreRelative) {
+    return {
+      path: appCoreRelative,
+      path_provenance: "relative_to_app_core",
+    };
+  }
+  return {
+    path: path.basename(absolute),
+    path_provenance: "external_artifact_basename",
+  };
+}
+
+function normalizeSourceForProvenance(value) {
+  if (Array.isArray(value)) return value.map(normalizeSourceForProvenance);
+  if (!value || typeof value !== "object") return value;
+  const normalized = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (
+      typeof child === "string" &&
+      path.isAbsolute(child) &&
+      (key === "path" || key.endsWith("_path"))
+    ) {
+      Object.assign(normalized, provenancePath(child));
+    } else if (
+      typeof child === "string" &&
+      path.isAbsolute(child) &&
+      (key === "cache_dir" || key.endsWith("_dir"))
+    ) {
+      normalized[key] = path.basename(child);
+      normalized[`${key}_provenance`] = "external_cache_dir_basename";
+    } else {
+      normalized[key] = normalizeSourceForProvenance(child);
+    }
+  }
+  return normalized;
+}
+
+function readJsonIfExists(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function fileProvenanceEntry({ filePath, relativePath, source }) {
+  const stat = fs.statSync(filePath);
+  return {
+    path: androidApkEntryPath(relativePath),
+    size_bytes: stat.size,
+    sha256: sha256File(filePath),
+    source: normalizeSourceForProvenance(source),
+  };
+}
+
+function androidApkEntryPath(relativePath) {
+  const entryPath = toPosixPath(relativePath);
+  return entryPath.replace(/^jniLibs\//, "lib/");
+}
+
+function normalizeBunChannel(value) {
+  const channel = String(value ?? DEFAULT_BUN_CHANNEL)
+    .trim()
+    .toLowerCase();
+  if (channel === "stable" || channel === "release") return "stable";
+  if (channel === "canary") return "canary";
+  throw new Error(
+    `Unsupported ELIZA_BUN_CHANNEL=${JSON.stringify(value)}. ` +
+      "Expected stable or canary.",
+  );
+}
+
+function resolveBunChannel(preferredChannel) {
+  return normalizeBunChannel(
+    process.env.ELIZA_BUN_CHANNEL ?? preferredChannel ?? DEFAULT_BUN_CHANNEL,
+  );
+}
+
+function bunCacheKey(channel) {
+  return channel === "canary" ? "canary" : BUN_VERSION;
+}
+
+function bunChannelLabel(channel) {
+  return channel === "canary" ? "bun-canary" : `bun-${BUN_VERSION}`;
+}
+
+function defaultBunCacheDir(channel) {
+  return path.join(
+    os.homedir(),
+    ".cache",
+    "eliza-android-agent",
+    `bun-${bunCacheKey(channel)}`,
+  );
+}
+
+async function ensureBunBinary({ cacheDir, bunArch, bunChannel, log }) {
+  const channelTag = bunChannel === "canary" ? "canary" : `bun-v${BUN_VERSION}`;
+  const cacheKey = bunCacheKey(bunChannel);
   const archCache = path.join(cacheDir, `bun-${bunArch}-${cacheKey}`);
   const bunPath = path.join(archCache, "bun");
+  const sourceSha256Path = path.join(archCache, ".source.sha256");
+  const expectedRiscv64Sha256 =
+    bunArch === "riscv64" ? riscv64BunSha256() : null;
   // Canary cache invalidates after 24h so we pull bug-fix snapshots
   // automatically without forcing every CI run to re-download.
   const isFresh = (() => {
     if (!fs.existsSync(bunPath)) return false;
     const st = fs.statSync(bunPath);
     if (st.size <= 1_000_000) return false;
-    if (BUN_CHANNEL !== "canary") return true;
+    if (bunArch === "riscv64") {
+      if (!expectedRiscv64Sha256) return false;
+      if (!fs.existsSync(sourceSha256Path)) return false;
+      const cachedSha256 = fs
+        .readFileSync(sourceSha256Path, "utf8")
+        .trim()
+        .toLowerCase();
+      if (cachedSha256 !== expectedRiscv64Sha256) return false;
+    }
+    if (bunChannel !== "canary") return true;
     const ageMs = Date.now() - st.mtimeMs;
     return ageMs < 24 * 60 * 60 * 1000;
   })();
-  if (isFresh) return bunPath;
+  if (isFresh) {
+    return {
+      bunPath,
+      source: {
+        kind: "cache",
+        cache_key: path.basename(archCache),
+        artifact_sha256: expectedRiscv64Sha256,
+      },
+    };
+  }
   fs.mkdirSync(archCache, { recursive: true });
   const zipPath = path.join(archCache, "bun.zip");
-  const url =
-    BUN_CHANNEL === "canary"
-      ? `https://github.com/oven-sh/bun/releases/download/canary/bun-linux-${bunArch}-musl.zip`
-      : `https://github.com/oven-sh/bun/releases/download/${channelTag}/bun-linux-${bunArch}-musl.zip`;
-  const channelLabel =
-    BUN_CHANNEL === "canary" ? "bun-canary" : `bun-${BUN_VERSION}`;
-  log(`Downloading ${channelLabel} (${bunArch}-musl) from ${url}`);
-  await downloadFile(url, zipPath);
+  // riscv64 has no upstream Bun release. Allow operators to point at a
+  // self-built canary artifact via a local file or URL; otherwise refuse to
+  // download from a guessed URL and surface a clear pointer at the cross-build
+  // pipeline. We never invent a default URL.
+  let url;
+  let sourceFile;
+  if (bunArch === "riscv64") {
+    sourceFile = riscv64BunFilePath();
+    url = riscv64BunUrl();
+    if (!sourceFile && !url) {
+      throw new Error(
+        "Bun riscv64 artifact not available: upstream Bun has no riscv64-linux-musl release. " +
+          "Set ELIZA_BUN_RISCV64_FILE to a local " +
+          "self-built zip, or set ELIZA_BUN_RISCV64_URL " +
+          "to a hosted zip produced by packages/app-core/scripts/bun-riscv64/build.sh, " +
+          "or set ELIZA_BUN_RISCV64_OPTIONAL=1 for local non-objective builds.",
+      );
+    }
+    if (!expectedRiscv64Sha256) {
+      throw new Error(
+        "Bun riscv64 artifact hash is required: set ELIZA_BUN_RISCV64_SHA256 " +
+          "to the SHA-256 of bun-linux-riscv64-musl.zip.",
+      );
+    }
+  } else {
+    url =
+      bunChannel === "canary"
+        ? `https://github.com/oven-sh/bun/releases/download/canary/bun-linux-${bunArch}-musl.zip`
+        : `https://github.com/oven-sh/bun/releases/download/${channelTag}/bun-linux-${bunArch}-musl.zip`;
+  }
+  const channelLabel = bunChannelLabel(bunChannel);
+  if (sourceFile) {
+    if (!fs.existsSync(sourceFile)) {
+      throw new Error(`Bun riscv64 artifact file not found: ${sourceFile}`);
+    }
+    log(
+      `Using local ${channelLabel} (${bunArch}-musl) artifact at ${sourceFile}`,
+    );
+    fs.copyFileSync(sourceFile, zipPath);
+  } else {
+    log(`Downloading ${channelLabel} (${bunArch}-musl) from ${url}`);
+    await downloadFile(url, zipPath);
+  }
+  if (expectedRiscv64Sha256) {
+    const actualSha256 = sha256File(zipPath);
+    if (actualSha256 !== expectedRiscv64Sha256) {
+      fs.rmSync(zipPath, { force: true });
+      throw new Error(
+        `bun-linux-riscv64-musl.zip SHA-256 mismatch: expected ` +
+          `${expectedRiscv64Sha256}, got ${actualSha256}`,
+      );
+    }
+  }
   await run("unzip", ["-q", "-o", zipPath, "-d", archCache]);
   const extractedDir = path.join(archCache, `bun-linux-${bunArch}-musl`);
   const extractedBun = path.join(extractedDir, "bun");
@@ -220,7 +592,22 @@ async function ensureBunBinary({ cacheDir, bunArch, log }) {
   fs.rmSync(extractedDir, { recursive: true, force: true });
   fs.rmSync(zipPath, { force: true });
   fs.chmodSync(bunPath, 0o755);
-  return bunPath;
+  if (expectedRiscv64Sha256) {
+    fs.writeFileSync(sourceSha256Path, `${expectedRiscv64Sha256}\n`, "utf8");
+  }
+  return {
+    bunPath,
+    source: {
+      kind: sourceFile ? "file" : "url",
+      ...(sourceFile ? provenancePath(sourceFile) : {}),
+      url: sourceFile ? null : url,
+      artifact_filename:
+        bunArch === "riscv64"
+          ? RISCV64_BUN_ARTIFACT_FILENAME
+          : path.basename(url),
+      artifact_sha256: expectedRiscv64Sha256,
+    },
+  };
 }
 
 /**
@@ -304,12 +691,124 @@ function copyIfDifferent(source, target) {
   if (fs.existsSync(target)) {
     const a = fs.statSync(source);
     const b = fs.statSync(target);
-    if (a.size === b.size && a.mtimeMs <= b.mtimeMs) return false;
+    if (a.size === b.size) {
+      const sameBytes = fs.readFileSync(source).equals(fs.readFileSync(target));
+      if (sameBytes) return false;
+    }
   }
   fs.copyFileSync(source, target);
   return true;
 }
 
+function resolveNativeLlamaAssetDir(androidAbi) {
+  // Look up an env-var-supplied prebuilt native llama asset dir for this
+  // ABI. Each env var may be either:
+  //   - a single absolute dir (legacy arm64-only contract — the prebuilt
+  //     lives directly inside; only honoured when androidAbi is arm64-v8a),
+  //   - a per-ABI suffixed variant `<KEY>_<ABI>` where ABI is the upper-
+  //     snake-cased androidAbi (e.g. ELIZA_AOSP_LLAMA_ASSET_DIR_ARM64_V8A,
+  //     _X86_64, _RISCV64),
+  //   - or a base dir that contains per-ABI subdirectories named after the
+  //     androidAbi (e.g. `<dir>/arm64-v8a/`, `<dir>/x86_64/`, `<dir>/riscv64/`).
+  // The first env key that resolves to a real dir for this ABI wins. We
+  // never fall back across ABIs (an arm64 prebuilt is not valid for x86_64
+  // or riscv64).
+  const abiSuffix = androidAbi.replace(/-/g, "_").toUpperCase();
+  for (const key of NATIVE_LLAMA_ASSET_ENV_KEYS) {
+    // 1. Per-ABI env var wins outright.
+    const perAbiRaw = process.env[`${key}_${abiSuffix}`]?.trim();
+    if (perAbiRaw) {
+      const resolved = path.resolve(perAbiRaw);
+      if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+        return { dir: resolved, key: `${key}_${abiSuffix}` };
+      }
+    }
+    const raw = process.env[key]?.trim();
+    if (!raw) continue;
+    const baseResolved = path.resolve(raw);
+    if (!fs.existsSync(baseResolved)) continue;
+    if (!fs.statSync(baseResolved).isDirectory()) continue;
+    // 2. Base dir containing per-ABI subdirs.
+    const perAbiSubdir = path.join(baseResolved, androidAbi);
+    if (
+      fs.existsSync(perAbiSubdir) &&
+      fs.statSync(perAbiSubdir).isDirectory()
+    ) {
+      return { dir: perAbiSubdir, key: `${key}/${androidAbi}` };
+    }
+    // 3. Legacy: the env var points directly at the prebuilt dir; honour
+    //    it only for arm64-v8a since that's the only ABI the legacy
+    //    contract ever shipped a prebuilt for.
+    if (androidAbi === "arm64-v8a") {
+      return { dir: baseResolved, key };
+    }
+  }
+  return null;
+}
+
+function shouldStageNativeLlamaAsset(name) {
+  return (
+    /^lib(?:llama|llama-common|ggml|mtmd|eliza-llama|elizainference).*(?:\.so|\.so\.\d.*)$/.test(
+      name,
+    ) ||
+    /^libomnivoice(?:\.so|\.so\.\d.*)$/.test(name) ||
+    name === "llama-server" ||
+    name === "llama-omnivoice-server" ||
+    name === "CAPABILITIES.json" ||
+    name === "OMNIVOICE_FUSE_VERIFY.json"
+  );
+}
+
+function stageNativeLlamaAssetsForAbi({ androidAbi, abiAssetsDir, log }) {
+  const source = resolveNativeLlamaAssetDir(androidAbi);
+  if (!source) return 0;
+
+  let changes = 0;
+  let copied = 0;
+  for (const entry of fs.readdirSync(source.dir, { withFileTypes: true })) {
+    if (!entry.isFile() || !shouldStageNativeLlamaAsset(entry.name)) continue;
+    const src = path.join(source.dir, entry.name);
+    const dst = path.join(abiAssetsDir, entry.name);
+    if (copyIfDifferent(src, dst)) changes += 1;
+    if (
+      entry.name === "llama-server" ||
+      entry.name === "llama-omnivoice-server"
+    ) {
+      fs.chmodSync(dst, fs.statSync(dst).mode | 0o755);
+    }
+    copied += 1;
+  }
+
+  // The fused libelizainference.so is the activation lib (ElizaAgentService
+  // gates ELIZA_LOCAL_LLAMA on it). As of the static-fuse build recipe
+  // (BUILD_SHARED_LIBS=OFF + CMAKE_POSITION_INDEPENDENT_CODE=ON in
+  // build-helpers/omnivoice-merged.mjs fusedExtraCmakeFlags + the bionic JNI
+  // builder) it is SELF-CONTAINED: llama/ggml/mtmd are folded in as static
+  // archives, so its only DT_NEEDED entries are libc/libm/libdl — there is no
+  // runtime libllama.so / libggml*.so sibling to resolve via LD_LIBRARY_PATH.
+  // So only libelizainference.so is required. A non-fused bulk build may still
+  // emit libllama.so + the libggml* family as a byproduct; if present they
+  // stage harmlessly via shouldStageNativeLlamaAsset() above, but they are no
+  // longer a hard requirement for the fused activation path. The
+  // eliza-llama-shim was retired with the libllama TS adapter.
+  const required = ["libelizainference.so"];
+  const missing = required.filter(
+    (name) => !fs.existsSync(path.join(abiAssetsDir, name)),
+  );
+  if (missing.length > 0) {
+    log(
+      `Native llama asset dir from ${source.key} did not provide ${missing.join(", ")}; ` +
+        `ELIZA_LOCAL_LLAMA will remain disabled for ${androidAbi}.`,
+    );
+  } else {
+    log(
+      `Staged ${copied} native llama asset file(s) for ${androidAbi} from ${source.key}` +
+        (changes > 0 ? ` (${changes} updated)` : " (already current)"),
+    );
+  }
+  return changes;
+}
+
 function writeIfChanged(target, content) {
   if (fs.existsSync(target)) {
     const current = fs.readFileSync(target, "utf8");
@@ -331,8 +830,8 @@ function writeIfChanged(target, content) {
  *   - Drop `libsigsys-handler.so` next to it.
  *
  * Returns the number of files changed this call (0 when nothing
- * happened). When no compiled shim exists for the ABI we no-op and
- * return 0 — the Capacitor APK build path keeps the legacy loader.
+ * happened). When no compiled shim exists for the ABI this returns 0 and
+ * the Capacitor APK build path keeps the legacy loader.
  *
  * Exported for testing.
  */
@@ -343,17 +842,14 @@ export function stageSeccompShimForAbi({
   cacheDir = SECCOMP_SHIM_CACHE_DIR,
   log,
 }) {
-  // ARM64 short-circuits: compile-shim never builds for that ABI.
-  if (androidAbi !== "x86_64") return 0;
-
   const abiCacheDir = path.join(cacheDir, androidAbi);
   const cachedWrap = path.join(abiCacheDir, ldName);
   const cachedShim = path.join(abiCacheDir, "libsigsys-handler.so");
   if (!fs.existsSync(cachedWrap) || !fs.existsSync(cachedShim)) {
     log?.(
       `No compiled SIGSYS shim for ${androidAbi}; leaving the Alpine ` +
-        `loader at ${ldName} (run \`node scripts/elizaos/compile-shim.mjs\` for ` +
-        `the AOSP path).`,
+        `loader at ${ldName} (run \`node packages/app-core/scripts/aosp/compile-shim.mjs\` ` +
+        `for the AOSP path).`,
     );
     return 0;
   }
@@ -416,23 +912,20 @@ export function stageSeccompShimForAbi({
  *
  * Required:
  *   androidDir  Absolute path to packages/app/android/.
- *   spikeDir    Absolute path to scripts/spike-android-agent/ (source of
- *               the placeholder agent-bundle.js until Phase D wires up the
- *               real @elizaos/agent bundle).
+ *   spikeDir    Absolute path to the Android-agent script directory. Kept
+ *               for legacy workspace-root resolution; it is not used as a
+ *               bundle fallback.
  *
  * Optional:
  *   cacheDir    Defaults to ~/.cache/eliza-android-agent/<bun-version>/.
+ *   bunChannel  stable | canary. ELIZA_BUN_CHANNEL overrides this option.
  *   log         Defaults to console.log.
  */
 export async function stageAndroidAgentRuntime({
   androidDir,
   spikeDir,
-  cacheDir = path.join(
-    os.homedir(),
-    ".cache",
-    "eliza-android-agent",
-    `bun-${BUN_CHANNEL === "canary" ? "canary" : BUN_VERSION}`,
-  ),
+  cacheDir,
+  bunChannel: preferredBunChannel,
   log = console.log,
 } = {}) {
   if (!androidDir)
@@ -441,7 +934,10 @@ export async function stageAndroidAgentRuntime({
     throw new Error("stageAndroidAgentRuntime: spikeDir is required");
 
   const tlog = logFor(log);
-  fs.mkdirSync(cacheDir, { recursive: true });
+  const bunChannel = resolveBunChannel(preferredBunChannel);
+  const resolvedCacheDir = cacheDir ?? defaultBunCacheDir(bunChannel);
+  tlog(`Staging Android agent runtime with ${bunChannelLabel(bunChannel)}.`);
+  fs.mkdirSync(resolvedCacheDir, { recursive: true });
 
   // Runtime files ship under `assets/agent/{abi}/` for AOSP builds that can
   // execute from priv-app data, and under `jniLibs/{abi}/libeliza_*.so` for
@@ -461,17 +957,49 @@ export async function stageAndroidAgentRuntime({
   fs.mkdirSync(jniLibsDir, { recursive: true });
 
   let stagedCount = 0;
+  const stagedFiles = [];
+  const riscv64Artifact = {
+    required: true,
+    filename: RISCV64_BUN_ARTIFACT_FILENAME,
+    sha256: riscv64BunSha256(),
+    source: riscv64BunArtifactSource(),
+  };
 
   for (const target of ABI_TARGETS) {
     const { androidAbi, bunArch, alpineArch, ldName } = target;
+    // Objective builds fail closed on riscv64. Upstream Bun has no
+    // riscv64-linux-musl release, so provide ELIZA_BUN_RISCV64_FILE or
+    // ELIZA_BUN_RISCV64_URL from packages/app-core/scripts/bun-riscv64/build.sh.
+    // Local native-library iteration may opt out with
+    // ELIZA_BUN_RISCV64_OPTIONAL=1, but that build is not valid AOSP/chip
+    // objective evidence.
+    if (bunArch === "riscv64") {
+      const riscvFile = riscv64BunFilePath();
+      const riscvUrl = riscv64BunUrl();
+      const optional = process.env.ELIZA_BUN_RISCV64_OPTIONAL === "1";
+      if (!riscvFile && !riscvUrl && optional) {
+        tlog(
+          `Skipping optional ABI ${androidAbi}: no ELIZA_BUN_RISCV64_FILE or URL is set ` +
+            `(upstream Bun has no riscv64-linux-musl release). Build with ` +
+            `packages/app-core/scripts/bun-riscv64/build.sh and re-run for AOSP/chip evidence.`,
+        );
+        continue;
+      }
+    }
     const abiAssetsDir = path.join(assetsAgentDir, androidAbi);
     const abiJniDir = path.join(jniLibsDir, androidAbi);
     fs.mkdirSync(abiAssetsDir, { recursive: true });
     fs.mkdirSync(abiJniDir, { recursive: true });
 
-    const bunPath = await ensureBunBinary({ cacheDir, bunArch, log: tlog });
+    const bun = await ensureBunBinary({
+      cacheDir: resolvedCacheDir,
+      bunArch,
+      bunChannel,
+      log: tlog,
+    });
+    const bunPath = bun.bunPath;
     const extractDir = await ensureAlpineApkExtracted({
-      cacheDir,
+      cacheDir: resolvedCacheDir,
       alpineArch,
       log: tlog,
     });
@@ -496,11 +1024,17 @@ export async function stageAndroidAgentRuntime({
       if (copyIfDifferent(src, dst)) abiChanges += 1;
     }
 
+    abiChanges += stageNativeLlamaAssetsForAbi({
+      androidAbi,
+      abiAssetsDir,
+      log: tlog,
+    });
+
     // llama-server is produced by compile-libllama.mjs (per-ABI). It already
     // lands at <abiAssetsDir>/llama-server when that script ran successfully,
     // so we don't re-copy here — but we do ensure the bit is +x because some
     // file-copy paths (e.g. zip → unzip on Windows builders) lose the
-    // executable bit. The aosp-llama-adapter spawns it for DFlash decode;
+    // executable bit. The aosp-llama-adapter spawns it for MTP decode;
     // without +x exec fails with EACCES at runtime.
     const llamaServerStaged = path.join(abiAssetsDir, "llama-server");
     if (fs.existsSync(llamaServerStaged)) {
@@ -512,16 +1046,16 @@ export async function stageAndroidAgentRuntime({
       }
     } else {
       tlog(
-        `No llama-server staged for ${androidAbi}; DFlash spec-decode on AOSP ` +
+        `No llama-server staged for ${androidAbi}; MTP spec-decode on AOSP ` +
           `will fall back to single-model decode. Run \`node ` +
           `packages/app-core/scripts/aosp/compile-libllama.mjs\` to build it.`,
       );
     }
 
-    // Per-ABI seccomp shim install. Only x86_64 has compiled shim
-    // artifacts (arm64's kernel ABI omits the legacy syscalls Android's
-    // x86_64 seccomp filter traps on, so the shim is irrelevant). When
-    // the artifacts exist:
+    // Per-ABI seccomp shim install. Both x86_64 (legacy non-AT syscalls)
+    // and arm64-v8a (the new-syscall case — bun's `epoll_pwait2` blocked
+    // by Android's `untrusted_app` filter) have compiled shim artifacts.
+    // When the artifacts exist:
     //   1. Stage `libsigsys-handler.so` next to bun.
     //   2. Rename the Alpine-extracted ld-musl-*.so.1 → .so.1.real.
     //   3. Stage our `loader-wrap` ELF as ld-musl-*.so.1.
@@ -531,8 +1065,8 @@ export async function stageAndroidAgentRuntime({
     //
     // Idempotent: if the wrapper is already in place we just refresh
     // the .real loader and the shim file (handled by copyIfDifferent's
-    // size+mtime check). If shim artifacts are missing we leave the
-    // legacy loader in place so the Capacitor APK build still works.
+    // size+mtime check). If shim artifacts are missing we leave the packaged
+    // musl loader in place so the Capacitor APK build still works.
     const shimChanges = stageSeccompShimForAbi({
       androidAbi,
       ldName,
@@ -583,6 +1117,27 @@ export async function stageAndroidAgentRuntime({
       if (copyIfDifferent(src, dst)) abiChanges += 1;
     }
 
+    const stagedSource = {
+      bun: bun.source,
+      alpine: {
+        branch: ALPINE_BRANCH,
+        arch: alpineArch,
+        packages: APK_PACKAGES.map(({ pkg }) => pkg),
+      },
+    };
+    for (const [, dst] of [...sources, ...jniSources]) {
+      stagedFiles.push(
+        fileProvenanceEntry({
+          filePath: dst,
+          relativePath: path.relative(
+            path.join(androidDir, "app", "src", "main"),
+            dst,
+          ),
+          source: stagedSource,
+        }),
+      );
+    }
+
     stagedCount += abiChanges;
     tlog(
       `Staged ${sources.length} runtime file(s) for ABI ${androidAbi}` +
@@ -590,9 +1145,8 @@ export async function stageAndroidAgentRuntime({
     );
   }
 
-  // ABI-independent assets: agent-bundle.js + PGlite payload, falling back
-  // to the spike's tiny stub if Phase D hasn't been built yet. Phase D
-  // produces a 33 MB real bundle in packages/agent/dist-mobile/ via
+  // ABI-independent assets: agent-bundle.js + PGlite payload. The real
+  // bundle is produced in packages/agent/dist-mobile/ via
   // `bun run --cwd packages/agent build:mobile`. PGlite at runtime
   // resolves vector.tar.gz and fuzzystrmatch.tar.gz with `new URL("../X",
   // import.meta.url)`, so those two files must land ONE DIR ABOVE the
@@ -645,30 +1199,34 @@ export async function stageAndroidAgentRuntime({
     distMobileDir = elizaPackagesAgentDistMobile;
     distBundle = path.join(distMobileDir, "agent-bundle.js");
   }
-  const spikeServerJs = path.join(spikeDir, "server.js");
-
-  let bundleSrc;
-  if (fs.existsSync(distBundle)) {
-    bundleSrc = distBundle;
-    tlog(
-      `Using Phase D agent bundle (${(fs.statSync(distBundle).size / (1024 * 1024)).toFixed(1)} MB)`,
-    );
-  } else if (fs.existsSync(spikeServerJs)) {
-    bundleSrc = spikeServerJs;
-    tlog(
-      "Using spike placeholder agent-bundle.js — run `bun run --cwd " +
-        "packages/agent build:mobile` to ship the real agent.",
-    );
-  } else {
+  if (!fs.existsSync(distBundle)) {
     throw new Error(
-      `No agent bundle source found. Tried: ${distBundle}, ${spikeServerJs}.`,
+      `No mobile agent bundle found at ${distBundle}. Run ` +
+        "`bun run --cwd packages/agent build:mobile` before staging Android assets.",
     );
   }
+  const bundleSrc = distBundle;
+  tlog(
+    `Using mobile agent bundle (${(fs.statSync(distBundle).size / (1024 * 1024)).toFixed(1)} MB)`,
+  );
   const bundleTarget = path.join(assetsAgentDir, "agent-bundle.js");
   if (copyIfDifferent(bundleSrc, bundleTarget)) stagedCount += 1;
+  stagedFiles.push(
+    fileProvenanceEntry({
+      filePath: bundleTarget,
+      relativePath: path.relative(
+        path.join(androidDir, "app", "src", "main"),
+        bundleTarget,
+      ),
+      source: {
+        kind: "mobile-agent-bundle",
+        path: bundleSrc,
+      },
+    }),
+  );
 
-  // PGlite runtime artifacts. Only present when Phase D's build has run.
-  // Skip silently when missing so the spike-bundle path still works.
+  // PGlite runtime artifacts. They are optional because minimal mobile bundles
+  // can run without embedded database extensions.
   const pgliteAssets = [
     "pglite.wasm",
     "initdb.wasm",
@@ -682,17 +1240,100 @@ export async function stageAndroidAgentRuntime({
     if (!fs.existsSync(src)) continue;
     const dst = path.join(assetsAgentDir, name);
     if (copyIfDifferent(src, dst)) stagedCount += 1;
+    stagedFiles.push(
+      fileProvenanceEntry({
+        filePath: dst,
+        relativePath: path.relative(
+          path.join(androidDir, "app", "src", "main"),
+          dst,
+        ),
+        source: {
+          kind: "mobile-agent-bundle",
+          path: src,
+        },
+      }),
+    );
   }
 
   const launchTarget = path.join(assetsAgentDir, "launch.sh");
   if (writeIfChanged(launchTarget, LAUNCH_SCRIPT)) stagedCount += 1;
+  stagedFiles.push(
+    fileProvenanceEntry({
+      filePath: launchTarget,
+      relativePath: path.relative(
+        path.join(androidDir, "app", "src", "main"),
+        launchTarget,
+      ),
+      source: { kind: "stage-android-agent", constant: "LAUNCH_SCRIPT" },
+    }),
+  );
+  const llamaDiagnosticTarget = path.join(
+    assetsAgentDir,
+    "llama-kernel-diagnostic.mjs",
+  );
+  if (writeIfChanged(llamaDiagnosticTarget, LLAMA_KERNEL_DIAGNOSTIC_SCRIPT)) {
+    stagedCount += 1;
+  }
+  stagedFiles.push(
+    fileProvenanceEntry({
+      filePath: llamaDiagnosticTarget,
+      relativePath: path.relative(
+        path.join(androidDir, "app", "src", "main"),
+        llamaDiagnosticTarget,
+      ),
+      source: {
+        kind: "stage-android-agent",
+        constant: "LLAMA_KERNEL_DIAGNOSTIC_SCRIPT",
+      },
+    }),
+  );
+
+  const bunRiscv64VersionPath = path.resolve(
+    __dirname,
+    "..",
+    "bun-riscv64",
+    "bun-version.json",
+  );
+  const runtimeProvenanceTarget = path.join(
+    assetsAgentDir,
+    RUNTIME_PROVENANCE_FILENAME,
+  );
+  const runtimeProvenance = {
+    schema: "eliza.android_agent_runtime_provenance.v1",
+    generated_by: "packages/app-core/scripts/lib/stage-android-agent.mjs",
+    claim_boundary:
+      "apk_staged_runtime_file_hashes_only_not_android_boot_or_runtime_execution_evidence",
+    bun: {
+      version: BUN_VERSION,
+      channel: bunChannel,
+      cache_key: bunCacheKey(bunChannel),
+    },
+    alpine: {
+      branch: ALPINE_BRANCH,
+    },
+    riscv64_bun_artifact: riscv64Artifact,
+    riscv64_bun_build_contract: readJsonIfExists(bunRiscv64VersionPath),
+    files: stagedFiles.sort((a, b) => a.path.localeCompare(b.path)),
+  };
+  if (
+    writeIfChanged(
+      runtimeProvenanceTarget,
+      `${JSON.stringify(runtimeProvenance, null, 2)}\n`,
+    )
+  ) {
+    stagedCount += 1;
+  }
 
   tlog(
     `Staged on-device agent runtime in ${path.relative(androidDir, assetsAgentDir)} ` +
       `(${stagedCount} file change${stagedCount === 1 ? "" : "s"} this run).`,
   );
 
-  return { assetsAgentDir, stagedCount };
+  return {
+    assetsAgentDir,
+    stagedCount,
+    runtimeProvenancePath: runtimeProvenanceTarget,
+  };
 }
 
 export const __testables = {
@@ -701,4 +1342,12 @@ export const __testables = {
   ABI_TARGETS,
   APK_PACKAGES,
   LAUNCH_SCRIPT,
+  LLAMA_KERNEL_DIAGNOSTIC_SCRIPT,
+  RISCV64_BUN_ARTIFACT_FILENAME,
+  RUNTIME_PROVENANCE_FILENAME,
+  defaultRiscv64BunArtifactPath,
+  riscv64BunFilePath,
+  riscv64BunArtifactSource,
+  riscv64BunSha256,
+  provenancePath,
 };