@cueloop/schema 0.1.0-alpha.4 → 0.1.0-alpha.40

package/package.json

@@ -1,7 +1,21 @@
 {
   "name": "@cueloop/schema",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.40",
+  "description": "The ReviewSession primitive: types, markdown block model, quote-primary anchors, feedback serialization",
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mmurakaru/cueloop.git",
+    "directory": "packages/schema"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
@@ -9,16 +23,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
   "engines": {
     "bun": ">=1.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mmurakaru/cueloop.git",
-    "directory": "packages/schema"
   }
-}
+}

package/src/anchor.test.ts

@@ -15,80 +15,133 @@ Sessions are written as one JSON document per session. Sessions are written
 atomically.
 `;
 
-function blocksOf(md: string) {
-  return parseBlocks(md);
+function blocksOf(markdown: string) {
+  return parseBlocks(markdown);
 }
 
 describe("anchor cascade", () => {
   test("makeAnchor captures quote + context selectors", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const ctxIdx = blocks.findIndex((b) => b.text.startsWith("Review sessions"));
-    const a = makeAnchor(blocks, ctxIdx, 0, 15); // "Review sessions"
-    expect(a.quote).toBe("Review sessions");
-    expect(a.prefix).toBe("");
-    expect(a.suffix.startsWith(" currently")).toBe(true);
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+
+    // Act
+    const anchor = makeAnchor(blocks, contextBlockIndex, 0, 15); // "Review sessions"
+
+    // Assert
+    expect(anchor.quote).toBe("Review sessions");
+    expect(anchor.prefix).toBe("");
+    expect(anchor.suffix.startsWith(" currently")).toBe(true);
   });
 
   test("resolves at the recorded position when unchanged", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const ctxIdx = blocks.findIndex((b) => b.text.startsWith("Review sessions"));
-    const a = makeAnchor(blocks, ctxIdx, 7, 15); // "sessions"
-    const r = resolveAnchor(a, blocks)!;
-    expect(r.blockIndex).toBe(ctxIdx);
-    expect(r.start).toBe(7);
-    expect(r.approximate).toBe(false);
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+    const anchor = makeAnchor(blocks, contextBlockIndex, 7, 15); // "sessions"
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.blockIndex).toBe(contextBlockIndex);
+    expect(resolved.start).toBe(7);
+    expect(resolved.approximate).toBe(false);
   });
 
   test("survives text changes before the quote (quote search)", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const ctxIdx = blocks.findIndex((b) => b.text.startsWith("Review sessions"));
-    const a = makeAnchor(blocks, ctxIdx, 0, 15);
-    const edited = blocksOf(DOC.replace("Review sessions currently", "PREFIX. Review sessions now"));
-    const r = resolveAnchor(a, edited)!;
-    const idx = edited.findIndex((b) => b.text.includes("Review sessions"));
-    expect(r.blockIndex).toBe(idx);
-    expect(edited[r.blockIndex]!.text.slice(r.start, r.end)).toBe("Review sessions");
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+    const anchor = makeAnchor(blocks, contextBlockIndex, 0, 15);
+    const edited = blocksOf(
+      DOC.replace("Review sessions currently", "PREFIX. Review sessions now"),
+    );
+
+    // Act
+    const resolved = resolveAnchor(anchor, edited)!;
+
+    // Assert
+    const editedBlockIndex = edited.findIndex((block) => block.text.includes("Review sessions"));
+    expect(resolved.blockIndex).toBe(editedBlockIndex);
+    expect(edited[resolved.blockIndex]!.text.slice(resolved.start, resolved.end)).toBe(
+      "Review sessions",
+    );
   });
 
   test("prefix/suffix selectors disambiguate repeated quotes", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const storIdx = blocks.findIndex((b) => b.text.includes("atomically"));
+    const storageBlockIndex = blocks.findIndex((block) => block.text.includes("atomically"));
     // anchor on the SECOND "Sessions are written" occurrence
-    const text = blocks[storIdx]!.text;
+    const text = blocks[storageBlockIndex]!.text;
     const second = text.indexOf("Sessions are written", text.indexOf("Sessions are written") + 1);
-    const a = makeAnchor(blocks, storIdx, second, second + "Sessions are written".length);
-    const r = resolveAnchor(a, blocks)!;
-    expect(r.start).toBe(second);
+    const anchor = makeAnchor(
+      blocks,
+      storageBlockIndex,
+      second,
+      second + "Sessions are written".length,
+    );
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.start).toBe(second);
   });
 
   test("position hint breaks ties when context also repeats", () => {
-    const md = "word word word";
-    const blocks = blocksOf(md);
-    const a = makeAnchor(blocks, 0, 5, 9); // middle "word"
-    const r = resolveAnchor(a, blocks)!;
-    expect(r.start).toBe(5);
+    // Arrange
+    const repeatedWords = "word word word";
+    const blocks = blocksOf(repeatedWords);
+    const anchor = makeAnchor(blocks, 0, 5, 9); // middle "word"
+
+    // Act
+    const resolved = resolveAnchor(anchor, blocks)!;
+
+    // Assert
+    expect(resolved.start).toBe(5);
   });
 
   test("trimmed-quote fallback marks the resolution approximate", () => {
-    const blocks = blocksOf("some text here");
-    const a = { quote: " text ", prefix: "some", suffix: "here", blockIndex: 0, start: 4, end: 10 };
+    // Arrange
+    const anchor = {
+      quote: " text ",
+      prefix: "some",
+      suffix: "here",
+      blockIndex: 0,
+      start: 4,
+      end: 10,
+    };
     const edited = blocksOf("some\ntext\nhere");
     // " text " (with spaces) is gone, "text" survives
-    const r = resolveAnchor(a, edited);
-    expect(r).not.toBeNull();
-    expect(r!.approximate).toBe(true);
+
+    // Act
+    const resolved = resolveAnchor(anchor, edited);
+
+    // Assert
+    expect(resolved).not.toBeNull();
+    expect(resolved!.approximate).toBe(true);
   });
 
   test("orphans when the quote is gone entirely", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
-    const ctxIdx = blocks.findIndex((b) => b.text.startsWith("Review sessions"));
-    const a = makeAnchor(blocks, ctxIdx, 0, 15);
-    const edited = blocksOf(DOC.replace(/Review sessions[^\n]*\n[^\n]*/, "Completely different text."));
-    expect(resolveAnchor(a, edited)).toBeNull();
+    const contextBlockIndex = blocks.findIndex((block) => block.text.startsWith("Review sessions"));
+    const anchor = makeAnchor(blocks, contextBlockIndex, 0, 15);
+    const edited = blocksOf(
+      DOC.replace(/Review sessions[^\n]*\n[^\n]*/, "Completely different text."),
+    );
+
+    // Assert
+    expect(resolveAnchor(anchor, edited)).toBeNull();
   });
 
   test("empty quote never binds", () => {
+    // Arrange
     const blocks = blocksOf(DOC);
+
+    // Assert
     expect(resolveAnchor({ quote: "", prefix: "", suffix: "" }, blocks)).toBeNull();
   });
 });

package/src/anchor.ts

@@ -1,6 +1,6 @@
 /**
- * Anchor resolution: the quote-primary cascade (map #2, #22, verified in the
- * edit-mode deep-dive). Anchors resolve against the current block list:
+ * Anchor resolution: the quote-primary cascade. Anchors resolve against the
+ * current block list:
  *   1. exact quote in a block (prefix/suffix selectors break ties,
  *      position hint breaks remaining ties)
  *   2. trimmed quote
@@ -11,7 +11,8 @@
 import type { Anchor } from "./types";
 import type { Block } from "./markdown";
 
-const CONTEXT = 24;
+/** Characters of surrounding text captured as prefix/suffix selectors. */
+const ANCHOR_CONTEXT_CHARS = 24;
 
 export interface ResolvedAnchor {
   blockIndex: number;
@@ -21,12 +22,17 @@ export interface ResolvedAnchor {
   approximate: boolean;
 }
 
-export function makeAnchor(blocks: Block[], blockIndex: number, start: number, end: number): Anchor {
-  const t = blocks[blockIndex]?.text ?? "";
+export function makeAnchor(
+  blocks: Block[],
+  blockIndex: number,
+  start: number,
+  end: number,
+): Anchor {
+  const blockText = blocks[blockIndex]?.text ?? "";
   return {
-    quote: t.slice(start, end),
-    prefix: t.slice(Math.max(0, start - CONTEXT), start),
-    suffix: t.slice(end, end + CONTEXT),
+    quote: blockText.slice(start, end),
+    prefix: blockText.slice(Math.max(0, start - ANCHOR_CONTEXT_CHARS), start),
+    suffix: blockText.slice(end, end + ANCHOR_CONTEXT_CHARS),
     blockIndex,
     start,
     end,
@@ -38,21 +44,34 @@ interface Candidate extends ResolvedAnchor {
 }
 
 function findCandidates(anchor: Anchor, blocks: Block[], quote: string): Candidate[] {
-  const out: Candidate[] = [];
-  blocks.forEach((b, blockIndex) => {
-    const text = b.text;
-    for (let i = text.indexOf(quote); i !== -1; i = text.indexOf(quote, i + 1)) {
-      const pre = text.slice(Math.max(0, i - CONTEXT), i);
-      const suf = text.slice(i + quote.length, i + quote.length + CONTEXT);
+  const candidates: Candidate[] = [];
+  blocks.forEach((block, blockIndex) => {
+    const text = block.text;
+    for (
+      let matchStart = text.indexOf(quote);
+      matchStart !== -1;
+      matchStart = text.indexOf(quote, matchStart + 1)
+    ) {
+      const prefix = text.slice(Math.max(0, matchStart - ANCHOR_CONTEXT_CHARS), matchStart);
+      const suffix = text.slice(
+        matchStart + quote.length,
+        matchStart + quote.length + ANCHOR_CONTEXT_CHARS,
+      );
       let score = 0;
-      if (pre === anchor.prefix) score += 2;
-      if (suf === anchor.suffix) score += 2;
+      if (prefix === anchor.prefix) score += 2;
+      if (suffix === anchor.suffix) score += 2;
       if (anchor.blockIndex === blockIndex) score += 1;
-      if (anchor.blockIndex === blockIndex && anchor.start === i) score += 1;
-      out.push({ blockIndex, start: i, end: i + quote.length, approximate: false, score });
+      if (anchor.blockIndex === blockIndex && anchor.start === matchStart) score += 1;
+      candidates.push({
+        blockIndex,
+        start: matchStart,
+        end: matchStart + quote.length,
+        approximate: false,
+        score,
+      });
     }
   });
-  return out;
+  return candidates;
 }
 
 /** Resolve an anchor against the current blocks, or null when orphaned. */
@@ -68,7 +87,7 @@ export function resolveAnchor(anchor: Anchor, blocks: Block[]): ResolvedAnchor |
     }
   }
   if (candidates.length === 0) return null;
-  candidates.sort((a, b) => b.score - a.score);
+  candidates.sort((left, right) => right.score - left.score);
   const best = candidates[0]!;
   return { ...best, approximate };
 }

package/src/diff.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { lcsDiff, unifiedDiff, unifiedDiffText, editStats, wordDiff } from "./diff";
+import { lcsDiff, unifiedDiff, unifiedDiffText, editStats } from "./diff";
 
 describe("unifiedDiff", () => {
   test("equal inputs return null, not an empty diff", () => {
@@ -7,12 +7,17 @@ describe("unifiedDiff", () => {
   });
 
   test("produces hunk headers with correct line numbers", () => {
+    // Arrange
     const oldText = ["l1", "l2", "l3", "l4", "l5", "l6", "l7", "l8"].join("\n");
     const newText = ["l1", "l2", "l3", "CHANGED", "l5", "l6", "l7", "l8"].join("\n");
-    const d = unifiedDiff(oldText, newText, 1)!;
-    expect(d[0]!.t).toBe("hunk");
-    expect(d[0]!.text).toBe("@@ -3,3 +3,3 @@");
-    expect(d.map((l) => l.text)).toEqual([
+
+    // Act
+    const diffLines = unifiedDiff(oldText, newText, 1)!;
+
+    // Assert
+    expect(diffLines[0]!.kind).toBe("hunk");
+    expect(diffLines[0]!.text).toBe("@@ -3,3 +3,3 @@");
+    expect(diffLines.map((line) => line.text)).toEqual([
       "@@ -3,3 +3,3 @@",
       " l3",
       "-l4",
@@ -22,29 +27,42 @@ describe("unifiedDiff", () => {
   });
 
   test("distant changes split into separate hunks", () => {
+    // Arrange
     const oldLines = Array.from({ length: 30 }, (_, i) => `line ${i + 1}`);
     const newLines = [...oldLines];
     newLines[1] = "first change";
     newLines[27] = "second change";
-    const d = unifiedDiff(oldLines.join("\n"), newLines.join("\n"), 2)!;
-    expect(d.filter((l) => l.t === "hunk").length).toBe(2);
+
+    // Act
+    const diffLines = unifiedDiff(oldLines.join("\n"), newLines.join("\n"), 2)!;
+
+    // Assert
+    expect(diffLines.filter((line) => line.kind === "hunk").length).toBe(2);
   });
 
   test("applies cleanly: reconstructing new text from old + diff", () => {
+    // Arrange
     const oldText = "keep\ndrop\nkeep2\nkeep3";
     const newText = "keep\nadded\nkeep2\nkeep3\ntail";
-    const d = unifiedDiff(oldText, newText, 50)!;
+
+    // Act
+    const diffLines = unifiedDiff(oldText, newText, 50)!;
+
+    // Assert
     const rebuilt: string[] = [];
-    for (const l of d) {
-      if (l.t === "hunk") continue;
-      if (l.t === "ctx" || l.t === "add") rebuilt.push(l.text.slice(1));
+    for (const line of diffLines) {
+      if (line.kind === "hunk") continue;
+      if (line.kind === "ctx" || line.kind === "add") rebuilt.push(line.text.slice(1));
     }
     expect(rebuilt.join("\n")).toBe(newText);
   });
 
   test("unifiedDiffText carries file headers and path", () => {
-    const t = unifiedDiffText("a", "b", "docs/plan.md")!;
-    expect(t.startsWith("--- a/docs/plan.md\n+++ b/docs/plan.md\n@@")).toBe(true);
+    // Act
+    const diffText = unifiedDiffText("a", "b", "docs/plan.md")!;
+
+    // Assert
+    expect(diffText.startsWith("--- a/docs/plan.md\n+++ b/docs/plan.md\n@@")).toBe(true);
   });
 });
 
@@ -54,19 +72,16 @@ describe("editStats", () => {
   });
 });
 
-describe("wordDiff", () => {
-  test("preserves whitespace tokens and reconstructs both sides", () => {
-    const ops = wordDiff("the quick brown fox", "the slow brown foxes");
-    const oldSide = ops.filter((o) => o.t !== "add").map((o) => o.a).join("");
-    const newSide = ops.filter((o) => o.t !== "del").map((o) => o.b).join("");
-    expect(oldSide).toBe("the quick brown fox");
-    expect(newSide).toBe("the slow brown foxes");
-  });
-});
-
 describe("lcsDiff", () => {
   test("custom equality", () => {
-    const ops = lcsDiff([{ v: 1 }, { v: 2 }], [{ v: 2 }, { v: 3 }], (x, y) => x.v === y.v);
-    expect(ops.map((o) => o.t)).toEqual(["del", "ctx", "add"]);
+    // Act
+    const ops = lcsDiff(
+      [{ v: 1 }, { v: 2 }],
+      [{ v: 2 }, { v: 3 }],
+      (oldItem, newItem) => oldItem.v === newItem.v,
+    );
+
+    // Assert
+    expect(ops.map((op) => op.kind)).toEqual(["del", "ctx", "add"]);
   });
 });

package/src/diff.ts

@@ -1,52 +1,63 @@
 /**
  * Line/token diffing and unified-diff serialization. The working copy
- * serializes as ONE unified diff against the submitted revision (map #2).
+ * serializes as ONE unified diff against the submitted revision.
  * Pure algorithms, no IO.
  */
 
-export type DiffOpType = "ctx" | "del" | "add";
+export type DiffOpKind = "ctx" | "del" | "add";
 
 export interface DiffOp<T = string> {
-  t: DiffOpType;
+  kind: DiffOpKind;
   /** Present for ctx and del. */
-  a?: T;
+  oldValue?: T;
   /** Present for ctx and add. */
-  b?: T;
+  newValue?: T;
 }
 
 /** LCS diff over arrays. O(n*m) - fine for plan-sized documents. */
-export function lcsDiff<T>(a: T[], b: T[], eq: (x: T, y: T) => boolean = (x, y) => x === y): DiffOp<T>[] {
-  const n = a.length;
-  const m = b.length;
-  const dp: number[][] = Array.from({ length: n + 1 }, () => new Array<number>(m + 1).fill(0));
-  for (let i = n - 1; i >= 0; i--) {
-    for (let j = m - 1; j >= 0; j--) {
-      dp[i]![j] = eq(a[i]!, b[j]!) ? dp[i + 1]![j + 1]! + 1 : Math.max(dp[i + 1]![j]!, dp[i]![j + 1]!);
+export function lcsDiff<T>(
+  oldItems: T[],
+  newItems: T[],
+  equals: (oldItem: T, newItem: T) => boolean = (oldItem, newItem) => oldItem === newItem,
+): DiffOp<T>[] {
+  const oldCount = oldItems.length;
+  const newCount = newItems.length;
+  const longestCommon: number[][] = Array.from({ length: oldCount + 1 }, () =>
+    Array.from({ length: newCount + 1 }, () => 0),
+  );
+  for (let oldIndex = oldCount - 1; oldIndex >= 0; oldIndex--) {
+    for (let newIndex = newCount - 1; newIndex >= 0; newIndex--) {
+      longestCommon[oldIndex]![newIndex] = equals(oldItems[oldIndex]!, newItems[newIndex]!)
+        ? longestCommon[oldIndex + 1]![newIndex + 1]! + 1
+        : Math.max(
+            longestCommon[oldIndex + 1]![newIndex]!,
+            longestCommon[oldIndex]![newIndex + 1]!,
+          );
     }
   }
-  const out: DiffOp<T>[] = [];
-  let i = 0;
-  let j = 0;
-  while (i < n && j < m) {
-    if (eq(a[i]!, b[j]!)) {
-      out.push({ t: "ctx", a: a[i], b: b[j] });
-      i++;
-      j++;
-    } else if (dp[i + 1]![j]! >= dp[i]![j + 1]!) {
-      out.push({ t: "del", a: a[i] });
-      i++;
+  const ops: DiffOp<T>[] = [];
+  let oldIndex = 0;
+  let newIndex = 0;
+  while (oldIndex < oldCount && newIndex < newCount) {
+    if (equals(oldItems[oldIndex]!, newItems[newIndex]!)) {
+      ops.push({ kind: "ctx", oldValue: oldItems[oldIndex], newValue: newItems[newIndex] });
+      oldIndex++;
+      newIndex++;
+    } else if (longestCommon[oldIndex + 1]![newIndex]! >= longestCommon[oldIndex]![newIndex + 1]!) {
+      ops.push({ kind: "del", oldValue: oldItems[oldIndex] });
+      oldIndex++;
     } else {
-      out.push({ t: "add", b: b[j] });
-      j++;
+      ops.push({ kind: "add", newValue: newItems[newIndex] });
+      newIndex++;
     }
   }
-  while (i < n) out.push({ t: "del", a: a[i++] });
-  while (j < m) out.push({ t: "add", b: b[j++] });
-  return out;
+  while (oldIndex < oldCount) ops.push({ kind: "del", oldValue: oldItems[oldIndex++] });
+  while (newIndex < newCount) ops.push({ kind: "add", newValue: newItems[newIndex++] });
+  return ops;
 }
 
 export interface UnifiedLine {
-  t: DiffOpType | "hunk";
+  kind: DiffOpKind | "hunk";
   text: string;
 }
 
@@ -56,58 +67,72 @@ export interface UnifiedLine {
  */
 export function unifiedDiff(oldText: string, newText: string, context = 3): UnifiedLine[] | null {
   const ops = lcsDiff(oldText.split("\n"), newText.split("\n"));
-  if (!ops.some((o) => o.t !== "ctx")) return null;
-  let ol = 1;
-  let nl = 1;
-  const rows = ops.map((o) => {
-    const r = {
-      t: o.t,
-      text: (o.t === "add" ? o.b : o.a) ?? "",
-      ol: o.t !== "add" ? ol : null,
-      nl: o.t !== "del" ? nl : null,
+  if (!ops.some((op) => op.kind !== "ctx")) return null;
+  let oldLineNumber = 1;
+  let newLineNumber = 1;
+  const rows = ops.map((op) => {
+    const row = {
+      kind: op.kind,
+      text: (op.kind === "add" ? op.newValue : op.oldValue) ?? "",
+      oldLine: op.kind !== "add" ? oldLineNumber : null,
+      newLine: op.kind !== "del" ? newLineNumber : null,
     };
-    if (o.t !== "add") ol++;
-    if (o.t !== "del") nl++;
-    return r;
+    if (op.kind !== "add") oldLineNumber++;
+    if (op.kind !== "del") newLineNumber++;
+    return row;
   });
-  const keep = new Array<boolean>(rows.length).fill(false);
-  rows.forEach((r, idx) => {
-    if (r.t !== "ctx") {
-      for (let k = Math.max(0, idx - context); k <= Math.min(rows.length - 1, idx + context); k++) keep[k] = true;
+  const keep = Array.from({ length: rows.length }, () => false);
+  rows.forEach((row, rowIndex) => {
+    if (row.kind !== "ctx") {
+      for (
+        let keepIndex = Math.max(0, rowIndex - context);
+        keepIndex <= Math.min(rows.length - 1, rowIndex + context);
+        keepIndex++
+      ) {
+        keep[keepIndex] = true;
+      }
     }
   });
   const hunks: { rows: (typeof rows)[number][] }[] = [];
-  let cur: { rows: (typeof rows)[number][] } | null = null;
-  rows.forEach((r, idx) => {
-    if (!keep[idx]) {
-      cur = null;
+  let openHunk: { rows: (typeof rows)[number][] } | null = null;
+  rows.forEach((row, rowIndex) => {
+    if (!keep[rowIndex]) {
+      openHunk = null;
       return;
     }
-    if (!cur) {
-      cur = { rows: [] };
-      hunks.push(cur);
+    if (!openHunk) {
+      openHunk = { rows: [] };
+      hunks.push(openHunk);
     }
-    cur.rows.push(r);
+    openHunk.rows.push(row);
   });
-  const out: UnifiedLine[] = [];
-  for (const h of hunks) {
-    const oStart = h.rows.find((r) => r.ol !== null)?.ol ?? 1;
-    const nStart = h.rows.find((r) => r.nl !== null)?.nl ?? 1;
-    const oCount = h.rows.filter((r) => r.t !== "add").length;
-    const nCount = h.rows.filter((r) => r.t !== "del").length;
-    out.push({ t: "hunk", text: `@@ -${oStart},${oCount} +${nStart},${nCount} @@` });
-    for (const r of h.rows) {
-      out.push({ t: r.t, text: (r.t === "add" ? "+" : r.t === "del" ? "-" : " ") + r.text });
+  const lines: UnifiedLine[] = [];
+  for (const hunk of hunks) {
+    const oldStart = hunk.rows.find((row) => row.oldLine !== null)?.oldLine ?? 1;
+    const newStart = hunk.rows.find((row) => row.newLine !== null)?.newLine ?? 1;
+    const oldCount = hunk.rows.filter((row) => row.kind !== "add").length;
+    const newCount = hunk.rows.filter((row) => row.kind !== "del").length;
+    lines.push({ kind: "hunk", text: `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@` });
+    for (const row of hunk.rows) {
+      lines.push({
+        kind: row.kind,
+        text: (row.kind === "add" ? "+" : row.kind === "del" ? "-" : " ") + row.text,
+      });
     }
   }
-  return out;
+  return lines;
 }
 
 /** Render a unified diff as text with file headers. */
-export function unifiedDiffText(oldText: string, newText: string, path = "plan.md", context = 3): string | null {
-  const d = unifiedDiff(oldText, newText, context);
-  if (!d) return null;
-  return [`--- a/${path}`, `+++ b/${path}`, ...d.map((l) => l.text)].join("\n");
+export function unifiedDiffText(
+  oldText: string,
+  newText: string,
+  path = "plan.md",
+  context = 3,
+): string | null {
+  const lines = unifiedDiff(oldText, newText, context);
+  if (!lines) return null;
+  return [`--- a/${path}`, `+++ b/${path}`, ...lines.map((line) => line.text)].join("\n");
 }
 
 export interface EditStats {
@@ -116,16 +141,10 @@ export interface EditStats {
 }
 
 export function editStats(oldText: string, newText: string): EditStats {
-  const d = unifiedDiff(oldText, newText, 0);
-  if (!d) return { added: 0, removed: 0 };
+  const lines = unifiedDiff(oldText, newText, 0);
+  if (!lines) return { added: 0, removed: 0 };
   return {
-    added: d.filter((r) => r.t === "add").length,
-    removed: d.filter((r) => r.t === "del").length,
+    added: lines.filter((line) => line.kind === "add").length,
+    removed: lines.filter((line) => line.kind === "del").length,
   };
 }
-
-/** Word-level diff ops for tracked-changes rendering. Whitespace-preserving. */
-export function wordDiff(oldText: string, newText: string): DiffOp[] {
-  const tok = (s: string) => s.split(/(\s+)/).filter((x) => x !== "");
-  return lcsDiff(tok(oldText), tok(newText));
-}