tasku 0.3.9 → 0.4.1

data/lib/tasku/config.rb

@@ -27,14 +27,104 @@ module Tasku
         values: %w[on off],
         default: "on",
         description: "Show status colour segment in row bar"
+      },
+      "col_project" => {
+        values: %w[on off],
+        default: "off",
+        description: "Show project column in task list"
+      },
+      "col_priority" => {
+        values: %w[on off],
+        default: "on",
+        description: "Show priority column in task list"
+      },
+      "col_status" => {
+        values: %w[on off],
+        default: "on",
+        description: "Show status column in task list"
+      },
+      "col_due" => {
+        values: %w[on off],
+        default: "on",
+        description: "Show due date column in task list"
+      },
+      "col_name_min" => {
+        range: 10..200,
+        default: "20",
+        description: "Minimum width (chars) of the name column"
+      },
+      "col_priority_min" => {
+        range: 4..40,
+        default: "10",
+        description: "Minimum width (chars) of the priority column"
+      },
+      "col_status_min" => {
+        range: 4..40,
+        default: "11",
+        description: "Minimum width (chars) of the status column"
+      },
+      "col_due_min" => {
+        range: 4..40,
+        default: "19",
+        description: "Minimum width (chars) of the due date column"
       }
     }.freeze
 
+    # ── Cloud sync settings ────────────────────────────────────────────────
+    CLOUD_URL_DEFAULT = "https://tasku.cloud".freeze
+
+    def self.cloud_token
+      cloud["token"]
+    end
+
+    def self.cloud_token=(value)
+      save_cloud("token", value)
+    end
+
+    def self.cloud_url
+      cloud["url"] || CLOUD_URL_DEFAULT
+    end
+
+    def self.cloud_url=(value)
+      save_cloud("url", value)
+    end
+
+    def self.last_synced_at
+      raw = cloud["last_synced_at"]
+      raw ? Time.parse(raw).utc : nil
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def self.last_synced_at=(time)
+      save_cloud("last_synced_at", time&.utc&.iso8601)
+    end
+
+    def self.cloud_configured?
+      !cloud_token.nil?
+    end
+
     def self.get(key)
       all[key] || VALID_KEYS.dig(key, :default)
     end
 
+    def self.get_int(key)
+      get(key).to_i
+    end
+
     def self.set(key, value)
+      pastel = Pastel.new rescue nil
+      meta = VALID_KEYS[key]
+      raise ArgumentError, "Unknown key '#{key}'" unless meta
+
+      if meta[:range]
+        int = Integer(value) rescue nil
+        raise ArgumentError, "Value must be an integer between #{meta[:range].min} and #{meta[:range].max}" unless int && meta[:range].include?(int)
+        value = int.to_s
+      elsif meta[:values]
+        raise ArgumentError, "Invalid value '#{value}'. Valid: #{meta[:values].join(', ')}" unless meta[:values].include?(value)
+      end
+
       current = all
       current[key] = value
       FileUtils.mkdir_p(File.dirname(CONFIG_PATH))
@@ -48,5 +138,18 @@ module Tasku
     rescue JSON::ParserError
       {}
     end
+
+    def self.cloud
+      all["cloud"] || {}
+    end
+
+    def self.save_cloud(key, value)
+      current = all
+      current["cloud"] ||= {}
+      current["cloud"][key] = value
+      FileUtils.mkdir_p(File.dirname(CONFIG_PATH))
+      File.write(CONFIG_PATH, JSON.pretty_generate(current))
+    end
+    private_class_method :cloud, :save_cloud
   end
 end

data/lib/tasku/database.rb

@@ -2,6 +2,7 @@
 
 require "sequel"
 require "fileutils"
+require "securerandom"
 
 module Tasku
   module Database
@@ -10,6 +11,9 @@ module Tasku
 
     def self.connect
       FileUtils.mkdir_p(DB_DIR)
+      # Treat all stored datetime strings as UTC so comparisons with
+      # cloud timestamps (which are always UTC) stay consistent.
+      Sequel.database_timezone = :utc
       @db = Sequel.sqlite(DB_PATH)
       Sequel::Model.db = @db
       migrate
@@ -43,6 +47,14 @@ module Tasku
         db.alter_table(:tasks) { add_column :code, String }
       end
 
+      if db.table_exists?(:tasks) && !db.schema(:tasks).map(&:first).include?(:uuid)
+        db.alter_table(:tasks) { add_column :uuid, String }
+        # Backfill existing tasks with UUIDs
+        db[:tasks].where(uuid: nil).each do |row|
+          db[:tasks].where(id: row[:id]).update(uuid: SecureRandom.uuid)
+        end
+      end
+
       db.create_table? :projects do
         String :name, primary_key: true
         String :colour

data/lib/tasku/output/terminal.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pastel"
+require "io/console"
 
 module Tasku
   module Output
@@ -39,27 +40,30 @@ module Tasku
         "archived"    => { color: :dim,    symbol: "⊘" }
       }.freeze
 
-      COL_SEP = "  "
+      COL_SEP = " │ "
+      # Maximum visible width of a due_cell value:
+      # "Mmm DD (NNNd ago)" = 17 chars.
+      DUE_COL_MIN_WIDTH = 17
 
       def initialize
         @pastel = Pastel.new
         @term_width = terminal_width
       end
 
-      def render_list(tasks, colour_map: {}, spacing: "compact", bar: {})
+      def render_list(tasks, colour_map: {}, spacing: "compact", bar: {}, cols_cfg: {})
         if tasks.empty?
           puts @pastel.yellow("  No tasks found.")
           return
         end
 
-        rows = tasks.map { |t| build_columns(t, colour_map, bar) }
-        col_widths = compute_widths(rows)
+        rows = tasks.map { |t| build_columns(t, colour_map, bar, cols_cfg) }
+        col_widths = compute_widths(rows, cols_cfg)
         total = col_widths.sum + (COL_SEP.length * (col_widths.length - 1))
 
         puts ""
         puts @pastel.dim("  #{"─" * total}")
         rows.each do |cols|
-          line = cols.each_with_index.map { |c, i| c.to_s.ljust(col_widths[i]) }.join(COL_SEP)
+          line = cols.each_with_index.map { |c, i| ansi_ljust(c.to_s, col_widths[i]) }.join(COL_SEP)
           puts "  #{line}"
           puts "" if spacing == "spacious"
         end
@@ -154,26 +158,55 @@ module Tasku
       end
 
       # Returns an array of pre-formatted row strings for MadoList.
-      # Accounts for the "[>] " prefix (4 extra chars) when computing widths.
-      def build_mado_rows(tasks, colour_map = {}, bar = {})
-        return [] if tasks.empty?
+      # Accounts for the "  [>] " prefix (6 extra chars) when computing widths.
+      # Optional columns (project → priority → status, never due) are dropped
+      # until ≥15 chars are available for task names.  Names are only truncated
+      # if they still overflow after all optional columns have been tried.
+      def build_mado_rows(tasks, colour_map = {}, bar = {}, cols_cfg = {})
+        return { rows: [], row_width: 0 } if tasks.empty?
 
         orig_width  = @term_width
-        @term_width = [@term_width - 4, 40].max
+        @term_width = [orig_width - 6, 40].max
 
-        col_rows   = tasks.map { |t| build_columns(t, colour_map, bar) }
-        col_widths = compute_widths(col_rows)
-        result = col_rows.map do |cols|
-          cols.each_with_index.map { |c, i| ansi_ljust(c.to_s, col_widths[i]) }.join(COL_SEP)
+        cfg = cols_cfg.dup
+
+        # Drop optional columns (project → category → priority → status) until names have room.
+        %i[project category priority status].each do |drop_col|
+          probe = tasks.map { |t| build_columns(t, colour_map, bar, cfg) }
+          ws    = mado_max_col_widths(probe, cfg)
+          break if mado_name_available(ws) >= 15
+          next if cfg["col_#{drop_col}"] == "off"
+          cfg["col_#{drop_col}"] = "off"
+        end
+
+        col_rows   = tasks.map { |t| build_columns(t, colour_map, bar, cfg) }
+        col_widths = mado_max_col_widths(col_rows, cfg)
+        col_widths = mado_apply_truncation(col_rows, col_widths)
+
+        dim_sep = @pastel.dim(COL_SEP)
+        result  = col_rows.map do |cols|
+          cols.each_with_index.map { |c, i| ansi_ljust(c.to_s, col_widths[i]) }.join(dim_sep)
+        end
+
+        # Build header row aligned to col_widths.
+        labels = ["ID", "Name"]
+        %i[project category priority status due].each do |col|
+          next if cfg["col_#{col}"] == "off"
+          labels << { project: "Project", category: "Category",
+                      priority: "Priority", status: "Status", due: "Due" }[col]
         end
+        header = labels.each_with_index
+                       .map { |lbl, i| ansi_ljust(@pastel.dim(lbl), col_widths[i]) }
+                       .join(dim_sep)
 
+        row_width = col_widths.sum + COL_SEP.length * (col_widths.length - 1)
         @term_width = orig_width
-        result
+        { rows: result, row_width: row_width, header: header }
       end
 
       private
 
-      def build_columns(task, colour_map = {}, bar = {})
+      def build_columns(task, colour_map = {}, bar = {}, cols_cfg = {})
         id_val = task.code && !task.code.empty? ? "#{task.code}-#{task.id}" : task.id.to_s
 
         segments = []
@@ -193,36 +226,120 @@ module Tasku
                  else
                    @pastel.dim(id_val)
                  end
-        name_str = @pastel.bold(task.name)
-        proj_str = project_str(task.project, colour_map)
-        prio_str = priority_tag(task.priority)
-        stat_str = status_tag(task.status)
-        due_str = due_cell(task)
-        [id_str, name_str, proj_str, prio_str, stat_str, due_str]
+
+        # ID (col 0) and Name (col 1) are always present.
+        result = [id_str, @pastel.bold(task.name)]
+        result << project_str(task.project, colour_map) unless cols_cfg["col_project"]  == "off"
+        result << category_str(task.category)           unless cols_cfg["col_category"] == "off"
+        result << priority_tag(task.priority)           unless cols_cfg["col_priority"] == "off"
+        result << status_tag(task.status)               unless cols_cfg["col_status"]   == "off"
+        result << due_cell(task)                        unless cols_cfg["col_due"]       == "off"
+        result
       end
 
-      def compute_widths(rows)
+      def compute_widths(rows, cols_cfg = {})
         raw = rows.map { |cols| cols.map { |c| strip_ansi(c.to_s).length } }
         maxes = raw.transpose.map(&:max)
-        sep_total = COL_SEP.length * (maxes.length - 1)
-        fixed_cols = maxes[0] + maxes[2] + maxes[3] + maxes[4] + maxes[5]
-        available_name = @term_width - fixed_cols - sep_total - 4
-        min_name = 20
 
-        if maxes[1] > available_name || maxes[1] < min_name
-          name_width = [available_name, min_name].max
-          rows.each_with_index do |cols, _ri|
+        # Track which array index each optional column landed at (after id=0, name=1).
+        col_idx = {}
+        i = 2
+        %i[project category priority status due].each do |col|
+          unless cols_cfg["col_#{col}"] == "off"
+            col_idx[col] = i
+            i += 1
+          end
+        end
+
+        # Apply user-configured minimum widths for optional fixed columns.
+        {
+          priority: [cols_cfg["col_priority_min"].to_i, 4].max,
+          status:   [cols_cfg["col_status_min"].to_i,   4].max,
+          due:      [[cols_cfg["col_due_min"].to_i, DUE_COL_MIN_WIDTH].max]
+        }.each do |col, mins|
+          if (idx = col_idx[col])
+            maxes[idx] = ([maxes[idx]] + Array(mins)).max
+          end
+        end
+
+        sep_total = COL_SEP.length * (maxes.length - 1)
+        # Fixed cols = everything except the name column (always at index 1).
+        fixed_cols = maxes.each_with_index.sum { |m, i| i == 1 ? 0 : m }
+        available_name = @term_width - fixed_cols - sep_total - 6
+
+        # Truncate names that would overflow; use count-based slice to avoid
+        # Ruby's negative-index wrapping when name_width is 0 or 1.
+        name_width = [available_name, 0].max
+        if maxes[1] > name_width
+          rows.each do |cols|
             raw_str = strip_ansi(cols[1].to_s)
             if raw_str.length > name_width
-              cols[1] = "#{raw_str[0..name_width - 2]}#{@pastel.dim("…")}"
+              keep = [name_width - 1, 0].max
+              cols[1] = keep > 0 ? "#{raw_str[0, keep]}#{@pastel.dim("…")}" : ""
             end
           end
-          maxes[1] = name_width
+        else
+          name_width = maxes[1]
+        end
+        maxes[1] = name_width
+
+        maxes
+      end
+
+      # Returns per-column max widths, applying configured minimums for
+      # priority (≥4), status (≥4), and due (≥DUE_COL_MIN_WIDTH).
+      # @term_width must already be reduced by 6 (the MadoList prefix).
+      def mado_max_col_widths(rows, cols_cfg = {})
+        raw   = rows.map { |cols| cols.map { |c| strip_ansi(c.to_s).length } }
+        maxes = raw.transpose.map(&:max)
+
+        col_idx = {}
+        i = 2
+        %i[project category priority status due].each do |col|
+          next if cols_cfg["col_#{col}"] == "off"
+          col_idx[col] = i
+          i += 1
+        end
+
+        { priority: [cols_cfg["col_priority_min"].to_i, 4].max,
+          status:   [cols_cfg["col_status_min"].to_i,   4].max,
+          due:      [cols_cfg["col_due_min"].to_i, DUE_COL_MIN_WIDTH].max
+        }.each do |col, min|
+          maxes[col_idx[col]] = [maxes[col_idx[col]], min].max if col_idx[col]
         end
 
         maxes
       end
 
+      # How many chars are available for the name column given a widths array.
+      def mado_name_available(maxes)
+        sep_total  = COL_SEP.length * (maxes.length - 1)
+        fixed_cols = maxes.each_with_index.sum { |m, i| i == 1 ? 0 : m }
+        @term_width - fixed_cols - sep_total
+      end
+
+      # Truncate name cells in-place if they exceed available space.
+      # Always expands the name column to fill available space so the table
+      # spans the full terminal width (short names are padded by ansi_ljust).
+      # Returns the (possibly updated) widths array.
+      def mado_apply_truncation(rows, maxes)
+        avail  = mado_name_available(maxes)
+        name_w = [avail, 0].max
+        if maxes[1] > name_w
+          rows.each do |cols|
+            s = strip_ansi(cols[1].to_s)
+            if s.length > name_w
+              keep    = [name_w - 1, 0].max
+              cols[1] = keep > 0 ? "#{s[0, keep]}#{@pastel.dim("…")}" : ""
+            end
+          end
+        end
+        # Always set name column to full available width so the table fills
+        # the terminal — short names will be space-padded by ansi_ljust.
+        maxes[1] = name_w
+        maxes
+      end
+
       def strip_ansi(str)
         str.gsub(/\e\[[0-9;]*m/, "")
       end
@@ -236,6 +353,13 @@ module Tasku
       end
 
       def terminal_width
+        # Mado writes the exact PTY column count to this file before running
+        # tasku list, bypassing unreliable ioctl/winsize methods inside the PTY.
+        cols_file = ENV["TASKU_COLS_FILE"] || "/tmp/tasku_mado_cols"
+        cols = File.read(cols_file).strip.to_i rescue 0
+        return cols if cols > 0
+
+        `stty size 2>/dev/null`.split.last.to_i.tap { |w| return w if w > 0 }
         IO.console&.winsize&.[](1) || 80
       rescue
         80
@@ -257,6 +381,10 @@ module Tasku
         "\e[38;2;#{r};#{g};#{b}m#{text}\e[0m"
       end
 
+      def category_str(category)
+        category && !category.empty? ? @pastel.cyan(category) : @pastel.dim("—")
+      end
+
       def project_str(project, colour_map)
         return @pastel.dim("—") unless project
 
@@ -274,6 +402,9 @@ module Tasku
         day = task.due_day.strftime("%b %d")
         if task.overdue?
           @pastel.red("#{day} (#{diff.abs}d ago)")
+        elsif diff < 0
+          # Past due but task is done/cancelled — show dimly, no alarm
+          @pastel.dim("#{day} (#{diff.abs}d ago)")
         elsif diff.zero?
           @pastel.yellow("#{day} (today)")
         elsif diff <= 7

data/lib/tasku/task.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "database"
+require "securerandom"
 
 module Tasku
   class Task < Sequel::Model(:tasks)
@@ -9,6 +10,11 @@ module Tasku
     VALID_PRIORITIES = %w[none low medium high urgent].freeze
     VALID_STATUSES = %w[backlog todo in_progress done cancelled archived].freeze
 
+    def before_create
+      super
+      self.uuid ||= SecureRandom.uuid
+    end
+
     def before_validation
       super
       self.code = code.to_s.upcase[0, 3] if code

data/lib/tasku/tui/mado_list.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "io/console"
+require "shellwords"
 require "pastel"
+require_relative "mado_log"
 
 module Tasku
   module TUI
@@ -10,37 +12,45 @@ module Tasku
     # selected task's ID is written to ENV["TASKU_SEL_FILE"] so that Mado
     # button handlers can inject it into commands like `tasku edit <id>`.
     class MadoList
-      HINT = "  ↑↓ navigate   a add   e/↵ edit   d delete   q quit"
+      HINT = "  ↑↓ navigate   a add   e/↵ edit   d delete   s stats   q quit"
 
-      def initialize(tasks, colour_map: {}, bar: {})
-        @tasks    = tasks
-        @cursor   = 0
-        @pastel   = Pastel.new
-        @sel_file = ENV["TASKU_SEL_FILE"]
-        @running  = true
+      def initialize(tasks, colour_map: {}, bar: {}, cols_cfg: {}, project: nil, list_cmd: nil)
+        @tasks      = tasks
+        @cursor     = 0
+        @pastel     = Pastel.new
+        @sel_file   = ENV["TASKU_SEL_FILE"]
+        @running    = true
+        @inline_cmd = nil
+        @list_cmd   = list_cmd || (project ? "tasku list --project #{Shellwords.shellescape(project)}" : "tasku list")
 
         # Pre-render row content once so key-press redraws are cheap.
-        @rows = Output::Terminal.new.build_mado_rows(tasks, colour_map, bar)
+        table      = Output::Terminal.new.build_mado_rows(tasks, colour_map, bar, cols_cfg)
+        @rows      = table[:rows]
+        @row_width = table[:row_width]
+        @header    = table[:header]
+
+        MadoLog.log("init tasks=#{tasks.length} cols_file=#{ENV["TASKU_COLS_FILE"]&.then { |f| File.read(f).strip rescue "?" }}")
       end
 
       def run
-        return if @tasks.empty?
-
-        write_selection
+        MadoLog.log("run tasks=#{@tasks.length}")
+        write_selection unless @tasks.empty?
 
         $stdout.print "\e[?25l"  # hide cursor
         at_exit { restore_terminal }
-        trap("INT") { @running = false }
+        trap("INT") { MadoLog.log("SIGINT received"); @running = false }
 
         $stdin.raw do |io|
           full_render
           while @running
             prev = @cursor
             key  = read_key(io)
+            MadoLog.log("key=#{key.inspect} cursor=#{@cursor} tasks=#{@tasks.length}") unless key.nil?
             handle_key(key)
             full_render if @running && @cursor != prev
           end
         end
+        MadoLog.log("run exited normally")
       end
 
       private
@@ -54,18 +64,50 @@ module Tasku
 
       # Full clear + repaint (initial draw or after a command).
       def full_render
-        $stdout.print "\e[H\e[J"  # cursor home, clear to end of screen
+        $stdout.print "\e[3J\e[H\e[2J"
+        if @tasks.empty?
+          $stdout.print "\r\n  #{@pastel.dim("No tasks found.")}\r\n"
+          $stdout.print "\r\n#{@pastel.dim("  Press any key to return to list…")}\r\n"
+          $stdout.flush
+          return
+        end
+        border = @pastel.dim("  " + "─" * (@row_width + 4))
+        $stdout.print "#{border}\r\n"
+        $stdout.print "  #{@pastel.dim("   ")} #{@header}\r\n" if @header
+        $stdout.print "#{border}\r\n"
         @rows.each_with_index do |row, i|
-          marker = i == @cursor ? @pastel.bright_blue("[>]") : @pastel.dim("[ ]")
-          $stdout.print "  #{marker} #{row}\r\n"
+          if i == @cursor
+            marker  = @pastel.bright_blue("[>]")
+            # Re-apply the highlight background after every ANSI reset so it
+            # persists through pre-rendered colour codes embedded in the row.
+            content = "  #{marker} #{row}".gsub("\e[0m", "\e[0m\e[48;5;236m")
+            $stdout.print "\e[48;5;236m#{content}\e[48;5;236m\e[K\e[0m\r\n"
+          else
+            marker = @pastel.dim("[ ]")
+            $stdout.print "  #{marker} #{row}\r\n"
+          end
         end
+        $stdout.print "#{border}\r\n"
+        $stdout.print "#{@pastel.dim("  #{@tasks.length} task(s) found")}\r\n"
         $stdout.print "\r\n#{@pastel.dim(HINT)}\r\n"
         $stdout.flush
       end
 
-def read_key(io)
+      def read_key(io)
         byte = io.getbyte
         case byte
+        when 0x02 # STX — inline exec protocol from Mado buttons.
+                  # Read the command string until newline; store it and
+                  # return :inline_exec so handle_key can exec it directly
+                  # without relying on the shell to pick up buffered input.
+          cmd = "".b
+          loop do
+            b = io.getbyte
+            break if b.nil? || b == 0x0A
+            cmd << b
+          end
+          @inline_cmd = cmd.force_encoding("UTF-8").scrub
+          :inline_exec
         when 0x1B
           second = io.getbyte
           if second == 0x5B
@@ -83,11 +125,21 @@ def read_key(io)
         when 0x64       then :delete   # d
         when 0x65       then :edit     # e
         when 0x71       then :q        # q
+        when 0x73       then :stats    # s
         else nil
         end
       end
 
       def handle_key(key)
+        if @tasks.empty?
+          case key
+          when :ctrl_c, :escape
+            @running = false
+          else
+            run_command("true")  # any other key → exec tasku list
+          end
+          return
+        end
         case key
         when :up
           @cursor = [@cursor - 1, 0].max
@@ -105,16 +157,77 @@ def read_key(io)
         when :delete
           return if @tasks.empty?
           run_command("tasku delete #{@tasks[@cursor].id} -f")
+        when :stats
+          run_and_show("tasku stats")
+        when :inline_exec
+          cmd = @inline_cmd.to_s
+          MadoLog.log("inline_exec cmd=#{cmd.inspect}")
+          if cmd == "SQL"
+            run_sql
+          elsif cmd.start_with?("tasku list")
+            # exec directly so the new MadoList initialises with the correct
+            # @list_cmd (project filter, status filter, etc.).  Using
+            # run_command would nest a subprocess and then re-exec @list_cmd
+            # (no filter) when the subprocess exits — losing the filter.
+            # Must restore terminal + cooked mode before exec so the new
+            # process doesn't inherit raw-mode terminal attributes.
+            @running = false
+            restore_terminal
+            $stdin.cooked!
+            MadoLog.log("inline_exec tasku list → exec #{cmd.inspect}")
+            exec(cmd)
+          else
+            run_command(cmd)
+          end
         end
       end
 
       # Restore the terminal, run a tasku command interactively, then re-exec
       # `tasku list` so the MadoList restarts fresh with updated data.
       def run_command(cmd)
+        MadoLog.log("run_command cmd=#{cmd.inspect}")
         @running = false
         restore_terminal
+        $stdin.cooked!
         system(cmd)
-        exec("tasku list")
+        MadoLog.log("run_command finished cmd=#{cmd.inspect} → exec #{@list_cmd}")
+        exec(@list_cmd)
+      end
+
+      # Run a non-interactive display command, wait for any keypress via
+      # getch (works in cooked mode — no raw-mode setup needed), then
+      # re-exec `tasku list`.
+      def run_and_show(cmd)
+        MadoLog.log("run_and_show cmd=#{cmd.inspect}")
+        @running = false
+        restore_terminal
+        $stdin.cooked!
+        system(cmd)
+        $stdout.print "\r\n\e[2m  Press any key to return to list…\e[0m\r\n"
+        $stdout.flush
+        $stdin.getch
+        MadoLog.log("run_and_show keypress received → exec #{@list_cmd}")
+        exec(@list_cmd)
+      end
+
+      # Show a SQL prompt, run the query, wait for keypress, then re-exec list.
+      def run_sql
+        MadoLog.log("run_sql")
+        @running = false
+        restore_terminal
+        $stdin.cooked!
+        $stdout.print "\r\n\e[36m  SELECT * FROM tasks WHERE status = 'todo'\e[0m\r\n\r\n"
+        $stdout.print "\e[2m  SQL> \e[0m"
+        $stdout.flush
+        q = $stdin.gets&.chomp
+        if q && !q.empty?
+          system("tasku", "sql", q)
+          $stdout.print "\r\n\e[2m  Press any key to return to list…\e[0m\r\n"
+          $stdout.flush
+          $stdin.getch
+        end
+        MadoLog.log("run_sql done → exec #{@list_cmd}")
+        exec(@list_cmd)
       end
 
       def restore_terminal