pi-openai-codex-compat 0.0.6 → 0.0.7

package/extensions/openai-codex-compat/apply-patch-diff-render.ts

@@ -10,8 +10,24 @@ import {
 import {
   type AppliedPatchChange,
   type ApplyPatchDetails,
+  type ApplyPatchFinalPathState,
+  type ApplyPatchFailureDetails,
+  type ApplyPatchInstructionDetails,
+  type ApplyPatchInstructionEffect,
+  type ApplyPatchInstructionReason,
+  type ApplyPatchInstructionStatus,
+  applyPatchHasOtherFilesystemChanges,
+  applyPatchNeedsInstructionResults,
+  applyPatchSummaryPaths,
   coalesceAppliedPatchChangesForRendering,
+  formatApplyPatchFailureHeading,
+  formatApplyPatchInstructionFeedback,
+  formatApplyPatchInstructionStatusLabel,
 } from "./apply-patch-engine.ts";
+import type {
+  FormatterMatchCandidateRange,
+  FormatterMatchFailureDetails,
+} from "./apply-patch-matcher.ts";
 import { usesLightToolPalette } from "./codex-tool-surface.ts";
 
 type DiffLineKind = "add" | "delete" | "context";
@@ -73,6 +89,10 @@ function displayPath(path: string, cwd: string): string {
 }
 
 function changePath(change: AppliedPatchChange, cwd: string): string {
+  if (change.kind === "move") {
+    const path = `${displayPath(change.sourcePath, cwd)} → ${displayPath(change.destinationPath, cwd)}`;
+    return change.replacedDestination ? `${path} (replaced destination)` : path;
+  }
   const path = displayPath(change.path, cwd);
   return change.kind === "update" && change.moveTo
     ? `${path} → ${displayPath(change.moveTo, cwd)}`
@@ -84,12 +104,21 @@ function changeVerb(change: AppliedPatchChange): string {
     case "add":
       return "Added";
     case "delete":
-      return "Deleted";
+      return change.entryType === "symlink" ? "Deleted symlink" : "Deleted";
+    case "move":
+      return "Moved";
     case "update":
       return "Edited";
   }
 }
 
+function changeListPath(change: AppliedPatchChange, cwd: string): string {
+  const path = changePath(change, cwd);
+  return change.kind === "delete" && change.entryType === "symlink"
+    ? `${path} (deleted symlink)`
+    : path;
+}
+
 function countSummary(additions: number, deletions: number, theme: Theme): string {
   return `(${theme.fg("success", `+${additions}`)} ${theme.fg("error", `-${deletions}`)})`;
 }
@@ -109,6 +138,11 @@ function isAppliedPatchChange(value: unknown): value is AppliedPatchChange {
     kind?: unknown;
     path?: unknown;
     moveTo?: unknown;
+    sourcePath?: unknown;
+    destinationPath?: unknown;
+    replacedDestination?: unknown;
+    entryType?: unknown;
+    exact?: unknown;
     content?: unknown;
     oldContent?: unknown;
     newContent?: unknown;
@@ -117,15 +151,27 @@ function isAppliedPatchChange(value: unknown): value is AppliedPatchChange {
     deletions?: unknown;
   };
   if (
-    typeof change.path !== "string" ||
     typeof change.displayDiff !== "string" ||
     typeof change.additions !== "number" ||
     typeof change.deletions !== "number"
   ) {
     return false;
   }
+  if (change.kind === "move") {
+    return (
+      typeof change.sourcePath === "string" &&
+      typeof change.destinationPath === "string" &&
+      typeof change.replacedDestination === "boolean" &&
+      (change.entryType === "regular-file" || change.entryType === "symlink") &&
+      typeof change.exact === "boolean"
+    );
+  }
+  if (typeof change.path !== "string") return false;
   if (change.kind === "add" || change.kind === "delete") {
-    return typeof change.content === "string";
+    return change.kind === "delete"
+      ? (change.entryType === "regular-file" || change.entryType === "symlink") &&
+          (change.content === undefined || typeof change.content === "string")
+      : typeof change.content === "string";
   }
   return (
     change.kind === "update" &&
@@ -135,6 +181,244 @@ function isAppliedPatchChange(value: unknown): value is AppliedPatchChange {
   );
 }
 
+const INSTRUCTION_STATUSES = new Set<ApplyPatchInstructionStatus>([
+  "applied",
+  "planned",
+  "no-op",
+  "dead",
+  "failed",
+  "not-run",
+]);
+
+const INSTRUCTION_REASON_CODES = new Set<ApplyPatchInstructionReason["code"]>([
+  "empty-update",
+  "identity-update",
+  "content-already-present",
+  "update-result-unchanged",
+  "path-already-absent",
+  "same-entry-move",
+  "move-already-fulfilled",
+  "dead-dominated",
+]);
+
+function isApplyPatchInstructionReason(value: unknown): value is ApplyPatchInstructionReason {
+  if (typeof value !== "object" || value === null) return false;
+  const reason = value as {
+    code?: unknown;
+    message?: unknown;
+    dominatingInstructions?: unknown;
+    relatedInstructions?: unknown;
+  };
+  return (
+    typeof reason.code === "string" &&
+    INSTRUCTION_REASON_CODES.has(reason.code as ApplyPatchInstructionReason["code"]) &&
+    typeof reason.message === "string" &&
+    (reason.dominatingInstructions === undefined ||
+      (Array.isArray(reason.dominatingInstructions) &&
+        reason.dominatingInstructions.every((index) => typeof index === "number"))) &&
+    (reason.relatedInstructions === undefined ||
+      (Array.isArray(reason.relatedInstructions) &&
+        reason.relatedInstructions.every((index) => typeof index === "number"))) &&
+    (reason.code !== "move-already-fulfilled" ||
+      (Array.isArray(reason.relatedInstructions) && reason.relatedInstructions.length === 1))
+  );
+}
+
+const INSTRUCTION_EFFECT_KINDS = new Set<ApplyPatchInstructionEffect["kind"]>([
+  "created",
+  "replaced",
+  "updated",
+  "deleted",
+  "directory-created",
+  "temporary-entry-remains",
+  "source-remains",
+  "symlink-removed",
+  "symlink-moved",
+  "symlink-target-modified",
+]);
+
+function isApplyPatchInstructionEffect(value: unknown): value is ApplyPatchInstructionEffect {
+  if (typeof value !== "object" || value === null) return false;
+  const effect = value as {
+    kind?: unknown;
+    path?: unknown;
+    previousEntry?: unknown;
+    replacementEntry?: unknown;
+    target?: unknown;
+  };
+  if (
+    typeof effect.kind !== "string" ||
+    !INSTRUCTION_EFFECT_KINDS.has(effect.kind as ApplyPatchInstructionEffect["kind"]) ||
+    typeof effect.path !== "string"
+  ) {
+    return false;
+  }
+  if (effect.kind === "replaced") {
+    const isFileEntry = (entry: unknown): boolean => {
+      if (typeof entry !== "object" || entry === null) return false;
+      const candidate = entry as { entryType?: unknown; target?: unknown };
+      return (
+        candidate.entryType === "regular-file" ||
+        (candidate.entryType === "symlink" && typeof candidate.target === "string")
+      );
+    };
+    return isFileEntry(effect.previousEntry) && isFileEntry(effect.replacementEntry);
+  }
+  if (
+    effect.kind === "symlink-removed" ||
+    effect.kind === "symlink-moved" ||
+    effect.kind === "symlink-target-modified"
+  ) {
+    return typeof effect.target === "string";
+  }
+  return true;
+}
+
+const FINAL_PATH_STATES = new Set<ApplyPatchFinalPathState["state"]>([
+  "absent",
+  "regular-file",
+  "symlink",
+  "directory",
+  "other-entry",
+  "unchanged",
+  "requested-content",
+  "different-from-requested-content",
+  "different-from-requested-and-previous-content",
+  "different-from-previous-content",
+  "different-entry",
+  "different-entry-type",
+  "not-verified",
+]);
+
+function isApplyPatchFinalPathState(value: unknown): value is ApplyPatchFinalPathState {
+  if (typeof value !== "object" || value === null) return false;
+  const state = value as { path?: unknown; state?: unknown };
+  return (
+    typeof state.path === "string" &&
+    typeof state.state === "string" &&
+    FINAL_PATH_STATES.has(state.state as ApplyPatchFinalPathState["state"])
+  );
+}
+
+function isApplyPatchInstruction(value: unknown): value is ApplyPatchInstructionDetails {
+  if (typeof value !== "object" || value === null) return false;
+  const instruction = value as {
+    index?: unknown;
+    kind?: unknown;
+    path?: unknown;
+    moveTo?: unknown;
+    status?: unknown;
+    reason?: unknown;
+    effects?: unknown;
+    finalStates?: unknown;
+    matcher?: unknown;
+    changeIndexes?: unknown;
+    error?: unknown;
+  };
+  return (
+    typeof instruction.index === "number" &&
+    (instruction.kind === "add" ||
+      instruction.kind === "delete" ||
+      instruction.kind === "update" ||
+      instruction.kind === "move") &&
+    typeof instruction.path === "string" &&
+    (instruction.moveTo === undefined || typeof instruction.moveTo === "string") &&
+    typeof instruction.status === "string" &&
+    INSTRUCTION_STATUSES.has(instruction.status as ApplyPatchInstructionStatus) &&
+    (instruction.reason === undefined || isApplyPatchInstructionReason(instruction.reason)) &&
+    (instruction.effects === undefined ||
+      (Array.isArray(instruction.effects) &&
+        instruction.effects.every(isApplyPatchInstructionEffect))) &&
+    (instruction.finalStates === undefined ||
+      (Array.isArray(instruction.finalStates) &&
+        instruction.finalStates.every(isApplyPatchFinalPathState))) &&
+    (instruction.matcher === undefined || isFormatterMatchFailure(instruction.matcher)) &&
+    (instruction.changeIndexes === undefined ||
+      (Array.isArray(instruction.changeIndexes) &&
+        instruction.changeIndexes.every((index) => typeof index === "number"))) &&
+    (instruction.error === undefined || typeof instruction.error === "string")
+  );
+}
+
+function isMatcherRange(value: unknown): value is FormatterMatchCandidateRange {
+  if (typeof value !== "object" || value === null) return false;
+  const range = value as { startLine?: unknown; endLine?: unknown };
+  return typeof range.startLine === "number" && typeof range.endLine === "number";
+}
+
+const MATCHER_REASONS = new Set<FormatterMatchFailureDetails["reason"]>([
+  "no-candidate",
+  "no-ordered-mapping",
+  "too-many-candidates",
+  "ambiguous-output",
+  "mapping-limit",
+  "overlapping-edits",
+]);
+
+function isFormatterMatchFailure(value: unknown): value is FormatterMatchFailureDetails {
+  if (typeof value !== "object" || value === null) return false;
+  const failure = value as {
+    reason?: unknown;
+    path?: unknown;
+    groupCount?: unknown;
+    groupIndex?: unknown;
+    chunkCount?: unknown;
+    chunkIndex?: unknown;
+    candidateCount?: unknown;
+    candidates?: unknown;
+    previousGroupIndex?: unknown;
+    previousCandidates?: unknown;
+    reverseOrdered?: unknown;
+    overlapping?: unknown;
+    replacementCandidateCount?: unknown;
+    replacementCandidates?: unknown;
+    oldExcerpt?: unknown;
+  };
+  return (
+    typeof failure.reason === "string" &&
+    MATCHER_REASONS.has(failure.reason as FormatterMatchFailureDetails["reason"]) &&
+    typeof failure.path === "string" &&
+    typeof failure.groupCount === "number" &&
+    (failure.groupIndex === undefined || typeof failure.groupIndex === "number") &&
+    (failure.chunkCount === undefined || typeof failure.chunkCount === "number") &&
+    (failure.chunkIndex === undefined || typeof failure.chunkIndex === "number") &&
+    typeof failure.candidateCount === "number" &&
+    Array.isArray(failure.candidates) &&
+    failure.candidates.every(isMatcherRange) &&
+    (failure.previousGroupIndex === undefined || typeof failure.previousGroupIndex === "number") &&
+    (failure.previousCandidates === undefined ||
+      (Array.isArray(failure.previousCandidates) &&
+        failure.previousCandidates.every(isMatcherRange))) &&
+    (failure.reverseOrdered === undefined || typeof failure.reverseOrdered === "boolean") &&
+    (failure.overlapping === undefined || typeof failure.overlapping === "boolean") &&
+    (failure.replacementCandidateCount === undefined ||
+      typeof failure.replacementCandidateCount === "number") &&
+    (failure.replacementCandidates === undefined ||
+      (Array.isArray(failure.replacementCandidates) &&
+        failure.replacementCandidates.every(isMatcherRange))) &&
+    (failure.oldExcerpt === undefined || typeof failure.oldExcerpt === "string")
+  );
+}
+
+function isApplyPatchFailure(value: unknown): value is ApplyPatchFailureDetails {
+  if (typeof value !== "object" || value === null) return false;
+  const failure = value as {
+    phase?: unknown;
+    message?: unknown;
+    failedInstruction?: unknown;
+    matcher?: unknown;
+  };
+  return (
+    (failure.phase === "input" ||
+      failure.phase === "parse" ||
+      failure.phase === "preflight" ||
+      failure.phase === "execution") &&
+    typeof failure.message === "string" &&
+    (failure.failedInstruction === undefined || typeof failure.failedInstruction === "number") &&
+    (failure.matcher === undefined || isFormatterMatchFailure(failure.matcher))
+  );
+}
+
 export function isApplyPatchDetails(value: unknown): value is ApplyPatchDetails {
   if (typeof value !== "object" || value === null) return false;
   const details = value as {
@@ -144,6 +428,9 @@ export function isApplyPatchDetails(value: unknown): value is ApplyPatchDetails
     added?: unknown;
     modified?: unknown;
     deleted?: unknown;
+    instructions?: unknown;
+    failure?: unknown;
+    error?: unknown;
   };
   return (
     (details.status === "completed" || details.status === "failed") &&
@@ -152,14 +439,22 @@ export function isApplyPatchDetails(value: unknown): value is ApplyPatchDetails
     details.changes.every(isAppliedPatchChange) &&
     isStringArray(details.added) &&
     isStringArray(details.modified) &&
-    isStringArray(details.deleted)
+    isStringArray(details.deleted) &&
+    (details.instructions === undefined ||
+      (Array.isArray(details.instructions) &&
+        details.instructions.every(isApplyPatchInstruction))) &&
+    (details.failure === undefined || isApplyPatchFailure(details.failure)) &&
+    (details.error === undefined || typeof details.error === "string")
   );
 }
 
 function sortedChanges(details: ApplyPatchDetails, cwd: string): AppliedPatchChange[] {
   if (!isApplyPatchDetails(details)) return [];
   return coalesceAppliedPatchChangesForRendering(details.changes, cwd).toSorted((left, right) =>
-    comparePaths(resolve(cwd, left.path), resolve(cwd, right.path)),
+    comparePaths(
+      resolve(cwd, left.kind === "move" ? left.sourcePath : left.path),
+      resolve(cwd, right.kind === "move" ? right.sourcePath : right.path),
+    ),
   );
 }
 
@@ -231,6 +526,7 @@ function changeDiffLines(change: AppliedPatchChange): DiffLine[] {
       .map((content, index) => ({ kind: "add", lineNumber: index + 1, content }));
   }
   if (change.kind === "delete") {
+    if (change.content === undefined) return [];
     return change.content
       .replace(/\n$/, "")
       .split("\n")
@@ -334,6 +630,46 @@ function renderHeader(changes: readonly AppliedPatchChange[], theme: Theme, cwd:
   return `${theme.fg("dim", "• ")}${theme.bold("Edited")} ${changes.length} ${noun} ${countSummary(additions, deletions, theme)}`;
 }
 
+function renderFailedChangeSummary(
+  details: ApplyPatchDetails,
+  changes: readonly AppliedPatchChange[],
+  theme: Theme,
+  cwd: string,
+): string[] {
+  const summary = applyPatchSummaryPaths(details);
+  const paths = [
+    ...summary.added.map((path) => ({ status: "A", path })),
+    ...summary.modified.map((path) => ({ status: "M", path })),
+    ...summary.deleted.map((path) => ({ status: "D", path })),
+  ];
+  if (paths.length === 0) return [];
+  const additions = changes.reduce((total, change) => total + change.additions, 0);
+  const deletions = changes.reduce((total, change) => total + change.deletions, 0);
+  const noun = paths.length === 1 ? "file" : "files";
+  return [
+    `${theme.fg("dim", "• ")}${theme.bold("Changed")} ${paths.length} ${noun} ${countSummary(additions, deletions, theme)}`,
+    ...paths.map(
+      ({ status, path }) => `  ${theme.fg("dim", "└ ")}${status} ${displayPath(path, cwd)}`,
+    ),
+  ];
+}
+
+function failedResultHasChangedFiles(details: ApplyPatchDetails): boolean {
+  const summary = applyPatchSummaryPaths(details);
+  return summary.added.length > 0 || summary.modified.length > 0 || summary.deleted.length > 0;
+}
+
+function failedResultHasNoChanges(details: ApplyPatchDetails): boolean {
+  const hasUnverifiedState = (details.instructions ?? []).some((instruction) =>
+    instruction.finalStates?.some((state) => state.state === "not-verified"),
+  );
+  return (
+    !failedResultHasChangedFiles(details) &&
+    !applyPatchHasOtherFilesystemChanges(details) &&
+    !hasUnverifiedState
+  );
+}
+
 function renderChange(
   change: AppliedPatchChange,
   width: number,
@@ -341,6 +677,7 @@ function renderChange(
   palette: DiffPalette,
 ): string[] {
   const lines = changeDiffLines(change);
+  if (change.kind === "move") return [];
   const languagePath = change.kind === "update" && change.moveTo ? change.moveTo : change.path;
   highlightDiffLines(lines, languagePath);
   const lineNumberWidth = lines.reduce(
@@ -351,6 +688,95 @@ function renderChange(
   return lines.flatMap((line) => renderDiffLine(line, width, lineNumberWidth, theme, palette));
 }
 
+function instructionStatusLabel(status: ApplyPatchInstructionStatus, theme: Theme): string {
+  const label = `[${formatApplyPatchInstructionStatusLabel(status)}]`;
+  switch (status) {
+    case "applied":
+      return theme.fg("success", label);
+    case "failed":
+      return theme.fg("error", label);
+    case "dead":
+    case "no-op":
+    case "not-run":
+    case "planned":
+      return theme.fg("dim", label);
+  }
+}
+
+function instructionLabel(instruction: ApplyPatchInstructionDetails, cwd: string): string {
+  const verb =
+    instruction.kind === "add"
+      ? "Add"
+      : instruction.kind === "delete"
+        ? "Delete"
+        : instruction.kind === "move"
+          ? "Move"
+          : "Update";
+  const path = displayPath(instruction.path, cwd);
+  if (!instruction.moveTo) return `${verb} ${path}`;
+  return instruction.kind === "update"
+    ? `Update & Move ${path} → ${displayPath(instruction.moveTo, cwd)}`
+    : `${verb} ${path} → ${displayPath(instruction.moveTo, cwd)}`;
+}
+
+function instructionChanges(
+  details: ApplyPatchDetails,
+  instructionIndex: number,
+): AppliedPatchChange[] {
+  const instruction = details.instructions?.find(
+    (candidate) => candidate.index === instructionIndex,
+  );
+  return (instruction?.changeIndexes ?? []).flatMap((index) => {
+    const change = details.changes[index];
+    return change && !(instruction?.status === "failed" && change.kind === "move" && !change.exact)
+      ? [change]
+      : [];
+  });
+}
+
+function renderInstructionResults(
+  details: ApplyPatchDetails,
+  theme: Theme,
+  cwd: string,
+  expanded: boolean,
+  width?: number,
+): string[] {
+  const lines: string[] = [];
+  const instructions = details.instructions ?? [];
+  if (!applyPatchNeedsInstructionResults(details, cwd)) return lines;
+  lines.push(theme.bold("Patch instruction results:"));
+  const palette = diffPalette(theme);
+  for (const instruction of instructions) {
+    const feedback = formatApplyPatchInstructionFeedback(instruction, details, cwd);
+    lines.push(
+      `  ${instruction.index}. ${instructionStatusLabel(instruction.status, theme)} ${instructionLabel(instruction, cwd)}${feedback ? ` ${theme.fg("dim", `— ${feedback}`)}` : ""}`,
+    );
+    if (expanded && width !== undefined) {
+      const changes = instructionChanges(details, instruction.index);
+      const inset = Math.min(4, Math.max(0, width - 1));
+      const contentWidth = Math.max(1, width - inset);
+      for (const change of changes) {
+        lines.push(
+          ...renderChange(change, contentWidth, theme, palette).map(
+            (line) => `${" ".repeat(inset)}${line}`,
+          ),
+        );
+      }
+    } else if (expanded) {
+      for (const change of instructionChanges(details, instruction.index)) {
+        lines.push(
+          ...changeDiffLines(change).map((line) => {
+            if (line.separator) return `    ${theme.fg("dim", "⋮")}`;
+            const sign = line.kind === "add" ? "+" : line.kind === "delete" ? "-" : " ";
+            return `    ${sign}${line.lineNumber ?? ""} ${line.content}`;
+          }),
+        );
+      }
+    }
+  }
+  return lines;
+}
+
 export function formatApplyPatchRenderText(
   details: ApplyPatchDetails,
   theme: Theme,
@@ -358,27 +784,48 @@ export function formatApplyPatchRenderText(
 ): string {
   const lines: string[] = [];
   const changes = sortedChanges(details, cwd);
-  if (changes.length > 0) {
+  const showInstructionResults = applyPatchNeedsInstructionResults(details, cwd);
+  if (details.status === "failed") {
+    lines.push(...renderFailedChangeSummary(details, changes, theme, cwd));
+  } else if (changes.length > 0) {
     lines.push(renderHeader(changes, theme, cwd));
     for (const [index, change] of changes.entries()) {
       if (changes.length > 1) {
         lines.push(
-          `  ${theme.fg("dim", "└ ")}${changePath(change, cwd)} ${countSummary(change.additions, change.deletions, theme)}`,
+          `  ${theme.fg("dim", "└ ")}${changeListPath(change, cwd)} ${countSummary(change.additions, change.deletions, theme)}`,
+        );
+      }
+      if (!showInstructionResults) {
+        lines.push(
+          ...changeDiffLines(change).map((line) => {
+            if (line.separator) return `    ${theme.fg("dim", "⋮")}`;
+            const sign = line.kind === "add" ? "+" : line.kind === "delete" ? "-" : " ";
+            return `    ${sign}${line.lineNumber ?? ""} ${line.content}`;
+          }),
         );
       }
-      lines.push(
-        ...changeDiffLines(change).map((line) => {
-          if (line.separator) return `    ${theme.fg("dim", "⋮")}`;
-          const sign = line.kind === "add" ? "+" : line.kind === "delete" ? "-" : " ";
-          return `    ${sign}${line.lineNumber ?? ""} ${line.content}`;
-        }),
-      );
       if (index !== changes.length - 1) lines.push("");
     }
   }
   if (details?.status === "failed") {
     if (lines.length > 0) lines.push("");
     lines.push(theme.bold(theme.fg("error", "✘ Failed to apply patch")));
+    lines.push(
+      ...formatApplyPatchFailureHeading(details).map((line) => `  ${theme.fg("dim", line)}`),
+    );
+    if (failedResultHasNoChanges(details)) lines.push("  No files were changed.");
+    else if (
+      !failedResultHasChangedFiles(details) &&
+      applyPatchHasOtherFilesystemChanges(details)
+    ) {
+      lines.push("  Filesystem changed.");
+    }
+  } else {
+    if (changes.length === 0) lines.push(theme.bold("Success. No files were changed."));
+  }
+  if (showInstructionResults) {
+    if (lines.length > 0) lines.push("");
+    lines.push(...renderInstructionResults(details, theme, cwd, true));
   }
   return lines.join("\n");
 }
@@ -399,20 +846,25 @@ export class ApplyPatchDiffComponent implements Component {
   render(width: number): string[] {
     const effectiveWidth = Math.max(1, width);
     const changes = sortedChanges(this.details, this.cwd);
-    const palette = diffPalette(this.theme);
+    const showInstructionResults = applyPatchNeedsInstructionResults(this.details, this.cwd);
     const lines: string[] = [];
 
-    if (changes.length > 0) {
+    if (this.details.status === "failed") {
+      for (const line of renderFailedChangeSummary(this.details, changes, this.theme, this.cwd)) {
+        lines.push(...wrapTextWithAnsi(line, effectiveWidth));
+      }
+    } else if (changes.length > 0) {
       lines.push(...wrapTextWithAnsi(renderHeader(changes, this.theme, this.cwd), effectiveWidth));
       for (const [index, change] of changes.entries()) {
         if (this.expanded && index > 0) lines.push("");
         if (changes.length > 1) {
-          const header = `  ${this.theme.fg("dim", "└ ")}${changePath(change, this.cwd)} ${countSummary(change.additions, change.deletions, this.theme)}`;
+          const header = `  ${this.theme.fg("dim", "└ ")}${changeListPath(change, this.cwd)} ${countSummary(change.additions, change.deletions, this.theme)}`;
           lines.push(...wrapTextWithAnsi(header, effectiveWidth));
         }
-        if (this.expanded) {
+        if (this.expanded && !showInstructionResults) {
           const inset = Math.min(4, Math.max(0, effectiveWidth - 1));
           const contentWidth = Math.max(1, effectiveWidth - inset);
+          const palette = diffPalette(this.theme);
           lines.push(
             ...renderChange(change, contentWidth, this.theme, palette).map(
               (line) => `${" ".repeat(inset)}${line}`,
@@ -425,12 +877,39 @@ export class ApplyPatchDiffComponent implements Component {
     if (this.details?.status === "failed") {
       if (lines.length > 0) lines.push("");
       lines.push(
-        truncateToWidth(
+        ...wrapTextWithAnsi(
           this.theme.bold(this.theme.fg("error", "✘ Failed to apply patch")),
           effectiveWidth,
-          "",
         ),
       );
+      for (const line of formatApplyPatchFailureHeading(this.details)) {
+        lines.push(...wrapTextWithAnsi(`  ${this.theme.fg("dim", line)}`, effectiveWidth));
+      }
+      if (failedResultHasNoChanges(this.details)) {
+        lines.push(...wrapTextWithAnsi("  No files were changed.", effectiveWidth));
+      } else if (
+        !failedResultHasChangedFiles(this.details) &&
+        applyPatchHasOtherFilesystemChanges(this.details)
+      ) {
+        lines.push(...wrapTextWithAnsi("  Filesystem changed.", effectiveWidth));
+      }
+    } else if (changes.length === 0) {
+      lines.push(
+        ...wrapTextWithAnsi(this.theme.bold("Success. No files were changed."), effectiveWidth),
+      );
+    }
+
+    if (showInstructionResults) {
+      if (lines.length > 0) lines.push("");
+      for (const line of renderInstructionResults(
+        this.details,
+        this.theme,
+        this.cwd,
+        this.expanded,
+        effectiveWidth,
+      )) {
+        lines.push(...wrapTextWithAnsi(line, effectiveWidth));
+      }
     }
 
     return lines;