nolo-cli 0.1.38 → 0.1.40

package/cli/agentRunCommand.ts

@@ -4,13 +4,7 @@ import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "./agent
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
 import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "../ai/skills/skillDocProtocol";
-import { resolveCliAgentKeyInput } from "./agentAliases";
-import {
-  ensureWorkspacePackageLinks,
-  formatPreparedTaskWorktree,
-  prepareTaskWorktree,
-  type PreparedTaskWorktree,
-} from "./client/taskWorktree";
+import { MIMO_MONTH_AGENT_KEY, resolveCliAgentKeyInput } from "./agentAliases";
 import type { TaskRunPromptContext } from "./client/taskRunPrompt";
 
 type EnvLike = Record<string, string | undefined>;
@@ -25,8 +19,6 @@ type AgentRunCommandDeps = {
   output?: OutputLike;
   runner?: typeof runAgentTurn;
   localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
-  prepareTaskWorktree?: typeof prepareTaskWorktree;
-  ensureWorkspacePackageLinks?: typeof ensureWorkspacePackageLinks;
   inspectLocalRunWorkspace?: typeof inspectLocalRunWorkspace;
   resolveWorkflowReference?: typeof resolveWorkflowReference;
 };
@@ -58,12 +50,11 @@ type ParsedAgentRunArgs = {
   parentDialogId?: string;
   background: boolean;
   noStream: boolean;
-  noDefaultTestRoot: boolean;
   cwd?: string;
-  maxToolRounds?: number;
   timeoutMs?: number;
   traceTools: boolean;
-  useTaskWorktree: boolean;
+  eventsMode?: "jsonl";
+  injectFeatureWorktreeInstruction: boolean;
   taskRunContext?: TaskRunPromptContext;
   workflowRef?: string;
 };
@@ -74,10 +65,6 @@ type ResolvedWorkflowReference = {
   config?: Partial<WorkflowReferenceConfig>;
 };
 
-const DEFAULT_TEST_ROOT_DIALOG_ID = "01KN6V3MVEQA4Q1PNKVM2W7YY8";
-const DEFAULT_TEST_ROOT_DIALOG_KEY = `dialog-b2e06f801f-${DEFAULT_TEST_ROOT_DIALOG_ID}`;
-const DEFAULT_TEST_DIALOG_CATEGORY_ID = "test-dialogs";
-
 function readFlagValue(args: string[], flag: string) {
   const index = args.indexOf(flag);
   if (index < 0) return undefined;
@@ -102,11 +89,19 @@ function runtimeModeFromArgs(args: string[]): AgentRuntimeRequestedMode | undefi
   return undefined;
 }
 
-function parseNonNegativeInteger(value: string | undefined) {
-  if (!value) return undefined;
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed < 0) return undefined;
-  return Math.floor(parsed);
+function isMonthlyMimoAgentRef(raw: string | undefined, resolved: string) {
+  const normalized = raw?.trim().toLowerCase();
+  return (
+    resolved === MIMO_MONTH_AGENT_KEY ||
+    normalized === "fullstack" ||
+    normalized === "full-stack" ||
+    normalized === "nolo-fullstack" ||
+    normalized === "包月mimo" ||
+    normalized === "包月mimo2.5" ||
+    normalized === "mimo-month" ||
+    normalized === "全栈" ||
+    normalized === "nolo 全栈工程师"
+  );
 }
 
 function parsePositiveInteger(value: string | undefined) {
@@ -123,12 +118,10 @@ function positionalArgs(args: string[]) {
     "--server",
     "--auto",
     "--dangerously-allow-shell",
-    "--worktree-task",
     "--trace-tools",
     "--bg",
     "--no-stream",
     "--debug",
-    "--no-default-test-root",
   ]);
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
@@ -146,7 +139,8 @@ export function parseAgentRunArgs(
   args: string[],
   options: ParseAgentRunArgsOptions = {}
 ): ParsedAgentRunArgs | null {
-  const agentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
+  const rawAgentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
+  const agentKey = rawAgentKey ? resolveCliAgentKeyInput(rawAgentKey) : undefined;
   const explicitMsg = readFlagValue(args, "--msg");
   const msgFile = readFlagValue(args, "--msg-file");
   const fileMessage = msgFile
@@ -160,25 +154,19 @@ export function parseAgentRunArgs(
   const spaceId = readFlagValue(args, "--space");
   const category = readFlagValue(args, "--category");
   const inheritedFromDialog = readFlagValue(args, "--inherit-from-dialog");
-  const noDefaultTestRoot = args.includes("--no-default-test-root");
   const cwd = readFlagValue(args, "--cwd");
-  const maxToolRounds = parseNonNegativeInteger(
-    readFlagValue(args, "--max-tool-rounds") ?? readFlagValue(args, "--rounds")
-  );
   const timeoutMs = parsePositiveInteger(readFlagValue(args, "--timeout-ms"));
+  const rawEventsMode = readFlagValue(args, "--events");
+  const eventsMode = rawEventsMode === "jsonl" ? "jsonl" : undefined;
   const inheritedRef = inheritedFromDialog
     ? parseDialogReference(inheritedFromDialog)
-    : !continueDialogId && !noDefaultTestRoot
-      ? {
-          dialogKey: DEFAULT_TEST_ROOT_DIALOG_KEY,
-          dialogId: DEFAULT_TEST_ROOT_DIALOG_ID,
-        }
-      : undefined;
+    : undefined;
   const imageUrls = [
     ...readRepeatedFlagValues(args, "--image"),
     ...readRepeatedFlagValues(args, "--image-url"),
   ];
-  const useTaskWorktree = args.includes("--worktree-task");
+  const mimoLocalWorkspaceDefault =
+    isMonthlyMimoAgentRef(rawAgentKey, agentKey) && runtimeMode !== "server";
   const workflowRef = readFlagValue(args, "--workflow");
   const taskRowDbKey = readFlagValue(args, "--task-row-dbkey");
   const artifactIds = readFlagValue(args, "--artifact-ids")
@@ -186,12 +174,13 @@ export function parseAgentRunArgs(
     .map((item) => item.trim())
     .filter(Boolean);
   return {
-    agentKey: resolveCliAgentKeyInput(agentKey),
+    agentKey,
     message,
     imageUrls,
-    allowShell: args.includes("--dangerously-allow-shell"),
+    allowShell: args.includes("--dangerously-allow-shell") || mimoLocalWorkspaceDefault,
     traceTools: args.includes("--trace-tools"),
-    useTaskWorktree,
+    ...(eventsMode ? { eventsMode } : {}),
+    injectFeatureWorktreeInstruction: mimoLocalWorkspaceDefault,
     ...(workflowRef ? { workflowRef } : {}),
     ...(taskRowDbKey
       ? {
@@ -203,17 +192,19 @@ export function parseAgentRunArgs(
           },
         }
       : {}),
-    ...(runtimeMode ? { runtimeMode } : useTaskWorktree ? { runtimeMode: "local" as const } : {}),
+    ...(runtimeMode
+      ? { runtimeMode }
+      : mimoLocalWorkspaceDefault || args.includes("--dangerously-allow-shell")
+        ? { runtimeMode: "local" as const }
+        : {}),
     background: args.includes("--bg"),
     noStream: args.includes("--no-stream"),
-    noDefaultTestRoot,
     ...(continueDialogId ? { continueDialogId } : {}),
     ...(!continueDialogId && spaceId ? { spaceId } : {}),
-    ...(category ? { category } : !continueDialogId && !noDefaultTestRoot ? { category: DEFAULT_TEST_DIALOG_CATEGORY_ID } : {}),
+    ...(category ? { category } : {}),
     ...(inheritedRef?.dialogKey ? { inheritedFromDialogKey: inheritedRef.dialogKey } : {}),
     ...(inheritedRef?.dialogId ? { parentDialogId: inheritedRef.dialogId } : {}),
     ...(cwd ? { cwd } : {}),
-    ...(typeof maxToolRounds === "number" ? { maxToolRounds } : {}),
     ...(typeof timeoutMs === "number" ? { timeoutMs } : {}),
   };
 }
@@ -269,6 +260,20 @@ export function prependWorkflowReferencePrompt(message: string, workflow?: Resol
   ].join("\n");
 }
 
+function prependFeatureWorktreeInstruction(message: string, enabled: boolean) {
+  if (!enabled) return message;
+  return [
+    "Local execution rule:",
+    "- You are running in the current git checkout with shell access.",
+    "- For read-only checks, smoke tests, or answering questions, stay in the current directory.",
+    "- Before developing a new feature or making non-trivial code changes, create a separate git worktree yourself with git worktree and do the edits there.",
+    "- Commit and push only when the user explicitly asks or the task requires it.",
+    "",
+    "User task:",
+    message,
+  ].join("\n");
+}
+
 function parseDialogReference(rawInput: string) {
   const normalized = rawInput.trim();
   if (normalized.startsWith("dialog-")) {
@@ -381,26 +386,20 @@ function resolveServerUrl(env: EnvLike) {
   return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
-function shouldPrepareTaskWorktree(parsed: ParsedAgentRunArgs) {
-  return !parsed.cwd && (parsed.useTaskWorktree || parsed.allowShell);
-}
-
-function buildTaskWorktreeEnv(args: {
+function buildLocalRunEnv(args: {
   env: EnvLike;
-  worktreePath?: string;
   allowShell: boolean;
 }) {
+  void args.allowShell;
   return {
     ...args.env,
-    ...(args.allowShell ? { NOLO_LOCAL_SHELL_MODE: "worktree" } : {}),
-    ...(args.worktreePath ? { NOLO_LOCAL_WORKTREE: args.worktreePath } : {}),
   };
 }
 
 function writeUsage(output: OutputLike) {
   output.write(
-    "Usage: nolo agent run <agent> <message> [--local|--server|--auto] [--continue <dialogId>] [--cwd <path>] [--max-tool-rounds <n>]\n" +
-      "       nolo agent run --agent <agent> (--msg <message>|--msg-file <path>) [--image <url-or-path>] [--space <spaceId>] [--category <name>] [--inherit-from-dialog <dialog>] [--task-row-dbkey <key>] [--bg] [--timeout-ms <n>] [--no-stream]\n"
+    "Usage: nolo agent run <agent> <message> [--local|--server|--auto] [--continue <dialogId>] [--cwd <path>]\n" +
+      "       nolo agent run --agent <agent> (--msg <message>|--msg-file <path>) [--image <url-or-path>] [--space <spaceId>] [--category <name>] [--inherit-from-dialog <dialog>] [--task-row-dbkey <key>] [--bg] [--timeout-ms <n>] [--events jsonl] [--no-stream]\n"
   );
 }
 
@@ -426,52 +425,24 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     }
   }
   let localRuntimeCwd = parsed.cwd;
-  if (shouldPrepareTaskWorktree(parsed)) {
-    try {
-      const preparedWorktree = await (deps.prepareTaskWorktree ?? prepareTaskWorktree)({
-        agentKey: parsed.agentKey,
-        env,
-      });
-      localRuntimeCwd = preparedWorktree.path;
-      output.write(formatPreparedTaskWorktree(preparedWorktree));
-    } catch (error) {
-      output.write(
-        "[nolo] Could not prepare a local task worktree.\n" +
-          "Run from inside a git repository, or set NOLO_LOCAL_WORKTREE to an existing isolated checkout.\n" +
-          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
-      );
-      return 1;
-    }
-  }
-  const shouldBindLocalWorkspace =
-    !!localRuntimeCwd &&
-    (parsed.runtimeMode === "local" || parsed.allowShell || parsed.useTaskWorktree);
-  if (shouldBindLocalWorkspace) {
-    try {
-      await (deps.ensureWorkspacePackageLinks ?? ensureWorkspacePackageLinks)(
-        localRuntimeCwd!
-      );
-    } catch (error) {
-      output.write(
-        "[nolo] Dependency preflight failed for local task worktree.\n" +
-          "The worktree may have node_modules entries that point outside the task checkout, or paths that cannot be repaired safely.\n" +
-          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
-      );
-      return 1;
-    }
+  if (!localRuntimeCwd && parsed.runtimeMode === "local") {
+    localRuntimeCwd = process.cwd();
   }
-  const runEnv = shouldBindLocalWorkspace
-    ? buildTaskWorktreeEnv({
-        env,
-        worktreePath: localRuntimeCwd,
-        allowShell: parsed.allowShell,
-      })
-    : env;
+  const runEnv = buildLocalRunEnv({
+    env,
+    allowShell: parsed.allowShell,
+  });
   const result: RunAgentTurnResult = await runner({
     agentName: parsed.agentKey,
     agentKey: parsed.agentKey,
     serverUrl: resolveServerUrl(env),
-    message: prependWorkflowReferencePrompt(parsed.message, workflowReference),
+    message: prependWorkflowReferencePrompt(
+      prependFeatureWorktreeInstruction(
+        parsed.message,
+        parsed.injectFeatureWorktreeInstruction
+      ),
+      workflowReference
+    ),
     imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
     scriptDir: deps.scriptDir,
     env: runEnv,
@@ -488,10 +459,9 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     ...(parsed.parentDialogId ? { parentDialogId: parsed.parentDialogId } : {}),
     background: parsed.background,
     noStream: parsed.noStream,
-    noDefaultTestRoot: parsed.noDefaultTestRoot,
-    ...(typeof parsed.maxToolRounds === "number" ? { maxToolRounds: parsed.maxToolRounds } : {}),
     ...(typeof parsed.timeoutMs === "number" ? { timeoutMs: parsed.timeoutMs } : {}),
     traceTools: parsed.traceTools,
+    ...(parsed.eventsMode ? { eventsMode: parsed.eventsMode } : {}),
     ...(parsed.taskRunContext ? { taskRunContext: parsed.taskRunContext } : {}),
   });
 

package/cli/agentRuntimeLocal.ts

@@ -5,12 +5,9 @@ export {
   hasDirectOpenAiCompatibleProvider,
   createHybridRecordStore,
   executeLocalToolWithPolicy,
-  activateWorkspaceSession,
-  createWorkspaceSession,
   buildAgentRuntimeAgentLookupKeys,
   buildAgentRuntimeDialogWritePlan,
   dialogMessageRecordToAgentRuntimeMessage,
-  formatWorkspaceSessionActivation,
   pickAgentRuntimeInferenceOptions,
   parseOpenAiCompatibleChatCompletionResponse,
   parsePlatformChatCompletionData,
@@ -23,6 +20,7 @@ export {
   resolveLocalToolPolicy,
   resolveOpenAiCompatibleProviderConfig,
   resolveRequestedRuntimeToolNames,
+  resolveRuntimeToolSurfaceForAgent,
   evaluateShellCommandPolicy,
   isDestructiveShellCommand,
   shouldUsePlatformChatProvider,
@@ -44,8 +42,4 @@ export type {
   HybridRecordKvDb,
   HybridRecordStore,
   LocalToolPolicyDecision,
-  PreparedTaskWorkspace,
-  PrepareTaskWorkspace,
-  WorkspaceSession,
-  WorkspaceSessionMode,
 } from "../agent-runtime";

package/cli/cliEnvHelpers.ts

@@ -96,14 +96,18 @@ export function resolveAuthToken(
 }
 
 export function parseUserIdFromAuthToken(token: string) {
-  const payload = token.trim().split(".")[0];
-  if (!payload) return "";
-  try {
-    const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
-    return typeof parsed?.userId === "string" ? parsed.userId : "";
-  } catch {
-    return "";
+  const parts = token.trim().split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  for (const payload of payloadCandidates) {
+    if (!payload) continue;
+    try {
+      const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+      if (typeof parsed?.userId === "string") return parsed.userId;
+    } catch {
+      // Try the next token shape.
+    }
   }
+  return "";
 }
 
 export function readOption(args: string[], flag: string) {

package/cli/client/agentRun.ts

@@ -9,7 +9,7 @@ import {
 } from "../agentAliases";
 import type { LocalAgentToolEvent } from "../../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
-import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+import { createCliLocalRuntimeAdapter, isBuiltinNoloAgentRef } from "./localRuntimeAdapter";
 import { createStreamingTextWriter } from "./streamingOutput";
 import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
 
@@ -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;
@@ -180,10 +179,27 @@ function isKnownServerPlatformAgent(options: RunAgentTurnOptions) {
   const normalizedKey = normalizeAgentRef(options.agentKey);
   return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
 }
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
-}
+
+function isMachineBoundLocalhostCustomProvider(agentConfig: any) {
+  const machineId =
+    agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object"
+      ? String(agentConfig.runtimeBinding.machineId ?? "").trim()
+      : "";
+  const providerUrl = typeof agentConfig?.customProviderUrl === "string"
+    ? agentConfig.customProviderUrl.trim()
+    : "";
+  if (!machineId || !providerUrl) return false;
+  try {
+    const hostname = new URL(providerUrl).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
 
 function shouldShowUsage(env: EnvLike) {
   return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
@@ -214,6 +230,10 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
 }
 
 async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
+  if (isBuiltinNoloAgentRef(options.agentKey)) return false;
+  if (options.localRuntimeCwd) {
+    return false;
+  }
   if (isKnownServerPlatformAgent(options)) {
     options.output.write(
       `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
@@ -229,6 +249,13 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   } catch {
     return false;
   }
+  if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. ` +
+        "Use --local explicitly to force the current machine.\n"
+    );
+    return true;
+  }
   const serverTools = resolveServerPlatformToolNames(agentConfig);
   if (serverTools.length === 0) return false;
   options.output.write(
@@ -250,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) {
@@ -279,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 &&
@@ -298,37 +323,44 @@ 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) {
   if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
+  if (
+    options.env.NOLO_DISABLE_CLI_WORKSPACE_TOOLS !== "1" &&
+    isBuiltinNoloAgentRef(options.agentKey) &&
+    resolveAuthToken(options.env)
+  ) {
+    return true;
+  }
   return Boolean(
     options.env.NOLO_LOCAL_OPENAI_API_KEY ||
       options.env.OPENAI_API_KEY ||
@@ -594,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,
       }),
@@ -632,8 +663,21 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
 
   if (!res.ok) {
     options.output.write(`[nolo] Agent request failed: HTTP ${res.status}\n`);
-    if (data?.error || data?.message) {
-      options.output.write(`${data.error || data.message}\n`);
+    const errorText = typeof data?.error === "string" ? data.error.trim() : "";
+    const messageText = typeof data?.message === "string" ? data.message.trim() : "";
+    const reasonText = typeof data?.reason === "string" ? data.reason.trim() : "";
+    const codeText = typeof data?.code === "string" ? data.code.trim() : "";
+    if (errorText || messageText) {
+      options.output.write(`${errorText || messageText}\n`);
+      if (messageText && messageText !== errorText) {
+        options.output.write(`${messageText}\n`);
+      }
+      if (codeText && codeText !== errorText && codeText !== messageText) {
+        options.output.write(`code=${codeText}\n`);
+      }
+      if (reasonText && reasonText !== errorText && reasonText !== messageText) {
+        options.output.write(`reason=${reasonText}\n`);
+      }
     }
     await recordTaskRunOutcome({
       options,
@@ -669,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) {
@@ -679,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 }
@@ -742,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,
@@ -756,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
         ? {
@@ -764,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)
+                );
               }
             },
           }
@@ -920,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,
@@ -934,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) {