nolo-cli 0.1.39 → 0.1.41

package/client/localRuntimeAdapter.ts

@@ -21,6 +21,7 @@ import {
   resolveCurrentRunRuntimeToolPolicy,
   resolveLocalWorkspaceExecutorOptionsFromPolicy,
   resolveRequestedRuntimeToolNames,
+  resolveRuntimeToolSurfaceForAgent,
   shouldUsePlatformChatProvider,
 } from "../agentRuntimeLocal";
 import type { AgentRuntimeChatMessage } from "../agent-runtime";
@@ -41,8 +42,11 @@ import {
   type HybridRecordStore,
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
+import { inferCaptureIntent } from "../ai/policy/runtimePolicy";
+import { prepareTools } from "../ai/tools/prepareTools";
 import { taskRunFunctionSchema } from "../ai/tools/agent/taskRunTool";
 import {
+  MIMO_MONTH_AGENT_KEY,
   NOLO_DEFAULT_AGENT_ID,
   NOLO_DEFAULT_AGENT_KEY,
 } from "../agentAliases";
@@ -50,20 +54,45 @@ import {
   buildNoloWorkspaceCliToolExecutors,
   buildNoloWorkspaceOpenAiTools,
   filterNoloWorkspaceToolNames,
-  NOLO_WORKSPACE_TOOL_NAMES,
-  NOLO_WORKSPACE_TOOL_PROMPT,
   parseNoloWorkspaceToolArguments,
 } from "../agent-runtime/noloWorkspaceTools";
+import { executeCli as defaultExecuteCli, type CliExecuteResult, type CliImageInput } from "../ai/agent/cliExecutor";
+import { buildCliPrompt } from "../ai/agent/cliPrompt";
+import {
+  readXhsProfileFunc,
+  readXhsProfileFunctionSchema,
+} from "../ai/tools/readXhsProfileTool";
+import { resolveDefaultXhsProfileDir } from "../integrations/xhs-reader/bridge/readXhsProfileWithBridge";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
+type LocalCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: {
+    model?: string;
+    timeout?: number;
+    cwd?: string;
+    yolo?: boolean;
+    env?: Record<string, string | undefined>;
+    imageInputs?: CliImageInput[];
+  }
+) => Promise<CliExecuteResult>;
 const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
 const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
 export const BUILTIN_NOLO_AGENT_ID = NOLO_DEFAULT_AGENT_ID;
 export const BUILTIN_NOLO_AGENT_KEY = NOLO_DEFAULT_AGENT_KEY;
 const CLI_DIR = dirname(fileURLToPath(import.meta.url));
 const CLI_ENTRYPOINT = join(CLI_DIR, "..", "index.ts");
+const LOCAL_SERVER_TABLE_TOOL_NAMES = [
+  "createTable",
+  "addTableRow",
+  "addTableRows",
+  "updateTableRow",
+  "updateTableRows",
+] as const;
+const LOCAL_SERVER_TABLE_TOOL_NAME_SET = new Set<string>(LOCAL_SERVER_TABLE_TOOL_NAMES);
 
 export type CliLocalRuntimeDb = CliKvDb;
 
@@ -77,6 +106,8 @@ export type CliLocalRuntimeAdapterDeps = {
   cwd?: string;
   output?: { write(chunk: string): unknown };
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
+  readXhsProfile?: typeof readXhsProfileFunc;
+  executeCli?: LocalCliExecutor;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
 };
@@ -93,10 +124,6 @@ function resolveLocalUserId(env: EnvLike) {
   return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
-function shellModeEnabled(env: EnvLike) {
-  return env.NOLO_LOCAL_SHELL_MODE === "worktree";
-}
-
 function parseLocalToolBudgets(env: EnvLike) {
   const raw = env.NOLO_LOCAL_TOOL_BUDGETS?.trim();
   if (!raw) return {};
@@ -224,12 +251,14 @@ function buildRequestTimeoutSignal(timeoutMs?: number) {
   if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
     return undefined;
   }
-  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
-    return AbortSignal.timeout(timeoutMs);
-  }
   const controller = new AbortController();
-  setTimeout(() => controller.abort(new Error(`request timed out after ${timeoutMs}ms`)), timeoutMs);
-  return controller.signal;
+  const timeout = setTimeout(() => {
+    controller.abort(new Error(`request timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+  return {
+    signal: controller.signal,
+    clear: () => clearTimeout(timeout),
+  };
 }
 
 function summarizeEndpoint(value: unknown) {
@@ -251,7 +280,79 @@ function parseJsonObject(raw: string) {
   }
 }
 
+function isCliProviderAgent(agentConfig: AgentRuntimeAgentConfig) {
+  return Boolean(
+    agentConfig.apiSource === "cli" ||
+      agentConfig.provider === "cli" ||
+      agentConfig.cliProvider
+  );
+}
+
+function resolveCliProviderName(agentConfig: AgentRuntimeAgentConfig) {
+  return (agentConfig.cliProvider || agentConfig.provider || "codex").trim() || "codex";
+}
+
+function stringifyRuntimeMessageContent(content: AgentRuntimeChatMessage["content"]) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && "text" in part) {
+          return String((part as any).text ?? "");
+        }
+        return JSON.stringify(part);
+      })
+      .filter((part) => part.trim())
+      .join("\n");
+  }
+  return content == null ? "" : String(content);
+}
+
+function buildPromptForCliProvider(messages: AgentRuntimeChatMessage[]) {
+  const systemPrompt = messages
+    .filter((message) => message.role === "system")
+    .map((message) => stringifyRuntimeMessageContent(message.content).trim())
+    .filter(Boolean)
+    .join("\n\n");
+  const taskPrompt = messages
+    .filter((message) => message.role !== "system")
+    .map((message) => {
+      const content = stringifyRuntimeMessageContent(message.content).trim();
+      if (!content) return "";
+      return `[${message.role}]\n${content}`;
+    })
+    .filter(Boolean)
+    .join("\n\n");
+  return buildCliPrompt(systemPrompt, taskPrompt);
+}
+
+function collectCliProviderImageInputs(messages: AgentRuntimeChatMessage[]) {
+  const urls: string[] = [];
+  for (const message of messages) {
+    if (!Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      if (
+        part &&
+        typeof part === "object" &&
+        (part as any).type === "image_url" &&
+        typeof (part as any).image_url?.url === "string" &&
+        (part as any).image_url.url.trim()
+      ) {
+        urls.push((part as any).image_url.url.trim());
+      }
+    }
+  }
+  return urls;
+}
+
 function logLocalRuntimeDiagnostic(event: string, fields: Record<string, unknown>) {
+  if (
+    process.env.NOLO_LOCAL_RUNTIME_DEBUG !== "1" &&
+    process.env.NOLO_DEBUG !== "1"
+  ) {
+    return;
+  }
   console.error(`[nolo-local-runtime] ${event} ${JSON.stringify(fields)}`);
 }
 
@@ -266,39 +367,51 @@ function summarizeOpenAiToolNames(tools: Array<Record<string, unknown>>) {
     .filter((name): name is string => Boolean(name));
 }
 
-function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
+function shouldExposeLocalPlatformTools(agentKey?: string) {
+  return agentKey !== MIMO_MONTH_AGENT_KEY;
+}
+
+function buildOpenAiTools(args: { agentKey?: string; toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
+  const exposePlatformTools = shouldExposeLocalPlatformTools(args.agentKey);
   return [
     ...buildLocalWorkspaceOpenAiTools({
       toolNames: toolset.toolNames,
       exposeShellTools: toolset.exposeShellTools,
     }),
-    ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
-    ...buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }),
+    ...(exposePlatformTools ? buildServerPlatformOpenAiTools({ toolNames: args.toolNames }) : []),
+    ...(exposePlatformTools ? buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }) : []),
   ];
 }
 
 function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
+  void args.env;
   const toolset = buildLocalWorkspaceToolset({
     declaredToolNames: args.toolNames,
-    exposeShellTools: shellModeEnabled(args.env),
+    exposeShellTools: true,
   });
   return toolset;
 }
 
 function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
+  void args.env;
   return [
     ...buildLocalWorkspacePolicyToolNames({
       declaredToolNames: args.toolNames,
-      exposeShellTools: shellModeEnabled(args.env),
+      exposeShellTools: true,
     }),
     ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...((args.toolNames ?? []).includes("read_xhs_profile") ? ["read_xhs_profile"] : []),
+    ...(args.toolNames ?? []).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)),
     ...filterNoloWorkspaceToolNames(args.toolNames),
   ];
 }
 
 function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
   const toolNames = new Set(args.toolNames ?? []);
+  const tableTools = prepareTools(
+    (args.toolNames ?? []).filter((name) => LOCAL_SERVER_TABLE_TOOL_NAME_SET.has(name)),
+  );
   return [
     ...(toolNames.has("taskRun")
       ? [{
@@ -306,6 +419,13 @@ function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
           function: taskRunFunctionSchema,
         }]
       : []),
+    ...(toolNames.has("read_xhs_profile")
+      ? [{
+          type: "function",
+          function: readXhsProfileFunctionSchema,
+        }]
+      : []),
+    ...tableTools,
   ];
 }
 
@@ -336,16 +456,32 @@ function isBuiltinNoloAgentConfig(agentConfig: AgentRuntimeAgentConfig | null |
   return isBuiltinNoloAgentRef(key) || isBuiltinNoloAgentRef(id);
 }
 
-function withBuiltinNoloCliTools(agentConfig: AgentRuntimeAgentConfig | null) {
-  if (!agentConfig || !isBuiltinNoloAgentConfig(agentConfig)) return agentConfig;
-  const toolNames = [...new Set([...(agentConfig.toolNames ?? []), ...NOLO_WORKSPACE_TOOL_NAMES])];
+function withResolvedRuntimeToolSurface(
+  agentConfig: AgentRuntimeAgentConfig | null,
+  env: EnvLike
+) {
+  if (!agentConfig) return agentConfig;
+  const currentUserId = resolveLocalUserId(env);
+  const rawRecord = (agentConfig as any).rawRecord ?? {};
+  const ownerId =
+    typeof rawRecord.userId === "string" && rawRecord.userId.trim()
+      ? rawRecord.userId.trim()
+      : null;
+  const toolSurface = resolveRuntimeToolSurfaceForAgent({
+    explicitToolNames: agentConfig.toolNames,
+    currentUserId,
+    agentOwnerId: ownerId,
+    agentKey: rawRecord.dbKey ?? agentConfig.key,
+    isPublic: !isBuiltinNoloAgentConfig(agentConfig) && rawRecord.isPublic === true,
+    sharingLevel: typeof rawRecord.sharingLevel === "string" ? rawRecord.sharingLevel : null,
+    trustedPrivateInvocation: isBuiltinNoloAgentConfig(agentConfig),
+    runtimeHost: "cli",
+  });
   return {
     ...agentConfig,
-    toolNames,
-    prompt: [
-      agentConfig.prompt?.trim() ?? "",
-      NOLO_WORKSPACE_TOOL_PROMPT,
-    ].filter(Boolean).join("\n\n"),
+    toolNames: toolSurface.finalToolNames,
+    toolSurface,
+    prompt: agentConfig.prompt,
   };
 }
 
@@ -361,29 +497,72 @@ function buildServerPlatformToolExecutors(args: {
   env: EnvLike;
   fetchImpl: typeof fetch;
 }) {
+  const postServer = async (path: string, body: object) => {
+    const serverUrl = resolveRuntimeServerUrl(args.env);
+    const authToken = resolveRuntimeAuthToken(args.env);
+    if (!serverUrl) throw new Error("server platform tools require NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
+    if (!authToken) throw new Error("server platform tools require AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
+    const response = await args.fetchImpl(`${serverUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+      },
+      body: JSON.stringify(body),
+    });
+    const text = await response.text().catch(() => "");
+    if (!response.ok) {
+      throw new Error(`server platform tool bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
+    }
+    return text;
+  };
+  const guardExplicitTableCapture = (call: any) => {
+    if (inferCaptureIntent(String(call.userInput ?? "")) === "strong") return null;
+    return JSON.stringify({
+      error: "knowledge_capture_requires_confirmation",
+      message:
+        "当前本地运行不允许自动写入表格。只有当用户在当前请求里明确要求保存、建表、写入 table 或做成数据集时，才能继续；否则请先询问用户。",
+      policy: {
+        capability: "knowledge_capture",
+        target: "table",
+        mode: "explicit-only-local",
+      },
+    });
+  };
+  const tableExecutors = Object.fromEntries(
+    LOCAL_SERVER_TABLE_TOOL_NAMES.map((toolName) => [
+      toolName,
+      async (call: any) => {
+        const blocked = guardExplicitTableCapture(call);
+        if (blocked) {
+          return {
+            content: blocked,
+            metadata: { serverPlatformTool: true, tableWriteBlocked: true },
+          };
+        }
+        const parsed = parseNoloWorkspaceToolArguments(call.arguments);
+        const path =
+          toolName === "createTable" ? "/api/table/create"
+          : toolName === "addTableRow" ? "/api/table/add-row"
+          : toolName === "addTableRows" ? "/api/table/add-rows"
+          : toolName === "updateTableRow" ? "/api/table/update-row"
+          : "/api/table/update-rows";
+        const content = await postServer(path, parsed);
+        return {
+          content,
+          metadata: { serverPlatformTool: true, tableWrite: true },
+        };
+      },
+    ]),
+  );
   return {
     taskRun: async (call: any) => {
-      const serverUrl = resolveRuntimeServerUrl(args.env);
-      const authToken = resolveRuntimeAuthToken(args.env);
-      if (!serverUrl) throw new Error("taskRun requires NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
-      if (!authToken) throw new Error("taskRun requires AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
-      const response = await args.fetchImpl(`${serverUrl}/api/task-run`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${authToken}`,
-        },
-        body: JSON.stringify(parseNoloWorkspaceToolArguments(call.arguments)),
-      });
-      const text = await response.text().catch(() => "");
-      if (!response.ok) {
-        throw new Error(`taskRun bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
-      }
       return {
-        content: text,
+        content: await postServer("/api/task-run", parseNoloWorkspaceToolArguments(call.arguments)),
         metadata: { serverPlatformTool: true },
       };
     },
+    ...tableExecutors,
   };
 }
 
@@ -392,9 +571,34 @@ function buildLocalToolExecutors(args: {
   env: EnvLike;
   fetchImpl: typeof fetch;
   localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
+  readXhsProfile?: CliLocalRuntimeAdapterDeps["readXhsProfile"];
   commandTimeoutMs?: number;
   commandOutputLimit?: number;
 }) {
+  const resolveCliDefaultXhsArgs = (parsedArgs: any) => {
+    if (
+      parsedArgs?.profileDir ||
+      parsedArgs?.profile_dir ||
+      args.env.NOLO_XHS_READER_PROFILE_DIR
+    ) {
+      return parsedArgs;
+    }
+    return {
+      ...parsedArgs,
+      profileDir: resolveDefaultXhsProfileDir({
+        env: {
+          ...process.env,
+          ...args.env,
+          NOLO_DESKTOP: "1",
+          NOLO_DESKTOP_CHANNEL:
+            args.env.NOLO_DESKTOP_CHANNEL?.trim() ||
+            args.env.NOLO_XHS_READER_DESKTOP_CHANNEL?.trim() ||
+            "stable",
+        },
+      }),
+    };
+  };
+
   return {
     ...createLocalWorkspaceToolExecutors({
       workspaceRoot: args.workspaceRoot,
@@ -408,6 +612,22 @@ function buildLocalToolExecutors(args: {
     ...buildCliWorkspaceToolExecutors({
       env: args.env,
     }),
+    read_xhs_profile: async (call: any) => {
+      const parsedArgs = (() => {
+        try { return JSON.parse(call.arguments || "{}"); } catch { return {}; }
+      })();
+      const result = await (args.readXhsProfile ?? readXhsProfileFunc)(
+        resolveCliDefaultXhsArgs(parsedArgs),
+        undefined,
+      );
+      return {
+        content: JSON.stringify(result.rawData),
+        metadata: {
+          xhsLocalBridge: true,
+          displayData: result.displayData,
+        },
+      };
+    },
     ...(args.localToolExecutors ?? {}),
   };
 }
@@ -493,6 +713,7 @@ export function createCliLocalRuntimeAdapter(
     env: deps.env,
     fetchImpl,
     localToolExecutors: deps.localToolExecutors,
+    readXhsProfile: deps.readXhsProfile,
     ...runtimeToolExecutionLimits,
   });
 
@@ -500,11 +721,14 @@ export function createCliLocalRuntimeAdapter(
     host: "cli",
     capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
     loadAgentConfig: async (agentRef) => {
-      const agentConfig = withBuiltinNoloCliTools(await readAgentFromStore({
-        agentRef,
-        store: await resolveStore(deps),
-        userId,
-      }));
+      const agentConfig = withResolvedRuntimeToolSurface(
+        await readAgentFromStore({
+          agentRef,
+          store: await resolveStore(deps),
+          userId,
+        }),
+        deps.env
+      );
       const requestedToolNames = agentConfig
         ? resolveRequestedRuntimeToolNames({ agentConfig })
         : [];
@@ -520,6 +744,7 @@ export function createCliLocalRuntimeAdapter(
         env: deps.env,
         fetchImpl,
         localToolExecutors: deps.localToolExecutors,
+        readXhsProfile: deps.readXhsProfile,
         ...runtimeToolExecutionLimits,
       });
       return agentConfig;
@@ -537,6 +762,50 @@ export function createCliLocalRuntimeAdapter(
       cwd: workspaceRoot,
     }),
     resolveProvider: async (agentConfig) => {
+      if (isCliProviderAgent(agentConfig)) {
+        const provider = resolveCliProviderName(agentConfig);
+        logLocalRuntimeDiagnostic("provider.selected", {
+          agentKey: agentConfig.key,
+          transport: "local-cli",
+          apiSource: agentConfig.apiSource ?? null,
+          provider,
+          model: agentConfig.model ?? null,
+          cwd: workspaceRoot,
+        });
+        return {
+          model: agentConfig.model || provider,
+          complete: async (messages, options) => {
+            const executeCli = deps.executeCli ?? (defaultExecuteCli as LocalCliExecutor);
+            const imageUrls = collectCliProviderImageInputs(messages);
+            const imageInputs: CliImageInput[] | undefined =
+              imageUrls.length > 0
+                ? imageUrls.map((url) => ({ source: url }))
+                : undefined;
+            const prompt = buildPromptForCliProvider(messages);
+            try {
+              const result = await executeCli(provider, prompt, {
+                ...(agentConfig.model ? { model: agentConfig.model } : {}),
+                ...(options?.timeoutMs ? { timeout: options.timeoutMs } : {}),
+                cwd: workspaceRoot,
+                yolo: true,
+                env: deps.env,
+                ...(imageInputs ? { imageInputs } : {}),
+              });
+              return {
+                content: result.text,
+                model: agentConfig.model || provider,
+                raw: result.raw,
+              };
+            } catch (error) {
+              const message = error instanceof Error ? error.message : String(error);
+              throw new Error(
+                `Local CLI provider "${provider}" is unavailable or failed: ${message}`
+              );
+            }
+          },
+        };
+      }
+
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
         const providerConfig = resolvePlatformChatProviderConfig({
           agentConfig,
@@ -563,6 +832,7 @@ export function createCliLocalRuntimeAdapter(
               agentConfig,
             });
             const tools = buildOpenAiTools({
+              agentKey: agentConfig.key,
               toolNames: requestedToolNames,
               env: deps.env,
             });
@@ -571,7 +841,7 @@ export function createCliLocalRuntimeAdapter(
               messages,
               tools,
             });
-            const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+            const timeoutSignal = buildRequestTimeoutSignal(options?.timeoutMs);
             logLocalRuntimeDiagnostic("provider.request.start", {
               agentKey: agentConfig.key,
               transport: "platform-proxy",
@@ -582,16 +852,15 @@ export function createCliLocalRuntimeAdapter(
               toolCount: tools.length,
               requestedToolNames,
               openAiToolNames: summarizeOpenAiToolNames(tools),
-              shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
               timeoutMs: options?.timeoutMs ?? null,
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
               ...request.init,
-              ...(signal ? { signal } : {}),
+              ...(timeoutSignal ? { signal: timeoutSignal.signal } : {}),
             }, {
               sleep: deps.sleep,
               loopbackRequest,
-            });
+            }).finally(() => timeoutSignal?.clear());
             const raw = await res.text().catch(() => "");
             logLocalRuntimeDiagnostic("provider.request.result", {
               agentKey: agentConfig.key,
@@ -636,6 +905,7 @@ export function createCliLocalRuntimeAdapter(
             agentConfig,
           });
           const tools = buildOpenAiTools({
+            agentKey: agentConfig.key,
             toolNames: requestedToolNames,
             env: deps.env,
           });
@@ -644,7 +914,7 @@ export function createCliLocalRuntimeAdapter(
             messages,
             tools,
           });
-          const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+          const timeoutSignal = buildRequestTimeoutSignal(options?.timeoutMs);
           logLocalRuntimeDiagnostic("provider.request.start", {
             agentKey: agentConfig.key,
             transport: "direct-openai-compatible",
@@ -654,16 +924,15 @@ export function createCliLocalRuntimeAdapter(
             toolCount: tools.length,
             requestedToolNames,
             openAiToolNames: summarizeOpenAiToolNames(tools),
-            shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
             timeoutMs: options?.timeoutMs ?? null,
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
             ...request.init,
-            ...(signal ? { signal } : {}),
+            ...(timeoutSignal ? { signal: timeoutSignal.signal } : {}),
           }, {
             sleep: deps.sleep,
             loopbackRequest,
-          });
+          }).finally(() => timeoutSignal?.clear());
           const raw = await res.text().catch(() => "");
           logLocalRuntimeDiagnostic("provider.request.result", {
             agentKey: agentConfig.key,

package/client/localRuntimeDryRun.test.ts

@@ -7,6 +7,26 @@ import { runLocalAgentTurn } from "../agent-runtime/localLoop";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime dry run", () => {
+  const DEFAULT_PRIVATE_LOCAL_TOOL_NAMES = [
+    "listFiles",
+    "readFile",
+    "writeFile",
+    "editFile",
+    "searchFiles",
+    "execShell",
+    "listDialogs",
+    "readDialog",
+    "listAgents",
+    "readAgent",
+    "listSpaces",
+    "readSpace",
+    "readDoc",
+    "readSkillDoc",
+    "queryTableRows",
+    "cliWhoami",
+    "cliDoctor",
+  ];
+
   test("lets a declared workspace file tool write a file and save the tool trace", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-local-runtime-dry-run-"));
     try {
@@ -18,7 +38,7 @@ describe("CLI local runtime dry run", () => {
           prompt: "Use workspace file tools to edit files.",
           model: "qwen-coder",
           tools: [
-            { type: "function", function: { name: "writeWorkspaceFile" } },
+            { type: "function", function: { name: "writeFile" } },
           ],
         }],
       ]);
@@ -52,13 +72,7 @@ describe("CLI local runtime dry run", () => {
           const body = JSON.parse(String(init?.body));
           completeCount += 1;
           if (completeCount === 1) {
-            expect(body.tools.map((tool: any) => tool.function.name)).toEqual([
-              "writeWorkspaceFile",
-              "listFiles",
-              "readFile",
-              "editFile",
-              "searchFiles",
-            ]);
+            expect(body.tools.map((tool: any) => tool.function.name)).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
             return Response.json({
               model: "qwen-coder",
               choices: [{
@@ -68,7 +82,7 @@ describe("CLI local runtime dry run", () => {
                     id: "call-1",
                     type: "function",
                     function: {
-                      name: "writeWorkspaceFile",
+                      name: "writeFile",
                       arguments: JSON.stringify({
                         path: "src/notification.css",
                         content: ".notification { border-radius: 8px; }\n",

package/client/localToolPolicy.test.ts

@@ -3,20 +3,20 @@ import { describe, expect, test } from "bun:test";
 import { executeLocalToolWithPolicy, resolveLocalToolPolicy } from "./localToolPolicy";
 
 describe("CLI local tool policy", () => {
-  test("allows execShell in explicit worktree shell mode", () => {
+  test("allows execShell by default", () => {
     expect(resolveLocalToolPolicy({
-      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
+      env: {},
       agentToolNames: [],
       toolName: "execShell",
     })).toEqual({ allowed: true, toolName: "execShell" });
   });
 
-  test("blocks execShell unless explicit shell mode is enabled", () => {
+  test("allows execShell even without env allowlist", () => {
     expect(resolveLocalToolPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "execShell" },
       agentToolNames: ["execShell"],
       toolName: "execShell",
-    })).toMatchObject({ allowed: false });
+    })).toEqual({ allowed: true, toolName: "execShell" });
   });
 
   test("requires both env allowlist and agent declaration", () => {