joplin 1.0.2 → 1.2.0

data/bin/jp

@@ -0,0 +1,4155 @@
+#!/usr/bin/env ruby
+
+require 'sqlite3'
+require 'date'
+require 'set'
+require 'thor'
+require 'colorize'
+require 'cgi'
+require 'uri'
+require 'io/console'
+require 'stringio'
+require 'shellwords'
+require 'json'
+require 'bundler/setup'
+
+
+# Polyfill for CGI.parse which was removed in Ruby 4.x
+unless CGI.respond_to?(:parse)
+  def CGI.parse(query)
+    return {} if query.nil? || query.empty?
+    URI.decode_www_form(query).each_with_object({}) do |(k, v), h|
+      (h[k] ||= []) << v
+    end
+  end
+end
+require 'fileutils'
+require 'tempfile'
+require 'tmpdir'
+require 'tty-markdown'
+require 'kramdown/converter/toc'
+require 'yaml'
+require 'securerandom'
+require 'zlib'
+
+# Disable colorization if not outputting to a TTY (for piping)
+String.disable_colorization = true unless STDOUT.tty?
+PRG = File.basename $PROGRAM_NAME
+
+# Simple Tee class to duplicate output
+class Tee
+  def initialize(captured, original)
+    @captured = captured
+    @original = original
+  end
+  def write(data); @captured.write(data); @original.write(data); end
+  def puts(*args); @captured.puts(*args); @original.puts(*args); end
+  def print(*args); @captured.print(*args); @original.print(*args); end
+  def flush; @captured.flush; @original.flush; end
+  def tty?; @original.tty?; end
+end
+
+class TestInput < StringIO
+  def initialize(content = "", tty: false)
+    super(content)
+    @tty = tty
+  end
+
+  def tty?; @tty; end
+end
+
+# In-process test runner
+class TestRunner
+  attr_reader :cli, :stdout_io, :stderr_io, :dir
+
+  def initialize(debug: false)
+    @dir = Dir.mktmpdir("jp_test")
+    @db_path = File.join(@dir, "database.sqlite")
+    
+    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 tags (id TEXT PRIMARY KEY, title TEXT);
+      CREATE TABLE note_tags (id TEXT PRIMARY KEY, note_id TEXT, tag_id TEXT);
+    SQL
+    db.close
+
+    @old_joplin_data_dir = ENV['JOPLIN_DATA_DIR']
+    ENV['JOPLIN_DATA_DIR'] = @dir
+
+    @old_stdout = $stdout
+    @old_stderr = $stderr
+    @stdout_io = StringIO.new
+    @stderr_io = StringIO.new
+    
+    if debug
+      $stdout = Tee.new(@stdout_io, @old_stdout)
+      $stderr = Tee.new(@stderr_io, @old_stderr)
+    else
+      $stdout = @stdout_io
+      $stderr = @stderr_io
+    end
+
+    @cli = CLI.new
+    String.disable_colorization = false
+  end
+
+  def db
+    @cli.instance_variable_get(:@db)
+  end
+
+  def prepare_yaml(target)
+    @cli.send(:prepare_yaml_edit_data_for_target, target)
+  end
+
+  def apply_yaml(init, newd)
+    @cli.send(:apply_yaml_changes, init, newd)
+  end
+
+  def expand_toc(body)
+    @cli.send(:expand_toc_markers, body)
+  end
+
+  def should_page(output, raw: false, no_pager: false, tty: true, rows: 24, columns: 80)
+    @cli.send(:should_page_output?, output, raw: raw, no_pager: no_pager, tty: tty, rows: rows, columns: columns)
+  end
+
+  def settings_path
+    File.join(@dir, "settings.json")
+  end
+
+  def format_settings(data, color: true)
+    @cli.send(:format_settings_list, data, color: color)
+  end
+
+  def run_cmd(argv, stdin: nil, stdin_tty: false)
+    args = argv.is_a?(Array) ? argv : argv.to_s.split(' ')
+    old_stdin = $stdin
+    $stdin = TestInput.new(stdin || "", tty: stdin_tty) unless stdin.nil?
+    begin
+      CLI.start(args)
+    ensure
+      Thread.current[:jp_args] = nil
+      Thread.current[:jp_setting_overrides] = nil
+      $stdin = old_stdin
+      flush_output
+    end
+  end
+
+  def flush_output
+    @stdout_io.rewind
+    @stderr_io.rewind
+    @last_out = @stdout_io.read
+    @last_err = @stderr_io.read
+    @stdout_io.truncate(0); @stdout_io.rewind
+    @stderr_io.truncate(0); @stderr_io.rewind
+  end
+
+  def last_stdout; @last_out || ""; end
+  def last_stderr; @last_err || ""; end
+
+  def close
+    $stdout = @old_stdout
+    $stderr = @old_stderr
+    ENV['JOPLIN_DATA_DIR'] = @old_joplin_data_dir
+    db.close rescue nil
+    FileUtils.remove_entry(@dir) rescue nil
+  end
+end
+
+module TestSuite
+  require 'minitest'
+  require 'minitest/spec'
+
+  class << self
+    attr_accessor :debug
+    def strip_ansi(str); str.gsub(/\e\[(\d+;?)*m/, ""); end
+  end
+
+  describe "JP CLI" do
+    before { runner }
+    let(:runner) { TestRunner.new(debug: TestSuite.debug) }
+    after do
+      out = runner.last_stdout
+      err = runner.last_stderr
+      runner.close
+      if !passed?
+        $stdout.puts "\n#{"="*30} CAPTURED OUTPUT #{"="*30}".red
+        $stdout.puts "STDOUT:".yellow
+        $stdout.puts out
+        unless err.empty?
+          $stdout.puts "\nSTDERR:".red
+          $stdout.puts err
+        end
+        $stdout.puts "#{"="*77}".red
+      end
+    end
+
+    describe "ls overview" do
+      it "lists only top-level notebooks and all tags" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'Work')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f2', 'Projects', 'f1')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'urgent')")
+        runner.run_cmd("ls")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Work"
+        refute_includes out, "Projects"
+        assert_includes out, "urgent"
+      end
+
+      it "shows the complete notebook hierarchy with -T" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'Work')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f2', 'Projects', 'f1')")
+
+        runner.run_cmd("ls -T")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Work"
+        assert_includes out, "Projects"
+      end
+
+      it "lists notebook contents recursively with -R" do
+        runner.db.execute("INSERT INTO folders (id, title) 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, updated_time) VALUES ('n1', 'f1', 'Work Note', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('n2', 'f2', 'Project Note', 1718294400000)")
+
+        runner.run_cmd("ls -R")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, ".:"
+        assert_includes out, "Work:"
+        assert_includes out, "Work/Projects:"
+        assert_includes out, "Work Note"
+        assert_includes out, "Project Note"
+        refute_match /[├└]──/, out
+      end
+
+      it "shows all notebooks as an alphabetically sorted flat list with -a" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'work')")
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f2', 'Archive')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f3', 'zeta', 'f1')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f4', 'Alpha', 'f1')")
+
+        runner.run_cmd("ls -a -n")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        expected = ["Alpha", "Archive", "work", "zeta"]
+        expected.each { |title| assert_includes out, title }
+        refute_includes out, "work/Alpha"
+        positions = expected.map { |title| out.index(title) }
+        assert_equal positions.sort, positions
+      end
+
+      it "sorts top-level notebooks case-insensitively" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'zebra')")
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f2', 'Alpha')")
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f3', 'beta')")
+
+        runner.run_cmd("ls -n -l")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        positions = ["Alpha", "beta", "zebra"].map { |title| out.index(title) }
+        assert_equal positions.sort, positions
+      end
+
+      it "shows note counts instead of notebook and tag IDs with -l" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('folder123', 'Work')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title) VALUES ('n1', 'folder123', 'One')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title) VALUES ('n2', 'folder123', 'Two')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('tag123', 'urgent')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'n1', 'tag123')")
+
+        runner.run_cmd("ls -l")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Work [2]"
+        assert_includes out, "urgent [1]"
+        refute_includes out, "folde"
+        refute_includes out, "tag12"
+      end
+
+      it "respects -t and -n" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'Work')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'urgent')")
+        
+        runner.run_cmd("ls -t")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "urgent"
+        refute_includes TestSuite.strip_ansi(runner.last_stdout), "Work"
+
+        runner.run_cmd("ls -n")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Work"
+        refute_includes TestSuite.strip_ansi(runner.last_stdout), "urgent"
+      end
+    end
+
+    describe "settings" do
+      it "is registered as a Thor subcommand" do
+        assert_includes CLI.subcommands, "settings"
+        %w[get list set unset].each { |command| assert_includes Settings.commands, command }
+      end
+
+      it "populates jp.pager during ordinary commands when it is missing" do
+        FileUtils.rm_f(runner.settings_path)
+
+        runner.run_cmd("ls")
+
+        settings = JSON.parse(File.read(runner.settings_path))
+        assert_equal "less -R", settings["jp.pager"]
+        assert_equal false, settings["jp.readOnly"]
+        assert_equal 10, settings["jp.backupKeep"]
+        assert_equal true, settings["jp.backupAuto"]
+        assert_equal 24, settings["jp.backupAutoInterval"]
+      end
+
+      it "adds the default pager to the existing Joplin settings file" do
+        File.write(runner.settings_path, JSON.pretty_generate(
+          "sync.target" => 2,
+          "spellChecker.languages" => ["en-US", "vi-VN"]
+        ))
+
+        runner.run_cmd("settings list")
+
+        settings = JSON.parse(File.read(runner.settings_path))
+        assert_equal 2, settings["sync.target"]
+        assert_equal "less -R", settings["jp.pager"]
+        assert_equal false, settings["jp.readOnly"]
+        assert_equal 10, settings["jp.backupKeep"]
+        assert_equal true, settings["jp.backupAuto"]
+        assert_equal 24, settings["jp.backupAutoInterval"]
+        assert_includes runner.last_stdout, "jp.pager: less -R"
+        assert_includes runner.last_stdout, "jp.readOnly: false"
+        assert_includes runner.last_stdout, "jp.backupKeep: 10"
+        assert_includes runner.last_stdout, "jp.backupAuto: true"
+        assert_includes runner.last_stdout, "jp.backupAutoInterval: 24"
+        assert_includes runner.last_stdout, "sync.target: 2"
+        assert_includes runner.last_stdout, "spellChecker.languages:\n- en-US\n- vi-VN"
+        refute_includes runner.last_stdout, "---"
+        refute_includes runner.last_stdout, "{"
+      end
+
+      it "colorizes YAML settings for terminal output" do
+        output = runner.format_settings({ "jp.pager" => "less -R", "sync.target" => 2 })
+
+        assert_includes output, "jp.pager".cyan
+        assert_includes output, ":".colorize(mode: :dim)
+        assert_includes output, "less -R".green
+        assert_includes output, "2".green
+        assert_equal "jp.pager: less -R\nsync.target: 2\n", TestSuite.strip_ansi(output)
+      end
+
+      it "gets, sets, and unsets settings while preserving value types" do
+        runner.run_cmd(["settings", "set", "jp.pager", "false"])
+        assert_equal false, JSON.parse(File.read(runner.settings_path))["jp.pager"]
+
+        runner.run_cmd("settings get jp.pager")
+        assert_equal "false\n", runner.last_stdout
+
+        runner.run_cmd(["settings", "set", "example.name", "some value"])
+        runner.run_cmd("settings get example.name")
+        assert_equal "some value\n", runner.last_stdout
+
+        runner.run_cmd(["settings", "set", "jp.readOnly", "true"])
+        assert_equal true, JSON.parse(File.read(runner.settings_path))["jp.readOnly"]
+
+        runner.run_cmd(["settings", "set", "jp.backupKeep", "3"])
+        assert_equal 3, JSON.parse(File.read(runner.settings_path))["jp.backupKeep"]
+
+        runner.run_cmd(["settings", "set", "jp.backupAuto", "false"])
+        assert_equal false, JSON.parse(File.read(runner.settings_path))["jp.backupAuto"]
+
+        runner.run_cmd(["settings", "set", "jp.backupAutoInterval", "0"])
+        assert_equal 0, JSON.parse(File.read(runner.settings_path))["jp.backupAutoInterval"]
+
+        runner.run_cmd("settings unset example.name")
+        refute JSON.parse(File.read(runner.settings_path)).key?("example.name")
+      end
+
+      it "allows disabling read-only mode through settings" do
+        runner.run_cmd(["settings", "set", "jp.readOnly", "true"])
+        runner.run_cmd(["settings", "set", "jp.readOnly", "false"])
+
+        assert_equal false, JSON.parse(File.read(runner.settings_path))["jp.readOnly"]
+      end
+
+      it "blocks mutating commands when jp.readOnly is true" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f111111', 'Inbox')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, body, deleted_time) VALUES ('n111111', 'f111111', 'Plan', 'Body', 0)")
+        runner.db.execute("INSERT INTO notes (id, title, deleted_time) VALUES ('n222222', 'Deleted', 1781524800000)")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t111111', 'todo')")
+        runner.run_cmd(["settings", "set", "jp.readOnly", "true"])
+
+        runner.run_cmd(["add", "Inbox", "--title", "New", "Body"], stdin: "", stdin_tty: true)
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Read-only mode is enabled"
+        assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
+
+        runner.run_cmd(["mv", "Inbox", "Archive"])
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Read-only mode is enabled"
+        assert_equal "Inbox", runner.db.get_first_value("SELECT title FROM folders WHERE id = 'f111111'")
+
+        runner.run_cmd(["edit", "n1111"])
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Read-only mode is enabled"
+        assert_equal "Body", runner.db.get_first_value("SELECT body FROM notes WHERE id = 'n111111'")
+
+        runner.run_cmd(["rm", "n1111"])
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Read-only mode is enabled"
+        assert_equal 0, runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'n111111'")
+
+        runner.run_cmd(["journal", "2026-06-17", "blocked"])
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Read-only mode is enabled"
+        assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
+
+        runner.run_cmd(["trash", "restore", "n2222"])
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Read-only mode is enabled"
+        assert_operator runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'n222222'"), :>, 0
+
+        runner.run_cmd(["trash", "empty"], stdin: "yes\n", stdin_tty: true)
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Read-only mode is enabled"
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM notes WHERE deleted_time > 0")
+      end
+
+      it "allows a one-shot read-only override without changing settings" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f111111', 'Inbox')")
+        runner.run_cmd(["settings", "set", "jp.readOnly", "true"])
+
+        runner.run_cmd(["-o", "readonly=false", "add", "Inbox", "--title", "New", "Body"], stdin: "", stdin_tty: true)
+
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Created note"
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
+        assert_equal true, JSON.parse(File.read(runner.settings_path))["jp.readOnly"]
+      end
+
+      it "does not let rm -f bypass read-only mode" do
+        runner.db.execute("INSERT INTO notes (id, title, body, deleted_time) VALUES ('n111111', 'Plan', 'Body', 0)")
+        runner.run_cmd(["settings", "set", "jp.readOnly", "true"])
+
+        runner.run_cmd(["rm", "-f", "n1111"])
+
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Read-only mode is enabled"
+        assert_equal 0, runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'n111111'")
+      end
+
+      it "accepts a one-shot pager override without changing settings" do
+        runner.run_cmd(["-o", "pager=false", "cat", "missing"])
+
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "No note found matching 'missing'"
+        assert_equal "less -R", JSON.parse(File.read(runner.settings_path))["jp.pager"]
+      end
+
+      it "rejects malformed and unsupported one-shot overrides" do
+        assert_raises(Thor::Error) { runner.run_cmd(["-o", "readonly", "ls"]) }
+        assert_raises(Thor::Error) { runner.run_cmd(["-o", "backupAuto=false", "ls"]) }
+        assert_raises(Thor::Error) { runner.run_cmd(["-o", "readonly=maybe", "ls"]) }
+      end
+
+      it "disables paging when jp.pager is false" do
+        runner.run_cmd(["settings", "set", "jp.pager", "false"])
+        long_output = (1..30).map { |n| "line #{n}" }.join("\n")
+
+        refute runner.should_page(long_output, rows: 24)
+      end
+    end
+
+    describe "version" do
+      it "prints only the CLI version" do
+        runner.run_cmd("version")
+
+        assert_equal "#{CLI::VERSION}\n", runner.last_stdout
+      end
+    end
+
+    describe "info" do
+      it "shows paths, version, and active item counts" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'Active')")
+        runner.db.execute("INSERT INTO folders (id, title, deleted_time) VALUES ('f2', 'Deleted', 1)")
+        runner.db.execute("INSERT INTO notes (id, title) VALUES ('n1', 'Active')")
+        runner.db.execute("INSERT INTO notes (id, title, deleted_time) VALUES ('n2', 'Deleted', 1)")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'tag')")
+        backup_epoch = Time.now.to_i - 3600
+        File.write(File.join(runner.dir, "joplin_#{backup_epoch}.sqlite3.gz"), "backup")
+
+        runner.run_cmd("info")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Joplin Utility Version:  #{CLI::VERSION}"
+        assert_includes out, "Database:                #{File.join(runner.dir, 'database.sqlite')}"
+        assert_includes out, "Settings File:           #{runner.settings_path}"
+        assert_includes out, "Statistics:              1 notebook, 1 note, 1 tag"
+        assert_includes out, "Backups:                 1 files"
+        assert_includes out, Time.at(backup_epoch).strftime('%Y-%m-%d %H:%M:%S')
+        assert_includes out, "(1 hours ago)"
+      end
+    end
+
+    describe "bkup" do
+      it "creates a compressed database backup" do
+        runner.db.execute("INSERT INTO notes (id, title, body) VALUES ('n1', 'Backup Note', 'Body')")
+
+        runner.run_cmd("bkup")
+
+        backups = Dir.glob(File.join(runner.dir, "joplin_*.sqlite3.gz"))
+        assert_equal 1, backups.length
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Backup created:"
+        Tempfile.create(["jp_backup_check", ".sqlite3"]) do |file|
+          Zlib::GzipReader.open(backups.first) { |gz| file.write(gz.read) }
+          file.flush
+          copy = SQLite3::Database.new(file.path)
+          assert_equal "Backup Note", copy.get_first_value("SELECT title FROM notes WHERE id = 'n1'")
+          copy.close
+        end
+      end
+
+      it "rotates old backups using jp.backupKeep" do
+        runner.run_cmd(["settings", "set", "jp.backupKeep", "2"])
+        old1 = File.join(runner.dir, "joplin_100.sqlite3.gz")
+        old2 = File.join(runner.dir, "joplin_200.sqlite3.gz")
+        File.write(old1, "old")
+        File.write(old2, "old")
+
+        runner.run_cmd("bkup")
+
+        backups = Dir.glob(File.join(runner.dir, "joplin_*.sqlite3.gz")).map { |path| File.basename(path) }
+        assert_equal 2, backups.length
+        refute_includes backups, "joplin_100.sqlite3.gz"
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Removed 1 old backup"
+      end
+
+      it "auto-backs up after successful writes when the interval has elapsed" do
+        runner.run_cmd(["settings", "set", "jp.backupAutoInterval", "0"])
+
+        runner.run_cmd(["add", "Inbox", "--title", "Auto", "Body"], stdin: "", stdin_tty: true)
+
+        backups = Dir.glob(File.join(runner.dir, "joplin_*.sqlite3.gz"))
+        assert_equal 1, backups.length
+      end
+
+      it "does not auto-back up when jp.backupAuto is false" do
+        runner.run_cmd(["settings", "set", "jp.backupAuto", "false"])
+
+        runner.run_cmd(["add", "Inbox", "--title", "No Auto", "Body"], stdin: "", stdin_tty: true)
+
+        backups = Dir.glob(File.join(runner.dir, "joplin_*.sqlite3.gz"))
+        assert_empty backups
+      end
+
+      it "skips auto-backup while the interval has not elapsed" do
+        existing = File.join(runner.dir, "joplin_#{Time.now.to_i}.sqlite3.gz")
+        File.write(existing, "recent")
+
+        runner.run_cmd(["add", "Inbox", "--title", "Recent", "Body"], stdin: "", stdin_tty: true)
+
+        backups = Dir.glob(File.join(runner.dir, "joplin_*.sqlite3.gz"))
+        assert_equal [existing], backups
+      end
+    end
+
+    describe "ls target" do
+      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)")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('n2', 'f1', 'Old Note', 1718208000000)")
+
+        runner.run_cmd(["ls", "Work", "-d", "2024-06-13"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert_includes out, "Today Note"
+        refute_includes out, "Old Note"
+      end
+
+      it "filters tagged notes by date" do
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('tag1', 'todo')")
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n1', 'Today Note', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n2', 'Old Note', 1718208000000)")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'n1', 'tag1')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt2', 'n2', 'tag1')")
+
+        runner.run_cmd(["ls", "todo", "-d", "2024-06-13"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert_includes out, "Today Note"
+        refute_includes out, "Old Note"
+      end
+
+      it "filters long note counts by date" do
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f1', 'Work', '')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('tag1', 'todo')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('n1', 'f1', 'Today Note', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('n2', 'f1', 'Old Note', 1718208000000)")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'n1', 'tag1')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt2', 'n2', 'tag1')")
+
+        runner.run_cmd(["ls", "-l", "-d", "2024-06-13"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert_includes out, "Work [1]"
+        assert_includes out, "todo [1]"
+      end
+
+      it "recursively lists only the targeted notebook subtree with -R" do
+        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', 'Personal', '')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('n1', 'f2', 'Plan', 1718294400000)")
+
+        runner.run_cmd("ls Work -R")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Work:"
+        assert_includes out, "Work/Projects:"
+        assert_includes out, "Plan"
+        refute_includes out, "Personal"
+      end
+
+      it "lists notes for a notebook with ID first" do
+        nb_id = 'nb123456789012345678901234567890'
+        n_id = 'n123456789012345678901234567890'
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('#{nb_id}', 'Journal')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('#{n_id}', '#{nb_id}', 'E1', 1718294400000)")
+        runner.run_cmd("ls Journal")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Notes:"
+        assert_match /^n1234 /, out.split("\n").last.strip
+        assert_includes out, "E1"
+      end
+
+      it "resolves notebook paths like Journal/2026" do
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('p1', 'Journal', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('c1', '2026', 'p1')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('n1', 'c1', 'Deep Note', 1718294400000)")
+        runner.run_cmd("ls Journal/2026")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Notebook: Journal/2026:"
+        assert_includes out, "Notes:"
+        assert_includes out, "Deep Note"
+      end
+
+      it "handles multiple notebooks with the same name" do
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('p1', 'Work', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('p2', 'Home', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('c1', '2025', 'p1')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('c2', '2025', 'p2')")
+        runner.run_cmd("ls 2025")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Notebook: Work/2025:"
+        assert_includes out, "Notebook: Home/2025:"
+      end
+
+      it "supports long format -l to show notebook note counts" do
+        id = 'f1234567890123456789012345678901'
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('#{id}', 'Work')")
+        runner.run_cmd("ls -l")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Work [0]"
+        refute_includes out, "f1234"
+      end
+
+      it "targets notebooks and tags by short ID without prefixes" do
+        id = 'abcde123456789012345678901234567'
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('#{id}', 'Target')")
+        runner.run_cmd("ls abcde")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Notebook: Target:"
+      end
+
+      it "lists notes for a tag" do
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('tag1', 'todo')")
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n1', 'T1', 1718294400000)")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'n1', 'tag1')")
+        runner.run_cmd("ls todo")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Notes tagged with 'todo'"
+        assert_includes out, "T1"
+      end
+
+      it "handles collisions and prefixes" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'Health')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, updated_time) VALUES ('n1', 'f1', 'Note in folder', 1718294400000)")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'Health')")
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n2', 'Note with tag', 1718294400000)")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'n2', 't1')")
+        
+        runner.run_cmd("ls Health")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Notebook: Health:"
+        assert_includes out, "Notes:"
+        assert_includes out, "Note in folder"
+        assert_includes out, "Notes tagged with 'Health'"
+        assert_includes out, "Note with tag"
+
+        runner.run_cmd("ls n:Health")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Notebook: Health:"
+        assert_includes out, "Notes:"
+        refute_includes out, "Notes tagged with 'Health'"
+
+        runner.run_cmd("ls t:Health")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Notes tagged with 'Health'"
+        refute_includes out, "Notebook: Health:"
+      end
+
+      it "shows notebook and tag IDs in targeted long output" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f123456', 'Health')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t123456', 'Health')")
+
+        runner.run_cmd("ls Health -l")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Notebook: Health (f1234):"
+        assert_includes out, "Notes tagged with 'Health' (t1234):"
+      end
+
+      it "shows notebook structure/path when targeting a note id" do
+        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, updated_time) VALUES ('e1234', 'f2', 'My Project Note', 1718294400000)")
+        
+        runner.run_cmd("ls e1234")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Note: Work/Projects/My Project Note"
+      end
+    end
+
+    describe "mv" do
+      it "renames a uniquely named notebook or tag" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('a111111', 'Work')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('b111111', 'urgent')")
+
+        runner.run_cmd(["mv", "Work", "Office"])
+        runner.run_cmd(["mv", "urgent", "important"])
+
+        assert_equal "Office", runner.db.get_first_value("SELECT title FROM folders WHERE id = 'a111111'")
+        assert_equal "important", runner.db.get_first_value("SELECT title FROM tags WHERE id = 'b111111'")
+      end
+
+      it "requires a UUID when notebook names collide at different levels" do
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('a111111', 'Work', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('b111111', 'Home', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('c111111', 'Archive', 'a111111')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('d111111', 'Archive', 'b111111')")
+
+        runner.run_cmd(["mv", "Archive", "Old"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Ambiguous source 'Archive'"
+        assert_includes out, "c1111"
+        assert_includes out, "d1111"
+        assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM folders WHERE title = 'Archive'")
+
+        runner.run_cmd(["mv", "c1111", "Old"])
+        assert_equal "Old", runner.db.get_first_value("SELECT title FROM folders WHERE id = 'c111111'")
+      end
+
+      it "requires a UUID when a notebook and tag share a name" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('a222222', 'Health')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('b222222', 'Health')")
+
+        runner.run_cmd(["mv", "Health", "Wellness"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Ambiguous source 'Health'"
+        assert_includes out, "a2222 Notebook Health"
+        assert_includes out, "b2222 Tag Health"
+
+        runner.run_cmd(["mv", "b2222", "Wellness"])
+        assert_equal "Health", runner.db.get_first_value("SELECT title FROM folders WHERE id = 'a222222'")
+        assert_equal "Wellness", runner.db.get_first_value("SELECT title FROM tags WHERE id = 'b222222'")
+      end
+    end
+
+    describe "rm" do
+      it "requires -r for notebooks and tags, even when empty" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('a111111', 'EmptyNotebook')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('b111111', 'empty-tag')")
+
+        runner.run_cmd(["rm", "EmptyNotebook"], stdin: "", stdin_tty: true)
+        runner.run_cmd(["rm", "empty-tag"], stdin: "", stdin_tty: true)
+
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "use -r"
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM tags")
+
+        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 0, runner.db.get_first_value("SELECT COUNT(*) FROM tags")
+      end
+
+      it "moves a specific note to Trash without -r" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'Work')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title) VALUES ('n111111', 'f1', 'Plan')")
+
+        runner.run_cmd(["rm", "Work/Plan"])
+
+        assert_operator runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'n111111'"), :>, 0
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
+      end
+
+      it "prompts before trashing notebook notes and honors rejection" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('a222222', 'Work')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title) VALUES ('n1', 'a222222', 'Plan')")
+
+        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_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
+
+      it "trashes notes in a notebook subtree after confirmation" do
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('a333333', 'Work', '')")
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('b333333', 'Projects', 'a333333')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title) VALUES ('n1', 'a333333', 'Root Note')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title) VALUES ('n2', 'b333333', 'Child Note')")
+
+        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 notes WHERE deleted_time > 0")
+      end
+
+      it "force-removes a tag and trashes its active notes" do
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('a444444', 'obsolete')")
+        runner.db.execute("INSERT INTO notes (id, title) VALUES ('n1', 'Tagged')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'n1', 'a444444')")
+
+        runner.run_cmd(["rm", "obsolete", "-rf"])
+
+        assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM tags")
+        assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM note_tags")
+        assert_operator runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'n1'"), :>, 0
+      end
+
+      it "requires a UUID for ambiguous notebook and tag names" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('a555555', 'Archive')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('b555555', 'Archive')")
+
+        runner.run_cmd(["rm", "Archive", "-rf"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Ambiguous target 'Archive'"
+        assert_includes out, "a5555 Notebook Archive"
+        assert_includes out, "b5555 Tag Archive"
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM folders")
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM tags")
+      end
+
+      it "requires a UUID when a note collides with a notebook or tag name" do
+        runner.db.execute("INSERT INTO notes (id, title) VALUES ('e666666', 'Health')")
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f666666', 'Health')")
+
+        runner.run_cmd(["rm", "Health", "-rf"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "e6666 Note Health"
+        assert_includes out, "f6666 Notebook Health"
+        assert_equal 0, runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'e666666'")
+
+        runner.run_cmd(["rm", "e6666"])
+        assert_operator runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'e666666'"), :>, 0
+      end
+    end
+
+    describe "trash" do
+      it "is registered as a Thor subcommand" do
+        assert_includes CLI.subcommands, "trash"
+        %w[empty ls restore].each { |command| assert_includes Trash.commands, command }
+      end
+
+      it "lists trashed notes" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f1', 'Work')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, deleted_time) VALUES ('e111111', 'f1', 'Deleted Plan', 1781524800000)")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, deleted_time) VALUES ('e222222', 'f1', 'Active Plan', 0)")
+
+        runner.run_cmd("trash ls")
+
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "e1111"
+        assert_includes out, "Work/Deleted Plan"
+        refute_includes out, "Active Plan"
+      end
+
+      it "restores a trashed note by UUID" do
+        runner.db.execute("INSERT INTO notes (id, title, deleted_time) VALUES ('e333333', 'Restore Me', 1781524800000)")
+
+        runner.run_cmd(["trash", "restore", "e3333"])
+
+        assert_equal 0, runner.db.get_first_value("SELECT deleted_time FROM notes WHERE id = 'e333333'")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Restored note 'Restore Me'"
+      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)")
+
+        runner.run_cmd(["trash", "restore", "e4444"])
+
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Ambiguous trashed note"
+        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")
+      end
+
+      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.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")
+
+        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'")
+      end
+    end
+
+    describe "add" do
+      it "creates nested notebooks, a note, and merged tags" do
+        runner.run_cmd(["add", "Work/Projects", "--title", "Plan", "-T", "work,urgent", "-T", "urgent", "Initial", "body"], stdin: "", stdin_tty: true)
+
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Created note Work/Projects/Plan"
+        folders = runner.db.execute("SELECT id, title, parent_id FROM folders ORDER BY rowid")
+        assert_equal ["Work", "Projects"], folders.map { |folder| folder['title'] }
+        note = runner.db.get_first_row("SELECT * FROM notes WHERE title = 'Plan'")
+        assert_equal "Initial body", note['body']
+        assert_equal folders.first['id'], folders.last['parent_id']
+        tags = runner.db.execute("SELECT title FROM tags ORDER BY title").map { |tag| tag['title'] }
+        assert_equal ["urgent", "work"], tags
+        assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM note_tags WHERE note_id = ?", [note['id']])
+      end
+
+      it "reads stdin and derives the title from the first non-empty heading" do
+        body = "\n# Derived Title\n\nContent\n"
+        runner.run_cmd(["add", "Inbox"], stdin: body)
+
+        note = runner.db.get_first_row("SELECT * FROM notes")
+        assert_equal "Derived Title", note['title']
+        assert_equal body, note['body']
+      end
+
+      it "rejects positional body combined with stdin" do
+        runner.run_cmd(["add", "Inbox", "body"], stdin: "piped body")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "body cannot be supplied both"
+        assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
+      end
+
+      it "allows duplicate note titles" do
+        2.times do
+          runner.run_cmd(["add", "Inbox", "--title", "Same", "Body"], stdin: "", stdin_tty: true)
+        end
+        assert_equal 2, runner.db.get_first_value("SELECT COUNT(*) FROM notes WHERE title = 'Same'")
+      end
+
+      it "opens a Joplin-style text editor when title and body are absent" do
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'File.write(ARGV[0], \"Editor Note\\nignored separator\\nEditor body\\nsecond line\")'"
+        begin
+          runner.run_cmd(["add", "Journal/2026", "-T", "daily"], stdin: "", stdin_tty: true)
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+
+        note = runner.db.get_first_row("SELECT * FROM notes")
+        assert_equal "Editor Note", note['title']
+        assert_equal "Editor body\nsecond line", note['body']
+        assert_equal "Journal/2026/Editor Note", runner.cli.send(:get_full_path_for_note, note)
+        assert_equal ["daily"], runner.db.execute("SELECT title FROM tags").map { |tag| tag['title'] }
+      end
+
+      it "starts the add editor with title and body positions" do
+        captured = File.join(runner.dir, 'add_editor_input')
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'File.write(\"#{captured}\", File.read(ARGV[0])); File.write(ARGV[0], \"Title\\n\\nBody\")'"
+        begin
+          runner.run_cmd(["add", "Inbox"], stdin: "", stdin_tty: true)
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+
+        assert_equal "\n\n", File.read(captured)
+      end
+
+      it "rejects empty piped input instead of opening an editor" do
+        runner.run_cmd(["add", "Inbox"], stdin: "")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Empty stdin"
+        assert_equal 0, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
+      end
+
+      it "cancels cleanly when the editor fails" do
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = 'false'
+        begin
+          runner.run_cmd(["add", "Inbox"], stdin: "", stdin_tty: true)
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Add cancelled."
+        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 "rolls back notebook creation if note insertion fails" do
+        runner.db.execute(<<~SQL)
+          CREATE TRIGGER reject_note BEFORE INSERT ON notes
+          BEGIN
+            SELECT RAISE(ABORT, 'forced note failure');
+          END;
+        SQL
+
+        runner.run_cmd(["add", "New/Nested", "--title", "Plan", "Body"], stdin: "", stdin_tty: true)
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Could not create note"
+        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
+    end
+
+    describe "journal" do
+      it "creates the journal hierarchy and note for a date" do
+        runner.run_cmd(["journal", "2026-06-17", "first", "entry"])
+
+        note = runner.db.get_first_row("SELECT * FROM notes")
+        assert_equal "2026-06-17", note["title"]
+        assert_equal "first entry", note["body"]
+        assert_equal "Journal/2026/06-Jun/2026-06-17", runner.cli.send(:get_full_path_for_note, note)
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Updated journal Journal/2026/06-Jun/2026-06-17"
+      end
+
+      it "aliases j to journal" do
+        runner.run_cmd(["j", "2026-06-17", "short", "entry"])
+
+        note = runner.db.get_first_row("SELECT * FROM notes")
+        assert_equal "2026-06-17", note["title"]
+        assert_equal "short entry", note["body"]
+      end
+
+      it "appends text to an existing journal note" do
+        runner.run_cmd(["journal", "2026-06-17", "first"])
+        runner.run_cmd(["journal", "2026-06-17", "second"])
+
+        assert_equal 1, runner.db.get_first_value("SELECT COUNT(*) FROM notes")
+        assert_equal "first\n\nsecond", runner.db.get_first_value("SELECT body FROM notes")
+      end
+
+      it "defaults to today when no date token is provided" do
+        runner.run_cmd(["journal", "plain", "text"])
+
+        today = Date.today
+        note = runner.db.get_first_row("SELECT * FROM notes")
+        assert_equal today.strftime("%Y-%m-%d"), note["title"]
+        assert_equal "plain text", note["body"]
+        assert_equal "Journal/#{today.strftime('%Y')}/#{today.strftime('%m-%b')}/#{today.strftime('%Y-%m-%d')}", runner.cli.send(:get_full_path_for_note, note)
+      end
+
+      it "opens an editor when text is empty" do
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'File.write(ARGV[0], \"editor body\")'"
+        begin
+          runner.run_cmd(["journal", "2026-06-17"], stdin: "", stdin_tty: true)
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+
+        assert_equal "editor body", runner.db.get_first_value("SELECT body FROM notes")
+      end
+
+      it "opens the existing journal body when editing without text" do
+        runner.run_cmd(["journal", "2026-06-17", "existing body"])
+        captured = File.join(runner.dir, "journal_editor_input")
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'File.write(\"#{captured}\", File.read(ARGV[0])); File.write(ARGV[0], \"existing body\\nnew line\")'"
+        begin
+          runner.run_cmd(["journal", "2026-06-17"], stdin: "", stdin_tty: true)
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+
+        assert_equal "existing body", File.read(captured)
+        assert_equal "existing body\nnew line", runner.db.get_first_value("SELECT body FROM notes")
+      end
+    end
+
+    describe "cat" do
+      it "displays note body" do
+        id = 'e1234567890123456789012345678901'
+        body = "# Header\nContent"
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('#{id}', 'Note', ?, 1718294400000)", [body])
+        
+        runner.run_cmd("cat e1234")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Note"
+        assert_includes out, "Header"
+        assert_includes out, "Content"
+      end
+
+      it "displays multiple note targets in order" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1111', 'First', 'first body', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e2222', 'Second', 'second body', 1718294400000)")
+
+        runner.run_cmd(["cat", "e1111", "e2222"])
+        out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert_operator out.index("First"), :<, out.index("Second")
+        assert_includes out, "first body"
+        assert_includes out, "second body"
+        assert_match(/first body\s*\n\nSecond/, out)
+      end
+
+      it "reads note targets from stdin when none are provided" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1111', 'First', 'first body', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e2222', 'Second', 'second body', 1718294400000)")
+
+        runner.run_cmd(["cat"], stdin: "e1111\ne2222\n")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert_operator out.index("First"), :<, out.index("Second")
+        assert_includes out, "first body"
+        assert_includes out, "second body"
+      end
+
+      it "resolves notes by path" do
+        runner.db.execute("INSERT INTO folders (id, title, parent_id) VALUES ('f1', 'Work', '')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, body, updated_time) VALUES ('n1', 'f1', 'Task', 'Done', 1718294400000)")
+        runner.run_cmd("cat Work/Task")
+        assert_includes runner.last_stdout, "Done"
+      end
+
+      it "handles ambiguous note titles" do
+        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', 'Home', '')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, body) VALUES ('n1', 'f1', 'Todo', 'Work task')")
+        runner.db.execute("INSERT INTO notes (id, parent_id, title, body) VALUES ('n2', 'f2', 'Todo', 'Home task')")
+        
+        runner.run_cmd("cat Todo")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Ambiguous target: 'Todo' matches multiple notes"
+        assert_includes out, "Work/Todo"
+        assert_includes out, "Home/Todo"
+      end
+
+      it "renders around malformed markdown link definitions" do
+        body = "# Heading\n\n1. text ^[trust]\n\n[trust]: referring to sweden when talking about it recently @2024.06.17"
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'Issues', ?, 1718294400000)", [body])
+
+        runner.run_cmd("cat e1")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Heading"
+        refute_includes out, "# Heading"
+        assert_includes out, "1. text ^[trust]"
+        assert_includes out, "[trust]: referring to sweden when talking about it recently @2024.06.17"
+      end
+
+      it "supports raw output" do
+        body = "# Heading\n\n**bold**"
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'Raw Note', ?, 1718294400000)", [body])
+
+        runner.run_cmd("cat e1 -r")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_equal "#{body}\n", out
+        refute_includes out, "Raw Note"
+        refute_includes out, "e1"
+      end
+
+      it "prints multiple raw note bodies separated by a blank line" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1111', 'First', 'one', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e2222', 'Second', 'two', 1718294400000)")
+
+        runner.run_cmd(["cat", "e1111", "e2222", "-r"])
+
+        assert_equal "one\n\ntwo\n", TestSuite.strip_ansi(runner.last_stdout)
+      end
+
+      it "splits single-line stdin targets on whitespace" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1111', 'First', 'one', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e2222', 'Second', 'two', 1718294400000)")
+
+        runner.run_cmd(["cat", "-r"], stdin: "e1111 e2222\n")
+
+        assert_equal "one\n\ntwo\n", TestSuite.strip_ansi(runner.last_stdout)
+      end
+
+      it "pages only long interactive rendered output" do
+        long_output = (1..30).map { |n| "line #{n}" }.join("\n")
+        assert runner.should_page(long_output, rows: 24)
+        refute runner.should_page("short", rows: 24)
+        refute runner.should_page(long_output, raw: true, rows: 24)
+        refute runner.should_page(long_output, no_pager: true, rows: 24)
+        refute runner.should_page(long_output, tty: false, rows: 24)
+      end
+
+      it "accounts for wrapped terminal lines when deciding to page" do
+        assert runner.should_page("a" * 81, rows: 1, columns: 80)
+      end
+
+      it "renders Joplin resource links" do
+        body = "# Attachment\n\n[document](:/64de182c41ee454ebcd9d5733346d5db)"
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'Resource Note', ?, 1718294400000)", [body])
+
+        runner.run_cmd("cat e1")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Attachment"
+        assert_includes out, "document"
+      end
+
+      it "shows existing metadata in verbose mode" do
+        created_time = Time.local(2024, 6, 12, 19, 0).to_i * 1000
+        updated_time = Time.local(2024, 6, 13, 19, 0).to_i * 1000
+        runner.db.execute(<<~SQL, [created_time, updated_time])
+          INSERT INTO notes (id, title, body, created_time, updated_time, latitude, longitude, source_url)
+          VALUES ('e1', 'Metadata Note', 'Body', ?, ?, 10.7769, 106.7009, 'https://example.com/source')
+        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', 'e1', 't1')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt2', 'e1', 't2')")
+
+        runner.run_cmd("cat e1 -v")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Created: 2024-06-12 19:00"
+        assert_includes out, "Updated: 2024-06-13 19:00"
+        assert_includes out, "Location: 10.7769, 106.7009"
+        assert_includes out, "https://www.google.com/maps?q=10.7769,106.7009"
+        assert_includes out, "URL: https://example.com/source"
+        assert_includes out, "Tags: Urgent, work"
+      end
+
+      it "omits missing metadata in verbose mode" do
+        runner.db.execute("INSERT INTO notes (id, title, body) VALUES ('e1', 'Plain Note', 'Body')")
+
+        runner.run_cmd("cat e1 -v")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        refute_includes out, "Created:"
+        refute_includes out, "Updated:"
+        refute_includes out, "Location:"
+        refute_includes out, "URL:"
+        refute_includes out, "Tags:"
+      end
+
+      it "expands Joplin table of contents markers" do
+        body = <<~'MARKDOWN'
+          # Overview
+
+          [toc]
+
+          ## First Section
+
+          ### Details
+
+          ## Second Section
+        MARKDOWN
+
+        expanded = runner.expand_toc(body)
+        assert_includes expanded, "- Overview"
+        assert_includes expanded, "  - First Section"
+        assert_includes expanded, "    - Details"
+        assert_includes expanded, "  - Second Section"
+        refute_includes expanded, "[toc]"
+      end
+
+      it "supports every Joplin table of contents marker" do
+        ['${toc}', '[[toc]]', '[toc]', '[[_toc_]]'].each do |marker|
+          expanded = runner.expand_toc("#{marker}\n\n# Heading\n")
+          assert_includes expanded, "- Heading"
+          refute_includes expanded, marker
+        end
+      end
+
+      it "ignores headings inside fenced code when building a table of contents" do
+        body = "[toc]\n\n# Real\n\n```markdown\n# Not A Heading\n```\n"
+        expanded = runner.expand_toc(body)
+        assert_includes expanded, "- Real"
+        refute_includes expanded, "- Not A Heading"
+      end
+
+      it "uses Kramdown heading parsing for Setext and inline formatting" do
+        body = "[toc]\n\nMain *Title*\n============\n\n## Child `Code`\n"
+        expanded = runner.expand_toc(body)
+        assert_includes expanded, "- Main Title"
+        assert_includes expanded, "  - Child Code"
+      end
+    end
+
+    describe "random" do
+      it "displays a random non-deleted note" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'Random Note', '# Random Body', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time, deleted_time) VALUES ('e2', 'Deleted Note', 'Hidden', 1718294400000, 1)")
+
+        runner.run_cmd("random")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Random Note"
+        assert_includes out, "Random Body"
+        refute_includes out, "Deleted Note"
+      end
+
+      it "reports when there are no notes" do
+        runner.run_cmd("random")
+        assert_includes runner.last_stdout, "No notes found."
+      end
+    end
+
+    describe "search" do
+      it "searches notes for keywords" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('n1', 'Meeting', 'Plan for project', 1718294400000)")
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('n2', 'Shopping', 'Buy milk', 1718294400000)")
+        
+        runner.run_cmd("search Plan")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Meeting"
+        refute_includes out, "Shopping"
+      end
+
+      it "shows snippets in verbose mode" do
+        long_body = "A" * 50 + "keyword" + "B" * 50
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('n1', 'Note', ?, 1718294400000)", [long_body])
+        runner.run_cmd("search keyword -v")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Note"
+        assert_includes out, "..."
+        assert_includes out, "keyword"
+      end
+    end
+
+    describe "init" do
+      it "is registered as a Thor subcommand" do
+        assert_includes CLI.subcommands, "init"
+        assert_includes Init.commands, "fish"
+        refute_includes Init.commands, "bash"
+      end
+
+      it "prints fish completion setup" do
+        runner.run_cmd("init fish")
+        out = runner.last_stdout
+        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, "jp init fish"
+      end
+
+      it "provides machine-readable dynamic completions" do
+        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) VALUES ('n12345', 'f2', 'Plan')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'urgent')")
+
+        runner.run_cmd("__complete targets")
+        out = runner.last_stdout
+        assert_includes out, "Work/Projects\tNotebook"
+        assert_includes out, "urgent\tTag"
+        assert_includes out, "n1234\tNote Work/Projects/Plan"
+
+        runner.run_cmd("__complete notes")
+        assert_includes runner.last_stdout, "Work/Projects/Plan\tNote n1234"
+
+        runner.run_cmd("__complete tags")
+        assert_equal "urgent\tTag\n", runner.last_stdout
+      end
+
+      it "uses UUIDs for ambiguous mv completion candidates" do
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('a111111', 'Health')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('b111111', 'Health')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('c111111', 'unique')")
+
+        runner.run_cmd("__complete movable")
+        out = runner.last_stdout
+        assert_includes out, "a1111\tNotebook Health"
+        assert_includes out, "b1111\tTag Health"
+        assert_includes out, "unique\tTag"
+        refute_match /^Health\t/, out
+      end
+
+      it "includes notes and uses UUIDs for ambiguous rm completion candidates" do
+        runner.db.execute("INSERT INTO notes (id, title) VALUES ('e222222', 'Health')")
+        runner.db.execute("INSERT INTO folders (id, title) VALUES ('f222222', 'Health')")
+        runner.db.execute("INSERT INTO notes (id, title) VALUES ('e333333', 'Unique Note')")
+
+        runner.run_cmd("__complete removable")
+        out = runner.last_stdout
+        assert_includes out, "e2222\tNote Health"
+        assert_includes out, "f2222\tNotebook Health"
+        assert_includes out, "Unique Note\tNote"
+      end
+    end
+
+    describe "help" do
+      it "colorizes the command listing" do
+        runner.run_cmd("help")
+        out = runner.last_stdout
+        plain = TestSuite.strip_ansi(out)
+
+        assert_includes plain, "Joplin Utility (v#{CLI::VERSION})"
+        assert_includes plain, "Usage:"
+        assert_includes plain, "jp ls [TARGET]"
+        assert_includes plain, "jp journal [today|yesterday|YYYY-MM-DD] [TEXT...]"
+        assert_includes out, "ls".green.bold
+        refute_includes plain, "__complete"
+      end
+
+      it "marks the completion command as hidden from Thor suggestions" do
+        assert CLI.all_commands.fetch("__complete").hidden?
+      end
+
+      it "shows nested subcommand children in the command tree" do
+        runner.run_cmd("tree")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_match /settings.*list/m, out
+        assert_match /settings.*get/m, out
+        assert_match /settings.*set/m, out
+        assert_match /settings.*unset/m, out
+        assert_match /init.*fish/m, out
+        assert_match /trash.*ls/m, out
+        assert_match /trash.*restore/m, out
+        assert_match /trash.*empty/m, out
+      end
+    end
+
+    describe "configuration" do
+      it "builds the default data dir from HOME" do
+        assert_equal File.join(ENV.fetch('HOME'), '.config', 'joplin'), CLI::DEFAULT_JOPLIN_DATA_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
+      end
+    end
+
+    describe "cal" do
+      it "shows calendar and highlights note updated_time date" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('n1', 'N1', 'B1', 1781524800000)")
+        
+        runner.run_cmd("cal 2026-06")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "June 2026"
+        assert_match /\b15\b/, out
+      end
+
+      it "filters calendar highlights by tag" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('n1', 'N1', 'B1', 1781524800000)")
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('n2', 'N2', 'B2', 1781611200000)")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'tagA')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t2', 'tagB')")
+        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', 'n2', 't2')")
+
+        runner.run_cmd("cal 2026-06 -i tagA")
+        out = runner.last_stdout
+        assert_includes out, "15".bold.yellow
+        refute_includes out, "16".bold.yellow
+
+        runner.run_cmd("cal 2026-06 -x tagA")
+        out = runner.last_stdout
+        refute_includes out, "15".bold.yellow
+        assert_includes out, "16".bold.yellow
+      end
+    end
+
+    describe "edit" do
+      it "edits a note title and body using Joplin's text layout" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'original title', 'original content', 1781524800000)")
+        
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'File.write(ARGV[0], \"updated title\\nignored separator\\nupdated content\\nsecond body line\")'"
+        begin
+          runner.run_cmd("edit e1")
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+        
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Updated note 'updated title'"
+        note = runner.db.get_first_row("SELECT title, body FROM notes WHERE id = 'e1'")
+        assert_equal "updated title", note['title']
+        assert_equal "updated content\nsecond body line", note['body']
+      end
+
+      it "writes title, blank separator, and body to the editor" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'Title', 'Body', 1781524800000)")
+        captured = File.join(runner.dir, 'editor_input')
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'File.write(\"#{captured}\", File.read(ARGV[0]))'"
+        begin
+          runner.run_cmd("edit e1")
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+
+        assert_equal "Title\n\nBody", File.read(captured)
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "No changes made."
+      end
+
+      it "updates content and tags via YAML edit" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'original title', 'original content', 1781524800000)")
+        
+        res = runner.prepare_yaml('e1')
+        assert res
+        init = res[0]
+        newd = Marshal.load(Marshal.dump(init))
+        newd[0]['body'] = 'content v2'
+        newd[0]['tags'] = ['mod_tag']
+        
+        runner.apply_yaml(init, newd)
+        
+        runner.run_cmd("cat e1")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "content v2"
+        
+        rows = runner.db.execute("SELECT t.title FROM tags t JOIN note_tags nt ON t.id = nt.tag_id WHERE nt.note_id = 'e1'")
+        assert_equal ['mod_tag'], rows.map { |r| r['title'] }
+      end
+
+      it "creates new tags through the edit -y command" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'new note', 'body', 1781524800000)")
+
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'require \"yaml\"; p=ARGV[0]; d=YAML.load_file(p); d[0][\"tags\"]=[\"new_tag\", \" second_tag \"]; File.write(p,d.to_yaml)'"
+        begin
+          runner.run_cmd("edit e1 -y")
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+
+        tags = runner.db.execute(<<~SQL).map { |row| row['title'] }
+          SELECT t.title FROM tags t
+          JOIN note_tags nt ON t.id = nt.tag_id
+          WHERE nt.note_id = 'e1'
+          ORDER BY t.title
+        SQL
+        assert_equal ['new_tag', 'second_tag'], tags
+      end
+
+      it "edits a tag stack via 'edit -y'" do
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e1', 'entry 1', 'body 1', 1781524800000)")
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('e2', 'entry 2', 'body 2', 1781611200000)")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'stack_test')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'e1', 't1')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt2', 'e2', 't1')")
+        
+        old_editor = ENV['EDITOR']
+        ENV['EDITOR'] = "ruby -e 'require \"yaml\"; data = YAML.load_file(ARGV[0]); data[0][\"body\"] = \"modified 1\"; data[1][\"body\"] = \"modified 2\"; File.write(ARGV[0], data.to_yaml)'"
+        begin
+          runner.run_cmd("edit stack_test -y")
+        ensure
+          ENV['EDITOR'] = old_editor
+        end
+        
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "Updated stack for tag 'stack_test'"
+        runner.run_cmd("cat e1")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "modified 1"
+        runner.run_cmd("cat e2")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "modified 2"
+      end
+    end
+
+    describe "log" do
+      it "lists entries chronologically using 'log'" do
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n123456', 'log entry 1', 1781524800000)")
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n234567', 'log entry 2', 1781611200000)")
+        
+        runner.run_cmd("log 2026-06")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "n1234"
+        assert_includes out, "n2345"
+        assert_includes out, "log entry 1"
+        assert_includes out, "log entry 2"
+      end
+
+      it "shows blue notebook names and bracketed green tags before titles with -l" do
+        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, updated_time) VALUES ('n123456', 'f2', 'Plan', 1781524800000)")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'urgent')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'n123456', 't1')")
+
+        runner.run_cmd("log 2026-06 -l")
+        out = runner.last_stdout
+        assert_includes out, "Projects".blue
+        assert_includes out, "[#{'urgent'.green}]"
+        plain = TestSuite.strip_ansi(out)
+        refute_includes plain, "Work/Projects"
+        assert_match /n1234 .* Projects \[urgent\] Plan/, plain
+      end
+
+      it "supports index and range selection in log" do
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n1', 'entry 1', 1781524800000)")
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n2', 'entry 2', 1781611200000)")
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n3', 'entry 3', 1781697600000)")
+
+        # Test single index
+        runner.run_cmd("log [-1]")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "entry 3"
+        refute_includes out, "entry 2"
+
+        # Test range
+        runner.run_cmd("log [-2..-1]")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "entry 2"
+        assert_includes out, "entry 3"
+        refute_includes out, "entry 1"
+      end
+
+      it "excludes entries with specific tags in log" do
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n1', 'content to keep', 1781524800000)")
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('n2', 'content to hide', 1781611200000)")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'keep')")
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t2', 'hide')")
+        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', 'n2', 't2')")
+
+        runner.run_cmd("log")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "content to keep"
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "content to hide"
+
+        runner.run_cmd("log -x hide")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "content to keep"
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        refute_includes out, "content to hide"
+      end
+
+
+      it "treats last1week the same as last7days" do
+        inside = (Date.today - 6).to_time.to_i * 1000
+        outside = (Date.today - 7).to_time.to_i * 1000
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('a1', 'inside range', ?)", [inside])
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('a2', 'outside range', ?)", [outside])
+
+        runner.run_cmd("log last7days")
+        days_out = TestSuite.strip_ansi(runner.last_stdout)
+        runner.run_cmd("log last1week")
+        week_out = TestSuite.strip_ansi(runner.last_stdout)
+
+        assert_equal days_out, week_out
+        assert_includes week_out, "inside range"
+        refute_includes week_out, "outside range"
+      end
+
+      it "supports rolling multi-week ranges" do
+        inside = (Date.today - 13).to_time.to_i * 1000
+        outside = (Date.today - 14).to_time.to_i * 1000
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('a1', 'inside two weeks', ?)", [inside])
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('a2', 'outside two weeks', ?)", [outside])
+
+        runner.run_cmd("log last2weeks")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "inside two weeks"
+        refute_includes out, "outside two weeks"
+      end
+
+      it "supports rolling month ranges" do
+        anchor = Date.today << 1
+        inside = anchor.to_time.to_i * 1000
+        outside = (anchor - 1).to_time.to_i * 1000
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('a1', 'inside month', ?)", [inside])
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('a2', 'outside month', ?)", [outside])
+
+        runner.run_cmd("log last1month")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "inside month"
+        refute_includes out, "outside month"
+      end
+
+      it "supports rolling year ranges" do
+        anchor = Date.today << 12
+        inside = anchor.to_time.to_i * 1000
+        outside = (anchor - 1).to_time.to_i * 1000
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('a1', 'inside year', ?)", [inside])
+        runner.db.execute("INSERT INTO notes (id, title, updated_time) VALUES ('a2', 'outside year', ?)", [outside])
+
+        runner.run_cmd("log last1year")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "inside year"
+        refute_includes out, "outside year"
+      end
+    end
+
+    describe "flashback" do
+      it "shows notes from the same day in previous years" do
+        target = Date.new(2026, 6, 15)
+        one_year_ago = Time.local(2025, 6, 15, 10, 0).to_i * 1000
+        two_years_ago = Time.local(2024, 6, 15, 11, 0).to_i * 1000
+        other_day = Time.local(2025, 6, 14, 10, 0).to_i * 1000
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('a1', 'One Year', 'memory one', ?)", [one_year_ago])
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('a2', 'Two Years', 'memory two', ?)", [two_years_ago])
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('a3', 'Other Day', 'not a flashback', ?)", [other_day])
+
+        runner.run_cmd("flashback #{target}")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Flashbacks for June 15:"
+        assert_includes out, "1 Year Ago"
+        assert_includes out, "One Year"
+        assert_includes out, "2 Years Ago"
+        assert_includes out, "Two Years"
+        refute_includes out, "Other Day"
+      end
+
+      it "supports verbose output and tag exclusion" do
+        timestamp = Time.local(2025, 6, 15, 10, 0).to_i * 1000
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('a1', 'Visible', 'visible body', ?)", [timestamp])
+        runner.db.execute("INSERT INTO notes (id, title, body, updated_time) VALUES ('a2', 'Hidden', 'hidden body', ?)", [timestamp])
+        runner.db.execute("INSERT INTO tags (id, title) VALUES ('t1', 'skip')")
+        runner.db.execute("INSERT INTO note_tags (id, note_id, tag_id) VALUES ('nt1', 'a2', 't1')")
+
+        runner.run_cmd("flashback 2026-06-15 -vv -x skip")
+        out = TestSuite.strip_ansi(runner.last_stdout)
+        assert_includes out, "Visible"
+        assert_includes out, "visible body"
+        refute_includes out, "Hidden"
+      end
+
+      it "reports when no flashbacks exist" do
+        runner.run_cmd("flashback 2026-06-15")
+        assert_includes TestSuite.strip_ansi(runner.last_stdout), "No flashbacks found for June 15."
+      end
+    end
+  end
+end
+
+class GroupedReporter < Minitest::AbstractReporter
+  attr_accessor :io, :failures, :assertions, :count, :start_time
+  def initialize(io = $stdout)
+    @io, @failures, @assertions, @count = io, [], 0, 0
+  end
+  def start; @start_time = Minitest.clock_time; io.puts "\n#{PRG.bold} Test Suite".yellow; end
+  def record(result)
+    @count += 1; @assertions += result.assertions
+    io.puts "\n#{result.klass.to_s.blue.bold}" if @current_suite != result.klass
+    @current_suite = result.klass
+    name = result.name.gsub(/^test_\d+_/, '')
+    if result.passed?; io.puts "  #{name.ljust(60)} ✅".green
+    elsif result.skipped?; io.puts "  #{name.ljust(60)} ⚠️".yellow
+    else; io.puts "  #{name.ljust(60)} ❌".red; @failures << result; end
+  end
+  def report
+    total_time = Minitest.clock_time - @start_time
+    io.puts "\n--------------------"
+    if failures.any?
+      io.puts "#{@count} tests, #{@assertions} assertions, #{@failures.size} failures".red
+      @failures.each { |f| io.puts "\n#{f.klass} > #{f.name}:".red; io.puts "  #{f.failures.first.message}" }
+    else; io.puts "#{@count} tests, #{@assertions} assertions passed!".green; end
+    io.puts "Finished in #{"%.6f" % total_time}s".colorize(mode: :dim)
+  end
+  def passed?; @failures.empty?; end
+end
+
+class Settings < Thor
+  def self.exit_on_failure? = true
+
+  desc "list", "List settings"
+  def list
+    cli = CLI.new
+    print cli.send(:format_settings_list, cli.send(:load_settings), color: $stdout.tty?)
+  end
+
+  desc "get NAME", "Get a setting"
+  def get(name)
+    cli = CLI.new
+    data = cli.send(:load_settings)
+    return say "Setting not found: #{name}" unless data.key?(name)
+
+    puts cli.send(:format_setting_value, data[name])
+  end
+
+  desc "set NAME VALUE", "Set a setting"
+  def set(name, value)
+    cli = CLI.new
+    data = cli.send(:load_settings)
+    parsed_value = cli.send(:parse_setting_value, value)
+    cli.send(:validate_setting_value!, name, parsed_value)
+    data[name] = parsed_value
+    cli.send(:write_settings, data)
+  end
+
+  desc "unset NAME", "Unset a setting"
+  def unset(name)
+    cli = CLI.new
+    data = cli.send(:load_settings)
+    data.delete(name)
+    cli.send(:write_settings, data)
+  end
+end
+
+class Init < Thor
+  def self.exit_on_failure? = true
+
+  desc "fish", "Print Fish shell integration code"
+  def fish
+    puts CLI.new.send(:fish_completion_script)
+  end
+end
+
+class Trash < Thor
+  def self.exit_on_failure? = true
+
+  desc "ls", "List trashed notes"
+  def ls
+    CLI.new.send(:list_trash)
+  end
+
+  desc "restore UUID", "Restore a trashed note"
+  def restore(uuid)
+    CLI.new.send(:restore_trash_note, uuid)
+  end
+
+  desc "empty", "Permanently delete all trashed notes"
+  def empty
+    CLI.new.send(:empty_trash)
+  end
+end
+
+class CLI < Thor
+  AddError = Class.new(StandardError)
+
+  def self.exit_on_failure?; true; end
+
+  def self.start(given_args = ARGV, config = {})
+    sanitized_args, overrides = extract_runtime_overrides(given_args)
+    Thread.current[:jp_args] = sanitized_args
+    Thread.current[:jp_setting_overrides] = overrides
+    super(sanitized_args, config)
+  ensure
+    Thread.current[:jp_setting_overrides] = nil
+  end
+
+  def self.extract_runtime_overrides(given_args)
+    args = Array(given_args).map(&:to_s)
+    sanitized = []
+    overrides = {}
+    index = 0
+
+    while index < args.length
+      argument = args[index]
+      if argument == "-o" || argument == "--option"
+        value = args[index + 1]
+        raise Thor::Error, "#{argument} requires KEY=VALUE." if value.nil?
+
+        overrides.merge!(parse_runtime_override(value))
+        index += 2
+      elsif argument.start_with?("--option=")
+        overrides.merge!(parse_runtime_override(argument.delete_prefix("--option=")))
+        index += 1
+      else
+        sanitized << argument
+        index += 1
+      end
+    end
+
+    [sanitized, overrides]
+  end
+
+  def self.parse_runtime_override(value)
+    key, raw_value = value.to_s.split("=", 2)
+    raise Thor::Error, "Override must use KEY=VALUE." if key.to_s.empty? || raw_value.nil?
+
+    setting = normalize_runtime_override_key(key)
+    parsed_value = parse_runtime_override_value(raw_value)
+    validate_runtime_override_value!(setting, parsed_value)
+    { setting => parsed_value }
+  end
+
+  def self.normalize_runtime_override_key(key)
+    case key
+    when "readonly", "jp.readOnly"
+      "jp.readOnly"
+    when "pager", "jp.pager"
+      "jp.pager"
+    else
+      raise Thor::Error, "Unsupported override: #{key}. Supported overrides: readonly, pager."
+    end
+  end
+
+  def self.parse_runtime_override_value(value)
+    JSON.parse(value)
+  rescue JSON::ParserError
+    value
+  end
+
+  def self.validate_runtime_override_value!(setting, value)
+    case setting
+    when "jp.readOnly"
+      return if value == true || value == false
+
+      raise Thor::Error, "jp.readOnly must be true or false."
+    when "jp.pager"
+      return if value == false || value.is_a?(String)
+
+      raise Thor::Error, "jp.pager must be false or a command string."
+    end
+  end
+
+  def self.printable_commands(all = true, subcommand = false)
+    super.reject { |command| command.first.include?("__complete") }
+  end
+
+  VERSION = "0.36.0"
+  DEFAULT_JOPLIN_DATA_DIR = File.join(ENV.fetch('HOME'), '.config', 'joplin')
+
+  def self.joplin_data_dir
+    ENV.fetch('JOPLIN_DATA_DIR', DEFAULT_JOPLIN_DATA_DIR)
+  end
+
+  desc "settings SUBCOMMAND", "Manage settings"
+  subcommand "settings", Settings
+
+  desc "init SUBCOMMAND", "Print shell integration code"
+  subcommand "init", Init
+
+  desc "trash SUBCOMMAND", "Manage trashed notes"
+  subcommand "trash", Trash
+
+  def self.help(shell, subcommand = false)
+    shell.say "Joplin Utility (v#{VERSION})".bold.yellow.underline
+    shell.say ""
+    shell.say "Usage:".yellow
+    shell.say "  #{PRG.cyan} " + "COMMAND ".green.bold + "[ARGS]"
+    shell.say ""
+    shell.say "Commands:".yellow
+
+    list = printable_commands(true, subcommand)
+    Thor::Util.thor_classes_in(self).each do |klass|
+      list += klass.printable_commands(false)
+    end
+    list.sort!
+
+    max_len = list.map { |command| command[0].length }.max || 0
+    list.each do |command_full, description|
+      parts = command_full.split
+      program = parts.shift
+      command = parts.shift
+      args = parts.join(' ')
+
+      colored_args = args.gsub(/(\[|\]|\.\.\.)/) { |part| part.colorize(mode: :dim) }
+      colored_args.gsub!(/([A-Z_]{2,})/, "\\1".cyan.colorize(mode: :dim))
+
+      plain_command = [program, command, args].reject(&:empty?).join(' ')
+      colored_command = "#{program.cyan} #{command.green.bold}"
+      colored_command += " #{colored_args}" unless args.empty?
+      padding = " " * (max_len - plain_command.length)
+      detail = "# #{description.gsub(/^#\s*/, '')}".colorize(mode: :dim)
+
+      shell.say "  #{colored_command}#{padding}  #{detail}"
+    end
+    shell.say ""
+  end
+
+  def initialize(*args)
+    super
+    @joplin_data_dir = self.class.joplin_data_dir
+    @db_path = File.join(@joplin_data_dir, 'database.sqlite')
+    @db = SQLite3::Database.new(@db_path)
+    @db.results_as_hash = true
+    load_settings unless Array(Thread.current[:jp_args]).first == "test"
+  end
+
+  desc "version", "Show version"
+  def version
+    puts VERSION
+  end
+
+  desc "info", "Show JP and Joplin profile information"
+  def info
+    notebooks = @db.get_first_value("SELECT COUNT(*) FROM folders WHERE deleted_time = 0")
+    notes = @db.get_first_value("SELECT COUNT(*) FROM notes WHERE deleted_time = 0")
+    tags = @db.get_first_value("SELECT COUNT(*) FROM tags")
+    count_label = ->(count, noun) { "#{count} #{noun}#{count == 1 ? '' : 's'}" }
+
+    say "Joplin Utility Version: ".cyan + " #{VERSION}".green
+    say "Database:               ".cyan + " #{@db_path}".green
+    say "Settings File:          ".cyan + " #{settings_path}".green
+    say "Statistics:             ".cyan + " #{count_label.call(notebooks, 'notebook')}".white +
+      ", ".green + "#{count_label.call(notes, 'note')}".white +
+      ", ".green + "#{count_label.call(tags, 'tag')}".white
+
+    backups = backup_files
+    if backups.any?
+      say "Backups:                ".cyan + " #{backups.size} files".green
+      backups.each do |path|
+        epoch = File.basename(path)[/\Ajoplin_(\d+)\.sqlite3\.gz\z/, 1].to_i
+        timestamp = Time.at(epoch)
+        say "  #{timestamp.strftime('%Y-%m-%d %H:%M:%S')}".cyan + "  " + "(#{time_ago(timestamp)})".yellow
+      end
+    else
+      say "Backups:                ".cyan + " none".yellow
+    end
+  end
+
+  desc "bkup", "Backup the database"
+  def bkup
+    begin
+      compressed = create_backup
+      say "Backup created: #{compressed.green}"
+    rescue => e
+      say "Backup failed: #{e.message}".red
+    end
+  end
+
+  desc "ls [TARGET]", "List notebooks, notes, or tags"
+  method_option :long, aliases: "-l", type: :boolean, desc: "Show note counts"
+  method_option :tree, aliases: "-T", type: :boolean
+  method_option :recursive, aliases: "-R", type: :boolean, desc: "List notebook contents recursively"
+  method_option :type, aliases: "-t", type: :boolean
+  method_option :nb, aliases: "-n", type: :boolean
+  method_option :all, aliases: "-a", type: :boolean, desc: "Show all notebooks"
+  method_option :date, aliases: "-d", type: :string, desc: "Filter notes by date/shortcut"
+  def ls(target = nil)
+    if target.nil?
+      list_overview
+    else
+      list_target(target)
+    end
+  end
+
+  desc "add NOTEBOOK [BODY...]", "Add a note"
+  method_option :title, aliases: "-t", type: :string, desc: "Note title"
+  method_option :tag, aliases: "-T", type: :string, desc: "Tag (repeatable or comma-separated)"
+  def add(notebook_path, *body_parts)
+    return unless ensure_writable!
+
+    stdin_body = nil
+    unless $stdin.tty?
+      stdin_body = $stdin.read
+      if body_parts.any? && !stdin_body.empty?
+        return say "Error: body cannot be supplied both as arguments and stdin.".red
+      end
+    end
+
+    tags = normalize_add_tags(extract_add_tag_options)
+    title = options[:title].to_s.strip
+    body = body_parts.any? ? body_parts.join(' ') : stdin_body
+
+    if title.empty? && body.nil?
+      edited = edit_add_text_buffer
+      return unless edited
+      title, body = edited
+    elsif body_parts.empty? && stdin_body&.empty?
+      return say "Error: Empty stdin, nothing added.".red
+    end
+
+    body ||= ""
+    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
+    )
+
+    say "Created note #{note[:path].green}"
+    say "  ID: #{note[:id][0..4].colorize(mode: :dim)}"
+    auto_bkup_if_needed
+  rescue AddError => e
+    say "Error: #{e.message}".red
+  end
+
+  desc "journal [today|yesterday|YYYY-MM-DD] [TEXT...]", "Append to a daily journal note; omit DATE for today"
+  def journal(date_or_text = nil, *text_parts)
+    return unless ensure_writable!
+
+    date, body = parse_journal_args(date_or_text, text_parts)
+    replace_body = body.nil? || body.empty?
+    body = edit_journal_text_buffer(date) if replace_body
+    return unless body && !body.empty?
+
+    note = append_or_create_journal_note(date, body, append: !replace_body)
+    say "Updated journal #{note[:path].green}"
+    say "  ID: #{note[:id][0..4].colorize(mode: :dim)}"
+    auto_bkup_if_needed
+  rescue AddError => e
+    say "Error: #{e.message}".red
+  end
+  map "j" => :journal
+
+  desc "__complete TYPE", "Return shell completion candidates", hide: true
+  def __complete(type)
+    case type
+    when "targets"
+      completion_notebooks.each { |path| puts "#{path}\tNotebook" }
+      @db.execute("SELECT title FROM tags ORDER BY title").each { |tag| puts "#{tag['title']}\tTag" }
+      completion_notes.each { |note| puts "#{note['id'][0..4]}\tNote #{get_full_path_for_note(note)}" }
+    when "notes"
+      completion_notes.each do |note|
+        puts "#{get_full_path_for_note(note)}\tNote #{note['id'][0..4]}"
+      end
+    when "tags"
+      @db.execute("SELECT title FROM tags ORDER BY title").each { |tag| puts "#{tag['title']}\tTag" }
+    when "notebooks"
+      completion_notebooks.each { |path| puts "#{path}\tNotebook" }
+    when "movable"
+      completion_movable_items.each { |candidate, description| puts "#{candidate}\t#{description}" }
+    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)}" }
+    end
+  end
+
+  desc "cat TARGET...", "Display note content"
+  method_option :raw, aliases: "-r", type: :boolean, desc: "Display raw Markdown source"
+  method_option :verbose, aliases: "-v", type: :boolean, desc: "Show note metadata"
+  method_option :pager, type: :boolean, default: true, desc: "Use a pager for long output"
+  def cat(*targets)
+    targets = cat_targets_from_stdin if targets.empty? && !$stdin.tty?
+    return say "Error: TARGET is required.".red if targets.empty?
+
+    displayed = 0
+    targets.each do |target|
+      note = resolve_cat_target(target)
+      next unless note
+
+      puts if displayed.positive?
+      display_note(note, raw: options[:raw], verbose: options[:verbose], no_pager: !options[:pager])
+      displayed += 1
+    end
+  end
+
+  no_commands do
+    def cat_targets_from_stdin
+      input = $stdin.read
+      return [] if input.nil? || input.strip.empty?
+
+      lines = input.lines.map(&:strip).reject(&:empty?)
+      return lines unless lines.length == 1
+
+      lines.first.split(/\s+/)
+    end
+
+    def resolve_cat_target(target)
+      notes = find_notes(target)
+      if notes.empty?
+        say "No note found matching '#{target}'."
+        nil
+      elsif notes.size > 1
+        say "Ambiguous target: '#{target}' matches multiple notes:".yellow
+        notes.each do |n|
+          say "  #{n['id'][0..4].colorize(:mode => :dim)} #{get_full_path_for_note(n)}"
+        end
+        say "Use the short ID to specify."
+        nil
+      else
+        notes.first
+      end
+    end
+  end
+
+  desc "random", "Display a random note"
+  def random
+    note = @db.get_first_row("SELECT * FROM notes WHERE deleted_time = 0 ORDER BY RANDOM() LIMIT 1")
+    return say "No notes found." unless note
+
+    display_note(note)
+  end
+
+  desc "search QUERY", "Search notes for text"
+  method_option :verbose, aliases: "-v", type: :boolean, desc: "Show content snippets"
+  def search(*query_parts)
+    query = query_parts.join(' ')
+    return say "Error:".yellow + " Search query is required." if query.empty?
+
+    results = fetch_notes(query: query)
+    if results.empty?
+      say "No results found for '#{query.cyan}'."
+    else
+      say "Search results for '#{query}':".bold
+      results.each do |note|
+        ts = Time.at(note['updated_time'] / 1000).strftime('%Y-%m-%d %H:%M').colorize(mode: :dim)
+        id_str = note['id'][0..4].colorize(:mode => :dim)
+        # Highlight in title
+        title = note['title'].gsub(/(#{Regexp.escape(query)})/i) { |m| m.red.on_yellow.bold }
+        puts "#{id_str} #{ts} #{title}"
+        
+        if options[:verbose]
+          snippet = get_snippet(note['body'] || "", query)
+          puts snippet if snippet
+        end
+      end
+    end
+  end
+  map "grep" => :search
+
+  desc "cal [DATE]", "Show calendar"
+  method_option :year, aliases: "-y", type: :boolean, desc: "Show full year calendar"
+  method_option :include, aliases: "-i", type: :string, desc: "Filter by tags (comma-separated)"
+  method_option :exclude, aliases: "-x", type: :string, desc: "Exclude entries with these tags"
+  def cal(date_str = nil)
+    include_tags = options[:include] ? options[:include].split(',').map(&:strip) : []
+    exclude_tags = options[:exclude] ? options[:exclude].split(',').map(&:strip) : []
+
+    sql = "SELECT n.updated_time, (SELECT GROUP_CONCAT(t.title) FROM note_tags nt JOIN tags t ON nt.tag_id = t.id WHERE nt.note_id = n.id) as tags FROM notes n WHERE n.deleted_time = 0"
+    rows = @db.execute(sql)
+
+    dates = rows.select do |row|
+      row_tags = row['tags'].to_s.split(',')
+      if include_tags.any? && !tag_matches_any?(row_tags, include_tags)
+        next false
+      end
+      if exclude_tags.any? && tag_matches_any?(row_tags, exclude_tags)
+        next false
+      end
+      true
+    end.map do |row|
+      Time.at(row['updated_time'] / 1000).strftime('%Y-%m-%d')
+    end.to_set
+
+    # Use unified parser
+    _, _, date_format, anchor_date = parse_date_query(date_str)
+    
+    # Grid generation
+    if date_format == '%Y' || options[:year]
+      say "#{anchor_date.year}".center(66).bold
+      months = (1..12).map { |m| get_month_data(Date.new(anchor_date.year, m, 1), dates) }
+
+      # Print 3 columns
+      months.each_slice(3) do |slice|
+        # Print titles
+        slice.each { |m| print m[:title].center(22) }
+        say ""
+        slice.each { |_| print "Su Mo Tu We Th Fr Sa  ".colorize(mode: :dim) }
+        say ""
+
+        # Print grid rows (up to 6 rows per month)
+        (0..5).each do |r|
+          slice.each do |m|
+            row = m[:rows][r]
+            if row
+              print row.join(" ") + "  "
+            else
+              print " " * 22
+            end
+          end
+          say ""
+        end
+        say ""
+      end
+    else
+      # Single month
+      m = get_month_data(anchor_date, dates)
+      print_month(m, anchor_date.year)
+    end
+  end
+
+  desc "log [DATE] [SLICE]", "Show log (shortcuts: today, yesterday, week, month, year, last-week, last-month, 7days, 3hours, 1yearago)\nfor 7days or 3hours, the number can be replaced by any integer"
+  method_option :verbose, aliases: "-v", type: :boolean, desc: "Show more info (-vv for IDs/updates)"
+  method_option :long, aliases: "-l", type: :boolean, desc: "Alias for -v"
+  method_option :all, aliases: "-a", type: :boolean, desc: "Include hidden/excluded entries"
+  method_option :exclude, aliases: "-x", type: :string, desc: "Exclude entries with these tags"
+  def log(arg1 = nil, arg2 = nil)
+    verbosity = determine_verbosity
+    date_arg = nil
+    slice_arg = nil
+
+    # Identify which argument is the date/shortcut
+    [arg1, arg2].each do |arg|
+      next if arg.nil?
+      if is_date_query?(arg)
+        date_arg = arg
+      else
+        slice_arg = arg
+      end
+    end
+
+    range, date_filter, format, _ = parse_date_query(date_arg)
+
+    # Strip brackets if passed
+    slice_arg = $1 if slice_arg =~ /^\[(.+)\]$/
+
+    exclude_list = options[:exclude] ? options[:exclude].split(',').map(&:strip) : []
+    list_chronological(verbosity, slice_arg, date_filter, format, exclude_list, range: range, include_hidden: options[:all])
+  end
+
+  desc "flashback [DATE]", "Show notes from this day in previous years"
+  method_option :verbose, aliases: "-v", type: :boolean, desc: "Show more info (-vv for note bodies)"
+  method_option :long, aliases: "-l", type: :boolean, desc: "Alias for -v"
+  method_option :exclude, aliases: "-x", type: :string, desc: "Exclude notes with these tags"
+  method_option :all, aliases: "-a", type: :boolean, desc: "Include excluded notes"
+  def flashback(date_str = nil)
+    verbosity = determine_verbosity
+    exclude_list = options[:exclude] ? options[:exclude].split(',').map(&:strip) : []
+    _, _, _, target_date = parse_date_query(date_str)
+
+    say "Flashbacks for #{target_date.strftime('%B %d')}:".bold.yellow
+    say ""
+
+    found_any = false
+    (1..20).each do |years_ago|
+      date = target_date << (years_ago * 12)
+      start_time = date.to_time.to_i
+      notes = fetch_notes_log(range: [start_time, start_time + 86_399])
+      notes = notes.reject { |note| tag_matches_any?(note['tags'], exclude_list) } unless options[:all]
+      next if notes.empty?
+
+      found_any = true
+      label = years_ago == 1 ? "1 Year Ago" : "#{years_ago} Years Ago"
+      say "--- #{label.bold} (#{date.strftime('%Y-%m-%d').cyan}) ---"
+      display_log_notes(notes, verbosity)
+      say ""
+    end
+
+    say "No flashbacks found for #{target_date.strftime('%B %d')}." unless found_any
+  end
+
+  desc "edit TARGET", "Edit a note or tag stack"
+  method_option :yaml, aliases: "-y", type: :boolean, desc: "Edit note and tags using YAML"
+  def edit(target)
+    return unless ensure_writable!
+
+    if options[:yaml]
+      result = prepare_yaml_edit_data_for_target(target)
+      if result
+        data, msg = result
+        perform_yaml_edit(data, msg)
+        return
+      else
+        say "Note or tag '#{target.cyan}' not found."
+        return
+      end
+    end
+
+    notes = find_notes(target)
+    if notes.empty?
+      # Check if it's a tag
+      tag_row = @db.get_first_row("SELECT * FROM tags WHERE title = ? OR id LIKE ?", [target, "#{target.downcase}%"])
+      if tag_row
+        edit_tag_stack(tag_row['title'])
+      else
+        say "Note or tag '#{target.cyan}' not found."
+      end
+    elsif notes.size > 1
+      say "Ambiguous target: '#{target}' matches multiple notes:".yellow
+      notes.each do |n|
+        say "  #{n['id'][0..4].colorize(:mode => :dim)} #{get_full_path_for_note(n)}"
+      end
+      say "Use the short ID to specify."
+    else
+      edit_single_note(notes.first)
+    end
+  end
+
+  desc "mv SOURCE DESTINATION", "Rename a notebook or tag"
+  def mv(source, destination)
+    return unless ensure_writable!
+
+    destination = destination.to_s.strip
+    raise Thor::Error, "Destination name cannot be empty." if destination.empty?
+
+    matches = find_movable_items(source)
+    if matches.empty?
+      return say "No notebook or tag found matching '#{source}'."
+    end
+    if matches.length > 1
+      say "Ambiguous source '#{source}'. Use the UUID:".yellow
+      matches.each do |item|
+        label = item[:type] == :notebook ? "Notebook #{get_full_path(item[:row])}" : "Tag #{item[:row]['title']}"
+        say "  #{item[:row]['id'][0..4].colorize(mode: :dim)} #{label}"
+      end
+      return
+    end
+
+    item = matches.first
+    old_name = item[:row]['title']
+    rename_movable_item(item, destination)
+    type = item[:type] == :notebook ? "Notebook" : "Tag"
+    say "Renamed #{type.downcase} '#{old_name}' to '#{destination}'.".green
+    auto_bkup_if_needed
+  end
+
+  desc "rm TARGET", "Move a note to Trash or recursively remove a notebook or 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)
+    return unless ensure_writable!
+
+    matches = find_removable_items(target)
+    if matches.empty?
+      return say "No note, notebook, or tag found matching '#{target}'."
+    end
+    if matches.length > 1
+      say "Ambiguous target '#{target}'. Use the UUID:".yellow
+      matches.each do |item|
+        label = removable_item_label(item)
+        say "  #{item[:row]['id'][0..4].colorize(mode: :dim)} #{label}"
+      end
+      return
+    end
+
+    item = matches.first
+    if item[:type] == :note
+      trash_notes([item[:row]['id']])
+      say "Moved note '#{item[:row]['title']}' to Trash.".green
+      auto_bkup_if_needed
+      return
+    end
+    unless options[:recursive]
+      return say "Cannot remove #{item[:type]} '#{item[:row]['title']}': use -r."
+    end
+
+    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] "
+      answer = $stdin.gets.to_s.strip.downcase
+      unless %w[y yes].include?(answer)
+        say "Cancelled."
+        return
+      end
+    end
+
+    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
+    auto_bkup_if_needed
+  end
+
+  desc "test", "Run tests"
+  method_option :verbose, aliases: "-v", type: :boolean
+  def test
+    TestSuite.debug = options[:verbose]
+    Minitest.seed = srand % 0xFFFF
+    reporter = GroupedReporter.new
+    reporter.start
+    Minitest::Runnable.runnables.reject { |r| [Minitest::Test, Minitest::Spec].include?(r) }.sort_by(&:to_s).each do |suite|
+      suite.runnable_methods.each { |m| reporter.record(suite.new(m).run) }
+    end
+    reporter.report
+    exit 1 unless reporter.passed?
+  end
+
+  private
+
+  def find_movable_items(source)
+    if source.match?(/\A[a-f0-9]{1,32}\z/i)
+      prefix = "#{source.downcase}%"
+      matches = @db.execute(
+        "SELECT id, title, parent_id FROM folders WHERE LOWER(id) LIKE ? AND deleted_time = 0",
+        [prefix]
+      ).map { |row| { type: :notebook, row: row } }
+      matches.concat(
+        @db.execute("SELECT id, title FROM tags WHERE LOWER(id) LIKE ?", [prefix]).map do |row|
+          { type: :tag, row: row }
+        end
+      )
+      return matches
+    end
+
+    matches = @db.execute(
+      "SELECT id, title, parent_id FROM folders WHERE title = ? AND deleted_time = 0",
+      [source]
+    ).map { |row| { type: :notebook, row: row } }
+    matches.concat(
+      @db.execute("SELECT id, title FROM tags WHERE title = ?", [source]).map do |row|
+        { type: :tag, row: row }
+      end
+    )
+    matches
+  end
+
+  def find_removable_items(source)
+    if source.match?(/\A[a-f0-9]{1,32}\z/i)
+      prefix = "#{source.downcase}%"
+      matches = find_movable_items(source)
+      matches.concat(
+        @db.execute(
+          "SELECT id, title, parent_id FROM notes WHERE LOWER(id) LIKE ? AND deleted_time = 0",
+          [prefix]
+        ).map { |row| { type: :note, row: row } }
+      )
+      return matches
+    end
+
+    matches = find_movable_items(source)
+    find_notes(source).each { |row| matches << { type: :note, row: row } }
+    matches
+  end
+
+  def removable_item_label(item)
+    case item[:type]
+    when :notebook then "Notebook #{get_full_path(item[:row])}"
+    when :tag then "Tag #{item[:row]['title']}"
+    else "Note #{get_full_path_for_note(item[:row])}"
+    end
+  end
+
+  def rename_movable_item(item, destination)
+    table = item[:type] == :notebook ? "folders" : "tags"
+    columns = @db.execute("PRAGMA table_info(#{table})").map { |column| column['name'] }.to_set
+    assignments = ["title = ?"]
+    values = [destination]
+    now = Time.now.to_i * 1000
+    %w(updated_time user_updated_time).each do |column|
+      next unless columns.include?(column)
+
+      assignments << "#{column} = ?"
+      values << now
+    end
+    values << item[:row]['id']
+    @db.execute("UPDATE #{table} SET #{assignments.join(', ')} WHERE id = ?", values)
+  end
+
+  def removable_note_ids(item)
+    if item[:type] == :tag
+      @db.execute(<<~SQL, [item[:row]['id']]).map { |row| row['id'] }
+        SELECT DISTINCT n.id
+        FROM notes n
+        JOIN note_tags nt ON nt.note_id = n.id
+        WHERE nt.tag_id = ? AND n.deleted_time = 0
+      SQL
+    else
+      folder_ids = notebook_subtree_ids(item[:row]['id'])
+      placeholders = Array.new(folder_ids.length, "?").join(", ")
+      @db.execute(
+        "SELECT id FROM notes WHERE parent_id IN (#{placeholders}) AND deleted_time = 0",
+        folder_ids
+      ).map { |row| row['id'] }
+    end
+  end
+
+  def notebook_subtree_ids(root_id)
+    ids = []
+    pending = [root_id]
+    until pending.empty?
+      parent_id = pending.shift
+      ids << parent_id
+      pending.concat(
+        @db.execute("SELECT id FROM folders WHERE parent_id = ? AND deleted_time = 0", [parent_id]).map { |row| row['id'] }
+      )
+    end
+    ids
+  end
+
+  def remove_item(item, note_ids)
+    @db.transaction do
+      trash_notes(note_ids)
+      if item[:type] == :tag
+        @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)
+      end
+    end
+  end
+
+  def trash_notes(note_ids)
+    return if note_ids.empty?
+
+    columns = @db.execute("PRAGMA table_info(notes)").map { |column| column['name'] }.to_set
+    now = Time.now.to_i * 1000
+    assignments = ["deleted_time = ?"]
+    values = [now]
+    if columns.include?("updated_time")
+      assignments << "updated_time = ?"
+      values << now
+    end
+    placeholders = Array.new(note_ids.length, "?").join(", ")
+    @db.execute(
+      "UPDATE notes SET #{assignments.join(', ')} WHERE id IN (#{placeholders})",
+      [*values, *note_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")
+  end
+
+  def list_trash
+    notes = trashed_notes
+    return say "Trash is empty." if notes.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)}"
+    end
+  end
+
+  def restore_trash_note(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?
+
+    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)}"
+      end
+      return
+    end
+
+    note = matches.first
+    @db.execute("UPDATE notes SET deleted_time = 0 WHERE id = ?", [note['id']])
+    say "Restored note '#{note['title']}'.".green
+    auto_bkup_if_needed
+  end
+
+  def empty_trash
+    return unless ensure_writable!
+
+    count = @db.get_first_value("SELECT COUNT(*) FROM notes WHERE deleted_time > 0").to_i
+    return say "Trash is empty." if count.zero?
+
+    noun = count == 1 ? "note" : "notes"
+    print "Permanently delete #{count} trashed #{noun}? [y/N] "
+    answer = $stdin.gets.to_s.strip.downcase
+    unless %w[y yes].include?(answer)
+      say "Cancelled."
+      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(", ")
+    @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)
+    end
+    say "Emptied Trash.".green
+    auto_bkup_if_needed
+  end
+
+  def extract_add_tag_options
+    args = Thread.current[:jp_args] || []
+    tags = []
+    index = 0
+    while index < args.length
+      argument = args[index]
+      case argument
+      when '-T', '--tag'
+        tags << args[index + 1] if args[index + 1]
+        index += 2
+      when /\A--tag=(.*)\z/
+        tags << Regexp.last_match(1)
+        index += 1
+      else
+        index += 1
+      end
+    end
+    tags << options[:tag] if tags.empty? && options[:tag]
+    tags
+  end
+
+  def normalize_add_tags(values)
+    Array(values).flat_map do |value|
+      value.is_a?(Array) ? value : value.to_s.split(',')
+    end.map { |tag| tag.to_s.strip }.reject(&:empty?).uniq
+  end
+
+  def parse_journal_args(date_or_text, text_parts)
+    if journal_date_token?(date_or_text)
+      [journal_date_from_token(date_or_text), text_parts.join(' ')]
+    else
+      [Date.today, [date_or_text, *text_parts].compact.join(' ')]
+    end
+  end
+
+  def journal_date_token?(value)
+    value.nil? || value == "today" || value == "yesterday" || value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+  end
+
+  def journal_date_from_token(value)
+    case value
+    when nil, "today" then Date.today
+    when "yesterday" then Date.today - 1
+    else
+      Date.strptime(value, "%Y-%m-%d")
+    end
+  rescue ArgumentError
+    raise AddError, "Invalid journal date: #{value}"
+  end
+
+  def journal_notebook_path(date)
+    "Journal/#{date.strftime('%Y')}/#{date.strftime('%m-%b')}"
+  end
+
+  def journal_note_title(date)
+    date.strftime("%Y-%m-%d")
+  end
+
+  def edit_journal_text_buffer(date)
+    temp = Tempfile.new(['jp_journal', '.md'])
+    begin
+      notes = journal_notes_for_date(date)
+      raise AddError, "Journal note is ambiguous for #{journal_note_title(date)}." if notes.length > 1
+
+      temp.write(notes.first ? notes.first['body'].to_s : "")
+      temp.close
+      editor = ENV['EDITOR'] || 'vi'
+      success = system("#{editor} #{Shellwords.escape(temp.path)}")
+      unless success
+        say "Journal cancelled."
+        return nil
+      end
+
+      body = File.read(temp.path).delete_suffix("\n")
+      if body.empty?
+        say "Journal cancelled."
+        return nil
+      end
+      body
+    ensure
+      temp.unlink
+    end
+  end
+
+  def journal_notes_for_date(date)
+    notebook_path = journal_notebook_path(date)
+    title = journal_note_title(date)
+    find_notes("#{notebook_path}/#{title}")
+  end
+
+  def append_or_create_journal_note(date, body, append: true)
+    notebook_path = journal_notebook_path(date)
+    title = journal_note_title(date)
+    notes = journal_notes_for_date(date)
+
+    if notes.any?
+      raise AddError, "Journal note is ambiguous for #{title}." if notes.length > 1
+
+      note = notes.first
+      existing = note['body'].to_s
+      separator = existing.empty? ? "" : "\n\n"
+      updated_body = append ? "#{existing}#{separator}#{body}" : body
+      now = Time.now.to_i * 1000
+      columns = @db.execute("PRAGMA table_info(notes)").map { |column| column['name'] }.to_set
+      updates = ["body = ?"]
+      params = [updated_body]
+      %w(updated_time user_updated_time).each do |column|
+        next unless columns.include?(column)
+
+        updates << "#{column} = ?"
+        params << now
+      end
+      params << note['id']
+      @db.execute("UPDATE notes SET #{updates.join(', ')} WHERE id = ?", params)
+      note['body'] = updated_body
+      note['path'] = "#{notebook_path}/#{title}"
+      return { id: note['id'], path: note['path'] }
+    end
+
+    create_note_with_hierarchy(
+      notebook_path: notebook_path,
+      title: title,
+      body: body,
+      tags: [],
+      source_url: "",
+      latitude: nil,
+      longitude: nil
+    )
+  end
+
+  def derive_note_title(body)
+    line = body.each_line.find { |candidate| !candidate.strip.empty? }
+    return nil unless line
+
+    line.strip.sub(/\A\#{1,6}\s+/, '').sub(/\s+\#+\z/, '').strip
+  end
+
+  def edit_add_text_buffer
+    temp = Tempfile.new(['jp_add', '.md'])
+    begin
+      temp.write("\n\n")
+      temp.close
+      editor = ENV['EDITOR'] || 'vi'
+      success = system("#{editor} #{Shellwords.escape(temp.path)}")
+      unless success
+        say "Add cancelled."
+        return nil
+      end
+
+      lines = File.read(temp.path).lines
+      title = lines.shift.to_s.chomp
+      lines.shift
+      body = lines.join.delete_suffix("\n")
+      if title.empty? && body.empty?
+        say "Add cancelled."
+        return nil
+      end
+      [title, body]
+    ensure
+      temp.unlink
+    end
+  end
+
+  def parse_coordinate(value, name, minimum, maximum)
+    return nil if value.nil? || value.to_s.strip.empty?
+
+    coordinate = Float(value)
+    raise AddError, "#{name} must be between #{minimum} and #{maximum}." unless coordinate.between?(minimum, maximum)
+    coordinate
+  rescue ArgumentError, TypeError
+    raise AddError, "#{name} must be a number."
+  end
+
+  def create_note_with_hierarchy(notebook_path:, title:, body:, tags:, source_url:, latitude:, longitude:)
+    components = notebook_path.to_s.split('/', -1).map(&:strip)
+    raise AddError, "Notebook path is required." if components.empty? || components.any?(&:empty?)
+
+    now = Time.now.to_i * 1000
+    note_id = SecureRandom.hex(16)
+    parent_id = ""
+
+    @db.transaction do
+      components.each do |component|
+        folders = @db.execute(
+          "SELECT id FROM folders WHERE title = ? AND parent_id = ? AND deleted_time = 0",
+          [component, parent_id]
+        )
+        raise AddError, "Notebook path is ambiguous at '#{component}'." if folders.size > 1
+
+        if folders.empty?
+          folder_id = SecureRandom.hex(16)
+          insert_available_columns('folders', {
+            'id' => folder_id,
+            'title' => component,
+            'parent_id' => parent_id,
+            'created_time' => now,
+            'updated_time' => now,
+            'user_created_time' => now,
+            'user_updated_time' => now,
+            'deleted_time' => 0
+          })
+          parent_id = folder_id
+        else
+          parent_id = folders.first['id']
+        end
+      end
+
+      insert_available_columns('notes', {
+        'id' => note_id,
+        'parent_id' => parent_id,
+        'title' => title,
+        'body' => body,
+        'created_time' => now,
+        'updated_time' => now,
+        'user_created_time' => now,
+        'user_updated_time' => now,
+        'latitude' => latitude,
+        'longitude' => longitude,
+        'source_url' => source_url,
+        'deleted_time' => 0
+      })
+
+      tags.each do |tag_title|
+        tag = @db.get_first_row("SELECT id FROM tags WHERE title = ?", [tag_title])
+        tag_id = tag && tag['id']
+        unless tag_id
+          tag_id = SecureRandom.hex(16)
+          insert_available_columns('tags', {
+            'id' => tag_id,
+            'title' => tag_title,
+            'created_time' => now,
+            'updated_time' => now,
+            'user_created_time' => now,
+            'user_updated_time' => now
+          })
+        end
+        insert_available_columns('note_tags', {
+          'id' => SecureRandom.hex(16),
+          'note_id' => note_id,
+          'tag_id' => tag_id,
+          'created_time' => now,
+          'updated_time' => now,
+          'user_created_time' => now,
+          'user_updated_time' => now
+        })
+      end
+    end
+
+    { id: note_id, path: "#{components.join('/')}/#{title}" }
+  rescue SQLite3::Exception => e
+    raise AddError, "Could not create note: #{e.message}"
+  end
+
+  def insert_available_columns(table, attributes)
+    available = @db.execute("PRAGMA table_info(#{table})").map { |column| column['name'] }.to_set
+    values = attributes.select { |column, value| available.include?(column) && !value.nil? }
+    columns = values.keys
+    placeholders = Array.new(columns.length, '?').join(', ')
+    @db.execute(
+      "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{placeholders})",
+      values.values
+    )
+  end
+
+  def display_note(note, raw: false, verbose: false, no_pager: false)
+    return puts(note['body'] || "") if raw
+
+    width = (IO.console.winsize[1] rescue 80)
+    output = StringIO.new
+    output.puts "#{note['title'].bold.yellow} (#{note['id'][0..4].colorize(mode: :dim)})"
+    display_note_metadata(note).each { |line| output.puts line.colorize(mode: :dim) } if verbose
+    output.puts "-" * 40
+    output.puts render_markdown(note['body'] || "", width: width)
+    write_with_pager(output.string, raw: raw, no_pager: no_pager)
+  end
+
+  def display_note_metadata(note)
+    metadata = []
+    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?
+
+    latitude = note['latitude'].to_f
+    longitude = note['longitude'].to_f
+    if latitude.nonzero? || longitude.nonzero?
+      coordinates = "#{latitude}, #{longitude}"
+      metadata << "Location: #{coordinates} (https://www.google.com/maps?q=#{latitude},#{longitude})"
+    end
+
+    source_url = note['source_url'].to_s.strip
+    metadata << "URL: #{source_url}" unless source_url.empty?
+
+    tags = @db.execute(
+      "SELECT t.title FROM tags t JOIN note_tags nt ON t.id = nt.tag_id WHERE nt.note_id = ? ORDER BY t.title COLLATE NOCASE",
+      [note['id']]
+    ).map { |tag| tag['title'] }
+    metadata << "Tags: #{tags.join(', ')}" if tags.any?
+    metadata
+  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)
+      return print output
+    end
+
+    command = pager_command
+    return print output unless command
+
+    IO.popen(command, 'w') { |pager| pager.write(output) }
+  rescue Errno::ENOENT, Errno::EPIPE
+    print output
+  end
+
+  def should_page_output?(output, raw:, no_pager:, tty:, rows:, columns:)
+    return false if raw || no_pager || !tty || rows.to_i <= 0 || columns.to_i <= 0 || pager_command.nil?
+
+    visible_output = output.gsub(/\e\[(\d+;?)*m/, '')
+    visible_lines = visible_output.lines.sum do |line|
+      [1, (line.chomp.length.to_f / columns).ceil].max
+    end
+    visible_lines > rows
+  end
+
+  def settings_path
+    File.join(@joplin_data_dir, "settings.json")
+  end
+
+  def load_settings
+    data = if File.exist?(settings_path)
+             JSON.parse(File.read(settings_path))
+           else
+             {}
+           end
+    raise Thor::Error, "Settings file must contain a JSON object: #{settings_path}" unless data.is_a?(Hash)
+
+    changed = false
+    unless data.key?("jp.pager")
+      data["jp.pager"] = "less -R"
+      changed = true
+    end
+    unless data.key?("jp.readOnly")
+      data["jp.readOnly"] = false
+      changed = true
+    end
+    unless data.key?("jp.backupKeep")
+      data["jp.backupKeep"] = 10
+      changed = true
+    end
+    unless data.key?("jp.backupAuto")
+      data["jp.backupAuto"] = true
+      changed = true
+    end
+    unless data.key?("jp.backupAutoInterval")
+      data["jp.backupAutoInterval"] = 24
+      changed = true
+    end
+    write_settings(data) if changed
+    data
+  rescue JSON::ParserError => e
+    raise Thor::Error, "Invalid JSON in #{settings_path}: #{e.message}"
+  end
+
+  def write_settings(data)
+    mode = File.exist?(settings_path) ? File.stat(settings_path).mode & 0o777 : 0o600
+    Tempfile.create(["settings", ".json"], File.dirname(settings_path)) do |file|
+      file.write(JSON.pretty_generate(data))
+      file.write("\n")
+      file.flush
+      file.fsync
+      File.chmod(mode, file.path)
+      File.rename(file.path, settings_path)
+    end
+  end
+
+  def parse_setting_value(value)
+    JSON.parse(value)
+  rescue JSON::ParserError
+    value
+  end
+
+  def format_setting_value(value)
+    value.is_a?(String) ? value : JSON.generate(value)
+  end
+
+  def format_settings_list(data, color:)
+    yaml = YAML.dump(data.sort.to_h).delete_prefix("---\n")
+    return yaml unless color
+
+    yaml.lines.map { |line| colorize_setting_line(line) }.join
+  end
+
+  def colorize_setting_line(line)
+    newline = line.end_with?("\n") ? "\n" : ""
+    content = line.chomp
+
+    if content =~ /\A(\s*)(-)(\s+)(.*)\z/
+      "#{$1}#{$2.colorize(mode: :dim)}#{$3}#{$4.green}#{newline}"
+    elsif content =~ /\A(\s*)(.+?)(:)(?:\s(.*))?\z/
+      value = $4
+      output = "#{$1}#{$2.cyan}#{$3.colorize(mode: :dim)}"
+      output += " #{value.green}" if value
+      "#{output}#{newline}"
+    else
+      line
+    end
+  end
+
+  def validate_setting_value!(name, value)
+    case name
+    when "jp.pager"
+      return if value == false || value.is_a?(String)
+
+      raise Thor::Error, "jp.pager must be false or a command string."
+    when "jp.readOnly"
+      return if value == true || value == false
+
+      raise Thor::Error, "jp.readOnly must be true or false."
+    when "jp.backupKeep"
+      return if value.is_a?(Integer) && value.positive?
+
+      raise Thor::Error, "jp.backupKeep must be a positive integer."
+    when "jp.backupAuto"
+      return if value == true || value == false
+
+      raise Thor::Error, "jp.backupAuto must be true or false."
+    when "jp.backupAutoInterval"
+      return if value.is_a?(Numeric) && value >= 0
+
+      raise Thor::Error, "jp.backupAutoInterval must be a non-negative number of hours."
+    end
+  end
+
+  def backup_keep
+    value = load_settings["jp.backupKeep"]
+    raise Thor::Error, "jp.backupKeep must be a positive integer." unless value.is_a?(Integer) && value.positive?
+
+    value
+  end
+
+  def backup_files
+    Dir.glob(File.join(@joplin_data_dir, 'joplin_*.sqlite3.gz')).select do |path|
+      File.basename(path).match?(/\Ajoplin_\d+\.sqlite3\.gz\z/)
+    end.sort_by do |path|
+      -File.basename(path)[/\Ajoplin_(\d+)\.sqlite3\.gz\z/, 1].to_i
+    end
+  end
+
+  def rotate_backups
+    files = backup_files.reverse
+    return unless files.size > backup_keep
+
+    to_delete = files[0...-backup_keep]
+    to_delete.each { |path| File.delete(path) }
+    say "Removed #{to_delete.size} old backup(s).".yellow
+  end
+
+  def create_backup
+    timestamp = Time.now.to_i
+    compressed = File.join(@joplin_data_dir, "joplin_#{timestamp}.sqlite3.gz")
+    temp_db_path = File.join(Dir.tmpdir, "jp_#{timestamp}.db")
+
+    source_db = @db
+    dest_db = SQLite3::Database.new(temp_db_path)
+
+    backup = SQLite3::Backup.new(dest_db, "main", source_db, "main")
+    backup.step(-1)
+    backup.finish
+    dest_db.close
+
+    File.open(temp_db_path, 'rb') do |src|
+      Zlib::GzipWriter.open(compressed) do |gz|
+        IO.copy_stream(src, gz)
+      end
+    end
+
+    rotate_backups
+    compressed
+  ensure
+    dest_db&.close rescue nil
+    File.delete(temp_db_path) if temp_db_path && File.exist?(temp_db_path)
+  end
+
+  def auto_bkup_if_needed
+    settings = load_settings
+    return unless settings["jp.backupAuto"] == true
+
+    interval = settings["jp.backupAutoInterval"]
+    raise Thor::Error, "jp.backupAutoInterval must be a non-negative number of hours." unless interval.is_a?(Numeric) && interval >= 0
+
+    latest_epoch = backup_files.map { |path| File.basename(path)[/\Ajoplin_(\d+)\.sqlite3\.gz\z/, 1].to_i }.max
+    return if latest_epoch && (Time.now.to_i - latest_epoch) < (interval * 3600)
+
+    create_backup
+  rescue => e
+    say "Auto-backup failed: #{e.message}".red
+  end
+
+  def read_only?
+    effective_settings["jp.readOnly"] == true
+  end
+
+  def ensure_writable!
+    return true unless read_only?
+
+    say "Read-only mode is enabled (jp.readOnly: true).".red
+    false
+  end
+
+  def pager_command
+    value = effective_settings["jp.pager"]
+    return nil if value == false
+    raise Thor::Error, "jp.pager must be false or a command string." unless value.is_a?(String)
+
+    command = Shellwords.split(value)
+    command.empty? ? nil : command
+  end
+
+  def effective_settings
+    load_settings.merge(Thread.current[:jp_setting_overrides] || {})
+  end
+
+  def terminal_dimensions
+    IO.console.winsize
+  rescue StandardError
+    [24, 80]
+  end
+
+  def format_note_time(milliseconds)
+    Time.at(milliseconds / 1000.0).strftime('%Y-%m-%d %H:%M')
+  end
+
+  def time_ago(time)
+    diff = Time.now - time
+    if diff < 60
+      "just now"
+    elsif diff < 3600
+      "#{(diff / 60).to_i} minutes ago"
+    elsif diff < 86400
+      "#{(diff / 3600).to_i} hours ago"
+    else
+      "#{(diff / 86400).to_i} days ago"
+    end
+  end
+
+  def render_markdown(body, width:)
+    renderable = expand_toc_markers(body).gsub(/\((:\/[a-f0-9]{32})\)/i, '(joplin-resource\1)')
+    TTY::Markdown.parse(renderable, width: width)
+  rescue URI::InvalidURIError
+    repaired = expand_toc_markers(body).gsub(/^(\s*)\[([^\]]+)\]:(\s+.+)$/) { "#{$1}\\[#{$2}\]:#{$3}" }
+    repaired = repaired.gsub(/\((:\/[a-f0-9]{32})\)/i, '(joplin-resource\1)')
+    begin
+      TTY::Markdown.parse(repaired, width: width)
+    rescue URI::InvalidURIError
+      body
+    end
+  end
+
+  def expand_toc_markers(body)
+    marker = /^\s*(?:\$\{toc\}|\[\[toc\]\]|\[toc\]|\[\[_toc_\]\])\s*$/i
+    return body unless body.match?(marker)
+
+    toc_tree = Kramdown::Document.new(body).to_toc
+    toc = toc_tree.children.flat_map { |node| toc_markdown_lines(node) }.join("\n")
+
+    body.gsub(marker, toc)
+  end
+
+  def toc_markdown_lines(node, depth = 0)
+    title = kramdown_element_text(node.value).strip
+    ["#{'  ' * depth}- #{title}"] + node.children.flat_map do |child|
+      toc_markdown_lines(child, depth + 1)
+    end
+  end
+
+  def kramdown_element_text(element)
+    return element.value.to_s if [:text, :codespan].include?(element.type)
+    return element.attr['alt'].to_s if element.type == :img
+
+    element.children.map { |child| kramdown_element_text(child) }.join
+  end
+
+  def fish_completion_script
+    <<~'FISH'
+      # Fish completions for jp. Load with: jp init fish | source
+      function __jp_needs_command
+          set -l words (commandline -opc)
+          test (count $words) -eq 1
+      end
+
+      function __jp_using_command
+          set -l words (commandline -opc)
+          test (count $words) -gt 1; and test "$words[2]" = "$argv[1]"
+      end
+
+      function __jp_complete
+          command jp __complete $argv[1] 2>/dev/null
+      end
+
+      complete -c jp -f
+      complete -c jp -s o -l option -r -d 'Override readonly or pager for this command'
+      complete -c jp -n __jp_needs_command -a add -d 'Add a note'
+      complete -c jp -n __jp_needs_command -a journal -d 'Append to a daily journal note'
+      complete -c jp -n __jp_needs_command -a j -d 'Append to a daily journal note'
+      complete -c jp -n __jp_needs_command -a ls -d 'List notebooks, notes, or tags'
+      complete -c jp -n __jp_needs_command -a cat -d 'Display note content'
+      complete -c jp -n __jp_needs_command -a random -d 'Display a random note'
+      complete -c jp -n __jp_needs_command -a search -d 'Search notes for text'
+      complete -c jp -n __jp_needs_command -a cal -d 'Show calendar'
+      complete -c jp -n __jp_needs_command -a log -d 'Show log'
+      complete -c jp -n __jp_needs_command -a flashback -d 'Show notes from this day in previous years'
+      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 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 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'
+
+      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 journal' -a 'today yesterday' -d 'Journal date'
+      complete -c jp -n '__jp_using_command j' -a 'today yesterday' -d 'Journal date'
+
+      complete -c jp -n '__jp_using_command ls' -s l -l long -d 'Show note counts'
+      complete -c jp -n '__jp_using_command ls' -s T -l tree -d 'Show notebook tree'
+      complete -c jp -n '__jp_using_command ls' -s R -l recursive -d 'List notebook contents recursively'
+      complete -c jp -n '__jp_using_command ls' -s t -l type -d 'Show tags only'
+      complete -c jp -n '__jp_using_command ls' -s n -l nb -d 'Show notebooks only'
+      complete -c jp -n '__jp_using_command ls' -s a -l all -d 'Show all notebooks'
+      complete -c jp -n '__jp_using_command ls' -a '(__jp_complete targets)'
+
+      complete -c jp -n '__jp_using_command cat' -a '(__jp_complete notes)'
+      complete -c jp -n '__jp_using_command cat' -s r -l raw -d 'Display raw Markdown source'
+      complete -c jp -n '__jp_using_command cat' -s v -l verbose -d 'Show note metadata'
+      complete -c jp -n '__jp_using_command cat' -l no-pager -d 'Disable paging'
+      complete -c jp -n '__jp_using_command settings' -a 'list get set unset'
+      complete -c jp -n '__jp_using_command edit' -s y -l yaml -d 'Edit note and tags as YAML'
+      complete -c jp -n '__jp_using_command edit' -a '(__jp_complete notes; __jp_complete tags)'
+      complete -c jp -n '__jp_using_command mv' -a '(__jp_complete movable)'
+      complete -c jp -n '__jp_using_command rm' -a '(__jp_complete removable)'
+      complete -c jp -n '__jp_using_command rm' -s r -l recursive -d 'Remove a notebook or tag recursively'
+      complete -c jp -n '__jp_using_command rm' -s f -l force -d 'Do not prompt before trashing notes'
+      complete -c jp -n '__jp_using_command trash' -a 'ls restore empty'
+      complete -c jp -n '__jp_using_command trash; and contains -- restore (commandline -opc)' -a '(__jp_complete trashed)'
+      complete -c jp -n '__jp_using_command search' -s v -l verbose -d 'Show content snippets'
+      complete -c jp -n '__jp_using_command cal' -s y -l year -d 'Show full year'
+      complete -c jp -n '__jp_using_command cal' -s i -l include -r -d 'Include tags'
+      complete -c jp -n '__jp_using_command cal' -s x -l exclude -r -d 'Exclude tags'
+      complete -c jp -n '__jp_using_command log' -s v -l verbose -d 'Show more information'
+      complete -c jp -n '__jp_using_command log' -s l -l long -d 'Show more information'
+      complete -c jp -n '__jp_using_command log' -s a -l all -d 'Include hidden entries'
+      complete -c jp -n '__jp_using_command log' -s x -l exclude -r -d 'Exclude tags'
+      complete -c jp -n '__jp_using_command log' -a 'today yesterday week month year last-week last-month last7days last1week last30days last1month last3months last1year last3hours' -d 'Date shortcut'
+      complete -c jp -n '__jp_using_command flashback' -s v -l verbose -d 'Show more information'
+      complete -c jp -n '__jp_using_command flashback' -s l -l long -d 'Show more information'
+      complete -c jp -n '__jp_using_command flashback' -s a -l all -d 'Include excluded notes'
+      complete -c jp -n '__jp_using_command flashback' -s x -l exclude -r -d 'Exclude tags'
+    FISH
+  end
+
+  def completion_notebooks
+    @db.execute("SELECT id, title, parent_id FROM folders WHERE deleted_time = 0 ORDER BY title").map do |notebook|
+      get_full_path(notebook)
+    end.sort
+  end
+
+  def completion_notes
+    @db.execute("SELECT id, title, parent_id FROM notes WHERE deleted_time = 0 ORDER BY title")
+  end
+
+  def completion_movable_items
+    items = []
+    items.concat(@db.execute("SELECT id, title, 'Notebook' AS type FROM folders WHERE deleted_time = 0"))
+    items.concat(@db.execute("SELECT id, title, 'Tag' AS type FROM tags"))
+    counts = items.each_with_object(Hash.new(0)) { |item, totals| totals[item['title']] += 1 }
+    items.sort_by { |item| [item['title'].downcase, item['type'], item['id']] }.map do |item|
+      if counts[item['title']] == 1
+        [item['title'], item['type']]
+      else
+        [item['id'][0..4], "#{item['type']} #{item['title']}"]
+      end
+    end
+  end
+
+  def completion_removable_items
+    items = []
+    items.concat(@db.execute("SELECT id, title, 'Notebook' AS type FROM folders WHERE deleted_time = 0"))
+    items.concat(@db.execute("SELECT id, title, 'Tag' AS type FROM tags"))
+    items.concat(@db.execute("SELECT id, title, 'Note' AS type FROM notes WHERE deleted_time = 0"))
+    counts = items.each_with_object(Hash.new(0)) { |item, totals| totals[item['title']] += 1 }
+    items.sort_by { |item| [item['title'].downcase, item['type'], item['id']] }.map do |item|
+      if counts[item['title']] == 1
+        [item['title'], item['type']]
+      else
+        [item['id'][0..4], "#{item['type']} #{item['title']}"]
+      end
+    end
+  end
+
+  def print_counted_names(items, color:, indent: "")
+    entries = items.map do |item|
+      "#{item['title'].colorize(color)} #{"[#{item['note_count']}]".colorize(mode: :dim)}"
+    end
+    print_in_columns(entries, indent: indent)
+  end
+
+  def ls_note_date_scope
+    @ls_note_date_scope ||= if options[:date]
+                              parse_date_query(options[:date])[0, 3]
+                            else
+                              [nil, nil, '%Y-%m-%d']
+                            end
+  end
+
+  def ls_note_date_clause(table_alias)
+    range, date_filter, date_format = ls_note_date_scope
+    if range
+      ["#{table_alias}.updated_time >= ? AND #{table_alias}.updated_time <= ?", [range[0] * 1000, range[1] * 1000]]
+    elsif date_filter
+      ["strftime('#{date_format}', #{table_alias}.updated_time / 1000, 'unixepoch', 'localtime') = ?", [date_filter]]
+    else
+      [nil, []]
+    end
+  end
+
+  def ls_notes_where(table_alias, *clauses)
+    date_clause, date_params = ls_note_date_clause(table_alias)
+    where = [*clauses, "#{table_alias}.deleted_time = 0", date_clause].compact.join(" AND ")
+    [where, date_params]
+  end
+
+  def list_overview
+    sn, st = options[:nb] || (!options[:type]), options[:type] || (!options[:nb])
+    long = options[:long]
+    note_date_clause, note_date_params = ls_note_date_clause("n")
+    note_join_clause = ["n.parent_id = f.id", "n.deleted_time = 0", note_date_clause].compact.join(" AND ")
+    if sn
+      puts "Notebooks:".bold.yellow
+      if options[:recursive]; list_notebooks_recursive
+      elsif options[:tree]; list_notebook_tree
+      else
+        notebooks = if options[:all]
+                      @db.execute(<<~SQL, note_date_params)
+                        SELECT f.id, f.title, COUNT(n.id) AS note_count
+                        FROM folders f
+                        LEFT JOIN notes n ON #{note_join_clause}
+                        WHERE f.deleted_time = 0
+                        GROUP BY f.id, f.title
+                        ORDER BY f.title COLLATE NOCASE
+                      SQL
+                    else
+                      @db.execute(<<~SQL, note_date_params)
+                        SELECT f.id, f.title, COUNT(n.id) AS note_count
+                        FROM folders f
+                        LEFT JOIN notes n ON #{note_join_clause}
+                        WHERE f.parent_id = '' AND f.deleted_time = 0
+                        GROUP BY f.id, f.title
+                        ORDER BY f.title COLLATE NOCASE
+                      SQL
+                    end
+        if long
+          print_counted_names(notebooks, color: :blue)
+        else
+          print_in_columns(notebooks.map { |notebook| notebook['title'] }, color: :blue)
+        end
+      end
+      puts ""
+    end
+    if st
+      puts "Tags:".bold.yellow
+      tag_note_date_clause, tag_note_date_params = ls_note_date_clause("n")
+      tag_note_join_clause = ["n.id = nt.note_id", "n.deleted_time = 0", tag_note_date_clause].compact.join(" AND ")
+      tags = @db.execute(<<~SQL, tag_note_date_params)
+        SELECT t.id, t.title, COUNT(DISTINCT n.id) AS note_count
+        FROM tags t
+        LEFT JOIN note_tags nt ON nt.tag_id = t.id
+        LEFT JOIN notes n ON #{tag_note_join_clause}
+        GROUP BY t.id, t.title
+        ORDER BY t.title COLLATE NOCASE
+      SQL
+      if long
+        print_counted_names(tags, color: :green)
+      else
+        print_in_columns(tags.map { |t| t['title'] }, color: :green)
+      end
+      puts ""
+    end
+  end
+
+  def list_notebook_tree
+    note_date_clause, note_date_params = ls_note_date_clause("n")
+    note_join_clause = ["n.parent_id = f.id", "n.deleted_time = 0", note_date_clause].compact.join(" AND ")
+    folders = @db.execute(<<~SQL, note_date_params)
+      SELECT f.id, f.title, f.parent_id, COUNT(n.id) AS note_count
+      FROM folders f
+      LEFT JOIN notes n ON #{note_join_clause}
+      WHERE f.deleted_time = 0
+      GROUP BY f.id, f.title, f.parent_id
+      ORDER BY f.title COLLATE NOCASE
+    SQL
+    tree = Hash.new { |h, k| h[k] = [] }
+    folders.each { |f| tree[f['parent_id']] << f }
+    print_tree_node(tree, "", "")
+  end
+
+  def print_tree_node(tree, parent_id, indent = "")
+    tree[parent_id].each_with_index do |node, index|
+      last = (index == tree[parent_id].size - 1)
+      count = options[:long] ? " #{"[#{node['note_count']}]".colorize(mode: :dim)}" : ""
+      puts "#{indent}#{last ? "└── " : "├── "}#{node['title'].blue}#{count}"
+      print_tree_node(tree, node['id'], indent + (last ? "    " : "│   "))
+    end
+  end
+
+  def list_notebooks_recursive(notebook = nil)
+    parent_id = notebook ? notebook['id'] : ""
+    path = notebook ? get_full_path(notebook) : "."
+    print_recursive_notebook_contents(parent_id, path)
+  end
+
+  def print_recursive_notebook_contents(parent_id, path)
+    puts "#{path}:".bold.yellow
+    note_date_clause, note_date_params = ls_note_date_clause("n")
+    note_join_clause = ["n.parent_id = f.id", "n.deleted_time = 0", note_date_clause].compact.join(" AND ")
+    subfolders = @db.execute(
+      <<~SQL,
+        SELECT f.id, f.title, f.parent_id, COUNT(n.id) AS note_count
+        FROM folders f
+        LEFT JOIN notes n ON #{note_join_clause}
+        WHERE f.parent_id = ? AND f.deleted_time = 0
+        GROUP BY f.id, f.title, f.parent_id
+        ORDER BY f.title COLLATE NOCASE
+      SQL
+      [*note_date_params, parent_id]
+    )
+    notes_where, notes_params = ls_notes_where("n", "n.parent_id = ?")
+    notes = @db.execute(
+      "SELECT id, title, updated_time FROM notes n WHERE #{notes_where} ORDER BY title COLLATE NOCASE",
+      [parent_id, *notes_params]
+    )
+
+    if options[:long]
+      print_counted_names(subfolders, color: :blue)
+    else
+      print_in_columns(subfolders.map { |folder| folder['title'] }, color: :blue) if subfolders.any?
+    end
+    notes.each do |note|
+      timestamp = Time.at(note['updated_time'] / 1000).strftime('%Y-%m-%d %H:%M').colorize(mode: :dim)
+      id = note['id'][0..4].colorize(mode: :dim)
+      puts "#{id} #{timestamp} #{note['title']}"
+    end
+
+    subfolders.each do |folder|
+      puts ""
+      print_recursive_notebook_contents(folder['id'], path == "." ? folder['title'] : "#{path}/#{folder['title']}")
+    end
+  end
+
+  def list_target(target)
+    # Prioritize ID resolution since IDs are unique across Joplin
+    if target =~ /^[a-f0-9]{1,32}$/i
+      notebooks = @db.execute("SELECT id, title, parent_id FROM folders WHERE id LIKE ? AND deleted_time = 0", ["#{target.downcase}%"])
+      tags = @db.execute("SELECT id, title FROM tags WHERE id LIKE ?", ["#{target.downcase}%"])
+      notes_where, notes_params = ls_notes_where("n", "n.id LIKE ?")
+      notes = @db.execute(
+        "SELECT id, title, parent_id FROM notes n WHERE #{notes_where}",
+        ["#{target.downcase}%", *notes_params]
+      )
+      
+      if notebooks.any? || tags.any? || notes.any?
+        notebooks.each { |n| list_notebook_contents(n) }
+        tags.each { |t| list_tag_contents(t) }
+        notes.each do |n|
+          id_hdr = options[:long] ? " (#{n['id'][0..4].colorize(:mode => :dim)})" : ""
+          puts "Note: #{get_full_path_for_note(n)}#{id_hdr}".bold.yellow
+        end
+        return
+      end
+    end
+
+    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
+
+    found = false
+    if sn
+      notebooks = find_notebooks_by_path(target)
+      notebooks.each do |notebook|
+        list_notebook_contents(notebook)
+        found = true
+      end
+    end
+    if st
+      tags = find_tags_by_id_or_title(target)
+      tags.each do |tag|
+        puts "" if found
+        list_tag_contents(tag)
+        found = true
+      end
+    end
+    say "No notebook or tag found matching '#{target}'." unless found
+  end
+
+  def list_notebook_contents(notebook)
+    long = options[:long]
+    id_header = long ? " (#{notebook['id'][0..4].colorize(mode: :dim)})" : ""
+    puts "Notebook: #{get_full_path(notebook)}#{id_header}:".bold.yellow
+    if options[:recursive]
+      list_notebooks_recursive(notebook)
+      return
+    elsif options[:tree]
+      puts "Notebooks:".bold.yellow
+      folders = @db.execute(<<~SQL)
+        SELECT f.id, f.title, f.parent_id, COUNT(n.id) AS note_count
+        FROM folders f
+        LEFT JOIN notes n ON n.parent_id = f.id AND n.deleted_time = 0
+        WHERE f.deleted_time = 0
+        GROUP BY f.id, f.title, f.parent_id
+        ORDER BY f.title COLLATE NOCASE
+      SQL
+      tree = Hash.new { |h, k| h[k] = [] }
+      folders.each { |f| tree[f['parent_id']] << f }
+      print_tree_node(tree, notebook['id'], "")
+    else
+      note_date_clause, note_date_params = ls_note_date_clause("n")
+      note_join_clause = ["n.parent_id = f.id", "n.deleted_time = 0", note_date_clause].compact.join(" AND ")
+      subfolders = @db.execute(<<~SQL, [*note_date_params, notebook['id']])
+        SELECT f.id, f.title, COUNT(n.id) AS note_count
+        FROM folders f
+        LEFT JOIN notes n ON #{note_join_clause}
+        WHERE f.parent_id = ? AND f.deleted_time = 0
+        GROUP BY f.id, f.title
+        ORDER BY f.title COLLATE NOCASE
+      SQL
+      if subfolders.any?
+        puts "Notebooks:".bold.yellow
+        if long
+          print_counted_names(subfolders, color: :blue, indent: "  ")
+        else
+          print_in_columns(subfolders.map { |f| f['title'] }, color: :blue)
+        end
+        puts ""
+      end
+    end
+
+    notes_where, notes_params = ls_notes_where("n", "n.parent_id = ?")
+    notes = @db.execute(
+      "SELECT id, title, updated_time FROM notes n WHERE #{notes_where} ORDER BY updated_time DESC",
+      [notebook['id'], *notes_params]
+    )
+    if notes.any?
+      puts "Notes:".bold.yellow
+      notes.each do |n|
+        ts = Time.at(n['updated_time'] / 1000).strftime('%Y-%m-%d %H:%M').colorize(mode: :dim)
+        id_str = n['id'][0..4].colorize(:mode => :dim)
+        puts "#{id_str} #{ts} #{n['title']}"
+      end
+    end
+    puts ""
+  end
+
+  def list_tag_contents(tag)
+    notes_where, notes_params = ls_notes_where("n", "nt.tag_id = ?")
+    notes = @db.execute(
+      "SELECT n.id, n.title, n.updated_time FROM notes n JOIN note_tags nt ON n.id = nt.note_id WHERE #{notes_where} ORDER BY n.updated_time DESC",
+      [tag['id'], *notes_params]
+    )
+    id_header = options[:long] ? " (#{tag['id'][0..4].colorize(mode: :dim)})" : ""
+    puts "Notes tagged with '#{tag['title']}'#{id_header}:".bold.yellow
+    notes.each do |n|
+      ts = Time.at(n['updated_time'] / 1000).strftime('%Y-%m-%d %H:%M').colorize(mode: :dim)
+      id_str = n['id'][0..4].colorize(:mode => :dim)
+      puts "#{id_str} #{ts} #{n['title']}"
+    end
+  end
+
+  def find_notes(target)
+    # 1. ID Match (Short or Full)
+    if target =~ /^[a-f0-9]{1,32}$/i
+      rows = @db.execute("SELECT n.* FROM notes n WHERE n.id LIKE ? AND n.deleted_time = 0", ["#{target.downcase}%"])
+      return rows if rows.any?
+    end
+
+    # 2. Path Match (Notebook/Note)
+    if target.include?('/')
+      parts = target.split('/')
+      note_title = parts.pop
+      folder_path = parts.join('/')
+      folders = find_notebooks_by_path(folder_path)
+      if folders.any?
+        placeholders = folders.map { "?" }.join(',')
+        return @db.execute("SELECT n.* FROM notes n WHERE n.title = ? AND n.parent_id IN (#{placeholders}) AND n.deleted_time = 0", [note_title, *folders.map { |f| f['id'] }])
+      end
+    end
+
+    # 3. Exact Title Match
+    @db.execute("SELECT n.* FROM notes n WHERE n.title = ? AND n.deleted_time = 0", [target])
+  end
+
+  def fetch_notes(query: nil)
+    params = []
+    sql = "SELECT n.* FROM notes n WHERE n.deleted_time = 0"
+    if query
+      sql += " AND (n.title LIKE ? OR n.body LIKE ?)"
+      params << "%#{query}%"
+      params << "%#{query}%"
+    end
+    sql += " ORDER BY n.updated_time DESC"
+    @db.execute(sql, params)
+  end
+
+  def get_snippet(text, query, context = 40)
+    idx = text.downcase.index(query.downcase)
+    return nil unless idx
+    
+    start = [0, idx - context].max
+    finish = [text.length, idx + query.length + context].min
+    
+    snippet = text[start...finish].gsub("\n", " ")
+    snippet = "..." + snippet if start > 0
+    snippet = snippet + "..." if finish < text.length
+    
+    # Highlight in snippet
+    snippet.gsub(/(#{Regexp.escape(query)})/i) { |m| m.red.on_yellow.bold }.colorize(:mode => :dim)
+  end
+
+  def get_full_path_for_note(note)
+    folder = @db.get_first_row("SELECT id, title, parent_id FROM folders WHERE id = ?", [note['parent_id']])
+    if folder
+      "#{get_full_path(folder)}/#{note['title']}"
+    else
+      note['title']
+    end
+  end
+
+  def find_notebooks_by_path(path)
+    # Short ID or Full ID match
+    if path =~ /^[a-f0-9]{1,32}$/i
+      rows = @db.execute("SELECT id, title, parent_id FROM folders WHERE id LIKE ? AND deleted_time = 0", ["#{path.downcase}%"])
+      return rows if rows.any?
+    end
+
+    # Exact title match (might contain slashes)
+    exact = @db.execute("SELECT id, title, parent_id FROM folders WHERE title = ? AND deleted_time = 0", [path])
+    return exact if exact.any?
+
+    if path.include?('/')
+      parts = path.split('/')
+      candidates = [""] # parent_ids
+      notebooks = []
+      parts.each_with_index do |part, index|
+        new_candidates = []
+        candidates.each do |pid|
+          rows = @db.execute("SELECT id, title, parent_id FROM folders WHERE title = ? AND parent_id = ? AND deleted_time = 0", [part, pid])
+          rows.each do |row|
+            if index == parts.size - 1
+              notebooks << row
+            else
+              new_candidates << row['id']
+            end
+          end
+        end
+        candidates = new_candidates
+        break if candidates.empty? && notebooks.empty?
+      end
+      notebooks
+    else
+      @db.execute("SELECT id, title, parent_id FROM folders WHERE title = ? AND deleted_time = 0", [path])
+    end
+  end
+
+  def find_tags_by_id_or_title(target)
+    if target =~ /^[a-f0-9]{1,32}$/i
+      rows = @db.execute("SELECT id, title FROM tags WHERE id LIKE ?", ["#{target.downcase}%"])
+      return rows if rows.any?
+    end
+    @db.execute("SELECT id, title FROM tags WHERE title = ?", [target])
+  end
+
+  def get_full_path(notebook)
+    path = [notebook['title']]
+    current = notebook
+    while current['parent_id'] != ""
+      current = @db.get_first_row("SELECT id, title, parent_id FROM folders WHERE id = ?", [current['parent_id']])
+      break unless current
+      path.unshift(current['title'])
+    end
+    path.join('/')
+  end
+
+  def print_in_columns(items, color: nil, indent: "")
+    return if items.empty?
+    w = (IO.console.winsize[1] rescue 80)
+    visible_length = ->(item) { item.gsub(/\e\[(\d+;?)*m/, '').length }
+    ml = (items.map { |item| visible_length.call(item) }.max || 0) + 2
+    cols = [1, ((w - indent.length) / ml).to_i].max
+    rows = (items.size.to_f / cols).ceil
+    rows.times do |r|
+      print indent
+      cols.times do |c|
+        idx = r + c * rows
+        if idx < items.size
+          item = items[idx]
+          padding = " " * (ml - visible_length.call(item))
+          print color ? "#{item.colorize(color)}#{padding}" : "#{item}#{padding}"
+        end
+      end
+      puts ""
+    end
+  end
+
+  DATE_SHORTCUTS = %w(today yesterday week month year last-week last-month)
+  DATE_REGEXES = {
+    iso: /^\d{4}(-\d{2})?(-\d{2})?$/,
+    days: /^(last)?(\d+)days?$/,
+    weeks: /^(last)?(\d+)weeks?$/,
+    months: /^(last)?(\d+)months?$/,
+    years: /^(last)?(\d+)years?$/,
+    hours: /^(last)?(\d+)hours?$/,
+    ago: /^(\d+)(day|week|month|year)s?ago$/
+  }
+
+  def parse_date_query(arg)
+    return [nil, nil, '%Y-%m-%d', Date.today] if arg.nil?
+
+    range = nil
+    date_filter = arg
+    format = '%Y-%m-%d'
+    anchor_date = Date.today
+
+    case arg
+    when 'today'
+      anchor_date = Date.today
+      s = anchor_date.to_time.to_i
+      range = [s, s + 86400 - 1]
+      date_filter = nil
+    when 'yesterday'
+      anchor_date = Date.today - 1
+      s = anchor_date.to_time.to_i
+      range = [s, s + 86400 - 1]
+      date_filter = nil
+    when 'week', 'last-week'
+      anchor_date = Date.today - 6
+      range = [anchor_date.to_time.to_i, Time.now.to_i]
+      date_filter = nil
+    when 'month'
+      anchor_date = Date.new(Date.today.year, Date.today.month, 1)
+      s = anchor_date.to_time.to_i
+      nxt = Date.today.next_month
+      e = Date.new(nxt.year, nxt.month, 1).to_time.to_i - 1
+      range = [s, e]
+      date_filter = nil
+    when 'last-month'
+      anchor_date = Date.today.prev_month
+      s = Date.new(anchor_date.year, anchor_date.month, 1).to_time.to_i
+      e = Date.new(Date.today.year, Date.today.month, 1).to_time.to_i - 1
+      range = [s, e]
+      date_filter = nil
+    when 'year'
+      anchor_date = Date.new(Date.today.year, 1, 1)
+      s = anchor_date.to_time.to_i
+      e = Date.new(Date.today.year + 1, 1, 1).to_time.to_i - 1
+      range = [s, e]
+      date_filter = nil
+    when DATE_REGEXES[:days]
+      days = $2.to_i
+      anchor_date = Date.today - (days - 1)
+      range = [anchor_date.to_time.to_i, Time.now.to_i]
+      date_filter = nil
+    when DATE_REGEXES[:weeks]
+      days = $2.to_i * 7
+      anchor_date = Date.today - (days - 1)
+      range = [anchor_date.to_time.to_i, Time.now.to_i]
+      date_filter = nil
+    when DATE_REGEXES[:months]
+      anchor_date = Date.today << $2.to_i
+      range = [anchor_date.to_time.to_i, Time.now.to_i]
+      date_filter = nil
+    when DATE_REGEXES[:years]
+      anchor_date = Date.today << ($2.to_i * 12)
+      range = [anchor_date.to_time.to_i, Time.now.to_i]
+      date_filter = nil
+    when DATE_REGEXES[:hours]
+      hours = $2.to_i
+      range = [Time.now.to_i - (hours * 3600), Time.now.to_i]
+      date_filter = nil
+    when DATE_REGEXES[:ago]
+      n = $1.to_i
+      unit = $2
+      anchor_date = case unit
+                    when 'day'   then Date.today - n
+                    when 'week'  then Date.today - (n * 7)
+                    when 'month' then Date.today << n
+                    when 'year'  then Date.today << (n * 12)
+                    end
+      s = anchor_date.to_time.to_i
+      range = [s, s + 86400 - 1]
+      date_filter = nil
+    when /^\d{4}-\d{2}$/
+      format = '%Y-%m'
+      begin
+        anchor_date = Date.strptime(arg, format)
+      rescue ArgumentError
+        anchor_date = Date.today
+      end
+    when /^\d{4}$/
+      format = '%Y'
+      anchor_date = Date.new(arg.to_i, 1, 1)
+    when /^\d{4}-\d{2}-\d{2}$/
+      begin
+        anchor_date = Date.parse(arg)
+      rescue ArgumentError
+        anchor_date = Date.today
+      end
+    end
+
+    [range, date_filter, format, anchor_date]
+  end
+
+  def tag_matches_any?(tag_list, patterns)
+    return false if patterns.empty?
+    tags = tag_list.is_a?(Array) ? tag_list : tag_list.to_s.split(',').map(&:strip)
+    tags.any? do |tag|
+      patterns.any? { |p| File.fnmatch?(p, tag, File::FNM_CASEFOLD) }
+    end
+  end
+
+  def get_month_data(date, active_dates)
+    start_day = Date.new(date.year, date.month, 1).wday
+    days_in_month = Date.new(date.year, date.month, -1).day
+    
+    rows = []
+    current_row = ["  "] * start_day
+    
+    (1..days_in_month).each do |day|
+      curr = Date.new(date.year, date.month, day)
+      day_str = day.to_s.rjust(2)
+      
+      formatted_day = if active_dates.include?(curr.strftime('%Y-%m-%d'))
+                        day_str.bold.yellow
+                      else
+                        day_str.colorize(mode: :dim)
+                      end
+      current_row << formatted_day
+      
+      if current_row.size == 7
+        rows << current_row
+        current_row = []
+      end
+    end
+    current_row += ["  "] * (7 - current_row.size) unless current_row.empty?
+    rows << current_row unless current_row.empty?
+    
+    { title: date.strftime('%B'), rows: rows }
+  end
+
+  def print_month(m, year = nil)
+    say "\n      #{m[:title]} #{year}".bold.white
+    say "Su Mo Tu We Th Fr Sa".colorize(mode: :dim)
+    m[:rows].each { |row| say row.join(" ") }
+  end
+
+  def is_date_query?(arg)
+    return false if arg.nil?
+    return false if arg.start_with?('[') && arg.end_with?(']')
+    return true if DATE_SHORTCUTS.include?(arg)
+    DATE_REGEXES.any? { |_, re| arg =~ re }
+  end
+
+  def fetch_notes_log(range: nil, date_filter: nil, date_format: '%Y-%m-%d')
+    base_query = "SELECT n.*, (SELECT GROUP_CONCAT(t.title) FROM note_tags nt JOIN tags t ON nt.tag_id = t.id WHERE nt.note_id = n.id) as tags FROM notes n WHERE n.deleted_time = 0"
+    params = []
+    where_clauses = []
+
+    if range
+      where_clauses << "n.updated_time >= ? AND n.updated_time <= ?"
+      params << range[0] * 1000
+      params << range[1] * 1000
+    elsif date_filter
+      where_clauses << "strftime('#{date_format}', n.updated_time / 1000, 'unixepoch', 'localtime') = ?"
+      params << date_filter
+    end
+
+    sql = base_query
+    sql += " AND #{where_clauses.join(' AND ')}" unless where_clauses.empty?
+    sql += " ORDER BY n.updated_time ASC"
+    @db.execute(sql, params).each do |note|
+      folder = @db.get_first_row("SELECT id, title, parent_id FROM folders WHERE id = ? AND deleted_time = 0", [note['parent_id']])
+      note['notebook'] = folder ? folder['title'] : ""
+    end
+  end
+
+  def list_chronological(verbosity, slice_arg = nil, date_filter = nil, date_format = '%Y-%m-%d', exclude = [], range: nil, include_hidden: false)
+    notes = fetch_notes_log(range: range, date_filter: date_filter, date_format: date_format)
+
+    unless include_hidden
+      if exclude.any?
+        notes = notes.reject { |n| tag_matches_any?(n['tags'], exclude) }
+      end
+    end
+
+    if slice_arg
+      notes = apply_slice(notes, slice_arg)
+    end
+
+    if notes.empty?
+      say "No notes found."
+    else
+      display_log_notes(notes, verbosity)
+    end
+  end
+
+  def display_log_notes(notes, verbosity)
+    notes.each do |note|
+      timestamp = Time.at(note['updated_time'] / 1000).strftime('%Y-%m-%d %H:%M').colorize(mode: :dim)
+      id = note['id'][0..4].colorize(mode: :dim)
+      tags = note['tags'] || ''
+      notebook = note['notebook'] || ''
+
+      case verbosity
+      when 0
+        say "#{id} #{timestamp} #{note['title']}"
+      when 1
+        notebook_part = notebook.empty? ? "" : "#{notebook.blue} "
+        tags_part = tags.empty? ? "" : "[#{tags.green}] "
+        say "#{id} #{timestamp} #{notebook_part}#{tags_part}#{note['title']}"
+      else
+        notebook_part = notebook.empty? ? "" : "#{notebook.blue} "
+        tags_part = tags.empty? ? "" : "[#{tags.green}] "
+        say "#{id} #{timestamp} #{notebook_part}#{tags_part}#{note['title']}"
+        if note['body'] && !note['body'].strip.empty?
+          width = (IO.console.winsize[1] rescue 80)
+          say render_markdown(note['body'], width: width)
+        end
+      end
+    end
+  end
+
+  def apply_slice(entries, index_part)
+    if index_part.include?('..')
+      range = eval(index_part)
+      entries[range] || []
+    else
+      index = index_part.to_i
+      [entries[index]].compact
+    end
+  rescue => e
+    say "Error parsing index [#{index_part}]:".yellow + " #{e.message}"
+    []
+  end
+
+  def determine_verbosity
+    args = Thread.current[:jp_args] || ARGV
+    count = args.grep(/^-/).join.count('v')
+    count = 1 if count == 0 && (options[:verbose] || options[:long])
+    count
+  end
+
+  def prepare_yaml_edit_data_for_target(target)
+    # Check if target matches note(s) first
+    notes = find_notes(target)
+    if notes.size == 1
+      note = notes.first
+      tags = @db.execute("SELECT t.title FROM tags t JOIN note_tags nt ON t.id = nt.tag_id WHERE nt.note_id = ?", [note['id']]).map { |r| r['title'] }
+      h = {
+        'id' => note['id'],
+        'title' => note['title'],
+        'tags' => tags,
+        'body' => note['body'] || ""
+      }
+      return [[h], "Updated note '#{note['title'].green}'."]
+    end
+
+    # If not a note, check if it's a tag
+    tag_row = @db.get_first_row("SELECT * FROM tags WHERE title = ? OR id LIKE ?", [target, "#{target.downcase}%"])
+    if tag_row
+      notes = @db.execute("SELECT n.* FROM notes n JOIN note_tags nt ON n.id = nt.note_id WHERE nt.tag_id = ? AND n.deleted_time = 0 ORDER BY n.updated_time ASC", [tag_row['id']])
+      stack_data = notes.map do |n|
+        tags = @db.execute("SELECT t.title FROM tags t JOIN note_tags nt ON t.id = nt.tag_id WHERE nt.note_id = ?", [n['id']]).map { |r| r['title'] }
+        {
+          'id' => n['id'],
+          'title' => n['title'],
+          'tags' => tags,
+          'body' => n['body'] || ""
+        }
+      end
+      return [stack_data, "Updated stack for tag '#{tag_row['title'].blue}'."]
+    end
+
+    nil
+  end
+
+  def apply_yaml_changes(initial_data, new_data)
+    @db.transaction do
+      new_data.each do |new_n|
+        old_n = initial_data.find { |o| o['id'] == new_n['id'] }
+        if old_n
+          updates = []
+          params = []
+          
+          if new_n['title'] != old_n['title']
+            updates << "title = ?"
+            params << new_n['title']
+          end
+
+          if new_n['body'] != old_n['body']
+            updates << "body = ?"
+            params << new_n['body']
+          end
+
+          if updates.any?
+            updates << "updated_time = ?"
+            params << Time.now.to_i * 1000
+            query = "UPDATE notes SET #{updates.join(', ')} WHERE id = ?"
+            params << new_n['id']
+            @db.execute(query, params)
+          end
+
+          # Sync tags
+          new_tags = normalize_add_tags(new_n['tags'])
+          old_tags = normalize_add_tags(old_n['tags'])
+          now = Time.now.to_i * 1000
+
+          # Added tags
+          (new_tags - old_tags).each do |tag_title|
+            tag = @db.get_first_row("SELECT id FROM tags WHERE title = ?", [tag_title])
+            unless tag
+              tag_id = SecureRandom.hex(16)
+              insert_available_columns('tags', {
+                'id' => tag_id,
+                'title' => tag_title,
+                'created_time' => now,
+                'updated_time' => now,
+                'user_created_time' => now,
+                'user_updated_time' => now
+              })
+              tag = { 'id' => tag_id }
+            end
+
+            existing = @db.get_first_row(
+              "SELECT id FROM note_tags WHERE note_id = ? AND tag_id = ?",
+              [new_n['id'], tag['id']]
+            )
+            next if existing
+
+            insert_available_columns('note_tags', {
+              'id' => SecureRandom.hex(16),
+              'note_id' => new_n['id'],
+              'tag_id' => tag['id'],
+              'created_time' => now,
+              'updated_time' => now,
+              'user_created_time' => now,
+              'user_updated_time' => now
+            })
+          end
+
+          # Removed tags
+          (old_tags - new_tags).each do |tag_title|
+            tag = @db.get_first_row("SELECT * FROM tags WHERE title = ?", [tag_title])
+            if tag
+              @db.execute("DELETE FROM note_tags WHERE note_id = ? AND tag_id = ?", [new_n['id'], tag['id']])
+            end
+          end
+        end
+      end
+
+      new_ids = new_data.map { |n| n['id'] }
+      initial_data.each do |old_n|
+        unless new_ids.include?(old_n['id'])
+          @db.execute("UPDATE notes SET deleted_time = ? WHERE id = ?", [Time.now.to_i * 1000, old_n['id']])
+        end
+      end
+    end
+  end
+
+  def perform_yaml_edit(initial_data, success_msg)
+    temp = Tempfile.new(['jp_edit', '.yml'])
+    begin
+      temp.write(initial_data.to_yaml)
+      temp.close
+      editor = ENV['EDITOR'] || 'vi'
+      system("#{editor} #{temp.path}")
+
+      begin
+        new_data = YAML.load_file(temp.path)
+        new_data = [new_data] unless new_data.is_a?(Array)
+      rescue Psych::SyntaxError => e
+        say "Error parsing YAML:".yellow + " #{e.message}", :red
+        return
+      end
+      
+      return say "No changes made." if new_data == initial_data
+
+      apply_yaml_changes(initial_data, new_data)
+      say success_msg
+      auto_bkup_if_needed
+    ensure
+      temp.unlink
+    end
+  end
+
+  def edit_single_note(note)
+    temp = Tempfile.new(['jp_edit', '.md'])
+    begin
+      temp.write("#{note['title']}\n\n#{note['body'] || ''}")
+      temp.close
+      editor = ENV['EDITOR'] || 'vi'
+      success = system("#{editor} #{Shellwords.escape(temp.path)}")
+      return say "Edit cancelled." unless success
+
+      lines = File.read(temp.path).lines
+      new_title = lines.shift.to_s.chomp
+      lines.shift
+      new_body = lines.join.delete_suffix("\n")
+
+      if new_title != note['title'].to_s || new_body != (note['body'] || "")
+        now_ms = Time.now.to_i * 1000
+        @db.execute(
+          "UPDATE notes SET title = ?, body = ?, updated_time = ? WHERE id = ?",
+          [new_title, new_body, now_ms, note['id']]
+        )
+        say "Updated note '#{new_title.green}'."
+        auto_bkup_if_needed
+      else
+        say "No changes made."
+      end
+    ensure
+      temp.unlink
+    end
+  end
+
+  def edit_tag_stack(tag)
+    result = prepare_yaml_edit_data_for_target(tag)
+    if result
+      data, msg = result
+      perform_yaml_edit(data, msg)
+    else
+      say "Tag '#{tag.cyan}' not found."
+    end
+  end
+end
+
+CLI.start(ARGV)