diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
new file mode 100644
index 0000000..911acf8
--- /dev/null
+++ b/.claude-plugin/marketplace.json
@@ -0,0 +1,47 @@
+{
+  "$schema": "https://raw.githubusercontent.com/anthropics/claude-code/refs/heads/main/marketplace/marketplace.schema.json",
+  "name": "diagnostics-report-analyzer-skill",
+  "version": "1.0.0",
+  "owner": {
+    "name": "Antoine van der Lee",
+    "email": "contact@avanderlee.com"
+  },
+  "metadata": {
+    "description": "Analyze AvdLee Diagnostics HTML reports using embedded JSON first, with legacy HTML report fallback."
+  },
+  "plugins": [
+    {
+      "name": "diagnostics-report-analyzer",
+      "description": "Support and debugging guidance for AvdLee Diagnostics reports, session logs, app metadata, and MetricKit diagnostics.",
+      "repository": "https://github.com/AvdLee/Diagnostics",
+      "version": "1.0.0",
+      "author": {
+        "name": "Antoine van der Lee",
+        "email": "contact@avanderlee.com"
+      },
+      "license": "MIT",
+      "category": "development",
+      "keywords": [
+        "diagnostics",
+        "support",
+        "debugging",
+        "logs",
+        "html-report",
+        "json",
+        "swift",
+        "ios",
+        "macos"
+      ],
+      "tags": [
+        "diagnostics",
+        "support",
+        "debugging",
+        "logs",
+        "swift",
+        "ios",
+        "macos"
+      ],
+      "source": "./"
+    }
+  ]
+}
diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
new file mode 100644
index 0000000..8f959b4
--- /dev/null
+++ b/.claude-plugin/plugin.json
@@ -0,0 +1,25 @@
+{
+  "name": "diagnostics-report-analyzer",
+  "version": "1.0.0",
+  "description": "Analyze AvdLee Diagnostics HTML reports using embedded JSON first, with legacy HTML report fallback.",
+  "author": {
+    "name": "Antoine van der Lee",
+    "email": "contact@avanderlee.com"
+  },
+  "repository": "https://github.com/AvdLee/Diagnostics",
+  "license": "MIT",
+  "keywords": [
+    "diagnostics",
+    "support",
+    "debugging",
+    "logs",
+    "html-report",
+    "json",
+    "swift",
+    "ios",
+    "macos"
+  ],
+  "skills": [
+    "./diagnostics-report-analyzer-skill"
+  ]
+}
diff --git a/.cursor-plugin/plugin.json b/.cursor-plugin/plugin.json
new file mode 100644
index 0000000..e75c0b4
--- /dev/null
+++ b/.cursor-plugin/plugin.json
@@ -0,0 +1,25 @@
+{
+  "name": "diagnostics-report-analyzer",
+  "version": "1.0.0",
+  "description": "Analyze AvdLee Diagnostics HTML reports using embedded JSON first, with legacy HTML report fallback.",
+  "author": {
+    "name": "Antoine van der Lee",
+    "email": "contact@avanderlee.com"
+  },
+  "repository": "https://github.com/AvdLee/Diagnostics",
+  "license": "MIT",
+  "keywords": [
+    "diagnostics",
+    "support",
+    "debugging",
+    "logs",
+    "html-report",
+    "json",
+    "swift",
+    "ios",
+    "macos"
+  ],
+  "skills": [
+    "diagnostics-report-analyzer-skill"
+  ]
+}
diff --git a/Changelog.md b/Changelog.md
index f4521aa..ce13059 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,6 @@
+### 7.0.0
+- NEW: Diagnostics reports are now agent-friendly single-file HTML documents with embedded structured JSON. The browser view is rendered from the JSON payload, while agents can inspect structured chapters, session metadata, log events, and crash diagnostics directly. Existing historic log sessions remain readable, and uncaught exceptions are persisted as timestamped `crash` events.
+
 ### 6.0.1
 - Add projects using Roadmap to README ([#185](https://github.com/AvdLee/Diagnostics/pull/185)) via [@AvdLee](https://github.com/AvdLee)
 - Add Helm for App Store Connect to projects list ([#186](https://github.com/AvdLee/Diagnostics/pull/186)) via [@hiddevdploeg](https://github.com/hiddevdploeg)
diff --git a/DiagnosticsTests/DiagnosticsReporterTests.swift b/DiagnosticsTests/DiagnosticsReporterTests.swift
index 9545dbe..06e3248 100644
--- a/DiagnosticsTests/DiagnosticsReporterTests.swift
+++ b/DiagnosticsTests/DiagnosticsReporterTests.swift
@@ -29,18 +29,63 @@ final class DiagnosticsReporterTests: XCTestCase {
         let reporters = [reporter]
         let report = await DiagnosticsReporter.create(using: reporters)
         let html = String(data: report.data, encoding: .utf8)!
-
-        XCTAssertTrue(html.contains("<h3>\(diagnosticsChapter.title)</h3>"))
-        XCTAssertTrue(html.contains(diagnosticsChapter.diagnostics as! String))
+        let document = try XCTUnwrap(html.diagnosticsReportDocument)
+
+        XCTAssertTrue(html.contains("<script id=\"diagnostics-report-data\" type=\"application/json\">"))
+        XCTAssertTrue(html.contains("<main id=\"diagnostics-report\" class=\"container\"></main>"))
+        XCTAssertEqual(document.chapters.first?.title, diagnosticsChapter.title)
+        if case .text(let value)? = document.chapters.first?.data {
+            XCTAssertEqual(value, diagnosticsChapter.diagnostics as! String)
+        } else {
+            XCTFail("Expected text diagnostics")
+        }
     }
 
     /// It should create a chapter for each reporter.
     func testReportingChapters() async throws {
         let report = await DiagnosticsReporter.create()
         let html = String(data: report.data, encoding: .utf8)!
+        let document = try XCTUnwrap(html.diagnosticsReportDocument)
         let expectedChaptersCount = DiagnosticsReporter.DefaultReporter.allCases.count
-        let chaptersCount = html.components(separatedBy: "<div class=\"chapter\"").count - 1
-        XCTAssertEqual(expectedChaptersCount, chaptersCount)
+        XCTAssertEqual(expectedChaptersCount, document.chapters.count)
+    }
+
+    func testGeneralInfoPreservesFormattedHTMLAndHiddenTitle() async throws {
+        let report = await DiagnosticsReporter.create(using: [GeneralInfoReporter()])
+        let html = String(data: report.data, encoding: .utf8)!
+        let document = try XCTUnwrap(html.diagnosticsReportDocument)
+        let chapter = try XCTUnwrap(document.chapters.first)
+
+        XCTAssertFalse(chapter.showTitle)
+        XCTAssertTrue(chapter.legacyHTML?.contains("<p>This diagnostics report can help") == true)
+        if case .text(let value) = chapter.data {
+            XCTAssertTrue(value.contains("<p>This diagnostics report can help"))
+        } else {
+            XCTFail("Expected text diagnostics")
+        }
+    }
+
+    func testCustomFormatterPreservesBrowserHTMLAndStructuredData() async throws {
+        let suiteName = "DiagnosticsReporterTests-\(UUID().uuidString)"
+        let userDefaults = try XCTUnwrap(UserDefaults(suiteName: suiteName))
+        defer { userDefaults.removePersistentDomain(forName: suiteName) }
+
+        userDefaults.set("agent-friendly", forKey: "mode")
+        let reporter = UserDefaultsReporter(userDefaults: userDefaults, keys: ["mode"])
+
+        let report = await DiagnosticsReporter.create(using: [reporter])
+        let html = String(data: report.data, encoding: .utf8)!
+        let document = try XCTUnwrap(html.diagnosticsReportDocument)
+        let chapter = try XCTUnwrap(document.chapters.first)
+
+        XCTAssertTrue(chapter.legacyHTML?.contains("<pre>") == true)
+        XCTAssertTrue(chapter.legacyHTML?.contains("agent-friendly") == true)
+        if case .table(let rows) = chapter.data {
+            XCTAssertEqual(rows.first?.key, "mode")
+            XCTAssertEqual(rows.first?.value, "agent-friendly")
+        } else {
+            XCTFail("Expected table diagnostics")
+        }
     }
 
     /// It should filter using passed filters.
@@ -88,6 +133,19 @@ final class DiagnosticsReporterTests: XCTestCase {
     }
 }
 
+private extension String {
+    var diagnosticsReportDocument: DiagnosticsReportDocument? {
+        guard
+            let startRange = range(of: "<script id=\"diagnostics-report-data\" type=\"application/json\">"),
+            let endRange = range(of: "</script>", range: startRange.upperBound..<endIndex) else {
+            return nil
+        }
+
+        let json = String(self[startRange.upperBound..<endRange.lowerBound])
+        return try? JSONDecoder().decode(DiagnosticsReportDocument.self, from: Data(json.utf8))
+    }
+}
+
 struct MockedReport: DiagnosticsReporting {
     var diagnostics: Diagnostics = [String: String]()
     func report() -> DiagnosticsChapter {
diff --git a/DiagnosticsTests/Logging/DiagnosticsLoggerTests.swift b/DiagnosticsTests/Logging/DiagnosticsLoggerTests.swift
index ebaf09c..c86cfa0 100644
--- a/DiagnosticsTests/Logging/DiagnosticsLoggerTests.swift
+++ b/DiagnosticsTests/Logging/DiagnosticsLoggerTests.swift
@@ -8,6 +8,30 @@ import XCTest
 
 final class DiagnosticsLoggerTests: XCTestCase {
 
+    override func setUpWithError() throws {
+        try super.setUpWithError()
+        try DiagnosticsLogger.setup()
+    }
+
+    override func tearDownWithError() throws {
+        try DiagnosticsLogger.standard.deleteLogs()
+        try super.tearDownWithError()
+    }
+
+    func testSynchronousCrashLogIsPersistedBeforeReturning() throws {
+        let exception = NSException(name: .genericException, reason: "Synchronous crash test")
+
+        DiagnosticsLogger.standard.logSynchronously(ExceptionLog(exception, description: "Uncaught Exception"))
+
+        let logData = try XCTUnwrap(DiagnosticsLogger.standard.readLog())
+        let log = String(decoding: logData, as: UTF8.self)
+
+        XCTAssertTrue(log.contains(DiagnosticsLogRecord.linePrefix))
+        XCTAssertTrue(log.contains("\"level\":\"crash\""))
+        XCTAssertTrue(log.contains("Synchronous crash test"))
+        XCTAssertTrue(log.contains("Uncaught Exception"))
+    }
+
     #if os(macOS)
     /// On unsandboxed macOS processes (including the `swift test` runner), the Application
     /// Support directory used for the log file must be scoped by the current bundle identifier
diff --git a/DiagnosticsTests/Logging/LogsWriterTests.swift b/DiagnosticsTests/Logging/LogsWriterTests.swift
index cd95cdd..6b685d3 100644
--- a/DiagnosticsTests/Logging/LogsWriterTests.swift
+++ b/DiagnosticsTests/Logging/LogsWriterTests.swift
@@ -33,6 +33,26 @@ final class LogsWriterTests: XCTestCase {
         let contents = String(decoding: data, as: UTF8.self)
 
         XCTAssertTrue(contents.contains("Test log line"))
+        XCTAssertTrue(contents.contains(DiagnosticsLogRecord.linePrefix))
+    }
+
+    func testWriteAppendsStructuredDataAfterLegacyContent() throws {
+        let legacyContent = """
+        <summary><div class="session-header"><p><span>Date: </span>2026-01-01</p></div></summary>
+        <p class="debug"><span class="log-message">Legacy event</span></p>
+
+        """
+        try Data(legacyContent.utf8).write(to: tempLogFileURL)
+
+        let writer = LogsWriter(logFileLocation: tempLogFileURL, maximumLogSize: 1024 * 1024)
+        writer.write(SystemLog(line: "Structured event"))
+
+        let data = try Data(contentsOf: tempLogFileURL)
+        let contents = String(decoding: data, as: UTF8.self)
+
+        XCTAssertTrue(contents.contains("Legacy event"))
+        XCTAssertTrue(contents.contains("Structured event"))
+        XCTAssertTrue(contents.contains(DiagnosticsLogRecord.linePrefix))
     }
 
     func testTrimmingOccursWhenExceedingMaxSize() throws {
diff --git a/DiagnosticsTests/Reporters/LogsReporterTests.swift b/DiagnosticsTests/Reporters/LogsReporterTests.swift
index 1a5f9cc..c74c42c 100644
--- a/DiagnosticsTests/Reporters/LogsReporterTests.swift
+++ b/DiagnosticsTests/Reporters/LogsReporterTests.swift
@@ -26,12 +26,16 @@ final class LogsReporterTests: XCTestCase {
         let identifier = UUID().uuidString
         let message = "<b>\(identifier)</b>"
         DiagnosticsLogger.log(message: message)
-        let diagnostics = LogsReporter().report().diagnostics as! String
-        XCTAssertTrue(diagnostics.contains(identifier), "Diagnostics is \(diagnostics)")
-        XCTAssertEqual(diagnostics.debugLogs.count, 1)
-        let debugLog = try XCTUnwrap(diagnostics.debugLogs.first)
-        XCTAssertTrue(debugLog.contains("<span class=\"log-prefix\">LogsReporterTests.swift:L28</span>"), "Prefix should be added")
-        XCTAssertTrue(debugLog.contains("<span class=\"log-message\">&lt;b&gt;\(identifier)&lt;/b&gt;</span>"), "Log message should be added to \(debugLog)")
+        let diagnostics = LogsReporter().report().diagnostics as! DiagnosticsLogReport
+        let debugLogs = diagnostics.sessions.flatMap(\.events).filter { $0.level == "debug" }
+        let html = diagnostics.html()
+        XCTAssertTrue(html.contains(identifier), "Diagnostics is \(html)")
+        XCTAssertEqual(debugLogs.count, 1)
+        let debugLog = try XCTUnwrap(debugLogs.first)
+        XCTAssertEqual(debugLog.prefix, "LogsReporterTests.swift:L28", "Prefix should be added")
+        XCTAssertEqual(debugLog.message, message, "Raw message should be preserved for agents")
+        XCTAssertTrue(html.contains("<span class=\"log-prefix\">LogsReporterTests.swift:L28</span>"), "Prefix should be added")
+        XCTAssertTrue(html.contains("<span class=\"log-message\">&lt;b&gt;\(identifier)&lt;/b&gt;</span>"), "Log message should be added to \(html)")
     }
 
     /// It should show errors.
@@ -45,11 +49,14 @@ final class LogsReporterTests: XCTestCase {
         }
 
         DiagnosticsLogger.log(error: Error.testCase)
-        let diagnostics = LogsReporter().report().diagnostics as! String
-        XCTAssertTrue(diagnostics.contains("testCase"))
-        XCTAssertEqual(diagnostics.errorLogs.count, 1)
-        let errorLog = try XCTUnwrap(diagnostics.errorLogs.first)
-        XCTAssertTrue(errorLog.contains("<span class=\"log-message\">ERROR: testCase | &lt;b&gt;example description&lt;/b&gt"))
+        let diagnostics = LogsReporter().report().diagnostics as! DiagnosticsLogReport
+        let errorLogs = diagnostics.sessions.flatMap(\.events).filter { $0.level == "error" }
+        let html = diagnostics.html()
+        XCTAssertTrue(html.contains("testCase"))
+        XCTAssertEqual(errorLogs.count, 1)
+        let errorLog = try XCTUnwrap(errorLogs.first)
+        XCTAssertTrue(errorLog.message.contains("ERROR: testCase | <b>example description</b>"))
+        XCTAssertTrue(html.contains("<span class=\"log-message\">ERROR: testCase | &lt;b&gt;example description&lt;/b&gt"))
     }
 
     /// It should reverse the order of sessions to have the most recent session on top.
@@ -57,9 +64,62 @@ final class LogsReporterTests: XCTestCase {
         DiagnosticsLogger.log(message: "first")
         DiagnosticsLogger.standard.startNewSession()
         DiagnosticsLogger.log(message: "second")
-        let diagnostics = LogsReporter().report().diagnostics as! String
-        let firstIndex = try XCTUnwrap(diagnostics.range(of: "first")?.lowerBound)
-        let secondIndex = try XCTUnwrap(diagnostics.range(of: "second")?.lowerBound)
+        let diagnostics = LogsReporter().report().diagnostics as! DiagnosticsLogReport
+        let html = diagnostics.html()
+        let firstIndex = try XCTUnwrap(html.range(of: "first")?.lowerBound)
+        let secondIndex = try XCTUnwrap(html.range(of: "second")?.lowerBound)
         XCTAssertTrue(firstIndex > secondIndex)
     }
+
+    /// It should keep historic legacy sessions readable when new structured records are appended after an app update.
+    func testMixedLegacyAndStructuredSessions() throws {
+        let legacySession = """
+
+        ---
+
+        <summary><div class="session-header"><p><span>Date: </span>2026-01-01 10:00:00</p><p><span>System: </span>iOS 18.0</p><p><span>Locale: </span>en</p><p><span>Version: </span>1.0 (1)</p></div></summary>
+        <p class="debug"><span class="log-message">legacy historic event</span></p>
+        """
+        let structuredSession = String(decoding: NewSession().logData, as: UTF8.self)
+        let structuredEvent = String(decoding: LogItem(.debug(message: "structured update event"), file: #file, function: #function, line: #line).logData, as: UTF8.self)
+
+        let report = DiagnosticsLogParser().parse(legacySession + structuredSession + structuredEvent)
+        let html = report.html()
+
+        XCTAssertEqual(report.sessions.count, 2)
+        XCTAssertTrue(html.contains("legacy historic event"))
+        XCTAssertTrue(html.contains("structured update event"))
+        let legacyIndex = try XCTUnwrap(html.range(of: "legacy historic event")?.lowerBound)
+        let structuredIndex = try XCTUnwrap(html.range(of: "structured update event")?.lowerBound)
+        XCTAssertTrue(structuredIndex < legacyIndex)
+    }
+
+    /// It should encode structured session metadata keys and values before rendering HTML.
+    func testStructuredSessionMetadataHTMLEncoding() {
+        let session = DiagnosticsLogSession(
+            title: "Session",
+            metadata: ["<Date>": "<2026-06-19>"]
+        )
+
+        let html = session.html()
+
+        XCTAssertTrue(html.contains("&lt;Date&gt;"))
+        XCTAssertTrue(html.contains("&lt;2026-06-19&gt;"))
+        XCTAssertFalse(html.contains("<span><Date>: </span>"))
+    }
+
+    func testExceptionLogUsesCrashLevelAndPreformattedHTML() throws {
+        let exception = NSException(name: .genericException, reason: "Boom")
+        let recordLine = String(decoding: ExceptionLog(exception, description: "Crash description").logData, as: UTF8.self)
+
+        let report = DiagnosticsLogParser().parse(recordLine)
+        let event = try XCTUnwrap(report.sessions.first?.events.first)
+        let html = event.html()
+
+        XCTAssertEqual(event.level, "crash")
+        XCTAssertNotNil(event.date)
+        XCTAssertTrue(event.message.contains("CRASH:"))
+        XCTAssertTrue(html.contains("<pre class=\"crash\">"))
+        XCTAssertTrue(html.contains("Crash description"))
+    }
 }
diff --git a/DiagnosticsTests/Reporters/LogsTrimmerTests.swift b/DiagnosticsTests/Reporters/LogsTrimmerTests.swift
index 19a79d2..a266f6d 100644
--- a/DiagnosticsTests/Reporters/LogsTrimmerTests.swift
+++ b/DiagnosticsTests/Reporters/LogsTrimmerTests.swift
@@ -58,5 +58,41 @@ final class LogsTrimmerTests: XCTestCase {
         let outputString = String(data: inputData, encoding: .utf8)
         XCTAssertEqual(outputString, expectedOutput)
     }
+
+    /// It should trim structured log records while preserving session start records.
+    func testTrimmingStructuredRecords() {
+        let session = String(decoding: NewSession().logData, as: UTF8.self)
+        let oldLog = String(decoding: SystemLog(line: "Old structured log").logData, as: UTF8.self)
+        let newLog = String(decoding: SystemLog(line: "New structured log").logData, as: UTF8.self)
+
+        var inputData = Data((session + oldLog + newLog).utf8)
+        let trimmer = LogsTrimmer(numberOfLinesToTrim: 1)
+
+        trimmer.trim(data: &inputData)
+
+        let outputString = String(decoding: inputData, as: UTF8.self)
+        XCTAssertTrue(outputString.contains("\"type\":\"sessionStart\""))
+        XCTAssertFalse(outputString.contains("Old structured log"))
+        XCTAssertTrue(outputString.contains("New structured log"))
+    }
+
+    /// It should trim legacy records before structured records in mixed-format files.
+    func testTrimmingMixedFormatLogsTrimsLegacyRecordsFirst() {
+        let legacyLog = """
+        <p class="system"><span class="log-message">Old legacy log</span></p>
+        """
+        let structuredSession = String(decoding: NewSession().logData, as: UTF8.self)
+        let structuredLog = String(decoding: SystemLog(line: "New structured log").logData, as: UTF8.self)
+
+        var inputData = Data((legacyLog + structuredSession + structuredLog).utf8)
+        let trimmer = LogsTrimmer(numberOfLinesToTrim: 1)
+
+        trimmer.trim(data: &inputData)
+
+        let outputString = String(decoding: inputData, as: UTF8.self)
+        XCTAssertFalse(outputString.contains("Old legacy log"))
+        XCTAssertTrue(outputString.contains("\"type\":\"sessionStart\""))
+        XCTAssertTrue(outputString.contains("New structured log"))
+    }
 }
 //  swiftlint:enable line_length
diff --git a/README.md b/README.md
index 51557bd..6c3a568 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,8 @@ Diagnostics is a library written in Swift which makes it really easy to share Di
 - [Features](#features)
 - [Requirements](#requirements)
 - [Usage](#usage)
+    - [Agent-friendly reports](#agent-friendly-reports)
+    - [Install the Agent Skill](#install-the-agent-skill)
 	- [Using a custom UserDefaults type](#using-a-custom-userdefaults-type) 
 	- [Filtering out sensitive data](#filtering-out-sensitive-data) 
 	- [Adding your own custom logs](#adding-your-own-custom-logs)
@@ -38,6 +40,7 @@ The library allows to easily attach the Diagnostics Report as an attachment to t
     - System logs divided per session
 - [x] Possibility to filter out sensitive data using a `DiagnosticsReportFilter`
 - [x] A custom `DiagnosticsLogger` to add your own logs
+- [x] Agent-friendly single-file HTML reports with embedded structured JSON
 - [x] Smart insights like _"⚠️ User is low on storage"_ and *"✅ User is using the latest app version"*
 - [x] Flexible setup to add your own smart insights
 - [x] Flexible setup to add your own custom diagnostics
@@ -130,6 +133,28 @@ func send(report: DiagnosticsReport) {
 }
 ```
 
+### Agent-friendly reports
+
+Diagnostics reports remain a single `.html` attachment that users can email and open in a browser. New reports also embed a structured JSON payload in:
+
+```html
+<script id="diagnostics-report-data" type="application/json">
+```
+
+Support agents and AI tools should parse that JSON first instead of loading the rendered HTML. The payload contains report metadata, agent hints, structured chapters, session metadata, and log events with levels like `debug`, `system`, `error`, and `crash`.
+
+The browser view is generated from this JSON. Chapters can still include `legacyHTML` when custom formatting is needed, and older on-device log sessions remain readable after users update to a newer Diagnostics version. This repository also includes a reusable analyzer skill in `diagnostics-report-analyzer-skill` for clients that support agent skills/plugins.
+
+### Install the Agent Skill
+
+For the easiest setup, install the analyzer skill with `npx skills`:
+
+```bash
+npx skills add https://github.com/AvdLee/Diagnostics --skill diagnostics-report-analyzer-skill
+```
+
+See [agent-skill-install-instructions.md](agent-skill-install-instructions.md) for Claude, Cursor, OpenAI-compatible tools, pi, and manual installation options.
+
 ### Using a UserDefaultsReporter
 In order to use `UserDefaultsReporter`, you need to specify the desired `UserDefaults` instance together with all the keys you would like to read, and use it in `DiagnosticsReporter.create(filename:using:filters:smartInsightsProvider)` to create a `DiagnosticsReport`.
 
diff --git a/Sources/DiagnosticsReportDocument.swift b/Sources/DiagnosticsReportDocument.swift
new file mode 100644
index 0000000..556aaa6
--- /dev/null
+++ b/Sources/DiagnosticsReportDocument.swift
@@ -0,0 +1,195 @@
+//
+//  DiagnosticsReportDocument.swift
+//  Diagnostics
+//
+//  Created by Diagnostics.
+//
+
+import Foundation
+
+struct DiagnosticsReportDocument: Codable, Sendable {
+    let schemaVersion: Int
+    let generatedAt: String
+    let title: String
+    let agentHints: [String]
+    let chapters: [DiagnosticsReportDocumentChapter]
+
+    init(title: String, chapters: [DiagnosticsChapter]) {
+        self.schemaVersion = 1
+        self.generatedAt = ISO8601DateFormatter().string(from: Date())
+        self.title = title
+        self.agentHints = [
+            "Agents should read this JSON payload instead of the rendered HTML.",
+            "Start with chapters where kind is logs, then inspect crash, error, and system events in the newest sessions first.",
+            "Use legacyHTML only as a browser-rendering fallback for custom diagnostics or HTML-formatted text; prefer data for analysis."
+        ]
+        self.chapters = chapters.map(DiagnosticsReportDocumentChapter.init)
+    }
+}
+
+struct DiagnosticsReportDocumentChapter: Codable, Sendable {
+    let id: String
+    let title: String
+    let showTitle: Bool
+    let kind: String
+    let data: DiagnosticsReportDocumentValue
+    let legacyHTML: String?
+
+    init(chapter: DiagnosticsChapter) {
+        self.id = chapter.title.anchor
+        self.title = chapter.title
+        self.showTitle = chapter.shouldShowTitle
+        let reportDocumentValue = chapter.diagnostics.reportDocumentValue
+
+        switch reportDocumentValue {
+        case .logs:
+            self.kind = "logs"
+        case .table:
+            self.kind = "table"
+        case .preformatted:
+            self.kind = "preformatted"
+        case .text:
+            self.kind = "text"
+        case .legacyHTML:
+            self.kind = "legacyHTML"
+        }
+
+        self.data = reportDocumentValue
+
+        if case .logs = reportDocumentValue {
+            self.legacyHTML = nil
+        } else if chapter.formatter != nil || chapter.diagnostics.prefersHTMLRendering {
+            self.legacyHTML = chapter.renderedContentHTML
+        } else if case .legacyHTML(let html) = reportDocumentValue {
+            self.legacyHTML = html
+        } else {
+            self.legacyHTML = nil
+        }
+    }
+}
+
+enum DiagnosticsReportDocumentValue: Codable, Sendable {
+    case table([DiagnosticsReportTableRow])
+    case text(String)
+    case preformatted(String)
+    case logs(DiagnosticsLogReport)
+    case legacyHTML(String)
+
+    private enum CodingKeys: String, CodingKey {
+        case type
+        case rows
+        case value
+        case sessions
+    }
+
+    private enum ValueType: String, Codable {
+        case table
+        case text
+        case preformatted
+        case logs
+        case legacyHTML
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+
+        switch self {
+        case .table(let rows):
+            try container.encode(ValueType.table, forKey: .type)
+            try container.encode(rows, forKey: .rows)
+        case .text(let value):
+            try container.encode(ValueType.text, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case .preformatted(let value):
+            try container.encode(ValueType.preformatted, forKey: .type)
+            try container.encode(value, forKey: .value)
+        case .logs(let report):
+            try container.encode(ValueType.logs, forKey: .type)
+            try container.encode(report.sessions, forKey: .sessions)
+        case .legacyHTML(let value):
+            try container.encode(ValueType.legacyHTML, forKey: .type)
+            try container.encode(value, forKey: .value)
+        }
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try container.decode(ValueType.self, forKey: .type)
+
+        switch type {
+        case .table:
+            self = .table(try container.decode([DiagnosticsReportTableRow].self, forKey: .rows))
+        case .text:
+            self = .text(try container.decode(String.self, forKey: .value))
+        case .preformatted:
+            self = .preformatted(try container.decode(String.self, forKey: .value))
+        case .logs:
+            self = .logs(DiagnosticsLogReport(sessions: try container.decode([DiagnosticsLogSession].self, forKey: .sessions)))
+        case .legacyHTML:
+            self = .legacyHTML(try container.decode(String.self, forKey: .value))
+        }
+    }
+}
+
+struct DiagnosticsReportTableRow: Codable, Sendable {
+    let key: String
+    let value: String
+}
+
+extension Diagnostics {
+    var reportDocumentValue: DiagnosticsReportDocumentValue {
+        if let logs = self as? DiagnosticsLogReport {
+            return .logs(logs)
+        }
+
+        if let table = self as? [String: String] {
+            return .table(table.sorted(by: { $0.key < $1.key }).map { DiagnosticsReportTableRow(key: $0.key, value: $0.value) })
+        }
+
+        if let keyValuePairs = self as? KeyValuePairs<String, String> {
+            return .table(keyValuePairs.map { DiagnosticsReportTableRow(key: $0.key, value: $0.value) })
+        }
+
+        if let directoryTree = self as? DirectoryTreeNode {
+            return .preformatted(String(describing: directoryTree))
+        }
+
+        if let text = self as? String {
+            return .text(text)
+        }
+
+        return .legacyHTML(html())
+    }
+
+    var prefersHTMLRendering: Bool {
+        guard let text = self as? String else {
+            return false
+        }
+
+        return text.contains("<") && text.contains(">")
+    }
+}
+
+private extension DiagnosticsChapter {
+    var renderedContentHTML: HTML {
+        if let formatter {
+            return formatter.format(diagnostics)
+        }
+        return diagnostics.html()
+    }
+}
+
+extension DiagnosticsReportDocument {
+    var json: String {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+
+        guard
+            let data = try? encoder.encode(self),
+            let string = String(data: data, encoding: .utf8) else {
+            return "{}"
+        }
+
+        return string
+    }
+}
diff --git a/Sources/DiagnosticsReporter.swift b/Sources/DiagnosticsReporter.swift
index 9f18b51..0f84f90 100644
--- a/Sources/DiagnosticsReporter.swift
+++ b/Sources/DiagnosticsReporter.swift
@@ -84,7 +84,8 @@ public enum DiagnosticsReporter {
             reportChapters.insert(smartInsightsChapter, at: smartInsightsChapterIndex)
         }
 
-        let html = generateHTML(using: reportChapters, reportTitle: reportTitle)
+        let document = DiagnosticsReportDocument(title: reportTitle, chapters: reportChapters)
+        let html = generateHTML(using: document)
         let data = html.data(using: .utf8)!
         return DiagnosticsReport(filename: filename, data: data)
     }
@@ -92,24 +93,22 @@ public enum DiagnosticsReporter {
 
 // MARK: - HTML Report Generation
 extension DiagnosticsReporter {
-    private static func generateHTML(using reportChapters: [DiagnosticsChapter], reportTitle: String) -> HTML {
-        var html = "<html>"
-        html += header()
+    private static func generateHTML(using document: DiagnosticsReportDocument) -> HTML {
+        var html = "<!doctype html><html>"
+        html += header(reportTitle: document.title)
         html += "<body>"
-        html += "<main class=\"container\">"
-
-        html += menu(using: reportChapters)
-        html += mainContent(using: reportChapters, reportTitle: reportTitle)
-
-        html += "</main>"
+        html += "<!-- Agents: extract and analyze the JSON in script#diagnostics-report-data instead of the rendered HTML. -->"
+        html += "<script id=\"diagnostics-report-data\" type=\"application/json\">\(document.json.escapingForEmbeddedScript())</script>"
+        html += "<noscript>This Diagnostics report uses embedded JSON and JavaScript to render the browser view. Agents should read the JSON in script#diagnostics-report-data.</noscript>"
+        html += "<main id=\"diagnostics-report\" class=\"container\"></main>"
         html += footer()
-        html += "</body>"
+        html += "</body></html>"
         return html
     }
 
-    private static func header() -> HTML {
+    private static func header(reportTitle: String) -> HTML {
         var html = "<head>"
-        html += "<title>\(Bundle.appName) - Diagnostics Report</title>"
+        html += "<title>\(reportTitle)</title>"
         html += style()
         html += scripts()
         html += "<meta charset=\"utf-8\">"
@@ -144,35 +143,16 @@ extension DiagnosticsReporter {
         return "<script type=\"text/javascript\">\(scripts)</script>"
     }
 
-    //  swiftlint:disable line_length
-    static func menu(using chapters: [DiagnosticsChapter]) -> HTML {
-        var html = "<aside class=\"nav-container\"><nav><ul>"
-        chapters.forEach { chapter in
-            html += "<li><a href=\"#\(chapter.title.anchor)\">\(chapter.title)</a></li>"
-        }
-        html += "<li><button id=\"expand-sections\">Expand sessions</button></li>"
-        html += "<li><button id=\"collapse-sections\">Collapse sessions</button></li>"
-        html += "<li><input type=\"checkbox\" id=\"system-logs\" name=\"system-logs\" checked><label for=\"system-logs\">Show system logs</label></li>"
-        html += "<li><input type=\"checkbox\" id=\"error-logs\" name=\"error-logs\" checked><label for=\"error-logs\">Show error logs</label></li>"
-        html += "<li><input type=\"checkbox\" id=\"debug-logs\" name=\"debug-logs\" checked><label for=\"debug-logs\">Show debug logs</label></li>"
-        html += "</ul></nav></aside>"
-        return html
-    }
-    //  swiftlint:enable line_length
-
-    static func mainContent(using chapters: [DiagnosticsChapter], reportTitle: String) -> HTML {
-        var html = "<div class=\"main-content\">"
-        html += "<header><h1>\(reportTitle)</h1></header>"
-        chapters.forEach { chapter in
-            html += chapter.html()
-        }
-        html += "</div>"
-        return html
-    }
 }
 
 extension String {
     var anchor: String {
         return lowercased().replacingOccurrences(of: " ", with: "-")
     }
+
+    func escapingForEmbeddedScript() -> String {
+        replacingOccurrences(of: "&", with: "\\u0026")
+            .replacingOccurrences(of: "<", with: "\\u003C")
+            .replacingOccurrences(of: ">", with: "\\u003E")
+    }
 }
diff --git a/Sources/Logging/DiagnosticsLogReport.swift b/Sources/Logging/DiagnosticsLogReport.swift
new file mode 100644
index 0000000..e1f5866
--- /dev/null
+++ b/Sources/Logging/DiagnosticsLogReport.swift
@@ -0,0 +1,234 @@
+//
+//  DiagnosticsLogReport.swift
+//  Diagnostics
+//
+//  Created by Diagnostics.
+//
+
+import Foundation
+
+struct DiagnosticsLogReport: Diagnostics, Codable, Sendable {
+    var sessions: [DiagnosticsLogSession]
+
+    func html() -> HTML {
+        var html = "<div id=\"log-sessions\">"
+        sessions.reversed().forEach { session in
+            html += session.html()
+        }
+        html += "</div>"
+        return html
+    }
+}
+
+struct DiagnosticsLogSession: Codable, Sendable {
+    var id: String
+    var title: String
+    var metadata: [String: String]
+    var events: [DiagnosticsLogEvent]
+    var legacyHTML: String?
+
+    init(
+        id: String = UUID().uuidString,
+        title: String,
+        metadata: [String: String] = [:],
+        events: [DiagnosticsLogEvent] = [],
+        legacyHTML: String? = nil
+    ) {
+        self.id = id
+        self.title = title
+        self.metadata = metadata
+        self.events = events
+        self.legacyHTML = legacyHTML
+    }
+
+    func html() -> HTML {
+        var html = "<div class=\"collapsible-session\"><details>"
+
+        if let legacyHTML {
+            if legacyHTML.isOldStyleSession {
+                html += "<summary>\(title.addingHTMLEncoding())</summary>"
+                html += "<pre>\(legacyHTML.addingHTMLEncoding())</pre>"
+            } else {
+                html += legacyHTML
+            }
+        } else {
+            html += "<summary><div class=\"session-header\">"
+            metadata.sorted(by: { $0.key < $1.key }).forEach { key, value in
+                html += "<p><span>\(key.addingHTMLEncoding()): </span>\(value.addingHTMLEncoding())</p>"
+            }
+            html += "</div></summary>"
+            events.forEach { event in
+                html += event.html()
+            }
+        }
+
+        html += "</details></div>"
+        return html
+    }
+}
+
+struct DiagnosticsLogEvent: Codable, Sendable {
+    let date: String?
+    let level: String
+    let prefix: String?
+    let message: String
+    let legacyHTML: String?
+
+    init(date: String?, level: String, prefix: String?, message: String, legacyHTML: String? = nil) {
+        self.date = date
+        self.level = level
+        self.prefix = prefix
+        self.message = message
+        self.legacyHTML = legacyHTML
+    }
+
+    func html() -> HTML {
+        if let legacyHTML {
+            return legacyHTML
+        }
+
+        var parts: [String] = []
+        if let date {
+            parts.append("<span class=\"log-date\">\(date.addingHTMLEncoding())</span>")
+        }
+        if let prefix {
+            parts.append("<span class=\"log-prefix\">\(prefix.addingHTMLEncoding())</span>")
+        }
+        parts.append("<span class=\"log-message\">\(message.addingHTMLEncoding())</span>")
+        let content = parts.joined(separator: "<span class=\"log-separator\"> | </span>")
+        if level == LoggableCSSClass.crash.rawValue {
+            return "<pre class=\"\(level)\">\(content)</pre>\n"
+        }
+        return "<p class=\"\(level)\">\(content)</p>\n"
+    }
+}
+
+struct DiagnosticsLogRecord: Codable, Sendable {
+    static let linePrefix = "DIAGNOSTICS_JSON "
+
+    let type: String
+    let date: String?
+    let level: String?
+    let prefix: String?
+    let message: String?
+    let metadata: [String: String]?
+
+    var lineData: Data {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.sortedKeys]
+
+        guard
+            let data = try? encoder.encode(self),
+            let json = String(data: data, encoding: .utf8) else {
+            return Data()
+        }
+
+        return Data("\(Self.linePrefix)\(json)\n".utf8)
+    }
+
+    init(loggable: Loggable) {
+        self.type = "log"
+        self.date = loggable.date.map(DateFormatter.current.string(from:))
+        self.level = loggable.cssClass?.rawValue ?? "debug"
+        self.prefix = loggable.prefix
+        self.message = loggable.message.removingHTMLEncoding()
+        self.metadata = nil
+    }
+
+    init(session: NewSession) {
+        self.type = "sessionStart"
+        self.date = session.metadata["Date"]
+        self.level = nil
+        self.prefix = nil
+        self.message = nil
+        self.metadata = session.metadata
+    }
+
+    init?(line: String) {
+        guard line.hasPrefix(Self.linePrefix) else {
+            return nil
+        }
+
+        let json = line.dropFirst(Self.linePrefix.count)
+        guard let data = String(json).data(using: .utf8),
+              let record = try? JSONDecoder().decode(Self.self, from: data) else {
+            return nil
+        }
+
+        self = record
+    }
+
+    var session: DiagnosticsLogSession {
+        let metadata = metadata ?? [:]
+        let title = metadata["Date"].map { "Session \($0)" } ?? "Session"
+        return DiagnosticsLogSession(title: title, metadata: metadata)
+    }
+
+    var event: DiagnosticsLogEvent? {
+        guard type == "log", let message else {
+            return nil
+        }
+
+        return DiagnosticsLogEvent(date: date, level: level ?? "debug", prefix: prefix, message: message)
+    }
+}
+
+struct DiagnosticsLogParser: Sendable {
+    func parse(_ logs: String) -> DiagnosticsLogReport {
+        var sessions: [DiagnosticsLogSession] = []
+        var currentStructuredSession: DiagnosticsLogSession?
+
+        logs.components(separatedBy: "\n\n---\n\n").forEach { chunk in
+            var legacyLines: [String] = []
+
+            func flushLegacyLines() {
+                let legacyHTML = legacyLines.joined(separator: "\n")
+                legacyLines.removeAll()
+                guard !legacyHTML.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return }
+
+                let title = legacyHTML.split(whereSeparator: \.isNewline).first.map(String.init) ?? "Unknown session title"
+                sessions.append(DiagnosticsLogSession(title: title, legacyHTML: legacyHTML))
+            }
+
+            chunk.components(separatedBy: .newlines).forEach { line in
+                guard let record = DiagnosticsLogRecord(line: line) else {
+                    legacyLines.append(line)
+                    return
+                }
+
+                flushLegacyLines()
+
+                if record.type == "sessionStart" {
+                    if let currentStructuredSession {
+                        sessions.append(currentStructuredSession)
+                    }
+                    currentStructuredSession = record.session
+                } else if let event = record.event {
+                    if currentStructuredSession == nil {
+                        currentStructuredSession = DiagnosticsLogSession(title: "Session")
+                    }
+                    currentStructuredSession?.events.append(event)
+                }
+            }
+
+            flushLegacyLines()
+        }
+
+        if let currentStructuredSession {
+            sessions.append(currentStructuredSession)
+        }
+
+        return DiagnosticsLogReport(sessions: sessions)
+    }
+}
+
+private extension String {
+    var isOldStyleSession: Bool {
+        !contains("class=\"session-header")
+    }
+
+    func removingHTMLEncoding() -> String {
+        replacingOccurrences(of: "&lt;", with: "<")
+            .replacingOccurrences(of: "&gt;", with: ">")
+    }
+}
diff --git a/Sources/Logging/DiagnosticsLogger.swift b/Sources/Logging/DiagnosticsLogger.swift
index 056c6ee..5a521b2 100644
--- a/Sources/Logging/DiagnosticsLogger.swift
+++ b/Sources/Logging/DiagnosticsLogger.swift
@@ -177,6 +177,16 @@ extension DiagnosticsLogger {
             self?.logsWriter.write(loggable)
         }
     }
+
+    func logSynchronously(_ loggable: Loggable) {
+        guard isSetup else {
+            return assertionFailure("Trying to log a message while not set up")
+        }
+
+        queue.sync { [weak self] in
+            self?.logsWriter.write(loggable)
+        }
+    }
 }
 
 // MARK: - System logs
diff --git a/Sources/Logging/Loggable.swift b/Sources/Logging/Loggable.swift
index ff27382..03b3774 100644
--- a/Sources/Logging/Loggable.swift
+++ b/Sources/Logging/Loggable.swift
@@ -2,7 +2,7 @@ import Foundation
 import MetricKit
 
 enum LoggableCSSClass: String, Sendable {
-    case debug, error, system
+    case crash, debug, error, system
 }
 
 protocol Loggable: Sendable {
@@ -25,35 +25,29 @@ extension Loggable {
     var cssClass: LoggableCSSClass? { nil }
 
     var logData: Data {
-        if let cssClass {
-            Data("<p class=\"\(cssClass)\">\(logMessage)</p>\n".utf8)
-        } else {
-            Data("\(message)\n".utf8)
+        if let newSession = self as? NewSession {
+            return DiagnosticsLogRecord(session: newSession).lineData
         }
+        return DiagnosticsLogRecord(loggable: self).lineData
     }
 
-    private var logMessage: String {
-        var messages: [String] = []
-        if let date {
-            let date = DateFormatter.current.string(from: date)
-            messages.append("<span class=\"log-date\">\(date)</span>")
-        }
-        if let prefix {
-            messages.append("<span class=\"log-prefix\">\(prefix)</span>")
-        }
-        messages.append("<span class=\"log-message\">\(self.message)</span>")
-        return messages.joined(separator: "<span class=\"log-separator\"> | </span>")
-    }
 }
 
 struct NewSession: Loggable {
     let message: String
+    let metadata: [String: String]
 
     init() {
         let date = DateFormatter.current.string(from: Date())
         let appVersion = "\(Bundle.appVersion) (\(Bundle.appBuildNumber))"
         let system = "\(Device.systemName) \(Device.systemVersion)"
         let locale = Locale.preferredLanguages[0]
+        self.metadata = [
+            "Date": date,
+            "System": system,
+            "Locale": locale,
+            "Version": appVersion
+        ]
 
         /// We start with `\n\n---\n\n` for backwards compatibility since it's
         /// used for splitting the log into sections.
@@ -121,7 +115,9 @@ struct SystemLog: Loggable {
 }
 
 struct ExceptionLog: Loggable {
+    let date: Date? = Date()
     let message: String
+    let cssClass: LoggableCSSClass? = .crash
 
     init(_ exception: NSException, description: String) {
         let message = """
@@ -146,6 +142,8 @@ struct ExceptionLog: Loggable {
 #if os(iOS)
 extension MXDiagnosticPayload: @unchecked @retroactive Sendable {}
 extension MXDiagnosticPayload: Loggable {
+    var cssClass: LoggableCSSClass? { .crash }
+
     var message: String {
         """
 
diff --git a/Sources/Logging/LogsTrimmer.swift b/Sources/Logging/LogsTrimmer.swift
index 6b34735..1c9d5ce 100644
--- a/Sources/Logging/LogsTrimmer.swift
+++ b/Sources/Logging/LogsTrimmer.swift
@@ -19,13 +19,27 @@ struct LogsTrimmer: Sendable {
 
     func trim(data: inout Data) {
         var logs = String(decoding: data, as: UTF8.self)
+        let legacyRecordsTrimmed = trimLegacyRecords(from: &logs, maximumNumberOfRecordsToTrim: numberOfLinesToTrim)
+        guard legacyRecordsTrimmed < numberOfLinesToTrim else {
+            data = Data(logs.utf8)
+            return
+        }
+
+        _ = trimStructuredRecords(
+            from: &logs,
+            maximumNumberOfRecordsToTrim: numberOfLinesToTrim - legacyRecordsTrimmed
+        )
+        data = Data(logs.utf8)
+    }
+
+    private func trimLegacyRecords(from logs: inout String, maximumNumberOfRecordsToTrim: Int) -> Int {
         let nsLogs = logs as NSString
         let matches = LogsTrimmer.regex
             .matches(in: logs, range: NSRange(location: 0, length: nsLogs.length))
 
-        let linesToRemove = matches.prefix(numberOfLinesToTrim)
+        let linesToRemove = matches.prefix(maximumNumberOfRecordsToTrim)
         guard let firstMatch = linesToRemove.first, let lastMatch = linesToRemove.last else {
-            return
+            return 0
         }
 
         let range = NSRange(
@@ -34,6 +48,27 @@ struct LogsTrimmer: Sendable {
         )
 
         logs = nsLogs.replacingCharacters(in: range, with: "")
-        data = Data(logs.utf8)
+        return linesToRemove.count
+    }
+
+    private func trimStructuredRecords(from logs: inout String, maximumNumberOfRecordsToTrim: Int) -> Int {
+        var trimmedRecords = 0
+        var lines = logs.components(separatedBy: .newlines)
+
+        while trimmedRecords < maximumNumberOfRecordsToTrim {
+            guard let index = lines.firstIndex(where: { line in
+                line.hasPrefix(DiagnosticsLogRecord.linePrefix) && line.contains("\"type\":\"log\"")
+            }) else {
+                break
+            }
+
+            lines.remove(at: index)
+            trimmedRecords += 1
+        }
+
+        guard trimmedRecords > 0 else { return 0 }
+
+        logs = lines.joined(separator: "\n")
+        return trimmedRecords
     }
 }
diff --git a/Sources/MetricKit/MetricsMonitor.swift b/Sources/MetricKit/MetricsMonitor.swift
index b44d220..9804829 100644
--- a/Sources/MetricKit/MetricsMonitor.swift
+++ b/Sources/MetricKit/MetricsMonitor.swift
@@ -23,7 +23,7 @@ final class MetricsMonitor: NSObject, Sendable {
 
     /// Creates a new log section with the current thread call stack symbols.
     private static func logExceptionUsingCallStackSymbols(_ exception: NSException, description: String) {
-        DiagnosticsLogger.standard.log(ExceptionLog(exception, description: description))
+        DiagnosticsLogger.standard.logSynchronously(ExceptionLog(exception, description: description))
     }
 }
 
diff --git a/Sources/Reporters/LogsReporter.swift b/Sources/Reporters/LogsReporter.swift
index c333aea..5da263a 100644
--- a/Sources/Reporters/LogsReporter.swift
+++ b/Sources/Reporters/LogsReporter.swift
@@ -13,32 +13,19 @@ struct LogsReporter: DiagnosticsReporting {
 
     let title: String = "Session Logs"
 
-    var diagnostics: String {
+    var diagnostics: DiagnosticsLogReport {
         do {
             guard let data = try DiagnosticsLogger.standard.readLog(), let logs = String(data: data, encoding: .utf8) else {
-                return "Parsing the log failed (Unknown error)"
+                return DiagnosticsLogReport(sessions: [
+                    DiagnosticsLogSession(title: "Parsing failed", legacyHTML: "Parsing the log failed (Unknown error)")
+                ])
             }
 
-            let sessions = logs.components(separatedBy: "\n\n---\n\n").reversed()
-            var diagnostics = ""
-            sessions.forEach { session in
-                guard !session.isEmpty else { return }
-
-                diagnostics += "<div class=\"collapsible-session\">"
-                diagnostics += "<details>"
-                if session.isOldStyleSession {
-                    let title = session.split(whereSeparator: \.isNewline).first ?? "Unknown session title"
-                    diagnostics += "<summary>\(title)</summary>"
-                    diagnostics += "<pre>\(session.addingHTMLEncoding())</pre>"
-                } else {
-                    diagnostics += session
-                }
-                diagnostics += "</details>"
-                diagnostics += "</div>"
-            }
-            return diagnostics
+            return DiagnosticsLogParser().parse(logs)
         } catch {
-            return "Parsing the log failed (\(error.localizedDescription))"
+            return DiagnosticsLogReport(sessions: [
+                DiagnosticsLogSession(title: "Parsing failed", legacyHTML: "Parsing the log failed (\(error.localizedDescription))")
+            ])
         }
     }
 
@@ -49,12 +36,6 @@ struct LogsReporter: DiagnosticsReporting {
 
 extension LogsReporter: HTMLFormatting {
     static func format(_ diagnostics: Diagnostics) -> HTML {
-        return "<div id=\"log-sessions\">\(diagnostics)</div>"
-    }
-}
-
-private extension String {
-    var isOldStyleSession: Bool {
-        !contains("class=\"session-header")
+        return diagnostics.html()
     }
 }
diff --git a/Sources/functions.js b/Sources/functions.js
index e4625e8..314fdd9 100644
--- a/Sources/functions.js
+++ b/Sources/functions.js
@@ -22,35 +22,263 @@ function showSystemLogs(shouldShow, className) {
     });
 }
 
-window.onload = (function () {
-    document.getElementById("expand-sections").onclick = function() {
-        expandElements(true);
-    };
-    document.getElementById("collapse-sections").onclick = function() {
-        expandElements(false);
-    };
-
-    document.getElementById('system-logs').addEventListener('change', (event) => {
-      if (event.currentTarget.checked) {
-        showSystemLogs(true, '.system');
-      } else {
-        showSystemLogs(false, '.system');
-      }
-    });
-
-    document.getElementById('debug-logs').addEventListener('change', (event) => {
-      if (event.currentTarget.checked) {
-        showSystemLogs(true, '.debug');
-      } else {
-        showSystemLogs(false, '.debug');
-      }
-    });
-
-    document.getElementById('error-logs').addEventListener('change', (event) => {
-      if (event.currentTarget.checked) {
-        showSystemLogs(true, '.error');
-      } else {
-        showSystemLogs(false, '.error');
-      }
+function appendTextElement(parent, tagName, text, className) {
+    const element = document.createElement(tagName);
+    element.textContent = text;
+    if (className) {
+        element.className = className;
+    }
+    parent.appendChild(element);
+    return element;
+}
+
+function renderLogEvent(event) {
+    if (event.legacyHTML) {
+        const template = document.createElement('template');
+        template.innerHTML = event.legacyHTML;
+        return template.content;
+    }
+
+    const element = event.level === 'crash' ? document.createElement('pre') : document.createElement('p');
+    element.className = event.level || 'debug';
+
+    const parts = [];
+    if (event.date) {
+        parts.push(['log-date', event.date]);
+    }
+    if (event.prefix) {
+        parts.push(['log-prefix', event.prefix]);
+    }
+    parts.push(['log-message', event.message || '']);
+
+    parts.forEach(([className, text], index) => {
+        if (index > 0) {
+            appendTextElement(element, 'span', ' | ', 'log-separator');
+        }
+        appendTextElement(element, 'span', text, className);
+    });
+
+    return element;
+}
+
+function renderLogSession(session) {
+    const wrapper = document.createElement('div');
+    wrapper.className = 'collapsible-session';
+    const details = document.createElement('details');
+    wrapper.appendChild(details);
+
+    if (session.legacyHTML) {
+        if (session.legacyHTML.includes('class="session-header')) {
+            const template = document.createElement('template');
+            template.innerHTML = session.legacyHTML;
+            details.appendChild(template.content);
+        } else {
+            appendTextElement(details, 'summary', session.title || 'Unknown session title');
+            const pre = document.createElement('pre');
+            pre.textContent = session.legacyHTML;
+            details.appendChild(pre);
+        }
+        return wrapper;
+    }
+
+    const summary = document.createElement('summary');
+    const header = document.createElement('div');
+    header.className = 'session-header';
+    Object.keys(session.metadata || {}).sort().forEach(key => {
+        const paragraph = document.createElement('p');
+        appendTextElement(paragraph, 'span', `${key}: `);
+        paragraph.appendChild(document.createTextNode(session.metadata[key]));
+        header.appendChild(paragraph);
+    });
+    summary.appendChild(header);
+    details.appendChild(summary);
+
+    (session.events || []).forEach(event => {
+        details.appendChild(renderLogEvent(event));
+    });
+
+    return wrapper;
+}
+
+function renderChapterContent(chapter) {
+    const content = document.createElement('div');
+    content.className = 'chapter-content';
+    const data = chapter.data || {};
+
+    if (chapter.legacyHTML) {
+        content.innerHTML = chapter.legacyHTML;
+        return content;
+    }
+
+    if (data.type === 'table') {
+        const table = document.createElement('table');
+        (data.rows || []).forEach(row => {
+            const tr = document.createElement('tr');
+            appendTextElement(tr, 'th', row.key);
+            appendTextElement(tr, 'td', row.value);
+            table.appendChild(tr);
+        });
+        content.appendChild(table);
+    } else if (data.type === 'logs') {
+        const logSessions = document.createElement('div');
+        logSessions.id = 'log-sessions';
+        (data.sessions || []).slice().reverse().forEach(session => {
+            logSessions.appendChild(renderLogSession(session));
+        });
+        content.appendChild(logSessions);
+    } else if (data.type === 'preformatted') {
+        const pre = document.createElement('pre');
+        pre.textContent = data.value || '';
+        content.appendChild(pre);
+    } else if (data.type === 'legacyHTML') {
+        content.innerHTML = data.value || chapter.legacyHTML || '';
+    } else {
+        content.textContent = data.value || '';
+    }
+
+    return content;
+}
+
+function renderDiagnosticsReport() {
+    const dataElement = document.getElementById('diagnostics-report-data');
+    const mountElement = document.getElementById('diagnostics-report');
+    if (!dataElement || !mountElement) {
+        return;
+    }
+
+    let report;
+    try {
+        report = JSON.parse(dataElement.textContent);
+    } catch (error) {
+        mountElement.textContent = `Unable to parse diagnostics report data: ${error}`;
+        return;
+    }
+
+    const aside = document.createElement('aside');
+    aside.className = 'nav-container';
+    const nav = document.createElement('nav');
+    const navList = document.createElement('ul');
+    (report.chapters || []).forEach(chapter => {
+        const listItem = document.createElement('li');
+        const anchor = document.createElement('a');
+        anchor.href = `#${chapter.id}`;
+        anchor.textContent = chapter.title;
+        listItem.appendChild(anchor);
+        navList.appendChild(listItem);
+    });
+
+    [
+        ['expand-sections', 'Expand sessions'],
+        ['collapse-sections', 'Collapse sessions']
+    ].forEach(([id, label]) => {
+        const listItem = document.createElement('li');
+        const button = appendTextElement(listItem, 'button', label);
+        button.id = id;
+        navList.appendChild(listItem);
+    });
+
+    [
+        ['system-logs', 'Show system logs'],
+        ['crash-logs', 'Show crash logs'],
+        ['error-logs', 'Show error logs'],
+        ['debug-logs', 'Show debug logs']
+    ].forEach(([id, label]) => {
+        const listItem = document.createElement('li');
+        const input = document.createElement('input');
+        input.type = 'checkbox';
+        input.id = id;
+        input.name = id;
+        input.checked = true;
+        const labelElement = appendTextElement(listItem, 'label', label);
+        labelElement.htmlFor = id;
+        listItem.prepend(input);
+        navList.appendChild(listItem);
+    });
+
+    nav.appendChild(navList);
+    aside.appendChild(nav);
+    mountElement.appendChild(aside);
+
+    const mainContent = document.createElement('div');
+    mainContent.className = 'main-content';
+    const header = document.createElement('header');
+    appendTextElement(header, 'h1', report.title || 'Diagnostics Report');
+    mainContent.appendChild(header);
+
+    (report.chapters || []).forEach(chapter => {
+        const chapterElement = document.createElement('div');
+        chapterElement.className = 'chapter';
+        const anchor = document.createElement('span');
+        anchor.className = 'anchor';
+        anchor.id = chapter.id;
+        chapterElement.appendChild(anchor);
+        if (chapter.showTitle !== false) {
+            appendTextElement(chapterElement, 'h3', chapter.title);
+        }
+        chapterElement.appendChild(renderChapterContent(chapter));
+        mainContent.appendChild(chapterElement);
     });
+
+    mountElement.appendChild(mainContent);
+}
+
+window.onload = (function () {
+    renderDiagnosticsReport();
+
+    const expandSections = document.getElementById("expand-sections");
+    if (expandSections) {
+        expandSections.onclick = function() {
+            expandElements(true);
+        };
+    }
+    const collapseSections = document.getElementById("collapse-sections");
+    if (collapseSections) {
+        collapseSections.onclick = function() {
+            expandElements(false);
+        };
+    }
+
+    const systemLogs = document.getElementById('system-logs');
+    if (systemLogs) {
+        systemLogs.addEventListener('change', (event) => {
+          if (event.currentTarget.checked) {
+            showSystemLogs(true, '.system');
+          } else {
+            showSystemLogs(false, '.system');
+          }
+        });
+    }
+
+    const debugLogs = document.getElementById('debug-logs');
+    if (debugLogs) {
+        debugLogs.addEventListener('change', (event) => {
+          if (event.currentTarget.checked) {
+            showSystemLogs(true, '.debug');
+          } else {
+            showSystemLogs(false, '.debug');
+          }
+        });
+    }
+
+    const errorLogs = document.getElementById('error-logs');
+    if (errorLogs) {
+        errorLogs.addEventListener('change', (event) => {
+          if (event.currentTarget.checked) {
+            showSystemLogs(true, '.error');
+          } else {
+            showSystemLogs(false, '.error');
+          }
+        });
+    }
+
+    const crashLogs = document.getElementById('crash-logs');
+    if (crashLogs) {
+        crashLogs.addEventListener('change', (event) => {
+          if (event.currentTarget.checked) {
+            showSystemLogs(true, '.crash');
+          } else {
+            showSystemLogs(false, '.crash');
+          }
+        });
+    }
 });
\ No newline at end of file
diff --git a/Sources/style.css b/Sources/style.css
index 887de96..93f40b6 100644
--- a/Sources/style.css
+++ b/Sources/style.css
@@ -125,6 +125,12 @@ table th, table td {
   background-color: rgba(255, 0, 0, 0.4);
 }
 
+.crash {
+  background-color: rgba(255, 0, 0, 0.4);
+  padding: 8px;
+  white-space: pre-wrap;
+}
+
 input[type=checkbox] {
   margin: 10px 10px 10px 0px;
 }
diff --git a/agent-skill-install-instructions.md b/agent-skill-install-instructions.md
new file mode 100644
index 0000000..a3479ef
--- /dev/null
+++ b/agent-skill-install-instructions.md
@@ -0,0 +1,104 @@
+# Diagnostics Report Analyzer Skill Installation
+
+The Diagnostics Report Analyzer Skill helps AI agents inspect `Diagnostics-Report.html` attachments by reading the embedded JSON payload first, while still understanding legacy HTML-only and mixed-format reports.
+
+## Recommended: skills.sh
+
+Install the skill with `npx skills`:
+
+```bash
+npx skills add https://github.com/AvdLee/Diagnostics --skill diagnostics-report-analyzer-skill
+```
+
+Then ask your agent to use it when analyzing a report:
+
+```text
+Use the diagnostics report analyzer skill to inspect Diagnostics-Report.html and summarize the most likely issue.
+```
+
+## Claude Code Plugin
+
+This repository includes a Claude plugin manifest in `.claude-plugin/`.
+
+For personal use in Claude Code:
+
+1. Add this repository as a marketplace:
+
+```bash
+/plugin marketplace add AvdLee/Diagnostics
+```
+
+2. Install the plugin:
+
+```bash
+/plugin install diagnostics-report-analyzer@diagnostics-report-analyzer-skill
+```
+
+For project configuration, add the plugin to your repository's `.claude/settings.json`:
+
+```json
+{
+  "enabledPlugins": {
+    "diagnostics-report-analyzer@diagnostics-report-analyzer-skill": true
+  },
+  "extraKnownMarketplaces": {
+    "diagnostics-report-analyzer-skill": {
+      "source": {
+        "source": "github",
+        "repo": "AvdLee/Diagnostics"
+      }
+    }
+  }
+}
+```
+
+Claude Code will prompt contributors to install the plugin when they open the project.
+
+## Cursor Plugin
+
+This repository includes a Cursor plugin manifest in `.cursor-plugin/plugin.json`.
+
+Install or enable it using Cursor's plugin support, then ask Cursor to use the `diagnostics-report-analyzer-skill` when inspecting Diagnostics report attachments. See the [Cursor plugins documentation](https://cursor.com/docs/plugins) and [Cursor skills documentation](https://cursor.com/docs/context/skills#enabling-skills) for the latest installation flow.
+
+## OpenAI-Compatible Tools and Codex
+
+This repository includes OpenAI-compatible manifests at:
+
+- `openai.yml`
+- `agents/openai.yaml`
+
+For tools that use local skill folders, copy or symlink the skill folder into your tool's skills directory:
+
+```bash
+cp -R diagnostics-report-analyzer-skill/ "$CODEX_HOME/skills/diagnostics-report-analyzer-skill"
+```
+
+See the [Codex skills documentation](https://developers.openai.com/codex/skills/) for where your client expects skills to be saved.
+
+## pi Package Manager
+
+This repository includes `package.json` metadata for pi-compatible skill installation:
+
+```bash
+pi install https://github.com/AvdLee/Diagnostics
+```
+
+The skill will be available automatically in pi sessions that load the package.
+
+## Generic Plugin Manifest
+
+Clients that support generic plugin discovery can read `plugins.json`. It points to:
+
+```text
+diagnostics-report-analyzer-skill/
+```
+
+Use this path as the canonical skill folder for any client that supports the Agent Skills open format.
+
+## Manual Installation
+
+1. Clone this repository.
+2. Install or symlink `diagnostics-report-analyzer-skill/` into your AI client's skills directory.
+3. Ask your agent to use the Diagnostics Report Analyzer Skill when inspecting `.html` report attachments.
+
+To verify installation, ask your agent to inspect a Diagnostics report and confirm it reads `script#diagnostics-report-data` before falling back to rendered HTML.
diff --git a/agents/openai.yaml b/agents/openai.yaml
new file mode 100644
index 0000000..8d83aa7
--- /dev/null
+++ b/agents/openai.yaml
@@ -0,0 +1,22 @@
+name: diagnostics-report-analyzer
+version: "1.0.0"
+description: >-
+  Analyze AvdLee Diagnostics HTML reports using embedded JSON first, with
+  legacy HTML report fallback for older customer attachments.
+author:
+  name: Antoine van der Lee
+  email: contact@avanderlee.com
+repository: https://github.com/AvdLee/Diagnostics
+license: MIT
+keywords:
+  - diagnostics
+  - support
+  - debugging
+  - logs
+  - html-report
+  - json
+  - swift
+  - ios
+  - macos
+skills:
+  - diagnostics-report-analyzer-skill
diff --git a/diagnostics-report-analyzer-skill/SKILL.md b/diagnostics-report-analyzer-skill/SKILL.md
new file mode 100644
index 0000000..f6e01d2
--- /dev/null
+++ b/diagnostics-report-analyzer-skill/SKILL.md
@@ -0,0 +1,100 @@
+---
+name: diagnostics-report-analyzer-skill
+description: Analyze AvdLee Diagnostics HTML reports for customer support and debugging. Use this skill whenever the user asks to inspect, summarize, triage, debug, or explain a Diagnostics-Report.html attachment, Diagnostics session logs, embedded diagnostics JSON, legacy HTML-only reports, MetricKit crash diagnostics, app/system metadata, or support reports generated by the Diagnostics framework.
+---
+
+# Diagnostics Report Analyzer Skill
+
+Use this skill to analyze single-file reports generated by the AvdLee Diagnostics framework. These reports are usually emailed as `.html` attachments and may contain either structured JSON plus a browser renderer or older pre-rendered HTML only.
+
+## Core Principle
+
+Treat the report as diagnostic evidence, not as a webpage to summarize. Newer reports are intentionally designed for agents: they contain a structured JSON payload that is more precise and token-efficient than the rendered HTML.
+
+## Analysis Workflow
+
+### 1. Prefer Embedded JSON
+
+If the report contains this element, extract and parse its text content:
+
+```html
+<script id="diagnostics-report-data" type="application/json">
+```
+
+Use that JSON as the source of truth. Ignore CSS, JavaScript, navigation markup, and rendered HTML unless a chapter explicitly uses `legacyHTML`.
+
+Expected top-level fields:
+
+- `schemaVersion`: report schema version.
+- `title`: human-readable report title.
+- `agentHints`: producer-provided analysis hints.
+- `chapters`: report sections.
+
+Expected chapter shapes:
+
+- `showTitle`: browser rendering hint; does not affect analysis.
+- `kind: "logs"` with `data.sessions`.
+- `kind: "table"` with `data.rows`.
+- `kind: "text"` or `kind: "preformatted"` with `data.value`.
+- `kind: "legacyHTML"` for custom diagnostics or fallback content.
+- `legacyHTML`: optional display HTML for chapters that need custom browser rendering. Prefer `data` for analysis unless `data.type` is `legacyHTML` or the structured fields do not answer the question.
+
+### 2. Fall Back To Legacy HTML
+
+If the JSON script tag is absent, parse the HTML report directly:
+
+- Session logs are usually inside `#log-sessions`.
+- Sessions are usually wrapped in `.collapsible-session details`.
+- Session metadata is often in `<summary><div class="session-header">...`.
+- Log levels are usually expressed as `.debug`, `.error`, `.system`, and `.crash`.
+- Older reports may only expose crashes as `system` lines such as `SYSTEM: *** Terminating app due to uncaught exception...` or `SYSTEM: *** First throw call stack:`.
+- Older plain sessions may use delimiter-like content and `<pre>` blocks.
+
+Keep fallback parsing focused. Do not load or restate the entire HTML file when a small section answers the question.
+
+### 3. Prioritize Evidence
+
+Analyze in this order:
+
+1. Read `agentHints` if present.
+2. Inspect app/system metadata for app version, build, OS, device, locale, and environment.
+3. Inspect newest sessions first.
+4. Prioritize `crash` events, then `error` events, MetricKit diagnostics, and unusual system logs.
+5. If a session has no `crash` event, treat crash-like `system` lines as legacy crash evidence, but prefer structured `crash` events when both exist.
+6. Compare failing sessions with older sessions only when it helps explain a regression or repeated pattern.
+7. Inspect custom chapters for domain-specific state: feature flags, user defaults, directory trees, configuration, account state, or cached files.
+
+## Output Format
+
+Unless the user asks for a different format, respond with:
+
+```markdown
+## Summary
+One or two sentences describing what most likely happened.
+
+## Evidence
+- Specific session, timestamp, event level, metadata row, or chapter detail that supports the conclusion.
+- Another relevant detail if needed.
+
+## Recommended Next Steps
+- Concrete debugging or support action.
+- Code/config area to inspect if apparent.
+```
+
+Lead with the most likely explanation. If the evidence is inconclusive, say so and list the missing signal that would disambiguate it.
+
+## Token Discipline
+
+Diagnostics reports can be large. Stay selective:
+
+- Prefer the embedded JSON payload over raw HTML.
+- Start with newest sessions and crash/error events.
+- Summarize noisy system/debug logs by pattern before quoting individual entries.
+- Quote only short snippets that directly support a conclusion.
+- Avoid dumping raw logs unless the user explicitly asks.
+
+## Compatibility Notes
+
+Newer Diagnostics reports may include structured sessions and legacy sessions in the same payload because users can update an app after historic logs have already been persisted on device. Treat both as valid evidence.
+
+Legacy HTML chapters may contain trusted report markup created by the Diagnostics framework. Use them when structured data is unavailable, but keep the JSON payload as the preferred machine-readable interface whenever present.
diff --git a/diagnostics-report-analyzer-skill/evals/evals.json b/diagnostics-report-analyzer-skill/evals/evals.json
new file mode 100644
index 0000000..f61fb92
--- /dev/null
+++ b/diagnostics-report-analyzer-skill/evals/evals.json
@@ -0,0 +1,29 @@
+{
+  "skill_name": "diagnostics-report-analyzer-skill",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "A customer emailed me a Diagnostics-Report.html generated by the latest Diagnostics framework. It has script#diagnostics-report-data, several sessions, and errors in the newest session. Analyze what likely happened and tell me where to look next.",
+      "expected_output": "Extracts the embedded JSON instead of summarizing rendered HTML, focuses on newest sessions and error events, and returns a concise evidence-backed support/debug summary.",
+      "files": [
+        "fixtures/json-backed-report.html"
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "This is an older Diagnostics HTML report without embedded JSON. Inspect the session logs and summarize the likely crash cause without dumping all logs.",
+      "expected_output": "Falls back to legacy HTML parsing, identifies session metadata and error/crash-like entries, and avoids restating the full report.",
+      "files": [
+        "fixtures/legacy-report.html"
+      ]
+    },
+    {
+      "id": 3,
+      "prompt": "This report contains both historic legacy sessions and newer structured sessions after an app update. Determine whether the reported issue started before or after the update.",
+      "expected_output": "Recognizes mixed-format sessions as expected, treats crash-like system lines as legacy crash evidence when no structured crash event exists, prefers structured crash events when present, and cites timestamps/version metadata when reasoning about the app update boundary.",
+      "files": [
+        "fixtures/mixed-format-report.html"
+      ]
+    }
+  ]
+}
diff --git a/diagnostics-report-analyzer-skill/evals/fixtures/json-backed-report.html b/diagnostics-report-analyzer-skill/evals/fixtures/json-backed-report.html
new file mode 100644
index 0000000..344308c
--- /dev/null
+++ b/diagnostics-report-analyzer-skill/evals/fixtures/json-backed-report.html
@@ -0,0 +1,67 @@
+<!doctype html>
+<html>
+<head><title>Example Diagnostics Report</title></head>
+<body>
+<script id="diagnostics-report-data" type="application/json">
+{
+  "schemaVersion": 1,
+  "title": "Example App - Diagnostics Report",
+  "agentHints": [
+    "Agents should read this JSON payload instead of the rendered HTML.",
+    "Start with chapters where kind is logs, then inspect crash, error, and system events in the newest sessions first.",
+    "Use legacyHTML only as a browser-rendering fallback for custom diagnostics or HTML-formatted text; prefer data for analysis."
+  ],
+  "chapters": [
+    {
+      "id": "app-system-details",
+      "title": "App & System Details",
+      "showTitle": true,
+      "kind": "table",
+      "data": {
+        "type": "table",
+        "rows": [
+          { "key": "App Version", "value": "2.4.1 (2410)" },
+          { "key": "System", "value": "iOS 18.2" },
+          { "key": "Locale", "value": "en-US" }
+        ]
+      },
+      "legacyHTML": null
+    },
+    {
+      "id": "session-logs",
+      "title": "Session Logs",
+      "showTitle": true,
+      "kind": "logs",
+      "data": {
+        "type": "logs",
+        "sessions": [
+          {
+            "id": "old-session",
+            "title": "Session 2026-06-18 12:00:00",
+            "metadata": { "Date": "2026-06-18 12:00:00", "Version": "2.4.0 (2400)" },
+            "events": [
+              { "date": "2026-06-18 12:00:02", "level": "debug", "prefix": "Checkout.swift:L10", "message": "Checkout completed", "legacyHTML": null }
+            ],
+            "legacyHTML": null
+          },
+          {
+            "id": "new-session",
+            "title": "Session 2026-06-19 09:15:00",
+            "metadata": { "Date": "2026-06-19 09:15:00", "Version": "2.4.1 (2410)" },
+            "events": [
+              { "date": null, "level": "crash", "prefix": null, "message": "CRASH:\nDescription: app crashed during checkout restore\nReason: nil token after restore", "legacyHTML": null },
+              { "date": "2026-06-19 09:15:11", "level": "error", "prefix": "CheckoutStore.swift:L88", "message": "ERROR: paymentTokenMissing | The payment token was nil after app restore", "legacyHTML": null },
+              { "date": "2026-06-19 09:15:12", "level": "system", "prefix": null, "message": "SYSTEM: applicationWillTerminate", "legacyHTML": null }
+            ],
+            "legacyHTML": null
+          }
+        ]
+      },
+      "legacyHTML": null
+    }
+  ]
+}
+</script>
+<main id="diagnostics-report"></main>
+</body>
+</html>
diff --git a/diagnostics-report-analyzer-skill/evals/fixtures/legacy-report.html b/diagnostics-report-analyzer-skill/evals/fixtures/legacy-report.html
new file mode 100644
index 0000000..5bfb625
--- /dev/null
+++ b/diagnostics-report-analyzer-skill/evals/fixtures/legacy-report.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<html>
+<body>
+<main class="container">
+  <div class="main-content">
+    <div class="chapter">
+      <span class="anchor" id="session-logs"></span>
+      <h3>Session Logs</h3>
+      <div class="chapter-content">
+        <div id="log-sessions">
+          <div class="collapsible-session">
+            <details>
+              <summary><div class="session-header"><p><span>Date: </span>2026-06-19 08:00:00</p><p><span>System: </span>iOS 17.5</p><p><span>Version: </span>1.9.0 (1900)</p></div></summary>
+              <p class="debug"><span class="log-date">2026-06-19 08:00:02</span><span class="log-separator"> | </span><span class="log-prefix">LaunchViewModel.swift:L44</span><span class="log-separator"> | </span><span class="log-message">Loading cached account</span></p>
+              <p class="error"><span class="log-date">2026-06-19 08:00:04</span><span class="log-separator"> | </span><span class="log-prefix">AccountStore.swift:L102</span><span class="log-separator"> | </span><span class="log-message">ERROR: keychainItemNotFound | User session could not be restored</span></p>
+            </details>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</main>
+</body>
+</html>
diff --git a/diagnostics-report-analyzer-skill/evals/fixtures/mixed-format-report.html b/diagnostics-report-analyzer-skill/evals/fixtures/mixed-format-report.html
new file mode 100644
index 0000000..1d1a29d
--- /dev/null
+++ b/diagnostics-report-analyzer-skill/evals/fixtures/mixed-format-report.html
@@ -0,0 +1,56 @@
+<!doctype html>
+<html>
+<body>
+<script id="diagnostics-report-data" type="application/json">
+{
+  "schemaVersion": 1,
+  "title": "Mixed Format Diagnostics Report",
+  "agentHints": [
+    "This report contains legacy sessions from before the app update and structured sessions after the update."
+  ],
+  "chapters": [
+    {
+      "id": "session-logs",
+      "title": "Session Logs",
+      "showTitle": true,
+      "kind": "logs",
+      "data": {
+        "type": "logs",
+        "sessions": [
+          {
+            "id": "legacy-session",
+            "title": "Legacy session",
+            "metadata": {},
+            "events": [],
+            "legacyHTML": "<summary><div class=\"session-header\"><p><span>Date: </span>2026-06-18 18:30:00</p><p><span>Version: </span>3.1.0 (3100)</p></div></summary><p class=\"debug\"><span class=\"log-message\">User opened settings successfully</span></p>"
+          },
+          {
+            "id": "structured-session",
+            "title": "Session 2026-06-19 10:00:00",
+            "metadata": { "Date": "2026-06-19 10:00:00", "Version": "3.2.0 (3200)" },
+            "events": [
+              { "date": "2026-06-19 10:00:03", "level": "system", "prefix": null, "message": "SYSTEM: *** Terminating app due to uncaught exception 'NSRangeException', reason: 'index 4 beyond bounds [0 .. 2]'", "legacyHTML": null },
+              { "date": "2026-06-19 10:00:06", "level": "error", "prefix": "SettingsStore.swift:L61", "message": "ERROR: migrationFailed | Missing settings schema version", "legacyHTML": null }
+            ],
+            "legacyHTML": null
+          },
+          {
+            "id": "structured-crash-session",
+            "title": "Session 2026-06-19 10:05:00",
+            "metadata": { "Date": "2026-06-19 10:05:00", "Version": "3.2.0 (3200)" },
+            "events": [
+              { "date": "2026-06-19 10:05:02", "level": "system", "prefix": null, "message": "SYSTEM: *** Terminating app due to uncaught exception 'NSRangeException', reason: 'index 4 beyond bounds [0 .. 2]'", "legacyHTML": null },
+              { "date": "2026-06-19 10:05:02", "level": "crash", "prefix": null, "message": "CRASH:\nDescription: Uncaught Exception\nException name: NSRangeException\nReason: index 4 beyond bounds [0 .. 2]", "legacyHTML": null }
+            ],
+            "legacyHTML": null
+          }
+        ]
+      },
+      "legacyHTML": null
+    }
+  ]
+}
+</script>
+<main id="diagnostics-report"></main>
+</body>
+</html>
diff --git a/openai.yml b/openai.yml
new file mode 100644
index 0000000..8d83aa7
--- /dev/null
+++ b/openai.yml
@@ -0,0 +1,22 @@
+name: diagnostics-report-analyzer
+version: "1.0.0"
+description: >-
+  Analyze AvdLee Diagnostics HTML reports using embedded JSON first, with
+  legacy HTML report fallback for older customer attachments.
+author:
+  name: Antoine van der Lee
+  email: contact@avanderlee.com
+repository: https://github.com/AvdLee/Diagnostics
+license: MIT
+keywords:
+  - diagnostics
+  - support
+  - debugging
+  - logs
+  - html-report
+  - json
+  - swift
+  - ios
+  - macos
+skills:
+  - diagnostics-report-analyzer-skill
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..b5cbb48
--- /dev/null
+++ b/package.json
@@ -0,0 +1,6 @@
+{
+  "keywords": ["pi-package"],
+  "pi": {
+    "skills": ["./diagnostics-report-analyzer-skill"]
+  }
+}
diff --git a/plugins.json b/plugins.json
new file mode 100644
index 0000000..7feef70
--- /dev/null
+++ b/plugins.json
@@ -0,0 +1,14 @@
+{
+  "plugins": [
+    {
+      "name": "diagnostics-report-analyzer",
+      "version": "1.0.0",
+      "description": "Analyze AvdLee Diagnostics HTML reports using embedded JSON first, with legacy HTML report fallback.",
+      "repository": "https://github.com/AvdLee/Diagnostics",
+      "license": "MIT",
+      "skills": [
+        "./diagnostics-report-analyzer-skill"
+      ]
+    }
+  ]
+}