@cydm/pie 1.0.16 → 1.0.18

package/dist/builtin/extensions/ask-user/index.js

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createAskUserCapability
-} from "../../../chunks/chunk-7GAYJ6AF.js";
+} from "../../../chunks/chunk-G4GV2CRT.js";
 import "../../../chunks/chunk-VE2HDCNB.js";
 import "../../../chunks/chunk-5DA2D3K2.js";
 import "../../../chunks/chunk-TG2EQLX2.js";

package/dist/builtin/extensions/plan-mode/index.js

@@ -7,7 +7,7 @@ import {
   isPlanModeSafeCommand,
   markCompletedPlanSteps,
   restoreExecutionState
-} from "../../../chunks/chunk-7GAYJ6AF.js";
+} from "../../../chunks/chunk-G4GV2CRT.js";
 import "../../../chunks/chunk-VE2HDCNB.js";
 import "../../../chunks/chunk-5DA2D3K2.js";
 import "../../../chunks/chunk-TG2EQLX2.js";

package/dist/builtin/extensions/subagent/index.js

@@ -1,11 +1,11 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   createCliHostCapabilities
-} from "../../../chunks/chunk-62XU6P2H.js";
+} from "../../../chunks/chunk-MHFUWY7I.js";
 import {
   createSharedFileSystemTools,
   createSubagentCapability
-} from "../../../chunks/chunk-7GAYJ6AF.js";
+} from "../../../chunks/chunk-G4GV2CRT.js";
 import "../../../chunks/chunk-VE2HDCNB.js";
 import "../../../chunks/chunk-5DA2D3K2.js";
 import "../../../chunks/chunk-TG2EQLX2.js";

package/dist/builtin/extensions/todo/index.js

@@ -7,7 +7,7 @@ import {
   executeManageTodoList,
   executionStateToTodos,
   restoreExecutionState
-} from "../../../chunks/chunk-7GAYJ6AF.js";
+} from "../../../chunks/chunk-G4GV2CRT.js";
 import "../../../chunks/chunk-VE2HDCNB.js";
 import "../../../chunks/chunk-5DA2D3K2.js";
 import "../../../chunks/chunk-TG2EQLX2.js";

package/dist/chunks/{chunk-7GAYJ6AF.js → chunk-G4GV2CRT.js}

@@ -1633,10 +1633,17 @@ ${sections.join("\n\n")}` : "";
 }
 async function createCompactionSummary(messages, options = {}) {
   const { model, apiKey, systemPrompt, compactPrompt, signal } = options;
+  const throwIfAborted = () => {
+    if (signal?.aborted) {
+      throw new Error("Compaction aborted");
+    }
+  };
   if (!model) {
+    throwIfAborted();
     return appendFileOperationsToSummary(createSimpleSummary(messages), messages);
   }
   try {
+    throwIfAborted();
     const response = await streamSimple(
       model,
       {
@@ -1655,8 +1662,10 @@ async function createCompactionSummary(messages, options = {}) {
         signal
       }
     ).result();
+    throwIfAborted();
     return appendFileOperationsToSummary(getAssistantText(response) || createSimpleSummary(messages), messages);
   } catch (error) {
+    throwIfAborted();
     console.warn("[Compaction] Failed to create Codex-style summary:", error);
     return appendFileOperationsToSummary(createSimpleSummary(messages), messages);
   }
@@ -2970,6 +2979,7 @@ var AgentSessionAutoCompactScheduler = class {
   autoCompactTimer;
   pendingAutoCompact;
   runningAutoCompact;
+  runningAbortController;
   pendingWait;
   resolvePendingWait;
   get hasPendingAutoCompact() {
@@ -3001,11 +3011,17 @@ var AgentSessionAutoCompactScheduler = class {
         this.schedule(pending, 100);
         return;
       }
-      this.runningAutoCompact = this.options.runAutoCompact(pending).catch(() => {
+      const abortController = new AbortController();
+      this.runningAbortController = abortController;
+      const running = this.options.runAutoCompact(pending, abortController.signal).catch(() => {
       }).finally(() => {
-        this.runningAutoCompact = void 0;
-        this.resolvePending();
+        if (this.runningAutoCompact === running) {
+          this.runningAutoCompact = void 0;
+          this.runningAbortController = void 0;
+          this.resolvePending();
+        }
       });
+      this.runningAutoCompact = running;
     }, delayMs);
   }
   cancel() {
@@ -3015,6 +3031,9 @@ var AgentSessionAutoCompactScheduler = class {
       this.autoCompactTimer = void 0;
     }
     this.pendingAutoCompact = void 0;
+    this.runningAbortController?.abort();
+    this.runningAbortController = void 0;
+    this.runningAutoCompact = void 0;
     this.resolvePending();
   }
   ensurePendingWait() {
@@ -3143,8 +3162,15 @@ async function runAgentSessionCompaction(params) {
   if (!params.compaction) {
     throw new Error("No compaction handler configured");
   }
+  const abortedResult = () => ({ aborted: true });
+  const isAborted = () => params.signal?.aborted === true;
   params.emit({ type: "auto_compaction_start", reason: params.reason, willRetry: params.willRetry });
   try {
+    if (isAborted()) {
+      const result2 = abortedResult();
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: result2 });
+      return result2;
+    }
     if (params.willRetry) {
       params.removeTrailingAssistantError();
     }
@@ -3154,22 +3180,43 @@ async function runAgentSessionCompaction(params) {
       agent: params.agent,
       sessionManager: params.sessionManager,
       messages: params.agent.state.messages.slice(),
-      cwd: params.cwd
+      cwd: params.cwd,
+      signal: params.signal
     });
+    if (isAborted() || result?.aborted) {
+      const aborted = { ...result, aborted: true };
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
+      return aborted;
+    }
     if (result?.summary && result.firstKeptEntryId) {
       params.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore);
       params.replaceMessagesAndMarkSynced(params.sessionManager.getMessages());
     } else if (result?.messages) {
       params.replaceMessagesAndMarkSynced(result.messages, { updateSession: true });
     }
+    if (isAborted()) {
+      const aborted = { ...result, aborted: true };
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
+      return aborted;
+    }
     params.markSyncedToAgentState();
     await params.sessionManager.save();
+    if (isAborted()) {
+      const aborted = { ...result, aborted: true };
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result: aborted });
+      return aborted;
+    }
     if (params.willRetry && !result?.aborted) {
       await params.continueTurn();
     }
     params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result });
     return result;
   } catch (error) {
+    if (isAborted()) {
+      const result = abortedResult();
+      params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, result });
+      return result;
+    }
     const errorMessage = error instanceof Error ? error.message : String(error);
     params.emit({ type: "auto_compaction_end", reason: params.reason, willRetry: params.willRetry, errorMessage });
     throw error;
@@ -3685,6 +3732,9 @@ var AgentSessionRetryController = class {
 // ../../packages/agent-framework/src/session/controller/runtime-guard.ts
 var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_CHARS = 16384;
 var RUNAWAY_TOOLCALL_WHITESPACE_DELTA_EVENTS = 40;
+var TOOL_FAILURE_SIGNATURE_CHARS = 1e3;
+var TOOL_FAILURE_SIGNATURE_CONTEXT_LINES = 5;
+var FAILURE_DIAGNOSTIC_LINE_PATTERN = /\b(E2E_FAILED|AssertionError|TimeoutError|SyntaxError|ReferenceError|TypeError|Error):|(^|\b)(failed|failure|timed out|timeout|exit code|command failed|npm ERR!)/i;
 function stableStringify(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value) ?? String(value);
@@ -3703,6 +3753,20 @@ function summarizeToolResultForGuard(result) {
   const text = content.filter((block) => !!block && typeof block === "object" && "type" in block).filter((block) => block.type === "text").map((block) => block.text || "").join("\n").trim();
   return text || stableStringify(result);
 }
+function summarizeToolFailureSignature(result) {
+  const summary = summarizeToolResultForGuard(result).replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+  if (!summary) {
+    return "";
+  }
+  const lines = summary.split("\n");
+  for (let index = lines.length - 1; index >= 0; index--) {
+    if (!FAILURE_DIAGNOSTIC_LINE_PATTERN.test(lines[index] ?? "")) {
+      continue;
+    }
+    return lines.slice(index, Math.min(lines.length, index + TOOL_FAILURE_SIGNATURE_CONTEXT_LINES)).join("\n").slice(0, TOOL_FAILURE_SIGNATURE_CHARS);
+  }
+  return summary.slice(-TOOL_FAILURE_SIGNATURE_CHARS);
+}
 var AgentSessionRuntimeGuard = class {
   constructor(trigger) {
     this.trigger = trigger;
@@ -3767,7 +3831,7 @@ var AgentSessionRuntimeGuard = class {
       }
       return;
     }
-    const resultSummary = summarizeToolResultForGuard(event.result).slice(0, 500);
+    const resultSummary = summarizeToolFailureSignature(event.result);
     const key = `${event.toolName}:${stableStringify(event.args)}:${resultSummary}`;
     const repeatCount = (this.repeatedToolFailures.get(key) ?? 0) + 1;
     this.repeatedToolFailures.set(key, repeatCount);
@@ -4009,6 +4073,7 @@ async function runAgentSessionControllerAutoCompact(params) {
     const result = await runAgentSessionCompaction({
       reason: params.reason,
       willRetry: params.willRetry,
+      signal: params.signal,
       compaction: params.compaction,
       agent: params.agent,
       sessionManager: params.sessionManager,
@@ -4020,14 +4085,15 @@ async function runAgentSessionControllerAutoCompact(params) {
       continueTurn: params.continueTurn
     });
     if (!params.willRetry || result?.aborted) {
+      const alreadyCancelled = params.getRecoveryState?.() === "cancelled" || params.getDisposed?.() === true;
       params.setRecoveryState(result?.aborted && cancelOnAbort ? "cancelled" : "none");
       if (result?.aborted) {
         params.cancelRetry();
-        if (cancelOnAbort) {
+        if (cancelOnAbort && !alreadyCancelled) {
           params.emit({ type: "turn_cancelled", reason: "compaction_aborted" });
         }
       }
-      if (emitSettled) {
+      if (emitSettled && !alreadyCancelled) {
         params.emit({ type: "turn_settled" });
       }
       if (!result?.aborted && runAfterAgentEndHook) {
@@ -4125,8 +4191,8 @@ var AgentSessionController = class {
       getDisposed: () => this.disposed,
       getRuntimeGuardTriggered: () => this.runtimeGuard.triggered,
       isStreaming: () => this.isStreaming,
-      runAutoCompact: async (decision) => {
-        await this.runAutoCompact(decision.reason, decision.willRetry);
+      runAutoCompact: async (decision, signal) => {
+        await this.runAutoCompact(decision.reason, decision.willRetry, { signal });
       }
     });
     this.autoContinue = new AgentSessionAutoContinueController({
@@ -4309,6 +4375,7 @@ var AgentSessionController = class {
     return runAgentSessionControllerAutoCompact({
       reason,
       willRetry,
+      signal: options?.signal,
       compaction: this.compaction,
       agent: this.agent,
       sessionManager: this.sessionManager,
@@ -4318,6 +4385,8 @@ var AgentSessionController = class {
       setRecoveryState: (state) => {
         this.recoveryState = state;
       },
+      getRecoveryState: () => this.recoveryState,
+      getDisposed: () => this.disposed,
       cancelRetry: () => this.retryController.cancel(),
       clearPendingFailure: () => {
         this.pendingCompactionFailure = void 0;
@@ -5738,7 +5807,49 @@ function restoreLineEndings(text, ending) {
   return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
 }
 function normalizeForFuzzyMatch(text) {
-  return text.split("\n").map((line) => line.trimEnd()).join("\n").replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+  return buildFuzzyIndexMap(text).normalized;
+}
+function normalizeCharForFuzzyMatch(char) {
+  if (/[\u2018\u2019\u201A\u201B]/.test(char)) return "'";
+  if (/[\u201C\u201D\u201E\u201F]/.test(char)) return '"';
+  if (/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/.test(char)) return "-";
+  if (/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/.test(char)) return " ";
+  return char;
+}
+function buildFuzzyIndexMap(text) {
+  const lines = text.split("\n");
+  let normalized = "";
+  const originalStartByNormalizedIndex = [];
+  const originalEndByNormalizedIndex = [];
+  let originalLineStart = 0;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex] ?? "";
+    const trimmedLine = line.trimEnd();
+    for (let index = 0; index < trimmedLine.length; index++) {
+      normalized += normalizeCharForFuzzyMatch(trimmedLine[index]);
+      originalStartByNormalizedIndex.push(originalLineStart + index);
+      originalEndByNormalizedIndex.push(originalLineStart + index + 1);
+    }
+    if (lineIndex < lines.length - 1) {
+      normalized += "\n";
+      originalStartByNormalizedIndex.push(originalLineStart + line.length);
+      originalEndByNormalizedIndex.push(originalLineStart + line.length + 1);
+    }
+    originalLineStart += line.length + (lineIndex < lines.length - 1 ? 1 : 0);
+  }
+  return { normalized, originalStartByNormalizedIndex, originalEndByNormalizedIndex };
+}
+function countOccurrences(content, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let index = 0;
+  while (true) {
+    const nextIndex = content.indexOf(needle, index);
+    if (nextIndex === -1) break;
+    count++;
+    index = nextIndex + needle.length;
+  }
+  return count;
 }
 function fuzzyFindText(content, oldText) {
   const exactIndex = content.indexOf(oldText);
@@ -5748,11 +5859,25 @@ function fuzzyFindText(content, oldText) {
       index: exactIndex,
       matchLength: oldText.length,
       usedFuzzyMatch: false,
-      contentForReplacement: content
+      contentForReplacement: content,
+      occurrences: countOccurrences(content, oldText),
+      matchKind: "exact"
     };
   }
-  const fuzzyContent = normalizeForFuzzyMatch(content);
+  const fuzzyMap = buildFuzzyIndexMap(content);
+  const fuzzyContent = fuzzyMap.normalized;
   const fuzzyOldText = normalizeForFuzzyMatch(oldText);
+  if (fuzzyOldText.length === 0) {
+    return {
+      found: false,
+      index: -1,
+      matchLength: 0,
+      usedFuzzyMatch: false,
+      contentForReplacement: content,
+      occurrences: 0,
+      matchKind: "none"
+    };
+  }
   const fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
   if (fuzzyIndex === -1) {
     return {
@@ -5760,35 +5885,65 @@ function fuzzyFindText(content, oldText) {
       index: -1,
       matchLength: 0,
       usedFuzzyMatch: false,
-      contentForReplacement: content
+      contentForReplacement: content,
+      occurrences: 0,
+      matchKind: "none"
     };
   }
+  const endFuzzyIndex = fuzzyIndex + fuzzyOldText.length - 1;
+  const originalStart = fuzzyMap.originalStartByNormalizedIndex[fuzzyIndex];
+  const originalEnd = fuzzyMap.originalEndByNormalizedIndex[endFuzzyIndex];
   return {
     found: true,
-    index: fuzzyIndex,
-    matchLength: fuzzyOldText.length,
+    index: originalStart,
+    matchLength: originalEnd - originalStart,
     usedFuzzyMatch: true,
-    contentForReplacement: fuzzyContent
+    contentForReplacement: content,
+    occurrences: countOccurrences(fuzzyContent, fuzzyOldText),
+    matchKind: "fuzzy"
   };
 }
 function stripBom(content) {
   return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
 }
-function generateDiffString(oldContent, newContent, _contextLines = 4) {
-  const oldLines = oldContent.split("\n");
-  const newLines = newContent.split("\n");
-  let firstChangedLine;
-  for (let i = 0; i < Math.max(oldLines.length, newLines.length); i++) {
-    if (oldLines[i] !== newLines[i]) {
-      firstChangedLine = i + 1;
-      break;
-    }
-  }
-  const diff = `--- old
-+++ new
-@@ -1,${oldLines.length} +1,${newLines.length} @@
-[Diff: ${oldLines.length} lines -> ${newLines.length} lines]`;
-  return { diff, firstChangedLine };
+function generateDiffString(oldContent, newContent, contextLines = 4) {
+  const oldLines = normalizeToLF(stripBom(oldContent).text).split("\n");
+  const newLines = normalizeToLF(stripBom(newContent).text).split("\n");
+  let prefixLength = 0;
+  while (prefixLength < oldLines.length && prefixLength < newLines.length && oldLines[prefixLength] === newLines[prefixLength]) {
+    prefixLength++;
+  }
+  if (prefixLength === oldLines.length && prefixLength === newLines.length) {
+    return { diff: "--- old\n+++ new\n", firstChangedLine: void 0 };
+  }
+  let oldSuffixIndex = oldLines.length - 1;
+  let newSuffixIndex = newLines.length - 1;
+  while (oldSuffixIndex >= prefixLength && newSuffixIndex >= prefixLength && oldLines[oldSuffixIndex] === newLines[newSuffixIndex]) {
+    oldSuffixIndex--;
+    newSuffixIndex--;
+  }
+  const beforeContext = Math.min(contextLines, prefixLength);
+  const removedCount = Math.max(0, oldSuffixIndex - prefixLength + 1);
+  const addedCount = Math.max(0, newSuffixIndex - prefixLength + 1);
+  const afterContext = Math.min(contextLines, oldLines.length - oldSuffixIndex - 1, newLines.length - newSuffixIndex - 1);
+  const hunkOldStart = Math.max(0, prefixLength - beforeContext);
+  const hunkNewStart = Math.max(0, prefixLength - beforeContext);
+  const hunkOldCount = beforeContext + removedCount + afterContext;
+  const hunkNewCount = beforeContext + addedCount + afterContext;
+  const lines = ["--- old", "+++ new", `@@ -${hunkOldStart + 1},${hunkOldCount} +${hunkNewStart + 1},${hunkNewCount} @@`];
+  for (let index = prefixLength - beforeContext; index < prefixLength; index++) {
+    lines.push(` ${oldLines[index] ?? ""}`);
+  }
+  for (let index = prefixLength; index <= oldSuffixIndex; index++) {
+    lines.push(`-${oldLines[index] ?? ""}`);
+  }
+  for (let index = prefixLength; index <= newSuffixIndex; index++) {
+    lines.push(`+${newLines[index] ?? ""}`);
+  }
+  for (let offset = 1; offset <= afterContext; offset++) {
+    lines.push(` ${oldLines[oldSuffixIndex + offset] ?? ""}`);
+  }
+  return { diff: lines.join("\n"), firstChangedLine: prefixLength + 1 };
 }
 
 // ../../packages/shared-headless-capabilities/src/builtin/fs/edit.ts
@@ -5810,7 +5965,7 @@ function validateEditArgs(path3, oldText, newText) {
     throw new Error("Invalid edit_file arguments: path, oldText, and newText must be real edit values, not tool-call markup.");
   }
 }
-function countOccurrences(content, needle) {
+function countOccurrences2(content, needle) {
   if (needle.length === 0) return 0;
   let count = 0;
   let index = 0;
@@ -5822,6 +5977,29 @@ function countOccurrences(content, needle) {
   }
   return count;
 }
+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." : ""
+  ].filter(Boolean);
+  return {
+    content: [{ type: "text", text: detailLines.join("\n") }],
+    details: {
+      status: "error",
+      matchKind: params.matchKind,
+      changed: false,
+      diff: "",
+      oldTextOccurrences: params.oldTextOccurrences,
+      newTextOccurrences: params.newTextOccurrences,
+      errorReason: params.errorReason,
+      recoveryHint: params.recoveryHint,
+      staleBaseLikely: params.staleBaseLikely,
+      alreadyAppliedCandidate: params.alreadyAppliedCandidate
+    },
+    isError: true
+  };
+}
 function createEditTool(cwd, options) {
   const fs2 = getFileSystem();
   const rootSchema = buildRootParameterSchema(cwd, options);
@@ -5871,37 +6049,53 @@ function createEditTool(cwd, options) {
             const normalizedContent = normalizeToLF(content);
             const normalizedOldText = normalizeToLF(oldText);
             const normalizedNewText = normalizeToLF(newText);
+            const newTextOccurrences = countOccurrences2(normalizedContent, normalizedNewText);
             const matchResult = fuzzyFindText(normalizedContent, normalizedOldText);
             if (!matchResult.found) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              reject(
-                new Error(
-                  `Could not find the exact text in ${path3}. The old text must match exactly including all whitespace and newlines.`
-                )
+              resolve2(
+                createEditErrorResult({
+                  message: `Could not find oldText in ${path3}.`,
+                  matchKind: "none",
+                  errorReason: "old_text_not_found",
+                  oldTextOccurrences: 0,
+                  newTextOccurrences,
+                  staleBaseLikely: newTextOccurrences > 0,
+                  alreadyAppliedCandidate: newTextOccurrences > 0,
+                  recoveryHint: newTextOccurrences > 0 ? "The replacement text already appears in the current file. Read the current file before retrying; this may be a stale oldText from an earlier edit in the same turn." : "Read the current file and retry with a larger exact block copied from the latest file contents."
+                })
               );
               return;
             }
-            const fuzzyContent = normalizeForFuzzyMatch(normalizedContent);
-            const fuzzyOldText = normalizeForFuzzyMatch(normalizedOldText);
-            const occurrences = countOccurrences(fuzzyContent, fuzzyOldText);
-            if (occurrences > 1) {
+            if (matchResult.occurrences > 1) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              reject(
-                new Error(
-                  `Found ${occurrences} occurrences of the text in ${path3}. The text must be unique. Please provide more context to make it unique.`
-                )
+              resolve2(
+                createEditErrorResult({
+                  message: `Found ${matchResult.occurrences} occurrences of oldText in ${path3}. The text must be unique.`,
+                  matchKind: matchResult.matchKind,
+                  errorReason: "old_text_not_unique",
+                  oldTextOccurrences: matchResult.occurrences,
+                  newTextOccurrences,
+                  recoveryHint: "Read the current file and retry with a larger exact block that uniquely identifies the intended location."
+                })
               );
               return;
             }
             if (aborted) return;
-            const baseContent = matchResult.contentForReplacement;
+            const baseContent = normalizedContent;
             const newContent = baseContent.substring(0, matchResult.index) + normalizedNewText + baseContent.substring(matchResult.index + matchResult.matchLength);
             if (baseContent === newContent) {
               if (signal) signal.removeEventListener("abort", onAbort);
-              reject(
-                new Error(
-                  `No changes made to ${path3}. The replacement produced identical content.`
-                )
+              resolve2(
+                createEditErrorResult({
+                  message: `No changes made to ${path3}. The replacement produced identical content.`,
+                  matchKind: matchResult.matchKind,
+                  errorReason: "replacement_no_change",
+                  oldTextOccurrences: matchResult.occurrences,
+                  newTextOccurrences,
+                  recoveryHint: "Read the current file and verify whether the intended edit is already present or whether oldText/newText need a larger exact block.",
+                  alreadyAppliedCandidate: newTextOccurrences > 0
+                })
               );
               return;
             }
@@ -5911,16 +6105,24 @@ function createEditTool(cwd, options) {
             if (signal) {
               signal.removeEventListener("abort", onAbort);
             }
-            const diffResult = generateDiffString(content, finalContent);
+            const diffResult = generateDiffString(content, restoreLineEndings(newContent, originalEnding));
             resolve2({
               content: [
                 {
                   type: "text",
-                  text: `Successfully replaced text in ${path3}.`
+                  text: `Successfully replaced text in ${path3} using ${matchResult.matchKind} match.`
                 },
                 { type: "text", text: diffResult.diff }
               ],
-              details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine }
+              details: {
+                status: "success",
+                matchKind: matchResult.matchKind,
+                changed: true,
+                diff: diffResult.diff,
+                firstChangedLine: diffResult.firstChangedLine,
+                oldTextOccurrences: matchResult.occurrences,
+                newTextOccurrences
+              }
             });
           } catch (error) {
             if (signal) {
@@ -6974,6 +7176,145 @@ function createEmptyRuntimeSummary() {
     toolErrors: 0
   };
 }
+function summarizeString(value, maxLength = 300) {
+  return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}
+function summarizeMessage(message) {
+  if (!isRecord(message)) return typeof message;
+  if ("contentBlocks" in message && !("content" in message)) return message;
+  const content = Array.isArray(message.content) ? message.content : [];
+  const blockTypes = content.filter(isRecord).map((block) => String(block.type || "unknown")).slice(0, 10);
+  const text = getTextFromMessageContent(content);
+  return {
+    role: message.role,
+    stopReason: message.stopReason,
+    errorMessage: typeof message.errorMessage === "string" ? summarizeString(message.errorMessage) : void 0,
+    contentBlocks: content.length,
+    blockTypes,
+    textLength: text.length
+  };
+}
+function summarizeToolResults(value) {
+  if (isRecord(value) && typeof value.count === "number" && !Array.isArray(value)) return value;
+  if (!Array.isArray(value)) return typeof value;
+  let errors = 0;
+  const toolNames = [];
+  for (const result of value) {
+    if (!isRecord(result)) continue;
+    if (result.isError === true) errors++;
+    const toolName = typeof result.toolName === "string" ? result.toolName : typeof result.name === "string" ? result.name : void 0;
+    if (toolName && toolNames.length < 10) toolNames.push(toolName);
+  }
+  return { count: value.length, errors, toolNames };
+}
+function collectTextLength(content) {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return 0;
+  let length = 0;
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (typeof block.text === "string") length += block.text.length;
+  }
+  return length;
+}
+function collectArgumentLength(content) {
+  if (!Array.isArray(content)) return 0;
+  let length = 0;
+  for (const block of content) {
+    if (!isRecord(block) || !("arguments" in block)) continue;
+    if (typeof block.arguments === "string") {
+      length += block.arguments.length;
+      continue;
+    }
+    try {
+      length += JSON.stringify(block.arguments).length;
+    } catch {
+      length += String(block.arguments).length;
+    }
+  }
+  return length;
+}
+function summarizeMessages(value) {
+  if (!Array.isArray(value)) return typeof value;
+  const roles = [];
+  const toolNames = [];
+  const stopReasons = [];
+  let errorCount = 0;
+  let contentBlocks = 0;
+  let textLength = 0;
+  let argumentLength = 0;
+  for (const message of value) {
+    if (!isRecord(message)) continue;
+    const role = typeof message.role === "string" ? message.role : void 0;
+    if (role && roles.length < 20) roles.push(role);
+    if (typeof message.stopReason === "string" && stopReasons.length < 20) stopReasons.push(message.stopReason);
+    if (typeof message.errorMessage === "string" && message.errorMessage) errorCount++;
+    if (typeof message.toolName === "string" && toolNames.length < 20) toolNames.push(message.toolName);
+    const content = Array.isArray(message.content) ? message.content : [];
+    contentBlocks += content.length;
+    textLength += collectTextLength(message.content);
+    argumentLength += collectArgumentLength(message.content);
+    for (const block of content) {
+      if (isRecord(block) && typeof block.name === "string" && toolNames.length < 20) {
+        toolNames.push(block.name);
+      }
+    }
+  }
+  return {
+    count: value.length,
+    roles,
+    toolNames: [...new Set(toolNames)].slice(0, 20),
+    stopReasons: [...new Set(stopReasons)].slice(0, 20),
+    errorCount,
+    contentBlocks,
+    textLength,
+    argumentLength
+  };
+}
+function summarizeFailure(value) {
+  if (!isRecord(value)) return typeof value;
+  return {
+    kind: value.kind,
+    retryable: value.retryable,
+    compactable: value.compactable,
+    userAbort: value.userAbort,
+    terminal: value.terminal,
+    message: typeof value.message === "string" ? summarizeString(value.message) : void 0
+  };
+}
+function summarizeRuntimeEvent(value) {
+  if (!isRecord(value)) return typeof value;
+  const summary = {
+    type: value.type
+  };
+  if ("toolCallId" in value) summary.toolCallId = value.toolCallId;
+  if ("toolName" in value) summary.toolName = value.toolName;
+  if ("turnIndex" in value) summary.turnIndex = value.turnIndex;
+  if ("isError" in value) summary.isError = value.isError;
+  if ("errorMessage" in value && typeof value.errorMessage === "string") {
+    summary.errorMessage = summarizeString(value.errorMessage);
+  }
+  if ("message" in value) summary.message = summarizeMessage(value.message);
+  if ("toolResults" in value) summary.toolResults = summarizeToolResults(value.toolResults);
+  return summary;
+}
+function shouldRecordRuntimeEvent(type) {
+  const normalizedType = type.startsWith("runtime:") ? type.slice("runtime:".length) : type;
+  return normalizedType !== "agent_event" && normalizedType !== "semantic_event";
+}
+function recomputeRuntimeSummaryFromTimeline(events) {
+  const summary = createEmptyRuntimeSummary();
+  for (const event of events ?? []) {
+    if (/queue|queued_turn/.test(event.type)) summary.queuedTurnEvents++;
+    if (/retry/.test(event.type)) summary.retryEvents++;
+    if (/auto_compaction|auto_compact|compaction/.test(event.type)) summary.autoCompactionEvents++;
+    if (/runtime_guard|repeated_tool_error/.test(event.type)) summary.runtimeGuardEvents++;
+    if (/subagent/.test(event.type)) summary.subagentEvents++;
+    if (event.type === "tool_end" || event.type === "tool_error") summary.toolResults++;
+    if (event.type === "tool_error") summary.toolErrors++;
+  }
+  return summary;
+}
 function summarizeMeta(meta) {
   if (!isRecord(meta)) return meta;
   const summary = {};
@@ -6982,6 +7323,26 @@ function summarizeMeta(meta) {
       summary[key] = Array.isArray(value) ? { count: value.length } : typeof value;
       continue;
     }
+    if (key === "addedMessages") {
+      summary[key] = summarizeMessages(value);
+      continue;
+    }
+    if (key === "message") {
+      summary[key] = summarizeMessage(value);
+      continue;
+    }
+    if (key === "toolResults") {
+      summary[key] = summarizeToolResults(value);
+      continue;
+    }
+    if (key === "failure") {
+      summary[key] = summarizeFailure(value);
+      continue;
+    }
+    if (key === "event") {
+      summary[key] = summarizeRuntimeEvent(value);
+      continue;
+    }
     if (key === "queuedInput" && isRecord(value)) {
       summary[key] = {
         mode: value.mode,
@@ -6991,7 +7352,7 @@ function summarizeMeta(meta) {
       };
       continue;
     }
-    summary[key] = typeof value === "string" && value.length > 300 ? `${value.slice(0, 300)}...` : value;
+    summary[key] = typeof value === "string" ? summarizeString(value) : value;
   }
   return summary;
 }
@@ -7105,9 +7466,7 @@ function timelineEventFromTraceEvent(type, meta) {
       failure: typeof data.failureCategory === "string" && data.failureCategory.length > 0
     };
   }
-  if (normalizedType === "subagent_summary") {
-    return { type: "subagent_child_end", summary: `subagent summary count=${String(data.count ?? "?")}`, details: detail };
-  }
+  if (normalizedType === "subagent_summary") return null;
   return null;
 }
 function cloneTurn(turn) {
@@ -7148,6 +7507,9 @@ var SessionTraceController = class {
     if (!Array.isArray(this.trace.recentTimeline)) {
       this.trace.recentTimeline = [];
     }
+    this.trace.recentEvents = this.trace.recentEvents.slice(-this.recentEventsLimit);
+    this.trace.recentTimeline = this.trace.recentTimeline.slice(-this.recentEventsLimit);
+    this.trace.runtimeSummary = recomputeRuntimeSummaryFromTimeline(this.trace.recentTimeline);
   }
   trace;
   recentTurnsLimit;
@@ -7162,7 +7524,6 @@ var SessionTraceController = class {
     if (this.trace.recentEvents.length > this.recentEventsLimit) {
       this.trace.recentEvents = this.trace.recentEvents.slice(-this.recentEventsLimit);
     }
-    this.updateRuntimeSummary(type, meta);
     const timelineEvent = timelineEventFromTraceEvent(type, meta);
     if (timelineEvent) {
       this.pushTimeline(timelineEvent);
@@ -7177,17 +7538,7 @@ var SessionTraceController = class {
     if (this.trace.recentTimeline.length > this.recentEventsLimit) {
       this.trace.recentTimeline = this.trace.recentTimeline.slice(-this.recentEventsLimit);
     }
-  }
-  updateRuntimeSummary(type, meta) {
-    const summary = this.trace.runtimeSummary ?? createEmptyRuntimeSummary();
-    if (/queue|queued_turn/.test(type)) summary.queuedTurnEvents++;
-    if (/retry/.test(type)) summary.retryEvents++;
-    if (/auto_compaction|auto_compact|compaction/.test(type)) summary.autoCompactionEvents++;
-    if (/runtime_guard|repeated_tool_error/.test(type)) summary.runtimeGuardEvents++;
-    if (/subagent/.test(type)) summary.subagentEvents++;
-    if (type === "tool_end") summary.toolResults++;
-    if (type === "tool_end" && isRecord(meta) && meta.isError) summary.toolErrors++;
-    this.trace.runtimeSummary = summary;
+    this.trace.runtimeSummary = recomputeRuntimeSummaryFromTimeline(this.trace.recentTimeline);
   }
   nextTurnIndex() {
     if (this.trace.activeTurn) {
@@ -7259,6 +7610,7 @@ var SessionTraceController = class {
     this.touch();
   }
   noteRuntimeEvent(type, meta) {
+    if (!shouldRecordRuntimeEvent(type)) return;
     this.pushEvent(`runtime:${type}`, summarizeMeta(meta));
     this.touch();
   }
@@ -7283,7 +7635,6 @@ var SessionTraceController = class {
     if (!message || message.role !== "assistant" || !this.trace.activeTurn) return;
     this.trace.activeTurn.state = this.trace.activeTurn.toolCalls.some((tool) => tool.status === "running") ? "tool_running" : "streaming";
     this.trace.activeTurn.assistantText = getTextFromMessageContent(message.content);
-    this.pushEvent("assistant_update");
     this.touch();
   }
   startTool(toolCallId, toolName, args) {

package/dist/chunks/{chunk-62XU6P2H.js → chunk-MHFUWY7I.js}

@@ -8,7 +8,7 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-7GAYJ6AF.js";
+} from "./chunk-G4GV2CRT.js";
 import {
   Type
 } from "./chunk-5DA2D3K2.js";

package/dist/cli.js

@@ -14,7 +14,7 @@ import {
   getSettingsPath,
   getThemesDir,
   migrateConfigFromAgentDir
-} from "./chunks/chunk-62XU6P2H.js";
+} from "./chunks/chunk-MHFUWY7I.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -55,7 +55,7 @@ import {
   selectToolsForRuntimePolicy,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-7GAYJ6AF.js";
+} from "./chunks/chunk-G4GV2CRT.js";
 import "./chunks/chunk-VE2HDCNB.js";
 import {
   Deref,
@@ -59550,6 +59550,26 @@ ${theme.fg("muted", "Receiving edit parameters...")}`;
 
 ${theme.fg("error", errorText)}`;
         }
+      } else if (this.result?.details?.diff && rawPath) {
+        const diff = this.result.details.diff;
+        const firstChangedLine = this.result.details.firstChangedLine;
+        if (firstChangedLine) {
+          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path27 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
+        }
+        const lines = diff.split("\n");
+        const maxLines = this.expanded ? lines.length : 15;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += "\n\n" + displayLines.map((line) => {
+          if (line.startsWith("+")) return theme.fg("success", line);
+          if (line.startsWith("-")) return theme.fg("error", line);
+          if (line.startsWith("@@")) return theme.fg("warning", line);
+          return theme.fg("toolOutput", line);
+        }).join("\n");
+        if (remaining > 0) {
+          text += theme.fg("muted", `
+... (${remaining} more lines, press Ctrl+O to expand)`);
+        }
       } else if (hasOldText && hasNewText && rawPath) {
         const diff = generateEditDiff(oldText, newText, rawPath);
         const firstChangedLine = findFirstChangedLine(oldText, newText);
@@ -64117,6 +64137,9 @@ function shouldCliAutoCompactTokens(params) {
   return tokenLimit !== void 0 && params.tokens > tokenLimit;
 }
 async function createCliAutoCompactionResult(params) {
+  if (params.context.signal?.aborted) {
+    return { aborted: true };
+  }
   const activeEntryId = params.context.sessionManager.getActiveEntryId();
   if (!activeEntryId) {
     return { aborted: true };
@@ -64129,9 +64152,13 @@ async function createCliAutoCompactionResult(params) {
   const compactOptions = {
     model: params.model,
     apiKey: params.apiKey,
-    systemPrompt: params.systemPrompt
+    systemPrompt: params.systemPrompt,
+    signal: params.context.signal
   };
   const summary = await createCompactionSummary(params.context.messages, compactOptions);
+  if (params.context.signal?.aborted) {
+    return { aborted: true };
+  }
   return {
     summary,
     firstKeptEntryId,
@@ -68035,6 +68062,18 @@ async function runJsonEventsMode(params) {
         break;
     }
   }
+  function rememberTerminal(kind, detail, options) {
+    if (!activeTurn || activeTurn.finalized) return;
+    if (activeTurn.pendingTerminal && options?.overwrite === false) return;
+    activeTurn.pendingTerminal = { kind, detail };
+    touch();
+  }
+  function finalizePendingTerminal() {
+    if (!activeTurn || activeTurn.finalized) return;
+    const pending = activeTurn.pendingTerminal;
+    if (!pending) return;
+    finalize(pending.kind, pending.detail);
+  }
   function handleSemanticEvent(event) {
     if (!activeTurn || activeTurn.finalized) return;
     switch (event.type) {
@@ -68082,6 +68121,7 @@ async function runJsonEventsMode(params) {
   function handleControllerEvent(event) {
     trace?.noteRuntimeEvent(event.type, event);
     if (event.type === "turn_settled" && activeTurn) {
+      finalizePendingTerminal();
       writeEvent({
         type: "turn.settled",
         sessionId: activeTurn.sessionId,
@@ -68166,7 +68206,7 @@ async function runJsonEventsMode(params) {
     } else if (event.type === "turn_completed") {
       const text = assistantTextFromMessage(event.message);
       flushAssistantOutput(text);
-      finalize("completed", text || activeTurn.summary.trim());
+      rememberTerminal("completed", text || activeTurn.summary.trim());
     } else if (event.type === "turn_failed_terminal") {
       touch();
       if (lastRetryEvent) {
@@ -68181,9 +68221,9 @@ async function runJsonEventsMode(params) {
         });
         lastRetryEvent = void 0;
       }
-      finalize("failed", event.failure.message);
+      rememberTerminal("failed", event.failure.message);
     } else if (event.type === "turn_cancelled") {
-      finalize("cancelled", event.reason);
+      rememberTerminal("cancelled", event.reason, { overwrite: false });
     }
   }
   async function ensureRuntime() {
@@ -68359,6 +68399,7 @@ async function runJsonEventsMode(params) {
       trace?.noteWaitForIdleStart({ mode: "json-events" });
       await controller.waitForSettled();
       trace?.noteWaitForIdleSettled({ mode: "json-events" });
+      finalizePendingTerminal();
       if (!activeTurn?.finalized) {
         const finalError = assistantErrorFromAgent(agent);
         if (activeTurn?.interrupted) {
@@ -68434,7 +68475,11 @@ async function runJsonEventsMode(params) {
       if (activeTurn && !activeTurn.finalized) {
         activeTurn.interrupted = true;
         controller?.abort();
-        finalize("cancelled", message.reason || "shutdown");
+        if (!controller) {
+          finalize("cancelled", message.reason || "shutdown");
+        } else {
+          rememberTerminal("cancelled", message.reason || "shutdown");
+        }
       }
       break;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cydm/pie",
-	"version": "1.0.16",
+	"version": "1.0.18",
 	"description": "Pie AI Agent CLI",
 	"type": "module",
 	"bin": {