@elizaos/app-core 2.0.3-beta.2 → 2.0.3-beta.3

package/scripts/copy-runtime-node-modules.ts

@@ -57,6 +57,10 @@ const ALLOW_REGISTRY_FETCH =
   process.env.ELIZA_RUNTIME_COPY_ALLOW_REGISTRY_FETCH === "1";
 const DEP_SKIP = new Set(["typescript", "@types/node"]);
 const ALWAYS_HOISTED_PACKAGES = new Set([
+  // @brighter/storage-adapter-s3 accepts broad S3 client ranges; reuse the
+  // runtime root copy instead of nesting a private AWS SDK tree that exceeds
+  // Electrobun's tar-safe path limits.
+  "@aws-sdk/client-s3",
   "@elizaos/core",
   "commander",
   "pg",
@@ -159,6 +163,13 @@ const registryPackageIndex = new Map<string, ResolvedPackage>();
 const trackedPackageIndex = new Map<string, ResolvedPackage>();
 const workspacePackageIndex = new Map<string, ResolvedPackage[]>();
 let workspacePackageIndexBuilt = false;
+let activeRuntimeCopyTargetNodeModules: string | null = null;
+
+function resolveBunCommand(): string {
+  return path.basename(process.execPath).startsWith("bun")
+    ? process.execPath
+    : (process.env.BUN ?? "bun");
+}
 
 function isRequiredRuntimeDocDirectory(entryPath: string): boolean {
   const normalizedPath = entryPath.split(path.sep).join("/");
@@ -371,6 +382,14 @@ function packagePath(name: string, baseDir: string): string {
   return path.join(baseDir, name);
 }
 
+function isPathInsideOrEqual(candidate: string, parent: string): boolean {
+  const relative = path.relative(parent, candidate);
+  return (
+    relative === "" ||
+    (!relative.startsWith("..") && !path.isAbsolute(relative))
+  );
+}
+
 function addWorkspacePackageCandidate(
   name: string,
   resolved: ResolvedPackage,
@@ -962,6 +981,16 @@ function copyPackageDirSync(
       });
       return;
     } catch (error) {
+      if (
+        error &&
+        typeof error === "object" &&
+        (error as { code?: string }).code === "ENAMETOOLONG"
+      ) {
+        throw new Error(
+          `[runtime-copy] path too long while copying ${name} from ${sourceDir} to ${copyDest}`,
+          { cause: error },
+        );
+      }
       if (!isEnoentError(error) || attempt === maxAttempts - 1) {
         throw error;
       }
@@ -1848,6 +1877,12 @@ function collectInstalledPackageDirs(
 
   const addCandidate = (candidate: string): void => {
     if (!fs.existsSync(candidate) || seen.has(candidate)) return;
+    if (
+      activeRuntimeCopyTargetNodeModules &&
+      isPathInsideOrEqual(candidate, activeRuntimeCopyTargetNodeModules)
+    ) {
+      return;
+    }
     seen.add(candidate);
     candidates.push(candidate);
   };
@@ -2070,6 +2105,42 @@ type CopyTargetOptions = {
   resolvedVersion: string | null;
 };
 
+function findReusableAncestorNodeModules({
+  name,
+  requesterDestDir,
+  rootDestDir,
+  resolvedVersion,
+}: Pick<
+  CopyTargetOptions,
+  "name" | "requesterDestDir" | "rootDestDir" | "resolvedVersion"
+>): string | null {
+  const root = path.resolve(rootDestDir);
+  let currentDir = requesterDestDir;
+
+  while (true) {
+    const candidateNodeModules = path.join(currentDir, "node_modules");
+    const candidatePackageDir = packagePath(name, candidateNodeModules);
+    const candidateManifest = path.join(candidatePackageDir, "package.json");
+
+    if (
+      fs.existsSync(candidateManifest) &&
+      getPackageVersion(candidateManifest) === resolvedVersion
+    ) {
+      return candidateNodeModules;
+    }
+
+    if (path.resolve(currentDir) === root) {
+      return null;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
 export function selectCopyTargetNodeModules({
   name,
   requesterDestDir,
@@ -2097,6 +2168,16 @@ export function selectCopyTargetNodeModules({
     return targetNodeModules;
   }
 
+  const reusableAncestorNodeModules = findReusableAncestorNodeModules({
+    name,
+    requesterDestDir,
+    rootDestDir,
+    resolvedVersion,
+  });
+  if (reusableAncestorNodeModules) {
+    return reusableAncestorNodeModules;
+  }
+
   return path.join(requesterDestDir, "node_modules");
 }
 
@@ -2208,6 +2289,69 @@ function getRequiredRuntimeEntryPaths(pkgJsonPath: string): string[] {
   return [...entries].sort();
 }
 
+function workspacePackageNeedsRuntimeBuild(packageJsonPath: string): boolean {
+  for (const entryPath of getRequiredRuntimeEntryPaths(packageJsonPath)) {
+    if (!runtimeManifestEntryExists(path.dirname(packageJsonPath), entryPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function packageHasBuildScript(packageJsonPath: string): boolean {
+  try {
+    const manifest = readJson<{ scripts?: Record<string, unknown> }>(
+      packageJsonPath,
+    );
+    return typeof manifest.scripts?.build === "string";
+  } catch {
+    return false;
+  }
+}
+
+function ensureWorkspaceRuntimeEntriesBuilt(
+  packageNames: Iterable<string>,
+): void {
+  buildWorkspacePackageIndex();
+  const built = new Set<string>();
+
+  for (const packageName of [...new Set(packageNames)].sort()) {
+    if (!isPackageNameCompatibleWithCurrentPlatform(packageName)) continue;
+
+    for (const candidate of workspacePackageIndex.get(packageName) ?? []) {
+      if (built.has(candidate.sourceDir)) continue;
+      if (!isPackageCompatibleWithCurrentPlatform(candidate.packageJsonPath)) {
+        continue;
+      }
+      if (!workspacePackageNeedsRuntimeBuild(candidate.packageJsonPath)) {
+        continue;
+      }
+      if (!packageHasBuildScript(candidate.packageJsonPath)) {
+        continue;
+      }
+
+      console.log(
+        `[runtime-copy] building ${packageName} workspace runtime entries`,
+      );
+      try {
+        execFileSync(resolveBunCommand(), ["run", "build"], {
+          cwd: candidate.sourceDir,
+          env: { ...process.env, FORCE_COLOR: "0" },
+          stdio: "inherit",
+        });
+      } catch (error) {
+        if (workspacePackageNeedsRuntimeBuild(candidate.packageJsonPath)) {
+          throw error;
+        }
+        console.warn(
+          `[runtime-copy] warning: ${packageName} build exited non-zero after producing required runtime entries; continuing`,
+        );
+      }
+      built.add(candidate.sourceDir);
+    }
+  }
+}
+
 // Post-copy assertion: missingAlwaysBundled catches resolve failures, but
 // can't catch a transitive-walk filter silently skipping a CORE plugin or
 // pruneCopiedPackageDir removing a load-bearing package.json or entrypoint.
@@ -2292,6 +2436,7 @@ function assertTarSafeRuntimePaths(targetDist: string): void {
 function main(): void {
   const { scanDir, targetDist } = parseArgs(process.argv.slice(2));
   const targetNodeModules = path.join(targetDist, "node_modules");
+  activeRuntimeCopyTargetNodeModules = targetNodeModules;
 
   if (!fs.existsSync(scanDir)) {
     throw new Error(`scan dir does not exist: ${scanDir}`);
@@ -2339,6 +2484,7 @@ function main(): void {
         return shouldBundle;
       }),
     );
+    ensureWorkspaceRuntimeEntriesBuilt([...alwaysBundled, ...discovered]);
     const queue: QueueEntry[] = [...new Set([...alwaysBundled, ...discovered])]
       .sort()
       .map((name) => ({
@@ -2478,6 +2624,7 @@ function main(): void {
       );
     }
   } finally {
+    activeRuntimeCopyTargetNodeModules = null;
     releaseRuntimeCopyLock();
   }
 }

package/scripts/desktop-build.mjs

@@ -5,6 +5,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveElectrobunDir, resolveMainAppDir } from "./lib/app-dir.mjs";
+import { maxMtimeUnder } from "./lib/artifact-staleness.mjs";
 import {
   buildWindowsRepairSteps,
   classifyElectrobunViewFailure,
@@ -13,6 +14,7 @@ import {
   isSupportedBunVersion,
 } from "./lib/desktop-preflight.mjs";
 import { appIdentityEnv } from "./lib/read-app-identity.mjs";
+import { assertRendererRebuiltSince } from "./lib/renderer-build-manifest.mjs";
 
 const ROOT = process.cwd();
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -488,6 +490,26 @@ function runPackageBinary(binary, binaryArgs, options = {}) {
   fail(`Could not find bunx or npx to run ${binary}.`);
 }
 
+function resolveLocalPackageBinary(binary, cwdCandidates = []) {
+  const executableNames =
+    process.platform === "win32"
+      ? [`${binary}.cmd`, `${binary}.exe`, binary]
+      : [binary];
+  const candidates = [];
+
+  for (const cwd of cwdCandidates) {
+    for (const executableName of executableNames) {
+      candidates.push(path.join(cwd, "node_modules", ".bin", executableName));
+    }
+  }
+
+  for (const executableName of executableNames) {
+    candidates.push(path.join(ROOT, "node_modules", ".bin", executableName));
+  }
+
+  return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+}
+
 function runBunPackageBinary(binary, binaryArgs, options = {}) {
   const bunx = which("bunx");
   if (bunx) {
@@ -499,6 +521,15 @@ function runBunPackageBinary(binary, binaryArgs, options = {}) {
 }
 
 function runElectrobun(commandArgs, options = {}) {
+  const local = resolveLocalPackageBinary(
+    "electrobun",
+    [options.cwd, ELECTROBUN_DIR].filter(Boolean),
+  );
+  if (local) {
+    run(local, commandArgs, options);
+    return;
+  }
+
   const direct = which("electrobun");
   if (direct) {
     run(direct, commandArgs, options);
@@ -802,10 +833,7 @@ function ensureWorkspaceRuntimePackageBuilt(packageName, packageDir) {
   });
 }
 
-function workspaceRuntimePackageLooksBuilt(packageName, packageDir) {
-  const distDir = path.join(packageDir, "dist");
-  if (!fs.existsSync(distDir)) return false;
-
+function workspaceRuntimePackageMarkersPresent(packageName, distDir) {
   if (packageName === "@elizaos/core") {
     return (
       fs.existsSync(path.join(distDir, "node", "index.node.js")) &&
@@ -825,6 +853,31 @@ function workspaceRuntimePackageLooksBuilt(packageName, packageDir) {
   return true;
 }
 
+function workspaceRuntimePackageLooksBuilt(packageName, packageDir) {
+  const distDir = path.join(packageDir, "dist");
+  if (!fs.existsSync(distDir)) return false;
+  if (!workspaceRuntimePackageMarkersPresent(packageName, distDir))
+    return false;
+
+  // Presence of the marker files isn't enough — a dist built from older sources
+  // would silently reuse stale runtime code (issue #9309). Reuse only when the
+  // dist is at least as new as the package's src. ELIZA_DESKTOP_TRUST_RUNTIME_-
+  // PACKAGE_DIST=1 bypasses the mtime check for environments where checkout
+  // mtimes are unreliable.
+  if (process.env.ELIZA_DESKTOP_TRUST_RUNTIME_PACKAGE_DIST === "1") return true;
+  const srcDir = path.join(packageDir, "src");
+  if (!fs.existsSync(srcDir)) return true;
+  const srcMtime = maxMtimeUnder(srcDir);
+  const distMtime = maxMtimeUnder(distDir);
+  if (srcMtime > distMtime) {
+    console.log(
+      `[desktop-build] ${packageName} dist is stale (src newer than dist) — rebuilding`,
+    );
+    return false;
+  }
+  return true;
+}
+
 function ensureWorkspaceRuntimePackagesBuilt() {
   ensureWorkspaceRuntimePackageBuilt("@elizaos/core", CORE_PACKAGE_DIR);
   ensureWorkspaceRuntimePackageBuilt("@elizaos/shared", SHARED_PACKAGE_DIR);
@@ -982,6 +1035,251 @@ function copyRuntimeNodeModulesWithRetry() {
   }
 }
 
+const FUSED_LIB_STAGE_SCRIPT = path.join(
+  SCRIPT_DIR,
+  "stage-desktop-fused-lib.mjs",
+);
+// "auto" → the stager picks the host's best backend (Metal on macOS, CUDA when
+// nvcc is present, else CPU) with the CPU fallback always baked in, so a local
+// `--build-fused-lib` produces "CPU + platform GPU" for the build host.
+const FUSED_LIB_VARIANT =
+  getArgValue(args, "fused-lib-variant") ??
+  process.env.ELIZA_DESKTOP_FUSED_LIB_VARIANT ??
+  "auto";
+// Where the fused lib is staged so the Electrobun copy (dist -> eliza-dist)
+// carries it; app-core's runtime probe (ensureBundledFusedLibDir) then finds
+// `<eliza-dist>/local-inference/lib` with no env wiring.
+const FUSED_LIB_OUT_DIR = path.join(ROOT, "dist", "local-inference", "lib");
+
+function fusedLibFilenames() {
+  if (process.platform === "darwin") return ["libelizainference.dylib"];
+  if (process.platform === "win32")
+    return ["elizainference.dll", "libelizainference.dll"];
+  return ["libelizainference.so"];
+}
+
+function fusedLibAlreadyStaged() {
+  return fusedLibFilenames().some((name) =>
+    fs.existsSync(path.join(FUSED_LIB_OUT_DIR, name)),
+  );
+}
+
+// Provenance for the staged fused lib so the reuse gate never silently reuses a
+// lib built for a DIFFERENT variant/platform than this build targets (#9309).
+const FUSED_LIB_SIDECAR = path.join(FUSED_LIB_OUT_DIR, "staged-fused-lib.json");
+
+function readFusedLibSidecar() {
+  try {
+    return JSON.parse(fs.readFileSync(FUSED_LIB_SIDECAR, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeFusedLibSidecar() {
+  fs.mkdirSync(FUSED_LIB_OUT_DIR, { recursive: true });
+  fs.writeFileSync(
+    FUSED_LIB_SIDECAR,
+    `${JSON.stringify(
+      {
+        variant: FUSED_LIB_VARIANT,
+        platform: process.platform,
+        builtAt: new Date().toISOString(),
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+/**
+ * A staged lib whose provenance sidecar names a DIFFERENT variant/platform than
+ * this build targets — a confirmed wrong-variant lib we must not ship.
+ */
+function fusedLibStagedVariantMismatch() {
+  if (!fusedLibAlreadyStaged()) return false;
+  const sidecar = readFusedLibSidecar();
+  if (!sidecar) return false; // no provenance ≠ wrong provenance
+  return (
+    sidecar.variant !== FUSED_LIB_VARIANT ||
+    sidecar.platform !== process.platform
+  );
+}
+
+/**
+ * Whether a staged lib can be reused. A lib with a matching sidecar is reused; a
+ * sidecar-less lib (e.g. a prebuilt artifact a CI step dropped into
+ * dist/local-inference/lib) is TRUSTED and reused — we can't confirm its variant
+ * but it was deliberately staged. Only a sidecar that names a different
+ * variant/platform forces a rebuild.
+ */
+function fusedLibStagedForCurrentVariant() {
+  return fusedLibAlreadyStaged() && !fusedLibStagedVariantMismatch();
+}
+
+const FUSED_LIB_FORK_DIR = path.join(
+  PLUGIN_LOCAL_INFERENCE_PACKAGE_DIR,
+  "native",
+  "llama.cpp",
+);
+
+/**
+ * Ensure the native llama.cpp fork submodule is checked out (the fused build
+ * needs its CMakeLists). Release CI checks out with `submodules: false`, so the
+ * fork is absent; init just the one path on demand rather than requiring the
+ * workflow to fetch every submodule. Returns true if the fork is present after.
+ */
+function ensureFusedLibSubmodule() {
+  if (fs.existsSync(path.join(FUSED_LIB_FORK_DIR, "CMakeLists.txt")))
+    return true;
+  const rel = path.relative(ROOT, FUSED_LIB_FORK_DIR).split(path.sep).join("/");
+  console.log(
+    `[desktop-build] Native fork missing; initializing submodule ${rel}`,
+  );
+  // NB: no --depth/shallow here — a shallow submodule fetch fails with
+  // "Server does not allow request for unadvertised object <sha>" when the
+  // recorded gitlink commit isn't the remote tip, which is common. Reliability
+  // over speed: this path must actually produce the fork.
+  spawnSync(
+    "git",
+    ["-C", ROOT, "submodule", "update", "--init", "--recursive", rel],
+    { stdio: "inherit" },
+  );
+  return fs.existsSync(path.join(FUSED_LIB_FORK_DIR, "CMakeLists.txt"));
+}
+
+/**
+ * Build + stage the fused `libelizainference` into the desktop bundle so a
+ * COMPILED app ships with working local inference — no first-run download, no
+ * manual `build:fused-desktop`. The "auto" variant bakes CPU in and layers the
+ * host's best GPU backend (Metal on macOS; CUDA when nvcc is present; else CPU),
+ * so it works on every host.
+ *
+ * Gating:
+ *   - Reuses an already-staged lib (a prior build, or a prebuilt artifact a CI
+ *     step dropped into dist/local-inference/lib).
+ *   - Builds when explicitly asked (`--build-fused-lib` /
+ *     ELIZA_DESKTOP_BUILD_FUSED_LIB=1) OR automatically on CI release builds
+ *     (CI=true) — initializing the native submodule on demand. Off for plain
+ *     local dev builds (keeps iteration fast).
+ *   - An EXPLICIT request hard-fails if it can't produce the lib (unless
+ *     ELIZA_DESKTOP_FUSED_LIB_OPTIONAL=1). A CI auto-build is BEST-EFFORT: a
+ *     missing toolchain or a build failure warns and ships without the lib
+ *     (cloud fallback) rather than breaking the release. Set
+ *     ELIZA_DESKTOP_FUSED_LIB_REQUIRED=1 to make CI auto-builds hard-fail too.
+ */
+function stageDesktopFusedLib() {
+  const explicitlyRequested =
+    getBooleanArg(args, "build-fused-lib") ||
+    process.env.ELIZA_DESKTOP_BUILD_FUSED_LIB === "1";
+  const ciAutoBuild = process.env.CI === "true";
+  const shouldBuild = explicitlyRequested || ciAutoBuild;
+  const required =
+    (explicitlyRequested ||
+      process.env.ELIZA_DESKTOP_FUSED_LIB_REQUIRED === "1") &&
+    process.env.ELIZA_DESKTOP_FUSED_LIB_OPTIONAL !== "1";
+
+  if (
+    fusedLibStagedForCurrentVariant() &&
+    process.env.ELIZA_DESKTOP_REBUILD_FUSED_LIB !== "1"
+  ) {
+    console.log(
+      `[desktop-build] Reusing already-staged fused lib in ${FUSED_LIB_OUT_DIR} ` +
+        `(variant=${FUSED_LIB_VARIANT}, ${process.platform})`,
+    );
+    return;
+  }
+
+  // A staged lib whose sidecar names a DIFFERENT variant/platform is a confirmed
+  // wrong-variant lib — never silently reused. (A sidecar-less drop-in is trusted
+  // and was already reused above.)
+  const variantMismatch = fusedLibStagedVariantMismatch();
+  if (variantMismatch) {
+    const sidecar = readFusedLibSidecar();
+    console.warn(
+      `[desktop-build] Staged fused lib does not match this build ` +
+        `(want variant=${FUSED_LIB_VARIANT}/${process.platform}, found ` +
+        `${sidecar.variant}/${sidecar.platform}). ` +
+        `It will be rebuilt to avoid shipping a wrong-variant native lib.`,
+    );
+  }
+
+  if (!shouldBuild) {
+    if (variantMismatch) {
+      // Can't rebuild here (no toolchain requested) and the staged lib is the
+      // wrong variant — drop it so the app cleanly falls back to cloud inference
+      // instead of dlopen()-ing a mismatched backend on the device.
+      for (const name of fusedLibFilenames()) {
+        fs.rmSync(path.join(FUSED_LIB_OUT_DIR, name), { force: true });
+      }
+      fs.rmSync(FUSED_LIB_SIDECAR, { force: true });
+      console.warn(
+        "[desktop-build] Removed the mismatched fused lib; this build ships without " +
+          "local inference. Rebuild with --build-fused-lib to stage the right variant.",
+      );
+      return;
+    }
+    console.log(
+      "[desktop-build] Skipping fused libelizainference build (local-inference will be " +
+        "unavailable in this build). Enable with --build-fused-lib or " +
+        "ELIZA_DESKTOP_BUILD_FUSED_LIB=1 (CI release builds enable it automatically).",
+    );
+    return;
+  }
+
+  // Surface a hard failure for an explicit request that can't proceed; otherwise
+  // warn and ship without the lib so a release never breaks on the native build.
+  const giveUp = (reason) => {
+    if (required) {
+      fail(
+        `Cannot build the fused libelizainference for the desktop bundle: ${reason}. ` +
+          "Install the toolchain / init submodules, or set " +
+          "ELIZA_DESKTOP_FUSED_LIB_OPTIONAL=1 to ship without local inference.",
+      );
+    }
+    console.warn(
+      `[desktop-build] Skipping fused libelizainference build — ${reason}. ` +
+        "The compiled app will fall back to cloud inference.",
+    );
+  };
+
+  if (!which("cmake")) {
+    giveUp("cmake not found on PATH");
+    return;
+  }
+  if (!ensureFusedLibSubmodule()) {
+    giveUp(`native fork not available at ${FUSED_LIB_FORK_DIR}`);
+    return;
+  }
+
+  fs.mkdirSync(FUSED_LIB_OUT_DIR, { recursive: true });
+  run(
+    "node",
+    [
+      FUSED_LIB_STAGE_SCRIPT,
+      "--variant",
+      FUSED_LIB_VARIANT,
+      "--out",
+      FUSED_LIB_OUT_DIR,
+    ],
+    {
+      cwd: ROOT,
+      // A CI auto-build that fails must not abort the whole release; an explicit
+      // request is allowed to hard-fail.
+      allowFailure: !required,
+      label: `Building + staging fused libelizainference (${FUSED_LIB_VARIANT}) into the desktop bundle`,
+    },
+  );
+
+  if (!fusedLibAlreadyStaged()) {
+    giveUp("the build produced no lib in the output dir");
+    return;
+  }
+  // Record provenance so a later build with a different variant/platform won't
+  // silently reuse this lib.
+  writeFusedLibSidecar();
+}
+
 function stageDesktopBuild() {
   ensureWorkspaceCheckoutPresent();
   ensureAppDirs();
@@ -989,6 +1287,11 @@ function stageDesktopBuild() {
   ensureRootRuntimeBundle();
   ensureWorkspaceRuntimePackagesBuilt();
 
+  // Build + bundle the fused local-inference native lib so the packaged app
+  // serves local AI out of the box. Gated (see stageDesktopFusedLib) so plain
+  // dev builds stay fast; auto-built best-effort on CI release builds.
+  stageDesktopFusedLib();
+
   runBun(["run", "generate:css-strings"], {
     cwd: UI_PACKAGE_DIR,
     label: "Generating UI runtime CSS string modules",
@@ -1017,11 +1320,21 @@ function stageDesktopBuild() {
 
   ensureUiGeneratedAssets();
 
+  // Capture the moment the renderer build starts so we can prove afterward that
+  // a FRESH bundle was produced — not a stale dist silently reused (issue #9309).
+  const rendererBuildStartedAt = Date.now() - 1000;
   runBunPackageBinary("vite", ["build"], {
     cwd: APP_DIR,
     env: desktopRendererBuildEnv(),
     label: `Building renderer bundle (VITE_APP_VARIANT=${variant}, ELIZA_BUILD_VARIANT=${buildVariant})`,
   });
+  // Fail loudly if the renderer manifest is missing or predates this build (a
+  // cached/stale dist was reused) or was built for a different variant.
+  assertRendererRebuiltSince(path.join(APP_DIR, "dist"), {
+    notBefore: rendererBuildStartedAt,
+    expectVariant: buildVariant,
+    label: "desktop",
+  });
 
   runDesktopPreflight();
 

package/scripts/docker-ci-smoke.sh

@@ -69,11 +69,12 @@ BOOT_CRASH_PATTERNS=(
   'ERR_MODULE_NOT_FOUND'
   'ERR_REQUIRE_ESM'
   'MODULE_NOT_FOUND'
-  # The agent now starts under plain `node` (no tsx loader, #8837). If any
-  # workspace package shipped without a built dist, link-docker-local-app-packages.mjs
-  # rewrites its exports to ./src/*.ts, and importing that at runtime throws
-  # ERR_UNKNOWN_FILE_EXTENSION on the core boot path. Fail fast on that signature
-  # instead of waiting out the full health timeout.
+  # Defense-in-depth: the agent boots under the tsx loader (see APP_CMD_START),
+  # so .ts extensions resolve at runtime today. But if a workspace package ever
+  # shipped without a built dist, link-docker-local-app-packages.mjs rewrites its
+  # exports to ./src/*.ts, and importing that under a tsx-less or mislinked boot
+  # would throw ERR_UNKNOWN_FILE_EXTENSION on the core boot path. Fail fast on that
+  # signature instead of waiting out the full health timeout.
   'ERR_UNKNOWN_FILE_EXTENSION'
   'Unknown file extension'
   'Failed to start'
@@ -224,9 +225,7 @@ load_env_file "deploy/deploy.env"
 
 APP_IMAGE="${APP_IMAGE:-eliza/agent}"
 APP_ENTRYPOINT="${APP_ENTRYPOINT:-$AGENT_DIR/dist/bin.js}"
-# F6 (#8812): start under plain `node` — the prebuilt dist is compiled JS with
-# `.ts` specifiers rewritten to `.js`, so the tsx loader only added startup tax.
-APP_CMD_START="${APP_CMD_START:-node ${APP_ENTRYPOINT} start}"
+APP_CMD_START="${APP_CMD_START:-node --import /opt/tsx/node_modules/tsx/dist/loader.mjs ${APP_ENTRYPOINT} start}"
 APP_PORT="${APP_PORT:-2138}"
 APP_API_BIND="${APP_API_BIND:-127.0.0.1}"
 OCI_SOURCE="${OCI_SOURCE:-}"
@@ -479,11 +478,37 @@ boot_verify() {
       log "[boot-kpi] WARNING: jq or budgets.json unavailable; using default coldReadyMs budget ${budget_default}ms"
     fi
 
+    # Record runner contention alongside readyMs (#8812 item 5). Boot is
+    # single-threaded and import-bound, so a heavily loaded runner inflates
+    # readyMs; we log loadavg/cpu so a breach can be triaged, and (below) refuse
+    # to FAIL on a breach when the runner is clearly overloaded, so enforcement
+    # only catches a genuine boot-time regression — not transient runner load.
+    local load1="" cpus="" contended="false"
+    if [[ -r /proc/loadavg ]]; then
+      load1="$(cut -d' ' -f1 /proc/loadavg 2>/dev/null || true)"
+    fi
+    cpus="$(nproc 2>/dev/null || getconf _NPROCESSORS_ONLN 2>/dev/null || echo 1)"
+    log "[boot-kpi] runner loadavg(1m)=${load1:-?} cpus=${cpus}"
+    # Heavy contention = loadavg(1m) above 2x the cpu count. Float compare via
+    # awk (no bc dependency); guarded so a missing loadavg never trips it.
+    if [[ -n "$load1" && "$cpus" =~ ^[0-9]+$ ]]; then
+      if awk -v l="$load1" -v c="$cpus" 'BEGIN{exit !(l > 2*c)}' 2>/dev/null; then
+        contended="true"
+      fi
+    fi
+
     log "[boot-kpi] cold readyMs=${ready_ms} budget=${budget}"
     log "[boot-kpi] peakRss: not measured (docker stats samples instantaneously, not boot peak)"
 
     if (( ready_ms > budget )); then
       local msg="boot-kpi cold readyMs=${ready_ms} exceeded budget=${budget} (boot.coldReadyMs)"
+      if [[ "${BOOT_KPI_ENFORCE:-}" == "1" && "$contended" == "true" ]]; then
+        if [[ "${GITHUB_ACTIONS:-}" == "true" ]]; then
+          printf '::warning::%s — runner contended (loadavg %s over %s cpus), not failing\n' "$msg" "$load1" "$cpus" >&2
+        fi
+        log "[boot-kpi] WARNING (runner contended, loadavg ${load1} over ${cpus} cpus — not failing): $msg"
+        return 0
+      fi
       if [[ "${BOOT_KPI_ENFORCE:-}" == "1" ]]; then
         if [[ "${GITHUB_ACTIONS:-}" == "true" ]]; then
           printf '::error::%s\n' "$msg" >&2

package/scripts/ensure-type-package-aliases.mjs

@@ -56,7 +56,7 @@ const MATERIALIZED_TYPE_PACKAGES = [
   "three",
   "ws",
 ];
-const MATERIALIZED_PACKAGES = ["bun-types"];
+const MATERIALIZED_PACKAGES = ["bun-types", "csstype"];
 
 function collectBrokenBundledTypePackages() {
   const packageNames = new Set();

package/scripts/ios-xcframework/run-physical-device-smoke.mjs

@@ -1437,7 +1437,7 @@ char * eliza_ios_text_benchmark_run(const char * model_path, const char * mode)
     const int use_cpu = mode && strcmp(mode, "cpu") == 0;
     const char * ctx_params_cpu = "{\\"n_ctx\\":512,\\"n_batch\\":512,\\"n_ubatch\\":128,\\"no_gpu_devices\\":true,\\"n_gpu_layers\\":0,\\"flash_attn\\":false,\\"use_mmap\\":true,\\"n_threads\\":4}";
     const char * ctx_params_metal = "{\\"n_ctx\\":512,\\"n_batch\\":512,\\"n_ubatch\\":128,\\"n_gpu_layers\\":999,\\"flash_attn\\":true,\\"use_mmap\\":true,\\"n_threads\\":4}";
-    const char * completion_params = "{\\"n_predict\\":32,\\"temperature\\":0,\\"seed\\":42,\\"top_k\\":1,\\"n_threads\\":4,\\"stop\\":[\\"<|im_end|>\\"]}";
+    const char * completion_params = "{\\"n_predict\\":32,\\"temperature\\":0,\\"seed\\":42,\\"top_k\\":1,\\"n_threads\\":4,\\"stop\\":[\\"<end_of_turn>\\"]}";
     const char * prompt = "You are Eliza. Write one short benchmark sentence.";
     int64_t ctx = llama_init_context(model_path, use_cpu ? ctx_params_cpu : ctx_params_metal);
     if (ctx <= 0) {