joplin 1.2.1 → 1.3.0

data/bin/jp

@@ -10,6 +10,7 @@ require 'uri'
 require 'io/console'
 require 'stringio'
 require 'shellwords'
+require 'open3'
 require 'json'
 
 # Polyfill for CGI.parse which was removed in Ruby 4.x
@@ -67,14 +68,18 @@ class TestRunner
     db = SQLite3::Database.new(@db_path)
     db.execute_batch <<-SQL
       CREATE TABLE folders (id TEXT PRIMARY KEY, title TEXT, parent_id TEXT NOT NULL DEFAULT "", deleted_time INT NOT NULL DEFAULT 0);
-      CREATE TABLE notes (id TEXT PRIMARY KEY, parent_id TEXT NOT NULL DEFAULT "", title TEXT, body TEXT, created_time INT, updated_time INT, latitude REAL, longitude REAL, source_url TEXT, deleted_time INT NOT NULL DEFAULT 0);
+      CREATE TABLE notes (id TEXT PRIMARY KEY, parent_id TEXT NOT NULL DEFAULT "", title TEXT, body TEXT, created_time INT, updated_time INT, user_created_time INT, user_updated_time INT, latitude REAL, longitude REAL, altitude REAL, author TEXT, source_url TEXT, is_todo INT NOT NULL DEFAULT 0, todo_due INT NOT NULL DEFAULT 0, todo_completed INT NOT NULL DEFAULT 0, deleted_time INT NOT NULL DEFAULT 0);
       CREATE TABLE tags (id TEXT PRIMARY KEY, title TEXT);
       CREATE TABLE note_tags (id TEXT PRIMARY KEY, note_id TEXT, tag_id TEXT);
+      CREATE TABLE resources (id TEXT PRIMARY KEY, title TEXT, mime TEXT, filename TEXT, file_extension TEXT);
+      CREATE TABLE alarms (id INTEGER PRIMARY KEY AUTOINCREMENT, note_id TEXT NOT NULL, trigger_time INT NOT NULL);
     SQL
     db.close
 
     @old_joplin_data_dir = ENV['JOPLIN_DATA_DIR']
     ENV['JOPLIN_DATA_DIR'] = @dir
+    @old_core_location_cli = ENV['CORE_LOCATION_CLI']
+    ENV['CORE_LOCATION_CLI'] = ""
 
     @old_stdout = $stdout
     @old_stderr = $stderr
@@ -151,6 +156,7 @@ class TestRunner
     $stdout = @old_stdout
     $stderr = @old_stderr
     ENV['JOPLIN_DATA_DIR'] = @old_joplin_data_dir
+    ENV['CORE_LOCATION_CLI'] = @old_core_location_cli
     db.close rescue nil
     FileUtils.remove_entry(@dir) rescue nil
   end
@@ -472,6 +478,106 @@ module TestSuite
         assert_includes out, Time.at(backup_epoch).strftime('%Y-%m-%d %H:%M:%S')
         assert_includes out, "(1 hours ago)"
       end
+
+      it "shows when CoreLocationCLI is not installed on macOS" do
+        runner.cli.send(:show_core_location_cli_info, macos: true)
+        runner.flush_output
+
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "WARNING: CoreLocationCLI is not installed. New notes will not include GPS coordinates."
+      end
+
+      it "does not show CoreLocationCLI when it is installed" do
+        cli = File.join(runner.dir, "CoreLocationCLI")
+        File.write(cli, "#!/bin/sh\nexit 0\n")
+        FileUtils.chmod(0o755, cli)
+        ENV['CORE_LOCATION_CLI'] = cli
+
+        runner.cli.send(:show_core_location_cli_info, macos: true)
+        runner.flush_output
+
+        assert_empty runner.last_stdout
+      end
+    end
+
+    describe "active alarm warnings" do
+      it "shows a triggered reminder before command output" do
+        trigger_time = (Time.now.to_i - 60) * 1000
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'Work')")
+        runner.db.execute("INSERT INTO notes (id, title, is_todo) VALUES ('n111111', 'Submit report', 1)")
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('n111111', ?)", [trigger_time])
+
+        runner.run_cmd("ls")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        expected = "WARNING: 1 active reminder\n  #{Time.at(trigger_time / 1000).strftime('%Y-%m-%d %H:%M')} [n1111] Submit report\n\n"
+
+        assert out.start_with?(expected)
+        assert_operator out.index("Submit report"), :<, out.index("Work")
+      end
+
+      it "lists multiple reminders in trigger-time order" do
+        later = (Time.now.to_i - 60) * 1000
+        earlier = later - 60_000
+        runner.db.execute("INSERT INTO notes (id, title, is_todo) VALUES ('n111111', 'Later', 1)")
+        runner.db.execute("INSERT INTO notes (id, title, is_todo) VALUES ('n222222', 'Earlier', 1)")
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('n111111', ?)", [later])
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('n222222', ?)", [earlier])
+
+        runner.run_cmd("version")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert out.start_with?("WARNING: 2 active reminders\n")
+        assert_operator out.index("Earlier"), :<, out.index("Later")
+        assert out.end_with?("#{CLI::VERSION}\n")
+      end
+
+      it "excludes inactive and invalid alarms" do
+        now = Time.now.to_i * 1000
+        notes = [
+          ['active1', 'Active', 1, 0, 0],
+          ['future1', 'Future', 1, 0, 0],
+          ['done111', 'Completed', 1, now - 10_000, 0],
+          ['deleted', 'Deleted', 1, 0, now - 10_000],
+          ['regular', 'Regular note', 0, 0, 0],
+          ['zero111', 'Zero trigger', 1, 0, 0]
+        ]
+        notes.each do |id, title, is_todo, completed, deleted|
+          runner.db.execute(
+            "INSERT INTO notes (id, title, is_todo, todo_completed, deleted_time) VALUES (?, ?, ?, ?, ?)",
+            [id, title, is_todo, completed, deleted]
+          )
+        end
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('active1', ?)", [now - 60_000])
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('future1', ?)", [now + 60_000])
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('done111', ?)", [now - 60_000])
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('deleted', ?)", [now - 60_000])
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('regular', ?)", [now - 60_000])
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('zero111', 0)")
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('missing', ?)", [now - 60_000])
+
+        runner.run_cmd("version")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert_includes out, "Active"
+        %w[Future Completed Deleted Regular Zero].each { |title| refute_includes out, title }
+      end
+
+      it "suppresses reminders for raw and completion output" do
+        trigger_time = (Time.now.to_i - 60) * 1000
+        runner.db.execute("INSERT INTO notes (id, title, body, is_todo) VALUES ('a111111', 'Raw note', '# Raw', 1)")
+        runner.db.execute("INSERT INTO alarms (note_id, trigger_time) VALUES ('a111111', ?)", [trigger_time])
+
+        runner.run_cmd("cat a1111 --raw")
+        assert_equal "# Raw\n", TestSuite.strip_ansi(runner.last_stdout)
+
+        runner.run_cmd("cat a1111 -r")
+        assert_equal "# Raw\n", TestSuite.strip_ansi(runner.last_stdout)
+
+        runner.run_cmd("__complete notes")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        refute_includes out, "WARNING:"
+        assert_includes out, "Raw note"
+      end
     end
 
     describe "bkup" do
@@ -537,6 +643,18 @@ module TestSuite
     end
 
     describe "ls target" do
+      it "displays a note when no notebook or tag matches its path" do
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f1', 'projects', '')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, body) VALUES ('n1', 'f1', 'reef', '# Reef body')")
+
+        runner.run_cmd("ls projects/reef")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert_includes out, "reef (n1)"
+        assert_includes out, "Reef body"
+        refute_includes out, "No notebook or tag found"
+      end
+
       it "filters notebook notes by date" do
         runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f1', 'Work', '')")
         runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('n1', 'f1', 'Today Note', 1718294400000)")
@@ -760,7 +878,8 @@ module TestSuite
         runner.run_cmd(["rm", "EmptyNotebook", "-r"])
         runner.run_cmd(["rm", "empty-tag", "-r"])
 
-        assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
+        assert_operator runner.db.get_first_value("SELECT deleted_time FROM folders WHERE id = 'a111111'"), :>, 0
         assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM tags")
       end
 
@@ -780,7 +899,7 @@ module TestSuite
 
         runner.run_cmd(["rm", "Work", "-r"], stdin: "n\n", stdin_tty: true)
 
-        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Move 1 note to Trash"
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Move notebook 'Work' and 1 note to Trash"
         assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
         assert_equal 0, runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'n1'")
       end
@@ -793,7 +912,8 @@ module TestSuite
 
         runner.run_cmd(["rm", "Work", "-r"], stdin: "yes\n", stdin_tty: true)
 
-        assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
+        assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
+        assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM folders WHERE deleted_time > 0")
         assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM notes WHERE deleted_time > 0")
       end
 
@@ -853,9 +973,34 @@ module TestSuite
         out = TestSuite.strip_ansi(runner.last_stdout)
         assert_includes out, "e1111"
         assert_includes out, "Work/Deleted Plan"
+        refute_includes out, "Note Work/Deleted Plan"
         refute_includes out, "Active Plan"
       end
 
+      it "lists notebook contents as note paths without a redundant notebook entry" do
+        runner.db.execute("INSERT INTO folders (id, title, deleted_time) VALUES ('f111111', 'Work', 1781524800000)")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, deleted_time) VALUES ('e111111', 'f111111', 'Plan', 1781524800000)")
+
+        runner.run_cmd("trash ls")
+
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "e1111"
+        assert_includes out, "Work/Plan"
+        refute_includes out, "f1111"
+        refute_includes out, "Note "
+        refute_includes out, "Notebook "
+      end
+
+      it "lists an empty trashed notebook with a trailing slash" do
+        runner.db.execute("INSERT INTO folders (id, title, deleted_time) VALUES ('f111111', 'Empty', 1781524800000)")
+
+        runner.run_cmd("trash ls")
+
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_match(/f1111 .* Empty\/$/, out)
+        refute_includes out, "Notebook "
+      end
+
       it "restores a trashed note by UUID" do
         runner.db.execute("INSERT INTO notes (id, title, deleted_time) VALUES ('e333333', 'Restore Me', 1781524800000)")
 
@@ -865,6 +1010,31 @@ module TestSuite
         assert_includes TestSuite.strip_ansi(runner.last_stdout), "Restored note 'Restore Me'"
       end
 
+      it "restores a notebook subtree and notes deleted with it" do
+        deleted_at = 1781524800000
+        runner.db.execute("INSERT INTO folders (id, title, parent_id, deleted_time) VALUES ('f111111', 'Work', '', ?)", [deleted_at])
+        runner.db.execute("INSERT INTO folders (id, title, parent_id, deleted_time) VALUES ('f222222', 'Projects', 'f111111', ?)", [deleted_at])
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, deleted_time) VALUES ('e111111', 'f222222', 'Plan', ?)", [deleted_at])
+
+        runner.run_cmd(["trash", "restore", "f1111"])
+
+        assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM folders WHERE deleted_time > 0")
+        assert_equal 0, runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'e111111'")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Restored notebook 'Work'"
+      end
+
+      it "restores all deleted contents in a notebook" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f111111', 'Work')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, deleted_time) VALUES ('e111111', 'f111111', 'Old Trash', 1000)")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title) VALUES ('e222222', 'f111111', 'Active')")
+
+        runner.run_cmd(["rm", "Work", "-rf"])
+        runner.run_cmd(["trash", "restore", "f1111"])
+
+        assert_equal 0, runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'e111111'")
+        assert_equal 0, runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'e222222'")
+      end
+
       it "requires a unique UUID when restoring" do
         runner.db.execute("INSERT INTO notes (id, title, deleted_time) VALUES ('e444441', 'One', 1781524800000)")
         runner.db.execute("INSERT INTO notes (id, title, deleted_time) VALUES ('e444442', 'Two', 1781524800000)")
@@ -872,7 +1042,7 @@ module TestSuite
         runner.run_cmd(["trash", "restore", "e4444"])
 
         out = TestSuite.strip_ansi(runner.last_stdout)
-        assert_includes out, "Ambiguous trashed note"
+        assert_includes out, "Ambiguous trashed item"
         assert_includes out, "e4444 One"
         assert_includes out, "e4444 Two"
         assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM notes WHERE deleted_time > 0")
@@ -881,13 +1051,16 @@ module TestSuite
       it "empties Trash only after confirmation" do
         runner.db.execute("INSERT INTO notes (id, title, deleted_time) VALUES ('e555555', 'Delete Me', 1781524800000)")
         runner.db.execute("INSERT INTO notes (id, title, deleted_time) VALUES ('e666666', 'Keep Me', 0)")
+        runner.db.execute("INSERT INTO folders (id, title, deleted_time) VALUES ('f555555', 'Delete Book', 1781524800000)")
 
         runner.run_cmd(["trash", "empty"], stdin: "n\n", stdin_tty: true)
         assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM notes WHERE deleted_time > 0")
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM folders WHERE deleted_time > 0")
 
         runner.run_cmd(["trash", "empty"], stdin: "yes\n", stdin_tty: true)
         assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM notes WHERE deleted_time > 0")
         assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM notes WHERE id = 'e666666'")
+        assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
       end
     end
 
@@ -991,6 +1164,46 @@ module TestSuite
         assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
         assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
       end
+
+      it "adds CoreLocationCLI coordinates to a new note when available" do
+        cli = File.join(runner.dir, "CoreLocationCLI")
+        File.write(cli, "#!/bin/sh\nprintf '10.7769 106.7009 12.5\\n'\n")
+        FileUtils.chmod(0o755, cli)
+        ENV['CORE_LOCATION_CLI'] = cli
+
+        runner.run_cmd(["add", "Places", "--title", "Cafe", "Visited"], stdin: "", stdin_tty: true)
+
+        note = runner.db.get_first_row("SELECT latitude, longitude, altitude FROM notes")
+        assert_equal 10.7769, note['latitude']
+        assert_equal 106.7009, note['longitude']
+        assert_equal 12.5, note['altitude']
+      end
+
+      it "shows the CoreLocationCLI permission error and still creates the note" do
+        cli = File.join(runner.dir, "CoreLocationCLI")
+        message = "CoreLocationCLI: ❌ Location services are disabled or location access denied. Please visit System Settings > Privacy & Security > Location Services"
+        File.write(cli, "#!/bin/sh\nprintf '%s\\n' '#{message}' >&2\nexit 1\n")
+        FileUtils.chmod(0o755, cli)
+        ENV['CORE_LOCATION_CLI'] = cli
+
+        runner.run_cmd(["add", "Inbox", "--title", "Note", "Body"], stdin: "", stdin_tty: true)
+
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), message
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
+      end
+
+      it "shows any CoreLocationCLI error and still creates the note" do
+        cli = File.join(runner.dir, "CoreLocationCLI")
+        message = "CoreLocationCLI: unable to determine location"
+        File.write(cli, "#!/bin/sh\nprintf '%s\\n' '#{message}' >&2\nexit 2\n")
+        FileUtils.chmod(0o755, cli)
+        ENV['CORE_LOCATION_CLI'] = cli
+
+        runner.run_cmd(["add", "Inbox", "--title", "Note", "Body"], stdin: "", stdin_tty: true)
+
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), message
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
+      end
     end
 
     describe "journal" do
@@ -1004,6 +1217,20 @@ module TestSuite
         assert_includes TestSuite.strip_ansi(runner.last_stdout), "Updated journal Journal/2026/06-Jun/2026-06-17"
       end
 
+      it "adds CoreLocationCLI coordinates to a new journal note" do
+        cli = File.join(runner.dir, "CoreLocationCLI")
+        File.write(cli, "#!/bin/sh\nprintf '10.7769 106.7009 12.5\\n'\n")
+        FileUtils.chmod(0o755, cli)
+        ENV['CORE_LOCATION_CLI'] = cli
+
+        runner.run_cmd(["journal", "2026-06-17", "visited"])
+
+        note = runner.db.get_first_row("SELECT latitude, longitude, altitude FROM notes")
+        assert_equal 10.7769, note['latitude']
+        assert_equal 106.7009, note['longitude']
+        assert_equal 12.5, note['altitude']
+      end
+
       it "aliases j to journal" do
         runner.run_cmd(["j", "2026-06-17", "short", "entry"])
 
@@ -1056,6 +1283,27 @@ module TestSuite
         assert_equal "existing body", File.read(captured)
         assert_equal "existing body\nnew line", runner.db.get_first_value("SELECT body FROM notes")
       end
+
+      it "does not update an existing journal note when editor content is unchanged" do
+        runner.run_cmd(["journal", "2026-06-17", "existing body"])
+        original_updated_time = 1718294400000
+        runner.db.execute("UPDATE notes SET updated_time = ? WHERE title = ?", [original_updated_time, "2026-06-17"])
+
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'exit 0'"
+        begin
+          runner.run_cmd(["journal", "2026-06-17"], stdin: "", stdin_tty: true)
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+
+        note = runner.db.get_first_row("SELECT body, updated_time FROM notes WHERE title = ?", ["2026-06-17"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_equal "existing body", note["body"]
+        assert_equal original_updated_time, note["updated_time"]
+        assert_includes out, "No changes made."
+        refute_includes out, "Updated journal"
+      end
     end
 
     describe "cat" do
@@ -1202,6 +1450,18 @@ module TestSuite
         assert_includes out, "Tags: Urgent, work"
       end
 
+      it "shows the notebook path in verbose mode" do
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f1', 'people', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f2', 'lee', 'f1')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, body) VALUES ('e9ced1', 'f2', 'Saturday', 'Body')")
+
+        runner.run_cmd("cat e9ced -v")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Notebook: people/lee"
+
+        runner.run_cmd("cat e9ced -vv")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Notebook: people/lee"
+      end
+
       it "omits missing metadata in verbose mode" do
         runner.db.execute("INSERT INTO notes (id, title, body) VALUES ('e1', 'Plain Note', 'Body')")
 
@@ -1311,6 +1571,7 @@ module TestSuite
         assert_includes out, "complete -c jp"
         assert_includes out, "Override readonly or pager for this command"
         assert_includes out, "__jp_complete targets"
+        assert_includes out, "-a export"
         assert_includes out, "jp init fish"
       end
 
@@ -1359,6 +1620,121 @@ module TestSuite
       end
     end
 
+    describe "export" do
+      it "exports notebook directories and Joplin-compatible front matter" do
+        export_dir = File.join(runner.dir, "markdown-export")
+        created = Time.utc(2024, 6, 12, 19, 0).to_i * 1000
+        updated = Time.utc(2024, 6, 13, 20, 30).to_i * 1000
+        due = Time.utc(2024, 6, 20, 9, 15).to_i * 1000
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f1', 'Work', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f2', 'Projects', 'f1')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f3', 'Empty', '')")
+        runner.db.execute(<<~SQL, [created, updated, due])
+          INSERT INTO notes (
+            id, parent_id, title, body, user_created_time, user_updated_time,
+            latitude, longitude, altitude, author, source_url, is_todo, todo_due, todo_completed
+          ) VALUES (
+            'n1', 'f2', 'Plan / Q3', '# Body', ?, ?,
+            10.7769, 106.7009, 12.5, 'Ada', 'https://example.com/source', 1, ?, 1
+          )
+        SQL
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'work')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t2', 'Urgent')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'n1', 't1')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt2', 'n1', 't2')")
+
+        runner.run_cmd(["export", export_dir])
+
+        note_path = File.join(export_dir, "Work", "Projects", "Plan - Q3.md")
+        assert File.directory?(File.join(export_dir, "Empty"))
+        assert File.file?(note_path)
+        front_matter, body = File.read(note_path).sub(/\A---\n/, '').split("---\n\n", 2)
+        metadata = YAML.safe_load(front_matter)
+        assert_equal "Plan / Q3", metadata['title']
+        assert_equal "2024-06-12 19:00:00Z", metadata['created']
+        assert_equal "2024-06-13 20:30:00Z", metadata['updated']
+        assert_equal "2024-06-20 09:15:00Z", metadata['due']
+        assert_equal 10.7769, metadata['latitude']
+        assert_equal 106.7009, metadata['longitude']
+        assert_equal 12.5, metadata['altitude']
+        assert_equal "Ada", metadata['author']
+        assert_equal "https://example.com/source", metadata['source']
+        assert_equal true, metadata['completed?']
+        assert_equal %w[Urgent work], metadata['tags']
+        assert_equal "# Body", body
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Exported 1 note and 3 notebooks"
+      end
+
+      it "keeps duplicate and unsafe note titles in distinct files" do
+        export_dir = File.join(runner.dir, "markdown-export")
+        runner.db.execute("INSERT INTO notes (id, title, body) VALUES ('abcdef111', '../Same', 'First')")
+        runner.db.execute("INSERT INTO notes (id, title, body) VALUES ('abcdef222', '../Same', 'Second')")
+
+        runner.run_cmd(["export", export_dir])
+
+        files = Dir.glob(File.join(export_dir, "*.md")).map { |path| File.basename(path) }.sort
+        assert_equal ["_-Same (abcde).md", "_-Same.md"], files
+        assert_equal 2, files.map { |name| File.read(File.join(export_dir, name)) }.uniq.size
+      end
+
+      it "copies referenced resources and rewrites nested note links" do
+        export_dir = File.join(runner.dir, "markdown-export")
+        resource_id = "a" * 32
+        orphan_id = "b" * 32
+        resource_dir = File.join(runner.dir, "resources")
+        FileUtils.mkdir_p(resource_dir)
+        File.write(File.join(resource_dir, "#{resource_id}.pdf"), "PDF data")
+        File.write(File.join(resource_dir, "#{orphan_id}.png"), "orphan")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f1', 'Work', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f2', 'Projects', 'f1')")
+        runner.db.execute(
+          "INSERT INTO notes (id, parent_id, title, body) VALUES ('n1', 'f2', 'Attachment', ?)",
+          ["[document](:/#{resource_id})"]
+        )
+        runner.db.execute(
+          "INSERT INTO resources (id, title, mime, filename, file_extension) VALUES (?, 'Document', 'application/pdf', 'report.pdf', 'pdf')",
+          [resource_id]
+        )
+        runner.db.execute(
+          "INSERT INTO resources (id, title, mime, filename, file_extension) VALUES (?, 'Orphan', 'image/png', 'orphan.png', 'png')",
+          [orphan_id]
+        )
+
+        runner.run_cmd(["export", export_dir])
+
+        exported_resource = File.join(export_dir, "_resources", "#{resource_id}.pdf")
+        note = File.read(File.join(export_dir, "Work", "Projects", "Attachment.md"))
+        assert_equal "PDF data", File.read(exported_resource)
+        assert_includes note, "[document](../../_resources/#{resource_id}.pdf)"
+        refute File.exist?(File.join(export_dir, "_resources", "#{orphan_id}.png"))
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Copied 1 resource."
+      end
+
+      it "skips resources with -N and --no-resources" do
+        resource_id = "a" * 32
+        resource_dir = File.join(runner.dir, "resources")
+        FileUtils.mkdir_p(resource_dir)
+        File.write(File.join(resource_dir, "#{resource_id}.pdf"), "PDF data")
+        runner.db.execute(
+          "INSERT INTO notes (id, title, body) VALUES ('n1', 'Attachment', ?)",
+          ["[document](:/#{resource_id})"]
+        )
+        runner.db.execute(
+          "INSERT INTO resources (id, title, mime, filename, file_extension) VALUES (?, 'Document', 'application/pdf', 'report.pdf', 'pdf')",
+          [resource_id]
+        )
+
+        ["-N", "--no-resources"].each_with_index do |option, index|
+          export_dir = File.join(runner.dir, "markdown-export-#{index}")
+          runner.run_cmd(["export", option, export_dir])
+
+          note = File.read(File.join(export_dir, "Attachment.md"))
+          assert_includes note, "[document](:/#{resource_id})"
+          refute File.exist?(File.join(export_dir, "_resources"))
+        end
+      end
+    end
+
     describe "help" do
       it "colorizes the command listing" do
         runner.run_cmd("help")
@@ -1369,6 +1745,7 @@ module TestSuite
         assert_includes plain, "Usage:"
         assert_includes plain, "jp ls [TARGET]"
         assert_includes plain, "jp journal [today|yesterday|YYYY-MM-DD] [TEXT...]"
+        assert_includes plain, "jp export PATH"
         assert_includes out, "ls".green.bold
         refute_includes plain, "__complete"
       end
@@ -1396,6 +1773,18 @@ module TestSuite
         assert_equal File.join(ENV.fetch('HOME'), '.config', 'joplin'), CLI::DEFAULT_JOPLIN_DATA_DIR
       end
 
+      it "falls back to joplin-desktop when the joplin config directory is absent" do
+        config_dir = Dir.mktmpdir("jp_config")
+        desktop_dir = File.join(config_dir, "joplin-desktop")
+        FileUtils.mkdir_p(desktop_dir)
+        old_joplin_data_dir = ENV.delete('JOPLIN_DATA_DIR')
+
+        assert_equal desktop_dir, CLI.joplin_data_dir(candidates: [File.join(config_dir, "joplin"), desktop_dir])
+      ensure
+        ENV['JOPLIN_DATA_DIR'] = old_joplin_data_dir if old_joplin_data_dir
+        FileUtils.remove_entry(config_dir) if config_dir && File.exist?(config_dir)
+      end
+
       it "uses JOPLIN_DATA_DIR for the database and settings file" do
         assert_equal File.join(runner.dir, 'database.sqlite'), runner.cli.instance_variable_get(:@db_path)
         assert_equal File.join(runner.dir, 'settings.json'), runner.settings_path
@@ -1767,17 +2156,17 @@ end
 class Trash < Thor
   def self.exit_on_failure? = true
 
-  desc "ls", "List trashed notes"
+  desc "ls", "List trashed notes and notebooks"
   def ls
     CLI.new.send(:list_trash)
   end
 
-  desc "restore UUID", "Restore a trashed note"
+  desc "restore UUID", "Restore a trashed note or notebook"
   def restore(uuid)
-    CLI.new.send(:restore_trash_note, uuid)
+    CLI.new.send(:restore_trash_item, uuid)
   end
 
-  desc "empty", "Permanently delete all trashed notes"
+  desc "empty", "Permanently delete all trashed items"
   def empty
     CLI.new.send(:empty_trash)
   end
@@ -1867,11 +2256,18 @@ class CLI < Thor
     super.reject { |command| command.first.include?("__complete") }
   end
 
-  VERSION = "0.36.1"
+  VERSION = "0.38.8"
   DEFAULT_JOPLIN_DATA_DIR = File.join(ENV.fetch('HOME'), '.config', 'joplin')
+  FALLBACK_JOPLIN_DATA_DIR = File.join(ENV.fetch('HOME'), '.config', 'joplin-desktop')
+
+  def self.joplin_data_dir(candidates: [DEFAULT_JOPLIN_DATA_DIR, FALLBACK_JOPLIN_DATA_DIR])
+    return ENV['JOPLIN_DATA_DIR'] if ENV.key?('JOPLIN_DATA_DIR')
 
-  def self.joplin_data_dir
-    ENV.fetch('JOPLIN_DATA_DIR', DEFAULT_JOPLIN_DATA_DIR)
+    candidates.find { |path| File.directory?(path) } || candidates.first
+  end
+
+  def self.macos?
+    RUBY_PLATFORM.include?('darwin')
   end
 
   desc "settings SUBCOMMAND", "Manage settings"
@@ -1880,7 +2276,7 @@ class CLI < Thor
   desc "init SUBCOMMAND", "Print shell integration code"
   subcommand "init", Init
 
-  desc "trash SUBCOMMAND", "Manage trashed notes"
+  desc "trash SUBCOMMAND", "Manage trashed notes and notebooks"
   subcommand "trash", Trash
 
   def self.help(shell, subcommand = false)
@@ -1932,6 +2328,13 @@ class CLI < Thor
     load_settings unless Array(Thread.current[:jp_args]).first == "test"
   end
 
+  no_commands do
+    def invoke_command(command, *args)
+      show_active_alarm_warning unless alarm_warning_suppressed?(command)
+      super
+    end
+  end
+
   desc "version", "Show version"
   def version
     puts VERSION
@@ -1962,6 +2365,8 @@ class CLI < Thor
     else
       say "Backups:                ".cyan + " none".yellow
     end
+
+    show_core_location_cli_info
   end
 
   desc "bkup", "Backup the database"
@@ -2020,17 +2425,12 @@ class CLI < Thor
     title = derive_note_title(body) if title.empty?
     return say "Error: Note title is required.".red if title.nil? || title.empty?
 
-    source_url ||= ""
-    latitude ||= nil
-    longitude ||= nil
     note = create_note_with_hierarchy(
       notebook_path: notebook_path,
       title: title,
       body: body,
       tags: tags,
-      source_url: source_url,
-      latitude: latitude,
-      longitude: longitude
+      source_url: ""
     )
 
     say "Created note #{note[:path].green}"
@@ -2078,7 +2478,8 @@ class CLI < Thor
     when "removable"
       completion_removable_items.each { |candidate, description| puts "#{candidate}\t#{description}" }
     when "trashed"
-      trashed_notes.each { |note| puts "#{note['id'][0..4]}\tNote #{get_full_path_for_note(note)}" }
+      visible_trashed_folders.each { |folder| puts "#{folder['id'][0..4]}\t#{get_full_path(folder)}/" }
+      trashed_notes.each { |note| puts "#{note['id'][0..4]}\t#{get_full_path_for_note(note)}" }
     end
   end
 
@@ -2112,8 +2513,8 @@ class CLI < Thor
       lines.first.split(/\s+/)
     end
 
-    def resolve_cat_target(target)
-      notes = find_notes(target)
+    def resolve_cat_target(target, notes: nil)
+      notes ||= find_notes(target)
       if notes.empty?
         say "No note found matching '#{target}'."
         nil
@@ -2351,7 +2752,7 @@ class CLI < Thor
     auto_bkup_if_needed
   end
 
-  desc "rm TARGET", "Move a note to Trash or recursively remove a notebook or tag"
+  desc "rm TARGET", "Move a note or notebook to Trash, or recursively remove a tag"
   method_option :recursive, aliases: "-r", type: :boolean, desc: "Remove a notebook or tag recursively"
   method_option :force, aliases: "-f", type: :boolean, desc: "Do not prompt before trashing notes"
   def rm(target)
@@ -2384,7 +2785,11 @@ class CLI < Thor
     note_ids = removable_note_ids(item)
     unless note_ids.empty? || options[:force]
       noun = note_ids.length == 1 ? "note" : "notes"
-      print "Move #{note_ids.length} #{noun} to Trash and remove #{item[:type]} '#{item[:row]['title']}'? [y/N] "
+      if item[:type] == :notebook
+        print "Move notebook '#{item[:row]['title']}' and #{note_ids.length} #{noun} to Trash? [y/N] "
+      else
+        print "Move #{note_ids.length} #{noun} to Trash and remove tag '#{item[:row]['title']}'? [y/N] "
+      end
       answer = $stdin.gets.to_s.strip.downcase
       unless %w[y yes].include?(answer)
         say "Cancelled."
@@ -2394,11 +2799,71 @@ class CLI < Thor
 
     remove_item(item, note_ids)
     noun = item[:type] == :notebook ? "notebook" : "tag"
-    summary = note_ids.empty? ? "" : " and moved #{note_ids.length} #{note_ids.length == 1 ? 'note' : 'notes'} to Trash"
-    say "Removed #{noun} '#{item[:row]['title']}'#{summary}.".green
+    if item[:type] == :notebook
+      say "Moved notebook '#{item[:row]['title']}' and its contents to Trash.".green
+    else
+      summary = note_ids.empty? ? "" : " and moved #{note_ids.length} #{note_ids.length == 1 ? 'note' : 'notes'} to Trash"
+      say "Removed #{noun} '#{item[:row]['title']}'#{summary}.".green
+    end
     auto_bkup_if_needed
   end
 
+  desc "export PATH", "Export notes as Markdown with front matter"
+  method_option :no_resources, aliases: "-N", type: :boolean, desc: "Do not copy or rewrite resources"
+  def export(path)
+    target_dir = File.expand_path(path)
+    if File.exist?(target_dir) && !File.directory?(target_dir)
+      raise Thor::Error, "Export path is not a directory: #{target_dir}"
+    end
+    FileUtils.mkdir_p(target_dir)
+
+    folders = @db.execute(
+      "SELECT id, title, parent_id FROM folders WHERE deleted_time = 0 ORDER BY title COLLATE NOCASE, id"
+    )
+    folder_components = export_folder_components(folders)
+    folder_components.each_value { |components| FileUtils.mkdir_p(File.join(target_dir, *components)) }
+
+    tags_by_note = Hash.new { |hash, note_id| hash[note_id] = [] }
+    @db.execute(<<~SQL).each do |row|
+      SELECT nt.note_id, t.title
+      FROM note_tags nt
+      JOIN tags t ON t.id = nt.tag_id
+      JOIN notes n ON n.id = nt.note_id
+      WHERE n.deleted_time = 0
+      ORDER BY t.title COLLATE NOCASE, t.id
+    SQL
+      tags_by_note[row['note_id']] << row['title']
+    end
+
+    used_names = Hash.new { |hash, directory| hash[directory] = Set.new }
+    notes = @db.execute(
+      "SELECT * FROM notes WHERE deleted_time = 0 ORDER BY title COLLATE NOCASE, id"
+    )
+    resource_paths = options[:no_resources] ? {} : export_resources(notes, target_dir)
+    notes.each do |note|
+      components = folder_components.fetch(note['parent_id'], [])
+      directory = File.join(target_dir, *components)
+      basename = unique_export_component(
+        sanitize_export_component(note['title']),
+        note['id'],
+        used_names[directory]
+      )
+      metadata = export_front_matter(note, tags_by_note[note['id']])
+      body = export_note_body(note['body'], resource_paths, components.length)
+      File.write(File.join(directory, "#{basename}.md"), metadata.to_yaml + "---\n\n" + body)
+    end
+
+    note_label = notes.length == 1 ? "note" : "notes"
+    folder_label = folders.length == 1 ? "notebook" : "notebooks"
+    say "Exported #{notes.length} #{note_label} and #{folders.length} #{folder_label} to #{target_dir}.".green
+    unless options[:no_resources] || resource_paths.empty?
+      resource_label = resource_paths.length == 1 ? "resource" : "resources"
+      say "Copied #{resource_paths.length} #{resource_label}.".green
+    end
+  rescue SystemCallError, SQLite3::Exception => e
+    raise Thor::Error, "Export failed: #{e.message}"
+  end
+
   desc "test", "Run tests"
   method_option :verbose, aliases: "-v", type: :boolean
   def test
@@ -2415,6 +2880,156 @@ class CLI < Thor
 
   private
 
+  def export_resources(notes, target_dir)
+    referenced_ids = notes.each_with_object(Set.new) do |note, ids|
+      note['body'].to_s.scan(/:\/([a-f0-9]{32})(?![a-f0-9])/i) { |match| ids << match.first.downcase }
+    end
+    return {} if referenced_ids.empty?
+
+    resources = []
+    referenced_ids.to_a.each_slice(500) do |ids|
+      placeholders = Array.new(ids.length, '?').join(', ')
+      resources.concat(@db.execute(
+        "SELECT id, file_extension FROM resources WHERE LOWER(id) IN (#{placeholders})",
+        ids
+      ))
+    end
+
+    exported = {}
+    resources.each do |resource|
+      resource_id = resource['id'].downcase
+      source = find_resource_file(resource_id, resource['file_extension'])
+      unless source
+        say "Warning: resource file not found for #{resource_id}.".yellow
+        next
+      end
+
+      resource_dir = File.join(target_dir, '_resources')
+      FileUtils.mkdir_p(resource_dir)
+      filename = File.basename(source)
+      FileUtils.cp(source, File.join(resource_dir, filename))
+      exported[resource_id] = filename
+    end
+    exported
+  end
+
+  def find_resource_file(resource_id, extension)
+    resource_dir = File.join(@joplin_data_dir, 'resources')
+    expected_name = extension.to_s.empty? ? resource_id : "#{resource_id}.#{extension}"
+    expected = File.join(resource_dir, expected_name)
+    return expected if File.file?(expected)
+
+    exact = File.join(resource_dir, resource_id)
+    return exact if File.file?(exact)
+
+    Dir.glob(File.join(resource_dir, "#{resource_id}.*")).sort.find { |path| File.file?(path) }
+  end
+
+  def export_note_body(body, resource_paths, notebook_depth)
+    prefix = "../" * notebook_depth
+    body.to_s.gsub(/:\/([a-f0-9]{32})(?![a-f0-9])/i) do |link|
+      filename = resource_paths[Regexp.last_match(1).downcase]
+      filename ? "#{prefix}_resources/#{filename}" : link
+    end
+  end
+
+  def export_folder_components(folders)
+    folders_by_id = folders.to_h { |folder| [folder['id'], folder] }
+    component_by_id = {}
+
+    folders.group_by { |folder| folders_by_id.key?(folder['parent_id']) ? folder['parent_id'] : "" }.each_value do |siblings|
+      used = Set.new
+      siblings.sort_by { |folder| [folder['title'].to_s.downcase, folder['id'].to_s] }.each do |folder|
+        component_by_id[folder['id']] = unique_export_component(
+          sanitize_export_component(folder['title']),
+          folder['id'],
+          used
+        )
+      end
+    end
+
+    resolved = {}
+    resolve = lambda do |folder_id, visiting = Set.new|
+      return resolved[folder_id] if resolved.key?(folder_id)
+      return [] if visiting.include?(folder_id)
+
+      folder = folders_by_id[folder_id]
+      return [] unless folder
+
+      parent_components = resolve.call(folder['parent_id'], visiting | [folder_id])
+      resolved[folder_id] = parent_components + [component_by_id.fetch(folder_id)]
+    end
+    folders.each { |folder| resolve.call(folder['id']) }
+    resolved
+  end
+
+  def sanitize_export_component(value)
+    component = value.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+    component = component.gsub(/[<>:"\\\/|?*\x00-\x1f]/, '-').strip
+    component = component.sub(/\A\.+/, '_')
+    component = component.sub(/[. ]+\z/, '')
+    component = "Untitled" if component.empty? || component == "." || component == ".."
+    component += "_" if component.match?(/\A(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\..*)?\z/i)
+    component = component[0...-1] while component.bytesize > 180
+    component
+  end
+
+  def unique_export_component(component, id, used)
+    candidate = component
+    suffix = " (#{id.to_s[0, 5]})"
+    counter = 2
+    while used.include?(candidate.downcase)
+      candidate = "#{component}#{suffix}"
+      if used.include?(candidate.downcase)
+        candidate = "#{component}#{suffix} #{counter}"
+        counter += 1
+      end
+    end
+    used << candidate.downcase
+    candidate
+  end
+
+  def export_front_matter(note, tags)
+    metadata = { 'title' => note['title'].to_s }
+    updated = export_note_time(note, 'user_updated_time', 'updated_time')
+    created = export_note_time(note, 'user_created_time', 'created_time')
+    metadata['updated'] = updated if updated
+    metadata['created'] = created if created
+
+    source = note['source_url'].to_s.strip
+    author = note['author'].to_s.strip
+    metadata['source'] = source unless source.empty?
+    metadata['author'] = author unless author.empty?
+
+    latitude = note['latitude'].to_f
+    longitude = note['longitude'].to_f
+    if latitude.nonzero? || longitude.nonzero?
+      metadata['latitude'] = latitude
+      metadata['longitude'] = longitude
+    end
+    altitude = note['altitude'].to_f
+    metadata['altitude'] = altitude if altitude.nonzero?
+
+    if note['is_todo'].to_i != 0
+      metadata['completed?'] = note['todo_completed'].to_i.positive?
+      due = export_timestamp(note['todo_due'])
+      metadata['due'] = due if due
+    end
+    metadata['tags'] = tags if tags.any?
+    metadata
+  end
+
+  def export_note_time(note, preferred_key, fallback_key)
+    export_timestamp(note[preferred_key]) || export_timestamp(note[fallback_key])
+  end
+
+  def export_timestamp(milliseconds)
+    value = milliseconds.to_i
+    return nil unless value.positive?
+
+    Time.at(value / 1000.0).utc.strftime('%Y-%m-%d %H:%M:%SZ')
+  end
+
   def find_movable_items(source)
     if source.match?(/\A[a-f0-9]{1,32}\z/i)
       prefix = "#{source.downcase}%"
@@ -2515,83 +3130,188 @@ class CLI < Thor
     ids
   end
 
+  def all_notebook_subtree_ids(root_id)
+    ids = []
+    pending = [root_id]
+    until pending.empty?
+      parent_id = pending.shift
+      next if ids.include?(parent_id)
+
+      ids << parent_id
+      pending.concat(
+        @db.execute("SELECT id FROM folders WHERE parent_id = ?", [parent_id]).map { |row| row['id'] }
+      )
+    end
+    ids
+  end
+
   def remove_item(item, note_ids)
+    deleted_at = Time.now.to_i * 1000
     @db.transaction do
-      trash_notes(note_ids)
       if item[:type] == :tag
+        trash_notes(note_ids, deleted_at: deleted_at)
         @db.execute("DELETE FROM note_tags WHERE tag_id = ?", [item[:row]['id']])
         @db.execute("DELETE FROM tags WHERE id = ?", [item[:row]['id']])
       else
         folder_ids = notebook_subtree_ids(item[:row]['id'])
-        placeholders = Array.new(folder_ids.length, "?").join(", ")
-        @db.execute("DELETE FROM folders WHERE id IN (#{placeholders})", folder_ids)
+        trash_notes(note_ids, deleted_at: deleted_at)
+        set_deleted_time('folders', folder_ids, deleted_at)
       end
     end
   end
 
-  def trash_notes(note_ids)
-    return if note_ids.empty?
+  def trash_notes(note_ids, deleted_at: Time.now.to_i * 1000)
+    set_deleted_time('notes', note_ids, deleted_at)
+  end
 
-    columns = @db.execute("PRAGMA table_info(notes)").map { |column| column['name'] }.to_set
-    now = Time.now.to_i * 1000
+  def set_deleted_time(table, ids, deleted_at)
+    return if ids.empty?
+
+    columns = @db.execute("PRAGMA table_info(#{table})").map { |column| column['name'] }.to_set
     assignments = ["deleted_time = ?"]
-    values = [now]
-    if columns.include?("updated_time")
-      assignments << "updated_time = ?"
-      values << now
+    values = [deleted_at]
+    %w[updated_time user_updated_time].each do |column|
+      next unless columns.include?(column)
+
+      assignments << "#{column} = ?"
+      values << deleted_at
     end
-    placeholders = Array.new(note_ids.length, "?").join(", ")
+    placeholders = Array.new(ids.length, "?").join(", ")
     @db.execute(
-      "UPDATE notes SET #{assignments.join(', ')} WHERE id IN (#{placeholders})",
-      [*values, *note_ids]
+      "UPDATE #{table} SET #{assignments.join(', ')} WHERE id IN (#{placeholders})",
+      [*values, *ids]
     )
   end
 
   def trashed_notes
-    @db.execute("SELECT id, title, parent_id, deleted_time FROM notes WHERE deleted_time > 0 ORDER BY deleted_time DESC")
+    @db.execute(
+      "SELECT id, title, parent_id, deleted_time FROM notes WHERE deleted_time > 0 ORDER BY deleted_time DESC, title COLLATE NOCASE"
+    )
+  end
+
+  def trashed_folders
+    @db.execute(<<~SQL)
+      SELECT f.id, f.title, f.parent_id, f.deleted_time
+      FROM folders f
+      LEFT JOIN folders parent ON parent.id = f.parent_id
+      WHERE f.deleted_time > 0 AND (parent.id IS NULL OR parent.deleted_time = 0)
+      ORDER BY f.deleted_time DESC, f.title COLLATE NOCASE
+    SQL
+  end
+
+  def visible_trashed_folders
+    trashed_folders.reject do |folder|
+      folder_ids = all_notebook_subtree_ids(folder['id'])
+      placeholders = Array.new(folder_ids.length, '?').join(', ')
+      @db.get_first_value(
+        "SELECT COUNT(*) FROM notes WHERE parent_id IN (#{placeholders}) AND deleted_time > 0",
+        folder_ids
+      ).to_i.positive?
+    end
   end
 
   def list_trash
     notes = trashed_notes
-    return say "Trash is empty." if notes.empty?
+    folders = visible_trashed_folders
+    return say "Trash is empty." if notes.empty? && folders.empty?
 
-    notes.each do |note|
-      id = note['id'][0..4].colorize(mode: :dim)
-      timestamp = format_note_time(note['deleted_time']).colorize(mode: :dim)
-      say "#{id} #{timestamp} #{get_full_path_for_note(note)}"
+    items = folders.map { |folder| { type: :notebook, row: folder } } +
+      notes.map { |note| { type: :note, row: note } }
+    items.sort_by { |item| [-item[:row]['deleted_time'].to_i, item[:row]['title'].to_s.downcase] }.each do |item|
+      row = item[:row]
+      id = row['id'][0..4].colorize(mode: :dim)
+      timestamp = format_note_time(row['deleted_time']).colorize(mode: :dim)
+      path = item[:type] == :notebook ? "#{get_full_path(row)}/" : get_full_path_for_note(row)
+      say "#{id} #{timestamp} #{path}"
     end
   end
 
-  def restore_trash_note(uuid)
+  def restore_trash_item(uuid)
     return unless ensure_writable!
 
-    matches = @db.execute(
-      "SELECT id, title, parent_id FROM notes WHERE LOWER(id) LIKE ? AND deleted_time > 0 ORDER BY title COLLATE NOCASE",
-      ["#{uuid.downcase}%"]
-    )
-    return say "No trashed note found matching '#{uuid}'." if matches.empty?
+    prefix = "#{uuid.downcase}%"
+    matches = trashed_folders.select { |folder| folder['id'].downcase.start_with?(uuid.downcase) }.map do |folder|
+      { type: :notebook, row: folder }
+    end
+    matches.concat(@db.execute(
+      "SELECT id, title, parent_id, deleted_time FROM notes WHERE LOWER(id) LIKE ? AND deleted_time > 0 ORDER BY title COLLATE NOCASE",
+      [prefix]
+    ).map { |note| { type: :note, row: note } })
+    return say "No trashed note or notebook found matching '#{uuid}'." if matches.empty?
 
     if matches.length > 1
-      say "Ambiguous trashed note '#{uuid}'. Use a longer UUID:".yellow
-      matches.each do |note|
-        say "  #{note['id'][0..4].colorize(mode: :dim)} #{get_full_path_for_note(note)}"
+      say "Ambiguous trashed item '#{uuid}'. Use a longer UUID:".yellow
+      matches.each do |item|
+        row = item[:row]
+        path = item[:type] == :notebook ? "#{get_full_path(row)}/" : get_full_path_for_note(row)
+        say "  #{row['id'][0..4].colorize(mode: :dim)} #{path}"
       end
       return
     end
 
-    note = matches.first
-    @db.execute("UPDATE notes SET deleted_time = 0 WHERE id = ?", [note['id']])
-    say "Restored note '#{note['title']}'.".green
+    item = matches.first
+    item[:type] == :notebook ? restore_trashed_notebook(item[:row]) : restore_trashed_note(item[:row])
     auto_bkup_if_needed
   end
 
+  def restore_trashed_note(note)
+    parent = @db.get_first_row("SELECT deleted_time FROM folders WHERE id = ?", [note['parent_id']])
+    parent_id = parent && parent['deleted_time'].to_i.zero? ? note['parent_id'] : ""
+    @db.transaction do
+      @db.execute("UPDATE notes SET parent_id = ? WHERE id = ?", [parent_id, note['id']])
+      restore_deleted_items('notes', [note['id']])
+    end
+    say "Restored note '#{note['title']}'.".green
+  end
+
+  def restore_trashed_notebook(folder)
+    subtree_ids = all_notebook_subtree_ids(folder['id'])
+    placeholders = Array.new(subtree_ids.length, '?').join(', ')
+    parent = @db.get_first_row("SELECT deleted_time FROM folders WHERE id = ?", [folder['parent_id']])
+    parent_id = parent && parent['deleted_time'].to_i.zero? ? folder['parent_id'] : ""
+
+    @db.transaction do
+      @db.execute("UPDATE folders SET parent_id = ? WHERE id = ?", [parent_id, folder['id']])
+      deleted_folder_ids = @db.execute(
+        "SELECT id FROM folders WHERE id IN (#{placeholders}) AND deleted_time > 0",
+        subtree_ids
+      ).map { |row| row['id'] }
+      restore_deleted_items('folders', deleted_folder_ids)
+      note_ids = @db.execute(
+        "SELECT id FROM notes WHERE parent_id IN (#{placeholders}) AND deleted_time > 0",
+        subtree_ids
+      ).map { |row| row['id'] }
+      restore_deleted_items('notes', note_ids)
+    end
+    say "Restored notebook '#{folder['title']}'.".green
+  end
+
+  def restore_deleted_items(table, ids)
+    return if ids.empty?
+
+    columns = @db.execute("PRAGMA table_info(#{table})").map { |column| column['name'] }.to_set
+    assignments = ["deleted_time = 0"]
+    values = []
+    if columns.include?('updated_time')
+      assignments << "updated_time = ?"
+      values << Time.now.to_i * 1000
+    end
+    placeholders = Array.new(ids.length, '?').join(', ')
+    @db.execute(
+      "UPDATE #{table} SET #{assignments.join(', ')} WHERE id IN (#{placeholders})",
+      [*values, *ids]
+    )
+  end
+
   def empty_trash
     return unless ensure_writable!
 
-    count = @db.get_first_value("SELECT COUNT(*) FROM notes WHERE deleted_time > 0").to_i
+    folders = trashed_folders
+    notes = trashed_notes
+    count = visible_trashed_folders.length + notes.length
     return say "Trash is empty." if count.zero?
 
-    noun = count == 1 ? "note" : "notes"
+    noun = count == 1 ? "item" : "items"
     print "Permanently delete #{count} trashed #{noun}? [y/N] "
     answer = $stdin.gets.to_s.strip.downcase
     unless %w[y yes].include?(answer)
@@ -2599,11 +3319,23 @@ class CLI < Thor
       return
     end
 
-    trashed_ids = @db.execute("SELECT id FROM notes WHERE deleted_time > 0").map { |row| row['id'] }
-    placeholders = Array.new(trashed_ids.length, "?").join(", ")
+    folder_ids = folders.flat_map { |folder| all_notebook_subtree_ids(folder['id']) }.uniq
+    note_ids = @db.execute("SELECT id FROM notes WHERE deleted_time > 0").map { |row| row['id'] }
+    unless folder_ids.empty?
+      placeholders = Array.new(folder_ids.length, '?').join(', ')
+      note_ids.concat(@db.execute("SELECT id FROM notes WHERE parent_id IN (#{placeholders})", folder_ids).map { |row| row['id'] })
+    end
+    note_ids.uniq!
     @db.transaction do
-      @db.execute("DELETE FROM note_tags WHERE note_id IN (#{placeholders})", trashed_ids)
-      @db.execute("DELETE FROM notes WHERE id IN (#{placeholders})", trashed_ids)
+      unless note_ids.empty?
+        placeholders = Array.new(note_ids.length, '?').join(', ')
+        @db.execute("DELETE FROM note_tags WHERE note_id IN (#{placeholders})", note_ids)
+        @db.execute("DELETE FROM notes WHERE id IN (#{placeholders})", note_ids)
+      end
+      unless folder_ids.empty?
+        placeholders = Array.new(folder_ids.length, '?').join(', ')
+        @db.execute("DELETE FROM folders WHERE id IN (#{placeholders})", folder_ids)
+      end
     end
     say "Emptied Trash.".green
     auto_bkup_if_needed
@@ -2682,7 +3414,13 @@ class CLI < Thor
         return nil
       end
 
-      body = File.read(temp.path).delete_suffix("\n")
+      raw_body = File.read(temp.path)
+      if notes.first && raw_body == notes.first['body'].to_s
+        say "No changes made."
+        return nil
+      end
+
+      body = raw_body.delete_suffix("\n")
       if body.empty?
         say "Journal cancelled."
         return nil
@@ -2733,9 +3471,7 @@ class CLI < Thor
       title: title,
       body: body,
       tags: [],
-      source_url: "",
-      latitude: nil,
-      longitude: nil
+      source_url: ""
     )
   end
 
@@ -2782,10 +3518,67 @@ class CLI < Thor
     raise AddError, "#{name} must be a number."
   end
 
-  def create_note_with_hierarchy(notebook_path:, title:, body:, tags:, source_url:, latitude:, longitude:)
+  def core_location
+    executable = core_location_cli
+    return nil unless executable
+
+    stdout, stderr, status = Open3.capture3(
+      executable,
+      '--format',
+      "%latitude %longitude %altitude"
+    )
+    output = [stdout, stderr].reject(&:empty?).join("\n")
+    unless status.success?
+      message = output.strip
+      message = "CoreLocationCLI exited with status #{status.exitstatus}." if message.empty?
+      say message.red
+      return nil
+    end
+
+    values = stdout.strip.split(/\s+/)
+    return nil if values.length < 2
+
+    latitude = Float(values[0])
+    longitude = Float(values[1])
+    return nil unless latitude.finite? && latitude.between?(-90, 90)
+    return nil unless longitude.finite? && longitude.between?(-180, 180)
+
+    altitude = Float(values[2]) if values[2]
+    altitude = nil unless altitude&.finite?
+    [latitude, longitude, altitude]
+  rescue SystemCallError => e
+    say "CoreLocationCLI: #{e.message}".red
+    nil
+  rescue ArgumentError, TypeError
+    nil
+  end
+
+  def show_core_location_cli_info(macos: self.class.macos?)
+    return unless macos
+
+    executable = core_location_cli
+    return if executable
+
+    say "\nWARNING: CoreLocationCLI is not installed. New notes will not include GPS coordinates.".yellow.bold
+  end
+
+  def core_location_cli
+    configured = ENV.fetch('CORE_LOCATION_CLI', 'CoreLocationCLI')
+    return nil if configured.empty?
+    return configured if configured.include?(File::SEPARATOR) && File.file?(configured) && File.executable?(configured)
+
+    ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).each do |directory|
+      candidate = File.join(directory, configured)
+      return candidate if File.file?(candidate) && File.executable?(candidate)
+    end
+    nil
+  end
+
+  def create_note_with_hierarchy(notebook_path:, title:, body:, tags:, source_url:)
     components = notebook_path.to_s.split('/', -1).map(&:strip)
     raise AddError, "Notebook path is required." if components.empty? || components.any?(&:empty?)
 
+    latitude, longitude, altitude = core_location || [nil, nil, nil]
     now = Time.now.to_i * 1000
     note_id = SecureRandom.hex(16)
     parent_id = ""
@@ -2827,6 +3620,7 @@ class CLI < Thor
         'user_updated_time' => now,
         'latitude' => latitude,
         'longitude' => longitude,
+        'altitude' => altitude,
         'source_url' => source_url,
         'deleted_time' => 0
       })
@@ -2887,6 +3681,7 @@ class CLI < Thor
 
   def display_note_metadata(note)
     metadata = []
+    metadata << "Notebook: #{notebook_path_for_note(note)}"
     metadata << "Created: #{format_note_time(note['created_time'])}" if note['created_time'].to_i.positive?
     metadata << "Updated: #{format_note_time(note['updated_time'])}" if note['updated_time'].to_i.positive?
 
@@ -2908,6 +3703,11 @@ class CLI < Thor
     metadata
   end
 
+  def notebook_path_for_note(note)
+    folder = @db.get_first_row("SELECT id, title, parent_id FROM folders WHERE id = ?", [note['parent_id']])
+    folder ? get_full_path(folder) : "/"
+  end
+
   def write_with_pager(output, raw:, no_pager:)
     rows, columns = terminal_dimensions
     unless should_page_output?(output, raw: raw, no_pager: no_pager, tty: $stdout.tty?, rows: rows, columns: columns)
@@ -3140,6 +3940,35 @@ class CLI < Thor
     Time.at(milliseconds / 1000.0).strftime('%Y-%m-%d %H:%M')
   end
 
+  def alarm_warning_suppressed?(command)
+    command_name = command.name.to_s
+    %w[__complete test].include?(command_name) || (command_name == "cat" && options[:raw])
+  end
+
+  def show_active_alarm_warning(now: Time.now)
+    alarms = @db.execute(<<~SQL, [now.to_i * 1000])
+      SELECT a.id, a.trigger_time, n.id AS note_id, n.title
+      FROM alarms a
+      JOIN notes n ON n.id = a.note_id
+      WHERE a.trigger_time > 0
+        AND a.trigger_time <= ?
+        AND n.is_todo != 0
+        AND n.todo_completed = 0
+        AND n.deleted_time = 0
+      ORDER BY a.trigger_time, n.title COLLATE NOCASE, a.id
+    SQL
+    return if alarms.empty?
+
+    noun = alarms.length == 1 ? "reminder" : "reminders"
+    say "WARNING: #{alarms.length} active #{noun}".yellow.bold
+    alarms.each do |alarm|
+      title = alarm['title'].to_s.gsub(/\s+/, ' ').strip
+      title = "(untitled)" if title.empty?
+      say "  #{format_note_time(alarm['trigger_time'])} [#{alarm['note_id'][0, 5]}] #{title}".yellow
+    end
+    say ""
+  end
+
   def time_ago(time)
     diff = Time.now - time
     if diff < 60
@@ -3222,10 +4051,11 @@ class CLI < Thor
       complete -c jp -n __jp_needs_command -a edit -d 'Edit a note or tag stack'
       complete -c jp -n __jp_needs_command -a mv -d 'Rename a notebook or tag'
       complete -c jp -n __jp_needs_command -a rm -d 'Remove a notebook or tag'
-      complete -c jp -n __jp_needs_command -a trash -d 'Manage trashed notes'
+      complete -c jp -n __jp_needs_command -a trash -d 'Manage trashed notes and notebooks'
       complete -c jp -n __jp_needs_command -a settings -d 'Manage settings'
       complete -c jp -n __jp_needs_command -a info -d 'Show JP and Joplin profile information'
       complete -c jp -n __jp_needs_command -a bkup -d 'Backup the database'
+      complete -c jp -n __jp_needs_command -a export -d 'Export notes as Markdown with front matter'
       complete -c jp -n __jp_needs_command -a version -d 'Show version'
       complete -c jp -n __jp_needs_command -a init -d 'Print shell integration code'
       complete -c jp -n '__jp_using_command init' -a fish -d 'Fish shell'
@@ -3233,6 +4063,7 @@ class CLI < Thor
       complete -c jp -n '__jp_using_command add' -a '(__jp_complete notebooks)'
       complete -c jp -n '__jp_using_command add' -s t -l title -r -d 'Note title'
       complete -c jp -n '__jp_using_command add' -s T -l tag -r -a '(__jp_complete tags)' -d 'Tag'
+      complete -c jp -n '__jp_using_command export' -s N -l no-resources -d 'Do not copy or rewrite resources'
       complete -c jp -n '__jp_using_command journal' -a 'today yesterday' -d 'Journal date'
       complete -c jp -n '__jp_using_command j' -a 'today yesterday' -d 'Journal date'
 
@@ -3493,6 +4324,7 @@ class CLI < Thor
       end
     end
 
+    explicit_type = options[:nb] || options[:type] || target.match?(/\A[nt]:/)
     sn, st = options[:nb] || (!options[:type]), options[:type] || (!options[:nb])
     if target =~ /^n:(.+)$/; sn, st, target = true, false, $1
     elsif target =~ /^t:(.+)$/; sn, st, target = false, true, $1; end
@@ -3513,7 +4345,16 @@ class CLI < Thor
         found = true
       end
     end
-    say "No notebook or tag found matching '#{target}'." unless found
+    return if found
+
+    notes = explicit_type ? [] : find_notes(target)
+    if notes.empty?
+      say "No notebook or tag found matching '#{target}'."
+      return
+    end
+
+    note = resolve_cat_target(target, notes: notes)
+    display_note(note, raw: false, verbose: false, no_pager: false) if note
   end
 
   def list_notebook_contents(notebook)