nolo-cli 0.1.39 → 0.1.41

package/cli/agentRunCommand.ts

@@ -50,11 +50,10 @@ type ParsedAgentRunArgs = {
   parentDialogId?: string;
   background: boolean;
   noStream: boolean;
-  noDefaultTestRoot: boolean;
   cwd?: string;
-  maxToolRounds?: number;
   timeoutMs?: number;
   traceTools: boolean;
+  eventsMode?: "jsonl";
   injectFeatureWorktreeInstruction: boolean;
   taskRunContext?: TaskRunPromptContext;
   workflowRef?: string;
@@ -66,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;
@@ -109,13 +104,6 @@ function isMonthlyMimoAgentRef(raw: string | undefined, resolved: string) {
   );
 }
 
-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 parsePositiveInteger(value: string | undefined) {
   if (!value) return undefined;
   const parsed = Number(value);
@@ -134,7 +122,6 @@ function positionalArgs(args: string[]) {
     "--bg",
     "--no-stream",
     "--debug",
-    "--no-default-test-root",
   ]);
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
@@ -167,20 +154,13 @@ 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"),
@@ -199,6 +179,7 @@ export function parseAgentRunArgs(
     imageUrls,
     allowShell: args.includes("--dangerously-allow-shell") || mimoLocalWorkspaceDefault,
     traceTools: args.includes("--trace-tools"),
+    ...(eventsMode ? { eventsMode } : {}),
     injectFeatureWorktreeInstruction: mimoLocalWorkspaceDefault,
     ...(workflowRef ? { workflowRef } : {}),
     ...(taskRowDbKey
@@ -218,14 +199,12 @@ export function parseAgentRunArgs(
         : {}),
     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 } : {}),
   };
 }
@@ -411,16 +390,16 @@ function buildLocalRunEnv(args: {
   env: EnvLike;
   allowShell: boolean;
 }) {
+  void args.allowShell;
   return {
     ...args.env,
-    ...(args.allowShell ? { NOLO_LOCAL_SHELL_MODE: "worktree" } : {}),
   };
 }
 
 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"
   );
 }
 
@@ -480,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

@@ -20,6 +20,7 @@ export {
   resolveLocalToolPolicy,
   resolveOpenAiCompatibleProviderConfig,
   resolveRequestedRuntimeToolNames,
+  resolveRuntimeToolSurfaceForAgent,
   evaluateShellCommandPolicy,
   isDestructiveShellCommand,
   shouldUsePlatformChatProvider,

package/cli/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;
@@ -198,6 +197,16 @@ function isMachineBoundLocalhostCustomProvider(agentConfig: any) {
   }
 }
 
+function isCliProviderAgentConfig(agentConfig: any) {
+  const cliProvider = typeof agentConfig?.cliProvider === "string"
+    ? agentConfig.cliProvider.trim()
+    : "";
+  const provider = typeof agentConfig?.provider === "string"
+    ? agentConfig.provider.trim()
+    : "";
+  return Boolean(cliProvider) || provider === "agy" || provider === "codex" || provider === "claude";
+}
+
 function resolveAuthToken(env: EnvLike) {
   return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
 }
@@ -232,24 +241,33 @@ 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)) {
-    options.output.write(
-      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
-        "Use --local explicitly to force local workspace tools.\n"
-    );
-    return true;
-  }
+  const knownServerPlatformAgent = isKnownServerPlatformAgent(options);
   const adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) return false;
+  if (!adapter) return knownServerPlatformAgent;
   let agentConfig;
   try {
     agentConfig = await adapter.loadAgentConfig(options.agentKey);
   } catch {
+    if (knownServerPlatformAgent) {
+      options.output.write(
+        `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
+          "Use --local explicitly to force local workspace tools.\n"
+      );
+      return true;
+    }
     return false;
   }
+  if (isCliProviderAgentConfig(agentConfig)) return false;
+  if (knownServerPlatformAgent) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
+        "Use --local explicitly to force local workspace tools.\n"
+    );
+    return true;
+  }
   if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
     options.output.write(
       `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. ` +
@@ -278,7 +296,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 +332,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 +342,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 +645,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 +732,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 +742,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 +758,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 +773,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 +780,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 +940,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 +954,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) {