diff --git a/CHANGELOG.md b/CHANGELOG.md
index af36953..2e8babc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,17 @@
 All notable changes to Sumbee are documented here. This project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## [Unreleased]
+
+### Added
+- **In-app HTML viewer.** HTML summaries now render with their own styling inside the preview pane
+  instead of falling back to plain text. The viewer is deliberately basic and private: it does not
+  run the document's JavaScript, blocks remote network loads, persists no cookies or cache, and
+  opens link clicks in your browser; the preview font controls zoom it. When a summary uses
+  interactive or dynamic features (scripts, embeds, media, forms), a **View in Browser** button
+  appears in the top right for the full experience. (FR-047 to FR-052; see
+  `specs/003-html-preview-viewer/`)
+
 ## [0.2.7] - 2026-06-22
 
 ### Fixed
diff --git a/README.md b/README.md
index 04306ac..21ec780 100644
--- a/README.md
+++ b/README.md
@@ -58,8 +58,11 @@ uploads or sees your library. No proprietary format, no lock-in.
   toolbar; the size sticks across sessions and scales headings proportionally.
 - **Secure key storage** in the macOS Keychain; summarizing is gated until a valid key is set, and
   re-gated automatically on an auth failure.
-- **Markdown or HTML output**, with an optional shared HTML-styling prompt. The Markdown preview
-  renders tables and clickable links; drag a summary to Finder, or **space-bar Quick Look** it.
+- **Markdown or HTML output**, with an optional shared HTML-styling prompt. Both render in-app: the
+  Markdown preview renders tables and clickable links, and HTML summaries render with their own
+  styling in a built-in viewer that stays basic and private (no scripts run, no remote loads, link
+  clicks open in your browser). Interactive HTML gets a one-click **View in Browser** button. Drag a
+  summary to Finder, or **space-bar Quick Look** it.
 - **Geek mode.** Flip it on in the bottom bar to preview the exact prompt and an estimated token
   count before each summary is sent.
 - **Model-capability aware:** defaults to the latest Claude model and only sends parameters a given
diff --git a/Sources/SumbeeKit/Services/HTMLFeatureScanner.swift b/Sources/SumbeeKit/Services/HTMLFeatureScanner.swift
new file mode 100644
index 0000000..b40cd6a
--- /dev/null
+++ b/Sources/SumbeeKit/Services/HTMLFeatureScanner.swift
@@ -0,0 +1,60 @@
+import Foundation
+
+/// Detects "advanced" constructs in a saved HTML summary that the in-app, static, JavaScript-free
+/// preview won't execute (FR-050). When any are present, the UI offers a "View in Browser" escape
+/// hatch (FR-051) so the user gets the full experience in their real browser.
+///
+/// The scan is intentionally a cheap, case-insensitive text match on the raw document, not a full
+/// HTML parse: deciding "is there a `<script>`/`<iframe>`/…" does not require a DOM. Plain anchor
+/// links (`<a href>`) are normal content and never count - notably the centered grey source link
+/// the app stamps into YouTube HTML (`HTMLMetaCodec.insertSourceLink`) must not trip the detector.
+public enum HTMLFeatureScanner {
+    public struct Result: Equatable {
+        /// True when at least one advanced construct was found.
+        public let hasAdvancedFeatures: Bool
+        /// Friendly, deduped, stable-ordered labels (e.g. ["JavaScript", "Media"]) for tooltips.
+        public let features: [String]
+
+        public init(hasAdvancedFeatures: Bool, features: [String]) {
+            self.hasAdvancedFeatures = hasAdvancedFeatures
+            self.features = features
+        }
+    }
+
+    /// One detectable category: a friendly label plus the lowercased tokens that imply it.
+    private struct Category {
+        let label: String
+        let tokens: [String]
+    }
+
+    // Order here is the stable order of `features` in the result.
+    private static let categories: [Category] = [
+        Category(label: "JavaScript", tokens: ["<script"]),
+        Category(label: "Embedded content", tokens: ["<iframe", "<embed", "<object"]),
+        Category(label: "Media", tokens: ["<video", "<audio"]),
+        Category(label: "Graphics", tokens: ["<canvas"]),
+        Category(label: "Interactive controls",
+                 tokens: ["<form", "<input", "<button", "<select", "<textarea"]),
+    ]
+
+    /// Matches an inline event handler attribute (`onclick=`, `onload=`, …). The leading boundary
+    /// (whitespace, quote, or `<`/tag char) keeps it from matching words that merely contain "on".
+    private static let eventHandler = try! NSRegularExpression(
+        pattern: "[\\s\"'/]on[a-z]+\\s*=", options: [.caseInsensitive])
+
+    public static func scan(_ html: String) -> Result {
+        let lower = html.lowercased()
+        var found: [String] = []
+
+        for category in categories where category.tokens.contains(where: { lower.contains($0) }) {
+            found.append(category.label)
+        }
+
+        let range = NSRange(lower.startIndex..<lower.endIndex, in: lower)
+        if eventHandler.firstMatch(in: lower, options: [], range: range) != nil {
+            found.append("Scripted handlers")
+        }
+
+        return Result(hasAdvancedFeatures: !found.isEmpty, features: found)
+    }
+}
diff --git a/Sources/SumbeeKit/Views/AssetBrowser/HTMLWebView.swift b/Sources/SumbeeKit/Views/AssetBrowser/HTMLWebView.swift
new file mode 100644
index 0000000..7c68fe2
--- /dev/null
+++ b/Sources/SumbeeKit/Views/AssetBrowser/HTMLWebView.swift
@@ -0,0 +1,150 @@
+import SwiftUI
+import WebKit
+import AppKit
+
+/// A basic, read-only, *static* in-app viewer for an HTML summary (FR-047).
+///
+/// It renders the model's self-contained HTML with its own styling, but deliberately is **not** a
+/// browser (FR-048): JavaScript is disabled, remote network loads are blocked, nothing is persisted
+/// to disk, and link clicks open in the user's real browser. Documents that need more (scripts,
+/// embeds, media, forms) are flagged by `HTMLFeatureScanner` so the UI can offer "View in Browser".
+///
+/// Threading note (this was a real "first HTML renders blank" bug): every `WKWebView` /
+/// `WKUserContentController` mutation, `loadHTMLString` included, MUST happen on the main thread. The
+/// remote-load rule list compiles asynchronously and its completion handler is not guaranteed to run
+/// on main, so we hop to main before installing the rule and issuing the load. The load stays gated
+/// behind rule installation, so the document is never painted before the remote-load block is active.
+struct HTMLWebView: NSViewRepresentable {
+    let html: String
+    /// The preview toolbar's base font size; mapped to page zoom (16pt == 1.0). (FR-049)
+    var baseSize: Double
+
+    private var zoom: CGFloat { max(0.6, min(2.0, CGFloat(baseSize / 16.0))) }
+
+    func makeCoordinator() -> Coordinator { Coordinator() }
+
+    func makeNSView(context: Context) -> WKWebView {
+        // Keep a strong reference to the content controller we create: `WKWebView.configuration`
+        // returns a *copy*, so a rule list added to it post-init wouldn't reach the live view.
+        let controller = WKUserContentController()
+
+        let config = WKWebViewConfiguration()
+        config.userContentController = controller
+        config.websiteDataStore = .nonPersistent()                        // no cookies/cache on disk
+        config.defaultWebpagePreferences.allowsContentJavaScript = false  // static, JS-free render
+
+        let webView = WKWebView(frame: .zero, configuration: config)
+        webView.navigationDelegate = context.coordinator
+        webView.pageZoom = zoom
+
+        context.coordinator.controller = controller
+        context.coordinator.render(html, on: webView)
+        return webView
+    }
+
+    func updateNSView(_ webView: WKWebView, context: Context) {
+        webView.pageZoom = zoom
+        context.coordinator.render(html, on: webView)
+    }
+
+    final class Coordinator: NSObject, WKNavigationDelegate {
+        private var currentHTML = ""
+        private var loadedHTML: String?
+        var controller: WKUserContentController?
+        private var didInitialLoad = false
+        private var ruleState: RuleState = .pending
+
+        private enum RuleState { case pending, installing, ready }
+
+        /// Record the latest requested document and, once the remote-load block is installed on this
+        /// controller, load it. The load is always issued on the main thread (callers are the SwiftUI
+        /// make/update cycle; the install completion hops to main), which fixes the blank-first-render
+        /// bug, and stays gated behind installation so nothing paints before remote loads are blocked.
+        func render(_ html: String, on webView: WKWebView) {
+            currentHTML = html
+            switch ruleState {
+            case .ready:
+                loadIfNeeded(into: webView)
+            case .installing:
+                break                                   // the install completion loads the latest doc
+            case .pending:
+                ruleState = .installing
+                guard let controller else { ruleState = .ready; loadIfNeeded(into: webView); return }
+                RemoteResourceBlock.install(on: controller) { [weak self, weak webView] in
+                    guard let self, let webView else { return }   // always invoked on the main thread
+                    self.ruleState = .ready
+                    self.loadIfNeeded(into: webView)
+                }
+            }
+        }
+
+        /// Load the current document once per distinct, non-empty value: skips the transient "" that
+        /// appears while the file is read, and avoids reloading the same doc on a zoom change.
+        private func loadIfNeeded(into webView: WKWebView) {
+            let html = currentHTML
+            guard !html.isEmpty, html != loadedHTML else { return }
+            loadedHTML = html
+            didInitialLoad = false
+            // baseURL nil: model HTML is self-contained; no surprise relative/remote resolution.
+            webView.loadHTMLString(html, baseURL: nil)
+        }
+
+        func webView(_ webView: WKWebView,
+                     decidePolicyFor navigationAction: WKNavigationAction,
+                     decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+            // A clicked hyperlink opens in the user's browser; the in-app pane never navigates away.
+            if navigationAction.navigationType == .linkActivated {
+                if let url = navigationAction.request.url,
+                   let scheme = url.scheme?.lowercased(),
+                   scheme == "http" || scheme == "https" || scheme == "mailto" {
+                    NSWorkspace.shared.open(url)
+                }
+                decisionHandler(.cancel)                // (in-doc about:blank#anchor clicks just no-op)
+                return
+            }
+            // Allow exactly the first programmatic document load; cancel any later navigation.
+            if didInitialLoad {
+                decisionHandler(.cancel)
+            } else {
+                didInitialLoad = true
+                decisionHandler(.allow)
+            }
+        }
+    }
+}
+
+/// Best-effort `WKContentRuleList` that blocks remote (`http`/`https`) loads so the static preview
+/// never auto-fetches remote images/fonts/trackers (FR-048, privacy). The filter is scoped to
+/// `http(s)` so the in-memory document (`about:blank`/`data:`) is never matched and never blanked.
+/// JavaScript is disabled regardless, so a compile failure degrades safely. Compiled once, cached.
+///
+/// All state here is read/written on the main thread only: `install` is called from the SwiftUI
+/// make/update cycle, and the (possibly off-main) compile completion hops to main before touching
+/// `cached` or the controller. `completion` is therefore always invoked on the main thread.
+private enum RemoteResourceBlock {
+    private static let identifier = "sumbee.preview.block-remote.v1"
+    private static let encodedRules =
+        #"[{"trigger":{"url-filter":"^https?://"},"action":{"type":"block"}}]"#
+    private static var cached: WKContentRuleList?
+
+    static func install(on controller: WKUserContentController, completion: @escaping () -> Void) {
+        if let cached {
+            controller.add(cached)
+            completion()
+            return
+        }
+        guard let store = WKContentRuleListStore.default() else { completion(); return }
+        store.compileContentRuleList(forIdentifier: identifier,
+                                     encodedContentRuleList: encodedRules) { [weak controller] list, _ in
+            // The compile completion thread is not guaranteed to be main; hop before any WebKit
+            // mutation or the gated content load. This is the core fix for the blank-first-render bug.
+            DispatchQueue.main.async {
+                if let list {
+                    cached = list
+                    controller?.add(list)
+                }
+                completion()   // best-effort: render even if the rule list failed to compile
+            }
+        }
+    }
+}
diff --git a/Sources/SumbeeKit/Views/AssetBrowser/MarkdownPreview.swift b/Sources/SumbeeKit/Views/AssetBrowser/MarkdownPreview.swift
index 042b940..6d39298 100644
--- a/Sources/SumbeeKit/Views/AssetBrowser/MarkdownPreview.swift
+++ b/Sources/SumbeeKit/Views/AssetBrowser/MarkdownPreview.swift
@@ -11,6 +11,8 @@ struct PreviewPane: View {
 
     @EnvironmentObject private var state: AppState
     @State private var content: String = ""
+    @State private var htmlRaw: String = ""
+    @State private var htmlFeatures = HTMLFeatureScanner.Result(hasAdvancedFeatures: false, features: [])
     @State private var keyMonitor: Any?
     @State private var showRegenerate = false
 
@@ -24,10 +26,16 @@ struct PreviewPane: View {
             } else if let asset {
                 toolbar(asset)
                 Divider().overlay(Theme.hairline)
-                ScrollView {
-                    MarkdownText(raw: content, baseSize: state.settings.previewFontSize)
-                        .padding(16)
-                        .frame(maxWidth: .infinity, alignment: .leading)
+                if asset.format == .html {
+                    // Basic, static, private in-app HTML viewer (FR-047/048); it scrolls internally.
+                    HTMLWebView(html: htmlRaw, baseSize: state.settings.previewFontSize)
+                        .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else {
+                    ScrollView {
+                        MarkdownText(raw: content, baseSize: state.settings.previewFontSize)
+                            .padding(16)
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                    }
                 }
             } else {
                 placeholder
@@ -84,6 +92,12 @@ struct PreviewPane: View {
                 .font(.uiBody.weight(.semibold))
                 .lineLimit(1)
             Spacer()
+            // For HTML with interactive/dynamic features the static viewer can't run, offer the
+            // browser (FR-051). Kept top-right and clearly labeled.
+            if asset.format == .html && htmlFeatures.hasAdvancedFeatures {
+                viewInBrowserButton(asset)
+                Divider().frame(height: 16).overlay(Theme.hairline)
+            }
             iconButton("textformat.size.smaller", "Decrease font size") { adjustFont(-1) }
                 .disabled(state.settings.previewFontSize <= Self.minFont)
             iconButton("textformat.size.larger", "Increase font size") { adjustFont(1) }
@@ -107,6 +121,29 @@ struct PreviewPane: View {
         .padding(.vertical, 8)
     }
 
+    /// A labeled, accent "View in Browser" action shown for HTML summaries with advanced features.
+    private func viewInBrowserButton(_ asset: Asset) -> some View {
+        Button { NSWorkspace.shared.open(asset.url) } label: {
+            HStack(spacing: 4) {
+                Image(systemName: "globe")
+                Text("View in Browser")
+            }
+            .font(.uiCallout.weight(.semibold))
+        }
+        .buttonStyle(.plain)
+        .foregroundStyle(Theme.accent)
+        .help(browserHelp)
+        .accessibilityLabel("View in Browser")
+    }
+
+    /// Tooltip naming the detected features so the user knows why the escape hatch is offered.
+    private var browserHelp: String {
+        let f = htmlFeatures.features
+        guard !f.isEmpty else { return "Open this summary in your browser" }
+        let list = f.map { $0.lowercased() }.joined(separator: ", ")
+        return "This summary uses \(list); open it in your browser for the full experience."
+    }
+
     /// Adjust the sticky preview base font size (FR-036) and persist it.
     private func adjustFont(_ delta: Double) {
         let v = min(max(state.settings.previewFontSize + delta, Self.minFont), Self.maxFont)
@@ -131,6 +168,8 @@ struct PreviewPane: View {
     }
 
     private func load() {
+        htmlRaw = ""
+        htmlFeatures = HTMLFeatureScanner.Result(hasAdvancedFeatures: false, features: [])
         guard let asset else { content = ""; return }
         guard let raw = try? String(contentsOf: asset.url, encoding: .utf8) else {
             content = "_Couldn’t read this file._"
@@ -140,8 +179,11 @@ struct PreviewPane: View {
         case .markdown:
             content = FrontmatterCodec.parse(raw).body
         case .html:
-            content = "HTML summary. Use **Open** to view it styled in your browser.\n\n"
-                + VTTParser.stripTags(raw)   // reuse tag stripper for a plain-text fallback
+            // Render the document itself in the in-app web viewer (FR-047) and decide whether to
+            // surface "View in Browser" based on its features (FR-050/051).
+            content = ""
+            htmlRaw = raw
+            htmlFeatures = HTMLFeatureScanner.scan(raw)
         }
     }
 }
diff --git a/Tests/SumbeeKitTests/HTMLFeatureScannerTests.swift b/Tests/SumbeeKitTests/HTMLFeatureScannerTests.swift
new file mode 100644
index 0000000..486d678
--- /dev/null
+++ b/Tests/SumbeeKitTests/HTMLFeatureScannerTests.swift
@@ -0,0 +1,82 @@
+import XCTest
+@testable import SumbeeKit
+
+final class HTMLFeatureScannerTests: XCTestCase {
+
+    // Plain styled prose/tables/lists with inline CSS is the common, "basic" case: not advanced.
+    func testPlainStyledHTMLIsNotAdvanced() {
+        let html = """
+        <!DOCTYPE html><html><head><style>body{font-family:serif;color:#222}</style></head>
+        <body><h1>Q2 Roadmap</h1><p>Decisions and next steps.</p>
+        <table><tr><th>Owner</th><th>Task</th></tr><tr><td>Wynn</td><td>Spec</td></tr></table>
+        <ul><li>Ship preview</li></ul></body></html>
+        """
+        let r = HTMLFeatureScanner.scan(html)
+        XCTAssertFalse(r.hasAdvancedFeatures)
+        XCTAssertTrue(r.features.isEmpty)
+    }
+
+    // The KEY false-positive guard: a plain anchor link - including the stamped grey source link -
+    // must NOT make a document "advanced".
+    func testAnchorAndSourceLinkAreNotAdvanced() {
+        let html = """
+        <!DOCTYPE html><html><body><h1>Video notes</h1><p>See <a href="https://example.com">docs</a>.</p>
+        <p style="text-align:center;margin:2.5em 0 1em">
+        <a href="https://www.youtube.com/watch?v=abc123" style="color:#888;text-decoration:underline">\
+        https://www.youtube.com/watch?v=abc123</a></p></body></html>
+        """
+        let r = HTMLFeatureScanner.scan(html)
+        XCTAssertFalse(r.hasAdvancedFeatures, "anchor links must not count as advanced")
+    }
+
+    func testScriptIsAdvanced() {
+        let r = HTMLFeatureScanner.scan("<html><body><script>document.title='x'</script></body></html>")
+        XCTAssertTrue(r.hasAdvancedFeatures)
+        XCTAssertEqual(r.features, ["JavaScript"])
+    }
+
+    func testIframeEmbedObjectAreEmbeddedContent() {
+        XCTAssertEqual(HTMLFeatureScanner.scan("<iframe src='x'></iframe>").features, ["Embedded content"])
+        XCTAssertEqual(HTMLFeatureScanner.scan("<embed src='x'>").features, ["Embedded content"])
+        XCTAssertEqual(HTMLFeatureScanner.scan("<object data='x'></object>").features, ["Embedded content"])
+    }
+
+    func testMediaIsAdvanced() {
+        XCTAssertEqual(HTMLFeatureScanner.scan("<video controls></video>").features, ["Media"])
+        XCTAssertEqual(HTMLFeatureScanner.scan("<audio src='a.mp3'></audio>").features, ["Media"])
+    }
+
+    func testCanvasIsGraphics() {
+        XCTAssertEqual(HTMLFeatureScanner.scan("<canvas id='c'></canvas>").features, ["Graphics"])
+    }
+
+    func testFormControlsAreInteractive() {
+        XCTAssertEqual(HTMLFeatureScanner.scan("<form><input type='text'></form>").features,
+                       ["Interactive controls"])
+        XCTAssertEqual(HTMLFeatureScanner.scan("<select><option>a</option></select>").features,
+                       ["Interactive controls"])
+    }
+
+    func testInlineEventHandlerIsScriptedHandler() {
+        let r = HTMLFeatureScanner.scan("<div onclick=\"go()\">tap</div>")
+        XCTAssertTrue(r.hasAdvancedFeatures)
+        XCTAssertEqual(r.features, ["Scripted handlers"])
+    }
+
+    // "on" inside ordinary attribute values / words must not be mistaken for an event handler.
+    func testWordContainingOnIsNotAHandler() {
+        let r = HTMLFeatureScanner.scan("<p class=\"section\">Companion notes, onboarding.</p>")
+        XCTAssertFalse(r.hasAdvancedFeatures)
+    }
+
+    // Multiple categories: labels are present, deduped, and in stable (declaration) order.
+    func testMultipleFeaturesAreDedupedAndOrdered() {
+        let html = "<script></script><script></script><video></video><div onmouseover='x'></div>"
+        let r = HTMLFeatureScanner.scan(html)
+        XCTAssertEqual(r.features, ["JavaScript", "Media", "Scripted handlers"])
+    }
+
+    func testDetectionIsCaseInsensitive() {
+        XCTAssertTrue(HTMLFeatureScanner.scan("<BODY><SCRIPT>x</SCRIPT></BODY>").hasAdvancedFeatures)
+    }
+}
diff --git a/docs/swift-macos-learnings.md b/docs/swift-macos-learnings.md
index cd4f430..dc169fe 100644
--- a/docs/swift-macos-learnings.md
+++ b/docs/swift-macos-learnings.md
@@ -73,6 +73,22 @@ permissions, the library list, fonts, icons, or shell scripts. Each entry: **Sym
 - **Symptom**: a `TextEditor` over a material looked like a flat white/gray box.
 - **Rule**: add `.scrollContentBackground(.hidden)` so the material/background shows through.
 
+### 18. A `WKWebView` loaded off the main thread silently renders a blank page
+- **Symptom**: the *first* HTML summary opened in a session showed a blank white page; the next one
+  rendered fine, and returning to the first then worked too (100% repro).
+- **Cause**: the in-app HTML viewer gated its first `loadHTMLString` behind a one-time
+  `WKContentRuleListStore.compileContentRuleList(...)` (the remote-load privacy block). That
+  completion handler is **not guaranteed to run on the main thread**, so the first document's only
+  load (and the `WKUserContentController.add`) executed off-main. `WKWebView` is main-thread-only;
+  off-main calls are undefined behavior and here just painted nothing. Every later load came from the
+  SwiftUI `updateNSView` pass (main thread) once the rule list was cached, hence "only the first".
+- **Rule**: treat every `WKWebView`/`WKUserContentController` mutation (including `loadHTMLString`)
+  as main-thread-only. Any async completion that drives them (rule-list compile, file read, network)
+  must `DispatchQueue.main.async` before touching WebKit. If you gate the first paint on async setup
+  for a good reason (we gate on the remote-load block for privacy), keep the gate but make the
+  resumed load run on main. Verified by independent adversarial review: the naive fix (load eagerly,
+  ungated) reintroduced a privacy hole by painting before the block installed.
+
 ## Layout & typography
 
 ### 10. `.dynamicTypeSize` barely scales macOS's built-in text styles
diff --git a/screenshots/screen-01-app.png b/screenshots/screen-01-app.png
index 3f43d90..f491a5a 100644
Binary files a/screenshots/screen-01-app.png and b/screenshots/screen-01-app.png differ
diff --git a/screenshots/screen-02-settings-generation.png b/screenshots/screen-02-settings-generation.png
index bc80e60..4da058b 100644
Binary files a/screenshots/screen-02-settings-generation.png and b/screenshots/screen-02-settings-generation.png differ
diff --git a/screenshots/screen-03-styles.png b/screenshots/screen-03-styles.png
index adedad4..122a9ab 100644
Binary files a/screenshots/screen-03-styles.png and b/screenshots/screen-03-styles.png differ
diff --git a/screenshots/screen-04-output.png b/screenshots/screen-04-output.png
index a43446d..bfe562a 100644
Binary files a/screenshots/screen-04-output.png and b/screenshots/screen-04-output.png differ
diff --git a/specs/003-html-preview-viewer/plan.md b/specs/003-html-preview-viewer/plan.md
new file mode 100644
index 0000000..2ad019f
--- /dev/null
+++ b/specs/003-html-preview-viewer/plan.md
@@ -0,0 +1,108 @@
+# Implementation Plan: In-app HTML preview viewer
+
+**Spec**: `spec.md`  ·  **Decisions**: `research.md`  ·  **Tasks**: `tasks.md`
+
+## Summary
+
+Replace the plain-text HTML fallback in the preview pane with a basic, static, private `WKWebView`
+viewer, add a deterministic advanced-feature scan, and surface a top-right **"View in Browser"**
+button when advanced features are present. No new dependency (WebKit is an Apple framework).
+
+## Architecture & touch points
+
+```
+Sources/SumbeeKit/
+  Services/
+    HTMLFeatureScanner.swift        # NEW  pure, testable: scan(html) -> Result{advanced, labels}
+  Views/AssetBrowser/
+    HTMLWebView.swift               # NEW  NSViewRepresentable around WKWebView (JS off, no remote,
+                                    #      nonPersistent store, link clicks -> browser, pageZoom)
+    MarkdownPreview.swift           # EDIT PreviewPane: branch .html -> HTMLWebView; toolbar gains a
+                                    #      conditional top-right "View in Browser" button
+Tests/SumbeeKitTests/
+    HTMLFeatureScannerTests.swift   # NEW  detector unit tests incl. anchor-link false-positive guard
+```
+
+Everything else (AppState, LibraryStore, Asset model, streaming, settings) is untouched. The
+viewer reads the file the same way `load()` already does.
+
+## Component contracts
+
+### `HTMLFeatureScanner` (Services)
+
+```swift
+public enum HTMLFeatureScanner {
+    public struct Result: Equatable {
+        public let hasAdvancedFeatures: Bool
+        public let features: [String]      // friendly labels, deduped, stable order
+    }
+    public static func scan(_ html: String) -> Result
+}
+```
+
+- Pure, synchronous, no I/O. Case-insensitive. Anchor `<a>` never contributes.
+- `features` drives the button's help/tooltip text; `hasAdvancedFeatures == !features.isEmpty`.
+
+### `HTMLWebView` (Views)
+
+```swift
+struct HTMLWebView: NSViewRepresentable {   // NSViewRepresentable
+    let html: String
+    var baseSize: Double                      // -> pageZoom = clamp(baseSize/16, 0.6...2.0)
+}
+```
+
+- `makeNSView`: build `WKWebViewConfiguration` (JS off, `.nonPersistent()` store), attach the
+  cached/compiled `WKContentRuleList` blocking `^https?://` (best-effort), set `navigationDelegate`,
+  `loadHTMLString(html, baseURL: nil)`.
+- `updateNSView`: apply `pageZoom`; reload only if `html` changed.
+- `Coordinator: WKNavigationDelegate`: allow the first programmatic load; `.linkActivated` →
+  `NSWorkspace.shared.open(url)` + `.cancel`; any later main-frame navigation → `.cancel`.
+
+### `PreviewPane` (edits)
+
+- `load()`: for `.html`, store the **raw** file text (for the web view) and compute
+  `HTMLFeatureScanner.scan(...)`; for `.markdown`, unchanged.
+- `body`: when `asset.format == .html` and not streaming, show `HTMLWebView(html:baseSize:)` inside
+  the existing scroll area instead of `MarkdownText`. Markdown path unchanged.
+- `toolbar`: after the title `Spacer()`, add a labeled "View in Browser" button **only** when
+  `asset.format == .html && htmlFeatures.hasAdvancedFeatures`. Existing icon buttons remain.
+- Font +/- buttons stay enabled for HTML (they now drive `pageZoom`).
+
+## Security / privacy checklist (maps to FR-048 / US3)
+
+- [ ] `allowsContentJavaScript = false`
+- [ ] `websiteDataStore = .nonPersistent()`
+- [ ] content rule list blocks `^https?://` (best-effort, scoped so the local doc never matches)
+- [ ] link clicks + stray navigations cancelled; links open via `NSWorkspace`
+- [ ] `baseURL: nil` (no implicit relative/remote resolution)
+
+## Testing
+
+- **Unit (added)**: `HTMLFeatureScannerTests` - plain styled HTML → not advanced; `<script>`,
+  `<iframe>`, `<video>`, `<canvas>`, `<form>`/`<input>`, inline `onclick` → advanced with the right
+  labels; **anchor-only / source-link footer → not advanced** (false-positive guard); labels are
+  deduped/stable.
+- **Build/verify**: `swift build` (0 warnings), `swift test` (all green). No app launch (Keychain;
+  learnings #3/#4) - user validates render from the PR build.
+- The `WKWebView` wiring is not unit-tested (UI/system view); it is kept small and reviewed against
+  `research.md` D-B.
+
+## Risks & mitigations
+
+- *No local visual check*: detector is fully unit-tested; web-view code minimized and documented.
+- *Content rule list*: scoped to `http(s)`, compile failure is non-fatal (JS-off remains).
+- *Dark mode*: model HTML carries its own background; a light document on a dark app is expected
+  (same as Quick Look / a browser). Not forced.
+
+## Rollback
+
+Self-contained: deleting `HTMLWebView.swift` + `HTMLFeatureScanner.swift` and reverting the
+`MarkdownPreview.swift` edit restores the plain-text fallback. No persistence/format changes.
+
+## Docs to update on completion
+
+- `CHANGELOG.md` (Unreleased / next version - release is a separate, user-initiated step).
+- `README.md` features bullet for HTML preview (the Markdown-preview bullet currently implies HTML
+  is browser-only).
+- `specs/003-html-preview-viewer/*` kept current (this set).
diff --git a/specs/003-html-preview-viewer/research.md b/specs/003-html-preview-viewer/research.md
new file mode 100644
index 0000000..ff929f3
--- /dev/null
+++ b/specs/003-html-preview-viewer/research.md
@@ -0,0 +1,97 @@
+# Research & Decisions: In-app HTML preview viewer
+
+Decisions are lettered `D-A…` to stay distinct from `001`'s `D1–D16`.
+
+## D-A. Render engine: `WKWebView` (WebKit)
+
+- **Decision**: Render the saved HTML in a `WKWebView` wrapped as an `NSViewRepresentable`.
+- **Alternatives rejected**:
+  - *Reuse `MarkdownText`*: cannot honor the document's own CSS; the whole point of HTML output is
+    custom styling.
+  - *`NSAttributedString(html:)`*: lossy and slow for full documents; ignores most CSS; deprecated
+    threading caveats. Not faithful.
+  - *Hand-rolled HTML→SwiftUI renderer*: large surface, perpetual fidelity gap, not "lightweight".
+- **Dependency note**: WebKit is an Apple **system framework** (`import WebKit`), linked
+  automatically. This does **not** violate the "zero third-party runtime deps" rule (it is the same
+  category as AppKit / PDFKit / Quartz already used).
+
+## D-B. Static & private by default (the "basic viewer" posture)
+
+The viewer is deliberately *not* a browser. Three guards, each cheap:
+
+1. **JavaScript off** - `configuration.defaultWebpagePreferences.allowsContentJavaScript = false`.
+   The static styled document renders; scripts simply don't run. This is what makes the in-app view
+   "basic" and is why script-bearing docs get the "View in Browser" escape (D-E).
+2. **No remote network egress** - a `WKContentRuleList` blocking `^https?://` loads, so remote
+   images/fonts/trackers are not auto-fetched. Scoped to `http(s)` only, so the in-memory document
+   (`about:blank` / `data:`) is never matched and never blanked. Best-effort: if the rule list fails
+   to compile, the viewer still renders (JS is still off). Honors the local-first promise (`001`).
+3. **No on-disk state** - `configuration.websiteDataStore = .nonPersistent()` (no cookies/cache).
+
+Link clicks are routed out: the `WKNavigationDelegate` cancels `.linkActivated` navigations and
+hands the URL to `NSWorkspace.shared.open`, and cancels any other main-frame navigation after the
+initial programmatic load. So the pane only ever shows the one summary.
+
+**Main-thread loading (and the gate).** Every `WKWebView`/`WKUserContentController` mutation,
+`loadHTMLString` included, runs on the main thread. The async rule-list compile completion is **not
+guaranteed** to be on main, so it hops via `DispatchQueue.main.async` before installing the rule and
+resuming the (gated) first load. The first paint stays gated behind rule installation so a document
+is never shown before remote loads are blocked. (A first cut loaded from the off-main compile
+completion and rendered the first document blank; a naive "load eagerly, ungated" fix then
+reintroduced a remote-load privacy hole. See learnings #18.)
+
+- **Load method**: `loadHTMLString(html, baseURL: nil)`. Keeping `baseURL` nil means relative paths
+  don't resolve - acceptable because model output is self-contained, and it reinforces "no remote
+  fetch by surprise". (In-document `#anchor` jumps may be inert; minor, acceptable for a basic
+  viewer.)
+
+## D-C. Zoom reuses the existing `previewFontSize`
+
+`WKWebView.pageZoom` maps cleanly from the existing preview base size: `zoom = baseSize / 16`,
+clamped to `[0.6, 2.0]`. The existing toolbar +/- buttons therefore work for HTML with no new
+setting and the size persists exactly as it does for Markdown (`001` FR-036).
+
+## D-D. Advanced-feature detection - a deterministic, testable scan
+
+A pure function `HTMLFeatureScanner.scan(_:) -> Result` flags constructs the static viewer won't
+execute, grouped into friendly labels for tooltips:
+
+| Label                | Triggers (case-insensitive)                                  |
+|----------------------|--------------------------------------------------------------|
+| JavaScript           | `<script`                                                    |
+| Embedded content     | `<iframe`, `<embed`, `<object`                               |
+| Media                | `<video`, `<audio`                                           |
+| Graphics             | `<canvas`                                                    |
+| Interactive controls | `<form`, `<input`, `<button`, `<select`, `<textarea`         |
+| Scripted handlers    | inline `on<event>=` attributes (regex ` on[a-z]+\s*=`)       |
+
+- **False-positive guard (the key correctness point)**: plain `<a href="…">` anchor links - notably
+  the centered grey **source link** the app stamps into YouTube HTML (`HTMLMetaCodec.insertSourceLink`)
+  - MUST NOT trigger detection. Anchors are normal content and are handled by link-routing (D-B).
+  This is asserted directly in tests.
+- **Robustness**: substring/regex matching on the raw text is sufficient and cheap; we do not need a
+  full HTML parser to decide "is there a `<script>`". `<details>`/`<summary>` (native, JS-free) are
+  intentionally **not** flagged.
+
+## D-E. "View in Browser" affordance
+
+- Shown only for `.html` assets where `HTMLFeatureScanner` reports advanced features, as a **labeled**
+  button (globe icon + "View in Browser") at the **top-right** of the preview toolbar (per the
+  explicit request). It calls the same open path as the existing "Open" action
+  (`NSWorkspace.shared.open(asset.url)`).
+- The existing generic Open / Quick Look / Reveal actions remain for both formats; the new button is
+  an additional, prominent, conditional escape hatch.
+
+## D-F. Streaming unchanged
+
+Live generation keeps streaming as text into the pane (existing behavior). Re-loading a `WKWebView`
+per streamed token is wasteful and flickery; the styled web view applies to the finished, selected
+summary. Noted as out of scope in the spec.
+
+## Risks
+
+- **Cannot launch locally to eyeball** (ad-hoc signing → Keychain prompt; see learnings #3/#4). We
+  verify via `swift build` + `swift test` (detector is fully unit-tested) and a careful read of the
+  WebKit wiring; the user validates the rendered output from the PR build.
+- **Content-rule-list scope**: limited strictly to `^https?://` so it cannot blank the local
+  document; failure to compile is non-fatal (JS-off still holds).
diff --git a/specs/003-html-preview-viewer/spec.md b/specs/003-html-preview-viewer/spec.md
new file mode 100644
index 0000000..ed7b162
--- /dev/null
+++ b/specs/003-html-preview-viewer/spec.md
@@ -0,0 +1,146 @@
+# Feature Specification: In-app HTML preview viewer
+
+**Feature Branch**: `003-html-preview-viewer`
+
+**Created**: 2026-06-22
+
+**Status**: Draft
+
+**Input**: User description: "Improve the HTML preview. It should have a basic viewer. Balance
+the decision between simple and light-weight vs. having some small, nice features for a richer
+interactive interface. When more advanced features are detected, put a button in the top right
+to say 'View in Browser'."
+
+## Background
+
+Sumbee can write each summary as Markdown or as a complete, self-contained HTML document
+(`<!DOCTYPE html>` … `</html>`, styling inline via the optional HTML-styling prompt; see
+`001` FR-013 and `PromptBuilder.convention`). Markdown summaries get a pleasant in-app render
+(`MarkdownText`). HTML summaries, however, currently degrade to a **plain-text fallback** in the
+preview pane:
+
+> "HTML summary. Use **Open** to view it styled in your browser." + tag-stripped text.
+
+So the one format the user explicitly chose for *visual* output is the one format they cannot see
+styled without leaving the app. This feature gives HTML summaries a real in-app viewer.
+
+## Clarifications
+
+### Session 2026-06-22
+
+- Q: Render engine for in-app HTML? → A: **WebKit (`WKWebView`)**. It is an Apple system
+  framework (no third-party dependency added; the "zero runtime deps" rule holds) and is the only
+  way to render arbitrary model-authored HTML+CSS faithfully. Hand-rolling an HTML renderer or
+  reusing the Markdown renderer cannot honor the document's own styling.
+- Q: How "rich" should the in-app viewer be? → A: **A basic, safe, static viewer with a few small
+  niceties**, not a browser. It renders the document's HTML+CSS, supports the existing font-size
+  controls (as page zoom), and opens link clicks in the user's real browser. It deliberately does
+  **not** run the document's JavaScript or auto-load remote resources (privacy + lightweight).
+- Q: What does "more advanced features detected" mean for the "View in Browser" button? → A: The
+  saved HTML contains genuinely interactive/dynamic constructs the static viewer won't execute -
+  scripts, embedded frames/objects, video/audio, canvas, or form controls / inline event handlers.
+  When any are present, the in-app render may be incomplete, so the app surfaces a prominent
+  **"View in Browser"** button (top-right of the preview toolbar) for the full experience.
+- Q: Should a plain footer link (e.g. the YouTube source URL the app stamps in) count as
+  "advanced"? → A: **No.** Anchor links are normal content; they must not trip the detector
+  (link clicks already open in the browser on demand). Only auto-executing/auto-loading
+  constructs count.
+
+## User Scenarios & Testing
+
+### User Story 1 - See an HTML summary styled, in-app (Priority: P1)
+
+A user whose default (or per-style) output format is HTML selects a summary in the library.
+
+**Why this priority**: This is the core gap. Without it the HTML format is effectively
+"export-only" inside the app.
+
+**Acceptance**:
+1. **Given** a selected `.html` summary, **when** the preview pane shows it, **then** the document
+   renders with its own styling (headings, colors, layout), read-only, not as plain text.
+2. **Given** the rendered HTML, **when** the user clicks a hyperlink in it, **then** the link opens
+   in the user's default browser (the in-app view does not navigate away).
+3. **Given** the rendered HTML, **when** the user presses the font-size +/- controls, **then** the
+   content scales and the chosen size persists across sessions (shared with the Markdown preview).
+
+### User Story 2 - Escape hatch for interactive HTML (Priority: P1)
+
+A user selects an HTML summary whose document uses interactive features (e.g. a `<script>`-driven
+collapsible outline, an embedded chart, or a `<video>`).
+
+**Why this priority**: The lightweight viewer intentionally won't run those; the user still needs a
+one-click path to the real thing. Pairs directly with US1.
+
+**Acceptance**:
+1. **Given** an HTML summary containing advanced features, **when** it is previewed, **then** a
+   labeled **"View in Browser"** button is visible in the **top-right** of the preview toolbar.
+2. **Given** that button, **when** the user clicks it, **then** the `.html` file opens in the
+   default browser.
+3. **Given** an HTML summary with **no** advanced features (plain styled prose/tables/lists),
+   **when** it is previewed, **then** the "View in Browser" button is **absent** (the in-app view
+   is sufficient); a plain footer source-link must not, by itself, make it appear.
+
+### User Story 3 - Privacy & safety preserved (Priority: P2)
+
+Sumbee's promise is local-first: the only network calls are the summarize request and YouTube
+caption fetch.
+
+**Why this priority**: Rendering arbitrary HTML must not quietly become a third network egress
+(remote images, trackers, fonts) or run untrusted scripts.
+
+**Acceptance**:
+1. **Given** an HTML document that references remote resources, **when** it renders in-app, **then**
+   those remote loads are blocked (nothing is auto-fetched from the network by the preview).
+2. **Given** any HTML document, **when** it renders in-app, **then** its JavaScript does not run,
+   and no cookies/cache are persisted to disk by the viewer.
+3. The Markdown preview, library, search, regenerate, Quick Look, drag-export, and existing
+   "Open"/"Reveal" actions are unchanged.
+
+### Edge Cases
+
+- Malformed / partial HTML → the viewer shows whatever WebKit can parse; it never crashes the app.
+- Very large HTML → renders within the existing scrollable pane (WebKit scrolls internally).
+- Switching rapidly between a Markdown and an HTML summary → the correct renderer is shown for the
+  current selection with no stale content.
+- An HTML doc that is *only* a footer source link plus styled prose → not "advanced".
+- Streaming: live generation continues to stream as text (unchanged); the styled web view applies
+  to the saved, selected summary. (HTML live-render is out of scope; see below.)
+
+## Requirements
+
+### Functional Requirements
+
+- **FR-047**: HTML summaries MUST render with their own styling inside the preview pane (a basic,
+  read-only in-app viewer), replacing the previous plain-text fallback.
+- **FR-048**: The in-app viewer MUST be static and private: it MUST NOT execute the document's
+  JavaScript, MUST block remote network resource loads, and MUST NOT persist cookies/cache to disk.
+  Hyperlink clicks MUST open in the user's default browser rather than navigating the in-app view.
+- **FR-049**: The existing preview font-size controls MUST scale the HTML render (via page zoom),
+  reusing and persisting the same `previewFontSize` setting as the Markdown preview.
+- **FR-050**: The app MUST detect "advanced" features in a saved HTML summary - scripts, embedded
+  frames/objects (`iframe`/`embed`/`object`), media (`video`/`audio`), `canvas`, and form controls
+  / inline event handlers - via a deterministic, unit-tested scan. Plain anchor links MUST NOT be
+  treated as advanced.
+- **FR-051**: When advanced features are detected, a labeled **"View in Browser"** button MUST
+  appear in the top-right of the preview toolbar and open the `.html` file in the default browser.
+  When none are detected, the button MUST be absent.
+- **FR-052**: No new third-party runtime dependency may be introduced (WebKit is an Apple system
+  framework). The Markdown path and all other preview actions MUST be unaffected.
+
+### Out of scope (this feature)
+
+- Live, styled HTML rendering *during* streaming generation (still streams as text).
+- Editing HTML in-app, printing, or an in-app "reader mode" reflow.
+- A user setting to opt back into JavaScript / remote loads inside the app (browser is the path
+  for that).
+
+## Success Criteria
+
+- **SC-001**: Selecting an HTML summary shows it styled in-app (no plain-text fallback) for 100% of
+  well-formed model-authored HTML.
+- **SC-002**: For HTML containing any advanced construct, the "View in Browser" button appears and
+  opens the file in the browser; for plain styled HTML it does not appear. Verified by unit tests
+  over the detector and by manual validation of the toolbar.
+- **SC-003**: `swift build` is clean (0 warnings) and `swift test` is green, including new detector
+  tests. No new SPM dependency in `Package.swift`.
+- **SC-004**: No regression in the Markdown preview or other library actions.
diff --git a/specs/003-html-preview-viewer/tasks.md b/specs/003-html-preview-viewer/tasks.md
new file mode 100644
index 0000000..1e95b6e
--- /dev/null
+++ b/specs/003-html-preview-viewer/tasks.md
@@ -0,0 +1,48 @@
+# Tasks: In-app HTML preview viewer
+
+**Input**: `spec.md`, `research.md`, `plan.md`
+**Tests**: Detector is unit-tested (deterministic); the `WKWebView` view is reviewed, not unit-tested.
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]**: parallelizable (different files, no dependency)
+- **[Story]**: US1 (in-app render), US2 (View-in-Browser escape), US3 (privacy/safety)
+
+---
+
+## Phase 1: Detection (foundational, pure logic)
+
+- [x] T001 [P] [US2] `Services/HTMLFeatureScanner.swift` - pure `scan(_:) -> Result{hasAdvancedFeatures, features}`;
+      case-insensitive triggers per research D-D; anchors never contribute.
+- [x] T002 [P] [US2] `Tests/SumbeeKitTests/HTMLFeatureScannerTests.swift` - plain styled HTML →
+      not advanced; script/iframe/video/canvas/form/onclick → advanced w/ correct labels;
+      **anchor-only + source-link footer → not advanced**; labels deduped/stable.
+
+## Phase 2: Viewer
+
+- [x] T003 [US1][US3] `Views/AssetBrowser/HTMLWebView.swift` - `NSViewRepresentable` over `WKWebView`:
+      JS off, `.nonPersistent()` store, `^https?://` content-rule-list block (best-effort),
+      `loadHTMLString(_, baseURL: nil)`, `pageZoom` from `baseSize`, navigation delegate routes
+      `.linkActivated` to `NSWorkspace` and cancels stray navigations.
+
+## Phase 3: Integration
+
+- [x] T004 [US1] `Views/AssetBrowser/MarkdownPreview.swift` - `PreviewPane.load()` stores raw HTML +
+      `HTMLFeatureScanner` result for `.html`; `body` renders `HTMLWebView` for `.html` (non-streaming);
+      Markdown path unchanged.
+- [x] T005 [US2] `Views/AssetBrowser/MarkdownPreview.swift` - add the top-right, labeled
+      **"View in Browser"** toolbar button, shown only when `.html` && advanced; keep font +/- enabled
+      for HTML.
+
+## Phase 4: Verify & document
+
+- [x] T006 `swift build` clean (0 warnings) + `swift test` green (incl. new detector tests);
+      confirm no new dependency in `Package.swift`.
+- [x] T007 [P] Update `CHANGELOG.md` (next/Unreleased) and the `README.md` HTML-preview feature
+      bullet. (Release/tag is a separate, user-initiated step.)
+- [x] T008 Push branch `003-html-preview-viewer`, open PR for user validation.
+
+---
+
+**Checkpoint**: HTML summaries render styled in-app; advanced docs show "View in Browser"; build +
+tests green; PR open.