nolo-cli 0.1.22 → 0.1.26

package/client/agentRun.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { runLocalAgentTurn } from "../agentRuntimeLocal";
+import { LOCAL_AGENT_CONFIG_MISSING_CODE } from "../agent-runtime/localLoop";
 import {
   FRONTEND_IMPLEMENTER_AGENT_KEY,
   NOLO_FULLSTACK_AGENT_KEY,
@@ -59,7 +60,7 @@ type RunAgentTurnOptions = {
   taskRunContext?: TaskRunPromptContext;
   taskRunRecorder?: (args: {
     options: RunAgentTurnOptions;
-    status: "completed" | "failed";
+    status: "running" | "completed" | "failed";
     dialogId?: string;
     resultSummary?: string;
     errorCode?: string;
@@ -69,10 +70,11 @@ type RunAgentTurnOptions = {
   fetchImpl?: typeof fetch;
 };
 
-export type RunAgentTurnResult = {
-  exitCode: number;
-  dialogId?: string;
-};
+export type RunAgentTurnResult = {
+  exitCode: number;
+  dialogId?: string;
+  streamInterrupted?: boolean;
+};
 
 type ScriptBridgeDecision = {
   hasAuthToken: boolean;
@@ -132,6 +134,15 @@ export function findServerPlatformTools(toolNames?: string[]) {
   return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
 }
 
+function resolveServerPlatformToolNames(agentConfig: any) {
+  return findServerPlatformTools([
+    ...(Array.isArray(agentConfig?.toolNames) ? agentConfig.toolNames : []),
+    ...(Array.isArray(agentConfig?.runtimeToolPolicy?.agentTools)
+      ? agentConfig.runtimeToolPolicy.agentTools
+      : []),
+  ]);
+}
+
 function normalizeAgentRef(ref?: string) {
   return ref?.trim().toLowerCase().replace(/\s+/g, " ");
 }
@@ -190,7 +201,7 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   } catch {
     return false;
   }
-  const serverTools = findServerPlatformTools(agentConfig?.toolNames);
+  const serverTools = resolveServerPlatformToolNames(agentConfig);
   if (serverTools.length === 0) return false;
   options.output.write(
     `[nolo] auto runtime: skipping local runtime because ${options.agentKey} declares server platform tools ` +
@@ -240,7 +251,7 @@ function summarizeLocalToolEvidence(events: LocalAgentToolEvent[]): TaskRunToolE
   };
 }
 
-const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 128;
+const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 512;
 
 function parseLocalToolRoundLimitError(error: unknown) {
   const message = error instanceof Error ? error.message : String(error);
@@ -249,6 +260,16 @@ function parseLocalToolRoundLimitError(error: unknown) {
   return Number(match[1]);
 }
 
+function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
+  return Boolean(
+    error &&
+      typeof error === "object" &&
+      "code" in error &&
+      (error as { code?: string; agentRef?: string }).code === LOCAL_AGENT_CONFIG_MISSING_CODE &&
+      (error as { code?: string; agentRef?: string }).agentRef === agentRef
+  );
+}
+
 function parsePositiveInteger(value: string | undefined) {
   if (!value) return null;
   const parsed = Number(value);
@@ -348,7 +369,7 @@ async function runTaskRunCli(args: {
 
 async function defaultTaskRunRecorder(args: {
   options: RunAgentTurnOptions;
-  status: "completed" | "failed";
+  status: "running" | "completed" | "failed";
   dialogId?: string;
   resultSummary?: string;
   errorCode?: string;
@@ -357,7 +378,7 @@ async function defaultTaskRunRecorder(args: {
   const context = args.options.taskRunContext;
   if (!context?.rowDbKey) return;
   const role = inferTaskRunAgentRole(args.options.agentName || args.options.agentKey);
-  if (role === "reviewer") {
+  if (role === "reviewer" && args.status !== "running") {
     await runTaskRunCli({
       options: args.options,
       cliArgs: [
@@ -415,7 +436,7 @@ async function defaultTaskRunRecorder(args: {
       ],
     });
   }
-  if (role === "reviewer") {
+  if (role === "reviewer" && args.status !== "running") {
     const reviewStatus =
       args.status === "failed" ? "blocked" : classifyTaskRunReviewStatus(args.resultSummary);
     if (reviewStatus) {
@@ -441,7 +462,7 @@ async function defaultTaskRunRecorder(args: {
 
 async function recordTaskRunOutcome(args: {
   options: RunAgentTurnOptions;
-  status: "completed" | "failed";
+  status: "running" | "completed" | "failed";
   dialogId?: string;
   resultSummary?: string;
   errorCode?: string;
@@ -566,12 +587,28 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
           options.imageUrls
         ),
         runtimeContext: {
-          surface: "cli",
-          host: "terminal",
-          runtime: "bun",
-          entrypoint: "nolo-cli",
-          capabilities: ["text-io", "streaming", "slash-commands"],
-        },
+          surface: "cli",
+          host: "terminal",
+          runtime: "bun",
+          entrypoint: "nolo-cli",
+          capabilities: ["text-io", "streaming", "slash-commands"],
+          ...(options.taskRunContext
+            ? {
+                taskRun: {
+                  rowDbKey: options.taskRunContext.rowDbKey,
+                  ...(options.taskRunContext.taskRunId
+                    ? { taskRunId: options.taskRunContext.taskRunId }
+                    : {}),
+                  ...(options.taskRunContext.workItemId
+                    ? { workItemId: options.taskRunContext.workItemId }
+                    : {}),
+                  ...(options.taskRunContext.artifactIds?.length
+                    ? { artifactIds: options.taskRunContext.artifactIds }
+                    : {}),
+                },
+              }
+            : {}),
+        },
         ...(options.continueDialogId
           ? { continueDialogId: options.continueDialogId }
           : {}),
@@ -597,7 +634,11 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
     const result = await readStreamingAgentRun(options, res);
     await recordTaskRunOutcome({
       options,
-      status: result.exitCode === 0 ? "completed" : "failed",
+      status: result.streamInterrupted
+        ? "running"
+        : result.exitCode === 0
+          ? "completed"
+          : "failed",
       dialogId: result.dialogId,
       ...(result.exitCode !== 0 ? { errorCode: "STREAM_FAILED" } : {}),
     });
@@ -642,9 +683,9 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
   };
   await recordTaskRunOutcome({
     options,
-    status: "completed",
+    status: options.background ? "running" : "completed",
     dialogId: result.dialogId,
-    resultSummary: content || undefined,
+    ...(!options.background && content ? { resultSummary: content } : {}),
   });
   return result;
 }
@@ -653,6 +694,13 @@ async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
   return runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: true });
 }
 
+async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
+  const adapter = resolveLocalRuntimeAdapter(options);
+  if (!adapter) return false;
+  const agentConfig = await adapter.loadAgentConfig(options.agentKey);
+  return Boolean(agentConfig);
+}
+
 async function runLocalAgentTurnWithAutoRoundExpansion(
   options: RunAgentTurnOptions,
   settings: { reportFailure: boolean }
@@ -747,9 +795,9 @@ async function runLocalAgentTurnForCli(
     }
     await recordTaskRunOutcome({
       options,
-      status: "completed",
+      status: options.background ? "running" : "completed",
       dialogId: result.dialogId,
-      resultSummary: content || undefined,
+      ...(!options.background && content ? { resultSummary: content } : {}),
       toolEvidence: summarizeLocalToolEvidence(toolEvents),
     });
     return { exitCode: 0, dialogId: result.dialogId };
@@ -791,15 +839,20 @@ async function readStreamingAgentRun(
     hasPrintedLabel = true;
   };
 
-  const handlePayload = (payload: any) => {
-    if (payload?.error || payload?.type === "error") {
-      throw new Error(String(payload.error || payload.message || "Agent stream failed"));
-    }
-    if (payload?.type === "done") {
-      if (typeof payload.dialogId === "string") dialogId = payload.dialogId;
-      usage = payload.usage;
-      return;
-    }
+  const handlePayload = (payload: any) => {
+    if (typeof payload?.dialogId === "string" && payload.dialogId.trim()) {
+      dialogId = payload.dialogId;
+    }
+    if (payload?.error || payload?.type === "error") {
+      throw new Error(String(payload.error || payload.message || "Agent stream failed"));
+    }
+    if (payload?.type === "done") {
+      usage = payload.usage;
+      return;
+    }
+    if (payload?.type === "dialog" || payload?.type === "status") {
+      return;
+    }
 
     const chunk =
       payload?.type === "text"
@@ -842,10 +895,18 @@ async function readStreamingAgentRun(
         .trim();
       if (raw) handlePayload(JSON.parse(raw));
     }
-  } catch (error) {
-    options.output.write(`\n[nolo] Agent stream failed: ${error instanceof Error ? error.message : String(error)}\n`);
-    return { exitCode: 1 };
-  } finally {
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (dialogId) {
+      options.output.write(
+        `\n[nolo] Agent stream transport interrupted after dialog ${dialogId} was created: ${message}\n`
+      );
+      options.output.write("[nolo] The agent run may still finish on the server; read the dialog before retrying.\n");
+      return { exitCode: 0, dialogId, streamInterrupted: true };
+    }
+    options.output.write(`\n[nolo] Agent stream failed: ${message}\n`);
+    return { exitCode: 1 };
+  } finally {
     writer.flushAll();
   }
 
@@ -883,6 +944,27 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
           ...(localResult.dialogId ? { dialogId: localResult.dialogId } : {}),
         };
       }
+      if (isMissingLocalAgentConfigError(localResult.localError, options.agentKey)) {
+        options.output.write(
+          `[nolo] Local agent config was missing; refreshing from the configured server and retrying local once.\n`
+        );
+        try {
+          const refreshed = await refreshMissingLocalAgentConfig(options);
+          if (refreshed) {
+            const retriedLocalResult = await runLocalAgentTurnWithAutoRoundExpansion(options, {
+              reportFailure: false,
+            });
+            if (retriedLocalResult.exitCode === 0) {
+              return {
+                exitCode: retriedLocalResult.exitCode,
+                ...(retriedLocalResult.dialogId ? { dialogId: retriedLocalResult.dialogId } : {}),
+              };
+            }
+          }
+        } catch {
+          // Fall through to the existing server runtime fallback below.
+        }
+      }
     }
   }
 

package/client/hybridRecordStore.test.ts

@@ -87,6 +87,48 @@ describe("CLI hybrid record store", () => {
     });
   });
 
+  test("falls back across known cluster servers on local miss and caches the first remote hit", async () => {
+    const { db, store: memory } = createMemoryDb();
+    const requests: string[] = [];
+    const hybrid = createCliHybridRecordStore({
+      db,
+      env: {
+        NOLO_SERVER: "http://127.0.0.1:38123",
+        AUTH_TOKEN: "token-1",
+      },
+      fetchImpl: async (url) => {
+        const target = String(url);
+        requests.push(target);
+        if (target.startsWith("http://127.0.0.1:38123/")) {
+          throw new Error("ConnectionRefused");
+        }
+        if (target.startsWith("https://nolo.chat/")) {
+          return Response.json({
+            data: {
+              dbKey: "agent-user-1-cluster",
+              name: "cluster remote",
+              updatedAt: "2026-05-24T00:00:00.000Z",
+            },
+          });
+        }
+        return new Response(null, { status: 404 });
+      },
+    });
+
+    await expect(hybrid.read("agent-user-1-cluster")).resolves.toMatchObject({
+      name: "cluster remote",
+      serverOrigin: "https://nolo.chat",
+    });
+    expect(requests).toEqual([
+      "http://127.0.0.1:38123/api/v1/db/read/agent-user-1-cluster",
+      "https://nolo.chat/api/v1/db/read/agent-user-1-cluster",
+    ]);
+    expect(memory.get("agent-user-1-cluster")).toMatchObject({
+      name: "cluster remote",
+      serverOrigin: "https://nolo.chat",
+    });
+  });
+
   test("keeps newer local records over stale remote records", () => {
     expect(shouldCacheRemoteRecord(
       { updatedAt: "2026-05-12T00:00:00.000Z" },

package/client/hybridRecordStore.ts

@@ -1,4 +1,5 @@
 import { DEFAULT_NOLO_SERVER_URL } from "../defaultServer";
+import { NOLO_CLUSTER_SERVERS } from "../database/config";
 import {
   createHybridRecordStore,
   shouldCacheHybridRemoteRecord,
@@ -21,6 +22,15 @@ function normalizeServer(value: string) {
   return value.trim().replace(/\/+$/, "");
 }
 
+function resolveFallbackServers(env: EnvLike) {
+  const values = [
+    env.NOLO_SERVER_URL,
+    env.BASE_URL,
+    ...NOLO_CLUSTER_SERVERS,
+  ].filter((value): value is string => typeof value === "string" && value.trim().length > 0);
+  return [...new Set(values.map(normalizeServer))];
+}
+
 function resolveAuthToken(env: EnvLike) {
   return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
 }
@@ -35,6 +45,7 @@ export function createCliHybridRecordStore(
   return createHybridRecordStore({
     db: deps.db,
     defaultServer: normalizeServer(deps.env.NOLO_SERVER || deps.env.BASE_URL || DEFAULT_NOLO_SERVER_URL),
+    fallbackServers: resolveFallbackServers(deps.env),
     authToken: resolveAuthToken(deps.env),
     fetchImpl: deps.fetchImpl,
   });

package/client/localRuntimeAdapter.test.ts

@@ -8,26 +8,22 @@ import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime adapter", () => {
   const DEFAULT_LOCAL_CODING_TOOL_NAMES = [
-    "readWorkspaceFile",
+    "listFiles",
+    "readFile",
+    "writeFile",
+    "editFile",
+    "searchFiles",
+  ];
+  const LEGACY_WRITE_LOCAL_CODING_TOOL_NAMES = [
     "writeWorkspaceFile",
-    "replaceWorkspaceText",
-    "searchWorkspace",
-    "applyPatch",
-    "gitStatus",
-    "gitDiff",
-    "gitCreateBranch",
-    "commitWorkspace",
-    "runPackageScript",
-    "startPreview",
-    "getPreviewStatus",
-    "stopPreview",
-    "releasePreview",
-    "captureVisualState",
+    "listFiles",
+    "readFile",
+    "editFile",
+    "searchFiles",
   ];
   const SHELL_LOCAL_CODING_TOOL_NAMES = [
     ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
     "execShell",
-    "execBash",
   ];
 
   function toolNamesFromRequest(request: any) {
@@ -211,6 +207,77 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
+  test("keeps local runtime runnable when the configured local server is down but a cluster server can provide agent config", async () => {
+    const memory = new Map<string, any>();
+    const requests: string[] = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_SERVER: "http://127.0.0.1:38123",
+        AUTH_TOKEN: "token-1",
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async (key) => {
+          if (!memory.has(key)) throw new Error(`not found: ${key}`);
+          return memory.get(key);
+        },
+        put: async (key, value) => {
+          memory.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") memory.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      createId: () => "01CLUSTER",
+      fetchImpl: async (url, init) => {
+        const target = String(url);
+        requests.push(target);
+        if (target === "http://127.0.0.1:38123/api/v1/db/read/agent-user-1-cluster") {
+          throw new Error("ConnectionRefused");
+        }
+        if (target === "https://nolo.chat/api/v1/db/read/agent-user-1-cluster") {
+          expect(new Headers(init?.headers).get("Authorization")).toBe("Bearer token-1");
+          return Response.json({
+            data: {
+              dbKey: "agent-user-1-cluster",
+              name: "Cluster cached",
+              prompt: "Use cached config",
+              model: "gpt-4.1-mini",
+            },
+          });
+        }
+        if (target === "http://127.0.0.1:11434/v1/chat/completions") {
+          return Response.json({
+            choices: [{ message: { content: "cluster cache ok" } }],
+          });
+        }
+        return new Response(null, { status: 404 });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "agent-user-1-cluster",
+      input: "hello",
+    });
+
+    expect(result.content).toBe("cluster cache ok");
+    expect(requests).toEqual([
+      "http://127.0.0.1:38123/api/v1/db/read/agent-user-1-cluster",
+      "https://nolo.chat/api/v1/db/read/agent-user-1-cluster",
+      "http://127.0.0.1:11434/v1/chat/completions",
+    ]);
+    expect(memory.get("agent-user-1-cluster")).toMatchObject({
+      name: "Cluster cached",
+      serverOrigin: "https://nolo.chat",
+    });
+  });
+
   test("uses agent customProviderUrl for local OpenAI-compatible requests", async () => {
     const requests: Array<{ url: string; auth: string | null; body: any }> = [];
     const store = new Map<string, any>([
@@ -353,9 +420,10 @@ describe("CLI local runtime adapter", () => {
         tool_choice: "auto",
         url: "https://api.fireworks.ai/inference/v1/chat/completions",
         provider: "fireworks",
+        agentKey: "agent-user-1-frontend",
       },
     });
-    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(requests[0])).toEqual(LEGACY_WRITE_LOCAL_CODING_TOOL_NAMES);
   });
 
   test("uses the Nolo chat proxy for platform agents even when direct provider env exists", async () => {
@@ -369,7 +437,7 @@ describe("CLI local runtime adapter", () => {
         provider: "fireworks",
         apiSource: "platform",
         useServerProxy: true,
-        tools: ["gitStatus"],
+        tools: ["readWorkspaceFile"],
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -419,6 +487,7 @@ describe("CLI local runtime adapter", () => {
       body: {
         provider: "fireworks",
         apiSource: "platform",
+        agentKey: "agent-user-1-frontend",
       },
     });
   });
@@ -573,6 +642,12 @@ describe("CLI local runtime adapter", () => {
       cwd: import.meta.dir,
       now: () => 1710000000000,
       createId: () => "01TRACE",
+      localToolExecutors: {
+        execShell: async () => ({
+          content: "stdout:\ntrace-ok\n\nexitCode: 0",
+          metadata: { exitCode: 0, timedOut: false },
+        }),
+      },
       fetchImpl: async (_url, init) => {
         const body = JSON.parse(String(init?.body));
         const hasToolResult = body.messages.some((message: any) => message.role === "tool");
@@ -586,7 +661,11 @@ describe("CLI local runtime adapter", () => {
                   type: "function",
                   function: {
                     name: "execShell",
-                    arguments: JSON.stringify({ cmd: "printf trace-ok" }),
+                    arguments: JSON.stringify({
+                      cmd: process.platform === "win32"
+                        ? "Write-Output trace-ok"
+                        : "printf trace-ok",
+                    }),
                   },
                 }],
               },
@@ -951,7 +1030,7 @@ describe("CLI local runtime adapter", () => {
       await adapter.loadAgentConfig("default-tools");
       await expect(adapter.executeTool({
         id: "call-read",
-        name: "readWorkspaceFile",
+        name: "readFile",
         arguments: JSON.stringify({ path: "README.md" }),
       })).resolves.toMatchObject({
         content: "local ok\n",
@@ -961,6 +1040,91 @@ describe("CLI local runtime adapter", () => {
     }
   });
 
+  test("exposes declared taskRun as a platform tool in local runtime requests", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-taskrun",
+          prompt: "Use taskRun.",
+          model: "gpt-4.1-mini",
+          toolNames: ["taskRun"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: "taskrun",
+      input: "read task context",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).toContain("taskRun");
+  });
+
+  test("executes declared taskRun through the server task-run bridge", async () => {
+    const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        BASE_URL: "https://us.nolo.chat",
+        AUTH_TOKEN: "machine-token",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-taskrun",
+          toolNames: ["taskRun"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (url, init) => {
+        requests.push({
+          url: String(url),
+          auth: new Headers(init?.headers).get("authorization"),
+          body: JSON.parse(String(init?.body)),
+        });
+        return Response.json({ ok: true, row: { rowId: "task-1" } });
+      },
+    });
+
+    await adapter.loadAgentConfig("taskrun");
+    const result = await adapter.executeTool({
+      id: "call-taskrun",
+      name: "taskRun",
+      arguments: JSON.stringify({
+        action: "readTaskContext",
+        dbKey: "row-user-NOLOTASKBOARD-task-1",
+      }),
+    });
+
+    expect(requests).toEqual([
+      {
+        url: "https://us.nolo.chat/api/task-run",
+        auth: "Bearer machine-token",
+        body: {
+          action: "readTaskContext",
+          dbKey: "row-user-NOLOTASKBOARD-task-1",
+        },
+      },
+    ]);
+    expect(result.content).toContain("\"ok\":true");
+    expect(result.metadata).toMatchObject({ serverPlatformTool: true });
+  });
+
   test("activates an agent-declared task worktree before running workspace tools", async () => {
     const taskWorktreeRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-worktree-"));
     const chunks: string[] = [];
@@ -992,7 +1156,7 @@ describe("CLI local runtime adapter", () => {
       await adapter.loadAgentConfig("frontend");
       const result = await adapter.executeTool({
         id: "call-read",
-        name: "readWorkspaceFile",
+        name: "readFile",
         arguments: JSON.stringify({ path: "README.md" }),
       });
 
@@ -1017,6 +1181,12 @@ describe("CLI local runtime adapter", () => {
         iterator: () => (async function* () {})(),
       },
       cwd: import.meta.dir,
+      localToolExecutors: {
+        execShell: async () => ({
+          content: import.meta.dir,
+          metadata: { exitCode: 0, timedOut: false },
+        }),
+      },
       fetchImpl: async () => Response.json({}),
     });
 
@@ -1068,7 +1238,7 @@ describe("CLI local runtime adapter", () => {
         }),
       });
 
-      expect(result.content).toBe("wrote src/app.ts");
+      expect(result.content).toBe(`wrote ${join("src", "app.ts")}`);
       expect(readFileSync(join(workspaceRoot, "src/app.ts"), "utf8")).toBe("export const cliValue = 1;\n");
     } finally {
       rmSync(workspaceRoot, { recursive: true, force: true });