nolo-cli 0.1.19 → 0.1.21

package/client/agentRun.ts

@@ -1,16 +1,30 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { runLocalAgentTurn } from "../agentRuntimeLocal";
+import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 import { createStreamingTextWriter } from "./streamingOutput";
+import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
 
 type EnvLike = Record<string, string | undefined>;
 
-type OutputLike = {
-  write(chunk: string): unknown;
-};
-
+type OutputLike = {
+  write(chunk: string): unknown;
+};
+
+type TaskRunAgentRole = "pm" | "frontend" | "fullstack" | "reviewer" | "codex";
+type TaskRunReviewStatus = "passed" | "needs_changes" | "blocked";
+type TaskRunToolEvidence = {
+  toolsUsed: string[];
+  summary: {
+    callCount: number;
+    resultCount: number;
+    errorCount: number;
+    rounds: number;
+  };
+};
+
 type RunAgentTurnOptions = {
   agentName: string;
   agentKey: string;
@@ -18,13 +32,32 @@ type RunAgentTurnOptions = {
   message: string;
   imageUrls?: string[];
   continueDialogId?: string;
-  scriptDir: string;
+  spaceId?: string;
+  category?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
+  background?: boolean;
+  noStream?: boolean;
+  noDefaultTestRoot?: boolean;
+  scriptDir: string;
   env: EnvLike;
   output: OutputLike;
   runtimeMode?: AgentRuntimeRequestedMode;
   localRuntimeAdapter?: AgentRuntimeHostAdapter;
-  localRuntimeAdapterFactory?: (env: EnvLike) => AgentRuntimeHostAdapter;
+  localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
   localRuntimeCwd?: string;
+  maxToolRounds?: number;
+  timeoutMs?: number;
+  traceTools?: boolean;
+  taskRunContext?: TaskRunPromptContext;
+  taskRunRecorder?: (args: {
+    options: RunAgentTurnOptions;
+    status: "completed" | "failed";
+    dialogId?: string;
+    resultSummary?: string;
+    errorCode?: string;
+    toolEvidence?: TaskRunToolEvidence;
+  }) => Promise<void>;
   scriptPathExists?: (path: string) => boolean;
   fetchImpl?: typeof fetch;
 };
@@ -34,14 +67,31 @@ export type RunAgentTurnResult = {
   dialogId?: string;
 };
 
-type ScriptBridgeDecision = {
-  hasAuthToken: boolean;
-  scriptPathExists: boolean;
-};
-
-export function shouldUseScriptBridge(decision: ScriptBridgeDecision) {
-  return !decision.hasAuthToken && decision.scriptPathExists;
-}
+type ScriptBridgeDecision = {
+  hasAuthToken: boolean;
+  scriptPathExists: boolean;
+};
+
+const SERVER_PLATFORM_TOOL_NAMES = new Set([
+  "addTableRow",
+  "addTableRows",
+  "deleteTableRow",
+  "deleteTableRows",
+  "queryTableRows",
+  "streamParallelAgents",
+  "taskRun",
+  "updateTableRow",
+  "updateTableRows",
+]);
+
+export function shouldUseScriptBridge(decision: ScriptBridgeDecision) {
+  return !decision.hasAuthToken && decision.scriptPathExists;
+}
+
+export function findServerPlatformTools(toolNames?: string[]) {
+  if (!Array.isArray(toolNames)) return [];
+  return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
+}
 
 function resolveAuthToken(env: EnvLike) {
   return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
@@ -63,9 +113,36 @@ function buildDefaultLocalRuntimeAdapter(options: RunAgentTurnOptions) {
     env: options.env,
     fetchImpl: options.fetchImpl,
     cwd: options.localRuntimeCwd,
+    output: options.output,
   });
 }
 
+function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
+  return (
+    options.localRuntimeAdapter ||
+    options.localRuntimeAdapterFactory?.(options.env, { cwd: options.localRuntimeCwd }) ||
+    buildDefaultLocalRuntimeAdapter(options)
+  );
+}
+
+async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
+  const adapter = resolveLocalRuntimeAdapter(options);
+  if (!adapter) return false;
+  let agentConfig;
+  try {
+    agentConfig = await adapter.loadAgentConfig(options.agentKey);
+  } catch {
+    return false;
+  }
+  const serverTools = findServerPlatformTools(agentConfig?.toolNames);
+  if (serverTools.length === 0) return false;
+  options.output.write(
+    `[nolo] auto runtime: skipping local runtime because ${options.agentKey} declares server platform tools ` +
+      `(${serverTools.join(", ")}). Use --local explicitly to force local workspace tools.\n`
+  );
+  return true;
+}
+
 function buildUserInputContent(message: string, imageUrls: string[] = []) {
   if (imageUrls.length === 0) return message;
   return [
@@ -77,6 +154,74 @@ function buildUserInputContent(message: string, imageUrls: string[] = []) {
   ];
 }
 
+function shouldTraceLocalTools(options: RunAgentTurnOptions) {
+  return Boolean(options.traceTools || options.env.NOLO_TRACE_TOOLS === "1");
+}
+
+function shouldCollectLocalToolEvidence(options: RunAgentTurnOptions) {
+  return Boolean(options.taskRunContext?.rowDbKey);
+}
+
+function summarizeLocalToolEvidence(events: LocalAgentToolEvent[]): TaskRunToolEvidence | undefined {
+  if (events.length === 0) return undefined;
+  const toolsUsed = [
+    ...new Set(
+      events
+        .filter((event) => event.type === "tool-call")
+        .map((event) => event.toolName)
+        .filter(Boolean)
+    ),
+  ];
+  const rounds = new Set(events.map((event) => event.round)).size;
+  return {
+    toolsUsed,
+    summary: {
+      callCount: events.filter((event) => event.type === "tool-call").length,
+      resultCount: events.filter((event) => event.type === "tool-result").length,
+      errorCount: events.filter((event) => event.type === "tool-error").length,
+      rounds,
+    },
+  };
+}
+
+const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 128;
+
+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 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;
+  if (event.type === "tool-call") {
+    return `[nolo:tool] round ${round} -> ${event.toolName} (${event.toolCallId})\n`;
+  }
+  if (event.type === "tool-error") {
+    return `[nolo:tool] round ${round} !! ${event.toolName}: ${event.message ?? "failed"}\n`;
+  }
+  return `[nolo:tool] round ${round} <- ${event.toolName} (${event.toolCallId})\n`;
+}
+
 function shouldAttemptAutoLocal(options: RunAgentTurnOptions) {
   if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
   return Boolean(
@@ -87,6 +232,174 @@ function shouldAttemptAutoLocal(options: RunAgentTurnOptions) {
       options.env.NOLO_LOCAL_AGENT_KEY
   );
 }
+
+function inferTaskRunAgentRole(agentRef: string): TaskRunAgentRole {
+  const normalized = agentRef.toLowerCase();
+  if (normalized.includes("project-manager") || normalized.includes("manager")) return "pm";
+  if (normalized.includes("frontend")) return "frontend";
+  if (normalized.includes("fullstack")) return "fullstack";
+  if (normalized.includes("review")) return "reviewer";
+  return "codex";
+}
+
+export function classifyTaskRunReviewStatus(summary?: string): TaskRunReviewStatus | undefined {
+  const normalized = summary?.toLowerCase().trim();
+  if (!normalized) return undefined;
+
+  const explicit = normalized.match(/review\s+decision\s*:\s*(passed|needs_changes|blocked)/);
+  if (explicit?.[1]) return explicit[1] as TaskRunReviewStatus;
+
+  if (/\b(blocked|cannot review|unable to review)\b|无法审查|阻塞/.test(normalized)) {
+    return "blocked";
+  }
+  if (
+    /\b(needs changes|request changes|changes requested|not approved)\b|需要修改|需修改|发现问题/.test(
+      normalized
+    )
+  ) {
+    return "needs_changes";
+  }
+  if (/\b(approved|lgtm|no issues|passed)\b|通过|无问题/.test(normalized)) {
+    return "passed";
+  }
+  return undefined;
+}
+
+async function runTaskRunCli(args: {
+  options: RunAgentTurnOptions;
+  cliArgs: string[];
+}) {
+  const scriptPath = join(args.options.scriptDir, "taskRun.ts");
+  const proc = Bun.spawn({
+    cmd: [process.execPath, scriptPath, ...args.cliArgs],
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      ...args.options.env,
+      BASE_URL: args.options.serverUrl,
+    },
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    throw new Error((stderr || stdout || `taskRun.ts exited ${exitCode}`).trim());
+  }
+}
+
+async function defaultTaskRunRecorder(args: {
+  options: RunAgentTurnOptions;
+  status: "completed" | "failed";
+  dialogId?: string;
+  resultSummary?: string;
+  errorCode?: string;
+  toolEvidence?: TaskRunToolEvidence;
+}) {
+  const context = args.options.taskRunContext;
+  if (!context?.rowDbKey) return;
+  const role = inferTaskRunAgentRole(args.options.agentName || args.options.agentKey);
+  if (role === "reviewer") {
+    await runTaskRunCli({
+      options: args.options,
+      cliArgs: [
+        "request-review",
+        "--row-dbkey",
+        context.rowDbKey,
+        "--base-url",
+        args.options.serverUrl,
+        "--reviewer-agent-key",
+        args.options.agentKey,
+        ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
+        ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
+      ],
+    });
+  }
+  await runTaskRunCli({
+    options: args.options,
+    cliArgs: [
+      "record-agent-run",
+      "--row-dbkey",
+      context.rowDbKey,
+      "--base-url",
+      args.options.serverUrl,
+      "--agent-key",
+      args.options.agentKey,
+      "--role",
+      role,
+      "--run-status",
+      args.status,
+      ...(context.workItemId ? ["--work-item-id", context.workItemId] : []),
+      ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
+      ...(args.resultSummary ? ["--result-summary", args.resultSummary.slice(0, 240)] : []),
+      ...(args.errorCode ? ["--error-code", args.errorCode] : []),
+      ...(args.toolEvidence?.toolsUsed?.length
+        ? ["--tools-used", args.toolEvidence.toolsUsed.join(",")]
+        : []),
+      ...(args.toolEvidence?.summary
+        ? ["--tool-trace-summary", JSON.stringify(args.toolEvidence.summary)]
+        : []),
+    ],
+  });
+  if (context.workItemId && args.dialogId) {
+    await runTaskRunCli({
+      options: args.options,
+      cliArgs: [
+        "update-work-item",
+        "--row-dbkey",
+        context.rowDbKey,
+        "--base-url",
+        args.options.serverUrl,
+        "--id",
+        context.workItemId,
+        "--dialog-ids",
+        args.dialogId,
+      ],
+    });
+  }
+  if (role === "reviewer") {
+    const reviewStatus =
+      args.status === "failed" ? "blocked" : classifyTaskRunReviewStatus(args.resultSummary);
+    if (reviewStatus) {
+      await runTaskRunCli({
+        options: args.options,
+        cliArgs: [
+          "review-result",
+          "--row-dbkey",
+          context.rowDbKey,
+          "--base-url",
+          args.options.serverUrl,
+          "--review-status",
+          reviewStatus,
+          "--reviewer-agent-key",
+          args.options.agentKey,
+          ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
+          ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
+        ],
+      });
+    }
+  }
+}
+
+async function recordTaskRunOutcome(args: {
+  options: RunAgentTurnOptions;
+  status: "completed" | "failed";
+  dialogId?: string;
+  resultSummary?: string;
+  errorCode?: string;
+  toolEvidence?: TaskRunToolEvidence;
+}) {
+  if (!args.options.taskRunContext?.rowDbKey) return;
+  try {
+    await (args.options.taskRunRecorder ?? defaultTaskRunRecorder)(args);
+  } catch (error) {
+    args.options.output.write(
+      `[nolo] task-run writeback failed: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+  }
+}
 
 function formatUsage(usage: any, dialogId: unknown) {
   const parts: string[] = [];
@@ -134,12 +447,32 @@ async function runScriptBridge(options: RunAgentTurnOptions, scriptPath: string)
       options.agentKey,
       "--server",
       options.serverUrl,
-      "--msg",
-      options.message,
-      "--no-default-test-root",
-      ...(options.continueDialogId
-        ? ["--continue", options.continueDialogId]
-        : []),
+      "--msg",
+      options.message,
+      ...(options.taskRunContext?.rowDbKey
+        ? ["--task-row-dbkey", options.taskRunContext.rowDbKey]
+        : []),
+      ...(options.taskRunContext?.taskRunId
+        ? ["--task-run-id", options.taskRunContext.taskRunId]
+        : []),
+      ...(options.taskRunContext?.workItemId
+        ? ["--work-item-id", options.taskRunContext.workItemId]
+        : []),
+      ...(options.taskRunContext?.artifactIds?.length
+        ? ["--artifact-ids", options.taskRunContext.artifactIds.join(",")]
+        : []),
+      ...(options.noDefaultTestRoot ? ["--no-default-test-root"] : []),
+      ...(options.continueDialogId
+        ? ["--continue", options.continueDialogId]
+        : []),
+      ...(options.spaceId ? ["--space", options.spaceId] : []),
+      ...(options.category ? ["--category", options.category] : []),
+      ...(options.inheritedFromDialogKey
+        ? ["--inherit-from-dialog", options.inheritedFromDialogKey]
+        : []),
+      ...(options.background ? ["--bg"] : []),
+      ...(typeof options.timeoutMs === "number" ? ["--timeout-ms", String(options.timeoutMs)] : []),
+      ...(options.noStream ? ["--no-stream"] : []),
     ],
     stdin: "inherit",
     stdout: "inherit",
@@ -151,12 +484,12 @@ async function runScriptBridge(options: RunAgentTurnOptions, scriptPath: string)
     },
   });
 
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    options.output.write(`\n[nolo] Agent run exited with code ${exitCode}.\n`);
-  }
-  return { exitCode };
-}
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    options.output.write(`\n[nolo] Agent run exited with code ${exitCode}.\n`);
+  }
+  return { exitCode };
+}
 
 async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string) {
   options.output.write(`\n${options.agentName} -> working...\n`);
@@ -172,7 +505,10 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
       },
       body: JSON.stringify({
         agentKey: options.agentKey,
-        userInput: buildUserInputContent(options.message, options.imageUrls),
+        userInput: buildUserInputContent(
+          prependTaskRunPrompt(options.message, options.taskRunContext),
+          options.imageUrls
+        ),
         runtimeContext: {
           surface: "cli",
           host: "terminal",
@@ -180,21 +516,37 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
           entrypoint: "nolo-cli",
           capabilities: ["text-io", "streaming", "slash-commands"],
         },
-        ...(options.continueDialogId
-          ? { continueDialogId: options.continueDialogId }
-          : {}),
-        stream: true,
-      }),
+        ...(options.continueDialogId
+          ? { continueDialogId: options.continueDialogId }
+          : {}),
+        ...(options.spaceId ? { spaceId: options.spaceId } : {}),
+        ...(options.category ? { category: options.category } : {}),
+        ...(options.inheritedFromDialogKey
+          ? { inheritedFromDialogKey: options.inheritedFromDialogKey }
+          : {}),
+        ...(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,
+      }),
     });
   } catch (error) {
     options.output.write(buildTransportErrorHint(options.serverUrl, error));
     return { exitCode: 1 };
   }
 
-  const contentType = res.headers.get("content-type") || "";
-  if (contentType.includes("text/event-stream") && res.body) {
-    return readStreamingAgentRun(options, res);
-  }
+  const contentType = res.headers.get("content-type") || "";
+  if (contentType.includes("text/event-stream") && res.body) {
+    const result = await readStreamingAgentRun(options, res);
+    await recordTaskRunOutcome({
+      options,
+      status: result.exitCode === 0 ? "completed" : "failed",
+      dialogId: result.dialogId,
+      ...(result.exitCode !== 0 ? { errorCode: "STREAM_FAILED" } : {}),
+    });
+    return result;
+  }
 
   let data: any = {};
   try {
@@ -203,13 +555,19 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
     data = {};
   }
 
-  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`);
-    }
-    return { exitCode: 1 };
-  }
+  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`);
+    }
+    await recordTaskRunOutcome({
+      options,
+      status: "failed",
+      errorCode: `HTTP_${res.status}`,
+      resultSummary: String(data?.error || data?.message || "").trim() || undefined,
+    });
+    return { exitCode: 1 };
+  }
 
   const content = String(data?.content ?? data?.message ?? "").trim();
   if (content) {
@@ -218,40 +576,112 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
     options.output.write(`\n${options.agentName} > (no text response)\n`);
   }
 
-  const usage = formatUsage(data?.usage, data?.dialogId);
-  if (usage && shouldShowUsage(options.env)) options.output.write(`${usage}\n`);
-  return {
-    exitCode: 0,
-    ...(typeof data?.dialogId === "string" && data.dialogId
-      ? { dialogId: data.dialogId }
-      : {}),
-  };
+  const usage = formatUsage(data?.usage, data?.dialogId);
+  if (usage && shouldShowUsage(options.env)) options.output.write(`${usage}\n`);
+  const result = {
+    exitCode: 0,
+    ...(typeof data?.dialogId === "string" && data.dialogId
+      ? { dialogId: data.dialogId }
+      : {}),
+  };
+  await recordTaskRunOutcome({
+    options,
+    status: "completed",
+    dialogId: result.dialogId,
+    resultSummary: content || undefined,
+  });
+  return result;
 }
 
 async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
-  return runLocalAgentTurnForCli(options, { reportFailure: true });
+  return runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: true });
+}
+
+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 }
 ) {
-  const adapter =
-    options.localRuntimeAdapter ||
-    options.localRuntimeAdapterFactory?.(options.env) ||
-    buildDefaultLocalRuntimeAdapter(options);
+  const adapter = resolveLocalRuntimeAdapter(options);
   if (!adapter) {
     options.output.write("[nolo] Local runtime was requested but no local runtime adapter is available.\n");
     return { exitCode: 1 };
   }
 
   options.output.write(`\n${options.agentName} -> working locally...\n`);
+  const toolEvents: LocalAgentToolEvent[] = [];
   try {
+    const traceLocalTools = shouldTraceLocalTools(options);
+    const collectToolEvidence = shouldCollectLocalToolEvidence(options);
     const result = await runLocalAgentTurn({
       adapter,
       agentRef: options.agentKey,
-      input: buildUserInputContent(options.message, options.imageUrls),
+      input: buildUserInputContent(
+        prependTaskRunPrompt(options.message, options.taskRunContext),
+        options.imageUrls
+      ),
       continueDialogId: options.continueDialogId,
+      spaceId: options.spaceId,
+      category: options.category,
+      inheritedFromDialogKey: options.inheritedFromDialogKey,
+      parentDialogId: options.parentDialogId,
+      background: options.background,
+      noStream: options.noStream,
+      maxToolRounds: options.maxToolRounds,
+      ...(traceLocalTools || collectToolEvidence
+        ? {
+            onToolEvent: (event) => {
+              if (collectToolEvidence) toolEvents.push(event);
+              if (traceLocalTools) options.output.write(formatToolTraceEvent(event));
+            },
+          }
+        : {}),
     });
     const content = result.content.trim();
     if (content) {
@@ -259,6 +689,13 @@ async function runLocalAgentTurnForCli(
     } else {
       options.output.write(`\n${options.agentName} > (no text response)\n`);
     }
+    await recordTaskRunOutcome({
+      options,
+      status: "completed",
+      dialogId: result.dialogId,
+      resultSummary: content || undefined,
+      toolEvidence: summarizeLocalToolEvidence(toolEvents),
+    });
     return { exitCode: 0, dialogId: result.dialogId };
   } catch (error) {
     if (settings.reportFailure) {
@@ -268,7 +705,7 @@ async function runLocalAgentTurnForCli(
         }\n`
       );
     }
-    return { exitCode: 1, localError: error };
+    return { exitCode: 1, localError: error, toolEvidence: summarizeLocalToolEvidence(toolEvents) };
   }
 }
 
@@ -381,12 +818,15 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
   }
 
   if (runtimeMode === "auto" && shouldAttemptAutoLocal(options)) {
-    const localResult = await runLocalAgentTurnForCli(options, { reportFailure: false });
-    if (localResult.exitCode === 0) {
-      return {
-        exitCode: localResult.exitCode,
-        ...(localResult.dialogId ? { dialogId: localResult.dialogId } : {}),
-      };
+    const skipLocal = await shouldSkipAutoLocalForServerPlatformTools(options);
+    if (!skipLocal) {
+      const localResult = await runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: false });
+      if (localResult.exitCode === 0) {
+        return {
+          exitCode: localResult.exitCode,
+          ...(localResult.dialogId ? { dialogId: localResult.dialogId } : {}),
+        };
+      }
     }
   }