@khanglvm/relay 0.13.7 → 0.13.9

package/README.md

@@ -76,6 +76,7 @@ unchanged; pick whichever surface fits.
 | ASCII architecture art | Mermaid, Graphviz, PlantUML — zoomable, full-screen, even user-editable |
 | Numbers buried in prose | Charts and sortable tables; screenshots and HTML prototypes in a sandbox |
 | "Here's the diff — paste it in your editor" | Side-by-side **diff** blocks, syntax-highlighted **code**, **video** walkthroughs, and **file paths you click to open** in the default app |
+| "Which commits should I pick? Resolve this conflict manually." | `rly git pick` / `rly git cherry-pick` boards and color-coded `git-conflict` resolvers with ours/theirs/custom hunk choices |
 | "Type *done* when finished reviewing" | A Submit button; answers, notes, and inline comments returned as JSON |
 | Feedback = another wall of text | Click any chart point, diagram node, table cell, or sentence to comment — the agent replies and the thread grows on the board |
 
@@ -88,6 +89,8 @@ Node ≥ 18; Chart.js / Mermaid / Graphviz are vendored and lazy-loaded offline.
 | | |
 |---|---|
 | `rly help` | every command at a glance |
+| `rly git pick` / `rly git cherry-pick` | choose commit actions and rank the order directly on a board; add `--code` to cherry-pick with split code review and per-hunk Apply/Skip/Hold |
+| `rly git conflict [files…]` | auto-detect unmerged conflict files, or open specific local paths, and return resolved content in `result.blockEdits` |
 | `rly view <file.md> …` | open a quick read-only board that renders local markdown file(s), data files, or PDFs — library-free; great for plans, READMEs, reports, quotes |
 | `rly install --target <agent>` | write relay's rules into an agent's instruction file — `claude` `codex` `cursor` `copilot` `kiro` `windsurf` `cline` `gemini` `opencode` `droid` `agents`; `--all`, `--scope`, `--print`, `--list` |
 | `rly upgrade` | update the CLI **and** refresh the skill in one step (safe around open boards; `--dry-run`, `--cli-only`, `--skill-only`) |

package/docs/AGENT.md

@@ -12,7 +12,7 @@ walls of monospace text, or can't show it at all (a terminal can't draw a PNG).
 relay renders it in a real browser board. So whenever your output would read better
 than monospace — or is a file/visual the user should look at — show it in relay
 instead of printing it. Fast paths: `rly view file.md` (or `data.csv`), `rly diff`,
-or an `image`/`chart`/`table` block on a board.
+`rly git pick` / `rly git conflict`, or an `image`/`chart`/`table` block on a board.
 
 **Use relay even in plan mode** — for any clarifying or decision question (Claude
 Code / Codex), route it through a relay board, **not** the native
@@ -161,6 +161,25 @@ rly diff --detach                     # working-tree diff (git args pass through
 rly diff --staged --split             #   --staged, HEAD~1, -- path, …); --split = side-by-side
 ```
 
+Pick/cherry-pick commits or resolve conflicts on a board:
+
+```sh
+rly git pick --limit 20               # checklist: pick/cherry-pick/drop + rank order
+rly git cherry-pick main..feature     # checklist: cherry-pick/skip/hold + rank order
+rly git cherry-pick --code main..feature # adds split code review with Apply/Skip/Hold per hunk
+rly git conflict                      # auto-detect unmerged files with conflict markers
+rly git conflict src/app.js           # resolve a specific conflicted file
+```
+
+For authored boards, use a `git-conflict` block. It accepts inline conflict
+marker content or a local file path, auto-detects each hunk, and returns user
+choices plus the full resolved file in `result.blockEdits[blockId]`:
+
+```jsonc
+{ "type": "git-conflict", "file": "src/app.js" }
+{ "type": "git-conflict", "filename": "app.js", "content": "<<<<<<< HEAD\nours\n=======\ntheirs\n>>>>>>> feature\n" }
+```
+
 ## Board spec (JSON)
 
 ```jsonc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khanglvm/relay",
-  "version": "0.13.7",
+  "version": "0.13.9",
   "description": "Question boards with rich blocks (markdown, charts, mermaid, tables, code, diffs, video, sandboxed HTML), clickable local file-links, and element-level annotations for AI coding agents (Claude Code, Codex, …): ask users structured questions, present interactive visuals, collect inline comments, read answers as JSON — in a local browser board OR rendered INLINE inside the Claude & Codex apps as an MCP App (SEP-1865).",
   "keywords": [
     "ai-agents",

package/skills/relay/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: relay
-description: "Collect user decisions & answers — choice, multi, yes-no, text, scale, rank (prioritize), checklist (sign-off), allocate (split a budget), color — and present plans, data, code, or designs with blocks: diagrams (mermaid/graphviz/plantuml), charts, KPI cards, tables (sortable/filterable/CSV, load .csv/.json), code, multi-file diffs, before/after compare, typography, palettes, video, images (click-to-pin), HTML — plus inline element comments and links that open a visual in a modal. Opens a browser board (or inline in Claude/Codex), returns JSON answers/notes/comments/annotations on Submit. Use PROACTIVELY over native ask tools (2+ answers), ASCII/prose for structures/metrics/designs, or printing a file/image/chart/diff the terminal can't render. A dedicated component exists for most content — use the most specific, don't fall back to prose. Triggers: ask the user, decisions, prioritize, sign-off, allocate, plan review, chart, metrics, table, view a CSV, before/after, git diff, markdown file. Skip single yes/no."
+description: "Collect user decisions & answers — choice, multi, yes-no, text, scale, rank, checklist, allocate, color — and present plans, data, code, git diffs/conflicts, designs, charts, tables, diagrams, images, PDFs, videos, HTML, palettes, typography, and file views on a browser or inline MCP board. Returns JSON answers/notes/comments/annotations/blockEdits on Submit. Use PROACTIVELY for 2+ questions, visual review, plans, metrics, tables, diffs, git pick/cherry-pick/conflict decisions, markdown files, or anything the terminal cannot render well. Use the most specific component instead of prose. Skip single yes/no."
 ---
 
 # relay (`rly`)
@@ -46,6 +46,7 @@ at — show it in a relay board instead of printing it.**
 | Gather requirements / plan approval / feedback round | **rly** |
 | Architecture or flow that benefits from a diagram | **rly** (mermaid block) |
 | "Show me the diff" / git diff / code changes / before-after | **rly** (`diff` block — run `git diff`, render it; never dump it in the terminal) |
+| Pick/cherry-pick commits or resolve conflict files | **rly git** (`rly git pick`, `rly git cherry-pick --code`, `rly git conflict`) |
 | A demo, screen recording or walkthrough | **rly** (`video` block) |
 | Point the user at a file to open (log, capture, report) | **rly** (a clickable local file-link in markdown) |
 | Let the user read a markdown file (README, plan, report) | **rly view file.md** (or a `markdown` block with `mdFile`) — never dump the file into the terminal |
@@ -83,6 +84,7 @@ priority call in a `rank` question — not in paragraphs. Unsure which exists? R
 | `plantuml` | UML (sequence / class / component) |
 | `code` | source / config / command output — highlighted, line numbers, hover-a-line to comment |
 | `diff` | code changes — colored unified/split, multi-file (`rly diff` builds the whole board) |
+| `git-conflict` | conflict-marker files — side-by-side ours/theirs/base with hunk choices; returns resolved content in `result.blockEdits[blockId]` |
 | `image` | screenshots / mockups / renders — zoom+pan; `pins:true` → click-to-drop point comments |
 | `compare` | a before/after pair — draggable divider |
 | `video` | a demo / screen recording / walkthrough |
@@ -283,6 +285,10 @@ single/multi question.
 // ^ a unified / `git diff` text rendered as a colored, line-numbered comparison
 //   (no git needed — just paste the diff). "view":"split" = side-by-side; the
 //   viewer also has a live Unified⇄Split toggle. "diffFile" loads it from a file.
+{ "type": "git-conflict", "file": "src/app.js" }
+{ "type": "git-conflict", "filename": "app.js", "content": "<<<<<<< HEAD\nours\n=======\ntheirs\n>>>>>>> feature\n" }
+// ^ conflict markers rendered as a resolver: choose ours/theirs/both/custom per
+//   hunk. User choices + full resolved content return in result.blockEdits[blockId].
 { "type": "video",    "src": "https://youtu.be/dQw4w9WgXcQ", "title": "Demo walkthrough" }
 { "type": "video",    "src": "recordings/demo.mp4", "title": "Local capture", "height": 360 }
 // ^ YouTube/Vimeo URL embeds a player; an http(s) media URL or a local video

package/src/cli.js

@@ -32,7 +32,7 @@ const PKG_NAME = PKG_JSON.name; // e.g. "@khanglvm/relay" — the global package
 const VALUED_FLAGS = new Set([
   'file', 'html', 'html-file', 'title', 'intro', 'timeout', 'port',
   'submit-label', 'height', 'limit', 'target', 'id', 'replies',
-  'on-result', 'notify-cmd', 'idle-grace', 'scope',
+  'on-result', 'notify-cmd', 'idle-grace', 'scope', 'range',
   'host', 'token', 'allow-origin',
 ]);
 
@@ -282,6 +282,148 @@ async function cmdDiff(rest) {
   return runOrDetach(record, args);
 }
 
+function runGit(args, message) {
+  const res = spawnSync('git', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  if (res.error) throw new CliError(`could not run git: ${res.error.message}. Is git installed and is this a repo?`);
+  if (res.status !== 0) {
+    const detail = (res.stderr || res.stdout || '').trim();
+    throw new CliError(`${message}: ${detail || `git ${args.join(' ')} exited ${res.status}`}`, res.status || 1);
+  }
+  return res.stdout || '';
+}
+
+function gitConflictPaths(explicitPaths) {
+  if (explicitPaths.length) return explicitPaths;
+  const out = runGit(['diff', '--name-only', '--diff-filter=U'], 'git conflict detection failed');
+  return out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+}
+
+function gitCommitRows(range, limit) {
+  const n = Math.max(1, Math.min(200, Number.parseInt(limit, 10) || 20));
+  const args = ['log', `-n${n}`, '--date=short', '--pretty=format:%H%x09%h%x09%ad%x09%an%x09%s'];
+  if (range) args.push(range);
+  return runGit(args, 'git log failed')
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      const [sha, short, date, author, ...subjectParts] = line.split('\t');
+      const subject = subjectParts.join('\t');
+      return { sha, short, date, author, subject };
+    })
+    .filter((r) => r.sha && r.short);
+}
+
+function gitCommitDiff(commit) {
+  return runGit([
+    '--no-pager',
+    'show',
+    '--format=',
+    '--patch',
+    '--find-renames',
+    '--find-copies',
+    '--no-ext-diff',
+    commit,
+  ], `git show ${commit} failed`).trimEnd();
+}
+
+async function cmdGit(rest) {
+  const args = parseArgs(rest);
+  const modes = new Set(['pick', 'cherry-pick', 'cherrypick', 'conflict', 'conflicts', 'resolve']);
+  let mode = 'pick';
+  if (args._[0] && modes.has(args._[0])) mode = args._.shift();
+  if (mode === 'cherrypick') mode = 'cherry-pick';
+  if (mode === 'conflicts' || mode === 'resolve') mode = 'conflict';
+
+  const blocks = [];
+  const questions = [];
+  let reviewDiffCount = 0;
+
+  if (mode === 'pick' || mode === 'cherry-pick') {
+    const range = args.range || args._[0] || '';
+    const commits = gitCommitRows(range, args.limit);
+    if (!commits.length) throw new CliError(`git log${range ? ` ${range}` : ''} produced no commits to show.`);
+    const withCode = args.code === true || args.patch === true || args.diff === true;
+    blocks.push({
+      type: 'table',
+      columns: ['short', 'date', 'author', 'subject'],
+      rows: commits.map((c) => ({ short: c.short, date: c.date, author: c.author, subject: c.subject })),
+      sortable: true,
+      filterable: true,
+      exportable: true,
+    });
+    const options = commits.map((c) => ({
+      value: c.sha,
+      label: `${c.short} ${c.subject}`,
+      description: `${c.date} · ${c.author}`,
+    }));
+    questions.push({
+      id: 'commit_actions',
+      type: 'checklist',
+      label: mode === 'cherry-pick' ? 'Choose cherry-pick actions' : 'Choose commit actions',
+      description: 'Set only the commits you want the agent to act on.',
+      options,
+      statuses: mode === 'cherry-pick'
+        ? [{ value: 'cherry-pick', label: 'Cherry-pick', tone: 'ok' }, { value: 'skip', label: 'Skip', tone: 'muted' }, { value: 'hold', label: 'Hold', tone: 'warn' }]
+        : [{ value: 'pick', label: 'Pick', tone: 'ok' }, { value: 'cherry-pick', label: 'Cherry-pick', tone: 'warn' }, { value: 'drop', label: 'Drop', tone: 'bad' }],
+    });
+    if (options.length > 1) {
+      questions.push({
+        id: 'commit_order',
+        type: 'rank',
+        label: mode === 'cherry-pick' ? 'Cherry-pick order' : 'Preferred commit order',
+        description: 'Drag or move commits into the order the agent should apply them.',
+        options,
+      });
+    }
+    if (withCode) {
+      for (const c of commits) {
+        const diff = gitCommitDiff(c.sha);
+        if (!diff.trim()) continue;
+        blocks.push({
+          type: 'diff',
+          title: `${c.short} ${c.subject}`,
+          filename: `${c.short} ${c.subject}`,
+          commit: c.sha,
+          reviewKind: mode,
+          review: true,
+          view: 'split',
+          diff,
+        });
+        reviewDiffCount++;
+      }
+    }
+  }
+
+  const paths = mode === 'conflict' ? gitConflictPaths(args._) : gitConflictPaths([]);
+  for (const p of paths) {
+    let text = '';
+    try { text = fs.readFileSync(path.resolve(p), 'utf8'); } catch { /* normalizeSpec will report unreadable explicit files below */ }
+    if (!text || /<<<<<<<[\s\S]*=======[\s\S]*>>>>>>>/.test(text)) {
+      blocks.push({ type: 'git-conflict', path: p, filename: p });
+    }
+  }
+
+  if (mode === 'conflict' && !blocks.some((b) => b.type === 'git-conflict')) {
+    throw new CliError(args._.length
+      ? 'no conflict markers found in the provided file(s).'
+      : 'no unmerged git files with conflict markers were detected.');
+  }
+
+  const conflictCount = blocks.filter((b) => b.type === 'git-conflict').length;
+  const title = args.title || (mode === 'conflict'
+    ? `Resolve ${conflictCount} git conflict${conflictCount === 1 ? '' : 's'}`
+    : mode === 'cherry-pick' ? 'Cherry-pick commits' : 'Pick commits');
+  const intro = args.intro || (conflictCount
+    ? 'Resolve each conflict on the board. The submitted result includes result.blockEdits with per-hunk choices and a full resolved file preview for every conflict block.'
+    : reviewDiffCount
+      ? 'Review commit code hunks on the board. Apply, skip, or hold each hunk; submit returns commit actions plus diff-review hunk choices as JSON.'
+      : 'Pick commit actions and order on the board. Submit returns the selected actions and rank order as JSON.');
+  const spec = normalizeSpec({ title, intro, blocks, questions, submitLabel: 'Submit git choices' });
+  await assertSpecReady(spec);
+  const record = createBoard(spec);
+  return runOrDetach(record, args);
+}
+
 // `rly view <file.md> [more.md …]` — quick read-only board that renders files
 // with purpose-built blocks (markdown, data tables, PDF). With 2+ files a small
 // filename heading separates them. Sugar over `rly show`.
@@ -907,13 +1049,17 @@ the user should view — put it in relay instead of printing it.**
   diagram/chart/table/code/image/html blocks — never ASCII diagrams or walls of prose.
 - **"Show me the diff / git diff / these changes"** → \`rly diff\` (runs git diff →
   a diff board), or render diff text in a \`diff\` block — never paste a raw diff.
+- **Git pick/cherry-pick/conflict decisions** → \`rly git pick\`, \`rly git cherry-pick\`,
+  or \`rly git conflict [files]\`. Conflict boards can also be authored with a
+  \`git-conflict\` block from inline \`content\` or a local \`file\`/\`path\`; user
+  hunk choices come back in \`result.blockEdits[blockId]\` with resolved content.
 - Point the user at a file with a clickable local path in a markdown block; embed a
   screen recording with a \`video\` block; when answer choices are visual, give each
   option its own visual (\`options[].blocks\`) so the user picks by looking.
 - **There's a purpose-built component for most content — use the MOST SPECIFIC one,
   never plain prose when a block fits.** Blocks: \`table\` (sortable/filterable/CSV,
   load from .csv/.json), \`chart\`, \`kpi\` (stat cards), \`mermaid\`/\`graphviz\`/\`plantuml\`,
-  \`code\`, \`diff\`, \`image\` (+\`pins\`), \`compare\` (before/after), \`video\`, \`pdf\`, \`palette\`,
+  \`code\`, \`diff\`, \`git-conflict\`, \`image\` (+\`pins\`), \`compare\` (before/after), \`video\`, \`pdf\`, \`palette\`,
   \`typography\`, \`html\`. Question types: \`single\`/\`multi\`/\`yesno\`/\`scale\`/\`color\`/
   \`text\`/\`textarea\` plus \`rank\` (prioritize), \`allocate\` (split a budget), \`checklist\`
   (per-item sign-off). For a business user, reach for \`kpi\`+\`chart\`+\`table\` and
@@ -1403,6 +1549,11 @@ USAGE
                                        .pdf streams in an inline PDF viewer)
   rly diff [git args…]                run git diff and show it in a diff board (--split, --detach,
                                       --title; other args pass to git: rly diff --staged | HEAD~1 | -- path)
+  rly git pick [range]                board for choosing pick/cherry-pick/drop actions plus commit order
+  rly git cherry-pick [range]         board for choosing commits and cherry-pick order
+                                      add --code for split code view with per-hunk Apply/Skip/Hold
+  rly git conflict [files…]           board for resolving conflict-marker files; with no files, auto-detects
+                                      unmerged git files and returns resolved content in result.blockEdits
   rly wait <id> [--timeout 3600]      block until board finishes, print result JSON
                                       --while-active [--idle-grace 180]: keep waiting past the deadline
                                         while the user is still viewing/focused & recently active
@@ -1479,6 +1630,8 @@ export async function main(argv) {
         return await cmdView(parseArgs(rest));
       case 'diff':
         return await cmdDiff(rest);
+      case 'git':
+        return await cmdGit(rest);
       case 'reopen':
         return await cmdReopen(parseArgs(rest));
       case 'rescue':

package/src/mcp-ui/board.js

@@ -396,6 +396,12 @@
       },
     };
   }
+  document.addEventListener('relay:block-edit', (e) => {
+    const d = e.detail || {};
+    if (!d.blockId) return;
+    if (d.value === null || d.value === undefined) delete state.blockEdits[d.blockId];
+    else state.blockEdits[d.blockId] = d.value;
+  });
   function renderBlocks(container, blocks, questionId) {
     if (!Array.isArray(blocks) || !blocks.length) return;
     const target = el('div', { class: 'blocks' });

package/src/server.js

@@ -184,9 +184,75 @@ function sanitizeAnnotations(value) {
   return out;
 }
 
+function limitString(v, max) {
+  return typeof v === 'string' ? v.slice(0, max) : '';
+}
+
+function sanitizeConflictResolution(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  if (value.type !== 'git-conflict-resolution') return null;
+  const out = {
+    type: 'git-conflict-resolution',
+    filename: limitString(value.filename, 500),
+    file: limitString(value.file, 1200),
+    resolved: value.resolved === true,
+    resolutions: {},
+    content: limitString(value.content, 512 * 1024),
+  };
+  const raw = value.resolutions && typeof value.resolutions === 'object' && !Array.isArray(value.resolutions)
+    ? value.resolutions
+    : {};
+  let n = 0;
+  for (const id of Object.keys(raw)) {
+    if (n >= 200) break;
+    const r = raw[id];
+    if (!r || typeof r !== 'object' || Array.isArray(r)) continue;
+    const choice = limitString(r.choice, 30);
+    if (!['ours', 'theirs', 'both', 'custom'].includes(choice)) continue;
+    out.resolutions[limitString(id, 80)] = {
+      choice,
+      value: limitString(r.value, 128 * 1024),
+    };
+    n++;
+  }
+  return Object.keys(out.resolutions).length ? out : null;
+}
+
+function sanitizeDiffReview(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  if (value.type !== 'diff-review') return null;
+  const out = {
+    type: 'diff-review',
+    reviewKind: limitString(value.reviewKind, 80),
+    commit: limitString(value.commit, 120),
+    title: limitString(value.title, 500),
+    resolved: value.resolved === true,
+    hunks: {},
+  };
+  const raw = value.hunks && typeof value.hunks === 'object' && !Array.isArray(value.hunks)
+    ? value.hunks
+    : {};
+  let n = 0;
+  for (const id of Object.keys(raw)) {
+    if (n >= 500) break;
+    const h = raw[id];
+    if (!h || typeof h !== 'object' || Array.isArray(h)) continue;
+    const choice = limitString(h.choice, 30);
+    if (!['apply', 'skip', 'hold'].includes(choice)) continue;
+    out.hunks[limitString(id, 80)] = {
+      choice,
+      file: limitString(h.file, 1200),
+      header: limitString(h.header, 500),
+    };
+    n++;
+  }
+  return Object.keys(out.hunks).length ? out : null;
+}
+
 // Validates + sanitizes an incoming blockEdits map (from draft/submit).
-// Keeps only string-keyed entries with string values <= 20000 chars; caps at
-// 50 entries; drops invalid entries. Returns {} when nothing valid is present.
+// String values are editable Mermaid source. Structured git-conflict-resolution
+// and diff-review values carry bounded per-hunk choices. Caps prevent a draft
+// from bloating board storage; invalid entries are dropped.
 function sanitizeBlockEdits(value) {
   if (value === null || typeof value !== 'object' || Array.isArray(value)) return {};
   const out = {};
@@ -195,8 +261,14 @@ function sanitizeBlockEdits(value) {
     if (n >= 50) break;
     if (typeof key !== 'string') continue;
     const v = value[key];
-    if (typeof v !== 'string' || v.length > 20000) continue;
-    out[key] = v;
+    if (typeof v === 'string') {
+      if (v.length > 20000) continue;
+      out[key] = v;
+    } else {
+      const edit = sanitizeConflictResolution(v) || sanitizeDiffReview(v);
+      if (!edit) continue;
+      out[key] = edit;
+    }
     n++;
   }
   return out;

package/src/spec.js

@@ -41,7 +41,7 @@ const HTML_HEIGHT = { min: 100, max: 2400, boardDefault: 400, questionDefault: 3
 
 // Block heights clamp to the same window; defaults vary per block type.
 const BLOCK_HEIGHT = { min: 100, max: 2400 };
-export const BLOCK_TYPES = ['markdown', 'mermaid', 'graphviz', 'plantuml', 'chart', 'table', 'code', 'diff', 'video', 'pdf', 'html', 'image', 'palette', 'kpi', 'typography', 'compare'];
+export const BLOCK_TYPES = ['markdown', 'mermaid', 'graphviz', 'plantuml', 'chart', 'table', 'code', 'diff', 'git-conflict', 'video', 'pdf', 'html', 'image', 'palette', 'kpi', 'typography', 'compare'];
 const CHART_KINDS = ['bar', 'line', 'pie', 'doughnut', 'radar', 'scatter'];
 
 // code/diff blocks may load their text from a local file (like htmlFile). Caps
@@ -127,6 +127,103 @@ function readTextSource(block, inlineKey, fileKey, cwd, where) {
   return '';
 }
 
+function readAnyTextSource(block, inlineKeys, fileKeys, cwd, where, label) {
+  for (const key of inlineKeys) {
+    if (typeof block[key] === 'string' && block[key] !== '') return { text: block[key], sourceKey: key };
+  }
+  for (const key of fileKeys) {
+    if (typeof block[key] === 'string' && block[key].trim()) {
+      const p = path.resolve(cwd, block[key]);
+      let buf;
+      try {
+        buf = fs.readFileSync(p);
+      } catch {
+        throw new CliError(`${where}: cannot read ${label} "${block[key]}" (resolved: ${p})`);
+      }
+      if (buf.length > TEXT_FILE_MAX_BYTES) {
+        throw new CliError(`${where}: ${label} "${block[key]}" is ${(buf.length / 1024).toFixed(0)}KB — max ${TEXT_FILE_MAX_BYTES / 1024}KB.`);
+      }
+      return { text: buf.toString('utf8'), sourceKey: key, file: p };
+    }
+  }
+  return { text: '', sourceKey: '' };
+}
+
+function joinConflictLines(lines) {
+  return lines.join('\n');
+}
+
+function parseGitConflictContent(content, where) {
+  const lines = String(content || '').replace(/\r\n?/g, '\n').split('\n');
+  const parts = [];
+  const conflicts = [];
+  let textBuf = [];
+  const flushText = () => {
+    if (!textBuf.length) return;
+    parts.push({ type: 'text', text: joinConflictLines(textBuf) });
+    textBuf = [];
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const start = lines[i].match(/^<<<<<<<(?:\s+(.*))?$/);
+    if (!start) {
+      textBuf.push(lines[i]);
+      continue;
+    }
+
+    flushText();
+    const oursLabel = start[1] || 'ours';
+    const ours = [];
+    const base = [];
+    const theirs = [];
+    let baseLabel = '';
+    let theirsLabel = 'theirs';
+    let section = 'ours';
+    let closed = false;
+
+    for (i = i + 1; i < lines.length; i++) {
+      const line = lines[i];
+      const baseStart = line.match(/^\|\|\|\|\|\|\|(?:\s+(.*))?$/);
+      if (baseStart && section === 'ours') {
+        baseLabel = baseStart[1] || 'base';
+        section = 'base';
+        continue;
+      }
+      if (/^=======$/.test(line) && (section === 'ours' || section === 'base')) {
+        section = 'theirs';
+        continue;
+      }
+      const end = line.match(/^>>>>>>>(?:\s+(.*))?$/);
+      if (end && section === 'theirs') {
+        theirsLabel = end[1] || theirsLabel;
+        closed = true;
+        break;
+      }
+      if (section === 'ours') ours.push(line);
+      else if (section === 'base') base.push(line);
+      else theirs.push(line);
+    }
+
+    if (!closed) {
+      throw new CliError(`${where}: conflict marker starting at line ${conflicts.length + 1} is missing a matching >>>>>>> marker.`);
+    }
+    const id = `c${conflicts.length + 1}`;
+    conflicts.push({
+      id,
+      oursLabel,
+      theirsLabel,
+      ...(baseLabel ? { baseLabel } : {}),
+      ours: joinConflictLines(ours),
+      theirs: joinConflictLines(theirs),
+      ...(baseLabel ? { base: joinConflictLines(base) } : {}),
+    });
+    parts.push({ type: 'conflict', conflictId: id });
+  }
+
+  flushText();
+  return { conflicts, parts };
+}
+
 // Resolve an image source (shared by the `image` and `compare` blocks): an
 // http(s)/data URL passes through; a local file is read + embedded as a data
 // URI (capped) so the board stays self-contained offline.
@@ -395,12 +492,41 @@ function normalizeBlock(rawBlock, id, cwd, where) {
     const block = { id, type: 'diff', diff };
     if (rawBlock.lang !== undefined) block.lang = asStr(rawBlock.lang);
     if (rawBlock.filename !== undefined) block.filename = asStr(rawBlock.filename);
+    if (rawBlock.title !== undefined) block.title = asStr(rawBlock.title);
+    if (rawBlock.review === true) block.review = true;
+    if (rawBlock.reviewKind !== undefined) block.reviewKind = asStr(rawBlock.reviewKind);
+    if (rawBlock.commit !== undefined) block.commit = asStr(rawBlock.commit);
     const view = asStr(rawBlock.view).trim().toLowerCase();
     if (view === 'split' || view === 'unified') block.view = view;
     if (hasHeight) block.height = clampInt(rawBlock.height, BLOCK_HEIGHT.min, BLOCK_HEIGHT.max, undefined);
     return block;
   }
 
+  if (type === 'git-conflict') {
+    const src = readAnyTextSource(rawBlock, ['content', 'text'], ['file', 'path', 'src'], cwd, where, 'git conflict file');
+    if (!src.text.trim()) {
+      throw new CliError(`${where}: git-conflict block needs inline "content"/"text" or a readable local "file"/"path".`);
+    }
+    const parsed = parseGitConflictContent(src.text, where);
+    if (!parsed.conflicts.length) {
+      throw new CliError(`${where}: no git conflict markers found (expected <<<<<<<, =======, >>>>>>>).`);
+    }
+    const filename = asStr(rawBlock.filename ?? rawBlock.name ?? (src.file ? path.basename(src.file) : '')).trim();
+    const block = {
+      id,
+      type: 'git-conflict',
+      filename,
+      conflicts: parsed.conflicts,
+      parts: parsed.parts,
+    };
+    const lang = asStr(rawBlock.lang).trim() || (filename ? path.extname(filename).slice(1).toLowerCase() : '');
+    if (lang) block.lang = lang;
+    if (rawBlock.title !== undefined) block.title = asStr(rawBlock.title);
+    if (src.file) block.file = src.file;
+    if (hasHeight) block.height = clampInt(rawBlock.height, BLOCK_HEIGHT.min, BLOCK_HEIGHT.max, undefined);
+    return block;
+  }
+
   if (type === 'video') {
     const src = asStr(rawBlock.src ?? rawBlock.file ?? rawBlock.url).trim();
     if (!src) throw new CliError(`${where}: video block needs a "src" (YouTube/Vimeo URL, http(s) media URL, or local file path).`);
@@ -905,14 +1031,21 @@ const BLOCK_SCHEMA = {
       mdFile: { type: 'string', description: 'markdown: path to a local .md file to load + render instead of inline "md" (e.g. view a README/plan/report). Resolved against the CWD. Quick view of one or more files: `rly view a.md b.md`.' },
       code: { type: 'string', description: 'mermaid: diagram source (e.g. "graph TD; A-->B"); plantuml: the @startuml…@enduml source; code: the source to display (syntax-highlighted with line numbers).' },
       codeFile: { type: 'string', description: 'code: path to a local source file to load + display instead of inline "code". Resolved against the CWD; lang defaults from the file extension.' },
-      filename: { type: 'string', description: 'code/diff: optional file name/path shown as a header label above the block.' },
+      filename: { type: 'string', description: 'code/diff/git-conflict: optional file name/path shown as a header label above the block.' },
       editable: { type: 'boolean', description: 'mermaid: when true, render an "Edit diagram" toggle so the user can edit the diagram source live. The edited source is returned in result.blockEdits[<blockId>].' },
       dot: { type: 'string', description: 'graphviz: DOT source (e.g. "digraph { a -> b }"). Rendered offline via vendored Viz.js; nodes and edges are individually commentable.' },
       server: { type: 'string', description: 'plantuml: PlantUML server base URL (http(s)). Defaults to https://www.plantuml.com/plantuml. Diagrams render via this server (needs network).' },
-      lang: { type: 'string', description: 'code/diff block: language hint for syntax highlighting (js, ts, py, go, rust, java, c, cpp, csharp, ruby, php, swift, kotlin, sql, yaml, json, sh, css, html, …).' },
+      lang: { type: 'string', description: 'code/diff/git-conflict block: language hint for syntax highlighting (js, ts, py, go, rust, java, c, cpp, csharp, ruby, php, swift, kotlin, sql, yaml, json, sh, css, html, …).' },
       diff: { type: 'string', description: 'diff: a unified diff (git diff / diff -u output) — rendered as a colored, line-numbered comparison with +added / −removed / context rows and file/hunk headers. No git needed; just write/paste the diff text.' },
       diffFile: { type: 'string', description: 'diff: path to a local file containing a unified diff (alternative to "diff"). Resolved against the CWD.' },
       view: { type: 'string', enum: ['unified', 'split'], description: 'diff: initial layout — "unified" (default, one column) or "split" (side-by-side old vs new). The viewer also has a live toggle either way.' },
+      review: { type: 'boolean', description: 'diff: when true, render per-hunk Apply / Skip / Hold controls and return choices in result.blockEdits[blockId] as {type:"diff-review", hunks:{...}}. Used by `rly git cherry-pick --code`.' },
+      reviewKind: { type: 'string', description: 'diff review: optional label for the review workflow, such as "cherry-pick" or "pick".' },
+      commit: { type: 'string', description: 'diff review: optional commit SHA associated with this diff.' },
+      content: { type: 'string', description: 'git-conflict: inline file content containing conflict markers (<<<<<<< / ======= / >>>>>>>). The board auto-detects each hunk and returns resolutions in result.blockEdits[blockId].' },
+      text: { type: 'string', description: 'git-conflict: alias for inline "content".' },
+      file: { type: 'string', description: 'git-conflict: local conflicted file path to load, parse, and resolve. Resolved against the CWD.' },
+      path: { type: 'string', description: 'git-conflict: alias for local conflicted file path.' },
       config: { type: 'object', description: 'chart: a full Chart.js config object.' },
       kind: { type: 'string', enum: CHART_KINDS, description: 'chart shorthand: chart kind (alternative to "config").' },
       labels: { type: 'array', description: 'chart shorthand: x-axis / category labels.' },
@@ -1053,7 +1186,7 @@ export const SPEC_SCHEMA = {
       type: 'object',
       readOnly: true,
       description:
-        'Returned in the result (not part of the input spec). A map blockId→edited mermaid source for any editable mermaid block the user changed. null when the user made no edits. Read result.blockEdits[<blockId>] for the user\'s edited diagram source.',
+        'Returned in the result (not part of the input spec). A map blockId→edited block payload. Editable mermaid blocks return edited source strings. git-conflict blocks return {type:"git-conflict-resolution", resolutions, content, resolved, filename, file}. diff review blocks return {type:"diff-review", hunks, resolved, commit}. null when the user made no edits.',
     },
   },
   anyOf: [{ required: ['questions'] }, { required: ['blocks'] }, { required: ['html'] }, { required: ['htmlFile'] }],

package/src/ui/app.js

@@ -532,6 +532,12 @@
     scheduleSave();
   }
 
+  document.addEventListener('relay:block-edit', (e) => {
+    const d = e.detail || {};
+    if (!d.blockId) return;
+    onBlockEdit(d.blockId, d.value);
+  });
+
   // ctx for RelayBlocks.render — theme()/htmlSrc per the shared contract, plus
   // the editable-mermaid plumbing (edits map + onBlockEdit callback).
   function blockCtx(questionId) {

package/src/ui/blocks.css

@@ -260,6 +260,163 @@
 }
 .diff-file-chip:hover { color: var(--accent); border-color: var(--accent); }
 
+/* diff review: cherry-pick/apply hunk choices on top of the diff renderer */
+.diff-review-head {
+  align-items: flex-start;
+}
+.diff-review-topactions {
+  display: flex; flex-wrap: wrap; justify-content: flex-end; align-items: center; gap: 6px;
+}
+.diff-review-status {
+  flex: none; border: 1px solid rgba(185, 145, 63, 0.34);
+  background: rgba(185, 145, 63, 0.12); color: var(--warn);
+  border-radius: 999px; padding: 3px 8px; font-size: 0.72rem; font-weight: 760;
+}
+.diff-review-status.is-complete {
+  border-color: rgba(77, 138, 102, 0.42);
+  background: rgba(77, 138, 102, 0.14); color: var(--ok);
+}
+.diff-review-btn {
+  flex: none; cursor: pointer; font: inherit; font-size: 0.72rem; font-weight: 700;
+  color: var(--fg-2); background: var(--card);
+  border: 1px solid var(--border); border-radius: 6px; padding: 2px 8px;
+  transition: color 150ms var(--ease), border-color 150ms var(--ease), background 150ms var(--ease);
+}
+.diff-review-btn:hover {
+  color: var(--accent); border-color: var(--accent);
+}
+.diff-review-choice.sel {
+  color: var(--accent); border-color: var(--accent); background: var(--accent-soft);
+}
+.diff-review-list {
+  border: 1px solid var(--border); border-radius: 0 0 10px 10px;
+  overflow: hidden; background: var(--bg-sunken);
+}
+.diff-review-hunk + .diff-review-hunk {
+  border-top: 1px solid var(--border);
+}
+.diff-review-hunkbar {
+  display: flex; justify-content: space-between; align-items: center; gap: 10px;
+  padding: 6px 8px 6px 12px; background: var(--card); border-bottom: 1px solid var(--border);
+}
+.diff-review-hunkmeta {
+  min-width: 0; display: flex; flex-wrap: wrap; align-items: center; gap: 8px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+}
+.diff-review-file {
+  max-width: 360px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  color: var(--fg-2); font-size: 0.76rem; font-weight: 760;
+}
+.diff-review-header {
+  color: var(--muted); font-size: 0.72rem;
+}
+.diff-review-actions {
+  flex: none; display: flex; flex-wrap: wrap; justify-content: flex-end; gap: 6px;
+}
+.diff-review-hunk .blk-difftable {
+  min-width: 760px;
+}
+@media (max-width: 720px) {
+  .diff-review-head, .diff-review-hunkbar { flex-direction: column; align-items: flex-start; }
+  .diff-review-topactions, .diff-review-actions { justify-content: flex-start; }
+  .diff-review-file { max-width: 100%; }
+}
+
+/* ---------- git conflict resolver ---------- */
+.gitconf {
+  border: 1px solid var(--border); border-radius: 10px; overflow: hidden;
+  background: var(--card);
+}
+.gitconf-head {
+  display: flex; justify-content: space-between; gap: 12px; align-items: flex-start;
+  padding: 11px 12px; border-bottom: 1px solid var(--border);
+  background: linear-gradient(180deg, var(--card), var(--bg-sunken));
+}
+.gitconf-title {
+  font-weight: 750; color: var(--fg);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+}
+.gitconf-file {
+  margin-top: 3px; color: var(--muted); font-size: 0.76rem;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  overflow-wrap: anywhere;
+}
+.gitconf-status {
+  flex: none; border: 1px solid rgba(188, 68, 52, 0.35);
+  background: rgba(188, 68, 52, 0.12); color: var(--danger);
+  border-radius: 999px; padding: 3px 9px; font-size: 0.74rem; font-weight: 700;
+}
+.gitconf-status.is-complete {
+  border-color: rgba(77, 138, 102, 0.42);
+  background: rgba(77, 138, 102, 0.14); color: var(--ok);
+}
+.gitconf-card { padding: 12px; border-bottom: 1px solid var(--border); }
+.gitconf-cardhead {
+  display: flex; align-items: center; justify-content: space-between; gap: 10px;
+  margin-bottom: 9px;
+}
+.gitconf-badge {
+  font-size: 0.74rem; font-weight: 760; letter-spacing: 0;
+  color: var(--fg); background: var(--bg-sunken); border: 1px solid var(--border);
+  border-radius: 999px; padding: 3px 8px;
+}
+.gitconf-hint { color: var(--muted); font-size: 0.76rem; }
+.gitconf-choicebar { display: flex; flex-wrap: wrap; gap: 7px; margin-bottom: 10px; }
+.gitconf-choice {
+  cursor: pointer; font: inherit; font-size: 0.76rem; font-weight: 700;
+  color: var(--fg-2); background: var(--bg-sunken);
+  border: 1px solid var(--border); border-radius: 7px; padding: 5px 9px;
+}
+.gitconf-choice:hover { border-color: var(--accent); color: var(--accent); }
+.gitconf-choice.sel {
+  border-color: var(--accent); color: var(--accent);
+  background: var(--accent-soft);
+}
+.gitconf-sides {
+  display: grid; grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
+  gap: 8px; align-items: stretch;
+}
+.gitconf-side {
+  min-width: 0; border: 1px solid var(--border); border-radius: 8px;
+  overflow: hidden; background: var(--bg-sunken);
+}
+.gitconf-ours { border-color: rgba(188, 68, 52, 0.28); background: rgba(188, 68, 52, 0.06); }
+.gitconf-base { border-color: rgba(185, 145, 63, 0.32); background: rgba(185, 145, 63, 0.08); }
+.gitconf-theirs { border-color: rgba(77, 138, 102, 0.3); background: rgba(77, 138, 102, 0.07); }
+.gitconf-label {
+  padding: 5px 8px; border-bottom: 1px solid var(--border);
+  color: var(--fg-2); font-size: 0.72rem; font-weight: 760;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  overflow-wrap: anywhere;
+}
+.gitconf-pre, .gitconf-resolved {
+  margin: 0; padding: 9px 10px; overflow: auto;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 0.8rem; line-height: 1.45; color: var(--fg);
+  white-space: pre;
+}
+.gitconf-pre code, .gitconf-resolved code { font: inherit; background: none; color: inherit; }
+.gitconf-custom {
+  display: none; width: 100%; box-sizing: border-box; margin-top: 10px;
+  border: 1px solid var(--border-strong); border-radius: 8px;
+  background: var(--bg); color: var(--fg); padding: 9px 10px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 0.82rem; line-height: 1.45; resize: vertical;
+}
+.gitconf-body.is-custom .gitconf-custom { display: block; }
+.gitconf-preview { padding: 10px 12px; background: var(--bg-sunken); }
+.gitconf-preview summary {
+  cursor: pointer; color: var(--fg-2); font-weight: 720; font-size: 0.82rem;
+}
+.gitconf-resolved {
+  margin-top: 8px; border: 1px solid var(--border); border-radius: 8px;
+  background: var(--card); max-height: 340px;
+}
+@media (max-width: 640px) {
+  .gitconf-head, .gitconf-cardhead { flex-direction: column; align-items: flex-start; }
+  .gitconf-sides { grid-template-columns: 1fr; }
+}
+
 /* clickable line-number gutter: hover a number to comment on that line */
 .blk-gutter-c { padding: 14px 0; }
 .blk-gutter-c .blk-gutterline {

package/src/ui/blocks.js

@@ -582,8 +582,159 @@
   // Per-file header lines are redundant once we render a filename header bar.
   const DIFF_NOISE = /^(diff --git |index |--- |\+\+\+ )/;
 
+  function buildDiffReviewHunks(files, block) {
+    const hunks = [];
+    files.forEach((f) => {
+      const name = f.name || (files.length === 1 ? (block.filename || '') : '') || 'file';
+      let rows = parseDiff(f.text);
+      if (name) rows = rows.filter((r) => !(r.kind === 'meta' && DIFF_NOISE.test(r.text)));
+      let current = null;
+      const push = () => {
+        if (!current) return;
+        const hasChange = current.rows.some((r) => r.kind === 'add' || r.kind === 'del');
+        if (hasChange) hunks.push(current);
+        current = null;
+      };
+      rows.forEach((r) => {
+        if (r.kind === 'hunk') {
+          push();
+          current = { id: 'h' + (hunks.length + 1), file: name, header: r.text, rows: [r] };
+        } else if (current) {
+          current.rows.push(r);
+        } else if (r.kind === 'add' || r.kind === 'del' || r.kind === 'ctx') {
+          current = { id: 'h' + (hunks.length + 1), file: name, header: 'Change', rows: [r] };
+        }
+      });
+      push();
+    });
+    return hunks;
+  }
+
+  function renderDiffReview(block, ctx, blockId, files) {
+    const hunks = buildDiffReviewHunks(files, block);
+    let view = block.view === 'split' ? 'split' : 'unified';
+    const prior = ctx && ctx.edits && ctx.edits[blockId] && typeof ctx.edits[blockId] === 'object'
+      ? ctx.edits[blockId]
+      : {};
+    const choices = prior.hunks && typeof prior.hunks === 'object' ? { ...prior.hunks } : {};
+    const buttonsByHunk = new Map();
+    const wrap = el('div', { class: 'blk-codewrap blk-diffwrap diff-review' });
+    const status = el('span', { class: 'diff-review-status' }, '');
+    const list = el('div', { class: 'diff-review-list' });
+
+    const emit = () => {
+      const picked = {};
+      hunks.forEach((h) => {
+        const r = choices[h.id];
+        if (!r || !['apply', 'skip', 'hold'].includes(r.choice)) return;
+        picked[h.id] = { choice: r.choice, file: h.file, header: h.header };
+      });
+      const touched = Object.keys(picked).length;
+      const payload = touched
+        ? {
+            type: 'diff-review',
+            reviewKind: block.reviewKind || '',
+            commit: block.commit || '',
+            title: block.title || block.filename || '',
+            resolved: touched === hunks.length,
+            hunks: picked,
+          }
+        : null;
+      if (ctx && typeof ctx.onBlockEdit === 'function') ctx.onBlockEdit(blockId, payload);
+      wrap.dispatchEvent(new CustomEvent('relay:block-edit', {
+        bubbles: true,
+        detail: { blockId, value: payload },
+      }));
+      status.textContent = `${touched}/${hunks.length} reviewed`;
+      status.classList.toggle('is-complete', hunks.length > 0 && touched === hunks.length);
+      for (const h of hunks) {
+        const set = buttonsByHunk.get(h.id) || [];
+        const chosen = choices[h.id] && choices[h.id].choice;
+        set.forEach((b) => b.el.classList.toggle('sel', b.choice === chosen));
+      }
+    };
+
+    const setChoice = (h, choice) => {
+      choices[h.id] = { choice, file: h.file, header: h.header };
+      emit();
+    };
+
+    const setAll = (choice) => {
+      hunks.forEach((h) => {
+        choices[h.id] = { choice, file: h.file, header: h.header };
+      });
+      emit();
+    };
+
+    const makeReviewButton = (label, onClick, extraClass = '') => {
+      const b = el('button', { type: 'button', class: 'diff-review-btn' + (extraClass ? ' ' + extraClass : '') }, label);
+      b.addEventListener('mousedown', (e) => e.stopPropagation());
+      b.addEventListener('click', (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        onClick();
+      });
+      return b;
+    };
+
+    const repaint = () => {
+      list.replaceChildren();
+      hunks.forEach((h) => {
+        const actionbar = el('div', { class: 'diff-review-hunkbar' },
+          el('div', { class: 'diff-review-hunkmeta' },
+            el('span', { class: 'diff-review-file' }, h.file),
+            el('span', { class: 'diff-review-header' }, h.header)
+          )
+        );
+        const rowButtons = [
+          { choice: 'apply', label: 'Apply hunk' },
+          { choice: 'skip', label: 'Skip hunk' },
+          { choice: 'hold', label: 'Hold' },
+        ].map((item) => ({
+          choice: item.choice,
+          el: makeReviewButton(item.label, () => setChoice(h, item.choice), 'diff-review-choice'),
+        }));
+        buttonsByHunk.set(h.id, rowButtons);
+        actionbar.append(el('div', { class: 'diff-review-actions' }, rowButtons.map((b) => b.el)));
+        list.append(el('section', { class: 'diff-review-hunk' },
+          actionbar,
+          view === 'split' ? buildSplitDiff(h.rows, block.lang) : buildUnifiedDiff(h.rows, block.lang)
+        ));
+      });
+      emit();
+    };
+
+    const toggle = makeReviewButton('', () => {
+      view = view === 'split' ? 'unified' : 'split';
+      wrap.classList.toggle('is-split', view === 'split');
+      toggle.textContent = view === 'split' ? 'Unified view' : 'Split view';
+      repaint();
+    }, 'blk-difftoggle');
+    toggle.title = 'Toggle side-by-side view';
+    toggle.textContent = view === 'split' ? 'Unified view' : 'Split view';
+
+    const title = block.title || block.filename || (files.length > 1 ? `${files.length} files changed` : 'Diff review');
+    wrap.append(el('div', { class: 'blk-codehead diff-review-head' },
+      el('span', { class: 'blk-codename' }, title),
+      el('div', { class: 'diff-review-topactions' },
+        status,
+        makeReviewButton('Apply all', () => setAll('apply')),
+        makeReviewButton('Skip all', () => setAll('skip')),
+        makeReviewButton('Hold all', () => setAll('hold')),
+        toggle
+      )
+    ));
+    wrap.classList.toggle('is-split', view === 'split');
+    wrap.append(list);
+    repaint();
+    ctx && ctx.annotate && ctx.annotate.enableTextSelection(list, { blockId, questionId: ctx.questionId });
+    attachViewer(wrap, { zoomEl: null, label: 'diff review', comment: wholeBlockComment(ctx, blockId, 'diff review') });
+    return wrap;
+  }
+
   function renderDiff(block, ctx, blockId) {
     const files = splitDiffFiles(block.diff);
+    if (block.review === true) return renderDiffReview(block, ctx, blockId, files);
     const named = files.filter((f) => f.name);
     const multi = named.length > 1;
     let view = block.view === 'split' ? 'split' : 'unified';
@@ -649,6 +800,156 @@
     attachViewer(wrap, { zoomEl: null, label: 'diff', comment: wholeBlockComment(ctx, blockId, 'diff') });
     return wrap;
   }
+
+  // ---------- git conflict resolver ----------
+  function markerConflictText(h) {
+    const chunks = [
+      '<<<<<<< ' + (h.oursLabel || 'ours'),
+      h.ours || '',
+    ];
+    if (h.baseLabel) chunks.push('||||||| ' + h.baseLabel, h.base || '');
+    chunks.push('=======', h.theirs || '', '>>>>>>> ' + (h.theirsLabel || 'theirs'));
+    return chunks.join('\n');
+  }
+
+  function conflictChoiceText(h, choice, custom) {
+    if (choice === 'ours') return h.ours || '';
+    if (choice === 'theirs') return h.theirs || '';
+    if (choice === 'both') {
+      const left = h.ours || '';
+      const right = h.theirs || '';
+      return left && right ? left + '\n' + right : left || right;
+    }
+    if (choice === 'custom') return custom || '';
+    return markerConflictText(h);
+  }
+
+  function joinResolvedParts(block, resolutions) {
+    const byId = new Map((block.conflicts || []).map((h) => [h.id, h]));
+    return (block.parts || []).map((part) => {
+      if (!part || part.type === 'text') return part && part.text ? part.text : '';
+      const h = byId.get(part.conflictId);
+      if (!h) return '';
+      const r = resolutions && resolutions[h.id] ? resolutions[h.id] : {};
+      return conflictChoiceText(h, r.choice, r.value);
+    }).join('\n');
+  }
+
+  function renderConflictCode(text, lang) {
+    const pre = el('pre', { class: 'gitconf-pre' });
+    const code = el('code');
+    code.innerHTML = tintCode(text || ' ', lang);
+    pre.append(code);
+    return pre;
+  }
+
+  function renderGitConflict(block, ctx, blockId) {
+    const conflicts = Array.isArray(block.conflicts) ? block.conflicts : [];
+    const prior = ctx && ctx.edits && ctx.edits[blockId] && typeof ctx.edits[blockId] === 'object'
+      ? ctx.edits[blockId]
+      : {};
+    const resolutions = prior.resolutions && typeof prior.resolutions === 'object' ? { ...prior.resolutions } : {};
+    const wrap = el('div', { class: 'gitconf' });
+    const count = conflicts.length;
+    const title = block.title || block.filename || 'Git conflict';
+    const status = el('span', { class: 'gitconf-status' }, `${count} conflict${count === 1 ? '' : 's'}`);
+    const resolvedPreview = el('pre', { class: 'gitconf-resolved' }, el('code'));
+
+    function emit() {
+      const touched = Object.keys(resolutions).filter((id) => resolutions[id] && resolutions[id].choice);
+      const payload = touched.length
+        ? {
+            type: 'git-conflict-resolution',
+            filename: block.filename || '',
+            file: block.file || '',
+            resolved: touched.length === count,
+            resolutions,
+            content: joinResolvedParts(block, resolutions),
+          }
+        : null;
+      if (ctx && typeof ctx.onBlockEdit === 'function') ctx.onBlockEdit(blockId, payload);
+      wrap.dispatchEvent(new CustomEvent('relay:block-edit', {
+        bubbles: true,
+        detail: { blockId, value: payload },
+      }));
+      resolvedPreview.querySelector('code').textContent = joinResolvedParts(block, resolutions);
+      status.textContent = `${touched.length}/${count} resolved`;
+      status.classList.toggle('is-complete', touched.length === count);
+    }
+
+    wrap.append(el('div', { class: 'gitconf-head' },
+      el('div', {},
+        el('div', { class: 'gitconf-title' }, title),
+        block.file ? el('div', { class: 'gitconf-file' }, block.file) : null),
+      status
+    ));
+
+    conflicts.forEach((h, idx) => {
+      const body = el('div', { class: 'gitconf-body' });
+      const custom = el('textarea', {
+        class: 'gitconf-custom',
+        spellcheck: 'false',
+        rows: '5',
+        placeholder: 'Write the resolved content for this hunk',
+      });
+      const buttons = [];
+      const setChoice = (choice) => {
+        const current = resolutions[h.id] || {};
+        const next = { choice, value: choice === 'custom' ? custom.value : conflictChoiceText(h, choice, custom.value) };
+        resolutions[h.id] = next;
+        for (const b of buttons) b.el.classList.toggle('sel', b.choice === choice);
+        body.classList.toggle('is-custom', choice === 'custom');
+        emit();
+      };
+      const makeButton = (choice, label) => {
+        const b = el('button', { type: 'button', class: 'gitconf-choice' }, label);
+        b.addEventListener('mousedown', (e) => e.stopPropagation());
+        b.addEventListener('click', (e) => { e.preventDefault(); e.stopPropagation(); setChoice(choice); });
+        buttons.push({ choice, el: b });
+        return b;
+      };
+      const existing = resolutions[h.id] || {};
+      if (existing.choice === 'custom') custom.value = existing.value || '';
+      else custom.value = conflictChoiceText(h, existing.choice || 'ours', '');
+      custom.addEventListener('input', () => setChoice('custom'));
+
+      body.append(el('div', { class: 'gitconf-choicebar' },
+        makeButton('ours', 'Use ours'),
+        makeButton('theirs', 'Use theirs'),
+        makeButton('both', 'Keep both'),
+        makeButton('custom', 'Custom')
+      ));
+      body.append(el('div', { class: 'gitconf-sides' },
+        el('section', { class: 'gitconf-side gitconf-ours' },
+          el('div', { class: 'gitconf-label' }, h.oursLabel || 'ours'),
+          renderConflictCode(h.ours || '', block.lang)),
+        h.baseLabel ? el('section', { class: 'gitconf-side gitconf-base' },
+          el('div', { class: 'gitconf-label' }, h.baseLabel),
+          renderConflictCode(h.base || '', block.lang)) : null,
+        el('section', { class: 'gitconf-side gitconf-theirs' },
+          el('div', { class: 'gitconf-label' }, h.theirsLabel || 'theirs'),
+          renderConflictCode(h.theirs || '', block.lang))
+      ));
+      body.append(custom);
+
+      const card = el('section', { class: 'gitconf-card' },
+        el('div', { class: 'gitconf-cardhead' },
+          el('span', { class: 'gitconf-badge' }, `Conflict ${idx + 1}`),
+          el('span', { class: 'gitconf-hint' }, 'Choose a side, keep both, or write the final hunk.')),
+        body
+      );
+      wrap.append(card);
+      if (existing.choice) setChoice(existing.choice);
+    });
+
+    wrap.append(el('details', { class: 'gitconf-preview' },
+      el('summary', {}, 'Resolved file preview'),
+      resolvedPreview
+    ));
+    emit();
+    ctx && ctx.annotate && ctx.annotate.enableTextSelection(wrap, { blockId, questionId: ctx.questionId });
+    return wrap;
+  }
   // ---------- video (YouTube/Vimeo embed, local stream, or direct URL) ----------
   function renderVideo(block, ctx, blockId) {
     const wrap = el('div', { class: 'blk-videowrap' });
@@ -2216,6 +2517,10 @@
         inner = renderDiff(block, ctx, blockId);
         wrapper.append(inner);
         break;
+      case 'git-conflict':
+        inner = renderGitConflict(block, ctx, blockId);
+        wrapper.append(inner);
+        break;
       case 'video':
         inner = renderVideo(block, ctx, blockId);
         wrapper.append(inner);