@@ -0,0 +1,8 @@
+---
+'@object-ui/app-shell': patch
+---
+
+Clause-②: no
+Metadata-protocol: none
+
+Marketplace package page: README blockquotes (`>` lines) render as quotes instead of printing their `>`, and a GitHub alert (`> [!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, `[!CAUTION]`) renders as the same plain quote without its marker. The Versions panel renders each version's release notes as Markdown (headings, bold, lists, code) in a compact size, instead of printing them as plain text; single line breaks inside a paragraph now join as Markdown does. Raw HTML stays skipped in both places.
@@ -8,6 +8,12 @@
  *   • `1. ` numbered lists (single level)
  *   • `**bold**`, `*italic*`, `` `code` ``, `[text](url)` inline
  *   • Triple-backtick fenced code blocks
+ *   • `>` blockquotes: consecutive `>` lines, their content parsed as blocks
+ *     (so a quote nests lists, code and further quotes). A GitHub alert —
+ *     `> [!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, `[!CAUTION]` on the
+ *     quote's first line — renders as the same plain quote with the marker
+ *     dropped. CommonMark's lazy continuation (an unprefixed line continuing a
+ *     quoted paragraph) is not read: an unprefixed line ends the quote.
  *
  * Deliberately NOT a full Markdown engine — we want zero new deps and
  * predictable output. If a README really needs tables or images, the
@@ -29,12 +35,26 @@
 import { RAW_HTML_CLOSING_TAG, RAW_HTML_OPEN_TAG, renderInlineMarkdown } from '@object-ui/components';
 
 interface Block {
-  type: 'h1' | 'h2' | 'h3' | 'p' | 'ul' | 'ol' | 'code' | 'html';
+  type: 'h1' | 'h2' | 'h3' | 'p' | 'ul' | 'ol' | 'code' | 'html' | 'quote';
   text?: string;
   items?: string[];
   lang?: string;
+  /** A blockquote's content, parsed as blocks. */
+  children?: Block[];
 }
 
+// ── Blockquotes ─────────────────────────────────────────────────────────────
+
+/** A blockquote line: up to three spaces of indent, then `>`. */
+const QUOTE_LINE = /^ {0,3}>/;
+/** The quote marker and the one optional space after it. */
+const QUOTE_MARKER = /^ {0,3}> ?/;
+/**
+ * GitHub's alert marker, alone on a quote's first line. GitHub matches the
+ * five types case-insensitively; anything else in brackets stays text.
+ */
+const ALERT_MARKER = /^\[!(?:NOTE|TIP|IMPORTANT|WARNING|CAUTION)\][ \t]*$/i;
+
 // ── CommonMark raw-HTML grammar ─────────────────────────────────────────────
 // The open and closing tag come from `@object-ui/components`, where the inline
 // "Raw HTML" pass that shares them lives; the block rules below build on them.
@@ -115,6 +135,19 @@ function parseBlocks(src: string): Block[] {
       continue;
     }
 
+    // Blockquote: the run of `>` lines, unprefixed, parsed as its own blocks.
+    // A GitHub alert's marker line is dropped, leaving a plain quote.
+    if (QUOTE_LINE.test(line)) {
+      const inner: string[] = [];
+      while (i < lines.length && QUOTE_LINE.test(lines[i])) {
+        inner.push(lines[i].replace(QUOTE_MARKER, ''));
+        i++;
+      }
+      if (ALERT_MARKER.test(inner[0])) inner.shift();
+      blocks.push({ type: 'quote', children: parseBlocks(inner.join('\n')) });
+      continue;
+    }
+
     // Headings
     const h = /^(#{1,3})\s+(.*)$/.exec(line);
     if (h) {
@@ -161,6 +194,7 @@ function parseBlocks(src: string): Block[] {
       !/^[-*]\s+/.test(lines[i]) &&
       !/^\d+\.\s+/.test(lines[i]) &&
       !lines[i].startsWith('```') &&
+      !QUOTE_LINE.test(lines[i]) &&
       !htmlBlockRule(lines[i])?.interruptsParagraph
     ) {
       buf.push(lines[i]);
@@ -188,51 +222,87 @@ function renderInline(input: string): React.ReactNode {
   return renderInlineMarkdown(input, README_INLINE);
 }
 
-export function MarkdownText({ source, className }: { source: string; className?: string }) {
-  const blocks = parseBlocks(source);
-  return (
-    <div className={`flex flex-col gap-4 text-sm leading-relaxed text-foreground/90 ${className ?? ''}`}>
-      {blocks.map((b, i) => {
-        switch (b.type) {
-          case 'h1':
-            return <h2 key={i} className="mt-2 text-xl font-bold tracking-tight">{renderInline(b.text ?? '')}</h2>;
-          case 'h2':
-            return <h3 key={i} className="mt-3 text-base font-semibold tracking-tight">{renderInline(b.text ?? '')}</h3>;
-          case 'h3':
-            return <h4 key={i} className="mt-2 text-sm font-semibold tracking-tight text-foreground/80">{renderInline(b.text ?? '')}</h4>;
-          case 'p':
-            return <p key={i}>{renderInline(b.text ?? '')}</p>;
-          case 'ul':
-            return (
-              <ul key={i} className="ml-1 flex list-none flex-col gap-1.5">
-                {(b.items ?? []).map((it, j) => (
-                  <li key={j} className="flex gap-2">
-                    <span aria-hidden="true" className="mt-1.5 inline-block h-1.5 w-1.5 shrink-0 rounded-full bg-violet-500/70" />
-                    <span>{renderInline(it)}</span>
-                  </li>
-                ))}
-              </ul>
-            );
-          case 'ol':
-            return (
-              <ol key={i} className="ml-5 flex list-decimal flex-col gap-1.5 marker:text-muted-foreground">
-                {(b.items ?? []).map((it, j) => (
-                  <li key={j} className="pl-1">{renderInline(it)}</li>
-                ))}
-              </ol>
-            );
-          case 'code':
-            return (
-              <pre key={i} className="overflow-x-auto rounded-lg border bg-muted/40 p-3 text-xs leading-relaxed">
-                <code className="font-mono">{b.text}</code>
-              </pre>
-            );
-          case 'html':
-            // Skipped: neither rendered nor printed (objectui#12146).
-            return null;
-        }
+/**
+ * The two places a package's Markdown is read: `base` is the About card's
+ * README, `compact` the Versions panel's release notes — a narrow side column
+ * in muted small print, where README-sized headings would outweigh the
+ * version they annotate.
+ */
+type MarkdownSize = 'base' | 'compact';
+
+const SIZE_CLASSES: Record<MarkdownSize, { root: string; stack: string; h1: string; h2: string; h3: string }> = {
+  base: {
+    root: 'text-sm leading-relaxed text-foreground/90',
+    stack: 'gap-4',
+    h1: 'mt-2 text-xl font-bold tracking-tight',
+    h2: 'mt-3 text-base font-semibold tracking-tight',
+    h3: 'mt-2 text-sm font-semibold tracking-tight text-foreground/80',
+  },
+  compact: {
+    root: 'text-xs leading-relaxed text-muted-foreground',
+    stack: 'gap-2',
+    h1: 'text-sm font-semibold tracking-tight text-foreground',
+    h2: 'text-xs font-semibold tracking-tight text-foreground',
+    h3: 'text-xs font-medium tracking-tight text-foreground/80',
+  },
+};
+
+function renderBlocks(blocks: Block[], size: MarkdownSize): React.ReactNode[] {
+  const cls = SIZE_CLASSES[size];
+  return blocks.map((b, i) => {
+    switch (b.type) {
+      case 'h1':
+        return <h2 key={i} className={cls.h1}>{renderInline(b.text ?? '')}</h2>;
+      case 'h2':
+        return <h3 key={i} className={cls.h2}>{renderInline(b.text ?? '')}</h3>;
+      case 'h3':
+        return <h4 key={i} className={cls.h3}>{renderInline(b.text ?? '')}</h4>;
+      case 'p':
+        return <p key={i}>{renderInline(b.text ?? '')}</p>;
+      case 'ul':
+        return (
+          <ul key={i} className="ml-1 flex list-none flex-col gap-1.5">
+            {(b.items ?? []).map((it, j) => (
+              <li key={j} className="flex gap-2">
+                <span aria-hidden="true" className="mt-1.5 inline-block h-1.5 w-1.5 shrink-0 rounded-full bg-violet-500/70" />
+                <span>{renderInline(it)}</span>
+              </li>
+            ))}
+          </ul>
+        );
+      case 'ol':
+        return (
+          <ol key={i} className="ml-5 flex list-decimal flex-col gap-1.5 marker:text-muted-foreground">
+            {(b.items ?? []).map((it, j) => (
+              <li key={j} className="pl-1">{renderInline(it)}</li>
+            ))}
+          </ol>
+        );
+      case 'code':
+        return (
+          <pre key={i} className="overflow-x-auto rounded-lg border bg-muted/40 p-3 text-xs leading-relaxed">
+            <code className="font-mono">{b.text}</code>
+          </pre>
+        );
+      case 'quote':
+        return (
+          <blockquote key={i} className={`flex flex-col ${cls.stack} border-l-2 border-violet-500/40 pl-4 text-muted-foreground`}>
+            {renderBlocks(b.children ?? [], size)}
+          </blockquote>
+        );
+      case 'html':
+        // Skipped: neither rendered nor printed (objectui#12146).
         return null;
-      })}
+    }
+    return null;
+  });
+}
+
+export function MarkdownText({ source, className, size = 'base' }: { source: string; className?: string; size?: MarkdownSize }) {
+  const cls = SIZE_CLASSES[size];
+  return (
+    <div className={`flex flex-col ${cls.stack} ${cls.root} ${className ?? ''}`}>
+      {renderBlocks(parseBlocks(source), size)}
     </div>
   );
 }
@@ -1441,7 +1441,7 @@ export function MarketplacePackagePage() {
                         </span>
                       </div>
                       {v.release_notes && v.release_notes.trim() && (
-                        <p className="whitespace-pre-line pl-5 text-xs text-muted-foreground">{v.release_notes.trim()}</p>
+                        <MarkdownText source={v.release_notes.trim()} size="compact" className="pl-5" />
                       )}
                     </li>
                   ))}
 
@@ -0,0 +1,117 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * A package README's `>` blockquotes render as quotes, and a GitHub alert
+ * (`> [!NOTE]` and its siblings) as the same plain quote without its marker.
+ *
+ * Seen on staging, on HotCRM 6.0.0's package page: the About card printed the
+ * README's opening quote with its leading `>` on every line, and its
+ * `> [!NOTE]` callout with the `[!NOTE]` marker as literal text, because
+ * `MarkdownText` had no blockquote rule and read the lines as a paragraph.
+ *
+ * The CONTROLS pin the edges: a `>` inside a fenced block is code, a bracketed
+ * word that is not one of GitHub's five alert types stays text, and the
+ * marker counts only on a quote's first line.
+ */
+
+import '@testing-library/jest-dom/vitest';
+import { describe, it, expect } from 'vitest';
+import { render } from '@testing-library/react';
+import { MarkdownText } from '../MarkdownText';
+
+/** HotCRM's README opening and its NOTE callout, as it publishes them. */
+const HOTCRM_README = [
+  '# HotCRM',
+  '',
+  '> **The ontology is the software.** One executable business ontology.',
+  '>',
+  '> 本体即软件。',
+  '',
+  'HotCRM is the reference implementation.',
+  '',
+  '> [!NOTE]',
+  '> **Small enough for an agent to hold whole.** The sales package carries **~68k tokens**.',
+  '> Measured, not estimated: `node scripts/check-source-token-ratchet.mjs` prints both figures.',
+].join('\n');
+
+function renderMd(source: string) {
+  return render(<MarkdownText source={source} />).container;
+}
+
+describe('a README with blockquotes', () => {
+  it('renders each quote as a blockquote, with no literal `>`', () => {
+    const root = renderMd(HOTCRM_README);
+
+    const quotes = root.querySelectorAll('blockquote');
+    expect(quotes).toHaveLength(2);
+    expect(root.textContent).not.toContain('>');
+
+    // The first quote: two paragraphs (the bare `>` line separates them), inline marks rendered.
+    const [first, second] = Array.from(quotes);
+    const paras = first.querySelectorAll(':scope > p');
+    expect(paras).toHaveLength(2);
+    expect(paras[0].querySelector('strong')?.textContent).toBe('The ontology is the software.');
+    expect(paras[0].textContent).toBe('The ontology is the software. One executable business ontology.');
+    expect(paras[1].textContent).toBe('本体即软件。');
+
+    // The paragraph between the quotes is outside both.
+    const between = Array.from(root.querySelectorAll(':scope > div > p')).map((p) => p.textContent);
+    expect(between).toEqual(['HotCRM is the reference implementation.']);
+
+    // The alert's two lines are one paragraph, as in any quote.
+    expect(second.querySelectorAll(':scope > p')).toHaveLength(1);
+    expect(second.querySelector('code')?.textContent).toBe('node scripts/check-source-token-ratchet.mjs');
+  });
+
+  it('drops the GitHub alert marker and keeps the quote', () => {
+    const root = renderMd(HOTCRM_README);
+    expect(root.textContent).not.toContain('[!NOTE]');
+    expect(root.textContent).not.toContain('NOTE');
+    const alert = root.querySelectorAll('blockquote')[1];
+    expect(alert.textContent).toMatch(/^Small enough for an agent to hold whole\. The sales package carries ~68k tokens\./);
+  });
+
+  it.each(['NOTE', 'TIP', 'IMPORTANT', 'WARNING', 'CAUTION', 'note', 'Warning'])('drops the %s marker', (type) => {
+    const root = renderMd(`> [!${type}]\n> Body.`);
+    expect(root.querySelector('blockquote')?.textContent).toBe('Body.');
+    expect(root.textContent).not.toContain('[!');
+  });
+
+  it('parses a quote’s content as blocks: a list and a nested quote inside it', () => {
+    const root = renderMd(['> Steps:', '>', '> - one', '> - two', '>', '> > nested'].join('\n'));
+    const outer = root.querySelector(':scope > div > blockquote')!;
+    expect(outer.querySelectorAll('li')).toHaveLength(2);
+    expect(outer.querySelector('blockquote')?.textContent).toBe('nested');
+    expect(root.textContent).not.toContain('>');
+  });
+
+  it('ends a paragraph where a quote starts, and a quote at the first unprefixed line', () => {
+    const root = renderMd('Intro line\n> quoted\nafter');
+    expect(root.querySelector('blockquote')?.textContent).toBe('quoted');
+    expect(Array.from(root.querySelectorAll(':scope > div > p')).map((p) => p.textContent)).toEqual(['Intro line', 'after']);
+  });
+});
+
+describe('controls', () => {
+  it('a `>` inside a fenced block is code', () => {
+    const root = renderMd('```\n> not a quote\n```');
+    expect(root.querySelector('blockquote')).toBeNull();
+    expect(root.querySelector('pre')?.textContent).toBe('> not a quote');
+  });
+
+  it('a bracketed word that is not an alert type stays text', () => {
+    const root = renderMd('> [!FOO]\n> Body.');
+    expect(root.querySelector('blockquote')?.textContent).toBe('[!FOO] Body.');
+  });
+
+  it('the marker counts only on the quote’s first line', () => {
+    const root = renderMd('> Body.\n>\n> [!NOTE]');
+    expect(root.querySelector('blockquote')?.textContent).toContain('[!NOTE]');
+  });
+
+  it('raw HTML inside a quote is still skipped', () => {
+    const root = renderMd('> <div align="center">\n> <img src="x.svg">\n> </div>\n>\n> Text.');
+    expect(root.querySelector('img')).toBeNull();
+    expect(root.querySelector('blockquote')?.textContent).toBe('Text.');
+  });
+});