dsh-code 0.1.0 → 0.3.0

package/src/invariant.ts

@@ -1,12 +1,12 @@
 /**
- * Package-owned invariant companion for `@deepseek-ai/dsh-tui`.
- * @module @deepseek-ai/dsh-tui/invariant
+ * Package-owned invariant companion for `dsh-code`.
+ * @module dsh-code/invariant
  */
 
 import type { Context } from '@deepseek-ai/cordis'
 import type { InvariantInstaller } from '@deepseek-ai/dsh-invariants'
 
-const PACKAGE_NAME = '@deepseek-ai/dsh-tui'
+const PACKAGE_NAME = 'dsh-code'
 
 /** Cordis companion plugin name. */
 export const name = 'tui-invariant'

package/src/mentions.ts

@@ -0,0 +1,193 @@
+/**
+ * Workspace @mention support: file candidates from a bounded async scan of
+ * the session cwd, session candidates from the opt-in `sessionReferenceResolver`
+ * service, and submission preparation through its `prepare()` API. Picked
+ * session mentions land as canonical `@[label](dsh-session:…)` tokens; on
+ * submit the text is parsed back into readable `@label` text plus structured
+ * references, snapshots are injected via `agent.inject()` before the readable
+ * message wakes the driver (`followup` idle, `steer` running) — exactly the
+ * upstream README's wiring.
+ *
+ * @module @deepseek-ai/dsh-code/mentions
+ */
+
+import { readdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import {
+  formatSessionReferenceMention,
+  parseSessionReferenceText,
+  type SessionReferenceCandidate,
+  type SessionReferenceInput,
+} from '@deepseek-ai/dsh-session-reference'
+
+/** Parsed submission text: readable text plus structured references. */
+type ParsedSessionReferenceText = ReturnType<typeof parseSessionReferenceText>
+
+/** One filesystem entry the @ menu can complete. */
+export interface FileCandidate {
+  /** Workspace-relative path with forward slashes. */
+  path: string
+  /** Entry kind; directories insert with a trailing slash. */
+  kind: 'file' | 'directory'
+}
+
+/** One merged menu candidate (files and sessions, already ranked). */
+export interface MentionCandidate {
+  /** Text inserted after the `@` (directories carry a trailing slash). */
+  label: string
+  /** Human-readable origin shown beside the label. */
+  description: string
+  /** Origin kind for icon/coloring decisions. */
+  kind: 'file' | 'directory' | 'session'
+}
+
+/** Prepared submission: readable content plus optional injected context. */
+export interface PreparedMention {
+  /** Readable text with mention tokens normalized to `@label`. */
+  text: string
+  /** Structured source sessions in appearance order (empty when none). */
+  references: SessionReferenceInput[]
+  /** Aggregated snapshot for `agent.inject()`, undefined without references. */
+  additionalContext?: import('@deepseek-ai/dsh-session').UserMessage
+}
+
+/** Directories never entered and files never listed during the scan. */
+const SKIP_DIRS = new Set(['.git', 'node_modules', 'lib', 'dist', 'out', '.omc', 'coverage'])
+const MAX_FILES = 4000
+const MAX_DEPTH = 12
+
+/** Bounded async BFS scan of a workspace; unreadable entries are skipped. */
+export async function scanWorkspaceFiles(root: string, signal?: AbortSignal): Promise<readonly FileCandidate[]> {
+  const found: FileCandidate[] = []
+  const pending: Array<{ absolute: string; relative: string; depth: number }> = [{ absolute: root, relative: '', depth: 0 }]
+  const aborted = (): boolean => signal?.aborted === true
+  while (pending.length > 0 && found.length < MAX_FILES && !aborted()) {
+    const current = pending.shift()
+    if (current === undefined) break
+    let entries
+    try {
+      entries = await readdir(current.absolute, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (found.length >= MAX_FILES || aborted()) return found
+      if (entry.name.startsWith('.')) continue
+      const relative = current.relative === '' ? entry.name : `${current.relative}/${entry.name}`
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name) || current.depth + 1 > MAX_DEPTH) continue
+        pending.push({ absolute: join(current.absolute, entry.name), relative, depth: current.depth + 1 })
+      } else if (entry.isFile()) {
+        found.push({ path: relative, kind: 'file' })
+      }
+    }
+  }
+  return found.sort((left, right) => left.path < right.path ? -1 : 1)
+}
+
+/** True when every query character appears in order in the haystack. */
+function isSubsequence(query: string, haystack: string): boolean {
+  let at = 0
+  for (const char of haystack) {
+    if (char === query[at]) at += 1
+    if (at >= query.length) return true
+  }
+  return at >= query.length
+}
+
+/** Rank one file path against the typed query (community-TUI scoring shape). */
+function scoreFile(path: string, query: string): number {
+  const name = path.slice(path.lastIndexOf('/') + 1)
+  if (query === '') return 0
+  if (name === query) return 1000
+  if (name.startsWith(query)) return 900
+  if (name.includes(query)) return 700
+  if (path.includes(query)) return 500
+  if (isSubsequence(query, name)) return 300
+  return 0
+}
+
+/** The mention API the input editor and the runner share. */
+export interface MentionsApi {
+  /** Scanned workspace files, cached across one session. */
+  files(): Promise<readonly FileCandidate[]>
+  /** Ranked menu candidates for the typed `@` query. */
+  candidates(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>
+  /** Parse submission text into readable text plus structured references. */
+  parse(text: string): ParsedSessionReferenceText
+  /**
+   * Snapshot references and build the injected context. Throws the service's
+   * typed error on failure — the caller restores the draft and notifies.
+   */
+  prepare(parsed: ParsedSessionReferenceText, signal?: AbortSignal): Promise<PreparedMention>
+  /** Canonical mention token for a picked session candidate. */
+  sessionMention(candidate: SessionReferenceCandidate): string
+}
+
+/**
+ * Create the mention API for one agent's workspace. A missing
+ * session-reference service degrades to file mentions only (the scan still
+ * works); `prepare` then passes text through untouched.
+ * @param ctx - context carrying the optional `sessionReferenceResolver`.
+ * @param agent - the session owner; excluded from its own candidates.
+ * @param cwd - workspace root to scan.
+ */
+export function createMentions(ctx: Context, agent: Agent, cwd: string): MentionsApi {
+  const resolver = ctx.get('sessionReferenceResolver')
+  let filesPromise: Promise<readonly FileCandidate[]> | undefined
+
+  return {
+    files(): Promise<readonly FileCandidate[]> {
+      filesPromise ??= scanWorkspaceFiles(cwd)
+      return filesPromise
+    },
+    async candidates(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]> {
+      const needle = query.trim()
+      const [files, sessions] = await Promise.all([
+        this.files(),
+        resolver === undefined
+          ? Promise.resolve([])
+          : resolver.listCandidates(agent, needle, 10, signal).catch(() => []),
+      ])
+      const fileRows: MentionCandidate[] = files
+        .filter(candidate => scoreFile(candidate.path, needle) > 0)
+        .sort((left, right) => scoreFile(right.path, needle) - scoreFile(left.path, needle))
+        .slice(0, 20)
+        .map(candidate => ({
+          label: candidate.path,
+          description: candidate.kind === 'directory' ? 'Folder' : 'File',
+          kind: candidate.kind,
+        }))
+      const sessionRows: MentionCandidate[] = sessions.map(candidate => ({
+        label: formatSessionReferenceMention(candidate),
+        description: `Session · ${candidate.cwd ?? '(no cwd)'}`,
+        kind: 'session',
+      }))
+      return [...sessionRows, ...fileRows]
+    },
+    parse(text: string): ParsedSessionReferenceText {
+      return parseSessionReferenceText(text)
+    },
+    async prepare(parsed: ParsedSessionReferenceText, signal?: AbortSignal): Promise<PreparedMention> {
+      if (parsed.references.length === 0 || resolver === undefined) {
+        return { text: parsed.text, references: parsed.references }
+      }
+      const prepared = await resolver.prepare(
+        agent,
+        [{ type: 'text', text: parsed.text }],
+        parsed.references,
+        signal,
+      )
+      return {
+        text: prepared.content.filter(block => block.type === 'text').map(block => block.text).join(''),
+        references: parsed.references,
+        additionalContext: prepared.additionalContext,
+      }
+    },
+    sessionMention(candidate: SessionReferenceCandidate): string {
+      return formatSessionReferenceMention({ sessionId: candidate.sessionId, label: candidate.label })
+    },
+  }
+}

package/src/models.ts

@@ -0,0 +1,66 @@
+/**
+ * Model directory for the `/model` panel: the in-process equivalent of the
+ * web host's model catalog (`buildModelCatalog`), reading the advisory
+ * `ctx.llm` registry directly. Catalog membership is advisory — a route
+ * serving a model it stopped advertising stays usable — so selection never
+ * fails on catalog absence alone.
+ *
+ * @module @deepseek-ai/dsh-tui/models
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { LlmModelInfo } from '@deepseek-ai/dsh-llm'
+
+/** One selectable row in the `/model` panel. */
+export interface ModelRow {
+  /** Registered provider route. */
+  provider: string
+  /** Display name of the provider route. */
+  providerName: string
+  /** Provider-owned model id. */
+  model: string
+  /** Human-readable model name. */
+  modelName: string
+}
+
+/** The resolved directory: rows plus per-provider discovery failures. */
+export interface ModelDirectory {
+  /** Advisory rows, provider-major in registry order. */
+  rows: readonly ModelRow[]
+  /** Provider ids whose model listing failed; those providers contribute no rows. */
+  failures: readonly string[]
+}
+
+/**
+ * Load the selectable model directory from the live `ctx.llm` registry.
+ * Providers are listed synchronously; each provider's models are discovered
+ * with a bounded parallel fan-out whose failures degrade to that provider
+ * contributing no rows (mirrors the web catalog's per-provider failures).
+ * @param ctx - context carrying the `llm` service.
+ * @returns the resolved directory; empty rows when `llm` is unavailable.
+ */
+export async function loadModelDirectory(ctx: Context): Promise<ModelDirectory> {
+  const llm = ctx.get('llm')
+  if (llm === undefined) return { rows: [], failures: [] }
+  const providers = llm.listProviders()
+  const listed = await Promise.all(providers.map(async (provider) => {
+    try {
+      const models: readonly LlmModelInfo[] = await llm.listModels(provider.id)
+      return {
+        provider: provider.id,
+        providerName: provider.name,
+        models: models.map(model => ({
+          provider: provider.id,
+          providerName: provider.name,
+          model: model.id,
+          modelName: model.name,
+        })),
+      }
+    } catch {
+      return { provider: provider.id, providerName: provider.name, models: [] as ModelRow[], failed: true }
+    }
+  }))
+  const rows = listed.flatMap(entry => entry.models)
+  const failures = listed.filter(entry => 'failed' in entry && entry.failed === true).map(entry => entry.provider)
+  return { rows, failures }
+}

package/src/questions.ts

@@ -0,0 +1,143 @@
+/**
+ * The terminal ask_user_question provider: registers the single UI provider
+ * on `ctx.userQuestions` and drives it with a FIFO queue — one question
+ * request on screen at a time, everything else waiting — then resolves the
+ * collected answers back into the tool's promise. The community TUI proved
+ * this exact pipeline shape; here the dialog is an Ink bar instead of a
+ * pi-tui inline modal.
+ *
+ * Plan reviews (`exit_plan_mode`) arrive through the same service with an
+ * `intent: { kind: 'plan-review' }` — the renderer highlights the approve
+ * option; the answer encoding is identical either way.
+ *
+ * @module @deepseek-ai/dsh-code/questions
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import {
+  UserQuestionError,
+  type AskUserQuestionAnswer,
+  type AskUserQuestionRequest,
+} from '@deepseek-ai/dsh-user-questions'
+
+/** One question request waiting on the human, with its settle channels. */
+export interface PendingQuestion {
+  /** The request the renderer walks through question by question. */
+  request: AskUserQuestionRequest
+  /** Resolve the provider promise with the collected answers. */
+  resolve(answers: AskUserQuestionAnswer): void
+  /** Reject the provider promise as aborted (also used for Esc cancel). */
+  reject(error: Error): void
+}
+
+/** The pending-question snapshot the renderer subscribes to. */
+export interface QuestionSnapshot {
+  /** The active request, or undefined when nothing is being asked. */
+  pending: PendingQuestion | undefined
+}
+
+/** Store the pending question lands in; the renderer reads, the provider writes. */
+export interface QuestionStore {
+  /** Subscribe to pending-state changes; returns the unsubscribe function. */
+  subscribe(listener: () => void): () => void
+  /** Read the current snapshot (identity-stable between changes). */
+  getSnapshot(): QuestionSnapshot
+  /** Submit the collected answers for the active request and advance the queue. */
+  submit(pending: PendingQuestion, answers: AskUserQuestionAnswer): void
+  /** Cancel the active request (Esc) — rejects ASK_ABORTED and advances the queue. */
+  cancel(pending: PendingQuestion): void
+}
+
+const ABORT_ERROR = new UserQuestionError(
+  'ask_user_question was interrupted before the user answered',
+  'ASK_ABORTED',
+)
+
+/**
+ * Mount the single `ctx.userQuestions` UI provider over a FIFO queue.
+ * @param ctx - context carrying the `userQuestions` service (dsh-base).
+ * @returns the store the renderer subscribes to; a context without the
+ * service yields a permanently empty store.
+ */
+export function mountQuestionProvider(ctx: Context): QuestionStore {
+  const service = ctx.get('userQuestions')
+  let snapshot: QuestionSnapshot = { pending: undefined }
+  let active: PendingQuestion | undefined
+  const queue: PendingQuestion[] = []
+  const listeners = new Set<() => void>()
+  const set = (next: QuestionSnapshot): void => {
+    snapshot = next
+    for (const listener of listeners) listener()
+  }
+
+  /** Settle the active request and show the next queued one, if any. */
+  const advance = (): void => {
+    const next = queue.shift()
+    active = next
+    set({ pending: next })
+  }
+
+  if (service !== undefined) {
+    service.registerProvider({
+      ask(request: AskUserQuestionRequest): Promise<AskUserQuestionAnswer> {
+        return new Promise((resolve, reject) => {
+          const pending: PendingQuestion = {
+            request,
+            resolve,
+            reject,
+          }
+          // Abort settles through the same channel as an Esc cancel: the
+          // owning tool/step died, so the answer must not linger.
+          const onAbort = (): void => {
+            if (active === pending) {
+              active = undefined
+              set({ pending: undefined })
+              advance()
+            } else {
+              const at = queue.indexOf(pending)
+              if (at >= 0) queue.splice(at, 1)
+            }
+            reject(ABORT_ERROR)
+          }
+          if (request.signal?.aborted === true) {
+            reject(ABORT_ERROR)
+            return
+          }
+          request.signal?.addEventListener('abort', onAbort, { once: true })
+          if (active === undefined) {
+            active = pending
+            set({ pending })
+          } else {
+            queue.push(pending)
+          }
+        })
+      },
+    })
+  }
+
+  return {
+    subscribe(listener: () => void): () => void {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    getSnapshot(): QuestionSnapshot {
+      return snapshot
+    },
+    submit(pending: PendingQuestion, answers: AskUserQuestionAnswer): void {
+      if (active !== pending) return
+      active = undefined
+      set({ pending: undefined })
+      pending.resolve(answers)
+      advance()
+    },
+    cancel(pending: PendingQuestion): void {
+      if (active !== pending) return
+      active = undefined
+      set({ pending: undefined })
+      pending.reject(ABORT_ERROR)
+      advance()
+    },
+  }
+}

package/src/render/animations.ts

@@ -0,0 +1,22 @@
+/**
+ * Terminal animation frame tables derived from the web design language:
+ * the StateDot "ongoing" pixel chase (3×3 ring, 125ms flat-hold brightness
+ * steps, 1s cycle) becomes the single-cell stepped pulse below, and the
+ * streaming caret blink is the Claude-Code convention. Pure functions only —
+ * the Ink layer owns timers and colors.
+ *
+ * @module @deepseek-ai/dsh-code/render/animations
+ */
+
+/** Single-cell stepped pulse: flat holds mirroring the web's 125ms keyframes. */
+export const PULSE_FRAMES = ['█', '█', '▆', '▃', '▁', '▃', '▆', '█'] as const
+
+/** Pulse frame for a monotonic tick. */
+export function pulseFrame(tick: number): string {
+  return PULSE_FRAMES[tick % PULSE_FRAMES.length] ?? PULSE_FRAMES[0]
+}
+
+/** Caret visibility: half the ticks on, half off (530ms blink). */
+export function caretVisible(tick: number): boolean {
+  return tick % 2 === 0
+}

package/src/render/markdown.ts

@@ -0,0 +1,235 @@
+/**
+ * Terminal markdown renderer for assistant replies: a pure GFM-subset
+ * block/inline parser producing styled line segments the Ink renderer maps
+ * to colored text. No ANSI here — the app owns color mapping, tests own the
+ * structure. The subset mirrors what agent replies actually emit: headings,
+ * emphasis, inline/fenced code, flat lists, blockquotes, links, rules, and
+ * wrapped paragraphs. Unknown syntax degrades to plain text (never throws).
+ *
+ * @module @deepseek-ai/dsh-code/render/markdown
+ */
+
+/** Style classes the renderer emits; the app maps them to colors/props. */
+export type MdStyle = 'plain' | 'bold' | 'italic' | 'boldItalic' | 'code' | 'accent' | 'dim' | 'strike'
+
+/** One styled run of text. */
+export interface MdSegment {
+  /** Visible text (no ANSI). */
+  text: string
+  /** Presentation class for the app's color map. */
+  style: MdStyle
+}
+
+/** One rendered line: a sequence of styled runs. */
+export interface MdLine {
+  segments: readonly MdSegment[]
+}
+
+/** Plain segment helper. */
+function seg(text: string, style: MdStyle = 'plain'): MdSegment {
+  return { text, style }
+}
+
+/** Visible width of a run in columns (CJK counts double). */
+export function visibleColumns(text: string): number {
+  let columns = 0
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0
+    columns += code > 0x2e7f ? 2 : 1
+  }
+  return columns
+}
+
+/** Walk a segment list, breaking it into lines that fit `width` columns. */
+function wrapSegments(segments: readonly MdSegment[], width: number): readonly MdSegment[][] {
+  const lines: MdSegment[][] = []
+  let current: MdSegment[] = []
+  let used = 0
+  for (const segment of segments) {
+    // Break the segment at spaces into words so long runs wrap mid-text.
+    const words = segment.text.split(/( )/u)
+    for (const word of words) {
+      if (word === '') continue
+      const columns = visibleColumns(word)
+      if (used + columns > width && used > 0) {
+        lines.push(current)
+        current = []
+        used = 0
+      }
+      // A single word wider than the line still goes on its own line.
+      current.push({ text: word, style: segment.style })
+      used += columns
+    }
+  }
+  if (current.length > 0) lines.push(current)
+  // Drop the trailing space a wrapped line picked up before the break.
+  return lines.map(line => {
+    const last = line[line.length - 1]
+    if (last !== undefined && last.text === ' ' && line.length > 1) return line.slice(0, -1)
+    return line
+  })
+}
+
+/** Join adjacent same-style runs so the app renders fewer elements. */
+function merge(segments: readonly MdSegment[]): readonly MdSegment[] {
+  const merged: MdSegment[] = []
+  for (const segment of segments) {
+    const last = merged[merged.length - 1]
+    if (last !== undefined && last.style === segment.style) {
+      merged[merged.length - 1] = { text: last.text + segment.text, style: last.style }
+    } else {
+      merged.push({ ...segment })
+    }
+  }
+  return merged
+}
+
+/** One parsed inline run before wrapping. */
+interface InlineRun {
+  text: string
+  style: MdStyle
+}
+
+/**
+ * Parse inline markdown in one line of text. Link destinations render as a
+ * dim `(url)` suffix — the visible text keeps the accent.
+ */
+function parseInline(text: string): readonly InlineRun[] {
+  const runs: InlineRun[] = []
+  let rest = text
+  while (rest !== '') {
+    const code = /^`([^`]+)`/u.exec(rest)
+    if (code !== null) {
+      runs.push({ text: code[1] ?? '', style: 'code' })
+      rest = rest.slice(code[0].length)
+      continue
+    }
+    const boldItalic = /^\*\*\*([^*]+)\*\*\*/u.exec(rest)
+    if (boldItalic !== null) {
+      runs.push({ text: boldItalic[1] ?? '', style: 'boldItalic' })
+      rest = rest.slice(boldItalic[0].length)
+      continue
+    }
+    const bold = /^\*\*([^*]+)\*\*/u.exec(rest)
+    if (bold !== null) {
+      runs.push({ text: bold[1] ?? '', style: 'bold' })
+      rest = rest.slice(bold[0].length)
+      continue
+    }
+    const italic = /^\*([^*]+)\*/u.exec(rest) ?? /^_([^_]+)_/u.exec(rest)
+    if (italic !== null) {
+      runs.push({ text: italic[1] ?? '', style: 'italic' })
+      rest = rest.slice(italic[0].length)
+      continue
+    }
+    const strike = /^~~([^~]+)~~/u.exec(rest)
+    if (strike !== null) {
+      runs.push({ text: strike[1] ?? '', style: 'strike' })
+      rest = rest.slice(strike[0].length)
+      continue
+    }
+    const link = /^\[([^\]]+)\]\(([^)\s]+)\)/u.exec(rest)
+    if (link !== null) {
+      const label = link[1] ?? ''
+      const url = link[2] ?? ''
+      runs.push({ text: label, style: 'accent' })
+      runs.push({ text: ` (${url})`, style: 'dim' })
+      rest = rest.slice(link[0].length)
+      continue
+    }
+    // Plain run up to the next special opener.
+    const next = rest.search(/[*_`~[]/u)
+    if (next === -1) {
+      runs.push({ text: rest, style: 'plain' })
+      break
+    }
+    if (next > 0) {
+      runs.push({ text: rest.slice(0, next), style: 'plain' })
+      rest = rest.slice(next)
+      continue
+    }
+    // A special opener at position 0 that no pattern consumed: emit it
+    // literally and advance, so unbalanced syntax never loops.
+    runs.push({ text: rest.slice(0, 1), style: 'plain' })
+    rest = rest.slice(1)
+  }
+  return runs
+}
+
+const HEADING = /^(#{1,6})\s+(.*)$/u
+const FENCE = /^```([^\s`]*)\s*$/u
+const RULE = /^(?:---|\*\*\*|___)\s*$/u
+const QUOTE = /^>\s?(.*)$/u
+const UNORDERED = /^\s*[-*+]\s+(.*)$/u
+const ORDERED = /^\s*(\d+)[.)]\s+(.*)$/u
+
+/** Render markdown text into styled lines of at most `width` columns. */
+export function renderMarkdown(text: string, width: number): readonly MdLine[] {
+  const lines: MdLine[] = []
+  const push = (segments: readonly MdSegment[]): void => {
+    for (const wrapped of wrapSegments(segments, Math.max(10, width))) {
+      lines.push({ segments: merge(wrapped) })
+    }
+  }
+  const raw = text.replaceAll('\r', '')
+  const source = raw.split('\n')
+  let index = 0
+  while (index < source.length) {
+    const line = source[index] ?? ''
+    index += 1
+
+    // Fenced code block: verbatim lines in code style, language label first.
+    const fence = FENCE.exec(line)
+    if (fence !== null) {
+      const language = fence[1] ?? ''
+      if (language !== '') push([seg(`  ${language}`, 'dim')])
+      while (index < source.length && !FENCE.test(source[index] ?? '')) {
+        push([seg(`  ${source[index] ?? ''}`, 'code')])
+        index += 1
+      }
+      index += 1 // closing fence
+      continue
+    }
+
+    if (line.trim() === '') continue
+    if (RULE.test(line.trim())) {
+      push([seg(`  ${'─'.repeat(Math.max(1, Math.floor(width / 4)))}`, 'dim')])
+      continue
+    }
+    const heading = HEADING.exec(line)
+    if (heading !== null) {
+      push([seg(heading[2] ?? '', 'accent')])
+      continue
+    }
+    const quote = QUOTE.exec(line)
+    if (quote !== null) {
+      push([seg('  │ ', 'accent'), ...parseInline(quote[1] ?? '').map(run => seg(run.text, run.style === 'plain' ? 'dim' : run.style))])
+      continue
+    }
+    const ordered = ORDERED.exec(line)
+    if (ordered !== null) {
+      push([seg(`  ${ordered[1] ?? ''}. `, 'accent'), ...parseInline(ordered[2] ?? '').map(run => seg(run.text, run.style))])
+      continue
+    }
+    const unordered = UNORDERED.exec(line)
+    if (unordered !== null) {
+      push([seg('  • ', 'accent'), ...parseInline(unordered[1] ?? '').map(run => seg(run.text, run.style))])
+      continue
+    }
+
+    // Paragraph: gather until a blank line, then wrap as one flow. Line
+    // breaks inside a paragraph join as a single space (GFM soft breaks).
+    const paragraph = [line]
+    while (index < source.length && (source[index] ?? '').trim() !== '') {
+      paragraph.push(source[index] ?? '')
+      index += 1
+    }
+    const runs: InlineRun[] = []
+    for (let at = 0; at < paragraph.length; at += 1) {
+      if (at > 0) runs.push({ text: ' ', style: 'plain' })
+      runs.push(...parseInline(paragraph[at] ?? ''))
+    }
+    push(runs.map(run => seg(run.text, run.style)))
+  }
+  return lines
+}