fix(agent-worker): restart Metro after mobile build so preview shows the built app

Root cause of the stale mobile web preview ('Welcome to Expo' scaffold showing even
after the agent built the app): Metro boots on the scaffold BEFORE the agent edits
files, and its file-watcher never sees those edits — inotify is unreliable on the
Daytona FS (the Next.js path already force-polls via CHOKIDAR/WATCHPACK, but Metro
has no polling watcher). So Metro's module graph stays pinned to the scaffold; even
a hard refresh re-bundles from the stale server-side map. Reproduces on prod.

Fix (mobile only): after the edit stream finishes, restart the Metro dev server once.
A fresh 'expo start -c' re-crawls the workspace and reads the agent's edited files,
sidestepping the watcher entirely. Reuses existing process-replacement (startProcess
kills the old app-preview + frees port 8081) and the deterministic port-8081 preview
URL, so the client URL is unchanged. New restartMobilePreview() + a gated await before
snapshotAppBuilderWorkspace; extracted executeAppBuilderRunPath to keep complexity <=15.
Also added -c to the Expo argv (defense-in-depth, matches V1). Web/Next.js untouched.

Gate green (18/18).

Author: iamjr15

apps/agent-worker/src/durable-objects/agent-run-app-builder.ts

@@ -147,6 +147,26 @@ async function startTemplatePreview(
   return { previewUrl, expoUrl };
 }
 
+// Metro (mobile) starts BEFORE the model edits files, and its file-watcher never observes the
+// agent's Daytona uploadFile writes in the sandbox container (no watchman + unreliable inotify —
+// the same reason the Next.js path force-polls). So its in-memory file-map keeps bundling the
+// scaffold even after the counter lands on disk, and a browser hard-refresh just re-bundles from
+// that stale map. Restarting the dev server once the edit stream completes makes a fresh Metro
+// process re-crawl the workspace and bundle the finished app. startProcess reuses the "app-preview"
+// slot (it kills the old process + frees port 8081), and the port-8081 preview URL is deterministic,
+// so the restart is transparent to the client. Mobile only — web/Next.js hot-reloads via polling.
+export async function restartMobilePreview(
+  options: Pick<RunAppBuilderOptions, "append" | "env" | "logger" | "sandbox" | "setRunStage">,
+): Promise<void> {
+  const { append, env, logger, sandbox, setRunStage } = options;
+  setRunStage("Reloading the preview.");
+  const { expoUrl, previewUrl } = await startExpoDevServer(env, sandbox, logger);
+  await append({
+    type: "data-sandbox-status",
+    data: { v: 1, status: "ready", previewUrl, ...(expoUrl ? { expoUrl } : {}) },
+  });
+}
+
 // First import run only: clone the public GitHub repo over the empty workspace,
 // drop the one-shot marker, best-effort install, and hand control to the agent
 // without auto-starting a dev server (framework/port are unknowable). Failure
@@ -415,11 +435,15 @@ async function startExpoDevServer(
       // build as a real web page at `/` (iframe-renderable in the Computer panel),
       // while the SAME server keeps answering exp:// manifests for Expo Go — so we
       // get both the in-panel preview and the QR from one process on port 8081.
+      // `-c` clears Metro's transform/file-map cache on start (boolean flag, order-
+      // independent among the other flags): harmless on the initial boot, and what
+      // makes the post-edit restart (restartMobilePreview) re-crawl from a clean slate.
       command: [
         "pnpm",
         "exec",
         "expo",
         "start",
+        "-c",
         "--web",
         "--host",
         "lan",

apps/agent-worker/src/durable-objects/agent-run.ts

@@ -12,6 +12,7 @@ import {
 } from "../streaming/ui-message-stream";
 import { emitRunAbandoned } from "./agent-run-abandonment";
 import {
+  restartMobilePreview,
   restoreBestEffortSnapshot,
   runAppBuilder,
   snapshotAppBuilderWorkspace,
@@ -510,48 +511,69 @@ export class AgentRun extends DurableObject<AgentRunEnv> {
       input.projectMode === "app-builder-mobile" ||
       isAppBuilderRequest(input.messageText)
     ) {
-      await warmSandbox(sandbox, logger);
-      if (this.isRunCanceled()) {
-        return "completed";
-      }
-      const { agentContextNote } = await runAppBuilder({
+      return this.executeAppBuilderRunPath(input, sandbox, logger, abortSignal);
+    }
+    await streamMastraRunWithFallback(this.streamDriverDeps(), {
+      abortSignal,
+      input,
+      logger,
+      sandbox,
+    });
+    if (this.isRunCanceled()) {
+      return "completed";
+    }
+    return "continue";
+  }
+
+  private async executeAppBuilderRunPath(
+    input: StartRunInput,
+    sandbox: ProjectSandboxStub,
+    logger: ReturnType<typeof createLogger>,
+    abortSignal: AbortSignal,
+  ): Promise<"completed" | "continue"> {
+    await warmSandbox(sandbox, logger);
+    if (this.isRunCanceled()) {
+      return "completed";
+    }
+    const { agentContextNote } = await runAppBuilder({
+      append: (chunk) => this.append(chunk),
+      env: this.env,
+      input,
+      logger,
+      sandbox,
+      setRunStage: (stage) => this.setRunStage(stage),
+    });
+    if (this.isRunCanceled()) {
+      return "completed";
+    }
+    await streamMastraRunWithFallback(this.streamDriverDeps(), {
+      abortSignal,
+      ...(agentContextNote === undefined ? {} : { agentContextNote }),
+      input,
+      logger,
+      sandbox,
+    });
+    if (this.isRunCanceled()) {
+      return "completed";
+    }
+    // Mobile Metro can't watch the model's sandbox file edits, so restart it once the edit
+    // stream is done to re-crawl the finished app onto the (unchanged) preview URL. Web/Next.js
+    // hot-reloads via polling and needs no restart.
+    if (input.projectMode === "app-builder-mobile") {
+      await restartMobilePreview({
         append: (chunk) => this.append(chunk),
         env: this.env,
-        input,
         logger,
         sandbox,
         setRunStage: (stage) => this.setRunStage(stage),
       });
-      if (this.isRunCanceled()) {
-        return "completed";
-      }
-      await streamMastraRunWithFallback(this.streamDriverDeps(), {
-        abortSignal,
-        ...(agentContextNote === undefined ? {} : { agentContextNote }),
-        input,
-        logger,
-        sandbox,
-      });
-      if (this.isRunCanceled()) {
-        return "completed";
-      }
-      await snapshotAppBuilderWorkspace({
-        env: this.env,
-        input,
-        logger,
-        sandbox,
-      });
-      return "continue";
     }
-    await streamMastraRunWithFallback(this.streamDriverDeps(), {
-      abortSignal,
+    await snapshotAppBuilderWorkspace({
+      env: this.env,
       input,
       logger,
       sandbox,
     });
-    if (this.isRunCanceled()) {
-      return "completed";
-    }
     return "continue";
   }