nolo-cli 0.1.39 → 0.1.40

package/cli/offlineMarxistsAgentCommand.ts

@@ -40,15 +40,17 @@ function readFlagValue(args: string[], flag: string) {
 }
 
 function parseUserIdFromToken(token: string) {
-  const payload = token.split(".")[0];
-  if (!payload) return "";
+  const payload = token.split(".")[1];
+  if (!payload) return undefined;
   try {
     const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
     const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
     const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
-    return typeof parsed?.userId === "string" ? parsed.userId : "";
+    return typeof parsed?.userId === "string" && parsed.userId.trim()
+      ? parsed.userId.trim()
+      : undefined;
   } catch {
-    return "";
+    return undefined;
   }
 }
 

package/client/agentConfigResolver.test.ts

@@ -15,7 +15,7 @@ describe("agent config resolver", () => {
       cliProvider: "codex",
       customProviderUrl: "https://provider.example/v1",
       toolNames: ["legacyTool", "readFile"],
-      tools: ["readFile", "applyEdit"],
+      tools: ["readFile", "editFile"],
       runtimeBinding: { machineId: "machine-1" },
       delegation: { target: "local" },
       temperature: 0.2,
@@ -33,7 +33,7 @@ describe("agent config resolver", () => {
       apiSource: "platform",
       cliProvider: "codex",
       customProviderUrl: "https://provider.example/v1",
-      toolNames: ["legacyTool", "readFile", "applyEdit"],
+      toolNames: ["legacyTool", "readFile", "editFile"],
       runtimeBinding: { machineId: "machine-1" },
       delegation: { target: "local" },
       temperature: 0.2,

package/client/agentRun.test.ts

@@ -35,11 +35,11 @@ describe("cli agent run client", () => {
   });
 
   test("identifies server platform tools that local runtime cannot provide", () => {
-    expect(findServerPlatformTools(["readWorkspaceFile", "queryTableRows", "updateTableRow"])).toEqual([
+    expect(findServerPlatformTools(["readFile", "queryTableRows", "updateTableRow"])).toEqual([
       "queryTableRows",
       "updateTableRow",
     ]);
-    expect(findServerPlatformTools(["readWorkspaceFile", "execShell"])).toEqual([]);
+    expect(findServerPlatformTools(["readFile", "execShell"])).toEqual([]);
   });
 
   test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
@@ -239,7 +239,6 @@ describe("cli agent run client", () => {
       parentDialogId: "dialog-2",
       background: true,
       noStream: true,
-      maxToolRounds: 12,
       timeoutMs: 600000,
       scriptDir: "C:/missing/scripts",
       env: { AUTH_TOKEN: "token-123" },
@@ -259,7 +258,6 @@ describe("cli agent run client", () => {
       inheritedFromDialogKey: "dialog-user-1-dialog-2",
       parentDialogId: "dialog-2",
       background: true,
-      maxRounds: 12,
       timeoutMs: 600000,
       stream: false,
     });
@@ -345,72 +343,75 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("frontend > local:polish notifications");
   });
 
-  test("increases local max tool rounds when a forced local run exhausts them", async () => {
+  test("continues forced local tool loops until the provider returns final text", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
+    let toolCalls = 0;
+
     const result = await runAgentTurn({
       agentName: "frontend",
       agentKey: "frontend-local",
       serverUrl: "https://nolo.chat",
-      message: "polish notifications",
+      message: "make screenshots",
       scriptDir: "C:/missing/scripts",
-      env: { AUTH_TOKEN: "token-123", NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "1" },
+      env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "local",
-      maxToolRounds: 0,
       localRuntimeAdapter: {
         host: "cli",
-        capabilities: ["local-provider", "local-persistence"],
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
         loadAgentConfig: async (agentRef) => ({
           key: agentRef,
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        saveTurn: async () => ({ dialogId: "dialog-local-retry" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
             completeCalls += 1;
-            return {
-              content: "",
-              model: "fake-local",
-              tool_calls: [{
-                id: `call-${completeCalls}`,
-                type: "function",
-                function: { name: "readWorkspaceFile", arguments: "{}" },
-              }],
-            };
+            if (completeCalls <= 3) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: `call-${completeCalls}`,
+                  type: "function",
+                  function: { name: "readFile", arguments: "{}" },
+                }],
+              };
+            }
+            return { content: "done after retry", model: "fake-local" };
           },
         }),
-        executeTool: async () => ({ content: "ok" }),
-      },
-      fetchImpl: async () => {
-        throw new Error("HTTP should not be called for forced local runs");
+        executeTool: async () => {
+          toolCalls += 1;
+          return { content: "ok" };
+        },
       },
     });
 
-    expect(result).toMatchObject({ exitCode: 1 });
-    expect(output.text()).toContain("Local agent used all 0 tool rounds; retrying with 1.");
-    expect(output.text()).toContain("Local agent exceeded max tool rounds: 1");
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-retry" });
+    expect(toolCalls).toBe(3);
+    expect(output.text()).toContain("frontend > done after retry");
   });
 
-  test("completes a forced local run after automatically increasing tool rounds", async () => {
+  test("prints compact local tool trace by default", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
-    let toolCalls = 0;
 
     const result = await runAgentTurn({
       agentName: "frontend",
       agentKey: "frontend-local",
       serverUrl: "https://nolo.chat",
-      message: "make screenshots",
+      message: "inspect repo",
       scriptDir: "C:/missing/scripts",
       env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "local",
-      maxToolRounds: 1,
       localRuntimeAdapter: {
         host: "cli",
         capabilities: ["local-provider", "local-persistence", "local-tools"],
@@ -419,42 +420,39 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local-retry" }),
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
             completeCalls += 1;
-            if (completeCalls <= 3) {
+            if (completeCalls === 1) {
               return {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: `call-${completeCalls}`,
+                  id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: "{}" },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
-            return { content: "done after retry", model: "fake-local" };
+            return { content: "done", model: "fake-local" };
           },
         }),
-        executeTool: async () => {
-          toolCalls += 1;
-          return { content: "ok" };
-        },
+        executeTool: async () => ({ content: "clean" }),
       },
     });
 
-    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-retry" });
-    expect(toolCalls).toBe(2);
-    expect(output.text()).toContain("Local agent used all 1 tool rounds; retrying with 2.");
-    expect(output.text()).toContain("frontend > done after retry");
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
+    expect(output.text()).toContain("[nolo:tool] #1 -> readFile README.md");
+    expect(output.text()).toContain("[nolo:tool] #1 <- readFile");
+    expect(output.text()).toContain("1 line");
   });
 
-  test("prints local tool trace when requested", async () => {
+  test("does not print local tool trace when disabled by env", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
 
@@ -464,10 +462,9 @@ describe("cli agent run client", () => {
       serverUrl: "https://nolo.chat",
       message: "inspect repo",
       scriptDir: "C:/missing/scripts",
-      env: { AUTH_TOKEN: "token-123" },
+      env: { AUTH_TOKEN: "token-123", NOLO_TRACE_TOOLS: "0" },
       output,
       runtimeMode: "local",
-      traceTools: true,
       localRuntimeAdapter: {
         host: "cli",
         capabilities: ["local-provider", "local-persistence", "local-tools"],
@@ -476,10 +473,10 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        saveTurn: async () => ({ dialogId: "dialog-local-no-trace" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
@@ -491,7 +488,7 @@ describe("cli agent run client", () => {
                 tool_calls: [{
                   id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -502,9 +499,79 @@ describe("cli agent run client", () => {
       },
     });
 
-    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
-    expect(output.text()).toContain("[nolo:tool] round 1 -> readWorkspaceFile (call-read)");
-    expect(output.text()).toContain("[nolo:tool] round 1 <- readWorkspaceFile (call-read)");
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local-no-trace" });
+    expect(output.text()).not.toContain("[nolo:tool]");
+  });
+
+  test("prints local tool events as jsonl when requested", async () => {
+    const output = new CaptureOutput();
+    let completeCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "inspect repo",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      eventsMode: "jsonl",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+          toolNames: ["execShell"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local-jsonl" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            completeCalls += 1;
+            if (completeCalls === 1) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: "call-shell",
+                  type: "function",
+                  function: { name: "execShell", arguments: JSON.stringify({ command: "git status --short" }) },
+                }],
+              };
+            }
+            return { content: "done", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => ({ content: "stdout:\nclean\n\nexitCode: 0", metadata: { exitCode: 0 } }),
+      },
+    });
+
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local-jsonl" });
+    const events = output.text()
+      .split(/\r?\n/)
+      .filter((line) => line.startsWith("{"))
+      .map((line) => JSON.parse(line))
+      .filter((event) => typeof event.type === "string" && event.type.startsWith("tool-"));
+    expect(events).toHaveLength(2);
+    expect(events[0]).toMatchObject({
+      schemaVersion: 1,
+      type: "tool-call",
+      round: 1,
+      tool: "execShell",
+      argsPreview: "git status --short",
+    });
+    expect(events[1]).toMatchObject({
+      schemaVersion: 1,
+      type: "tool-result",
+      round: 1,
+      tool: "execShell",
+      summary: expect.stringContaining("exit=0"),
+    });
   });
 
   test("passes local tool evidence to task-run writeback", async () => {
@@ -536,7 +603,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -551,7 +618,7 @@ describe("cli agent run client", () => {
                 tool_calls: [{
                   id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -565,7 +632,7 @@ describe("cli agent run client", () => {
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
     expect(writebacks).toHaveLength(1);
     expect(writebacks[0].toolEvidence).toEqual({
-      toolsUsed: ["readWorkspaceFile"],
+      toolsUsed: ["readFile"],
       summary: {
         callCount: 1,
         resultCount: 1,
@@ -833,7 +900,6 @@ describe("cli agent run client", () => {
       scriptDir: "C:/missing/scripts",
       env: {
         AUTH_TOKEN: "token-123",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       output,
       runtimeMode: "auto",

package/client/agentRun.ts

@@ -44,7 +44,6 @@ type RunAgentTurnOptions = {
   parentDialogId?: string;
   background?: boolean;
   noStream?: boolean;
-  noDefaultTestRoot?: boolean;
   scriptDir: string;
   env: EnvLike;
   output: OutputLike;
@@ -52,9 +51,9 @@ type RunAgentTurnOptions = {
   localRuntimeAdapter?: AgentRuntimeHostAdapter;
   localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
   localRuntimeCwd?: string;
-  maxToolRounds?: number;
   timeoutMs?: number;
   traceTools?: boolean;
+  eventsMode?: "jsonl";
   taskRunContext?: TaskRunPromptContext;
   taskRunRecorder?: (args: {
     options: RunAgentTurnOptions;
@@ -232,7 +231,7 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
 
 async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
   if (isBuiltinNoloAgentRef(options.agentKey)) return false;
-  if (options.localRuntimeCwd && options.env.NOLO_LOCAL_SHELL_MODE === "worktree") {
+  if (options.localRuntimeCwd) {
     return false;
   }
   if (isKnownServerPlatformAgent(options)) {
@@ -278,7 +277,14 @@ function buildUserInputContent(message: string, imageUrls: string[] = []) {
 }
 
 function shouldTraceLocalTools(options: RunAgentTurnOptions) {
-  return Boolean(options.traceTools || options.env.NOLO_TRACE_TOOLS === "1");
+  const setting = (options.env.NOLO_TRACE_TOOLS ?? "").trim().toLowerCase();
+  if (setting === "0" || setting === "false" || setting === "off") return false;
+  return true;
+}
+
+function resolveAgentEventMode(options: RunAgentTurnOptions): "text" | "jsonl" {
+  if (options.eventsMode === "jsonl") return "jsonl";
+  return options.env.NOLO_AGENT_EVENTS === "jsonl" ? "jsonl" : "text";
 }
 
 function shouldCollectLocalToolEvidence(options: RunAgentTurnOptions) {
@@ -307,15 +313,6 @@ function summarizeLocalToolEvidence(events: LocalAgentToolEvent[]): TaskRunToolE
   };
 }
 
-const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 512;
-
-function parseLocalToolRoundLimitError(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
-  const match = message.match(/Local agent exceeded max tool rounds:\s*(\d+)/);
-  if (!match) return null;
-  return Number(match[1]);
-}
-
 function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
   return Boolean(
     error &&
@@ -326,33 +323,33 @@ function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
   );
 }
 
-function parsePositiveInteger(value: string | undefined) {
-  if (!value) return null;
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) return null;
-  return parsed;
-}
-
-function resolveLocalToolRoundRetryLimit(options: RunAgentTurnOptions) {
-  return (
-    parsePositiveInteger(options.env.NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT) ??
-    DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT
-  );
-}
-
-function nextLocalToolRoundLimit(current: number) {
-  return current <= 0 ? 1 : current * 2;
-}
-
 function formatToolTraceEvent(event: LocalAgentToolEvent) {
   const round = event.round + 1;
+  const detail = event.argumentsPreview ? ` ${event.argumentsPreview}` : "";
   if (event.type === "tool-call") {
-    return `[nolo:tool] round ${round} -> ${event.toolName} (${event.toolCallId})\n`;
+    return `[nolo:tool] #${round} -> ${event.toolName}${detail}\n`;
   }
   if (event.type === "tool-error") {
-    return `[nolo:tool] round ${round} !! ${event.toolName}: ${event.message ?? "failed"}\n`;
+    const elapsed = typeof event.elapsedMs === "number" ? ` ${event.elapsedMs}ms` : "";
+    return `[nolo:tool] #${round} !! ${event.toolName}${elapsed}: ${event.message ?? "failed"}\n`;
   }
-  return `[nolo:tool] round ${round} <- ${event.toolName} (${event.toolCallId})\n`;
+  const elapsed = typeof event.elapsedMs === "number" ? ` ${event.elapsedMs}ms` : "";
+  const summary = event.summary ? ` ${event.summary}` : "";
+  return `[nolo:tool] #${round} <- ${event.toolName}${elapsed}${summary}\n`;
+}
+
+function formatToolJsonEvent(event: LocalAgentToolEvent) {
+  return `${JSON.stringify({
+    schemaVersion: 1,
+    type: event.type,
+    round: event.round + 1,
+    tool: event.toolName,
+    toolCallId: event.toolCallId,
+    ...(event.argumentsPreview ? { argsPreview: event.argumentsPreview } : {}),
+    ...(typeof event.elapsedMs === "number" ? { elapsedMs: event.elapsedMs } : {}),
+    ...(event.summary ? { summary: event.summary } : {}),
+    ...(event.message ? { message: event.message } : {}),
+  })}\n`;
 }
 
 function shouldAttemptAutoLocal(options: RunAgentTurnOptions) {
@@ -629,7 +626,6 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
           : {}),
         ...(options.parentDialogId ? { parentDialogId: options.parentDialogId } : {}),
         ...(options.background ? { background: true } : {}),
-        ...(typeof options.maxToolRounds === "number" ? { maxRounds: options.maxToolRounds } : {}),
         ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
         stream: !options.noStream && !options.background,
       }),
@@ -717,7 +713,7 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
 }
 
 async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
-  return runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: true });
+  return runLocalAgentTurnForCli(options, { reportFailure: true });
 }
 
 async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
@@ -727,53 +723,6 @@ async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
   return Boolean(agentConfig);
 }
 
-async function runLocalAgentTurnWithAutoRoundExpansion(
-  options: RunAgentTurnOptions,
-  settings: { reportFailure: boolean }
-) {
-  const maxRetryLimit = resolveLocalToolRoundRetryLimit(options);
-  let currentMaxToolRounds = options.maxToolRounds;
-  let lastResult: Awaited<ReturnType<typeof runLocalAgentTurnForCli>> | null = null;
-
-  while (true) {
-    const attemptOptions = {
-      ...options,
-      ...(typeof currentMaxToolRounds === "number" ? { maxToolRounds: currentMaxToolRounds } : {}),
-    };
-    const result = await runLocalAgentTurnForCli(attemptOptions, { reportFailure: false });
-    lastResult = result;
-    if (result.exitCode === 0) return result;
-
-    const exhaustedRounds = parseLocalToolRoundLimitError(result.localError);
-    if (exhaustedRounds === null) break;
-
-    const nextMaxToolRounds = nextLocalToolRoundLimit(exhaustedRounds);
-    if (nextMaxToolRounds > maxRetryLimit) break;
-
-    options.output.write(
-      `[nolo] Local agent used all ${exhaustedRounds} tool rounds; retrying with ${nextMaxToolRounds}.\n`
-    );
-    currentMaxToolRounds = nextMaxToolRounds;
-  }
-
-  if (settings.reportFailure && lastResult?.localError) {
-    options.output.write(
-      `[nolo] Local agent run failed: ${
-        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError)
-      }\n`
-    );
-    await recordTaskRunOutcome({
-      options,
-      status: "failed",
-      errorCode: "LOCAL_AGENT_FAILED",
-      resultSummary:
-        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError),
-      toolEvidence: lastResult.toolEvidence,
-    });
-  }
-  return lastResult ?? { exitCode: 1 };
-}
-
 async function runLocalAgentTurnForCli(
   options: RunAgentTurnOptions,
   settings: { reportFailure: boolean }
@@ -790,6 +739,7 @@ async function runLocalAgentTurnForCli(
   try {
     const traceLocalTools = shouldTraceLocalTools(options);
     const collectToolEvidence = shouldCollectLocalToolEvidence(options);
+    const eventMode = resolveAgentEventMode(options);
     const result = await runLocalAgentTurn({
       adapter,
       agentRef: options.agentKey,
@@ -804,7 +754,6 @@ async function runLocalAgentTurnForCli(
       parentDialogId: options.parentDialogId,
       background: options.background,
       noStream: options.noStream,
-      maxToolRounds: options.maxToolRounds,
       ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
       ...(traceLocalTools || collectToolEvidence
         ? {
@@ -812,7 +761,11 @@ async function runLocalAgentTurnForCli(
               if (collectToolEvidence) toolEvents.push(event);
               if (traceLocalTools) {
                 spinner.stop();
-                options.output.write(formatToolTraceEvent(event));
+                options.output.write(
+                  eventMode === "jsonl"
+                    ? formatToolJsonEvent(event)
+                    : formatToolTraceEvent(event)
+                );
               }
             },
           }
@@ -968,7 +921,7 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
   if (runtimeMode === "auto" && shouldAttemptAutoLocal(options)) {
     const skipLocal = await shouldSkipAutoLocalForServerPlatformTools(options);
     if (!skipLocal) {
-      const localResult = await runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: false });
+      const localResult = await runLocalAgentTurnForCli(options, { reportFailure: false });
       if (localResult.exitCode === 0) {
         return {
           exitCode: localResult.exitCode,
@@ -982,7 +935,7 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
         try {
           const refreshed = await refreshMissingLocalAgentConfig(options);
           if (refreshed) {
-            const retriedLocalResult = await runLocalAgentTurnWithAutoRoundExpansion(options, {
+            const retriedLocalResult = await runLocalAgentTurnForCli(options, {
               reportFailure: false,
             });
             if (retriedLocalResult.exitCode === 0) {