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

package/scripts/lib/agent-source-watcher.mjs

@@ -0,0 +1,174 @@
+/**
+ * Agent source hot-reload watcher.
+ *
+ * Watches the backend `<pkg>/src` dirs (the TypeScript the dev API child loads via
+ * the `eliza-source` condition) and fires a debounced callback when real code
+ * changes. Watching each `<pkg>/src` dir directly — never `dist/`, `node_modules/`,
+ * or build output — means concurrent package builds rewriting `dist/` generate
+ * no events here. That decoupling is the whole point: the old `node --watch`
+ * followed imports into `dist/` and reloaded mid-build, so it had to be
+ * disabled; this never does.
+ *
+ * dev-ui.mjs wires `onChange` to the API supervisor's `restart()`.
+ */
+
+import { existsSync, readdirSync, watch } from "node:fs";
+import path from "node:path";
+
+// Pure-frontend packages are served + HMR'd by Vite and are NOT loaded by the
+// API child, so editing them must not bounce the agent.
+export const HOT_RELOAD_FRONTEND_PACKAGES = new Set([
+  "ui",
+  "app",
+  "cloud-frontend",
+  "os-homepage",
+  "homepage",
+  "docs",
+  "docs-elizacloud-redirect",
+  "tui",
+  "robot",
+  "os",
+]);
+
+// Only hand-written agent source: .ts/.tsx/.mts/.cts + .json. Compiled `.js`
+// is deliberately NOT matched — this monorepo emits compiled `.js`/`.d.ts`
+// shadows next to `.ts` source, and reacting to those would bounce the agent on
+// every build. `.d.ts` (declaration emit) is excluded explicitly since it ends
+// in `.ts`.
+export const HOT_RELOAD_CODE_FILE = /\.(?:tsx?|mts|cts|json)$/;
+export const HOT_RELOAD_DECLARATION = /\.d\.[cm]?ts$/;
+export const HOT_RELOAD_TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
+export const HOT_RELOAD_IGNORED_SEGMENT =
+  /(?:^|[/\\])(?:dist|node_modules|\.turbo|\.git|coverage|__tests__|\.vite|build|generated)(?:[/\\]|$)/;
+export const HOT_RELOAD_DEBOUNCE_MS = 350;
+
+/**
+ * Collect the `<group>/<pkg>/src` dirs whose changes should reload the agent.
+ * Skips pure-frontend packages (Vite owns those) and any package without a
+ * `src/` dir.
+ *
+ * @param {string} root Repo root that holds `packages/` and `plugins/`.
+ * @returns {string[]} Absolute `<pkg>/src` dirs to watch.
+ */
+export function collectAgentSourceDirs(root) {
+  const dirs = [];
+  for (const group of ["packages", "plugins"]) {
+    const groupDir = path.join(root, group);
+    let entries;
+    try {
+      entries = readdirSync(groupDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (
+        group === "packages" &&
+        HOT_RELOAD_FRONTEND_PACKAGES.has(entry.name)
+      ) {
+        continue;
+      }
+      const srcDir = path.join(groupDir, entry.name, "src");
+      if (existsSync(srcDir)) dirs.push(srcDir);
+    }
+  }
+  return dirs;
+}
+
+/**
+ * Whether a watch event for `absPath` should trigger a reload. A null/empty
+ * path (some platforms omit the filename) is treated as reloadable so we never
+ * miss a real change. Build output, deps, generated, and test/coverage dirs are
+ * ignored, as are declaration (`.d.ts`) and test/spec files; only hand-written
+ * source (ts/tsx/mts/cts/json) qualifies.
+ *
+ * @param {string | null | undefined} absPath
+ * @returns {boolean}
+ */
+export function isReloadableChangePath(absPath) {
+  if (!absPath) return true;
+  if (HOT_RELOAD_IGNORED_SEGMENT.test(absPath)) return false;
+  if (HOT_RELOAD_DECLARATION.test(absPath)) return false;
+  if (HOT_RELOAD_TEST_FILE.test(absPath)) return false;
+  return HOT_RELOAD_CODE_FILE.test(absPath);
+}
+
+/**
+ * Start watching the agent source dirs. Returns a handle with the number of
+ * dirs watched and a `close()`.
+ *
+ * @param {Object} params
+ * @param {string} params.root Repo root.
+ * @param {(relPath: string, changedCount: number) => void} params.onChange
+ *   Debounced; receives one sample path (relative to `root`, or "source" when
+ *   the filename is unknown) and the number of DISTINCT files that changed in
+ *   the window — so the caller can ignore bulk rewrites (a git reset / checkout
+ *   / build touches many files at once; a human edit touches one or a few).
+ * @param {(dir: string, err: Error) => void} [params.onError] Per-dir watch
+ *   setup failure (e.g. a platform without recursive watch).
+ * @param {number} [params.debounceMs]
+ * @returns {{ count: number, close: () => void }}
+ */
+export function startAgentSourceWatcher({
+  root,
+  onChange,
+  onError,
+  debounceMs = HOT_RELOAD_DEBOUNCE_MS,
+}) {
+  const dirs = collectAgentSourceDirs(root);
+  /** @type {import("node:fs").FSWatcher[]} */
+  const watchers = [];
+  /** @type {ReturnType<typeof setTimeout> | null} */
+  let debounce = null;
+  /** Distinct changed paths accumulated in the current debounce window. */
+  const pendingFiles = new Set();
+  let pendingSample = null;
+
+  const fire = (absPath) => {
+    if (absPath && !isReloadableChangePath(absPath)) return;
+    if (absPath) {
+      pendingFiles.add(absPath);
+      pendingSample = absPath;
+    }
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(() => {
+      const count = pendingFiles.size;
+      const sample = pendingSample;
+      pendingFiles.clear();
+      pendingSample = null;
+      debounce = null;
+      onChange(sample ? path.relative(root, sample) : "source", count);
+    }, debounceMs);
+    debounce.unref?.();
+  };
+
+  for (const dir of dirs) {
+    try {
+      const fsWatcher = watch(dir, { recursive: true }, (_event, filename) => {
+        fire(filename ? path.join(dir, filename.toString()) : null);
+      });
+      // A dir vanishing mid-build (clean step) must not crash the dev process.
+      fsWatcher.on("error", () => {});
+      watchers.push(fsWatcher);
+    } catch (err) {
+      onError?.(dir, err);
+    }
+  }
+
+  return {
+    count: dirs.length,
+    close() {
+      if (debounce) {
+        clearTimeout(debounce);
+        debounce = null;
+      }
+      for (const fsWatcher of watchers) {
+        try {
+          fsWatcher.close();
+        } catch {
+          // already closed
+        }
+      }
+    },
+  };
+}

package/scripts/lib/agent-source-watcher.test.mjs

@@ -0,0 +1,184 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  collectAgentSourceDirs,
+  isReloadableChangePath,
+  startAgentSourceWatcher,
+} from "./agent-source-watcher.mjs";
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitUntil(predicate, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (predicate()) return true;
+    await delay(40);
+  }
+  return predicate();
+}
+
+describe("collectAgentSourceDirs", () => {
+  let root = null;
+  afterEach(() => {
+    if (root) rmSync(root, { recursive: true, force: true });
+    root = null;
+  });
+
+  it("includes backend packages + all plugins, excludes frontend + src-less dirs", () => {
+    root = mkdtempSync(path.join(tmpdir(), "agent-watch-"));
+    const mk = (...p) => mkdirSync(path.join(root, ...p), { recursive: true });
+    mk("packages", "core", "src");
+    mk("packages", "agent", "src");
+    mk("packages", "ui", "src"); // frontend → excluded
+    mk("packages", "app", "src"); // frontend → excluded
+    mk("packages", "no-src"); // has no src → excluded
+    mk("plugins", "plugin-app-control", "src");
+    mk("plugins", "plugin-x", "src");
+
+    const dirs = collectAgentSourceDirs(root)
+      .map((d) => path.relative(root, d).split(path.sep).join("/"))
+      .sort();
+    expect(dirs).toEqual([
+      "packages/agent/src",
+      "packages/core/src",
+      "plugins/plugin-app-control/src",
+      "plugins/plugin-x/src",
+    ]);
+  });
+
+  it("returns [] when packages/ and plugins/ are absent", () => {
+    root = mkdtempSync(path.join(tmpdir(), "agent-watch-empty-"));
+    expect(collectAgentSourceDirs(root)).toEqual([]);
+  });
+});
+
+describe("isReloadableChangePath", () => {
+  it("reloads for hand-written TS source + json the agent loads", () => {
+    for (const p of [
+      "/r/plugins/plugin-app-control/src/actions/views.ts",
+      "/r/packages/agent/src/api/server.ts",
+      "/r/packages/core/src/runtime/x.tsx",
+      "/r/packages/core/src/runtime/y.mts",
+      "/r/plugins/p/src/registry.json",
+    ]) {
+      expect(isReloadableChangePath(p)).toBe(true);
+    }
+  });
+
+  it("does NOT react to compiled .js / .d.ts shadows next to source", () => {
+    // This monorepo emits .js/.d.ts into src/; reacting would bounce the agent
+    // on every build.
+    for (const p of [
+      "/r/packages/core/src/runtime/views.js",
+      "/r/packages/core/src/runtime/views.mjs",
+      "/r/packages/core/src/runtime/views.d.ts",
+      "/r/packages/core/src/runtime/views.d.mts",
+    ]) {
+      expect(isReloadableChangePath(p)).toBe(false);
+    }
+  });
+
+  it("ignores build output, deps, generated, and test/coverage dirs", () => {
+    for (const p of [
+      "/r/packages/core/dist/index.ts",
+      "/r/packages/core/src/node_modules/x/y.ts",
+      "/r/packages/core/src/__tests__/a.ts",
+      "/r/packages/core/src/generated/data.ts",
+      "/r/packages/core/.turbo/log.json",
+      "/r/packages/core/coverage/lcov.ts",
+    ]) {
+      expect(isReloadableChangePath(p)).toBe(false);
+    }
+  });
+
+  it("ignores co-located test/spec files and non-code files", () => {
+    for (const p of [
+      "/r/packages/core/src/views.test.ts",
+      "/r/packages/core/src/views.spec.tsx",
+      "/r/packages/core/src/readme.md",
+      "/r/packages/core/src/styles.css",
+    ]) {
+      expect(isReloadableChangePath(p)).toBe(false);
+    }
+  });
+
+  it("treats an unknown (null/undefined) filename as reloadable", () => {
+    expect(isReloadableChangePath(null)).toBe(true);
+    expect(isReloadableChangePath(undefined)).toBe(true);
+  });
+});
+
+describe("startAgentSourceWatcher (integration)", () => {
+  let root = null;
+  let handle = null;
+  afterEach(() => {
+    if (handle) handle.close();
+    handle = null;
+    if (root) rmSync(root, { recursive: true, force: true });
+    root = null;
+  });
+
+  it("fires onChange (debounced) for a real backend src edit", async () => {
+    root = mkdtempSync(path.join(tmpdir(), "agent-watch-int-"));
+    const mk = (...p) => mkdirSync(path.join(root, ...p), { recursive: true });
+    mk("plugins", "plugin-app-control", "src", "actions");
+    mk("packages", "ui", "src"); // frontend → not among watched dirs
+
+    const calls = [];
+    handle = startAgentSourceWatcher({
+      root,
+      debounceMs: 60,
+      onChange: (rel, count) => calls.push({ rel, count }),
+    });
+    // Only the plugin src is watched; the frontend package is excluded.
+    expect(handle.count).toBe(1);
+
+    await delay(200); // let the OS watcher arm before the first write
+    writeFileSync(
+      path.join(root, "plugins/plugin-app-control/src/actions/views.ts"),
+      "export const x = 1;\n",
+    );
+
+    const fired = await waitUntil(() => calls.length > 0, 4000);
+    expect(fired).toBe(true);
+    expect(calls.some((c) => c.rel.includes("views.ts"))).toBe(true);
+    // A single edit reports a small changed-count (the bulk guard keys on this).
+    expect(calls.every((c) => c.count <= 2)).toBe(true);
+  });
+
+  it("reports a high changed-count for a bulk rewrite (so callers can skip it)", async () => {
+    root = mkdtempSync(path.join(tmpdir(), "agent-watch-bulk-"));
+    const srcDir = path.join(root, "plugins", "plugin-x", "src");
+    mkdirSync(srcDir, { recursive: true });
+    for (let i = 0; i < 20; i++) {
+      writeFileSync(path.join(srcDir, `mod-${i}.ts`), `export const v${i}=0;\n`);
+    }
+
+    const calls = [];
+    handle = startAgentSourceWatcher({
+      root,
+      debounceMs: 300,
+      onChange: (rel, count) => calls.push({ rel, count }),
+    });
+    expect(handle.count).toBe(1);
+
+    await delay(200);
+    // Simulate a reset/checkout: many files rewritten in one burst.
+    for (let i = 0; i < 20; i++) {
+      writeFileSync(
+        path.join(srcDir, `mod-${i}.ts`),
+        `export const v${i}=1;\n`,
+      );
+      await delay(5);
+    }
+
+    const fired = await waitUntil(() => calls.length > 0, 4000);
+    expect(fired).toBe(true);
+    // macOS can coalesce fs.watch events, but burst rewrites still report more
+    // than the default bulk threshold used by dev-ui.
+    expect(Math.max(...calls.map((c) => c.count))).toBeGreaterThan(4);
+  });
+});

package/scripts/lib/api-supervisor.mjs

@@ -3,13 +3,17 @@
  *
  * Both `dev-ui.mjs` and `dev-platform.mjs` need to keep the API server alive
  * across `process.exit(0)` (RESTART action), `process.exit(75)` (CLI runner
- * restart exit code), and `bun --watch` reloads — but stop trying when the
- * server keeps exiting in a tight window (a real crash that needs a human).
+ * restart exit code), and intentional reloads — but stop trying when the server
+ * keeps exiting in a tight window (a real crash that needs a human).
  *
  * The supervisor is unaware of how the API is spawned; callers pass a
  * `spawnChild()` factory that returns a node ChildProcess. The factory is
  * called once per launch, including relaunches.
  *
+ * `restart()` lets a source watcher bounce the running child for a hot reload:
+ * the kill it triggers is classified as intentional, so it relaunches
+ * immediately and never counts toward the crash streak.
+ *
  * Defaults:
  *   - 10s rolling window
  *   - 5 restarts permitted in that window before giving up
@@ -19,6 +23,7 @@
 const DEFAULT_WINDOW_MS = 10_000;
 const DEFAULT_LIMIT = 5;
 const DEFAULT_RESPAWN_DELAY_MS = 400;
+const DEFAULT_KILL_ESCALATE_MS = 4_000;
 
 /**
  * @typedef {Object} ApiSupervisorOptions
@@ -35,6 +40,9 @@ const DEFAULT_RESPAWN_DELAY_MS = 400;
  *   trigger shutdown.
  * @property {() => boolean} isShuttingDown
  *   Returns true while the parent process is in shutdown. Suppresses relaunch.
+ * @property {(child: import("node:child_process").ChildProcess, signal: "SIGTERM" | "SIGKILL") => void} [terminate]
+ *   How to kill a child for an intentional `restart()`. Defaults to
+ *   `child.kill(signal)`; callers that spawn process trees pass a tree-killer.
  * @property {(message: string) => void} [log] Defaults to `console.log`.
  * @property {(message: string) => void} [warn] Defaults to `console.error`.
  * @property {number} [windowMs] Default 10_000.
@@ -52,6 +60,13 @@ export function createApiSupervisor(opts) {
     onExit,
     onGiveUp,
     isShuttingDown,
+    terminate = (child, signal) => {
+      try {
+        child.kill(signal);
+      } catch {
+        // child already gone — nothing to signal.
+      }
+    },
     log = console.log.bind(console),
     warn = console.error.bind(console),
     windowMs = DEFAULT_WINDOW_MS,
@@ -63,14 +78,45 @@ export function createApiSupervisor(opts) {
   let lastExitAt = 0;
   /** @type {ReturnType<typeof setTimeout> | null} */
   let pendingRespawn = null;
+  /** @type {import("node:child_process").ChildProcess | null} */
+  let currentChild = null;
+  /** When true, the next exit is a hot reload, not a crash. */
+  let intentionalRestart = false;
+  /** @type {ReturnType<typeof setTimeout> | null} */
+  let killEscalation = null;
+
+  function clearKillEscalation() {
+    if (killEscalation) {
+      clearTimeout(killEscalation);
+      killEscalation = null;
+    }
+  }
+
+  function scheduleRelaunch() {
+    pendingRespawn = setTimeout(() => {
+      pendingRespawn = null;
+      if (!isShuttingDown()) launch();
+    }, respawnDelayMs);
+  }
 
   function launch() {
     const child = spawnChild();
+    currentChild = child;
     if (onSpawn) onSpawn(child);
     child.on("exit", (code) => {
       if (onExit) onExit(child);
+      if (child === currentChild) currentChild = null;
+      clearKillEscalation();
       if (isShuttingDown()) return;
 
+      // Intentional hot reload (a source change). Relaunch promptly without
+      // touching the crash streak — this is expected, not a failure.
+      if (intentionalRestart) {
+        intentionalRestart = false;
+        scheduleRelaunch();
+        return;
+      }
+
       const now = Date.now();
       streak = now - lastExitAt < windowMs ? streak + 1 : 1;
       lastExitAt = now;
@@ -87,15 +133,11 @@ export function createApiSupervisor(opts) {
 
       // The agent's RESTART action and `/api/restart` both bounce the server
       // with `process.exit(0)`; the CLI runner uses 75 as the dedicated
-      // restart exit code; Bun's `--watch` reload also exits cleanly. Treat
-      // any non-shutdown exit as "please restart me" and re-spawn.
+      // restart exit code. Treat any non-shutdown exit as "please restart me".
       log(
         `API exited with code ${code} — relaunching (attempt ${streak}/${limit})…`,
       );
-      pendingRespawn = setTimeout(() => {
-        pendingRespawn = null;
-        if (!isShuttingDown()) launch();
-      }, respawnDelayMs);
+      scheduleRelaunch();
     });
     return child;
   }
@@ -104,12 +146,39 @@ export function createApiSupervisor(opts) {
     start() {
       return launch();
     },
-    /** Cancel any pending relaunch (e.g. during shutdown). */
+    /**
+     * Bounce the running API child for a hot reload. No-op during shutdown.
+     * Safe to call repeatedly (e.g. from a debounced watcher) — overlapping
+     * calls collapse onto the one in-flight kill.
+     */
+    restart() {
+      if (isShuttingDown()) return;
+      const child = currentChild;
+      if (!child) {
+        // Already between processes — a relaunch is queued (or will be). Make
+        // sure one is actually pending so a restart() in the gap isn't lost.
+        if (!pendingRespawn) launch();
+        return;
+      }
+      // An intentional reload is not a crash — reset the streak so a burst of
+      // edits can never trip the crash-loop give-up.
+      streak = 0;
+      if (intentionalRestart) return; // a kill is already in flight
+      intentionalRestart = true;
+      terminate(child, "SIGTERM");
+      killEscalation = setTimeout(() => {
+        killEscalation = null;
+        if (currentChild === child) terminate(child, "SIGKILL");
+      }, DEFAULT_KILL_ESCALATE_MS);
+      killEscalation.unref?.();
+    },
+    /** Cancel any pending relaunch / kill escalation (e.g. during shutdown). */
     cancelPendingRespawn() {
       if (pendingRespawn) {
         clearTimeout(pendingRespawn);
         pendingRespawn = null;
       }
+      clearKillEscalation();
     },
   };
 }

package/scripts/lib/api-supervisor.test.mjs

@@ -0,0 +1,121 @@
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { createApiSupervisor } from "./api-supervisor.mjs";
+
+function makeChild() {
+  const child = new EventEmitter();
+  child.kill = vi.fn();
+  return child;
+}
+
+function setup(overrides = {}) {
+  const spawned = [];
+  const terminate = vi.fn();
+  const onGiveUp = vi.fn();
+  let shuttingDown = false;
+  const sup = createApiSupervisor({
+    spawnChild: () => {
+      const child = makeChild();
+      spawned.push(child);
+      return child;
+    },
+    onGiveUp,
+    isShuttingDown: () => shuttingDown,
+    terminate,
+    log: () => {},
+    warn: () => {},
+    respawnDelayMs: 10,
+    ...overrides,
+  });
+  return {
+    sup,
+    spawned,
+    terminate,
+    onGiveUp,
+    setShutdown: (value) => {
+      shuttingDown = value;
+    },
+    last: () => spawned[spawned.length - 1],
+  };
+}
+
+describe("createApiSupervisor", () => {
+  beforeEach(() => vi.useFakeTimers());
+  afterEach(() => vi.useRealTimers());
+
+  it("relaunches after an unintentional exit", () => {
+    const { sup, spawned } = setup();
+    sup.start();
+    expect(spawned).toHaveLength(1);
+    spawned[0].emit("exit", 1);
+    vi.advanceTimersByTime(20);
+    expect(spawned).toHaveLength(2);
+  });
+
+  it("gives up after exceeding the crash limit within the window", () => {
+    const { sup, onGiveUp, last } = setup({ limit: 3, windowMs: 10_000 });
+    sup.start();
+    for (let i = 0; i < 5; i++) {
+      last().emit("exit", 1);
+      vi.advanceTimersByTime(20);
+    }
+    expect(onGiveUp).toHaveBeenCalled();
+  });
+
+  it("restart() bounces the child WITHOUT ever counting as a crash", () => {
+    const { sup, spawned, terminate, onGiveUp } = setup({ limit: 3 });
+    sup.start();
+    // Far more intentional reloads than the crash limit, in a tight window.
+    for (let i = 0; i < 12; i++) {
+      const before = spawned.length;
+      sup.restart();
+      expect(terminate).toHaveBeenLastCalledWith(
+        spawned[before - 1],
+        "SIGTERM",
+      );
+      spawned[before - 1].emit("exit", 0); // child honors SIGTERM
+      vi.advanceTimersByTime(20);
+      expect(spawned).toHaveLength(before + 1);
+    }
+    expect(onGiveUp).not.toHaveBeenCalled();
+  });
+
+  it("collapses overlapping restart() calls onto one in-flight kill", () => {
+    const { sup, spawned, terminate } = setup();
+    sup.start();
+    sup.restart();
+    sup.restart();
+    sup.restart();
+    expect(terminate).toHaveBeenCalledTimes(1);
+    spawned[0].emit("exit", 0);
+    vi.advanceTimersByTime(20);
+    expect(spawned).toHaveLength(2);
+  });
+
+  it("escalates to SIGKILL when the child ignores SIGTERM", () => {
+    const { sup, spawned, terminate } = setup();
+    sup.start();
+    sup.restart();
+    expect(terminate).toHaveBeenCalledWith(spawned[0], "SIGTERM");
+    vi.advanceTimersByTime(4000);
+    expect(terminate).toHaveBeenCalledWith(spawned[0], "SIGKILL");
+  });
+
+  it("restart() is a no-op during shutdown", () => {
+    const { sup, terminate, setShutdown } = setup();
+    sup.start();
+    setShutdown(true);
+    sup.restart();
+    expect(terminate).not.toHaveBeenCalled();
+  });
+
+  it("does not relaunch when the child exits during shutdown", () => {
+    const { sup, spawned, setShutdown } = setup();
+    sup.start();
+    setShutdown(true);
+    spawned[0].emit("exit", 0);
+    vi.advanceTimersByTime(20);
+    expect(spawned).toHaveLength(1);
+  });
+});

package/scripts/lib/app-dir.mjs

@@ -10,35 +10,21 @@ function firstExistingPackage(candidates) {
 }
 
 export function resolveMainAppDir(repoRoot, appName = "app") {
-  const cwd = path.resolve(process.cwd());
-  const elizaRoot = path.join(repoRoot, "eliza");
-  const cwdIsInsideNestedEliza =
-    hasPackageJson(elizaRoot) &&
-    (cwd === path.resolve(elizaRoot) ||
-      cwd.startsWith(`${path.resolve(elizaRoot)}${path.sep}`));
-
   const isOuterMonorepo = hasPackageJson(path.join(repoRoot, "eliza"));
   if (appName === "app") {
     const localCandidates = [
       path.join(repoRoot, "packages", "app"),
       path.join(repoRoot, "apps", "app"),
     ];
-    const outerCandidates = [
-      path.join(repoRoot, "eliza", "packages", "app"),
-      path.join(repoRoot, "eliza", "apps", "app"),
-      path.join(repoRoot, "apps", "app"),
-    ];
     return firstExistingPackage(
-      isOuterMonorepo && !cwdIsInsideNestedEliza
+      isOuterMonorepo
         ? [
             path.join(repoRoot, "apps", "app"),
             path.join(repoRoot, "packages", "app"),
             path.join(repoRoot, "eliza", "packages", "app"),
             path.join(repoRoot, "eliza", "apps", "app"),
           ]
-        : isOuterMonorepo
-          ? outerCandidates
-          : localCandidates,
+        : localCandidates,
     );
   }