@cydm/pie 1.0.48 → 1.0.50

package/dist/builtin/skills/skill-creator/eval-viewer/viewer.html

@@ -545,7 +545,7 @@
     <div class="header">
       <div>
         <h1>Eval Review: <span id="skill-name"></span></h1>
-        <div class="instructions">Review each output and leave feedback below. Navigate with arrow keys or buttons. When done, copy feedback and paste into Claude Code.</div>
+        <div class="instructions">Review each output and leave feedback below. Navigate with arrow keys or buttons. When done, copy feedback and paste it back into your Pie session.</div>
       </div>
       <div class="progress" id="progress"></div>
     </div>
@@ -634,7 +634,7 @@
   <div class="done-overlay" id="done-overlay">
     <div class="done-card">
       <h2>Review Complete</h2>
-      <p>Your feedback has been saved. Go back to your Claude Code session and tell Claude you're done reviewing.</p>
+      <p>Your feedback has been saved. Go back to your Pie session and say you're done reviewing.</p>
       <div class="btn-row">
         <button onclick="closeDoneDialog()">OK</button>
       </div>

package/dist/builtin/skills/skill-creator/references/schemas.md

@@ -225,7 +225,7 @@ Output from Benchmark mode. Located at `benchmarks/<timestamp>/benchmark.json`.
   "metadata": {
     "skill_name": "pdf",
     "skill_path": "/path/to/pdf",
-    "executor_model": "claude-sonnet-4-20250514",
+    "executor_model": "pie-agent",
     "analyzer_model": "most-capable-model",
     "timestamp": "2026-01-15T10:30:00Z",
     "evals_run": [1, 2, 3],

package/dist/builtin/skills/skill-creator/scripts/generate_report.mjs

@@ -75,7 +75,7 @@ ${refreshTag}    <title>${titlePrefix}Skill Description Optimization</title>
 <body>
     <h1>${titlePrefix}Skill Description Optimization</h1>
     <div class="explainer">
-        <strong>Optimizing your skill's description.</strong> This page updates automatically as Claude tests different versions of your skill's description. Each row is an iteration — a new description attempt. The columns show test queries: green checkmarks mean the skill triggered correctly (or correctly didn't trigger), red crosses mean it got it wrong.
+        <strong>Optimizing your skill's description.</strong> This page updates automatically as the model tests different versions of your skill's description. Each row is an iteration — a new description attempt. The columns show test queries: green checkmarks mean the skill triggered correctly (or correctly didn't trigger), red crosses mean it got it wrong.
     </div>
     <div class="summary">
         <p><strong>Original:</strong> ${escapeHtml(data?.original_description ?? "N/A")}</p>

package/dist/builtin/skills/skill-creator/scripts/improve_description.mjs

@@ -25,9 +25,9 @@ export async function improveDescription({
     ? `Train: ${trainScore}, Test: ${testResults.summary.passed}/${testResults.summary.total}`
     : `Train: ${trainScore}`;
 
-  let prompt = `You are optimizing a skill description for a Claude Code skill called "${skillName}". A "skill" is sort of like a prompt, but with progressive disclosure -- there's a title and description that Claude sees when deciding whether to use the skill, and then if it does use the skill, it reads the .md file which has lots more details and potentially links to other resources in the skill folder like helper files and scripts and additional documentation or examples.
+  let prompt = `You are optimizing a skill description for a Pie skill called "${skillName}". A "skill" is sort of like a prompt, but with progressive disclosure -- there's a title and description that the agent sees when deciding whether to use the skill, and then if it does use the skill, it reads the .md file which has lots more details and potentially links to other resources in the skill folder like helper files and scripts and additional documentation or examples.
 
-The description appears in Claude's "available_skills" list. When a user sends a query, Claude decides whether to invoke the skill based solely on the title and on this description. Your goal is to write a description that triggers for relevant queries, and doesn't trigger for irrelevant ones.
+The description appears in the agent's "available_skills" list. When a user sends a query, the agent decides whether to invoke the skill based solely on the title and on this description. Your goal is to write a description that triggers for relevant queries, and doesn't trigger for irrelevant ones.
 
 Here's the current description:
 <current_description>
@@ -93,7 +93,7 @@ Concretely, your description should not be more than about 100-200 words, even i
 Here are some tips that we've found to work well in writing these descriptions:
 - The skill should be phrased in the imperative -- "Use this skill for" rather than "this skill does"
 - The skill description should focus on the user's intent, what they are trying to achieve, vs. the implementation details of how the skill works.
-- The description competes with other skills for Claude's attention — make it distinctive and immediately recognizable.
+- The description competes with other skills for the model's attention — make it distinctive and immediately recognizable.
 - If you're getting lots of failures after repeated attempts, change things up. Try different sentence structures or wordings.
 
 I'd encourage you to be creative and mix up the style in different iterations since you'll have multiple opportunities to try different approaches and we'll just grab the highest-scoring one at the end.

package/dist/builtin/skills/skill-creator/scripts/pie_runner.mjs

@@ -2,11 +2,11 @@
 
 import crypto from "node:crypto";
 import { spawn } from "node:child_process";
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = path.resolve(SCRIPT_DIR, "../../../../../../");
 
 export function findProjectRoot(start = process.cwd()) {
   return path.resolve(start);
@@ -29,13 +29,41 @@ export function openInBrowser(target) {
   spawn("xdg-open", [target], { detached: true, stdio: "ignore" }).unref();
 }
 
-function getPieCliPath(cwd = process.cwd()) {
-  return path.join(REPO_ROOT, "products/cli/dist/cli.js");
+let cachedCliPath;
+
+/**
+ * Locate the Pie CLI entry point across layouts:
+ * - installed package: <pkg>/dist/builtin/skills/skill-creator/scripts -> <pkg>/dist/cli.js
+ * - dev repository:   <repo>/products/cli/builtin/skills/skill-creator/scripts -> <repo>/products/cli/dist/cli.js
+ * - explicit override via PIE_CLI_PATH
+ *
+ * Candidate order is layout-aware: an installed build always prefers the
+ * package root and a dev checkout always prefers products/cli, so an
+ * unrelated sibling artifact cannot win over the correct entry.
+ */
+export function getPieCliPath() {
+  if (cachedCliPath) return cachedCliPath;
+  const installed = path.resolve(SCRIPT_DIR, "../../../../../dist/cli.js"); // installed package root
+  const dev = path.resolve(SCRIPT_DIR, "../../../../dist/cli.js"); // dev repo: products/cli
+  const inInstalledLayout = SCRIPT_DIR.includes(`${path.sep}dist${path.sep}builtin${path.sep}`);
+  const candidates = [
+    process.env.PIE_CLI_PATH,
+    ...(inInstalledLayout ? [installed, dev] : [dev, installed]),
+  ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      cachedCliPath = candidate;
+      return cachedCliPath;
+    }
+  }
+  throw new Error(
+    `Pie CLI entry not found. Tried: ${candidates.join(", ")}. Set PIE_CLI_PATH to the cli.js entry point.`,
+  );
 }
 
 export async function runPieJsonPrompt(prompt, { cwd = process.cwd(), timeout = 300_000, sessionId = null } = {}) {
   return new Promise((resolve, reject) => {
-    const args = [getPieCliPath(cwd), prompt, "--json-output"];
+    const args = [getPieCliPath(), prompt, "--json-output"];
     if (sessionId) {
       args.push("--session-id", sessionId);
     }

package/dist/builtin/skills/skill-creator/scripts/run_loop.mjs

@@ -6,7 +6,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { generateHtml } from "./generate_report.mjs";
 import { improveDescription } from "./improve_description.mjs";
-import { findProjectRoot, openInBrowser } from "./claude_cli.mjs";
+import { findProjectRoot, openInBrowser } from "./pie_runner.mjs";
 import { runEval } from "./run_eval.mjs";
 import { parseSkillFile, resolveSkillPath } from "./skill_metadata.mjs";
 

package/dist/chunks/{chunk-IJMP3JTX.js → chunk-DZS34ACX.js}

@@ -848,6 +848,10 @@ var BUILTIN_TOOL_CAPABILITY_METADATA = {
   spawn_subagents_parallel: { riskClass: "read_only", concurrencySafe: false, permissionScope: "host", readsHostResource: true, availableInPlanMode: true, maxOutputChars: 1e5 },
   ask_user_multi: { riskClass: "user_interaction", concurrencySafe: false, permissionScope: "user", asksUser: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
   manage_todo_list: { riskClass: "session_mutation", concurrencySafe: false, permissionScope: "session", mutatesSession: true, availableInPlanMode: true },
+  // plan_scratch ships as the plan-mode extension's session-local draft tool;
+  // registration feeds /permissions display and the legacy plan-mode name list,
+  // while runtime decisions still honor the tool's inline risk metadata first.
+  plan_scratch: { riskClass: "session_mutation", concurrencySafe: false, permissionScope: "session", mutatesSession: true, availableInPlanMode: true },
   unity_project_inspect: { riskClass: "read_only", concurrencySafe: true, permissionScope: "unity", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
   unity_scene_query: { riskClass: "read_only", concurrencySafe: true, permissionScope: "unity", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
   unity_scene_object_inspect: { riskClass: "read_only", concurrencySafe: true, permissionScope: "unity", readsHostResource: true, availableInPlanMode: true, allowedForSubagentByDefault: true },
@@ -1409,8 +1413,9 @@ function buildSubagentPlan(deps, task, name, priority, timeoutSeconds) {
   const complexity = inferComplexity(task, priority);
   const modelClass = selectModelClass(complexity, priority);
   const modelResolution = deps.resolveModelClass?.(modelClass);
-  const model = modelResolution?.model ?? deps.model;
-  const apiKey = modelResolution?.apiKey ?? deps.apiKey;
+  const resolvedPair = modelResolution?.model && modelResolution?.apiKey ? { model: modelResolution.model, apiKey: modelResolution.apiKey } : void 0;
+  const model = resolvedPair?.model ?? deps.model;
+  const apiKey = resolvedPair?.apiKey ?? deps.apiKey;
   const partialPlan = {
     task,
     name,
@@ -1508,6 +1513,9 @@ async function runSubagentWithProgress(deps, task, reportProgress, signal) {
     if (!apiKey) {
       throw new Error("No API key available for subagent execution.");
     }
+    if (!model) {
+      throw new Error("No model configured for subagent execution.");
+    }
     if (signal?.aborted) {
       throw new Error("Subagent aborted by parent");
     }
@@ -1845,6 +1853,12 @@ var ManageTodoListParamsSchema = Type.Object(
   },
   { additionalProperties: false }
 );
+var MANAGE_TODO_LIST_TOOL_DESCRIPTION = `Manage a session-local todo list. Use when the user explicitly asks to use the todo tool, create/manage todos, track tasks, follow a todo list, show tasks, or mark a task done.
+NEVER use for: internal planning, tracking your own progress, remembering subtasks, or creating checklists for yourself.
+Use action=create with items to create a list; provide todo titles and optional descriptions only. The tool assigns ids and starts item 1 automatically.
+Use action=complete_current after finishing the current item; the tool advances to the next item or clears the list after the final item. Do not call complete_current after a required install, build, test, or verification command just failed; fix/retry first or clear with a reason.
+When a todo list exists, keep executing from the current in-progress item until it is cleared. If the work cannot continue, explain the failure and use action=clear with a reason.
+Actions: create, read, complete_current, clear.`;
 function cloneTodos(todos) {
   return todos.map((todo) => ({ ...todo }));
 }
@@ -7869,6 +7883,193 @@ function fuzzyFindText(content, oldText) {
 function stripBom(content) {
   return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
 }
+function findEditMatch(content, oldText, newText) {
+  const direct = fuzzyFindText(content, oldText);
+  if (direct.found) {
+    return { found: true, occurrences: direct.occurrences, matches: direct.matches, matchKind: direct.matchKind };
+  }
+  return findWhitespaceRelaxedMatch(content, oldText, newText);
+}
+function leadingWhitespace(line) {
+  const match2 = line.match(/^[ \t]*/);
+  return match2 ? match2[0] : "";
+}
+function findRelaxedWindows(fileLines, qLines) {
+  const firstNonBlank = qLines.findIndex((line) => line.trim() !== "");
+  if (firstNonBlank === -1) return [];
+  const anchor = qLines[firstNonBlank].trim();
+  if (!anchor) return [];
+  const windows = [];
+  for (let anchorFileLine = 0; anchorFileLine < fileLines.length; anchorFileLine++) {
+    if (fileLines[anchorFileLine].trim() !== anchor) continue;
+    const startLine = anchorFileLine - firstNonBlank;
+    if (startLine < 0) continue;
+    let fileLine = startLine;
+    let ok = true;
+    let lastPaired = -1;
+    const qLineToFileLine = /* @__PURE__ */ new Map();
+    for (let qLine = 0; qLine < qLines.length; qLine++) {
+      if (fileLine >= fileLines.length) {
+        ok = false;
+        break;
+      }
+      const q = qLines[qLine];
+      const f = fileLines[fileLine];
+      if (q.trim() === "") {
+        if (f.trim() !== "") {
+          ok = false;
+          break;
+        }
+      } else {
+        if (f.trim() !== q.trim()) {
+          ok = false;
+          break;
+        }
+        qLineToFileLine.set(qLine, fileLine);
+        lastPaired = fileLine;
+      }
+      fileLine++;
+    }
+    if (ok && lastPaired !== -1) windows.push({ startLine, endLine: lastPaired, qLineToFileLine });
+  }
+  return windows;
+}
+function lineSpanToCharSpan(fileLines, startLine, endLine) {
+  let index = 0;
+  for (let i = 0; i < startLine; i++) index += fileLines[i].length + 1;
+  let matchLength = 0;
+  for (let i = startLine; i <= endLine; i++) matchLength += fileLines[i].length + (i < endLine ? 1 : 0);
+  return { index, matchLength };
+}
+function reindentNewText(newText, qLines, fileLines, window) {
+  const newLines = newText.split("\n");
+  const qIndent = (qLine) => {
+    const fileLine = window.qLineToFileLine.get(qLine);
+    return fileLine === void 0 ? "" : leadingWhitespace(fileLines[fileLine]);
+  };
+  const qIdx = [];
+  for (let i = 0; i < qLines.length; i++) if (qLines[i].trim() !== "") qIdx.push(i);
+  const nIdx = [];
+  const nPosOfLine = /* @__PURE__ */ new Map();
+  for (let i = 0; i < newLines.length; i++) {
+    if (newLines[i].trim() === "") continue;
+    nPosOfLine.set(i, nIdx.length);
+    nIdx.push(i);
+  }
+  if (nIdx.length === 0) return newText;
+  const counterpart = /* @__PURE__ */ new Map();
+  let p = 0;
+  while (p < qIdx.length && p < nIdx.length && qLines[qIdx[p]].trim() === newLines[nIdx[p]].trim()) {
+    counterpart.set(p, p);
+    p++;
+  }
+  let s = 0;
+  while (s < qIdx.length - p && s < nIdx.length - p && qLines[qIdx[qIdx.length - 1 - s]].trim() === newLines[nIdx[nIdx.length - 1 - s]].trim()) {
+    counterpart.set(nIdx.length - 1 - s, qIdx.length - 1 - s);
+    s++;
+  }
+  const midQ = [];
+  for (let pos = p; pos < qIdx.length - s; pos++) midQ.push(pos);
+  const midN = [];
+  for (let pos = p; pos < nIdx.length - s; pos++) midN.push(pos);
+  const pairRegion = (qLo, qHi, nLo, nHi) => {
+    const qCount = qHi - qLo;
+    const nCount = nHi - nLo;
+    const paired = Math.min(qCount, nCount);
+    for (let k = 0; k < paired; k++) counterpart.set(nLo + k, qLo + k);
+    const fallbackQ = qCount > 0 ? qHi - 1 : Math.max(qLo - 1, 0);
+    for (let k = paired; k < nCount; k++) counterpart.set(nLo + k, fallbackQ);
+  };
+  const qTextCounts = /* @__PURE__ */ new Map();
+  for (const qPos of midQ) {
+    const t = qLines[qIdx[qPos]].trim();
+    qTextCounts.set(t, (qTextCounts.get(t) ?? 0) + 1);
+  }
+  const qPosByText = /* @__PURE__ */ new Map();
+  for (const qPos of midQ) {
+    const t = qLines[qIdx[qPos]].trim();
+    if (qTextCounts.get(t) === 1) qPosByText.set(t, qPos);
+  }
+  const nTextCounts = /* @__PURE__ */ new Map();
+  for (const nPos of midN) {
+    const t = newLines[nIdx[nPos]].trim();
+    nTextCounts.set(t, (nTextCounts.get(t) ?? 0) + 1);
+  }
+  let cursorQ = p;
+  let cursorN = p;
+  for (const nPos of midN) {
+    const t = newLines[nIdx[nPos]].trim();
+    const qPos = qPosByText.get(t);
+    if (nTextCounts.get(t) !== 1 || qPos === void 0 || qPos < cursorQ) continue;
+    pairRegion(cursorQ, qPos, cursorN, nPos);
+    counterpart.set(nPos, qPos);
+    cursorQ = qPos + 1;
+    cursorN = nPos + 1;
+  }
+  pairRegion(cursorQ, qIdx.length - s, cursorN, nIdx.length - s);
+  const result = [];
+  for (let i = 0; i < newLines.length; i++) {
+    if (newLines[i].trim() === "") {
+      result.push("");
+      continue;
+    }
+    const nPos = nPosOfLine.get(i) ?? 0;
+    const qPos = counterpart.get(nPos) ?? 0;
+    result.push(qIndent(qIdx[qPos] ?? qIdx[0]) + newLines[i].trim());
+  }
+  return result.join("\n");
+}
+function findWhitespaceRelaxedMatch(content, oldText, newText) {
+  const fileLines = content.split("\n");
+  const qLines = oldText.split("\n");
+  const windows = findRelaxedWindows(fileLines, qLines);
+  if (windows.length === 0) {
+    return { found: false, occurrences: 0, matches: [], matchKind: "none" };
+  }
+  const matches = windows.map((window) => {
+    const span = lineSpanToCharSpan(fileLines, window.startLine, window.endLine);
+    return { ...span, replacementText: reindentNewText(newText, qLines, fileLines, window) };
+  });
+  return { found: true, occurrences: matches.length, matches, matchKind: "whitespace-relaxed" };
+}
+function describeClosestRegion(content, oldText) {
+  const qLines = oldText.split("\n");
+  const firstNonBlank = qLines.findIndex((line) => line.trim() !== "");
+  if (firstNonBlank === -1) return void 0;
+  const anchor = qLines[firstNonBlank].trim();
+  const fileLines = content.split("\n");
+  const clip = (text) => text.length > 90 ? `${text.slice(0, 90)}\u2026` : text;
+  let best;
+  for (let i = 0; i < fileLines.length; i++) {
+    if (fileLines[i].trim() !== anchor) continue;
+    let matched = 0;
+    let fi = i;
+    let firstDiff;
+    for (let qi = firstNonBlank; qi < qLines.length; qi++) {
+      const q = qLines[qi].trim();
+      if (!q) continue;
+      while (fi < fileLines.length && !fileLines[fi].trim()) fi++;
+      if (fi >= fileLines.length || fileLines[fi].trim() !== q) {
+        firstDiff = { fileNo: fi + 1, fileLine: fileLines[fi] ?? "<end of file>", qLine: qLines[qi] };
+        break;
+      }
+      matched++;
+      fi++;
+    }
+    if (!best || matched > best.matched) best = { start: i, matched, firstDiff };
+  }
+  const total = qLines.filter((line) => line.trim() !== "").length;
+  if (!best) {
+    return `No line matching ${JSON.stringify(clip(anchor))} exists in this file \u2014 the text may live in a different file, or the file changed since it was read.`;
+  }
+  const parts = [`Closest match: file lines ${best.start + 1}\u2013${best.start + total} (${best.matched}/${total} lines matched by trimmed content).`];
+  if (best.firstDiff) {
+    parts.push(`First difference at line ${best.firstDiff.fileNo}: file has ${JSON.stringify(clip(best.firstDiff.fileLine.trim()))}, edit expected ${JSON.stringify(clip(best.firstDiff.qLine.trim()))}.`);
+  } else {
+    parts.push("All non-empty lines match by trimmed content \u2014 the mismatch is leading whitespace or blank-line placement.");
+  }
+  return parts.join(" ");
+}
 function generateDiffString(oldContent, newContent, contextLines = 4) {
   const oldLines = normalizeToLF(stripBom(oldContent).text).split("\n");
   const newLines = normalizeToLF(stripBom(newContent).text).split("\n");
@@ -7982,7 +8183,8 @@ function createEditErrorResult(params) {
   const detailLines = [
     params.message,
     params.recoveryHint,
-    params.alreadyAppliedCandidate ? "Diagnostic: newText already appears in the current file, but edit_file did not treat that as success because it may be an unrelated occurrence." : ""
+    params.alreadyAppliedCandidate ? "Diagnostic: newText already appears in the current file, but edit_file did not treat that as success because it may be an unrelated occurrence." : "",
+    params.closestMatch ? `Diagnostic: ${params.closestMatch}` : ""
   ].filter(Boolean);
   return {
     content: [{ type: "text", text: detailLines.join("\n") }],
@@ -8034,7 +8236,7 @@ function createEditTool(cwd, options) {
       newText: Type.String({ description: "Replacement text", maxLength: MAX_EDIT_INPUT_CHARS }),
       replaceAll: Type.Optional(Type.Boolean({ description: "Replace every occurrence" }))
     }), {
-      description: "One or more independent replacements matched against the original file",
+      description: "Replacements applied in order: each edit matches the file as left by the previous edit, so later edits can build on earlier ones. Whole-line indentation drift is tolerated \u2014 matches locate by trimmed content and the replacement adopts the file's indentation.",
       minItems: 1,
       maxItems: MAX_EDIT_BLOCKS
     })
@@ -8043,7 +8245,7 @@ function createEditTool(cwd, options) {
   return {
     name: "edit",
     label: "edit",
-    description: `Make precise exact-text replacements in one file. For multiple changes in the same file, put all independent replacements in one edits[] call. ${pathResolutionDescription}`,
+    description: `Make precise exact-text replacements in one file. For multiple changes in the same file, put all replacements in one edits[] call \u2014 they apply in order, so later edits can target what earlier ones just changed. ${pathResolutionDescription}`,
     parameters: editSchema,
     execute: async (_toolCallId, params, signal) => {
       const { path: path4, root } = params;
@@ -8087,7 +8289,9 @@ function createEditTool(cwd, options) {
             const { bom, text: content } = stripBom(rawContent);
             const originalEnding = detectLineEnding(content);
             const normalizedContent = normalizeToLF(content);
-            const planned = [];
+            let workingContent = normalizedContent;
+            const plannedKinds = /* @__PURE__ */ new Set();
+            let replacedOccurrences = 0;
             let totalOldOccurrences = 0;
             let totalNewOccurrences = 0;
             let anyReplaceAll = false;
@@ -8095,8 +8299,8 @@ function createEditTool(cwd, options) {
               throwIfAborted();
               const normalizedOldText = normalizeToLF(replacement.oldText);
               const normalizedNewText = normalizeToLF(replacement.newText);
-              const newTextOccurrences = countOccurrences(normalizedContent, normalizedNewText);
-              const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
+              const newTextOccurrences = countOccurrences(workingContent, normalizedNewText);
+              const matchResult = findEditMatch(workingContent, normalizedOldText, normalizedNewText);
               totalOldOccurrences += matchResult.occurrences;
               totalNewOccurrences += newTextOccurrences;
               anyReplaceAll ||= replacement.replaceAll;
@@ -8111,7 +8315,8 @@ function createEditTool(cwd, options) {
                   replaceAll: replacement.replaceAll,
                   staleBaseLikely: newTextOccurrences > 0,
                   alreadyAppliedCandidate: newTextOccurrences > 0,
-                  recoveryHint: newTextOccurrences > 0 ? "The replacement may already be present. Read the current file before retrying." : "Read the latest file and retry with exact text."
+                  recoveryHint: newTextOccurrences > 0 ? "The replacement may already be present. Read the current file before retrying." : "Read the latest file and retry with exact text.",
+                  closestMatch: describeClosestRegion(workingContent, normalizedOldText)
                 }));
                 return;
               }
@@ -8128,9 +8333,9 @@ function createEditTool(cwd, options) {
                 }));
                 return;
               }
-              const matches = replacement.replaceAll ? matchResult.matches : matchResult.matches.slice(0, 1);
-              const changingMatches = matches.filter(
-                (match2) => normalizedContent.slice(match2.index, match2.index + match2.matchLength) !== normalizedNewText
+              const selected = replacement.replaceAll ? matchResult.matches : matchResult.matches.slice(0, 1);
+              const changingMatches = selected.filter(
+                (match2) => workingContent.slice(match2.index, match2.index + match2.matchLength) !== (match2.replacementText ?? normalizedNewText)
               );
               if (changingMatches.length === 0) {
                 if (signal) signal.removeEventListener("abort", onAbort);
@@ -8146,42 +8351,20 @@ function createEditTool(cwd, options) {
                 }));
                 return;
               }
-              for (const match2 of changingMatches) {
-                planned.push({ ...match2, newText: normalizedNewText, matchKind: matchResult.matchKind });
-              }
-            }
-            const ordered = [...planned].sort((left, right) => left.index - right.index);
-            for (let index = 1; index < ordered.length; index++) {
-              throwIfAborted();
-              const previous = ordered[index - 1];
-              const current = ordered[index];
-              if (current.index < previous.index + previous.matchLength) {
-                if (signal) signal.removeEventListener("abort", onAbort);
-                resolve3(createEditErrorResult({
-                  message: `Edits overlap in ${path4}; no changes were made.`,
-                  matchKind: "mixed",
-                  errorReason: "overlapping_edits",
-                  oldTextOccurrences: totalOldOccurrences,
-                  newTextOccurrences: totalNewOccurrences,
-                  replaceAll: anyReplaceAll,
-                  recoveryHint: "Merge overlapping replacements into one exact edit."
-                }));
-                return;
+              for (const match2 of [...changingMatches].sort((left, right) => right.index - left.index)) {
+                throwIfAborted();
+                workingContent = workingContent.substring(0, match2.index) + (match2.replacementText ?? normalizedNewText) + workingContent.substring(match2.index + match2.matchLength);
+                replacedOccurrences++;
+                if (matchResult.matchKind !== "none") plannedKinds.add(matchResult.matchKind);
               }
             }
             throwIfAborted();
-            const baseContent = normalizedContent;
-            let newContent = baseContent;
-            for (const match2 of [...planned].sort((left, right) => right.index - left.index)) {
-              throwIfAborted();
-              newContent = newContent.substring(0, match2.index) + match2.newText + newContent.substring(match2.index + match2.matchLength);
-            }
-            if (baseContent === newContent) {
+            if (workingContent === normalizedContent) {
               if (signal) signal.removeEventListener("abort", onAbort);
               resolve3(
                 createEditErrorResult({
                   message: `No changes made to ${path4}. The replacement produced identical content.`,
-                  matchKind: planned.every((match2) => match2.matchKind === planned[0]?.matchKind) ? planned[0]?.matchKind ?? "none" : "mixed",
+                  matchKind: plannedKinds.size === 1 ? [...plannedKinds][0] : "mixed",
                   errorReason: "replacement_no_change",
                   oldTextOccurrences: totalOldOccurrences,
                   newTextOccurrences: totalNewOccurrences,
@@ -8192,6 +8375,7 @@ function createEditTool(cwd, options) {
               );
               return;
             }
+            const newContent = workingContent;
             const finalContent = bom + restoreLineEndings(newContent, originalEnding);
             throwIfAborted();
             await fs2.writeFile(absolutePath, finalContent, "utf-8");
@@ -8201,13 +8385,12 @@ function createEditTool(cwd, options) {
               signal.removeEventListener("abort", onAbort);
             }
             const diffResult = generateDiffString(content, restoreLineEndings(newContent, originalEnding));
-            const matchKinds = new Set(planned.map((match2) => match2.matchKind));
-            const matchKind = matchKinds.size === 1 ? planned[0]?.matchKind ?? "none" : "mixed";
+            const matchKind = plannedKinds.size === 1 ? [...plannedKinds][0] : "mixed";
             resolve3({
               content: [
                 {
                   type: "text",
-                  text: `Changed ${path4}: ${replacements.length} edit block${replacements.length === 1 ? "" : "s"}, ${planned.length} replacement${planned.length === 1 ? "" : "s"}. First changed line: ${diffResult.firstChangedLine}.`
+                  text: `Changed ${path4}: ${replacements.length} edit block${replacements.length === 1 ? "" : "s"}, ${replacedOccurrences} replacement${replacedOccurrences === 1 ? "" : "s"}. First changed line: ${diffResult.firstChangedLine}.`
                 },
                 { type: "text", text: boundedDiff(diffResult.diff) }
               ],
@@ -8221,7 +8404,7 @@ function createEditTool(cwd, options) {
                 oldTextOccurrences: totalOldOccurrences,
                 newTextOccurrences: totalNewOccurrences,
                 replaceAll: anyReplaceAll,
-                replacedOccurrences: planned.length,
+                replacedOccurrences,
                 replacedBlocks: replacements.length
               }
             });
@@ -12363,7 +12546,7 @@ function sanitizeTitle(title) {
 }
 function isTextCompletionStepTitle(title) {
   const normalized = sanitizeTitle(title).toLowerCase();
-  return /反馈|总结|结论|汇报|说明|解释|收尾|验证|确认|位置|结果/u.test(title) || /\b(summarize|summary|report|explain|explanation|wrap[\s-]?up|verify|verification|confirm|result|results|location|findings)\b/i.test(normalized);
+  return /反馈|总结|结论|汇报|说明|解释|收尾|验证|确认|位置|结果/u.test(normalized) || /\b(summarize|summary|report|explain|explanation|wrap[\s-]?up|verify|verification|confirm|result|results|location|findings)\b/i.test(normalized);
 }
 function maybeAdvanceTodoExecutionState(state, signal) {
   if (state.mode !== "todo" || state.source === "user_todo" || state.lifecycle !== "active" || !state.currentStepId) {
@@ -14997,6 +15180,7 @@ export {
   interpretShellExit,
   createSubagentCapability,
   ManageTodoListParamsSchema,
+  MANAGE_TODO_LIST_TOOL_DESCRIPTION,
   executeManageTodoList,
   maybeAdvanceTodoExecutionState,
   createAskUserCapability,

package/dist/chunks/{chunk-U4B6RJ6Z.js → chunk-XBWFDIAU.js}

@@ -8,7 +8,7 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-IJMP3JTX.js";
+} from "./chunk-DZS34ACX.js";
 import {
   Type
 } from "./chunk-K6ZOCJ4V.js";