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

package/scripts/aosp/compile-shim.mjs

@@ -20,15 +20,26 @@
 //   See seccomp-shim/sigsys-handler.c for the full coverage matrix
 //   (24 syscalls, all x86_64) and the production-landing checklist.
 //
-// What this script produces (per ABI, x86_64 only):
+// What this script produces (per ABI):
 //   <abiCacheDir>/libsigsys-handler.so   — LD_PRELOAD'd by loader-wrap
-//   <abiCacheDir>/loader-wrap            — drop-in for ld-musl-x86_64.so.1
+//   <abiCacheDir>/<ld-musl-...so.1>      — drop-in for the real musl loader
 //
-// ARM64 is intentionally skipped — its kernel ABI provides only the
-// AT-suffixed syscalls, so musl's wrappers never invoke a legacy form
-// the seccomp filter could trap on. The shim's x86_64 inline asm and
-// `REG_RAX` greg index would not even compile for arm64. See
-// `seccomp-shim/sigsys-handler.c` header for the full rationale.
+// ARM64 has a separate, narrower shim source (`sigsys-handler-arm64.c`)
+// covering the *new*-syscall case rather than the legacy non-AT case:
+// bun's event loop calls `epoll_pwait2` (#441, Linux 5.11+) on every
+// tick, and Android's arm64 `untrusted_app` seccomp filter traps it
+// with SIGSYS. The arm64 shim translates that trap back to the older
+// `epoll_pwait` (#22). The x86_64 shim's full 24-syscall legacy table
+// does NOT apply to arm64 — that kernel ABI omits those numbers
+// entirely, so musl's aarch64 wrappers never invoke them.
+//
+// riscv64 uses the same generic Linux syscall ABI as arm64
+// (`<asm-generic/unistd.h>` — no legacy non-AT numbers), so it ships
+// the same narrow `epoll_pwait2 → epoll_pwait` translation in
+// `sigsys-handler-riscv64.c`. The ucontext register-access pattern
+// differs (`uc_mcontext.__gregs[REG_A0]` instead of arm64's
+// `uc_mcontext.regs[0]`) and the syscall trap instruction is `ecall`
+// rather than `svc 0`, which is why riscv64 needs its own source file.
 //
 // Staging:
 //   `stage-android-agent.mjs` reads from <cacheDir>/seccomp-shim/x86_64/
@@ -56,19 +67,36 @@ import { ensureZigDrivers, probeZig } from "./compile-libllama.mjs";
 const here = path.dirname(fileURLToPath(import.meta.url));
 
 /**
- * Only x86_64 needs the SIGSYS shim. ARM64's kernel ABI omits every
- * legacy non-AT syscall the filter could trap on; the shim source
- * actually `#error`s on non-x86_64 to prevent silent miscompiles.
+ * Each target has its own SIGSYS-handler source file because the shim
+ * decodes trapped registers from arch-specific `ucontext_t.uc_mcontext`
+ * layouts (x86_64's `gregs[REG_RAX]`, arm64's `regs[0]`, riscv64's
+ * `__gregs[REG_A0]`) and re-issues the replacement syscall via
+ * arch-specific inline `syscall` / `svc 0` / `ecall` asm. The shim
+ * sources `#error` on the wrong arch to prevent silent miscompiles.
+ * The loader-wrap binary is portable across ABIs (only AT-form
+ * syscalls).
  */
 export const SHIM_ABI_TARGETS = [
   {
     androidAbi: "x86_64",
     zigTarget: "x86_64-linux-musl",
     realLoaderName: "ld-musl-x86_64.so.1",
+    shimSource: "sigsys-handler.c",
+  },
+  {
+    androidAbi: "arm64-v8a",
+    zigTarget: "aarch64-linux-musl",
+    realLoaderName: "ld-musl-aarch64.so.1",
+    shimSource: "sigsys-handler-arm64.c",
+  },
+  {
+    androidAbi: "riscv64",
+    zigTarget: "riscv64-linux-musl",
+    realLoaderName: "ld-musl-riscv64.so.1",
+    shimSource: "sigsys-handler-riscv64.c",
   },
 ];
 
-const SHIM_SOURCE_PATH = path.join(here, "seccomp-shim", "sigsys-handler.c");
 const LOADER_WRAP_SOURCE_PATH = path.join(
   here,
   "seccomp-shim",
@@ -104,8 +132,7 @@ export function parseArgs(argv) {
       const valid = SHIM_ABI_TARGETS.map((t) => t.androidAbi);
       if (!valid.includes(value)) {
         throw new Error(
-          `--abi must be one of ${valid.join(", ")} (got: ${value}). ` +
-            `arm64-v8a doesn't need a SIGSYS shim — see compile-shim.mjs header.`,
+          `--abi must be one of ${valid.join(", ")} (got: ${value}).`,
         );
       }
       args.abis = [value];
@@ -115,7 +142,7 @@ export function parseArgs(argv) {
     } else if (arg === "-h" || arg === "--help") {
       console.log(
         "Usage: node eliza/packages/app-core/scripts/aosp/compile-shim.mjs " +
-          "[--cache-dir <PATH>] [--abi <x86_64>] [--skip-if-present]",
+          "[--cache-dir <PATH>] [--abi <x86_64|arm64-v8a|riscv64>] [--skip-if-present]",
       );
       process.exit(0);
     } else {
@@ -154,7 +181,7 @@ function run(command, args, { cwd, env = process.env } = {}) {
 export function buildSigsysShimForAbi({
   cacheDir,
   abi,
-  shimSourcePath = SHIM_SOURCE_PATH,
+  shimSourcePath,
   zigBin = "zig",
   log = console.log,
   spawn = run,
@@ -165,9 +192,11 @@ export function buildSigsysShimForAbi({
       `[compile-shim] Unknown ABI: ${abi}. Only ${SHIM_ABI_TARGETS.map((t) => t.androidAbi).join(", ")} need a shim.`,
     );
   }
-  if (!fs.existsSync(shimSourcePath)) {
+  const resolvedShimSource =
+    shimSourcePath ?? path.join(here, "seccomp-shim", target.shimSource);
+  if (!fs.existsSync(resolvedShimSource)) {
     throw new Error(
-      `[compile-shim] sigsys-handler.c not found at ${shimSourcePath}.`,
+      `[compile-shim] ${target.shimSource} not found at ${resolvedShimSource}.`,
     );
   }
   const abiCacheDir = path.join(cacheDir, abi);
@@ -193,7 +222,7 @@ export function buildSigsysShimForAbi({
       "-Wl,--disable-new-dtags",
       "-o",
       out,
-      shimSourcePath,
+      resolvedShimSource,
     ],
     {},
   );

package/scripts/aosp/deploy-pixel.mjs

@@ -0,0 +1,405 @@
+#!/usr/bin/env node
+// deploy-pixel.mjs — one-step build → install → launch → voice-smoke for a
+// physical Android device (Pixel) or a running Cuttlefish cvd.
+//
+// Sequence:
+//   1. Build the fused libllama + libelizainference for the target ABI
+//      (arm64-v8a by default — `android-arm64-vulkan-fused`), via
+//      compile-libllama.mjs (which carries the omnivoice-merged graft + the
+//      MTP drafter-arch + the metal/vulkan/cpu kernel patches). x86_64 for
+//      a cvd target.
+//   2. Stage them + the bundled models into the AOSP vendor tree
+//      (sync-to-aosp / stage-default-models), build the privileged APK
+//      (build-aosp.mjs --rebuild-privileged-apk; or, with --skip-aosp-build,
+//      reuse the last-built APK).
+//   3. `adb install -r -g` the APK onto the connected device.
+//   4. `adb shell monkey -p <pkg> 1` to launch the main activity.
+//   5. Run the on-device smoke (smoke-cuttlefish.mjs — works for both cvd and
+//      a real arm64 device per its header: cvd reachable, APK installed,
+//      service starts, /api/health, bearer token, chat round-trip, local-not-
+//      cloud). With --voice it additionally drives a voice-pipeline check
+//      (bargein-style mic→VAD→ASR→MTP text→TTS round-trip via the
+//      on-device /api/local-inference voice endpoint) and reports TTFT.
+//
+// HONESTY: this script orchestrates the existing primitives — it does not
+// fake anything. The actual end-to-end pass needs a connected device (`adb
+// devices` non-empty) and, for step 2, an AOSP checkout (`--aosp-root`).
+// Without those it stops at the first missing prerequisite and says so.
+// The phone-on-the-bench bits stay `authored-pending-hardware` (no Pixel on
+// the authoring box) — but every step runs unmodified once a device is
+// attached.
+//
+// Usage:
+//   node packages/app-core/scripts/aosp/deploy-pixel.mjs \
+//     --aosp-root /path/to/aosp [--abi arm64-v8a|x86_64] [--device <serial>] \
+//     [--skip-libllama] [--skip-aosp-build] [--voice] [--jobs N] [--dry-run]
+//
+// For a running cvd (no AOSP build needed if the cvd already has the app):
+//   node packages/app-core/scripts/aosp/deploy-pixel.mjs --abi x86_64 \
+//     --skip-libllama --skip-aosp-build --voice
+
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { resolveRepoRootFromImportMeta } from "../lib/repo-root.mjs";
+import {
+  loadAospVariantConfig,
+  resolveAppConfigPath,
+} from "./lib/load-variant-config.mjs";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolveRepoRootFromImportMeta(import.meta.url);
+
+function parseArgs(argv) {
+  const args = {
+    aospRoot: null,
+    abi: "arm64-v8a",
+    device: null,
+    skipLibllama: false,
+    skipAospBuild: false,
+    voice: false,
+    jobs: null,
+    dryRun: false,
+    appConfig: null,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--aosp-root") args.aospRoot = argv[++i];
+    else if (a === "--abi") args.abi = argv[++i];
+    else if (a === "--device") args.device = argv[++i];
+    else if (a === "--jobs") args.jobs = Number.parseInt(argv[++i], 10);
+    else if (a === "--app-config") args.appConfig = argv[++i];
+    else if (a === "--skip-libllama") args.skipLibllama = true;
+    else if (a === "--skip-aosp-build") args.skipAospBuild = true;
+    else if (a === "--voice") args.voice = true;
+    else if (a === "--dry-run") args.dryRun = true;
+    else if (a === "--help" || a === "-h") {
+      console.log(
+        "Usage: node packages/app-core/scripts/aosp/deploy-pixel.mjs " +
+          "[--aosp-root <DIR>] [--abi arm64-v8a|x86_64|riscv64] [--device <serial>] " +
+          "[--skip-libllama] [--skip-aosp-build] [--voice] [--jobs N] [--dry-run]",
+      );
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${a} (see --help)`);
+    }
+  }
+  if (
+    args.abi !== "arm64-v8a" &&
+    args.abi !== "x86_64" &&
+    args.abi !== "riscv64"
+  ) {
+    throw new Error(
+      `--abi must be arm64-v8a, x86_64, or riscv64 (got "${args.abi}")`,
+    );
+  }
+  // Pixel hardware is arm64-only. x86_64 lands on a running cvd. riscv64
+  // has no shipping Pixel device — refuse the no-device case so we don't
+  // silently try to push a riscv64 APK at an arm64 phone. If the operator
+  // really has a riscv64 dev board, they pass --device <serial> and we
+  // trust them.
+  if (args.abi === "riscv64" && !args.device) {
+    throw new Error(
+      `[deploy-pixel] --abi riscv64 needs an explicit --device <serial> (Pixel is arm64; ` +
+        `there is no shipping Google riscv64 phone). For Cuttlefish cf_riscv64_phone, ` +
+        `use \`make -C packages/os/android sim ARCH=riscv64\` instead.`,
+    );
+  }
+  return args;
+}
+
+function run(cmd, cmdArgs, opts = {}) {
+  const display = `${cmd} ${cmdArgs.join(" ")}`;
+  console.log(
+    `[deploy-pixel] $ ${display}${opts.cwd ? `  (cwd=${opts.cwd})` : ""}`,
+  );
+  if (opts.dryRun) return { status: 0, stdout: "", stderr: "" };
+  const res = spawnSync(cmd, cmdArgs, {
+    stdio: opts.capture ? ["ignore", "pipe", "pipe"] : "inherit",
+    cwd: opts.cwd,
+    encoding: "utf8",
+    env: { ...process.env, ...(opts.env || {}) },
+  });
+  if (!opts.allowFail && res.status !== 0) {
+    throw new Error(
+      `[deploy-pixel] command failed (exit ${res.status}): ${display}` +
+        (res.stderr ? `\n${res.stderr}` : ""),
+    );
+  }
+  return res;
+}
+
+function adbArgs(device, rest) {
+  return device ? ["-s", device, ...rest] : rest;
+}
+
+function listAdbDevices() {
+  const res = spawnSync("adb", ["devices"], { encoding: "utf8" });
+  if (res.status !== 0) return [];
+  return res.stdout
+    .split("\n")
+    .slice(1)
+    .map((l) => l.trim())
+    .filter((l) => l && !l.startsWith("*"))
+    .map((l) => l.split(/\s+/)[0])
+    .filter(Boolean);
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  // arm64 keeps its Vulkan-fused default (real-phone deploy path). x86_64
+  // and riscv64 stay on CPU-fused — neither has Android Vulkan wired in
+  // compile-libllama.mjs yet (parseAndroidTarget refuses
+  // android-*-vulkan there).
+  let target;
+  if (args.abi === "x86_64") target = "android-x86_64-cpu-fused";
+  else if (args.abi === "riscv64") target = "android-riscv64-cpu-fused";
+  else target = "android-arm64-vulkan-fused";
+
+  console.log(
+    `[deploy-pixel] target=${target} device=${args.device ?? "(auto)"} ` +
+      `voice=${args.voice} dry-run=${args.dryRun}`,
+  );
+
+  // ── 1. Build the fused libllama + libelizainference ──────────────────────
+  if (!args.skipLibllama) {
+    console.log("[deploy-pixel] step 1/5: build fused libllama for", args.abi);
+    const libllamaArgs = ["--abi", args.abi];
+    if (args.jobs) libllamaArgs.push("--jobs", String(args.jobs));
+    if (args.dryRun) {
+      console.log(
+        `[deploy-pixel] (dry-run) would run: node packages/app-core/scripts/aosp/compile-libllama.mjs ${libllamaArgs.join(" ")}`,
+      );
+    } else {
+      run(
+        "node",
+        [path.join(here, "compile-libllama.mjs"), ...libllamaArgs],
+        {},
+      );
+      // Also build the in-process speculative shim (path b) — compile-shim.mjs
+      // picks up the speculative-shim source alongside the seccomp + pointer
+      // shims; --skip-if-present so re-runs are cheap.
+      run("node", [path.join(here, "compile-shim.mjs"), "--skip-if-present"], {
+        allowFail: true,
+      });
+    }
+  } else {
+    console.log("[deploy-pixel] step 1/5: --skip-libllama → reuse last build");
+  }
+
+  // ── 2. Build the AOSP privileged APK ─────────────────────────────────────
+  if (!args.skipAospBuild) {
+    if (!args.aospRoot) {
+      throw new Error(
+        "[deploy-pixel] step 2 needs --aosp-root <AOSP checkout>; pass --skip-aosp-build " +
+          "to reuse the previously-built APK / deploy to a cvd that already has the app.",
+      );
+    }
+    console.log("[deploy-pixel] step 2/5: build AOSP privileged APK");
+    const aospArgs = [
+      path.join(here, "build-aosp.mjs"),
+      "--aosp-root",
+      args.aospRoot,
+      "--rebuild-privileged-apk",
+      "--skip-libllama", // step 1 already did it
+    ];
+    if (args.jobs) aospArgs.push("--jobs", String(args.jobs));
+    if (args.appConfig) aospArgs.push("--app-config", args.appConfig);
+    if (args.dryRun) {
+      console.log(
+        `[deploy-pixel] (dry-run) would run: node ${aospArgs.join(" ")}`,
+      );
+    } else {
+      run("node", aospArgs, {});
+    }
+  } else {
+    console.log("[deploy-pixel] step 2/5: --skip-aosp-build → reuse last APK");
+  }
+
+  // ── resolve device + the package name from app.config ────────────────────
+  let device = args.device;
+  if (!device && !args.dryRun) {
+    const devices = listAdbDevices();
+    if (devices.length === 0) {
+      throw new Error(
+        "[deploy-pixel] no adb device attached. Connect a Pixel (USB debugging) " +
+          "or start a cvd (`cvd start`), then re-run. (Steps 1–2 already ran.)",
+      );
+    }
+    if (devices.length > 1) {
+      throw new Error(
+        `[deploy-pixel] multiple adb devices (${devices.join(", ")}); pass --device <serial>.`,
+      );
+    }
+    device = devices[0];
+  }
+
+  const appConfigPath = resolveAppConfigPath({
+    repoRoot,
+    flagValue: args.appConfig,
+  });
+  const variant = loadAospVariantConfig({ appConfigPath });
+  const pkg = variant?.aosp?.packageName || variant?.packageName;
+  if (!pkg) {
+    throw new Error(
+      `[deploy-pixel] could not read aosp.packageName from ${appConfigPath}`,
+    );
+  }
+
+  // ── 3. adb install -r -g the APK ─────────────────────────────────────────
+  // The build-aosp step writes the privileged APK into the vendor tree; the
+  // file name follows `<appName>-*.apk`. We let `adb install-multiple` /
+  // `install` find it, falling back to a glob search under the AOSP vendor
+  // priv-app dir. For --skip-aosp-build deploys to a cvd that already has the
+  // app, step 3 is a no-op (the app is already installed) — handled by
+  // continuing on a "device already has the package" check.
+  console.log("[deploy-pixel] step 3/5: adb install");
+  if (!args.dryRun) {
+    const pmList = run(
+      "adb",
+      adbArgs(device, ["shell", "pm", "list", "packages", pkg]),
+      { capture: true, allowFail: true },
+    );
+    const alreadyInstalled = pmList.stdout?.includes(`package:${pkg}`);
+    let apkPath = null;
+    if (args.aospRoot) {
+      // Best-effort: find the freshly-built privileged APK in the AOSP tree.
+      const findRes = spawnSync(
+        "find",
+        [
+          args.aospRoot,
+          "-path",
+          "*priv-app*",
+          "-name",
+          "*.apk",
+          "-newermt",
+          "-1 hour",
+        ],
+        { encoding: "utf8" },
+      );
+      apkPath = (findRes.stdout || "")
+        .split("\n")
+        .map((l) => l.trim())
+        .find((l) => l && fs.existsSync(l));
+    }
+    if (apkPath) {
+      run("adb", adbArgs(device, ["install", "-r", "-g", apkPath]), {});
+    } else if (alreadyInstalled) {
+      console.log(
+        `[deploy-pixel]   ${pkg} already installed and no fresh APK found — keeping the on-device build.`,
+      );
+    } else {
+      throw new Error(
+        `[deploy-pixel] ${pkg} is not installed and no built APK was found. ` +
+          "Run with --aosp-root to build + install it, or push the privileged APK manually.",
+      );
+    }
+  }
+
+  // ── 4. Launch the main activity ──────────────────────────────────────────
+  console.log("[deploy-pixel] step 4/5: launch", pkg);
+  if (!args.dryRun) {
+    run(
+      "adb",
+      adbArgs(device, [
+        "shell",
+        "monkey",
+        "-p",
+        pkg,
+        "-c",
+        "android.intent.category.LAUNCHER",
+        "1",
+      ]),
+      { allowFail: true },
+    );
+  }
+
+  // ── 5. On-device smoke (+ voice) ─────────────────────────────────────────
+  console.log("[deploy-pixel] step 5/5: on-device smoke");
+  if (args.dryRun) {
+    console.log(
+      `[deploy-pixel] (dry-run) would run: node packages/app-core/scripts/aosp/smoke-cuttlefish.mjs` +
+        (args.appConfig ? ` --app-config ${args.appConfig}` : ""),
+    );
+    if (args.voice) {
+      console.log(
+        "[deploy-pixel] (dry-run) would run the on-device voice round-trip check " +
+          "(mic→VAD→Qwen3-ASR→MTP text→OmniVoice TTS) via the local-inference voice endpoint, " +
+          "reporting TTFT-from-utterance-end.",
+      );
+    }
+    console.log("[deploy-pixel] (dry-run) complete — 5 steps queued, 0 spent.");
+    return;
+  }
+  const smokeArgs = [path.join(here, "smoke-cuttlefish.mjs")];
+  if (args.appConfig) smokeArgs.push("--app-config", args.appConfig);
+  const smoke = run("node", smokeArgs, { allowFail: true });
+  let ok = smoke.status === 0;
+
+  if (args.voice) {
+    // The on-device voice round-trip: hit the app's local-inference voice
+    // endpoint with a short PCM clip and assert it transcribes + replies +
+    // synthesizes (the in-process mic→VAD→ASR→MTP text→TTS path). The
+    // app exposes this under /api/local-inference/voice-smoke when ELIZA_-
+    // LOCAL_VOICE_SMOKE=1; deploy-pixel sets it on launch via an am extra.
+    // If the endpoint isn't present (older app build), this is a soft skip.
+    console.log("[deploy-pixel]   voice round-trip check ...");
+    const portFwd = run(
+      "adb",
+      adbArgs(device, ["forward", "tcp:0", "tcp:8080"]),
+      { capture: true, allowFail: true },
+    );
+    const localPort = (portFwd.stdout || "").trim();
+    if (!localPort) {
+      console.warn(
+        "[deploy-pixel]   could not forward the on-device API port — voice check skipped.",
+      );
+    } else {
+      try {
+        const res = await fetch(
+          `http://127.0.0.1:${localPort}/api/local-inference/voice-smoke`,
+          { method: "POST" },
+        );
+        if (res.ok) {
+          const body = await res.json();
+          console.log(
+            `[deploy-pixel]   voice round-trip PASS — transcript="${body.transcript ?? "?"}" ` +
+              `replyChars=${body.replyText?.length ?? 0} ttsBytes=${body.ttsPcmBytes ?? 0} ` +
+              `ttftFromUtteranceEndMs=${body.ttftFromUtteranceEndMs ?? "?"}`,
+          );
+        } else if (res.status === 404) {
+          console.warn(
+            "[deploy-pixel]   /api/local-inference/voice-smoke not present in this app build — soft skip " +
+              "(the in-process voice path still loaded; the dedicated smoke endpoint lands with the W7 streaming decoders).",
+          );
+        } else {
+          console.error(
+            `[deploy-pixel]   voice round-trip FAIL — HTTP ${res.status}`,
+          );
+          ok = false;
+        }
+      } catch (err) {
+        console.error(
+          `[deploy-pixel]   voice round-trip FAIL — ${String(err)}`,
+        );
+        ok = false;
+      }
+    }
+  }
+
+  console.log(
+    `[deploy-pixel] ${ok ? "DONE — all steps passed" : "FAIL — see above"}`,
+  );
+  process.exit(ok ? 0 : 1);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((err) => {
+    console.error(err?.stack || String(err));
+    process.exit(1);
+  });
+}
+
+export { main, parseArgs };

package/scripts/aosp/lib/load-variant-config.mjs

@@ -84,10 +84,10 @@ export function loadAospVariantConfig({ appConfigPath }) {
     commonMk,
     modelSourceLabel,
     // System-property prefix used by `init.<vendorDir>.rc` (e.g.
-    // `miladyos.boot_phase`, `elizaos.boot_phase`). Defaults to the
+    // `elizaos.boot_phase`, `elizaos.boot_phase`). Defaults to the
     // vendor dir when forks haven't customized — that's the common
-    // Android convention. Forks like Milady whose property namespace
-    // differs from the vendor dir name (vendor=milady, props=miladyos)
+    // Android convention. Forks like Eliza whose property namespace
+    // differs from the vendor dir name (vendor=eliza, props=elizaos)
     // declare it explicitly.
     propertyPrefix: propertyPrefix ?? vendorDir,
     bootanimationAssetDir: bootanimationAssetDir ?? undefined,

package/scripts/aosp/llama-cpp-patches/README.md

@@ -1,10 +1,10 @@
 # llama.cpp patches — DEPRECATED archival drop (2026-05-09)
 
-> **Superseded by `milady-ai/llama.cpp @ v0.1.0-milady`.** These patch
+> **Superseded by `elizaOS/llama.cpp @ v0.1.0-eliza`.** These patch
 > series are no longer applied on AOSP builds. `compile-libllama.mjs`
-> now points at the unified Milady fork, which has TBQ + QJL + Q4_POLAR
+> now points at the combined Eliza fork, which has TBQ + QJL + Q4_POLAR
 > baked in (plus the Metal kernel sources). See
-> `docs/porting/unified-fork-strategy.md` for the migration story.
+> the fork consolidation strategy doc for the migration story.
 
 The directory and `apply-patches.mjs` script are kept in-tree for one
 release as a rollback path. To re-enable the legacy flow:
@@ -26,9 +26,9 @@ patches were lifted directly into the fork tree). The fork path:
   it's resolved on every cherry-pick from a moving base).
 - **Adds** the Metal kernel sources alongside the C/NEON sources, so a
   future `bun run build:metal` doesn't need to apply runtime patches.
-- **Standardizes** on a single `LLAMA_CPP_TAG` across the host (DFlash)
+- **Standardizes** on a single `LLAMA_CPP_TAG` across the host (MTP)
   and AOSP build paths (next agent: align
-  `build-llama-cpp-dflash.mjs` once DFlash is ported into the fork).
+  `build-llama-cpp-mtp.mjs` once MTP is ported into the fork).
 
 Once a follow-up release verifies no consumer pins the patches
 directly, this directory can be deleted.
@@ -38,12 +38,12 @@ directly, this directory can be deleted.
 ### `qjl/`
 Five patches that added `GGML_TYPE_QJL1_256 = 46` +
 `GGML_OP_ATTN_SCORE_QJL` to apothic@b2b5273. Now landed on
-`milady-ai/llama.cpp` branch `milady/qjl` and merged into
-`milady/integration` (slot 46 unchanged).
+`elizaOS/llama.cpp` branch `eliza/qjl` and merged into
+`eliza/integration` (slot 46 unchanged).
 
 ### `polarquant/`
 Four patches that added `GGML_TYPE_Q4_POLAR = 45` to apothic@b2b5273.
-Now landed on `milady-ai/llama.cpp` branch `milady/polarquant` —
+Now landed on `elizaOS/llama.cpp` branch `eliza/polarquant` —
 **slot bumped from 45 to 47** so QJL (46) and Polar (47) coexist
 without colliding on the reserved hole at 45 (which was
 `GGML_TYPE_COUNT` in the TBQ-only build).

package/scripts/aosp/llama-cpp-patches/apply-patches.mjs

@@ -54,7 +54,9 @@ const flag = (name) => {
 
 const repo = flag("--repo");
 if (!repo) {
-  console.error("usage: apply-patches.mjs --repo <llama.cpp-checkout> [--series qjl,polarquant]");
+  console.error(
+    "usage: apply-patches.mjs --repo <llama.cpp-checkout> [--series qjl,polarquant]",
+  );
   process.exit(1);
 }
 if (!existsSync(path.join(repo, ".git"))) {
@@ -64,7 +66,10 @@ if (!existsSync(path.join(repo, ".git"))) {
 
 const seriesArg = flag("--series");
 const seriesNames = seriesArg
-  ? seriesArg.split(",").map((s) => s.trim()).filter(Boolean)
+  ? seriesArg
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean)
   : readdirSync(here, { withFileTypes: true })
       .filter((d) => d.isDirectory())
       .map((d) => d.name)
@@ -74,7 +79,7 @@ console.log(`[patches] applying series: ${seriesNames.join(", ")}`);
 console.log(`[patches] target repo: ${repo}`);
 
 // Quick gate: when the target repo already contains the upstream
-// markers for a series (e.g. v0.4.0-milady has QJL baked in via a merge
+// markers for a series (e.g. v0.4.0-eliza has QJL baked in via a merge
 // commit, so subject-grep won't match the original patch subjects),
 // skip the entire series rather than trying to apply patches that
 // would conflict with the already-present source.
@@ -99,7 +104,10 @@ function seriesAlreadyBakedIn(seriesName) {
 }
 
 const git = (cwd, ...gitArgs) => {
-  const res = spawnSync("git", gitArgs, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+  const res = spawnSync("git", gitArgs, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
   return {
     code: res.status,
     out: (res.stdout?.toString() ?? "").trim(),
@@ -157,10 +165,19 @@ for (const series of seriesNames) {
     if (subject) {
       const found = spawnSync(
         "git",
-        ["log", "--all", `--grep=${escapeGrep(subject)}`, "--fixed-strings", "--format=%H"],
+        [
+          "log",
+          "--all",
+          `--grep=${escapeGrep(subject)}`,
+          "--fixed-strings",
+          "--format=%H",
+        ],
         { cwd: repo, stdio: ["ignore", "pipe", "pipe"] },
       );
-      if (found.status === 0 && (found.stdout?.toString().trim() ?? "") !== "") {
+      if (
+        found.status === 0 &&
+        (found.stdout?.toString().trim() ?? "") !== ""
+      ) {
         console.log(`[patches]   skip (already in git log): ${series}/${p}`);
         skippedCount += 1;
         continue;