nolo-cli 0.1.39 → 0.1.41

package/README.md

@@ -178,10 +178,10 @@ nolo dialog list --space <space>
 nolo dialog read <dialog>
 nolo dialog delete <dialog> --yes
 nolo doc list --agent <agent>
-nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --limit 20
-nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items
-nolo table update-row --table meta-b2e06f801f-NOLOTASKBOARD --row 01ROWID --changes '{"status":"已完成"}'
-nolo table add-column --table meta-b2e06f801f-NOLOTASKBOARD --schema-write-ok --name "blockedBy" --label "Blocked By"
+nolo table query --table meta-0e95801d90-NOLOTASKBOARD --limit 20
+nolo table query --table meta-0e95801d90-NOLOTASKBOARD --columns '["title","status","owner","priority","codeStatus"]' --no-base-fields --output items
+nolo table update-row --table meta-0e95801d90-NOLOTASKBOARD --row 01ROWID --changes '{"status":"已完成"}'
+nolo table add-column --table meta-0e95801d90-NOLOTASKBOARD --schema-write-ok --name "blockedBy" --label "Blocked By"
 ```
 
 `agent list`, `dialog list`, and record delete commands use global server

package/agent-runtime/dialogWritePlan.ts

@@ -34,6 +34,28 @@ function resolveDialogTitle(args: {
   return lastUserText ? lastUserText.slice(0, 80) : "Local agent run";
 }
 
+function normalizeNonEmptyString(value: unknown) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function buildDialogLineageFields(args: {
+  input: AgentRuntimeSaveTurnInput;
+  existingDialog?: DialogRecord | null;
+}) {
+  const inheritedFromDialogKey = normalizeNonEmptyString(args.input.inheritedFromDialogKey);
+  const parentDialogId = normalizeNonEmptyString(args.input.parentDialogId);
+  if (!inheritedFromDialogKey && !parentDialogId) return {};
+  const rootDialogId =
+    normalizeNonEmptyString(args.existingDialog?.rootDialogId) ??
+    normalizeNonEmptyString(args.existingDialog?.parentDialogId) ??
+    parentDialogId;
+  return {
+    ...(inheritedFromDialogKey ? { inheritedFromDialogKey } : {}),
+    ...(parentDialogId ? { parentDialogId } : {}),
+    ...(rootDialogId ? { rootDialogId } : {}),
+  };
+}
+
 function buildDialogMessageWriteOps(args: {
   dialogId: string;
   input: AgentRuntimeSaveTurnInput;
@@ -102,6 +124,12 @@ export function buildAgentRuntimeDialogWritePlan(args: {
     updatedAt: nowIso,
     finishedAt: args.now,
     usage: args.input.result.usage,
+    ...(normalizeNonEmptyString(args.input.spaceId) ? { spaceId: normalizeNonEmptyString(args.input.spaceId) } : {}),
+    ...(normalizeNonEmptyString(args.input.category) ? { category: normalizeNonEmptyString(args.input.category) } : {}),
+    ...buildDialogLineageFields({
+      input: args.input,
+      existingDialog: args.existingDialog,
+    }),
     ...(typeof args.input.result.toolCallCount === "number"
       ? { toolCallCount: args.input.result.toolCallCount }
       : {}),
@@ -109,6 +137,17 @@ export function buildAgentRuntimeDialogWritePlan(args: {
       host: args.runtimeHost,
       ...(args.runtimeMetadata ?? {}),
     },
+    ...(args.input.result.runtimeToolSurface
+      ? {
+          runtimeCheckpoint: {
+            ...(args.existingDialog?.runtimeCheckpoint &&
+            typeof args.existingDialog.runtimeCheckpoint === "object"
+              ? args.existingDialog.runtimeCheckpoint
+              : {}),
+            toolSurface: args.input.result.runtimeToolSurface,
+          },
+        }
+      : {}),
   };
   return {
     dialogId,

package/agent-runtime/hostAdapter.ts

@@ -56,6 +56,10 @@ export type AgentRuntimeSaveTurnInput = {
   messages: AgentRuntimeChatMessage[];
   result: AgentRuntimeResult;
   continueDialogId?: string;
+  spaceId?: string;
+  category?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
 };
 
 export type AgentRuntimeHostAdapter = {

package/agent-runtime/hybridRecordStore.ts

@@ -126,7 +126,8 @@ export function createHybridRecordStore(
   return {
     read: async (dbKey, options) => {
       const localRecord = await readHybridLocalRecord(deps.db, dbKey);
-      if (localRecord) return { ...localRecord, dbKey };
+      const normalizedLocalRecord = normalizeHybridRecord(dbKey, localRecord);
+      if (normalizedLocalRecord && options?.remote !== true) return normalizedLocalRecord;
       if (options?.remote === false) return null;
 
       for (const server of resolveHybridServers(
@@ -148,11 +149,12 @@ export function createHybridRecordStore(
         if (!remoteRecord) continue;
         if (shouldCacheHybridRemoteRecord(remoteRecord, localRecord)) {
           await deps.db.put(dbKey, remoteRecord);
+          return remoteRecord;
         }
-        return remoteRecord;
+        return normalizedLocalRecord ?? remoteRecord;
       }
 
-      return null;
+      return normalizedLocalRecord ?? null;
     },
     write: async (dbKey, record) => {
       const nextRecord = normalizeHybridRecord(dbKey, record) ?? { dbKey };

package/agent-runtime/index.ts

@@ -56,6 +56,14 @@ export {
   resolveLocalRuntimeEnvFromPolicy,
   resolveLocalWorkspaceExecutorOptionsFromPolicy,
 } from "./runtimeToolPolicy";
+export {
+  DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOLS,
+  inferOwnerIdFromRuntimeAgentKey,
+  isPublicRuntimeAgentRef,
+  redactAgentRecordForWorkspaceTool,
+  resolveRuntimeToolSurfaceForAgent,
+  resolveRuntimeToolSurface,
+} from "./runtimeToolSurface";
 export {
   buildLocalWorkspaceOpenAiTools,
   buildLocalWorkspacePolicyToolNames,
@@ -111,6 +119,13 @@ export type {
 export type {
   PlatformChatProviderConfig,
 } from "./platformChatProvider";
+export type {
+  RuntimeToolSurfaceHost,
+  RuntimeToolSurfaceForAgentInput,
+  RuntimeToolSurfaceInput,
+  RuntimeToolSurfaceResult,
+  RuntimeToolSurfaceVisibility,
+} from "./runtimeToolSurface";
 export type {
   AgentRuntimeChatMessage,
   AgentRuntimeDecision,

package/agent-runtime/localLoop.ts

@@ -12,7 +12,10 @@ export type LocalAgentTurnInput = {
   agentRef: string;
   input: AgentRuntimeMessageContent;
   continueDialogId?: string;
-  maxToolRounds?: number;
+  spaceId?: string;
+  category?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
   timeoutMs?: number;
   onToolEvent?: (event: LocalAgentToolEvent) => void;
 };
@@ -26,11 +29,13 @@ export type LocalAgentToolEvent = {
   round: number;
   toolCallId: string;
   toolName: string;
+  argumentsPreview?: string;
+  elapsedMs?: number;
+  summary?: string;
   message?: string;
   metadata?: Record<string, unknown>;
 };
 
-export const DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS = 128;
 export const LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
 
 function formatToolExecutionError(args: {
@@ -75,6 +80,72 @@ function emitToolEvent(
   input.onToolEvent?.(event);
 }
 
+function compactWhitespace(value: string) {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function clip(value: string, max = 240) {
+  const compact = compactWhitespace(value);
+  return compact.length > max ? `${compact.slice(0, max - 3)}...` : compact;
+}
+
+function parseToolArguments(raw: string | undefined) {
+  if (!raw?.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function summarizeToolArguments(toolName: string, rawArgs: string | undefined) {
+  const args = parseToolArguments(rawArgs);
+  const pick = (...keys: string[]) => {
+    for (const key of keys) {
+      const value = args[key];
+      if (typeof value === "string" && value.trim()) return value.trim();
+    }
+    return "";
+  };
+  const command = pick("command", "cmd", "runCommand", "executeCommand", "bash");
+  if (command) return clip(command);
+  const filePath = pick("filePath", "path", "filename", "file");
+  if (filePath) return clip(filePath);
+  const query = pick("query", "pattern", "search", "q");
+  if (query) return clip(query);
+  const keys = Object.keys(args);
+  if (keys.length === 0) return "";
+  return clip(keys.slice(0, 6).map((key) => {
+    const value = args[key];
+    if (typeof value === "string") return `${key}=${clip(value, 80)}`;
+    if (typeof value === "number" || typeof value === "boolean") return `${key}=${String(value)}`;
+    if (Array.isArray(value)) return `${key}[${value.length}]`;
+    return `${key}=${value === null ? "null" : typeof value}`;
+  }).join(" "));
+}
+
+function summarizeToolResult(content: unknown, metadata?: Record<string, unknown>) {
+  const parts: string[] = [];
+  const exitCode = metadata?.exitCode;
+  if (typeof exitCode === "number") parts.push(`exit=${exitCode}`);
+  if (typeof content === "string") {
+    const trimmed = content.trim();
+    if (trimmed) {
+      const lines = trimmed.split(/\r?\n/).length;
+      parts.push(`${lines} line${lines === 1 ? "" : "s"}`);
+      parts.push(`${trimmed.length} chars`);
+      const tail = clip(trimmed.slice(-160), 160);
+      if (tail) parts.push(`tail="${tail}"`);
+    } else {
+      parts.push("empty");
+    }
+  }
+  return parts.join(" ");
+}
+
 function buildMessages(args: {
   prompt?: string;
   history: AgentRuntimeChatMessage[];
@@ -124,19 +195,16 @@ export async function runLocalAgentTurn(
     input: input.input,
   });
   const provider = await input.adapter.resolveProvider(agentConfig);
-  const maxToolRounds = input.maxToolRounds ?? DEFAULT_LOCAL_AGENT_MAX_TOOL_ROUNDS;
   const userInputText = extractUserInputText(input.input);
   let toolCallCount = 0;
   let result: AgentRuntimeResult;
-  for (let round = 0; round <= maxToolRounds; round += 1) {
+  let round = 0;
+  while (true) {
     result = await provider.complete(messages, {
       ...(typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {}),
     });
     const toolCalls = result.tool_calls ?? [];
     if (toolCalls.length === 0) break;
-    if (round === maxToolRounds) {
-      throw new Error(`Local agent exceeded max tool rounds: ${maxToolRounds}`);
-    }
     toolCallCount += toolCalls.length;
     messages.push({
       role: "assistant",
@@ -147,11 +215,13 @@ export async function runLocalAgentTurn(
     for (const toolCall of toolCalls) {
       const toolName = toolCall.function.name;
       let toolResult;
+      const startedAt = Date.now();
       emitToolEvent(input, {
         type: "tool-call",
         round,
         toolCallId: toolCall.id,
         toolName,
+        argumentsPreview: summarizeToolArguments(toolName, toolCall.function.arguments),
       });
       try {
         toolResult = await input.adapter.executeTool({
@@ -165,6 +235,8 @@ export async function runLocalAgentTurn(
           round,
           toolCallId: toolCall.id,
           toolName,
+          elapsedMs: Math.max(0, Date.now() - startedAt),
+          summary: summarizeToolResult(toolResult.content, toolResult.metadata),
           metadata: toolResult.metadata,
         });
       } catch (error) {
@@ -174,6 +246,7 @@ export async function runLocalAgentTurn(
           round,
           toolCallId: toolCall.id,
           toolName,
+          elapsedMs: Math.max(0, Date.now() - startedAt),
           message: error instanceof Error ? error.message : String(error),
         });
         toolResult = {
@@ -201,6 +274,7 @@ export async function runLocalAgentTurn(
         ...(toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}),
       });
     }
+    round += 1;
   }
   result = result!;
   messages.push({
@@ -213,13 +287,19 @@ export async function runLocalAgentTurn(
     result: {
       ...result,
       ...(toolCallCount > 0 ? { toolCallCount } : {}),
+      ...((agentConfig as any).toolSurface ? { runtimeToolSurface: (agentConfig as any).toolSurface } : {}),
     },
     ...(input.continueDialogId ? { continueDialogId: input.continueDialogId } : {}),
+    ...(input.spaceId ? { spaceId: input.spaceId } : {}),
+    ...(input.category ? { category: input.category } : {}),
+    ...(input.inheritedFromDialogKey ? { inheritedFromDialogKey: input.inheritedFromDialogKey } : {}),
+    ...(input.parentDialogId ? { parentDialogId: input.parentDialogId } : {}),
   });
 
   return {
     ...result,
     ...(toolCallCount > 0 ? { toolCallCount } : {}),
+    ...((agentConfig as any).toolSurface ? { runtimeToolSurface: (agentConfig as any).toolSurface } : {}),
     dialogId: saved.dialogId,
   };
 }

package/agent-runtime/localToolPolicy.ts

@@ -28,16 +28,12 @@ const REMOVED_LOCAL_TOOLS = new Set([
 ]);
 
 const DEFAULT_LOCAL_TOOLS = new Set([
-  "listWorkspaceFiles",
-  "readWorkspaceFile",
-  "writeWorkspaceFile",
-  "replaceWorkspaceText",
   "listFiles",
   "readFile",
   "writeFile",
   "editFile",
   "searchFiles",
-  "searchWorkspace",
+  "execShell",
 ]);
 
 function parseToolAllowlist(value: string | undefined) {
@@ -96,14 +92,7 @@ export function resolveLocalToolPolicy(args: {
   }
 
   if (toolName === "execShell") {
-    if (args.env.NOLO_LOCAL_SHELL_MODE === "worktree") {
-      return { allowed: true, toolName };
-    }
-    return {
-      allowed: false,
-      toolName,
-      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree for local runtime runs.",
-    };
+    return { allowed: true, toolName };
   }
 
   if (NEVER_LOCAL_TOOLS.has(toolName)) {

package/agent-runtime/localWorkspaceTools.ts

@@ -43,18 +43,11 @@ type OpenAiCompatibleTool = Record<string, unknown> & {
 };
 
 const WORKSPACE_TOOL_NAMES = [
-  "listWorkspaceFiles",
-  "readWorkspaceFile",
-  "writeWorkspaceFile",
-  "replaceWorkspaceText",
   "listFiles",
   "readFile",
   "writeFile",
   "editFile",
   "searchFiles",
-  "searchWorkspace",
-  "applyEdit",
-  "applyLineEdits",
   "startPreview",
   "getPreviewStatus",
   "stopPreview",
@@ -93,7 +86,7 @@ function buildListWorkspaceFilesTool(): OpenAiCompatibleTool {
   return {
     type: "function",
     function: {
-      name: "listWorkspaceFiles",
+      name: "listFiles",
       description: "List files and directories inside a workspace directory.",
       parameters: {
         type: "object",
@@ -109,9 +102,9 @@ function buildReadWorkspaceFileTool(): OpenAiCompatibleTool {
   return {
     type: "function",
     function: {
-      name: "readWorkspaceFile",
+      name: "readFile",
       description:
-        "Read a UTF-8 text file inside the workspace. Read before editing when you need the current content or exact text for replaceWorkspaceText; skip unnecessary reads for trivial known writes.",
+        "Read a UTF-8 text file inside the workspace. Read before editing when you need the current content or exact text for editFile; skip unnecessary reads for trivial known writes.",
       parameters: {
         type: "object",
         properties: {
@@ -127,9 +120,9 @@ function buildWriteWorkspaceFileTool(): OpenAiCompatibleTool {
   return {
     type: "function",
     function: {
-      name: "writeWorkspaceFile",
+      name: "writeFile",
       description:
-        "Write full UTF-8 file content inside the workspace. Prefer replaceWorkspaceText for small edits to existing large files; use this for new files or deliberate whole-file rewrites.",
+        "Write full UTF-8 file content inside the workspace. For new files or deliberate whole-file rewrites only. For existing files, prefer editFile for targeted edits. Warn that whole-file rewrites can cause line-ending churn.",
       parameters: {
         type: "object",
         properties: {
@@ -149,9 +142,9 @@ function buildReplaceWorkspaceTextTool(): OpenAiCompatibleTool {
   return {
     type: "function",
     function: {
-      name: "replaceWorkspaceText",
+      name: "editFile",
       description:
-        "Use for small, exact edits in one workspace file without constructing a patch. Read the file first when you need the exact oldText; set expectedReplacements to avoid accidental broad edits.",
+        "Use for small, exact edits in one workspace file without constructing a patch. Read the file first when you need the exact oldText; set expectedReplacements to avoid accidental broad edits. When expected replacement count fails, report a blocker instead of falling back to a full-file rewrite.",
       parameters: {
         type: "object",
         properties: {
@@ -179,7 +172,7 @@ function buildSearchWorkspaceTool(): OpenAiCompatibleTool {
   return {
     type: "function",
     function: {
-      name: "searchWorkspace",
+      name: "searchFiles",
       description: "Search text in the current workspace using ripgrep when available.",
       parameters: {
         type: "object",
@@ -337,45 +330,21 @@ function buildWorkspaceShellCommand(args: {
     : buildBashCommand(args.command);
 }
 
-function renameWorkspaceToolDefinition(
-  tool: OpenAiCompatibleTool,
-  name: string
-): OpenAiCompatibleTool {
-  const description = typeof tool.function?.description === "string"
-    ? tool.function.description
-        .replaceAll("replaceWorkspaceText", "editFile")
-        .replaceAll("readWorkspaceFile", "readFile")
-    : tool.function?.description;
-  return {
-    ...tool,
-    function: {
-      ...(tool.function ?? {}),
-      name,
-      description,
-    },
-  };
-}
-
 function buildWorkspaceToolDefinition(toolName: string) {
-  if (toolName === "listWorkspaceFiles" || toolName === "listFiles") {
-    return renameWorkspaceToolDefinition(buildListWorkspaceFilesTool(), toolName);
+  if (toolName === "listFiles") {
+    return buildListWorkspaceFilesTool();
   }
-  if (toolName === "readWorkspaceFile" || toolName === "readFile") {
-    return renameWorkspaceToolDefinition(buildReadWorkspaceFileTool(), toolName);
+  if (toolName === "readFile") {
+    return buildReadWorkspaceFileTool();
   }
-  if (toolName === "writeWorkspaceFile" || toolName === "writeFile") {
-    return renameWorkspaceToolDefinition(buildWriteWorkspaceFileTool(), toolName);
+  if (toolName === "writeFile") {
+    return buildWriteWorkspaceFileTool();
   }
-  if (
-    toolName === "replaceWorkspaceText" ||
-    toolName === "editFile" ||
-    toolName === "applyEdit" ||
-    toolName === "applyLineEdits"
-  ) {
-    return renameWorkspaceToolDefinition(buildReplaceWorkspaceTextTool(), toolName);
+  if (toolName === "editFile") {
+    return buildReplaceWorkspaceTextTool();
   }
-  if (toolName === "searchWorkspace" || toolName === "searchFiles") {
-    return renameWorkspaceToolDefinition(buildSearchWorkspaceTool(), toolName);
+  if (toolName === "searchFiles") {
+    return buildSearchWorkspaceTool();
   }
   if (toolName === "startPreview" || toolName === "getPreviewStatus" || toolName === "stopPreview" || toolName === "releasePreview") {
     return buildPreviewLifecycleTool(toolName);
@@ -385,20 +354,6 @@ function buildWorkspaceToolDefinition(toolName: string) {
   return null;
 }
 
-function removeRedundantWorkspaceToolAliases(toolNames: Set<string>) {
-  const next = new Set(toolNames);
-  if (next.has("listWorkspaceFiles")) next.delete("listFiles");
-  if (next.has("readWorkspaceFile")) next.delete("readFile");
-  if (next.has("writeWorkspaceFile")) next.delete("writeFile");
-  if (next.has("replaceWorkspaceText")) {
-    next.delete("editFile");
-    next.delete("applyEdit");
-    next.delete("applyLineEdits");
-  }
-  if (next.has("searchWorkspace")) next.delete("searchFiles");
-  return next;
-}
-
 function filterDeclaredWorkspaceToolNames(args: {
   toolNames?: string[];
   exposeShellTools: boolean;
@@ -415,14 +370,14 @@ export function buildLocalWorkspaceToolset(args: {
   exposeShellTools?: boolean;
 }) {
   const exposeShellTools = args.exposeShellTools === true;
-  const toolNames = removeRedundantWorkspaceToolAliases(new Set([
+  const toolNames = new Set([
     ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
     ...(exposeShellTools ? SHELL_TOOL_NAMES : []),
     ...filterDeclaredWorkspaceToolNames({
       toolNames: args.declaredToolNames,
       exposeShellTools,
     }),
-  ]));
+  ]);
   return {
     toolNames: [...toolNames],
     exposeShellTools,
@@ -448,7 +403,7 @@ export function buildLocalWorkspaceOpenAiTools(args: {
   toolNames?: string[];
   exposeShellTools?: boolean;
 }) {
-  const declaredTools = removeRedundantWorkspaceToolAliases(new Set(args.toolNames ?? []));
+  const declaredTools = new Set(args.toolNames ?? []);
   return WORKSPACE_TOOL_NAMES
     .filter((toolName) => {
       if (!declaredTools.has(toolName)) return false;
@@ -494,21 +449,21 @@ function requireWorkspaceToolPath(args: WorkspaceFileArgs) {
 
 function requireWorkspaceFileContent(args: WorkspaceFileArgs) {
   if (typeof args.content !== "string") {
-    throw new Error("writeWorkspaceFile requires string content.");
+    throw new Error("writeFile requires string content.");
   }
   return args.content;
 }
 
 function requireWorkspaceOldText(args: WorkspaceFileArgs) {
   if (typeof args.oldText !== "string" || !args.oldText) {
-    throw new Error("replaceWorkspaceText requires non-empty oldText.");
+    throw new Error("editFile requires non-empty oldText.");
   }
   return args.oldText;
 }
 
 function requireWorkspaceNewText(args: WorkspaceFileArgs) {
   if (typeof args.newText !== "string") {
-    throw new Error("replaceWorkspaceText requires string newText.");
+    throw new Error("editFile requires string newText.");
   }
   return args.newText;
 }
@@ -517,7 +472,7 @@ function readExpectedReplacementCount(args: WorkspaceFileArgs) {
   if (args.expectedReplacements === undefined) return 1;
   const value = Number(args.expectedReplacements);
   if (!Number.isInteger(value) || value < 1) {
-    throw new Error("replaceWorkspaceText expectedReplacements must be a positive integer.");
+    throw new Error("editFile expectedReplacements must be a positive integer.");
   }
   return value;
 }
@@ -535,7 +490,7 @@ function pluralizeReplacement(count: number) {
 
 function requireWorkspaceSearchQuery(args: WorkspaceFileArgs) {
   const query = typeof args.query === "string" ? args.query.trim() : "";
-  if (!query) throw new Error("searchWorkspace requires a non-empty query.");
+  if (!query) throw new Error("searchFiles requires a non-empty query.");
   return query;
 }
 
@@ -783,7 +738,7 @@ export function resolveLocalWorkspaceToolPath(args: {
   return targetPath;
 }
 
-async function readWorkspaceFileTool(args: {
+async function readFileTool(args: {
   call: AgentRuntimeToolCallInput;
   workspaceRoot: string;
 }): Promise<AgentRuntimeToolResult> {
@@ -806,10 +761,15 @@ async function readWorkspaceFileTool(args: {
   };
 }
 
-async function writeWorkspaceFileTool(args: {
+async function writeFileTool(args: {
   call: AgentRuntimeToolCallInput;
   workspaceRoot: string;
 }): Promise<AgentRuntimeToolResult> {
+  // TODO: Explore cheaply including diff stat/EOL warning after writeFile.
+  // If implementation is larger than a small safe change, defer it.
+  // Exact boundaries: writeFileTool function in localWorkspaceTools.ts.
+  // Consider adding a post-write hook that runs `git diff --stat` and checks line endings.
+  // Keep it optional and non-blocking.
   const parsed = parseWorkspaceToolArguments(args.call.arguments);
   const requestedPath = requireWorkspaceToolPath(parsed);
   const content = requireWorkspaceFileContent(parsed);
@@ -832,7 +792,7 @@ async function writeWorkspaceFileTool(args: {
   };
 }
 
-async function replaceWorkspaceTextTool(args: {
+async function editFileTool(args: {
   call: AgentRuntimeToolCallInput;
   workspaceRoot: string;
 }): Promise<AgentRuntimeToolResult> {
@@ -849,7 +809,7 @@ async function replaceWorkspaceTextTool(args: {
   const replacementCount = countExactTextOccurrences({ content, oldText });
   if (replacementCount !== expectedReplacements) {
     throw new Error(
-      `replaceWorkspaceText expected ${expectedReplacements} ${pluralizeReplacement(expectedReplacements)} ` +
+      `editFile expected ${expectedReplacements} ${pluralizeReplacement(expectedReplacements)} ` +
         `but found ${replacementCount} in ${requestedPath}.`
     );
   }
@@ -883,7 +843,7 @@ async function formatWorkspaceDirEntry(args: {
   return info.isDirectory() ? `${relativePath}/` : relativePath;
 }
 
-async function listWorkspaceFilesTool(args: {
+async function listFilesTool(args: {
   call: AgentRuntimeToolCallInput;
   workspaceRoot: string;
 }): Promise<AgentRuntimeToolResult> {
@@ -910,7 +870,7 @@ async function listWorkspaceFilesTool(args: {
   };
 }
 
-async function searchWorkspaceTool(args: {
+async function searchFilesTool(args: {
   call: AgentRuntimeToolCallInput;
   workspaceRoot: string;
 }): Promise<AgentRuntimeToolResult> {
@@ -1110,51 +1070,23 @@ async function execShellTool(args: {
 
 export function createLocalWorkspaceToolExecutors(args: LocalWorkspaceToolArgs) {
   return {
-    listWorkspaceFiles: (call: AgentRuntimeToolCallInput) => listWorkspaceFilesTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    readWorkspaceFile: (call: AgentRuntimeToolCallInput) => readWorkspaceFileTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    writeWorkspaceFile: (call: AgentRuntimeToolCallInput) => writeWorkspaceFileTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    replaceWorkspaceText: (call: AgentRuntimeToolCallInput) => replaceWorkspaceTextTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    editFile: (call: AgentRuntimeToolCallInput) => replaceWorkspaceTextTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    applyEdit: (call: AgentRuntimeToolCallInput) => replaceWorkspaceTextTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    applyLineEdits: (call: AgentRuntimeToolCallInput) => replaceWorkspaceTextTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    listFiles: (call: AgentRuntimeToolCallInput) => listWorkspaceFilesTool({
+    editFile: (call: AgentRuntimeToolCallInput) => editFileTool({
       call,
       workspaceRoot: args.workspaceRoot,
     }),
-    readFile: (call: AgentRuntimeToolCallInput) => readWorkspaceFileTool({
+    listFiles: (call: AgentRuntimeToolCallInput) => listFilesTool({
       call,
       workspaceRoot: args.workspaceRoot,
     }),
-    writeFile: (call: AgentRuntimeToolCallInput) => writeWorkspaceFileTool({
+    readFile: (call: AgentRuntimeToolCallInput) => readFileTool({
       call,
       workspaceRoot: args.workspaceRoot,
     }),
-    searchWorkspace: (call: AgentRuntimeToolCallInput) => searchWorkspaceTool({
+    writeFile: (call: AgentRuntimeToolCallInput) => writeFileTool({
       call,
       workspaceRoot: args.workspaceRoot,
     }),
-    searchFiles: (call: AgentRuntimeToolCallInput) => searchWorkspaceTool({
+    searchFiles: (call: AgentRuntimeToolCallInput) => searchFilesTool({
       call,
       workspaceRoot: args.workspaceRoot,
     }),