fix: handle markdown hard line breaks and list continuations (#483)

* fix: handle markdown hard line breaks and list continuation lines

List items with indented continuation lines (no blank line separator) now
merge into the preceding bullet instead of becoming orphan paragraphs.
InlineMarkdown now converts two-trailing-space and backslash line breaks
into <br> elements. Synced to the diff view's InlineMarkdown copy.

Closes #482

For provenance purposes, this commit was AI assisted.

* fix: allow bold/italic to span across hard line breaks

Changed bold/italic regexes from .+? to [\s\S]+? so emphasis can match
across newlines (per CommonMark spec). Moved hard break check after all
^-anchored inline patterns so bold/italic get first crack, then the
recursive InlineMarkdown call inside <strong>/<em> handles the break.

For provenance purposes, this commit was AI assisted.

Author: backnotprop

packages/ui/components/Viewer.tsx

@@ -771,16 +771,16 @@ const InlineMarkdown: React.FC<{ text: string; onOpenLinkedDoc?: (path: string)
   let key = 0;
 
   while (remaining.length > 0) {
-    // Bold: **text**
-    let match = remaining.match(/^\*\*(.+?)\*\*/);
+    // Bold: **text** ([\s\S]+? allows matching across hard line breaks)
+    let match = remaining.match(/^\*\*([\s\S]+?)\*\*/);
     if (match) {
       parts.push(<strong key={key++} className="font-semibold"><InlineMarkdown imageBaseDir={imageBaseDir} onImageClick={onImageClick} text={match[1]} onOpenLinkedDoc={onOpenLinkedDoc} /></strong>);
       remaining = remaining.slice(match[0].length);
       continue;
     }
 
     // Italic: *text*
-    match = remaining.match(/^\*(.+?)\*/);
+    match = remaining.match(/^\*([\s\S]+?)\*/);
     if (match) {
       parts.push(<em key={key++}><InlineMarkdown imageBaseDir={imageBaseDir} onImageClick={onImageClick} text={match[1]} onOpenLinkedDoc={onOpenLinkedDoc} /></em>);
       remaining = remaining.slice(match[0].length);
@@ -908,6 +908,18 @@ const InlineMarkdown: React.FC<{ text: string; onOpenLinkedDoc?: (path: string)
       continue;
     }
 
+    // Hard line break: two+ trailing spaces + newline, or backslash + newline
+    match = remaining.match(/ {2,}\n|\\\n/);
+    if (match && match.index !== undefined) {
+      const before = remaining.slice(0, match.index);
+      if (before) {
+        parts.push(<InlineMarkdown key={key++} text={before} onOpenLinkedDoc={onOpenLinkedDoc} imageBaseDir={imageBaseDir} onImageClick={onImageClick} />);
+      }
+      parts.push(<br key={key++} />);
+      remaining = remaining.slice(match.index + match[0].length);
+      continue;
+    }
+
     // Find next special character or consume one regular character
     const nextSpecial = remaining.slice(1).search(/[\*`\[!]/);
     if (nextSpecial === -1) {

packages/ui/components/plan-diff/PlanCleanDiffView.tsx

@@ -589,7 +589,8 @@ const InlineMarkdown: React.FC<{ text: string }> = ({ text }) => {
   let key = 0;
 
   while (remaining.length > 0) {
-    let match = remaining.match(/^\*\*(.+?)\*\*/);
+    // Bold: **text** ([\s\S]+? allows matching across hard line breaks)
+    let match = remaining.match(/^\*\*([\s\S]+?)\*\*/);
     if (match) {
       parts.push(
         <strong key={key++} className="font-semibold">
@@ -600,7 +601,8 @@ const InlineMarkdown: React.FC<{ text: string }> = ({ text }) => {
       continue;
     }
 
-    match = remaining.match(/^\*(.+?)\*/);
+    // Italic: *text*
+    match = remaining.match(/^\*([\s\S]+?)\*/);
     if (match) {
       parts.push(<em key={key++}><InlineMarkdown text={match[1]} /></em>);
       remaining = remaining.slice(match[0].length);
@@ -638,7 +640,19 @@ const InlineMarkdown: React.FC<{ text: string }> = ({ text }) => {
       continue;
     }
 
-    const nextSpecial = remaining.slice(1).search(/[*`[]/);
+    // Hard line break: two+ trailing spaces + newline, or backslash + newline
+    match = remaining.match(/ {2,}\n|\\\n/);
+    if (match && match.index !== undefined) {
+      const before = remaining.slice(0, match.index);
+      if (before) {
+        parts.push(<InlineMarkdown key={key++} text={before} />);
+      }
+      parts.push(<br key={key++} />);
+      remaining = remaining.slice(match.index + match[0].length);
+      continue;
+    }
+
+    const nextSpecial = remaining.slice(1).search(/[*`\[!]/);
     if (nextSpecial === -1) {
       parts.push(remaining);
       break;

packages/ui/utils/parser.test.ts

@@ -208,3 +208,69 @@ describe("parseMarkdownToBlocks — real-world plan regression", () => {
     expect(blocks[5].type).toBe("heading");
   });
 });
+
+describe("parseMarkdownToBlocks — list continuation lines", () => {
+  test("indented continuation line merges into preceding list item", () => {
+    const md = "- First item with text\n  that continues here\n- Second item";
+    const blocks = parseMarkdownToBlocks(md);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe("list-item");
+    expect(blocks[0].content).toBe("First item with text\nthat continues here");
+    expect(blocks[1].type).toBe("list-item");
+    expect(blocks[1].content).toBe("Second item");
+  });
+
+  test("multiple continuation lines merge into one list item", () => {
+    const md = "- Line one\n  line two\n  line three\n- Next";
+    const blocks = parseMarkdownToBlocks(md);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe("list-item");
+    expect(blocks[0].content).toBe("Line one\nline two\nline three");
+  });
+
+  test("non-indented line after list item starts a new paragraph", () => {
+    const md = "- Item\nNot indented";
+    const blocks = parseMarkdownToBlocks(md);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe("list-item");
+    expect(blocks[1].type).toBe("paragraph");
+    expect(blocks[1].content).toBe("Not indented");
+  });
+
+  test("blank line between list item and indented text prevents merging", () => {
+    const md = "- Item\n\n  Indented paragraph";
+    const blocks = parseMarkdownToBlocks(md);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe("list-item");
+    expect(blocks[1].type).toBe("paragraph");
+  });
+
+  test("continuation does not swallow nested list items", () => {
+    const md = "- Parent\n  - Child\n- Sibling";
+    const blocks = parseMarkdownToBlocks(md);
+    expect(blocks).toHaveLength(3);
+    expect(blocks[0].type).toBe("list-item");
+    expect(blocks[0].content).toBe("Parent");
+    expect(blocks[1].type).toBe("list-item");
+    expect(blocks[1].content).toBe("Child");
+    expect(blocks[2].type).toBe("list-item");
+    expect(blocks[2].content).toBe("Sibling");
+  });
+
+  test("continuation works when list item follows a blank line", () => {
+    const md = "Some paragraph\n\n- Item with continuation\n  that continues here";
+    const blocks = parseMarkdownToBlocks(md);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe("paragraph");
+    expect(blocks[1].type).toBe("list-item");
+    expect(blocks[1].content).toBe("Item with continuation\nthat continues here");
+  });
+
+  test("block-level elements after list items are not swallowed", () => {
+    const md = "- Item\n# Heading";
+    const blocks = parseMarkdownToBlocks(md);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe("list-item");
+    expect(blocks[1].type).toBe("heading");
+  });
+});

packages/ui/utils/parser.ts

@@ -78,6 +78,7 @@ export const parseMarkdownToBlocks = (markdown: string): Block[] => {
   let currentType: Block['type'] = 'paragraph';
   let currentLevel = 0;
   let bufferStartLine = 1; // Track the start line of the current buffer
+  let lastLineWasBlank = false;
 
   const flush = () => {
     if (buffer.length > 0) {
@@ -98,6 +99,8 @@ export const parseMarkdownToBlocks = (markdown: string): Block[] => {
     const line = lines[i];
     const trimmed = line.trim();
     const currentLineNum = i + 1; // 1-based index
+    const prevLineWasBlank = lastLineWasBlank;
+    lastLineWasBlank = false;
 
     // Headings
     if (trimmed.startsWith('#')) {
@@ -232,6 +235,18 @@ export const parseMarkdownToBlocks = (markdown: string): Block[] => {
     if (trimmed === '') {
       flush();
       currentType = 'paragraph';
+      lastLineWasBlank = true;
+      continue;
+    }
+    // List continuation: indented line after a list item merges into it
+    if (
+      !prevLineWasBlank &&
+      buffer.length === 0 &&
+      blocks.length > 0 &&
+      blocks[blocks.length - 1].type === 'list-item' &&
+      /^\s+/.test(line)
+    ) {
+      blocks[blocks.length - 1].content += '\n' + trimmed;
       continue;
     }
 

test-fixtures/01-reported-issue.md

@@ -0,0 +1,18 @@
+## Web Researcher Subagent
+
+### Changes
+
+**New file: `home/dot_config/opencode/exact_agents/web-researcher.md`**
+
+Subagent definition with:
+- Model: kimi-k2p5-turbo (matches other subagents)
+- Mode: subagent (not hidden; available for direct user invocation too)
+- Permissions: blanket deny, then allow only `web *` and `jq *` (bash), plus Context7 MCP tools
+- Prompt covering:
+  - Fallback priority: Context7 (curated library docs) → web search → web fetch
+  - Error surfacing: MUST report all tool failures (auth errors, timeouts, HTTP errors, empty
+    results) unconditionally and verbatim to the caller
+  - Progressive refinement: if initial results are thin, refine query and search again
+  - Constraint on max iterations to prevent runaway cycles
+  - "When stuck" guidance
+  - Output template (enforced structure for quality):

test-fixtures/02-list-continuations.md

@@ -0,0 +1,66 @@
+# List Continuation Edge Cases
+
+## Simple continuation
+
+- This is a list item that has a continuation
+  line that wraps to the next line
+- This is a normal single-line item
+
+## Multiple continuation lines
+
+- This item has multiple
+  continuation lines that
+  all should merge into one bullet
+- Next item
+
+## Nested list with continuation
+
+- Top level item
+  - Nested item that has a long description
+    that continues on the next line
+  - Another nested item
+- Back to top level
+
+## Deep nesting with continuations
+
+- Level 0
+  - Level 1 with continuation
+    that wraps here
+    - Level 2 item
+      - Level 3 with continuation
+        that also wraps
+
+## Continuation after blank line (should NOT merge)
+
+- First item
+
+  This should be a separate paragraph, not merged into the list item.
+
+- Second item
+
+## Non-indented line after list (should NOT merge)
+
+- Item one
+This is not indented so it should be a new paragraph.
+- Item two
+
+## Mixed content after list items
+
+- Item followed by a heading
+# This Heading Should Not Merge
+
+- Item followed by a blockquote
+> This quote should not merge
+
+- Item followed by a code fence
+  ```ts
+  const x = 1;
+  ```
+
+- Item followed by a table
+| A | B |
+|---|---|
+| 1 | 2 |
+
+- Item followed by a horizontal rule
+---

test-fixtures/03-hard-line-breaks.md

@@ -0,0 +1,43 @@
+# Hard Line Break Tests
+
+## Two trailing spaces (standard hard break)
+
+This line has two trailing spaces  
+and this should appear on a new line.
+
+## Backslash hard break
+
+This line ends with a backslash\
+and this should appear on a new line.
+
+## Soft wrap (should NOT break)
+
+This line has no trailing spaces
+and should flow as a single line with a space between.
+
+## Multiple hard breaks in a row
+
+Line one  
+Line two  
+Line three  
+Line four
+
+## Hard break inside a list item
+
+- This list item has a hard break  
+  and continues on the next visual line
+- Normal item after
+
+## Hard break with inline formatting
+
+**Bold text with break  
+continuation** and more text.
+
+This has `inline code` then a break  
+and continues here.
+
+## Paragraph with no breaks (control case)
+
+This is just a normal paragraph with no special line break handling.
+It should render as flowing text with spaces between lines.
+Nothing should change here at all.

test-fixtures/04-unchanged-baseline.md

@@ -0,0 +1,79 @@
+# Baseline — Nothing Here Should Change
+
+## Headings
+
+### Level 3 heading
+#### Level 4 heading
+
+## Simple paragraph
+
+This is a simple paragraph with no special formatting. It should render exactly as before — a single block of text.
+
+## Paragraph with inline formatting
+
+This has **bold**, *italic*, `inline code`, and [a link](https://example.com).
+
+## Simple list
+
+- Item one
+- Item two
+- Item three
+
+## Nested list (no continuations)
+
+- Parent item
+  - Child item
+  - Another child
+    - Grandchild
+- Another parent
+
+## Checkbox list
+
+- [x] Completed task
+- [ ] Pending task
+- [x] Another done task
+
+## Code block
+
+```typescript
+function hello() {
+  console.log("world");
+}
+```
+
+## Blockquote
+
+> This is a blockquote.
+> It has multiple lines.
+
+## Table
+
+| Header 1 | Header 2 | Header 3 |
+|----------|----------|----------|
+| Cell 1   | Cell 2   | Cell 3   |
+| Cell 4   | Cell 5   | Cell 6   |
+
+## Horizontal rule
+
+---
+
+## Images and links
+
+This paragraph has a [markdown link](https://example.com) and some `code`.
+
+## Mixed content plan
+
+### 1. Update the parser
+
+- **Remove** the old regex
+- **Add** new pattern matching:
+  ```ts
+  const pattern = /new-regex/;
+  ```
+- **Test** the changes
+
+### 2. Update the renderer
+
+- Modify `InlineMarkdown` component
+- Add `<br>` support
+- Run visual tests