nolo-cli 0.34.0-alpha.1 → 0.35.0-alpha.1

package/{chunk-DX6BP4K7.js → chunk-7KY6U7MW.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-AGGIDPCZ.js";
 import {
   runLlm
-} from "./chunk-AUH2LTIY.js";
+} from "./chunk-55C3UZSC.js";
 import {
   cleanupCliSessionForDialog
 } from "./chunk-MGIHZ5CJ.js";
@@ -3519,7 +3519,7 @@ var messageSlice = createSliceWithThunks({
             runtimeOptions: args.runtimeOptions
           });
           if (agentKeyToUse) {
-            const { streamAgentChatTurn } = await import("./agentSlice-HFR7SP3B.js");
+            const { streamAgentChatTurn } = await import("./agentSlice-B2IMSPH5.js");
             await dispatch(
               streamAgentChatTurn({
                 agentKey: agentKeyToUse,
@@ -4742,7 +4742,7 @@ var deleteDialogThunk = async (payload, thunkApi) => {
   }
   if (isCurrentDialog) {
     await thunkApi.dispatch(resetMsgs());
-    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-P2VSKG2X.js");
+    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-62JC4ZMX.js");
     dispatch(clearPendingAttachments2());
   }
   return { dialogKey, isCurrentDialog, attachmentPlan };
@@ -4750,15 +4750,15 @@ var deleteDialogThunk = async (payload, thunkApi) => {
 
 // packages/chat/dialog/dialogSlice.ts
 var runCreateDialogAction = async (args, thunkApi) => {
-  const { createDialogAction } = await import("./createDialogAction-U4LDV2RW.js");
+  const { createDialogAction } = await import("./createDialogAction-5LB4YBPS.js");
   return createDialogAction(args, thunkApi);
 };
 var runCreateAgentAutomationAction = async (args, thunkApi) => {
-  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-BH3D2L2H.js");
+  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-IDIY6K45.js");
   return createAgentAutomationAction(args, thunkApi);
 };
 var runUpdateDialogTitleAction = async (args, thunkApi) => {
-  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-WOTSDSFQ.js");
+  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-2A3BEXSP.js");
   return updateDialogTitleAction(args, thunkApi);
 };
 var runAddDialogAgentAction = async (args, thunkApi) => {
@@ -4782,7 +4782,7 @@ var runSetDialogExtraReferencesAction = async (args, thunkApi) => {
   return setDialogExtraReferencesAction(args, thunkApi);
 };
 var runHandleSendMessageAction = async (args, thunkApi) => {
-  const { handleSendMessageAction } = await import("./handleSendMessageAction-RRZ53YYH.js");
+  const { handleSendMessageAction } = await import("./handleSendMessageAction-YB64A32O.js");
   return handleSendMessageAction(args, thunkApi);
 };
 function clearDialogState() {
@@ -4795,7 +4795,7 @@ var createPageAndAddReference = createAsyncThunk(
   async (payload, { dispatch, getState, rejectWithValue }) => {
     const { slateData, jsonData, title, type, fileId, groupId, dialogKey } = payload;
     try {
-      const { createDocState } = await import("./docStore-J5UWRBB4.js");
+      const { createDocState } = await import("./docStore-ZRNKZZXU.js");
       const pageKey = await createDocState(
         { slateData, title },
         { dispatch, getState }

package/{chunk-VSA6QAGV.js → chunk-E2OQ5N2F.js}

@@ -8,7 +8,7 @@ import {
 
 // packages/cli/agentRunControl.ts
 import { homedir as nodeHomedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import * as nodeFs from "node:fs";
 import { execFileSync as nodeExecFileSync, spawn as nodeSpawn } from "node:child_process";
 var RUN_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
@@ -380,16 +380,42 @@ function rewriteMsgFileArg(args, messagePath) {
   }
   return result;
 }
-function buildAgentRunChildCommand(options) {
+function resolveValidCliEntrypoint(cliEntrypointPath, fs = nodeFs) {
+  if (cliEntrypointPath && fs.existsSync(cliEntrypointPath)) {
+    return cliEntrypointPath;
+  }
+  const fallback = resolveCliEntrypointPath();
+  if (fs.existsSync(fallback)) {
+    return fallback;
+  }
+  const candidates = [
+    join(dirname(fallback), "cli", "index.ts"),
+    join(dirname(fallback), "cli", "index.js"),
+    join(dirname(fallback), "..", "packages", "cli", "index.ts"),
+    join(dirname(fallback), "..", "packages", "cli", "index.js"),
+    join(dirname(fallback), "..", "index.js")
+  ];
+  for (const cand of candidates) {
+    if (fs.existsSync(cand)) {
+      return cand;
+    }
+  }
+  return fallback;
+}
+function buildAgentRunChildCommand(options, deps = {}) {
+  const fs = deps.fs ?? nodeFs;
   const execPath = process.execPath;
-  const entrypoint = options.cliEntrypointPath || resolveCliEntrypointPath();
   const commandParts = options.commandPath ?? [];
   let strippedArgs = stripBackgroundFlag(options.rawArgs);
   if (options.messagePath) {
     strippedArgs = rewriteMsgFileArg(strippedArgs, options.messagePath);
   }
   strippedArgs = absolutizeSkillArgs(strippedArgs);
-  if (isCompiledBinary() || entrypoint === execPath) {
+  if (isCompiledBinary() || options.cliEntrypointPath === execPath) {
+    return { execPath, childArgs: [...commandParts, ...strippedArgs] };
+  }
+  const entrypoint = resolveValidCliEntrypoint(options.cliEntrypointPath, fs);
+  if (entrypoint === execPath) {
     return { execPath, childArgs: [...commandParts, ...strippedArgs] };
   }
   return { execPath, childArgs: [entrypoint, ...commandParts, ...strippedArgs] };
@@ -453,12 +479,15 @@ async function spawnLocalBackgroundRun(input, deps = {}) {
     ...spawnHead ? { spawnHead } : {}
   };
   fs.writeFileSync(recordPath, JSON.stringify(record, null, 2));
-  const { execPath, childArgs } = buildAgentRunChildCommand({
-    rawArgs: input.rawArgs,
-    commandPath: input.commandPath,
-    cliEntrypointPath: input.cliEntrypointPath,
-    messagePath
-  });
+  const { execPath, childArgs } = buildAgentRunChildCommand(
+    {
+      rawArgs: input.rawArgs,
+      commandPath: input.commandPath,
+      cliEntrypointPath: input.cliEntrypointPath,
+      messagePath
+    },
+    deps
+  );
   const childEnv = {
     ...env,
     NOLO_AGENT_RUN_CHILD: "1",
@@ -1042,6 +1071,7 @@ export {
   stripBackgroundFlag,
   absolutizeSkillArgs,
   rewriteMsgFileArg,
+  buildAgentRunChildCommand,
   spawnLocalBackgroundRun,
   ackRunRecord,
   DEFAULT_ACK_LEASE_TTL_MS,

package/{chunk-LQ6PUHW6.js → chunk-EFN2AFWF.js}

@@ -23,10 +23,11 @@ import {
 } from "./chunk-T27IEBNQ.js";
 import {
   EMPTY_ASSISTANT_REPAIR_PROMPT,
+  formatLengthTruncatedReasoningTail,
   hasAssistantVisibleOutput,
   resolveEmptyAssistantFallbackMessage,
   resolveEmptyAssistantOutcome
-} from "./chunk-MI2J67UU.js";
+} from "./chunk-P66M7LSQ.js";
 import {
   createThinkParserState,
   createToolCallAccumulator,
@@ -721,6 +722,191 @@ async function maybeAutoCompactLocalHistory(args) {
   }
 }
 
+// packages/agent-runtime/progressGuard.ts
+var DEFAULT_MAX_CONSECUTIVE_IDENTICAL_ROUNDS = 5;
+var DEFAULT_MAX_CONSECUTIVE_STAGNANT_TOOL_ROUNDS = 8;
+function sortJsonKeys(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(sortJsonKeys);
+  const sorted = {};
+  for (const key of Object.keys(obj).sort()) {
+    sorted[key] = sortJsonKeys(obj[key]);
+  }
+  return sorted;
+}
+function normalizeToolArguments(rawArgs) {
+  if (typeof rawArgs !== "string") {
+    try {
+      return JSON.stringify(sortJsonKeys(rawArgs ?? ""));
+    } catch {
+      return String(rawArgs ?? "");
+    }
+  }
+  const trimmed = rawArgs.trim();
+  if (!trimmed) return "";
+  try {
+    const parsed = JSON.parse(trimmed);
+    return JSON.stringify(sortJsonKeys(parsed));
+  } catch {
+    return trimmed;
+  }
+}
+function extractNormalizedContentText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (part?.type === "text") return String(part.text ?? "").trim();
+    if (part?.type === "image_url") return `[img:${part.image_url?.url ?? ""}]`;
+    return "";
+  }).filter(Boolean).join("\n");
+}
+function buildToolCallsSignature(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) return "";
+  return toolCalls.map(
+    (tc) => `${tc.function?.name ?? ""}:${normalizeToolArguments(tc.function?.arguments)}`
+  ).join(";;");
+}
+function buildAssistantActionFingerprint(result) {
+  const content = extractNormalizedContentText(result.content);
+  const reasoning = typeof result.reasoning_content === "string" ? result.reasoning_content.trim() : "";
+  let toolCallsSig = buildToolCallsSignature(result.tool_calls);
+  let hasToolCalls = Array.isArray(result.tool_calls) && result.tool_calls.length > 0;
+  if (!toolCallsSig && Array.isArray(result.output) && result.output.length > 0) {
+    const blocksToolCalls = result.output.filter(
+      (b) => b.type === "toolCall"
+    ).map((b) => b.toolCall);
+    if (blocksToolCalls.length > 0) {
+      toolCallsSig = buildToolCallsSignature(blocksToolCalls);
+      hasToolCalls = true;
+    }
+  }
+  const hasNonEmptyText = content.length > 0 || reasoning.length > 0;
+  const fingerprint = `${content}##${reasoning}##${toolCallsSig}`;
+  return {
+    fingerprint,
+    hasNonEmptyText,
+    hasToolCalls,
+    toolCallsSignature: toolCallsSig
+  };
+}
+function buildToolResultsSignature(toolExecutions) {
+  if (toolExecutions.length === 0) return "";
+  return toolExecutions.map((exec) => {
+    const contentStr = typeof exec.content === "string" ? exec.content.trim() : "";
+    const metaStr = exec.metadata ? JSON.stringify(sortJsonKeys(exec.metadata)) : "";
+    return `${exec.toolName}:${contentStr}:${metaStr}`;
+  }).join(";;");
+}
+function resolveProgressGuardConfig(options, env = typeof process !== "undefined" ? process.env : {}) {
+  const envDisabled = env.NOLO_LOOP_PROGRESS_GUARD_DISABLED === "true" || env.NOLO_LOOP_PROGRESS_GUARD_DISABLED === "1";
+  const disabled = options?.disabled ?? envDisabled ?? false;
+  const parsePositiveInt = (val, fallback) => {
+    if (typeof val === "number" && Number.isFinite(val) && val >= 1) {
+      return Math.floor(val);
+    }
+    if (typeof val === "string") {
+      const parsed = parseInt(val, 10);
+      if (Number.isFinite(parsed) && parsed >= 1) {
+        return parsed;
+      }
+    }
+    return fallback;
+  };
+  const maxConsecutiveIdenticalRounds = parsePositiveInt(
+    options?.maxConsecutiveIdenticalRounds ?? env.NOLO_LOOP_MAX_IDENTICAL_ROUNDS,
+    DEFAULT_MAX_CONSECUTIVE_IDENTICAL_ROUNDS
+  );
+  const maxConsecutiveStagnantToolRounds = parsePositiveInt(
+    options?.maxConsecutiveStagnantToolRounds ?? env.NOLO_LOOP_MAX_STAGNANT_TOOL_ROUNDS,
+    DEFAULT_MAX_CONSECUTIVE_STAGNANT_TOOL_ROUNDS
+  );
+  return {
+    disabled,
+    maxConsecutiveIdenticalRounds,
+    maxConsecutiveStagnantToolRounds
+  };
+}
+var LocalLoopProgressGuard = class {
+  config;
+  lastAssistantFingerprint = null;
+  lastAssistantHasNonEmptyText = false;
+  consecutiveIdenticalCount = 0;
+  lastToolCallsSignature = null;
+  lastToolResultsSignature = null;
+  consecutiveStagnantToolCount = 0;
+  constructor(config, env) {
+    this.config = resolveProgressGuardConfig(config, env);
+  }
+  /**
+   * 在 LLM 返回 assistant 响应后调用。
+   * 仅在纯文本/无工具调用且实质文本相同达到阈值时直接熔断；
+   * 若存在工具调用，则不在此处熔断，留待工具执行后结合工具结果综合判定。
+   */
+  observeAssistantResponse(result) {
+    if (this.config.disabled) return { action: "continue" };
+    const { fingerprint, hasNonEmptyText, hasToolCalls } = buildAssistantActionFingerprint(result);
+    if (this.lastAssistantFingerprint !== null && this.lastAssistantFingerprint === fingerprint) {
+      this.consecutiveIdenticalCount += 1;
+      if (!hasToolCalls && hasNonEmptyText && this.consecutiveIdenticalCount >= this.config.maxConsecutiveIdenticalRounds) {
+        return {
+          action: "stall",
+          reason: "repetition_loop",
+          detail: `Consecutive identical text-only assistant response for ${this.consecutiveIdenticalCount} rounds.`,
+          consecutiveRounds: this.consecutiveIdenticalCount
+        };
+      }
+    } else {
+      this.lastAssistantFingerprint = fingerprint;
+      this.lastAssistantHasNonEmptyText = hasNonEmptyText;
+      this.consecutiveIdenticalCount = 1;
+    }
+    return { action: "continue" };
+  }
+  /**
+   * 在本轮所有工具执行完毕后调用，检查是否陷入停滞死循环。
+   * 只有当工具返回内容与元数据完全无变化时才计入无进展 streak；
+   * 一旦工具结果发生变化（如合法轮询状态推进），立即重置 identical streak，确保绝不误杀正常长任务。
+   */
+  observeToolExecution(toolCalls, toolResults) {
+    if (this.config.disabled) return { action: "continue" };
+    if (!toolCalls || toolCalls.length === 0) return { action: "continue" };
+    const toolCallsSig = buildToolCallsSignature(toolCalls);
+    const toolResultsSig = buildToolResultsSignature(toolResults);
+    const toolCallsUnchanged = this.lastToolCallsSignature !== null && this.lastToolCallsSignature === toolCallsSig;
+    const toolResultsUnchanged = this.lastToolResultsSignature !== null && this.lastToolResultsSignature === toolResultsSig;
+    if (toolCallsUnchanged && toolResultsUnchanged) {
+      this.consecutiveStagnantToolCount += 1;
+      if (this.consecutiveIdenticalCount >= this.config.maxConsecutiveIdenticalRounds) {
+        return {
+          action: "stall",
+          reason: "repetition_loop",
+          detail: `Consecutive identical assistant response with unchanged tool results for ${this.consecutiveIdenticalCount} rounds.`,
+          consecutiveRounds: this.consecutiveIdenticalCount
+        };
+      }
+      if (this.consecutiveStagnantToolCount >= this.config.maxConsecutiveStagnantToolRounds) {
+        return {
+          action: "stall",
+          reason: "stagnant_tool_calls",
+          detail: `Consecutive stagnant tool calls with unchanged results for ${this.consecutiveStagnantToolCount} rounds.`,
+          consecutiveRounds: this.consecutiveStagnantToolCount
+        };
+      }
+    } else {
+      this.lastToolCallsSignature = toolCallsSig;
+      this.lastToolResultsSignature = toolResultsSig;
+      this.consecutiveStagnantToolCount = 1;
+      if (!toolResultsUnchanged) {
+        this.consecutiveIdenticalCount = 1;
+      }
+    }
+    return { action: "continue" };
+  }
+};
+function createLocalLoopProgressGuard(config, env) {
+  return new LocalLoopProgressGuard(config, env);
+}
+
 // packages/agent-runtime/localLoop.ts
 var LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
 function formatToolExecutionError(args) {
@@ -1489,6 +1675,7 @@ async function runLocalAgentTurn(input) {
   let reasoningEmptyRepairCount = 0;
   let skipFinalAppend = false;
   let partialContent = "";
+  const progressGuard = createLocalLoopProgressGuard(input.progressGuardConfig);
   try {
     const provider = await resolveProviderOnce();
     while (true) {
@@ -1548,6 +1735,23 @@ async function runLocalAgentTurn(input) {
           ...result.provider || agentConfig.provider ? { provider: result.provider || agentConfig.provider } : {}
         });
       }
+      const assistantGuardVerdict = progressGuard.observeAssistantResponse(result);
+      if (assistantGuardVerdict.action === "stall") {
+        emitLoopEvent(input, {
+          kind: "loop-stalled",
+          round,
+          reason: assistantGuardVerdict.reason,
+          detail: assistantGuardVerdict.detail,
+          consecutiveRounds: assistantGuardVerdict.consecutiveRounds,
+          atMs: Date.now()
+        });
+        result = {
+          ...result,
+          content: resolveEmptyAssistantFallbackMessage(assistantGuardVerdict.reason),
+          emptyAssistantFallbackReason: assistantGuardVerdict.reason
+        };
+        break;
+      }
       const toolCalls = result.tool_calls ?? [];
       const rawToolCallsCount = (result.tool_calls?.length ?? 0) || (Array.isArray(result.raw_tool_calls) ? result.raw_tool_calls.length : 0);
       if (toolCalls.length === 0 && rawToolCallsCount === 0) {
@@ -1567,9 +1771,21 @@ async function runLocalAgentTurn(input) {
           continue;
         }
         if (outcome.kind === "fallback") {
+          if (outcome.reason === "length_truncated" && result.reasoning_content) {
+            const reasoningTailLog = formatLengthTruncatedReasoningTail(result.reasoning_content);
+            if (reasoningTailLog) {
+              console.warn(`
+${reasoningTailLog}
+`);
+            }
+          }
           result = {
             ...result,
-            content: resolveEmptyAssistantFallbackMessage(outcome.reason)
+            content: resolveEmptyAssistantFallbackMessage(outcome.reason),
+            // 只打标记不抛错：交互侧仍照常显示诊断文案（零行为变化）。
+            // 上层（后台 run 编排者）据 emptyAssistantFallbackReason 判断
+            // 是否把本轮结算为 failed。见 LocalAgentTurnResult 注释。
+            emptyAssistantFallbackReason: outcome.reason
           };
           break;
         }
@@ -1605,6 +1821,7 @@ async function runLocalAgentTurn(input) {
         ...result.reasoning_content ? { reasoning_content: result.reasoning_content } : {},
         tool_calls: toolCalls
       });
+      const executedToolResults = [];
       for (const toolCall of toolCalls) {
         throwIfAborted(input);
         const toolName = toolCall.function.name;
@@ -1717,6 +1934,11 @@ async function runLocalAgentTurn(input) {
             }
           };
         }
+        executedToolResults.push({
+          toolName,
+          content: toolResult.content,
+          metadata: toolResult.metadata
+        });
         messages.push({
           role: "tool",
           content: formatToolMessageContent({
@@ -1729,6 +1951,26 @@ async function runLocalAgentTurn(input) {
           ...toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}
         });
       }
+      const toolExecutionGuardVerdict = progressGuard.observeToolExecution(
+        toolCalls,
+        executedToolResults
+      );
+      if (toolExecutionGuardVerdict.action === "stall") {
+        emitLoopEvent(input, {
+          kind: "loop-stalled",
+          round,
+          reason: toolExecutionGuardVerdict.reason,
+          detail: toolExecutionGuardVerdict.detail,
+          consecutiveRounds: toolExecutionGuardVerdict.consecutiveRounds,
+          atMs: Date.now()
+        });
+        result = {
+          ...result,
+          content: resolveEmptyAssistantFallbackMessage(toolExecutionGuardVerdict.reason),
+          emptyAssistantFallbackReason: toolExecutionGuardVerdict.reason
+        };
+        break;
+      }
       round += 1;
     }
   } catch (error) {
@@ -3044,14 +3286,6 @@ var NEVER_LOCAL_TOOLS = /* @__PURE__ */ new Set([
   "updateSelf",
   "createAgent"
 ]);
-var REMOVED_LOCAL_TOOLS = /* @__PURE__ */ new Set([
-  "gitStatus",
-  "gitDiff",
-  "gitCreateBranch",
-  "gitAdd",
-  "gitCommit",
-  "commitWorkspace"
-]);
 var DEFAULT_LOCAL_TOOLS = /* @__PURE__ */ new Set([
   "readFile",
   "writeFile",
@@ -3099,13 +3333,6 @@ function resolveLocalToolPolicy(args) {
       reason: `${toolName} is blocked by the local runtime safety policy.`
     };
   }
-  if (REMOVED_LOCAL_TOOLS.has(toolName)) {
-    return {
-      allowed: false,
-      toolName,
-      reason: `${toolName} has been removed from the local runtime tool surface. Use execShell in shell-enabled workspace runs when shell is needed.`
-    };
-  }
   const allowedByEnv = new Set(parseToolAllowlist(args.env.NOLO_LOCAL_ALLOWED_TOOLS));
   const agentTools = new Set(
     (args.agentToolNames ?? []).flatMap((item) => {
@@ -4076,14 +4303,6 @@ var WORKSPACE_TOOL_NAMES = [
 ];
 var SHELL_TOOL_NAMES = ["execShell", "launchProcess", "listProcesses"];
 var WORKSPACE_TOOL_NAME_SET = new Set(WORKSPACE_TOOL_NAMES);
-var REMOVED_WORKSPACE_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "gitStatus",
-  "gitDiff",
-  "gitCreateBranch",
-  "gitAdd",
-  "gitCommit",
-  "commitWorkspace"
-]);
 function buildWorkspacePathProperty() {
   return {
     type: "string",
@@ -4327,7 +4546,7 @@ function buildWorkspaceToolDefinition(toolName) {
 }
 function filterDeclaredWorkspaceToolNames(args) {
   return (args.toolNames ?? []).filter(
-    (toolName) => WORKSPACE_TOOL_NAME_SET.has(toolName) && !REMOVED_WORKSPACE_TOOL_NAMES.has(toolName) && (args.exposeShellTools || !SHELL_TOOL_NAMES.includes(toolName))
+    (toolName) => WORKSPACE_TOOL_NAME_SET.has(toolName) && (args.exposeShellTools || !SHELL_TOOL_NAMES.includes(toolName))
   );
 }
 
@@ -4418,7 +4637,7 @@ function buildLocalWorkspacePolicyToolNames(args) {
       toolNames: args.declaredToolNames,
       exposeShellTools: args.exposeShellTools === true
     })
-  ])].filter((toolName) => !REMOVED_WORKSPACE_TOOL_NAMES.has(toolName));
+  ])];
 }
 function buildLocalWorkspaceOpenAiTools(args) {
   const declaredTools = new Set(args.toolNames ?? []);
@@ -4489,7 +4708,6 @@ function readExpectedReplacementCount(args) {
   return value;
 }
 var READ_FILE_SLICE_FALLBACK_LINES = 200;
-var LEGACY_SLICE_ARG_NAMES = ["startLine", "endLine", "maxLines", "tailLines"];
 function isAbsentArg(value) {
   return value === void 0 || value === null;
 }
@@ -4559,46 +4777,16 @@ function parseLinesArg(value) {
 }
 function readFileSliceArgs(args) {
   const warnings = [];
-  const legacyUsed = LEGACY_SLICE_ARG_NAMES.filter((name) => !isAbsentArg(args[name]));
-  const withFallback = (slice) => {
+  const withFallback = (slice2) => {
     warnings.push(
       `No usable line range remained; returned the first ${READ_FILE_SLICE_FALLBACK_LINES} lines instead of the whole file.`
     );
-    return { ...slice, maxLines: READ_FILE_SLICE_FALLBACK_LINES, warnings };
+    return { ...slice2, maxLines: READ_FILE_SLICE_FALLBACK_LINES, warnings };
   };
-  if (!isAbsentArg(args.lines)) {
-    if (legacyUsed.length > 0) {
-      warnings.push(`Ignored ${legacyUsed.join(", ")}: superseded by lines.`);
-    }
-    const { slice, warning } = parseLinesArg(args.lines);
-    if (warning) warnings.push(warning);
-    return slice ? { ...slice, warnings } : withFallback({});
-  }
-  if (legacyUsed.length === 0) return { warnings };
-  warnings.push(
-    `${legacyUsed.join(", ")} ${legacyUsed.length > 1 ? "are" : "is"} deprecated; use lines instead (${LINES_ARG_SYNTAX}).`
-  );
-  const take = (name, max) => collectIntegerArg({ value: args[name], name, max, warnings });
-  const resolved = {
-    startLine: take("startLine"),
-    endLine: take("endLine"),
-    maxLines: take("maxLines", 2e3),
-    tailLines: take("tailLines", 2e3)
-  };
-  if (resolved.endLine !== void 0 && resolved.startLine !== void 0 && resolved.endLine < resolved.startLine) {
-    warnings.push(
-      `Ignored endLine (${resolved.endLine}): endLine must be greater than or equal to startLine (${resolved.startLine}).`
-    );
-    resolved.endLine = void 0;
-  }
-  if (resolved.tailLines !== void 0 && (resolved.startLine !== void 0 || resolved.endLine !== void 0)) {
-    warnings.push(
-      `Ignored tailLines (${resolved.tailLines}): tailLines cannot be combined with startLine or endLine.`
-    );
-    resolved.tailLines = void 0;
-  }
-  const nothingUsable = LEGACY_SLICE_ARG_NAMES.every((name) => resolved[name] === void 0);
-  return nothingUsable ? withFallback(resolved) : { ...resolved, warnings };
+  if (isAbsentArg(args.lines)) return { warnings };
+  const { slice, warning } = parseLinesArg(args.lines);
+  if (warning) warnings.push(warning);
+  return slice ? { ...slice, warnings } : withFallback({});
 }
 function buildReadFileSliceHint(totalLines) {
   return `File has ${totalLines} lines. Use lines: ${LINES_ARG_SYNTAX}, or omit it for the whole file.`;