Pre-push review: T-1840 clipboard prose rewritten as mermaid

diff --git a/prism/Services/ClipboardService.swift b/prism/Services/ClipboardService.swiftindex b19e021..9f1a029 100644--- a/prism/Services/ClipboardService.swift+++ b/prism/Services/ClipboardService.swift@@ -28,24 +28,29 @@ enum ClipboardService {     /// Requirement 2.5: Same limit as file-based documents.     static let maxContentSize = 10_485_760 +    /// Maximum whitespace-separated tokens a mermaid diagram declaration may carry.+    ///+    /// The type keyword plus at most one direction or modifier token+    /// (`flowchart LR`, `pie showData`). See `declaredDiagramType`.+    private static let maxDeclarationTokenCount = 2+     // MARK: - Mermaid Detection Patterns -    /// Regex patterns for mermaid-specific syntax that wouldn't appear in prose.+    /// Strong mermaid syntax patterns: operator shapes that do not occur in prose.     ///-    /// These patterns detect:-    /// - Arrow operators: `-->`, `A---B`, `-.->`, `==>`, `-->>`, `->>`, `->>`-    /// - Node definitions with identifiers: `A[text]`, `A(text)`, `A{text}`, `A((text))`, `A[[text]]`-    /// - Relationship syntax: `:::`, `|text|`-    /// - Sequence diagram arrows: `->>`, `-->>`, `-x`, `--x`-    /// - Class diagram: `<|--`, `*--`, `o--`-    /// - ER diagram: `||--o{`, `}|--|{`-    /// - Pie chart: `"label": number` pattern-    /// - Gantt/Timeline: `section`, `title` keywords with content-    /// - Journey: `section` keyword+    /// A line matching any of these is treated as mermaid syntax unconditionally —+    /// including lines that end in sentence punctuation. Sequence-diagram messages+    /// routinely do (`Alice->>Bob: Are you there?`, `Bob-->>Alice: Yes, I am.`), and+    /// the arrow is unambiguous evidence regardless of how the label ends (T-1840).     ///-    /// Note: Node definition patterns require a preceding identifier to avoid matching-    /// prose with parentheses, markdown links [text](url), or JSON snippets {key: value}.-    private static let mermaidSyntaxPatterns: [String] = [+    /// These patterns detect:+    /// - Flowchart arrows: `-->`, `A---B`, `-.->`, `==>`+    /// - Sequence diagram arrows: `->>`, `-->>`+    /// - Class/style syntax: `:::`+    /// - Class diagram relationships: `<|--`, `*--`, `o--`+    /// - ER diagram relationships: `||--`, `}o--`, `}|--`, `--o{`, `--|{`+    /// - Pie chart: `"label": number` value lines+    private static let strongMermaidSyntaxPatterns: [String] = [         // Flowchart arrows (most common, placed first for early exit)         #"-->"#,           // Flowchart arrow         #"\w+[^\S\n]*---[^\S\n]*\w+"#, // Solid line with node identifiers (A---B) on same line@@ -54,17 +59,8 @@ enum ClipboardService {         // Sequence diagram arrows         #"->>"#,           // Async arrow         #"-->>"#,          // Async dashed arrow-        #"-x"#,            // Cross-        #"--x"#,           // Dashed cross-        // Node definitions - require preceding identifier to avoid matching prose-        #"\w\[[^\]]+\]"#,  // Square bracket nodes: A[text] (not markdown links)-        #"\w\([^)]+\)"#,   // Parenthesis nodes: A(text) (not prose parentheses)-        #"\w\{[^}]+\}"#,   // Curly brace nodes: A{text} (not JSON snippets)-        #"\(\([^)]+\)\)"#, // Double parenthesis ((text)) - unique to mermaid-        #"\[\[[^\]]+\]\]"#, // Double brackets [[text]] - unique to mermaid         // Class/style syntax         #":::"#,           // Class definition-        #"\|[^|]+\|"#,     // Edge labels |text|         // Class diagram relationships         #"<\|--"#,         // Inheritance         #"\*--"#,          // Composition@@ -77,18 +73,97 @@ enum ClipboardService {         #"--\|\{"#,        // ER one-to-many mandatory         // Pie chart syntax         #""[^"]+"\s*:\s*\d+(?:\.\d+)?"#, // "label": number (integer or float)+    ]++    /// Weak mermaid *shape* patterns: node and edge shapes that ordinary prose can+    /// also produce.+    ///+    /// These only count as mermaid syntax on lines that do not end in sentence+    /// punctuation (see `endsInSentencePunctuation`), because each shape has a+    /// common prose double: a numbered citation (`results[3]`), an unspaced+    /// parenthetical (`the tool(a favorite)`), a JSON snippet (`{key: value}`), a+    /// wiki-link (`[[Page]]`), a footnote marker (`[*]`), a table/pipe fragment+    /// (`|x|`), or a hyphenated word containing `-x` (`non-xml`) (T-1840).+    ///+    /// These patterns detect:+    /// - Node definitions with identifiers: `A[text]`, `A(text)`, `A{text}`, `A((text))`, `A[[text]]`+    /// - Member-block openers: `class Animal{`, `CUSTOMER {` (see below)+    /// - Sequence diagram crosses: `-x`, `--x`+    /// - Edge labels: `|text|`+    /// - State diagram start/end: `[*]`+    ///+    /// Note: Node definition patterns require a preceding identifier to avoid matching+    /// prose with parentheses, markdown links [text](url), or JSON snippets {key: value}.+    ///+    /// The member-block opener is what makes class, ER, and state diagrams detectable+    /// when their body spans lines. `\w\{[^}]+\}` only matches a brace pair closed on+    /// the same line, so a fields-only `class Animal{ … }` — the form in mermaid's own+    /// documentation — carries no other syntax for detection to land on once matching+    /// became per-line (T-1840).+    private static let weakMermaidShapePatterns: [String] = [+        // Sequence diagram crosses (`-x` is a substring of hyphenated words)+        #"-x"#,            // Cross+        #"--x"#,           // Dashed cross+        // Node definitions - require preceding identifier to avoid matching prose+        #"\w\[[^\]]+\]"#,  // Square bracket nodes: A[text] (not markdown links)+        #"\w\([^)]+\)"#,   // Parenthesis nodes: A(text) (not prose parentheses)+        #"\w\{[^}]+\}"#,   // Curly brace nodes: A{text} (not JSON snippets)+        #"\(\([^)]+\)\)"#, // Double parenthesis ((text)) - unique to mermaid+        #"\[\[[^\]]+\]\]"#, // Double brackets [[text]] - unique to mermaid+        // Edge labels+        #"\|[^|]+\|"#,     // Edge labels |text|         // State diagram         #"\[\*\]"#,        // Start/end state [*]-        // Gantt/Timeline/Journey keywords (at start of line)-        #"(?m)^\s*section\s+"#, // section keyword-        #"(?m)^\s*title\s+"#,   // title keyword-        #"(?m)^\s*dateFormat\s+"#, // dateFormat keyword+        // Member-block opener: identifier followed by an unclosed brace (class Animal{)+        #"\w[^\S\n]*\{[^\S\n]*$"#,+    ]++    /// Weak mermaid *directive* patterns: the Gantt/Timeline/Journey line keywords+    /// `section`, `title`, and `dateFormat`, each paired with the diagram types it+    /// actually belongs to.+    ///+    /// Also weak — an ordinary sentence can start with "section" or "title"+    /// ("title case is preferred for headings.") — so, like the shape patterns, a+    /// directive is suppressed on a line ending in sentence punctuation. Unlike+    /// them it gets one narrow exemption: `?` and `!` are idiomatic in genuine+    /// diagram titles and sections (`title Are we on track?`, `section Ship it!`),+    /// so a `?`/`!`-terminated directive still counts when the text opens with a+    /// bare declaration of a diagram type that admits that directive (see+    /// `declaredDiagramType`). A trailing period never counts: a period-terminated+    /// title reads as prose in every diagram type.+    ///+    /// The type pairing is what keeps the exemption honest. `title` and `section`+    /// only mean anything in gantt, journey, timeline, and (for `title`) pie;+    /// `dateFormat` only in gantt. So `gantt` + `title Are we on track?` is+    /// detected, while a paragraph opening "Timeline mapping is useful" and later+    /// carrying "section 3 covers this?" is not — its opening line is prose, not a+    /// declaration (T-1840).+    private static let weakMermaidDirectives: [(pattern: String, diagramTypes: Set<String>)] = [+        // section keyword — gantt, journey, and timeline group their entries by section+        (#"(?m)^\s*section\s+"#, ["Gantt Chart", "User Journey", "Timeline"]),+        // title keyword — the same three plus pie+        (#"(?m)^\s*title\s+"#, ["Gantt Chart", "User Journey", "Timeline", "Pie Chart"]),+        // dateFormat keyword — gantt only+        (#"(?m)^\s*dateFormat\s+"#, ["Gantt Chart"]),     ]      /// Pre-compiled regex patterns for mermaid syntax detection.     /// Compiled once at load time to avoid repeated compilation on each paste operation.-    private static let compiledMermaidPatterns: [NSRegularExpression] = {-        mermaidSyntaxPatterns.compactMap { try? NSRegularExpression(pattern: $0) }+    private static let compiledStrongMermaidPatterns: [NSRegularExpression] = {+        strongMermaidSyntaxPatterns.compactMap { try? NSRegularExpression(pattern: $0) }+    }()++    private static let compiledWeakShapePatterns: [NSRegularExpression] = {+        weakMermaidShapePatterns.compactMap { try? NSRegularExpression(pattern: $0) }+    }()++    private static let compiledWeakDirectives: [(regex: NSRegularExpression, diagramTypes: Set<String>)] = {+        weakMermaidDirectives.compactMap { directive in+            guard let regex = try? NSRegularExpression(pattern: directive.pattern) else {+                return nil+            }+            return (regex: regex, diagramTypes: directive.diagramTypes)+        }     }()      /// Checks if clipboard contains text without reading content.@@ -219,12 +294,129 @@ enum ClipboardService {     /// that wouldn't normally appear in prose text. Uses pre-compiled regex     /// patterns for performance.     ///+    /// Matching is done per line, in three tiers (T-1840). Strong patterns (arrows,+    /// relationship operators, pie's `"label": number`) match on every line — a+    /// sequence-diagram message like `Alice->>Bob: Are you there?` ends in sentence+    /// punctuation but the arrow is unambiguous. The two weak tiers also occur in+    /// ordinary prose, so both are suppressed on a line ending in sentence+    /// punctuation (`.`, `?`, `!`):+    ///+    /// - Shape patterns (bracket/paren node shapes, edge labels, state markers) get+    ///   no exemption, because their prose doubles — a numbered citation+    ///   (`results[3]`), a parenthetical aside (`the tool(a favorite)`) — appear in+    ///   questions and exclamations just as readily as in declarative sentences.+    /// - Directive patterns (`title`/`section`/`dateFormat`) get one narrow+    ///   exemption: a `?`/`!`-terminated directive still counts when the text opens+    ///   with a bare declaration of a diagram type that admits it (see+    ///   `declaredDiagramType` and `weakMermaidDirectives`). So `gantt` followed by+    ///   `title Are we on track?` is detected, while a paragraph opening "Timeline+    ///   mapping is useful" and later carrying "section 3 covers this?" is not.+    ///   A trailing period is never exempt in either tier.+    ///+    /// See the fixture diagrams and prose fixtures in ClipboardServiceTests.+    ///+    /// Per-line matching scopes the negated-character-class patterns (`[^\]]`,+    /// `[^)]`, `[^}]`, `[^"]`) to a single line; when the whole text was matched in+    /// one pass they could span a literal newline (e.g. `A[first\nsecond]`).+    ///+    /// For the bracket, paren, and quote shapes that corner is out of scope: mermaid+    /// labels use `<br/>` (or backtick-quoted markdown strings) for line breaks, a+    /// raw newline inside a plain bracket label is not valid diagram source, and any+    /// real diagram has other single-line syntax for detection to land on.+    ///+    /// The brace shape is NOT such a corner and must not be dismissed as one. A+    /// multi-line `{ … }` is not a label — it is the member block of a class, ER, or+    /// state diagram, and a fields-only body (`class Animal{` / `+int age` / `}`) has+    /// no other syntax on any line. `\w\{[^}]+\}` stopped matching it the moment+    /// matching went per-line, so `weakMermaidShapePatterns` carries an explicit+    /// member-block-opener pattern to keep those three diagram types detected.+    ///     /// - Parameter text: The text to check.-    /// - Returns: True if any mermaid syntax pattern is found.+    /// - Returns: True if any strong pattern is found on any line, or any weak+    ///            pattern on a line its punctuation gate lets through.     static func containsMermaidSyntax(_ text: String) -> Bool {-        let nsRange = NSRange(text.startIndex..., in: text)-        return compiledMermaidPatterns.contains { regex in-            regex.firstMatch(in: text, range: nsRange) != nil+        let declaredType = declaredDiagramType(in: text)+        return text.components(separatedBy: .newlines).contains { line in+            let trimmed = line.trimmingCharacters(in: .whitespaces)+            guard !trimmed.isEmpty else {+                return false+            }+            let nsRange = NSRange(trimmed.startIndex..., in: trimmed)+            if compiledStrongMermaidPatterns.contains(where: { regex in+                regex.firstMatch(in: trimmed, range: nsRange) != nil+            }) {+                return true+            }+            guard !endsInSentencePunctuation(trimmed) else {+                // The one exemption: a `?`/`!`-terminated directive whose keyword+                // belongs to the diagram type the text actually declares.+                return trimmed.last != "." && compiledWeakDirectives.contains { directive in+                    directive.regex.firstMatch(in: trimmed, range: nsRange) != nil+                        && declaredType.map(directive.diagramTypes.contains) == true+                }+            }+            if compiledWeakDirectives.contains(where: { directive in+                directive.regex.firstMatch(in: trimmed, range: nsRange) != nil+            }) {+                return true+            }+            return compiledWeakShapePatterns.contains { regex in+                regex.firstMatch(in: trimmed, range: nsRange) != nil+            }+        }+    }++    /// The mermaid diagram type the text *declares*, or nil when its opening line is+    /// not a declaration.+    ///+    /// `MermaidTypeParser.parse` inspects only the first word of the first+    /// non-comment line, which is deliberately permissive — it exists to label+    /// source already known to be a diagram. That permissiveness is the whole reason+    /// prose can reach the syntax check at all: "Timeline for the migration project+    /// remains aggressive." parses as `Timeline`, because "Graph", "Pie", "Journey",+    /// "Timeline", "Kanban", "Architecture", and "Block" are ordinary English words+    /// as well as diagram keywords (T-1840).+    ///+    /// A real declaration is the keyword on its own, optionally followed by a single+    /// direction or modifier token (`gantt`, `journey`, `flowchart LR`,+    /// `pie showData`) — never a sentence. Requiring that shape before granting the+    /// directive tier its `?`/`!` exemption is what separates a punctuated gantt+    /// title from a hard-wrapped paragraph that merely starts with a keyword.+    ///+    /// - Parameter text: The full text being checked.+    /// - Returns: The declared diagram type name, or nil if the opening line is not+    ///            a bare declaration of a recognised type.+    private static func declaredDiagramType(in text: String) -> String? {+        for line in text.components(separatedBy: .newlines) {+            let trimmed = line.trimmingCharacters(in: .whitespaces)+            if trimmed.isEmpty || trimmed.hasPrefix("%%") {+                continue+            }+            guard trimmed.split(whereSeparator: \.isWhitespace).count <= maxDeclarationTokenCount else {+                return nil+            }+            let type = MermaidTypeParser.parse(trimmed)+            return type == "Diagram" ? nil : type+        }+        return nil+    }++    /// Checks whether a (trimmed, non-empty) line ends in any sentence-terminating+    /// punctuation.+    ///+    /// Mermaid syntax lines (`A[Node]`, `title My Diagram`, `"Label": 30`, ...) are+    /// terse and do not usually end with sentence-terminating punctuation, while+    /// ordinary prose sentences almost always do — a cheap discriminator that does+    /// not require parsing English (T-1840). It gates both weak tiers: the shape+    /// patterns unconditionally, and the directive patterns unless the text opens+    /// with a declaration of a type that admits the directive.+    ///+    /// - Parameter line: A trimmed, non-empty line.+    /// - Returns: True if the line ends with `.`, `?`, or `!`.+    private static func endsInSentencePunctuation(_ line: String) -> Bool {+        guard let last = line.last else {+            return false         }+        return last == "." || last == "?" || last == "!"     } }

diff --git a/prismTests/ClipboardServiceTests.swift b/prismTests/ClipboardServiceTests.swiftindex f2ba6fa..954dcc2 100644--- a/prismTests/ClipboardServiceTests.swift+++ b/prismTests/ClipboardServiceTests.swift@@ -514,4 +514,352 @@ struct ClipboardServiceTests {         let result = ClipboardService.wrapMermaidIfNeeded(input)         #expect(result == input, "Prose with JSON snippets should not be wrapped")     }++    // MARK: - T-1840: Prose False Positive Regression Tests+    //+    // Bug: wrapMermaidIfNeeded's heuristics were loose enough that ordinary prose+    // with numbered citations, parenthetical asides, or a "section"/"title" line+    // satisfied every gate (first-line keyword + syntax pattern + 2+ lines) and got+    // auto-wrapped in a mermaid codefence. Each case below starts with a line whose+    // first word is a genuine mermaid keyword that also happens to be an ordinary+    // English word ("graph", "kanban", "pie", "journey", "timeline", "architecture",+    // "block"), which is what let it through the MermaidTypeParser gate.++    @Test("wrapMermaidIfNeeded does NOT wrap prose with a numbered citation")+    func wrapMermaidIfNeededDoesNotWrapProseWithNumberedCitation() {+        // "applications[3]" satisfies the \w\[...\] node pattern exactly like a+        // real mermaid node (e.g. A[Start]) would.+        let input = """+            Graph theory has broad applications[3] in computer science.+            Many results[12] extend to infinite graphs as well.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Prose with numbered citations should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose with a keyword-adjacent parenthetical")+    func wrapMermaidIfNeededDoesNotWrapProseWithKeywordAdjacentParenthetical() {+        // "used(for tracking work)" satisfies the \w\(...\) node pattern.+        let input = """+            Kanban boards such as Trello are widely used(for tracking work).+            Teams report increased visibility into their backlog.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Prose with a keyword-adjacent parenthetical should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose starting with a keyword and a parenthetical aside")+    func wrapMermaidIfNeededDoesNotWrapProseWithParentheticalAside() {+        let input = """+            Pie is my favorite dessert(specifically apple pie).+            Many people prefer it over cake for celebrations.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Prose with a parenthetical aside should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose containing a lowercase 'section' sentence")+    func wrapMermaidIfNeededDoesNotWrapProseWithSectionSentence() {+        // "section 3 of the report..." satisfies the `^\s*section\s+` gantt/journey+        // directive pattern even though it's an ordinary sentence.+        let input = """+            Timeline for the migration project remains aggressive.+            section 3 of the report covers rollout details and risk.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Prose with a 'section ...' sentence should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose containing a lowercase 'title' sentence")+    func wrapMermaidIfNeededDoesNotWrapProseWithTitleSentence() {+        // "title case is preferred..." satisfies the `^\s*title\s+` directive pattern.+        let input = """+            Architecture reviews happen quarterly at our company.+            title case is preferred for all section headings in docs.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Prose with a 'title ...' sentence should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose with a bracketed citation on both lines")+    func wrapMermaidIfNeededDoesNotWrapProseWithBracketedCitationOnBothLines() {+        let input = """+            Block quotes are useful[1] for citing other authors.+            This technique appears frequently in academic writing[2].+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Prose with bracketed citations should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose starting with 'journey' and a parenthetical")+    func wrapMermaidIfNeededDoesNotWrapProseWithJourneyParenthetical() {+        let input = """+            Journey mapping(a UX technique) helps teams understand users.+            It is often used early in the design process.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Prose with a 'journey' opener and a parenthetical should not be wrapped")+    }++    // The same prose shapes, terminated with `?`/`!` instead of a period. The weak+    // *shape* patterns (citations, parentheticals) must stay gated on any sentence+    // punctuation — only the title/section/dateFormat directives get the `?`/`!`+    // exemption, so questions and exclamations cannot reopen this false-positive+    // class through a node-shape match.++    @Test("wrapMermaidIfNeeded does NOT wrap prose with a numbered citation ending in a question mark")+    func wrapMermaidIfNeededDoesNotWrapQuestionTerminatedProseWithCitation() {+        let input = """+            Graph theory has broad applications[3] in computer science?+            Many results[12] extend to infinite graphs as well.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Question-terminated prose with numbered citations should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose with a parenthetical ending in an exclamation mark")+    func wrapMermaidIfNeededDoesNotWrapExclamationTerminatedProseWithParenthetical() {+        let input = """+            Kanban boards such as Trello are widely used(for tracking work)!+            Teams report increased visibility into their backlog.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Exclamation-terminated prose with a parenthetical should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap 'journey' prose with a parenthetical ending in a question mark")+    func wrapMermaidIfNeededDoesNotWrapQuestionTerminatedJourneyParenthetical() {+        let input = """+            Journey mapping(a UX technique) helps teams understand users?+            It is often used early in the design process.+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Question-terminated 'journey' prose with a parenthetical should not be wrapped")+    }++    // Legitimate diagram shapes the syntax-pattern heuristic exists for must still be+    // detected — these have no arrow operator, so they rely entirely on the+    // title/section/dateFormat/quoted-number patterns the fix above narrows.++    @Test("wrapMermaidIfNeeded still wraps pie chart (no arrows, relies on quoted-number pattern)")+    func wrapMermaidIfNeededStillWrapsPieChartWithoutArrows() {+        let input = "pie\ntitle My Pie\n\"A\": 30\n\"B\": 70"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps gantt chart (no arrows, relies on title/dateFormat)")+    func wrapMermaidIfNeededStillWrapsGanttWithoutArrows() {+        let input = "gantt\ntitle A Gantt Diagram\ndateFormat YYYY-MM-DD"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps user journey (no arrows, relies on title/section)")+    func wrapMermaidIfNeededStillWrapsJourneyWithoutArrows() {+        let input = "journey\ntitle My working day\nsection Go to work"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps timeline (no arrows, relies on title pattern)")+    func wrapMermaidIfNeededStillWrapsTimelineWithoutArrows() {+        let input = "timeline\ntitle History\n2000 : Event A"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    // Punctuated diagram lines: the sentence-like gate must never suppress a line+    // carrying a strong operator pattern (arrows, relationships, pie values), and+    // `?`/`!` endings — idiomatic in genuine titles and labels — must not gate the+    // weak directive patterns either. Both shapes were detected on main and briefly+    // regressed when the gate skipped every punctuated line before matching.++    @Test("wrapMermaidIfNeeded still wraps sequence diagram whose messages end in punctuation")+    func wrapMermaidIfNeededStillWrapsPunctuatedSequenceDiagram() {+        let input = "sequenceDiagram\nAlice->>Bob: Are you there?\nBob-->>Alice: Yes, I am!"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps sequence diagram whose messages end in periods")+    func wrapMermaidIfNeededStillWrapsPeriodTerminatedSequenceDiagram() {+        let input = "sequenceDiagram\nClient->>Server: Please respond.\nServer-->>Client: Here you go."+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps gantt chart whose title ends in a question mark")+    func wrapMermaidIfNeededStillWrapsPunctuatedGantt() {+        let input = "gantt\ntitle Are we on track?\nsection Can we ship?"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps user journey whose title and section end in punctuation")+    func wrapMermaidIfNeededStillWrapsPunctuatedJourney() {+        let input = "journey\ntitle Are we on track?\nsection Is this done?"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("containsMermaidSyntax matches strong operator patterns on sentence-like lines")+    func containsMermaidSyntaxMatchesStrongPatternsOnSentenceLikeLines() {+        #expect(ClipboardService.containsMermaidSyntax("Alice->>Bob: Are you there?") == true)+        #expect(ClipboardService.containsMermaidSyntax("Bob-->>Alice: Yes, I am!") == true)+        #expect(ClipboardService.containsMermaidSyntax("Server-->>Client: Here you go.") == true)+        #expect(ClipboardService.containsMermaidSyntax("A --> B: Done.") == true)+    }++    @Test("containsMermaidSyntax ignores a matching pattern on a sentence-like line")+    func containsMermaidSyntaxIgnoresSentenceLikeLine() {+        #expect(ClipboardService.containsMermaidSyntax("Results improved[3] significantly.") == false)+        #expect(ClipboardService.containsMermaidSyntax("section 3 covers rollout details and risk.") == false)+        #expect(ClipboardService.containsMermaidSyntax("title case is preferred for headings.") == false)+    }++    @Test("containsMermaidSyntax still matches the same pattern without terminal punctuation")+    func containsMermaidSyntaxStillMatchesWithoutTerminalPunctuation() {+        #expect(ClipboardService.containsMermaidSyntax("Results[3] improved significantly") == true)+        #expect(ClipboardService.containsMermaidSyntax("section Go to work") == true)+        #expect(ClipboardService.containsMermaidSyntax("title My Diagram") == true)+    }++    @Test("containsMermaidSyntax ignores weak shape patterns on question- and exclamation-terminated lines")+    func containsMermaidSyntaxIgnoresShapePatternsOnPunctuatedLines() {+        #expect(ClipboardService.containsMermaidSyntax("Graph theory has broad applications[3] in computer science?") == false)+        #expect(ClipboardService.containsMermaidSyntax("Trello is widely used(for tracking work)!") == false)+        #expect(ClipboardService.containsMermaidSyntax("Journey mapping(a UX technique) helps teams understand users?") == false)+    }++    @Test("containsMermaidSyntax still matches directive patterns on question- and exclamation-terminated lines")+    func containsMermaidSyntaxMatchesDirectivesOnPunctuatedLines() {+        // The `?`/`!` exemption is granted by the declaration line, so these carry+        // one: gantt and journey both admit `title` and `section`.+        #expect(ClipboardService.containsMermaidSyntax("gantt\ntitle Are we on track?") == true)+        #expect(ClipboardService.containsMermaidSyntax("journey\nsection Ship it!") == true)+    }++    // The directive tier's `?`/`!` exemption is correlated with the declared diagram+    // type, so prose cannot claim it. A hard-wrapped paragraph whose first line+    // merely *starts* with a mermaid keyword is not a declaration, and a keyword+    // that is a declaration only exempts the directives its diagram type uses.++    @Test("containsMermaidSyntax ignores directive keywords in prose with no diagram declaration")+    func containsMermaidSyntaxIgnoresDirectiveProseWithoutDeclaration() {+        #expect(ClipboardService.containsMermaidSyntax("title case is preferred for headings, right?") == false)+        #expect(ClipboardService.containsMermaidSyntax("section 3 of the report covers revenue, doesn't it?") == false)+        #expect(ClipboardService.containsMermaidSyntax("Timeline mapping is useful\nsection 3 covers this?") == false)+    }++    @Test("containsMermaidSyntax ignores a punctuated directive the declared diagram type does not use")+    func containsMermaidSyntaxIgnoresPunctuatedDirectiveForeignToDeclaredType() {+        // Flowcharts have no `section`, and only gantt uses `dateFormat`.+        #expect(ClipboardService.containsMermaidSyntax("flowchart\nsection Ship it!") == false)+        #expect(ClipboardService.containsMermaidSyntax("journey\ndateFormat is confusing?") == false)+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose with a 'title' sentence ending in a question mark")+    func wrapMermaidIfNeededDoesNotWrapQuestionTerminatedProseWithTitleSentence() {+        let input = """+            Architecture reviews happen quarterly at our company.+            title case is preferred for all section headings, right?+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Question-terminated prose with a 'title ...' sentence should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap prose with a 'section' sentence ending in an exclamation mark")+    func wrapMermaidIfNeededDoesNotWrapExclamationTerminatedProseWithSectionSentence() {+        let input = """+            Timeline for the migration project remains aggressive.+            section 3 of the report covers rollout details and risk!+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "Exclamation-terminated prose with a 'section ...' sentence should not be wrapped")+    }++    @Test("wrapMermaidIfNeeded does NOT wrap a keyword-led paragraph whose 'section' line asks a question")+    func wrapMermaidIfNeededDoesNotWrapQuestionTerminatedSectionInKeywordParagraph() {+        // The reviewer's shape: "Timeline" opens the paragraph, so MermaidTypeParser+        // reports Timeline — a type that genuinely uses `section`. Only the opening+        // line failing to be a declaration keeps this out of the codefence.+        let input = """+            Timeline mapping is useful+            section 3 covers this?+            """+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == input, "A prose opener is not a diagram declaration and must not exempt the directive")+    }++    // Diagrams whose only mermaid syntax is a member block spanning several lines.+    // `\w\{[^}]+\}` requires the brace pair to close on the same line, so moving to+    // per-line matching silently un-detected every fields-only class, ER, and state+    // diagram — the exact form used in mermaid's own documentation. These pin the+    // member-block-opener pattern that keeps them detected.++    @Test("wrapMermaidIfNeeded still wraps a class diagram whose member block spans lines")+    func wrapMermaidIfNeededStillWrapsMultiLineClassBody() {+        let input = "classDiagram\nclass Animal{\n +int age\n +String gender\n}"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps a class diagram with a space before the member block")+    func wrapMermaidIfNeededStillWrapsSpacedClassBody() {+        let input = "classDiagram\nclass Animal {\n +int age\n}"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps an ER diagram whose attribute block spans lines")+    func wrapMermaidIfNeededStillWrapsMultiLineERBody() {+        let input = "erDiagram\nCUSTOMER{\nstring name\nstring email\n}"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("wrapMermaidIfNeeded still wraps a state diagram whose composite state spans lines")+    func wrapMermaidIfNeededStillWrapsCompositeState() {+        let input = "stateDiagram-v2\nstate First{\n Second\n}"+        let result = ClipboardService.wrapMermaidIfNeeded(input)+        #expect(result == "```mermaid\n\(input)\n```")+    }++    @Test("containsMermaidSyntax does NOT treat a prose line ending in a brace as a member block")+    func containsMermaidSyntaxIgnoresProseEndingInBrace() {+        // The brace must follow an identifier directly; `(x) {` and `else {` after a+        // non-word character do not qualify, so pasted pseudo-code stays prose.+        #expect(ClipboardService.containsMermaidSyntax("Here is some pseudo code: if (x) {") == false)+    }++    // The directive tier's type pairing, exercised for every entry. Only `title`+    // admits Pie Chart; `section` does not, and `dateFormat` is gantt-only. Without+    // these the Timeline and Pie Chart entries are never consulted, so a rename of+    // either display name would disable the exemption with a green suite.++    @Test("containsMermaidSyntax honours the declared type for every directive pairing")+    func containsMermaidSyntaxHonoursDirectiveTypePairings() {+        #expect(ClipboardService.containsMermaidSyntax("timeline\ntitle What happened?") == true)+        #expect(ClipboardService.containsMermaidSyntax("timeline\nsection Ship it!") == true)+        #expect(ClipboardService.containsMermaidSyntax("pie\ntitle Where does time go?") == true)+        #expect(ClipboardService.containsMermaidSyntax("gantt\ndateFormat YYYY?") == true)+        // Pie has no `section`, so the exemption must not extend to it.+        #expect(ClipboardService.containsMermaidSyntax("pie\nsection Ship it!") == false)+    }++    @Test("containsMermaidSyntax never exempts a period-terminated directive")+    func containsMermaidSyntaxNeverExemptsPeriodTerminatedDirective() {+        // Pins the `trimmed.last != "."` clause: a real declaration is present and the+        // type admits the directive, so only the trailing period keeps these out.+        #expect(ClipboardService.containsMermaidSyntax("gantt\ntitle Ship it.") == false)+        #expect(ClipboardService.containsMermaidSyntax("journey\nsection Go to work.") == false)+    }++    @Test("declaration recognition accepts a two-token declaration and skips comments")+    func declarationRecognitionAcceptsTwoTokensAndSkipsComments() {+        // Pins maxDeclarationTokenCount = 2 and the `%%` skip in declaredDiagramType.+        #expect(ClipboardService.containsMermaidSyntax("pie showData\ntitle Are we on track?") == true)+        #expect(ClipboardService.containsMermaidSyntax("%% a comment\ngantt\ntitle Are we on track?") == true)+    } }

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 9938073..6a45f39 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -19,6 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0  ### Fixed +- Pasting ordinary prose into clipboard mode no longer sometimes rewrites it as a broken mermaid diagram (T-1840). Prism auto-wraps clipboard text that looks like raw mermaid diagram source in a codefence so it renders correctly; the check for "looks like mermaid source" was loose enough that a paragraph with a numbered citation (`results[3]`), a parenthetical aside written without a leading space (`the tool(a favorite)`), or a sentence that happened to start with the word "section" or "title" could satisfy it, as long as the paragraph's first word was also a mermaid keyword — "Graph", "Pie", "Journey", "Timeline", "Kanban", "Architecture", and "Block" are all both. The check now weighs each line by how much the syntax on it could plausibly be prose. Operator syntax prose never produces — arrows, class and ER relationship operators, pie's `"label": number` lines — counts wherever it appears, even on a line ending in sentence punctuation, because a sequence-diagram message routinely does (`Alice->>Bob: Are you there?`). The ambiguous shapes prose also produces — bracketed or parenthesised tokens, edge-label pipes, and lines starting with "section", "title", or "dateFormat" — are ignored on any line that ends in `.`, `?`, or `!`, which is what a sentence does and a diagram label usually doesn't. Genuine diagram titles and sections *can* end in `?` or `!` (`title Are we on track?`), so those keywords get one narrow exemption: they still count when the text opens with an actual diagram declaration — the type keyword on its own, as in `gantt` or `journey`, not merely a paragraph whose first word happens to be one — and that declared type is one the keyword belongs to (`title` in gantt, journey, timeline, and pie; `section` in the first three of those; `dateFormat` in gantt alone). So a real gantt or journey whose title asks a question still wraps, while a paragraph opening "Timeline mapping is useful" and later carrying "section 3 covers this?" does not. A trailing full stop is never exempt in any diagram type, which is the one place detection deliberately narrowed: a gantt, journey, or pie chart whose only `title` or `section` line ends in a full stop is no longer auto-wrapped, and has to be fenced by hand. Every other real diagram shape is still detected, including the types with no arrow operator to fall back on (pie, gantt, journey, timeline) and the class, ER, and state diagrams whose member block spans several lines. - Arrow keys, Page Up/Down, Space, and the View menu's **Page Down**/**Page Up**/**Scroll to Top**/**Scroll to Bottom** no longer scroll the document behind an open note, footnote, add-note, reply, or document-note modal (T-1099, reopened). This was fixed once before; the WebKit rendering cutover restructured the views that carried the fix and the binding was never rebuilt, so scroll commands kept reaching the document underneath a modal that should have blocked them. The gate is restored on both the iPhone and iPad/Mac layouts, taking effect immediately when a modal is already open and staying live across every presentation and dismissal. - Replying to a document-level note is no longer silently discarded on a document that has only imported notes (T-1865). NotesPanel and SidebarNotesView create replies through a convenience method that used the document's saved user notes as its source of context; on a document where no user note had ever been created — only imported ones — that context was `nil`, so the guard returned early before the reply was ever built, leaving the tap with no visible effect and nothing written to disk. The method now falls back to the document's cached identifier, the same fallback its sibling document-note-creation method already used, so a reply always creates the note container it needs. - The safeguard that stops a broken document from reloading forever now holds when the crashes keep landing mid-load (T-2107). When a document's rendering process stops, the app reloads it, and if the reloads repeatedly fail to bring the document back it gives up after a few attempts and shows a banner offering a manual reload rather than retrying endlessly (T-1943 below). But a reload was counted as having succeeded the moment the page reported in — before it had finished laying out — so a renderer that reliably crashed in that window looked like a fresh failure each time instead of the same one continuing: the count started over on every attempt, and the document reloaded forever, which is exactly the loop the safeguard exists to prevent. A recovery now only counts as successful once the reloaded document has actually settled on screen, so crashes landing in that window accumulate toward the limit and reach the banner. Recoveries that do bring the document back still reset the count, and the banner's reload still restores everything as before.