From 066e49bf80d733c8d0f64df7f96a2713b9f70d24 Mon Sep 17 00:00:00 2001
From: Boris Kudryashov <boris.kudryashov@gmail.com>
Date: Mon, 26 Oct 2026 01:19:58 +0300
Subject: [PATCH 1/5] projcore: Task::rich_notes and Editor::set_rich_notes
 (#1801)

A task's notes can carry richtext markup beside the plain text every
reader uses. set_rich_notes splits a value into the two (markup kept only
when it formats something), and a plain set_notes of new text drops the
markup so old formatting never comes back over new text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L2XCadpiTmNZGJmLxXsMvK
---
 projcore/src/editor.rs             |  32 +++++++-
 projcore/src/editor/cells/tests.rs | 126 +++++++++++++++++++++++++++++
 projcore/src/model.rs              |   5 ++
 projcore/src/richtext.rs           |  53 ++++++++++++
 4 files changed, 215 insertions(+), 1 deletion(-)

diff --git a/projcore/src/editor.rs b/projcore/src/editor.rs
index 5f54ca6d6..beb1817bb 100644
--- a/projcore/src/editor.rs
+++ b/projcore/src/editor.rs
@@ -1573,7 +1573,37 @@ impl Editor {
             return Ok(false);
         }
         self.snapshot();
-        self.proj.tasks[i].notes = notes;
+        let task = &mut self.proj.tasks[i];
+        task.notes = notes;
+        // New plain text: the old formatting does not describe it (#1801).
+        task.rich_notes = None;
+        self.changed();
+        Ok(true)
+    }
+
+    /// Set a task's notes from a [`crate::richtext`] value as ONE undo step
+    /// (#1801): `notes` becomes its plain text (newline-normalised, empty
+    /// removes the notes) and `rich_notes` its canonical markup, kept only
+    /// when it formats something (`richtext::split_notes`). A value that is
+    /// not markup is plain text. Equal plain text with other formatting is a
+    /// change; the value a task already has changes nothing (`Ok(false)`). A
+    /// blank row cannot take notes.
+    pub fn set_rich_notes(&mut self, uid: i32, value: &str) -> Result<bool, String> {
+        let i = self.index(uid)?;
+        if self.proj.tasks[i].is_null {
+            return Err("A blank row cannot take notes".into());
+        }
+        let (notes, rich) = crate::richtext::split_notes(value);
+        let task = &self.proj.tasks[i];
+        if task.notes.as_deref().unwrap_or("") == notes.as_deref().unwrap_or("")
+            && task.rich_notes == rich
+        {
+            return Ok(false);
+        }
+        self.snapshot();
+        let task = &mut self.proj.tasks[i];
+        task.notes = notes;
+        task.rich_notes = rich;
         self.changed();
         Ok(true)
     }
diff --git a/projcore/src/editor/cells/tests.rs b/projcore/src/editor/cells/tests.rs
index e3dcd529f..261d7eca3 100644
--- a/projcore/src/editor/cells/tests.rs
+++ b/projcore/src/editor/cells/tests.rs
@@ -246,6 +246,132 @@ fn set_notes_survive_mspdi_save() {
     assert!(!xml.contains("<Notes>"));
 }
 
+/// Criterion 1 of #1801: markup is kept only when it formats, and its
+/// plain text is then the notes.
+fn rich_notes_consistent(task: &crate::Task) -> bool {
+    match &task.rich_notes {
+        None => true,
+        Some(m) => crate::richtext::split_notes(m) == (task.notes.clone(), Some(m.clone())),
+    }
+}
+
+const BOLD_NOTE: &str = "<p><b>Line 1</b></p>\n<li>Line 2</li>";
+
+#[test]
+fn rich_notes_set_plain_and_markup_as_one_step() {
+    let mut ed = editor();
+    let before = ed.project().clone();
+    assert!(ed.set_rich_notes(10, BOLD_NOTE).unwrap());
+    assert_eq!(ed.undo_depth(), 1);
+    assert!(ed.dirty());
+    let task = ed.project().task(10).unwrap();
+    assert_eq!(task.notes.as_deref(), Some("Line 1\nLine 2"));
+    assert_eq!(task.rich_notes.as_deref(), Some(BOLD_NOTE));
+    assert!(rich_notes_consistent(task));
+    let after = ed.project().clone();
+    assert!(ed.undo());
+    assert_eq!(ed.project(), &before);
+    assert!(ed.redo());
+    assert_eq!(ed.project(), &after);
+}
+
+#[test]
+fn rich_notes_style_only_change_is_a_step() {
+    let mut ed = editor();
+    assert!(ed.set_notes(10, "Line 1\nLine 2").unwrap());
+    ed.mark_saved();
+    let depth = ed.undo_depth();
+    // Same plain text, bold and a bullet added: a change of its own.
+    assert!(ed.set_rich_notes(10, BOLD_NOTE).unwrap());
+    assert_eq!(ed.undo_depth(), depth + 1);
+    assert!(ed.dirty());
+    assert!(ed.undo());
+    let task = ed.project().task(10).unwrap();
+    assert_eq!(task.notes.as_deref(), Some("Line 1\nLine 2"));
+    assert_eq!(task.rich_notes, None);
+}
+
+#[test]
+fn rich_notes_identical_is_no_step() {
+    let mut ed = editor();
+    assert!(ed.set_rich_notes(10, BOLD_NOTE).unwrap());
+    ed.mark_saved();
+    let history = (ed.undo_depth(), ed.redo_depth(), ed.dirty());
+    assert!(!ed.set_rich_notes(10, BOLD_NOTE).unwrap());
+    // A non-canonical spelling of the same value is the same value.
+    assert!(
+        !ed.set_rich_notes(10, "<p><b>Line </b><b>1</b></p>\n<li>Line 2</li>")
+            .unwrap()
+    );
+    assert_eq!((ed.undo_depth(), ed.redo_depth(), ed.dirty()), history);
+    // Plain markup of the plain notes a task has is no change either.
+    assert!(ed.set_notes(10, "x").unwrap());
+    let history = (ed.undo_depth(), ed.redo_depth(), ed.dirty());
+    assert!(!ed.set_rich_notes(10, "<p>x</p>").unwrap());
+    assert!(!ed.set_rich_notes(10, "x").unwrap());
+    assert_eq!((ed.undo_depth(), ed.redo_depth(), ed.dirty()), history);
+}
+
+#[test]
+fn rich_notes_without_formatting_store_none() {
+    let mut ed = editor();
+    assert!(ed.set_rich_notes(10, "<p>a &amp; b</p>\n<p></p>").unwrap());
+    let task = ed.project().task(10).unwrap();
+    assert_eq!(task.notes.as_deref(), Some("a & b\n"));
+    assert_eq!(task.rich_notes, None);
+    // Not markup: plain text, newline-normalised.
+    assert!(ed.set_rich_notes(10, "if a<b>c\r\nd").unwrap());
+    let task = ed.project().task(10).unwrap();
+    assert_eq!(task.notes.as_deref(), Some("if a<b>c\nd"));
+    assert_eq!(task.rich_notes, None);
+    // Empty removes the notes, formatting and all.
+    assert!(ed.set_rich_notes(10, BOLD_NOTE).unwrap());
+    assert!(ed.set_rich_notes(10, "<li></li>").unwrap());
+    let task = ed.project().task(10).unwrap();
+    assert_eq!((task.notes.clone(), task.rich_notes.clone()), (None, None));
+    // A blank row refuses, as for plain notes.
+    let i = ed.insert_blank_row(Some(10)).unwrap();
+    let blank = ed.project().tasks[i].uid;
+    assert_eq!(
+        ed.set_rich_notes(blank, BOLD_NOTE).unwrap_err(),
+        "A blank row cannot take notes"
+    );
+}
+
+#[test]
+fn set_notes_new_text_clears_rich_notes() {
+    let mut ed = editor();
+    ed.set_rich_notes(10, BOLD_NOTE).unwrap();
+    let depth = ed.undo_depth();
+    assert!(ed.set_notes(10, "Line 1\nLine 2!").unwrap());
+    assert_eq!(ed.undo_depth(), depth + 1);
+    let task = ed.project().task(10).unwrap();
+    assert_eq!(task.rich_notes, None);
+    assert!(rich_notes_consistent(task));
+    // Undo brings both back as they were.
+    assert!(ed.undo());
+    assert_eq!(
+        ed.project().task(10).unwrap().rich_notes.as_deref(),
+        Some(BOLD_NOTE)
+    );
+    // Removing the notes drops the formatting too.
+    assert!(ed.set_notes(10, "").unwrap());
+    assert_eq!(ed.project().task(10).unwrap().rich_notes, None);
+}
+
+#[test]
+fn set_notes_same_text_keeps_rich_notes() {
+    let mut ed = editor();
+    ed.set_rich_notes(10, BOLD_NOTE).unwrap();
+    let history = (ed.undo_depth(), ed.redo_depth(), ed.dirty());
+    // A host rewriting the unchanged plain text loses nothing.
+    assert!(!ed.set_notes(10, "Line 1\r\nLine 2").unwrap());
+    assert_eq!((ed.undo_depth(), ed.redo_depth(), ed.dirty()), history);
+    let task = ed.project().task(10).unwrap();
+    assert_eq!(task.rich_notes.as_deref(), Some(BOLD_NOTE));
+    assert!(rich_notes_consistent(task));
+}
+
 #[test]
 fn resources_preserve_allocations_and_undo_creation_together() {
     let mut ed = editor();
diff --git a/projcore/src/model.rs b/projcore/src/model.rs
index 800f1ccdd..5fea55e87 100644
--- a/projcore/src/model.rs
+++ b/projcore/src/model.rs
@@ -395,6 +395,11 @@ pub struct Task {
     pub hyperlink_sub_address: Option<String>,
     pub ignore_resource_calendar: Option<bool>,
     pub notes: Option<String>,
+    /// The notes' formatting as canonical [`crate::richtext`] markup (#1801):
+    /// `Some` only when it carries what `notes` cannot (bold, italic, a
+    /// non-left alignment or a bullet), and then its plain text is `notes`.
+    /// Saved in `formatting.xml` (`<note uid markup>`), never in MSPDI.
+    pub rich_notes: Option<String>,
     pub earned_value_method: Option<i32>,
     pub recurring: Option<bool>,
     pub hide_bar: Option<bool>,
diff --git a/projcore/src/richtext.rs b/projcore/src/richtext.rs
index ddaede8ba..0823960f5 100644
--- a/projcore/src/richtext.rs
+++ b/projcore/src/richtext.rs
@@ -125,6 +125,25 @@ impl Rich {
     }
 }
 
+/// A task's notes from a rich value (#1801): the plain text (`None` when
+/// empty) and the canonical markup, `None` unless it carries formatting the
+/// plain text cannot (bold, italic, a non-left alignment or a bullet). A
+/// value that is not markup is plain text, newline-normalised; empty plain
+/// text keeps no markup (an empty bullet is no note).
+pub fn split_notes(value: &str) -> (Option<String>, Option<String>) {
+    if !is_markup(value) {
+        let plain = crate::text::normalize_newlines(value);
+        return ((!plain.is_empty()).then_some(plain), None);
+    }
+    let rich = parse_markup(value);
+    if rich.text.is_empty() {
+        return (None, None);
+    }
+    let markup = rich.to_markup();
+    let formatted = markup != Rich::plain(&rich.text).to_markup();
+    (Some(rich.text), formatted.then_some(markup))
+}
+
 /// The canonical markup of `text` with its attributes. Short or missing
 /// attributes are read as plain / left, so a desynced state still writes.
 pub fn to_markup(text: &str, chars: &[u8], paras: &[Para]) -> String {
@@ -504,4 +523,38 @@ mod tests {
             invariant(&Rich::parse(s));
         }
     }
+
+    #[test]
+    fn split_notes_keeps_markup_only_when_it_formats() {
+        // Plain text, newline-normalised, no markup.
+        assert_eq!(split_notes("a\r\nb"), (Some("a\nb".into()), None));
+        assert_eq!(split_notes(""), (None, None));
+        // Markup without formatting is its plain text.
+        assert_eq!(
+            split_notes("<p> a\tb </p>\n<p></p>\n<p>c</p>"),
+            (Some(" a\tb \n\nc".into()), None)
+        );
+        // A plain note that looks like a tag is escaped, so it formats nothing.
+        let looks = Rich::plain("<p>hi").to_markup();
+        assert_eq!(looks, "<p>&lt;p&gt;hi</p>");
+        assert_eq!(split_notes(&looks), (Some("<p>hi".into()), None));
+        // Bold, a bullet or an alignment keep the canonical markup.
+        for m in [
+            "<p><b>x</b> y</p>",
+            "<li>x</li>",
+            "<p align=\"center\">x</p>",
+            "<p><i>a &amp; &lt;b&gt;</i></p>\n<li align=\"right\">c</li>",
+        ] {
+            let (plain, rich) = split_notes(m);
+            assert_eq!(rich.as_deref(), Some(m), "{m}");
+            assert_eq!(plain, Some(Rich::parse(m).to_plain()));
+        }
+        // Not canonical in, canonical out.
+        assert_eq!(
+            split_notes("<p><b>x</b><b>y</b></p>").1.as_deref(),
+            Some("<p><b>xy</b></p>")
+        );
+        // An empty formatted line is no note.
+        assert_eq!(split_notes("<li></li>"), (None, None));
+    }
 }

From 200ea61c122e276027f4fad641ae959880125f85 Mon Sep 17 00:00:00 2001
From: Boris Kudryashov <boris.kudryashov@gmail.com>
Date: Mon, 26 Oct 2026 01:22:39 +0300
Subject: [PATCH 2/5] projcore: rich task notes in formatting.xml, .yppx and
 the plugin seam (#1801)

The markup travels where the formatting does, as <note uid markup>
children of formatting.xml, so a .mpp plugin gets it through the
existing _ex symbols and a .yppx save keeps it. A note is applied on read
only to a task whose plain notes it still describes; a plan without rich
notes writes the part exactly as before (or none).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L2XCadpiTmNZGJmLxXsMvK
---
 projcore/src/formats/plugin.rs         |   7 +-
 projcore/src/formatting.rs             |   2 +
 projcore/src/formatting/notes.rs       | 127 +++++++++++++++++++++++
 projcore/src/formatting/notes/tests.rs | 138 +++++++++++++++++++++++++
 projcore/src/yppx.rs                   |  53 ++++++++--
 projcore/tests/plugins.rs              |  64 ++++++++++++
 6 files changed, 383 insertions(+), 8 deletions(-)
 create mode 100644 projcore/src/formatting/notes.rs
 create mode 100644 projcore/src/formatting/notes/tests.rs

diff --git a/projcore/src/formats/plugin.rs b/projcore/src/formats/plugin.rs
index 15e31eff9..462daf60c 100644
--- a/projcore/src/formats/plugin.rs
+++ b/projcore/src/formats/plugin.rs
@@ -629,6 +629,9 @@ impl ProjectFormat for PluginFormat {
                 .map_err(|_| format!("{}: the formatting it returned is not UTF-8", plugin.name))?;
             project.formatting = Formatting::from_xml(&text)
                 .map_err(|e| format!("{}: the formatting it returned: {e}", plugin.name))?;
+            // The tasks' rich notes travel in the same text (#1801).
+            crate::formatting::apply_notes(&mut project, &text)
+                .map_err(|e| format!("{}: the formatting it returned: {e}", plugin.name))?;
         }
         Ok(project)
     }
@@ -641,7 +644,9 @@ impl ProjectFormat for PluginFormat {
             ));
         }
         let xml = write_mspdi(project);
-        let formatting = (!project.formatting.is_empty()).then(|| project.formatting.to_xml());
+        // The formatting and the tasks' rich notes (#1801), NULL without
+        // either.
+        let formatting = crate::formatting::part_xml(project);
         self.plugin
             .write_file(&self.ext_c, &xml, formatting.as_deref(), source)
     }
diff --git a/projcore/src/formatting.rs b/projcore/src/formatting.rs
index e5844a6be..e27ccd989 100644
--- a/projcore/src/formatting.rs
+++ b/projcore/src/formatting.rs
@@ -15,9 +15,11 @@ use opccore::xml::{Event, XmlParser};
 pub mod bars;
 pub mod gridlines;
 pub mod layout;
+pub mod notes;
 pub use bars::{BarRow, BarText, Facts, Mark, Middle, TaskBar};
 pub use gridlines::{Gridline, Gridlines, LineType};
 pub use layout::Layout;
+pub use notes::{apply_notes, part_xml, rich_notes_json};
 
 /// The `.yppx` part the formatting is saved in.
 pub const PART: &str = "formatting.xml";
diff --git a/projcore/src/formatting/notes.rs b/projcore/src/formatting/notes.rs
new file mode 100644
index 000000000..9d37c5789
--- /dev/null
+++ b/projcore/src/formatting/notes.rs
@@ -0,0 +1,127 @@
+//! Rich task notes in the formatting part (#1801). `Task::rich_notes` is
+//! not formatting, but it travels where the formatting does: the `.yppx`
+//! `formatting.xml` part and the text a format plugin's `_ex` symbols carry
+//! (#1702), so a `.mpp` plugin gets the markup on write and returns it on
+//! read without a new ABI symbol.
+//!
+//! Shape: one `<note uid="N" markup="…"/>` per task with rich notes, in task
+//! order, after the formatting's own children. `markup` is the canonical
+//! [`crate::richtext`] markup with the attribute escapes plus `&#10;` for a
+//! newline and `&#9;` for a tab (an XML reader turns a raw one into a space).
+//! The other C0 controls cannot be written in XML 1.0 at all; they are
+//! written as they are and read back by this reader only.
+//!
+//! On read a `<note>` is applied only to an existing, non-blank task whose
+//! plain notes are the markup's plain text, so old formatting never lands on
+//! other text; any other is dropped. [`Formatting::from_xml`] ignores
+//! `<note>`, as an older build does, which then saves the part without them.
+//!
+//! [`Formatting::from_xml`]: super::Formatting::from_xml
+
+use super::{PART, decode};
+use crate::json::Json;
+use crate::model::Project;
+use opccore::xml::{Event, XmlParser};
+
+/// The `formatting.xml` text for `proj`: its formatting and the tasks' rich
+/// notes, or `None` when there is neither (no part is written, and a plugin
+/// gets no formatting text). Without rich notes it is exactly
+/// [`super::Formatting::to_xml`].
+pub fn part_xml(proj: &Project) -> Option<String> {
+    let noted = || proj.tasks.iter().filter(|t| t.rich_notes.is_some());
+    if proj.formatting.is_empty() && noted().next().is_none() {
+        return None;
+    }
+    let mut xml = proj.formatting.to_xml();
+    let mut notes = String::new();
+    for t in noted() {
+        notes.push_str("  <note");
+        super::push_attr(&mut notes, "uid", &t.uid.to_string());
+        push_markup(&mut notes, t.rich_notes.as_deref().unwrap_or(""));
+        notes.push_str("/>\n");
+    }
+    if !notes.is_empty() {
+        let end = xml.rfind("</formatting>").unwrap_or(xml.len());
+        xml.insert_str(end, &notes);
+    }
+    Some(xml)
+}
+
+/// ` markup="…"`, escaping what an attribute must keep: the markup's tags,
+/// quotes, and its newlines and tabs as character references.
+fn push_markup(out: &mut String, value: &str) {
+    out.push_str(" markup=\"");
+    for c in value.chars() {
+        match c {
+            '&' => out.push_str("&amp;"),
+            '<' => out.push_str("&lt;"),
+            '>' => out.push_str("&gt;"),
+            '"' => out.push_str("&quot;"),
+            '\n' => out.push_str("&#10;"),
+            '\t' => out.push_str("&#9;"),
+            '\r' => {}
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+}
+
+/// The `<note>`s of a `formatting.xml` text as `(uid, markup)`, in order.
+/// A note without a numeric `uid` is skipped.
+pub fn read_notes(xml: &str) -> Result<Vec<(i32, String)>, String> {
+    let mut parser = XmlParser::new(xml);
+    let mut out = Vec::new();
+    let mut depth = 0usize;
+    loop {
+        match parser.next() {
+            Event::Start => {
+                if depth == 1 && parser.name() == "note" {
+                    let uid = decode(parser.attr("uid")).trim().parse::<i32>().ok();
+                    if let Some(uid) = uid {
+                        out.push((uid, decode(parser.attr("markup"))));
+                    }
+                }
+                depth += 1;
+            }
+            Event::End => depth = depth.saturating_sub(1),
+            Event::Text => {}
+            Event::Eof => break,
+        }
+    }
+    if parser.is_malformed() {
+        return Err(format!("{PART}: not well-formed XML"));
+    }
+    Ok(out)
+}
+
+/// Give `proj`'s tasks the rich notes of a `formatting.xml` text, read after
+/// the tasks themselves (MSPDI). A note whose task is missing or blank, whose
+/// plain text is not the task's notes, or that formats nothing is dropped.
+pub fn apply_notes(proj: &mut Project, xml: &str) -> Result<(), String> {
+    for (uid, markup) in read_notes(xml)? {
+        let Some(task) = proj.tasks.iter_mut().find(|t| t.uid == uid && !t.is_null) else {
+            continue;
+        };
+        let (plain, rich) = crate::richtext::split_notes(&markup);
+        let notes = task.notes.as_deref().map(crate::text::normalize_newlines);
+        if rich.is_some() && plain == notes {
+            task.rich_notes = rich;
+        }
+    }
+    Ok(())
+}
+
+/// The UI plugin requests' read-only `view.rich_notes`: `{"<uid>": markup}`
+/// for every task with rich notes. A task not in it has plain notes only
+/// (MSPDI `<Notes>`, to be read as [`crate::richtext::Rich::plain`]).
+pub fn rich_notes_json(proj: &Project) -> Json {
+    Json::Obj(
+        proj.tasks
+            .iter()
+            .filter_map(|t| Some((t.uid.to_string(), Json::str(t.rich_notes.clone()?))))
+            .collect(),
+    )
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/projcore/src/formatting/notes/tests.rs b/projcore/src/formatting/notes/tests.rs
new file mode 100644
index 000000000..48139a89a
--- /dev/null
+++ b/projcore/src/formatting/notes/tests.rs
@@ -0,0 +1,138 @@
+use super::*;
+use crate::formatting::Formatting;
+use crate::model::Task;
+
+fn task(uid: i32, notes: Option<&str>, rich: Option<&str>) -> Task {
+    Task {
+        uid,
+        id: uid,
+        name: format!("T{uid}"),
+        notes: notes.map(str::to_string),
+        rich_notes: rich.map(str::to_string),
+        ..Task::default()
+    }
+}
+
+/// Every awkward thing a note can hold: bold, italic, a bullet, a centred
+/// line, escapes, a tab, spaces at both ends, an empty middle line.
+const RICH: &str = "<p align=\"center\"><b>Title</b></p>\n<li><i>a &amp; &lt;b&gt;</i>\t\"q\"</li>\n<p></p>\n<p> end </p>";
+const PLAIN: &str = "Title\na & <b>\t\"q\"\n\n end ";
+
+fn plan() -> Project {
+    Project {
+        tasks: vec![
+            task(1, Some(PLAIN), Some(RICH)),
+            task(2, Some("plain only"), None),
+            task(3, Some("x"), Some("<li>x</li>")),
+        ],
+        ..Project::default()
+    }
+}
+
+/// The tasks as they come out of MSPDI: plain notes, no markup.
+fn stripped(p: &Project) -> Project {
+    let mut p = p.clone();
+    for t in &mut p.tasks {
+        t.rich_notes = None;
+    }
+    p
+}
+
+#[test]
+fn notes_round_trip_in_formatting_xml() {
+    let proj = plan();
+    let xml = part_xml(&proj).expect("rich notes alone make a part");
+    // Newlines and tabs are character references; no raw one is left in the
+    // attribute, so a conforming XML reader keeps them.
+    let line = xml.lines().find(|l| l.contains("uid=\"1\"")).unwrap();
+    assert!(line.contains("&#10;") && line.contains("&#9;"), "{line}");
+    assert!(!line.contains('\t'));
+    assert!(xml.contains("  <note uid=\"3\" markup=\"&lt;li&gt;x&lt;/li&gt;\"/>\n</formatting>\n"));
+    assert!(
+        !xml.contains("uid=\"2\""),
+        "a plain-only task writes no note"
+    );
+    assert_eq!(
+        read_notes(&xml).unwrap(),
+        vec![(1, RICH.to_string()), (3, "<li>x</li>".to_string())]
+    );
+    let mut back = stripped(&proj);
+    apply_notes(&mut back, &xml).unwrap();
+    assert_eq!(back, proj);
+}
+
+#[test]
+fn no_rich_notes_formatting_xml_is_byte_identical() {
+    let mut proj = stripped(&plan());
+    assert_eq!(part_xml(&proj), None, "nothing to write, no part");
+    proj.formatting.palette = Some("fx.blue".into());
+    proj.formatting.set_switch("flag", Some(true));
+    assert_eq!(part_xml(&proj), Some(proj.formatting.to_xml()));
+}
+
+#[test]
+fn notes_follow_the_formatting() {
+    let mut proj = plan();
+    proj.formatting.palette = Some("fx.blue".into());
+    let xml = part_xml(&proj).unwrap();
+    // The formatting reads back as it was; its reader ignores the notes, as
+    // an older build does.
+    assert_eq!(Formatting::from_xml(&xml).unwrap(), proj.formatting);
+    let mut back = stripped(&proj);
+    apply_notes(&mut back, &xml).unwrap();
+    assert_eq!(back.tasks, proj.tasks);
+}
+
+#[test]
+fn from_xml_ignores_note_elements() {
+    let mut f = Formatting::default();
+    f.link_style = Some("curved".into());
+    let without = f.to_xml();
+    let with = without.replace(
+        "</formatting>",
+        "  <note uid=\"1\" markup=\"&lt;li&gt;x&lt;/li&gt;\"/>\n</formatting>",
+    );
+    assert_eq!(
+        Formatting::from_xml(&with).unwrap(),
+        Formatting::from_xml(&without).unwrap()
+    );
+}
+
+#[test]
+fn stale_note_is_dropped_on_apply() {
+    let xml = part_xml(&plan()).unwrap();
+    let mut proj = stripped(&plan());
+    // Task 1's text changed since the note was written; task 3 is now a
+    // blank row; a note for uid 9 has no task.
+    proj.tasks[0].notes = Some("Title\nsomething else".into());
+    proj.tasks[2].is_null = true;
+    let xml = xml.replace(
+        "</formatting>",
+        "  <note uid=\"9\" markup=\"&lt;li&gt;x&lt;/li&gt;\"/>\n</formatting>",
+    );
+    let before = proj.clone();
+    apply_notes(&mut proj, &xml).unwrap();
+    assert_eq!(proj, before);
+    // A note that formats nothing is no rich note, and a stored `\r\n` in the
+    // task's notes still matches.
+    let mut proj = Project {
+        tasks: vec![task(1, Some("a\r\nb"), None), task(2, Some("x"), None)],
+        ..Project::default()
+    };
+    let xml = "<formatting>\n  <note uid=\"1\" markup=\"&lt;li&gt;a&lt;/li&gt;&#10;&lt;p&gt;b&lt;/p&gt;\"/>\n  <note uid=\"2\" markup=\"&lt;p&gt;x&lt;/p&gt;\"/>\n  <note markup=\"&lt;li&gt;x&lt;/li&gt;\"/>\n</formatting>\n";
+    apply_notes(&mut proj, xml).unwrap();
+    assert_eq!(
+        proj.tasks[0].rich_notes.as_deref(),
+        Some("<li>a</li>\n<p>b</p>")
+    );
+    assert_eq!(proj.tasks[1].rich_notes, None);
+}
+
+#[test]
+fn rich_notes_json_lists_the_formatted_tasks_only() {
+    assert_eq!(
+        rich_notes_json(&plan()),
+        Json::obj(vec![("1", Json::str(RICH)), ("3", Json::str("<li>x</li>"))])
+    );
+    assert_eq!(rich_notes_json(&stripped(&plan())), Json::Obj(Vec::new()));
+}
diff --git a/projcore/src/yppx.rs b/projcore/src/yppx.rs
index 6d869ea1a..5d5c327f1 100644
--- a/projcore/src/yppx.rs
+++ b/projcore/src/yppx.rs
@@ -64,12 +64,15 @@ pub fn write_yppx(proj: &Project) -> Result<Vec<u8>, String> {
             proj.package.unreadable.join(", ")
         ));
     }
+    // The formatting part (#1532) with the tasks' rich notes (#1801), only
+    // when there is either to keep.
+    let formatting_xml = formatting::part_xml(proj);
     let mut entries = vec![
         (
             CONTENT_TYPES_PART.to_string(),
             build_content_types(
                 &proj.package,
-                !proj.formatting.is_empty(),
+                formatting_xml.is_some(),
                 !proj.table_view.is_empty(),
                 &FLAG_PARTS.map(|f| f.any(&proj.tasks)),
             )
@@ -103,12 +106,8 @@ pub fn write_yppx(proj: &Project) -> Result<Vec<u8>, String> {
             ));
         }
     }
-    // The formatting part (#1532), only when there is formatting to keep.
-    if !proj.formatting.is_empty() {
-        entries.push((
-            formatting::PART.to_string(),
-            proj.formatting.to_xml().into_bytes(),
-        ));
+    if let Some(xml) = formatting_xml {
+        entries.push((formatting::PART.to_string(), xml.into_bytes()));
     }
     for (name, bytes) in &proj.package.parts {
         if !name.ends_with('/') && seen.insert(name.to_ascii_lowercase()) {
@@ -440,6 +439,7 @@ fn read_yppx_within(bytes: &[u8], budget: u64) -> Result<Project, String> {
         let text = String::from_utf8(bytes)
             .map_err(|_| format!("{} is not valid UTF-8", formatting::PART))?;
         project.formatting = Formatting::from_xml(&text)?;
+        formatting::apply_notes(&mut project, &text)?;
     }
     if let Some(view) = table_view {
         project.table_view = view;
@@ -756,6 +756,45 @@ mod tests {
         }
     }
 
+    /// Rich task notes (#1801) ride in the formatting part: a note alone
+    /// writes it (and declares it), a save and reopen keeps the markup, and
+    /// MSPDI keeps the plain text only.
+    #[test]
+    fn rich_notes_survive_yppx_round_trip() {
+        let mut proj = sample();
+        let markup = "<p><b>Bold</b> &amp; more</p>\n<li align=\"right\">item</li>";
+        proj.tasks[0].notes = Some("Bold & more\nitem".into());
+        proj.tasks[0].rich_notes = Some(markup.into());
+        proj.tasks[1].notes = Some("plain".into());
+        assert!(proj.formatting.is_empty());
+        let bytes = write_yppx(&proj).unwrap();
+        let zip = ZipArchive::open(&bytes).unwrap();
+        let part = String::from_utf8(zip.read(crate::formatting::PART).unwrap()).unwrap();
+        assert!(part.contains("<note uid=\"1\""), "{part}");
+        let map = String::from_utf8(zip.read(CONTENT_TYPES_PART).unwrap()).unwrap();
+        assert!(map.contains("/formatting.xml"), "{map}");
+        let main = String::from_utf8(zip.read(MAIN_PART).unwrap()).unwrap();
+        assert!(main.contains("<Notes>Bold &amp; more\nitem</Notes>"));
+        assert!(!main.contains("<b>") && !main.contains("&lt;b&gt;"));
+        let back = read_yppx(&bytes).unwrap();
+        assert_eq!(back.tasks[0].rich_notes.as_deref(), Some(markup));
+        assert_eq!(back.tasks[1].rich_notes, None);
+        assert!(back.formatting.is_empty());
+        assert!(back.package.parts.is_empty(), "the part is the model's");
+        // Saved again, byte for byte.
+        assert_eq!(write_yppx(&back).unwrap(), bytes);
+    }
+
+    #[test]
+    fn plan_without_rich_notes_writes_no_formatting_part() {
+        let mut proj = sample();
+        proj.tasks[0].notes = Some("plain".into());
+        let bytes = write_yppx(&proj).unwrap();
+        let zip = ZipArchive::open(&bytes).unwrap();
+        assert!(zip.read(crate::formatting::PART).is_none());
+        assert_eq!(zip.entries().len(), 2);
+    }
+
     #[test]
     fn package_is_a_zip() {
         let bytes = write_yppx(&sample()).unwrap();
diff --git a/projcore/tests/plugins.rs b/projcore/tests/plugins.rs
index bce75e73e..28fc21191 100644
--- a/projcore/tests/plugins.rs
+++ b/projcore/tests/plugins.rs
@@ -163,6 +163,70 @@ fn a_plugin_write_and_read_carry_the_formatting() {
     let _ = std::fs::remove_dir_all(dir);
 }
 
+/// Rich task notes (#1801) cross the format plugin seam inside the
+/// formatting text: a plan whose only "formatting" is a rich note still hands
+/// the plugin a formatting text, and the markup comes back on read. MSPDI
+/// alone (a `.xml` save, or the plain read) keeps the plain text only.
+#[test]
+fn rich_notes_cross_the_plugin_seam_both_ways() {
+    let dir = fixture_plugin::plugin_dir("projcore-plugin-rich-notes");
+    let mut registry = Registry::new();
+    for format in load_plugins(std::slice::from_ref(&dir)) {
+        registry.register(format);
+    }
+    let path = Path::new("plan.fakeproj");
+    let mut project = corpus_plan();
+    assert!(project.formatting.is_empty());
+    let i = project
+        .tasks
+        .iter()
+        .position(|t| t.uid != 0 && !t.is_null)
+        .unwrap();
+    let uid = project.tasks[i].uid;
+    let markup = "<p><b>Bold</b> &amp; plain</p>\n<li align=\"center\">item</li>";
+    project.tasks[i].notes = Some("Bold & plain\nitem".into());
+    project.tasks[i].rich_notes = Some(markup.into());
+
+    let bytes = registry.write(&project, path, None).unwrap();
+    let text = String::from_utf8(bytes.clone()).unwrap();
+    assert!(text.contains("<!-- fixture-formatting: "), "{text}");
+    let back = registry.read(path, &bytes).unwrap();
+    let task = back.tasks.iter().find(|t| t.uid == uid).unwrap();
+    assert_eq!(task.rich_notes.as_deref(), Some(markup));
+    assert_eq!(task.notes.as_deref(), Some("Bold & plain\nitem"));
+    assert!(back.formatting.is_empty());
+    assert_eq!(
+        back.tasks.iter().filter(|t| t.rich_notes.is_some()).count(),
+        1
+    );
+
+    // MSPDI keeps the plain text only: the plain read of the same bytes, and
+    // a `.xml` save and reopen.
+    let plain = read_mspdi(&text).unwrap();
+    assert!(plain.tasks.iter().all(|t| t.rich_notes.is_none()));
+    let xml = Path::new("plan.xml");
+    let reopened = registry
+        .read(xml, &registry.write(&project, xml, None).unwrap())
+        .unwrap();
+    let task = reopened.tasks.iter().find(|t| t.uid == uid).unwrap();
+    assert_eq!(
+        (task.notes.as_deref(), task.rich_notes.as_deref()),
+        (Some("Bold & plain\nitem"), None)
+    );
+
+    // The plugin's file now holds other text for that task (edited outside):
+    // the stale note is dropped, the new text kept.
+    let edited = text.replace("Bold &amp; plain", "Rewritten");
+    let back = registry.read(path, edited.as_bytes()).unwrap();
+    let task = back.tasks.iter().find(|t| t.uid == uid).unwrap();
+    assert_eq!(
+        (task.notes.as_deref(), task.rich_notes.as_deref()),
+        (Some("Rewritten\nitem"), None)
+    );
+
+    let _ = std::fs::remove_dir_all(dir);
+}
+
 #[test]
 fn formatting_a_plugin_returns_that_cannot_be_read_fails_the_read() {
     let dir = fixture_plugin::plugin_dir("projcore-plugin-formatting-bad");

From 1af97bad85b2ff8a04f7e67c89351a3adc429fe5 Mon Sep 17 00:00:00 2001
From: Boris Kudryashov <boris.kudryashov@gmail.com>
Date: Mon, 26 Oct 2026 01:23:52 +0300
Subject: [PATCH 3/5] projctl: task.set rich_notes and the rich_notes reply key
 (#1801)

Markup is taken verbatim (never the one-line notes form), refused with
notes in one call, and every task reply with notes carries markup: the
stored formatting, else the plain notes' own canonical markup, so a plain
note that starts with <p> is never read as markup.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L2XCadpiTmNZGJmLxXsMvK
---
 projctl/src/lib.rs | 173 ++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 172 insertions(+), 1 deletion(-)

diff --git a/projctl/src/lib.rs b/projctl/src/lib.rs
index e6519b4e8..34f18f821 100644
--- a/projctl/src/lib.rs
+++ b/projctl/src/lib.rs
@@ -18,7 +18,7 @@
 //! | `task.list` | `{fields?}` | `{count, tasks:[{uid, id, outline_number, name, level, manual, duration, start, finish, critical, …}]}` |
 //! | `task.get` | `{uid, fields?}` | one task |
 //! | `task.fields` | — | `{count, fields:[name…]}`: the field names `fields` can read |
-//! | `task.set` | `{uid, name?, duration?, level?, manual?, start?, finish?, percent_complete?, actual_start?, actual_finish?, actual_duration?, remaining_duration?, priority?, deadline?, constraint?, task_type?, effort_driven?, notes?, milestone?, marked?, calendar?, ignore_resource_calendar?, wbs?, earned_value_method?, custom?}` | the updated task (`manual`: `true` Manually / `false` Auto Scheduled). The Task Information fields (#1550): `start` and `finish` (#1570) are set as typed in the Start and Finish cells: `YYYY-MM-DD` (the task calendar's first working time for a start, its last for a finish) or `YYYY-MM-DDTHH:MM`; an auto task gains a Start or Finish No Earlier Than constraint, a manual one is pinned (keeping its duration for a start, the duration following a finish), after `manual`, `duration`, `milestone` and the calendar are applied, and before the actuals and a given `constraint`; only these see the call's calendar, as a bare `actual_*`, `deadline` or `constraint.date` day resolves on the task's calendar before a `calendar` in the same call; both on an auto task, or either on an auto summary, are refused, and `null` is not accepted. `percent_complete` 0–100, the Update Tasks fields (#1568) `actual_start` / `actual_finish` (a date as for `deadline`, an actual start taking the day's first working time and a finish its last, or `null` to clear) and `actual_duration` / `remaining_duration` (durations: setting one adjusts % Complete, the remaining duration also the task's duration; an actual finish completes the task; a `percent_complete` given with an actual finish date, `actual_duration` or `remaining_duration` must equal the % they make or is refused, and with only `actual_start` or a cleared finish it applies after them, a started task getting that share as its actual duration; a `duration` given with `remaining_duration` must equal the actual plus the remaining), `priority` 0–1000, `deadline` a date (`YYYY-MM-DD`, the day's last working time, or `YYYY-MM-DDTHH:MM`) or `null`, `constraint` `{type, date?}` with the type `ASAP`/`ALAP`/`MSO`/`MFO`/`SNET`/`SNLT`/`FNET`/`FNLT`, `task_type` `fixed-units`/`fixed-duration`/`fixed-work`, `effort_driven`, `milestone` and `marked` (Project's Marked flag, #1667, saved in `.yppx` only) booleans, `notes` text (`\n` line breaks), `calendar` a base calendar's name or uid or `null`, `ignore_resource_calendar` a boolean, `wbs` text, `earned_value_method` `percent-complete`/`physical-percent-complete`. `custom` (#1554) is an object of Project custom field names to values as typed in the cell (`{"Text1": "Civil", "Flag3": true, "Date1": "2026-03-09", "Duration1": "3d", "Cost1": "$1,400", "Number1": null}`; `null` or `""` clears): the field needs a definition in the plan, a formula field is refused, a lookup-table field takes one of its values. Every argument is checked and all apply in one undo step, or none does |
+//! | `task.set` | `{uid, name?, duration?, level?, manual?, start?, finish?, percent_complete?, actual_start?, actual_finish?, actual_duration?, remaining_duration?, priority?, deadline?, constraint?, task_type?, effort_driven?, notes?, rich_notes?, milestone?, marked?, calendar?, ignore_resource_calendar?, wbs?, earned_value_method?, custom?}` | the updated task (`manual`: `true` Manually / `false` Auto Scheduled). The Task Information fields (#1550): `start` and `finish` (#1570) are set as typed in the Start and Finish cells: `YYYY-MM-DD` (the task calendar's first working time for a start, its last for a finish) or `YYYY-MM-DDTHH:MM`; an auto task gains a Start or Finish No Earlier Than constraint, a manual one is pinned (keeping its duration for a start, the duration following a finish), after `manual`, `duration`, `milestone` and the calendar are applied, and before the actuals and a given `constraint`; only these see the call's calendar, as a bare `actual_*`, `deadline` or `constraint.date` day resolves on the task's calendar before a `calendar` in the same call; both on an auto task, or either on an auto summary, are refused, and `null` is not accepted. `percent_complete` 0–100, the Update Tasks fields (#1568) `actual_start` / `actual_finish` (a date as for `deadline`, an actual start taking the day's first working time and a finish its last, or `null` to clear) and `actual_duration` / `remaining_duration` (durations: setting one adjusts % Complete, the remaining duration also the task's duration; an actual finish completes the task; a `percent_complete` given with an actual finish date, `actual_duration` or `remaining_duration` must equal the % they make or is refused, and with only `actual_start` or a cleared finish it applies after them, a started task getting that share as its actual duration; a `duration` given with `remaining_duration` must equal the actual plus the remaining), `priority` 0–1000, `deadline` a date (`YYYY-MM-DD`, the day's last working time, or `YYYY-MM-DDTHH:MM`) or `null`, `constraint` `{type, date?}` with the type `ASAP`/`ALAP`/`MSO`/`MFO`/`SNET`/`SNLT`/`FNET`/`FNLT`, `task_type` `fixed-units`/`fixed-duration`/`fixed-work`, `effort_driven`, `milestone` and `marked` (Project's Marked flag, #1667, saved in `.yppx` only) booleans, `notes` text (`\n` line breaks), `rich_notes` (#1801) `projcore::richtext` markup taken verbatim (real line breaks between blocks), setting the notes to its plain text and keeping the markup only when it formats something, a style-only change being a change; not with `notes` in one call; a task reply carries `rich_notes` whenever the task has notes (the stored markup, else the plain notes' canonical markup), `calendar` a base calendar's name or uid or `null`, `ignore_resource_calendar` a boolean, `wbs` text, `earned_value_method` `percent-complete`/`physical-percent-complete`. `custom` (#1554) is an object of Project custom field names to values as typed in the cell (`{"Text1": "Civil", "Flag3": true, "Date1": "2026-03-09", "Duration1": "3d", "Cost1": "$1,400", "Number1": null}`; `null` or `""` clears): the field needs a definition in the plan, a formula field is refused, a lookup-table field takes one of its values. Every argument is checked and all apply in one undo step, or none does |
 //! | `task.add` | `{after?, name?, duration?}` | the new task (without `duration`, 1 day, estimated when the plan's `NewTasksEstimated` is; inserted `after` a task that a finish-to-start link joins to the next, it is linked into that chain when the plan's `Autolink` is on, as it is by default) |
 //! | `task.del` | `{uid}` | `{deleted, removed:[uid…]}` (a summary takes its subtree) |
 //! | `link.add` | `{uid, pred, type?, lag?}` | the updated task (`lag` uses Predecessors cell spellings such as `4h`, `2ed`, `50%`; other duration spellings such as `1 month` are read as working-days lags) |
@@ -670,6 +670,15 @@ fn task_json(
     if let Some(d) = t.leveling_delay.filter(|d| *d != 0) {
         fields.push(("leveling_delay_min", Json::Num(d as f64 / 10.)));
     }
+    // The notes as markup (#1801): the stored formatting, else the plain
+    // notes' own markup, so a reader never mistakes plain text for markup.
+    if let Some(notes) = t.notes.as_deref().filter(|n| !n.is_empty()) {
+        let markup = t
+            .rich_notes
+            .clone()
+            .unwrap_or_else(|| projcore::richtext::Rich::plain(notes).to_markup());
+        fields.push(("rich_notes", Json::Str(markup)));
+    }
     if let Some(r) = ed.schedule().get(t.uid) {
         fields.push(("critical", Json::Bool(r.critical)));
         fields.push((
@@ -792,6 +801,8 @@ struct TaskInfoArgs {
     task_type: Option<TaskType>,
     effort_driven: Option<bool>,
     notes: Option<String>,
+    /// Rich notes as `projcore::richtext` markup (#1801), taken verbatim.
+    rich_notes: Option<String>,
     milestone: Option<bool>,
     /// Project's Marked flag (#1667).
     marked: Option<bool>,
@@ -839,6 +850,7 @@ impl TaskInfoArgs {
             || self.task_type.is_some()
             || self.effort_driven.is_some()
             || self.notes.is_some()
+            || self.rich_notes.is_some()
             || self.milestone.is_some()
             || self.marked.is_some()
             || self.calendar.is_some()
@@ -1041,6 +1053,9 @@ impl TaskInfoArgs {
                 }
             }),
         };
+        if args.get("notes").is_some() && args.get("rich_notes").is_some() {
+            return Err("give notes or rich_notes, not both".into());
+        }
         Ok(TaskInfoArgs {
             start,
             finish,
@@ -1055,6 +1070,7 @@ impl TaskInfoArgs {
             task_type,
             effort_driven: flag("effort_driven")?,
             notes: text("notes")?,
+            rich_notes: text("rich_notes")?,
             milestone: flag("milestone")?,
             marked: flag("marked")?,
             calendar,
@@ -1191,6 +1207,11 @@ impl TaskInfoArgs {
         if let Some(notes) = &self.notes {
             ed.set_notes(uid, &projcore::text::notes_from_line(notes))?;
         }
+        // Markup has real line breaks, so it is never read as the one-line
+        // form `notes` takes.
+        if let Some(markup) = &self.rich_notes {
+            ed.set_rich_notes(uid, markup)?;
+        }
         if let Some(on) = self.marked {
             ed.set_marked(uid, on)?;
         }
@@ -4009,6 +4030,156 @@ mod tests {
         assert!(bad.is_err());
     }
 
+    /// Rich notes (#1801): `task.set {rich_notes}` sets the plain notes and
+    /// the markup in one step, a style-only change is a step, the reply
+    /// reports the markup.
+    #[test]
+    fn task_set_rich_notes_sets_plain_and_markup() {
+        let mut a = app();
+        let uid = add(&mut a, "Design", "3d");
+        let markup = "<p><b>Check</b></p>\n<li>it</li>";
+        let depth = a.undo_depth();
+        let r = call(
+            &mut a,
+            "task.set",
+            vec![
+                ("uid", Json::Num(uid as f64)),
+                ("rich_notes", Json::Str(markup.into())),
+                ("name", Json::Str("Design 2".into())),
+            ],
+        )
+        .unwrap();
+        assert_eq!(a.undo_depth(), depth + 1, "one step with the name");
+        assert_eq!(r.get_str("rich_notes"), Some(markup));
+        let t = a.project().task(uid as i32).unwrap();
+        assert_eq!(t.notes.as_deref(), Some("Check\nit"));
+        assert_eq!(t.rich_notes.as_deref(), Some(markup));
+        // Same plain text, bold dropped: a step of its own.
+        call(
+            &mut a,
+            "task.set",
+            vec![
+                ("uid", Json::Num(uid as f64)),
+                ("rich_notes", Json::Str("<p>Check</p>\n<li>it</li>".into())),
+            ],
+        )
+        .unwrap();
+        assert_eq!(a.undo_depth(), depth + 2);
+        assert_eq!(
+            a.project().task(uid as i32).unwrap().rich_notes.as_deref(),
+            Some("<p>Check</p>\n<li>it</li>")
+        );
+    }
+
+    #[test]
+    fn task_set_rich_notes_is_verbatim() {
+        let mut a = app();
+        let uid = add(&mut a, "Design", "3d");
+        // `notes` reads `\n` (backslash, n) as a line break; markup does not.
+        call(
+            &mut a,
+            "task.set",
+            vec![
+                ("uid", Json::Num(uid as f64)),
+                ("rich_notes", Json::Str("<p><b>C:\\new</b></p>".into())),
+            ],
+        )
+        .unwrap();
+        let t = a.project().task(uid as i32).unwrap();
+        assert_eq!(t.notes.as_deref(), Some("C:\\new"));
+        assert_eq!(t.rich_notes.as_deref(), Some("<p><b>C:\\new</b></p>"));
+    }
+
+    #[test]
+    fn task_set_rich_notes_with_notes_is_refused() {
+        let mut a = app();
+        let uid = add(&mut a, "Design", "3d");
+        let before = a.project().clone();
+        let depth = a.undo_depth();
+        let err = call(
+            &mut a,
+            "task.set",
+            vec![
+                ("uid", Json::Num(uid as f64)),
+                ("notes", Json::Str("x".into())),
+                ("rich_notes", Json::Str("<li>x</li>".into())),
+            ],
+        )
+        .unwrap_err();
+        assert_eq!(err, "give notes or rich_notes, not both");
+        for bad in [Json::Null, Json::Num(1.0)] {
+            let err = call(
+                &mut a,
+                "task.set",
+                vec![("uid", Json::Num(uid as f64)), ("rich_notes", bad)],
+            )
+            .unwrap_err();
+            assert_eq!(err, "'rich_notes' must be text");
+        }
+        assert_eq!(a.project(), &before);
+        assert_eq!(a.undo_depth(), depth);
+    }
+
+    #[test]
+    fn task_get_reports_rich_notes() {
+        let mut a = app();
+        let uid = add(&mut a, "Design", "3d");
+        let get =
+            |a: &mut Editor| call(a, "task.get", vec![("uid", Json::Num(uid as f64))]).unwrap();
+        // No notes: no key.
+        assert_eq!(get(&mut a).get("rich_notes"), None);
+        // Plain notes: their own markup, escaped, so `<p>` stays text.
+        call(
+            &mut a,
+            "task.set",
+            vec![
+                ("uid", Json::Num(uid as f64)),
+                ("notes", Json::Str("<p>a\\nb".into())),
+            ],
+        )
+        .unwrap();
+        assert_eq!(
+            get(&mut a).get_str("rich_notes"),
+            Some("<p>&lt;p&gt;a</p>\n<p>b</p>")
+        );
+        // Stored markup, also in task.list.
+        a.set_rich_notes(uid as i32, "<li>x</li>").unwrap();
+        assert_eq!(get(&mut a).get_str("rich_notes"), Some("<li>x</li>"));
+        let list = call(&mut a, "task.list", vec![]).unwrap();
+        let entry = list
+            .get("tasks")
+            .and_then(Json::as_array)
+            .unwrap()
+            .iter()
+            .find(|t| t.get("uid").and_then(Json::as_f64) == Some(uid as f64))
+            .unwrap()
+            .clone();
+        assert_eq!(entry.get_str("rich_notes"), Some("<li>x</li>"));
+    }
+
+    #[test]
+    fn task_set_notes_clears_rich_notes() {
+        let mut a = app();
+        let uid = add(&mut a, "Design", "3d");
+        a.set_rich_notes(uid as i32, "<li>x</li>").unwrap();
+        let set = |a: &mut Editor, text: &str| {
+            call(
+                a,
+                "task.set",
+                vec![
+                    ("uid", Json::Num(uid as f64)),
+                    ("notes", Json::Str(text.into())),
+                ],
+            )
+            .unwrap()
+        };
+        // The same plain text keeps the formatting …
+        assert_eq!(set(&mut a, "x").get_str("rich_notes"), Some("<li>x</li>"));
+        // … new text drops it.
+        assert_eq!(set(&mut a, "y").get_str("rich_notes"), Some("<p>y</p>"));
+        assert_eq!(a.project().task(uid as i32).unwrap().rich_notes, None);
+    }
+
     /// The Task Information fields (#1550): every argument applies in the
     /// one undo step, and a refused one undoes them all.
     #[test]

From 12299de6a815b330ea7946de88705c32e691b84d Mon Sep 17 00:00:00 2001
From: Boris Kudryashov <boris.kudryashov@gmail.com>
Date: Mon, 26 Oct 2026 01:30:54 +0300
Subject: [PATCH 4/5] UI plugins read rich task notes from view.rich_notes
 (#1801)

MSPDI carries plain notes only, so without this a plugin's richtext Notes
page would prefill plain text and its OK would wipe the formatting. Both
hosts add a read-only {uid: markup} map built in projcore; the fixture's
fixture.richnote runs the downstream loop (read, extend, task.set).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L2XCadpiTmNZGJmLxXsMvK
---
 CLAUDE.md                               | 29 ++++++++++++
 projcore/src/uiplugin.rs                |  6 +++
 projcore/tests/plugin_fixture/src/ui.rs | 41 +++++++++++++++++
 suite/docxy/src/plugin_ui.rs            |  8 +++-
 suite/docxy/src/plugin_ui/tests.rs      | 26 +++++++++++
 yppxy/src/formats.rs                    |  5 ++
 yppxy/tests/plugins.rs                  | 61 +++++++++++++++++++++++++
 7 files changed, 175 insertions(+), 1 deletion(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 38943cf35..39417f929 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -853,6 +853,35 @@
   gridlines and clears them on the next press (`project-plugin-ui.uit`, not
   run on macOS).
 
+## Rich task notes (#1801)
+
+- `Task::rich_notes` is the notes' `projcore::richtext` markup beside the
+  plain `notes` every reader uses (MSPDI `<Notes>`, the grid, search, the
+  suite's built-in Notes field): `Some` only when it formats something
+  (bold, italic, a non-left alignment, a bullet), and then its plain text is
+  `notes` (`richtext::split_notes` is the one rule). `Editor::set_rich_notes`
+  sets both as one undo step (a style-only change is a step, the value held
+  none); `set_notes` with new text drops the markup, with the same text
+  keeps it, so a host rewriting unchanged notes loses nothing.
+- It travels where the formatting does: `<note uid markup/>` children of
+  `formatting.xml` after the formatting's own (`formatting::part_xml`, the
+  one writer and "is there a part" test: newlines `&#10;`, tabs `&#9;`), so
+  a `.yppx` save keeps it and a format plugin's `_ex` symbols carry it both
+  ways with no new ABI symbol. A plan without rich notes writes the part
+  byte-identically (or none). On read (`formatting::apply_notes`) a note
+  lands only on a non-blank task whose plain notes it still describes; an
+  older build's `Formatting::from_xml` ignores `<note>`.
+- projctl `task.set {rich_notes}` takes the markup verbatim (never the
+  one-line `notes` form), not with `notes` in one call; every task reply
+  with notes carries `rich_notes` (the stored markup, else the plain notes'
+  own markup, so plain text is never mistaken for markup). UI plugins read
+  it from the read-only `view.rich_notes` (`{uid: markup}`, tasks with
+  formatting only; `formatting::rich_notes_json`) in the suite's
+  `view_json` and yppxy's `run_command`. The fixture's `fixture.richnote`
+  (a command with no control) is the loop, `yppxy/tests/plugins.rs`.
+- Out of scope: resource and assignment notes, rich editing in the
+  built-in Notes field, RTF (the plugin converts).
+
 ## Project leveling as a plan edit (#1594)
 
 - `projcore::schedule::level_with(proj, &LevelScope {movable, order,
diff --git a/projcore/src/uiplugin.rs b/projcore/src/uiplugin.rs
index 7f27ce298..02912ec7f 100644
--- a/projcore/src/uiplugin.rs
+++ b/projcore/src/uiplugin.rs
@@ -1155,6 +1155,11 @@ impl Selection {
 pub struct StateCtx {
     pub plan: String,
     pub selection: Selection,
+    /// The view's switches and the plan's formatting, and (read-only, #1801)
+    /// `rich_notes`: `{"<uid>": markup}` for every task whose notes carry
+    /// [`crate::richtext`] formatting, which the plan's MSPDI cannot; a task
+    /// not listed has its plain `<Notes>` only. Its writer is the
+    /// `task.set {rich_notes}` op; a `view` reply never sets it.
     pub view: Json,
     /// `(dialog id, task uid)` when the host is about to open a dialog and
     /// wants its values prefilled, or asks again for an open one (#1602).
@@ -1391,6 +1396,7 @@ pub struct Command {
     pub id: String,
     pub plan: String,
     pub selection: Selection,
+    /// As [`StateCtx::view`], `rich_notes` included.
     pub view: Json,
     pub values: Option<Json>,
     pub button: Option<String>,
diff --git a/projcore/tests/plugin_fixture/src/ui.rs b/projcore/tests/plugin_fixture/src/ui.rs
index 02435f6a8..b4b54db14 100644
--- a/projcore/tests/plugin_fixture/src/ui.rs
+++ b/projcore/tests/plugin_fixture/src/ui.rs
@@ -58,6 +58,10 @@
 //!   date format `1/28`; a second press, seeing a bar height in the view,
 //!   clears it with null).
 //!   and `fixture.font` (#1669: the Fixture group's launcher; a status only).
+//!   and `fixture.richnote` (#1801, no control: a host runs it by id): the
+//!   first selected task's notes back through `task.set rich_notes`, bold
+//!   from the plan's plain notes, or with an italic bullet added to the
+//!   markup `view.rich_notes` holds for it.
 //!   and `fixture.mark` (#1667, a row-menu item after Rename: one
 //!   `task.set` marking the first selected task and making it 3 days long,
 //!   one `proj.highlight` of its name, and `view.text_styles` styling Marked
@@ -526,6 +530,43 @@ pub unsafe extern "C" fn yppx_ui_command(input: *const u8, len: usize, out: *mut
             }
             None => r#"{"ops":[],"status":"Fixture: select a task first"}"#.to_string(),
         },
+        // Rich task notes (#1801), the downstream's loop: read the first
+        // selected task's markup from `view.rich_notes`, else its plain
+        // notes from the plan (MSPDI, already escaped as markup needs),
+        // and write it back through `task.set rich_notes`: plain notes come
+        // back bold, line by line; stored markup gains an italic bullet.
+        "fixture.richnote" => match first_uid(&req) {
+            Some(uid) => {
+                let stored = req
+                    .get("view")
+                    .and_then(|v| v.get("rich_notes"))
+                    .and_then(|n| n.get(&uid.to_string()))
+                    .and_then(Json::str);
+                let markup = match stored {
+                    Some(m) => format!("{m}\n<li><i>again</i></li>"),
+                    None => {
+                        let uids = task_field(&req, "UID");
+                        let plain = uids
+                            .iter()
+                            .position(|u| u.trim() == uid.to_string())
+                            .and_then(|at| task_field(&req, "Notes").get(at).cloned())
+                            .filter(|n| !n.is_empty())
+                            .unwrap_or_else(|| "note".to_string());
+                        plain
+                            .split('\n')
+                            .map(|line| format!("<p><b>{line}</b></p>"))
+                            .collect::<Vec<_>>()
+                            .join("\n")
+                    }
+                };
+                format!(
+                    r#"{{"ops":[{{"verb":"task.set","args":{{"uid":{uid},"rich_notes":{}}}}}],"status":{}}}"#,
+                    quote(&markup),
+                    quote(&format!("Fixture: rich note on task {uid}"))
+                )
+            }
+            None => r#"{"ops":[],"status":"Fixture: select a task first"}"#.to_string(),
+        },
         // The Fixture group's dialog launcher (#1669).
         "fixture.font" => r#"{"ops":[],"status":"Fixture: font launcher"}"#.to_string(),
         "fixture.hello" => match (req.get("button").and_then(Json::str), req.get("values")) {
diff --git a/suite/docxy/src/plugin_ui.rs b/suite/docxy/src/plugin_ui.rs
index 85a81b648..d2e3282e0 100644
--- a/suite/docxy/src/plugin_ui.rs
+++ b/suite/docxy/src/plugin_ui.rs
@@ -367,7 +367,8 @@ pub(crate) struct PluginCache {
 /// gridline as drawn by Project's name (#1575), the plugins' switches, every
 /// text style category, and the selected cells' styles, #1572) in the shape
 /// `Formatting::apply_view` reads; `layout` is the Layout dialog's seven
-/// keys (#1695).
+/// keys (#1695); `rich_notes` the tasks' rich notes by uid (#1801), which
+/// `apply_view` ignores.
 fn view_json(v: &ProjectView) -> Json {
     let formatting = &v.ed.project().formatting;
     let text = |s: &Option<String>| s.clone().map_or(Json::Null, Json::Str);
@@ -405,6 +406,11 @@ fn view_json(v: &ProjectView) -> Json {
         ("layout", formatting.layout_json()),
         ("text_styles", Json::Obj(text_styles)),
         ("cells", Json::Arr(cells)),
+        // Read-only: the tasks' rich notes (#1801), which MSPDI cannot carry.
+        (
+            "rich_notes",
+            projcore::formatting::rich_notes_json(v.ed.project()),
+        ),
     ])
 }
 
diff --git a/suite/docxy/src/plugin_ui/tests.rs b/suite/docxy/src/plugin_ui/tests.rs
index 6b244b388..b48607f5f 100644
--- a/suite/docxy/src/plugin_ui/tests.rs
+++ b/suite/docxy/src/plugin_ui/tests.rs
@@ -104,6 +104,32 @@ fn the_view_json_carries_the_text_styles_and_the_selected_cells_styles() {
     assert!(view_json(v).list("cells").is_empty());
 }
 
+/// Rich task notes (#1801): MSPDI carries the plain notes only, so the view
+/// lists the tasks whose notes are formatted, read-only.
+#[test]
+fn the_view_json_carries_the_rich_notes() {
+    let mut tab = tab();
+    let Surface::Project(v) = &mut tab.surface else {
+        unreachable!()
+    };
+    let uid = v.ed.project().tasks[0].uid;
+    let other = v.ed.project().tasks[1].uid;
+    assert_eq!(view_json(v).get("rich_notes"), Some(&Json::Obj(Vec::new())));
+    v.ed.set_rich_notes(uid, "<p><b>Bold</b></p>").unwrap();
+    v.ed.set_notes(other, "plain").unwrap();
+    let view = view_json(v);
+    let notes = view.get("rich_notes").unwrap();
+    assert_eq!(notes.get_str(&uid.to_string()), Some("<p><b>Bold</b></p>"));
+    assert_eq!(
+        notes.get(&other.to_string()),
+        None,
+        "plain notes are not listed"
+    );
+    // A reply echoing the view writes nothing.
+    let mut f = v.ed.project().formatting.clone();
+    assert!(!f.apply_view(&view).unwrap());
+}
+
 #[test]
 fn the_view_json_carries_strikethrough_and_pattern() {
     let mut tab = tab();
diff --git a/yppxy/src/formats.rs b/yppxy/src/formats.rs
index b1dd8414f..bc6bb6a1f 100644
--- a/yppxy/src/formats.rs
+++ b/yppxy/src/formats.rs
@@ -269,6 +269,11 @@ impl Formats {
                 ("bars", ed.project().formatting.bars_json()),
                 ("task_bars", ed.project().formatting.task_bars_json()),
                 ("layout", ed.project().formatting.layout_json()),
+                // Read-only: the tasks' rich notes (#1801).
+                (
+                    "rich_notes",
+                    projcore::formatting::rich_notes_json(ed.project()),
+                ),
             ]),
             values,
             button: None,
diff --git a/yppxy/tests/plugins.rs b/yppxy/tests/plugins.rs
index e68a237c2..28d5c093a 100644
--- a/yppxy/tests/plugins.rs
+++ b/yppxy/tests/plugins.rs
@@ -253,3 +253,64 @@ fn a_ui_plugin_command_runs_headless() {
     );
     let _ = std::fs::remove_dir_all(dir);
 }
+
+/// Rich task notes (#1801), the downstream plugin's loop: a command reads a
+/// task's markup from the request's `view.rich_notes` (MSPDI has the plain
+/// text only) and writes it back through `task.set rich_notes`; a `.yppx`
+/// save keeps it, and the next press reads the stored markup back.
+#[test]
+fn a_ui_plugin_reads_and_writes_rich_notes() {
+    let plugins = fixture_plugin::plugin_dir("yppxy-plugin-rich-notes");
+    let dir = work_dir("yppxy-rich-notes-work");
+    let input = dir.join("plan.xml");
+    std::fs::copy(
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../corpus/mspdi/10-summary.xml"),
+        &input,
+    )
+    .unwrap();
+    let press = |from: &Path, to: &Path| {
+        let output = yppxy(
+            Some(&plugins),
+            &[
+                from,
+                Path::new("--command"),
+                Path::new("fixture.richnote"),
+                Path::new("--save"),
+                to,
+            ],
+        );
+        ok(&output);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        assert!(
+            stdout.starts_with("Fixture: rich note on task "),
+            "{stdout}"
+        );
+        let plan = projcore::yppx::read_yppx(&std::fs::read(to).unwrap()).unwrap();
+        let noted: Vec<_> = plan
+            .tasks
+            .iter()
+            .filter(|t| t.rich_notes.is_some())
+            .map(|t| (t.uid, t.notes.clone(), t.rich_notes.clone()))
+            .collect();
+        assert_eq!(noted.len(), 1, "{noted:?}");
+        noted.into_iter().next().unwrap()
+    };
+    // No rich notes yet: the plugin bolds the plain notes it reads from MSPDI.
+    let once = dir.join("once.yppx");
+    let (uid, notes, rich) = press(&input, &once);
+    let plain = notes.clone().unwrap();
+    let bold = plain
+        .split('\n')
+        .map(|l| format!("<p><b>{l}</b></p>"))
+        .collect::<Vec<_>>()
+        .join("\n");
+    assert_eq!(rich.as_deref(), Some(bold.as_str()));
+    // Reopened, the view hands the stored markup back, which the plugin
+    // extends: the bold survives, so it read the markup, not the plain text.
+    let twice = dir.join("twice.yppx");
+    let (uid2, notes, rich) = press(&once, &twice);
+    assert_eq!(uid2, uid);
+    assert_eq!(notes, Some(format!("{plain}\nagain")));
+    assert_eq!(rich, Some(format!("{bold}\n<li><i>again</i></li>")));
+    let _ = std::fs::remove_dir_all(dir);
+}

From c1839114106b5633b3f74d621924da3d485d51f2 Mon Sep 17 00:00:00 2001
From: Boris Kudryashov <boris.kudryashov@gmail.com>
Date: Mon, 26 Oct 2026 02:28:48 +0300
Subject: [PATCH 5/5] Docs: the _ex formatting text carries rich notes; yppxy
 task.set lists rich_notes (#1801)

Review r1: the plugin ABI, PROJECT.md and CLAUDE.md still said the
formatting text is NULL whenever the plan has no formatting and is only
formatting, so a plugin author could drop every rich note. yppxy's control
verb table now lists task.set rich_notes and the reply key.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L2XCadpiTmNZGJmLxXsMvK
---
 CLAUDE.md                  |  4 +++-
 PROJECT.md                 |  7 +++++--
 projcore/src/plugin_abi.rs | 10 ++++++++--
 yppxy/src/control.rs       |  2 +-
 4 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 39417f929..951772be2 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -472,7 +472,9 @@
 - A library may also export `yppx_plugin_read_ex` / `yppx_plugin_write_ex`
   (#1702; independent, optional, ABI still 1) to carry the plan's
   `Formatting`, which MSPDI does not: write_ex gets the `formatting.xml` text
-  beside the MSPDI (NULL/0 when the plan has none) and is called instead of
+  beside the MSPDI (NULL/0 when the plan has neither formatting nor rich
+  notes; its `<note>` children are the rich notes, #1801, which read_ex must
+  return for them to survive) and is called instead of
   `yppx_plugin_write`; read_ex returns it in a second buffer (empty leaves the
   default; non-UTF-8 or unparsable fails the read with the plugin's name).
   `.yppx` keeps it in `formatting.xml` as before. Hosts need nothing: they pass
diff --git a/PROJECT.md b/PROJECT.md
index f9e2008f0..adef71869 100644
--- a/PROJECT.md
+++ b/PROJECT.md
@@ -436,8 +436,11 @@ refusal is what it was before plugins existed.
   over what the model does not hold. Two more symbols are optional and
   independent (#1702; the ABI stays 1): `yppx_plugin_read_ex` also returns the
   plan's `formatting.xml` in a second buffer, and `yppx_plugin_write_ex` also
-  takes it (NULL and 0 when the plan has none); each is called instead of its
-  plain twin when present, since MSPDI holds no formatting.
+  takes it (NULL and 0 when the plan has neither formatting nor rich task
+  notes); each is called instead of its plain twin when present, since MSPDI
+  holds no formatting. The text also carries the tasks' rich notes as
+  `<note uid markup/>` children (#1801), which read_ex must return (with the
+  MSPDI `<Notes>` equal to their plain text) for them to survive.
 - **`projcore::formats::plugin`**, behind the cargo feature `plugins` (it
   adds `libloading`; hosts enable it, so the default build and the wasm
   builds stay dependency-free), loads the libraries, checks the ABI version
diff --git a/projcore/src/plugin_abi.rs b/projcore/src/plugin_abi.rs
index 8c7d50416..926872fc9 100644
--- a/projcore/src/plugin_abi.rs
+++ b/projcore/src/plugin_abi.rs
@@ -96,10 +96,16 @@
 //! ABI version stays 1. When `yppx_plugin_write_ex` exists the host calls it
 //! instead of `yppx_plugin_write`, with the `formatting.xml` text (UTF-8, the
 //! part a `.yppx` keeps) in `formatting_xml`, or NULL with `formatting_len` 0
-//! when the plan has no formatting; the rest is as for `yppx_plugin_write`.
+//! when the plan has neither formatting nor rich task notes; the rest is as
+//! for `yppx_plugin_write`. The text may hold `<note uid markup/>` children,
+//! the tasks' rich notes (#1801, shape in `formatting::notes`), so a plan with
+//! only rich notes still passes it.
 //! When `yppx_plugin_read_ex` exists the host calls it instead of
 //! `yppx_plugin_read`; a non-empty `formatting_out` (UTF-8 `formatting.xml`)
-//! becomes the plan's formatting, and an empty one leaves it default. A
+//! becomes the plan's formatting, and an empty one leaves it default. Its
+//! `<note>`s give the tasks their rich notes, each only where the MSPDI
+//! `<Notes>` is the note's plain text, so a plugin that keeps the formatting
+//! in native fields must return the `<note>`s too or the notes lose it. A
 //! `formatting_out` that is not UTF-8 or does not parse fails the read. Both
 //! buffers are freed whatever the return code. Without the symbols nothing
 //! changes: the formatting is not passed and a read returns none.
diff --git a/yppxy/src/control.rs b/yppxy/src/control.rs
index f0676d5eb..a96ea7e66 100644
--- a/yppxy/src/control.rs
+++ b/yppxy/src/control.rs
@@ -19,7 +19,7 @@
 //! | `task.list` | `{fields?}` | `{count, tasks:[{uid, id, outline_number, name, level, manual, duration, start, finish, critical, …}]}` |
 //! | `task.get` | `{uid, fields?}` | one task |
 //! | `task.fields` | — | `{count, fields:[name…]}`: the field names `fields` can read |
-//! | `task.set` | `{uid, name?, duration?, level?, manual?, fields?, the Task Information fields of #1550: percent_complete?, actual_start?, actual_finish?, actual_duration?, remaining_duration?, priority?, deadline?, constraint?, task_type?, effort_driven?, notes?, milestone?, marked? (#1667), calendar?, ignore_resource_calendar?, wbs?, earned_value_method?, and custom? (#1554: `{"Text1": "Civil", ...}`)}` | the updated task (`manual`: `true` Manually / `false` Auto Scheduled); see `projctl` for each field's form |
+//! | `task.set` | `{uid, name?, duration?, level?, manual?, fields?, the Task Information fields of #1550: percent_complete?, actual_start?, actual_finish?, actual_duration?, remaining_duration?, priority?, deadline?, constraint?, task_type?, effort_driven?, notes?, rich_notes? (#1801: markup, verbatim, not with `notes`; a reply with notes carries `rich_notes`), milestone?, marked? (#1667), calendar?, ignore_resource_calendar?, wbs?, earned_value_method?, and custom? (#1554: `{"Text1": "Civil", ...}`)}` | the updated task (`manual`: `true` Manually / `false` Auto Scheduled); see `projctl` for each field's form |
 //! | `task.add` | `{after?, name?, duration?, fields?}` | the new task (without `duration`, 1 day, estimated unless the plan's `NewTasksEstimated` is off; inserted `after` a task that a finish-to-start link joins to the next, it is linked into that chain, A->B becoming A->N->B, while the plan's `Autolink` is on, the default) |
 //! | `task.del` | `{uid}` | `{deleted, removed:[uid…]}` (a summary takes its subtree) |
 //! | `link.add` | `{uid, pred, type?, lag?, fields?}` | the updated task |