@tyvm/knowhow 0.0.118 → 0.0.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.118",
+  "version": "0.0.120",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -40,7 +40,6 @@
     "@types/jest": "^29.5.13",
     "@types/mocha": "^10.0.8",
     "@types/node": "^20.6.3",
-    "@types/pdf-parse": "^1.1.4",
     "@types/ws": "^8.18.1",
     "jest": "^29.1.1",
     "prettier": "2.6.2",
@@ -67,7 +66,6 @@
     "minimatch": "^10.1.2",
     "node-jq": "^6.0.1",
     "openai": "4.89.1",
-    "pdf-parse": "^1.1.1",
     "ws": "^8.18.1",
     "zod": "^3.25.0"
   },

package/src/agents/base/base.ts

@@ -68,6 +68,9 @@ export abstract class BaseAgent implements IAgent {
   protected compressThreshold = 30000;
   protected compressMinMessages = 30;
 
+  // Interrupt support: resolves the currently awaited tool call or completion
+  private _interruptResolve: ((value: any) => void) | null = null;
+
   protected threads = [] as Message[][];
 
   // Message from users
@@ -479,9 +482,18 @@ export abstract class BaseAgent implements IAgent {
   async processToolMessages(toolCall: ToolCall) {
     this.agentEvents.emit(this.eventTypes.toolCall, { toolCall });
 
-    const { functionResp, toolMessages } = await this.tools.callTool(
-      toolCall,
-      this.getEnabledToolNames()
+    const interruptMsg = `User interrupted this tool call (${toolCall.function?.name})`;
+    const interruptResult: Awaited<ReturnType<typeof this.tools.callTool>> = {
+      functionResp: interruptMsg,
+      toolCallId: toolCall.id,
+      functionName: toolCall.function?.name,
+      functionArgs: {},
+      toolMessages: [{ role: "tool", tool_call_id: toolCall.id, name: toolCall.function?.name, content: interruptMsg }],
+    };
+
+    const { functionResp, toolMessages } = await this.makeInterruptible(
+      this.tools.callTool(toolCall, this.getEnabledToolNames()),
+      interruptResult
     );
 
     this.agentEvents.emit(this.eventTypes.toolUsed, {
@@ -647,6 +659,48 @@ export abstract class BaseAgent implements IAgent {
     } as Message);
   }
 
+  /**
+   * Wrap a promise so it can be interrupted via interrupt().
+   * If interrupt() is called while waiting, the promise resolves with the
+   * interrupt message instead of waiting for the original operation to complete.
+   */
+  protected makeInterruptible<T>(
+    promise: Promise<T>,
+    interruptValue: T
+  ): Promise<T> {
+    return new Promise<T>((resolve) => {
+      this._interruptResolve = (value: any) => {
+        this._interruptResolve = null;
+        resolve(value);
+      };
+      promise.then((result) => {
+        if (this._interruptResolve) {
+          this._interruptResolve = null;
+          resolve(result);
+        }
+      }).catch((err) => {
+        if (this._interruptResolve) {
+          this._interruptResolve = null;
+          resolve(interruptValue);
+        }
+      });
+    });
+  }
+
+  /**
+   * Interrupt the currently awaited tool call or AI completion.
+   * The waiting promise will resolve immediately with an interrupt message,
+   * allowing the agent to continue its loop with the interruption as context.
+   */
+  interrupt(message = "User interrupted this action you were waiting on") {
+    this.log(`Interrupting current operation: ${message}`);
+    if (this._interruptResolve) {
+      this._interruptResolve(message);
+    } else {
+      this.log("No active interruptible operation to interrupt", "warn");
+    }
+  }
+
   async call(
     userInput: string | MessageContent[],
     _messages?: Message[],
@@ -717,13 +771,22 @@ export abstract class BaseAgent implements IAgent {
         "pre_call"
       );
 
-      const response = await this.getClient().createChatCompletion({
+      const interruptResponse: CompletionResponse = {
+        choices: [{ message: { role: "assistant", content: "User interrupted this AI completion. Please continue." } }],
         model,
-        messages,
-        tools: this.getEnabledTools(),
-        tool_choice: "auto",
-        long_ttl_cache: this.runTime() > 300_000,
-      });
+        usage: undefined,
+        usd_cost: 0,
+      };
+      const response = await this.makeInterruptible(
+        this.getClient().createChatCompletion({
+          model,
+          messages,
+          tools: this.getEnabledTools(),
+          tool_choice: "auto",
+          long_ttl_cache: this.runTime() > 300_000,
+        }),
+        interruptResponse
+      );
 
       // If the agent was paused while the completion was in-flight, wait here
       // before processing tool calls. This allows the user to send messages

package/src/agents/researcher/researcher.ts

@@ -8,8 +8,15 @@ export class ResearcherAgent extends BaseAgent {
 
   constructor(context: AgentContext) {
     super(context);
-    this.setModel(Models.google.Gemini_3_Flash_Preview);
-    this.setProvider("google");
+    // Prefer Gemini for research, but fall back to other registered providers
+    // so the agent still runs when GEMINI_API_KEY is not configured. Without
+    // fallbacks, an unregistered "google" provider causes the health-check loop
+    // to immediately throw "We have exhausted all model preferences."
+    this.setModelPreferences([
+      { model: Models.google.Gemini_3_Flash_Preview, provider: "google" },
+      { model: Models.anthropic.Sonnet4_6, provider: "anthropic" },
+      { model: Models.openai.GPT_53_Codex, provider: "openai" },
+    ]);
     this.disableTool("patchFile");
     this.disableTool("writeFile");
     this.disableTool("writeChunk");

package/src/agents/tools/list.ts

@@ -174,7 +174,7 @@ export const includedTools = [
     function: {
       name: "readFile",
       description:
-        "Read the contents of a file and return them as an array of blocks",
+        "Read the contents of a file as plain text. Optionally pass fromLine/toLine (1-based, inclusive) to read just a range of lines; ranged reads are prefixed with real source line numbers.",
       parameters: {
         type: "object",
         positional: true,
@@ -183,12 +183,23 @@ export const includedTools = [
             type: "string",
             description: "The path to the file to be read",
           },
+          fromLine: {
+            type: "number",
+            description:
+              "Optional 1-based start line (inclusive). When provided, only lines from this point are returned, prefixed with real source line numbers.",
+          },
+          toLine: {
+            type: "number",
+            description:
+              "Optional 1-based end line (inclusive). Defaults to the end of the file when omitted.",
+          },
         },
         required: ["filePath"],
       },
       returns: {
         type: "string",
-        description: "The file contents in diff format",
+        description:
+          "The file contents as plain text. When a line range is requested, each line is prefixed with its real source line number.",
       },
     },
   },

package/src/agents/tools/patch.ts

@@ -109,6 +109,31 @@ function findSequenceIndex(haystack: string[], needle: string[]): number {
   return -1;
 } // --- Hunk Parsing and Formatting (Keep as is) ---
 
+/**
+ * Like findSequenceIndex but compares lines by trimmed content, so it tolerates
+ * leading/trailing whitespace drift between a hand-written patch and the file.
+ * Returns the 0-based start index in haystack, or -1.
+ */
+function findSequenceIndexTrimmed(
+  haystack: string[],
+  needle: string[]
+): number {
+  if (!needle || needle.length === 0) return -1;
+  if (!haystack || needle.length > haystack.length) return -1;
+  const needleTrim = needle.map((l) => l.trim());
+  for (let start = 0; start <= haystack.length - needle.length; start++) {
+    let matches = true;
+    for (let i = 0; i < needle.length; i++) {
+      if (haystack[start + i].trim() !== needleTrim[i]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) return start;
+  }
+  return -1;
+}
+
 export interface Hunk {
   header: string;
   originalStartLine: number; // Parsed from -s,l
@@ -294,16 +319,34 @@ function fixSingleHunk(hunk: Hunk, originalContent: string): Hunk | null {
     deletionLinesContent.length === 0 &&
     additionLinesContent.length > 0
   ) {
-    // Find the context line just before the first addition in the *original* patch hunk
-    let precedingContextLine = "";
+    // Collect the FULL leading context block (all context lines that appear before the
+    // first addition) so we can anchor on the whole sequence. This is far more reliable
+    // than a single preceding line when that line (e.g. a closing `}`) is ambiguous and
+    // appears multiple times in the file.
+    const leadingContextBlock: string[] = [];
     for (const line of hunk.lines) {
       if (line.startsWith("+")) break; // Stop when we hit the first addition
       if (line.startsWith(" ")) {
-        precedingContextLine = line.slice(1); // Keep track of the last context line seen
+        leadingContextBlock.push(line.slice(1));
       }
     }
 
-    if (precedingContextLine) {
+    // 3a. Try to anchor on the full leading context sequence first (unambiguous).
+    if (leadingContextBlock.length > 1) {
+      const seqIdx = findSequenceIndex(originalLines, leadingContextBlock);
+      if (seqIdx !== -1) {
+        // Additions go AFTER the full leading context block.
+        actualOriginalStartLine = seqIdx + leadingContextBlock.length + 1;
+        console.log(
+          `Anchor found via leading context sequence (${leadingContextBlock.length} lines), targeting line ${actualOriginalStartLine}`
+        );
+      }
+    }
+
+    // 3b. Fall back to the single preceding context line (closest to the header hint).
+    if (actualOriginalStartLine === -1 && leadingContextBlock.length > 0) {
+      const precedingContextLine =
+        leadingContextBlock[leadingContextBlock.length - 1];
       const potentialLines = findAllLineNumbers(
         originalContent,
         precedingContextLine
@@ -394,6 +437,104 @@ function fixSingleHunk(hunk: Hunk, originalContent: string): Hunk | null {
   }
 
   if (hasInterleavedChanges) {
+    // Preferred strategy: in-order reconstruction.
+    //
+    // The block-grouping fallback below is lossy — it skips addition-only
+    // blocks (dropping inserted lines) and re-orders additions relative to
+    // surrounding context, which corrupts nested scopes (e.g. moving a
+    // replaced object property outside of its `{ ... }`). Before falling back
+    // to it, try to anchor the hunk's "original side" (context + deletions, in
+    // order) as a contiguous region of the file and rebuild that region by
+    // walking the hunk body in order. This preserves the exact author intent.
+    {
+      // The sequence of lines the hunk expects to exist in the original file,
+      // in order (context lines and deletions; additions are new).
+      const originalSideLines: string[] = [];
+      for (const line of hunk.lines) {
+        if (line.startsWith("+")) continue;
+        originalSideLines.push(line.startsWith(" ") || line.startsWith("-") ? line.slice(1) : line);
+      }
+      // Drop trailing blank context lines that patches sometimes include after
+      // the last real line — they aren't part of the file region and break the
+      // contiguous anchor match.
+      while (
+        originalSideLines.length > 0 &&
+        originalSideLines[originalSideLines.length - 1].trim() === ""
+      ) {
+        originalSideLines.pop();
+      }
+
+      if (originalSideLines.length > 0) {
+        // Prefer an exact anchor; fall back to a whitespace-tolerant match so
+        // hand-written patches with slightly off indentation still apply.
+        let anchorIdx = findSequenceIndex(originalLines, originalSideLines);
+        let usedTrimmed = false;
+        if (anchorIdx === -1) {
+          anchorIdx = findSequenceIndexTrimmed(originalLines, originalSideLines);
+          usedTrimmed = anchorIdx !== -1;
+        }
+        if (anchorIdx !== -1) {
+          // The file's actual lines for this region (authoritative indentation).
+          const fileRegion = originalLines.slice(
+            anchorIdx,
+            anchorIdx + originalSideLines.length
+          );
+          // Compute indentation correction: difference between the file's first
+          // context line indentation and the patch's first original-side line.
+          const fileIndent = (fileRegion[0].match(/^\s*/) || [""])[0];
+          const patchIndent = (originalSideLines[0].match(/^\s*/) || [""])[0];
+          const indentDelta =
+            usedTrimmed && fileIndent.length >= patchIndent.length
+              ? fileIndent.slice(patchIndent.length)
+              : "";
+          // Rebuild the anchored region by replaying the hunk body in order.
+          // For context lines we use the file's authoritative version; for
+          // additions we re-indent by the computed delta.
+          const rebuilt: string[] = [];
+          let origCursor = 0; // index into fileRegion for context/deletion lines
+          for (const line of hunk.lines) {
+            if (line.startsWith("+")) {
+              rebuilt.push(indentDelta + line.slice(1));
+            } else if (line.startsWith("-")) {
+              origCursor++; // consume a file line, drop it
+            } else {
+              // context line. If it is a trailing line beyond the anchored
+              // region (e.g. a formatting-artifact blank line), ignore it.
+              if (origCursor >= fileRegion.length) continue;
+              // Otherwise keep the file's authoritative version.
+              rebuilt.push(fileRegion[origCursor]);
+              origCursor++;
+            }
+          }
+
+          // Emit a pure replacement hunk: delete the file's authoritative
+          // region and insert the rebuilt content. The deletion content is an
+          // exact, contiguous slice of the file, so the diff library anchors it
+          // unambiguously without needing surrounding context lines.
+          const newBody: string[] = [
+            ...fileRegion.map((l) => `-${l}`),
+            ...rebuilt.map((l) => `+${l}`),
+          ];
+
+          const origCountR = fileRegion.length;
+          const newCountR = rebuilt.length;
+          const headerR = `@@ -${anchorIdx + 1},${origCountR} +${anchorIdx + 1},${newCountR} @@`;
+
+          return {
+            header: headerR,
+            originalStartLine: anchorIdx + 1,
+            originalLineCount: origCountR,
+            newStartLine: anchorIdx + 1,
+            newLineCount: newCountR,
+            lines: newBody,
+            additions: newBody.filter((l) => l.startsWith("+")),
+            subtractions: newBody.filter((l) => l.startsWith("-")),
+            contextLines: newBody.filter((l) => l.startsWith(" ")),
+          };
+        }
+      }
+    }
+
     // Group hunk lines into change-blocks separated by context
     // Each block: { deletions, additions }
     type ChangeBlock = { deletions: string[]; additions: string[]; };
@@ -513,19 +654,56 @@ function fixSingleHunk(hunk: Hunk, originalContent: string): Hunk | null {
     };
   }
 
-  // Pure insertion: output minimal -N,0 format required by unified diff spec
+  // Pure insertion: wrap the additions in real surrounding context from the file so the
+  // insertion position is unambiguous. A context-less `@@ -N,0 +N,M @@` hunk is applied
+  // inconsistently by the diff library (it can land the additions AFTER the anchor line
+  // instead of BEFORE it), which corrupts scopes (e.g. injecting a new function inside an
+  // existing function body). `actualOriginalStartLine` is the 1-based line that the new
+  // lines should be inserted *before*.
   if (deletionLinesContent.length === 0 && additionLinesContent.length > 0) {
-    const pureHeader = `@@ -${actualOriginalStartLine},0 +${actualOriginalStartLine},${hunk.additions.length} @@`;
+    // Insertion index (0-based) within originalLines where additions are placed.
+    const insertIdx = actualOriginalStartLine - 1;
+
+    // Take up to CONTEXT_LINES real lines before and after the insertion point.
+    const beforeStart = Math.max(0, insertIdx - CONTEXT_LINES);
+    const contextBeforeLines: string[] = [];
+    for (let i = beforeStart; i < insertIdx && i < originalLines.length; i++) {
+      contextBeforeLines.push(` ${originalLines[i]}`);
+    }
+
+    const contextAfterLines: string[] = [];
+    for (
+      let i = insertIdx;
+      i < insertIdx + CONTEXT_LINES && i < originalLines.length;
+      i++
+    ) {
+      contextAfterLines.push(` ${originalLines[i]}`);
+    }
+
+    const pureLines = [
+      ...contextBeforeLines,
+      ...hunk.additions,
+      ...contextAfterLines,
+    ];
+
+    const pureOrigStart = insertIdx - contextBeforeLines.length + 1; // 1-based
+    const pureOrigCount = contextBeforeLines.length + contextAfterLines.length;
+    const pureNewCount =
+      contextBeforeLines.length +
+      hunk.additions.length +
+      contextAfterLines.length;
+
+    const pureHeader = `@@ -${pureOrigStart},${pureOrigCount} +${pureOrigStart},${pureNewCount} @@`;
     return {
       header: pureHeader,
-      originalStartLine: actualOriginalStartLine,
-      originalLineCount: 0,
-      newStartLine: actualOriginalStartLine,
-      newLineCount: hunk.additions.length,
-      lines: hunk.additions,
+      originalStartLine: pureOrigStart,
+      originalLineCount: pureOrigCount,
+      newStartLine: pureOrigStart,
+      newLineCount: pureNewCount,
+      lines: pureLines,
       additions: hunk.additions,
       subtractions: [],
-      contextLines: [],
+      contextLines: [...contextBeforeLines, ...contextAfterLines],
     };
   }
 
@@ -557,14 +735,27 @@ function fixSingleHunk(hunk: Hunk, originalContent: string): Hunk | null {
     })
     .filter((l): l is string => l !== null);
 
-  // Supplement: add 1 extra line before the valid context for better anchoring
-  const supplementBeforeIdx = actualOriginalStartLine - 1 - validContextBefore.length - 1; // 0-based
-  const supplementBefore: string[] =
-    supplementBeforeIdx >= 0
-      ? [` ${originalLines[supplementBeforeIdx]}`]
-      : [];
-
-  const contextBefore = [...supplementBefore, ...validContextBefore];
+  // For deletion-anchored hunks, derive the leading context directly from the file just
+  // above the deletion start. This is far more reliable than mapping the hunk's context
+  // lines via `.find()` (which returns the FIRST match and mis-aligns when lines like a
+  // blank or a closing `}` repeat earlier in the file, producing duplicated context).
+  const fileContextBefore: string[] = [];
+  if (deletionLinesContent.length > 0) {
+    // Match the amount of leading context the original hunk carried (plus one extra
+    // anchor line, as the legacy implementation did), capped at CONTEXT_LINES. This keeps
+    // the header line counts stable while still deriving the *content* from the correct
+    // file position (avoiding the `.find()` duplication bug).
+    const desiredBeforeCount = Math.min(
+      CONTEXT_LINES,
+      validContextBefore.length + 1
+    );
+    const ctxStartIdx = Math.max(0, actualOriginalStartLine - 1 - desiredBeforeCount); // 0-based
+    for (let i = ctxStartIdx; i < actualOriginalStartLine - 1; i++) {
+      fileContextBefore.push(` ${originalLines[i]}`);
+    }
+  }
+  const contextBefore =
+    deletionLinesContent.length > 0 ? fileContextBefore : validContextBefore;
 
   // For context after: use valid context from hunk; if none, take 1 line from file
   const originalContentEndLine = actualOriginalStartLine + deletionLinesContent.length;
@@ -574,12 +765,22 @@ function fixSingleHunk(hunk: Hunk, originalContent: string): Hunk | null {
     const afterIdx = actualOriginalStartLine - 1; // 0-based index of line at insertion point
     contextAfter = afterIdx < originalLines.length ? [` ${originalLines[afterIdx]}`] : [];
   } else {
-    contextAfter = validContextAfter;
-    if (contextAfter.length === 0) {
-      const afterIdx = originalContentEndLine - 1; // 0-based index after deletions
-      if (afterIdx < originalLines.length) {
-        contextAfter = [` ${originalLines[afterIdx]}`];
-      }
+    // Derive trailing context directly from the file just below the deleted block, for the
+    // same reliability reasons as the leading context above. Match the amount of trailing
+    // context the original hunk carried (at least one line), capped at CONTEXT_LINES, so the
+    // header line counts stay stable.
+    contextAfter = [];
+    const desiredAfterCount = Math.max(
+      1,
+      Math.min(CONTEXT_LINES, validContextAfter.length)
+    );
+    const afterStartIdx = originalContentEndLine - 1; // 0-based index after deletions
+    for (
+      let i = afterStartIdx;
+      i < afterStartIdx + desiredAfterCount && i < originalLines.length;
+      i++
+    ) {
+      contextAfter.push(` ${originalLines[i]}`);
     }
   }
 
@@ -777,8 +978,57 @@ export async function patchFile(
 
     let updatedContent = applyPatch(originalContent, patch);
     let appliedPatch = patch; // Keep track of which patch succeeded
+    const patchHunks = parseHunks(patch);
+    const patchHasAdditions = patchHunks.some((h) => h.additions.length > 0);
+    const patchHasDeletions = patchHunks.some((h) => h.subtractions.length > 0);
+
+    /**
+     * Build a human-readable summary of what changed between two content strings.
+     */
+    function buildChangeSummary(original: string, updated: string): string {
+      const origLines = original === "" ? [] : original.split("\n");
+      const updLines = updated === "" ? [] : updated.split("\n");
+      const netChange = updLines.length - origLines.length;
+
+      // Find lines unique to each side (approximate diff)
+      const origSet = new Set(origLines);
+      const updSet = new Set(updLines);
+      const addedLines = updLines.filter((l) => !origSet.has(l));
+      const removedLines = origLines.filter((l) => !updSet.has(l));
+
+      const linesAdded = netChange > 0 ? netChange : addedLines.length;
+      const linesRemoved = netChange < 0 ? -netChange : removedLines.length;
+
+      const parts: string[] = [];
+      parts.push(`+${linesAdded} lines, -${linesRemoved} lines (net: ${netChange > 0 ? "+" : ""}${netChange})`);
+
+      // Preview: show first 3 added lines
+      const previewAdded = addedLines.slice(0, 3);
+      if (previewAdded.length > 0) {
+        parts.push("Preview of additions:\n" + previewAdded.map((l) => `  + ${l.trim().slice(0, 100)}`).join("\n"));
+      }
+      const previewRemoved = removedLines.slice(0, 3);
+      if (previewRemoved.length > 0) {
+        parts.push("Preview of removals:\n" + previewRemoved.map((l) => `  - ${l.trim().slice(0, 100)}`).join("\n"));
+      }
+      return parts.join("\n");
+    }
 
-    // If the patch doesn't apply, try to fix it
+    // Detect silent no-op: patch "succeeded" but content unchanged despite having additions/deletions
+    let wasNoOp = false;
+    if (
+      updatedContent !== false &&
+      updatedContent === originalContent &&
+      (patchHasAdditions || patchHasDeletions)
+    ) {
+      console.warn(
+        "Patch applied but resulted in NO CHANGES despite having additions/deletions. Treating as failure and attempting fix..."
+      );
+      wasNoOp = true;
+      updatedContent = false; // Force fix path
+    }
+
+    // If the patch doesn't apply (or was a silent no-op), try to fix it
     if (updatedContent === false) {
       // diff library often returns false on failure
       console.warn("Initial patch apply failed. Attempting to fix patch...");
@@ -812,7 +1062,16 @@ export async function patchFile(
         );
         // It might be valid that the patch had no real changes, but applyPatch failed anyway?
         // Let's return an error indicating failure.
-        return `Patch failed to apply and could not be fixed or resulted in no changes. Make sure you are making small patches`;
+        const hunkSummary = patchHunks.map((h, i) =>
+          `  Hunk ${i + 1}: ${h.header} — ${h.additions.length} additions, ${h.subtractions.length} deletions`
+        ).join("\n");
+        return [
+          `❌ Patch failed: could not apply or fix the patch (${patchHunks.length} hunk(s) attempted, 0 applied).`,
+          wasNoOp ? `⚠️  Note: The patch initially appeared to succeed but produced NO CHANGES (silent no-op). This often means context lines matched a different location than intended.` : null,
+          `File: ${filePath} (${originalContent.split("\n").length} lines)`,
+          `Hunks attempted:\n${hunkSummary}`,
+          `Tip: Break your patch into smaller hunks. Ensure context lines exactly match the file. Use readFile to verify the current content before patching.`,
+        ].filter(Boolean).join("\n");
       }
 
       updatedContent = applyPatch(originalContent, fixedPatch);
@@ -837,14 +1096,23 @@ export async function patchFile(
           "Fixed patch also failed to apply."
         );
         // Try to provide more specific feedback from applyPatch if possible (library might not offer it)
-        return "Patch failed to apply even after attempting to fix it. Make sure you are making small patches.";
+        return [
+          `❌ Patch failed: could not apply even after auto-correction (${patchHunks.length} hunk(s) attempted, 0 applied).`,
+          wasNoOp ? `⚠️  Note: The patch initially appeared to succeed but produced NO CHANGES (silent no-op). Context lines may have matched the wrong location.` : null,
+          `File: ${filePath} (${originalContent.split("\n").length} lines)`,
+          `The auto-fix attempted to re-anchor your hunks to the file content but the resulting patch still failed.`,
+          `Tip: Use readFile to get the current exact content, then rewrite your patch with precise context lines matching the file. Make smaller, more targeted hunks.`,
+        ].filter(Boolean).join("\n");
       } else {
         console.log("Successfully applied the *fixed* patch.");
+        appliedPatch = fixedPatch;
       }
     } else {
       console.log("Successfully applied the original patch.");
     }
 
+    const wasFixed = appliedPatch !== patch;
+
     const eventResults: any[] = [];
     // Emit pre-edit blocking event
     if (context.Events) {
@@ -885,9 +1153,27 @@ export async function patchFile(
       }
     }
 
-    return `Patch applied successfully.${
-      filePath ? ` Use readFile on ${filePath} to verify changes.` : ""
-    }${eventResultsText}`.trim();
+    // Build rich summary of what actually changed
+    const changeSummary = buildChangeSummary(originalContent, updatedContent as string);
+    const appliedHunks = parseHunks(appliedPatch);
+    const totalHunks = patchHunks.length;
+    const appliedHunkCount = appliedHunks.length;
+    const patchStatus = wasFixed
+      ? `⚠️  Original patch required auto-correction before applying.`
+      : `✅ Original patch applied cleanly.`;
+    const hunkStatus = appliedHunkCount < totalHunks
+      ? `⚠️  Only ${appliedHunkCount}/${totalHunks} hunks were applied.`
+      : `${appliedHunkCount}/${totalHunks} hunks applied.`;
+
+    const summaryLines = [
+      `Patch applied to ${filePath}.`,
+      patchStatus,
+      hunkStatus,
+      changeSummary,
+    ];
+    if (eventResultsText) summaryLines.push(eventResultsText);
+
+    return summaryLines.join("\n");
   } catch (e: any) {
     console.error(`Error in patchFile function for ${filePath}:`, e);
     // Save error only if it's not a controlled failure path that already saved