fix Edit/Write diff sheet: git-style patch headers + self-resetting boundary

Every Edit/Write detail crashed the iOS tool-call sheet since the Pierre
cutover (ba4b254): makeUnifiedDiff emitted bare @@ hunks, Pierre's
parsePatchFiles found zero files in them, and PatchDiff's
getSingularPatch threw — then the render boundary inside the RESIDENT
webview stuck on that error for every subsequent open. The working-tree
path never crashed because git-watch synthesizes full git headers.

makeUnifiedDiff now emits the git form (diff --git + --- a/ + +++ b/,
basename only — no /Users/... leak, drives language inference). Git mode
is load-bearing beyond the obvious: non-git mode splits files on
^---\s+\S anywhere, so a deleted '-- comment' line (SQL/Lua/Haskell)
renders as '--- comment' and forges a phantom second file. Hunk-body
lines always carry a +/-/space/\ prefix, so nothing can forge a
diff --git boundary. Also pads both fragment sides with a final newline
to suppress jsdiff's '\ No newline at end of file' markers — they
assert a file-end fact that snippet diffs cannot know.

App side: the hand-rolled RenderBoundary becomes react-error-boundary
with resetKeys=[payload], so a bad payload only poisons its own open.

Bump @pierre/diffs 1.2.7 -> 1.2.10 (worker asset re-synced): upstream
independently fixed the SQL-comment parse in 1.2.9 and 1.2.10 allows
shiki 4. Edge-case sweep (frontmatter ---, editing .patch files, CRLF,
CJK, 2000-line writes, spaced filenames) verified against the new parser.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: yyq1025

packages/app/package.json

@@ -22,7 +22,7 @@
     "@nandorojo/galeria": "^3.0.3",
     "@noble/ed25519": "^3.1.0",
     "@noble/hashes": "^2.2.0",
-    "@pierre/diffs": "^1.2.7",
+    "@pierre/diffs": "^1.2.10",
     "@pierre/theme": "^1.0.3",
     "@shikijs/core": "^4.2.0",
     "@shikijs/langs": "^4.2.0",
@@ -57,6 +57,7 @@
     "marked": "^18.0.5",
     "react": "19.2.3",
     "react-dom": "19.2.3",
+    "react-error-boundary": "^6.1.2",
     "react-native": "0.85.3",
     "react-native-drawer-layout": "^4.2.5",
     "react-native-enriched-markdown": "0.6.0",

packages/app/src/components/transcript/pierre-view.tsx

@@ -9,15 +9,8 @@ import {
   WorkerPoolContextProvider,
 } from "@pierre/diffs/react";
 import type { DOMProps } from "expo/dom";
-import {
-  Component,
-  type ReactNode,
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { ErrorBoundary } from "react-error-boundary";
 import { JETBRAINS_MONO_CSS } from "./jetbrains-mono-font";
 
 /**
@@ -109,33 +102,25 @@ export interface PierreViewProps {
   dom?: DOMProps;
 }
 
-/** Surfaces a render-phase throw instead of a silent blank webview. */
-class RenderBoundary extends Component<
-  { children: ReactNode },
-  { err: string | null }
-> {
-  state = { err: null as string | null };
-  static getDerivedStateFromError(e: unknown) {
-    return { err: e instanceof Error ? e.message : String(e) };
-  }
-  render() {
-    if (this.state.err) {
-      return (
-        <pre
-          style={{
-            color: "#dc2626",
-            whiteSpace: "pre-wrap",
-            wordBreak: "break-word",
-            font: "11px ui-monospace, monospace",
-            padding: 8,
-          }}
-        >
-          {this.state.err}
-        </pre>
-      );
-    }
-    return this.props.children;
-  }
+/** Fallback for the render boundary: surfaces a render-phase throw instead
+ *  of a silent blank webview. Hosted by react-error-boundary's
+ *  <ErrorBoundary> with `resetKeys=[decoded]` — the boundary lives inside
+ *  the RESIDENT webview, so without that reset one bad payload would leave
+ *  every subsequent sheet open stuck on the same error. */
+function RenderErrorFallback({ error }: { error: unknown }) {
+  return (
+    <pre
+      style={{
+        color: "#dc2626",
+        whiteSpace: "pre-wrap",
+        wordBreak: "break-word",
+        font: "11px ui-monospace, monospace",
+        padding: 8,
+      }}
+    >
+      {error instanceof Error ? error.message : String(error)}
+    </pre>
+  );
 }
 
 export default function PierreView({
@@ -202,7 +187,7 @@ export default function PierreView({
   );
 
   // Backstop per content change: if Pierre never commits (e.g. it throws before
-  // first render and RenderBoundary takes over), onPostRender never fires — open
+  // first render and the error boundary takes over), onPostRender never fires — open
   // anyway after a timeout so the sheet can't hang. Empty content is ready now.
   useEffect(() => {
     if (decoded.length === 0) {
@@ -299,7 +284,10 @@ export default function PierreView({
   );
 
   const tree = (
-    <RenderBoundary>
+    <ErrorBoundary
+      FallbackComponent={RenderErrorFallback}
+      resetKeys={[decoded]}
+    >
       {kind === "diff" ? (
         // Single-file diff scrolls the webview document. With WKWebView's auto
         // content-inset disabled (contentInsetAdjustmentBehavior:"never"), pad
@@ -367,7 +355,7 @@ export default function PierreView({
           />
         </div>
       )}
-    </RenderBoundary>
+    </ErrorBoundary>
   );
 
   return (

packages/daemon/src/messages/normalize.test.ts

@@ -198,7 +198,7 @@ describe("normalize", () => {
     expect(item.summary).toBe("foo.ts");
   });
 
-  it("Edit unifiedDiff is hunk-only (`@@ ... @@\\n+/-/space lines`) with no Index/===/---/+++ preamble", () => {
+  it("Edit unifiedDiff carries git-style basename headers (Pierre needs them to detect the file)", () => {
     const out = normalize([
       assistantMsg("a-1", [
         {
@@ -216,11 +216,96 @@ describe("normalize", () => {
     const item = out[0];
     if (item?.type !== "tool_call") throw new Error("expected tool_call");
     if (item.detail.type !== "edit") throw new Error("expected edit detail");
-    expect(item.detail.unifiedDiff.startsWith("@@")).toBe(true);
+    // A hunks-only diff parses as 0 files in Pierre and PatchDiff throws
+    // (the iOS sheet crash of 2026-06-12). The GIT header form is required
+    // (see makeUnifiedDiff docblock); basename keeps /Users/... out of the
+    // rendered header and drives language inference.
+    expect(
+      item.detail.unifiedDiff.startsWith(
+        "diff --git a/foo.ts b/foo.ts\n--- a/foo.ts\n+++ b/foo.ts\n@@",
+      ),
+    ).toBe(true);
     expect(item.detail.unifiedDiff).not.toContain("Index:");
     expect(item.detail.unifiedDiff).not.toContain("===");
-    expect(item.detail.unifiedDiff).not.toContain("--- ");
-    expect(item.detail.unifiedDiff).not.toContain("+++ ");
+    expect(item.detail.unifiedDiff).not.toContain("/abs/");
+  });
+
+  it("deleting a '-- comment' line cannot forge a Pierre file boundary (git headers)", () => {
+    // In Pierre's NON-git mode, files split on `^---\s+\S` anywhere — and a
+    // deleted SQL/Lua/Haskell comment line `-- old` renders as `--- old` in
+    // the hunk body, forging a phantom second file (getSingularPatch throws).
+    // Git mode splits only on `diff --git` lines; hunk-body lines always
+    // carry a +/-/space/\ prefix, so content can never forge that.
+    const out = normalize([
+      assistantMsg("a-1", [
+        {
+          type: "tool_use",
+          id: "tu-1",
+          name: "Edit",
+          input: {
+            file_path: "/abs/query.sql",
+            old_string: "SELECT 1;\n-- old comment\nSELECT 2;",
+            new_string: "SELECT 1;\nSELECT 2;",
+          },
+        },
+      ]),
+    ]);
+    const item = out[0];
+    if (item?.type !== "tool_call") throw new Error("expected tool_call");
+    if (item.detail.type !== "edit") throw new Error("expected edit detail");
+    expect(item.detail.unifiedDiff.startsWith("diff --git ")).toBe(true);
+    // The deleted comment is one hunk line — and must NOT be preceded by a
+    // newline-`---`-space sequence parseable as a file header in git mode.
+    expect(item.detail.unifiedDiff).toContain("\n--- old comment");
+    expect((item.detail.unifiedDiff.match(/^diff --git /gm) ?? []).length).toBe(
+      1,
+    );
+  });
+
+  it("Edit unifiedDiff has no '\\ No newline' markers (snippets say nothing about the file end)", () => {
+    const out = normalize([
+      assistantMsg("a-1", [
+        {
+          type: "tool_use",
+          id: "tu-1",
+          name: "Edit",
+          input: {
+            file_path: "/tmp/probe.md",
+            // Neither side ends with \n — raw jsdiff would emit the marker
+            // for both; the daemon pads a final newline to suppress it.
+            old_string: "hello sidecode",
+            new_string: "hello sidecode world",
+          },
+        },
+      ]),
+    ]);
+    const item = out[0];
+    if (item?.type !== "tool_call") throw new Error("expected tool_call");
+    if (item.detail.type !== "edit") throw new Error("expected edit detail");
+    expect(item.detail.unifiedDiff).toBe(
+      "diff --git a/probe.md b/probe.md\n--- a/probe.md\n+++ b/probe.md\n@@ -1,1 +1,1 @@\n-hello sidecode\n+hello sidecode world",
+    );
+  });
+
+  it("Edit with old === new produces an empty diff (no headers-only shell)", () => {
+    const out = normalize([
+      assistantMsg("a-1", [
+        {
+          type: "tool_use",
+          id: "tu-1",
+          name: "Edit",
+          input: {
+            file_path: "/abs/foo.ts",
+            old_string: "same",
+            new_string: "same",
+          },
+        },
+      ]),
+    ]);
+    const item = out[0];
+    if (item?.type !== "tool_call") throw new Error("expected tool_call");
+    if (item.detail.type !== "edit") throw new Error("expected edit detail");
+    expect(item.detail.unifiedDiff).toBe("");
   });
 
   it("Write produces an all-add diff against empty (we lack prior content)", () => {

packages/daemon/src/messages/tool-detail.ts

@@ -418,38 +418,74 @@ function unknownDetail(name: string, rawInput: unknown): ToolCallDetail {
 }
 
 /**
- * Compose a clean unified-diff string of just `@@...@@` hunks, ready for
- * MarkdownView's auto-detect diff renderer (no fence needed iOS-side).
+ * Compose a git-style unified diff (`diff --git` + `---`/`+++` headers +
+ * `@@` hunks), shaped for Pierre's PatchDiff (iOS tool-call sheet).
+ *
+ * The headers are REQUIRED, not cosmetic: Pierre's `parsePatchFiles`
+ * needs file boundaries — a hunks-only string parses as metadata with
+ * ZERO files, and `getSingularPatch` (inside `<PatchDiff>`) throws "must
+ * contain exactly 1 file diff". This was exactly the iOS sheet crash on
+ * every Edit/Write detail (found 2026-06-12).
+ *
+ * The GIT form specifically (not plain `--- x`/`+++ x` headers) is
+ * load-bearing too: in non-git mode Pierre splits files on `^---\s+\S`
+ * ANYWHERE in the patch, and a deleted content line that itself starts
+ * with `-- ` (SQL/Lua/Haskell comments) renders as `--- foo` in the hunk
+ * body — a phantom second file → same throw. Git mode only splits on
+ * `diff --git` lines, and hunk-body lines always carry a +/-/space/\\
+ * prefix, so no content can forge that boundary. Mirrors git-watch's
+ * synthesizeAddPatch, which is why the working-tree path never crashed.
+ *
+ * Basename (not the absolute path) in all three header lines — drives
+ * shiki language inference by extension and avoids leaking `/Users/...`
+ * into the rendered header. Verified against @pierre/diffs@1.2.7:
+ * `--- a/<name>` / `+++ b/<name>` parse via FILENAME_HEADER_REGEX_GIT
+ * (prefixes stripped, spaces in names fine).
  *
  * We use jsdiff's `structuredPatch` rather than `createPatch` to skip the
- * full-file boilerplate (`Index:`, `===`, `--- file`, `+++ file`) that:
- *   - CommonMark would otherwise mis-parse (`Index: foo\n====` becomes a
- *     setext h1; `+`-prefixed lines become bullet lists)
- *   - is cosmetic noise — MarkdownView's diff render already shows the
- *     filename in the chip / accordion summary; repeating the path in a
- *     `--- /Users/.../file` row above every diff is redundant.
+ * `Index:` / `===` boilerplate Pierre doesn't need.
  *
  * Output for a small Edit:
+ *   diff --git a/foo.ts b/foo.ts
+ *   --- a/foo.ts
+ *   +++ b/foo.ts
  *   @@ -1,3 +1,3 @@
  *   -const x = 1;
  *   +const x = 2;
  *    const y = 3;
  *
- * Empty oldString === newString produces an empty string (no hunks).
+ * Empty oldString === newString produces an empty string (no hunks — the
+ * sheet shows "(no output)" instead of an empty diff shell).
  */
 function makeUnifiedDiff(
   filePath: string,
   oldString: string,
   newString: string,
 ): string {
-  const patch = structuredPatch(filePath, filePath, oldString, newString);
-  return patch.hunks
-    .map(
-      (h) =>
-        `@@ -${h.oldStart},${h.oldLines} +${h.newStart},${h.newLines} @@\n` +
-        h.lines.join("\n"),
-    )
-    .join("\n");
+  // Suppress jsdiff's "\ No newline at end of file" markers by padding a
+  // final newline onto both sides (line content is unchanged). The marker
+  // asserts something about the FILE end, but Edit diffs compare file
+  // FRAGMENTS — a snippet ending without \n says nothing about the file —
+  // so the marker is noise stated as fact (and Pierre renders it as a
+  // dedicated row). Claude's own UIs drop it too. "" stays "" (Write's
+  // create-from-empty diff must keep the empty side truly empty).
+  const a =
+    oldString === "" || oldString.endsWith("\n") ? oldString : `${oldString}\n`;
+  const b =
+    newString === "" || newString.endsWith("\n") ? newString : `${newString}\n`;
+  const patch = structuredPatch(filePath, filePath, a, b);
+  if (patch.hunks.length === 0) return "";
+  const name = basenameOf(filePath);
+  return (
+    `diff --git a/${name} b/${name}\n--- a/${name}\n+++ b/${name}\n` +
+    patch.hunks
+      .map(
+        (h) =>
+          `@@ -${h.oldStart},${h.oldLines} +${h.newStart},${h.newLines} @@\n` +
+          h.lines.join("\n"),
+      )
+      .join("\n")
+  );
 }
 
 /**