@cueloop/client 0.1.0-alpha.77 → 0.1.0-alpha.79

package/src/config.ts

@@ -9,6 +9,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obsidian";
+import type { VerdictKind } from "@cueloop/schema";
 import { writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import * as v from "valibot";
@@ -107,6 +108,7 @@ export interface CueloopConfig {
     theme: ThemeName;
     /** How the Changes diff renders when wide: old|new side by side or one stacked column. */
     diffView: DiffViewMode;
+    defaultVerdict: VerdictKind;
     /** Session ids the user has pinned to the top of the sidebar; client-local view state. */
     pins: string[];
     /** The last pane layout a bare launch restores; unset until the user changes one. */
@@ -162,7 +164,6 @@ export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   share: ["S"],
   quit: ["q"],
   walk: ["w"],
-  leader: ["ctrl+g"],
 };
 
 const SkillsSectionSchema = v.object({ path: v.optional(v.string()) });
@@ -212,6 +213,10 @@ const UiSchema = v.object({
   editor: v.fallback(v.optional(v.string()), undefined),
   theme: v.fallback(v.optional(v.string()), undefined),
   diff_view: v.fallback(v.optional(v.picklist(["split", "stacked", "unified"])), undefined),
+  default_verdict: v.fallback(
+    v.optional(v.picklist(["comment", "approve", "request_changes"])),
+    undefined,
+  ),
   pins: v.fallback(v.optional(v.array(v.string())), undefined),
   layout: v.fallback(
     v.optional(
@@ -279,6 +284,7 @@ function applyUi(ui: CueloopConfig["ui"], parsed: v.InferOutput<typeof UiSchema>
   // "unified" is the pre-rename spelling of "stacked"; keep loading it so an upgrade never flips the layout
   if (parsed.diff_view !== undefined)
     ui.diffView = parsed.diff_view === "unified" ? "stacked" : parsed.diff_view;
+  if (parsed.default_verdict !== undefined) ui.defaultVerdict = parsed.default_verdict;
   if (parsed.pins !== undefined) ui.pins = parsed.pins;
   if (parsed.layout !== undefined) {
     ui.layout = {
@@ -358,6 +364,7 @@ export function loadConfig(
       autoClose: "off",
       theme: DEFAULT_THEME_NAME,
       diffView: "split",
+      defaultVerdict: "approve",
       pins: [],
     },
     authors: {},

package/src/diff-fold.ts

@@ -2,7 +2,7 @@
  * Per-file fold state for the diff sheet, applied over the flat diff rows so the
  * cursor, curation, and rendering all read one array. A collapsed file shows only
  * its file band; an expanded file shows its whole contents with the diff woven in
- * (unchanged lines become context rows), matching VSCode's "expand all lines".
+ * (unchanged lines become context rows), an "expand all lines" view.
  */
 
 import type { DiffRow } from "./view-diff";

package/src/diff-intraline.test.ts

@@ -1,5 +1,11 @@
-import { describe, expect, test } from "bun:test";
-import { intralineRunsByRow, wordLevelChanges, type IntralineRun } from "./diff-intraline";
+import { describe, expect, spyOn, test } from "bun:test";
+import * as intraline from "./diff-intraline";
+import {
+  createIntralineResolver,
+  intralineRunsByRow,
+  wordLevelChanges,
+  type IntralineRun,
+} from "./diff-intraline";
 import type { DiffRow } from "./view-diff";
 
 function line(kind: DiffRow["kind"], text: string): DiffRow {
@@ -163,3 +169,70 @@ describe("intralineRunsByRow", () => {
     expect(changedText(runsByRow.get(3)!)).toBe("FOUR");
   });
 });
+
+describe("createIntralineResolver", () => {
+  test("resolves each row to the same runs the eager pass would, on demand", () => {
+    // Arrange - context around two separate change blocks
+    const rows = [
+      line("ctx", "header"),
+      line("del", "one two"),
+      line("add", "one TWO"),
+      line("ctx", "middle"),
+      line("del", "alpha beta"),
+      line("add", "alpha GAMMA"),
+      line("ctx", "footer"),
+    ];
+    const eager = intralineRunsByRow(rows);
+
+    // Act
+    const resolver = createIntralineResolver(rows);
+
+    // Assert - lazy row-by-row output matches the eager map, including undefined for context rows
+    for (let index = 0; index < rows.length; index++) {
+      expect(resolver.runsForRow(index)).toEqual(eager.get(index));
+    }
+  });
+
+  test("a second call for the same row returns the cached runs", () => {
+    const rows = [line("del", "one two"), line("add", "one TWO")];
+    const resolver = createIntralineResolver(rows);
+
+    expect(resolver.runsForRow(0)).toBe(resolver.runsForRow(0));
+  });
+
+  // The performance guard: a virtualized diff must word-diff only the change blocks whose rows are on
+  // screen. This is deterministic (a call count, not a wall-clock), so it fails on any machine if a
+  // future change makes the resolver eager again - the regression the nav-latency benchmark would show.
+  test("word-diffs only the accessed block, not the whole diff", () => {
+    // Arrange - 50 independent change blocks, each a single del/add pair separated by context
+    const rows: DiffRow[] = [];
+
+    for (let block = 0; block < 50; block++) {
+      rows.push(
+        line("ctx", `ctx ${block}`),
+        line("del", `old ${block}`),
+        line("add", `new ${block}`),
+      );
+    }
+    const spy = spyOn(intraline, "wordLevelChanges");
+
+    try {
+      // Act - the eager pass word-diffs every block
+      spy.mockClear();
+      intralineRunsByRow(rows);
+      const eagerCalls = spy.mock.calls.length;
+
+      // Act - the resolver word-diffs only the one block whose row is asked for
+      spy.mockClear();
+      const resolver = createIntralineResolver(rows);
+      resolver.runsForRow(1); // a row in block 0
+      const oneBlockCalls = spy.mock.calls.length;
+
+      // Assert - eager pays for all 50 blocks; lazy pays for one
+      expect(eagerCalls).toBe(50);
+      expect(oneBlockCalls).toBe(1);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});

package/src/diff-intraline.ts

@@ -36,16 +36,16 @@ function stripTrailingNewline(text: string): string {
   return text.replace(/\n$/, "");
 }
 
-/**
- * Char-precise intra-line runs for modified diff rows. Within a change block - a
- * run of deletions immediately followed by additions - lines are aligned to their
- * real counterpart (see alignedPairs) and each matched pair is word-diffed so the
- * removed/added words are marked changed. Rows with no counterpart (pure add, pure
- * delete, or an unmatched line in a shifted block) are omitted, so the caller
- * renders those as a single run. Each row's runs concatenate back to that row's text.
- */
-export function intralineRunsByRow(rows: DiffRow[]): Map<number, IntralineRun[]> {
-  const runsByRow = new Map<number, IntralineRun[]>();
+/** A change block: a run of deletion rows immediately followed by addition rows. */
+interface IntralineBlock {
+  deletionStart: number;
+  additionStart: number;
+  end: number;
+}
+
+/** The change blocks in row order, found in one cheap pass (no word diff yet). */
+function intralineBlocks(rows: DiffRow[]): IntralineBlock[] {
+  const blocks: IntralineBlock[] = [];
   let index = 0;
 
   while (index < rows.length) {
@@ -59,22 +59,91 @@ export function intralineRunsByRow(rows: DiffRow[]): Map<number, IntralineRun[]>
     const additionStart = index;
 
     while (index < rows.length && rows[index]!.kind === "add") index++;
-    const deletionTexts = rows
-      .slice(deletionStart, additionStart)
-      .map((row) => stripTrailingNewline(row.text));
-    const additionTexts = rows
-      .slice(additionStart, index)
-      .map((row) => stripTrailingNewline(row.text));
-
-    for (const [deletionOffset, additionOffset] of alignedPairs(deletionTexts, additionTexts)) {
-      const changes = wordLevelChanges(
-        deletionTexts[deletionOffset]!,
-        additionTexts[additionOffset]!,
-      );
-
-      runsByRow.set(deletionStart + deletionOffset, sideRuns(changes, "removed"));
-      runsByRow.set(additionStart + additionOffset, sideRuns(changes, "added"));
-    }
+    blocks.push({ deletionStart, additionStart, end: index });
+  }
+
+  return blocks;
+}
+
+/** Word-diff one change block into [rowIndex, runs] pairs; unmatched rows get no entry. */
+function blockRunEntries(rows: DiffRow[], block: IntralineBlock): Array<[number, IntralineRun[]]> {
+  const deletionTexts = rows
+    .slice(block.deletionStart, block.additionStart)
+    .map((row) => stripTrailingNewline(row.text));
+  const additionTexts = rows
+    .slice(block.additionStart, block.end)
+    .map((row) => stripTrailingNewline(row.text));
+  const entries: Array<[number, IntralineRun[]]> = [];
+
+  for (const [deletionOffset, additionOffset] of alignedPairs(deletionTexts, additionTexts)) {
+    const changes = wordLevelChanges(
+      deletionTexts[deletionOffset]!,
+      additionTexts[additionOffset]!,
+    );
+
+    entries.push([block.deletionStart + deletionOffset, sideRuns(changes, "removed")]);
+    entries.push([block.additionStart + additionOffset, sideRuns(changes, "added")]);
+  }
+
+  return entries;
+}
+
+/** The change block whose rows cover `rowIndex`, by binary search over the ordered blocks. */
+function blockContaining(blocks: IntralineBlock[], rowIndex: number): number | undefined {
+  let low = 0;
+  let high = blocks.length - 1;
+
+  while (low <= high) {
+    const mid = (low + high) >> 1;
+    const block = blocks[mid]!;
+
+    if (rowIndex < block.deletionStart) high = mid - 1;
+    else if (rowIndex >= block.end) low = mid + 1;
+    else return mid;
+  }
+
+  return undefined;
+}
+
+/** A row's intra-line runs, resolved on demand. */
+export interface IntralineResolver {
+  runsForRow(rowIndex: number): IntralineRun[] | undefined;
+}
+
+/**
+ * Char-precise intra-line runs for modified diff rows, computed lazily. The change blocks are found
+ * up front in one cheap pass; a block is word-diffed only when a row inside it is first asked for,
+ * so a virtualized diff pays for the rows on screen, not for the whole file. Within a change block -
+ * deletions immediately followed by additions - lines align to their real counterpart (alignedPairs)
+ * and each matched pair is word-diffed; unmatched rows get no runs, so the caller renders those whole.
+ */
+export function createIntralineResolver(rows: DiffRow[]): IntralineResolver {
+  const blocks = intralineBlocks(rows);
+  const computed = new Set<number>();
+  const runsByRow = new Map<number, IntralineRun[]>();
+
+  return {
+    runsForRow(rowIndex) {
+      const blockIndex = blockContaining(blocks, rowIndex);
+
+      if (blockIndex === undefined) return undefined;
+      if (!computed.has(blockIndex)) {
+        computed.add(blockIndex);
+        for (const [row, runs] of blockRunEntries(rows, blocks[blockIndex]!))
+          runsByRow.set(row, runs);
+      }
+
+      return runsByRow.get(rowIndex);
+    },
+  };
+}
+
+/** Every modified row's intra-line runs, eagerly. Prefer createIntralineResolver on a hot path. */
+export function intralineRunsByRow(rows: DiffRow[]): Map<number, IntralineRun[]> {
+  const runsByRow = new Map<number, IntralineRun[]>();
+
+  for (const block of intralineBlocks(rows)) {
+    for (const [row, runs] of blockRunEntries(rows, block)) runsByRow.set(row, runs);
   }
 
   return runsByRow;

package/src/intent-dispatch.test.ts

@@ -93,6 +93,7 @@ function baseController(): ReviewController {
     curationItems: mock(() => []),
     restoreCuration: mock(),
     edit: mock(),
+    saveEditedBody: mock(),
     annotate: mock(() => undefined),
     addComment: mock(() => undefined),
     commentOnWorkbench: mock(() => Promise.resolve()),
@@ -108,7 +109,13 @@ function baseController(): ReviewController {
     walkLeave: mock(),
     submit: mock(),
     share: mock(),
+    unshare: mock(),
     setShareAccess: mock(),
+    shareLinks: mock(() => []),
+    createShareLink: mock(),
+    updateShareLink: mock(),
+    deleteShareLink: mock(),
+    copyShareLink: mock(),
     treeRows: mock(() => []),
     goToEntry: mock(),
     branch: mock(),
@@ -136,6 +143,7 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     inboxCursor: 0,
     mode: { type: "normal" },
     session: null,
+    defaultVerdict: "approve",
     focusedAnnotationId: undefined,
     selectedCurationId: undefined,
     railTab: "review",
@@ -155,9 +163,10 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
     setSelectedCurationId: mock(),
     setPulsedAnnotationId: mock(),
     selectCardFromDocument: mock(),
-    runEditorHandOff: mock(),
+    openBodyEditor: mock(),
     openCardEdit: mock(),
     toggleDiffView: mock(),
+    openShareDialog: mock(),
     ...overrides,
   };
 }
@@ -385,7 +394,7 @@ describe("openSubmit", () => {
 });
 
 describe("share", () => {
-  test("opens the public/private choice overlay instead of publishing directly", () => {
+  test("opens the share dialog instead of publishing directly", () => {
     // Arrange
     const deps = makeDeps();
     const dispatch = createIntentDispatch(deps);
@@ -394,7 +403,7 @@ describe("share", () => {
     dispatch({ type: "share" });
 
     // Assert
-    expect(deps.setMode).toHaveBeenCalledWith({ type: "shareChoice", index: 0 });
+    expect(deps.openShareDialog).toHaveBeenCalled();
     expect(deps.controller.share).not.toHaveBeenCalled();
   });
 });

package/src/intent-dispatch.ts

@@ -8,7 +8,7 @@
  */
 
 import type { Dispatch, MutableRefObject, SetStateAction } from "react";
-import { isAddressed, isAgentNote, type Thread, type VerdictKind } from "@cueloop/schema";
+import { isAddressed, type Thread, type VerdictKind } from "@cueloop/schema";
 import { displayText, spanKey, startSpan, type DisplayBlock, type SpanState } from "./view-plan";
 import type { DiffRow } from "./view-diff";
 import type { ReviewController } from "./thread-controller";
@@ -18,7 +18,7 @@ import { quickActionBody, type QuickAction } from "./config";
 import { VERDICTS } from "./components/ConfirmCard";
 
 /** Which pane of the session tree / review the keyboard grammar is aimed at. */
-export type RailTab = "review" | "agent" | "tree";
+export type RailTab = "review" | "tree";
 
 /** The one overlay/mode the TUI is in; every compose/submit/edit flow is a variant. */
 export type Mode =
@@ -40,7 +40,6 @@ export type Mode =
   | { type: "renameThread"; sessionId: string; text: string }
   | { type: "nameSelf"; text: string }
   | { type: "renameSelf"; text: string }
-  | { type: "shareChoice"; index: number }
   | { type: "treePrompt"; ask: TreeAsk; entryId?: string; text: string };
 
 /** What a tree prompt asks for: a branch name, a checkpoint name, or the summary a move back leaves. */
@@ -51,23 +50,6 @@ export function activeSpanState(mode: Mode): SpanState | null {
   return mode.type === "span" || mode.type === "spanActions" ? mode.span : null;
 }
 
-/**
- * Annotations that still count as feedback: agent notes never do, and an
- * annotation a revision already addressed is settled - it neither blocks the
- * verdict default nor re-enters the next feedback document.
- */
-export function reviewerAnnotations(session: Thread) {
-  return session.annotations.filter(
-    (annotation) => !isAgentNote(annotation) && !isAddressed(annotation),
-  );
-}
-
-export function defaultVerdict(session: Thread): VerdictKind {
-  return reviewerAnnotations(session).length || session.workingCopy !== undefined
-    ? "request_changes"
-    : "approve";
-}
-
 /**
  * Everything the reducer reads or writes, supplied fresh each render: the
  * controller and exit hook, the derived reads (view rows, cursor, mode,
@@ -86,6 +68,7 @@ export interface IntentDispatchDeps {
   inboxCursor: number;
   mode: Mode;
   session: Thread | null;
+  defaultVerdict: VerdictKind;
   focusedAnnotationId: string | undefined;
   /** The curation item selected for undo, if any. */
   selectedCurationId: string | undefined;
@@ -115,10 +98,12 @@ export interface IntentDispatchDeps {
   setPulsedAnnotationId: Dispatch<SetStateAction<string | null>>;
 
   selectCardFromDocument: (annotationId: string) => void;
-  runEditorHandOff: () => void;
+  openBodyEditor: () => void;
   openCardEdit: (annotationId: string) => void;
   /** Flip split/stacked diff and persist it (App-owned); split lays out only when wide/zoomed. */
   toggleDiffView: () => void;
+  /** Open the share dialog (App-owned); the dialog owns its own keys and links. */
+  openShareDialog: () => void;
 }
 
 type IntentOfType<Kind extends Intent["type"]> = Extract<Intent, { type: Kind }>;
@@ -383,12 +368,12 @@ function handleOpenSubmit(_intent: IntentOfType<"openSubmit">, deps: IntentDispa
 
   if (!session) return;
   deps.liveInput.current = "";
-  deps.setMode({ type: "submit", verdict: defaultVerdict(session), summary: "" });
+  deps.setMode({ type: "submit", verdict: deps.defaultVerdict, summary: "" });
 }
 
-// share opens the public/private choice overlay; the App owns the choice keys and publishes on pick
+// share opens the share dialog; it owns its own keys, links list, and publish wizard
 function handleShare(_intent: IntentOfType<"share">, deps: IntentDispatchDeps): void {
-  deps.setMode({ type: "shareChoice", index: 0 });
+  deps.openShareDialog();
 }
 
 function handleCut(_intent: IntentOfType<"cut">, deps: IntentDispatchDeps): void {
@@ -450,7 +435,7 @@ function handleRestoreCuration(
 }
 
 function handleEdit(_intent: IntentOfType<"edit">, deps: IntentDispatchDeps): void {
-  deps.runEditorHandOff();
+  deps.openBodyEditor();
 }
 
 function handleEditCard(_intent: IntentOfType<"editCard">, deps: IntentDispatchDeps): void {

package/src/key-bindings.ts

@@ -35,9 +35,6 @@ export type HintMode =
   | "walk"
   | "read-only";
 
-/** Display glyph for the Agent-tab terminal detach chord (ctrl+], App-owned). */
-export const AGENT_DETACH_HINT = "⌃]";
-
 export interface CheatsheetEntry {
   keys: string;
   label: string;
@@ -453,9 +450,6 @@ export class KeyBindings {
       build({ overlay: "none", spanMode: true }, "span", "Selection"),
       build({ overlay: "submit", spanMode: false }, "submit", "Submit"),
       build({ overlay: "walk", spanMode: false }, "walk", "Walk"),
-      // The Agent-tab terminal chord is owned by App (not the rebindable keymap),
-      // so it is listed statically rather than resolved from the active keys.
-      { title: "Agent terminal", entries: [{ keys: AGENT_DETACH_HINT, label: "detach" }] },
     ];
 
     this.context = saved;

package/src/keymap.test.ts

@@ -59,8 +59,8 @@ describe("submit overlay", () => {
   const keyState = state({ overlay: "submit" });
   const table: [string, Intent[]][] = [
     ["escape", [{ type: "closeOverlay" }]],
-    ["return", [{ type: "submitVerdict" }]],
-    ["enter", [{ type: "submitVerdict" }]],
+    ["return", []],
+    ["enter", []],
     ["left", [{ type: "cycleVerdict", direction: -1 }]],
     ["right", [{ type: "cycleVerdict", direction: 1 }]],
     ["j", []],

package/src/keymap.ts

@@ -87,7 +87,6 @@ export interface KeyState {
     | "submit"
     | "confirm"
     | "prompt"
-    | "shareChoice"
     | "spanActions"
     | "completion-prompt"
     | "completion-counting";
@@ -193,7 +192,6 @@ function submitOverlayGrammar(state: KeyState, key: KeyInput): Intent[] {
   const name = key.name;
 
   if (name === "escape") return [{ type: "closeOverlay" }];
-  if (name === "return" || name === "enter") return [{ type: "submitVerdict" }];
   if (name === "left" || name === "right") {
     return [{ type: "cycleVerdict", direction: name === "left" ? -1 : 1 }];
   }

package/src/markdown-editor-syntax-style.ts

@@ -0,0 +1,50 @@
+/**
+ * The native SyntaxStyle for the inline markdown editor: maps each markdown
+ * token group to a theme color and attribute set, and resolves the styleId the
+ * edit buffer needs for `addHighlightByCharRange`. Cached per theme, mirroring
+ * syntaxStyleFor. Syntax punctuation (the "marker" group) is dimmed rather than
+ * hidden, since the editor shows raw source.
+ */
+
+import { SyntaxStyle, type StyleDefinitionInput } from "@opentui/core";
+import { type Theme } from "./theme";
+import { MARKDOWN_HIGHLIGHT_GROUPS, type MarkdownHighlightGroup } from "./markdown-highlight";
+
+/** A markdown SyntaxStyle plus the lookup from token group to its native styleId. */
+export interface MarkdownEditorStyle {
+  style: SyntaxStyle;
+  styleIdFor: (group: MarkdownHighlightGroup) => number;
+}
+
+function markdownGroupStyles(theme: Theme): Record<MarkdownHighlightGroup, StyleDefinitionInput> {
+  return {
+    heading: { bold: true },
+    marker: { fg: theme.textDim },
+    link: { fg: theme.blue, underline: true },
+    code: { fg: theme.textDim },
+  };
+}
+
+const markdownEditorStyleCache = new WeakMap<Theme, MarkdownEditorStyle>();
+
+/** Build (or reuse) the markdown editor's SyntaxStyle for a theme, with a group-to-styleId lookup. */
+export function markdownEditorStyle(theme: Theme): MarkdownEditorStyle {
+  const cached = markdownEditorStyleCache.get(theme);
+
+  if (cached) return cached;
+  const groupStyles = markdownGroupStyles(theme);
+  const style = SyntaxStyle.fromStyles(groupStyles);
+  const styleIds = new Map<MarkdownHighlightGroup, number>();
+
+  for (const group of MARKDOWN_HIGHLIGHT_GROUPS) {
+    styleIds.set(group, style.getStyleId(group) ?? 0);
+  }
+  const entry: MarkdownEditorStyle = {
+    style,
+    styleIdFor: (group) => styleIds.get(group) ?? 0,
+  };
+
+  markdownEditorStyleCache.set(theme, entry);
+
+  return entry;
+}

package/src/markdown-grid.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from "bun:test";
+import {
+  layoutFrontmatterGrid,
+  layoutMarkdownTable,
+  parseFrontmatterRows,
+  parseMarkdownTable,
+} from "./markdown-grid";
+
+/** The plain text of a grid line, segments concatenated. */
+function lineText(line: { text: string }[]): string {
+  return line.map((segment) => segment.text).join("");
+}
+
+describe("parseMarkdownTable", () => {
+  test("reads header cells, alignments, and body rows", () => {
+    const table = parseMarkdownTable("| Name | Size |\n| :--- | ---: |\n| a | 1 |\n| bb | 22 |");
+
+    expect(table.header).toEqual(["Name", "Size"]);
+    expect(table.aligns).toEqual(["left", "right"]);
+    expect(table.rows).toEqual([
+      ["a", "1"],
+      ["bb", "22"],
+    ]);
+  });
+
+  test("center alignment reads from a :---: delimiter", () => {
+    expect(parseMarkdownTable("| a |\n| :---: |\n| x |").aligns).toEqual(["center"]);
+  });
+
+  test("an escaped pipe stays inside its cell instead of splitting the column", () => {
+    const table = parseMarkdownTable("| Name | Note |\n| --- | --- |\n| a | b \\| c |");
+
+    expect(table.rows).toEqual([["a", "b | c"]]);
+  });
+
+  test("a blank cell between border pipes survives the border strip", () => {
+    expect(parseMarkdownTable("|  | b |\n| --- | --- |\n| x | y |").header).toEqual(["", "b"]);
+  });
+});
+
+describe("layoutMarkdownTable", () => {
+  test("bolds the header, rules under it, and right-aligns a numeric column", () => {
+    const lines = layoutMarkdownTable(
+      parseMarkdownTable("| Name | Size |\n| --- | ---: |\n| a | 1 |"),
+    );
+
+    expect(lines[0]![0]!.bold).toBe(true);
+    expect(lineText(lines[0]!)).toBe("Name  Size");
+    expect(lines[1]![0]!.dim).toBe(true);
+    expect(lineText(lines[1]!)).toBe("─".repeat("Name  Size".length));
+    // "a" padded to the "Name" column, "1" right-aligned under "Size"
+    expect(lineText(lines[2]!)).toBe("a" + " ".repeat(8) + "1");
+  });
+});
+
+describe("parseFrontmatterRows", () => {
+  test("splits top-level key: value pairs", () => {
+    expect(parseFrontmatterRows("title: Plan\nowner: me")).toEqual([
+      { key: "title", value: "Plan" },
+      { key: "owner", value: "me" },
+    ]);
+  });
+
+  test("folds an indented continuation into the row above", () => {
+    expect(parseFrontmatterRows("tags:\n  - one\n  - two")).toEqual([
+      { key: "tags", value: "- one\n- two" },
+    ]);
+  });
+});
+
+describe("layoutFrontmatterGrid", () => {
+  test("draws a full border with a bold key and a rule between rows", () => {
+    const lines = layoutFrontmatterGrid(
+      [
+        { key: "title", value: "Plan" },
+        { key: "owner", value: "me" },
+      ],
+      40,
+    );
+
+    expect(lineText(lines[0]!).startsWith("┌")).toBe(true);
+    expect(lineText(lines.at(-1)!).startsWith("└")).toBe(true);
+    // the key cell is bold, the border pieces are dim
+    const firstRow = lines[1]!;
+
+    expect(firstRow.find((segment) => segment.text.includes("title"))!.bold).toBe(true);
+    expect(firstRow[0]!.dim).toBe(true);
+    // a divider separates the two rows
+    expect(lines.some((line) => lineText(line).startsWith("├"))).toBe(true);
+  });
+
+  test("wraps a long value across cell lines, keeping the key on the first", () => {
+    const lines = layoutFrontmatterGrid([{ key: "desc", value: "one two three four five" }], 24);
+    const bodyLines = lines.filter((line) => lineText(line).startsWith("│"));
+
+    expect(bodyLines.length).toBeGreaterThan(1);
+    expect(bodyLines[0]!.some((segment) => segment.text.includes("desc"))).toBe(true);
+    // the continuation line keeps the key column blank
+    expect(bodyLines[1]!.some((segment) => segment.text.includes("desc"))).toBe(false);
+  });
+});