@khanglvm/relay 0.13.6 → 0.13.8

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 |
+| `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,24 @@ 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 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.6",
+  "version": "0.13.8",
   "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`, `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

@@ -4,7 +4,7 @@ import os from 'node:os';
 import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { CliError, sleep, pollFor } from './util.js';
-import { normalizeSpec, questionFromInline, SPEC_SCHEMA } from './spec.js';
+import { assertSpecReady, normalizeSpec, questionFromInline, SPEC_SCHEMA } from './spec.js';
 import {
   createBoard,
   loadBoard,
@@ -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',
 ]);
 
@@ -197,6 +197,7 @@ function readFileOrThrow(p) {
 }
 
 async function runOrDetach(record, args) {
+  await assertSpecReady(record.spec);
   const timeoutSec = args.timeout !== undefined ? Math.max(0, Number.parseInt(args.timeout, 10) || 0) : 1800;
   const port = args.port !== undefined ? Number.parseInt(args.port, 10) || 0 : 0;
   const open = args.open !== false;
@@ -244,6 +245,7 @@ async function runOrDetach(record, args) {
 async function cmdAsk(args, mode) {
   const raw = await resolveSpecInput(args, mode);
   const spec = normalizeSpec(raw);
+  await assertSpecReady(spec);
   const record = createBoard(spec);
   return runOrDetach(record, args);
 }
@@ -275,6 +277,113 @@ async function cmdDiff(rest) {
   }
   const title = args.title || ('git diff' + (gitArgs.length ? ' ' + gitArgs.join(' ') : ''));
   const spec = normalizeSpec({ title, blocks: [{ type: 'diff', diff, view: args.split ? 'split' : 'unified' }] });
+  await assertSpecReady(spec);
+  const record = createBoard(spec);
+  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);
+}
+
+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 = [];
+
+  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.`);
+    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' }],
+    });
+    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,
+    });
+  }
+
+  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.'
+    : '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);
 }
@@ -299,6 +408,7 @@ async function cmdView(args) {
   raw.title = args.title || (multi ? `${files.length} files` : path.basename(files[0]));
   raw.submitLabel = args.submitLabel || 'Done';
   const spec = normalizeSpec(raw); // reads + validates each file, clear error if unreadable
+  await assertSpecReady(spec);
   const record = createBoard(spec);
   return runOrDetach(record, args);
 }
@@ -445,6 +555,7 @@ async function cmdUpdate(args) {
   } else {
     throw new CliError('update needs --file <spec.json>, --title, --intro, or -q "...".', 4);
   }
+  await assertSpecReady(spec);
 
   let res;
   try {
@@ -902,13 +1013,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
@@ -1398,6 +1513,10 @@ 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
+  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
@@ -1474,6 +1593,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/mcp.js

@@ -19,7 +19,7 @@ import path from 'node:path';
 import http from 'node:http';
 import crypto from 'node:crypto';
 import { fileURLToPath } from 'node:url';
-import { normalizeSpec, SPEC_SCHEMA } from './spec.js';
+import { assertSpecReady, normalizeSpec, SPEC_SCHEMA } from './spec.js';
 import { CliError } from './util.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -143,7 +143,7 @@ function resourceMeta() {
 }
 
 // ---------- request routing ----------
-function buildResult(method, params, clientProtocol) {
+async function buildResult(method, params, clientProtocol) {
   switch (method) {
     case 'initialize':
       return {
@@ -202,7 +202,7 @@ function readResource(params) {
 // ui/update-model-context as a best-effort context sync). Spec errors come back
 // as an isError tool result (not a protocol error) so the model can see and fix
 // them.
-function callTool(params) {
+async function callTool(params) {
   const name = params && params.name;
   if (name !== 'relay_ask' && name !== 'relay_show') {
     return { content: [{ type: 'text', text: 'unknown tool: ' + name }], isError: true };
@@ -211,6 +211,7 @@ function callTool(params) {
   let spec;
   try {
     spec = normalizeSpec(args);
+    await assertSpecReady(spec);
   } catch (err) {
     const msg = err instanceof CliError ? err.message : String((err && err.message) || err);
     return { content: [{ type: 'text', text: 'relay: invalid board spec — ' + msg }], isError: true };
@@ -265,7 +266,7 @@ export function runMcp() {
     catch { stdoutOpen = false; }
   };
 
-  function handleLine(line) {
+  async function handleLine(line) {
     let msg;
     try { msg = JSON.parse(line); } catch {
       send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'parse error' } });
@@ -278,7 +279,7 @@ export function runMcp() {
       if (typeof m.method !== 'string') continue; // a response to us — we issue none
       let result;
       try {
-        result = buildResult(m.method, m.params || {});
+        result = await buildResult(m.method, m.params || {});
       } catch (err) {
         if (isRequest) {
           send({ jsonrpc: '2.0', id: m.id, error: { code: err.code || -32603, message: err.message || String(err) } });
@@ -290,6 +291,7 @@ export function runMcp() {
   }
 
   let buf = '';
+  let queue = Promise.resolve();
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', (chunk) => {
     buf += chunk;
@@ -298,7 +300,7 @@ export function runMcp() {
       const line = buf.slice(0, idx);
       buf = buf.slice(idx + 1);
       const trimmed = line.trim();
-      if (trimmed) handleLine(trimmed);
+      if (trimmed) queue = queue.then(() => handleLine(trimmed)).catch(() => {});
     }
   });
 
@@ -406,7 +408,7 @@ export function runMcpHttp({ port = DEFAULT_HTTP_PORT, host = '127.0.0.1', token
     let body = '';
     let aborted = false;
     req.on('data', (c) => { body += c; if (body.length > MAX_BODY) { aborted = true; req.destroy(); } });
-    req.on('end', () => {
+    req.on('end', async () => {
       if (aborted) { res.writeHead(413, base); return res.end(); }
       let msg;
       try { msg = JSON.parse(body); } catch {
@@ -421,7 +423,7 @@ export function runMcpHttp({ port = DEFAULT_HTTP_PORT, host = '127.0.0.1', token
         if (m.method === 'initialize') isInit = true;
         const isRequest = m.id !== undefined && m.id !== null;
         try {
-          const result = buildResult(m.method, m.params || {});
+          const result = await buildResult(m.method, m.params || {});
           if (isRequest) responses.push({ jsonrpc: '2.0', id: m.id, result });
         } catch (err) {
           if (isRequest) responses.push({ jsonrpc: '2.0', id: m.id, error: { code: err.code || -32603, message: err.message || String(err) } });

package/src/server.js

@@ -7,6 +7,7 @@ import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { loadBoard, saveBoard, saveRunning, removeRunning, loadPref, savePref } from './store.js';
 import { openUrl } from './open.js';
+import { assertSpecReady } from './spec.js';
 
 const UI_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'ui');
 const PKG_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -183,9 +184,44 @@ 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;
+}
+
 // 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
+// values carry per-hunk choices plus resolved file content. 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 = {};
@@ -194,8 +230,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);
+      if (!edit) continue;
+      out[key] = edit;
+    }
     n++;
   }
   return out;
@@ -592,6 +634,11 @@ export async function runBoard({ id, port = 0, open = true, timeoutSec = 1800, q
             !Array.isArray(next.questions) || !Array.isArray(next.blocks)) {
           return sendJson(res, 400, { error: 'spec must be an object with questions[] and blocks[] arrays' });
         }
+        try {
+          await assertSpecReady(next);
+        } catch (err) {
+          return sendJson(res, 400, { error: err && err.message ? err.message : String(err) });
+        }
         record.spec = next;
         rev++;
         saveBoard(record);

package/src/spec.js

@@ -1,5 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
 import { CliError } from './util.js';
 
 export const TYPES = ['single', 'multi', 'yesno', 'text', 'textarea', 'scale', 'color', 'rank', 'checklist', 'allocate'];
@@ -39,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
@@ -65,6 +67,9 @@ const IMAGE_MIMES = {
   webp: 'image/webp', svg: 'image/svg+xml', avif: 'image/avif', bmp: 'image/bmp',
 };
 const IMAGE_MAX_BYTES = 8 * 1024 * 1024;
+const VENDOR_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'vendor');
+
+let mermaidValidatorPromise = null;
 
 const asStr = (v) => (typeof v === 'string' ? v : v == null ? '' : String(v));
 
@@ -122,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.
@@ -222,6 +324,99 @@ function parseVideoEmbed(src) {
   return null;
 }
 
+function compactError(err) {
+  const raw = err && (err.str || err.message) ? (err.str || err.message) : String(err || 'unknown error');
+  const msg = String(raw).replace(/\s+/g, ' ').trim();
+  return msg.length > 500 ? msg.slice(0, 497) + '...' : msg;
+}
+
+async function mermaidValidator() {
+  if (mermaidValidatorPromise) return mermaidValidatorPromise;
+  mermaidValidatorPromise = (async () => {
+    const sourcePath = path.join(VENDOR_DIR, 'mermaid.min.js');
+    let source;
+    try {
+      source = fs.readFileSync(sourcePath, 'utf8');
+    } catch {
+      throw new CliError('mermaid blocks need the vendored parser (vendor/mermaid.min.js is missing).');
+    }
+    const quietConsole = { log() {}, info() {}, warn() {}, error() {}, debug() {} };
+    const context = {
+      console: quietConsole,
+      setTimeout,
+      clearTimeout,
+    };
+    context.globalThis = context;
+    context.window = { addEventListener() {} };
+    vm.createContext(context);
+    try {
+      vm.runInContext(source, context, { filename: sourcePath });
+    } catch (err) {
+      throw new CliError(`could not load mermaid parser: ${compactError(err)}`);
+    }
+    if (!context.mermaid || typeof context.mermaid.parse !== 'function') {
+      throw new CliError('could not load mermaid parser: vendor/mermaid.min.js did not expose mermaid.parse.');
+    }
+    try {
+      context.mermaid.initialize({
+        startOnLoad: false,
+        securityLevel: 'strict',
+        suppressErrorRendering: true,
+      });
+    } catch {
+      // Some Mermaid versions dislike repeated initialize calls; parse below is
+      // the real readiness gate.
+    }
+    return context.mermaid;
+  })();
+  return mermaidValidatorPromise;
+}
+
+async function assertMermaidSyntax(code, where) {
+  const mermaid = await mermaidValidator();
+  try {
+    const parsed = mermaid.parse(code);
+    if (parsed && typeof parsed.then === 'function') await parsed;
+  } catch (err) {
+    throw new CliError(`${where}: invalid mermaid syntax — ${compactError(err)}`);
+  }
+}
+
+function* allBlocks(spec) {
+  const boardBlocks = Array.isArray(spec.blocks) ? spec.blocks : [];
+  for (let i = 0; i < boardBlocks.length; i++) {
+    yield { block: boardBlocks[i], where: `board.blocks[${i}]${boardBlocks[i]?.id ? ` (${boardBlocks[i].id})` : ''}` };
+  }
+  const questions = Array.isArray(spec.questions) ? spec.questions : [];
+  for (let qi = 0; qi < questions.length; qi++) {
+    const q = questions[qi] || {};
+    const qBlocks = Array.isArray(q.blocks) ? q.blocks : [];
+    for (let bi = 0; bi < qBlocks.length; bi++) {
+      yield { block: qBlocks[bi], where: `questions[${qi}].blocks[${bi}]${qBlocks[bi]?.id ? ` (${qBlocks[bi].id})` : ''}` };
+    }
+    const opts = Array.isArray(q.options) ? q.options : [];
+    for (let oi = 0; oi < opts.length; oi++) {
+      const oBlocks = Array.isArray(opts[oi]?.blocks) ? opts[oi].blocks : [];
+      for (let bi = 0; bi < oBlocks.length; bi++) {
+        yield {
+          block: oBlocks[bi],
+          where: `questions[${qi}].options[${oi}].blocks[${bi}]${oBlocks[bi]?.id ? ` (${oBlocks[bi].id})` : ''}`,
+        };
+      }
+    }
+  }
+}
+
+export async function assertSpecReady(spec) {
+  if (!spec || typeof spec !== 'object') return spec;
+  if (spec.__relayReady === true) return spec;
+  for (const { block, where } of allBlocks(spec)) {
+    if (block && block.type === 'mermaid') await assertMermaidSyntax(block.code || '', where);
+  }
+  Object.defineProperty(spec, '__relayReady', { value: true, enumerable: false, configurable: true });
+  return spec;
+}
+
 // Normalizes one block object. `id` is the already-assigned block id.
 // Returns the normalized block (with a guaranteed string `type` + `id`).
 function normalizeBlock(rawBlock, id, cwd, where) {
@@ -303,6 +498,31 @@ function normalizeBlock(rawBlock, id, cwd, where) {
     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).`);
@@ -807,14 +1027,18 @@ 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.' },
+      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.' },
@@ -955,7 +1179,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}. 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,101 @@
 }
 .diff-file-chip:hover { color: var(--accent); border-color: var(--accent); }
 
+/* ---------- 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

@@ -649,6 +649,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 +2366,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);