nolo-cli 0.1.18 → 0.1.20

package/client/localRuntimeAdapter.test.ts

@@ -1,9 +1,39 @@
 import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-import { runLocalAgentTurn } from "../../agent-runtime/localLoop";
+import { runLocalAgentTurn } from "../agent-runtime/localLoop";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime adapter", () => {
+  const DEFAULT_LOCAL_CODING_TOOL_NAMES = [
+    "readWorkspaceFile",
+    "writeWorkspaceFile",
+    "replaceWorkspaceText",
+    "searchWorkspace",
+    "applyPatch",
+    "gitStatus",
+    "gitDiff",
+    "gitCreateBranch",
+    "commitWorkspace",
+    "runPackageScript",
+    "startPreview",
+    "getPreviewStatus",
+    "stopPreview",
+    "releasePreview",
+    "captureVisualState",
+  ];
+  const SHELL_LOCAL_CODING_TOOL_NAMES = [
+    ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
+    "execShell",
+    "execBash",
+  ];
+
+  function toolNamesFromRequest(request: any) {
+    return request?.body?.tools?.map((tool: any) => tool.function.name) ?? [];
+  }
+
   test("loads agent/history from LevelDB and saves dialog/message records back to LevelDB", async () => {
     const requests: Array<{ url: string; body: any; auth: string | null }> = [];
     const store = new Map<string, any>([
@@ -81,9 +111,9 @@ describe("CLI local runtime adapter", () => {
     expect(result).toMatchObject({
       content: "local adapter ok",
       model: "gpt-4.1-mini",
-      dialogId: "01LOCAL",
+      dialogId: "dialog-existing",
     });
-    expect(requests).toEqual([{
+    expect(requests[0]).toMatchObject({
       url: "http://127.0.0.1:11434/v1/chat/completions",
       auth: "Bearer sk-local",
       body: {
@@ -95,31 +125,679 @@ describe("CLI local runtime adapter", () => {
         ],
         stream: false,
       },
-    }]);
+    });
+    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
     expect(batchOps.map((op) => op.key)).toEqual([
-      "dialog-user-1-01LOCAL",
-      "dialog-01LOCAL-msg-user",
-      "dialog-01LOCAL-msg-assistant",
+      "dialog-user-1-dialog-existing",
+      "dialog-dialog-existing-msg-1710000000000-001",
+      "dialog-dialog-existing-msg-1710000000000-002",
     ]);
-    expect(store.get("dialog-user-1-01LOCAL")).toMatchObject({
-      id: "01LOCAL",
-      dbKey: "dialog-user-1-01LOCAL",
+    expect(store.get("dialog-user-1-dialog-existing")).toMatchObject({
+      id: "dialog-existing",
+      dbKey: "dialog-user-1-dialog-existing",
       type: "dialog",
       primaryAgentKey: "agent-user-1-frontend",
       status: "done",
     });
-    expect(store.get("dialog-01LOCAL-msg-user")).toMatchObject({
-      dialogId: "01LOCAL",
+    expect(store.get("dialog-dialog-existing-msg-1710000000000-001")).toMatchObject({
+      dialogId: "dialog-existing",
       role: "user",
       content: "make it cleaner",
     });
-    expect(store.get("dialog-01LOCAL-msg-assistant")).toMatchObject({
-      dialogId: "01LOCAL",
+    expect(store.get("dialog-dialog-existing-msg-1710000000000-002")).toMatchObject({
+      dialogId: "dialog-existing",
       role: "assistant",
       content: "local adapter ok",
     });
   });
 
+  test("loads a missing explicit agent key through the hybrid store remote cache", async () => {
+    const memory = new Map<string, any>();
+    const requests: string[] = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_SERVER: "https://us.nolo.chat",
+        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: () => "01REMOTE",
+      fetchImpl: async (url, init) => {
+        requests.push(String(url));
+        if (String(url).includes("/api/v1/db/read/")) {
+          expect(new Headers(init?.headers).get("Authorization")).toBe("Bearer token-1");
+          return Response.json({
+            data: {
+              dbKey: "agent-user-1-remote",
+              name: "Remote cached",
+              prompt: "Remote prompt",
+              model: "gpt-4.1-mini",
+            },
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "remote cache ok" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "agent-user-1-remote",
+      input: "hello",
+    });
+
+    expect(result.content).toBe("remote cache ok");
+    expect(requests[0]).toBe("https://us.nolo.chat/api/v1/db/read/agent-user-1-remote");
+    expect(memory.get("agent-user-1-remote")).toMatchObject({
+      name: "Remote cached",
+      serverOrigin: "https://us.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>([
+      ["agent-user-1-custom", {
+        dbKey: "agent-user-1-custom",
+        id: "custom",
+        prompt: "Use custom provider.",
+        model: "custom-coder",
+        provider: "custom-openai-compatible",
+        apiSource: "custom",
+        customProviderUrl: "https://provider.example/v1/chat/completions",
+        temperature: 0.2,
+        max_tokens: 4096,
+        reasoning_effort: "medium",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        OPENAI_API_KEY: "sk-custom",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        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({
+          choices: [{ message: { content: "custom ok" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "custom",
+      input: "hello",
+    });
+
+    expect(result.content).toBe("custom ok");
+    expect(result.provider).toBe("custom-openai-compatible");
+    expect(requests[0]).toMatchObject({
+      url: "https://provider.example/v1/chat/completions",
+      auth: "Bearer sk-custom",
+      body: {
+        model: "custom-coder",
+        messages: [
+          { role: "system", content: "Use custom provider." },
+          { role: "user", content: "hello" },
+        ],
+        stream: false,
+        temperature: 0.2,
+        max_tokens: 4096,
+        reasoning_effort: "medium",
+      },
+    });
+    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+  });
+
+  test("uses the Nolo chat proxy when local provider keys are absent", async () => {
+    const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+    const store = new Map<string, any>([
+      ["agent-user-1-frontend", {
+        dbKey: "agent-user-1-frontend",
+        id: "frontend",
+        prompt: "Fix UI.",
+        model: "accounts/fireworks/models/kimi-k2p6",
+        provider: "fireworks",
+        tools: ["writeWorkspaceFile"],
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        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({
+          choices: [{ message: { content: "platform ok" } }],
+          usage: { prompt_tokens: 7, completion_tokens: 2 },
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "make notifications cleaner",
+    });
+
+    expect(result.content).toBe("platform ok");
+    expect(result.provider).toBe("fireworks");
+    expect(requests[0]).toMatchObject({
+      url: "https://us.nolo.chat/api/v1/chat",
+      auth: "Bearer token-1",
+      body: {
+        model: "accounts/fireworks/models/kimi-k2p6",
+        messages: [
+          { role: "system", content: "Fix UI." },
+          { role: "user", content: "make notifications cleaner" },
+        ],
+        stream: false,
+        tool_choice: "auto",
+        url: "https://api.fireworks.ai/inference/v1/chat/completions",
+        provider: "fireworks",
+      },
+    });
+    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+  });
+
+  test("uses the Nolo chat proxy for platform agents even when direct provider env exists", async () => {
+    const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+    const store = new Map<string, any>([
+      ["agent-user-1-frontend", {
+        dbKey: "agent-user-1-frontend",
+        id: "frontend",
+        prompt: "Fix UI.",
+        model: "accounts/fireworks/models/kimi-k2p6",
+        provider: "fireworks",
+        apiSource: "platform",
+        useServerProxy: true,
+        tools: ["gitStatus"],
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
+        OPENAI_API_KEY: "sk-direct",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        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({
+          choices: [{ message: { content: "platform ok" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "inspect",
+    });
+
+    expect(result.content).toBe("platform ok");
+    expect(requests[0]).toMatchObject({
+      url: "https://us.nolo.chat/api/v1/chat",
+      auth: "Bearer token-1",
+      body: {
+        provider: "fireworks",
+        apiSource: "platform",
+      },
+    });
+  });
+
+  test("retries transient certificate failures from the platform chat proxy", async () => {
+    let attempts = 0;
+    const store = new Map<string, any>([
+      ["agent-user-1-frontend", {
+        dbKey: "agent-user-1-frontend",
+        id: "frontend",
+        prompt: "Fix UI.",
+        model: "accounts/fireworks/models/kimi-k2p6",
+        provider: "fireworks",
+        apiSource: "platform",
+        useServerProxy: true,
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => {
+        attempts += 1;
+        if (attempts <= 2) {
+          throw new Error("unknown certificate verification error");
+        }
+        return Response.json({
+          choices: [{ message: { content: "platform retry ok" } }],
+        });
+      },
+      sleep: async () => {},
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "inspect",
+    });
+
+    expect(result.content).toBe("platform retry ok");
+    expect(attempts).toBe(3);
+  });
+
+  test("keeps retrying repeated transient certificate failures with backoff hooks", async () => {
+    let attempts = 0;
+    const retryDelays: number[] = [];
+    const store = new Map<string, any>([
+      ["agent-user-1-frontend", {
+        dbKey: "agent-user-1-frontend",
+        id: "frontend",
+        prompt: "Fix UI.",
+        model: "accounts/fireworks/models/kimi-k2p6",
+        provider: "fireworks",
+        apiSource: "platform",
+        useServerProxy: true,
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => {
+        attempts += 1;
+        if (attempts <= 5) {
+          throw new Error("unknown certificate verification error");
+        }
+        return Response.json({
+          choices: [{ message: { content: "platform longer retry ok" } }],
+        });
+      },
+      sleep: async (ms) => {
+        retryDelays.push(ms);
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "inspect",
+    });
+
+    expect(result.content).toBe("platform longer retry ok");
+    expect(attempts).toBe(6);
+    expect(retryDelays.length).toBe(5);
+    expect(retryDelays[0]).toBeGreaterThan(0);
+  });
+
+  test("saves local tool call trace and shell metadata into the local dialog", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-shell", {
+        dbKey: "agent-user-1-shell",
+        id: "shell",
+        prompt: "Use shell.",
+        model: "gpt-4.1-mini",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      now: () => 1710000000000,
+      createId: () => "01TRACE",
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init?.body));
+        const hasToolResult = body.messages.some((message: any) => message.role === "tool");
+        if (!hasToolResult) {
+          return Response.json({
+            choices: [{
+              message: {
+                content: "",
+                tool_calls: [{
+                  id: "call-shell",
+                  type: "function",
+                  function: {
+                    name: "execShell",
+                    arguments: JSON.stringify({ cmd: "printf trace-ok" }),
+                  },
+                }],
+              },
+            }],
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell",
+      input: "inspect",
+    });
+
+    expect(result.dialogId).toBe("01TRACE");
+    expect(store.get("dialog-user-1-01TRACE")).toMatchObject({
+      toolCallCount: 1,
+      localRuntime: expect.objectContaining({
+        host: "cli",
+        worktreePath: import.meta.dir,
+      }),
+    });
+    const messages = [...store.entries()]
+      .filter(([key]) => key.startsWith("dialog-01TRACE-msg-"))
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([, value]) => value);
+    expect(messages.map((message) => message.role)).toEqual([
+      "user",
+      "assistant",
+      "tool",
+      "assistant",
+    ]);
+    expect(messages[1]).toMatchObject({
+      tool_calls: [{
+        id: "call-shell",
+        function: { name: "execShell" },
+      }],
+    });
+    expect(messages[2]).toMatchObject({
+      role: "tool",
+      toolCallId: "call-shell",
+      metadata: { exitCode: 0 },
+    });
+    expect(messages[2].content).toContain("trace-ok");
+    expect(messages[3]).toMatchObject({
+      role: "assistant",
+      content: "done",
+    });
+  });
+
+  test("returns tool budget errors to the local loop", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-reader", {
+        dbKey: "agent-user-1-reader",
+        id: "reader",
+        prompt: "Read narrowly",
+        model: "gpt-4.1-mini",
+        provider: "openai-compatible",
+        tools: ["readWorkspaceFile"],
+      }],
+    ]);
+    let requestCount = 0;
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_LOCAL_OPENAI_BASE_URL: "https://llm.example/v1",
+        NOLO_LOCAL_OPENAI_API_KEY: "sk-test",
+        NOLO_LOCAL_TOOL_BUDGETS: "readWorkspaceFile=1",
+      },
+      store: {
+        read: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      now: () => 1710000000000,
+      createId: () => "01BUDGET",
+      localToolExecutors: {
+        readWorkspaceFile: async () => ({ content: "file content" }),
+      },
+      fetchImpl: async (_url, init) => {
+        requestCount += 1;
+        const body = JSON.parse(String(init?.body));
+        const toolMessages = body.messages.filter((message: any) => message.role === "tool");
+        if (toolMessages.some((message: any) => String(message.content).includes("exceeded local tool budget"))) {
+          return Response.json({ choices: [{ message: { content: "budget handled" } }] });
+        }
+        return Response.json({
+          choices: [{
+            message: {
+              content: "",
+              tool_calls: [{
+                id: `call-read-${requestCount}`,
+                type: "function",
+                function: {
+                  name: "readWorkspaceFile",
+                  arguments: JSON.stringify({ path: "file.ts" }),
+                },
+              }],
+            },
+          }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "agent-user-1-reader",
+      input: "inspect",
+      maxToolRounds: 3,
+    });
+
+    expect(result.content).toBe("budget handled");
+    const messages = [...store.values()];
+    expect(messages.some((message) => String(message.content).includes("exceeded local tool budget 1"))).toBe(true);
+  });
+
+  test("continues a local dialog instead of creating a new one", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-frontend", {
+        dbKey: "agent-user-1-frontend",
+        id: "frontend",
+        prompt: "Fix UI",
+        model: "gpt-4.1-mini",
+      }],
+      ["dialog-user-1-dialog-existing", {
+        dbKey: "dialog-user-1-dialog-existing",
+        id: "dialog-existing",
+        type: "dialog",
+        userId: "user-1",
+        title: "Existing dialog",
+      }],
+      ["dialog-dialog-existing-msg-001", {
+        dbKey: "dialog-dialog-existing-msg-001",
+        id: "msg-001",
+        dialogId: "dialog-existing",
+        role: "assistant",
+        content: "previous answer",
+      }],
+    ]);
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: ({ gte, lte }) => (async function* () {
+          for (const entry of [...store.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            if (entry[0] >= gte && entry[0] <= lte) yield entry;
+          }
+        })(),
+      },
+      now: () => 1710000000000,
+      createId: () => "SHOULDNOTUSE",
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init?.body));
+        expect(body.messages).toContainEqual({
+          role: "assistant",
+          content: "previous answer",
+        });
+        return Response.json({
+          choices: [{ message: { content: "continued" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "continue",
+      continueDialogId: "dialog-existing",
+    });
+
+    expect(result.dialogId).toBe("dialog-existing");
+    expect(store.has("dialog-user-1-SHOULDNOTUSE")).toBe(false);
+    expect(store.get("dialog-user-1-dialog-existing")).toMatchObject({
+      id: "dialog-existing",
+      title: "Existing dialog",
+      status: "done",
+    });
+    expect([...store.keys()].filter((key) => key.startsWith("dialog-dialog-existing-msg-"))).toContain(
+      "dialog-dialog-existing-msg-1710000000000-001"
+    );
+  });
+
   test("passes image_url message parts through to OpenAI-compatible providers", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
@@ -247,12 +925,83 @@ describe("CLI local runtime adapter", () => {
       input: "pwd",
     });
 
-    expect(requests[0]?.body.tools).toEqual([{
-      type: "function",
-      function: expect.objectContaining({
-        name: "execShell",
-      }),
-    }]);
+    expect(toolNamesFromRequest(requests[0])).toEqual(SHELL_LOCAL_CODING_TOOL_NAMES);
+  });
+
+  test("allows default semantic workspace tools without legacy agent tool declarations", async () => {
+    const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
+    try {
+      await Bun.write(join(workspaceRoot, "README.md"), "local ok\n");
+      const adapter = createCliLocalRuntimeAdapter({
+        env: {},
+        cwd: workspaceRoot,
+        db: {
+          get: async () => ({
+            dbKey: "agent-local-default-tools",
+            prompt: "Use local workspace tools.",
+            model: "gpt-4.1-mini",
+          }),
+          put: async () => {},
+          batch: async () => {},
+          iterator: () => (async function* () {})(),
+        },
+        fetchImpl: async () => Response.json({}),
+      });
+
+      await adapter.loadAgentConfig("default-tools");
+      await expect(adapter.executeTool({
+        id: "call-read",
+        name: "readWorkspaceFile",
+        arguments: JSON.stringify({ path: "README.md" }),
+      })).resolves.toMatchObject({
+        content: "local ok\n",
+      });
+    } finally {
+      rmSync(workspaceRoot, { recursive: true, force: 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[] = [];
+    try {
+      await Bun.write(join(taskWorktreeRoot, "README.md"), "worktree ok\n");
+      const adapter = createCliLocalRuntimeAdapter({
+        env: {
+          NOLO_LOCAL_USER_ID: "user-1",
+        },
+        output: { write: (chunk) => chunks.push(chunk) },
+        db: {
+          get: async () => ({
+            dbKey: "agent-user-1-frontend",
+            id: "frontend",
+            prompt: "Use local workspace tools.",
+            runtimeBinding: { localWorkspaceMode: "task-worktree" },
+          }),
+          put: async () => {},
+          batch: async () => {},
+          iterator: () => (async function* () {})(),
+        },
+        prepareTaskWorktree: async ({ agentKey }) => ({
+          path: taskWorktreeRoot,
+          branchName: `nolo-agent-${agentKey}`,
+        }),
+        fetchImpl: async () => Response.json({}),
+      });
+
+      await adapter.loadAgentConfig("frontend");
+      const result = await adapter.executeTool({
+        id: "call-read",
+        name: "readWorkspaceFile",
+        arguments: JSON.stringify({ path: "README.md" }),
+      });
+
+      expect(result.content).toBe("worktree ok\n");
+      expect(chunks.join("")).toContain(`workspace session: task-worktree ${taskWorktreeRoot}`);
+      expect(chunks.join("")).toContain("branch nolo-agent-frontend");
+    } finally {
+      rmSync(taskWorktreeRoot, { recursive: true, force: true });
+    }
   });
 
   test("runs execShell locally in explicit worktree shell mode", async () => {
@@ -281,4 +1030,48 @@ describe("CLI local runtime adapter", () => {
     expect(result.content).toContain(import.meta.dir);
     expect(result.metadata).toMatchObject({ exitCode: 0 });
   });
+
+  test("runs allowed workspace file tools through default local executors", async () => {
+    const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
+    try {
+      const store = new Map<string, any>([
+        ["agent-user-1-writer", {
+          dbKey: "agent-user-1-writer",
+          id: "writer",
+          toolNames: ["writeWorkspaceFile"],
+        }],
+      ]);
+      const adapter = createCliLocalRuntimeAdapter({
+        env: {
+          NOLO_LOCAL_USER_ID: "user-1",
+        },
+        db: {
+          get: async (key) => {
+            if (!store.has(key)) throw new Error(`not found: ${key}`);
+            return store.get(key);
+          },
+          put: async () => {},
+          batch: async () => {},
+          iterator: () => (async function* () {})(),
+        },
+        cwd: workspaceRoot,
+        fetchImpl: async () => Response.json({}),
+      });
+
+      await adapter.loadAgentConfig("writer");
+      const result = await adapter.executeTool({
+        id: "call-1",
+        name: "writeWorkspaceFile",
+        arguments: JSON.stringify({
+          path: "src/app.ts",
+          content: "export const cliValue = 1;\n",
+        }),
+      });
+
+      expect(result.content).toBe("wrote src/app.ts");
+      expect(readFileSync(join(workspaceRoot, "src/app.ts"), "utf8")).toBe("export const cliValue = 1;\n");
+    } finally {
+      rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+  });
 });