nolo-cli 0.1.23 → 0.1.26

package/cliEnvHelpers.ts

@@ -0,0 +1,44 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import { NOLO_CLUSTER_SERVERS } from "./database/config";
+
+export type EnvLike = Record<string, string | undefined>;
+
+export function resolveServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+}
+
+export function resolveServerCandidates(env: EnvLike, preferred?: string | null) {
+  const values = [
+    preferred?.trim(),
+    env.NOLO_SERVER,
+    env.BASE_URL,
+    env.NOLO_SERVER_URL,
+    DEFAULT_NOLO_SERVER_URL,
+    ...NOLO_CLUSTER_SERVERS,
+  ];
+  return [...new Set(
+    values
+      .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+      .map((value) => value.replace(/\/+$/, ""))
+  )];
+}
+
+export function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || "";
+}
+
+export function parseUserIdFromAuthToken(token: string) {
+  const payload = token.trim().split(".")[0];
+  if (!payload) return "";
+  try {
+    const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+    return typeof parsed?.userId === "string" ? parsed.userId : "";
+  } catch {
+    return "";
+  }
+}
+
+export function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}

package/client/agentRun.test.ts

@@ -45,7 +45,7 @@ describe("cli agent run client", () => {
       "queryTableRows",
       "updateTableRow",
     ]);
-    expect(findServerPlatformTools(["readWorkspaceFile", "gitStatus"])).toEqual([]);
+    expect(findServerPlatformTools(["readWorkspaceFile", "execShell"])).toEqual([]);
   });
 
   test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
@@ -84,15 +84,15 @@ describe("cli agent run client", () => {
           agentKey: "agent-pub-test",
           userInput: "hello",
           continueDialogId: "dialog-existing",
-          runtimeContext: {
-            surface: "cli",
-            host: "terminal",
-            runtime: "bun",
-            entrypoint: "nolo-cli",
-            capabilities: ["text-io", "streaming", "slash-commands"],
-          },
-          stream: true,
-        },
+          runtimeContext: {
+            surface: "cli",
+            host: "terminal",
+            runtime: "bun",
+            entrypoint: "nolo-cli",
+            capabilities: ["text-io", "streaming", "slash-commands"],
+          },
+          stream: true,
+        },
       },
     ]);
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
@@ -463,7 +463,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["gitStatus"],
+          toolNames: ["readWorkspaceFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -476,9 +476,9 @@ describe("cli agent run client", () => {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: "call-status",
+                  id: "call-read",
                   type: "function",
-                  function: { name: "gitStatus", arguments: "{}" },
+                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -491,8 +491,8 @@ describe("cli agent run client", () => {
     });
 
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
-    expect(output.text()).toContain("[nolo:tool] round 1 -> gitStatus (call-status)");
-    expect(output.text()).toContain("[nolo:tool] round 1 <- gitStatus (call-status)");
+    expect(output.text()).toContain("[nolo:tool] round 1 -> readWorkspaceFile (call-read)");
+    expect(output.text()).toContain("[nolo:tool] round 1 <- readWorkspaceFile (call-read)");
   });
 
   test("passes local tool evidence to task-run writeback", async () => {
@@ -524,7 +524,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["gitStatus"],
+          toolNames: ["readWorkspaceFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -537,9 +537,9 @@ describe("cli agent run client", () => {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: "call-status",
+                  id: "call-read",
                   type: "function",
-                  function: { name: "gitStatus", arguments: "{}" },
+                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -554,7 +554,7 @@ describe("cli agent run client", () => {
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
     expect(writebacks).toHaveLength(1);
     expect(writebacks[0].toolEvidence).toEqual({
-      toolsUsed: ["gitStatus"],
+      toolsUsed: ["readWorkspaceFile"],
       summary: {
         callCount: 1,
         resultCount: 1,
@@ -660,6 +660,110 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("frontend -> working locally");
   });
 
+  test("auto mode refreshes missing local agent config and retries local once before HTTP", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let loadAgentConfigCalls = 0;
+    let localCompletions = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence"],
+        loadAgentConfig: async (agentRef) => {
+          loadAgentConfigCalls += 1;
+          if (loadAgentConfigCalls < 3) return null;
+          return {
+            key: agentRef,
+            name: "Frontend",
+            prompt: "Fix UI",
+            model: "fake-local",
+          };
+        },
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-auto-local-retried" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            localCompletions += 1;
+            return { content: "auto local after refresh", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-auto-local-retried" });
+    expect(loadAgentConfigCalls).toBe(4);
+    expect(localCompletions).toBe(1);
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).toContain("refreshing from the configured server and retrying local once");
+    expect(output.text().match(/working locally/g)?.length).toBe(2);
+  });
+
+  test("auto mode falls back to HTTP when local agent config is still missing after one refresh retry", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: Array<{ url: string; body: any }> = [];
+    let loadAgentConfigCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence"],
+        loadAgentConfig: async () => {
+          loadAgentConfigCalls += 1;
+          return null;
+        },
+        loadDialogHistory: async () => [],
+        saveTurn: async () => {
+          throw new Error("local runtime should not save when config is missing");
+        },
+        resolveProvider: async () => {
+          throw new Error("local provider should not run when config is missing");
+        },
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url, init) => {
+        httpCalls.push({ url: String(url), body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "server fallback", dialogId: "dialog-server-fallback" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-server-fallback" });
+    expect(loadAgentConfigCalls).toBe(3);
+    expect(httpCalls).toHaveLength(1);
+    expect(httpCalls[0]?.body.agentKey).toBe("frontend-local");
+    expect(output.text()).toContain("refreshing from the configured server and retrying local once");
+    expect(output.text()).toContain("frontend -> working");
+    expect(output.text()).toContain("frontend > server fallback");
+  });
+
   test("auto mode skips local runtime for agents that declare server platform tools", async () => {
     const output = new CaptureOutput();
     const httpCalls: Array<{ url: string; body: any }> = [];

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,
@@ -250,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);
@@ -259,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);
@@ -683,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 }
@@ -926,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>([
@@ -356,7 +423,7 @@ describe("CLI local runtime adapter", () => {
         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 () => {
@@ -370,7 +437,7 @@ describe("CLI local runtime adapter", () => {
         provider: "fireworks",
         apiSource: "platform",
         useServerProxy: true,
-        tools: ["gitStatus"],
+        tools: ["readWorkspaceFile"],
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -575,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");
@@ -588,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",
+                    }),
                   },
                 }],
               },
@@ -953,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",
@@ -963,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[] = [];
@@ -994,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" }),
       });
 
@@ -1019,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({}),
     });
 
@@ -1070,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 });