Merge plain-entries: plain journal entries + crisis-scan policy

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: sparkly-quasar

ROADMAP.md

@@ -58,11 +58,12 @@ installer).
   wired to the dose-reference interaction data; DoseWiki's dangerous/unsafe/caution
   tiers map onto our danger/caution/note severities (with the reason text), and
   inline dose-range + interaction warnings appear while logging a dose.
-- **Distribution** — cross-platform signed installers (macOS universal `.dmg` +
-  Linux `.AppImage`/`.deb`/`.rpm`) via `tauri-action` CI on `v*` tags, plus
-  **in-app auto-update** (Tauri updater; "Install & restart" banner). macOS is
-  currently **unsigned** (right-click → Open on first launch) pending an Apple
-  Developer ID.
+- **Distribution** — cross-platform installers (macOS universal `.dmg` +
+  Linux `.AppImage`/`.deb`/`.rpm` + **Windows NSIS `.exe`/`.msi` from v0.5.0**)
+  via `tauri-action` CI on `v*` tags, plus **in-app auto-update** (Tauri updater;
+  "Install & restart" banner). macOS is currently **unsigned** (right-click →
+  Open on first launch) pending an Apple Developer ID; Windows is unsigned too
+  (SmartScreen "More info → Run anyway").
 
 ---
 
@@ -382,7 +383,7 @@ emotional presence.
 **v0.4.0 and v0.4.1 are shipped and public** — the knowledge corpus, contribution
 drafts, the phone portal (Phase 3a), the combo-checker fix, and the phone Companion fix.
 
-### Plain journal entries (not a drug session) — proposed
+### Plain journal entries (not a drug session) — ✅ shipped in v0.5.0
 
 Today an entry **has to be a session**. If you just want to write about your day, the
 app has nowhere to put it, which quietly narrows a journal into a drug log. It should
@@ -393,10 +394,15 @@ be possible to write a plain text entry, in the same journal, alongside the sess
   *yet* looks exactly like a note, and it would flip type under you mid-session. Add a
   `kind` column (`'session' | 'note'`, defaulting to `'session'` so every existing row
   keeps its meaning) and branch on it.
-- **The crisis scan still runs.** A plain entry is *more* likely to be where someone
-  writes that they're not okay, not less. `crisis.rs` must fire on these exactly as it
-  does on session notes. The interaction checker is simply irrelevant here — that's
-  fine, and different from being switched off.
+- **The crisis scan does NOT run on journal prose — owner's decision (2026-07-14).**
+  The journal is private; the app must not read over the user's shoulder. `crisis.rs`
+  fires in exactly two places: (1) what the user *says to* the Companion in an active
+  chat (self-harm / harm-to-others intent), and (2) the deterministic combo checker
+  when a dangerous interaction is flagged. Journal entries — session notes, timeline
+  notes, and plain entries — are saved as written and never scanned. (The phone's
+  timeline-note scan was removed for the same reason.) Don't relitigate this by
+  "adding safety"; the guardrails live where the user is talking to something, not
+  where they're talking to themselves.
 - **The UI should get quieter, not just different.** A plain entry has no doses, no
   timeline, no combo warnings, no elapsed-time header. It's a title, a body, a date.
   Resist re-using the session layout with the drug parts hidden.

src-tauri/src/commands.rs

@@ -273,6 +273,7 @@ pub fn import_experience(db: State<'_, Db>, parsed: ollama::ParsedExperience) ->
     let exp = db::create_experience(
         &conn,
         &ExperienceInput {
+            kind: "session".into(),
             title: if parsed.title.is_empty() { "Imported experience".into() } else { parsed.title.clone() },
             intention: parsed.intention.clone(),
             setting: parsed.setting.clone(),

src-tauri/src/db.rs

@@ -30,6 +30,16 @@ pub fn open(path: &Path, key: Option<&str>) -> rusqlite::Result<Connection> {
     conn.pragma_update(None, "journal_mode", "WAL")?;
     conn.pragma_update(None, "foreign_keys", "ON")?;
     conn.execute_batch(SCHEMA)?;
+    // Migration: `kind` postdates v0.5 journals. CREATE TABLE IF NOT EXISTS won't
+    // touch an existing table, so add the column when it's missing.
+    let has_kind: i64 = conn.query_row(
+        "SELECT COUNT(*) FROM pragma_table_info('experiences') WHERE name = 'kind'",
+        [],
+        |r| r.get(0),
+    )?;
+    if has_kind == 0 {
+        conn.execute_batch("ALTER TABLE experiences ADD COLUMN kind TEXT NOT NULL DEFAULT 'session'")?;
+    }
     Ok(conn)
 }
 
@@ -107,6 +117,10 @@ CREATE TABLE IF NOT EXISTS substances (
 
 CREATE TABLE IF NOT EXISTS experiences (
     id          INTEGER PRIMARY KEY,
+    -- 'session' (a drug session: doses, timeline, the works) or 'note' (a plain
+    -- journal entry: title, body, date — nothing else). Explicit, never inferred:
+    -- a session with no doses logged *yet* is still a session.
+    kind        TEXT NOT NULL DEFAULT 'session',
     title       TEXT NOT NULL DEFAULT '',
     intention   TEXT NOT NULL DEFAULT '',
     setting     TEXT NOT NULL DEFAULT '',
@@ -194,6 +208,8 @@ pub struct TimelineEvent {
 #[derive(Debug, Clone, Serialize)]
 pub struct Experience {
     pub id: i64,
+    /// `'session'` or `'note'`. Set at creation and never changed by edits.
+    pub kind: String,
     pub title: String,
     pub intention: String,
     pub setting: String,
@@ -240,6 +256,9 @@ pub struct SubstanceInput {
 
 #[derive(Debug, Deserialize)]
 pub struct ExperienceInput {
+    /// `'session'` (default) or `'note'` — anything else is treated as `'session'`.
+    #[serde(default = "default_kind")]
+    pub kind: String,
     #[serde(default)]
     pub title: String,
     #[serde(default)]
@@ -249,6 +268,10 @@ pub struct ExperienceInput {
     pub started_at: String,
 }
 
+fn default_kind() -> String {
+    "session".into()
+}
+
 #[derive(Debug, Deserialize)]
 pub struct DoseInput {
     pub experience_id: i64,
@@ -342,6 +365,7 @@ fn classes_for(conn: &Connection, name: &str) -> Vec<String> {
 fn row_to_experience(r: &rusqlite::Row) -> rusqlite::Result<Experience> {
     Ok(Experience {
         id: r.get("id")?,
+        kind: r.get("kind")?,
         title: r.get("title")?,
         intention: r.get("intention")?,
         setting: r.get("setting")?,
@@ -354,14 +378,33 @@ fn row_to_experience(r: &rusqlite::Row) -> rusqlite::Result<Experience> {
 }
 
 pub fn create_experience(conn: &Connection, input: &ExperienceInput) -> rusqlite::Result<Experience> {
+    // Normalize, don't validate-and-reject: unknown kinds mean an older client,
+    // and an older client means a session (that was the only kind there was).
+    let kind = if input.kind == "note" { "note" } else { "session" };
     conn.execute(
-        "INSERT INTO experiences (title, intention, setting, started_at) VALUES (?1, ?2, ?3, ?4)",
-        params![input.title, input.intention, input.setting, input.started_at],
+        "INSERT INTO experiences (kind, title, intention, setting, started_at) VALUES (?1, ?2, ?3, ?4, ?5)",
+        params![kind, input.title, input.intention, input.setting, input.started_at],
     )?;
     let id = conn.last_insert_rowid();
     get_experience_row(conn, id)
 }
 
+/// Refuse a session-only operation against a plain note. Notes have no doses, no
+/// timeline, and no "end": that invariant is enforced here, not hoped for in the UI.
+fn require_session(conn: &Connection, experience_id: i64, what: &str) -> rusqlite::Result<()> {
+    let kind: String =
+        conn.query_row("SELECT kind FROM experiences WHERE id = ?1", [experience_id], |r| r.get(0))?;
+    if kind == "note" {
+        // SqliteFailure with a message Displays as just the message, which is what
+        // `Db::with`'s to_string() hands the UI.
+        return Err(rusqlite::Error::SqliteFailure(
+            rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_CONSTRAINT),
+            Some(format!("This entry is a plain note, not a session — it can't have {what}.")),
+        ));
+    }
+    Ok(())
+}
+
 fn get_experience_row(conn: &Connection, id: i64) -> rusqlite::Result<Experience> {
     conn.query_row("SELECT * FROM experiences WHERE id = ?1", [id], row_to_experience)
 }
@@ -422,6 +465,7 @@ pub fn get_experience(conn: &Connection, id: i64) -> rusqlite::Result<Experience
 }
 
 pub fn end_experience(conn: &Connection, id: i64, ended_at: &str, rating: Option<i64>, notes: &str) -> rusqlite::Result<Experience> {
+    require_session(conn, id, "an end time or rating")?;
     conn.execute(
         "UPDATE experiences SET ended_at = ?2, rating = ?3, notes = ?4 WHERE id = ?1",
         params![id, ended_at, rating, notes],
@@ -434,6 +478,7 @@ pub fn end_experience(conn: &Connection, id: i64, ended_at: &str, rating: Option
 /// Insert a dose and return it together with any interaction warnings against the
 /// other substances already logged in the same experience.
 pub fn log_dose(conn: &Connection, input: &DoseInput) -> rusqlite::Result<(Dose, Vec<crate::interactions::Warning>)> {
+    require_session(conn, input.experience_id, "doses")?;
     let substance_id: Option<i64> = conn
         .query_row(
             "SELECT id FROM substances WHERE name = ?1 COLLATE NOCASE",
@@ -490,6 +535,7 @@ pub fn combo_warnings(conn: &Connection, names: &[String]) -> Vec<crate::interac
 }
 
 pub fn add_timeline_event(conn: &Connection, input: &TimelineInput) -> rusqlite::Result<TimelineEvent> {
+    require_session(conn, input.experience_id, "timeline events")?;
     conn.execute(
         "INSERT INTO timeline_events (experience_id, at, note, mood, intensity)
          VALUES (?1, ?2, ?3, ?4, ?5)",
@@ -781,6 +827,7 @@ mod tests {
         }).unwrap();
 
         let exp = create_experience(&c, &ExperienceInput {
+            kind: "session".into(),
             title: "test".into(), intention: String::new(), setting: String::new(),
             started_at: "2026-01-01T20:00:00Z".into(),
         }).unwrap();
@@ -813,6 +860,77 @@ mod tests {
         assert_eq!(detail.doses.len(), 2);
     }
 
+    #[test]
+    fn plain_notes_are_explicit_and_session_only_ops_refuse_them() {
+        let c = mem();
+
+        // Kind is normalized at creation: unknown values mean an older client.
+        let weird = create_experience(&c, &ExperienceInput {
+            kind: "diary".into(), title: "old client".into(),
+            intention: String::new(), setting: String::new(),
+            started_at: "2026-07-01T09:00:00Z".into(),
+        }).unwrap();
+        assert_eq!(weird.kind, "session");
+
+        let note = create_experience(&c, &ExperienceInput {
+            kind: "note".into(), title: "just a day".into(),
+            intention: String::new(), setting: String::new(),
+            started_at: "2026-07-02T09:00:00Z".into(),
+        }).unwrap();
+        assert_eq!(note.kind, "note");
+
+        // A note is not a session: no doses, no timeline, no "end".
+        let dose = log_dose(&c, &DoseInput {
+            experience_id: note.id, substance_name: "MDMA".into(), amount: Some(100.0),
+            unit: "mg".into(), route: "oral".into(), taken_at: "2026-07-02T10:00:00Z".into(),
+            note: String::new(),
+        });
+        assert!(dose.is_err());
+        let ev = add_timeline_event(&c, &TimelineInput {
+            experience_id: note.id, at: "2026-07-02T10:00:00Z".into(),
+            note: "hm".into(), mood: String::new(), intensity: None,
+        });
+        assert!(ev.is_err());
+        assert!(end_experience(&c, note.id, "2026-07-02T11:00:00Z", Some(5), "").is_err());
+
+        // Editing the body doesn't flip the kind.
+        let edited = update_experience(&c, note.id, &ExperienceUpdate {
+            title: "just a day".into(), intention: String::new(), setting: String::new(),
+            notes: "wrote some words".into(), rating: None,
+            started_at: "2026-07-02T09:00:00Z".into(), ended_at: None,
+        }).unwrap();
+        assert_eq!(edited.kind, "note");
+    }
+
+    #[test]
+    fn kind_column_is_added_to_pre_v05_journals() {
+        let dir = std::env::temp_dir().join(format!("fn-migrate-test-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("journal.db");
+
+        // A journal created before `kind` existed: same table minus the column.
+        {
+            let c = Connection::open(&path).unwrap();
+            c.execute_batch(
+                "CREATE TABLE experiences (
+                    id INTEGER PRIMARY KEY, title TEXT NOT NULL DEFAULT '',
+                    intention TEXT NOT NULL DEFAULT '', setting TEXT NOT NULL DEFAULT '',
+                    notes TEXT NOT NULL DEFAULT '', rating INTEGER,
+                    started_at TEXT NOT NULL, ended_at TEXT,
+                    created_at TEXT NOT NULL DEFAULT (datetime('now')));
+                 INSERT INTO experiences (title, started_at) VALUES ('old', '2026-01-01T00:00:00Z');",
+            ).unwrap();
+        }
+
+        // Reopening through the front door migrates it.
+        let c = open(&path, None).unwrap();
+        let exp = get_experience_row(&c, 1).unwrap();
+        assert_eq!(exp.kind, "session", "existing rows keep their meaning");
+        drop(c);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     // Uses the bundled DoseWiki snapshot (no network). MDMA + Tramadol is a
     // graded "dangerous" interaction on both sides, so it must surface at log time.
     #[test]
@@ -822,6 +940,7 @@ mod tests {
         pw_replace_all(&mut c, &all).unwrap();
 
         let exp = create_experience(&c, &ExperienceInput {
+            kind: "session".into(),
             title: "t".into(), intention: String::new(), setting: String::new(),
             started_at: "2026-01-01T00:00:00Z".into(),
         }).unwrap();