nolo-cli 0.1.23 → 0.1.29

package/client/agentRun.test.ts

@@ -45,7 +45,7 @@ describe("cli agent run client", () => {
       "queryTableRows",
       "updateTableRow",
     ]);
-    expect(findServerPlatformTools(["readWorkspaceFile", "gitStatus"])).toEqual([]);
+    expect(findServerPlatformTools(["readWorkspaceFile", "execShell"])).toEqual([]);
   });
 
   test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
@@ -84,15 +84,15 @@ describe("cli agent run client", () => {
           agentKey: "agent-pub-test",
           userInput: "hello",
           continueDialogId: "dialog-existing",
-          runtimeContext: {
-            surface: "cli",
-            host: "terminal",
-            runtime: "bun",
-            entrypoint: "nolo-cli",
-            capabilities: ["text-io", "streaming", "slash-commands"],
-          },
-          stream: true,
-        },
+          runtimeContext: {
+            surface: "cli",
+            host: "terminal",
+            runtime: "bun",
+            entrypoint: "nolo-cli",
+            capabilities: ["text-io", "streaming", "slash-commands"],
+          },
+          stream: true,
+        },
       },
     ]);
     expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
@@ -463,7 +463,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["gitStatus"],
+          toolNames: ["readWorkspaceFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -476,9 +476,9 @@ describe("cli agent run client", () => {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: "call-status",
+                  id: "call-read",
                   type: "function",
-                  function: { name: "gitStatus", arguments: "{}" },
+                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -491,8 +491,8 @@ describe("cli agent run client", () => {
     });
 
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
-    expect(output.text()).toContain("[nolo:tool] round 1 -> gitStatus (call-status)");
-    expect(output.text()).toContain("[nolo:tool] round 1 <- gitStatus (call-status)");
+    expect(output.text()).toContain("[nolo:tool] round 1 -> readWorkspaceFile (call-read)");
+    expect(output.text()).toContain("[nolo:tool] round 1 <- readWorkspaceFile (call-read)");
   });
 
   test("passes local tool evidence to task-run writeback", async () => {
@@ -524,7 +524,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["gitStatus"],
+          toolNames: ["readWorkspaceFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -537,9 +537,9 @@ describe("cli agent run client", () => {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: "call-status",
+                  id: "call-read",
                   type: "function",
-                  function: { name: "gitStatus", arguments: "{}" },
+                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -554,7 +554,7 @@ describe("cli agent run client", () => {
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
     expect(writebacks).toHaveLength(1);
     expect(writebacks[0].toolEvidence).toEqual({
-      toolsUsed: ["gitStatus"],
+      toolsUsed: ["readWorkspaceFile"],
       summary: {
         callCount: 1,
         resultCount: 1,
@@ -660,6 +660,110 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("frontend -> working locally");
   });
 
+  test("auto mode refreshes missing local agent config and retries local once before HTTP", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let loadAgentConfigCalls = 0;
+    let localCompletions = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence"],
+        loadAgentConfig: async (agentRef) => {
+          loadAgentConfigCalls += 1;
+          if (loadAgentConfigCalls < 3) return null;
+          return {
+            key: agentRef,
+            name: "Frontend",
+            prompt: "Fix UI",
+            model: "fake-local",
+          };
+        },
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-auto-local-retried" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            localCompletions += 1;
+            return { content: "auto local after refresh", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-auto-local-retried" });
+    expect(loadAgentConfigCalls).toBe(4);
+    expect(localCompletions).toBe(1);
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).toContain("refreshing from the configured server and retrying local once");
+    expect(output.text().match(/working locally/g)?.length).toBe(2);
+  });
+
+  test("auto mode falls back to HTTP when local agent config is still missing after one refresh retry", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: Array<{ url: string; body: any }> = [];
+    let loadAgentConfigCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence"],
+        loadAgentConfig: async () => {
+          loadAgentConfigCalls += 1;
+          return null;
+        },
+        loadDialogHistory: async () => [],
+        saveTurn: async () => {
+          throw new Error("local runtime should not save when config is missing");
+        },
+        resolveProvider: async () => {
+          throw new Error("local provider should not run when config is missing");
+        },
+        executeTool: async () => {
+          throw new Error("no tools expected");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url, init) => {
+        httpCalls.push({ url: String(url), body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "server fallback", dialogId: "dialog-server-fallback" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-server-fallback" });
+    expect(loadAgentConfigCalls).toBe(3);
+    expect(httpCalls).toHaveLength(1);
+    expect(httpCalls[0]?.body.agentKey).toBe("frontend-local");
+    expect(output.text()).toContain("refreshing from the configured server and retrying local once");
+    expect(output.text()).toContain("frontend -> working");
+    expect(output.text()).toContain("frontend > server fallback");
+  });
+
   test("auto mode skips local runtime for agents that declare server platform tools", async () => {
     const output = new CaptureOutput();
     const httpCalls: Array<{ url: string; body: any }> = [];

package/client/agentRun.ts

@@ -1,36 +1,36 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { runLocalAgentTurn } from "../agentRuntimeLocal";
-import {
-  FRONTEND_IMPLEMENTER_AGENT_KEY,
-  NOLO_FULLSTACK_AGENT_KEY,
-  NOLO_PROJECT_MANAGER_AGENT_KEY,
-  NOLO_REVIEW_AGENT_KEY,
-  NOLO_SENIOR_FULLSTACK_AGENT_KEY,
-} from "../agentAliases";
+import { LOCAL_AGENT_CONFIG_MISSING_CODE } from "../agent-runtime/localLoop";
 import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
+import type { EnvLike } from "../cliEnvHelpers";
+import type { OutputLike } from "../cliIoTypes";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 import { createStreamingTextWriter } from "./streamingOutput";
 import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
+import {
+  formatToolTraceEvent,
+  nextLocalToolRoundLimit,
+  parseLocalToolRoundLimitError,
+  resolveLocalToolRoundRetryLimit,
+  shouldCollectLocalToolEvidence,
+  shouldTraceLocalTools,
+  summarizeLocalToolEvidence,
+  type TaskRunToolEvidence,
+} from "./agentRunLocalExecution";
+import {
+  findServerPlatformTools,
+  resolveRequestedRuntimeMode,
+  shouldAttemptAutoLocal,
+  shouldShowUsage,
+  shouldSkipAutoLocalForServerPlatformTools,
+  shouldUseScriptBridge,
+} from "./agentRunRuntimeSelection";
+export { classifyTaskRunReviewStatus } from "./agentRunLocalExecution";
+export { findServerPlatformTools, shouldUseScriptBridge } from "./agentRunRuntimeSelection";
 
-type EnvLike = Record<string, string | undefined>;
-
-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;
@@ -75,64 +75,6 @@ export type RunAgentTurnResult = {
   streamInterrupted?: boolean;
 };
 
-type ScriptBridgeDecision = {
-  hasAuthToken: boolean;
-  scriptPathExists: boolean;
-};
-
-const SERVER_PLATFORM_TOOL_NAMES = new Set([
-  "addTableRow",
-  "addTableRows",
-  "deleteTableRow",
-  "deleteTableRows",
-  "queryTableRows",
-  "streamParallelAgents",
-  "taskRun",
-  "updateTableRow",
-  "updateTableRows",
-]);
-
-const KNOWN_SERVER_PLATFORM_AGENT_KEYS = new Set([
-  FRONTEND_IMPLEMENTER_AGENT_KEY,
-  NOLO_FULLSTACK_AGENT_KEY,
-  NOLO_PROJECT_MANAGER_AGENT_KEY,
-  NOLO_REVIEW_AGENT_KEY,
-  NOLO_SENIOR_FULLSTACK_AGENT_KEY,
-]);
-
-const KNOWN_SERVER_PLATFORM_AGENT_ALIASES = new Set([
-  "code-review",
-  "frontend",
-  "frontend-agent",
-  "frontend-implementer",
-  "full-stack",
-  "fullstack",
-  "nolo code review",
-  "nolo frontend",
-  "nolo fullstack",
-  "nolo project manager",
-  "nolo reviewer",
-  "nolo-code-review",
-  "nolo-frontend",
-  "nolo-fullstack",
-  "nolo-pm",
-  "nolo-project-manager",
-  "nolo-reviewer",
-  "pm",
-  "project-manager",
-  "review",
-  "reviewer",
-]);
-
-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 resolveServerPlatformToolNames(agentConfig: any) {
   return findServerPlatformTools([
     ...(Array.isArray(agentConfig?.toolNames) ? agentConfig.toolNames : []),
@@ -141,32 +83,11 @@ function resolveServerPlatformToolNames(agentConfig: any) {
       : []),
   ]);
 }
-
-function normalizeAgentRef(ref?: string) {
-  return ref?.trim().toLowerCase().replace(/\s+/g, " ");
-}
-
-function isKnownServerPlatformAgent(options: RunAgentTurnOptions) {
-  if (KNOWN_SERVER_PLATFORM_AGENT_KEYS.has(options.agentKey)) return true;
-  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 shouldShowUsage(env: EnvLike) {
-  return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
-}
-
-function resolveRequestedRuntimeMode(options: RunAgentTurnOptions) {
-  const envMode = options.env.NOLO_RUNTIME_MODE;
-  if (options.runtimeMode) return options.runtimeMode;
-  if (envMode === "local" || envMode === "server" || envMode === "auto") return envMode;
-  return "auto";
-}
-
 function buildDefaultLocalRuntimeAdapter(options: RunAgentTurnOptions) {
   return createCliLocalRuntimeAdapter({
     env: options.env,
@@ -184,31 +105,6 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
   );
 }
 
-async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
-  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 adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) return false;
-  let agentConfig;
-  try {
-    agentConfig = await adapter.loadAgentConfig(options.agentKey);
-  } catch {
-    return false;
-  }
-  const serverTools = resolveServerPlatformToolNames(agentConfig);
-  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 [
@@ -220,85 +116,17 @@ 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;
+function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
   return Boolean(
-    options.env.NOLO_LOCAL_OPENAI_API_KEY ||
-      options.env.OPENAI_API_KEY ||
-      options.env.NOLO_LOCAL_OPENAI_BASE_URL ||
-      options.env.OPENAI_BASE_URL ||
-      options.env.NOLO_LOCAL_AGENT_KEY
+    error &&
+      typeof error === "object" &&
+      "code" in error &&
+      (error as { code?: string; agentRef?: string }).code === LOCAL_AGENT_CONFIG_MISSING_CODE &&
+      (error as { code?: string; agentRef?: string }).agentRef === agentRef
   );
 }
 
+
 function inferTaskRunAgentRole(agentRef: string): TaskRunAgentRole {
   const normalized = agentRef.toLowerCase();
   if (normalized.includes("project-manager") || normalized.includes("manager")) return "pm";
@@ -308,29 +136,6 @@ function inferTaskRunAgentRole(agentRef: string): TaskRunAgentRole {
   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[];
@@ -683,6 +488,13 @@ async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
   return runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: true });
 }
 
+async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
+  const adapter = resolveLocalRuntimeAdapter(options);
+  if (!adapter) return false;
+  const agentConfig = await adapter.loadAgentConfig(options.agentKey);
+  return Boolean(agentConfig);
+}
+
 async function runLocalAgentTurnWithAutoRoundExpansion(
   options: RunAgentTurnOptions,
   settings: { reportFailure: boolean }
@@ -917,7 +729,10 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
   }
 
   if (runtimeMode === "auto" && shouldAttemptAutoLocal(options)) {
-    const skipLocal = await shouldSkipAutoLocalForServerPlatformTools(options);
+    const skipLocal = await shouldSkipAutoLocalForServerPlatformTools({
+      ...options,
+      resolveLocalRuntimeAdapter: () => resolveLocalRuntimeAdapter(options),
+    });
     if (!skipLocal) {
       const localResult = await runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: false });
       if (localResult.exitCode === 0) {
@@ -926,6 +741,27 @@ export async function runAgentTurn(options: RunAgentTurnOptions) {
           ...(localResult.dialogId ? { dialogId: localResult.dialogId } : {}),
         };
       }
+      if (isMissingLocalAgentConfigError(localResult.localError, options.agentKey)) {
+        options.output.write(
+          `[nolo] Local agent config was missing; refreshing from the configured server and retrying local once.\n`
+        );
+        try {
+          const refreshed = await refreshMissingLocalAgentConfig(options);
+          if (refreshed) {
+            const retriedLocalResult = await runLocalAgentTurnWithAutoRoundExpansion(options, {
+              reportFailure: false,
+            });
+            if (retriedLocalResult.exitCode === 0) {
+              return {
+                exitCode: retriedLocalResult.exitCode,
+                ...(retriedLocalResult.dialogId ? { dialogId: retriedLocalResult.dialogId } : {}),
+              };
+            }
+          }
+        } catch {
+          // Fall through to the existing server runtime fallback below.
+        }
+      }
     }
   }
 

package/client/agentRunLocalExecution.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+
+import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
+import {
+  classifyTaskRunReviewStatus,
+  formatToolTraceEvent,
+  nextLocalToolRoundLimit,
+  parseLocalToolRoundLimitError,
+  resolveLocalToolRoundRetryLimit,
+  shouldCollectLocalToolEvidence,
+  shouldTraceLocalTools,
+  summarizeLocalToolEvidence,
+} from "./agentRunLocalExecution";
+
+function makeToolEvent(
+  overrides: Partial<LocalAgentToolEvent> & Pick<LocalAgentToolEvent, "type">
+): LocalAgentToolEvent {
+  return {
+    type: overrides.type,
+    round: overrides.round ?? 0,
+    toolCallId: overrides.toolCallId ?? "call-1",
+    toolName: overrides.toolName ?? "readWorkspaceFile",
+    message: overrides.message,
+    metadata: overrides.metadata,
+  };
+}
+
+describe("agentRunLocalExecution", () => {
+  test("traces local tools from explicit option or env flag", () => {
+    expect(shouldTraceLocalTools({ traceTools: true, env: {} })).toBe(true);
+    expect(shouldTraceLocalTools({ traceTools: false, env: { NOLO_TRACE_TOOLS: "1" } })).toBe(
+      true
+    );
+    expect(shouldTraceLocalTools({ env: {} })).toBe(false);
+  });
+
+  test("collects local tool evidence only when task-run row key exists", () => {
+    expect(shouldCollectLocalToolEvidence({ taskRunContext: { rowDbKey: "row-1" } })).toBe(true);
+    expect(shouldCollectLocalToolEvidence({ taskRunContext: {} })).toBe(false);
+    expect(shouldCollectLocalToolEvidence({})).toBe(false);
+  });
+
+  test("summarizes tool evidence with unique tools and event counts", () => {
+    const events: LocalAgentToolEvent[] = [
+      makeToolEvent({ type: "tool-call", toolName: "readWorkspaceFile", toolCallId: "call-1" }),
+      makeToolEvent({ type: "tool-result", toolName: "readWorkspaceFile", toolCallId: "call-1" }),
+      makeToolEvent({ type: "tool-call", round: 1, toolName: "execShell", toolCallId: "call-2" }),
+      makeToolEvent({ type: "tool-error", round: 1, toolName: "execShell", toolCallId: "call-2" }),
+      makeToolEvent({ type: "tool-call", round: 1, toolName: "readWorkspaceFile", toolCallId: "call-3" }),
+    ];
+
+    expect(summarizeLocalToolEvidence(events)).toEqual({
+      toolsUsed: ["readWorkspaceFile", "execShell"],
+      summary: {
+        callCount: 3,
+        resultCount: 1,
+        errorCount: 1,
+        rounds: 2,
+      },
+    });
+    expect(summarizeLocalToolEvidence([])).toBeUndefined();
+  });
+
+  test("parses local tool round limit errors only from matching messages", () => {
+    expect(parseLocalToolRoundLimitError(new Error("Local agent exceeded max tool rounds: 256"))).toBe(
+      256
+    );
+    expect(parseLocalToolRoundLimitError("Local agent exceeded max tool rounds: 4")).toBe(4);
+    expect(parseLocalToolRoundLimitError(new Error("other failure"))).toBeNull();
+  });
+
+  test("resolves retry limit from env positive integers and falls back to default", () => {
+    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "64" } })).toBe(
+      64
+    );
+    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "0" } })).toBe(
+      512
+    );
+    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "abc" } })).toBe(
+      512
+    );
+    expect(resolveLocalToolRoundRetryLimit({ env: {} })).toBe(512);
+  });
+
+  test("increments next local tool round limit by doubling positive values", () => {
+    expect(nextLocalToolRoundLimit(0)).toBe(1);
+    expect(nextLocalToolRoundLimit(-1)).toBe(1);
+    expect(nextLocalToolRoundLimit(8)).toBe(16);
+  });
+
+  test("formats tool trace events for calls, results, and errors", () => {
+    expect(
+      formatToolTraceEvent(
+        makeToolEvent({ type: "tool-call", round: 0, toolName: "readWorkspaceFile", toolCallId: "call-1" })
+      )
+    ).toBe("[nolo:tool] round 1 -> readWorkspaceFile (call-1)\n");
+    expect(
+      formatToolTraceEvent(
+        makeToolEvent({ type: "tool-result", round: 1, toolName: "readWorkspaceFile", toolCallId: "call-1" })
+      )
+    ).toBe("[nolo:tool] round 2 <- readWorkspaceFile (call-1)\n");
+    expect(
+      formatToolTraceEvent(
+        makeToolEvent({
+          type: "tool-error",
+          round: 1,
+          toolName: "execShell",
+          toolCallId: "call-2",
+          message: "timed out",
+        })
+      )
+    ).toBe("[nolo:tool] round 2 !! execShell: timed out\n");
+  });
+
+  test("classifies review status only from explicit or strong signals", () => {
+    expect(classifyTaskRunReviewStatus("Review decision: passed")).toBe("passed");
+    expect(classifyTaskRunReviewStatus("Changes requested for missing test coverage")).toBe(
+      "needs_changes"
+    );
+    expect(classifyTaskRunReviewStatus("无法审查，存在阻塞")).toBe("blocked");
+    expect(classifyTaskRunReviewStatus("I looked at the diff and have notes")).toBeUndefined();
+  });
+});