Merge remote-tracking branch 'origin/develop' into develop

Author: Shaw

packages/agent/scripts/build-mobile-bundle.mjs

@@ -61,24 +61,51 @@ await rm(outDir, { recursive: true, force: true });
 await mkdir(outDir, { recursive: true });
 
 function findPgliteDist() {
+  // pglite.wasm + pglite.data MUST match the @electric-sql/pglite version
+  // that the bundled agent JS resolves at runtime — they're a triple
+  // (engine + filesystem image + JS shim). The agent imports from
+  // @elizaos/plugin-sql, which pins ^0.3.3, while the eliza repo's
+  // top-level deps may pull in a newer 0.4.x for unrelated reasons.
+  // Bun's hoisting can park a 0.4.x copy at the top of `node_modules/.bun`
+  // and a `readdirSync` walk will pick that up first. The runtime then
+  // throws "Invalid FS bundle size: <new> !== <old>" because the bundled
+  // 0.3.x WASM expects the 0.3.x .data while we shipped 0.4.x.
+  //
+  // Resolve plugin-sql's OWN private node_modules first so the staged
+  // assets always match the bundled engine. Fall back to the repoRoot
+  // hoisted location and to the .bun cache for the bundled-monorepo
+  // case where plugin-sql is hoisted instead of nested.
   const candidates = [
+    path.join(
+      repoRoot,
+      "plugins",
+      "plugin-sql",
+      "typescript",
+      "node_modules",
+      "@electric-sql",
+      "pglite",
+      "dist",
+    ),
     path.join(repoRoot, "node_modules", "@electric-sql", "pglite", "dist"),
   ];
   const bunDir = path.join(repoRoot, "node_modules", ".bun");
   if (existsSync(bunDir)) {
-    for (const entry of readdirSyncSafe(bunDir)) {
-      if (entry.startsWith("@electric-sql+pglite@")) {
-        candidates.push(
-          path.join(
-            bunDir,
-            entry,
-            "node_modules",
-            "@electric-sql",
-            "pglite",
-            "dist",
-          ),
-        );
-      }
+    // Sort .bun entries by version so that 0.3.x wins over 0.4.x —
+    // matches the plugin-sql ^0.3.3 pin without forcing a manual list.
+    const sortedEntries = readdirSyncSafe(bunDir)
+      .filter((e) => e.startsWith("@electric-sql+pglite@"))
+      .sort();
+    for (const entry of sortedEntries) {
+      candidates.push(
+        path.join(
+          bunDir,
+          entry,
+          "node_modules",
+          "@electric-sql",
+          "pglite",
+          "dist",
+        ),
+      );
     }
   }
   for (const c of candidates) {

packages/agent/src/runtime/prompt-compaction.ts

@@ -289,9 +289,19 @@ export function compactCodingExamplesForIntent(prompt: string): string {
 }
 
 /**
- * Context-aware action formatting. Replaces the <actions>...</actions>
- * block in the prompt with a version where only intent-relevant actions
- * have full <params> — the rest are stubs with just name + description.
+ * Context-aware action formatting. Replaces the available-actions block in
+ * the prompt with a version where only intent-relevant actions keep full
+ * parameter detail — the rest are stubs with just name + description.
+ *
+ * Supports two prompt encodings:
+ *   - TOON (current default): the actions provider emits
+ *       actions[N]:
+ *       - ACTION: description
+ *         aliases[..]: ...
+ *         tags[..]: ...
+ *         params[..]: ...
+ *         example: ...
+ *   - XML (legacy): <actions><action><name>..</name>...</action>...</actions>
  *
  * If no intents are detected (general chat), only universal actions
  * (REPLY, NONE, IGNORE) keep full params — all others are stubbed.
@@ -309,7 +319,116 @@ export function compactActionsForIntent(prompt: string): string {
   // are always preserved, so the LLM can still select the right action; it
   // just won't see detailed param schemas until the user triggers a known intent.
 
-  // Find the first <actions>...</actions> block (the Available Actions section)
+  const intentCategories = detectIntentCategories(prompt);
+  // When no specific intent is detected, it's general chat — only universal
+  // actions (REPLY, NONE, IGNORE) need full detail. All other actions get
+  // stubs so the LLM knows they exist but doesn't waste context on params.
+  const fullParamActions = buildFullParamActionSet(intentCategories);
+
+  // Try TOON-format first (current default), then fall back to XML for
+  // legacy prompts that still emit <actions>...</actions> blocks.
+  const toonCompacted = compactToonActionsBlock(prompt, fullParamActions);
+  if (toonCompacted !== null) return toonCompacted;
+  return compactXmlActionsBlock(prompt, fullParamActions);
+}
+
+/**
+ * Locate and compact a TOON-formatted "Available Actions" block. Returns
+ * `null` if no TOON block is found, so the caller can try XML.
+ */
+function compactToonActionsBlock(
+  prompt: string,
+  fullParamActions: Set<string>,
+): string | null {
+  // The actions provider emits "actions[N]:\n- NAME: desc\n  params[..]: ...".
+  // Anchor on that header line.
+  const headerRe = /^actions\[\d+\]:[ \t]*$/m;
+  const headerMatch = headerRe.exec(prompt);
+  if (!headerMatch) return null;
+
+  const blockStart = headerMatch.index;
+  const headerLine = headerMatch[0];
+  const bodyStart = blockStart + headerLine.length;
+
+  // Walk forward consuming action entries (`- NAME: ...`) and their
+  // two-space-indented continuation lines. Stop at the first non-indented
+  // non-entry line that isn't part of an entry.
+  const remainder = prompt.slice(bodyStart);
+  const lines = remainder.split("\n");
+
+  let consumed = 0;
+  if (lines.length > 0 && lines[0] === "") {
+    consumed = 1;
+  }
+
+  while (consumed < lines.length) {
+    const line = lines[consumed];
+    if (line.startsWith("- ") || line.startsWith("  ")) {
+      consumed += 1;
+      continue;
+    }
+    if (line === "") {
+      const next = lines[consumed + 1];
+      if (next !== undefined && next.startsWith("- ")) {
+        consumed += 1;
+        continue;
+      }
+      break;
+    }
+    break;
+  }
+
+  const bodyLines = lines.slice(0, consumed);
+  const blockEnd = bodyStart + bodyLines.join("\n").length;
+
+  type ToonAction = { name: string; entryLines: string[] };
+  const entries: ToonAction[] = [];
+  let current: ToonAction | null = null;
+  for (const line of bodyLines) {
+    if (line.startsWith("- ")) {
+      if (current) entries.push(current);
+      const nameMatch = /^- ([A-Z0-9_]+):/.exec(line);
+      const name = nameMatch?.[1] ?? "";
+      current = { name, entryLines: [line] };
+    } else if (current && (line.startsWith("  ") || line === "")) {
+      current.entryLines.push(line);
+    }
+  }
+  if (current) entries.push(current);
+
+  if (entries.length === 0) return null;
+
+  const compactedEntries = entries.map((entry) => {
+    if (!entry.name || fullParamActions.has(entry.name)) {
+      return entry.entryLines.join("\n");
+    }
+    // Stub: keep only `- NAME: description`; drop continuation lines.
+    return entry.entryLines[0];
+  });
+
+  while (
+    compactedEntries.length > 0 &&
+    compactedEntries[compactedEntries.length - 1] === ""
+  ) {
+    compactedEntries.pop();
+  }
+
+  const compactedBody = compactedEntries.join("\n");
+  const before = prompt.slice(0, bodyStart);
+  const after = prompt.slice(blockEnd);
+  const separator = bodyLines.length > 0 && bodyLines[0] === "" ? "\n" : "";
+  return `${before}${separator}${compactedBody}${after}`;
+}
+
+/**
+ * Legacy XML compaction: locate a `<actions>...</actions>` block and stub
+ * non-relevant `<action>` entries. Returns the original prompt unchanged
+ * when no XML block is present.
+ */
+function compactXmlActionsBlock(
+  prompt: string,
+  fullParamActions: Set<string>,
+): string {
   const actionsStart = prompt.indexOf("<actions>");
   if (actionsStart === -1) return prompt;
   const actionsEnd = prompt.indexOf("</actions>", actionsStart);
@@ -320,13 +439,6 @@ export function compactActionsForIntent(prompt: string): string {
     actionsEnd,
   );
 
-  const intentCategories = detectIntentCategories(prompt);
-  // When no specific intent is detected, it's general chat — only universal
-  // actions (REPLY, NONE, IGNORE) need full detail. All other actions get
-  // stubs so the LLM knows they exist but doesn't waste context on params.
-  const fullParamActions = buildFullParamActionSet(intentCategories);
-
-  // Parse individual <action>...</action> blocks
   const actionRegex = /<action>([\s\S]*?)<\/action>/g;
   const compactedActions: string[] = [];
 
@@ -338,10 +450,8 @@ export function compactActionsForIntent(prompt: string): string {
     const actionName = nameMatch[1].trim();
 
     if (fullParamActions.has(actionName)) {
-      // Keep full action with params
       compactedActions.push(`  <action>${actionInner}</action>`);
     } else {
-      // Stub: name + description only, strip <params>
       const descMatch = actionInner.match(
         /<description>([\s\S]*?)<\/description>/,
       );

packages/app-core/platforms/android/app/src/main/java/ai/elizaos/app/ElizaAgentService.java

@@ -11,6 +11,7 @@
 import android.content.res.AssetManager;
 import android.os.Build;
 import android.os.IBinder;
+import android.provider.Settings;
 import android.util.Log;
 
 import androidx.core.app.NotificationCompat;
@@ -808,6 +809,87 @@ private void startAgentProcess() {
             agentEnv.put("BUN_FEATURE_FLAG_FORCE_WAITER_THREAD", "1");
             agentEnv.put("BUN_FEATURE_FLAG_DISABLE_RWF_NONBLOCK", "1");
             agentEnv.put("BUN_FEATURE_FLAG_DISABLE_SPAWNSYNC_FAST_PATH", "1");
+            // BUN_FEATURE_FLAG_DISABLE_ASYNC_TRANSPILER=1
+            //     Forces bun's transpiler to run on the main thread
+            //     instead of the async worker pool. The worker pool
+            //     uses pthread + futex_waitv (added in 5.16) which
+            //     Android's app seccomp policy blocks on most kernels
+            //     before API 34. Disables the worker thread spawn
+            //     entirely — the transpiler still runs, just inline.
+            //
+            // NOTE: Do NOT set BUN_FEATURE_FLAG_DISABLE_MEMFD=1 here.
+            // memfd_create IS on Android's app seccomp allowlist
+            // (verified API 30+), and bun's JSC tier uses memfd as
+            // the W^X dual-mapping mechanism for JIT code pages.
+            // Disabling memfd forces JSC to fall back to raw RWX
+            // mmap, which IS blocked by SELinux execmem on platform_app
+            // — that combination kills bun before any log line is
+            // written. Tested empirically: with the 43 MB agent-bundle,
+            // DISABLE_MEMFD=1 produces an early SIGSYS during JIT init;
+            // with memfd allowed, bun reaches PGlite + listener.
+            agentEnv.put("BUN_FEATURE_FLAG_DISABLE_ASYNC_TRANSPILER", "1");
+
+            // ── No on-device prompt-optimization / training ────────────
+            //
+            // The runtime ships with a trajectory-driven prompt-optimization
+            // pipeline (MIPRO / GEPA / bootstrap-fewshot via the native
+            // backend). On boot, OptimizedPromptService kicks off a one-
+            // shot bootstrap when accumulated trajectories cross threshold,
+            // and the cron auto-trainer dispatches further rounds in the
+            // background. None of that belongs on a phone or a privileged
+            // system app:
+            //   - MIPRO/GEPA spawn coding sub-agents (PTY-backed bash) that
+            //     blow past the bun seccomp envelope this service builds.
+            //   - The trajectory writer fans out to the trajectories table
+            //     under PGlite which already churns the device flash.
+            //   - On AOSP cvd we want a deterministic agent binary, not
+            //     one that mutates its prompts mid-smoke.
+            //
+            // Hard-disable both the bootstrap and the trajectory ingest
+            // path so the agent never spins up a training round on-device.
+            // Trajectories are still useful for live chat context, but
+            // this disables PERSISTENCE — the optimizer has no input data
+            // and no-ops at boot. Both env names are set: the source uses
+            // ELIZA_* post-rename, the bundled training-trigger.js still
+            // reads MILADY_* in older dist-mobile builds.
+            agentEnv.put("ELIZA_DISABLE_AUTO_BOOTSTRAP", "1");
+            agentEnv.put("MILADY_DISABLE_AUTO_BOOTSTRAP", "1");
+            agentEnv.put("ELIZA_DISABLE_TRAJECTORY_LOGGING", "1");
+
+            // ── Vault passphrase ──────────────────────────────────────
+            // The runtime's vault-bootstrap mirrors process.env secrets
+            // through @elizaos/vault, which on a headless Linux host
+            // (Android counts: no reachable D-Bus session) refuses the
+            // OS keychain and demands ELIZA_VAULT_PASSPHRASE (≥12 chars)
+            // to derive a master key. Without it the bootstrap fails
+            // and startEliza() throws "[vault-bootstrap] all 1 secret
+            // writes failed; vault unreachable", which the watchdog
+            // interprets as a crash and restart-loops the agent.
+            //
+            // Derive a per-install stable passphrase from ANDROID_ID
+            // (Settings.Secure.ANDROID_ID — 16 hex chars, per-app-install
+            // on Android 8+, stable across reboots and OS updates).
+            // Prefix with a constant so the value is always ≥12 chars
+            // even if ANDROID_ID is unexpectedly short or null. The
+            // resulting passphrase is opaque to the user and is only
+            // ever stored in memory in the spawned bun process.
+            //
+            // Operators can override by setting ELIZA_VAULT_PASSPHRASE
+            // in the parent service env (e.g. for a deterministic dev
+            // passphrase across reinstalls).
+            if (!env.containsKey("ELIZA_VAULT_PASSPHRASE")) {
+                String androidId = Settings.Secure.getString(
+                    getContentResolver(),
+                    Settings.Secure.ANDROID_ID
+                );
+                if (androidId == null || androidId.length() < 8) {
+                    androidId = "fallback-" + Build.SERIAL;
+                }
+                agentEnv.put(
+                    "ELIZA_VAULT_PASSPHRASE",
+                    "elizaos-android-vault-" + androidId
+                );
+            }
 
             // Default to info-level logging so plugin resolution + listen
             // progress is visible in agent.log. The runtime defaults to

packages/app-core/scripts/lib/stage-android-agent.mjs

@@ -40,6 +40,9 @@ import { spawn } from "node:child_process";
 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 BUN_VERSION = "1.3.13";
 const ALPINE_BRANCH = "v3.21";
@@ -502,19 +505,50 @@ export async function stageAndroidAgentRuntime({
   // Mirror that by staging vector + fuzzystrmatch in the assets tree at
   // the same level as agent-bundle.js, leaving relative resolution alone.
   //
-  // spikeDir is `<repoRoot>/scripts/spike-android-agent/`; its parent's
-  // parent is the repo root. Resolve dist-mobile relative to that.
-  // (Inside this repo there is no nested `eliza/` directory — that
-  // prefix was a leftover from eliza's outer repo layout where eliza
-  // was a submodule.)
-  const distMobileDir = path.resolve(
+  // The agent bundle is produced by `bun run --cwd packages/agent build:mobile`
+  // and always lands in `<eliza-root>/packages/agent/dist-mobile/`. Resolve
+  // it relative to THIS script's location (eliza/packages/app-core/scripts/lib/)
+  // — that's a stable layout invariant. Resolving relative to spikeDir or
+  // process.cwd() breaks when the eliza package is nested as a submodule
+  // under a consumer repo (Eliza/Milady-style), because their `scripts/`
+  // and `packages/` directories live one level OUT from the eliza checkout.
+  //
+  // The legacy fallback to `<repoRoot>/packages/agent/dist-mobile/` is kept
+  // for the standalone-eliza-monorepo build path where this same script
+  // also runs and the bundle sits at the consumer-repo root.
+  const elizaPackagesAgentDistMobile = path.resolve(
+    __dirname,
+    "..", // scripts/
+    "..", // app-core/
+    "..", // packages/
+    "agent",
+    "dist-mobile",
+  );
+  const consumerPackagesAgentDistMobile = path.resolve(
     path.dirname(spikeDir),
     "..",
     "packages",
     "agent",
     "dist-mobile",
   );
-  const distBundle = path.join(distMobileDir, "agent-bundle.js");
+  const distMobileCandidates = [
+    elizaPackagesAgentDistMobile,
+    consumerPackagesAgentDistMobile,
+  ];
+  let distMobileDir = null;
+  let distBundle = null;
+  for (const candidate of distMobileCandidates) {
+    const bundle = path.join(candidate, "agent-bundle.js");
+    if (fs.existsSync(bundle)) {
+      distMobileDir = candidate;
+      distBundle = bundle;
+      break;
+    }
+  }
+  if (!distBundle) {
+    distMobileDir = elizaPackagesAgentDistMobile;
+    distBundle = path.join(distMobileDir, "agent-bundle.js");
+  }
   const spikeServerJs = path.join(spikeDir, "server.js");
 
   let bundleSrc;