decorated-pi 0.5.3 → 0.5.5

package/extensions/file-times.ts

@@ -53,16 +53,16 @@ export function checkStaleFile(absPath: string, displayPath: string): string | u
   if (lastRead === undefined) {
     // File exists but never read — must read first to avoid blind edits
     return (
-      `File not read yet: ${displayPath}. ` +
-      `Please read the file with the read tool before editing.`
+      `Please read the file with the read tool before editing. ` +
+      `File not read yet: ${displayPath}.`
     );
   }
 
   const currentMtime = getFileMtime(absPath);
   if (currentMtime > lastRead) {
     return (
-      `File modified since last read: ${displayPath}. ` +
-      `Please re-read the file with the read tool before editing.`
+      `Please re-read the file with the read tool before editing. ` +
+      `File modified since last read: ${displayPath}.`
     );
   }
 

package/extensions/io.ts

@@ -243,7 +243,13 @@ export function buildPatchCallComponent(component: PatchCallComponent, args: any
     return component;
   }
 
-  if (!body) return component;
+  if (!body) {
+    // Patch succeeded but the diff is empty (e.g., old_str === new_str, or
+    // every hunk's reps were skipped). Tell the user nothing changed.
+    component.addChild(new Spacer(1));
+    component.addChild(new Text(theme.fg("dim", `  (no changes)`), 0, 0));
+    return component;
+  }
 
   const lines = body.split("\n");
   const FOLD_THRESHOLD = 45;

package/extensions/patch.ts

@@ -176,6 +176,103 @@ function applyOverwrite(
 // Edits (exact string replacement)
 // ═══════════════════════════════════════════════════════════════════════════
 
+type LocateEditResult =
+  | {
+      found: true;
+      oldNorm: string;
+      newNorm: string;
+      matchIdx: number;
+      displayAnchor?: string;
+      anchorMissing: boolean;
+    }
+  | {
+      found: false;
+      oldNorm: string;
+      anchorState: "ok" | "missing" | "not_unique";
+      anchorMessage?: string;
+    };
+
+/** Shared edit location logic used by both one-shot and sequential paths.
+ *  Returns structured failure details when old_str is not found so callers can
+ *  preserve precise diagnostics instead of guessing why matching failed.
+ *  Throws ApplyError on duplicate global matches or non-unique old_str. */
+function locateEdit(
+  edit: { old_str: string; new_str: string; anchor?: string },
+  content: string,
+  displayPath: string,
+): LocateEditResult {
+  let oldNorm = normalizeLineEndings(edit.old_str);
+  let newNorm = normalizeLineEndings(edit.new_str);
+
+  let searchFrom = 0;
+  let displayAnchor: string | undefined;
+  let anchorMissing = false;
+  let anchorState: "ok" | "missing" | "not_unique" = "ok";
+  let anchorMessage: string | undefined;
+
+  // ── Anchor parsing ──
+  if (edit.anchor) {
+    const anchorNorm = normalizeLineEndings(edit.anchor);
+    const anchorIdx = content.indexOf(anchorNorm);
+    if (anchorIdx === -1) {
+      anchorState = "missing";
+      anchorMessage = `Anchor not found in ${displayPath}: "${truncate(edit.anchor)}".`;
+    } else {
+      const secondAnchor = content.indexOf(anchorNorm, anchorIdx + 1);
+      if (secondAnchor !== -1) {
+        anchorState = "not_unique";
+        anchorMessage = `Anchor is not unique in ${displayPath}: "${truncate(edit.anchor)}".`;
+      } else {
+        searchFrom = Math.max(0, anchorIdx - (oldNorm.length - 1));
+        displayAnchor = edit.anchor;
+      }
+    }
+  }
+
+  // ── Exact match in search range ──
+  let matchIdx = anchorMessage ? -1 : content.indexOf(oldNorm, searchFrom);
+
+  // ── Global exact match fallback (when anchor was missing/unusable) ──
+  if (matchIdx === -1 && anchorMessage) {
+    displayAnchor = edit.anchor;
+    anchorMissing = true;
+    matchIdx = content.indexOf(oldNorm, 0);
+    if (matchIdx !== -1) {
+      const secondGlobalMatch = content.indexOf(oldNorm, matchIdx + 1);
+      if (secondGlobalMatch !== -1) {
+        const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
+        throw new ApplyError(`${anchorMessage}\n${dupDiag}`);
+      }
+    }
+  }
+
+  // ── Fuzzy match ──
+  if (matchIdx === -1) {
+    const searchLine = searchFrom === 0 ? 0 : content.substring(0, searchFrom).split("\n").length - 1;
+    const fuzzy = tryFuzzyLineMatch(oldNorm, content, searchLine);
+    if (fuzzy) {
+      oldNorm = fuzzy.matched;
+      matchIdx = fuzzy.idx;
+      newNorm = normalizeIndentForFuzzy(fuzzy.matched.split("\n")[0] ?? "", newNorm);
+    }
+  }
+
+  if (matchIdx === -1) {
+    return { found: false, oldNorm, anchorState, anchorMessage };
+  }
+
+  // ── Uniqueness check (skip when anchor was used as a fallback) ──
+  if (!anchorMessage) {
+    const secondMatch = content.indexOf(oldNorm, matchIdx + 1);
+    if (secondMatch !== -1) {
+      const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
+      throw new ApplyError(`${dupDiag}`);
+    }
+  }
+
+  return { found: true, oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing };
+}
+
 async function applyEdits(
   absPath: string,
   displayPath: string,
@@ -192,150 +289,205 @@ async function applyEdits(
 
   const rawContent = fs.readFileSync(absPath, "utf8");
   const lineEnding = detectLineEnding(rawContent);
-  let content = normalizeLineEndings(rawContent);
+  const originalContent = normalizeLineEndings(rawContent);
 
-  // Precompute line offsets for O(log n) line number lookups
-  const lineOffsets = buildLineOffsets(rawContent);
+  // Precompute line offsets for the original file (used throughout)
+  const lineOffsets = buildLineOffsets(originalContent);
   const totalLines = lineOffsets.length - 1;
 
-  // Track cumulative offset for mapping current positions back to original
-  let cumulativeOffset = 0;
-  const replacements: ReplacementInfo[] = [];
-  const neededRanges: LineRange[] = [];
+  // ═══════════════════════════════════════════════════════════════════
+  // Phase 1: try matching every old_str against the ORIGINAL snapshot.
+  // If any edit requires content from a prior edit (chained dependency),
+  // fall back to sequential mode.
+  // ═══════════════════════════════════════════════════════════════════
+
+  const planned: Array<Extract<LocateEditResult, { found: true }>> = [];
+  let needsSequential = false;
 
   for (const edit of edits) {
     if (!edit.old_str) {
       throw new ApplyError(`old_str must not be empty in ${displayPath}.`);
     }
 
-    let oldNorm = normalizeLineEndings(edit.old_str);
-    let newNorm = normalizeLineEndings(edit.new_str);
-
-    // Determine search range
-    let searchFrom = 0;
-    let displayAnchor: string | undefined;
-    let anchorMissing = false;
-    let anchorNotFoundMessage: string | undefined;
+    const located = locateEdit(edit, originalContent, displayPath);
+    if (!located.found) {
+      // old_str not found in the original snapshot — likely chained edit.
+      // Fall back to sequential mode.
+      needsSequential = true;
+      break;
+    }
 
-    if (edit.anchor) {
-      const anchorNorm = normalizeLineEndings(edit.anchor);
+    planned.push(located);
+  }
 
-      // Find anchor — must be unique when present
-      const anchorIdx = content.indexOf(anchorNorm);
-      if (anchorIdx === -1) {
-        anchorNotFoundMessage = `Anchor not found in ${displayPath}: "${truncate(edit.anchor)}".`;
-      } else {
-        const secondAnchor = content.indexOf(anchorNorm, anchorIdx + 1);
-        if (secondAnchor !== -1) {
-          anchorNotFoundMessage = `Anchor is not unique in ${displayPath}: "${truncate(edit.anchor)}".`;
-        } else {
-          searchFrom = Math.max(0, anchorIdx - (oldNorm.length - 1));
-          displayAnchor = edit.anchor;
-          anchorMissing = false;
-        }
-      }
-    }
+  // ═══════════════════════════════════════════════════════════════════
+  // Sequential fallback — old behaviour for chained edits
+  // ═══════════════════════════════════════════════════════════════════
 
-    // Find old_str in range — must be unique
-    let matchIdx = anchorNotFoundMessage ? -1 : content.indexOf(oldNorm, searchFrom);
-    if (matchIdx === -1 && anchorNotFoundMessage) {
-      // Anchor was missing/unusable — try global exact match first
-      displayAnchor = edit.anchor;
-      anchorMissing = true;
-      matchIdx = content.indexOf(oldNorm, 0);
-      if (matchIdx !== -1) {
-        const secondGlobalMatch = content.indexOf(oldNorm, matchIdx + 1);
-        if (secondGlobalMatch !== -1) {
-          const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
-          throw new ApplyError(`${anchorNotFoundMessage}\n${dupDiag}`);
+  if (needsSequential) {
+    let content = originalContent;
+    let cumulativeOffset = 0;
+    const rawReplacements: ReplacementInfo[] = [];
+
+    for (const edit of edits) {
+      const located = locateEdit(edit, content, displayPath);
+      if (!located.found) {
+        const diag = diagnoseOldStrMismatch(located.oldNorm, content);
+        if (located.anchorState === "missing" || located.anchorState === "not_unique") {
+          throw new ApplyError(
+            `${located.anchorMessage}\nold_str not found in ${displayPath}: "${truncate(edit.old_str)}".\n${diag}`
+          );
         }
-      }
-    }
-
-    if (matchIdx === -1) {
-      // Fuzzy match fallback: normalize tab↔space + trailing whitespace
-      const searchLine = searchFrom === 0 ? 0 : content.substring(0, searchFrom).split("\n").length - 1;
-      const fuzzy = tryFuzzyLineMatch(oldNorm, content, searchLine);
-      if (fuzzy) {
-        oldNorm = fuzzy.matched;
-        matchIdx = fuzzy.idx;
-        newNorm = normalizeIndentForFuzzy(fuzzy.matched.split("\n")[0] ?? "", newNorm);
-      } else if (anchorNotFoundMessage) {
-        const diag = diagnoseOldStrMismatch(oldNorm, content);
-        throw new ApplyError(
-          `${anchorNotFoundMessage}\nold_str not found in ${displayPath}: "${truncate(edit.old_str)}".\n${diag}`
-        );
-      } else {
-        const diag = diagnoseOldStrMismatch(oldNorm, content);
         throw new ApplyError(
           `old_str not found in ${displayPath}` +
           (edit.anchor ? ` after anchor "${truncate(edit.anchor)}"` : "") +
           `: "${truncate(edit.old_str)}".\n${diag}`
         );
       }
+
+      const { oldNorm, newNorm, matchIdx, displayAnchor, anchorMissing } = located;
+
+      const oldStartLine = lineAtOffset(lineOffsets, matchIdx - cumulativeOffset);
+      const oldEndLine = lineAtOffset(lineOffsets, matchIdx - cumulativeOffset + oldNorm.length - 1);
+
+      content =
+        content.substring(0, matchIdx) +
+        newNorm +
+        content.substring(matchIdx + oldNorm.length);
+
+      cumulativeOffset += newNorm.length - oldNorm.length;
+
+      rawReplacements.push({
+        oldStartLine,
+        oldEndLine,
+        newStartLine: 0, // placeholder — recalculated after collapse
+        newEndLine: 0,
+        oldLines: oldNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
+        newLines: newNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
+        anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined,
+        anchorMissing,
+      });
     }
 
-    // Check uniqueness in anchor-narrowed / plain search path only when anchor was used normally
-    if (!anchorNotFoundMessage) {
-      const secondMatch = content.indexOf(oldNorm, matchIdx + 1);
-      if (secondMatch !== -1) {
-        const dupDiag = diagnoseOldStrNotUnique(oldNorm, content);
-        throw new ApplyError(
-          `${dupDiag}`
-        );
+    // Collapse chained-edit replacements into net-change replacements,
+    // so the TUI diff shows only the net effect (original→final).
+    const cleanReplacements = collapseSequentialReplacements(rawReplacements);
+
+    const mergedRanges = mergeRanges(cleanReplacements.map(r => ({
+      startLine: Math.max(1, r.oldStartLine - CONTEXT_LINES),
+      endLine: Math.min(totalLines, r.oldEndLine + CONTEXT_LINES),
+    })));
+    const neededLines: Map<number, string> = new Map();
+    for (const range of mergedRanges) {
+      const lines = extractLineRange(originalContent, lineOffsets, range.startLine, range.endLine);
+      for (let i = 0; i < lines.length; i++) {
+        neededLines.set(range.startLine + i, lines[i]);
       }
     }
 
-    // Compute line numbers in the original file for diff generation (O(log n) via binary search)
-    // matchIdx is in the modified content; subtract cumulative offset to map back to original
-    const origMatchIdx = matchIdx - cumulativeOffset;
-    const oldStartLine = lineAtOffset(lineOffsets, origMatchIdx);
-    const oldEndLine = lineAtOffset(lineOffsets, origMatchIdx + oldNorm.length - 1);
+    const fileDiff = generateLocalDiff(displayPath, cleanReplacements, neededLines, totalLines);
+    if (result.diff) {
+      result.diff += "\n" + fileDiff;
+    } else {
+      result.diff = fileDiff;
+    }
+
+    const finalContent = restoreLineEndings(content, lineEnding);
+    if (lineEnding === "\r\n" && rawContent.includes("\r\n")) {
+      result.warnings.push(`${displayPath}: CRLF line endings were normalized to LF during editing.`);
+    }
+
+    fs.writeFileSync(absPath, finalContent, "utf8");
+    result.modified.push(displayPath);
+    result.replacements.set(displayPath, cleanReplacements);
+    return;
+  }
+
+  // ═══════════════════════════════════════════════════════════════════
+  // Phase 2: Conflict detection — sort by position, check for overlaps
+  // ═══════════════════════════════════════════════════════════════════
+
+  const sorted = [...planned].sort((a, b) => a.matchIdx - b.matchIdx);
+
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const cur = sorted[i]!;
+    const next = sorted[i + 1]!;
+    const curEnd = cur.matchIdx + cur.oldNorm.length;
+    if (curEnd > next.matchIdx) {
+      const curStartLine = lineAtOffset(lineOffsets, cur.matchIdx);
+      const curEndLine = lineAtOffset(lineOffsets, curEnd - 1);
+      const nextStartLine = lineAtOffset(lineOffsets, next.matchIdx);
+      const overlapEnd = Math.min(curEnd, next.matchIdx + next.oldNorm.length);
+      const overlapEndLine = lineAtOffset(lineOffsets, overlapEnd - 1);
+      throw new ApplyError(
+        `Edits target overlapping regions in ${displayPath}: ` +
+        `edit targeting lines ${curStartLine}-${curEndLine} overlaps with ` +
+        `edit targeting lines ${nextStartLine}-${overlapEndLine}. ` +
+        `Split overlapping edits into separate patch calls.`
+      );
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════
+  // Phase 3: One-shot assembly — splice replacements into final content
+  // ═══════════════════════════════════════════════════════════════════
 
-    // Apply replacement
-    content =
-      content.substring(0, matchIdx) +
-      newNorm +
-      content.substring(matchIdx + oldNorm.length);
+  let content = "";
+  let cursor = 0;
+  const replacements: ReplacementInfo[] = [];
+  const neededRanges: LineRange[] = [];
+
+  for (const p of sorted) {
+    // Copy original content up to this edit
+    content += originalContent.substring(cursor, p.matchIdx);
 
-    // Track the offset shift for subsequent edits
-    cumulativeOffset += newNorm.length - oldNorm.length;
+    // Record where new_str lands in the assembled content
+    const newStartIdx = content.length;
+    content += p.newNorm;
+    const newEndIdx = content.length - 1;
 
-    // Compute new_str line numbers in the result
-    const newStartLine = charOffsetToLine(content, matchIdx);
-    const newEndLine = charOffsetToLine(content, matchIdx + newNorm.length - 1);
+    // Compute line numbers (original file coordinates for old, result for new)
+    const oldStartLine = lineAtOffset(lineOffsets, p.matchIdx);
+    const oldEndLine = lineAtOffset(lineOffsets, p.matchIdx + p.oldNorm.length - 1);
+    const newStartLine = charOffsetToLine(content, newStartIdx);
+    const newEndLine = charOffsetToLine(content, newEndIdx);
 
-    // Record replacement info
     replacements.push({
       oldStartLine,
       oldEndLine,
       newStartLine,
       newEndLine,
-      oldLines: oldNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
-      newLines: newNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
-      anchor: displayAnchor ? displayAnchor.split("\n")[0] : undefined,
-      anchorMissing,
+      oldLines: p.oldNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
+      newLines: p.newNorm.split("\n").filter((l, i, arr) => !(i === arr.length - 1 && l === "")),
+      anchor: p.displayAnchor ? p.displayAnchor.split("\n")[0] : undefined,
+      anchorMissing: p.anchorMissing,
     });
 
-    // Collect context range for this edit
     neededRanges.push({
       startLine: Math.max(1, oldStartLine - CONTEXT_LINES),
       endLine: Math.min(totalLines, oldEndLine + CONTEXT_LINES),
     });
+
+    cursor = p.matchIdx + p.oldNorm.length;
   }
 
-  // Generate diff using only needed context lines (no full-file split)
+  // Copy trailing original content
+  content += originalContent.substring(cursor);
+
+  // ═══════════════════════════════════════════════════════════════════
+  // Diff generation
+  // ═══════════════════════════════════════════════════════════════════
+
   const mergedRanges = mergeRanges(neededRanges);
-  const currentLineOffsets = buildLineOffsets(content);
+  const originalLineOffsets = buildLineOffsets(originalContent);
   const neededLines: Map<number, string> = new Map();
   for (const range of mergedRanges) {
-    const lines = extractLineRange(content, currentLineOffsets, range.startLine, range.endLine);
+    const lines = extractLineRange(originalContent, originalLineOffsets, range.startLine, range.endLine);
     for (let i = 0; i < lines.length; i++) {
       neededLines.set(range.startLine + i, lines[i]);
     }
   }
 
-  // Build diff for this file and append to result
   const fileDiff = generateLocalDiff(displayPath, replacements, neededLines, totalLines);
   if (result.diff) {
     result.diff += "\n" + fileDiff;
@@ -346,7 +498,6 @@ async function applyEdits(
   // Restore line endings
   const finalContent = restoreLineEndings(content, lineEnding);
 
-  // Warn if line endings were normalized (CRLF → LF)
   if (lineEnding === "\r\n" && rawContent.includes("\r\n")) {
     result.warnings.push(`${displayPath}: CRLF line endings were normalized to LF during editing.`);
   }
@@ -394,6 +545,11 @@ export async function computePatchPreview(
     const lineOffsets = buildLineOffsets(rawContent);
     const totalLines = lineOffsets.length - 1;
     let content = normalizeLineEndings(rawContent);
+    // Snapshot the original (pre-edit) content for diff display. The
+    // `content` variable below is mutated in-place as edits are applied,
+    // but the TUI diff should show the ORIGINAL lines (not the post-edit
+    // content) so leading whitespace is preserved correctly.
+    const originalContent = content;
     const allReplacements: ReplacementInfo[] = [];
     const neededRanges: LineRange[] = [];
     let cumulativeOffset = 0;
@@ -471,12 +627,13 @@ export async function computePatchPreview(
         cumulativeOffset += newNorm.length - oldNorm.length;
       }
 
-      // Merge needed ranges and extract only those lines
+      // Merge needed ranges and extract lines from the ORIGINAL content
+      // (not the mutated `content`), so the diff shows pre-edit lines.
       const mergedRanges = mergeRanges(neededRanges);
-      const currentLineOffsets = buildLineOffsets(content);
+      const originalLineOffsets = buildLineOffsets(originalContent);
       const neededLines: Map<number, string> = new Map();
       for (const range of mergedRanges) {
-        const lines = extractLineRange(content, currentLineOffsets, range.startLine, range.endLine);
+        const lines = extractLineRange(originalContent, originalLineOffsets, range.startLine, range.endLine);
         for (let i = 0; i < lines.length; i++) {
           neededLines.set(range.startLine + i, lines[i]);
         }
@@ -560,14 +717,17 @@ interface ChunkAnchor {
 function getChunkAnchors(chunk: ReplacementChunk): ChunkAnchor[] {
   const byText = new Map<string, ChunkAnchor>();
   for (const rep of chunk.reps) {
-    const text = rep.anchor?.trim();
-    if (!text) continue;
-    const existing = byText.get(text);
-    if (!existing) {
-      byText.set(text, { text, missing: Boolean(rep.anchorMissing) });
-    } else if (!rep.anchorMissing) {
-      // If any replacement successfully used this anchor, do not mark it missing.
-      existing.missing = false;
+    const raw = rep.anchor?.trim();
+    if (!raw) continue;
+    // Support \n-separated anchors from collapsed sequential replacements
+    const texts = raw.includes("\n") ? raw.split("\n").map(s => s.trim()).filter(Boolean) : [raw];
+    for (const text of texts) {
+      const existing = byText.get(text);
+      if (!existing) {
+        byText.set(text, { text, missing: Boolean(rep.anchorMissing) });
+      } else if (!rep.anchorMissing) {
+        existing.missing = false;
+      }
     }
   }
   return [...byText.values()];
@@ -607,6 +767,132 @@ function formatChunkMetadataLines(chunk: ReplacementChunk): string[] {
   return lines;
 }
 
+type RenderOp =
+  | { type: "context"; line: number; text: string }
+  | { type: "removed"; line: number; text: string }
+  | { type: "added"; line: number; text: string };
+
+interface RenderableReplacement {
+  operations: RenderOp[];
+  /** Line number of the first removed/added operation (BEFORE trimming).
+   *  Used to limit how far "context before" extends. */
+  firstChangeLine: number;
+  /** Line number of the last removed/added operation (BEFORE trimming). */
+  lastChangeLine: number;
+}
+
+/** Compute a minimal line-level diff between old and new lines using LCS.
+ *  Common lines become context, while only truly different lines become
+ *  removed/added. The resulting context is trimmed to `contextLines` lines
+ *  before the first and after the last non-context operation so the TUI hunk
+ *  doesn't grow with the size of the LLM's old_str. */
+function splitReplacementForRender(
+  rep: ReplacementInfo,
+  contextLines: number,
+): RenderableReplacement {
+  const m = rep.oldLines.length;
+  const n = rep.newLines.length;
+
+  // DP table: dp[i][j] = LCS length of oldLines[0..i) and newLines[0..j)
+  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array<number>(n + 1).fill(0));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (rep.oldLines[i - 1] === rep.newLines[j - 1]) {
+        dp[i]![j] = dp[i - 1]![j - 1]! + 1;
+      } else {
+        dp[i]![j] = Math.max(dp[i - 1]![j]!, dp[i]![j - 1]!);
+      }
+    }
+  }
+
+  // Backtrack to produce operations in reverse order.
+  const stack: RenderOp[] = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (rep.oldLines[i - 1] === rep.newLines[j - 1]) {
+      stack.push({ type: "context", line: rep.oldStartLine + i - 1, text: rep.oldLines[i - 1]! });
+      i--;
+      j--;
+    } else if (dp[i - 1]![j]! > dp[i]![j - 1]!) {
+      stack.push({ type: "removed", line: rep.oldStartLine + i - 1, text: rep.oldLines[i - 1]! });
+      i--;
+    } else {
+      stack.push({ type: "added", line: rep.oldStartLine + j - 1, text: rep.newLines[j - 1]! });
+      j--;
+    }
+  }
+  while (i > 0) {
+    stack.push({ type: "removed", line: rep.oldStartLine + i - 1, text: rep.oldLines[i - 1]! });
+    i--;
+  }
+  while (j > 0) {
+    stack.push({ type: "added", line: rep.oldStartLine + j - 1, text: rep.newLines[j - 1]! });
+    j--;
+  }
+
+  // Reverse to get the final order.
+  const operations: RenderOp[] = [];
+  while (stack.length > 0) operations.push(stack.pop()!);
+
+  // Find first and last non-context operations (in the original order).
+  let firstChangeLine = rep.oldStartLine;
+  let lastChangeLine = rep.oldStartLine;
+  for (const op of operations) {
+    if (op.type !== "context") {
+      firstChangeLine = op.line;
+      break;
+    }
+  }
+  for (let k = operations.length - 1; k >= 0; k--) {
+    if (operations[k]!.type !== "context") {
+      lastChangeLine = operations[k]!.line;
+      break;
+    }
+  }
+
+  // Trim context operations that sit far from any non-context change.
+  const firstNonContextIdx = operations.findIndex(op => op.type !== "context");
+  if (firstNonContextIdx === -1) {
+    return { operations: [], firstChangeLine, lastChangeLine };
+  }
+  let lastNonContextIdx = operations.length - 1;
+  for (let k = operations.length - 1; k >= 0; k--) {
+    if (operations[k]!.type !== "context") { lastNonContextIdx = k; break; }
+  }
+  const start = Math.max(0, firstNonContextIdx - contextLines);
+  const end = Math.min(operations.length - 1, lastNonContextIdx + contextLines);
+  const trimmed = operations.slice(start, end + 1);
+
+  return { operations: trimmed, firstChangeLine, lastChangeLine };
+}
+
+/** Compute the actual hunk range for a chunk by looking at the rendered
+ *  context (before / after) and the LCS-trimmed operations. Returns
+ *  [startLine, endLine] (1-based, inclusive). */
+function computeRenderedRange(
+  chunk: ReplacementChunk,
+  repViews: Array<{ rep: ReplacementInfo; view: RenderableReplacement; beforeStart: number; afterEnd: number }>,
+  totalLines: number,
+  contextLines: number,
+): { startLine: number; endLine: number } {
+  let renderedStart = Infinity;
+  let renderedEnd = -Infinity;
+  for (const { rep, view, beforeStart, afterEnd } of repViews) {
+    if (view.operations.length === 0 && beforeStart >= rep.oldStartLine && afterEnd <= rep.oldEndLine) continue;
+    const opStart = view.operations[0]!.line;
+    const opEnd = view.operations[view.operations.length - 1]!.line;
+    const s = Math.min(beforeStart, opStart);
+    const e = Math.max(afterEnd, opEnd);
+    if (s < renderedStart) renderedStart = s;
+    if (e > renderedEnd) renderedEnd = e;
+  }
+  if (renderedStart === Infinity) {
+    return { startLine: chunk.startLine, endLine: chunk.endLine };
+  }
+  return { startLine: renderedStart, endLine: Math.min(totalLines, renderedEnd) };
+}
+
 /**
  * Generate diff as visual chunks merged by overlapping/adjacent context windows.
  * This keeps spacing stable when multiple nearby edits would otherwise create
@@ -614,57 +900,72 @@ function formatChunkMetadataLines(chunk: ReplacementChunk): string[] {
  */
 function generateReplacementDiff(filePath: string, reps: ReplacementInfo[], originalLines: string[]): string {
   const parts: string[] = [];
-  parts.push(`--- ${filePath}`);
-  parts.push(`+++ ${filePath}`);
 
   if (reps.length === 0) {
-    parts.push("");
-    return parts.join("\n");
+    return "";
   }
 
   const maxLineNum = Math.max(originalLines.length, ...reps.map(r => r.oldEndLine));
   const numWidth = String(maxLineNum).length;
   const CONTEXT = 3;
   const chunks = buildReplacementChunks(reps, originalLines.length, CONTEXT);
+  let firstHunk = true;
 
   for (let c = 0; c < chunks.length; c++) {
     const chunk = chunks[c]!;
-    if (c > 0) parts.push("");
-    parts.push(formatChunkHeader(chunk));
-    parts.push(...formatChunkMetadataLines(chunk));
 
-    let cursor = chunk.startLine;
+    // Pre-compute the rendered range for this chunk so the hunk header
+    // reflects what we actually emit (not the full chunk window).
+    const repViews = chunk.reps.map(rep => {
+      const v = splitReplacementForRender(rep, CONTEXT);
+      const beforeStart = Math.max(chunk.startLine, v.firstChangeLine - CONTEXT);
+      const afterEnd = Math.min(chunk.endLine, v.lastChangeLine + CONTEXT);
+      return { rep, view: v, beforeStart, afterEnd };
+    });
 
-    for (const rep of chunk.reps) {
-      // Context before this replacement (only once per original line)
-      for (let i = cursor; i < rep.oldStartLine; i++) {
+    // Skip hunk entirely if every rep produced no effective changes
+    // (e.g., LLM sent old_str === new_str). Rendering context-only hunks
+    // is misleading — there is nothing to show.
+    if (repViews.every(r => r.view.operations.length === 0)) continue;
+
+    const { startLine: renderedStart, endLine: renderedEnd } = computeRenderedRange(
+      chunk, repViews, originalLines.length, CONTEXT,
+    );
+    const syntheticChunk = { ...chunk, startLine: renderedStart, endLine: renderedEnd };
+    parts.push(formatChunkHeader(syntheticChunk));
+    parts.push(...formatChunkMetadataLines(syntheticChunk));
+
+    for (const { rep, view, beforeStart } of repViews) {
+      // Context before this rep: only lines within CONTEXT of the first change.
+      for (let i = beforeStart; i < rep.oldStartLine; i++) {
         const num = String(i).padStart(numWidth, " ");
         parts.push(` ${num} ${originalLines[i - 1]}`);
       }
 
-      // Removed lines (from original)
-      for (let i = 0; i < rep.oldLines.length; i++) {
-        const num = String(rep.oldStartLine + i).padStart(numWidth, " ");
-        parts.push(`-${num} ${rep.oldLines[i]}`);
-      }
-
-      // Added lines
-      for (let i = 0; i < rep.newLines.length; i++) {
-        const num = String(rep.oldStartLine + i).padStart(numWidth, " ");
-        parts.push(`+${num} ${rep.newLines[i]}`);
+      for (const op of view.operations) {
+        const num = String(op.line).padStart(numWidth, " ");
+        if (op.type === "context") parts.push(` ${num} ${op.text}`);
+        // For removed lines, use the file's actual content (not the LLM's
+        // old_str) so leading whitespace is preserved even if the LLM
+        // stripped it from the old_str.
+        else if (op.type === "removed") {
+          const fileLine = originalLines[op.line - 1] ?? op.text;
+          parts.push(`-${num} ${fileLine}`);
+        }
+        else parts.push(`+${num} ${op.text}`);
       }
-
-      cursor = rep.oldEndLine + 1;
     }
 
-    // Trailing context for the merged chunk
-    for (let i = cursor; i <= chunk.endLine; i++) {
-      const num = String(i).padStart(numWidth, " ");
-      parts.push(` ${num} ${originalLines[i - 1]}`);
+    // Trailing context after the last rep (already bounded by afterEnd).
+    const lastEntry = repViews[repViews.length - 1];
+    if (lastEntry) {
+      for (let i = lastEntry.rep.oldEndLine + 1; i <= lastEntry.afterEnd; i++) {
+        const num = String(i).padStart(numWidth, " ");
+        parts.push(` ${num} ${originalLines[i - 1]}`);
+      }
     }
   }
 
-  if (parts[parts.length - 1] !== "") parts.push("");
   return parts.join("\n");
 }
 
@@ -795,6 +1096,76 @@ function charOffsetToLine(content: string, offset: number): number {
 /**
  * Generate diff using only the needed lines (partial file context).
  */
+/** Collapse chained-edit replacements (where out[i] === in[i+1]) into
+ *  net-change replacements showing only the net effect (original→final). */
+function collapseSequentialReplacements(
+  reps: ReplacementInfo[],
+): ReplacementInfo[] {
+  const collapsed: ReplacementInfo[] = [];
+  let i = 0;
+  while (i < reps.length) {
+    const start = reps[i]!;
+    let merged: ReplacementInfo = {
+      ...start,
+      newStartLine: start.oldStartLine,
+      newEndLine: start.oldStartLine + start.newLines.length - 1,
+    };
+
+    const anchors: string[] = [];
+    const seenAnchors = new Set<string>();
+    const addAnchor = (raw?: string) => {
+      if (!raw) return;
+      for (const text of raw.split("\n").map(s => s.trim()).filter(Boolean)) {
+        if (seenAnchors.has(text)) continue;
+        seenAnchors.add(text);
+        anchors.push(text);
+      }
+    };
+    addAnchor(start.anchor);
+
+    let j = i + 1;
+    while (j < reps.length) {
+      const next = reps[j]!;
+      // Merge chained edits when next edit's input matches merged output.
+      // We allow slightly shifted line numbers because sequential edits can
+      // change string lengths before we compute displayed line ranges.
+      if (!(linesEqual(merged.newLines, next.oldLines) && next.oldStartLine <= merged.oldEndLine + 1)) {
+        break;
+      }
+      addAnchor(next.anchor);
+      merged = {
+        // Keep the ORIGINAL region from the first replacement in the chain.
+        // Later chained replacements may have shifted line numbers, but the
+        // net diff should still point at the original file region.
+        oldStartLine: merged.oldStartLine,
+        oldEndLine: merged.oldEndLine,
+        newStartLine: merged.oldStartLine,
+        newEndLine: merged.oldStartLine + next.newLines.length - 1,
+        oldLines: merged.oldLines,
+        newLines: next.newLines,
+        anchor: undefined,
+        anchorMissing: merged.anchorMissing || next.anchorMissing,
+      };
+      j++;
+    }
+
+    collapsed.push({
+      ...merged,
+      anchor: anchors.length > 0 ? anchors.join("\n") : undefined,
+    });
+    i = j;
+  }
+  return collapsed;
+}
+
+function linesEqual(a: string[], b: string[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
 function generateLocalDiff(
   filePath: string,
   reps: ReplacementInfo[],
@@ -804,8 +1175,7 @@ function generateLocalDiff(
   if (reps.length === 0) return "";
 
   const parts: string[] = [];
-  parts.push(`--- ${filePath}`);
-  parts.push(`+++ ${filePath}`);
+  let firstHunk = true;
 
   // Calculate dynamic width based on max line number
   const maxLineNum = Math.max(totalLines, ...reps.map(r => r.oldEndLine));
@@ -814,36 +1184,69 @@ function generateLocalDiff(
   // Merge replacement chunks
   const chunks = buildReplacementChunks(reps, totalLines, CONTEXT_LINES);
   for (let c = 0; c < chunks.length; c++) {
-    if (c > 0) parts.push("");
     const chunk = chunks[c]!;
-    parts.push(formatChunkHeader(chunk));
-    parts.push(...formatChunkMetadataLines(chunk));
+
+    // Pre-compute the rendered range so the hunk header reflects what we
+    // actually emit (not the full chunk window).
+    const repViews = chunk.reps.map(rep => {
+      const view = splitReplacementForRender(rep, CONTEXT_LINES);
+      const beforeStart = Math.max(chunk.startLine, view.firstChangeLine - CONTEXT_LINES);
+      const afterEnd = Math.min(chunk.endLine, view.lastChangeLine + CONTEXT_LINES);
+      return { rep, view, beforeStart, afterEnd };
+    });
+
+    // Skip hunk entirely if every rep produced no effective changes
+    // (e.g., LLM sent old_str === new_str). Rendering context-only hunks
+    // is misleading — there is nothing to show.
+    if (repViews.every(r => r.view.operations.length === 0)) continue;
+
+    if (firstHunk) {
+      parts.push(`--- ${filePath}`);
+      parts.push(`+++ ${filePath}`);
+      firstHunk = false;
+    } else {
+      parts.push("");
+    }
+
+    const { startLine: renderedStart, endLine: renderedEnd } = computeRenderedRange(
+      chunk, repViews, totalLines, CONTEXT_LINES,
+    );
+    const syntheticChunk = { ...chunk, startLine: renderedStart, endLine: renderedEnd };
+    parts.push(formatChunkHeader(syntheticChunk));
+    parts.push(...formatChunkMetadataLines(syntheticChunk));
 
     // Output context + removed + added
-    let cursor = chunk.startLine;
-    for (const rep of chunk.reps) {
-      // Context before this replacement
-      for (let i = cursor; i < rep.oldStartLine; i++) {
+    for (const { rep, view, beforeStart } of repViews) {
+      // Context before this replacement (only lines close to the first change)
+      for (let i = beforeStart; i < rep.oldStartLine; i++) {
         const lineText = neededLines.get(i);
         if (lineText !== undefined) {
           parts.push(` ${String(i).padStart(numWidth, " ")} ${lineText}`);
         }
       }
-      // Removed lines
-      for (let i = 0; i < rep.oldLines.length; i++) {
-        parts.push(`-${String(rep.oldStartLine + i).padStart(numWidth, " ")} ${rep.oldLines[i]}`);
-      }
-      // Added lines
-      for (let i = 0; i < rep.newLines.length; i++) {
-        parts.push(`+${String(rep.oldStartLine + i).padStart(numWidth, " ")} ${rep.newLines[i]}`);
+
+      for (const op of view.operations) {
+        const num = String(op.line).padStart(numWidth, " ");
+        if (op.type === "context") parts.push(` ${num} ${op.text}`);
+        // For removed lines, use the file's actual content (not the LLM's
+        // old_str) so leading whitespace is preserved even if the LLM
+        // stripped it from the old_str.
+        else if (op.type === "removed") {
+          const fileLine = neededLines.get(op.line) ?? op.text;
+          parts.push(`-${num} ${fileLine}`);
+        }
+        else parts.push(`+${num} ${op.text}`);
       }
-      cursor = rep.oldEndLine + 1;
     }
-    // Trailing context
-    for (let i = cursor; i <= chunk.endLine; i++) {
-      const lineText = neededLines.get(i);
-      if (lineText !== undefined) {
-        parts.push(` ${String(i).padStart(numWidth, " ")} ${lineText}`);
+
+    // Trailing context after the last rep (already bounded by afterEnd).
+    const lastEntry = repViews[repViews.length - 1];
+    if (lastEntry) {
+      for (let i = lastEntry.rep.oldEndLine + 1; i <= lastEntry.afterEnd; i++) {
+        const lineText = neededLines.get(i);
+        if (lineText !== undefined) {
+          parts.push(` ${String(i).padStart(numWidth, " ")} ${lineText}`);
+        }
       }
     }
   }

package/extensions/session-title.ts

@@ -9,25 +9,50 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-function extractFirstMessage(entries: Array<{ type: string; message?: { role: string; content?: unknown } }>): string | undefined {
-  for (const entry of entries) {
-    if (entry.type !== "message" || !entry.message || entry.message.role !== "user") continue;
+/** Maximum length of the auto-derived session title. Single-line TUI footers
+ *  break easily, so we cap in addition to newline truncation. */
+export const MAX_SESSION_TITLE_LENGTH = 80;
 
-    const content = entry.message.content;
-    if (typeof content === "string" && content.trim()) {
-      return content.trim();
-    }
-    if (Array.isArray(content)) {
-      for (const part of content) {
-        if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.trim()) {
-          return part.text.trim();
-        }
+interface SessionEntryLike {
+  type: string;
+  message?: { role: string; content?: unknown };
+}
+
+function pickFirstUserText(content: unknown): string | undefined {
+  if (typeof content === "string" && content.trim()) {
+    return content.trim();
+  }
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.trim()) {
+        return part.text.trim();
       }
     }
   }
   return undefined;
 }
 
+/** Extract a single-line title from the first user message.
+ *  Truncates at the first newline and caps length to keep the TUI footer safe. */
+export function extractFirstMessage(entries: SessionEntryLike[]): string | undefined {
+  for (const entry of entries) {
+    if (entry.type !== "message" || !entry.message || entry.message.role !== "user") continue;
+
+    const raw = pickFirstUserText(entry.message.content);
+    if (!raw) continue;
+
+    // Truncate at first newline to avoid breaking TUI footer layout.
+    const nl = raw.indexOf("\n");
+    const oneLine = (nl === -1 ? raw : raw.slice(0, nl)).trim();
+    if (!oneLine) continue;
+
+    // Cap length to keep footer/terminal title rows short.
+    if (oneLine.length <= MAX_SESSION_TITLE_LENGTH) return oneLine;
+    return oneLine.slice(0, MAX_SESSION_TITLE_LENGTH - 1) + "…";
+  }
+  return undefined;
+}
+
 export function setupSessionTitle(pi: ExtensionAPI) {
   pi.on("session_start", (_event, ctx) => {
     if (ctx.sessionManager.getSessionName()) return;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decorated-pi",
-    "version": "0.5.3",
+    "version": "0.5.5",
     "description": "decorated-pi is a practical enhancement pack for pi — smarter tools that are token efficient and cache friendly.",
     "keywords": [
         "pi",