nolo-cli 0.1.41 → 0.1.43

package/client/localRuntimeAdapter.test.ts

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { runLocalAgentTurn } from "../agent-runtime/localLoop";
-import { MIMO_MONTH_AGENT_KEY } from "../agentAliases";
+import { LOCAL_CODEX_AGENT_KEY, LOCAL_QODER_AGENT_KEY, MIMO_MONTH_AGENT_KEY } from "../agentAliases";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime adapter", () => {
@@ -13,6 +13,7 @@ describe("CLI local runtime adapter", () => {
     "readFile",
     "writeFile",
     "editFile",
+    "globFiles",
     "searchFiles",
     "execShell",
   ];
@@ -21,6 +22,7 @@ describe("CLI local runtime adapter", () => {
     "readFile",
     "writeFile",
     "editFile",
+    "globFiles",
     "searchFiles",
     "execShell",
   ];
@@ -36,6 +38,7 @@ describe("CLI local runtime adapter", () => {
     "readSpace",
     "readDoc",
     "readSkillDoc",
+    "listTables",
     "queryTableRows",
     "cliWhoami",
     "cliDoctor",
@@ -49,6 +52,87 @@ describe("CLI local runtime adapter", () => {
     return request?.body?.tools?.map((tool: any) => tool.function.name) ?? [];
   }
 
+  function publicSchemaKeys(schema: any) {
+    return Object.keys(schema.parameters.properties).filter((key) => key !== "_activity");
+  }
+
+  test("loads stored local CLI agent records before falling back to built-ins", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "0e95801d90",
+      },
+      db: {
+        get: async (key) => {
+          if (key !== LOCAL_CODEX_AGENT_KEY) throw new Error(`not found: ${key}`);
+          return {
+            dbKey: LOCAL_CODEX_AGENT_KEY,
+            id: "01LOCALCODEXCLI000000NEW",
+            name: "User Edited Local Codex",
+            prompt: "User-owned local Codex prompt.",
+            apiSource: "cli",
+            provider: "cli",
+            cliProvider: "codex",
+            model: "gpt-5.4",
+          };
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => new Response("not found", { status: 404 }),
+    } as any);
+
+    await expect(adapter.loadAgentConfig(LOCAL_CODEX_AGENT_KEY)).resolves.toMatchObject({
+      key: LOCAL_CODEX_AGENT_KEY,
+      name: "User Edited Local Codex",
+      prompt: "User-owned local Codex prompt.",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "codex",
+      model: "gpt-5.4",
+    });
+  });
+
+  test("falls back to built-in local Codex and Qoder CLI agents without machine binding", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async (key) => {
+          throw new Error(`not found: ${key}`);
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => new Response("not found", { status: 404 }),
+    } as any);
+
+    const codex = await adapter.loadAgentConfig(LOCAL_CODEX_AGENT_KEY);
+    const qoder = await adapter.loadAgentConfig(LOCAL_QODER_AGENT_KEY);
+
+    expect(codex).toMatchObject({
+      key: LOCAL_CODEX_AGENT_KEY,
+      name: "Local Codex",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "codex",
+    });
+    expect(qoder).toMatchObject({
+      key: LOCAL_QODER_AGENT_KEY,
+      name: "Local Qoder",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "qoder",
+      model: "Qwen3.7-Max",
+    });
+    expect((codex as any)?.runtimeBinding).toBeUndefined();
+    expect((qoder as any)?.runtimeBinding).toBeUndefined();
+    expect((codex as any)?.rawRecord?.runtimeBinding).toBeUndefined();
+    expect((qoder as any)?.rawRecord?.runtimeBinding).toBeUndefined();
+  });
+
   test("runs cli-provider agents through the local CLI executor instead of OpenAI-compatible direct mode", async () => {
     const cliExecutions: Array<{ provider: string; prompt: string; options: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
@@ -1324,7 +1408,6 @@ describe("CLI local runtime adapter", () => {
             "execShell",
             "checkEnv",
             "queryTableRows",
-            "taskRun",
           ],
         }),
         put: async () => {},
@@ -1348,52 +1431,58 @@ describe("CLI local runtime adapter", () => {
     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({}),
-      });
+  test("can expose only declared local workspace tools for tool ablations", 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",
+        NOLO_LOCAL_WORKSPACE_TOOLSET: "declared-only",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use exactly the declared local tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["listFiles", "readFile", "execShell"],
+        }),
+        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 adapter.loadAgentConfig("default-tools");
-      await expect(adapter.executeTool({
-        id: "call-read",
-        name: "readFile",
-        arguments: JSON.stringify({ path: "README.md" }),
-      })).resolves.toMatchObject({
-        content: "local ok\n",
-      });
-    } finally {
-      rmSync(workspaceRoot, { recursive: true, force: true });
-    }
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: MIMO_MONTH_AGENT_KEY,
+      input: "inspect cwd",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).toEqual(["listFiles", "readFile", "execShell"]);
   });
 
-  test("exposes declared taskRun as a platform tool in local runtime requests", async () => {
+  test("defaults local workspace tools to strategy descriptions and rich parameters", 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",
+        NOLO_LOCAL_WORKSPACE_TOOLSET: "declared-only",
       },
       db: {
         get: async () => ({
-          dbKey: "agent-local-taskrun",
-          prompt: "Use taskRun.",
-          model: "gpt-4.1-mini",
-          toolNames: ["taskRun"],
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["listFiles", "readFile", "globFiles", "searchFiles"],
         }),
         put: async () => {},
         batch: async () => {},
@@ -1409,61 +1498,272 @@ describe("CLI local runtime adapter", () => {
 
     await runLocalAgentTurn({
       adapter,
-      agentRef: "taskrun",
-      input: "read task context",
+      agentRef: MIMO_MONTH_AGENT_KEY,
+      input: "inspect cwd",
     });
 
-    expect(toolNamesFromRequest(requests[0])).toContain("taskRun");
+    const tools = new Map(
+      requests[0]?.body.tools.map((tool: any) => [tool.function.name, tool.function]),
+    );
+    const listFiles = tools.get("listFiles") as any;
+    const readFile = tools.get("readFile") as any;
+    const globFiles = tools.get("globFiles") as any;
+    const searchFiles = tools.get("searchFiles") as any;
+
+    expect(listFiles.description).toContain("not for path-pattern discovery across the repo");
+    expect(publicSchemaKeys(listFiles)).toEqual([
+      "path",
+      "maxDepth",
+      "maxResults",
+      "entryType",
+    ]);
+    expect(readFile.description).toContain("Use line ranges");
+    expect(publicSchemaKeys(readFile)).toEqual([
+      "path",
+      "startLine",
+      "endLine",
+      "maxLines",
+      "tailLines",
+    ]);
+    expect(globFiles.description).toContain("any file discovery task");
+    expect(publicSchemaKeys(globFiles)).toEqual([
+      "pattern",
+      "path",
+      "exclude",
+      "includeIgnored",
+      "maxResults",
+    ]);
+    expect(searchFiles.description).toContain("using ripgrep when available");
+    expect(publicSchemaKeys(searchFiles)).toEqual([
+      "query",
+      "path",
+      "exclude",
+      "includeIgnored",
+      "maxResults",
+      "literal",
+      "caseSensitive",
+      "contextLines",
+    ]);
   });
 
-  test("executes declared taskRun through the server task-run bridge", async () => {
-    const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+  test("can vary globFiles schema through local runtime env", async () => {
+    const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
-        BASE_URL: "https://us.nolo.chat",
-        AUTH_TOKEN: "machine-token",
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_GLOBFILES_DESCRIPTION_VARIANT: "antiShell",
+        NOLO_GLOBFILES_PARAMETER_VARIANT: "rich",
       },
       db: {
         get: async () => ({
-          dbKey: "agent-local-taskrun",
-          toolNames: ["taskRun"],
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["globFiles"],
         }),
         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)),
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
         });
-        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",
-      }),
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: MIMO_MONTH_AGENT_KEY,
+      input: "find tests",
     });
 
-    expect(requests).toEqual([
-      {
-        url: "https://us.nolo.chat/api/task-run",
-        auth: "Bearer machine-token",
-        body: {
-          action: "readTaskContext",
-          dbKey: "row-user-NOLOTASKBOARD-task-1",
-        },
+    const globFiles = requests[0]?.body.tools.find((tool: any) => tool.function.name === "globFiles")?.function;
+    expect(globFiles.description).toContain("Do not use execShell or listFiles for path discovery");
+    expect(publicSchemaKeys(globFiles)).toEqual([
+      "pattern",
+      "path",
+      "exclude",
+      "includeIgnored",
+      "maxResults",
+    ]);
+  });
+
+  test("can vary listFiles schema through local runtime env", 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",
+        NOLO_LISTFILES_DESCRIPTION_VARIANT: "antiShell",
+        NOLO_LISTFILES_PARAMETER_VARIANT: "rich",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["listFiles"],
+        }),
+        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: MIMO_MONTH_AGENT_KEY,
+      input: "list directories",
+    });
+
+    const listFiles = requests[0]?.body.tools.find((tool: any) => tool.function.name === "listFiles")?.function;
+    expect(listFiles.description).toContain("Do not use execShell with ls/find/tree");
+    expect(publicSchemaKeys(listFiles)).toEqual([
+      "path",
+      "maxDepth",
+      "maxResults",
+      "entryType",
     ]);
-    expect(result.content).toContain("\"ok\":true");
-    expect(result.metadata).toMatchObject({ serverPlatformTool: true });
+  });
+
+  test("can vary readFile schema through local runtime env", 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",
+        NOLO_READFILE_DESCRIPTION_VARIANT: "strategy",
+        NOLO_READFILE_PARAMETER_VARIANT: "rich",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["readFile"],
+        }),
+        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: MIMO_MONTH_AGENT_KEY,
+      input: "read a file range",
+    });
+
+    const readFile = requests[0]?.body.tools.find((tool: any) => tool.function.name === "readFile")?.function;
+    expect(readFile.description).toContain("Use line ranges");
+    expect(readFile.parameters.properties.maxLines.description).toContain("each readFile preview consumes one budget slot");
+    expect(publicSchemaKeys(readFile)).toEqual([
+      "path",
+      "startLine",
+      "endLine",
+      "maxLines",
+      "tailLines",
+    ]);
+  });
+
+  test("can vary searchFiles schema through local runtime env", 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",
+        NOLO_SEARCHFILES_DESCRIPTION_VARIANT: "antiShell",
+        NOLO_SEARCHFILES_PARAMETER_VARIANT: "rich",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["searchFiles"],
+        }),
+        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: MIMO_MONTH_AGENT_KEY,
+      input: "find TODO",
+    });
+
+    const searchFiles = requests[0]?.body.tools.find((tool: any) => tool.function.name === "searchFiles")?.function;
+    expect(searchFiles.description).toContain("Do not use execShell for content search");
+    expect(publicSchemaKeys(searchFiles)).toEqual([
+      "query",
+      "path",
+      "exclude",
+      "includeIgnored",
+      "maxResults",
+      "literal",
+      "caseSensitive",
+      "contextLines",
+    ]);
+  });
+
+  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: "readFile",
+        arguments: JSON.stringify({ path: "README.md" }),
+      })).resolves.toMatchObject({
+        content: "local ok\n",
+      });
+    } finally {
+      rmSync(workspaceRoot, { recursive: true, force: true });
+    }
   });
 
   test("exposes declared server table write tools in local runtime requests", async () => {
@@ -1541,6 +1841,7 @@ describe("CLI local runtime adapter", () => {
       userInput: "采集这个用户并写入 table",
       arguments: JSON.stringify({
         title: "XHS profile",
+        purpose: "agent_eval_workbench",
         columns: [{ name: "nickname" }],
       }),
     });
@@ -1551,6 +1852,7 @@ describe("CLI local runtime adapter", () => {
         auth: "Bearer token-1",
         body: {
           title: "XHS profile",
+          purpose: "agent_eval_workbench",
           columns: [{ name: "nickname" }],
         },
       },
@@ -2063,6 +2365,76 @@ describe("CLI local runtime adapter", () => {
     expect(toolNamesFromRequest(requests[0])).toContain("read_xhs_profile");
   });
 
+  test("exposes read_x_post to OpenAI-compatible providers when the agent declares it", 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-x-post",
+          prompt: "Read X posts.",
+          model: "gpt-4.1-mini",
+          toolNames: ["read_x_post"],
+        }),
+        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: "x-post",
+      input: "读取 X 帖子",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).toContain("read_x_post");
+  });
+
+  test("adds read_x_post to local web-capable agent tool surface", 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-web-reader",
+          prompt: "Read web pages.",
+          model: "gpt-4.1-mini",
+          toolNames: ["fetchWebpage"],
+        }),
+        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: "web-reader",
+      input: "读取 X 帖子",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).toContain("read_x_post");
+  });
+
   test("does not expose read_xhs_profile when the agent does not declare it", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
@@ -2159,6 +2531,67 @@ describe("CLI local runtime adapter", () => {
     expect(parsed.data.profile.nickname).toBe("test-soul");
   });
 
+  test("default read_x_post executor calls the local bridge reader", async () => {
+    const readerCalls: Array<{ args: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-x-post-default",
+          id: "x-post-default",
+          prompt: "Read X posts.",
+          toolNames: ["read_x_post"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      readXPost: async (args) => {
+        readerCalls.push({ args });
+        return {
+          rawData: {
+            ok: true,
+            backend: "desktop_local_browser",
+            fetchedAt: "2026-06-08T00:00:00.000Z",
+            data: {
+              id: "2063842222307704944",
+              url: "https://x.com/BohuTANG/status/2063842222307704944",
+              text: "mock x post",
+              author: {
+                handle: "BohuTANG",
+                displayName: "Bohu",
+              },
+            },
+          } as any,
+          displayData: "已读取 X 帖子：@BohuTANG",
+        };
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("x-post-default");
+    const result = await adapter.executeTool({
+      id: "call-x-post-default",
+      name: "read_x_post",
+      arguments: JSON.stringify({
+        url: "https://x.com/BohuTANG/status/2063842222307704944",
+        keepOpen: true,
+      }),
+    });
+
+    expect(readerCalls).toHaveLength(1);
+    expect(readerCalls[0].args).toMatchObject({
+      url: "https://x.com/BohuTANG/status/2063842222307704944",
+      keepOpen: true,
+    });
+    expect(result.metadata).toMatchObject({ xPostLocalBridge: true });
+    const parsed = JSON.parse(result.content);
+    expect(parsed.ok).toBe(true);
+    expect(parsed.data.text).toBe("mock x post");
+  });
+
   test("default read_xhs_profile executor calls the local bridge reader", async () => {
     const readerCalls: Array<{ args: any; thunkApi: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
@@ -2221,9 +2654,7 @@ describe("CLI local runtime adapter", () => {
       includeComments: true,
       maxCommentPagesPerNote: 1,
     });
-    expect(String(readerCalls[0].args.profileDir).replaceAll("\\", "/")).toContain(
-      "chat.nolo.desktop/stable/external-readers/xhs-profile"
-    );
+    expect(readerCalls[0].args.profileDir).toBeUndefined();
     expect(readerCalls[0].thunkApi).toBeUndefined();
     expect(result.metadata).toMatchObject({
       xhsLocalBridge: true,
@@ -2232,7 +2663,7 @@ describe("CLI local runtime adapter", () => {
     expect(JSON.parse(result.content).data.profile.nickname).toBe("default-bridge");
   });
 
-  test("default read_xhs_profile executor honors explicit XHS profile env", async () => {
+  test("default read_xhs_profile executor ignores explicit XHS profile env", async () => {
     const readerCalls: Array<{ args: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {