Release 1.0.11: fix Edit diff extraction for real ACP wire data

- diffFromContent reads camelCase oldText/newText/_meta (real wire shape);
  snake_case previews still accepted
- isEdit flag follows detail merge semantics: content-less updates with
  explicit isEdit=false no longer clear a diff card's flag
- verified end-to-end against real ~/.grok session updates.jsonl (26 diff
  cards rendered with @@ headers, line numbers, +/- gutters)

Author: 3xian

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinkcode",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Desktop mission control for Grok agents.",
   "type": "module",
   "keywords": [

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "pinkcode"
-version = "1.0.10"
+version = "1.0.11"
 description = "Desktop control plane for Grok Build multi-task observability"
 authors = ["PinkCode"]
 license = "Apache-2.0"

src-tauri/Cargo.toml

@@ -2,7 +2,7 @@
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "PinkCode",
   "mainBinaryName": "PinkCode",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "identifier": "com.pinkcode.app",
   "build": {
     "beforeDevCommand": "npm run dev",

src-tauri/tauri.conf.json

@@ -627,6 +627,51 @@ describe("live timeline reducer", () => {
     expect(state.get("session")?.[0].detail).toContain("@@ -4,3 +4,3 @@");
   });
 
+  it("keeps the diff flag when a content-less update carries explicit isEdit=false", () => {
+    // Real wire shape: tool_call_update with title/status but no content sets
+    // detail=undefined, isEdit=false; it must not clear the card's diff flag.
+    const indexes = createTimelineReducerState();
+    let state = reduceAgentUpdate(
+      new Map(),
+      {
+        handleId: "handle",
+        sessionId: "session",
+        description: {
+          kind: "tool",
+          title: "Edit `src/main.ts`",
+          toolCallId: "call-edit-2",
+          toolBase: "Edit `src/main.ts`",
+          detail: "@@ -4,3 +4,3 @@\n let x = 1;\n-let x = 2;\n+let x = 3;",
+          isEdit: true,
+        },
+        now: 1,
+        nextId: () => "one",
+      },
+      indexes,
+    );
+    state = reduceAgentUpdate(
+      state,
+      {
+        handleId: "handle",
+        sessionId: "session",
+        description: {
+          kind: "tool",
+          title: "Edit `src/main.ts` ✓",
+          toolCallId: "call-edit-2",
+          toolBase: "Edit `src/main.ts`",
+          // No content on this update; formatToolCardParts yields no detail.
+          isEdit: false,
+        },
+        now: 2,
+        nextId: () => "two",
+      },
+      indexes,
+    );
+    const item = state.get("session")?.[0];
+    expect(item?.detail).toContain("@@ -4,3 +4,3 @@");
+    expect(item?.isEdit).toBe(true);
+  });
+
   it("merges shell snapshots without regressing output", () => {
     const indexes = createTimelineReducerState();
     let state = reduceShellUpdate(

src/hooks/liveTimeline.test.ts

@@ -405,10 +405,14 @@ export function reduceAgentUpdate(
         toolBase: merged.baseTitle,
         toolStatus: merged.status,
         toolCallId: description.toolCallId,
-        // `detail` merges as next-wins/fallback-prev; the diff flag must track
-        // the same rule so a status-only update keeps the card flagged while a
-        // completed update with plain detail clears it.
-        isEdit: description.isEdit ?? prev.isEdit,
+        // `detail` merges next-wins/fallback-prev (mergeToolCardParts); the diff
+        // flag follows the same rule: a content-less update (no detail, but an
+        // explicit isEdit=false) must not clear the flag, while an update that
+        // brings plain detail replaces both.
+        isEdit:
+          description.detail != null
+            ? Boolean(description.isEdit)
+            : Boolean(prev.isEdit),
         ts: now,
       };
       next.set(key, list);

src/hooks/liveTimeline.ts

@@ -120,6 +120,28 @@ describe("extractEditDiff", () => {
     expect(diff).toContain(" keep");
   });
 
+  it("accepts the real wire camelCase diff blocks (oldText/newText/_meta)", () => {
+    // Live ACP records serialize Diff blocks as camelCase with snake_case
+    // line numbers inside `_meta` (verified against ~/.grok sessions).
+    const diff = extractEditDiff({
+      kind: "edit",
+      title: "Edit `src/out.txt`",
+      content: [
+        {
+          type: "diff",
+          path: "/abs/src/out.txt",
+          oldText: "line1\nold\n",
+          newText: "line1\nnew\n",
+          _meta: { old_line: 1, new_line: 1 },
+        },
+      ],
+    });
+    expect(diff).toContain("@@ -1,2 +1,2 @@");
+    expect(diff).toContain("-old");
+    expect(diff).toContain("+new");
+    expect(diff).toContain(" line1");
+  });
+
   it("returns undefined for non-edit output", () => {
     expect(
       extractEditDiff({ kind: "Read", rawOutput: { type: "ReadFile" } }),

src/utils/editDiff.test.ts

@@ -282,18 +282,20 @@ function diffFromRawOutput(rawOutput: unknown): string | undefined {
 }
 
 /**
- * Strategy 2: ACP `content` Diff blocks `{ type: "diff", old_text, new_text, meta }`.
- * Full-text fallback (pre-execution previews and the write tool).
+ * Strategy 2: ACP `content` Diff blocks. The wire ships camelCase
+ * `{ type: "diff", path, oldText, newText, _meta: {old_line, new_line} }`;
+ * pre-execution previews and disk logs also carry snake_case `old_text` /
+ * `new_text` / `meta`. Accept both spellings.
  */
 function diffFromContent(content: unknown): string | undefined {
   if (!Array.isArray(content)) return undefined;
   for (const block of content) {
     const b = asRecord(block);
     if (!b || b.type !== "diff") continue;
-    const oldText = str(b.old_text);
-    const newText = str(b.new_text);
+    const oldText = str(b.oldText) || str(b.old_text);
+    const newText = str(b.newText) || str(b.new_text);
     if (!oldText && !newText) continue;
-    const meta = asRecord(b.meta);
+    const meta = asRecord(b._meta) ?? asRecord(b.meta);
     const startLine = num(meta?.new_line) ?? 1;
     const hunks = [
       trimHunk(